diff --git a/eng/pipelines/common/templates/wasi-wasm-coreclr-library-tests.yml b/eng/pipelines/common/templates/wasi-wasm-coreclr-library-tests.yml
new file mode 100644
index 00000000000000..dff30c87bbfa31
--- /dev/null
+++ b/eng/pipelines/common/templates/wasi-wasm-coreclr-library-tests.yml
@@ -0,0 +1,86 @@
+parameters:
+  alwaysRun: false
+  extraBuildArgs: ''
+  extraHelixArguments: ''
+  isExtraPlatformsBuild: false
+  isWasmOnlyBuild: false
+  nameSuffix: ''
+  platforms: []
+  scenarios: ['WasmTestOnWasmtime']
+  shouldContinueOnError: false
+  shouldRunSmokeOnly: false
+
+jobs:
+
+#
+# Build CoreCLR libraries for WASI and run the library tests on wasmtime via Helix.
+# Mirrors wasm-coreclr-library-tests.yml (the browser-CoreCLR LibraryTestsCoreCLR leg),
+# with the WasmTestOnWasmtime scenario and the wasi_wasm helix queue.
+# See https://github.com/dotnet/runtime/issues/130129.
+#
+# Bring-up leg: smoke-only and non-gating (rolling alwaysRun). WasiApp.CoreCLR.targets
+# performs a per-app native link of the wasihost corehost so a test's own
+# [UnmanagedCallersOnly] reverse thunks are generated + linked into the host; with that link
+# + the nested-type reverse-thunk
+# key fix (also filed standalone as dotnet/runtime#130740; the remaining enclosing-type
+# collision limitation is tracked by #130739) the interpreter discovers and runs the suite
+# (validated locally: 9930 System.Runtime.Tests cases). #130634 (cold portable-entry-point
+# publication) only affects a future R2R-enabled leg, not this pure-interpreter smoke.
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+  parameters:
+    jobTemplate: /eng/pipelines/common/global-build-job.yml
+    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+    buildConfig: Release
+    runtimeFlavor: coreclr
+    platforms: ${{ parameters.platforms }}
+    shouldContinueOnError: ${{ parameters.shouldContinueOnError }}
+    variables:
+      - name: alwaysRunVar
+        value: ${{ parameters.alwaysRun }}
+      - name: shouldRunOnDefaultPipelines
+        value: $[
+          or(
+            eq(variables['wasmDarcDependenciesChanged'], true),
+            eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
+            eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
+            eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_wasm_coreclr_runtimetests.containsChange'], true))
+          ]
+      # run smoke tests only if:
+      # - explicitly requested
+      # - libraries or illink changed and no wasm specific changes
+      - name: shouldRunSmokeOnlyVar
+        value: $[
+          or(
+            eq('${{ parameters.shouldRunSmokeOnly }}', 'true'),
+            and(
+              eq('${{ parameters.shouldRunSmokeOnly }}', 'onLibrariesAndIllinkChanges'),
+              ne(variables['wasmDarcDependenciesChanged'], true),
+              or(
+                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
+                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true)
+              )
+            )
+          )
+          ]
+      - name: _wasmRunSmokeTestsOnlyArg
+        value: /p:RunSmokeTestsOnly=$(shouldRunSmokeOnlyVar)
+
+    jobParameters:
+      isExtraPlatforms: ${{ parameters.isExtraPlatformsBuild }}
+      testGroup: innerloop
+      nameSuffix: LibraryTestsCoreCLR_WASI${{ parameters.nameSuffix }}
+      buildArgs: -s clr+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_wasmRunSmokeTestsOnlyArg) /maxcpucount:1 ${{ parameters.extraBuildArgs }}
+      timeoutInMinutes: 240
+      condition: >-
+        or(
+          eq(variables['alwaysRunVar'], true),
+          eq(variables['isDefaultPipeline'], variables['shouldRunOnDefaultPipelines']))
+      # extra steps, run tests
+      postBuildSteps:
+        - template: /eng/pipelines/libraries/helix.yml
+          parameters:
+            creator: dotnet-bot
+            testRunNamePrefixSuffix: CoreCLR_WASI_$(_BuildConfig)
+            extraHelixArguments: $(_wasmRunSmokeTestsOnlyArg) ${{ parameters.extraHelixArguments }}
+            scenarios: ${{ parameters.scenarios }}
diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml
index 77ec17437b8a1e..870fdb32116102 100644
--- a/eng/pipelines/runtime.yml
+++ b/eng/pipelines/runtime.yml
@@ -165,6 +165,16 @@ extends:
           - wasi_wasm
           alwaysRun: ${{ variables.isRollingBuild }}
 
+      # CoreCLR library-test smoke leg run on wasmtime via Helix
+      # (wasi_wasm queue). Starts with a single-library smoke set; see
+      # https://github.com/dotnet/runtime/issues/130129.
+      - template: /eng/pipelines/common/templates/wasi-wasm-coreclr-library-tests.yml
+        parameters:
+          platforms:
+          - wasi_wasm
+          shouldRunSmokeOnly: true
+          alwaysRun: ${{ variables.isRollingBuild }}
+
       - template: /eng/pipelines/common/platform-matrix.yml
         parameters:
           jobTemplate: /eng/pipelines/common/global-build-job.yml
diff --git a/eng/testing/tests.wasi.targets b/eng/testing/tests.wasi.targets
index ec824fe2f52f3d..9a591156932b1f 100644
--- a/eng/testing/tests.wasi.targets
+++ b/eng/testing/tests.wasi.targets
@@ -21,9 +21,22 @@
        for WBT, and debugger tests -->
   <Import Project="$(MSBuildThisFileDirectory)wasi-provisioning.targets" />
 
+  <!-- CoreCLR-WASI: WasiApp.CoreCLR.targets links the wasihost corehost per-app (so
+       library/test reverse P/Invoke thunks are covered), and the host preloads icudt.dat,
+       so the leg runs with full ICU globalization. -->
+  <PropertyGroup Condition="'$(RuntimeFlavor)' == 'CoreCLR'">
+    <InvariantGlobalization Condition="'$(InvariantGlobalization)' == ''">false</InvariantGlobalization>
+  </PropertyGroup>
+
   <PropertyGroup>
     <_AppArgs Condition="'$(WasmSingleFileBundle)' == 'true'">$([System.IO.Path]::GetFileNameWithoutExtension('$(WasmMainAssemblyFileName)')).wasm</_AppArgs>
