@nativescript/windows-jsc 0.1.0-alpha.0 → 0.1.0-next.2026-08-03-30819078286

package/README.md

@@ -1,55 +1,13 @@
-# @nativescript/windows-jsc
-
-NativeScript Windows runtime on **JavaScriptCore**, no Node. **Working** — the full WinRT demo
-passes (`exit 0`): typed WinRT calls, a 20-call stress loop, and a `JsonObject` round-trip.
-
-## As an app runtime (drop-in for `@nativescript/windows`)
-Publishes as `@nativescript/windows-jsc`, the **same** WinUI 3 framework as `@nativescript/windows`
-with the JavaScriptCore runtime DLL — swap the dependency and an app runs unchanged. Build the
-framework with the engine flag (needs a real `JavaScriptCore.lib` in `vendor/x64`):
-```sh
-pwsh -File ../../template/build.ps1 -Engine jsc   # or: npm run build
-```
-The engine → runtime-DLL adapter (the C ABI the WinUI 3 host P/Invokes) follows the reference
-implementation in `../windows-quickjs/src/abi.rs`. See `../README.md` for the full contract.
-
-## The engine binary — Playwright's WebKit (current)
-The official WebKit WinCairo buildbot is dead (last Windows build Sept 2024), and there's no NuGet/npm
-prebuilt. The **current** source of a Windows `JavaScriptCore.dll` is **Playwright**, which rebuilds
-WebKit constantly:
-
-```
-https://playwright.download.prss.microsoft.com/dbazure/download/playwright/builds/webkit/<rev>/webkit-win64.zip
-```
-(`<rev>` from `packages/playwright-core/browsers.json` in microsoft/playwright — 2331 at time of
-writing; the vendored `JavaScriptCore.dll` is dated 2026-07-14). It exports the full JSC C API and
-depends only on `icuin77.dll` / `icuuc77.dll` (+ `icudt77.dll` data).
-
-`vendor/x64/` holds (committed, no LFS): `JavaScriptCore.dll` (33 MB), `icudt77.dll` (32 MB),
-`icuin77.dll`, `icuuc77.dll`, and `JavaScriptCore.lib` — an **import lib generated from the DLL's
-exports** (no `.lib` ships in the zip):
-```sh
-llvm-objdump -p JavaScriptCore.dll | awk '/Export Table/{f=1;next} f&&/0x/{print $NF}' \
-  | grep -E '^(JS|WK|k)' | awk '{print ($0 ~ /^k/) ? $0" DATA" : $0}' > exports   # k* are DATA symbols
-printf 'EXPORTS\n' > JavaScriptCore.def; cat exports >> JavaScriptCore.def
-lib /def:JavaScriptCore.def /machine:x64 /out:JavaScriptCore.lib
-```
-
-## Build & run
-```sh
-cargo build --release --features jsc_link --manifest-path packages/windows-jsc/Cargo.toml
-target/release/nativescript-windows.exe
-```
-`build.rs` links `JavaScriptCore.lib` and copies the DLLs beside the exe.
-
-## Shim = napi-android's JSC provider (public C API), + two Windows fixes
-`jsc-api.cpp` is over JSC's stable public C API (no WebKit internals), so it's version-robust. Two
-bugs surfaced on Windows and are fixed in the vendored shim:
-- **UTF-16 read truncation**: `CopyTo` did `memcpy(buf, chars, size)` where `size` is a count of
-  2-byte `JSChar` → copied half the bytes (`'hi'`→`'h'`). Fixed to `size * sizeof(JSChar)`.
-- **napi functions weren't constructors**: `FunctionInfo`'s `JSClassDefinition` set `callAsFunction`
-  but not `callAsConstructor`, so a JS `Proxy` over them wasn't a constructor (`new
-  Windows.Data.Json.JsonObject()` → "not a constructor"). Added a `CallAsConstructor` callback (the
-  JSC analog of the QuickJS `JS_SetConstructorBit` fix; V8's napi functions are constructable by
-  default).
-Also `EXTERN_C` on the JSR bring-up decls (`jsr_common.h`) so the Rust host's `extern "C"` resolves.
+# @nativescript/windows-jsc
+
+NativeScript Windows runtime on **JavaScriptCore**.
+
+
+## The engine binary — Playwright's WebKit (current)
+The official WebKit WinCairo buildbot is dead (last Windows build Sept 2024), and there's no NuGet/npm
+prebuilt. The **current** source of a Windows `JavaScriptCore.dll` is **Playwright**, which rebuilds
+WebKit constantly:
+
+```
+https://playwright.download.prss.microsoft.com/dbazure/download/playwright/builds/webkit/<rev>/webkit-win64.zip
+```

package/framework/__PROJECT_NAME__/App.xaml

@@ -1,13 +1,13 @@
-<Application
-    x:Class="__PROJECT_NAME__.App"
-    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:local="using:__PROJECT_NAME__">
-    <Application.Resources>
-        <ResourceDictionary>
-            <ResourceDictionary.MergedDictionaries>
-                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
-            </ResourceDictionary.MergedDictionaries>
-        </ResourceDictionary>
-    </Application.Resources>
-</Application>
+<Application
+    x:Class="__PROJECT_NAME__.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:__PROJECT_NAME__">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>

package/framework/__PROJECT_NAME__/Package.appxmanifest

@@ -1,35 +1,35 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Package
-  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
-  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
-  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
-  IgnorableNamespaces="uap rescap">
-  <Identity Name="__APP_IDENTIFIER__" Publisher="CN=__PROJECT_NAME__" Version="1.0.0.0" />
-  <Properties>
-    <DisplayName>__PROJECT_NAME__</DisplayName>
-    <PublisherDisplayName>__PROJECT_NAME__</PublisherDisplayName>
-    <Logo>Assets\StoreLogo.png</Logo>
-  </Properties>
-  <Dependencies>
-    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26100.0" />
-    <!-- WinUI3 / Windows App SDK 1.6 framework package (framework-dependent). Required so the
-         registered app can activate Microsoft.UI.Xaml.* (else REGDB_E_CLASSNOTREG at startup). -->
-    <PackageDependency Name="Microsoft.WindowsAppRuntime.1.6" MinVersion="6000.0.0.0" Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US" />
-  </Dependencies>
-  <Resources>
-    <Resource Language="en-US" />
-  </Resources>
-  <Applications>
-    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="Windows.FullTrustApplication">
-      <uap:VisualElements DisplayName="__PROJECT_NAME__" Square150x150Logo="Assets\Square150x150Logo.png" Square44x44Logo="Assets\Square44x44Logo.png" Description="A NativeScript Windows application" BackgroundColor="#65ADF1">
-        <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png" />
-        <uap:SplashScreen Image="Assets\SplashScreen.png" />
-      </uap:VisualElements>
-    </Application>
-  </Applications>
-  <Capabilities>
-    <rescap:Capability Name="runFullTrust" />
-    <Capability Name="internetClient" />
-    <Capability Name="privateNetworkClientServer" />
-  </Capabilities>
-</Package>
+<?xml version="1.0" encoding="utf-8"?>
+<Package
+  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
+  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
+  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
+  IgnorableNamespaces="uap rescap">
+  <Identity Name="__APP_IDENTIFIER__" Publisher="CN=__PROJECT_NAME__" Version="1.0.0.0" />
+  <Properties>
+    <DisplayName>__PROJECT_NAME__</DisplayName>
+    <PublisherDisplayName>__PROJECT_NAME__</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26100.0" />
+    <!-- WinUI3 / Windows App SDK 1.6 framework package (framework-dependent). Required so the
+         registered app can activate Microsoft.UI.Xaml.* (else REGDB_E_CLASSNOTREG at startup). -->
+    <PackageDependency Name="Microsoft.WindowsAppRuntime.1.6" MinVersion="6000.0.0.0" Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US" />
+  </Dependencies>
+  <Resources>
+    <Resource Language="en-US" />
+  </Resources>
+  <Applications>
+    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="Windows.FullTrustApplication">
+      <uap:VisualElements DisplayName="__PROJECT_NAME__" Square150x150Logo="Assets\Square150x150Logo.png" Square44x44Logo="Assets\Square44x44Logo.png" Description="A NativeScript Windows application" BackgroundColor="#65ADF1">
+        <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png" />
+        <uap:SplashScreen Image="Assets\SplashScreen.png" />
+      </uap:VisualElements>
+    </Application>
+  </Applications>
+  <Capabilities>
+    <rescap:Capability Name="runFullTrust" />
+    <Capability Name="internetClient" />
+    <Capability Name="privateNetworkClientServer" />
+  </Capabilities>
+</Package>

package/framework/__PROJECT_NAME__/Program.cs

@@ -1,34 +1,34 @@
-using System;
-using System.Threading;
-using Microsoft.UI.Dispatching;
-using Microsoft.UI.Xaml;
-using WinRT;
-
-// Windows-only WinUI desktop app. The custom entry point (DISABLE_XAML_GENERATED_MAIN)
-// has no platform attribute, so CA1416 treats every Windows API call site as "reachable
-// on all platforms." Declaring the assembly's supported platform once tells the analyzer
-// the whole assembly only runs on Windows >= 17763, silencing those false positives.
-[assembly: System.Runtime.Versioning.SupportedOSPlatform("windows10.0.17763.0")]
-
-namespace __PROJECT_NAME__
-{
-    public static class Program
-    {
-        [System.STAThread]
-        public static void Main(string[] args)
-        {
-            ComWrappersSupport.InitializeComWrappers();
-
-            Application.Start((_callbackParams) =>
-            {
-                var dispatcherQueue = DispatcherQueue.GetForCurrentThread();
-                if (dispatcherQueue != null)
-                {
-                    SynchronizationContext.SetSynchronizationContext(new DispatcherQueueSynchronizationContext(dispatcherQueue));
-                }
-
-				new App();
-            });
-        }
-    }
-}
+using System;
+using System.Threading;
+using Microsoft.UI.Dispatching;
+using Microsoft.UI.Xaml;
+using WinRT;
+
+// Windows-only WinUI desktop app. The custom entry point (DISABLE_XAML_GENERATED_MAIN)
+// has no platform attribute, so CA1416 treats every Windows API call site as "reachable
+// on all platforms." Declaring the assembly's supported platform once tells the analyzer
+// the whole assembly only runs on Windows >= 17763, silencing those false positives.
+[assembly: System.Runtime.Versioning.SupportedOSPlatform("windows10.0.17763.0")]
+
+namespace __PROJECT_NAME__
+{
+    public static class Program
+    {
+        [System.STAThread]
+        public static void Main(string[] args)
+        {
+            ComWrappersSupport.InitializeComWrappers();
+
+            Application.Start((_callbackParams) =>
+            {
+                var dispatcherQueue = DispatcherQueue.GetForCurrentThread();
+                if (dispatcherQueue != null)
+                {
+                    SynchronizationContext.SetSynchronizationContext(new DispatcherQueueSynchronizationContext(dispatcherQueue));
+                }
+
+				new App();
+            });
+        }
+    }
+}

package/framework/__PROJECT_NAME__/Properties/Default.rd.xml

@@ -1,9 +1,9 @@
-<!--
-    Runtime Directives for .NET Native.
-    See https://go.microsoft.com/fwlink/?LinkID=391919
--->
-<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
-  <Application>
-    <Assembly Name="*Application*" Dynamic="Required All" />
-  </Application>
-</Directives>
+<!--
+    Runtime Directives for .NET Native.
+    See https://go.microsoft.com/fwlink/?LinkID=391919
+-->
+<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
+  <Application>
+    <Assembly Name="*Application*" Dynamic="Required All" />
+  </Application>
+</Directives>

package/framework/dotnet-bridge/BinaryProtocol.cs

@@ -1,161 +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);
-    }
-}
+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);
+    }
+}