diff --git a/docs/workflow/wasm-documentation.md b/docs/workflow/wasm-documentation.md
index 5e95f96038bdb2..604561e7b0e494 100644
--- a/docs/workflow/wasm-documentation.md
+++ b/docs/workflow/wasm-documentation.md
@@ -51,7 +51,7 @@ For debugging instructions including VS Code and Chrome DevTools setup, see the
 
 ### Running coreclr callhelpers generator
 
-After building the runtime, use the `generate-coreclr-helpers` script for your platform (`.cmd` or `.sh`) in `src/tasks/WasmAppBuilder` to [re]generate the call helpers in `src/coreclr/vm/wasm`.
+After building the runtime, use the `generate-coreclr-helpers` script for your platform (`.cmd` or `.sh`) in `src/coreclr/vm/wasm` to [re]generate the call helpers in `src/coreclr/vm/wasm`.
 
 ## Features and Configuration
 
diff --git a/eng/Subsets.props b/eng/Subsets.props
index 98d535f29edecc..0674e93cf4ded7 100644
--- a/eng/Subsets.props
+++ b/eng/Subsets.props
@@ -759,6 +759,17 @@
               Non-VMR builds normally use the crossgen2 built for the target host SDK from another build leg, but builds without one can opt in.
             -->
             <ProjectToBuild Condition="'$(RuntimeFlavor)' != 'Mono' and ('$(TargetsMobile)' != 'true' or '$(TargetOS)' == 'browser') and '$(TargetsLinuxBionic)' != 'true' and '$(BuildHostTools)' == 'true'" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\Microsoft.NETCore.App.Crossgen2.Host.sfxproj" Category="packs" />
+
+            <!--
+              The wasm-tools workload manifest declares the host crossgen2 pack, so the workload
+              testing legs need it in their local package feed. Those legs do not set
+              $(BuildHostTools), so the project above does not produce one for them. The Host variant
+              pins the RID to the build host, which is exactly the pack the workload resolves.
+
+              Opt-in only. The official build already publishes this pack from the host platform
+              legs, and building it here as well would produce a second package with the same id.
+            -->
+            <ProjectToBuild Condition="'$(BuildCrossgen2HostPackForWorkloadTesting)' == 'true' and '$(RuntimeFlavor)' != 'Mono' and '$(BuildHostTools)' != 'true'" Include="$(InstallerProjectRoot)pkg\sfx\Microsoft.NETCore.App\Microsoft.NETCore.App.Crossgen2.Host.sfxproj" Category="packs" />
           </ItemGroup>
           <ItemGroup>
             <SharedFrameworkProjectToBuild Condition="'$(_BuildHostPack)' == 'true'" Include="$(InstallerProjectRoot)pkg\archives\dotnet-nethost.proj" />
diff --git a/eng/pipelines/common/templates/browser-wasm-build-tests.yml b/eng/pipelines/common/templates/browser-wasm-build-tests.yml
index 88f99633ea54d5..a2c9e5a32bcab4 100644
--- a/eng/pipelines/common/templates/browser-wasm-build-tests.yml
+++ b/eng/pipelines/common/templates/browser-wasm-build-tests.yml
@@ -92,9 +92,10 @@ jobs:
               TargetFolder: '$(Build.SourcesDirectory)/artifacts'
               CleanTargetFolder: false
 
-          # Download the CoreCLR runtime pack. The wasm-tools workload manifest now includes
-          # the CoreCLR browser-wasm runtime pack, so installing the workload for testing
-          # requires the pack to be present in the local package feed.
+          # Download the CoreCLR runtime pack and the host crossgen2 pack. The wasm-tools workload
+          # manifest includes both, so installing the workload for testing requires them to be
+          # present in the local package feed. Only pipelines that build the CoreCLR browser-wasm
+          # runtime (e.g. runtime.yml) can stage them here.
           - ${{ if eq(parameters.includeCoreClrRuntimePack, true) }}:
             - task: DownloadPipelineArtifact@2
               displayName: Download built nugets for CoreCLR runtime
@@ -104,10 +105,12 @@ jobs:
                 targetPath: '$(Build.SourcesDirectory)/artifacts/BuildArtifacts_browser_wasm_$(_hostedOs)_Release_CoreCLR'
 
             - task: CopyFiles@2
-              displayName: Copy CoreCLR runtime pack
+              displayName: Copy CoreCLR runtime pack and host crossgen2 pack
               inputs:
                 SourceFolder: '$(Build.SourcesDirectory)/artifacts/BuildArtifacts_browser_wasm_$(_hostedOs)_Release_CoreCLR'
-                Contents: packages/$(_BuildConfig)/Shipping/Microsoft.NETCore.App.Runtime.browser-wasm.*
+                Contents: |
+                  packages/$(_BuildConfig)/Shipping/Microsoft.NETCore.App.Runtime.browser-wasm.*
+                  packages/$(_BuildConfig)/Shipping/Microsoft.NETCore.App.Crossgen2.*
                 TargetFolder: '$(Build.SourcesDirectory)/artifacts'
                 CleanTargetFolder: false
 
diff --git a/eng/pipelines/extra-platforms/runtime-extra-platforms-wasm.yml b/eng/pipelines/extra-platforms/runtime-extra-platforms-wasm.yml
index 0a7ea4973d2cfa..0dfb371196d872 100644
--- a/eng/pipelines/extra-platforms/runtime-extra-platforms-wasm.yml
+++ b/eng/pipelines/extra-platforms/runtime-extra-platforms-wasm.yml
@@ -209,7 +209,7 @@ jobs:
         - browser_wasm_win
       jobParameters:
         nameSuffix: CoreCLR
-        buildArgs: -s clr+libs+packs -c Release -rc $(_BuildConfig) /p:TestAssemblies=false /p:InstallWorkloadForTesting=false
+        buildArgs: -s clr+libs+packs -c Release -rc $(_BuildConfig) /p:TestAssemblies=false /p:InstallWorkloadForTesting=false /p:BuildCrossgen2HostPackForWorkloadTesting=true
         timeoutInMinutes: 120
         postBuildSteps:
           - template: /eng/pipelines/common/wasm-post-build-steps.yml
diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml
index 5cca8c7ca4d443..e58e2d50c0b2af 100644
--- a/eng/pipelines/runtime.yml
+++ b/eng/pipelines/runtime.yml
@@ -130,7 +130,7 @@ extends:
           - browser_wasm_win
           jobParameters:
             nameSuffix: CoreCLR
-            buildArgs: -s clr+libs+libs.tests+packs -c Release -rc $(_BuildConfig) /p:TestAssemblies=false /p:TestWasmBuildTests=true /p:ArchiveTests=true /p:InstallWorkloadForTesting=false
+            buildArgs: -s clr+libs+libs.tests+packs -c Release -rc $(_BuildConfig) /p:TestAssemblies=false /p:TestWasmBuildTests=true /p:ArchiveTests=true /p:InstallWorkloadForTesting=false /p:BuildCrossgen2HostPackForWorkloadTesting=true
             timeoutInMinutes: 120
             postBuildSteps:
               - template: /eng/pipelines/common/wasm-post-build-steps.yml
diff --git a/eng/wasm/WasmPInvokeModules.props b/eng/wasm/WasmPInvokeModules.props
index 537351c0268caa..843ce0127f8d20 100644
--- a/eng/wasm/WasmPInvokeModules.props
+++ b/eng/wasm/WasmPInvokeModules.props
@@ -1,12 +1,12 @@
 <!--
   The framework P/Invoke modules that CoreCLR resolves without dynamic loading on WebAssembly.
 
-  ManagedToNativeGenerator emits a direct-call entry for every [DllImport] whose module name is on
-  this list and nothing for the rest, so two builds have to agree on it:
+  The portable call-helpers generator emits a direct-call entry for every [DllImport] whose module
+  name is on this list and nothing for the rest, so two builds have to agree on it:
 
-    * src/tasks/WasmAppBuilder/WasmAppBuilder.csproj generates the checked-in call tables under
-      src/coreclr/vm/wasm from it (see generate-coreclr-helpers.md). They are compiled into
-      coreclr_gen_static, which the product's corerun links.
+    * src/coreclr/vm/wasm/generate-coreclr-helpers.proj imports this list to regenerate the
+      checked-in call tables under src/coreclr/vm/wasm (see generate-coreclr-helpers.md). They are
+      compiled into coreclr_gen_static, which the product's corerun links.
     * src/tests/Common/CLRTest.WasmCorerun.targets leaves coreclr_gen_static out when it links a
       test-specific corerun, and regenerates equivalent tables in its place. Those have to cover
       the same modules: one missing here surfaces as a DllNotFoundException at run time, inside
diff --git a/src/coreclr/tools/Common/JitInterface/WasmLowering.cs b/src/coreclr/tools/Common/JitInterface/WasmLowering.cs
index 457ea9554c0ea4..e04c0e77001a00 100644
--- a/src/coreclr/tools/Common/JitInterface/WasmLowering.cs
+++ b/src/coreclr/tools/Common/JitInterface/WasmLowering.cs
@@ -389,7 +389,9 @@ public static WasmValueType LowerType(TypeDesc type)
         /// <summary>
         /// Maps a WasmValueType to its single-character signature encoding.
         /// </summary>
-        private static char WasmValueTypeToSigChar(WasmValueType vt) => vt switch
+        // internal rather than private so the call-helper generator can encode a single type with the
+        // same table the signature builder below uses (see ILCompiler.PortableCallHelpers.InteropSignature).
+        internal static char WasmValueTypeToSigChar(WasmValueType vt) => vt switch
         {
             WasmValueType.I32 => 'i',
             WasmValueType.I64 => 'l',
@@ -409,6 +411,22 @@ public static WasmValueType LowerType(TypeDesc type)
             _ => throw new InvalidOperationException($"Unknown signature char: {c}")
         };
 
+        internal static string DescribeSigChar(char c) => c switch
+        {
+            'v' => "a void result",
+            'i' => "a 32-bit integer",
+            'l' => "a 64-bit integer",
+            'f' => "a 32-bit float",
+            'd' => "a 64-bit float",
+            'V' => "a 128-bit vector",
+            'S' or 'A' => "a struct passed by reference",
+            'T' => "the 'this' argument",
+            'p' => "the portable entry point argument",
+            'a' => "the async continuation argument",
+            'e' => "an empty struct",
+            _ => $"an unrecognized element '{c}'"
+        };
+
         private static int ParseStructSize(string sig, ref int pos)
         {
             Debug.Assert(sig[pos] is 'S' or 'A');
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/WasmArgumentLayoutTests.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/WasmArgumentLayoutTests.cs
index 089894a59e5451..f510b504affc6a 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/WasmArgumentLayoutTests.cs
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/WasmArgumentLayoutTests.cs
@@ -8,9 +8,14 @@
 using System.IO;
 using System.Linq;
 
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Emit;
+
 using crossgen2::ILCompiler;
 using crossgen2::ILCompiler.DependencyAnalysis.ReadyToRun;
 using crossgen2::ILCompiler.DependencyAnalysis.Wasm;
+using crossgen2::ILCompiler.PortableCallHelpers;
 using crossgen2::Internal.CallingConvention;
 using crossgen2::Internal.JitInterface;
 
@@ -546,11 +551,199 @@ private static MethodSignature MakeProbeSignature(ReadyToRunCompilerContext cont
             context.GetWellKnownType(WellKnownType.Int32).MakeByRefType());
 
 
+    /// <summary>
+    /// The generator encodes a type in parameter position with a single token. These are the three
+    /// shapes that encoding exists to tell apart: a multi-field struct, which goes by reference and
+    /// carries its size; a single-field wrapper, which is passed as the field it wraps; and a
+    /// primitive.
+    /// </summary>
+    [Theory]
+    [InlineData("Guid", "S16")]
+    [InlineData("DateTime", "l")]
+    [InlineData("Int32", "i")]
+    public void PortableCallHelpersGeneratorEncodesTypesTheWayTheCompilerLowersThem(string typeName, string expected)
+    {
+        ReadyToRunCompilerContext context = CreateWasmContext();
+
+        Assert.Equal(expected, InteropSignature.GetAbiToken(GetSystemType(context, typeName)));
+    }
+
+    /// <summary>
+    /// A struct that holds a reference lays out through the auto-layout path, which asks the
+    /// compilation group whether the base offset needs aligning. Generation is not a compilation, so
+    /// it has to configure a group itself for that question to have an answer at all.
+    /// </summary>
+    [Fact]
+    public void PortableCallHelpersGeneratorComputesLayoutOfStructsHoldingReferences()
+    {
+        ReadyToRunCompilerContext context = CreateWasmContext();
+        var type = GetSystemType(context, "RuntimeTypeHandle");
+
+        // If this stops holding, the test no longer covers the auto-layout path it was written for.
+        Assert.True(type.ContainsGCPointers, $"{type} was chosen because it holds a reference");
+
+        // One field the size of the whole struct: lowered to that field, a reference, passed as i32.
+        Assert.Equal("i", InteropSignature.GetAbiToken(type));
+    }
+
+    /// <summary>
+    /// The thunk a method gets is keyed by its lowered signature, so the generator has to encode a
+    /// method exactly as the compiler lowers it. Anything else and the interpreter calls through a
+    /// thunk built for a different shape.
+    /// </summary>
+    [Fact]
+    public void PortableCallHelpersGeneratorEncodesMethodsLikeTheCompiler()
+    {
+        ReadyToRunCompilerContext context = CreateWasmContext();
+        var method = (EcmaMethod)GetSystemType(context, "DateTime").GetMethod("AddTicks"u8, null);
+
+        string expected = WasmLowering.GetSignature(method.Signature, WasmLowering.LoweringFlags.None).SignatureString;
+        _output.WriteLine($"{method} lowers to '{expected}'");
+
+        Assert.Equal(expected, InteropSignature.GetMethodSignature(method));
+    }
+
+    /// <summary>
+    /// A type has to get the same token at the interop boundary as it does inside a lowered method
+    /// signature, because the runtime looks a thunk up by the signature the compiler produced. The
+    /// two encoders are separate code, so this pins them together for each shape the ABI treats
+    /// differently: multi-segment types passed by value across several slots, structs passed by
+    /// reference, single-field wrappers, and primitives.
+    /// </summary>
+    [Theory]
+    [InlineData("Int128")]
+    [InlineData("UInt128")]
+    [InlineData("Guid")]
+    [InlineData("DateTime")]
+    [InlineData("Int32")]
+    [InlineData("Double")]
+    public void PortableCallHelpersGeneratorEncodesTypesTheSameWayInAndOutOfASignature(string typeName)
+    {
+        ReadyToRunCompilerContext context = CreateWasmContext();
+        TypeDesc type = GetSystemType(context, typeName);
+
+        string signature = WasmLowering.GetSignature(
+            MakeStaticVoidSignature(context, type),
+            WasmLowering.LoweringFlags.None).SignatureString;
+        _output.WriteLine($"{typeName} lowers to '{signature}' in a signature");
+
+        // 'v' return, then the single parameter, then the 'p' entrypoint suffix.
+        List<string> tokens = InteropSignature.ParseSignatureTokens(signature);
+        Assert.Equal(tokens[1], InteropSignature.GetAbiToken(type));
+    }
+
+    private const string CoreLibSimpleName = "System.Private.CoreLib";
+
+    /// <summary>
+    /// An exported callback resolves its MethodDesc at run time through
+    /// LookupUnmanagedCallersOnlyMethodByName, which matches on the declaring type and the method name
+    /// alone. Overloads are indistinguishable to it, so generation has to reject a name it could not
+    /// resolve rather than emit a wrapper that calls whichever one the walk reaches first.
+    /// </summary>
+    [Theory]
+    // Two exported overloads: the lookup cannot tell them apart.
+    [InlineData("[UnmanagedCallersOnly(EntryPoint = \"cb_one\")]", "Handle",
+                "[UnmanagedCallersOnly(EntryPoint = \"cb_two\")]", "Handle", true)]
+    // The twin does not have to be exported to be returned by the walk, which only tests the attribute.
+    [InlineData("[UnmanagedCallersOnly(EntryPoint = \"cb_one\")]", "Handle",
+                "[UnmanagedCallersOnly]", "Handle", true)]
+    // Distinct names resolve unambiguously.
+    [InlineData("[UnmanagedCallersOnly(EntryPoint = \"cb_one\")]", "HandleOne",
+                "[UnmanagedCallersOnly(EntryPoint = \"cb_two\")]", "HandleTwo", false)]
+    // Nothing is exported, so neither wrapper reaches the name lookup: the runtime hands both their
+    // MethodDesc through the arity-aware g_ReverseThunks key instead.
+    [InlineData("[UnmanagedCallersOnly]", "Handle", "[UnmanagedCallersOnly]", "Handle", false)]
+    public void PortableCallHelpersGeneratorRejectsAnExportItCouldNotResolveByName(
+        string firstAttribute, string firstName, string secondAttribute, string secondName, bool expectRejected)
+    {
+        string source = $$"""
+            using System.Runtime.InteropServices;
+
+            public static class Exports
+            {
+                {{firstAttribute}}
+                public static int {{firstName}}(int a) => a;
+
+                {{secondAttribute}}
+                public static int {{secondName}}(int a, int b) => a + b;
+            }
+            """;
+
+        string workingDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+        Directory.CreateDirectory(workingDirectory);
+
+        try
+        {
+            string inputAssembly = CompileCallbackAssembly(source, Path.Combine(workingDirectory, "Callbacks.dll"));
+            string outputDirectory = Path.Combine(workingDirectory, "generated");
+
+            var options = new PortableCallHelpersGeneratorOptions
+            {
+                OutputDirectory = outputDirectory,
+                TargetOS = "browser",
+                PInvokeModules = new[] { "libSystem.Native" },
+            };
+
+            var log = new StringWriter();
+            int exitCode = PortableCallHelpersGenerator.Run(
+                CreateWasmContext(inputAssembly), options, new Logger(log, isVerbose: false));
+
+            if (expectRejected)
+            {
+                Assert.Equal(1, exitCode);
+                Assert.Contains($"declares more than one [UnmanagedCallersOnly] method named '{firstName}'", log.ToString());
+            }
+            else
+            {
+                Assert.Equal(0, exitCode);
+                Assert.DoesNotContain("declares more than one", log.ToString());
+            }
+        }
+        finally
+        {
+            // The type system maps an input assembly with FileShare.Read and never releases it - the
+            // context is not disposable - so on Windows the compiled input cannot be deleted while
+            // this process lives. Cleaning up is best effort rather than a second way to fail.
+            try
+            {
+                Directory.Delete(workingDirectory, recursive: true);
+            }
+            catch (Exception e) when (e is IOException or UnauthorizedAccessException)
+            {
+            }
+        }
+    }
+
+    /// <summary>
+    /// Builds an input assembly for the generator to scan. It references the same CoreLib the context
+    /// reads, so the attributes it applies are the ones the type system will resolve.
+    /// </summary>
+    private static string CompileCallbackAssembly(string source, string outputPath)
+    {
+        CSharpCompilation compilation = CSharpCompilation.Create(
+            Path.GetFileNameWithoutExtension(outputPath),
+            new[] { CSharpSyntaxTree.ParseText(source) },
+            new[] { MetadataReference.CreateFromFile(TestPaths.SystemPrivateCoreLibPath) },
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+
+        EmitResult result = compilation.Emit(outputPath);
+        Assert.True(result.Success,
+            string.Join(Environment.NewLine, result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error)));
+
+        return outputPath;
+    }
+
+    private static EcmaType GetSystemType(ReadyToRunCompilerContext context, string typeName)
+    {
+        return (EcmaType)context.SystemModule.GetType("System"u8, System.Text.Encoding.UTF8.GetBytes(typeName));
+    }
+
     /// <summary>
     /// Configures a type system context the way crossgen2 does for
-    /// <c>--targetarch wasm --targetos browser</c>.
+    /// <c>--targetarch wasm --targetos browser</c>. Extra input assemblies stand in for the rest of an
+    /// app closure, which a real build always supplies alongside CoreLib.
     /// </summary>
-    private ReadyToRunCompilerContext CreateWasmContext()
+    private ReadyToRunCompilerContext CreateWasmContext(params string[] extraInputAssemblyPaths)
     {
         string coreLibPath = TestPaths.SystemPrivateCoreLibPath;
         Assert.True(File.Exists(coreLibPath), $"System.Private.CoreLib.dll not found at '{coreLibPath}'");
@@ -558,14 +751,20 @@ private ReadyToRunCompilerContext CreateWasmContext()
         InstructionSetSupport instructionSetSupport = new(default, default, TargetArchitecture.Wasm32);
         TargetDetails target = new(TargetArchitecture.Wasm32, TargetOS.Browser, TargetAbi.NativeAot, instructionSetSupport.GetVectorTSimdVector());
 
+        Dictionary<string, string> inputFilePaths = new(StringComparer.OrdinalIgnoreCase) { { CoreLibSimpleName, coreLibPath } };
+        foreach (string path in extraInputAssemblyPaths)
+        {
+            inputFilePaths.Add(Path.GetFileNameWithoutExtension(path), path);
+        }
+
         // Wasm cannot generate code at runtime, matching what crossgen2's Program computes for this target.
         ReadyToRunCompilerContext context = new(target, SharedGenericsMode.CanonicalReferenceTypes, bubbleIncludesCoreModule: true, targetAllowsRuntimeCodeGeneration: false, instructionSetSupport, oldTypeSystemContext: null)
         {
-            InputFilePaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { "System.Private.CoreLib", coreLibPath } },
+            InputFilePaths = inputFilePaths,
             ReferenceFilePaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase),
         };
 
-        EcmaModule coreLib = (EcmaModule)context.GetModuleForSimpleName("System.Private.CoreLib");
+        EcmaModule coreLib = (EcmaModule)context.GetModuleForSimpleName(CoreLibSimpleName);
         context.SetSystemModule(coreLib);
 
         // The R2R field layout algorithm reaches into the compilation group to decide whether base
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj
index 289ae2e32d8849..d7cb06a93eb299 100644
--- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj
@@ -379,6 +379,13 @@
     <Compile Include="Compiler\SystemObjectFieldLayoutAlgorithm.cs" />
     <Compile Include="IL\ReadyToRunILProvider.cs" />
     <Compile Include="JitInterface\CorInfoImpl.ReadyToRun.cs" />