-    <_AppArgs Condition="'$(WasmSingleFileBundle)' != 'true'">dotnet.wasm WasmTestRunner</_AppArgs>
+    <!-- Mono launches dotnet.wasm with the entry assembly name; CoreCLR launches the
+         per-app-linked wasihost host with the managed entry assembly (.dll). The host is
+         linked into managed/ (as 'corerun') alongside the framework and finds the runtime via
+         CORE_ROOT (see WasiApp.CoreCLR.targets). Validated locally: discovers + runs the full
+         System.Runtime.Tests suite under wasmtime. -->
+    <_AppArgs Condition="'$(WasmSingleFileBundle)' != 'true' and '$(RuntimeFlavor)' != 'CoreCLR'">dotnet.wasm WasmTestRunner</_AppArgs>
+    <_AppArgs Condition="'$(WasmSingleFileBundle)' != 'true' and '$(RuntimeFlavor)' == 'CoreCLR'">managed/corerun managed/WasmTestRunner.dll</_AppArgs>
 
     <_AppArgs Condition="'$(IsFunctionalTest)' != 'true' and '$(WasmSingleFileBundle)' != 'true'">$(_AppArgs) managed/$(AssemblyName).dll</_AppArgs>
     <_AppArgs Condition="'$(IsFunctionalTest)' != 'true' and '$(WasmSingleFileBundle)' == 'true'">$(_AppArgs) $(AssemblyName).dll</_AppArgs>
@@ -52,6 +65,11 @@
     <_XHarnessArgs                                                 >$(_XHarnessArgs) --engine-arg=--wasi --engine-arg=allow-ip-name-lookup</_XHarnessArgs>
     <_XHarnessArgs                                                 >$(_XHarnessArgs) --engine-arg=--wasi --engine-arg=hostcall-fuel=4294967295</_XHarnessArgs>
     <_XHarnessArgs                                                 >$(_XHarnessArgs) --engine-arg=--env --engine-arg=DOTNET_WASI_PRINT_EXIT_CODE=1</_XHarnessArgs>
