diff --git a/src/mono/nuget/Microsoft.NET.Sdk.WebAssembly.Pack/build/Microsoft.NET.Sdk.WebAssembly.Browser.targets b/src/mono/nuget/Microsoft.NET.Sdk.WebAssembly.Pack/build/Microsoft.NET.Sdk.WebAssembly.Browser.targets
index 52d869fca3df6a..63554a5b72e5e7 100644
--- a/src/mono/nuget/Microsoft.NET.Sdk.WebAssembly.Pack/build/Microsoft.NET.Sdk.WebAssembly.Browser.targets
+++ b/src/mono/nuget/Microsoft.NET.Sdk.WebAssembly.Pack/build/Microsoft.NET.Sdk.WebAssembly.Browser.targets
@@ -292,7 +292,9 @@ Copyright (c) .NET Foundation. All rights reserved.
     </ItemGroup>
   </Target>
 
-  <Target Name="_ResolveWasmOutputs" DependsOnTargets="ResolveReferences;PrepareResourceNames;ComputeIntermediateSatelliteAssemblies;_ResolveWasmConfiguration;_WasmNativeForBuild">
+  <!-- Resolve and classify build asset candidates.
+       This target always runs to ensure candidate items are populated for downstream consumers. -->
+  <Target Name="_ComputeWasmBuildCandidates" DependsOnTargets="ResolveReferences;PrepareResourceNames;ComputeIntermediateSatelliteAssemblies;_ResolveWasmConfiguration;_WasmNativeForBuild">
     <PropertyGroup>
       <_WasmNativeAssetFileNames>;@(WasmNativeAsset->'%(FileName)%(Extension)');@(WasmAssembliesFinal->'%(FileName)%(Extension)');</_WasmNativeAssetFileNames>
       <_WasmIntermediateAssemblyFileNames Condition="@(WasmAssembliesFinal->Count()) != 0">;@(IntermediateAssembly->'%(FileName)%(Extension)');</_WasmIntermediateAssemblyFileNames>
@@ -362,17 +364,116 @@ Copyright (c) .NET Foundation. All rights reserved.
       <_WasmFrameworkCopyToOutputDirectory Condition="'$(_WasmFrameworkCopyToOutputDirectory)' == ''">Never</_WasmFrameworkCopyToOutputDirectory>
     </PropertyGroup>
 