+    <Compile Include="PortableCallHelpers\PortableCallHelpersGenerator.cs" />
+    <Compile Include="PortableCallHelpers\InteropSignature.cs" />
+    <Compile Include="PortableCallHelpers\InternalCallSignatureCollector.cs" />
+    <Compile Include="PortableCallHelpers\InterpToNativeGenerator.cs" />
+    <Compile Include="PortableCallHelpers\PInvokeCollector.cs" />
+    <Compile Include="PortableCallHelpers\PInvokeTableGenerator.cs" />
+    <Compile Include="PortableCallHelpers\TypeNames.cs" />
     <Compile Include="JitInterface\WasmLowering.ReadyToRun.cs" />
     <Compile Include="ObjectWriter\TargetExtensions.cs" />
     <Compile Include="TypeSystem\MethodDescExtensions.cs" />
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/InternalCallSignatureCollector.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/InternalCallSignatureCollector.cs
new file mode 100644
index 00000000000000..1da76145e87976
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/InternalCallSignatureCollector.cs
@@ -0,0 +1,100 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+
+using Internal.TypeSystem;
+using Internal.TypeSystem.Ecma;
+
+namespace ILCompiler.PortableCallHelpers
+{
+    /// <summary>
+    /// Reports a condition that should fail the build, with a message that is complete on its own.
+    /// </summary>
+    internal sealed class LogAsErrorException(string message) : Exception(message);
+
+    /// <summary>
+    /// Emits generator diagnostics in the canonical MSBuild format, so that a build driving
+    /// crossgen2 through Exec still reports them with their codes.
+    /// </summary>
+    internal sealed class InteropLogger(Logger logger)
+    {
+        private readonly HashSet<string> _reportedInfo = [];
+
+        public void Warning(string code, string message)
+            => logger.LogMessage($"crossgen2 : warning {code}: {message}");
+
+        /// <summary>
+        /// Reports an informational diagnostic once per distinct message, so that a type used by
+        /// many signatures does not produce the same line repeatedly.
+        /// </summary>
+        public void InfoHigh(string code, string message)
+        {
+            if (_reportedInfo.Add($"{code}:{message}"))
+                logger.LogMessage($"crossgen2 : message {code}: {message}");
+        }
+
+        public void Verbose(string message)
+        {
+            if (logger.IsVerbose)
+                logger.LogMessage(message);
+        }
+    }
+
+    /// <summary>
+    /// Scans assemblies for methods marked with <c>MethodImplAttributes.InternalCall</c> and
+    /// collects the portable entry point signatures the interpreter-to-native thunks are generated
+    /// from.
+    /// </summary>
+    internal sealed class InternalCallSignatureCollector(InteropLogger log)
+    {
+        private readonly Dictionary<string, MethodDesc> _signatures = [];
+
+        public IReadOnlyDictionary<string, MethodDesc> Signatures => _signatures;
+
+        public void ScanType(EcmaType type)
+        {
+            foreach (MethodDesc method in type.GetMethods())
+            {
+                if (!method.IsInternalCall)
+                    continue;
+
+                // String constructors never reach a signature-derived thunk. They are compiled as static
+                // factories ("String Ctor(args)", see WasmLowering.GetStringCtorActualSignature), and the
+                // runtime special-cases them in both directions with hardcoded keys before it consults
+                // this table: GetCookieForCalliSig and GetPortableEntryPointToInterpreterThunk in
+                // src/coreclr/vm/wasm/helpers.cpp. Emitting the declared "void .ctor(this, args)" shape
+                // here would only add entries nothing can look up.
+                if (method.IsConstructor && method.OwningType.IsWellKnownType(WellKnownType.String))
+                    continue;
+
+                // A generic has no single signature to generate a thunk from, so the interpreter
+                // would find none at call time - and a release build does not even assert on the
+                // miss, it takes the null cookie. CoreLib declares no such method today.
+                if (method.HasInstantiation || method.OwningType.HasInstantiation)
+                {
+                    throw new LogAsErrorException(
+                        $"Generic InternalCall method '{type}::{method.Name.ToString()}' has no single signature to generate a thunk from.");
+                }
+
+                try
+                {
+                    // A managed signature: the lowering adds the 'T' for an instance method and the
+                    // trailing 'p' for the portable entry point parameter.
+                    string signature = InteropSignature.GetMethodSignature(method);
+                    if (_signatures.TryAdd(signature, method))
+                        log.Verbose($"Adding InternalCall signature {signature} for method '{type}.{method.Name.ToString()}'");
+                }
+                catch (Exception ex) when (ex is not LogAsErrorException)
+                {
+                    // Every non-generic InternalCall has a signature the lowering can describe, so a
+                    // failure here is a bug in the generator rather than something the assembly did.
+                    // Skipping it would silently drop a thunk and only fail once the interpreter tries
+                    // to call the method.
+                    throw new LogAsErrorException($"Could not get the signature for InternalCall method '{type}::{method.Name.ToString()}': {ex.Message}");
+                }
+            }
+        }
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/InteropSignature.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/InteropSignature.cs
new file mode 100644
index 00000000000000..251e51037cc0b3
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/InteropSignature.cs
@@ -0,0 +1,190 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+
+using ILCompiler.DependencyAnalysis.Wasm;
+using Internal.JitInterface;
+using Internal.TypeSystem;
+
+namespace ILCompiler.PortableCallHelpers
+{
+    /// <summary>
+    /// Thrown when a signature token has no representation in the generated C.
+    /// </summary>
+    internal sealed class InvalidSignatureCharException(char c)
+        : Exception($"Can't handle signature '{c}'")
+    {
+        public char Char { get; } = c;
+    }
+
+    /// <summary>
+    /// Maps between the wasm signature strings produced by <see cref="WasmLowering"/> and the C
+    /// declarations the generated interop files are built from.
+    /// </summary>
+    /// <remarks>
+    /// The signature string format is documented in docs/design/coreclr/botr/readytorun-format.md
+    /// (section "Wasm Signature String Encoding"). <see cref="WasmLowering"/> is the single
+    /// implementation of the encoding; everything here either produces a string through it or
+    /// consumes one it produced.
+    /// </remarks>
+    internal static class InteropSignature
+    {
+        /// <summary>
+        /// Returns the wasm signature string for a method.
+        /// </summary>
+        /// <param name="method">The method to encode.</param>
+        /// <param name="flags">
+        /// The default lowers as a managed method, taking the leading 'T' for an instance method
+        /// and the trailing 'p' for the portable entry point argument;
+        /// <see cref="WasmLowering.LoweringFlags.IsUnmanagedCallersOnly"/> lowers as a native function.
+        /// </param>
+        public static string GetMethodSignature(MethodDesc method, WasmLowering.LoweringFlags flags = WasmLowering.LoweringFlags.None)
+            => WasmLowering.GetSignature(method.Signature, flags).SignatureString;
+
+        /// <summary>
+        /// Gets the signature encoding for a type in parameter position: a primitive character
+        /// (<c>i</c>, <c>l</c>, <c>f</c>, <c>d</c>, <c>V</c>), a multi-slot token, or
+        /// <c>S&lt;size&gt;</c>/<c>A&lt;size&gt;</c> for a struct that is passed by reference.
+        /// </summary>
+        public static string GetAbiToken(TypeDesc type)
+        {
+            if (type.IsVoid)
+                return "v";
+
+            TypeDesc loweredType = WasmLowering.LowerToAbiType(type);
+            if (loweredType is null)
+            {
+                // WasmLowering.GetSignature splits this case in two, and both have to be mirrored
+                // here or a type gets one token in a method signature and a different one at the
+                // interop boundary. Multi-segment types come first: they travel by value across
+                // several wasm parameters, so calling them by-reference structs would both hide
+                // them from the multi-slot rejection and mis-declare them in C.
+                if (WasmLowering.TryGetMultiSegmentLayout(type, out WasmValueType slotType, out int slotCount))
+                    return string.Create(CultureInfo.InvariantCulture, $"{WasmLowering.WasmValueTypeToSigChar(slotType)}{slotCount}");
+
+                // Passed by reference; the size is what the callee needs to know. 'A' marks a struct
+                // whose alignment exceeds a stack slot, matching what WasmLowering.GetSignature emits
+                // so a type gets the same token here as it does inside a method signature.
+                Debug.Assert(type is DefType, "LowerToAbiType only returns null for aggregates");
+                char kind = CompilerTypeSystemContext.GetClassAlignmentRequirementStatic((DefType)type) > 8 ? 'A' : 'S';
+                return string.Create(CultureInfo.InvariantCulture, $"{kind}{type.GetElementSize().AsInt}");
+            }
+
+            return WasmLowering.WasmValueTypeToSigChar(WasmLowering.LowerType(loweredType)).ToString();
+        }
+
+        /// <summary>
+        /// Parses a signature string into individual tokens. Single-char types produce one-char
+        /// tokens; struct encodings produce multi-char tokens like "S8" or "A32", and a multi-slot
+        /// parameter produces a two-char token like "l2" or "V4". The 'a' and 'p' suffixes are
+        /// included as their own tokens.
+        /// </summary>
+        public static List<string> ParseSignatureTokens(string signature)
+        {
+            List<string> tokens = [];
+            int i = 0;
+            while (i < signature.Length)
+            {
+                if (signature[i] is 'S' or 'A')
+                {
+                    int start = i;
+                    i++; // skip 'S'/'A'
+                    while (i < signature.Length && char.IsDigit(signature[i]))
+                        i++;
+                    tokens.Add(signature.Substring(start, i - start));
+                }
+                else if (signature[i] is 'l' or 'V' && i + 1 < signature.Length && char.IsDigit(signature[i + 1]))
+                {
+                    tokens.Add(signature.Substring(i, 2));
+                    i += 2;
+                }
+                else
+                {
+                    tokens.Add(signature[i].ToString());
+                    i++;
+                }
+            }
+
+            return tokens;
+        }
+
+        /// <summary>
+        /// True for a token describing a type passed by value across several wasm parameters
+        /// ("l2", "V2", "V4"). Interop signatures do not use these today.
+        /// </summary>
+        public static bool IsMultiSlotToken(string token)
+            => token.Length == 2 && token[0] is 'l' or 'V' && char.IsDigit(token[1]);
+
+        private static void RejectMultiSlotToken(string token)
+        {
+            if (IsMultiSlotToken(token))
+                throw new LogAsErrorException($"Multi-slot signature token '{token}' is not supported in interop thunks");
+        }
+
+        public static string TokenToNativeType(string token)
+        {
+            RejectMultiSlotToken(token);
+            return token[0] switch
+            {
+                'v' => "void",
+                'i' => "int32_t",
+                'l' => "int64_t",
+                'f' => "float",
+                'd' => "double",
+                'S' or 'A' or 'T' => "int32_t",
+                'p' => "PCODE",
+                _ => throw new InvalidSignatureCharException(token[0])
+            };
+        }
+
+        public static string TokenToNameType(string token)
+        {
+            RejectMultiSlotToken(token);
+            return token[0] switch
+            {
+                'v' => "Void",
+                'i' => "I32",
+                'l' => "I64",
+                'f' => "F32",
+                'd' => "F64",
+                'S' or 'A' => token,
+                'T' => "This",
+                'p' => "PE",
+                _ => throw new InvalidSignatureCharException(token[0])
+            };
+        }
+
+        public static string TokenToArgType(string token)
+        {
+            RejectMultiSlotToken(token);
+            return token[0] switch
+            {
+                'i' or 'T' => "ARG_I32",
+                'l' => "ARG_I64",
+                'f' => "ARG_F32",
+                'd' => "ARG_F64",
+                'S' or 'A' => "ARG_IND",
+                _ => throw new InvalidSignatureCharException(token[0])
+            };
+        }
+
+        /// <summary>
+        /// Returns the number of INTERP_STACK_SLOT_SIZE slots consumed by a token. Struct tokens
+        /// consume max((size + 7) / 8, 1) slots; all others consume 1.
+        /// </summary>
+        public static int TokenToSlotCount(string token)
+        {
+            if (token[0] is not ('S' or 'A') || token.Length < 2)
+                return 1;
+
+            return Math.Max((GetStructSize(token) + 7) / 8, 1);
+        }
+
+        public static int GetStructSize(string token)
+            => int.Parse(token.AsSpan(1), CultureInfo.InvariantCulture);
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/InterpToNativeGenerator.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/InterpToNativeGenerator.cs
new file mode 100644
index 00000000000000..cde95412ec9376
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/InterpToNativeGenerator.cs
@@ -0,0 +1,191 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using Internal.JitInterface;
+using Internal.TypeSystem;
+
+namespace ILCompiler.PortableCallHelpers
+{
+    /// <summary>
+    /// Generates the <c>g_portableCallHelperThunks</c> array and <c>CallFunc_*</c> functions used by the CoreCLR
+    /// interpreter to call native code on wasm.
+    /// </summary>
+    /// <remarks>
+    /// The generated code has to stay in sync with the CoreCLR runtime code that consumes these
+    /// thunks and call functions.
+    /// </remarks>
+    internal static class InterpToNativeGenerator
+    {
+        public static void Emit(TextWriter w, IReadOnlyDictionary<string, MethodDesc> cookies)
+        {
+            string[] signatures = cookies.Keys.ToArray();
+            Array.Sort(signatures, StringComparer.Ordinal);
+
+            // Collect unique struct return sizes so we can emit typedefs
+            var structReturnSizes = new SortedSet<int>();
+            foreach (string signature in signatures)
+            {
+                string returnToken = InteropSignature.ParseSignatureTokens(signature)[0];
+                if (returnToken[0] == 'S' && returnToken.Length > 1)
+                    structReturnSizes.Add(InteropSignature.GetStructSize(returnToken));
+            }
+
+            w.Write(
+            """
+            //
+            // GENERATED FILE, DON'T EDIT
+            // Generated by coreclr InterpToNativeGenerator
+            //
+
+            #include <callhelpers.hpp>
+            #include <minipal/utils.h>
+
+            // Arguments are passed on the stack with each argument aligned to INTERP_STACK_SLOT_SIZE.
+            #define ARG_ADDR(i) (pArgs + (i * INTERP_STACK_SLOT_SIZE))
+            #define ARG_IND(i) ((int32_t)((int32_t*)ARG_ADDR(i)))
+            #define ARG_I32(i) (*(int32_t*)ARG_ADDR(i))
+            #define ARG_I64(i) (*(int64_t*)ARG_ADDR(i))
+            #define ARG_F32(i) (*(float*)ARG_ADDR(i))
+            #define ARG_F64(i) (*(double*)ARG_ADDR(i))
+
+            """);
+
+            // Emit typedefs for struct return types so emcc generates the correct sret ABI
+            foreach (int size in structReturnSizes)
+                w.WriteLine($"typedef struct {{ char d[{size}]; }} portable_callhelper_ret_S{size};");
+
+            w.Write(
+            """
+
+            namespace
+            {
+            """);
+
+            foreach (string signature in signatures)
+            {
+                try
+                {
+                    List<string> tokens = InteropSignature.ParseSignatureTokens(signature);
+                    string returnToken = tokens[0];
+                    (bool isVoid, string nativeType) result = Result(returnToken);
+                    bool isPortableEntryPointCall = IsPortableEntryPointCall(tokens);
+                    if (isPortableEntryPointCall)
+                    {
+                        // Portable entrypoints have an extra hidden parameter for the portable entrypoint
+                        // context, so adjust the signature and result accordingly for the call function.
+                        tokens.RemoveAt(tokens.Count - 1);
+                    }
+
+                    RemoveAsyncCallMarker(tokens);
+
+                    List<string> args = Args(tokens);
+                    string argTypes = string.Join(", ", args.Select(InteropSignature.TokenToNativeType));
+
+                    string portableEntryPointComma = args.Count > 0 ? ", " : "";
+                    string portableEntrypointDeclaration = isPortableEntryPointCall ? portableEntryPointComma + "PCODE" : "";
+                    string portableEntrypointParam = isPortableEntryPointCall ? portableEntryPointComma + "pPortableEntryPoint" : "";
+                    string portableEntrypointStackDeclaration = isPortableEntryPointCall ? "int*, " : "";
+                    string portableEntrypointStackParam = isPortableEntryPointCall ? "&framePointer, " : "";
+                    string portableEntrypointPointerRD = isPortableEntryPointCall ? "*" : "";
+                    w.Write(
+                        $$"""
+
+                            {{(isPortableEntryPointCall ? "NOINLINE " : "")}}static void {{CallFuncName(args, InteropSignature.TokenToNameType(returnToken), isPortableEntryPointCall)}}(PCODE {{(isPortableEntryPointCall ? "pPortableEntryPoint" : "pcode")}}, int8_t* pArgs, int8_t* pRet)
+                            {{{(isPortableEntryPointCall ? "\n        alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK;" : "")}}
+                                {{result.nativeType}} (*fptr)({{portableEntrypointStackDeclaration}}{{argTypes}}{{portableEntrypointDeclaration}}) = {{portableEntrypointPointerRD}}({{result.nativeType}} ({{portableEntrypointPointerRD}}*)({{portableEntrypointStackDeclaration}}{{argTypes}}{{portableEntrypointDeclaration}})){{(isPortableEntryPointCall ? "(pPortableEntryPoint)" : "pcode")}};
+                                {{(result.isVoid ? "" : $"*(({result.nativeType}*)pRet) = ")}}(*fptr)({{portableEntrypointStackParam}}{{string.Join(", ", ArgsWithSlotOffsets(args))}}{{portableEntrypointParam}});
+                            }
+
+                        """);
+                }
+                catch (InvalidSignatureCharException e)
+                {
+                    throw new LogAsErrorException(
+                        $"Cannot generate an interop thunk for '{cookies[signature]}': its signature '{signature}' contains {WasmLowering.DescribeSigChar(e.Char)}, " +
+                        "which interop thunks cannot pass. Take it by reference, or wrap it in a blittable struct.");
+                }
+                catch (LogAsErrorException e)
+                {
+                    // The only place that still knows which method the signature came from.
+                    throw new LogAsErrorException($"Cannot generate an interop thunk for '{cookies[signature]}': {e.Message}");
+                }
+            }
+
+            w.Write(
+                $$"""
+                }
+
+                const StringToPortableSigThunk g_portableCallHelperThunks[] = {
+                {{string.Join($",{w.NewLine}", signatures.Select(ThunkEntry))}}
+                };
+
+                const size_t g_portableCallHelperThunksCount = sizeof(g_portableCallHelperThunks) / sizeof(g_portableCallHelperThunks[0]);
+
+                """);
+
+            static string ThunkEntry(string signature)
+            {
+                List<string> tokens = InteropSignature.ParseSignatureTokens(signature);
+                bool isPortableEntryPointCall = IsPortableEntryPointCall(tokens);
+                if (isPortableEntryPointCall)
+                    tokens.RemoveAt(tokens.Count - 1);
+                RemoveAsyncCallMarker(tokens);
+
+                string name = CallFuncName(Args(tokens), InteropSignature.TokenToNameType(tokens[0]), isPortableEntryPointCall);
+                return $"    {{ \"M{signature}\", (void*)&{name} }}";
+            }
+
+            static List<string> Args(List<string> tokens)
+                => tokens.Count > 1 ? tokens.GetRange(1, tokens.Count - 1) : [];
+
+            static List<string> ArgsWithSlotOffsets(List<string> args)
+            {
+                List<string> result = [];
+                int slot = 0;
+                foreach (string token in args)
+                {
+                    if (token[0] == 'A')
+                        slot = (slot + 1) & ~1;
+
+                    result.Add($"{InteropSignature.TokenToArgType(token)}({slot})");
+                    slot += InteropSignature.TokenToSlotCount(token);
+                }
+
+                return result;
+            }
+
+            static (bool IsVoid, string NativeType) Result(string returnToken)
+            {
+                // For struct returns, use the typedef so emcc generates the correct sret ABI
+                if (returnToken[0] == 'S' && returnToken.Length > 1)
+                    return (false, $"portable_callhelper_ret_S{InteropSignature.GetStructSize(returnToken)}");
+
+                return (returnToken == "v", InteropSignature.TokenToNativeType(returnToken));
+            }
+
+            static bool IsPortableEntryPointCall(List<string> tokens)
+                => tokens.Count > 0 && tokens[^1] == "p";
+
+            static void RemoveAsyncCallMarker(List<string> tokens)
+            {
+                int asyncMarkerIndex = tokens.IndexOf("a");
+                if (asyncMarkerIndex >= 0)
+                    tokens.RemoveAt(asyncMarkerIndex);
+            }
+        }
+
+        private static string CallFuncName(List<string> args, string result, bool isPortableEntryPointCall)
+        {
+            string paramTypes = args.Count > 0
+                ? string.Join("_", args.Select(InteropSignature.TokenToNameType))
+                : "Void";
+
+            return $"CallFunc_{paramTypes}_Ret{result}{(isPortableEntryPointCall ? "_PE" : "")}";
+        }
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/PInvokeCollector.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/PInvokeCollector.cs
new file mode 100644
index 00000000000000..f83b04e7a8b89c
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/PInvokeCollector.cs
@@ -0,0 +1,289 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
+
+using Internal.JitInterface;
+using Internal.TypeSystem;
+using Internal.TypeSystem.Ecma;
+
+namespace ILCompiler.PortableCallHelpers
+{
+    /// <summary>
+    /// A P/Invoke discovered while scanning the input assemblies.
+    /// </summary>
+    internal sealed class PInvokeInfo(string entryPoint, string module, EcmaMethod method, bool wasmLinkage)
+        : IEquatable<PInvokeInfo>
+    {
+        public string EntryPoint { get; } = entryPoint;
+        public string Module { get; } = module;
+        public EcmaMethod Method { get; } = method;
+        public bool WasmLinkage { get; } = wasmLinkage;
+        public bool Skip { get; set; }
+
+        /// <summary>A stable identity for de-duplicating declarations of the same import.</summary>
+        private string Identity => $"{EntryPoint}!{Module}!{Method.OwningType}::{Method.Name.ToString()}{Method.Signature}";
+
+        public bool Equals(PInvokeInfo other)
+            => other is not null && string.Equals(Identity, other.Identity, StringComparison.Ordinal);
+
+        public override bool Equals(object obj) => Equals(obj as PInvokeInfo);
+
+        public override int GetHashCode() => Identity.GetHashCode(StringComparison.Ordinal);
+
+        public override string ToString() => $"{{ EntryPoint: {EntryPoint}, Module: {Module}, Method: {Method}, Skip: {Skip} }}";
+    }
+
+    /// <summary>
+    /// A managed method callable from native code, discovered while scanning the input assemblies.
+    /// </summary>
+    internal sealed class PInvokeCallback
+    {
+        public PInvokeCallback(EcmaMethod method)
+        {
+            Method = method;
+            var type = (EcmaType)method.OwningType;
+
+            TypeName = type.Name.ToString();
+            TypeFullName = TypeNames.GetFullName(type);
+            AssemblyName = ((EcmaAssembly)type.Module).GetName().Name;
+
+            // Nested types: the runtime reverse-thunk key (vm/wasm/helpers.cpp GetHashCode ->
+            // GetFullyQualifiedNameInfo) reports an empty namespace for nested types, so match that
+            // here or the emitted g_ReverseThunks key won't be found at lookup time (#130129).
+            // This key drops the enclosing-type chain, so nested types with the same simple name in
+            // different namespaces collide; the duplicate-key check in PInvokeTableGenerator
+            // (EmitNativeToInterp) turns that into a build error.
+            // Tracked by https://github.com/dotnet/runtime/issues/130739.
+            Namespace = type.ContainingType is not null ? string.Empty : type.Namespace.ToString();
+            MethodName = method.Name.ToString();
+            ReturnType = method.Signature.ReturnType;
+            IsVoid = ReturnType.IsVoid;
+            Token = (uint)MetadataTokens.GetToken(method.Handle);
+
+            // FIXME: This name-based key is a temporary workaround. It must match the key generated by
+            // GetHashCode in vm/wasm/helpers.cpp because LookupThunk uses it to find the corresponding
+            // entry in g_ReverseThunks. The key must uniquely identify each callback; otherwise a
+            // collision could select a thunk whose native signature does not match the method.
+            //
+            // the key also needs to survive being encoded in C literals, if in doubt
+            // add something like "\U0001F412" to the key on both the managed and unmanaged side
+            Key = $"{MethodName}#{method.Signature.Length}:{AssemblyName}:{Namespace}:{TypeName}";
+
+            if (method.GetDecodedCustomAttribute("System.Runtime.InteropServices", "UnmanagedCallersOnlyAttribute")
+                is CustomAttributeValue<TypeDesc> attribute)
+            {
+                foreach (var argument in attribute.NamedArguments)
+                {
+                    if (argument.Name == "EntryPoint" && argument.Value is string entryPoint)
+                    {
+                        EntryPoint = entryPoint;
+                        IsExport = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// The name of the type that declares the callback, as the runtime spells it. Nested types
+        /// report an empty namespace here, which is what the reverse-thunk key expects.
+        /// </summary>
+        public string EntryName => $"{AssemblyName}_{Namespace}_{TypeName}_{MethodName}";
+
+        public MethodSignature Parameters => Method.Signature;
+        public string EntryPoint { get; }
+        public EcmaMethod Method { get; }
+        public string EntrySymbol { get; set; }
+        public string AssemblyName { get; }
+        public string TypeName { get; }
+        public string TypeFullName { get; }
+        public string Namespace { get; }
+        public string MethodName { get; }
+        public TypeDesc ReturnType { get; }
+        public bool IsExport { get; }
+        public bool IsVoid { get; }
+        public uint Token { get; }
+        public string Key { get; }
+    }
+
+    internal sealed class PInvokeCallbackComparer : IComparer<PInvokeCallback>
+    {
+        public int Compare(PInvokeCallback x, PInvokeCallback y)
+        {
+            int compare = string.Compare(x.Key, y.Key, StringComparison.Ordinal);
+            return compare != 0 ? compare : x.Token.CompareTo(y.Token);
+        }
+    }
+
+    /// <summary>
+    /// Scans assemblies for the interop surface the wasm interpreter needs thunks for: P/Invokes,
+    /// methods callable from native code, native function pointer signatures, and InternalCalls.
+    /// </summary>
+    internal sealed class PInvokeCollector(InteropLogger log, string targetOS)
+    {
+        private readonly Dictionary<TypeDesc, bool> _typeUnsupportedOnPlatform = [];
+        private readonly Dictionary<EcmaAssembly, bool> _assemblyUnsupportedOnPlatform = [];
+
+        public void CollectPInvokes(List<PInvokeInfo> pinvokes, List<PInvokeCallback> callbacks, Dictionary<string, MethodDesc> signatures, EcmaType type)
+        {
+            foreach (MethodDesc methodDesc in type.GetMethods())
+            {
+                var method = (EcmaMethod)methodDesc;
+                try
+                {
+                    CollectPInvokesForMethod(method);
+                    if (IsMethodCallback(method))
+                        callbacks.Add(new PInvokeCallback(method));
+                }
+                catch (Exception ex) when (ex is not LogAsErrorException)
+                {
+                    log.Warning("WASM0001", $"Could not get pinvoke, or callbacks for method '{type}::{method.Name.ToString()}' because '{ex}'");
+                }
+            }
+
+            if (type.HasCustomAttribute("System.Runtime.InteropServices", "UnmanagedFunctionPointerAttribute"))
+            {
+                // Each instantiation of an open generic delegate would marshal differently, so there is
+                // no single native signature to emit a thunk for. The encoding this used to produce came
+                // from mapping the type parameter itself, which was only ever right by accident.
+                if (type.HasInstantiation)
+                {
+                    log.Warning("WASM0001", $"Skipping generic function pointer delegate '{type}', which has no single native signature");
+                    return;
+                }
+
+                MethodDesc invokeMethod = type.GetMethod("Invoke"u8, null);
+                if (invokeMethod is not null)
+                    AddSignature(signatures, invokeMethod, WasmLowering.LoweringFlags.IsUnmanagedCallersOnly, "pinvoke");
+            }
+
+            void CollectPInvokesForMethod(EcmaMethod method)
+            {
+                if (!method.IsPInvoke)
+                    return;
+
+                if (IsUnsupportedOnPlatform(method))
+                    return;
+
+                PInvokeMetadata metadata = method.GetPInvokeMethodMetadata();
+                bool wasmLinkage = method.HasCustomAttribute("System.Runtime.InteropServices", "WasmImportLinkageAttribute");
+
+                pinvokes.Add(new PInvokeInfo(metadata.Name, metadata.Module, method, wasmLinkage));
+
+                AddSignature(signatures, method, WasmLowering.LoweringFlags.IsUnmanagedCallersOnly, "pinvoke");
+            }
+        }
+
+        private void AddSignature(Dictionary<string, MethodDesc> signatures, MethodDesc method, WasmLowering.LoweringFlags flags, string kind)
+        {
+            string signature = InteropSignature.GetMethodSignature(method, flags);
+            if (signatures.TryAdd(signature, method))
+                log.Verbose($"Adding {kind} signature {signature} for method '{method.OwningType}.{method.Name.ToString()}'");
+        }
+
+        private bool IsMethodCallback(EcmaMethod method)
+        {
+            if (!method.IsUnmanagedCallersOnly)
+                return false;
+
+            if (IsUnsupportedOnPlatform(method))
+                return false;
+
+            return true;
+        }
+
+        private bool IsUnsupportedOnPlatform(EcmaMethod method)
+            => EvaluatePlatformAttributes(method.GetDecodedCustomAttributes) switch
+            {
+                PlatformSupport.Unsupported => true,
+                PlatformSupport.Supported => false,
+                _ => IsUnsupportedOnPlatform(method.OwningType)
+            };
+
+        private bool IsUnsupportedOnPlatform(TypeDesc type)
+        {
+            if (type is not EcmaType ecmaType)
+                return false;
+
+            if (_typeUnsupportedOnPlatform.TryGetValue(type, out bool cached))
+                return cached;
+
+            bool value = EvaluatePlatformAttributes(ecmaType.GetDecodedCustomAttributes) switch
+            {
+                PlatformSupport.Unsupported => true,
+                PlatformSupport.Supported => false,
+                _ when ecmaType.ContainingType is not null => IsUnsupportedOnPlatform(ecmaType.ContainingType),
+                _ => IsAssemblyUnsupportedOnPlatform((EcmaAssembly)ecmaType.Module)
+            };
+
+            _typeUnsupportedOnPlatform[type] = value;
+            return value;
+        }
+
+        private bool IsAssemblyUnsupportedOnPlatform(EcmaAssembly assembly)
+        {
+            if (!_assemblyUnsupportedOnPlatform.TryGetValue(assembly, out bool value))
+            {
+                _assemblyUnsupportedOnPlatform[assembly] =
+                    value = EvaluatePlatformAttributes(assembly.GetDecodedCustomAttributes) == PlatformSupport.Unsupported;
+            }
+
+            return value;
+        }
+
+        private enum PlatformSupport
+        {
+            Unknown,     // No platform attributes were observed at this scope
+            Supported,   // Explicitly supported here (target appears in a SupportedOSPlatform list)
+            Unsupported, // Explicitly unsupported here (target matches UnsupportedOSPlatform, or
+                         // SupportedOSPlatform is present and does not list the target)
+        }
+
+        private PlatformSupport EvaluatePlatformAttributes(
+            Func<string, string, IEnumerable<CustomAttributeValue<TypeDesc>>> getAttributes)
+        {
+            const string Namespace = "System.Runtime.Versioning";
+
+            foreach (var attribute in getAttributes(Namespace, "UnsupportedOSPlatformAttribute"))
+            {
+                if (MatchesTargetOS(attribute))
+                    return PlatformSupport.Unsupported;
+            }
+
+            bool hasSupportedOSPlatform = false;
+            foreach (var attribute in getAttributes(Namespace, "SupportedOSPlatformAttribute"))
+            {
+                if (attribute.FixedArguments.Length == 0)
+                    continue;
+
+                hasSupportedOSPlatform = true;
+                if (MatchesTargetOS(attribute))
+                    return PlatformSupport.Supported;
+            }
+
+            return hasSupportedOSPlatform ? PlatformSupport.Unsupported : PlatformSupport.Unknown;
+
+            bool MatchesTargetOS(CustomAttributeValue<TypeDesc> attribute)
+            {
+                if (attribute.FixedArguments.Length == 0)
+                    return false;
+
+                string platformName = attribute.FixedArguments[0].Value?.ToString();
+                if (string.Equals(platformName, targetOS, StringComparison.OrdinalIgnoreCase))
+                    return true;
+
+                // A platform name may carry a version, as in [SupportedOSPlatform("browser1.0")].
+                // Nothing generated here varies by platform version, so a versioned name still
+                // names the target as long as a version is all that follows it.
+                if (platformName?.StartsWith(targetOS, StringComparison.OrdinalIgnoreCase) != true)
+                    return false;
+
+                return Version.TryParse(platformName.AsSpan(targetOS.Length), out _);
+            }
+        }
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/PInvokeTableGenerator.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/PInvokeTableGenerator.cs
new file mode 100644
index 00000000000000..2a4f23dbc21106
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/PInvokeTableGenerator.cs
@@ -0,0 +1,537 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+using Internal.TypeSystem;
+using Internal.TypeSystem.Ecma;
+
+namespace ILCompiler.PortableCallHelpers
+{
+    /// <summary>
+    /// Emits the static P/Invoke resolution table and the native-to-interpreter reverse thunks.
+    /// </summary>
+    internal sealed class PInvokeTableGenerator(InteropLogger log)
+    {
+        public void EmitPInvokeTable(TextWriter w, IEnumerable<string> pinvokeModules, List<PInvokeInfo> pinvokes)
+        {
+            // Modules an unresolved P/Invoke has already been reported for, so each is logged once.
+            // Only the logging is suppressed: a module a later P/Invoke does resolve - through
+            // [WasmImportLinkage], say - still has to make it into the table.
+            var skippedModules = new HashSet<string>(StringComparer.Ordinal);
+            var modules = new SortedSet<string>(StringComparer.Ordinal);
+            foreach (string module in pinvokeModules)
+                modules.Add(module);
+
+            // What actually gets linked in, captured before the scan below starts adding to modules.
+            // The lib-prefix fallback has to resolve against this rather than against modules, or an
+            // alias could be derived from another alias, or from a module that is only imported for
+            // [WasmImportLinkage] and has no archive behind it at all.
+            var linkedModules = new HashSet<string>(modules, StringComparer.Ordinal);
+
+            foreach (PInvokeInfo pinvoke in pinvokes)
+            {
+                if (modules.Contains(pinvoke.Module))
+                    continue;
+
+                // A static archive is named libFoo.a, so the module list - built from the file names
+                // of what gets linked in - carries "libFoo", while the managed side spells the
+                // [DllImport] "Foo", the name it would use on Windows. That is also the name the
+                // runtime resolver looks up, so accept it as naming the same module.
+                if (linkedModules.Contains($"lib{pinvoke.Module}"))
+                {
+                    modules.Add(pinvoke.Module);
+                    log.Verbose($"Adding module {pinvoke.Module} for statically linked lib{pinvoke.Module}");
+                    continue;
+                }
+
+                // Handle special modules, and add them to the list of modules otherwise, skip them
+                // and throw an exception at runtime if they are called.
+                if (pinvoke.WasmLinkage)
+                {
+                    // WasmLinkage means we need to import the module
+                    modules.Add(pinvoke.Module);
+                    log.Verbose($"Adding module {pinvoke.Module} for WasmImportLinkage");
+                }
+                else if (pinvoke.Module == "*")
+                {
+                    // Special case for * module to indicate static linking without specifying the module
+                    modules.Add(pinvoke.Module);
+                    log.Verbose($"Adding module {pinvoke.Module} for static linking");
+                }
+                else if (pinvoke.Module != "QCall")
+                {
+                    // Unresolved module: not statically linked, [WasmImportLinkage], "*" or QCall.
+                    // Skip it and throw at runtime if it is ever called, which is what Mono does too.
+                    // Deliberately not a warning: assemblies routinely carry P/Invokes for platforms they
+                    // are not running on - a NuGet package with Windows and Linux entry points, say - and
+                    // those are never reached on wasm. P/Invoke resolution failure is a runtime condition,
+                    // so reporting it at build time produces false positives that have to be suppressed.
+                    if (skippedModules.Add(pinvoke.Module))
+                        log.Verbose($"Skipping unresolved PInvoke module '{pinvoke.Module}' for method '{pinvoke.Method.OwningType}::{pinvoke.Method.Name.ToString()}' (not statically linked on wasm; will throw if called).");
+                }
+            }
+
+            w.WriteLine(
+                """
+                //
+                // GENERATED FILE, DON'T EDIT
+                // Generated by coreclr callhelpers generator
+                //
+
+                #include <callhelpers.hpp>
+                #include <minipal/entrypoints.h>
+
+                extern "C" {
+                """);
+
+            var pinvokesGroupedByEntryPoint = pinvokes
+                                                .Where(l => modules.Contains(l.Module))
+                                                .OrderBy(l => l.EntryPoint, StringComparer.Ordinal)
+                                                .GroupBy(CEntryPoint, StringComparer.Ordinal);
+
+            foreach (IGrouping<string, PInvokeInfo> group in pinvokesGroupedByEntryPoint)
+            {
+                PInvokeInfo[] candidates = group.Distinct().ToArray();
+                PInvokeInfo first = candidates[0];
+                if (ShouldTreatAsVariadic(candidates))
+                {
+                    string imports = string.Join(Environment.NewLine,
+                                                candidates.Select(
+                                                    p => $"    {p.Method} (in [{((EcmaAssembly)p.Method.Module).GetName().Name}] {p.Method.OwningType})"));
+                    log.Warning("WASM0001", $"Found a native function ({first.EntryPoint}) with varargs in {first.Module}." +
+                                     " Calling such functions is not supported, and will fail at runtime." +
+                                    $" Managed DllImports: {Environment.NewLine}{imports}");
+
+                    foreach (PInvokeInfo candidate in candidates)
+                        candidate.Skip = true;
+
+                    continue;
+                }
+
+                var decls = new HashSet<string>();
+                foreach (PInvokeInfo candidate in candidates)
+                {
+                    string decl = GenPInvokeDecl(candidate);
+                    if (decls.Add(decl))
+                        w.WriteLine(decl);
+                }
+            }
+
+            w.Write(
+                """
+                } // extern "C"
+
+                """);
+
+            var moduleImports = new Dictionary<string, List<string>>();
+            foreach (string module in modules)
+            {
+                // the order here is not important, because we use hash tables, we want it to be stable though
+                List<string> imports = pinvokes
+                    .Where(l => l.Module == module && !l.Skip)
+                    .OrderBy(l => l.EntryPoint, StringComparer.Ordinal)
+                    .GroupBy(d => d.EntryPoint, StringComparer.Ordinal)
+                    .Select(l =>
+                    {
+                        PInvokeInfo p = l.First();
+                        // Runtime resolver looks up by managed EntryPoint.
+                        // [WasmImportLinkage] mangles the C symbol per module,
+                        // so emit the entry-point string explicitly rather than
+                        // stringifying the mangled name via DllImportEntry.
+                        if (p.WasmLinkage)
+                            return $"    {{ \"{EscapeLiteral(p.EntryPoint)}\", (void*)&{CEntryPoint(p)} }}, // {ListRefs(l)}{w.NewLine}";
+                        return $"    DllImportEntry({CEntryPoint(p)}) // {ListRefs(l)}{w.NewLine}";
+                    })
+                    .ToList();
+
+                moduleImports[module] = imports;
+                w.Write(
+                    $$"""
+
+                    static const Entry s_{{FixupSymbolName(module)}} [] = {
+                    {{string.Concat(imports)}}};
+
+                    """);
+            }
+
+            w.Write(
+                $$"""
+
+                typedef struct PInvokeTable {
+                    const char* LibraryName;
+                    const Entry* Entries;
+                    size_t EntryCount;
+                } PInvokeTable;
+
+                static PInvokeTable s_PInvokeTables[] = {
+                    {{string.Join($",{w.NewLine}    ", modules.Select(m => $"{{\"{EscapeLiteral(m)}\", s_{FixupSymbolName(m)}, {moduleImports[m].Count}}}"))}}
+                };
+                const size_t s_PInvokeTablesCount = sizeof(s_PInvokeTables) / sizeof(s_PInvokeTables[0]);
+
+                const void* callhelpers_pinvoke_override(const char* library_name, const char* entry_point_name)
+                {
+                    for (size_t i = 0; i < s_PInvokeTablesCount; i++)
+                    {
+                        if (strcmp(library_name, s_PInvokeTables[i].LibraryName) == 0)
+                        {
+                            LOG((LF_INTEROP, LL_INFO1000, "Wasm callhelpers PInvoke override for: lib: %s, entry: %s \n", library_name, entry_point_name));
+                            return minipal_resolve_dllimport(s_PInvokeTables[i].Entries, s_PInvokeTables[i].EntryCount, entry_point_name);
+                        }
+                    }
+
+                    return nullptr;
+                }
+
+                """);
+
+            static bool ShouldTreatAsVariadic(PInvokeInfo[] candidates)
+            {
+                if (candidates.Length < 2)
+                    return false;
+
+                // Detect possible vararg entrypoint usage, where the same entrypoint is used with
+                // different numbers of arguments.
+                int firstNumArgs = candidates[0].Method.Signature.Length;
+                for (int i = 1; i < candidates.Length; i++)
+                {
+                    if (candidates[i].Method.Signature.Length != firstNumArgs)
+                        return true;
+                }
+
+                return false;
+            }
+
+            static string ListRefs(IGrouping<string, PInvokeInfo> l)
+                => string.Join(", ", l.Select(c => ((EcmaAssembly)c.Method.Module).GetName().Name).Distinct().OrderBy(n => n, StringComparer.Ordinal));
+        }
+
+        public void EmitNativeToInterp(TextWriter w, List<PInvokeCallback> callbacks)
+        {
+            // Generate the native->interpreter entry functions. Native code calls these directly, so
+            // each one carries the native signature its caller expects, taken from the
+            // [UnmanagedCallersOnly] method it wraps. Only blittable parameter and return types are
+            // supported.
+            //
+            // Each wrapper caches the MethodDesc it dispatches to in a static and hands the arguments to
+            // ExecuteInterpretedMethodFromUnmanaged. The g_ReverseThunks table emitted at the end maps
+            // the runtime's key for a method to its wrapper, and the runtime fills that static in as it
+            // hands the wrapper out. An export is not handed out that way, so it resolves the static
+            // itself, by name, on the first call.
+            w.Write(
+                """
+                //
+                // GENERATED FILE, DON'T EDIT
+                // Generated by coreclr callhelpers generator
+                //
+
+                #include <callhelpers.hpp>
+
+                // WASM-TODO: The method lookup would ideally be fully qualified assembly and then methodDef token.
+                // The current approach has limitations with overloaded methods.
+                extern "C" void LookupUnmanagedCallersOnlyMethodByName(const char* fullQualifiedTypeName, const char* methodName, MethodDesc** ppMD);
+                extern "C" void ExecuteInterpretedMethodFromUnmanaged(MethodDesc* pMD, int8_t* args, size_t argSize, int8_t* ret, PCODE callerIp);
+
+                """);
+
+            var callbackNames = new HashSet<string>();
+            var keys = new HashSet<string>();
+            callbacks.Sort(new PInvokeCallbackComparer());
+            foreach (PInvokeCallback cb in callbacks)
+            {
+                cb.EntrySymbol = FixedSymbolName(cb);
+
+                if (!callbackNames.Add(cb.EntrySymbol))
+                    throw new LogAsErrorException($"Two callbacks with the same symbol '{cb.EntrySymbol}' are not supported.");
+
+                if (!keys.Add(cb.Key))
+                    throw new LogAsErrorException($"Two callbacks with the same Name and number of arguments '{cb.Key}' are not supported.");
+
+                // That check only catches overloads of the same arity, which collide outright. Different
+                // arities produce distinct keys and distinct symbols, yet the export wrapper resolves its
+                // MethodDesc through LookupUnmanagedCallersOnlyMethodByName, which matches on the
+                // declaring type and the method name alone. Overloads are indistinguishable to it, so an
+                // export sharing its name with another callback would be handed whichever MethodDesc the
+                // walk reached first and would then call it with its own arguments.
+                //
+                // This is a stopgap for a lookup that cannot express what it means to ask. If the runtime
+                // ever resolves these unambiguously, this rejection should go away with it.
+                if (cb.IsExport)
+                    RejectAmbiguousExport(cb);
+
+                int parameterCount = cb.Parameters.Length;
+                string argsArgs = parameterCount > 0 ? "(int8_t*)args, sizeof(args)" : "nullptr, 0";
+                string[] parameterCTypes = ParameterTypes(cb.Parameters).Select(MapType).ToArray();
+                // A cast converts a float numerically, while the slot has to carry its bits, so copy
+                // those instead. Every other type this emits reaches the slot unchanged through a cast.
+                bool CarriesBits(int i) => parameterCTypes[i] is "float" or "double";
+                string argsDeclaration = parameterCount > 0
+                    ? $"\n    int64_t args[{parameterCount}] = {{ {string.Join(", ", Enumerable.Range(0, parameterCount).Select(i => CarriesBits(i) ? "0" : $"(int64_t)arg{i}"))} }};\n"
+                      + string.Concat(Enumerable.Range(0, parameterCount).Where(CarriesBits).Select(i => $"    memcpy(&args[{i}], &arg{i}, sizeof(arg{i}));\n"))
+                    : string.Empty;
+                string parametersDeclaration = string.Join(", ", parameterCTypes.Select((p, i) => $"{p} arg{i}"));
+                string arguments = string.Join(", ", Enumerable.Range(0, parameterCount).Select(i => $"arg{i}"));
+                string exportFunction = cb.IsExport ?
+                    $$"""
+
+
+                    extern "C" {{MapType(cb.ReturnType)}} {{cb.EntryPoint}}({{parametersDeclaration}})
+                    {
+                        {{(cb.IsVoid ? "" : "return ")}}Call_{{cb.EntrySymbol}}({{arguments}});
+                    }
+                    """ : string.Empty;
+                w.Write(
+                    $$"""
+
+                    static MethodDesc* MD_{{cb.EntrySymbol}} = nullptr;
+                    static {{
+                    MapType(cb.ReturnType)}} Call_{{cb.EntrySymbol}}({{parametersDeclaration}})
+                    {{{argsDeclaration}}
+                        // Lazy lookup of MethodDesc for the function export scenario.
+                        if (!MD_{{cb.EntrySymbol}})
+                        {
+                            LookupUnmanagedCallersOnlyMethodByName("{{cb.TypeFullName}}, {{cb.AssemblyName}}", "{{cb.MethodName}}", &MD_{{cb.EntrySymbol}});
+                        }{{
+                        (!cb.IsVoid ? $"{w.NewLine}{w.NewLine}    {MapType(cb.ReturnType)} result;" : "")}}
+                        ExecuteInterpretedMethodFromUnmanaged(MD_{{cb.EntrySymbol}}, {{argsArgs}}, {{(cb.IsVoid ? "nullptr" : "(int8_t*)&result")}}, (PCODE)&Call_{{cb.EntrySymbol}});{{
+                        (!cb.IsVoid ? $"{w.NewLine}    return result;" : "")}}
+                    }{{exportFunction}}
+
+                    """);
+            }
+
+            w.Write(
+                $$"""
+
+                const ReverseThunkMapEntry g_ReverseThunks[] =
+                {
+                {{string.Join($",{w.NewLine}", callbacks.Select(ThunkMapEntryLine))}}
+                };
+
+                const size_t g_ReverseThunksCount = sizeof(g_ReverseThunks) / sizeof(g_ReverseThunks[0]);
+
+                """);
+
+            // The runtime walks every [UnmanagedCallersOnly] method the type declares, so match that.
+            static void RejectAmbiguousExport(PInvokeCallback cb)
+            {
+                List<string> ambiguous = [];
+                foreach (MethodDesc candidate in cb.Method.OwningType.GetMethods())
+                {
+                    if (candidate != cb.Method
+                        && candidate.Name.StringEquals(cb.MethodName)
+                        && candidate.HasCustomAttribute("System.Runtime.InteropServices", "UnmanagedCallersOnlyAttribute"))
+                    {
+                        ambiguous.Add(candidate.ToString());
+                    }
+                }
+
+                if (ambiguous.Count == 0)
+                    return;
+
+                ambiguous.Add(cb.Method.ToString());
+                ambiguous.Sort(StringComparer.Ordinal);
+
+                throw new LogAsErrorException(
+                    $"Exported callback '{cb.EntryPoint}' cannot be resolved at run time: '{cb.TypeFullName}' declares more than one [UnmanagedCallersOnly] method named '{cb.MethodName}', and the runtime looks them up by name alone. Give them distinct names: {string.Join(", ", ambiguous)}");
+            }
+        }
+
+        private string CEntryPoint(PInvokeInfo pinvoke)
+        {
+            if (pinvoke.WasmLinkage)
+            {
+                // We mangle the name to avoid collisions with symbols in other modules
+                string namespaceName = TypeNames.GetNamespace(pinvoke.Method.OwningType);
+                return FixupSymbolName($"{namespaceName}#{pinvoke.Module}#{pinvoke.EntryPoint}");
+            }
+
+            return FixupSymbolName(pinvoke.EntryPoint);
+        }
+
+        private string GenPInvokeDecl(PInvokeInfo pinvoke)
+        {
+            MethodSignature signature = pinvoke.Method.Signature;
+            TypeDesc returnType = signature.ReturnType;
+            List<string> parameterTypes = [];
+            foreach (TypeDesc parameter in ParameterTypes(signature))
+                parameterTypes.Add(MapType(parameter));
+
+            if (IsPassedByReference(returnType))
+            {
+                returnType = pinvoke.Method.Context.GetWellKnownType(WellKnownType.Void);
+                parameterTypes.Insert(0, "void *");
+            }
+
+            string importAttributes = pinvoke.WasmLinkage
+                ? $"__attribute__((import_module(\"{EscapeLiteral(pinvoke.Module)}\"),import_name(\"{EscapeLiteral(pinvoke.EntryPoint)}\"))) "
+                : "";
+            string externKeyword = pinvoke.WasmLinkage ? "extern " : "";
+
+            return $"    {importAttributes}{externKeyword}{MapType(returnType)} {CEntryPoint(pinvoke)} ({string.Join(", ", parameterTypes)});";
+        }
+
+        private string FixedSymbolName(PInvokeCallback cb)
+        {
+            string paramTypes = cb.Parameters.Length > 0
+                ? string.Join("_", ParameterTypes(cb.Parameters).Select(TypeToNameType))
+                : "Void";
+
+            return FixupSymbolName($"{cb.EntryName}_{paramTypes}_Ret{TypeToNameType(cb.ReturnType)}");
+        }
+
+        private string ThunkMapEntryLine(PInvokeCallback cb)
+            => $"    {{ {HashString(cb.Key)}, \"{EscapeLiteral(cb.Key)}\", {{ &MD_{FixedSymbolName(cb)}, (void*)&Call_{cb.EntrySymbol} }} }}";
+
+        /// <summary>
+        /// Whether the wasm ABI moves a struct by reference instead of as a bare value. Padding,
+        /// several fields, or a type too wide for one slot all force the hidden-pointer form, so the
+        /// C declaration has to say <c>void *</c> rather than unwrap to the field's type.
+        /// </summary>
+        private static bool IsPassedByReference(TypeDesc type)
+        {
+            if (!type.IsValueType || type.IsPrimitive || type.IsEnum || type is FunctionPointerType)
+                return false;
+
+            return InteropSignature.GetAbiToken(type)[0] is 'S' or 'A';
+        }
+
+        private static string TypeToNameType(TypeDesc type)
+        {
+            if (!type.IsValueType || type.IsPointer || type.IsByRef || type is FunctionPointerType)
+                return "I32";
+
+            if (type.IsEnum)
+                return TypeToNameType(type.UnderlyingType);
+
+            return InteropSignature.TokenToNameType(InteropSignature.GetAbiToken(type));
+        }
+
+        private static string MapType(TypeDesc type) => type.Category switch
+        {
+            TypeFlags.Void => "void",
+            TypeFlags.Double => "double",
+            TypeFlags.Single => "float",
+            TypeFlags.Int64 => "int64_t",
+            TypeFlags.UInt64 => "uint64_t",
+            TypeFlags.Int32 or TypeFlags.Int16 or TypeFlags.Char or TypeFlags.Boolean or TypeFlags.SByte => "int32_t",
+            TypeFlags.UInt32 or TypeFlags.UInt16 or TypeFlags.Byte => "uint32_t",
+            TypeFlags.IntPtr or TypeFlags.UIntPtr => "void *",
+            _ => PickCTypeNameForUnknownType(type)
+        };
+
+        private static string PickCTypeNameForUnknownType(TypeDesc type)
+        {
+            // Pass objects by-reference (their address by-value), and pointers and function pointers
+            // by-value.
+            if (!type.IsValueType || type.IsPointer || type is FunctionPointerType)
+                return "void *";
+
+            if (type.IsEnum)
+                return MapType(type.UnderlyingType);
+
+            // The wasm C ABI hands a struct over as a bare scalar only when it recursively contains a
+            // single scalar that fills it. Padding or extra fields make it travel by reference, so ask
+            // the same lowering the runtime encodes into the signature instead of unwrapping blindly:
+            // otherwise a `[StructLayout(Size = 16)] struct { long V; }` parameter is declared int64_t
+            // while the caller passes a pointer.
+            if (IsPassedByReference(type))
+                return "void *";
+
+            // https://github.com/WebAssembly/tool-conventions/blob/main/BasicCABI.md#function-signatures
+            // Any struct or union that recursively (including through nested structs, unions, and arrays)
+            //  contains just a single scalar value and is not specified to have greater than natural alignment.
+            // FIXME: Handle the scenario where there are fields of struct types that contain no members
+            FieldDesc singleField = null;
+            foreach (FieldDesc field in ((MetadataType)type).GetFields())
+            {
+                if (field.IsStatic)
+                    continue;
+
+                if (singleField is not null)
+                    return "void *";
+
+                singleField = field;
+            }
+
+            return singleField is not null ? MapType(singleField.FieldType) : "void *";
+        }
+
+        private static readonly char[] s_charsToReplace = ['.', '-', '+', '<', '>'];
+
+        /// <summary><see cref="MethodSignature"/> is indexable but not enumerable; this makes it LINQ-friendly.</summary>
+        private static IEnumerable<TypeDesc> ParameterTypes(MethodSignature signature)
+        {
+            for (int i = 0; i < signature.Length; i++)
+                yield return signature[i];
+        }
+
+        /// <summary>
+        /// Rewrites a name into something that can be used as a C identifier, reversibly enough that
+        /// two different names cannot collide.
+        /// </summary>
+        private static string FixupSymbolName(string name)
+        {
+            var sb = new StringBuilder();
+            foreach (byte b in Encoding.UTF8.GetBytes(name))
+            {
+                if (b is (>= (byte)'0' and <= (byte)'9') or (>= (byte)'a' and <= (byte)'z') or (>= (byte)'A' and <= (byte)'Z') or (byte)'_')
+                    sb.Append((char)b);
+                else if (Array.IndexOf(s_charsToReplace, (char)b) >= 0)
+                    sb.Append('_');
+                else
+                    sb.Append(CultureInfo.InvariantCulture, $"_{b:X}_");
+            }
+
+            return sb.ToString();
+        }
+
+        private static string EscapeLiteral(string input)
+        {
+            if (input is null)
+                return string.Empty;
+
+            var sb = new StringBuilder();
+            for (int i = 0; i < input.Length; i++)
+            {
+                char c = input[i];
+
+                sb.Append(c switch
+                {
+                    '\\' => "\\\\",
+                    '\"' => "\\\"",
+                    '\n' => "\\n",
+                    '\r' => "\\r",
+                    '\t' => "\\t",
+                    // take special care with surrogate pairs to avoid
+                    // potential decoding issues in generated C literals
+                    _ when char.IsHighSurrogate(c) && i + 1 < input.Length && char.IsLowSurrogate(input[i + 1])
+                        => $"\\U{char.ConvertToUtf32(c, input[++i]):X8}",
+                    _ when char.IsControl(c) || c > 127
+                        => $"\\u{(int)c:X4}",
+                    _ => c.ToString()
+                });
+            }
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Equivalent to <c>ULONG HashString(LPCWSTR szStr)</c> in the CoreCLR runtime,
+        /// src/coreclr/inc/utilcode.h.
+        /// </summary>
+        private static uint HashString(string str)
+        {
+            uint hash = 5381;
+            foreach (char c in str)
+                hash = ((hash << 5) + hash) ^ c;
+
+            return hash;
+        }
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/PortableCallHelpersGenerator.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/PortableCallHelpersGenerator.cs
new file mode 100644
index 00000000000000..f20fcfbb6a2503
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/PortableCallHelpersGenerator.cs
@@ -0,0 +1,189 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+using Internal.TypeSystem;
+using Internal.TypeSystem.Ecma;
+using Internal.TypeSystem.Interop;
+
+namespace ILCompiler.PortableCallHelpers
+{
+    /// <summary>
+    /// Options for <see cref="PortableCallHelpersGenerator"/>, mirroring the command line.
+    /// </summary>
+    public sealed class PortableCallHelpersGeneratorOptions
+    {
+        public string OutputDirectory { get; init; }
+        public IReadOnlyList<string> PInvokeModules { get; init; } = [];
+        public string TargetOS { get; init; }
+    }
+
+    /// <summary>
+    /// Generates the C++ interop helpers the wasm interpreter needs: the static P/Invoke resolution
+    /// table, the native-to-managed reverse thunks, and the interpreter-to-native call thunks.
+    /// </summary>
+    /// <remarks>
+    /// This runs inside crossgen2 because the files it writes encode the wasm ABI - struct sizes,
+    /// alignment, and how each type is passed - which cannot be derived from metadata alone. Doing
+    /// it here means there is exactly one implementation of the lowering (<see cref="WasmLowering"/>,
+    /// shared with compiled code) rather than a second one in a build task that would be free to
+    /// drift from it.
+    ///
+    /// Usage:
+    ///   crossgen2 --generate-portable-callhelpers &lt;dir&gt; --targetos &lt;browser|wasi&gt; --targetarch wasm \
+    ///             --directpinvoke &lt;name&gt;... &lt;assembly&gt;...
+    /// </remarks>
+    public static class PortableCallHelpersGenerator
+    {
+        public const string PInvokeFileName = "callhelpers-pinvoke.cpp";
+        public const string ReversePInvokeFileName = "callhelpers-reverse.cpp";
+        public const string InterpToNativeFileName = "callhelpers-interp-to-managed.cpp";
+
+        public static int Run(ReadyToRunCompilerContext context, PortableCallHelpersGeneratorOptions options, Logger logger)
+        {
+            var log = new InteropLogger(logger);
+
+            try
+            {
+                // An empty directory would quietly write the files next to whatever the current
+                // directory happens to be, so name it as the error it is.
+                if (string.IsNullOrEmpty(options.OutputDirectory))
+                    throw new LogAsErrorException("--generate-portable-callhelpers needs a directory to write to.");
+
+                // The scan reads platform attributes against this name, and an empty one matches
+                // nothing, which would silently drop every method guarded by SupportedOSPlatform.
+                if (string.IsNullOrEmpty(options.TargetOS))
+                    throw new LogAsErrorException("--generate-portable-callhelpers needs a target OS to match platform attributes against.");
+
+                Generate(context, options, log);
+                return 0;
+            }
+            catch (LogAsErrorException ex)
+            {
+                logger.LogMessage($"crossgen2 : error : {ex.Message}");
+                return 1;
+            }
+        }
+
+        private static void Generate(ReadyToRunCompilerContext context, PortableCallHelpersGeneratorOptions options, InteropLogger log)
+        {
+            ConfigureCompilationGroup(context);
+
+            var collector = new PInvokeCollector(log, options.TargetOS);
+            var internalCallCollector = new InternalCallSignatureCollector(log);
+
+            List<PInvokeInfo> pinvokes = [];
+            List<PInvokeCallback> callbacks = [];
+            Dictionary<string, MethodDesc> signatures = [];
+
+            foreach (string simpleName in context.InputFilePaths.Keys)
+            {
+                EcmaModule module = context.GetModuleForSimpleName(simpleName);
+
+                // Only System.Private.CoreLib is scanned for InternalCall methods: all the ones that
+                // are used are defined there, scanning everything is expensive, and doing so can hit
+                // failures on assemblies that are not tested for it.
+                bool scanInternalCalls = module == context.SystemModule;
+
+                log.Verbose($"Scanning {simpleName} for pinvokes{(scanInternalCalls ? " and InternalCall methods" : "")}");
+
+                int pinvokesFromOtherModules = pinvokes.Count;
+
+                foreach (MetadataType type in module.GetAllTypes())
+                {
+                    if (type is not EcmaType ecmaType)
+                        continue;
+
+                    collector.CollectPInvokes(pinvokes, callbacks, signatures, ecmaType);
+
+                    if (scanInternalCalls)
+                        internalCallCollector.ScanType(ecmaType);
+                }
+
+                // WASM-TODO: The helpers describe every P/Invoke with the signature the type system
+                // reports, which is what native sees only when the module disables runtime
+                // marshalling. Make this check per-P/Invoke and marshalling-aware (see
+                // Marshaller.IsMarshallingRequired), then raise it to a warning. It stays a message
+                // while it names whole framework assemblies, which ship prebuilt and would fail
+                // builds nobody can fix. Tracked by https://github.com/dotnet/runtime/issues/133190.
+                if (pinvokes.Count != pinvokesFromOtherModules && MarshalHelpers.IsRuntimeMarshallingEnabled(module))
+                {
+                    log.InfoHigh("WASM0065",
+                        $"'{simpleName}' declares P/Invokes without [assembly: DisableRuntimeMarshalling]; the generated helpers assume its signatures cross to native unmarshalled.");
+                }
+            }
+
+            var generator = new PInvokeTableGenerator(log);
+
+            WriteIfDifferent(Path.Combine(options.OutputDirectory, PInvokeFileName), log,
+                w => generator.EmitPInvokeTable(w, options.PInvokeModules, pinvokes));
+
+            WriteIfDifferent(Path.Combine(options.OutputDirectory, ReversePInvokeFileName), log,
+                w => generator.EmitNativeToInterp(w, callbacks));
+
+            foreach (KeyValuePair<string, MethodDesc> internalCall in internalCallCollector.Signatures)
+                signatures.TryAdd(internalCall.Key, internalCall.Value);
+
+            WriteIfDifferent(Path.Combine(options.OutputDirectory, InterpToNativeFileName), log,
+                w => InterpToNativeGenerator.Emit(w, signatures));
+        }
+
+        /// <summary>
+        /// Writes generated content to <paramref name="path"/> only when it differs from what is
+        /// already there, so that an unchanged file keeps its timestamp and does not retrigger the
+        /// native build that consumes it.
+        /// </summary>
+        private static void WriteIfDifferent(string path, InteropLogger log, Action<TextWriter> emit)
+        {
+            var buffer = new StringWriter { NewLine = Environment.NewLine };
+            emit(buffer);
+            string content = buffer.ToString();
+
+            if (File.Exists(path) && File.ReadAllText(path) == content)
+            {
+                log.Verbose($"{path} is unchanged.");
+                return;
+            }
+
+            Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(path)));
+            File.WriteAllText(path, content, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
+            log.Verbose($"Generated {path}.");
+        }
+
+        /// <summary>
+        /// The ReadyToRun field layout algorithm asks the compilation group whether a derived type
+        /// needs its base offset aligned, so a context without a group throws before computing any
+        /// layout.
+        /// </summary>
+        /// <remarks>
+        /// Every input goes into a single version bubble. The alignment the group would otherwise
+        /// introduce exists to keep offsets baked into precompiled code valid across a version
+        /// boundary, and there is no precompiled code here: the interpreter loads these assemblies
+        /// and computes their layout itself. One bubble is what reports that layout.
+        /// </remarks>
+        private static void ConfigureCompilationGroup(ReadyToRunCompilerContext context)
+        {
+            List<EcmaModule> modules = new(context.InputFilePaths.Count);
+            foreach (string simpleName in context.InputFilePaths.Keys)
+                modules.Add(context.GetModuleForSimpleName(simpleName));
+
+            context.SetCompilationGroup(new ReadyToRunSingleAssemblyCompilationModuleGroup(new ReadyToRunCompilationModuleGroupConfig
+            {
+                Context = context,
+                // "Many inputs, one output unit" is what composite mode means, and it is what makes
+                // the group treat every input as a single compilation unit. Without it the group
+                // asserts on a compilation set larger than one assembly.
+                IsCompositeBuildMode = true,
+                IsInputBubble = true,
+                CompilationModuleSet = modules,
+                VersionBubbleModuleSet = modules,
+                CrossModuleInlineable = [],
+                InstructionSetSupport = context.InstructionSetSupport,
+            }));
+        }
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/TypeNames.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/TypeNames.cs
new file mode 100644
index 00000000000000..5430ce447e46bd
--- /dev/null
+++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers/TypeNames.cs
@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Internal.TypeSystem;
+
+namespace ILCompiler.PortableCallHelpers
+{
+    /// <summary>
+    /// Formats type names the way <see cref="System.Reflection"/> reports them. The runtime looks
+    /// callbacks up by these names and the emitted symbols embed them, so they have to match
+    /// reflection rather than the type system, which spells nested types differently.
+    /// </summary>
+    internal static class TypeNames
+    {
+        /// <summary>
+        /// The name <see cref="System.Type.FullName"/> would report, with nested types joined by '+'.
+        /// </summary>
+        public static string GetFullName(MetadataType type)
+        {
+            if (type.ContainingType is MetadataType containingType)
+                return $"{GetFullName(containingType)}+{type.Name.ToString()}";
+
+            string name = type.Name.ToString();
+            string ns = GetNamespace(type);
+
+            return string.IsNullOrEmpty(ns) ? name : $"{ns}.{name}";
+        }
+
+        /// <summary>
+        /// The namespace <see cref="System.Type.Namespace"/> would report. The type system stores it
+        /// only on the outermost type, while reflection reports the enclosing namespace for nested
+        /// types too.
+        /// </summary>
+        public static string GetNamespace(TypeDesc type)
+        {
+            if (type is not MetadataType metadataType)
+                return string.Empty;
+
+            while (metadataType.ContainingType is MetadataType containingType)
+                metadataType = containingType;
+
+            return metadataType.Namespace.ToString();
+        }
+    }
+}
diff --git a/src/coreclr/tools/aot/crossgen2/Crossgen2RootCommand.cs b/src/coreclr/tools/aot/crossgen2/Crossgen2RootCommand.cs
index adb460313a7cad..21227b5e739951 100644
--- a/src/coreclr/tools/aot/crossgen2/Crossgen2RootCommand.cs
+++ b/src/coreclr/tools/aot/crossgen2/Crossgen2RootCommand.cs
@@ -102,6 +102,10 @@ internal class Crossgen2RootCommand : RootCommand
             new("--jitpath") { Description = SR.JitPathOption };
         public Option<bool> PrintReproInstructions { get; } =
             new("--print-repro-instructions") { Description = SR.PrintReproInstructionsOption };
+        public Option<string> GeneratePortableCallHelpers { get; } =
+            new("--generate-portable-callhelpers") { Description = SR.GeneratePortableCallHelpersOption };
+        public Option<string[]> DirectPInvoke { get; } =
+            new("--directpinvoke") { DefaultValueFactory = _ => Array.Empty<string>(), Description = SR.DirectPInvokeOption };
         public Option<string> SingleMethodTypeName { get; } =
             new("--singlemethodtypename") { Description = SR.SingleMethodTypeName };
         public Option<string> SingleMethodName { get; } =
@@ -207,6 +211,8 @@ public Crossgen2RootCommand(string[] args) : base(SR.Crossgen2BannerText)
             Options.Add(TargetAllowsRuntimeCodeGeneration);
             Options.Add(JitPath);
             Options.Add(PrintReproInstructions);
+            Options.Add(GeneratePortableCallHelpers);
+            Options.Add(DirectPInvoke);
             Options.Add(SingleMethodTypeName);
             Options.Add(SingleMethodName);
             Options.Add(SingleMethodIndex);
diff --git a/src/coreclr/tools/aot/crossgen2/Program.cs b/src/coreclr/tools/aot/crossgen2/Program.cs
index 7224f9334fa071..2648ec32c64768 100644
--- a/src/coreclr/tools/aot/crossgen2/Program.cs
+++ b/src/coreclr/tools/aot/crossgen2/Program.cs
@@ -39,6 +39,7 @@ internal sealed class Program
         private readonly bool _singleFileCompilation;
         private readonly bool _outNearInput;
         private readonly string _outputFilePath;
+        private readonly string _generatePortableCallHelpers;
 
         public Program(Crossgen2RootCommand command)
         {
@@ -47,6 +48,7 @@ public Program(Crossgen2RootCommand command)
             _singleFileCompilation = Get(command.SingleFileCompilation);
             _outNearInput = Get(command.OutNearInput);
             _outputFilePath = Get(command.OutputFilePath);
+            _generatePortableCallHelpers = Get(command.GeneratePortableCallHelpers);
 
             if (Get(command.WaitForDebugger))
             {
@@ -68,7 +70,7 @@ private void ConfigureImageBase(TargetDetails targetDetails)
 
         public int Run()
         {
-            if (_outputFilePath == null && !_outNearInput)
+            if (_outputFilePath == null && !_outNearInput && _generatePortableCallHelpers is null)
                 throw new CommandLineException(SR.MissingOutputFile);
 
             if (_singleFileCompilation && !_outNearInput)
@@ -78,6 +80,13 @@ public int Run()
 
             (TargetArchitecture targetArchitecture, TargetOS targetOS, TargetAbi targetAbi) =
                 Helpers.GetTargetSpec(Get(_command.TargetArchitecture), Get(_command.TargetOS));
+
+            // The portable call-helpers generator is currently supported only for Wasm.
+            if (_generatePortableCallHelpers is not null
+                && (targetArchitecture != TargetArchitecture.Wasm32 || targetOS is not (TargetOS.Browser or TargetOS.Wasi)))
+            {
+                throw new CommandLineException(SR.GeneratePortableCallHelpersRequiresWasmTarget);
+            }
             bool targetAllowsRuntimeCodeGeneration = Get(_command.TargetAllowsRuntimeCodeGeneration)
                 ?? GetTargetAllowsRuntimeCodeGeneration(targetOS, targetArchitecture);
 
@@ -276,6 +285,18 @@ public int Run()
             _typeSystemContext.SetSystemModule((EcmaModule)_typeSystemContext.GetModuleForSimpleName(systemModuleName));
             ReadyToRunCompilerContext typeSystemContext = _typeSystemContext;
 
+            if (_generatePortableCallHelpers is not null)
+            {
+                return PortableCallHelpers.PortableCallHelpersGenerator.Run(typeSystemContext, new PortableCallHelpers.PortableCallHelpersGeneratorOptions
+                {
+                    OutputDirectory = _generatePortableCallHelpers,
+                    PInvokeModules = Get(_command.DirectPInvoke),
+                    // The normalized name, so that platform attributes match regardless of how
+                    // --targetos was spelled on the command line.
+                    TargetOS = targetOS.ToString().ToLowerInvariant(),
+                }, logger);
+            }
+
             if (_singleFileCompilation)
             {
                 var singleCompilationInputFilePaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
diff --git a/src/coreclr/tools/aot/crossgen2/Properties/Resources.resx b/src/coreclr/tools/aot/crossgen2/Properties/Resources.resx
index d042e370ae465b..dbfe9b13c86b38 100644
--- a/src/coreclr/tools/aot/crossgen2/Properties/Resources.resx
+++ b/src/coreclr/tools/aot/crossgen2/Properties/Resources.resx
@@ -288,6 +288,15 @@
   <data name="TargetOSOption" xml:space="preserve">
     <value>Target OS for cross compilation</value>
   </data>
+  <data name="GeneratePortableCallHelpersOption" xml:space="preserve">
+    <value>Generate the portable entry point call helper sources into the given directory instead of compiling</value>
+  </data>
+  <data name="DirectPInvokeOption" xml:space="preserve">
+    <value>Name of a statically linked native module P/Invokes may resolve against</value>
+  </data>
+  <data name="GeneratePortableCallHelpersRequiresWasmTarget" xml:space="preserve">
+    <value>--generate-portable-callhelpers requires --targetarch wasm together with --targetos browser or --targetos wasi</value>
+  </data>
   <data name="TargetOSUnsupported" xml:space="preserve">
     <value>Target OS is not supported</value>
   </data>
diff --git a/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp b/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp
index d6570db6f62385..c82a08e8fe4c57 100644
--- a/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp
+++ b/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp
@@ -674,7 +674,7 @@ namespace
     }
 }
 
-const StringToWasmSigThunk g_wasmThunks[] = {
+const StringToPortableSigThunk g_portableCallHelperThunks[] = {
     { "Mddddp", (void*)&CallFunc_F64_F64_F64_RetF64_PE },
     { "Mdddp", (void*)&CallFunc_F64_F64_RetF64_PE },
     { "Mddip", (void*)&CallFunc_F64_I32_RetF64_PE },
@@ -781,4 +781,4 @@ const StringToWasmSigThunk g_wasmThunks[] = {
     { "Mvp", (void*)&CallFunc_Void_RetVoid_PE }
 };
 
-const size_t g_wasmThunksCount = sizeof(g_wasmThunks) / sizeof(g_wasmThunks[0]);
+const size_t g_portableCallHelperThunksCount = sizeof(g_portableCallHelperThunks) / sizeof(g_portableCallHelperThunks[0]);
diff --git a/src/coreclr/vm/wasm/callhelpers.hpp b/src/coreclr/vm/wasm/callhelpers.hpp
index 6f60164ffa87c9..a7aac2eb63ab70 100644
--- a/src/coreclr/vm/wasm/callhelpers.hpp
+++ b/src/coreclr/vm/wasm/callhelpers.hpp
@@ -34,14 +34,14 @@
 #define TERMINATE_R2R_STACK_WALK_FP_OFFSET 4 // The framepointer is a pointer value, and therefore should be pointer aligned
 #endif
 
-struct StringToWasmSigThunk
+struct StringToPortableSigThunk
 {
     const char* key;
     void*       value;
 };
 
-extern const StringToWasmSigThunk g_wasmThunks[];
-extern const size_t g_wasmThunksCount;
+extern const StringToPortableSigThunk g_portableCallHelperThunks[];
+extern const size_t g_portableCallHelperThunksCount;
 
 struct ReverseThunkMapValue
 {
diff --git a/src/tasks/WasmAppBuilder/generate-coreclr-helpers.cmd b/src/coreclr/vm/wasm/generate-coreclr-helpers.cmd
similarity index 52%
rename from src/tasks/WasmAppBuilder/generate-coreclr-helpers.cmd
rename to src/coreclr/vm/wasm/generate-coreclr-helpers.cmd
index 3cf780d5c5659c..020edfca8f131c 100644
--- a/src/tasks/WasmAppBuilder/generate-coreclr-helpers.cmd
+++ b/src/coreclr/vm/wasm/generate-coreclr-helpers.cmd
@@ -6,9 +6,10 @@ set "configuration=Debug"
 set "browser_scan_path_override="
 set "wasi_scan_path_override="
 
-:: Get the repo root (script is in src/tasks/WasmAppBuilder).
+:: Get the repo root (script is in src/coreclr/vm/wasm).
 :: This must be computed before argument parsing, because SHIFT also shifts %0.
-for %%I in ("%~dp0..\..\..") do set "repo_root=%%~fI"
+set "script_dir=%~dp0"
+for %%I in ("%~dp0..\..\..\..") do set "repo_root=%%~fI"
 
 set "usage=Usage: %~nx0 [options]"
 set "usage=!usage!^
@@ -75,48 +76,27 @@ echo Repo root: %repo_root%
 
 cd /d "%repo_root%"
 
-:: Resolve scan paths (allow overrides).
+:: The scan paths, the crossgen2 lookup and the P/Invoke module list all live in the project next
+:: to this script, so they are not restated here and in the .sh.
+set "generator_proj=%script_dir%generate-coreclr-helpers.proj"
+
+:: Each override goes in as one quoted argument so that a path containing spaces survives. A
+:: trailing backslash would escape the closing quote, so it is dropped here; the project puts the
+:: separator back.
+set "browser_prop="
 if not "%browser_scan_path_override%"=="" (
-    set browser_scan_path=%browser_scan_path_override%
-) else (
-    set browser_scan_path=%repo_root%\artifacts\bin\testhost\net11.0-browser-%configuration%-wasm\shared\Microsoft.NETCore.App\11.0.0\
+    if "%browser_scan_path_override:~-1%."=="\." set "browser_scan_path_override=%browser_scan_path_override:~0,-1%"
+    set browser_prop="-p:BrowserScanPath=!browser_scan_path_override!"
 )
 
+set "wasi_prop="
 if not "%wasi_scan_path_override%"=="" (
-    set wasi_scan_path=%wasi_scan_path_override%
-) else (
-    set wasi_scan_path=%repo_root%\artifacts\bin\testhost\net11.0-wasi-%configuration%-wasm\shared\Microsoft.NETCore.App\11.0.0\
+    if "%wasi_scan_path_override:~-1%."=="\." set "wasi_scan_path_override=%wasi_scan_path_override:~0,-1%"
+    set wasi_prop="-p:WasiScanPath=!wasi_scan_path_override!"
 )
 
-call :run_generator browser "%browser_scan_path%" "%repo_root%\src\coreclr\vm\wasm\browser\"
-if errorlevel 1 exit /b 1
-
-call :run_generator wasi "%wasi_scan_path%" "%repo_root%\src\coreclr\vm\wasm\wasi\"
+call .\dotnet.cmd build "%generator_proj%" -t:GenerateCallHelpers "-p:Configuration=%configuration%" %browser_prop% %wasi_prop%
 if errorlevel 1 exit /b 1
 
 echo Done!
 exit /b 0
-
-:: run_generator <target_os> <scan_path> <output_dir>
-:run_generator
-set "target_os=%~1"
-set "scan_path=%~2"
-set "output_dir=%~3"
-
-if not exist "%scan_path%" (
-    echo Error: Scan path for %target_os% does not exist: %scan_path%
-    echo Please build the runtime first using: .\build.cmd clr+libs -os %target_os% -c %configuration%
-    exit /b 1
-)
-
-echo [%target_os%] Scan path: %scan_path%
-echo [%target_os%] Output path: %output_dir%
-echo Running generator for %target_os%...
-echo dotnet.cmd build /t:RunGenerator /p:RuntimeFlavor=CoreCLR /p:TargetOS=%target_os% /p:GeneratorOutputPath=%output_dir% /p:AssembliesScanPath=%scan_path% src\tasks\WasmAppBuilder\WasmAppBuilder.csproj
-call .\dotnet.cmd build /t:RunGenerator /p:RuntimeFlavor=CoreCLR /p:TargetOS=%target_os% /p:GeneratorOutputPath=%output_dir% /p:AssembliesScanPath=%scan_path% src\tasks\WasmAppBuilder\WasmAppBuilder.csproj
-
-if errorlevel 1 (
-    echo Generator failed for %target_os%!
-    exit /b 1
-)
-exit /b 0
diff --git a/src/coreclr/vm/wasm/generate-coreclr-helpers.md b/src/coreclr/vm/wasm/generate-coreclr-helpers.md
new file mode 100644
index 00000000000000..d0d15105b859e5
--- /dev/null
+++ b/src/coreclr/vm/wasm/generate-coreclr-helpers.md
@@ -0,0 +1,104 @@
+# Generating CoreCLR WebAssembly call helpers
+
+The `generate-coreclr-helpers.cmd` (Windows) and `generate-coreclr-helpers.sh` (Linux/macOS)
+scripts in this directory regenerate the checked-in CoreCLR call-helper source files used by the
+WebAssembly runtime. They parse their arguments and hand the work to
+`generate-coreclr-helpers.proj` next to them, which runs crossgen2 in
+`--generate-portable-callhelpers` mode over the managed framework assemblies to emit the native
+P/Invoke, reverse-P/Invoke, and interpreter-to-managed call helpers. The generator lives in
+[`ILCompiler.ReadyToRun/PortableCallHelpers`](../../tools/aot/ILCompiler.ReadyToRun/PortableCallHelpers) so it can use crossgen2's
+type system to compute the wasm ABI layout of the structs that cross the boundary.
+
+Keeping the scan paths, the crossgen2 lookup and the module list in the project rather than in the
+scripts means they are stated once instead of once per shell language.
+
+Each run leaves the exact generator invocation in a response file under
+`artifacts/obj/wasm-callhelpers/<target os>/generate-coreclr-helpers.rsp`, which is the first thing
+to look at when a regenerated table is not what was expected.
+
+The relink targets for browser and wasi apps run the same crossgen2 mode over the app's own
+assembly closure, so these checked-in files and a relinked app are produced by one code path.
+
+The scripts generate **both** WebAssembly variations:
+
+| Target OS | Output directory                | Default scan path (testhost) |
+|-----------|---------------------------------|------------------------------|
+| `browser` | `src/coreclr/vm/wasm/browser/`  | `artifacts/bin/testhost/net11.0-browser-<config>-wasm/shared/Microsoft.NETCore.App/11.0.0/` |
+| `wasi`    | `src/coreclr/vm/wasm/wasi/`     | `artifacts/bin/testhost/net11.0-wasi-<config>-wasm/shared/Microsoft.NETCore.App/11.0.0/` |
+
+Each run emits three files into the output directory:
+
+- `callhelpers-pinvoke.cpp`
+- `callhelpers-reverse.cpp`
+- `callhelpers-interp-to-managed.cpp`
+
+## The P/Invoke module list
+
+Only the framework native libraries the runtime links statically get an entry in the generated
+P/Invoke table. `generate-coreclr-helpers.proj` imports that list from
+[`eng/wasm/WasmPInvokeModules.props`](../../../../eng/wasm/WasmPInvokeModules.props), which
+`CLRTest.WasmCorerun.targets` imports too when it links a test-specific corerun, so the checked-in
+tables and the tests' own cannot be edited apart.
+
+`BrowserWasmApp.CoreCLR.targets` keeps a copy of the list on purpose: it ships in the WebAssembly
+workload and is evaluated inside the user's SDK, where the props file does not exist. That copy has
+to be updated alongside the props file.
+
+Adding a module means editing both, rerunning these scripts, and committing the regenerated files
+in the same change. A module missing from one of them surfaces as a `DllNotFoundException` at run
+time rather than as a build failure.
+
+## What needs to be built first
+
+The generator scans the **managed framework assemblies** in the `testhost` folder produced by a
+`clr+libs` build, and runs the self-contained crossgen2 that the same build produces. Because the
+scripts generate both the `browser` and `wasi` variations, you must build **both** WebAssembly
+flavors before running them. The first build of either flavor also downloads and
+provisions the Emscripten SDK (emsdk) automatically.
+
+From the repository root:
+
+**Windows:**
+```cmd
+.\build.cmd clr+libs -os browser -c Debug
+.\build.cmd clr+libs -os wasi    -c Debug
+```
+
+**Linux/macOS:**
+```bash
+./build.sh clr+libs -os browser -c Debug
+./build.sh clr+libs -os wasi    -c Debug
+```
+
+Notes:
+
+- Use a matching `-c <Debug|Release|Checked>` for the configuration you intend to pass to the
+  generator script (the script derives the scan path from the configuration name).
+- If a required `testhost` scan path or crossgen2 is missing, the script stops and prints the
+  exact `build` command needed to produce it.
+
+## Running the generator
+
+Once both flavors are built, run the script from anywhere (it resolves the repo root itself):
+
+**Windows:**
+```cmd
+src\coreclr\vm\wasm\generate-coreclr-helpers.cmd -c Debug
+```
+
+**Linux/macOS:**
+```bash
+src/coreclr/vm/wasm/generate-coreclr-helpers.sh -c Debug
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `-c`, `--configuration <Checked\|Debug\|Release>` | Build configuration (default: `Debug`). Determines the default scan paths. |
+| `-s`, `--scan-path <path>` | Override the default **browser** scan path. |
+| `-w`, `--wasi-scan-path <path>` | Override the default **wasi** scan path. |
+| `-h`, `--help` | Show usage. |
+
+After running, review and commit any changes to the generated files under
+`src/coreclr/vm/wasm/browser/` and `src/coreclr/vm/wasm/wasi/`.
diff --git a/src/coreclr/vm/wasm/generate-coreclr-helpers.proj b/src/coreclr/vm/wasm/generate-coreclr-helpers.proj
new file mode 100644
index 00000000000000..673be4e12e67bc
--- /dev/null
+++ b/src/coreclr/vm/wasm/generate-coreclr-helpers.proj
@@ -0,0 +1,143 @@
+<!--
+  Regenerates the checked-in CoreCLR WebAssembly call helpers under this directory.
+
+  Driven by generate-coreclr-helpers.sh / .cmd, which only parse arguments and hand the work
+  here, so the module list, the crossgen2 lookup and the scan paths are expressed once instead
+  of once per shell language. See generate-coreclr-helpers.md.
+
+  Properties:
+    Configuration     Debug (default), Release or Checked. Has to match the configuration the
+                      scanned assemblies were built in.
+    BrowserScanPath   Overrides the browser scan path.
+    WasiScanPath      Overrides the wasi scan path.
+-->
+<Project Sdk="Microsoft.Build.NoTargets">
+
+  <PropertyGroup>
+    <TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
+  </PropertyGroup>
+
+  <!-- The framework P/Invoke modules, shared with the runtime tests' corerun relink so the
+       checked-in tables and the ones the tests generate cannot drift apart. -->
+  <Import Project="$(RepositoryEngineeringDir)wasm\WasmPInvokeModules.props" />
+
+  <PropertyGroup>
+    <_TesthostDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'testhost'))</_TesthostDir>
+    <_FrameworkVersion>$(MajorVersion).$(MinorVersion).0</_FrameworkVersion>
+
+    <!-- The scripts that drive this project are per-OS, so name the one for the current OS. -->
+    <_BuildScript Condition="$([MSBuild]::IsOSPlatform('Windows'))">.\build.cmd</_BuildScript>
+    <_BuildScript Condition="'$(_BuildScript)' == ''">./build.sh</_BuildScript>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <_WasmCallHelperTarget Include="browser">
+      <ScanPath Condition="'$(BrowserScanPath)' != ''">$([MSBuild]::EnsureTrailingSlash('$(BrowserScanPath)'))</ScanPath>
+      <ScanPath Condition="'$(BrowserScanPath)' == ''">$(_TesthostDir)$(NetCoreAppCurrent)-browser-$(Configuration)-wasm/shared/Microsoft.NETCore.App/$(_FrameworkVersion)/</ScanPath>
+    </_WasmCallHelperTarget>
+    <_WasmCallHelperTarget Include="wasi">
+      <ScanPath Condition="'$(WasiScanPath)' != ''">$([MSBuild]::EnsureTrailingSlash('$(WasiScanPath)'))</ScanPath>
+      <ScanPath Condition="'$(WasiScanPath)' == ''">$(_TesthostDir)$(NetCoreAppCurrent)-wasi-$(Configuration)-wasm/shared/Microsoft.NETCore.App/$(_FrameworkVersion)/</ScanPath>
+    </_WasmCallHelperTarget>
+  </ItemGroup>
+
+  <!-- The generator leaves its output unstamped: run over a user application it would be writing a
+       file full of names taken from that application, which are not ours to license. The copies
+       checked in here are ours, so the regeneration path stamps them on the way out of staging.
+       Writing only on a real change keeps the timestamp the generator's own WriteIfDifferent was
+       protecting, so regenerating an unchanged table does not retrigger the native build. -->
+  <UsingTask TaskName="WriteWithLicenseHeader"
+             TaskFactory="RoslynCodeTaskFactory"
+             AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
+    <ParameterGroup>
+      <Files ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
+      <DestinationFolder ParameterType="System.String" Required="true" />
+    </ParameterGroup>
+    <Task>
+      <Using Namespace="System" />
+      <Using Namespace="System.IO" />
+      <Code Type="Fragment" Language="cs">
+        <![CDATA[
+        foreach (ITaskItem file in Files)
+        {
+            string text = File.ReadAllText(file.ItemSpec);
+            string newLine = text.Contains("\r\n") ? "\r\n" : "\n";
+            string content =
+                "// Licensed to the .NET Foundation under one or more agreements." + newLine +
+                "// The .NET Foundation licenses this file to you under the MIT license." + newLine +
+                "//" + newLine + newLine + text;
+
+            string destination = Path.Combine(DestinationFolder, Path.GetFileName(file.ItemSpec));
+            if (File.Exists(destination) && File.ReadAllText(destination) == content)
+            {
+                continue;
+            }
+
+            Log.LogMessage(MessageImportance.High, "Writing {0}", destination);
+            File.WriteAllText(destination, content);
+        }
+        ]]>
+      </Code>
+    </Task>
+  </UsingTask>
+
+  <!-- Batched over _WasmCallHelperTarget: one crossgen2 run per wasm flavor. -->
+  <Target Name="GenerateCallHelpers" Outputs="%(_WasmCallHelperTarget.Identity)">
+    <PropertyGroup>
+      <_TargetOS>%(_WasmCallHelperTarget.Identity)</_TargetOS>
+      <_ScanPath>%(_WasmCallHelperTarget.ScanPath)</_ScanPath>
+      <!-- The self-contained crossgen2 from the same per-flavor build output that produced the
+           scan path. -->
+      <_Crossgen2Path>$([MSBuild]::NormalizePath('$(ArtifactsBinDir)', 'coreclr', '$(_TargetOS).wasm.$(Configuration)', '$(BuildArchitecture)', 'crossgen2', 'crossgen2$(ExeSuffix)'))</_Crossgen2Path>
+      <_OutputDir>$(MSBuildThisFileDirectory)$(_TargetOS)/</_OutputDir>
+      <_ResponseFileDir>$([MSBuild]::NormalizeDirectory('$(ArtifactsObjDir)', 'wasm-callhelpers', '$(_TargetOS)'))</_ResponseFileDir>
+      <_ResponseFile>$(_ResponseFileDir)generate-coreclr-helpers.rsp</_ResponseFile>
+      <_StagingDir>$(_ResponseFileDir)generated/</_StagingDir>
+    </PropertyGroup>
+
+    <Error Condition="!Exists('$(_Crossgen2Path)')"
+           Text="crossgen2 was not found at $(_Crossgen2Path). Build the runtime first: $(_BuildScript) clr+libs -os $(_TargetOS) -c $(Configuration)" />
+    <Error Condition="!Exists('$(_ScanPath)')"
+           Text="Scan path for $(_TargetOS) does not exist: $(_ScanPath). Build the runtime first: $(_BuildScript) clr+libs -os $(_TargetOS) -c $(Configuration)" />
+    <Error Condition="'@(WasmCoreClrFrameworkPInvokeModule)' == ''"
+           Text="No WasmCoreClrFrameworkPInvokeModule entries were found in $(RepositoryEngineeringDir)wasm/WasmPInvokeModules.props." />
+
+    <Message Importance="High" Text="[$(_TargetOS)] Scan path: $(_ScanPath)" />
+    <Message Importance="High" Text="[$(_TargetOS)] Output path: $(_OutputDir)" />
+
+    <RemoveDir Directories="$(_StagingDir)" />
+    <MakeDir Directories="$(_OutputDir);$(_ResponseFileDir);$(_StagingDir)" />
+
+    <ItemGroup>
+      <_ScanAssembly Remove="@(_ScanAssembly)" />
+      <_ScanAssembly Include="$(_ScanPath)*.dll" />
+    </ItemGroup>
+
+    <Error Condition="'@(_ScanAssembly)' == ''"
+           Text="No assemblies to scan were found in $(_ScanPath)." />
+
+    <ItemGroup>
+      <_GeneratorArg Remove="@(_GeneratorArg)" />
+      <_GeneratorArg Include="--targetos:$(_TargetOS)" />
+      <_GeneratorArg Include="--targetarch:wasm" />
+      <_GeneratorArg Include="--generate-portable-callhelpers:$(_StagingDir)" />
+      <_GeneratorArg Include="@(WasmCoreClrFrameworkPInvokeModule->'--directpinvoke:%(Identity)')" />
+      <_GeneratorArg Include="@(_ScanAssembly->'%(FullPath)')" />
+    </ItemGroup>
+
+    <WriteLinesToFile File="$(_ResponseFile)" Lines="@(_GeneratorArg)" Overwrite="true" WriteOnlyWhenDifferent="true" />
+
+    <Exec Command="&quot;$(_Crossgen2Path)&quot; &quot;@$(_ResponseFile)&quot;"
+          WorkingDirectory="$(RepoRoot)" />
+
+    <ItemGroup>
+      <_StagedCallHelper Remove="@(_StagedCallHelper)" />
+      <_StagedCallHelper Include="$(_StagingDir)*.cpp" />
+    </ItemGroup>
+
+    <Error Condition="'@(_StagedCallHelper)' == ''" Text="The generator produced no files in $(_StagingDir)." />
+
+    <WriteWithLicenseHeader Files="@(_StagedCallHelper)" DestinationFolder="$(_OutputDir)" />
+  </Target>
+
+</Project>
diff --git a/src/tasks/WasmAppBuilder/generate-coreclr-helpers.sh b/src/coreclr/vm/wasm/generate-coreclr-helpers.sh
similarity index 50%
rename from src/tasks/WasmAppBuilder/generate-coreclr-helpers.sh
rename to src/coreclr/vm/wasm/generate-coreclr-helpers.sh
index 917b737b0a83a6..c45bf9f729eda6 100755
--- a/src/tasks/WasmAppBuilder/generate-coreclr-helpers.sh
+++ b/src/coreclr/vm/wasm/generate-coreclr-helpers.sh
@@ -53,49 +53,31 @@ case "$config_lower" in
         ;;
 esac
 
-# Get the repo root (script is in src/tasks/WasmAppBuilder)
+# Get the repo root (script is in src/coreclr/vm/wasm)
 script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-repo_root="$(cd "$script_dir/../../.." && pwd)"
+repo_root="$(cd "$script_dir/../../../.." && pwd)"
 
 echo "Configuration: $configuration"
 echo "Repo root: $repo_root"
 
 cd "$repo_root"
 
-# Run the generator for a given target OS.
-# Arguments: <target_os> <scan_path> <output_dir>
-run_generator() {
-    local target_os="$1"
-    local scan_path="$2"
-    local output_dir="$3"
+# The scan paths, the crossgen2 lookup and the P/Invoke module list all live in the project next
+# to this script, so they are not restated here and in the .cmd.
+args=(
+    build "$script_dir/generate-coreclr-helpers.proj"
+    -t:GenerateCallHelpers
+    "-p:Configuration=$configuration"
+)
 
-    if [[ ! -d "$scan_path" ]]; then
-        echo "Error: Scan path for $target_os does not exist: $scan_path"
-        echo "Please build the runtime first using: ./build.sh clr+libs -os $target_os -c $configuration"
-        exit 1
-    fi
-
-    echo "[$target_os] Scan path: $scan_path"
-    echo "[$target_os] Output path: $output_dir"
-    echo "Running generator for $target_os..."
-    echo "./dotnet.sh build /t:RunGenerator /p:RuntimeFlavor=CoreCLR /p:TargetOS=$target_os /p:GeneratorOutputPath=$output_dir /p:AssembliesScanPath=$scan_path src/tasks/WasmAppBuilder/WasmAppBuilder.csproj"
-    ./dotnet.sh build /t:RunGenerator /p:RuntimeFlavor=CoreCLR "/p:TargetOS=$target_os" "/p:GeneratorOutputPath=$output_dir" "/p:AssembliesScanPath=$scan_path" src/tasks/WasmAppBuilder/WasmAppBuilder.csproj
-}
-
-# Resolve scan paths (allow overrides).
 if [[ -n "$browser_scan_path_override" ]]; then
-    browser_scan_path="$browser_scan_path_override"
-else
-    browser_scan_path="$repo_root/artifacts/bin/testhost/net11.0-browser-$configuration-wasm/shared/Microsoft.NETCore.App/11.0.0/"
+    args+=("-p:BrowserScanPath=$browser_scan_path_override")
 fi
 
 if [[ -n "$wasi_scan_path_override" ]]; then
-    wasi_scan_path="$wasi_scan_path_override"
-else
-    wasi_scan_path="$repo_root/artifacts/bin/testhost/net11.0-wasi-$configuration-wasm/shared/Microsoft.NETCore.App/11.0.0/"
+    args+=("-p:WasiScanPath=$wasi_scan_path_override")
 fi
 
-run_generator "browser" "$browser_scan_path" "$repo_root/src/coreclr/vm/wasm/browser/"
-run_generator "wasi" "$wasi_scan_path" "$repo_root/src/coreclr/vm/wasm/wasi/"
+./dotnet.sh "${args[@]}"
 
 echo "Done!"
diff --git a/src/coreclr/vm/wasm/helpers.cpp b/src/coreclr/vm/wasm/helpers.cpp
index 518d763325a4d2..2774fd7b126c92 100644
--- a/src/coreclr/vm/wasm/helpers.cpp
+++ b/src/coreclr/vm/wasm/helpers.cpp
@@ -1065,15 +1065,15 @@ namespace
         return pos;
     }
 
-    typedef StringToThunkHash StringToWasmSigThunkHash;
-    static StringToWasmSigThunkHash* thunkCache = nullptr;
+    typedef StringToThunkHash StringToPortableSigThunkHash;
+    static StringToPortableSigThunkHash* thunkCache = nullptr;
 
-    // The fixed set of interpreter->native thunks compiled into libcoreclr (g_wasmThunks). It covers the
+    // The fixed set of interpreter->native thunks compiled into libcoreclr (g_portableCallHelperThunks). It covers the
     // runtime's own interp->native calls - FCall/QCall/pinvoke and other runtime-native managed methods,
     // plus unmanaged calli. crossgen2 does not emit these.
     static InterpreterCalliCookie LookupThunkInLibcoreclr(const char* key)
     {
-        StringToWasmSigThunkHash* table = thunkCache;
+        StringToPortableSigThunkHash* table = thunkCache;
         _ASSERTE(table != nullptr && "Wasm thunk cache not initialized. Call InitializeWasmThunkCaches() at EEStartup.");
         void* thunk;
         if (table->Lookup(key, &thunk))
@@ -1084,7 +1084,7 @@ namespace
 
     // For a managed method the interp->R2R thunk is emitted into the R2R image by crossgen2
     // (WasmInterpreterToR2RThunkNode, keyed "M"+signature) for every R2R-compiled method body. Prefer that
-    // image (the common case with R2R), then fall back to g_wasmThunks, which is the only source for managed
+    // image (the common case with R2R), then fall back to g_portableCallHelperThunks, which is the only source for managed
     // methods whose native code is not R2R (FCall/QCall/pinvoke/runtime stubs).
     static InterpreterCalliCookie LookupManagedThunk(const char* key)
     {
@@ -1137,8 +1137,8 @@ namespace
                 return NULL;
         }
 
-        // Managed methods (default calling convention) prefer the R2R image and fall back to g_wasmThunks;
-        // unmanaged calli are only ever in g_wasmThunks.
+        // Managed methods (default calling convention) prefer the R2R image and fall back to g_portableCallHelperThunks;
+        // unmanaged calli are only ever in g_portableCallHelperThunks.
         InterpreterCalliCookie thunk = (callConv == IMAGE_CEE_CS_CALLCONV_DEFAULT)
             ? LookupManagedThunk(keyBuffer)
             : LookupThunkInLibcoreclr(keyBuffer);
@@ -1292,11 +1292,11 @@ namespace
 void InitializeWasmThunkCaches()
 {
     {
-        StringToWasmSigThunkHash* newTable = new StringToWasmSigThunkHash();
-        newTable->Reallocate(g_wasmThunksCount * StringToWasmSigThunkHash::s_density_factor_denominator / StringToWasmSigThunkHash::s_density_factor_numerator + 1);
-        for (size_t i = 0; i < g_wasmThunksCount; i++)
+        StringToPortableSigThunkHash* newTable = new StringToPortableSigThunkHash();
+        newTable->Reallocate(g_portableCallHelperThunksCount * StringToPortableSigThunkHash::s_density_factor_denominator / StringToPortableSigThunkHash::s_density_factor_numerator + 1);
+        for (size_t i = 0; i < g_portableCallHelperThunksCount; i++)
         {
-            newTable->Add(g_wasmThunks[i].key, g_wasmThunks[i].value);
+            newTable->Add(g_portableCallHelperThunks[i].key, g_portableCallHelperThunks[i].value);
         }
         thunkCache = newTable;
     }
diff --git a/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp b/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp
index 56f77515c21288..03e37ec1bdc4d5 100644
--- a/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp
+++ b/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp
@@ -550,7 +550,7 @@ namespace
     }
 }
 
-const StringToWasmSigThunk g_wasmThunks[] = {
+const StringToPortableSigThunk g_portableCallHelperThunks[] = {
     { "Mddddp", (void*)&CallFunc_F64_F64_F64_RetF64_PE },
     { "Mdddp", (void*)&CallFunc_F64_F64_RetF64_PE },
     { "Mddip", (void*)&CallFunc_F64_I32_RetF64_PE },
@@ -633,4 +633,4 @@ const StringToWasmSigThunk g_wasmThunks[] = {
     { "Mvp", (void*)&CallFunc_Void_RetVoid_PE }
 };
 
-const size_t g_wasmThunksCount = sizeof(g_wasmThunks) / sizeof(g_wasmThunks[0]);
+const size_t g_portableCallHelperThunksCount = sizeof(g_portableCallHelperThunks) / sizeof(g_portableCallHelperThunks[0]);
diff --git a/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp b/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp
index 89b992b77aae8f..3dceaa7de8574b 100644
--- a/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp
+++ b/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp
@@ -346,7 +346,7 @@ static const Entry s_libSystem_Native [] = {
     DllImportEntry(SystemNative_GetCryptographicallySecureRandomBytes) // System.IO.Compression
     DllImportEntry(SystemNative_GetCwd) // System.Private.CoreLib
     DllImportEntry(SystemNative_GetDefaultSearchOrderPseudoHandle) // System.Private.CoreLib
-    DllImportEntry(SystemNative_GetErrNo) // System.Net.NameResolution, System.Private.CoreLib
+    DllImportEntry(SystemNative_GetErrNo) // System.Private.CoreLib
     DllImportEntry(SystemNative_GetHostEntryForName) // System.Net.NameResolution
     DllImportEntry(SystemNative_GetHostName) // System.Net.NameResolution
     DllImportEntry(SystemNative_GetIPv4Address) // System.Net.Primitives, System.Net.Sockets
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Crossgen2/Sdk.props b/src/installer/pkg/sfx/Microsoft.NETCore.App/Crossgen2/Sdk.props
new file mode 100644
index 00000000000000..a5cdb6c55a638d
--- /dev/null
+++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Crossgen2/Sdk.props
@@ -0,0 +1,18 @@
+<Project>
+  <!--
+    Shipped inside the crossgen2 tool pack as Sdk/Sdk.props, so that a workload can acquire the pack
+    and locate the tool with an MSBuild Sdk import.
+
+    The SDK's own ReadyToRun path does not need this: it downloads the pack itself and computes the
+    tool path in ResolveReadyToRunCompilers. Workloads that want crossgen2 for something other than
+    compiling ReadyToRun images have no such mechanism, because the pack is only ever resolved when
+    PublishReadyToRun is set.
+
+    The pack is host-specific and is selected by the workload resolver from the host RID, so the
+    executable suffix follows the machine that restored it.
+  -->
+  <PropertyGroup>
+    <_Crossgen2PackExeSuffix Condition="$([MSBuild]::IsOSPlatform('Windows'))">.exe</_Crossgen2PackExeSuffix>
+    <Crossgen2ToolPath Condition="'$(Crossgen2ToolPath)' == ''">$([MSBuild]::NormalizePath('$(MSBuildThisFileDirectory)', '..', 'tools', 'crossgen2$(_Crossgen2PackExeSuffix)'))</Crossgen2ToolPath>
+  </PropertyGroup>
+</Project>
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Crossgen2.props b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Crossgen2.props
index a400c42adf25c7..cdec0b7f158ee7 100644
--- a/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Crossgen2.props
+++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Crossgen2.props
@@ -18,6 +18,10 @@
       Include="$(CrossgenPublishProject)"
       OutputItemType="_RawCrossgenPublishFiles"
       ReferenceOutputAssembly="false" />
+
+    <!-- Lets a workload acquire this pack and find the tool with an MSBuild Sdk import. -->
+    <FilesToPackage Include="$(MSBuildThisFileDirectory)Crossgen2\Sdk.props"
+                    TargetPath="Sdk/" />
   </ItemGroup>
 
   <Target Name="PublishCrossgen"
diff --git a/src/libraries/System.Diagnostics.Tracing/tests/System.Diagnostics.Tracing.Tests.csproj b/src/libraries/System.Diagnostics.Tracing/tests/System.Diagnostics.Tracing.Tests.csproj
index 1789b2304a360f..85df35f6731827 100644
--- a/src/libraries/System.Diagnostics.Tracing/tests/System.Diagnostics.Tracing.Tests.csproj
+++ b/src/libraries/System.Diagnostics.Tracing/tests/System.Diagnostics.Tracing.Tests.csproj
@@ -8,7 +8,6 @@
     <!-- https://github.com/dotnet/runtime/issues/126862 -->
     <EnableTrimAnalyzer>false</EnableTrimAnalyzer>
     <TargetPlatformIdentifier>$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)'))</TargetPlatformIdentifier>
-    <NoWarn>$(NoWarn);WASM0066</NoWarn>
   </PropertyGroup>
   <PropertyGroup Condition="'$(TargetPlatformIdentifier)' == 'browser'">
     <!-- this is necessary for libmono-component-diagnostics_tracing-static.a to be linked, which makes the EventPipeEventProvider.EventActivityIdControl to work in Mono -->
diff --git a/src/libraries/System.Runtime/tests/System.Globalization.Tests/Invariant/Invariant.Tests.csproj b/src/libraries/System.Runtime/tests/System.Globalization.Tests/Invariant/Invariant.Tests.csproj
index be22e2a7dd3ad0..7d444810c694cd 100644
--- a/src/libraries/System.Runtime/tests/System.Globalization.Tests/Invariant/Invariant.Tests.csproj
+++ b/src/libraries/System.Runtime/tests/System.Globalization.Tests/Invariant/Invariant.Tests.csproj
@@ -4,7 +4,6 @@
     <TestRuntime>true</TestRuntime>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <InvariantGlobalization>true</InvariantGlobalization>
-    <WasmWarnOnUnresolvedPInvokeModules>false</WasmWarnOnUnresolvedPInvokeModules>
     <PredefinedCulturesOnly>false</PredefinedCulturesOnly>
   </PropertyGroup>
   <ItemGroup>
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/InvariantTimezone/System.Runtime.InvariantTimezone.Tests.csproj b/src/libraries/System.Runtime/tests/System.Runtime.Tests/InvariantTimezone/System.Runtime.InvariantTimezone.Tests.csproj
index a267620d5b7cd0..dda813137d5bcb 100644
--- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/InvariantTimezone/System.Runtime.InvariantTimezone.Tests.csproj
+++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/InvariantTimezone/System.Runtime.InvariantTimezone.Tests.csproj
@@ -7,7 +7,6 @@
     <TestRuntime>true</TestRuntime>
     <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
     <InvariantTimezone>true</InvariantTimezone>
-    <WasmWarnOnUnresolvedPInvokeModules>false</WasmWarnOnUnresolvedPInvokeModules>
   </PropertyGroup>
 
   <PropertyGroup>
diff --git a/src/mono/browser/build/BrowserWasmApp.CoreCLR.targets b/src/mono/browser/build/BrowserWasmApp.CoreCLR.targets
index 18033bb3e0c2b3..98360e93f59bb4 100644
--- a/src/mono/browser/build/BrowserWasmApp.CoreCLR.targets
+++ b/src/mono/browser/build/BrowserWasmApp.CoreCLR.targets
@@ -31,7 +31,6 @@
     <WasmEnableExceptionHandling>true</WasmEnableExceptionHandling>
     <WasmEnableSIMD>true</WasmEnableSIMD>
     <WasmClang>emcc</WasmClang>
-    <WasmWarnOnUnresolvedPInvokeModules Condition="'$(WasmWarnOnUnresolvedPInvokeModules)' == ''">true</WasmWarnOnUnresolvedPInvokeModules>
 
     <_WasmDefaultFlags>-fwasm-exceptions -sWASM_LEGACY_EXCEPTIONS=0 -msimd128</_WasmDefaultFlags>
 
@@ -95,7 +94,7 @@
              AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)"
              TaskFactory="TaskHostFactory"
              Condition="'$(WasmAppBuilderTasksAssemblyPath)' != ''" />
-  <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.CoreClr.ManagedToNativeGenerator"
+  <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.FilterManagedAssemblies"
              AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)"
              TaskFactory="TaskHostFactory"
              Condition="'$(WasmAppBuilderTasksAssemblyPath)' != ''" />
@@ -590,7 +589,7 @@
       <_EmccCFlags Include="$(EmccExtraCFlags)" />
     </ItemGroup>
 
-    <!-- Compile flags for ManagedToNativeGenerator output (callhelpers-pinvoke.cpp,
+    <!-- Compile flags for the generated interop helpers (callhelpers-pinvoke.cpp,
          callhelpers-interp-to-managed.cpp). The generated files #include the real CoreCLR
          headers (<callhelpers.hpp>, <minipal/entrypoints.h>, <minipal/utils.h>).
          Force-include coreclr_compat.h to provide the prerequisite types/macros
@@ -642,9 +641,6 @@
       <_WasmPInvokeTablePath>$(_WasmIntermediateOutputPath)callhelpers-pinvoke.cpp</_WasmPInvokeTablePath>
       <_WasmReversePInvokeTablePath>$(_WasmIntermediateOutputPath)callhelpers-reverse.cpp</_WasmReversePInvokeTablePath>
       <_WasmInterpToNativeTablePath>$(_WasmIntermediateOutputPath)callhelpers-interp-to-managed.cpp</_WasmInterpToNativeTablePath>
-      <_WasmM2NCachePath>$(_WasmIntermediateOutputPath)m2n_cache.txt</_WasmM2NCachePath>
-      <_IsLibraryMode Condition="'$(OutputType)' == 'Library'">true</_IsLibraryMode>
-      <_IsLibraryMode Condition="'$(_IsLibraryMode)' == ''">false</_IsLibraryMode>
     </PropertyGroup>
 
     <!-- P/Invoke modules: user native libraries + system native libraries -->
@@ -654,25 +650,31 @@
       <_WasmPInvokeModules Include="libSystem.Native" />
       <_WasmPInvokeModules Include="libSystem.IO.Compression.Native" />
       <_WasmPInvokeModules Include="libSystem.Globalization.Native" Condition="'$(InvariantGlobalization)' != 'true'" />
-      <_WasmIgnoredPInvokeModules Include="libSystem.Globalization.Native" Condition="'$(InvariantGlobalization)' == 'true'" />
       <_WasmPInvokeModules Include="libSystem.Native.Browser" />
       <_WasmPInvokeModules Include="libSystem.Runtime.InteropServices.JavaScript.Native" />
     </ItemGroup>
 
-    <!-- Managed assemblies to scan -->
+    <!-- Managed assemblies to scan. An app bundle legitimately carries native payloads named .dll -
+         per-architecture content shipped by a NuGet package is the usual case - and the generator
+         reads managed metadata, so narrow the list before handing it over. -->
     <ItemGroup>
-      <_WasmManagedAssemblies Include="@(WasmAssembliesToBundle->Distinct())" />
+      <_WasmBundledFile Include="@(WasmAssembliesToBundle->Distinct())" />
     </ItemGroup>
 
     <!-- With R2R the published .dll are webcil-in-wasm images MetadataLoadContext can't parse; scan the
          trimmed IL (same closure crossgen used) instead. Gated on the linker dir only, because the nested
-         WasmNestedPublishApp build where this runs doesn't carry PublishReadyToRun. -->
+         WasmNestedPublishApp build where this runs doesn't carry PublishReadyToRun. Remapped ahead of the
+         filter below, which reads PE headers and cannot make sense of webcil either. -->
     <ItemGroup Condition="'$(IntermediateLinkDir)' != ''">
-      <_WasmManagedAssembliesR2RRemap Include="@(_WasmManagedAssemblies)" Condition="Exists('$(IntermediateLinkDir)%(FileName)%(Extension)')" />
-      <_WasmManagedAssemblies Remove="@(_WasmManagedAssembliesR2RRemap)" />
-      <_WasmManagedAssemblies Include="@(_WasmManagedAssembliesR2RRemap->'$(IntermediateLinkDir)%(FileName)%(Extension)')" />
+      <_WasmBundledFileR2RRemap Include="@(_WasmBundledFile)" Condition="Exists('$(IntermediateLinkDir)%(FileName)%(Extension)')" />
+      <_WasmBundledFile Remove="@(_WasmBundledFileR2RRemap)" />
+      <_WasmBundledFile Include="@(_WasmBundledFileR2RRemap->'$(IntermediateLinkDir)%(FileName)%(Extension)')" />
     </ItemGroup>
 
+    <FilterManagedAssemblies Assemblies="@(_WasmBundledFile)">
+      <Output TaskParameter="ManagedAssemblies" ItemName="_WasmManagedAssemblies" />
+    </FilterManagedAssemblies>
+
     <!-- Locate System.Private.CoreLib in runtime pack if not already bundled -->
     <PropertyGroup>
       <_HasCoreLib Condition="'%(_WasmManagedAssemblies.FileName)%(_WasmManagedAssemblies.Extension)' == 'System.Private.CoreLib.dll'">true</_HasCoreLib>
@@ -688,19 +690,41 @@
       <_WasmManagedAssemblies Include="$(_CoreLibPath)" />
     </ItemGroup>
 
-    <ManagedToNativeGenerator
-      Assemblies="@(_WasmManagedAssemblies)"
-      PInvokeModules="@(_WasmPInvokeModules)"
-      IgnoredPInvokeModules="@(_WasmIgnoredPInvokeModules)"
-      PInvokeOutputPath="$(_WasmPInvokeTablePath)"
-      ReversePInvokeOutputPath="$(_WasmReversePInvokeTablePath)"
-      InterpToNativeOutputPath="$(_WasmInterpToNativeTablePath)"
-      CacheFilePath="$(_WasmM2NCachePath)"
-      TargetOS="browser"
-      WarnOnUnresolvedPInvokeModules="$(WasmWarnOnUnresolvedPInvokeModules)"
-      IsLibraryMode="$(_IsLibraryMode)">
-      <Output TaskParameter="FileWrites" ItemName="FileWrites" />
-    </ManagedToNativeGenerator>
+    <!-- crossgen2 has the type system that knows the wasm ABI, so it generates the helpers itself.
+         In the repo it comes from the build output; outside it, from the crossgen2 pack
+         the wasm-tools workload acquires, which sets $(Crossgen2ToolPath) from its Sdk.props. -->
+    <PropertyGroup>
+      <_PortableCallHelpersGeneratorExeSuffix Condition="'$(OS)' == 'Windows_NT'">.exe</_PortableCallHelpersGeneratorExeSuffix>
+      <PortableCallHelpersGeneratorPath Condition="'$(PortableCallHelpersGeneratorPath)' == '' and '$(Crossgen2InBuildDir)' != ''">$([MSBuild]::NormalizePath('$(Crossgen2InBuildDir)', 'crossgen2$(_PortableCallHelpersGeneratorExeSuffix)'))</PortableCallHelpersGeneratorPath>
+      <PortableCallHelpersGeneratorPath Condition="'$(PortableCallHelpersGeneratorPath)' == ''">$(Crossgen2ToolPath)</PortableCallHelpersGeneratorPath>
+    </PropertyGroup>
+
+    <Error Condition="'$(PortableCallHelpersGeneratorPath)' == ''"
+           Text="crossgen2 was not found, so the portable call helpers cannot be generated. Install the 'wasm-tools' workload, or set %24(PortableCallHelpersGeneratorPath) to a crossgen2 executable." />
+    <Error Condition="'$([System.IO.Path]::GetExtension(`$(PortableCallHelpersGeneratorPath)`))' == '.dll'"
+           Text="%24(PortableCallHelpersGeneratorPath) is '$(PortableCallHelpersGeneratorPath)'. It has to name a crossgen2 executable; an IL assembly cannot be launched directly." />
+    <Error Condition="!Exists('$(PortableCallHelpersGeneratorPath)')"
+           Text="%24(PortableCallHelpersGeneratorPath) is '$(PortableCallHelpersGeneratorPath)', which does not exist. In the repo, build crossgen2 first; outside it, install the 'wasm-tools' workload." />
+
+    <PropertyGroup>
+      <_PortableCallHelpersGeneratorRsp>$(_WasmIntermediateOutputPath)callhelpers-generator.rsp</_PortableCallHelpersGeneratorRsp>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <_PortableCallHelpersGeneratorArg Include="--targetos:browser" />
+      <_PortableCallHelpersGeneratorArg Include="--targetarch:wasm" />
+      <_PortableCallHelpersGeneratorArg Include="--generate-portable-callhelpers:$(_WasmIntermediateOutputPath)" />
+      <_PortableCallHelpersGeneratorArg Include="@(_WasmPInvokeModules->'--directpinvoke:%(Identity)')" />
+      <_PortableCallHelpersGeneratorArg Include="@(_WasmManagedAssemblies->'%(FullPath)')" />
+    </ItemGroup>
+
+    <WriteLinesToFile File="$(_PortableCallHelpersGeneratorRsp)" Lines="@(_PortableCallHelpersGeneratorArg)" Overwrite="true" WriteOnlyWhenDifferent="true" />
+
+    <Exec Command="&quot;$(PortableCallHelpersGeneratorPath)&quot; &quot;@$(_PortableCallHelpersGeneratorRsp)&quot;" />
+
+    <ItemGroup>
+      <FileWrites Include="$(_PortableCallHelpersGeneratorRsp);$(_WasmPInvokeTablePath);$(_WasmReversePInvokeTablePath);$(_WasmInterpToNativeTablePath)" />
+    </ItemGroup>
 
     <ItemGroup>
       <_WasmSourceFileToCompileGenerated Remove="@(_WasmSourceFileToCompileGenerated)" />
@@ -747,7 +771,7 @@
       <Output TaskParameter="OutputFiles" ItemName="FileWrites" />
     </EmccCompile>
 
-    <!-- Compile generated ManagedToNativeGenerator output (force-includes coreclr_compat.h). -->
+    <!-- Compile the generated interop helpers (force-includes coreclr_compat.h). -->
     <EmccCompile
           Condition="@(_WasmSourceFileToCompileGenerated->Count()) > 0"
           SourceFiles="@(_WasmSourceFileToCompileGenerated)"
diff --git a/src/mono/browser/build/coreclr_compat.h b/src/mono/browser/build/coreclr_compat.h
index 6df79256285c80..551a2636eaa256 100644
--- a/src/mono/browser/build/coreclr_compat.h
+++ b/src/mono/browser/build/coreclr_compat.h
@@ -3,8 +3,8 @@
 
 // Auto-included CoreCLR compat header for app native build.
 //
-// This header is pre-included via -include when compiling pinvoke-table.cpp
-// and wasm_m2n_invoke.g.cpp produced by ManagedToNativeGenerator. It provides
+// This header is pre-included via -include when compiling the callhelpers-*.cpp
+// produced by crossgen2's portable call-helpers generator. It provides
 // only the prerequisite types/macros that the real CoreCLR headers
 // (<callhelpers.hpp>, <minipal/entrypoints.h>) assume are already in scope from
 // the in-tree CoreCLR PCH (vm/common.h). The generated .cpp files still
@@ -18,9 +18,9 @@
 //   * INTERP_STACK_SLOT_SIZE -- defined in interpretershared.h in-tree; the
 //     interp-to-managed file uses it but does not include that header.
 //   * LF_INTEROP/LL_INFO1000/LOG/PORTABILITY_ASSERT -- CoreCLR logging
-//     primitives used by pinvoke-table.cpp.
+//     primitives used by callhelpers-pinvoke.cpp.
 //
-// Definitions for symbols declared by <callhelpers.hpp> (g_wasmThunks,
+// Definitions for symbols declared by <callhelpers.hpp> (g_portableCallHelperThunks,
 // g_ReverseThunks, ...) live in libcoreclr_static.a or in the same generated
 // .cpp (the generator emits the table bodies).
 
diff --git a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.json.in b/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.json.in
index 7b600623e798d8..48286c531fca63 100644
--- a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.json.in
+++ b/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.json.in
@@ -11,7 +11,8 @@
         "Microsoft.NET.Sdk.WebAssembly.Pack.${NetVersion}",
         "Microsoft.NETCore.App.Runtime.Mono.${NetVersion}.browser-wasm",
         "Microsoft.NETCore.App.Runtime.${NetVersion}.browser-wasm",
-        "Microsoft.NETCore.App.Runtime.AOT.Cross.${NetVersion}.browser-wasm"
+        "Microsoft.NETCore.App.Runtime.AOT.Cross.${NetVersion}.browser-wasm",
+        "Microsoft.NETCore.App.Crossgen2.${NetVersion}"
       ],
       "extends": [ "microsoft-net-runtime-mono-tooling", "microsoft-net-sdk-emscripten" ],
       "platforms": [ "win-x64", "win-arm64", "linux-x64", "linux-arm64", "linux-musl-x64", "linux-musl-arm64", "osx-x64", "osx-arm64" ]
@@ -452,6 +453,20 @@
         "osx-arm64": "Microsoft.NETCore.App.Runtime.AOT.osx-arm64.Cross.wasi-wasm"
       }
     },
+    "Microsoft.NETCore.App.Crossgen2.${NetVersion}": {
+      "kind": "Sdk",
+      "version": "${PackageVersion}",
+      "alias-to": {
+        "win-x64": "Microsoft.NETCore.App.Crossgen2.win-x64",
+        "win-arm64": "Microsoft.NETCore.App.Crossgen2.win-arm64",
+        "linux-x64": "Microsoft.NETCore.App.Crossgen2.linux-x64",
+        "linux-arm64": "Microsoft.NETCore.App.Crossgen2.linux-arm64",
+        "linux-musl-x64": "Microsoft.NETCore.App.Crossgen2.linux-musl-x64",
+        "linux-musl-arm64": "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64",
+        "osx-x64": "Microsoft.NETCore.App.Crossgen2.osx-x64",
+        "osx-arm64": "Microsoft.NETCore.App.Crossgen2.osx-arm64"
+      }
+    },
     "Microsoft.NETCore.App.Runtime.Mono.${NetVersion}.browser-wasm" : {
       "kind": "framework",
       "version": "${PackageVersion}",
diff --git a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.targets.in b/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.targets.in
index ad0e43d11e1f6b..7420fab69354c2 100644
--- a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.targets.in
+++ b/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.targets.in
@@ -214,10 +214,16 @@
 
   <!-- CoreCLR browser-wasm: only needs the WebAssembly.Sdk (build targets + emscripten).
        No MonoTargets.Sdk, no MonoAOTCompiler, no AOT.Cross pack — the SDK resolves
-       the CoreCLR runtime pack and crossgen2 via its own KnownRuntimePack/KnownCrossgen2Pack. -->
+       the CoreCLR runtime pack via its own KnownRuntimePack.
+
+       crossgen2 is imported for its type system, not to compile ReadyToRun images: it generates the
+       wasm P/Invoke call helpers, which encode struct sizes that cannot be derived from metadata
+       alone. The SDK only resolves its own KnownCrossgen2Pack when PublishReadyToRun is set, so the
+       pack is acquired through the workload instead. -->
   <ImportGroup Condition="'$(TargetsCurrent)' == 'true' and '$(RuntimeIdentifier)' == 'browser-wasm' and '$(UsingBrowserRuntimeWorkload)' == 'true' and '$(UseMonoRuntime)' == 'false'">
     <Import Project="Sdk.props" Sdk="Microsoft.NET.Runtime.WebAssembly.Sdk.${NetVersion}" />
     <Import Project="Sdk.targets" Sdk="Microsoft.NET.Runtime.WebAssembly.Sdk.${NetVersion}" />
+    <Import Project="Sdk.props" Sdk="Microsoft.NETCore.App.Crossgen2.${NetVersion}" />
   </ImportGroup>
 
   <ImportGroup Condition="'$(TargetsCurrent)' == 'true' and '$(RuntimeIdentifier)' == 'wasi-wasm' and '$(UsingWasiRuntimeWorkload)' == 'true'">
diff --git a/src/mono/wasi/build/WasiApp.CoreCLR.targets b/src/mono/wasi/build/WasiApp.CoreCLR.targets
index 9415a5ab7f9ca4..a1dd6dd842ceeb 100644
--- a/src/mono/wasi/build/WasiApp.CoreCLR.targets
+++ b/src/mono/wasi/build/WasiApp.CoreCLR.targets
@@ -6,8 +6,8 @@
     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
+    only covers framework top-level UCO callbacks). Runs crossgen2's portable call-helpers
+    generator (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
@@ -21,10 +21,7 @@
        WasmAppRuntimeFlavor=Mono default. -->
   <Import Project="$(MSBuildThisFileDirectory)WasiApp.targets" />
 
-  <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.CoreClr.ManagedToNativeGenerator"
-             AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)"
-             TaskFactory="TaskHostFactory"
-             Condition="'$(WasmAppBuilderTasksAssemblyPath)' != ''" />
+  <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.FilterManagedAssemblies" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" />
 
   <PropertyGroup>
     <WasmAppRuntimeFlavor>CoreCLR</WasmAppRuntimeFlavor>
@@ -108,7 +105,6 @@
       <_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
@@ -142,34 +138,57 @@
            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.) -->
+         The bundle can carry native payloads named .dll, and the generator reads managed
+         metadata, so narrow the list the same way the browser targets do. -->
     <ItemGroup>
-      <_WasiManagedAssemblies Include="$(WasmAppDir)managed\*.dll" />
+      <_WasiBundledFile 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>
+    <FilterManagedAssemblies Assemblies="@(_WasiBundledFile)">
+      <Output TaskParameter="ManagedAssemblies" ItemName="_WasiManagedAssemblies" />
+    </FilterManagedAssemblies>
+
+    <!-- crossgen2 has the type system that knows the wasm ABI, so it generates the helpers itself.
+         In the repo it comes from the build output; outside it, from a crossgen2 pack
+         that sets $(Crossgen2ToolPath). The wasi-experimental workload does not acquire that pack
+         today, so out-of-repo wasi relink needs $(PortableCallHelpersGeneratorPath) or
+         $(Crossgen2ToolPath) to be set explicitly. -->
+    <PropertyGroup>
+      <_PortableCallHelpersGeneratorExeSuffix Condition="'$(OS)' == 'Windows_NT'">.exe</_PortableCallHelpersGeneratorExeSuffix>
+      <PortableCallHelpersGeneratorPath Condition="'$(PortableCallHelpersGeneratorPath)' == '' and '$(Crossgen2InBuildDir)' != ''">$([MSBuild]::NormalizePath('$(Crossgen2InBuildDir)', 'crossgen2$(_PortableCallHelpersGeneratorExeSuffix)'))</PortableCallHelpersGeneratorPath>
+      <PortableCallHelpersGeneratorPath Condition="'$(PortableCallHelpersGeneratorPath)' == ''">$(Crossgen2ToolPath)</PortableCallHelpersGeneratorPath>
+    </PropertyGroup>
+
+    <Error Condition="'$(PortableCallHelpersGeneratorPath)' == ''"
+           Text="crossgen2 was not found, so the portable call helpers cannot be generated. Set %24(PortableCallHelpersGeneratorPath) to a crossgen2 executable." />
+    <Error Condition="'$([System.IO.Path]::GetExtension(`$(PortableCallHelpersGeneratorPath)`))' == '.dll'"
+           Text="%24(PortableCallHelpersGeneratorPath) is '$(PortableCallHelpersGeneratorPath)'. It has to name a crossgen2 executable; an IL assembly cannot be launched directly." />
+    <Error Condition="!Exists('$(PortableCallHelpersGeneratorPath)')"
+           Text="%24(PortableCallHelpersGeneratorPath) is '$(PortableCallHelpersGeneratorPath)', which does not exist. In the repo, build crossgen2 first; outside it, set it to a crossgen2 executable." />
+
+    <PropertyGroup>
+      <_PortableCallHelpersGeneratorRsp>$(_WasiRelinkObjDir)callhelpers-generator.rsp</_PortableCallHelpersGeneratorRsp>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <_PortableCallHelpersGeneratorArg Include="--targetos:wasi" />
+      <_PortableCallHelpersGeneratorArg Include="--targetarch:wasm" />
+      <_PortableCallHelpersGeneratorArg Include="--generate-portable-callhelpers:$(_WasiRelinkObjDir)" />
+      <_PortableCallHelpersGeneratorArg Include="@(_WasiPInvokeModules->'--directpinvoke:%(Identity)')" />
+      <_PortableCallHelpersGeneratorArg Include="@(_WasiManagedAssemblies->'%(FullPath)')" />
+    </ItemGroup>
+
+    <WriteLinesToFile File="$(_PortableCallHelpersGeneratorRsp)" Lines="@(_PortableCallHelpersGeneratorArg)" Overwrite="true" WriteOnlyWhenDifferent="true" />
+
+    <Exec Command="&quot;$(PortableCallHelpersGeneratorPath)&quot; &quot;@$(_PortableCallHelpersGeneratorRsp)&quot;" />
+
+    <ItemGroup>
+      <FileWrites Include="$(_PortableCallHelpersGeneratorRsp);$(_WasiPInvokeTablePath);$(_WasiReversePInvokeTablePath);$(_WasiInterpToNativeTablePath)" />
+    </ItemGroup>
 
     <!-- 2. Compile the three generated callhelper sources with the wasi-sdk clang.
          The generated .cpp #include the real <callhelpers.hpp>/<minipal/*.h>; the
diff --git a/src/mono/wasm/Wasm.Build.Tests/PInvokeTableGeneratorTests.cs b/src/mono/wasm/Wasm.Build.Tests/PInvokeTableGeneratorTests.cs
index 404fcfccbea1cb..ec5511fe58bbdf 100644
--- a/src/mono/wasm/Wasm.Build.Tests/PInvokeTableGeneratorTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/PInvokeTableGeneratorTests.cs
@@ -21,7 +21,9 @@ public PInvokeTableGeneratorTests(ITestOutputHelper output, SharedBuildPerTestCl
         {
         }
 
-        [Theory]
+        // Only Mono's generator rejects a non-blittable callback signature; crossgen2 leaves the
+        // check to Roslyn and the runtime.
+        [Theory, TestCategory("mono")]
         [BuildAndRun()]
         public void UnmanagedStructAndMethodIn_SameAssembly_WithoutDisableRuntimeMarshallingAttribute_NotConsideredBlittable
                         (Configuration config, bool aot)
@@ -90,19 +92,49 @@ private ProjectInfo PrepreProjectForBlittableTests(Configuration config, bool ao
                     new object[] { /*libraryHasAttribute*/ true, /*appHasAttribute*/ true, /*expectSuccess*/ true }
                 ).UnwrapItemsAsArrays();
 
-        [Theory]
+        // The library's struct is made non-blittable by a type the generator recognises by name, which
+        // only Mono's generator still does. Kept here so that path stays covered; the CoreCLR
+        // equivalent is the LayoutKind.Auto theory below.
+        [Theory, TestCategory("mono")]
         [MemberData(nameof(SeparateAssemblyWithDisableMarshallingAttributeTestData), parameters: Configuration.Debug)]
         [MemberData(nameof(SeparateAssemblyWithDisableMarshallingAttributeTestData), parameters: Configuration.Release)]
-        public async Task UnmanagedStructsAreConsideredBlittableFromDifferentAssembly
+        public Task UnmanagedStructsAreConsideredBlittableFromDifferentAssembly
                         (Configuration config, bool aot, bool libraryHasAttribute, bool appHasAttribute, bool expectSuccess)
+            => BlittableFromDifferentAssembly(
+                config, aot, libraryHasAttribute, appHasAttribute, expectSuccess, useAutoLayout: false);
+
+        // Same scenario, with the struct made non-blittable by its layout rather than by a name only a
+        // test can produce. What is under test either way is that the DisableRuntimeMarshalling the
+        // generator honours is the one on the assembly declaring the callback, not the struct.
+        [Theory, TestCategory("mono")]
+        [MemberData(nameof(SeparateAssemblyWithDisableMarshallingAttributeTestData), parameters: Configuration.Debug)]
+        [MemberData(nameof(SeparateAssemblyWithDisableMarshallingAttributeTestData), parameters: Configuration.Release)]
+        public Task UnmanagedStructsAreConsideredBlittableFromDifferentAssembly_WithAutoLayout
+                        (Configuration config, bool aot, bool libraryHasAttribute, bool appHasAttribute, bool expectSuccess)
+            => BlittableFromDifferentAssembly(
+                config, aot, libraryHasAttribute, appHasAttribute, expectSuccess, useAutoLayout: true);
+
+        private async Task BlittableFromDifferentAssembly
+                        (Configuration config, bool aot, bool libraryHasAttribute, bool appHasAttribute, bool expectSuccess, bool useAutoLayout)
         {
             string extraProperties = aot ? string.Empty : "<WasmBuildNative>true</WasmBuildNative>";
             string extraItems =  @$"<ProjectReference Include=""..\\Library\\Library.csproj"" />";
             string libRelativePath = Path.Combine("..", "Library", "Library.cs");
             string programRelativePath = Path.Combine("Common", "Program.cs");
-            ProjectInfo info = CopyTestAsset(config, aot, TestAsset.WasmBasicTestApp, "blittable_different_library", extraProperties: extraProperties, extraItems: extraItems);
+            string prefix = useAutoLayout ? "blittable_different_library_auto" : "blittable_different_library";
+            ProjectInfo info = CopyTestAsset(config, aot, TestAsset.WasmBasicTestApp, prefix, extraProperties: extraProperties, extraItems: extraItems);
             ReplaceFile(libRelativePath, Path.Combine(BuildEnvironment.TestAssetsPath, "EntryPoints", "PInvoke", "BittableDifferentAssembly_Lib.cs"));
             ReplaceFile(programRelativePath, Path.Combine(BuildEnvironment.TestAssetsPath, "EntryPoints", "PInvoke", "BittableDifferentAssembly.cs"));
+            if (useAutoLayout)
+            {
+                // Drop the marker type and let the layout make S non-blittable instead.
+                UpdateFile(libRelativePath, new Dictionary<string, string>
+                {
+                    { "public struct __NonBlittableTypeForAutomatedTests__ { }", "" },
+                    { "public struct S {", "[System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Auto)]\n    public struct S {" },
+                    { "public __NonBlittableTypeForAutomatedTests__ NonBlittable;", "public float Value2;" },
+                });
+            }
             if (!libraryHasAttribute)
             {
                 UpdateFile(libRelativePath, new Dictionary<string, string> { { "[assembly: System.Runtime.CompilerServices.DisableRuntimeMarshalling]", "" } });
diff --git a/src/mono/wasm/build/WasmApp.Common.targets b/src/mono/wasm/build/WasmApp.Common.targets
index 9cff34e8753a3b..5835ac039256f3 100644
--- a/src/mono/wasm/build/WasmApp.Common.targets
+++ b/src/mono/wasm/build/WasmApp.Common.targets
@@ -118,7 +118,6 @@
 
   <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.WasmLoadAssembliesAndReferences" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" TaskFactory="TaskHostFactory" />
   <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.Mono.ManagedToNativeGenerator" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" TaskFactory="TaskHostFactory" Condition="'$(WasmAppRuntimeFlavor)' == 'Mono'" />
-  <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.CoreClr.ManagedToNativeGenerator" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" TaskFactory="TaskHostFactory" Condition="'$(WasmAppRuntimeFlavor)' == 'CoreCLR'" />
   <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.EmccCompile" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" TaskFactory="TaskHostFactory" />
   <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.WasmCalculateInitialHeapSize" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" TaskFactory="TaskHostFactory" />
   <UsingTask TaskName="MonoTargetsTasks.MarshalingPInvokeScanner" AssemblyFile="$(MonoTargetsTasksAssemblyPath)" TaskFactory="TaskHostFactory" />
diff --git a/src/tasks/WasmAppBuilder/FilterManagedAssemblies.cs b/src/tasks/WasmAppBuilder/FilterManagedAssemblies.cs
new file mode 100644
index 00000000000000..8e1b0058cbddd4
--- /dev/null
+++ b/src/tasks/WasmAppBuilder/FilterManagedAssemblies.cs
@@ -0,0 +1,79 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+
+namespace Microsoft.WebAssembly.Build.Tasks;
+
+/// <summary>
+/// Narrows a bundle's files down to the managed assemblies the portable call-helpers generator
+/// can scan.
+/// An app bundle legitimately carries native payloads named <c>.dll</c> - per-architecture content
+/// shipped by a NuGet package is the usual case - and the tools that read managed metadata cannot
+/// be handed those. It can also carry several managed files sharing a simple name, satellite
+/// assemblies for different cultures being the common case, and the type system holds a single
+/// module per simple name, so only the first of those is worth scanning.
+/// </summary>
+public class FilterManagedAssemblies : Task
+{
+    [Required, NotNull]
+    public ITaskItem[]? Assemblies { get; set; }
+
+    [Output]
+    public ITaskItem[] ManagedAssemblies { get; private set; } = Array.Empty<ITaskItem>();
+
+    public override bool Execute()
+    {
+        List<ITaskItem> managedAssemblies = new(Assemblies.Length);
+        Dictionary<string, string> claimedSimpleNames = new(Assemblies.Length, StringComparer.OrdinalIgnoreCase);
+
+        foreach (ITaskItem assembly in Assemblies)
+        {
+            string path = assembly.GetMetadata("FullPath");
+
+            if (!File.Exists(path))
+            {
+                Log.LogError($"Cannot find assembly '{path}'.");
+                continue;
+            }
+
+            bool isManaged;
+            try
+            {
+                isManaged = Utils.IsManagedAssembly(path);
+            }
+            catch (Exception ex)
+            {
+                Log.LogError($"Failed to read assembly '{path}': {ex.Message}");
+                continue;
+            }
+
+            if (!isManaged)
+            {
+                Log.LogMessage(MessageImportance.Low, $"Skipping unmanaged {path}.");
+                continue;
+            }
+
+            // Unmanaged files are already gone, so a native payload can never claim a simple name
+            // ahead of the managed assembly that shares it.
+            string simpleName = Path.GetFileNameWithoutExtension(path);
+            if (claimedSimpleNames.TryGetValue(simpleName, out string? claimedPath))
+            {
+                Log.LogMessage(MessageImportance.Low, $"Skipping {path}, '{simpleName}' is already provided by {claimedPath}.");
+                continue;
+            }
+
+            claimedSimpleNames.Add(simpleName, path);
+            managedAssemblies.Add(assembly);
+        }
+
+        ManagedAssemblies = managedAssemblies.ToArray();
+
+        return !Log.HasLoggedErrors;
+    }
+}
diff --git a/src/tasks/WasmAppBuilder/IcallTableGenerator.cs b/src/tasks/WasmAppBuilder/IcallTableGenerator.cs
index cc55684aef6e00..e070ff654d9002 100644
--- a/src/tasks/WasmAppBuilder/IcallTableGenerator.cs
+++ b/src/tasks/WasmAppBuilder/IcallTableGenerator.cs
@@ -25,19 +25,16 @@ internal sealed class IcallTableGenerator
     private LogAdapter Log { get; set; }
     private readonly Func<string, string> _fixupSymbolName;
 
-    private bool _isCoreClr;
-
     //
     // Given the runtime generated icall table, and a set of assemblies, generate
     // a smaller linked icall table mapping tokens to C function names
     // The runtime icall table should be generated using
     // mono --print-icall-table
     //
-    public IcallTableGenerator(string? runtimeIcallTableFile, Func<string, string> fixupSymbolName, LogAdapter log, bool isCoreClr)
+    public IcallTableGenerator(string? runtimeIcallTableFile, Func<string, string> fixupSymbolName, LogAdapter log)
     {
         Log = log;
         _fixupSymbolName = fixupSymbolName;
-        _isCoreClr = isCoreClr;
         if (runtimeIcallTableFile != null)
             ReadTable(runtimeIcallTableFile);
     }
@@ -210,11 +207,8 @@ private void ProcessType(Type type)
 
         void AddSignature(Type type, MethodInfo method)
         {
-            string? signature = _isCoreClr ? CoreClr.SignatureMapper.MethodToSignature(method, Log) : Mono.SignatureMapper.MethodToSignature(method, Log);
-            if (signature == null)
-            {
-                throw new LogAsErrorException($"Unsupported parameter type in method '{type.FullName}.{method.Name}'");
-            }
+            string signature = Mono.SignatureMapper.MethodToSignature(method, Log)
+                ?? throw new LogAsErrorException($"Unsupported parameter type in method '{type.FullName}.{method.Name}'");
 
             if (_signatures.Add(signature))
                 Log.LogMessage(MessageImportance.Low, $"Adding icall signature {signature} for method '{type.FullName}.{method.Name}'");
diff --git a/src/tasks/WasmAppBuilder/WasmAppBuilder.csproj b/src/tasks/WasmAppBuilder/WasmAppBuilder.csproj
index 32cac2b06a82d4..b41b3e56ac6bb9 100644
--- a/src/tasks/WasmAppBuilder/WasmAppBuilder.csproj
+++ b/src/tasks/WasmAppBuilder/WasmAppBuilder.csproj
@@ -57,33 +57,5 @@
   </Target>
 
   <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.Mono.ManagedToNativeGenerator" TaskFactory="TaskHostFactory" AssemblyFile="$(OutputPath)net\WasmAppBuilder.dll" Condition="'$(RuntimeFlavor)' == 'Mono'" />
-  <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.CoreClr.ManagedToNativeGenerator" TaskFactory="TaskHostFactory" AssemblyFile="$(OutputPath)net\WasmAppBuilder.dll" Condition="'$(RuntimeFlavor)' == 'CoreCLR'" />
-
-  <!-- The module list is shared with the runtime tests' corerun relink, which has to cover the
-       same modules as the tables generated here. -->
-  <Import Project="$(RepositoryEngineeringDir)wasm\WasmPInvokeModules.props" />
-
-  <Target Name="RunGenerator" DependsOnTargets="Build" Condition="'$(AssembliesScanPath)' != ''">
-      <ItemGroup>
-        <WasmPInvokeAssembly Include="$(AssembliesScanPath)*.dll" />
-        <WasmPInvokeModule Include="@(WasmCoreClrFrameworkPInvokeModule)" />
-      </ItemGroup>
-
-      <PropertyGroup>
-        <_RunGeneratorTargetOS Condition="'$(TargetOS)' == ''">browser</_RunGeneratorTargetOS>
-        <_RunGeneratorTargetOS Condition="'$(TargetOS)' != ''">$(TargetOS)</_RunGeneratorTargetOS>
-      </PropertyGroup>
-
-      <Message Importance="high" Text="Running ManagedToNativeGenerator on @(WasmPInvokeAssembly) for TargetOS=$(_RunGeneratorTargetOS)" />
-      <ManagedToNativeGenerator
-          Assemblies="@(WasmPInvokeAssembly)"
-          PInvokeModules="@(WasmPInvokeModule)"
-          TargetOS="$(_RunGeneratorTargetOS)"
-          PInvokeOutputPath="$(GeneratorOutputPath)callhelpers-pinvoke.cpp"
-          ReversePInvokeOutputPath="$(GeneratorOutputPath)callhelpers-reverse.cpp"
-          InterpToNativeOutputPath="$(GeneratorOutputPath)callhelpers-interp-to-managed.cpp">
-          <Output TaskParameter="FileWrites" ItemName="FileWrites" />
-      </ManagedToNativeGenerator>
-  </Target>
 
 </Project>
diff --git a/src/tasks/WasmAppBuilder/coreclr/InternalCallSignatureCollector.cs b/src/tasks/WasmAppBuilder/coreclr/InternalCallSignatureCollector.cs
deleted file mode 100644
index eda8aedda299b4..00000000000000
--- a/src/tasks/WasmAppBuilder/coreclr/InternalCallSignatureCollector.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using Microsoft.Build.Framework;
-
-namespace Microsoft.WebAssembly.Build.Tasks.CoreClr;
-
-//
-// Scans assemblies for methods marked with MethodImplAttributes.InternalCall
-// and generates portable entry point signatures for the interpreter-to-native thunks.
-//
-internal sealed class InternalCallSignatureCollector
-{
-    private readonly HashSet<string> _signatures = new();
-    private readonly LogAdapter _log;
-
-    public InternalCallSignatureCollector(LogAdapter log) => _log = log;
-
-    public void ScanAssembly(Assembly asm)
-    {
-        foreach (Type type in asm.GetTypes())
-            ScanType(type);
-    }
-
-    public IEnumerable<string> GetSignatures() => _signatures;
-
-    private void ScanType(Type type)
-    {
-        foreach (var method in type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance))
-        {
-            if ((method.GetMethodImplementationFlags() & MethodImplAttributes.InternalCall) == 0)
-                continue;
-
-            try
-            {
-                string? signature = SignatureMapper.MethodToSignature(method, _log, includeThis: true);
-                if (signature is null)
-                {
-                    _log.Warning("WASM0001", $"Could not generate signature for InternalCall method '{type.FullName}::{method.Name}'");
-                    continue;
-                }
-
-                signature += "p";
-
-                if (_signatures.Add(signature))
-                    _log.LogMessage(MessageImportance.Low, $"Adding InternalCall signature {signature} for method '{type.FullName}.{method.Name}'");
-            }
-            catch (Exception ex) when (ex is not LogAsErrorException)
-            {
-                _log.Warning("WASM0001", $"Could not get signature for InternalCall method '{type.FullName}::{method.Name}' because '{ex.Message}'");
-            }
-        }
-    }
-}
diff --git a/src/tasks/WasmAppBuilder/coreclr/InterpToNativeGenerator.cs b/src/tasks/WasmAppBuilder/coreclr/InterpToNativeGenerator.cs
deleted file mode 100644
index e5183182df8088..00000000000000
--- a/src/tasks/WasmAppBuilder/coreclr/InterpToNativeGenerator.cs
+++ /dev/null
@@ -1,222 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Collections.Generic;
-using System.Globalization;
-using Microsoft.Build.Utilities;
-using Microsoft.Build.Framework;
-using System.Diagnostics.CodeAnalysis;
-
-using JoinedString;
-//
-// This class generates the g_wasmThunks array and CallFunc_* functions used by the CoreCLR interpreter to call native code on WASM.
-// The generated code should be kept in sync with the corresponding CoreCLR runtime code that consumes these thunks and call functions.
-//
-
-#nullable enable
-
-namespace Microsoft.WebAssembly.Build.Tasks.CoreClr;
-
-internal sealed class InterpToNativeGenerator
-{
-    private LogAdapter Log { get; set; }
-
-    public InterpToNativeGenerator(LogAdapter log) => Log = log;
-
-    public void Generate(IEnumerable<string> cookies, string outputPath)
-    {
-        using TempFileName tmpFileName = new();
-        using (var w = File.CreateText(tmpFileName.Path))
-        {
-            Emit(w, cookies);
-        }
-
-        if (Utils.CopyIfDifferent(tmpFileName.Path, outputPath, useHash: false))
-            Log.LogMessage(MessageImportance.Low, $"Generating managed2native table to '{outputPath}'.");
-        else
-            Log.LogMessage(MessageImportance.Low, $"Managed2native table in {outputPath} is unchanged.");
-    }
-
-    private static string SignatureToArguments(string signature)
-    {
-        var tokens = SignatureMapper.ParseSignatureTokens(signature);
-        if (tokens.Count <= 1)
-            return "void";
-
-        return string.Join(", ", tokens.Skip(1).Select(static t => SignatureMapper.TokenToNativeType(t)));
-    }
-
-    private static string CallFuncName(IEnumerable<string> args, string result, bool isPortableEntryPointCall)
-    {
-        var paramTypes = args.Any() ? string.Join("_", args.Select(static t => SignatureMapper.TokenToNameType(t))) : "Void";
-
-        return $"CallFunc_{paramTypes}_Ret{result}{(isPortableEntryPointCall ? "_PE" : "")}";
-    }
-
-    private static void Emit(StreamWriter w, IEnumerable<string> cookies)
-    {
-        // Use OrderBy because Order() is not available on .NET Framework
-        var signatures = cookies.OrderBy(c => c).Distinct().ToArray();
-        Array.Sort(signatures, StringComparer.Ordinal);
-
-        // Collect unique struct return sizes so we can emit typedefs
-        var structReturnSizes = new SortedSet<int>();
-        foreach (var sig in signatures)
-        {
-            var toks = SignatureMapper.ParseSignatureTokens(sig);
-            if (toks[0][0] == 'S' && toks[0].Length > 1)
-                structReturnSizes.Add(SignatureMapper.GetStructSize(toks[0]));
-        }
-
-        w.Write(
-        """
-        // Licensed to the .NET Foundation under one or more agreements.
-        // The .NET Foundation licenses this file to you under the MIT license.
-        //
-
-        //
-        // GENERATED FILE, DON'T EDIT
-        // Generated by coreclr InterpToNativeGenerator
-        //
-
-        #include <callhelpers.hpp>
-        #include <minipal/utils.h>
-
-        // Arguments are passed on the stack with each argument aligned to INTERP_STACK_SLOT_SIZE.
-        #define ARG_ADDR(i) (pArgs + (i * INTERP_STACK_SLOT_SIZE))
-        #define ARG_IND(i) ((int32_t)((int32_t*)ARG_ADDR(i)))
-        #define ARG_I32(i) (*(int32_t*)ARG_ADDR(i))
-        #define ARG_I64(i) (*(int64_t*)ARG_ADDR(i))
-        #define ARG_F32(i) (*(float*)ARG_ADDR(i))
-        #define ARG_F64(i) (*(double*)ARG_ADDR(i))
-
-        """);
-
-        // Emit typedefs for struct return types so emcc generates the correct sret ABI
-        foreach (var size in structReturnSizes)
-        {
-            w.WriteLine($"typedef struct {{ char d[{size}]; }} wasm_ret_S{size};");
-        }
-
-        w.Write(
-        """
-
-        namespace
-        {
-        """);
-
-        foreach (var signatureValue in signatures)
-        {
-            string signature = signatureValue;
-            try
-            {
-                var tokens = SignatureMapper.ParseSignatureTokens(signature);
-                string returnToken = tokens[0];
-                var result = Result(returnToken);
-                bool isPortableEntryPointCall = IsPortableEntryPointCall(tokens);
-                if (isPortableEntryPointCall)
-                {
-                    // Portable entrypoints have an extra hidden parameter for the portable entrypoint context, so we need to adjust the signature and result accordingly for the call function generation
-                    tokens.RemoveAt(tokens.Count - 1);
-                }
-
-                RemoveAsyncCallMarker(tokens);
-
-                var args = Args(tokens);
-
-                var portableEntryPointComma = args.Count > 0 ? ", " : "";
-                var portableEntrypointDeclaration = isPortableEntryPointCall ? portableEntryPointComma + "PCODE" : "";
-                var portableEntrypointParam = isPortableEntryPointCall ? portableEntryPointComma + "pPortableEntryPoint" : "";
-                var portableEntrypointStackDeclaration = isPortableEntryPointCall ? "int*, " : "";
-                var portableEntrypointStackParam = isPortableEntryPointCall ? "&framePointer, " : "";
-                var portableEntrypointPointerRD = isPortableEntryPointCall ? "*" : "";
-                w.Write(
-                    $$"""
-
-                        {{(isPortableEntryPointCall ? "NOINLINE " : "")}}static void {{CallFuncName(args, SignatureMapper.TokenToNameType(returnToken), isPortableEntryPointCall)}}(PCODE {{(isPortableEntryPointCall ? "pPortableEntryPoint" : "pcode")}}, int8_t* pArgs, int8_t* pRet)
-                        {{{(isPortableEntryPointCall ? "\n        alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK;" : "")}}
-                            {{result.nativeType}} (*fptr)({{portableEntrypointStackDeclaration}}{{string.Join(", ", args.Select(static t => SignatureMapper.TokenToNativeType(t)))}}{{portableEntrypointDeclaration}}) = {{portableEntrypointPointerRD}}({{result.nativeType}} ({{portableEntrypointPointerRD}}*)({{portableEntrypointStackDeclaration}}{{string.Join(", ", args.Select(static t => SignatureMapper.TokenToNativeType(t)))}}{{portableEntrypointDeclaration}})){{(isPortableEntryPointCall ? "(pPortableEntryPoint)" : "pcode")}};
-                            {{(result.isVoid ? "" : "*" + "((" + result.nativeType + "*)pRet) = ")}}(*fptr)({{portableEntrypointStackParam}}{{string.Join(", ", ArgsWithSlotOffsets(args))}}{{portableEntrypointParam}});
-                        }
-
-                    """);
-            }
-            catch (InvalidSignatureCharException e)
-            {
-                throw new LogAsErrorException($"Element '{e.Char}' of signature '{signature}' can't be handled by managed2native generator");
-            }
-        }
-
-        w.Write(
-            $$"""
-            }
-
-            const StringToWasmSigThunk g_wasmThunks[] = {
-            {{signatures.Join($",{w.NewLine}", signature =>
-            {
-                string initialSignature = signature;
-                var tokens = SignatureMapper.ParseSignatureTokens(signature);
-                bool isPortableEntryPointCall = IsPortableEntryPointCall(tokens);
-                if (isPortableEntryPointCall)
-                    tokens.RemoveAt(tokens.Count - 1);
-                RemoveAsyncCallMarker(tokens);
-                return $"    {{ \"M{initialSignature}\", (void*)&{CallFuncName(Args(tokens), SignatureMapper.TokenToNameType(tokens[0]), isPortableEntryPointCall)} }}";
-            }
-            )}}
-            };
-
-            const size_t g_wasmThunksCount = sizeof(g_wasmThunks) / sizeof(g_wasmThunks[0]);
-
-            """);
-
-        static List<string> Args(List<string> tokens)
-        {
-            return tokens.Count > 1 ? tokens.GetRange(1, tokens.Count - 1) : new List<string>();
-        }
-
-        static List<string> ArgsWithSlotOffsets(List<string> args)
-        {
-            var result = new List<string>();
-            int slot = 0;
-            foreach (var token in args)
-            {
-                if (token[0] == 'A')
-                {
-                    slot = (slot + 1) & ~1;
-                }
-
-                result.Add($"{SignatureMapper.TokenToArgType(token)}({slot})");
-                slot += SignatureMapper.TokenToSlotCount(token);
-            }
-
-            return result;
-        }
-
-        static (bool isVoid, string nativeType) Result(string returnToken)
-        {
-            // For struct returns, use the typedef so emcc generates the correct sret ABI
-            if (returnToken[0] == 'S' && returnToken.Length > 1)
-                return (false, $"wasm_ret_S{SignatureMapper.GetStructSize(returnToken)}");
-            return new(returnToken == "v", SignatureMapper.TokenToNativeType(returnToken));
-        }
-
-        static bool IsPortableEntryPointCall(List<string> tokens)
-        {
-            return tokens.Count > 0 && tokens[tokens.Count - 1] == "p";
-        }
-
-        static bool RemoveAsyncCallMarker(List<string> tokens)
-        {
-            int asyncMarkerIndex = tokens.IndexOf("a");
-            if (asyncMarkerIndex < 0)
-                return false;
-
-            tokens.RemoveAt(asyncMarkerIndex);
-            return true;
-        }
-    }
-}
diff --git a/src/tasks/WasmAppBuilder/coreclr/ManagedToNativeGenerator.cs b/src/tasks/WasmAppBuilder/coreclr/ManagedToNativeGenerator.cs
deleted file mode 100644
index f033d8b39ca3ed..00000000000000
--- a/src/tasks/WasmAppBuilder/coreclr/ManagedToNativeGenerator.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-
-namespace Microsoft.WebAssembly.Build.Tasks.CoreClr;
-
-public class ManagedToNativeGenerator : Task
-{
-    [Required]
-    public string[] Assemblies { get; set; } = Array.Empty<string>();
-
-    [Required, NotNull]
-    public string[]? PInvokeModules { get; set; }
-
-    public string[] IgnoredPInvokeModules { get; set; } = Array.Empty<string>();
-
-    [Required, NotNull]
-    public string? PInvokeOutputPath { get; set; }
-
-    [Required, NotNull]
-    public string? ReversePInvokeOutputPath { get; set; }
-
-    [Required, NotNull]
-    public string? InterpToNativeOutputPath { get; set; }
-    public string? CacheFilePath { get; set; }
-
-    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" };
-
-    [Output]
-    public string[]? FileWrites { get; private set; }
-
-    public override bool Execute()
-    {
-        if (Assemblies!.Length == 0)
-        {
-            Log.LogError($"{nameof(ManagedToNativeGenerator)}.{nameof(Assemblies)} cannot be empty");
-            return false;
-        }
-
-        if (PInvokeModules!.Length == 0)
-        {
-            Log.LogError($"{nameof(ManagedToNativeGenerator)}.{nameof(PInvokeModules)} cannot be empty");
-            return false;
-        }
-
-        if (string.IsNullOrWhiteSpace(TargetOS))
-        {
-            Log.LogError($"{nameof(ManagedToNativeGenerator)}.{nameof(TargetOS)} cannot be empty; expected one of: {string.Join(", ", s_knownTargetOSes)}");
-            return false;
-        }
-
-        TargetOS = TargetOS.Trim().ToLowerInvariant();
-        if (Array.IndexOf(s_knownTargetOSes, TargetOS) < 0)
-        {
-            Log.LogError($"{nameof(ManagedToNativeGenerator)}.{nameof(TargetOS)} '{TargetOS}' is not recognized; expected one of: {string.Join(", ", s_knownTargetOSes)}");
-            return false;
-        }
-
-        try
-        {
-            var logAdapter = new LogAdapter(Log);
-            ExecuteInternal(logAdapter);
-            return !Log.HasLoggedErrors;
-        }
-        catch (LogAsErrorException e)
-        {
-            Log.LogError(e.Message);
-            return false;
-        }
-    }
-
-    private void ExecuteInternal(LogAdapter log)
-    {
-        Dictionary<string, string> _symbolNameFixups = new();
-        List<string> managedAssemblies = FilterOutUnmanagedBinaries(Assemblies);
-        var pinvoke = new PInvokeTableGenerator(FixupSymbolName, log, IsLibraryMode, TargetOS, WarnOnUnresolvedPInvokeModules);
-        var internalCallCollector = new InternalCallSignatureCollector(log);
-
-        var resolver = new PathAssemblyResolver(managedAssemblies);
-        using var mlc = new MetadataLoadContext(resolver, "System.Private.CoreLib");
-        foreach (string asmPath in managedAssemblies)
-        {
-            log.LogMessage(MessageImportance.Low, $"Loading {asmPath} to scan for pinvokes and InternalCall methods");
-            Assembly asm = mlc.LoadFromAssemblyPath(asmPath);
-            pinvoke.ScanAssembly(asm);
-
-            if (asmPath.Contains("System.Private.CoreLib", StringComparison.OrdinalIgnoreCase))
-            {
-                // Only scan System.Private.CoreLib, as all used InternalCall methods should be defined there,
-                // and scanning all assemblies can be expensive, and can trigger failures which should be avoided.
-                // System.Private.CoreLib is tested such that this should never fail on that binary.
-                internalCallCollector.ScanAssembly(asm);
-            }
-        }
-
-        // Pregenerated signatures for commonly used shapes used by R2R code to reduce duplication in generated R2R binaries.
-        // The signatures should be in the form of a string where the first character represents the return type and the
-        // following characters represent the argument types. The type characters should match those used by the
-        // SignatureMapper.CharToNativeType method.
-        string[] pregeneratedInterpreterToNativeSignatures = Array.Empty<string>(); // Currently none, but can be added here as needed in the future.
-
-        IEnumerable<string> cookies = pinvoke.Generate(PInvokeModules, IgnoredPInvokeModules, PInvokeOutputPath, ReversePInvokeOutputPath);
-        cookies = cookies.Concat(internalCallCollector.GetSignatures());
-        cookies = cookies.Concat(pregeneratedInterpreterToNativeSignatures);
-
-        var m2n = new InterpToNativeGenerator(log);
-        m2n.Generate(cookies, InterpToNativeOutputPath);
-
-        if (!string.IsNullOrEmpty(CacheFilePath))
-        {
-            IEnumerable<string> cacheLines = PInvokeModules
-                .Select(module => $"module:{module}")
-                .Concat(IgnoredPInvokeModules.Select(module => $"ignored:{module}"));
-            File.WriteAllLines(CacheFilePath, cacheLines, Encoding.UTF8);
-        }
-
-        List<string> fileWritesList = new() { PInvokeOutputPath, InterpToNativeOutputPath };
-        if (!string.IsNullOrEmpty(CacheFilePath))
-            fileWritesList.Add(CacheFilePath);
-
-        FileWrites = fileWritesList.ToArray();
-
-        string FixupSymbolName(string name)
-        {
-            if (_symbolNameFixups.TryGetValue(name, out string? fixedName))
-                return fixedName;
-
-            fixedName = Utils.FixupSymbolName(name);
-            _symbolNameFixups[name] = fixedName;
-            return fixedName;
-        }
-    }
-
-    private List<string> FilterOutUnmanagedBinaries(string[] assemblies)
-    {
-        List<string> managedAssemblies = new(assemblies.Length);
-        foreach (string asmPath in Assemblies)
-        {
-            if (!File.Exists(asmPath))
-                throw new LogAsErrorException($"Cannot find assembly {asmPath}");
-
-            try
-            {
-                if (!Utils.IsManagedAssembly(asmPath))
-                {
-                    Log.LogMessage(MessageImportance.Low, $"Skipping unmanaged {asmPath}.");
-                    continue;
-                }
-            }
-            catch (Exception ex)
-            {
-                Log.LogMessage(MessageImportance.Low, $"Failed to read assembly {asmPath}: {ex}");
-                throw new LogAsErrorException($"Failed to read assembly {asmPath}: {ex.Message}");
-            }
-
-            managedAssemblies.Add(asmPath);
-        }
-
-        return managedAssemblies;
-    }
-}
diff --git a/src/tasks/WasmAppBuilder/coreclr/PInvokeCollector.cs b/src/tasks/WasmAppBuilder/coreclr/PInvokeCollector.cs
deleted file mode 100644
index ba59810c1b54c8..00000000000000
--- a/src/tasks/WasmAppBuilder/coreclr/PInvokeCollector.cs
+++ /dev/null
@@ -1,414 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Generic;
-using System;
-using System.Linq;
-using System.Diagnostics.CodeAnalysis;
-using System.Reflection;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-using Microsoft.Build.Tasks;
-using JoinedString;
-
-namespace Microsoft.WebAssembly.Build.Tasks.CoreClr;
-
-#pragma warning disable CA1067
-#pragma warning disable CS0649
-internal sealed class PInvoke : IEquatable<PInvoke>
-#pragma warning restore CA1067
-{
-    public PInvoke(string entryPoint, string module, MethodInfo method, bool wasmLinkage)
-    {
-        EntryPoint = entryPoint;
-        Module = module;
-        Method = method;
-        WasmLinkage = wasmLinkage;
-    }
-
-    public string EntryPoint;
-    public string Module;
-    public MethodInfo Method;
-    public bool Skip;
-    public bool WasmLinkage;
-
-    public bool Equals(PInvoke? other)
-        => other != null &&
-            string.Equals(EntryPoint, other.EntryPoint, StringComparison.Ordinal) &&
-            string.Equals(Module, other.Module, StringComparison.Ordinal) &&
-            string.Equals(Method.ToString(), other.Method.ToString(), StringComparison.Ordinal);
-
-    public override string ToString() => $"{{ EntryPoint: {EntryPoint}, Module: {Module}, Method: {Method}, Skip: {Skip} }}";
-}
-#pragma warning restore CS0649
-
-internal sealed class PInvokeComparer : IEqualityComparer<PInvoke>
-{
-    public bool Equals(PInvoke? x, PInvoke? y)
-    {
-        if (x == null && y == null)
-            return true;
-        if (x == null || y == null)
-            return false;
-
-        return x.Equals(y);
-    }
-
-    public int GetHashCode(PInvoke pinvoke)
-        => $"{pinvoke.EntryPoint}{pinvoke.Module}{pinvoke.Method}".GetHashCode();
-}
-
-
-internal sealed class PInvokeCollector {
-    private readonly Dictionary<Assembly, bool> _assemblyDisableRuntimeMarshallingAttributeCache = new();
-    private readonly Dictionary<Type, bool> _typeUnsupportedOnPlatformCache = new();
-    private readonly Dictionary<Assembly, bool> _assemblyUnsupportedOnPlatformCache = new();
-    private readonly string _targetOS;
-    private LogAdapter Log { get; init; }
-
-    public PInvokeCollector(LogAdapter log, string targetOS)
-    {
-        Log = log;
-        _targetOS = targetOS;
-    }
-
-    public void CollectPInvokes(List<PInvoke> pinvokes, List<PInvokeCallback> callbacks, HashSet<string> signatures, Type type)
-    {
-        foreach (var method in type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance))
-        {
-            try
-            {
-                CollectPInvokesForMethod(method);
-                if (DoesMethodHaveCallbacks(method, Log))
-                    callbacks.Add(new PInvokeCallback(method));
-            }
-            catch (Exception ex) when (ex is not LogAsErrorException)
-            {
-                Log.Warning("WASM0001", $"Could not get pinvoke, or callbacks for method '{type.FullName}::{method.Name}' because '{ex}'");
-            }
-        }
-
-        if (HasAttribute(type, "System.Runtime.InteropServices.UnmanagedFunctionPointerAttribute"))
-        {
-            var method = type.GetMethod("Invoke");
-
-            if (method != null)
-            {
-                string? signature = SignatureMapper.MethodToSignature(method!, Log);
-                if (signature == null)
-                    throw new NotSupportedException($"Unsupported parameter type in method '{type.FullName}.{method.Name}'");
-
-                if (signatures.Add(signature))
-                    Log.LogMessage(MessageImportance.Low, $"Adding pinvoke signature {signature} for method '{type.FullName}.{method.Name}'");
-            }
-        }
-
-        void CollectPInvokesForMethod(MethodInfo method)
-        {
-            if ((method.Attributes & MethodAttributes.PinvokeImpl) != 0)
-            {
-                if (IsUnsupportedOnPlatform(method))
-                    return;
-
-                var dllimport = method.CustomAttributes.First(attr => attr.AttributeType.Name == "DllImportAttribute");
-                var wasmLinkage = method.CustomAttributes.Any(attr => attr.AttributeType.Name == "WasmImportLinkageAttribute");
-                var module = (string)dllimport.ConstructorArguments[0].Value!;
-                var entrypoint = (string)dllimport.NamedArguments.First(arg => arg.MemberName == "EntryPoint").TypedValue.Value!;
-                pinvokes.Add(new PInvoke(entrypoint, module, method, wasmLinkage));
-
-                string? signature = SignatureMapper.MethodToSignature(method, Log);
-                if (signature == null)
-                {
-                    throw new NotSupportedException($"Unsupported parameter type in method '{type.FullName}.{method.Name}'");
-                }
-
-                if (signatures.Add(signature))
-                    Log.LogMessage(MessageImportance.Low, $"Adding pinvoke signature {signature} for method '{type.FullName}.{method.Name}'");
-            }
-        }
-
-        bool DoesMethodHaveCallbacks(MethodInfo method, LogAdapter log)
-        {
-            if (!MethodHasCallbackAttributes(method))
-                return false;
-
-            if (IsUnsupportedOnPlatform(method))
-                return false;
-
-            if (TryIsMethodGetParametersUnsupported(method, out string? reason))
-            {
-                Log.Warning("WASM0001", $"Skipping callback '{method.DeclaringType!.FullName}::{method.Name}' because '{reason}'.");
-                return false;
-            }
-
-            if (method.DeclaringType != null && HasAssemblyDisableRuntimeMarshallingAttribute(method.DeclaringType.Assembly))
-                return true;
-
-            // No DisableRuntimeMarshalling attribute, so check if the params/ret-type are
-            // blittable
-            bool isVoid = method.ReturnType.FullName == "System.Void";
-            if (!isVoid && !IsBlittable(method.ReturnType, log))
-                Error($"The return type '{method.ReturnType.FullName}' of pinvoke callback method '{method}' needs to be blittable.");
-
-            foreach (var p in method.GetParameters())
-            {
-                if (!IsBlittable(p.ParameterType, log))
-                    Error("Parameter types of pinvoke callback method '" + method + "' needs to be blittable.");
-            }
-
-            return true;
-        }
-
-        static bool MethodHasCallbackAttributes(MethodInfo method)
-        {
-            foreach (CustomAttributeData cattr in CustomAttributeData.GetCustomAttributes(method))
-            {
-                try
-                {
-                    if (cattr.AttributeType.FullName == "System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute" ||
-                        cattr.AttributeType.Name == "MonoPInvokeCallbackAttribute")
-                    {
-                        return true;
-                    }
-                }
-                catch
-                {
-                    // Assembly not found, ignore
-                }
-            }
-
-            return false;
-        }
-    }
-
-    public static bool IsBlittable(Type type, LogAdapter log) => PInvokeTableGenerator.IsBlittable(type, log);
-
-    private static void Error(string msg) => throw new LogAsErrorException(msg);
-
-    internal static bool HasAttribute(MemberInfo element, params string[] attributeNames) => PInvokeTableGenerator.HasAttribute(element, attributeNames);
-
-    private static bool TryIsMethodGetParametersUnsupported(MethodInfo method, [NotNullWhen(true)] out string? reason)
-    {
-        try
-        {
-            method.GetParameters();
-        }
-        catch (NotSupportedException nse)
-        {
-            reason = nse.Message;
-            return true;
-        }
-        catch
-        {
-            // not concerned with other exceptions
-        }
-
-        reason = null;
-        return false;
-    }
-
-    private bool HasAssemblyDisableRuntimeMarshallingAttribute(Assembly assembly)
-    {
-        if (!_assemblyDisableRuntimeMarshallingAttributeCache.TryGetValue(assembly, out var value))
-        {
-            _assemblyDisableRuntimeMarshallingAttributeCache[assembly] = value = assembly
-                .GetCustomAttributesData()
-                .Any(d => d.AttributeType.Name == "DisableRuntimeMarshallingAttribute");
-        }
-
-        return value;
-    }
-
-    private bool IsUnsupportedOnPlatform(MethodInfo method)
-    {
-        PlatformSupport methodResult = EvaluatePlatformAttributes(CustomAttributeData.GetCustomAttributes(method));
-        if (methodResult == PlatformSupport.Unsupported)
-            return true;
-        if (methodResult == PlatformSupport.Supported)
-            return false;
-
-        return IsUnsupportedOnPlatform(method.DeclaringType);
-    }
-
-    private bool IsUnsupportedOnPlatform(Type? type)
-    {
-        if (type is null)
-            return false;
-
-        if (_typeUnsupportedOnPlatformCache.TryGetValue(type, out bool cached))
-            return cached;
-
-        bool value;
-        PlatformSupport typeResult = EvaluatePlatformAttributes(CustomAttributeData.GetCustomAttributes(type));
-        if (typeResult == PlatformSupport.Unsupported)
-        {
-            value = true;
-        }
-        else if (typeResult == PlatformSupport.Supported)
-        {
-            value = false;
-        }
-        else if (type.DeclaringType is not null)
-        {
-            value = IsUnsupportedOnPlatform(type.DeclaringType);
-        }
-        else
-        {
-            value = IsAssemblyUnsupportedOnPlatform(type.Assembly);
-        }
-
-        _typeUnsupportedOnPlatformCache[type] = value;
-        return value;
-    }
-
-    private bool IsAssemblyUnsupportedOnPlatform(Assembly assembly)
-    {
-        if (!_assemblyUnsupportedOnPlatformCache.TryGetValue(assembly, out bool value))
-        {
-            PlatformSupport asmResult = EvaluatePlatformAttributes(assembly.GetCustomAttributesData());
-            value = asmResult == PlatformSupport.Unsupported;
-            _assemblyUnsupportedOnPlatformCache[assembly] = value;
-        }
-
-        return value;
-    }
-
-    private enum PlatformSupport
-    {
-        Unknown,     // No platform attributes were observed at this scope
-        Supported,   // Explicitly supported here (target appears in a SupportedOSPlatform list)
-        Unsupported, // Explicitly unsupported here (target matches UnsupportedOSPlatform, or
-                     // SupportedOSPlatform is present and does not list the target)
-    }
-
-    private PlatformSupport EvaluatePlatformAttributes(IList<CustomAttributeData> attrs)
-    {
-        bool hasSupportedOSPlatform = false;
-        bool hasSupportedTarget = false;
-        foreach (CustomAttributeData cattr in attrs)
-        {
-            try
-            {
-                if (cattr.AttributeType.FullName == "System.Runtime.Versioning.UnsupportedOSPlatformAttribute" &&
-                    cattr.ConstructorArguments.Count > 0 &&
-                    MatchesTargetOS(cattr.ConstructorArguments[0].Value?.ToString()))
-                {
-                    return PlatformSupport.Unsupported;
-                }
-                if (cattr.AttributeType.FullName == "System.Runtime.Versioning.SupportedOSPlatformAttribute" &&
-                    cattr.ConstructorArguments.Count > 0)
-                {
-                    hasSupportedOSPlatform = true;
-                    if (MatchesTargetOS(cattr.ConstructorArguments[0].Value?.ToString()))
-                        hasSupportedTarget = true;
-                }
-            }
-            catch
-            {
-                // Assembly not found, ignore
-            }
-        }
-
-        if (hasSupportedOSPlatform)
-            return hasSupportedTarget ? PlatformSupport.Supported : PlatformSupport.Unsupported;
-
-        return PlatformSupport.Unknown;
-    }
-
-    private bool MatchesTargetOS(string? platformName)
-    {
-        if (string.Equals(platformName, _targetOS, StringComparison.OrdinalIgnoreCase))
-            return true;
-
-        if (platformName?.StartsWith(_targetOS, StringComparison.OrdinalIgnoreCase) != true)
-            return false;
-
-#if NETFRAMEWORK
-        string version = platformName.Substring(_targetOS.Length);
-#else
-        ReadOnlySpan<char> version = platformName.AsSpan(_targetOS.Length);
-#endif
-        return Version.TryParse(version, out _);
-    }
-}
-
-internal sealed class PInvokeCallbackComparer : IComparer<PInvokeCallback>
-{
-    public int Compare(PInvokeCallback? x, PInvokeCallback? y)
-    {
-        int compare = string.Compare(x!.Key, y!.Key, StringComparison.Ordinal);
-        return compare != 0 ? compare : (int)(x.Token - y.Token);
-    }
-}
-
-#pragma warning disable CS0649
-internal sealed class PInvokeCallback
-{
-    public PInvokeCallback(MethodInfo method)
-    {
-        Method = method;
-        var t = method.DeclaringType!;
-        TypeName = t.Name!;
-        TypeFullName = t.FullName!;
-        AssemblyName = t.Module!.Assembly!.GetName()!.Name!;
-        AssemblyFQName = t.Module!.Assembly!.GetName()!.FullName!;
-        // Nested types: the runtime reverse-thunk key (vm/wasm/helpers.cpp GetHashCode ->
-        // GetFullyQualifiedNameInfo) reports an empty namespace for nested types, so match that
-        // here or the emitted g_ReverseThunks key won't be found at lookup time (#130129).
-        // This key drops the enclosing-type chain, so nested types with the same simple name in
-        // different namespaces collide; the duplicate-key check in PInvokeTableGenerator
-        // (EmitNativeToInterp) turns that into a build error.
-        // Tracked by https://github.com/dotnet/runtime/issues/130739.
-        Namespace = t.IsNested ? string.Empty : t.Namespace;
-        MethodName = method.Name!;
-        ReturnType = method.ReturnType!;
-        IsVoid = ReturnType.Name == "Void";
-        Token = (uint)method.MetadataToken;
-
-        // FIXME: this is a hack, we need to encode this better and allow reflection in the interp case
-        // but either way it needs to match the key generated in get_native_to_interp since the key is
-        // used to look up the interp entry function. It must be unique for each callback runtime errors
-        // can occur since it is used to look up the index in the wasm_native_to_interp_ftndescs and
-        // the signature of the interp entry function must match the native signature
-        //
-        // the key also needs to survive being encoded in C literals, if in doubt
-        // add something like "\U0001F412" to the key on both the managed and unmanaged side
-        Key = $"{MethodName}#{Method.GetParameters().Length}:{AssemblyName}:{Namespace}:{TypeName}";
-
-        IsExport = false;
-        foreach (var attr in method.CustomAttributes)
-        {
-            if (attr.AttributeType.Name == "UnmanagedCallersOnlyAttribute")
-            {
-                foreach (var arg in attr.NamedArguments)
-                {
-                    if (arg.MemberName == "EntryPoint")
-                    {
-                        EntryPoint = arg.TypedValue.Value!.ToString();
-                        IsExport = true;
-                        return;
-                    }
-                }
-            }
-        }
-    }
-
-    public string EntryName => $"{AssemblyName}_{Namespace}_{TypeName}_{MethodName}";
-
-    public ParameterInfo[] Parameters => Method.GetParameters();
-    public string? EntryPoint { get; }
-    public MethodInfo Method { get; }
-    public string? EntrySymbol { get; set; }
-    public string AssemblyName { get; }
-    public string AssemblyFQName { get; }
-    public string TypeName { get; }
-    public string TypeFullName { get; }
-    public string? Namespace { get;}
-    public string MethodName { get; }
-    public Type ReturnType { get;}
-    public bool IsExport { get; }
-    public bool IsVoid { get; }
-    public uint Token { get; }
-    public string Key { get; }
-}
-#pragma warning restore CS0649
diff --git a/src/tasks/WasmAppBuilder/coreclr/PInvokeTableGenerator.cs b/src/tasks/WasmAppBuilder/coreclr/PInvokeTableGenerator.cs
deleted file mode 100644
index c0445d8b5e2788..00000000000000
--- a/src/tasks/WasmAppBuilder/coreclr/PInvokeTableGenerator.cs
+++ /dev/null
@@ -1,647 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Reflection;
-using System.Runtime.InteropServices;
-using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-using JoinedString;
-
-namespace Microsoft.WebAssembly.Build.Tasks.CoreClr;
-
-internal sealed class PInvokeTableGenerator
-{
-    private LogAdapter Log { get; set; }
-    private readonly Func<string, string> _fixupSymbolName;
-    private readonly HashSet<string> signatures = new();
-    private readonly List<PInvoke> pinvokes = new();
-    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, bool warnOnUnresolvedModules = true)
-    {
-        Log = log;
-        _fixupSymbolName = fixupSymbolName;
-        _pinvokeCollector = new(log, targetOS);
-        _isLibraryMode = isLibraryMode;
-        _warnOnUnresolvedModules = warnOnUnresolvedModules;
-    }
-
-    public void ScanAssembly(Assembly asm)
-    {
-        foreach (Type type in asm.GetTypes())
-            _pinvokeCollector.CollectPInvokes(pinvokes, callbacks, signatures, type);
-    }
-
-    public IEnumerable<string> Generate(string[] pinvokeModules, string[] ignoredPInvokeModules, string outputPathPInvoke, string outputPathReversePInvoke)
-    {
-        var ignoredModules = new HashSet<string>(ignoredPInvokeModules, StringComparer.Ordinal);
-        var modules = new SortedDictionary<string, string>(StringComparer.Ordinal);
-        foreach (var module in pinvokeModules)
-        {
-            if (!ignoredModules.Contains(module))
-                modules[module] = module;
-        }
-
-        foreach (var module in ignoredModules.OrderBy(module => module, StringComparer.Ordinal))
-            Log.LogMessage(MessageImportance.Low, $"Ignoring PInvoke module {module}");
-
-        using TempFileName tmpFileNamePInvoke = new();
-        using (var w = new JoinedStringStreamWriter(tmpFileNamePInvoke.Path, false))
-        {
-            EmitPInvokeTable(w, modules, ignoredModules, pinvokes);
-        }
-
-        using TempFileName tmpFileNameReversePInvoke = new();
-        using (var w = new JoinedStringStreamWriter(tmpFileNameReversePInvoke.Path, false))
-        {
-            EmitNativeToInterp(w, callbacks);
-        }
-
-        if (Utils.CopyIfDifferent(tmpFileNamePInvoke.Path, outputPathPInvoke, useHash: false))
-            Log.LogMessage(MessageImportance.Low, $"Generating pinvoke table to '{outputPathPInvoke}'.");
-        else
-            Log.LogMessage(MessageImportance.Low, $"PInvoke table in {outputPathPInvoke} is unchanged.");
-
-        if (Utils.CopyIfDifferent(tmpFileNameReversePInvoke.Path, outputPathReversePInvoke, useHash: false))
-            Log.LogMessage(MessageImportance.Low, $"Generating pinvoke reverse table to '{outputPathReversePInvoke}'.");
-        else
-            Log.LogMessage(MessageImportance.Low, $"PInvoke reverse table in {outputPathReversePInvoke} is unchanged.");
-
-        return signatures;
-    }
-
-    private void EmitPInvokeTable(StreamWriter w, SortedDictionary<string, string> modules, HashSet<string> ignoredModules, List<PInvoke> pinvokes)
-    {
-        // What actually gets linked in, captured before the scan below starts adding to modules.
-        // The lib-prefix fallback has to resolve against this rather than against modules, or an
-        // alias could be derived from another alias, or from a module that is only imported for
-        // [WasmImportLinkage] and has no archive behind it at all.
-        HashSet<string> linkedModules = new(modules.Keys, StringComparer.Ordinal);
-
-        foreach (var pinvoke in pinvokes)
-        {
-            if (modules.ContainsKey(pinvoke.Module))
-                continue;
-            if (ignoredModules.Contains(pinvoke.Module))
-                continue;
-            // A static archive is named libFoo.a, so the module list -- built from the file names
-            // of what gets linked in -- carries "libFoo", while the managed side spells the
-            // [DllImport] "Foo", the name it would use on Windows. That is also the name the
-            // runtime resolver looks up, so accept it as naming the same module.
-            if (linkedModules.Contains($"lib{pinvoke.Module}"))
-            {
-                modules.Add(pinvoke.Module, pinvoke.Module);
-                Log.LogMessage(MessageImportance.Low, $"Adding module {pinvoke.Module} for statically linked lib{pinvoke.Module}");
-                continue;
-            }
-            // Handle special modules, and add them to the list of modules
-            // otherwise, skip them and throw an exception at runtime if they
-            // are called.
-            if (pinvoke.WasmLinkage)
-            {
-                // WasmLinkage means we need to import the module
-                modules.Add(pinvoke.Module, pinvoke.Module);
-                Log.LogMessage(MessageImportance.Low, $"Adding module {pinvoke.Module} for WasmImportLinkage");
-            }
-            else if (pinvoke.Module == "*")
-            {
-                // Special case for * module to indicate static linking without specifying the module
-                modules.Add(pinvoke.Module, pinvoke.Module);
-                Log.LogMessage(MessageImportance.Low, $"Adding module {pinvoke.Module} for static linking");
-            }
-            else if (pinvoke.Module != "QCall")
-            {
-                // 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)." );
-            }
-        }
-
-        w.WriteLine(
-            $$"""
-            // Licensed to the .NET Foundation under one or more agreements.
-            // The .NET Foundation licenses this file to you under the MIT license.
-            //
-
-            //
-            // GENERATED FILE, DON'T EDIT
-            // Generated by coreclr callhelpers generator
-            //
-
-            #include <callhelpers.hpp>
-            #include <minipal/entrypoints.h>
-
-            extern "C" {
-            """);
-
-        var pinvokesGroupedByEntryPoint = pinvokes
-                                            .Where(l => modules.ContainsKey(l.Module))
-                                            .OrderBy(l => l.EntryPoint, StringComparer.Ordinal)
-                                            .GroupBy(CEntryPoint, StringComparer.Ordinal);
-        var comparer = new PInvokeComparer();
-        foreach (IGrouping<string, PInvoke> group in pinvokesGroupedByEntryPoint)
-        {
-            var candidates = group.Distinct(comparer).ToArray();
-            PInvoke first = candidates[0];
-            if (ShouldTreatAsVariadic(candidates))
-            {
-                string imports = string.Join(Environment.NewLine,
-                                            candidates.Select(
-                                                p => $"    {p.Method} (in [{p.Method.DeclaringType?.Assembly.GetName().Name}] {p.Method.DeclaringType})"));
-                Log.Warning("WASM0001", $"Found a native function ({first.EntryPoint}) with varargs in {first.Module}." +
-                                 " Calling such functions is not supported, and will fail at runtime." +
-                                $" Managed DllImports: {Environment.NewLine}{imports}");
-
-                foreach (var c in candidates)
-                    c.Skip = true;
-
-                continue;
-            }
-
-            var decls = new HashSet<string>();
-            foreach (var candidate in candidates)
-            {
-                var decl = GenPInvokeDecl(candidate);
-                if (decl is null || decls.Contains(decl))
-                    continue;
-
-                w.WriteLine(decl);
-                decls.Add(decl);
-            }
-        }
-
-        w.Write(
-            $$"""
-            } // extern "C"
-
-            """);
-
-        var moduleImports = new Dictionary<string, List<string>>();
-        foreach (var module in modules.Keys)
-        {
-            // the order here is not important, because we use hash tables, we want it to be stable though
-            var imports = pinvokes
-                .Where(l => l.Module == module && !l.Skip)
-                .OrderBy(l => l.EntryPoint, StringComparer.Ordinal)
-                .GroupBy(d => d.EntryPoint, StringComparer.Ordinal)
-                .Select(l =>
-                {
-                    PInvoke p = l.First();
-                    // Runtime resolver looks up by managed EntryPoint.
-                    // [WasmImportLinkage] mangles the C symbol per module,
-                    // so emit the entry-point string explicitly rather than
-                    // stringifying the mangled name via DllImportEntry.
-                    if (p.WasmLinkage)
-                        return $"    {{ \"{EscapeLiteral(p.EntryPoint)}\", (void*)&{CEntryPoint(p)} }}, // {ListRefs(l)}{w.NewLine}";
-                    return $"    DllImportEntry({CEntryPoint(p)}) // {ListRefs(l)}{w.NewLine}";
-                })
-                .ToList();
-
-            moduleImports[module] = imports;
-            w.Write(
-                $$"""
-
-                static const Entry s_{{_fixupSymbolName(module)}} [] = {
-                {{string.Join("", imports)}}};
-
-                """);
-        }
-
-        w.Write(
-            $$"""
-
-            typedef struct PInvokeTable {
-                const char* LibraryName;
-                const Entry* Entries;
-                size_t EntryCount;
-            } PInvokeTable;
-
-            static PInvokeTable s_PInvokeTables[] = {
-                {{modules.Keys.Join($",{w.NewLine}    ", m => $"{{\"{EscapeLiteral(m)}\", s_{_fixupSymbolName(m)}, {moduleImports[m].Count}}}")}}
-            };
-            const size_t s_PInvokeTablesCount = sizeof(s_PInvokeTables) / sizeof(s_PInvokeTables[0]);
-
-            const void* callhelpers_pinvoke_override(const char* library_name, const char* entry_point_name)
-            {
-                for (size_t i = 0; i < s_PInvokeTablesCount; i++)
-                {
-                    if (strcmp(library_name, s_PInvokeTables[i].LibraryName) == 0)
-                    {
-                        LOG((LF_INTEROP, LL_INFO1000, "Wasm callhelpers PInvoke override for: lib: %s, entry: %s \n", library_name, entry_point_name));
-                        return minipal_resolve_dllimport(s_PInvokeTables[i].Entries, s_PInvokeTables[i].EntryCount, entry_point_name);
-                    }
-                }
-
-                return nullptr;
-            }
-
-            """);
-
-        static bool ShouldTreatAsVariadic(PInvoke[] candidates)
-        {
-            if (candidates.Length < 2)
-                return false;
-
-            PInvoke first = candidates[0];
-            if (!TryIsMethodGetParametersSupported(first.Method, out _))
-                return false;
-
-            int firstNumArgs = first.Method.GetParameters().Length;
-            return candidates
-                        .Skip(1)
-                        // detect possible vararg entrypoint usage
-                        // where the same entrypoint is used with different
-                        // number of arguments
-                        .Any(c => TryIsMethodGetParametersSupported(c.Method, out _) &&
-                                    c.Method.GetParameters().Length != firstNumArgs);
-        }
-
-        static string ListRefs(IGrouping<string, PInvoke> l) =>
-            string.Join(", ", l.Select(c => c.Method.DeclaringType!.Module!.Assembly!.GetName()!.Name!).Distinct().OrderBy(n => n));
-    }
-
-    private string CEntryPoint(PInvoke pinvoke)
-    {
-        if (pinvoke.WasmLinkage)
-        {
-            // We mangle the name to avoid collisions with symbols in other modules
-            string namespaceName = pinvoke.Method.DeclaringType?.Namespace ?? string.Empty;
-            return _fixupSymbolName($"{namespaceName}#{pinvoke.Module}#{pinvoke.EntryPoint}");
-        }
-        return _fixupSymbolName(pinvoke.EntryPoint);
-    }
-
-    private static string MapType(Type t) => t.Name switch
-    {
-        "Void" => "void",
-        nameof(Double) => "double",
-        nameof(Single) => "float",
-        nameof(Int64) => "int64_t",
-        nameof(UInt64) => "uint64_t",
-        nameof(Int32) => "int32_t",
-        nameof(UInt32) => "uint32_t",
-        nameof(Int16) => "int32_t",
-        nameof(UInt16) => "uint32_t",
-        nameof(Char) => "int32_t",
-        nameof(Boolean) => "int32_t",
-        nameof(SByte) => "int32_t",
-        nameof(Byte) => "uint32_t",
-        nameof(IntPtr) => "void *",
-        nameof(UIntPtr) => "void *",
-        _ => PickCTypeNameForUnknownType(t)
-    };
-
-    private static string PickCTypeNameForUnknownType(Type t)
-    {
-        // Pass objects by-reference (their address by-value)
-        if (!t.IsValueType)
-            return "void *";
-        // Pass pointers and function pointers by-value
-        else if (t.IsPointer || IsFunctionPointer(t))
-            return "void *";
-        else if (t.IsPrimitive)
-            throw new NotImplementedException("No native type mapping for type " + t);
-
-        // https://github.com/WebAssembly/tool-conventions/blob/main/BasicCABI.md#function-signatures
-        // Any struct or union that recursively (including through nested structs, unions, and arrays)
-        //  contains just a single scalar value and is not specified to have greater than natural alignment.
-        // FIXME: Handle the scenario where there are fields of struct types that contain no members
-        var fields = t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
-        if (fields.Length == 1)
-            return MapType(fields[0].FieldType);
-        else
-            return "void *";
-    }
-
-    // FIXME: System.Reflection.MetadataLoadContext can't decode function pointer types
-    // https://github.com/dotnet/runtime/issues/43791
-    private static bool TryIsMethodGetParametersSupported(MethodInfo method, [NotNullWhen(false)] out string? reason)
-    {
-        try
-        {
-            method.GetParameters();
-        }
-        catch (NotSupportedException nse)
-        {
-            reason = nse.Message;
-            return false;
-        }
-        catch
-        {
-            // not concerned with other exceptions
-        }
-
-        reason = null;
-        return true;
-    }
-
-    private string? GenPInvokeDecl(PInvoke pinvoke)
-    {
-        var method = pinvoke.Method;
-
-        if (!TryIsMethodGetParametersSupported(pinvoke.Method, out string? reason))
-        {
-            // Don't use method.ToString() or any of it's parameters, or return type
-            // because at least one of those are unsupported, and will throw
-            Log.Warning("WASM0001", $"Skipping pinvoke '{pinvoke.Method.DeclaringType!.FullName}::{pinvoke.Method.Name}' because '{reason}'.");
-
-            pinvoke.Skip = true;
-            return null;
-        }
-
-        var realReturnType = method.ReturnType;
-        var realParameterTypes = method.GetParameters().Select(p => MapType(p.ParameterType)).ToList();
-
-        SignatureMapper.TypeToChar(realReturnType, Log, out bool resultIsByRef);
-        if (resultIsByRef) {
-            realReturnType = typeof(void);
-            realParameterTypes.Insert(0, "void *");
-        }
-
-        var importAttributes = pinvoke.WasmLinkage
-            ? $"__attribute__((import_module(\"{EscapeLiteral(pinvoke.Module)}\"),import_name(\"{EscapeLiteral(pinvoke.EntryPoint)}\"))) "
-            : "";
-        var externKeyword = pinvoke.WasmLinkage ? "extern " : "";
-
-        return $"    {importAttributes}{externKeyword}{MapType(realReturnType)} {CEntryPoint(pinvoke)} ({string.Join(", ", realParameterTypes)});";
-    }
-
-    private static string EscapeLiteral(string? input)
-    {
-        if (input == null)
-            return string.Empty;
-
-        StringBuilder sb = new StringBuilder();
-
-        for (int i = 0; i < input.Length; i++)
-        {
-            char c = input[i];
-
-            sb.Append(c switch
-            {
-                '\\' => "\\\\",
-                '\"' => "\\\"",
-                '\n' => "\\n",
-                '\r' => "\\r",
-                '\t' => "\\t",
-                // take special care with surrogate pairs to avoid
-                // potential decoding issues in generated C literals
-                _ when char.IsHighSurrogate(c) && i + 1 < input.Length && char.IsLowSurrogate(input[i + 1])
-                    => $"\\U{char.ConvertToUtf32(c, input[++i]):X8}",
-                _ when char.IsControl(c) || c > 127
-                    => $"\\u{(int)c:X4}",
-                _ => c.ToString()
-            });
-        }
-
-        return sb.ToString();
-    }
-
-    // this is eqivalent to `ULONG HashString(LPCWSTR szStr)` in CoreCLR runtime, src/coreclr/inc/utilcode.h
-    private static uint HashString(string str)
-    {
-        uint hash = 5381;
-        foreach (char c in str)
-        {
-            hash = ((hash << 5) + hash) ^ (uint)c;
-        }
-
-        return hash;
-    }
-
-    private void EmitNativeToInterp(StreamWriter w, List<PInvokeCallback> callbacks)
-    {
-        // Generate native->interp entry functions
-        // These are called by native code, so they need to obtain
-        // the interp entry function/arg from a global array
-        // They also need to have a signature matching what the
-        // native code expects, which is the native signature
-        // of the delegate invoke in the [MonoPInvokeCallback]
-        // or [UnmanagedCallersOnly] attribute.
-        // Only blittable parameter/return types are supposed.
-        w.Write(
-            $$"""
-            // Licensed to the .NET Foundation under one or more agreements.
-            // The .NET Foundation licenses this file to you under the MIT license.
-            //
-
-            //
-            // GENERATED FILE, DON'T EDIT
-            // Generated by coreclr callhelpers generator
-            //
-
-            #include <callhelpers.hpp>
-
-            // WASM-TODO: The method lookup would ideally be fully qualified assembly and then methodDef token.
-            // The current approach has limitations with overloaded methods.
-            extern "C" void LookupUnmanagedCallersOnlyMethodByName(const char* fullQualifiedTypeName, const char* methodName, MethodDesc** ppMD);
-            extern "C" void ExecuteInterpretedMethodFromUnmanaged(MethodDesc* pMD, int8_t* args, size_t argSize, int8_t* ret, PCODE callerIp);
-
-            """);
-
-        var callbackNames = new HashSet<string>();
-        var keys = new HashSet<string>();
-        int cb_index = 0;
-        callbacks = callbacks.OrderBy(c => c, new PInvokeCallbackComparer()).ToList();
-        foreach (var cb in callbacks)
-        {
-            cb.EntrySymbol = FixedSymbolName(cb, Log);
-
-            if (callbackNames.Contains(cb.EntrySymbol))
-            {
-                Error($"Two callbacks with the same symbol '{cb.EntrySymbol}' are not supported.");
-            }
-            callbackNames.Add(cb.EntrySymbol);
-            if (keys.Contains(cb.Key))
-            {
-                Error($"Two callbacks with the same Name and number of arguments '{cb.Key}' are not supported.");
-            }
-            keys.Add(cb.Key);
-
-            // The signature of the interp entry function
-            // This is a gsharedvt_in signature
-            var entryArgs = new List<string>();
-            if (!cb.IsVoid)
-            {
-                entryArgs.Add("(int*)&result");
-            }
-            entryArgs.AddRange(cb.Parameters.Select((_, i) => $"(int*)&arg{i}"));
-            entryArgs.Add($"(int*)wasm_native_to_interp_ftndescs [{cb_index}].arg");
-
-            var argsArgs = cb.Parameters.Length > 0 ? "(int8_t*)args, sizeof(args)" : "nullptr, 0";
-            var argsDeclaration = cb.Parameters.Length > 0
-                ? $"\n    int64_t args[{cb.Parameters.Length}] = {{ {cb.Parameters.Join(", ", (info, i) => $"(int64_t)arg{i}")} }};\n"
-                : string.Empty;
-            var parametersDeclaration = cb.Parameters.Join(", ", (info, i) => $"{MapType(info.ParameterType)} arg{i}");
-            var exportFunction = cb.IsExport ?
-                $$"""
-
-
-                extern "C" {{MapType(cb.ReturnType)}} {{cb.EntryPoint}}({{parametersDeclaration}})
-                {
-                    {{(cb.IsVoid ? "" : "return ")}}Call_{{cb.EntrySymbol}}({{cb.Parameters.Join(", ", (info, i) => $"arg{i}")}});
-                }
-                """ : string.Empty;
-            w.Write(
-                $$"""
-
-                static MethodDesc* MD_{{cb.EntrySymbol}} = nullptr;
-                static {{
-                MapType(cb.ReturnType)}} Call_{{cb.EntrySymbol}}({{parametersDeclaration}})
-                {{{argsDeclaration}}
-                    // Lazy lookup of MethodDesc for the function export scenario.
-                    if (!MD_{{cb.EntrySymbol}})
-                    {
-                        LookupUnmanagedCallersOnlyMethodByName("{{cb.TypeFullName}}, {{cb.AssemblyName}}", "{{cb.MethodName}}", &MD_{{cb.EntrySymbol}});
-                    }{{
-                    (!cb.IsVoid ? $"{w.NewLine}{w.NewLine}    {MapType(cb.ReturnType)} result;" : "")}}
-                    ExecuteInterpretedMethodFromUnmanaged(MD_{{cb.EntrySymbol}}, {{argsArgs}}, {{(cb.IsVoid ? "nullptr" : "(int8_t*)&result")}}, (PCODE)&Call_{{cb.EntrySymbol}});{{
-                    (!cb.IsVoid ? $"{w.NewLine}    return result;" : "")}}
-                }{{exportFunction}}
-
-                """);
-            cb_index++;
-        }
-
-        w.Write(
-            $$"""
-
-            const ReverseThunkMapEntry g_ReverseThunks[] =
-            {
-            {{callbacks.Join($",{w.NewLine}", cb => ThunkMapEntryLine(cb, Log))}}
-            };
-
-            const size_t g_ReverseThunksCount = sizeof(g_ReverseThunks) / sizeof(g_ReverseThunks[0]);
-
-            """);
-    }
-
-    private string FixedSymbolName(PInvokeCallback cb, LogAdapter Log)
-    {
-        var paramTypes = cb.Parameters.Length > 0 ? cb.Parameters.Join("_", (info, i) => SignatureMapper.TypeToNameType(info.ParameterType, Log)).ToString() : "Void";
-        var sig = $"{paramTypes}_Ret{SignatureMapper.TypeToNameType(cb.ReturnType, Log)}";
-
-        return _fixupSymbolName($"{cb.EntryName}_{sig}");
-    }
-
-
-    private string ThunkMapEntryLine(PInvokeCallback cb, LogAdapter Log)
-    {
-        var fsName = FixedSymbolName(cb, Log);
-
-        return $"    {{ {HashString(cb.Key)}, \"{EscapeLiteral(cb.Key)}\", {{ &MD_{fsName}, (void*)&Call_{cb.EntrySymbol} }} }}";
-    }
-
-    private static readonly Dictionary<Type, bool> _blittableCache = new();
-
-    public static bool IsFunctionPointer(Type type)
-    {
-        object? bIsFunctionPointer = type.GetType().GetProperty("IsFunctionPointer")?.GetValue(type);
-        return (bIsFunctionPointer is bool b) && b;
-    }
-
-    public static bool IsBlittable(Type type, LogAdapter log)
-    {
-        // We maintain a cache of results in order to only produce log messages the first time
-        //  we analyze a given type. Otherwise, each (successful) use of a user-defined type
-        //  in a callback or pinvoke would generate duplicate messages.
-        lock (_blittableCache)
-            if (_blittableCache.TryGetValue(type, out bool blittable))
-                return blittable;
-
-        bool result = IsBlittableUncached(type, log);
-        lock (_blittableCache)
-            _blittableCache[type] = result;
-        return result;
-
-        static bool IsBlittableUncached(Type type, LogAdapter log)
-        {
-            if (type.IsPrimitive || type.IsByRef || type.IsPointer || type.IsEnum)
-                return true;
-
-            if (IsFunctionPointer(type))
-                return true;
-
-            // HACK: SkiaSharp has pinvokes that rely on this
-            if (HasAttribute(type, "System.Runtime.InteropServices.UnmanagedFunctionPointerAttribute"))
-                return true;
-
-            if (type.Name == "__NonBlittableTypeForAutomatedTests__")
-                return false;
-
-            if (!type.IsValueType)
-            {
-                log.InfoHigh("WASM0060", "Type {0} is not blittable: Not a ValueType", type);
-                return false;
-            }
-
-            var fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
-
-            if (!type.IsLayoutSequential && (fields.Length > 1))
-            {
-                log.InfoHigh("WASM0061", "Type {0} is not blittable: LayoutKind is not Sequential", type);
-                return false;
-            }
-
-            foreach (var ft in fields)
-            {
-                if (!IsBlittable(ft.FieldType, log))
-                {
-                    log.InfoHigh("WASM0062", "Type {0} is not blittable: Field {1} is not blittable", type, ft.Name);
-                    return false;
-                }
-                // HACK: Skip literals since they're complicated
-                // Ideally we would block initonly fields too since the callee could mutate them, but
-                //  we rely on being able to pass types like System.Guid which are readonly
-                if (ft.IsLiteral)
-                {
-                    log.InfoHigh("WASM0063", "Type {0} is not blittable: Field {1} is literal", type, ft.Name);
-                    return false;
-                }
-            }
-
-            return true;
-        }
-    }
-
-    public static bool HasAttribute(MemberInfo element, params string[] attributeNames)
-    {
-        foreach (CustomAttributeData cattr in CustomAttributeData.GetCustomAttributes(element))
-        {
-            try
-            {
-                for (int i = 0; i < attributeNames.Length; ++i)
-                {
-                    if (cattr.AttributeType.FullName == attributeNames[i] ||
-                        cattr.AttributeType.Name == attributeNames[i])
-                    {
-                        return true;
-                    }
-                }
-            }
-            catch
-            {
-                // Assembly not found, ignore
-            }
-        }
-        return false;
-    }
-
-    private static void Error(string msg) => throw new LogAsErrorException(msg);
-}
diff --git a/src/tasks/WasmAppBuilder/coreclr/SignatureMapper.cs b/src/tasks/WasmAppBuilder/coreclr/SignatureMapper.cs
deleted file mode 100644
index c1f07ec01067d9..00000000000000
--- a/src/tasks/WasmAppBuilder/coreclr/SignatureMapper.cs
+++ /dev/null
@@ -1,402 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Runtime.InteropServices;
-using System.Text;
-
-namespace Microsoft.WebAssembly.Build.Tasks.CoreClr;
-
-// Computes Wasm signature strings from reflection metadata.
-// The signature string format is documented in docs/design/coreclr/botr/readytorun-format.md
-// (section "Wasm Signature String Encoding").
-internal static class SignatureMapper
-{
-    // Hardcoded struct layouts for types that crossgen2 encodes as struct tokens.
-    // The fully general case is handled by crossgen2's type system; these
-    // cover the small set of multi-field structs that appear in InternalCall
-    // and PInvoke signatures.
-    private static readonly Dictionary<string, (int Size, int Alignment)> s_knownStructLayouts = new()
-    {
-        ["System.Runtime.CompilerServices.QCallModule"] = (8, 8),
-        ["System.Runtime.CompilerServices.QCallAssembly"] = (8, 8),
-        ["System.Runtime.CompilerServices.QCallTypeHandle"] = (8, 8),
-        ["System.GC+GCHeapHardLimitInfo"] = (64, 8),
-        // Used by WBT tests
-        ["WasmAppBuilderTestsPairStruct"] = (8, 8),
-        ["WasmAppBuilderTests.S"] = (8, 8),
-        ["WasmAppBuilderTests.Test+S"] = (8, 8),
-    };
-
-    private static char? TypeToChar(
-        Type t,
-        LogAdapter log,
-        out bool isByRefStruct,
-        out int structSize,
-        out int structAlignment,
-        int depth = 0)
-    {
-        isByRefStruct = false;
-        structSize = 0;
-        structAlignment = 0;
-
-        if (depth > 5) {
-            log.Warning("WASM0064", $"Unbounded recursion detected through parameter type '{t.Name}'");
-            return null;
-        }
-
-        // See https://github.com/WebAssembly/tool-conventions/blob/main/BasicCABI.md
-        char? c = null;
-        if (t.Namespace == "System")
-        {
-            c = t.Name switch
-            {
-                nameof(String) => 'i',
-                nameof(Boolean) => 'i',
-                nameof(Char) => 'i',
-                nameof(SByte) => 'i',
-                nameof(Byte) => 'i',
-                nameof(Int16) => 'i',
-                nameof(UInt16) => 'i',
-                nameof(Int32) => 'i',
-                nameof(UInt32) => 'i',
-                nameof(Int64) => 'l',
-                nameof(UInt64) => 'l',
-                nameof(Single) => 'f',
-                nameof(Double) => 'd',
-                // FIXME: These will need to be L for wasm64
-                nameof(IntPtr) => 'i',
-                nameof(UIntPtr) => 'i',
-                "Void" => 'v',
-                _ => null
-            };
-        }
-
-        if (c != null)
-            return c;
-
-        // FIXME: Most of these need to be L for wasm64
-        if (t.IsByRef)
-            c = 'i';
-        else if (t.IsClass)
-            c = 'i';
-        else if (t.IsInterface)
-            c = 'i';
-        else if (t.IsEnum)
-        {
-            Type underlyingType = t.GetEnumUnderlyingType();
-            c = TypeToChar(underlyingType, log, out _, out structSize, out structAlignment, ++depth);
-        }
-        else if (t.IsPointer)
-            c = 'i';
-        else if (PInvokeTableGenerator.IsFunctionPointer(t))
-            c = 'i';
-        else if (t.IsValueType)
-        {
-            var fields = t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
-            if (fields.Length == 1)
-            {
-                Type fieldType = fields[0].FieldType;
-                return TypeToChar(fieldType, log, out isByRefStruct, out structSize, out structAlignment, ++depth);
-            }
-            else
-            {
-                string fullName = t.FullName ?? t.Name;
-                if (s_knownStructLayouts.TryGetValue(fullName, out (int Size, int Alignment) layout))
-                {
-                    structSize = layout.Size;
-                    structAlignment = layout.Alignment;
-                }
-                else
-                {
-                    log.Error("WASM0067",
-                        $"SignatureMapper: unknown multi-field struct '{fullName}' (fields: {fields.Length}) — add its layout to s_knownStructLayouts in SignatureMapper.cs");
-                    return null;
-                }
-
-                c = 'S';
-            }
-
-            isByRefStruct = true;
-        }
-        else
-            log.Warning("WASM0065", $"Unsupported parameter type '{t.Name}'");
-
-        return c;
-    }
-
-    internal static char? TypeToChar(Type t, LogAdapter log, out bool isByRefStruct, out int structSize, int depth = 0)
-        => TypeToChar(t, log, out isByRefStruct, out structSize, out _, depth);
-
-    internal static char? TypeToChar(Type t, LogAdapter log, out bool isByRefStruct, int depth = 0)
-        => TypeToChar(t, log, out isByRefStruct, out _, depth);
-
-    /// <summary>
-    /// Builds the multi-char token for a type in the signature string.
-    /// For most types this is a single character; for multi-field structs it is a struct token.
-    /// </summary>
-    private static string? TypeToSignatureToken(Type t, LogAdapter log, out bool isByRefStruct, bool isReturn = false)
-    {
-        // Types the wasm ABI splits across several by-value slots are rejected in interop rather
-        // than encoded. Exposing them here means teaching the thunk generator that one signature
-        // token can map to several native parameters, which is a larger design question; today no
-        // InternalCall or PInvoke signature uses one.
-        if (IsMultiSlotType(t))
-        {
-            log.Error("WASM0068",
-                $"SignatureMapper: '{t.FullName ?? t.Name}' is passed across multiple wasm slots, which interop signatures do not support");
-            isByRefStruct = false;
-            return null;
-        }
-
-        char? c = TypeToChar(t, log, out isByRefStruct, out int structSize, out int structAlignment);
-        if (c is null)
-            return null;
-
-        if (c == 'S' && structSize > 0)
-            return $"{(!isReturn && structAlignment > 8 ? 'A' : 'S')}{structSize}";
-
-        return c.Value.ToString();
-    }
-
-    /// <summary>
-    /// True for a type the wasm ABI passes across several by-value slots: Int128/UInt128 and
-    /// Decimal128 as i64 slots, a 256- or 512-bit vector as v128 slots. A single-field wrapper is
-    /// passed as the type it wraps, so unwrap first, exactly as crossgen2 and the runtime do.
-    /// </summary>
-    private static bool IsMultiSlotType(Type t)
-    {
-        for (int depth = 0; depth <= 5; depth++)
-        {
-            switch (t.Namespace, t.Name)
-            {
-                case ("System", "Int128"):
-                case ("System", "UInt128"):
-                case ("System.Numerics", "Decimal128"):
-                    return true;
-                case ("System.Runtime.Intrinsics", "Vector256`1") when HasNumericElementType(t):
-                case ("System.Runtime.Intrinsics", "Vector512`1") when HasNumericElementType(t):
-                    return true;
-            }
-
-            if (!t.IsValueType || t.IsPrimitive || t.IsEnum)
-            {
-                return false;
-            }
-
-            // Only unwrap a wrapper its field fills exactly. Sizes cannot be measured here: these
-            // types come from a MetadataLoadContext, where Marshal.SizeOf always throws. A single
-            // field fills its struct unless the struct sets a size of its own or places the field
-            // at an offset, so treat either as padded and keep the struct ABI.
-            FieldInfo[] fields = t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
-            if (fields.Length != 1 ||
-                t.StructLayoutAttribute is not { Size: 0, Value: not LayoutKind.Explicit })
-            {
-                return false;
-            }
-
-            t = fields[0].FieldType;
-        }
-
-        return false;
-    }
-
-    /// <summary>
-    /// The other two encoders only treat a vector as a sequence of wasm values when its element type
-    /// is a primitive numeric, so Vector256&lt;bool&gt; and Vector256&lt;char&gt; use the struct ABI.
-    /// </summary>
-    private static bool HasNumericElementType(Type t)
-    {
-        Type[] arguments = t.GetGenericArguments();
-        if (arguments.Length != 1)
-        {
-            return false;
-        }
-
-        // An enum reports its underlying numeric type code, but crossgen2 and the runtime both
-        // reject enums as a vector element type.
-        if (arguments[0].IsEnum)
-        {
-            return false;
-        }
-
-        return Type.GetTypeCode(arguments[0]) is >= TypeCode.SByte and <= TypeCode.Double
-            || arguments[0] == typeof(IntPtr) || arguments[0] == typeof(UIntPtr);
-    }
-
-    public static string? MethodToSignature(MethodInfo method, LogAdapter log, bool includeThis = false)
-    {
-        string? returnToken = TypeToSignatureToken(method.ReturnType, log, out bool resultIsByRef, isReturn: true);
-        if (returnToken is null)
-            return null;
-
-        var sb = new StringBuilder();
-
-        if (resultIsByRef)
-        {
-            // Struct return — encode as S<N> (the return type token already has the size)
-            sb.Append(returnToken);
-        }
-        else
-        {
-            sb.Append(returnToken);
-        }
-
-        if (includeThis && !method.IsStatic)
-        {
-            sb.Append('T');
-        }
-
-        foreach (var parameter in method.GetParameters())
-        {
-            string? paramToken = TypeToSignatureToken(parameter.ParameterType, log, out _);
-            if (paramToken is null)
-                return null;
-
-            sb.Append(paramToken);
-        }
-
-        return sb.ToString();
-    }
-
-    /// <summary>
-    /// Parses a signature string into individual tokens.
-    /// Single-char types produce one-char tokens; struct encodings produce multi-char tokens like
-    /// "S8" or "A32", and a multi-slot parameter produces a two-char token like "l2" or "V4".
-    /// The 'a' and 'p' suffixes are included as their own tokens.
-    /// </summary>
-    public static List<string> ParseSignatureTokens(string signature)
-    {
-        var tokens = new List<string>();
-        int i = 0;
-        while (i < signature.Length)
-        {
-            if (signature[i] is 'S' or 'A')
-            {
-                int start = i;
-                i++; // skip 'S'/'A'
-                while (i < signature.Length && char.IsDigit(signature[i]))
-                    i++;
-                tokens.Add(signature.Substring(start, i - start));
-            }
-            else if (signature[i] is 'l' or 'V' && i + 1 < signature.Length && char.IsDigit(signature[i + 1]))
-            {
-                tokens.Add(signature.Substring(i, 2));
-                i += 2;
-            }
-            else
-            {
-                tokens.Add(signature[i].ToString());
-                i++;
-            }
-        }
-
-        return tokens;
-    }
-
-    /// <summary>
-    /// True for a token describing a type passed by value across several wasm parameters
-    /// ("l2", "V2", "V4"). Interop signatures do not use these today.
-    /// </summary>
-    private static bool IsMultiSlotToken(string token)
-        => token.Length == 2 && token[0] is 'l' or 'V' && char.IsDigit(token[1]);
-
-    private static void RejectMultiSlotToken(string token)
-    {
-        if (IsMultiSlotToken(token))
-            throw new NotSupportedException($"Multi-slot signature token '{token}' is not supported in interop thunks");
-    }
-
-    public static string TokenToNativeType(string token)
-    {
-        RejectMultiSlotToken(token);
-        return token[0] switch
-        {
-            'v' => "void",
-            'i' => "int32_t",
-            'l' => "int64_t",
-            'f' => "float",
-            'd' => "double",
-            'S' or 'A' => "int32_t",
-            'T' => "int32_t",
-            'p' => "PCODE",
-            _ => throw new InvalidSignatureCharException(token[0])
-        };
-    }
-
-    public static string TokenToNameType(string token)
-    {
-        RejectMultiSlotToken(token);
-        return token[0] switch
-        {
-            'v' => "Void",
-            'i' => "I32",
-            'l' => "I64",
-            'f' => "F32",
-            'd' => "F64",
-            'S' or 'A' => token,
-            'T' => "This",
-            'p' => "PE",
-            _ => throw new InvalidSignatureCharException(token[0])
-        };
-    }
-
-    public static string TokenToArgType(string token)
-    {
-        RejectMultiSlotToken(token);
-        return token[0] switch
-        {
-            'i' => "ARG_I32",
-            'l' => "ARG_I64",
-            'f' => "ARG_F32",
-            'd' => "ARG_F64",
-            'S' or 'A' => "ARG_IND",
-            'T' => "ARG_I32",
-            _ => throw new InvalidSignatureCharException(token[0])
-        };
-    }
-
-    /// <summary>
-    /// Returns the number of INTERP_STACK_SLOT_SIZE slots consumed by a token.
-    /// Struct tokens consume max((size + 7) / 8, 1) slots; all others consume 1.
-    /// </summary>
-    public static int TokenToSlotCount(string token)
-    {
-        if (token[0] is not ('S' or 'A') || token.Length < 2)
-            return 1;
-
-        int size = GetStructSize(token);
-        return Math.Max((size + 7) / 8, 1);
-    }
-
-    internal static int GetStructSize(string token)
-    {
-        return int.Parse(token.Substring(1));
-    }
-
-    // Legacy single-char overloads — still used by consumers that don't encounter S<N> tokens.
-    public static string CharToNativeType(char c) => TokenToNativeType(c.ToString());
-    public static string CharToNameType(char c) => TokenToNameType(c.ToString());
-    public static string CharToArgType(char c) => TokenToArgType(c.ToString());
-
-    public static string TypeToNameType(Type t, LogAdapter log)
-    {
-        char? c = TypeToChar(t, log, out _);
-        if (c is null)
-            throw new InvalidSignatureCharException('?');
-
-        return CharToNameType(c.Value);
-    }
-
-    public static bool IsVoidSignature(string signature) => signature[0] == 'v';
-}
-
-internal sealed class InvalidSignatureCharException : Exception
-{
-    public char Char { get; private set; }
-
-    public InvalidSignatureCharException(char c) : base($"Can't handle signature '{c}'") => Char = c;
-}
diff --git a/src/tasks/WasmAppBuilder/generate-coreclr-helpers.md b/src/tasks/WasmAppBuilder/generate-coreclr-helpers.md
deleted file mode 100644
index e5dcefabb04430..00000000000000
--- a/src/tasks/WasmAppBuilder/generate-coreclr-helpers.md
+++ /dev/null
@@ -1,85 +0,0 @@
-# Generating CoreCLR WebAssembly call helpers
-
-The `generate-coreclr-helpers.cmd` (Windows) and `generate-coreclr-helpers.sh` (Linux/macOS)
-scripts in this directory regenerate the checked-in CoreCLR call-helper source files used by the
-WebAssembly runtime. They run the `RunGenerator` target in
-[`WasmAppBuilder.csproj`](./WasmAppBuilder.csproj), which invokes the
-`ManagedToNativeGenerator` MSBuild task to scan the managed framework assemblies and emit the
-native P/Invoke, reverse-P/Invoke, and interpreter-to-managed call helpers.
-
-The scripts generate **both** WebAssembly variations:
-
-| Target OS | Output directory                | Default scan path (testhost) |
-|-----------|---------------------------------|------------------------------|
-| `browser` | `src/coreclr/vm/wasm/browser/`  | `artifacts/bin/testhost/net11.0-browser-<config>-wasm/shared/Microsoft.NETCore.App/11.0.0/` |
-| `wasi`    | `src/coreclr/vm/wasm/wasi/`     | `artifacts/bin/testhost/net11.0-wasi-<config>-wasm/shared/Microsoft.NETCore.App/11.0.0/` |
-
-Each run emits three files into the output directory:
-
-- `callhelpers-pinvoke.cpp`
-- `callhelpers-reverse.cpp`
-- `callhelpers-interp-to-managed.cpp`
-
-## The P/Invoke module list
-
-Only the framework native libraries listed in
-[`eng/wasm/WasmPInvokeModules.props`](../../../eng/wasm/WasmPInvokeModules.props) get an entry in
-the generated P/Invoke table. The runtime tests share that list — `CLRTest.WasmCorerun.targets`
-generates equivalent tables of its own when it links a test-specific corerun. Adding a module there
-means rerunning these scripts and committing the regenerated files in the same change.
-
-## What needs to be built first
-
-The generator scans the **managed framework assemblies** in the `testhost` folder produced by a
-`clr+libs` build. Because the scripts generate both the `browser` and `wasi` variations, you must
-build **both** WebAssembly flavors before running them. The first build of either flavor also
-downloads and provisions the Emscripten SDK (emsdk) automatically.
-
-From the repository root:
-
-**Windows:**
-```cmd
-.\build.cmd clr+libs -os browser -c Debug
-.\build.cmd clr+libs -os wasi    -c Debug
-```
-
-**Linux/macOS:**
-```bash
-./build.sh clr+libs -os browser -c Debug
-./build.sh clr+libs -os wasi    -c Debug
-```
-
-Notes:
-
-- Use a matching `-c <Debug|Release|Checked>` for the configuration you intend to pass to the
-  generator script (the script derives the scan path from the configuration name).
-- The `WasmAppBuilder` task itself is built on demand by the generator script (the `RunGenerator`
-  target depends on `Build`), so you do not need to build it separately.
-- If a required `testhost` scan path is missing, the script stops and prints the exact
-  `build` command needed to produce it.
-
-## Running the generator
-
-Once both flavors are built, run the script from anywhere (it resolves the repo root itself):
-
-**Windows:**
-```cmd
-src\tasks\WasmAppBuilder\generate-coreclr-helpers.cmd -c Debug
-```
-
-**Linux/macOS:**
-```bash
-src/tasks/WasmAppBuilder/generate-coreclr-helpers.sh -c Debug
-```
-
-### Options
-
-| Option | Description |
-|--------|-------------|
-| `-c`, `--configuration <Checked\|Debug\|Release>` | Build configuration (default: `Debug`). Determines the default scan paths. |
-| `-s`, `--scan-path <path>` | Override the default **browser** scan path. |
-| `-w`, `--wasi-scan-path <path>` | Override the default **wasi** scan path. |
-| `-h`, `--help` | Show usage. |
-
-After running, review and commit any changes to the generated files under
-`src/coreclr/vm/wasm/browser/` and `src/coreclr/vm/wasm/wasi/`.
diff --git a/src/tasks/WasmAppBuilder/mono/ManagedToNativeGenerator.cs b/src/tasks/WasmAppBuilder/mono/ManagedToNativeGenerator.cs
index 6169c9dccf5e13..89d58d22ebd573 100644
--- a/src/tasks/WasmAppBuilder/mono/ManagedToNativeGenerator.cs
+++ b/src/tasks/WasmAppBuilder/mono/ManagedToNativeGenerator.cs
@@ -88,7 +88,7 @@ private void ExecuteInternal(LogAdapter log)
         if (ShouldRun(managedAssemblies))
         {
             var pinvoke = new PInvokeTableGenerator(FixupSymbolName, log, IsLibraryMode, TargetOS);
-            var icall = new IcallTableGenerator(RuntimeIcallTableFile, FixupSymbolName, log, isCoreClr: false);
+            var icall = new IcallTableGenerator(RuntimeIcallTableFile, FixupSymbolName, log);
 
             var resolver = new PathAssemblyResolver(managedAssemblies);
             using var mlc = new MetadataLoadContext(resolver, "System.Private.CoreLib");
diff --git a/src/tests/Common/CLRTest.WasmCorerun.targets b/src/tests/Common/CLRTest.WasmCorerun.targets
index 78790e4a1698bd..cb0acf44c0b5a5 100644
--- a/src/tests/Common/CLRTest.WasmCorerun.targets
+++ b/src/tests/Common/CLRTest.WasmCorerun.targets
@@ -10,8 +10,8 @@ time the way a .so/.dylib/.dll is elsewhere. It has to be linked into the host u
 with a generated table mapping each [DllImport] to the address of its target. That is what this
 file does, once per test that has a CMakeProjectReference:
 
-  1. ManagedToNativeGenerator (src/tasks/WasmAppBuilder) scans the test's managed assemblies plus
-     the whole framework closure and emits callhelpers-{pinvoke,reverse,interp-to-managed}.cpp.
+  1. crossgen2, in its portable call-helpers generation mode, scans the test's managed assemblies
+     plus the whole framework closure and emits callhelpers-{pinvoke,reverse,interp-to-managed}.cpp.
   2. Those three sources are compiled with em++ using the response file exported by the CoreCLR
      build (see src/coreclr/hosts/corerun/wasm/testkit.cmake).
   3. They are linked, together with the test's own static libraries, against the same archives
@@ -60,7 +60,7 @@ against CORE_ROOT, and no SDK is involved. Only the generator task assembly is s
     <_WasmCorerunScriptExt Condition="$([MSBuild]::IsOSPlatform('windows'))">.bat</_WasmCorerunScriptExt>
   </PropertyGroup>
 
-  <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.CoreClr.ManagedToNativeGenerator"
+  <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.FilterManagedAssemblies"
              AssemblyFile="$([MSBuild]::NormalizePath('$(WasmAppBuilderDir)', 'WasmAppBuilder.dll'))"
              TaskFactory="TaskHostFactory" />
 
@@ -189,6 +189,7 @@ against CORE_ROOT, and no SDK is involved. Only the generator task assembly is s
            and corerun.wasm below belong in the output directory. -->
       <_WasmCorerunDir>$([MSBuild]::NormalizeDirectory('$(IntermediateOutputPath)', 'wasm-corerun'))</_WasmCorerunDir>
       <_WasmCorerunInputManifest>$(_WasmCorerunDir)inputs.txt</_WasmCorerunInputManifest>
+      <_WasmCorerunGeneratorRsp>$(_WasmCorerunDir)callhelpers-generator.rsp</_WasmCorerunGeneratorRsp>
 
       <!-- Consumed straight out of the kit: the paths in them are relative to the kit directory,
            which is why both em++ invocations below run from there. -->
@@ -312,22 +313,44 @@ against CORE_ROOT, and no SDK is involved. Only the generator task assembly is s
     </ItemGroup>
 
     <!--
-      WarnOnUnresolvedPInvokeModules is off on purpose: tests may P/Invoke into a module that is
-      deliberately absent (JIT/interpreter checks that DllNotFoundException is thrown), and the
-      framework assemblies reference modules that no wasm build links.
+      Tests may P/Invoke into a module that is deliberately absent (JIT/interpreter checks that
+      DllNotFoundException is thrown), and the framework assemblies reference modules no wasm build
+      links. The generator skips those rather than failing, which is what makes that safe.
     -->
-    <ManagedToNativeGenerator
-      Assemblies="@(_WasmCorerunAssembly->Distinct())"
-      PInvokeModules="@(_WasmCorerunPInvokeModule->Distinct())"
-      PInvokeOutputPath="$(_WasmCorerunDir)callhelpers-pinvoke.cpp"
-      ReversePInvokeOutputPath="$(_WasmCorerunDir)callhelpers-reverse.cpp"
-      InterpToNativeOutputPath="$(_WasmCorerunDir)callhelpers-interp-to-managed.cpp"
-      CacheFilePath="$(_WasmCorerunDir)m2n_cache.txt"
-      TargetOS="browser"
-      IsLibraryMode="false"
-      WarnOnUnresolvedPInvokeModules="false">
-      <Output TaskParameter="FileWrites" ItemName="FileWrites" />
-    </ManagedToNativeGenerator>
+    <FilterManagedAssemblies Assemblies="@(_WasmCorerunAssembly->Distinct())">
+      <Output TaskParameter="ManagedAssemblies" ItemName="_WasmCorerunManagedAssembly" />
+    </FilterManagedAssemblies>
+
+    <PropertyGroup>
+      <_WasmCorerunGeneratorExeSuffix Condition="'$(OS)' == 'Windows_NT'">.exe</_WasmCorerunGeneratorExeSuffix>
+      <_WasmCorerunGeneratorPath Condition="'$(_WasmCorerunGeneratorPath)' == '' and '$(Crossgen2InBuildDir)' != ''">$([MSBuild]::NormalizePath('$(Crossgen2InBuildDir)', 'crossgen2$(_WasmCorerunGeneratorExeSuffix)'))</_WasmCorerunGeneratorPath>
+    </PropertyGroup>
+
+    <Error Condition="'$(_WasmCorerunGeneratorPath)' == ''"
+           Text="crossgen2 was not found, so the test's portable call helpers cannot be generated. It is built by the 'clr' subset, or set %24(_WasmCorerunGeneratorPath) to a crossgen2 executable." />
+    <Error Condition="!Exists('$(_WasmCorerunGeneratorPath)')"
+           Text="crossgen2 was not found at '$(_WasmCorerunGeneratorPath)', so the test's portable call helpers cannot be generated. It is built by the 'clr' subset." />
+    <Error Condition="'$([System.IO.Path]::GetExtension(`$(_WasmCorerunGeneratorPath)`))' == '.dll'"
+           Text="%24(_WasmCorerunGeneratorPath) is '$(_WasmCorerunGeneratorPath)'. It has to name a crossgen2 executable; an IL assembly cannot be launched directly." />
+
+    <ItemGroup>
+      <!-- This file is only imported for browser, so $(TargetOS) is that; naming it rather than
+           repeating the literal keeps the two from drifting if wasi ever links a test corerun. -->
+      <_WasmCorerunGeneratorArg Include="--targetos:$(TargetOS)" />
+      <_WasmCorerunGeneratorArg Include="--targetarch:wasm" />
+      <_WasmCorerunGeneratorArg Include="--generate-portable-callhelpers:$(_WasmCorerunDir)" />
+      <_WasmCorerunGeneratorArg Include="@(_WasmCorerunPInvokeModule->'--directpinvoke:%(Identity)')" />
+      <_WasmCorerunGeneratorArg Include="@(_WasmCorerunManagedAssembly->'%(FullPath)')" />
+    </ItemGroup>
+
+    <WriteLinesToFile File="$(_WasmCorerunGeneratorRsp)" Lines="@(_WasmCorerunGeneratorArg)" Overwrite="true" WriteOnlyWhenDifferent="true" />
+
+    <Exec Command="&quot;$(_WasmCorerunGeneratorPath)&quot; &quot;@$(_WasmCorerunGeneratorRsp)&quot;" />
+
+    <ItemGroup>
+      <FileWrites Include="$(_WasmCorerunGeneratorRsp)" />
+      <FileWrites Include="@(_WasmCorerunGeneratedSource)" />
+    </ItemGroup>
   </Target>
 
   <!-- ======================== Compile ======================== -->