+    <!-- CoreCLR-WASI: enable the wasm exception-handling proposal (the host relies on it)
+         and point the host at the bundled framework via CORE_ROOT=/managed. Validated
+         locally: host+runtime live in managed/ and init succeeds under wasmtime. -->
+    <_XHarnessArgs Condition="'$(RuntimeFlavor)' == 'CoreCLR'">$(_XHarnessArgs) --engine-arg=-W --engine-arg=exceptions=y</_XHarnessArgs>
+    <_XHarnessArgs Condition="'$(RuntimeFlavor)' == 'CoreCLR'">$(_XHarnessArgs) --engine-arg=--env --engine-arg=CORE_ROOT=/managed</_XHarnessArgs>
     <_XHarnessArgs Condition="'$(WasmXHarnessArgsCli)' != ''"      >$(_XHarnessArgs) $(WasmXHarnessArgsCli)</_XHarnessArgs>
 
     <_InvariantGlobalization Condition="'$(InvariantGlobalization)' == 'true'">--env=DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=true</_InvariantGlobalization>
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/ExceptionTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/ExceptionTests.cs
index 843813a14997a4..879dfff4cd8d23 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/ExceptionTests.cs
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/ExceptionTests.cs
@@ -110,6 +110,7 @@ public static void Exception_TargetSite_Rethrow()
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.HasAssemblyFiles))]
         [ActiveIssue("https://github.com/mono/mono/issues/15140", TestRuntimes.Mono)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/124344", typeof(PlatformDetection), nameof(PlatformDetection.IsAppleMobile), nameof(PlatformDetection.IsCoreCLR))]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/130796", typeof(PlatformDetection), nameof(PlatformDetection.IsWasi), nameof(PlatformDetection.IsCoreCLR))]
         public static void ThrowStatementDoesNotResetExceptionStackLineSameMethod()
         {
             (string, string, int) rethrownExceptionStackFrame = (null, null, 0);
@@ -141,6 +142,7 @@ private static (string, string, int) ThrowAndRethrowSameMethod(out (string, stri
         // [ActiveIssue(https://github.com/dotnet/runtime/issues/1871)] can't use ActiveIssue for archs
         [ActiveIssue("https://github.com/mono/mono/issues/15141", TestRuntimes.Mono)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/124344", typeof(PlatformDetection), nameof(PlatformDetection.IsAppleMobile), nameof(PlatformDetection.IsX64Process), nameof(PlatformDetection.IsCoreCLR))]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/130796", typeof(PlatformDetection), nameof(PlatformDetection.IsWasi), nameof(PlatformDetection.IsCoreCLR))]
         public static void ThrowStatementDoesNotResetExceptionStackLineOtherMethod()
         {
             (string, string, int) rethrownExceptionStackFrame = (null, null, 0);
diff --git a/src/libraries/sendtohelix-wasi.targets b/src/libraries/sendtohelix-wasi.targets
index 44500dfaad7b7b..2da43e62f9cc6f 100644
--- a/src/libraries/sendtohelix-wasi.targets
+++ b/src/libraries/sendtohelix-wasi.targets
@@ -32,6 +32,9 @@
 
   <PropertyGroup>
     <IsRunningLibraryTests Condition="'$(Scenario)' == 'WasmTestOnWasmtime'">true</IsRunningLibraryTests>
+    <!-- Distinguish CoreCLR-WASI work items from Mono ones sharing the wasi_wasm queue
+         (mirror of the browser -CLR-ST- prefix in sendtohelix-browser.targets). -->
+    <WorkItemPrefix Condition="'$(WorkItemPrefix)' == '' and '$(RuntimeFlavor)' == 'CoreCLR'">$(Scenario)-CLR-ST-</WorkItemPrefix>
     <WasiEngine Condition="'$(Scenario)' == 'WasmTestOnWasmtime' or '$(Scenario)' == 'BuildWasmApps' or '$(Scenario)' == ''">wasmtime</WasiEngine>
     <NeedsWasmtime Condition="'$(WasiEngine)' == 'wasmtime'">true</NeedsWasmtime>
 
@@ -124,12 +127,21 @@
       <HelixCorrelationPayload Include="$(MicrosoftNetCoreAppRuntimePackDir)"    Destination="build/microsoft.netcore.app.runtime.wasi-wasm" />
 
       <HelixCorrelationPayload Include="$(WasiBuildTargetsDir)"       Destination="build/wasm" />
+    </ItemGroup>
+
+    <!-- Mono-only build tooling (AOT compiler, cross, Mono targets tasks). A CoreCLR
+         build does not produce these, and the CoreCLR-WASI wasihost link happens at
+         build time with the wasi-sdk (not the Mono AOT/cross tooling), so these Mono
+         runtime payloads are not needed on Helix. -->
+    <ItemGroup Condition="'$(RuntimeFlavor)' != 'CoreCLR'">
       <HelixCorrelationPayload Include="$(WasmBuildTargetsDir)"       Destination="build/wasm-shared" />
       <HelixCorrelationPayload Include="$(WasmAppBuilderDir)"         Destination="build/WasmAppBuilder" />
       <HelixCorrelationPayload Include="$(MonoAOTCompilerDir)"        Destination="build/MonoAOTCompiler" />
       <HelixCorrelationPayload Include="$(MonoAotCrossDir)"           Destination="build/cross" />
       <HelixCorrelationPayload Include="$(MonoTargetsTasksDir)"       Destination="build/MonoTargetsTasks" />
+    </ItemGroup>
 
+    <ItemGroup>
       <HelixCorrelationPayload Include="$(_ShippingPackagesPath)"     Destination="built-nugets" Condition="'$(NeedsBuiltNugets)' == 'true'" />
       <HelixCorrelationPayload Include="$(WasiSdkDirForHelixPayload)" Destination="build/wasi-sdk" Condition="'$(NeedsWasiSdk)' == 'true'" />
     </ItemGroup>
diff --git a/src/libraries/tests.proj b/src/libraries/tests.proj
index 4d543e9028294d..f5bb4e5f998421 100644
--- a/src/libraries/tests.proj
+++ b/src/libraries/tests.proj
@@ -557,8 +557,8 @@
     <SmokeTestProject Include="$(MSBuildThisFileDirectory)System.Net.WebSockets.Client\tests\System.Net.WebSockets.Client.Tests.csproj" />
   </ItemGroup>
 
-  <!-- wasi/interp smoke tests -->
-  <ItemGroup Condition="'$(TargetOS)' == 'wasi' and '$(RunAOTCompilation)' != 'true'">
+  <!-- wasi/interp smoke tests (Mono) -->
+  <ItemGroup Condition="'$(TargetOS)' == 'wasi' and '$(RunAOTCompilation)' != 'true' and '$(RuntimeFlavor)' != 'CoreCLR'">
     <SmokeTestProject Include="$(MSBuildThisFileDirectory)Microsoft.XmlSerializer.Generator\tests\Microsoft.XmlSerializer.Generator.Tests.csproj" />
     <SmokeTestProject Include="$(MSBuildThisFileDirectory)System.Collections.Specialized\tests\System.Collections.Specialized.Tests.csproj" />
     <SmokeTestProject Include="$(MSBuildThisFileDirectory)System.Collections\tests\System.Collections.Tests.csproj" />
@@ -576,7 +576,11 @@
     <SmokeTestProject Include="$(MSBuildThisFileDirectory)System.Net.Sockets\tests\FunctionalTests\System.Net.Sockets.Tests.csproj" />
   </ItemGroup>
 
-  <!-- wasi/aot non-smoke tests -->
+  <!-- wasi smoke tests CoreCLR. Start minimal (single library) for the bring-up leg;
+       expand as gaps close. See https://github.com/dotnet/runtime/issues/130129. -->
+  <ItemGroup Condition="'$(TargetOS)' == 'wasi' and '$(RunAOTCompilation)' != 'true' and '$(RuntimeFlavor)' == 'CoreCLR'">
+    <SmokeTestProject Include="$(MSBuildThisFileDirectory)System.Runtime\tests\System.Runtime.Tests\System.Runtime.Tests.csproj" />
+  </ItemGroup>
   <ItemGroup Condition="'$(TargetOS)' == 'wasi' and '$(BuildAOTTestsOnHelix)' == 'true' and '$(RunDisabledWasiTests)' != 'true' and '$(RunAOTCompilation)' == 'true' and '$(RunSmokeTestsOnly)' != 'true'">
     <ProjectReference Include="$(MSBuildThisFileDirectory)Microsoft.XmlSerializer.Generator\tests\Microsoft.XmlSerializer.Generator.Tests.csproj" />
     <ProjectReference Include="$(MSBuildThisFileDirectory)System.Collections.Specialized\tests\System.Collections.Specialized.Tests.csproj" />
diff --git a/src/mono/wasi/build/WasiApp.CoreCLR.targets b/src/mono/wasi/build/WasiApp.CoreCLR.targets
new file mode 100644
index 00000000000000..9415a5ab7f9ca4
--- /dev/null
+++ b/src/mono/wasi/build/WasiApp.CoreCLR.targets
@@ -0,0 +1,324 @@
+<Project>
+  <!--
+    CoreCLR-WASI app-builder targets. Sibling of Mono's WasiApp.targets, mirroring the
+    browser split (BrowserWasmApp.targets vs BrowserWasmApp.CoreCLR.targets).
+
+    Performs a per-app native link of the shipping wasihost corehost (libWasiHost.a, from
+    src/native/corehost/wasihost) so reverse P/Invoke thunks for the app/test
+    [UnmanagedCallersOnly] methods are covered (the baked libcoreclr_gen_static.a
+    only covers framework top-level UCO callbacks). Runs ManagedToNativeGenerator
+    (TargetOS=wasi) over the bundle, compiles the generated callhelpers with the wasi-sdk
+    clang, and links libWasiHost.a from the runtime-pack static archives + the app callhelper .o
+    (replacing libcoreclr_gen_static.a) via wasm-component-ld. The wasi:http import that
+    System.Net.* pulls in is declared via the component-type link flag
+    (WasiHttpWorld_component_type.wit, as Mono does); wasmtime gets -S http from
+    eng/testing/tests.wasi.targets.
+
+    See https://github.com/dotnet/runtime/issues/130129.
+  -->
+  <!-- Reuse the shared WASI bundling; the Mono-only clang-link targets stay inert (gated on
+       WasmBuildNative). Imported first so the CoreCLR overrides below win over its
+       WasmAppRuntimeFlavor=Mono default. -->
+  <Import Project="$(MSBuildThisFileDirectory)WasiApp.targets" />
+
+  <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.CoreClr.ManagedToNativeGenerator"
+             AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)"
+             TaskFactory="TaskHostFactory"
+             Condition="'$(WasmAppBuilderTasksAssemblyPath)' != ''" />
+
+  <PropertyGroup>
+    <WasmAppRuntimeFlavor>CoreCLR</WasmAppRuntimeFlavor>
+    <UseMonoRuntime>false</UseMonoRuntime>
+    <!-- The Mono per-app clang relink (WasmBuildNative) is not used; CoreCLR links the
+         wasihost corehost (libWasiHost.a) per-app through its own targets below. -->
+    <WasmBuildNative>false</WasmBuildNative>
+    <WasmSingleFileBundle Condition="'$(WasmSingleFileBundle)' == ''">false</WasmSingleFileBundle>
+  </PropertyGroup>
+
+  <!-- Override the same-named target imported above so we do NOT bundle Mono's
+       dotnet.wasm. The wasihost corehost (linked into managed/ as 'corerun' below) is placed
+       next to the framework; icudt.dat is bundled only when not invariant. -->
+  <Target Name="_GetWasiGenerateAppBundleDependencies">
+    <ItemGroup Condition="'$(InvariantGlobalization)' == 'true' or '$(WasmSingleFileBundle)' == 'true'">
+      <ReferenceCopyLocalPaths Remove="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)icudt.dat" />
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(InvariantGlobalization)' != 'true' and '$(WasmSingleFileBundle)' != 'true'">
+      <WasmIcuDataFileNames Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)icudt.dat"
+                            Condition="Exists('$(MicrosoftNetCoreAppRuntimePackRidNativeDir)icudt.dat')" />
+      <WasmNativeAsset Include="@(WasmIcuDataFileNames)" />
+    </ItemGroup>
+  </Target>
+
+  <!-- CoreCLR-WASI doesn't relink with emcc, so the Mono emcc prop blob (wasm-props.json)
+       isn't in the pack; no-op _ReadWasmProps so the build doesn't fail looking for it. -->
+  <Target Name="_ReadWasmProps" />
+
+  <!-- The SDK doesn't resolve a CoreCLR runtime pack for wasi-wasm, so the self-contained
+       publish only lands the app's own closure. Copy the framework (pack lib dir) +
+       System.Private.CoreLib.dll (pack native dir) into managed/, next to the wasihost host
+       (linked below), which finds them via CORE_ROOT. See https://github.com/dotnet/runtime/issues/130129. -->
+  <Target Name="_WasiCopyFrameworkToManaged"
+          AfterTargets="_WasiGenerateAppBundle"
+          Condition="'$(WasmGenerateAppBundle)' == 'true' and '$(WasmSingleFileBundle)' != 'true'">
+    <Error Condition="!Exists('$(MicrosoftNetCoreAppRuntimePackRidNativeDir)System.Private.CoreLib.dll')"
+           Text="System.Private.CoreLib.dll not found in the runtime pack native dir: $(MicrosoftNetCoreAppRuntimePackRidNativeDir)" />
+    <ItemGroup>
+      <_WasiCoreCLRCoreLib Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)System.Private.CoreLib.dll" />
+      <!-- Framework assemblies from the runtime pack (implementation, not ref). Filter out
+           any the app already published (its version is authoritative) into a separate list
+           so a single Copy runs on the remainder - avoids per-file Copy task batching. -->
+      <_WasiCoreCLRFrameworkFiles Include="$(MicrosoftNetCoreAppRuntimePackRidLibTfmDir)\*.dll" />
+      <_WasiCoreCLRFrameworkToCopy Include="@(_WasiCoreCLRFrameworkFiles)"
+                                   Condition="!Exists('$(WasmAppDir)managed\%(_WasiCoreCLRFrameworkFiles.FileName)%(_WasiCoreCLRFrameworkFiles.Extension)')" />
+    </ItemGroup>
+    <Copy SourceFiles="@(_WasiCoreCLRCoreLib)"
+          DestinationFolder="$(WasmAppDir)managed"
+          SkipUnchangedFiles="true" />
+    <Copy SourceFiles="@(_WasiCoreCLRFrameworkToCopy)"
+          DestinationFolder="$(WasmAppDir)managed"
+          SkipUnchangedFiles="true" />
+    <!-- Non-invariant: place icudt.dat next to the managed assemblies (CORE_ROOT) so the
+         wasihost corehost, which preloads it before managed globalization initializes, can
+         find it. -->
+    <Copy Condition="'$(InvariantGlobalization)' != 'true' and Exists('$(MicrosoftNetCoreAppRuntimePackRidNativeDir)icudt.dat')"
+          SourceFiles="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)icudt.dat"
+          DestinationFolder="$(WasmAppDir)managed"
+          SkipUnchangedFiles="true" />
+  </Target>
+
+  <!-- ============================ Per-app wasihost link ============================ -->
+
+  <Target Name="_WasiCoreCLRRelinkCoreRun"
+          AfterTargets="_WasiCopyFrameworkToManaged"
+          DependsOnTargets="_SetupWasiSdk"
+          Condition="'$(WasmGenerateAppBundle)' == 'true' and '$(WasmSingleFileBundle)' != 'true'">
+
+    <Error Condition="'$(_IsToolchainMissing)' == 'true'"
+           Text="$(_ToolchainMissingErrorMessage) The wasi-sdk is required to link the wasihost corehost for the CoreCLR-WASI test host." />
+
+    <PropertyGroup>
+      <_WasiRelinkObjDir>$([MSBuild]::NormalizeDirectory('$(_WasmIntermediateOutputPath)', 'corerun-relink'))</_WasiRelinkObjDir>
+      <_WasiClangxx>$(WASI_SDK_PATH)bin/clang++</_WasiClangxx>
+      <_WasiClangxx Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(_WasiClangxx).exe</_WasiClangxx>
+      <_WasiComponentLd>$(WasiSdkBinPath)wasm-component-ld</_WasiComponentLd>
+      <_WasiComponentLd Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(_WasiComponentLd).exe</_WasiComponentLd>
+      <_WasiSysroot>$(WASI_SDK_PATH)share/wasi-sysroot</_WasiSysroot>
+
+      <_WasiPInvokeTablePath>$(_WasiRelinkObjDir)callhelpers-pinvoke.cpp</_WasiPInvokeTablePath>
+      <_WasiReversePInvokeTablePath>$(_WasiRelinkObjDir)callhelpers-reverse.cpp</_WasiReversePInvokeTablePath>
+      <_WasiInterpToNativeTablePath>$(_WasiRelinkObjDir)callhelpers-interp-to-managed.cpp</_WasiInterpToNativeTablePath>
+      <_WasiM2NCachePath>$(_WasiRelinkObjDir)m2n_cache.txt</_WasiM2NCachePath>
+
+      <!-- Curated header set for the generated callhelpers (mirrors browser's
+           _EmccCFlagsGenerated): force-include coreclr_compat.h + -I the dirs with
+           <callhelpers.hpp> and minipal. In-tree uses the repo dirs; env vars override each
+           for out-of-tree. coreclr_compat.h is referenced from the browser build dir rather
+           than copied (a second copy would drift from the callhelpers ABI); relocating it to
+           a shared location + out-of-tree staging is tracked by #128362. -->
+      <_WasiCoreClrCompatHeader Condition="'$(CORECLR_COMPAT_HEADER)' != ''">$([System.IO.Path]::GetFullPath('$(CORECLR_COMPAT_HEADER)'))</_WasiCoreClrCompatHeader>
+      <_WasiCoreClrCompatHeader Condition="'$(_WasiCoreClrCompatHeader)' == ''">$([MSBuild]::NormalizePath('$(MSBuildThisFileDirectory)', '..', '..', 'browser', 'build', 'coreclr_compat.h'))</_WasiCoreClrCompatHeader>
+      <_WasiVmWasmIncludeDir Condition="'$(CORECLR_VM_WASM_INCLUDE_DIR)' != ''">$([MSBuild]::EnsureTrailingSlash($([System.IO.Path]::GetFullPath('$(CORECLR_VM_WASM_INCLUDE_DIR)'))))</_WasiVmWasmIncludeDir>
+      <_WasiVmWasmIncludeDir Condition="'$(_WasiVmWasmIncludeDir)' == ''">$([MSBuild]::NormalizeDirectory('$(MSBuildThisFileDirectory)..', '..', '..', 'coreclr', 'vm', 'wasm'))</_WasiVmWasmIncludeDir>
+      <_WasiMinipalIncludeRoot Condition="'$(MINIPAL_INCLUDE_DIR)' != ''">$([MSBuild]::NormalizeDirectory($([System.IO.Path]::GetFullPath('$(MINIPAL_INCLUDE_DIR)')), '..'))</_WasiMinipalIncludeRoot>
+      <_WasiMinipalIncludeRoot Condition="'$(_WasiMinipalIncludeRoot)' == ''">$([MSBuild]::NormalizeDirectory('$(MSBuildThisFileDirectory)..', '..', '..', 'native'))</_WasiMinipalIncludeRoot>
+
+      <!-- wasi:http world declaration for the component encoder. Prefer the pack native
+           dir (shippable); fall back to the in-repo source (in-tree builds). -->
+      <_WasiHttpWorldWit>$(MicrosoftNetCoreAppRuntimePackRidNativeDir)WasiHttpWorld_component_type.wit</_WasiHttpWorldWit>
+      <_WasiHttpWorldWit Condition="!Exists('$(_WasiHttpWorldWit)')">$([MSBuild]::NormalizePath('$(MSBuildThisFileDirectory)..', '..', '..', 'libraries', 'System.Net.Http', 'src', 'System', 'Net', 'Http', 'WasiHttpHandler', 'WasiHttpWorld_component_type.wit'))</_WasiHttpWorldWit>
+
+      <_WasiRelinkCompileRsp>$(_WasiRelinkObjDir)compile.rsp</_WasiRelinkCompileRsp>
+      <_WasiRelinkLinkRsp>$(_WasiRelinkObjDir)link.rsp</_WasiRelinkLinkRsp>
+      <_WasiRelinkOptFlag Condition="'$(Configuration)' == 'Debug'">-O1</_WasiRelinkOptFlag>
+      <_WasiRelinkOptFlag Condition="'$(_WasiRelinkOptFlag)' == ''">-O2</_WasiRelinkOptFlag>
+    </PropertyGroup>
+
+    <MakeDir Directories="$(_WasiRelinkObjDir)" />
+
+    <Error Condition="!Exists('$(_WasiCoreClrCompatHeader)')"
+           Text="coreclr_compat.h not found at $(_WasiCoreClrCompatHeader). For out-of-tree/pack builds set %24(CORECLR_COMPAT_HEADER) to the staged header (and CORECLR_VM_WASM_INCLUDE_DIR/MINIPAL_INCLUDE_DIR for the include dirs); see #128362." />
+    <Error Condition="!Exists('$(_WasiHttpWorldWit)')"
+           Text="WasiHttpWorld_component_type.wit not found at $(_WasiHttpWorldWit)." />
+
+    <!-- 1. Generate the per-app callhelper tables over the bundled managed closure.
+         WarnOnUnresolvedPInvokeModules=false: library-test bundles are untrimmed and pull in
+         cross-platform test-support assemblies whose foreign-platform P/Invokes (kernel32,
+         Security.framework, libsecret, ...) are unresolved on wasm. The generator correctly
+         skips them (throw-if-called), but the WASM0066 warning would fail the build under
+         warn-as-error; downgrade it to a message here. (BrowserWasmApp.CoreCLR.targets should
+         set the same flag when its library-test leg runs untrimmed closures.) -->
+    <ItemGroup>
+      <_WasiManagedAssemblies Include="$(WasmAppDir)managed\*.dll" />
+
+      <_WasiPInvokeModules Include="libSystem.Native" />
+      <_WasiPInvokeModules Include="libSystem.IO.Compression.Native" />
+      <_WasiPInvokeModules Include="libSystem.Globalization.Native" Condition="'$(InvariantGlobalization)' != 'true'" />
+      <_WasiIgnoredPInvokeModules Include="libSystem.Globalization.Native" Condition="'$(InvariantGlobalization)' == 'true'" />
+    </ItemGroup>
+
+    <ManagedToNativeGenerator
+      Assemblies="@(_WasiManagedAssemblies)"
+      PInvokeModules="@(_WasiPInvokeModules)"
+      IgnoredPInvokeModules="@(_WasiIgnoredPInvokeModules)"
+      PInvokeOutputPath="$(_WasiPInvokeTablePath)"
+      ReversePInvokeOutputPath="$(_WasiReversePInvokeTablePath)"
+      InterpToNativeOutputPath="$(_WasiInterpToNativeTablePath)"
+      CacheFilePath="$(_WasiM2NCachePath)"
+      TargetOS="wasi"
+      WarnOnUnresolvedPInvokeModules="false"
+      IsLibraryMode="false">
+      <Output TaskParameter="FileWrites" ItemName="FileWrites" />
+    </ManagedToNativeGenerator>
+
+    <!-- 2. Compile the three generated callhelper sources with the wasi-sdk clang.
+         The generated .cpp #include the real <callhelpers.hpp>/<minipal/*.h>; the
+         force-included coreclr_compat.h supplies the prerequisite types/macros the
+         in-tree PCH would otherwise provide. -->
+    <ItemGroup>
+      <_WasiRelinkCompileFlags Include="--target=wasm32-unknown-wasip2" />
+      <_WasiRelinkCompileFlags Include="--sysroot=&quot;$(_WasiSysroot.Replace('\','/'))&quot;" />
+      <_WasiRelinkCompileFlags Include="$(_WasiRelinkOptFlag)" />
+      <_WasiRelinkCompileFlags Include="-DNDEBUG" Condition="'$(Configuration)' != 'Debug'" />
+      <_WasiRelinkCompileFlags Include="-std=gnu++17" />
+      <_WasiRelinkCompileFlags Include="-fwasm-exceptions" />
+      <_WasiRelinkCompileFlags Include="-mllvm" />
+      <_WasiRelinkCompileFlags Include="-wasm-use-legacy-eh=false" />
+      <_WasiRelinkCompileFlags Include="-fno-rtti" />
+      <!-- Full CoreCLR-WASI VM define set (from the runtime callhelper compile) so the
+           generated callhelpers compile against the same ABI/struct layout as
+           libcoreclr_static.a; a subset causes EH/interp thunk skew. -->
+      <_WasiRelinkCompileFlags Include="-DGEN_PINVOKE=1" />
+      <_WasiRelinkCompileFlags Include="-DCOMPILER_SUPPORTS_W_RESERVED_IDENTIFIER" />
+      <_WasiRelinkCompileFlags Include="-DDEBUGGING_SUPPORTED" />
+      <_WasiRelinkCompileFlags Include="-DDISABLE_CONTRACTS" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_CACHED_INTERFACE_DISPATCH" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_COLLECTIBLE_TYPES" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_CORECLR" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_CORECLR_FLUSH_INSTRUCTION_CACHE_TO_PROTECT_STUB_READS" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_DBGIPC_TRANSPORT_DI" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_DBGIPC_TRANSPORT_VM" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_DEFAULT_INTERFACES" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_INTERPRETER" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_MULTICOREJIT" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_PAL_ANSI" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_PORTABLE_ENTRYPOINTS" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_PORTABLE_HELPERS" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_READYTORUN" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_REMOTE_PROC_MEM" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_STATICALLY_LINKED" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_SYMDIFF" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_USE_ASM_GC_WRITE_BARRIERS" />
+      <_WasiRelinkCompileFlags Include="-DFEATURE_WEBCIL" />
+      <_WasiRelinkCompileFlags Include="-DHOST_32BIT=1" />
+      <_WasiRelinkCompileFlags Include="-DHOST_UNIX" />
+      <_WasiRelinkCompileFlags Include="-DHOST_WASM" />
+      <_WasiRelinkCompileFlags Include="-DTARGET_32BIT" />
+      <_WasiRelinkCompileFlags Include="-DTARGET_UNIX" />
+      <_WasiRelinkCompileFlags Include="-DTARGET_WASI" />
+      <_WasiRelinkCompileFlags Include="-DTARGET_WASM" />
+      <_WasiRelinkCompileFlags Include="-DTARGET_WASM32" />
+      <_WasiRelinkCompileFlags Include="-DUNICODE" />
+      <_WasiRelinkCompileFlags Include="-D_UNICODE" />
+      <_WasiRelinkCompileFlags Include="-DURTBLDENV_FRIENDLY=Retail" />
+      <_WasiRelinkCompileFlags Include="-D_FILE_OFFSET_BITS=64" />
+      <_WasiRelinkCompileFlags Include="-D_TIME_BITS=64" />
+      <_WasiRelinkCompileFlags Include="-D_SECURE_SCL=0" />
+      <_WasiRelinkCompileFlags Include="-D_WASI_EMULATED_GETPID" />
+      <_WasiRelinkCompileFlags Include="-D_WASI_EMULATED_MMAN" />
+      <_WasiRelinkCompileFlags Include="-D_WASI_EMULATED_PROCESS_CLOCKS" />
+      <_WasiRelinkCompileFlags Include="-D_WASI_EMULATED_SIGNAL" />
+      <_WasiRelinkCompileFlags Include="-include &quot;$(_WasiCoreClrCompatHeader.Replace('\','/'))&quot;" />
+      <_WasiRelinkCompileFlags Include="-I&quot;$(_WasiVmWasmIncludeDir.TrimEnd('\/').Replace('\','/'))&quot;" />
+      <_WasiRelinkCompileFlags Include="-I&quot;$(_WasiMinipalIncludeRoot.TrimEnd('\/').Replace('\','/'))&quot;" />
+    </ItemGroup>
+    <WriteLinesToFile Lines="@(_WasiRelinkCompileFlags)" File="$(_WasiRelinkCompileRsp)" Overwrite="true" WriteOnlyWhenDifferent="true" />
+
+    <ItemGroup>
+      <_WasiCallHelperSource Include="$(_WasiPInvokeTablePath)"        ObjectFile="$(_WasiRelinkObjDir)callhelpers-pinvoke.o" />
+      <_WasiCallHelperSource Include="$(_WasiReversePInvokeTablePath)" ObjectFile="$(_WasiRelinkObjDir)callhelpers-reverse.o" />
+      <_WasiCallHelperSource Include="$(_WasiInterpToNativeTablePath)" ObjectFile="$(_WasiRelinkObjDir)callhelpers-interp-to-managed.o" />
+    </ItemGroup>
+
+    <Exec Command="&quot;$(_WasiClangxx)&quot; &quot;@$(_WasiRelinkCompileRsp)&quot; -c &quot;%(_WasiCallHelperSource.Identity)&quot; -o &quot;%(_WasiCallHelperSource.ObjectFile)&quot;"
+          WorkingDirectory="$(_WasiRelinkObjDir)" />
+
+    <!-- 3. Link the wasihost host: host archive (libWasiHost.a) + runtime-pack static libs + the
+         app callhelper .o (replacing libcoreclr_gen_static.a) + the wasi:http world. Lib
+         set/order (incl. the duplicated libminipal.a and mid-list -lstdc++) mirrors the corerun
+         CMake link line; wasm-ld archive resolution is order-sensitive. -->
+    <ItemGroup>
+      <!-- libWasiHost.a is whole-archive-wrapped below (not here) so main()/_start are
+           pulled: wasm-ld only pulls archive members for strong refs, and main is weakly
+           referenced by __main_void. -->
+      <_WasiHostLibsPre Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libminipal.a" />
+      <_WasiHostLibsPre Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libcoreclr_static.a" />
+      <_WasiHostLibsPre Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libSystem.IO.Compression.Native.a" />
+      <_WasiHostLibsPre Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libSystem.Native.a" />
+      <_WasiHostLibsPre Condition="'$(InvariantTimezone)' == 'true'" Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libSystem.Native.TimeZoneData.Invariant.a" />
+      <_WasiHostLibsPre Condition="'$(InvariantTimezone)' != 'true'" Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libSystem.Native.TimeZoneData.a" />
+      <!-- app callhelper .o goes here, in place of libcoreclr_gen_static.a -->
+      <_WasiHostLibsPre Include="%(_WasiCallHelperSource.ObjectFile)" />
+      <_WasiHostLibsPre Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libnativeresourcestring.a" />
+      <!-- Not linking libgcinfo_unix_wasm.a (browser does): it's the gcinfo ENCODER
+           (GcInfoArrayList, JIT/crossgen emit) the interp/R2R host never uses, so its refs
+           in libcoreclr_static.a gc-strip. The DECODER for GC stackwalks
+           (TGcInfoDecoder<Wasm32GcInfoEncoding>) is in libcoreclr_static.a. Mirrors the
+           corerun executable link, which also omits it. -->
+      <!-- Globalization + ICU only when not invariant, matching browser and the generator's
+           globalization P/Invoke handling (ignored/omitted above when invariant). -->
+      <_WasiHostLibsPre Condition="'$(InvariantGlobalization)' != 'true'" Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libSystem.Globalization.Native.a" />
+      <_WasiHostLibsPre Condition="'$(InvariantGlobalization)' != 'true'" Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libicuuc.a" />
+      <_WasiHostLibsPre Condition="'$(InvariantGlobalization)' != 'true'" Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libicui18n.a" />
+      <_WasiHostLibsPre Condition="'$(InvariantGlobalization)' != 'true'" Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libicudata.a" />
+
+      <!-- Linked after -lstdc++ -->
+      <_WasiHostLibsPost Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libcoreclrminipal.a" />
+      <_WasiHostLibsPost Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libcoreclrpal.a" />
+      <_WasiHostLibsPost Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libminipal.a" />
+      <_WasiHostLibsPost Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libz.a" />
+      <_WasiHostLibsPost Include="$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libzstd.a" Condition="Exists('$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libzstd.a')" />
+    </ItemGroup>
+
+    <PropertyGroup>
+      <_WasiRelinkOutput>$(WasmAppDir)managed\corerun</_WasiRelinkOutput>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <_WasiRelinkLinkFlags Include="--target=wasm32-unknown-wasip2" />
+      <_WasiRelinkLinkFlags Include="$(_WasiRelinkOptFlag)" />
+      <_WasiRelinkLinkFlags Include="-DNDEBUG" Condition="'$(Configuration)' != 'Debug'" />
+      <_WasiRelinkLinkFlags Include="-Wl,--gc-sections" />
+      <_WasiRelinkLinkFlags Include="-fwasm-exceptions" />
+      <_WasiRelinkLinkFlags Include="-mllvm" />
+      <_WasiRelinkLinkFlags Include="-wasm-use-legacy-eh=false" />
+      <_WasiRelinkLinkFlags Include="-Wno-unused-command-line-argument" />
+      <_WasiRelinkLinkFlags Include="-Wl,--error-limit=0" />
+      <_WasiRelinkLinkFlags Include="-lc -lc++ -lc++abi -lunwind -ldl" />
+      <_WasiRelinkLinkFlags Include="-lwasi-emulated-process-clocks -lwasi-emulated-signal -lwasi-emulated-mman -lwasi-emulated-getpid" />
+      <_WasiRelinkLinkFlags Include="-fuse-ld=&quot;$(_WasiComponentLd.Replace('\','/'))&quot;" />
+      <_WasiRelinkLinkFlags Include="-Wl,-z,stack-size=8388608" />
+      <_WasiRelinkLinkFlags Include="-Wl,--initial-memory=134217728" />
+      <_WasiRelinkLinkFlags Include="-Wl,--max-memory=4294967296" />
+      <_WasiRelinkLinkFlags Include="-Wl,--component-type,&quot;$(_WasiHttpWorldWit.Replace('\','/'))&quot;" />
+      <!-- Host archive first, whole-archive so main()/_start are included. -->
+      <_WasiRelinkLinkFlags Include="-Wl,--whole-archive" />
+      <_WasiRelinkLinkFlags Include="&quot;$(MicrosoftNetCoreAppRuntimePackRidNativeDir)libWasiHost.a&quot;" />
+      <_WasiRelinkLinkFlags Include="-Wl,--no-whole-archive" />
+      <_WasiRelinkLinkFlags Include="@(_WasiHostLibsPre->'&quot;%(Identity)&quot;')" />
+      <_WasiRelinkLinkFlags Include="-lstdc++" />
+      <_WasiRelinkLinkFlags Include="@(_WasiHostLibsPost->'&quot;%(Identity)&quot;')" />
+      <_WasiRelinkLinkFlags Include="-o &quot;$(_WasiRelinkOutput.Replace('\','/'))&quot;" />
+    </ItemGroup>
+    <WriteLinesToFile Lines="@(_WasiRelinkLinkFlags)" File="$(_WasiRelinkLinkRsp)" Overwrite="true" WriteOnlyWhenDifferent="true" />
+
+    <Message Text="Linking CoreCLR-WASI wasihost host with per-app callhelper thunks ..." Importance="High" />
+    <Exec Command="&quot;$(_WasiClangxx)&quot; &quot;@$(_WasiRelinkLinkRsp)&quot;"
+          WorkingDirectory="$(_WasiRelinkObjDir)" />
+
+    <ItemGroup>
+      <FileWrites Include="$(_WasiRelinkCompileRsp);$(_WasiRelinkLinkRsp)" />
+      <FileWrites Include="%(_WasiCallHelperSource.ObjectFile)" />
+    </ItemGroup>
+  </Target>
+</Project>
diff --git a/src/mono/wasi/build/WasiApp.InTree.props b/src/mono/wasi/build/WasiApp.InTree.props
index db34cf23a2f5f9..ae0f77312bfe23 100644
--- a/src/mono/wasi/build/WasiApp.InTree.props
+++ b/src/mono/wasi/build/WasiApp.InTree.props
@@ -1,6 +1,22 @@
 <Project>
   <!-- This depends on the root Directory.Build.props imported this file -->
   <Import Project="$(MSBuildThisFileDirectory)WasiApp.props" />