-    <ConvertDllsToWebcil Candidates="@(_BuildAssetsCandidates)" IntermediateOutputPath="$(_WasmBuildTmpWebcilPath)" OutputPath="$(_WasmBuildWebcilPath)" IsEnabled="$(_WasmEnableWebcil)" WebcilVersion="$(_WasmWebcilVersion)">
-      <Output TaskParameter="WebcilCandidates" ItemName="_WebcilAssetsCandidates" />
-      <Output TaskParameter="PassThroughCandidates" ItemName="_WasmFrameworkCandidates" />
+    <!-- Identify DLL candidates that need webcil conversion, separate culture from non-culture
+         DLLs, and compute their expected output paths for use as Outputs in the incremental
+         _ConvertBuildDllsToWebcil target. Culture and non-culture DLLs are separated into
+         distinct item groups to avoid MSBuild batching errors on metadata (like RelatedAsset)
+         that only culture items define.
+         Also pre-classify non-DLL candidates: items with WasmNativeBuildOutput metadata are
+         already per-project (Computed); items without are Framework assets needing per-project
+         materialization. Pre-filtering avoids MSBuild batching errors on WasmNativeBuildOutput
+         metadata that only WasmNativeAsset items define. -->
+    <ItemGroup Condition="'$(_WasmEnableWebcil)' == 'true'">
+      <!-- Build DLL candidates with pre-computed WebcilOutputPath metadata.
+           First filter to DLLs only, then split by culture to assign the correct output path.
+           The combined list enables MSBuild partial target execution via Outputs transform
+           (@(_WasmDllBuildCandidates->'%(WebcilOutputPath)')): only out-of-date input/output
+           pairs are passed to the target body, skipping unchanged DLLs entirely. -->
+      <_WasmDllBuildCandidates Include="@(_BuildAssetsCandidates)" Condition="'%(Extension)' == '.dll'" />
+      <_WasmDllBuildCandidatesNonCulture Include="@(_WasmDllBuildCandidates)" Condition="'%(AssetTraitName)' != 'Culture'">
+        <WebcilOutputPath>$(_WasmBuildWebcilPath)%(FileName).wasm</WebcilOutputPath>
+      </_WasmDllBuildCandidatesNonCulture>
+      <_WasmDllBuildCandidatesCulture Include="@(_WasmDllBuildCandidates)" Condition="'%(AssetTraitName)' == 'Culture'">
+        <WebcilOutputPath>$(_WasmBuildWebcilPath)%(AssetTraitValue)/%(FileName).wasm</WebcilOutputPath>
+      </_WasmDllBuildCandidatesCulture>
+      <!-- Rebuild _WasmDllBuildCandidates with WebcilOutputPath metadata from both groups -->
+      <_WasmDllBuildCandidates Remove="@(_WasmDllBuildCandidates)" />
+      <_WasmDllBuildCandidates Include="@(_WasmDllBuildCandidatesNonCulture);@(_WasmDllBuildCandidatesCulture)" />
+      <_WasmExpectedWebcilOutputs Include="@(_WasmDllBuildCandidates->'%(WebcilOutputPath)')" />
+    </ItemGroup>
+
+    <!-- Separate non-DLL items into native build outputs (per-project, Computed) and
+         framework candidates (shared, need materialization). WasmNativeBuildOutput metadata
+         is only set on WasmNativeAsset items so we filter from the source to avoid batching
+         errors on _BuildAssetsCandidates. -->
+    <ItemGroup>
+      <_WasmNativeBuildOutputCandidates Include="@(_BuildAssetsCandidates)" Condition="'%(Extension)' != '.dll' and '%(_BuildAssetsCandidates.WasmNativeBuildOutput)' != ''" />
+      <_WasmNonDllNonNativeCandidates Include="@(_BuildAssetsCandidates)" Condition="'%(Extension)' != '.dll'" />
+      <_WasmNonDllNonNativeCandidates Remove="@(_WasmNativeBuildOutputCandidates)" />
+    </ItemGroup>
+  </Target>
+
+  <!-- Convert DLL assemblies to webcil format.
+       Outputs is a direct transform of the item-based Inputs, enabling MSBuild partial target
+       execution: when only some DLLs change, MSBuild passes only out-of-date pairs to the
+       target body. Property inputs (project/targets/task assembly) are global dependencies —
+       if any changes, all outputs are rebuilt.
+       Touch is needed because the task uses content comparison (MoveIfDifferent) which preserves
+       old timestamps when webcil content is unchanged. Without Touch, property-triggered full
+       rebuilds would loop since skipped outputs retain pre-existing timestamps. -->
+  <Target Name="_ConvertBuildDllsToWebcil"
+    DependsOnTargets="_ComputeWasmBuildCandidates"
+    Condition="'$(_WasmEnableWebcil)' == 'true'"
+    Inputs="@(_WasmDllBuildCandidates);$(MSBuildProjectFullPath);$(MSBuildThisFileFullPath);$(_WebAssemblySdkTasksAssembly)"
+    Outputs="@(_WasmDllBuildCandidates->'%(WebcilOutputPath)')">
+
+    <ConvertDllsToWebcil Candidates="@(_WasmDllBuildCandidates)" IntermediateOutputPath="$(_WasmBuildTmpWebcilPath)" OutputPath="$(_WasmBuildWebcilPath)" IsEnabled="$(_WasmEnableWebcil)" WebcilVersion="$(_WasmWebcilVersion)">
       <Output TaskParameter="FileWrites" ItemName="FileWrites" />
+      <Output TaskParameter="FileWrites" ItemName="_WasmConvertedWebcilOutputs" />
     </ConvertDllsToWebcil>
 
