diff --git a/documentation/general/publish-build-optimization.md b/documentation/general/publish-build-optimization.md
new file mode 100644
index 000000000000..efafc791930d
--- /dev/null
+++ b/documentation/general/publish-build-optimization.md
@@ -0,0 +1,139 @@
+# Publish Build Optimization
+
+## Overview
+
+When `dotnet publish` runs, it implicitly runs a full `Build` before the publish step.
+This is necessary because the SDK cannot assume the previous `dotnet build` used the same
+configuration (e.g., the default build configuration is `Debug` while publish defaults to
+`Release`), runtime identifier, or other settings.
+
+However, for some publish modes, the full `Build` output (written to `bin\<config>\<tfm>\<rid>\`)
+is never used by the publish pipeline. The publish steps read from intermediate outputs
+(`obj\`) and resolution items, not from the `bin\` directory. This means the `Build` step
+produces artifacts that are confusing to users and automation, as `bin\<config>\<tfm>\<rid>\`
+contains a full self-contained managed deployment that is not the intended output.
+
+## How Publish Modes Work Today
+
+### Common Architecture
+
+All publish modes share this flow:
+
+1. **Build** (or equivalent) — produces the IL assembly at `@(IntermediateAssembly)` in `obj\`
+2. **ComputeResolvedFilesToPublishList** — collects files to publish from `@(IntermediateAssembly)`,
+   `@(RuntimeCopyLocalItems)`, `@(RuntimePackAsset)`, and content items
+3. **Post-processing** — mode-specific transformations (ILC, ILLink, crossgen2, bundler)
+4. **Copy to PublishDir** — final output written to `bin\<config>\<tfm>\<rid>\publish\`
+
+Key insight: All post-processing steps read from `@(IntermediateAssembly)` (obj) and
+`@(ResolvedFileToPublish)` (resolved from NuGet/project references), **never** from the
+`Build` output directory.
+
+### PublishAot (Native AOT)
+
+**Status: Optimized**
+
+- `IlcCompile` reads `@(IntermediateAssembly)` from `obj\` and produces a native binary
+- The full `Build` was running a self-contained deployment to `bin\<config>\<tfm>\<rid>\`,
+  including apphost, managed DLLs, deps.json, runtimeconfig.json, and runtime pack files
+- **None of these files are used** by the AOT pipeline
+- **Optimization**: Replace `Build` with `Compile` (plus resource/satellite targets)
+- **Opt-out**: Set `UseOptimizedPublish=false` to restore full Build behavior
+- `UseOptimizedPublish` currently has no effect when `PublishAot` is not enabled
+
+Target chain for optimized AOT publish:
+```
+BuildOnlySettings → PrepareForBuild → PrepareResources → Compile → CreateSatelliteAssemblies
+```
+
+Where `Compile` includes `ResolveReferences → ResolveProjectReferences → CoreCompile`.
+
+### PublishTrimmed (IL Trimming)
+
+**Status: Not yet optimized — candidate for future optimization**
+
+- `ILLink` (the IL trimmer) processes `@(ResolvedFileToPublish)` items marked with
+  `PostprocessAssembly=true`
+- These items come from `ComputeResolvedFilesToPublishList` which reads from
+  `@(IntermediateAssembly)` (obj) and resolved references
+- The `Build` output in `bin\` is not consumed by the trimmer
+- The same `Compile`-based optimization would apply here
+
+### PublishReadyToRun (R2R / Crossgen2)
+
+**Status: Not yet optimized — candidate for future optimization**
+
+- `RunCrossgen2` processes `@(ResolvedFileToPublish)` items
+- Input assemblies come from resolution, not from `Build` output
+- Same optimization opportunity as trimming
+
+### PublishSingleFile (Single-File Bundling)
+
+**Status: Not yet optimized — candidate for future optimization**
+
+- `GenerateSingleFileBundle` bundles `@(ResolvedFileToPublish)` items into one executable
+- All inputs come from resolved items and `@(IntermediateAssembly)`
+- Same optimization opportunity
+
+### Combined Modes
+
+These modes can be combined (e.g., `PublishAot` implies `PublishTrimmed`). The optimization
+applies when the outermost mode is optimized:
+
+| Combination | Optimized? | Notes |
+|---|---|---|
+| PublishAot (implies trimmed) | ✅ Yes | AOT is the outermost mode |
+| PublishTrimmed + PublishSingleFile | ❌ Not yet | Future candidate |
+| PublishReadyToRun + PublishSingleFile | ❌ Not yet | Future candidate |
+| PublishTrimmed alone | ❌ Not yet | Future candidate |
+| PublishReadyToRun alone | ❌ Not yet | Future candidate |
+
+## Breaking Change: AOT Publish Build Optimization
+
+### What Changed
+
+Starting in .NET 11, `dotnet publish` with `PublishAot=true` no longer runs a full `Build`
+before publish. Instead, it runs only `Compile` (and resource/satellite assembly targets).
+
+### Impact
+
+- **BeforeBuild / AfterBuild targets**: These will not execute during AOT publish. If you have
+  custom targets attached to `BeforeBuild`, `AfterBuild`, or using
+  `BeforeTargets="Build"` / `AfterTargets="Build"`, they will not run.
+  - **Workaround**: Attach your targets to `BeforeTargets="Publish"` / `AfterTargets="Publish"`,
+    or to `BeforeTargets="Compile"` / `AfterTargets="Compile"` instead.
+- **PreBuildEvent / PostBuildEvent**: These will not execute during AOT publish (consistent
+  with `--no-build` behavior).
+- **Third-party NuGet Build hooks**: Targets from NuGet packages that hook into `Build` will be
+  skipped (consistent with `--no-build` behavior).
+- **Output directory**: `bin\<config>\<tfm>\<rid>\` will no longer contain managed apphost,
+  DLLs, deps.json, runtimeconfig.json, or runtime pack files. Only `native\` and `publish\`
+  subdirectories will be present.
+
+### Opt-Out
+
+To restore the previous behavior of running a full `Build` before AOT publish, set:
+
+```xml
+<PropertyGroup>
+  <UseOptimizedPublish>false</UseOptimizedPublish>
+</PropertyGroup>
+```
+
+Or pass it on the command line:
+
+```
+dotnet publish /p:UseOptimizedPublish=false
+```
+
+## Future Work
+
+The same optimization could be applied to `PublishTrimmed`, `PublishReadyToRun`, and
+`PublishSingleFile` modes, as they all share the same architecture of reading from
+`@(IntermediateAssembly)` and resolved references rather than `Build` output. Each mode
+would need:
+
+1. Compatibility analysis for Build hooks used by projects and NuGet packages
+2. The same target chain: `BuildOnlySettings → PrepareForBuild → PrepareResources → Compile → CreateSatelliteAssemblies`
+3. Tests verifying the expected build and publish outputs
+4. Documentation of the breaking change for that mode
diff --git a/src/StaticWebAssetsSdk/Targets/Microsoft.NET.Sdk.StaticWebAssets.targets b/src/StaticWebAssetsSdk/Targets/Microsoft.NET.Sdk.StaticWebAssets.targets
index 5956ae0470de..b72da2d4f3c2 100644
--- a/src/StaticWebAssetsSdk/Targets/Microsoft.NET.Sdk.StaticWebAssets.targets
+++ b/src/StaticWebAssetsSdk/Targets/Microsoft.NET.Sdk.StaticWebAssets.targets
@@ -303,6 +303,13 @@ Copyright (c) .NET Foundation. All rights reserved.
 
     <GenerateStaticWebAssetsManifestDependsOn>$(GenerateStaticWebAssetsManifestDependsOn);ResolveBuildStaticWebAssets</GenerateStaticWebAssetsManifestDependsOn>
 
+    <!-- The AOT-optimized publish path (UseOptimizedPublish) runs Compile instead of full Build,
+         which skips PrepareForRun and therefore GenerateStaticWebAssetsManifest. The publish pipeline
+         still expects the static web assets build manifest (staticwebassets.build.json) to exist, so
+         contribute manifest generation to the optimized publish extension point. This writes only
+         to the intermediate (obj\) directory and does not copy assets to the output (bin\) directory. -->
+    <_AdditionalOptimizedPublishTargets>$(_AdditionalOptimizedPublishTargets);GenerateStaticWebAssetsManifest</_AdditionalOptimizedPublishTargets>
+
     <!-- There are now three stages:
       ResolveCoreStaticWebAssets: This is the stage where we resolve the static web assets for the current project, packages and project references. These assets exist on disk
       and are part of the project or one of its dependencies.
diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Publish.targets b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Publish.targets
index 95703653526e..a0949a31d568 100644
--- a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Publish.targets
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Publish.targets
@@ -148,19 +148,43 @@ Copyright (c) .NET Foundation. All rights reserved.
     </_CorePublishTargets>
 
     <_PublishNoBuildAlternativeDependsOn>$(_BeforePublishNoBuildTargets);$(_CorePublishTargets)</_PublishNoBuildAlternativeDependsOn>
+
+    <!-- For AOT publish, we only need Compile (not full Build) since IlcCompile reads from
+         @(IntermediateAssembly) in obj\, not from bin\ output. Skipping Build avoids producing
+         unnecessary self-contained managed output (apphost, deps.json, runtimeconfig, runtime
+         pack files) in the output directory that would confuse users and automation.
+         Set UseOptimizedPublish=false to restore the previous behavior of running full Build. -->
+    <UseOptimizedPublish Condition="'$(UseOptimizedPublish)' == '' and '$(PublishAot)' == 'true'">true</UseOptimizedPublish>
+    <!-- Native AOT is currently the only publish mode that supports optimized publish. -->
+    <_UseOptimizedPublish Condition="'$(PublishAot)' == 'true' and '$(UseOptimizedPublish)' == 'true'">true</_UseOptimizedPublish>
+    <_BeforeOptimizedPublishTargets Condition="'$(_UseOptimizedPublish)' == 'true'">
+      BuildOnlySettings;
+      PrepareForBuild;
+      PrepareResources;
+      Compile;
+      CreateSatelliteAssemblies;
+    </_BeforeOptimizedPublishTargets>
   </PropertyGroup>
 
   <Target Name="_PublishBuildAlternative"
-          Condition="'$(NoBuild)' != 'true'"
+          Condition="'$(NoBuild)' != 'true' and '$(_UseOptimizedPublish)' != 'true'"
           DependsOnTargets="Build;$(_CorePublishTargets)" />
 
+  <!-- $(_AdditionalOptimizedPublishTargets) is an extension point for SDKs (e.g. Static Web Assets)
+       that hook additional work into the full Build via targets which the AOT-optimized path skips.
+       It runs after Compile so contributors can rely on the intermediate assembly, and before the core
+       publish targets that consume its outputs. -->
+  <Target Name="_PublishOptimizedBuildAlternative"
+          Condition="'$(NoBuild)' != 'true' and '$(_UseOptimizedPublish)' == 'true'"
+          DependsOnTargets="$(_BeforeOptimizedPublishTargets);$(_AdditionalOptimizedPublishTargets);$(_CorePublishTargets)" />
+
   <Target Name="_PublishNoBuildAlternative"
           Condition="'$(NoBuild)' == 'true'"
           DependsOnTargets="$(_PublishNoBuildAlternativeDependsOn)" />
 
   <Target Name="Publish"
           Condition="$(IsPublishable) == 'true'"
-          DependsOnTargets="_PublishBuildAlternative;_PublishNoBuildAlternative" >
+          DependsOnTargets="_PublishBuildAlternative;_PublishOptimizedBuildAlternative;_PublishNoBuildAlternative" >
 
     <!-- Ensure there is minimal verbosity output pointing to the publish directory and not just the
          build step's minimal output. Otherwise there is no indication at minimal verbosity of where
diff --git a/test/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs b/test/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs
index 8a282a9076a3..cea5d8f69738 100644
--- a/test/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs
+++ b/test/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs
@@ -34,6 +34,7 @@ public void NativeAot_hw_runs_with_no_warnings_when_PublishAot_is_enabled(string
 
             var testProject = CreateHelloWorldTestProject(targetFramework, projectName, true);
             testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            testProject.RecordPropertiesBeforeTarget("Publish");
             testProject.AdditionalProperties["PublishAot"] = "true";
             // Linux symbol files are embedded and require additional steps to be stripped to a separate file
             // assumes /bin (or /usr/bin) are in the PATH
@@ -124,6 +125,7 @@ public void NativeAot_app_runs_in_debug_with_no_config_when_PublishAot_is_enable
 
             var testProject = CreateAppForConfigCheck(targetFramework, projectName, true);
             testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            testProject.RecordPropertiesBeforeTarget("Publish");
             testProject.AdditionalProperties["PublishAot"] = "true";
             testProject.AdditionalProperties["Configuration"] = projectConfiguration;
             // Linux symbol files are embedded and require additional steps to be stripped to a separate file
@@ -176,6 +178,7 @@ public void NativeAot_app_runs_in_release_with_no_config_when_PublishAot_is_enab
 
             var testProject = CreateAppForConfigCheck(targetFramework, projectName, true);
             testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            testProject.RecordPropertiesBeforeTarget("Publish");
             testProject.AdditionalProperties["PublishAot"] = "true";
             testProject.AdditionalProperties["Configuration"] = projectConfiguration;
             // Linux symbol files are embedded and require additional steps to be stripped to a separate file
@@ -267,6 +270,7 @@ public void NativeAot_hw_runs_with_PackageReference_PublishAot_is_enabled(string
 
             var testProject = CreateHelloWorldTestProject(targetFramework, projectName, true);
             testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            testProject.RecordPropertiesBeforeTarget("Publish");
             testProject.AdditionalProperties["PublishAot"] = "true";
 
             // This will add a reference to a package that will also be automatically imported by the SDK
@@ -390,6 +394,7 @@ public void NativeAot_hw_runs_with_cross_PackageReference_PublishAot_is_enabled(
 
                 var testProject = CreateHelloWorldTestProject(targetFramework, projectName, true);
                 testProject.RecordProperties("BundledNETCoreAppPackageVersion");
+                testProject.RecordPropertiesBeforeTarget("Publish");
                 testProject.AdditionalProperties["PublishAot"] = "true";
 
                 // This will add a reference to a package that will also be automatically imported by the SDK
@@ -732,6 +737,7 @@ public void NativeAot_compiler_runs_when_PublishAot_is_enabled(string targetFram
             // PublishAot should enable the EnableAotAnalyzer, EnableTrimAnalyzer and EnableSingleFileAnalyzer
             var testProject = CreateTestProjectWithAnalysisWarnings(targetFramework, projectName, true);
             testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            testProject.RecordPropertiesBeforeTarget("Publish");
             testProject.AdditionalProperties["PublishAot"] = "true";
             testProject.AdditionalProperties["SuppressTrimAnalysisWarnings"] = "false";
             testProject.AdditionalProperties["UseCurrentRuntimeIdentifier"] = "true";
@@ -829,6 +835,7 @@ public void Warnings_are_generated_even_with_analyzers_disabled(string targetFra
             // only if they don't have a predefined value
             var testProject = CreateTestProjectWithAnalysisWarnings(targetFramework, projectName, true);
             testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            testProject.RecordPropertiesBeforeTarget("Publish");
             testProject.AdditionalProperties["PublishAot"] = "true";
             testProject.AdditionalProperties["EnableAotAnalyzer"] = "false";
             testProject.AdditionalProperties["EnableTrimAnalyzer"] = "false";
@@ -869,6 +876,7 @@ public void NativeAotStaticLib_only_runs_when_switch_is_enabled(string targetFra
 
             var testProject = CreateTestProjectWithAotLibrary(targetFramework, projectName);
             testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            testProject.RecordPropertiesBeforeTarget("Publish");
             testProject.AdditionalProperties["PublishAot"] = "true";
             testProject.AdditionalProperties["UseCurrentRuntimeIdentifier"] = "true";
             testProject.AdditionalProperties["SelfContained"] = "true";
@@ -925,6 +933,7 @@ public void NativeAotSharedLib_only_runs_when_switch_is_enabled(string targetFra
 
             var testProject = CreateTestProjectWithAotLibrary(targetFramework, projectName);
             testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            testProject.RecordPropertiesBeforeTarget("Publish");
             testProject.AdditionalProperties["PublishAot"] = "true";
             testProject.AdditionalProperties["UseCurrentRuntimeIdentifier"] = "true";
             testProject.AdditionalProperties["NativeLib"] = "Shared";
@@ -1085,6 +1094,7 @@ public void NativeAot_app_publishes_with_app_and_package_satellite_assemblies()
             var projectName = "NativeAotAppWithSatellites";
             var testProject = CreateHelloWorldTestProject(ToolsetInfo.CurrentTargetFramework, projectName, true);
             testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            testProject.RecordPropertiesBeforeTarget("Publish");
             testProject.AdditionalProperties["PublishAot"] = "true";
             testProject.AdditionalProperties["SatelliteResourceLanguages"] = "fr;de";
             if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
@@ -1380,6 +1390,172 @@ private static bool IsNativeImage(string path)
             }
         }
 
+        [TestMethod]
+        public void Aot_optimized_publish_targets_are_reviewed_when_CoreBuildDependsOn_changes()
+        {
+            var testProject = CreateHelloWorldTestProject(ToolsetInfo.CurrentTargetFramework, "CoreBuildDependsOn", true);
+            var testAsset = TestAssetsManager.CreateTestProject(testProject);
+
+            var getValuesCommand = new GetValuesCommand(testAsset, "CoreBuildDependsOn")
+            {
+                ShouldCompile = false
+            };
+
+            getValuesCommand
+                .Execute()
+                .Should().Pass();
+
+            getValuesCommand.GetValues().Should().Equal([
+                "_CheckForBuildWithNoBuild",
+                "BuildOnlySettings",
+                "PrepareForBuild",
+                "PreBuildEvent",
+                "ResolveReferences",
+                "PrepareResources",
+                "ResolveKeySource",
+                "Compile",
+                "ExportWindowsMDFile",
+                "UnmanagedUnregistration",
+                "GenerateSerializationAssemblies",
+                "CreateSatelliteAssemblies",
+                "GenerateManifests",
+                "GetTargetPath",
+                "PrepareForRun",
+                "UnmanagedRegistration",
+                "IncrementalClean",
+                "PostBuildEvent",
+                "GenerateBuildDependencyFile",
+                "GenerateBuildRuntimeConfigurationFiles"],
+                because: "CoreBuildDependsOn changed. Review added or removed targets for their impact on optimized publish, update the optimized target chain if necessary, then update this expected list.");
+        }
+
+        [TestMethod]
+        public void UseOptimizedPublish_does_not_skip_build_for_unsupported_publish_modes()
+        {
+            var testProject = CreateHelloWorldTestProject(ToolsetInfo.CurrentTargetFramework, "UnsupportedOptimizedPublish", true);
+            testProject.AdditionalProperties["UseOptimizedPublish"] = "true";
+            var testAsset = TestAssetsManager.CreateTestProject(testProject)
+                .WithProjectChanges(project =>
+                {
+                    project.Root.Add(XElement.Parse("""
+                        <Target Name="ConfirmBuildExecuted" AfterTargets="Build">
+                          <Message Importance="High" Text="Build target executed" />
+                        </Target>
+                        """));
+                });
+
+            new PublishCommand(testAsset)
+                .Execute()
+                .Should().Pass()
+                .And.HaveStdOutContaining("Build target executed");
+        }
+
+        [TestMethod]
+        [RequiresMSBuildVersion("17.0.0.32901")]
+        public void NativeAot_publish_does_not_produce_managed_build_output()
+        {
+            // AOT publish should not create managed build artifacts (apphost, .dll, .deps.json,
+            // .runtimeconfig.json, runtime pack files) in the output directory (bin\<config>\<tfm>\<rid>\).
+            // The ILC pipeline reads from obj\, so full Build output in bin\ is unnecessary and confusing.
+            var projectName = "NativeAotCleanOutput";
+
+            var testProject = CreateHelloWorldTestProject(ToolsetInfo.CurrentTargetFramework, projectName, true);
+            testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            // Record properties before Publish since Build is skipped for AOT
+            testProject.RecordPropertiesBeforeTarget("Publish");
+            testProject.AdditionalProperties["PublishAot"] = "true";
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                testProject.AdditionalProperties["StripSymbols"] = "true";
+            }
+            var testAsset = TestAssetsManager.CreateTestProject(testProject);
+
+            var publishCommand = new PublishCommand(testAsset);
+            publishCommand
+                .Execute()
+                .Should().Pass();
+
+            var buildProperties = testProject.GetPropertyValues(testAsset.TestRoot, ToolsetInfo.CurrentTargetFramework);
+            var rid = buildProperties["NETCoreSdkPortableRuntimeIdentifier"];
+            var publishDirectory = publishCommand.GetOutputDirectory(targetFramework: ToolsetInfo.CurrentTargetFramework, runtimeIdentifier: rid).FullName;
+            var publishedExe = Path.Combine(publishDirectory, $"{testProject.Name}{Constants.ExeSuffix}");
+
+            // The publish directory should contain the native AOT binary
+            File.Exists(publishedExe).Should().BeTrue("the AOT-compiled native binary should exist in the publish directory");
+            IsNativeImage(publishedExe).Should().BeTrue("the published binary should be a native image");
+
+            // The output directory (parent of publish\) should only contain subdirectories.
+            var outputDirectory = Path.GetDirectoryName(publishDirectory);
+            Directory.GetFiles(outputDirectory).Should().BeEmpty(
+                "the AOT-optimized publish should not produce Build output files");
+        }
+
+        [TestMethod]
+        [RequiresMSBuildVersion("17.0.0.32901")]
+        public void NativeAot_publish_with_project_reference_succeeds()
+        {
+            // Verify that AOT publish still builds project references correctly via
+            // Compile → ResolveReferences → ResolveProjectReferences.
+            var referencedProject = new TestProject()
+            {
+                Name = "AotRefLib",
+                TargetFrameworks = ToolsetInfo.CurrentTargetFramework,
+            };
+            referencedProject.SourceFiles["AotRefLib.cs"] = @"
+namespace AotRefLib
+{
+    public class Greeter
+    {
+        public static string Greet() => ""Hello from referenced project"";
+    }
+}";
+
+            var testProject = new TestProject()
+            {
+                Name = "AotAppWithRef",
+                TargetFrameworks = ToolsetInfo.CurrentTargetFramework,
+                IsExe = true,
+            };
+            testProject.AdditionalProperties["PublishAot"] = "true";
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                testProject.AdditionalProperties["StripSymbols"] = "true";
+            }
+            testProject.ReferencedProjects.Add(referencedProject);
+            testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            // Record properties before Publish since Build is skipped for AOT
+            testProject.RecordPropertiesBeforeTarget("Publish");
+            testProject.SourceFiles["AotAppWithRef.cs"] = @"
+using System;
+class Test
+{
+    static void Main()
+    {
+        Console.WriteLine(AotRefLib.Greeter.Greet());
+    }
+}";
+
+            var testAsset = TestAssetsManager.CreateTestProject(testProject);
+
+            var publishCommand = new PublishCommand(testAsset);
+            publishCommand
+                .Execute("/p:UseCurrentRuntimeIdentifier=true", "/p:SelfContained=true")
+                .Should().Pass();
+
+            var buildProperties = testProject.GetPropertyValues(testAsset.TestRoot, ToolsetInfo.CurrentTargetFramework);
+            var rid = buildProperties["NETCoreSdkPortableRuntimeIdentifier"];
+            var publishDirectory = publishCommand.GetOutputDirectory(targetFramework: ToolsetInfo.CurrentTargetFramework, runtimeIdentifier: rid).FullName;
+            var publishedExe = Path.Combine(publishDirectory, $"{testProject.Name}{Constants.ExeSuffix}");
+
+            File.Exists(publishedExe).Should().BeTrue("the AOT-compiled native binary should exist");
+            IsNativeImage(publishedExe).Should().BeTrue("the published binary should be a native image");
+
+            var result = new RunExeCommand(Log, publishedExe)
+                .Execute();
+            result.Should().Pass()
+                .And.HaveStdOutContaining("Hello from referenced project");
+        }
+
         private void AddRuntimeConfigOption(XDocument project)
         {
             var ns = project.Root.Name.Namespace;
diff --git a/test/Microsoft.NET.Sdk.Web.Tests/PublishTests.cs b/test/Microsoft.NET.Sdk.Web.Tests/PublishTests.cs
index bab3646ab117..53a020a2efea 100644
--- a/test/Microsoft.NET.Sdk.Web.Tests/PublishTests.cs
+++ b/test/Microsoft.NET.Sdk.Web.Tests/PublishTests.cs
@@ -84,6 +84,11 @@ public void TrimmingOptions_Are_Defaulted_Correctly_On_Aot_Apps(string targetFra
 
             var testProject = CreateTestProjectForILLinkTesting(targetFramework, projectName);
             testProject.RecordProperties("NETCoreSdkPortableRuntimeIdentifier");
+            // AOT publish runs Compile instead of full Build, so the AfterBuild target (the default
+            // anchor for recording properties) never runs. Record before PrepareForPublish, which
+            // runs after Compile but before publish-time trimming (PrepareForILLink) defaults
+            // TrimMode to "full" - matching the pre-trimming values the original AfterBuild anchor saw.
+            testProject.RecordPropertiesBeforeTarget("PrepareForPublish");
             testProject.AdditionalProperties["PublishAot"] = "true";
             testProject.AdditionalProperties["UseCurrentRuntimeIdentifier"] = "true";
             testProject.PropertiesToRecord.Add("PublishTrimmed");