@nativescript/windows-hermes 0.1.0-next.2026-08-03-30819078286 → 1.0.0-beta.7

package/framework/__PROJECT_NAME__/App.xaml.cs

@@ -57,7 +57,7 @@ namespace __PROJECT_NAME__
             try
             {
                 var panicLogPath = System.IO.Path.Combine(
-                    ApplicationData.Current.LocalFolder.Path, "nativescript-panic.log");
+                    RuntimeHost.LocalFolderPath, "nativescript-panic.log");
                 if (System.IO.File.Exists(panicLogPath))
                 {
                     var content = System.IO.File.ReadAllText(panicLogPath);
@@ -121,7 +121,8 @@ namespace __PROJECT_NAME__
         {
             StopPump();
             _runtimeHost.NotifyAppEvent((int)AppEventKind.Exit, null);
-            ApplicationData.Current.LocalSettings.Values[LastLaunchArgsKey] = string.Empty;
+            try { ApplicationData.Current.LocalSettings.Values[LastLaunchArgsKey] = string.Empty; }
+            catch (InvalidOperationException) { } // unpackaged: no ApplicationData
             _runtimeHost.Dispose();
         }
 

package/framework/__PROJECT_NAME__/CrashDiagnostics.cs

@@ -101,7 +101,7 @@ namespace __PROJECT_NAME__
             // Include panic log from previous or current run
             try
             {
-                var panicLog = Path.Combine(ApplicationData.Current.LocalFolder.Path, "nativescript-panic.log");
+                var panicLog = Path.Combine(RuntimeHost.LocalFolderPath, "nativescript-panic.log");
                 if (File.Exists(panicLog))
                 {
                     var content = File.ReadAllText(panicLog, Encoding.UTF8).Trim();
@@ -130,7 +130,7 @@ namespace __PROJECT_NAME__
 
         public static string CrashLogPath()
         {
-            try { return Path.Combine(ApplicationData.Current.LocalFolder.Path, "nativescript-crash.log"); }
+            try { return Path.Combine(RuntimeHost.LocalFolderPath, "nativescript-crash.log"); }
             catch { return null; }
         }
 
@@ -272,7 +272,7 @@ namespace __PROJECT_NAME__
         {
             try
             {
-                var logPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "nativescript-crash.log");
+                var logPath = Path.Combine(RuntimeHost.LocalFolderPath, "nativescript-crash.log");
                 File.AppendAllText(logPath, content, Encoding.UTF8);
             }
             catch { }

package/framework/__PROJECT_NAME__/RuntimeHost.cs

@@ -32,6 +32,20 @@ namespace __PROJECT_NAME__
         [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_set_local_folder))]
         private static extern void runtime_set_local_folder([MarshalAs(UnmanagedType.LPUTF8Str)] string localFolder);
 
+        // Escape hatch for apps packed with `nsbundle_pack --key-hex <hex>` (custom-key
+        // app.nsbundle containers). Must be called before runtime_init if used at all: apps
+        // packed with the default pepper (no --key-hex) never need to call this. Not wired to a
+        // default call site here; an app author supplies their own key material and calls this
+        // from Initialize() before runtime_init(...).
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_set_bundle_key))]
+        private static extern int runtime_set_bundle_key([MarshalAs(UnmanagedType.LPUTF8Str)] string keyHex);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_read_protected_file))]
+        private static extern IntPtr runtime_read_protected_file([MarshalAs(UnmanagedType.LPUTF8Str)] string virtualPath);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_free_protected_string))]
+        private static extern void runtime_free_protected_string(IntPtr ptr);
+
         [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_get_last_js_error))]
         private static extern IntPtr runtime_get_last_js_error();
 
@@ -39,6 +53,7 @@ namespace __PROJECT_NAME__
         private static extern void runtime_free_js_error(IntPtr ptr);
 
         [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_has_devtools))]
+        [return: MarshalAs(UnmanagedType.U1)]
         private static extern bool runtime_has_devtools();
 
         [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_pump_timers))]
@@ -55,6 +70,18 @@ namespace __PROJECT_NAME__
         }
 
     #if DEBUG