-    <!-- Remove pass-throughs from webcil candidates so each file is classified exactly once:
-         webcil-converted files → Computed (per-project in obj/webcil/)
-         pass-through files → Framework (materialized per-project by UpdatePackageStaticWebAssets) -->
-    <ItemGroup>
-      <_WebcilAssetsCandidates Remove="@(_WasmFrameworkCandidates)" />
+    <!-- Touch is needed for property-triggered full rebuilds: the task's content comparison
+         (MoveIfDifferent) preserves old timestamps for unchanged webcil files, but MSBuild
+         needs all outputs to have current timestamps to skip the target on subsequent builds.
+         For item-triggered partial rebuilds, MSBuild only passes changed items so Touch only
+         affects those outputs. -->
+    <Touch Files="@(_WasmConvertedWebcilOutputs)" Condition="'@(_WasmConvertedWebcilOutputs)' != ''" />
+  </Target>
+
+  <!-- Resolve webcil candidate items and define static web assets for the build.
+       This target always runs because it populates item groups consumed by downstream targets.
+       It reuses %(WebcilOutputPath) metadata computed in _ComputeWasmBuildCandidates to construct
+       webcil candidate items, so items are correct whether the conversion target ran or was
+       skipped due to incrementalism.
+       Pass-through files are classified as Framework assets for per-project materialization. -->
+  <Target Name="_ResolveWasmOutputs" DependsOnTargets="_ComputeWasmBuildCandidates;_ConvertBuildDllsToWebcil">
+
+    <!-- When webcil is enabled, transform DLL candidates to their webcil output paths (reusing
+         %(WebcilOutputPath) computed in _ComputeWasmBuildCandidates) and fix metadata. Non-culture
+         and culture DLLs use separate intermediate items to avoid MSBuild batching errors on
+         metadata (like RelatedAsset) that only culture items define.
+         Only webcil-converted items and WasmNativeBuildOutput items go to _WebcilAssetsCandidates
+         (Computed SourceType). Framework candidates are classified separately. -->
+    <ItemGroup Condition="'$(_WasmEnableWebcil)' == 'true'">
+      <_WasmWebcilConvertedNonCulture Include="@(_WasmDllBuildCandidatesNonCulture->'%(WebcilOutputPath)')">
+        <RelativePath>$([System.IO.Path]::ChangeExtension(%(RelativePath), '.wasm'))</RelativePath>
+        <OriginalItemSpec>%(WebcilOutputPath)</OriginalItemSpec>
+      </_WasmWebcilConvertedNonCulture>
+      <_WasmWebcilConvertedCulture Include="@(_WasmDllBuildCandidatesCulture->'%(WebcilOutputPath)')">
+        <RelativePath>$([System.IO.Path]::ChangeExtension(%(RelativePath), '.wasm'))</RelativePath>
+        <OriginalItemSpec>%(WebcilOutputPath)</OriginalItemSpec>
+        <RelatedAsset>$([System.IO.Path]::ChangeExtension(%(RelatedAsset), '.wasm'))</RelatedAsset>
+      </_WasmWebcilConvertedCulture>
+
+      <!-- Webcil-converted items + WasmNativeBuildOutput items → Computed (per-project already) -->
+      <_WebcilAssetsCandidates Include="@(_WasmNativeBuildOutputCandidates)" />
+      <_WebcilAssetsCandidates Include="@(_WasmWebcilConvertedNonCulture)" />
+      <_WebcilAssetsCandidates Include="@(_WasmWebcilConvertedCulture)" />
+
+      <!-- Non-DLL items without WasmNativeBuildOutput → Framework (need per-project materialization) -->
+      <_WasmFrameworkCandidates Include="@(_WasmNonDllNonNativeCandidates)" />
+
+      <!-- Track webcil files for clean operations even when the conversion target was skipped -->
+      <FileWrites Include="@(_WasmExpectedWebcilOutputs)" />
+    </ItemGroup>
+
+    <!-- When webcil is disabled, DLLs retain their shared paths and also need Framework
+         materialization (along with non-DLL items). Only WasmNativeBuildOutput items are
+         already per-project (Computed). -->
+    <ItemGroup Condition="'$(_WasmEnableWebcil)' != 'true'">
+      <_WebcilAssetsCandidates Include="@(_WasmNativeBuildOutputCandidates)" />
+      <_WasmFrameworkCandidates Include="@(_WasmNonDllNonNativeCandidates)" />
+      <_WasmFrameworkCandidates Include="@(_BuildAssetsCandidates)" Condition="'%(Extension)' == '.dll'" />
     </ItemGroup>
 
     <ItemGroup>