+
+  <!-- Mirror of src/mono/browser/build/WasmApp.InTree.props: select the runtime
+       flavor. Unlike Mono (which relinks dotnet.wasm per-app), CoreCLR-WASI links the
+       wasihost corehost, per-app, to cover app/test reverse thunks (see
+       WasiApp.CoreCLR.targets). -->
+  <PropertyGroup Condition="'$(RuntimeFlavor)' == 'CoreCLR'">
+    <UseMonoRuntime>false</UseMonoRuntime>
+    <!-- Full ICU globalization: the wasihost corehost preloads icudt.dat (see
+         src/native/corehost/wasihost / WasiApp.CoreCLR.targets), so the leg no longer needs
+         invariant mode. -->
+    <InvariantGlobalization Condition="'$(InvariantGlobalization)' == ''">false</InvariantGlobalization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(RuntimeFlavor)' == 'Mono'">
+    <UseMonoRuntime>true</UseMonoRuntime>
+  </PropertyGroup>
+
   <PropertyGroup>
     <Platform>AnyCPU</Platform>
     <EnableTargetingPackDownload>false</EnableTargetingPackDownload>
@@ -10,7 +26,7 @@
     <TrimMode>full</TrimMode>
     <RunAnalyzers>false</RunAnalyzers>
   </PropertyGroup>