+        // Engine runtimes (@nativescript/windows-<engine>) only: a debug host always allows
+        // dev-server modules (Vite HMR). The classic runtime derives this from its devtools build
+        // and doesn't export it.
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_set_debug_build))]
+        private static extern void runtime_set_debug_build(int debug);
+
+        private static void TrySetDebugBuild()
+        {
+            try { runtime_set_debug_build(1); }
+            catch (EntryPointNotFoundException) { }
+        }
+
         [DllImport(NativeScriptLibrary, EntryPoint = nameof(ns_set_log_to_console))]
         private static extern int ns_set_log_to_console(int enabled);
 
@@ -84,6 +111,21 @@ namespace __PROJECT_NAME__
         [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_free_string))]
         private static extern void runtime_free_string(IntPtr ptr);
 
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_devtools_wait_for_debugger))]
+        [return: MarshalAs(UnmanagedType.U1)]
+        private static extern bool runtime_devtools_wait_for_debugger(long runtime, uint timeoutMs);
+
+        // iOS uses 41000 and Android 42000.
+        private const ushort DevtoolsPort = 43000;
+        private const uint DebuggerWaitTimeoutMs = 30000;
+
+        // LocalFolder sentinel files shared with the CLI's WindowsApplicationManager.
+        private const string InspectorMarker = "ns-inspector";
+        private const string DebugBreakMarker = "ns-debugbreak";
+        private const string DebuggerStartedMarker = "ns-debugger-started";
+
+        private bool _waitForDebugger;
+
         public string DevtoolsFrontendUrl { get; private set; }
 
         private bool _devtoolsAvailable;
@@ -104,7 +146,7 @@ namespace __PROJECT_NAME__
             IntPtr urlPtr = IntPtr.Zero;
             try
             {
-                urlPtr = runtime_devtools_start(_runtime, 42000);
+                urlPtr = runtime_devtools_start(_runtime, DevtoolsPort);
                 if (urlPtr == IntPtr.Zero) return;
                 var wsUrl = Marshal.PtrToStringUTF8(urlPtr);
                 DevtoolsFrontendUrl = wsUrl != null
@@ -113,6 +155,8 @@ namespace __PROJECT_NAME__
                 if (DevtoolsFrontendUrl != null)
                 {
                     _devtoolsAvailable = true;
+                    // The server may fall back to the next free port.
+                    WriteMarker(DebuggerStartedMarker, new Uri(wsUrl).Port.ToString());
                     System.Diagnostics.Debug.WriteLine($"[NativeScript DevTools] {DevtoolsFrontendUrl}");
                 }
             }
@@ -131,15 +175,41 @@ namespace __PROJECT_NAME__
         private long _runtime;
         private bool _initialized;
 
+        private static string _localFolderPath;
+
+        /// The app's local data folder: ApplicationData's LocalFolder for a packaged app, or
+        /// %LOCALAPPDATA%\<AssemblyName> for an unpackaged one (WindowsPackageType=None), which has
+        /// no package identity and therefore no ApplicationData.
+        internal static string LocalFolderPath
+        {
+            get
+            {
+                if (_localFolderPath != null) return _localFolderPath;
+                try
+                {
+                    _localFolderPath = Windows.Storage.ApplicationData.Current.LocalFolder.Path;
+                }
+                catch (InvalidOperationException)
+                {
+                    var name = Assembly.GetEntryAssembly()?.GetName().Name ?? "NativeScriptApp";
+                    _localFolderPath = Path.Combine(
+                        Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), name);
+                    Directory.CreateDirectory(_localFolderPath);
+                }
+                return _localFolderPath;
+            }
+        }
+
         public void Initialize()
         {
             if (_initialized) return;
             bool attached = false;
             try { attached = AttachConsole(ATTACH_PARENT_PROCESS); } catch { }
             runtime_install_ctrlc_handler(0);
-            runtime_set_local_folder(Windows.Storage.ApplicationData.Current.LocalFolder.Path);
+            runtime_set_local_folder(LocalFolderPath);
             _runtime = runtime_init(AppContext.BaseDirectory);
 #if DEBUG
+            TrySetDebugBuild();
             var trySet = TrySetLogToConsole(true);
             System.Diagnostics.Debug.WriteLine($"[NativeScript] TrySetLogToConsole returned={trySet}");
 
@@ -164,38 +234,85 @@ namespace __PROJECT_NAME__
                 }
             }
             catch { }