@@ -489,7 +590,9 @@ Copyright (c) .NET Foundation. All rights reserved.
     </ItemGroup>
   </Target>
 
-  <Target Name="_GenerateBuildWasmBootJson" DependsOnTargets="$(GenerateBuildWasmBootJsonDependsOn)">
+  <!-- Resolve static web asset endpoints for the boot JSON generation.
+       This target always runs to compute JS module candidates and wasm asset endpoints. -->
+  <Target Name="_ResolveBuildWasmBootJsonEndpoints" DependsOnTargets="$(GenerateBuildWasmBootJsonDependsOn)">
     <PropertyGroup>
       <_WasmBuildBootJsonPath>$(IntermediateOutputPath)$(_WasmBootConfigFileName)</_WasmBuildBootJsonPath>
       <_WasmBuildApplicationEnvironmentName>$(WasmApplicationEnvironmentName)</_WasmBuildApplicationEnvironmentName>
@@ -543,6 +646,33 @@ Copyright (c) .NET Foundation. All rights reserved.
     >
       <Output TaskParameter="ResolvedEndpoints" ItemName="_WasmResolvedEndpoints" />
     </ResolveFingerprintedStaticWebAssetEndpointsForAssets>
+  </Target>
+
+  <!-- Write a property stamp file that captures non-file parameters passed to GenerateWasmBootJson.
+       This ensures property-only changes (e.g., WasmDebugLevel, environment name) invalidate the
+       incremental boot JSON target. WriteOnlyWhenDifferent preserves the timestamp when unchanged. -->
+  <Target Name="_WriteWasmBootJsonBuildPropertyStamp"
+    DependsOnTargets="_ResolveBuildWasmBootJsonEndpoints">
+    <PropertyGroup>
+      <_WasmBootJsonBuildStampContent>$(WasmDebugLevel)|$(_WasmBuildApplicationEnvironmentName)|$(_BlazorCacheBootResources)|$(InvariantGlobalization)|$(_LoadCustomIcuData)|$(_BlazorWebAssemblyLoadAllGlobalizationData)|$(_BlazorWebAssemblyJiterpreter)|$(_BlazorWebAssemblyRuntimeOptions)|$(RunAOTCompilation)|$(WasmEnableThreads)|$(_WasmFingerprintAssets)|$(_WasmBundlerFriendlyBootConfig)|$(WasmProfilers)|$(TargetFrameworkVersion)|$(DiagnosticPorts)|$(StaticWebAssetStandaloneHosting)|@(WasmEnvironmentVariable->'%(Identity)=%(Value)')|@(BlazorWebAssemblyLazyLoad)|@(WasmModuleAfterConfigLoaded)|@(WasmModuleAfterRuntimeReady)|$(WasmTestExitOnUnhandledError)|$(WasmTestAppendElementOnExit)|$(WasmTestLogExitCode)|$(WasmTestAsyncFlushOnExit)|$(WasmTestForwardConsole)</_WasmBootJsonBuildStampContent>
+    </PropertyGroup>
+    <WriteLinesToFile
+      File="$(IntermediateOutputPath)wasm-bootjson-build.stamp"
+      Lines="$(_WasmBootJsonBuildStampContent)"
+      Overwrite="true"
+      WriteOnlyWhenDifferent="true" />
+    <ItemGroup>
+      <FileWrites Include="$(IntermediateOutputPath)wasm-bootjson-build.stamp" />
+    </ItemGroup>
+  </Target>
+
+  <!-- Write the boot JSON file for the build.
+       This target is incremental: when all inputs (assemblies, static web assets, VFS files,
+       config files, extensions, property stamp) are older than the output, the target is skipped. -->
+  <Target Name="_WriteBuildWasmBootJsonFile"
+    DependsOnTargets="_WriteWasmBootJsonBuildPropertyStamp"
+    Inputs="@(IntermediateAssembly);@(WasmStaticWebAsset);@(_WasmJsModuleCandidatesForBuild);@(_WasmFilesToIncludeInFileSystemStaticWebAsset);@(_WasmJsConfigStaticWebAsset);@(_WasmDotnetJsForBuild);@(WasmBootConfigExtension);$(ProjectRuntimeConfigFilePath);$(MSBuildProjectFullPath);$(MSBuildThisFileFullPath);$(_WebAssemblySdkTasksAssembly);$(IntermediateOutputPath)wasm-bootjson-build.stamp"
+    Outputs="$(_WasmBuildBootJsonPath)">
 
     <GenerateWasmBootJson
       AssemblyPath="@(IntermediateAssembly)"