-  <ItemGroup>
+  <ItemGroup Condition="'$(RuntimeFlavor)' != 'CoreCLR'">
     <_MonoRuntimeComponentDontLink Include="libmono-component-diagnostics_tracing-static.a"/>
     <_MonoRuntimeComponentDontLink Include="libmono-component-debugger-stub-static.a" />
     <_MonoRuntimeComponentDontLink Include="libmono-component-hot_reload-stub-static.a" />
diff --git a/src/mono/wasi/build/WasiApp.InTree.targets b/src/mono/wasi/build/WasiApp.InTree.targets
index 5161dead820985..03c856d16ad71d 100644
--- a/src/mono/wasi/build/WasiApp.InTree.targets
+++ b/src/mono/wasi/build/WasiApp.InTree.targets
@@ -7,7 +7,11 @@
   <!-- TODO: this breaks runtime tests on Helix due to the file not being there for some reason. Once this is fixed we can remove the UpdateRuntimePack target here -->
   <!--<Import Project="$(RepositoryEngineeringDir)targetingpacks.targets" Condition="'$(TargetingpacksTargetsImported)' != 'true'"/>-->
   <Import Project="$(RepositoryEngineeringDir)AcquireWasiSdk.targets" />
-  <Import Project="$(MSBuildThisFileDirectory)WasiApp.targets" />
+  <!-- Select the runtime flavor's app-builder targets (mirror of
+       src/mono/browser/build/WasmApp.InTree.targets). Mono relinks dotnet.wasm
+       per-app via wasi-sdk; CoreCLR links the wasihost corehost per-app (WasiApp.CoreCLR.targets). -->
+  <Import Project="$(MSBuildThisFileDirectory)WasiApp.targets" Condition="'$(RuntimeFlavor)' != 'CoreCLR'" />
+  <Import Project="$(MSBuildThisFileDirectory)WasiApp.CoreCLR.targets" Condition="'$(RuntimeFlavor)' == 'CoreCLR'" />
 
   <!-- Translate runtime-local $(RuntimeBuildWasiSdkPath) to $(WASI_SDK_PATH) that "WasiApp.targets" understands. -->
   <Target Name="SetWasiSdkPathForRuntimeBuild"