-            if (ConsumeDebugBreakMarker())
+            DeleteMarker(DebuggerStartedMarker);
+            var debugBreak = ConsumeMarker(DebugBreakMarker);
+            if (ConsumeMarker(InspectorMarker) || debugBreak)
+            {
                 StartDevtoolsSafely();
+                _waitForDebugger = debugBreak && _devtoolsAvailable;
+            }
 #endif
             _initialized = true;
         }
 
 #if DEBUG
-        /// <summary>
-        /// Returns true and deletes the marker if the CLI wrote ns-debugbreak to LocalFolder,
-        /// matching the Android sentinel-file pattern used by the NativeScript CLI.
-        /// </summary>
-        private static bool ConsumeDebugBreakMarker()
+        private static string MarkerPath(string name) =>
+            Path.Combine(LocalFolderPath, name);
+
+        private static bool ConsumeMarker(string name)
         {
             try
             {
-                var markerPath = System.IO.Path.Combine(
-                    Windows.Storage.ApplicationData.Current.LocalFolder.Path,
-                    "ns-debugbreak");
-                if (!System.IO.File.Exists(markerPath))
+                var markerPath = MarkerPath(name);
+                if (!File.Exists(markerPath))
                     return false;
-                System.IO.File.Delete(markerPath);
+                File.Delete(markerPath);
                 return true;
             }
             catch { return false; }
         }
+
+        private static void WriteMarker(string name, string contents)
+        {
+            try { File.WriteAllText(MarkerPath(name), contents); }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"[NativeScript DevTools] Could not write {name}: {ex.Message}");
+            }
+        }
+
+        private static void DeleteMarker(string name)
+        {
+            try { File.Delete(MarkerPath(name)); }
+            catch { }
+        }
 #endif
 