@@ -584,7 +714,19 @@ Copyright (c) .NET Foundation. All rights reserved.
       <FileWrites Include="$(_WasmBuildBootJsonPath)" />
     </ItemGroup>
 
+    <!-- The GenerateWasmBootJson task uses content comparison and preserves old timestamps when
+         the output content is unchanged. Touch the output so MSBuild's Inputs/Outputs check
+         sees a current timestamp and can correctly skip this target on subsequent builds. -->
+    <Touch Files="$(_WasmBuildBootJsonPath)" />
+  </Target>
+
+  <!-- Define the boot config file as a static web asset and create endpoints.
+       This target always runs to ensure items are populated even when _WriteBuildWasmBootJsonFile is skipped. -->
+  <Target Name="_GenerateBuildWasmBootJson" DependsOnTargets="_WriteBuildWasmBootJsonFile">
+
     <ItemGroup>
+      <!-- Track boot JSON for clean operations even when _WriteBuildWasmBootJsonFile was skipped -->
+      <FileWrites Include="$(_WasmBuildBootJsonPath)" />
       <_WasmBuildBootConfigCandidate
         Include="$(_WasmBuildBootJsonPath)"
         RelativePath="_framework/$(_WasmBootConfigFileName)" />
@@ -902,6 +1044,8 @@ Copyright (c) .NET Foundation. All rights reserved.
   <Target Name="_AddPublishWasmBootJsonToStaticWebAssets" DependsOnTargets="GeneratePublishWasmBootJson">
 
     <ItemGroup>
+      <!-- Track boot JSON for clean operations even when GeneratePublishWasmBootJson was skipped -->
+      <FileWrites Include="$(IntermediateOutputPath)$(_WasmPublishBootConfigFileName)" />
       <_WasmPublishBootConfigCandidate
         Include="$(IntermediateOutputPath)$(_WasmPublishBootConfigFileName)"
         RelativePath="_framework/$(_WasmBootConfigFileName)" />
@@ -939,7 +1083,9 @@ Copyright (c) .NET Foundation. All rights reserved.
 
   </Target>
 
-  <Target Name="GeneratePublishWasmBootJson" DependsOnTargets="$(GeneratePublishWasmBootJsonDependsOn)">
+  <!-- Resolve inputs for the publish boot JSON target.
+       This target always runs to compute publish asset items and endpoints. -->
+  <Target Name="_ResolvePublishWasmBootJsonInputs" DependsOnTargets="$(GeneratePublishWasmBootJsonDependsOn)">
     <PropertyGroup>
       <_WasmPublishApplicationEnvironmentName>$(WasmApplicationEnvironmentName)</_WasmPublishApplicationEnvironmentName>
     </PropertyGroup>
@@ -972,6 +1118,31 @@ Copyright (c) .NET Foundation. All rights reserved.
     >
       <Output TaskParameter="ResolvedEndpoints" ItemName="_WasmResolvedEndpointsForPublish" />
     </ResolveFingerprintedStaticWebAssetEndpointsForAssets>