diff --git a/src/tasks/WasmAppBuilder/coreclr/ManagedToNativeGenerator.cs b/src/tasks/WasmAppBuilder/coreclr/ManagedToNativeGenerator.cs
index 44053680af94c4..f033d8b39ca3ed 100644
--- a/src/tasks/WasmAppBuilder/coreclr/ManagedToNativeGenerator.cs
+++ b/src/tasks/WasmAppBuilder/coreclr/ManagedToNativeGenerator.cs
@@ -35,6 +35,13 @@ public class ManagedToNativeGenerator : Task
 
     public bool IsLibraryMode { get; set; }
 
+    // When true (default), a P/Invoke to a module that isn't statically linked, ignored,
+    // [WasmImportLinkage], "*" or QCall produces a WASM0066 warning. Consumers that scan
+    // untrimmed closures full of cross-platform interop (e.g. library-test bundles) set this
+    // false so the expected "unresolved module, skip and throw-if-called" case is logged as a
+    // message instead of a build-breaking (under warn-as-error) warning.
+    public bool WarnOnUnresolvedPInvokeModules { get; set; } = true;
+
     public string TargetOS { get; set; } = "browser";
 
     private static readonly string[] s_knownTargetOSes = new[] { "browser", "wasi" };
@@ -86,7 +93,7 @@ private void ExecuteInternal(LogAdapter log)
     {
         Dictionary<string, string> _symbolNameFixups = new();
         List<string> managedAssemblies = FilterOutUnmanagedBinaries(Assemblies);
-        var pinvoke = new PInvokeTableGenerator(FixupSymbolName, log, IsLibraryMode, TargetOS);
+        var pinvoke = new PInvokeTableGenerator(FixupSymbolName, log, IsLibraryMode, TargetOS, WarnOnUnresolvedPInvokeModules);
         var internalCallCollector = new InternalCallSignatureCollector(log);
 
         var resolver = new PathAssemblyResolver(managedAssemblies);
diff --git a/src/tasks/WasmAppBuilder/coreclr/PInvokeTableGenerator.cs b/src/tasks/WasmAppBuilder/coreclr/PInvokeTableGenerator.cs
index 7542c7ddb55557..13d3a151e47874 100644
--- a/src/tasks/WasmAppBuilder/coreclr/PInvokeTableGenerator.cs
+++ b/src/tasks/WasmAppBuilder/coreclr/PInvokeTableGenerator.cs
@@ -25,13 +25,15 @@ internal sealed class PInvokeTableGenerator
     private readonly List<PInvokeCallback> callbacks = new();
     private readonly PInvokeCollector _pinvokeCollector;
     private readonly bool _isLibraryMode;
+    private readonly bool _warnOnUnresolvedModules;
 
-    public PInvokeTableGenerator(Func<string, string> fixupSymbolName, LogAdapter log, bool isLibraryMode, string targetOS)
+    public PInvokeTableGenerator(Func<string, string> fixupSymbolName, LogAdapter log, bool isLibraryMode, string targetOS, bool warnOnUnresolvedModules = true)
     {
         Log = log;
         _fixupSymbolName = fixupSymbolName;
         _pinvokeCollector = new(log, targetOS);
         _isLibraryMode = isLibraryMode;
+        _warnOnUnresolvedModules = warnOnUnresolvedModules;
     }
 
     public void ScanAssembly(Assembly asm)
@@ -103,7 +105,15 @@ private void EmitPInvokeTable(StreamWriter w, SortedDictionary<string, string> m
             }
             else if (pinvoke.Module != "QCall")
             {
-                Log.Warning("WASM0066", $"PInvoke module '{pinvoke.Module}' for method '{pinvoke.Method.DeclaringType}::{pinvoke.Method.Name}' is not in the list of allowed modules. It is also not a specially treated module.");
+                // Unresolved module: not statically linked, ignored, [WasmImportLinkage], "*" or QCall.
+                // By design we skip it and throw at runtime if it is ever called. For hand-authored
+                // apps this is likely a bug, so warn; consumers scanning untrimmed closures full of
+                // cross-platform interop (library-test bundles) disable the warning to avoid failing
+                // the build under warn-as-error for P/Invokes that are never called on wasm.
+                if (_warnOnUnresolvedModules)
+                    Log.Warning("WASM0066", $"PInvoke module '{pinvoke.Module}' for method '{pinvoke.Method.DeclaringType}::{pinvoke.Method.Name}' is not in the list of allowed modules. It is also not a specially treated module.");
+                else if (ignoredModules.Add(pinvoke.Module))
+                    Log.LogMessage(MessageImportance.Low, $"Skipping unresolved PInvoke module '{pinvoke.Module}' for method '{pinvoke.Method.DeclaringType}::{pinvoke.Method.Name}' (not statically linked on wasm; will throw if called)." );
             }
         }