+        /// Reads a file that may live inside a sealed app.nsbundle instead of on disk: tries the
+        /// protected-VFS native call first (cheap no-op when no bundle is loaded), falls back to
+        /// the real filesystem. `path` is whatever candidate the caller already built for
+        /// `File.Exists`/`File.ReadAllText`: the native side strips it down to the bundle's
+        /// virtual (app/App-relative) path itself, so no extra bookkeeping is needed here.
+        private static string TryReadVirtual(string path)
+        {
+            IntPtr ptr = IntPtr.Zero;
+            try
+            {
+                ptr = runtime_read_protected_file(path);
+                return ptr == IntPtr.Zero ? null : Marshal.PtrToStringUTF8(ptr);
+            }
+            catch { return null; }
+            finally { if (ptr != IntPtr.Zero) runtime_free_protected_string(ptr); }
+        }
+
+        private static bool VExists(string path) => TryReadVirtual(path) != null || File.Exists(path);
+
+        private static string VReadAllText(string path) => TryReadVirtual(path) ?? File.ReadAllText(path);
+
         public void RunMainScript()
         {
             if (!_initialized)
                 throw new InvalidOperationException("Runtime must be initialized before running scripts.");
 
+#if DEBUG
+            if (_waitForDebugger)
+            {
+                // --debug-brk: hold the first script until DevTools attaches.
+                _waitForDebugger = false;
+                if (!runtime_devtools_wait_for_debugger(_runtime, DebuggerWaitTimeoutMs))
+                    System.Diagnostics.Debug.WriteLine("[NativeScript DevTools] No debugger attached, continuing.");
+            }
+#endif
             var entryPath = ResolveEntryScriptPath();
             if (entryPath == null)
             {
@@ -205,10 +322,14 @@ namespace __PROJECT_NAME__
 
             var dir = Path.GetDirectoryName(Path.GetFullPath(entryPath));
             var chunks = new List<string>();
-            foreach (var chunkName in new[] { "runtime.js", "vendor.js" })
+            // An ES-module entry (Vite's bundle.mjs) imports its own chunks; webpack's classic
+            // runtime.js/vendor.js prelude must not run in front of it (a stale pair can be left
+            // in app/ after switching bundlers).
+            var isModuleEntry = entryPath.EndsWith(".mjs", StringComparison.OrdinalIgnoreCase);
+            foreach (var chunkName in isModuleEntry ? Array.Empty<string>() : new[] { "runtime.js", "vendor.js" })
             {
                 var chunkPath = Path.Combine(dir, chunkName);
-                if (File.Exists(chunkPath) &&
+                if (VExists(chunkPath) &&
                     !string.Equals(chunkPath, Path.GetFullPath(entryPath), StringComparison.OrdinalIgnoreCase))
                 {
                     chunks.Add(chunkPath);
@@ -218,10 +339,14 @@ namespace __PROJECT_NAME__
 
             foreach (var scriptPath in chunks)
             {
-                var script = File.ReadAllText(Path.GetFullPath(scriptPath));
+                var script = VReadAllText(Path.GetFullPath(scriptPath));
                 try
                 {
-                    runtime_runscript(_runtime, script, Path.GetFileName(scriptPath));
+                    // Modules resolve their imports (chunks, ~/ paths) relative to their own
+                    // location, so they need the full path; classic scripts keep the short name
+                    // their stack traces and code-cache keys have always used.
+                    var name = isModuleEntry ? Path.GetFullPath(scriptPath) : Path.GetFileName(scriptPath);
+                    runtime_runscript(_runtime, script, name);
                 }
                 catch (Exception ex)
                 {
@@ -260,7 +385,7 @@ namespace __PROJECT_NAME__
             foreach (var dir in appDirCandidates)
             {
                 var candidate = Path.Combine(dir, "package.json");
-                if (File.Exists(candidate))
+                if (VExists(candidate))
                 {
                     packageJsonPath = candidate;
                     resolvedBaseDir = dir;
@@ -269,7 +394,7 @@ namespace __PROJECT_NAME__
             }
 
             // Also accept package.json at the project root (parent of bin/).
-            if (packageJsonPath == null && File.Exists(Path.Combine(parentDir, "package.json")))
+            if (packageJsonPath == null && VExists(Path.Combine(parentDir, "package.json")))
             {
                 packageJsonPath = Path.Combine(parentDir, "package.json");
                 resolvedBaseDir = parentDir;
@@ -278,7 +403,7 @@ namespace __PROJECT_NAME__
             string Fallback() =>
                 appDirCandidates
                     .SelectMany(d => new[] { Path.Combine(d, "bundle.js"), Path.Combine(d, "bundle.mjs") })
-                    .FirstOrDefault(File.Exists);
+                    .FirstOrDefault(VExists);
 
             if (packageJsonPath == null)
                 return Fallback();
@@ -304,7 +429,7 @@ namespace __PROJECT_NAME__
 
         private static RuntimePackageConfig ParsePackageConfig(string packageJsonPath)
         {
-            using var doc = JsonDocument.Parse(File.ReadAllText(packageJsonPath));
+            using var doc = JsonDocument.Parse(VReadAllText(packageJsonPath));
             var config = new RuntimePackageConfig();
             if (doc.RootElement.TryGetProperty("main", out var main) && main.ValueKind == JsonValueKind.String)
                 config.Main = main.GetString();
@@ -321,11 +446,11 @@ namespace __PROJECT_NAME__
             foreach (var candidate in new[] { normalized, normalized + ".js", normalized + ".mjs" })
             {
                 var direct = Path.IsPathRooted(candidate) ? candidate : Path.Combine(baseDir, candidate);
-                if (File.Exists(direct)) return direct;
+                if (VExists(direct)) return direct;
                 var appLower = Path.Combine(baseDir, "app", candidate);
-                if (File.Exists(appLower)) return appLower;
+                if (VExists(appLower)) return appLower;
                 var appUpper = Path.Combine(baseDir, "App", candidate);
-                if (File.Exists(appUpper)) return appUpper;
+                if (VExists(appUpper)) return appUpper;
             }
             return null;
         }

package/framework/__PROJECT_NAME__/__PROJECT_NAME__.csproj

@@ -25,19 +25,14 @@
     <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>
 
@@ -87,12 +82,32 @@
     <Content Include="Properties\Default.rd.xml" />
 
     <!-- App JS/resource files — copied to the output directory on every build -->
-    <Content Include="app\**\*">
+    <!-- Sealed source-protected bundle when present, takes
+         priority over the plaintext app\ tree; produced by the nsbundle_pack packer tool. -->
+    <Content Include="app.nsbundle" Condition="Exists('app.nsbundle')">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="app\**\*" Condition="!Exists('app.nsbundle')">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- App_Resources: platform-specific assets (images, fonts, etc.). C# sources anywhere under
+         App_Resources\Windows (e.g. App_Resources\Windows\src\*.cs) and in plugins\<plugin>\ are
+         compiled into the app by the SDK's default Compile glob — the counterpart of Java/Kotlin in
+         App_Resources/Android/src and Objective-C/Swift in App_Resources/iOS/src — and JavaScript
+         reaches their types by namespace. Sources and MSBuild files aren't copied to the output. -->
+    <Content Include="App_Resources\**\*" Exclude="App_Resources\**\*.cs;App_Resources\**\*.csproj;App_Resources\**\*.props;App_Resources\**\*.targets" Condition="Exists('App_Resources')">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
 
-    <!-- App_Resources: platform-specific assets (images, fonts, etc.) -->
-    <Content Include="App_Resources\**\*" Condition="Exists('App_Resources')">
+    <!-- The app's metadata filter (App_Resources/Windows/native-api-usage.json, which the CLI writes
+         out next to this project): the runtime reads it next to the exe. -->
+    <Content Include="$(NSWindowsRoot)\whitelist.mdg" Condition="Exists('$(NSWindowsRoot)\whitelist.mdg')">
+      <Link>whitelist.mdg</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(NSWindowsRoot)\blacklist.mdg" Condition="Exists('$(NSWindowsRoot)\blacklist.mdg')">
+      <Link>blacklist.mdg</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
 
@@ -170,44 +185,23 @@
         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;"
+  <!-- A filter the app dropped must not stay in force from an earlier build's copy. -->
+  <Target Name="RemoveStaleMetadataFilter" BeforeTargets="CopyFilesToOutputDirectory">
+    <Delete Files="$(OutDir)whitelist.mdg" Condition="!Exists('$(NSWindowsRoot)\whitelist.mdg')" />
+    <Delete Files="$(OutDir)blacklist.mdg" Condition="!Exists('$(NSWindowsRoot)\blacklist.mdg')" />
+  </Target>
+
+    <!-- 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. JS subclasses of .NET and
+         WinRT classes need no generated code: the bridge creates their managed types at runtime. -->
+    <Target Name="RunDotNetTool" BeforeTargets="CoreCompile">
+      <Exec Command="&quot;$(DotNetToolExe)&quot; --app-root &quot;$(MSBuildProjectDirectory)&quot; --dir App"
         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;"
+        Command="cargo run --quiet --manifest-path &quot;$(WindowsRuntimeRepoRoot)\Cargo.toml&quot; -p dotnet-tool -- --app-root &quot;$(MSBuildProjectDirectory)&quot; --dir App"
         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"

package/framework/dotnet-bridge/BinaryProtocol.cs

@@ -17,6 +17,20 @@ internal readonly struct WinRtRef(long ptr)
     public readonly long Ptr = ptr;
 }
 
+// A JS function passed where a delegate is expected (tag 0x0C): the runtime's callback id, wrapped
+// in a delegate of the parameter's type when the call's arguments are coerced.
+internal readonly struct JsFunctionRef(int id)
+{
+    public readonly int Id = id;
+}
+
+// A plain JS object (tag 0x0D) as JSON, deserialized into the struct/record/class the parameter or
+// return type expects (e.g. `{ Width: 120, Height: 40 }` for Windows.Foundation.Size).
+internal sealed class JsJsonValue(string json)
+{
+    public readonly string Json = json;
+}
+
 internal ref struct BinReader(ReadOnlySpan<byte> buf)
 {
     private readonly ReadOnlySpan<byte> _buf = buf;
@@ -24,6 +38,8 @@ internal ref struct BinReader(ReadOnlySpan<byte> buf)
 
     public byte ReadByte() => _buf[_pos++];
 
+    public bool HasMore => _pos < _buf.Length;
+
     public int ReadI32()
     {
         var v = BinaryPrimitives.ReadInt32LittleEndian(_buf[_pos..]);
@@ -96,6 +112,8 @@ internal ref struct BinReader(ReadOnlySpan<byte> buf)
                 0x05 => (object)ReadString16(),
                 0x06 => (object)new HandleRef(ReadI32()),
                 0x0A => (object)new WinRtRef(ReadI64()),
+                0x0C => (object)new JsFunctionRef(ReadI32()),
+                0x0D => (object)new JsJsonValue(ReadString32()),
                 _    => null,
             };
         }