+  </Target>
+
+  <!-- Write a property stamp for publish boot JSON incrementalism. Same approach as build stamp. -->
+  <Target Name="_WriteWasmPublishBootJsonPropertyStamp"
+    DependsOnTargets="_ResolvePublishWasmBootJsonInputs">
+    <PropertyGroup>
+      <_WasmBootJsonPublishStampContent>$(WasmDebugLevel)|$(_WasmPublishApplicationEnvironmentName)|$(_BlazorCacheBootResources)|$(InvariantGlobalization)|$(_LoadCustomIcuData)|$(_BlazorWebAssemblyLoadAllGlobalizationData)|$(_BlazorWebAssemblyJiterpreter)|$(_BlazorWebAssemblyRuntimeOptions)|$(RunAOTCompilation)|$(WasmEnableThreads)|$(_WasmFingerprintAssets)|$(_WasmBundlerFriendlyBootConfig)|$(WasmProfilers)|$(TargetFrameworkVersion)|$(DiagnosticPorts)|$(StaticWebAssetStandaloneHosting)|@(WasmEnvironmentVariable->'%(Identity)=%(Value)')|@(BlazorWebAssemblyLazyLoad)|@(WasmModuleAfterConfigLoaded)|@(WasmModuleAfterRuntimeReady)|$(WasmTestExitOnUnhandledError)|$(WasmTestAppendElementOnExit)|$(WasmTestLogExitCode)|$(WasmTestAsyncFlushOnExit)|$(WasmTestForwardConsole)</_WasmBootJsonPublishStampContent>
+    </PropertyGroup>
+    <WriteLinesToFile
+      File="$(IntermediateOutputPath)wasm-bootjson-publish.stamp"
+      Lines="$(_WasmBootJsonPublishStampContent)"
+      Overwrite="true"
+      WriteOnlyWhenDifferent="true" />
+    <ItemGroup>
+      <FileWrites Include="$(IntermediateOutputPath)wasm-bootjson-publish.stamp" />
+    </ItemGroup>
+  </Target>
+
+  <!-- Write the publish boot JSON file.
+       This target is incremental: when all inputs (assemblies, publish assets, config files,
+       extensions, property stamp) are older than the output, the target is skipped. -->
+  <Target Name="GeneratePublishWasmBootJson"
+    DependsOnTargets="_WriteWasmPublishBootJsonPropertyStamp"
+    Inputs="@(IntermediateAssembly);@(_WasmPublishAsset);@(_WasmJsModuleCandidatesForPublish);@(_WasmPublishConfigFile);@(_WasmDotnetJsForPublish);@(WasmBootConfigExtension);$(ProjectRuntimeConfigFilePath);$(MSBuildProjectFullPath);$(MSBuildThisFileFullPath);$(_WebAssemblySdkTasksAssembly);$(IntermediateOutputPath)wasm-bootjson-publish.stamp"
+    Outputs="$(IntermediateOutputPath)$(_WasmPublishBootConfigFileName)">
 
     <GenerateWasmBootJson
       AssemblyPath="@(IntermediateAssembly)"
@@ -1013,6 +1184,11 @@ Copyright (c) .NET Foundation. All rights reserved.
       <FileWrites Include="$(IntermediateOutputPath)$(_WasmPublishBootConfigFileName)" />
     </ItemGroup>
 
+    <!-- The GenerateWasmBootJson task uses content comparison and preserves old timestamps when
+         the output content is unchanged. Touch the output so MSBuild's Inputs/Outputs check
+         sees a current timestamp and can correctly skip this target on subsequent builds. -->
+    <Touch Files="$(IntermediateOutputPath)$(_WasmPublishBootConfigFileName)" />
+
   </Target>
 
   <Target Name="_WasmNative"
diff --git a/src/mono/wasm/Wasm.Build.Tests/RebuildTests.cs b/src/mono/wasm/Wasm.Build.Tests/RebuildTests.cs
index a3b8c189f26531..6174afab601d1a 100644
--- a/src/mono/wasm/Wasm.Build.Tests/RebuildTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/RebuildTests.cs
@@ -9,6 +9,7 @@
 using Xunit;
 using Xunit.Abstractions;
 using Xunit.Sdk;
