@nativescript/windows-jsc 0.1.0-alpha.0

package/framework/__PROJECT_NAME__/__PROJECT_NAME__.csproj

@@ -0,0 +1,263 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+  <OutputType>WinExe</OutputType>
+  <TargetFramework>net10.0-windows10.0.26100.0</TargetFramework>
+  <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+  <SupportedOSPlatformVersion>10.0.17763.0</SupportedOSPlatformVersion>
+  <RootNamespace>$(MSBuildProjectName)</RootNamespace>
+  <AssemblyName>$(MSBuildProjectName)</AssemblyName>
+    <UseWinUI>true</UseWinUI>
+    <Platform Condition="'$(Platform)' == '' or '$(Platform)' == 'AnyCPU'">x64</Platform>
+    <PlatformTarget Condition="'$(PlatformTarget)' == '' or '$(PlatformTarget)' == 'AnyCPU'">x64</PlatformTarget>
+    <Platforms>x64;arm64</Platforms>
+    <RuntimeIdentifiers>win-x64;win-arm64</RuntimeIdentifiers>
+    <RuntimeIdentifier Condition="'$(RuntimeIdentifier)' == '' and ('$(Platform)' == '' or '$(Platform)' == 'AnyCPU')">win-x64</RuntimeIdentifier>
+    <RuntimeIdentifier Condition="'$(RuntimeIdentifier)' == '' and '$(Platform)' != '' and '$(Platform)' != 'AnyCPU'">win-$([System.String]::Copy('$(Platform)').ToLowerInvariant())</RuntimeIdentifier>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <EnableMsixTooling>true</EnableMsixTooling>
+    <AppxPackageSigningEnabled>false</AppxPackageSigningEnabled>
+    <WindowsAppSdkDeploymentManagerInitialize>false</WindowsAppSdkDeploymentManagerInitialize>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <Nullable>disable</Nullable>
+    <DefineConstants>$(DefineConstants);DISABLE_XAML_GENERATED_MAIN</DefineConstants>
+    <!-- Parent of the project directory — contains the pre-built libs/ folder from the npm package -->
+    <NSWindowsRoot>$(MSBuildProjectDirectory)\..</NSWindowsRoot>
+  </PropertyGroup>
+
+  <!-- Static Binding Generator (SBG) output folder and helper properties for integrating generated proxies. -->
+  <PropertyGroup>
+    <NSGenDir>$(BaseIntermediateOutputPath)_ns_\gen</NSGenDir>
+    <SBG_OUTPUT_DIR>$(MSBuildProjectDirectory)\$(NSGenDir)</SBG_OUTPUT_DIR>
+        <!-- Path to the windows-runtime repository root. Can be overridden by setting the environment
+          variable `NS_WINDOWS_RUNTIME_ROOT` (useful when building an app that lives outside the
+          runtime repo). If not set, fall back to the project parent directory (legacy behavior). -->
+        <WindowsRuntimeRepoRoot Condition="'$(WindowsRuntimeRepoRoot)'=='' and '$(NS_WINDOWS_RUNTIME_ROOT)' != ''">$(NS_WINDOWS_RUNTIME_ROOT)</WindowsRuntimeRepoRoot>
+        <WindowsRuntimeRepoRoot Condition="'$(WindowsRuntimeRepoRoot)'==''">$(MSBuildProjectDirectory)\..</WindowsRuntimeRepoRoot>
+    <SBGMetadataSource>$(SBG_OUTPUT_DIR)\sbg_metadata.json</SBGMetadataSource>
+    <!-- Resolve pre-built tool binaries shipped inside the npm package tools/ directory -->
+    <NSToolsDir>$(NSWindowsRoot)\tools</NSToolsDir>
+    <SbgExe Condition="Exists('$(NSToolsDir)\sbg.exe')">$(NSToolsDir)\sbg.exe</SbgExe>
+    <DotNetToolExe Condition="Exists('$(NSToolsDir)\dotnet-tool.exe')">$(NSToolsDir)\dotnet-tool.exe</DotNetToolExe>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <!-- Derived library platform for selecting prebuilt native libs.
+         Prefer $(Platform); fall back to trimming 'win-' from $(RuntimeIdentifier); default to x64. -->
+    <NSLibPlatform Condition="'$(Platform)' != ''">$(Platform)</NSLibPlatform>
+    <NSLibPlatform Condition="'$(NSLibPlatform)' == '' and '$(RuntimeIdentifier)' != ''">$([System.Text.RegularExpressions.Regex]::Replace('$(RuntimeIdentifier)','^win-',''))</NSLibPlatform>
+    <NSLibPlatform Condition="'$(NSLibPlatform)' == ''">x64</NSLibPlatform>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.6.250205002" />
+    <PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.1742" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <!-- Deploys Microsoft.Web.WebView2.Core.winmd (~120 KB) next to the exe so the runtime can
+         project CoreWebView2 members (Navigate, Stop, …) dynamically. Set to false (App_Resources
+         props or /p:) for apps that never use WebView. -->
+    <NSIncludeWebView2Metadata Condition="'$(NSIncludeWebView2Metadata)' == ''">true</NSIncludeWebView2Metadata>
+  </PropertyGroup>
+
+  <!-- WinRT metadata for WebView2. The .NET build never deploys .winmd files (compiled apps bake
+       their projections at compile time), but the NativeScript runtime resolves WinRT types
+       dynamically and auto-scans the output dir for *.winmd on startup — without it, CoreWebView2
+       members (Navigate, Stop, …) don't project. WebView2 arrives transitively via
+       Microsoft.WindowsAppSDK, so we locate the winmd next to the resolved Core dll (it sits one
+       package's lib\). Version-agnostic: no pinned PackageReference, tracks whatever WebView2 version
+       WindowsAppSDK pulls in. WinUI resolves the Core dll from runtimes\<rid>\native_uap\, so the
+       winmd sits three directories up, in <pkgroot>\lib\. -->
+  <Target Name="NSDeployWebView2CoreMetadata"
+          AfterTargets="CopyFilesToOutputDirectory"
+          Condition="'$(NSIncludeWebView2Metadata)' == 'true'">
+    <PropertyGroup>
+      <_NSWebView2CoreDll>@(ReferenceCopyLocalPaths->WithMetadataValue('Filename','Microsoft.Web.WebView2.Core')->WithMetadataValue('Extension','.dll'))</_NSWebView2CoreDll>
+      <_NSWebView2CoreWinmd Condition="'$(_NSWebView2CoreDll)' != ''">$([System.IO.Path]::GetFullPath('$([System.IO.Path]::GetDirectoryName($(_NSWebView2CoreDll)))\..\..\..\lib\Microsoft.Web.WebView2.Core.winmd'))</_NSWebView2CoreWinmd>
+    </PropertyGroup>
+    <Copy SourceFiles="$(_NSWebView2CoreWinmd)"
+          DestinationFolder="$(OutDir)"
+          SkipUnchangedFiles="true"
+          Condition="'$(_NSWebView2CoreWinmd)' != '' and Exists('$(_NSWebView2CoreWinmd)')" />
+  </Target>
+
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest" />
+    <Content Include="Properties\Default.rd.xml" />
+
+    <!-- App JS/resource files — copied to the output directory on every build -->
+    <Content Include="app\**\*">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- App_Resources: platform-specific assets (images, fonts, etc.) -->
+    <Content Include="App_Resources\**\*" Condition="Exists('App_Resources')">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- Logo and splash assets required for the packaged desktop app manifest -->
+    <Content Include="Assets\**\*" Condition="Exists('Assets')">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- Debug: devtools-enabled runtime DLL (platform fallback via NSLibPlatform) -->
+    <Content Include="$(NSWindowsRoot)\libs\devtools\$(NSLibPlatform)\nativescript.dll"
+             Condition="'$(Configuration)' == 'Debug' and Exists('$(NSWindowsRoot)\libs\devtools\$(NSLibPlatform)\nativescript.dll')">
+      <Link>nativescript.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- Debug fallback: engine variants (quickjs/hermes/v8/jsc) ship no devtools build (no
+         inspector), so a Debug build must still pick up their plain runtime DLL instead of
+         silently omitting nativescript.dll from the output. -->
+    <Content Include="$(NSWindowsRoot)\libs\$(NSLibPlatform)\nativescript.dll"
+             Condition="'$(Configuration)' == 'Debug' and !Exists('$(NSWindowsRoot)\libs\devtools\$(NSLibPlatform)\nativescript.dll') and Exists('$(NSWindowsRoot)\libs\$(NSLibPlatform)\nativescript.dll')">
+      <Link>nativescript.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- Release: production runtime DLL (platform fallback via NSLibPlatform) -->
+    <Content Include="$(NSWindowsRoot)\libs\$(NSLibPlatform)\nativescript.dll"
+             Condition="'$(Configuration)' != 'Debug' and Exists('$(NSWindowsRoot)\libs\$(NSLibPlatform)\nativescript.dll')">
+      <Link>nativescript.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- Sidecar engine runtime DLLs some engine variants ship alongside nativescript.dll (e.g.
+         hermes.dll/hermes-icu.dll, JavaScriptCore.dll/icu*.dll) — same files regardless of
+         Debug/Release. nativescript.dll itself is excluded since it's handled above per config. -->
+    <Content Include="$(NSWindowsRoot)\libs\$(NSLibPlatform)\*.dll"
+             Exclude="$(NSWindowsRoot)\libs\$(NSLibPlatform)\nativescript.dll"
+             Condition="Exists('$(NSWindowsRoot)\libs\$(NSLibPlatform)')">
+      <Link>%(Filename)%(Extension)</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+  </ItemGroup>
+
+  <!--
+    Publishes DotNetBridge.dll before the app build.
+    Inputs/Outputs make this incremental: MSBuild skips the Exec when DotNetBridge.dll
+    is already newer than both source files.
+  -->
+  <Target Name="PublishDotNetBridge"
+          BeforeTargets="Build"
+          Inputs="$(NSWindowsRoot)\dotnet-bridge\DotNetBridge.csproj;
+                  $(NSWindowsRoot)\dotnet-bridge\Bridge.cs"
+          Outputs="$(NSWindowsRoot)\dotnet-bridge\publish\DotNetBridge.dll"
+          Condition="Exists('$(NSWindowsRoot)\dotnet-bridge\DotNetBridge.csproj')">
+    <Message Text="[NativeScript] Publishing DotNetBridge..." Importance="low" />
+    <Exec Command="dotnet publish &quot;$(NSWindowsRoot)\dotnet-bridge\DotNetBridge.csproj&quot; -c Release -o &quot;$(NSWindowsRoot)\dotnet-bridge\publish&quot; --no-self-contained /nologo" />
+  </Target>
+
+  <!--
+    Copies the published bridge files to the output directory AFTER PublishDotNetBridge
+    runs, avoiding the MSBuild evaluation-order problem where Condition="Exists(...)"
+    on a static Content item is checked before the publish target creates the directory.
+    Must land at dotnet-bridge\publish\ relative to the EXE so the Rust runtime can
+    locate DotNetBridge.dll via AppContext.BaseDirectory.
+  -->
+  <Target Name="CopyDotNetBridge"
+          AfterTargets="PublishDotNetBridge"
+          BeforeTargets="Build"
+          Condition="Exists('$(NSWindowsRoot)\dotnet-bridge\publish')">
+    <ItemGroup>
+      <_DotNetBridgeFiles Include="$(NSWindowsRoot)\dotnet-bridge\publish\**\*" />
+    </ItemGroup>
+      <Copy SourceFiles="@(_DotNetBridgeFiles)"
+    DestinationFiles="@(_DotNetBridgeFiles->'$(OutDir)dotnet-bridge\%(RecursiveDir)%(Filename)%(Extension)')"
+        SkipUnchangedFiles="true" />
+    </Target>
+
+    <!-- Run the Static Binding Generator (sbg) when project contains an sbg entry script
+     or when pre-existing metadata is present. Generated proxies will be written
+     into $(NSGenDir) and included in compilation. -->
+    <Target Name="RunStaticBindingGenerator" BeforeTargets="CoreCompile">
+      <MakeDir Directories="$(NSGenDir)" />
+      <!-- Run dotnet-tool to auto-detect .NET usage and publish/copy DotNetBridge.
+           Prefer the pre-built binary shipped in the npm package; fall back to cargo run for dev. -->
+      <Exec Command="&quot;$(DotNetToolExe)&quot; --app-root &quot;$(MSBuildProjectDirectory)&quot; --dir App --sbg-output &quot;$(SBG_OUTPUT_DIR)&quot;"
+        Condition="'$(DotNetToolExe)' != ''" />
+      <Exec WorkingDirectory="$(WindowsRuntimeRepoRoot)"
+        Command="cargo run --quiet --manifest-path &quot;$(WindowsRuntimeRepoRoot)\Cargo.toml&quot; -p dotnet-tool -- --app-root &quot;$(MSBuildProjectDirectory)&quot; --dir App --sbg-output &quot;$(SBG_OUTPUT_DIR)&quot;"
+        Condition="'$(DotNetToolExe)' == '' and Exists('$(WindowsRuntimeRepoRoot)\Cargo.toml')" />
+      <!-- Run SBG to generate C# proxies from captured metadata.
+           sbg_metadata.json is written by __nsProxyAutoCapture when the app runs
+           with extensions that use .extend() / @Interfaces / @CSharpProxy.
+           Search order: pre-built tools/ binary, then cargo run for dev. -->
+      <Exec
+        Command="&quot;$(SbgExe)&quot;"
+        EnvironmentVariables="NSWINRT_AUTO_METADATA_PATH=$(SBGMetadataSource);SBG_OUTPUT_DIR=$(SBG_OUTPUT_DIR);SBG_METADATA_SOURCE=$(SBGMetadataSource);SBG_TARGET_FRAMEWORK=$(TargetFramework);SBG_TARGET_PLATFORM_MIN_VERSION=$(TargetPlatformMinVersion);SBG_USE_UWP=false;SBG_APP_CS_SOURCES_DIR=$(MSBuildProjectDirectory)"
+        Condition="'$(SbgExe)' != '' and Exists('$(SBGMetadataSource)')" />
+      <Exec WorkingDirectory="$(WindowsRuntimeRepoRoot)"
+        Command="cargo run --quiet --manifest-path &quot;$(WindowsRuntimeRepoRoot)\Cargo.toml&quot; -p sbg"
+        EnvironmentVariables="NSWINRT_AUTO_METADATA_PATH=$(SBGMetadataSource);SBG_OUTPUT_DIR=$(SBG_OUTPUT_DIR);SBG_METADATA_SOURCE=$(SBGMetadataSource);SBG_TARGET_FRAMEWORK=$(TargetFramework);SBG_TARGET_PLATFORM_MIN_VERSION=$(TargetPlatformMinVersion);SBG_USE_UWP=false;SBG_APP_CS_SOURCES_DIR=$(MSBuildProjectDirectory)"
+        Condition="'$(SbgExe)' == '' and Exists('$(SBGMetadataSource)') and Exists('$(WindowsRuntimeRepoRoot)\Cargo.toml')" />
+    </Target>
+
+  <Target Name="CleanStaticBindingGeneratorOutput" AfterTargets="CoreClean">
+    <RemoveDir Directories="$(NSGenDir)" Condition="Exists('$(NSGenDir)')" />
+  </Target>
+
+  <ItemGroup>
+    <Compile Include="$(NSGenDir)\NSWinRTProxies\**\*.cs" Visible="false" Condition="Exists('$(NSGenDir)\NSWinRTProxies')" />
+    <Compile Remove="$(NSGenDir)\NSWinRTProxies\obj\**\*.cs" Condition="Exists('$(NSGenDir)\NSWinRTProxies\obj')" />
+    <Content Include="$(NSGenDir)\sbg-manifest.json" Link="sbg-manifest.json" CopyToOutputDirectory="PreserveNewest" Condition="Exists('$(NSGenDir)\sbg-manifest.json')" />
+    <Content Include="$(NSGenDir)\NSWinRTProxies\bin\Release\**\NSWinRTProxies.dll" Link="NSWinRTProxies.dll" CopyToOutputDirectory="PreserveNewest" Condition="Exists('$(NSGenDir)\NSWinRTProxies\bin\Release')" />
+  </ItemGroup>
+  
+
+  <!-- Ensure bridge files are included in the final `dotnet publish` output. -->
+  <Target Name="CopyDotNetBridgeToPublishDir"
+          AfterTargets="Publish"
+          Condition="Exists('$(NSWindowsRoot)\dotnet-bridge\publish')">
+      <ItemGroup>
+        <_DotNetBridgePublishFiles Include="$(NSWindowsRoot)\dotnet-bridge\publish\**\*" />
+      </ItemGroup>
+      <Copy SourceFiles="@(_DotNetBridgePublishFiles)"
+            DestinationFiles="@(_DotNetBridgePublishFiles->'$(PublishDir)dotnet-bridge\%(RecursiveDir)%(Filename)%(Extension)')"
+            SkipUnchangedFiles="true" />
+    </Target>
+
+  <!-- Inject the bridge publish files as Content before Publish so `dotnet publish` includes them automatically -->
+  <Target Name="AddDotNetBridgeContent" BeforeTargets="Publish" Condition="Exists('$(NSWindowsRoot)\dotnet-bridge\publish')">
+    <ItemGroup>
+      <Content Include="$(NSWindowsRoot)\dotnet-bridge\publish\**\*">
+        <Link>dotnet-bridge\%(RecursiveDir)%(Filename)%(Extension)</Link>
+        <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
+      </Content>
+    </ItemGroup>
+  </Target>
+
+    <!--
+      Wait for the `dotnet-tool` sentinel marker so Build/Publish don't race with
+      the external tool that publishes/copies DotNetBridge into the repo.
+      This polls for `dotnet-bridge/publish/.dotnet_tool_done` with a short timeout.
+    -->
+    <Target Name="WaitForDotNetToolDone" BeforeTargets="Build;Publish" Condition="Exists('$(NSWindowsRoot)\dotnet-bridge')">
+      <PropertyGroup>
+        <DotNetToolMarker>$(NSWindowsRoot)\dotnet-bridge\publish\.dotnet_tool_done</DotNetToolMarker>
+        <DotNetWaitTimeout>30</DotNetWaitTimeout>
+      </PropertyGroup>
+      <Message Text="[NativeScript] Waiting for dotnet-tool marker at $(DotNetToolMarker) (timeout $(DotNetWaitTimeout)s)..." Importance="low" />
+      <Exec Command="powershell -NoProfile -Command &quot;$t=0; while(-not(Test-Path '$(DotNetToolMarker)') -and $t -lt $(DotNetWaitTimeout)) { Start-Sleep -Seconds 1; $t++; }; if(-not(Test-Path '$(DotNetToolMarker)')) { Write-Error 'dotnet-tool marker not found after timeout'; exit 1 };&quot;" />
+    </Target>
+
+  <!-- Allow project-level Windows overrides: place App_Resources\Windows\app.csproj to extend/override generated settings -->
+  <Import Project="App_Resources\Windows\app.csproj" Condition="Exists('App_Resources\Windows\app.csproj')" />
+
+  <!-- App-level hook evaluated BEFORE plugins, analogous to Android's
+       App_Resources/Android/before-plugins.gradle. Place App_Resources\Windows\before-plugins.props
+       to declare NuGet package sources/feeds, pin or override versions, or set any properties/items
+       that plugin PackageReferences (added by each plugin's plugin.props) should resolve against. -->
+  <Import Project="App_Resources\Windows\before-plugins.props" Condition="Exists('App_Resources\Windows\before-plugins.props')" />
+
+  <!-- CLI-generated plugin imports (managed by the CLI during prepare) -->
+  <Import Project="plugins\Plugins.props" Condition="Exists('plugins\Plugins.props')" />
+  <Import Project="plugins\Plugins.targets" Condition="Exists('plugins\Plugins.targets')" />
+
+  <!-- App-level hook evaluated AFTER plugins, analogous to Android's App_Resources/Android/app.gradle.
+       Place App_Resources\Windows\after-plugins.props to override or extend anything a plugin set. -->
+  <Import Project="App_Resources\Windows\after-plugins.props" Condition="Exists('App_Resources\Windows\after-plugins.props')" />
+</Project>

package/framework/dotnet-bridge/BinaryProtocol.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Text;
+
+namespace NativeScriptBridge;
+
+internal readonly struct HandleRef(int id)
+{
+    public readonly int Id = id;
+}
+
+// Carries a raw IUnknown/IInspectable pointer from a WinRT proxy (tag 0x0A).
+// CoerceBin calls Marshal.GetObjectForIUnknown to create a managed RCW.
+internal readonly struct WinRtRef(long ptr)
+{
+    public readonly long Ptr = ptr;
+}
+
+internal ref struct BinReader(ReadOnlySpan<byte> buf)
+{
+    private readonly ReadOnlySpan<byte> _buf = buf;
+    private int _pos = 0;
+
+    public byte ReadByte() => _buf[_pos++];
+
+    public int ReadI32()
+    {
+        var v = BinaryPrimitives.ReadInt32LittleEndian(_buf[_pos..]);
+        _pos += 4;
+        return v;
+    }
+
+    public long ReadI64()
+    {
+        var v = BinaryPrimitives.ReadInt64LittleEndian(_buf[_pos..]);
+        _pos += 8;
+        return v;
+    }
+
+    public ushort ReadU16()
+    {
+        var v = BinaryPrimitives.ReadUInt16LittleEndian(_buf[_pos..]);
+        _pos += 2;
+        return v;
+    }
+
+    public double ReadF64()
+    {
+        var v = BinaryPrimitives.ReadDoubleLittleEndian(_buf[_pos..]);
+        _pos += 8;
+        return v;
+    }
+
+    public string ReadString16()
+    {
+        var len = ReadU16();
+        var s   = Encoding.UTF8.GetString(_buf.Slice(_pos, len));
+        _pos += len;
+        // Intern so repeated method/type names reuse the same heap string.
+        // Eliminates the allocation on every subsequent warm-path call.
+        return string.Intern(s);
+    }
+
+    public string ReadString32()
+    {
+        var len = BinaryPrimitives.ReadUInt32LittleEndian(_buf.Slice(_pos, 4));
+        _pos += 4;
+        var s = Encoding.UTF8.GetString(_buf.Slice(_pos, (int)len));
+        _pos += (int)len;
+        return string.Intern(s);
+    }
+
+    public uint ReadU32()
+    {
+        var v = BinaryPrimitives.ReadUInt32LittleEndian(_buf.Slice(_pos, 4));
+        _pos += 4;
+        return v;
+    }
+
+    public object?[] ReadArgs()
+    {
+        var count = ReadByte();
+        if (count == 0) return [];
+        var args = new object?[count];
+        for (int i = 0; i < count; i++)
+        {
+            var tag = ReadByte();
+            args[i] = tag switch
+            {
+                0x00 => null,
+                0x01 => (object)false,
+                0x02 => (object)true,
+                0x03 => (object)ReadI32(),
+                0x04 => (object)ReadF64(),
+                0x05 => (object)ReadString16(),
+                0x06 => (object)new HandleRef(ReadI32()),
+                0x0A => (object)new WinRtRef(ReadI64()),
+                _    => null,
+            };
+        }
+        return args;
+    }
+}
+
+internal ref struct BinWriter(ArrayBufferWriter<byte> buf)
+{
+    private readonly ArrayBufferWriter<byte> _buf = buf;
+
+    public void WriteByte(byte b)
+    {
+        _buf.GetSpan(1)[0] = b;
+        _buf.Advance(1);
+    }
+
+    public void WriteI32(int v)
+    {
+        BinaryPrimitives.WriteInt32LittleEndian(_buf.GetSpan(4), v);
+        _buf.Advance(4);
+    }
+
+    public void WriteU16(ushort v)
+    {
+        BinaryPrimitives.WriteUInt16LittleEndian(_buf.GetSpan(2), v);
+        _buf.Advance(2);
+    }
+
+    public void WriteU32(uint v)
+    {
+        BinaryPrimitives.WriteUInt32LittleEndian(_buf.GetSpan(4), v);
+        _buf.Advance(4);
+    }
+
+    public void WriteI64(long v)
+    {
+        BinaryPrimitives.WriteInt64LittleEndian(_buf.GetSpan(8), v);
+        _buf.Advance(8);
+    }
+
+    public void WriteF64(double v)
+    {
+        BinaryPrimitives.WriteDoubleLittleEndian(_buf.GetSpan(8), v);
+        _buf.Advance(8);
+    }
+
+    public void WriteString32(ReadOnlySpan<char> s)
+    {
+        var byteCount = Encoding.UTF8.GetByteCount(s);
+        WriteU32((uint)byteCount);
+        Encoding.UTF8.GetBytes(s, _buf.GetSpan(byteCount));
+        _buf.Advance(byteCount);
+    }
+
+    public void WriteString16(ReadOnlySpan<char> s)
+    {
+        var byteCount = Encoding.UTF8.GetByteCount(s);
+        WriteU16((ushort)byteCount);
+        Encoding.UTF8.GetBytes(s, _buf.GetSpan(byteCount));
+        _buf.Advance(byteCount);
+    }
+}