+using SL = Microsoft.Build.Logging.StructuredLogger;
 
 #nullable enable
 
@@ -46,5 +47,171 @@ public async Task NoOpRebuild(Configuration config, bool aot)
             PublishProject(info, config, new PublishOptions(UseCache: false));
             await RunForPublishWithWebServer(runOptions);
         }
+
+        [Theory]
+        [InlineData(Configuration.Debug)]
+        [InlineData(Configuration.Release)]
+        public void IncrementalPublish_NoChanges_SkipsBootJson(Configuration config)
+        {
+            ProjectInfo info = CopyTestAsset(config, aot: false, TestAsset.WasmBasicTestApp, "incremental_pub_noop");
+            UpdateFile(Path.Combine("Common", "Program.cs"), s_mainReturns42);
+
+            (_, string firstBinlog) = BuildProjectWithoutAssert(config, info.ProjectName, new PublishOptions(Label: "first"));
+            _testOutput.WriteLine($"First publish binlog: {firstBinlog}");
+
+            // no-op publish
+            (_, string secondBinlog) = BuildProjectWithoutAssert(config, info.ProjectName, new PublishOptions(UseCache: false, Label: "second"));
+            _testOutput.WriteLine($"Second publish binlog: {secondBinlog}");
+
+            AssertTargetSkipped(secondBinlog, "GeneratePublishWasmBootJson");
+        }
+
+        [Theory]
+        [InlineData(Configuration.Debug)]
+        [InlineData(Configuration.Release)]
+        public void IncrementalPublish_SourceChange_RunsBootJson(Configuration config)
+        {
+            ProjectInfo info = CopyTestAsset(config, aot: false, TestAsset.WasmBasicTestApp, "incremental_pub_src");
+            UpdateFile(Path.Combine("Common", "Program.cs"), s_mainReturns42);
+
+            BuildProjectWithoutAssert(config, info.ProjectName, new PublishOptions(Label: "first"));
+
+            // modify app source to trigger recompilation
+            string programPath = Path.Combine(_projectDir, "Common", "Program.cs");
+            File.AppendAllText(programPath, Environment.NewLine + "// incremental publish trigger");
+
+            (_, string secondBinlog) = BuildProjectWithoutAssert(config, info.ProjectName, new PublishOptions(UseCache: false, Label: "second"));
+            _testOutput.WriteLine($"Second publish binlog: {secondBinlog}");
+
+            AssertTargetRan(secondBinlog, "GeneratePublishWasmBootJson");
+        }
+
+        [Theory]
+        [InlineData(Configuration.Debug)]
+        [InlineData(Configuration.Release)]
+        public void IncrementalBuild_NoChanges_SkipsWebcilAndBootJson(Configuration config)
+        {
+            ProjectInfo info = CopyTestAsset(config, aot: false, TestAsset.WasmBasicTestApp, "incremental_noop");
+            UpdateFile(Path.Combine("Common", "Program.cs"), s_mainReturns42);
+
+            (_, string firstBinlog) = BuildProjectWithoutAssert(config, info.ProjectName, new BuildOptions(Label: "first"));
+            _testOutput.WriteLine($"First build binlog: {firstBinlog}");
+
+            // no-op rebuild
+            (_, string secondBinlog) = BuildProjectWithoutAssert(config, info.ProjectName, new BuildOptions(UseCache: false, Label: "second"));
+            _testOutput.WriteLine($"Second build binlog: {secondBinlog}");
+
+            if (UseWebcil)
+                AssertTargetSkipped(secondBinlog, "_ConvertBuildDllsToWebcil");
+            AssertTargetSkipped(secondBinlog, "_WriteBuildWasmBootJsonFile");
+        }
+
+        [Theory]
+        [InlineData(Configuration.Debug)]
+        [InlineData(Configuration.Release)]
+        public void IncrementalBuild_SourceChange_RunsWebcilForAppOnly(Configuration config)
+        {
+            ProjectInfo info = CopyTestAsset(config, aot: false, TestAsset.WasmBasicTestApp, "incremental_src");
+            UpdateFile(Path.Combine("Common", "Program.cs"), s_mainReturns42);
+
+            BuildProjectWithoutAssert(config, info.ProjectName, new BuildOptions(Label: "first"));
+
+            // modify app source to trigger recompilation
+            string programPath = Path.Combine(_projectDir, "Common", "Program.cs");
+            File.AppendAllText(programPath, Environment.NewLine + "// incremental rebuild trigger");
+
+            (_, string secondBinlog) = BuildProjectWithoutAssert(config, info.ProjectName, new BuildOptions(UseCache: false, Label: "second"));
+            _testOutput.WriteLine($"Second build binlog: {secondBinlog}");
+
+            // Boot JSON target must run because the app assembly changed
+            AssertTargetRan(secondBinlog, "_WriteBuildWasmBootJsonFile");
+
+            if (UseWebcil)
+            {
+                // Webcil conversion target must run because the app assembly changed
+                AssertTargetRan(secondBinlog, "_ConvertBuildDllsToWebcil");
+
+                // Only the app assembly should have been re-converted (not framework DLLs)
+                var convertedFiles = GetConvertedWebcilFiles(secondBinlog);
+                _testOutput.WriteLine($"Webcil-converted files: {string.Join(", ", convertedFiles)}");
+                Assert.Single(convertedFiles);
+                Assert.Contains(convertedFiles, f => f.Contains(info.ProjectName, StringComparison.OrdinalIgnoreCase));
+            }
+        }
+
+        private static void AssertTargetSkipped(string binlogPath, string targetName)
+        {
+            var build = SL.BinaryLog.ReadBuild(binlogPath);
+            SL.BuildAnalyzer.AnalyzeBuild(build);
+
+            bool found = false;
+            bool skipped = false;
+            build.VisitAllChildren<SL.Target>(t =>
+            {
+                if (t.Name == targetName)
+                {
+                    found = true;
+                    if (t.Children.OfType<SL.Message>().Any(m =>
+                        m.Text is not null && m.Text.Contains("Skipping target")))
+                    {
+                        skipped = true;
+                    }
+                }
+            });
+
+            Assert.True(found, $"Target '{targetName}' was not found in the binlog '{binlogPath}'.");
+            Assert.True(skipped, $"Target '{targetName}' was expected to be skipped but it ran.");
+        }
+
+        private static void AssertTargetRan(string binlogPath, string targetName)
+        {
+            var build = SL.BinaryLog.ReadBuild(binlogPath);
+            SL.BuildAnalyzer.AnalyzeBuild(build);
+
+            bool found = false;
+            bool ran = false;
+            build.VisitAllChildren<SL.Target>(t =>
+            {
+                if (t.Name == targetName)
+                {
+                    found = true;
+                    if (t.Children.OfType<SL.Message>().Any(m =>
+                        m.Text is not null && m.Text.Contains("Building target")))
+                    {
+                        ran = true;
+                    }
+                }
+            });
+
+            Assert.True(found, $"Target '{targetName}' was not found in the binlog '{binlogPath}'.");
+            Assert.True(ran, $"Target '{targetName}' was expected to run but it was skipped.");
+        }
+
+        private static List<string> GetConvertedWebcilFiles(string binlogPath)
+        {
+            var build = SL.BinaryLog.ReadBuild(binlogPath);
+            SL.BuildAnalyzer.AnalyzeBuild(build);
+
+            var converted = new List<string>();
+            build.VisitAllChildren<SL.Target>(t =>
+            {
+                if (t.Name != "_ConvertBuildDllsToWebcil")
+                    return;
+
+                foreach (var child in t.Children)
+                {
+                    if (child is not SL.Task { Name: "ConvertDllsToWebcil" } convertTask)
+                        continue;
+
+                    convertTask.VisitAllChildren<SL.Message>(m =>
+                    {
+                        if (m.Text is not null && m.Text.StartsWith("Converting to Webcil:"))
+                            converted.Add(m.Text);
+                    });
+                }
+            });
+
+            return converted;
+        }
     }
 }