@nativescript/windows 0.1.0-alpha.1 → 0.1.0-alpha.10

package/build.ps1

@@ -27,7 +27,8 @@
 param(
     [switch]$SkipArm64,
     [switch]$SkipRelease,
-    [switch]$SkipDevtools
+    [switch]$SkipDevtools,
+    [switch]$SkipDotnet
 )
 
 Set-StrictMode -Version Latest
@@ -69,6 +70,38 @@ function Build-Crate {
     }
 }
 
+# ── DotNet Bridge ─────────────────────────────────────────────────────────────
+# Copies the dotnet-bridge source (csproj + .cs files) into
+# template/framework/dotnet-bridge/ so it ships inside the npm package.
+# The actual `dotnet publish` is deferred to the app's MSBuild process —
+# see the PublishDotNetBridge target in __PROJECT_NAME__.csproj.
+
+if (-not $SkipDotnet) {
+    Write-Host "`n=== DotNet Bridge (source copy) ===" -ForegroundColor Cyan
+    $BridgeSrc  = Join-Path $RepoRoot "dotnet-bridge"
+    $BridgeDest = Join-Path $ScriptDir "framework\dotnet-bridge"
+
+    # Wipe the destination so stale files don't linger between runs.
+    if (Test-Path $BridgeDest) { Remove-Item -Recurse -Force $BridgeDest }
+    $null = New-Item -ItemType Directory -Force -Path $BridgeDest
+
+    # Copy only source files; exclude build/publish artefacts.
+    Get-ChildItem -Path $BridgeSrc -Recurse |
+        Where-Object {
+            $rel = $_.FullName.Substring($BridgeSrc.Length + 1)
+            $rel -notmatch '^(bin|obj|publish)(\\|$)'
+        } |
+        ForEach-Object {
+            $dest = Join-Path $BridgeDest $_.FullName.Substring($BridgeSrc.Length + 1)
+            if ($_.PSIsContainer) {
+                $null = New-Item -ItemType Directory -Force -Path $dest
+            } else {
+                Copy-Item -Force $_.FullName $dest
+                Write-Host "  copied  $($_.FullName.Substring($BridgeSrc.Length + 1))"
+            }
+        }
+}
+
 # ── Targets ───────────────────────────────────────────────────────────────────
 
 $Targets = @(

package/framework/__PROJECT_NAME__/RuntimeHost.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text.Json;
 
@@ -139,28 +140,63 @@ namespace __PROJECT_NAME__
         private static string ResolveEntryScriptPath()
         {
             var baseDir = AppContext.BaseDirectory;
-            var defaultPath = Path.Combine(baseDir, "App", "main.js");
-            var packageJsonPath = Path.Combine(baseDir, "package.json");
+            // EXE lives in <project>/bin/; webpack bundle lives in <project>/app/.
+            var parentDir = Path.GetDirectoryName(
+                baseDir.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar))
+                ?? baseDir;
 
-            if (!File.Exists(packageJsonPath)) return defaultPath;
+            // Candidate app directories: sibling of bin/ first, then directly under baseDir.
+            var appDirCandidates = new[]
+            {
+                Path.Combine(parentDir, "app"),
+                Path.Combine(parentDir, "App"),
+                Path.Combine(baseDir, "app"),
+                Path.Combine(baseDir, "App"),
+            };
+
+            string packageJsonPath = null;
+            string resolvedBaseDir = null;
+            foreach (var dir in appDirCandidates)
+            {
+                var candidate = Path.Combine(dir, "package.json");
+                if (File.Exists(candidate))
+                {
+                    packageJsonPath = candidate;
+                    resolvedBaseDir = dir;
+                    break;
+                }
+            }
+
+            // Also accept package.json at the project root (parent of bin/).
+            if (packageJsonPath == null && File.Exists(Path.Combine(parentDir, "package.json")))
+            {
+                packageJsonPath = Path.Combine(parentDir, "package.json");
+                resolvedBaseDir = parentDir;
+            }
+
+            string Fallback() =>
+                appDirCandidates.Select(d => Path.Combine(d, "bundle.js")).FirstOrDefault(File.Exists);
+
+            if (packageJsonPath == null)
+                return Fallback();
 
             try
             {
                 var config = ParsePackageConfig(packageJsonPath);
                 if (!string.IsNullOrWhiteSpace(config.WindowsMain))
                 {
-                    var p = ResolveScriptPath(baseDir, config.WindowsMain);
+                    var p = ResolveScriptPath(resolvedBaseDir, config.WindowsMain);
                     if (p != null) return p;
                 }
                 if (!string.IsNullOrWhiteSpace(config.Main))
                 {
-                    var p = ResolveScriptPath(baseDir, config.Main);
+                    var p = ResolveScriptPath(resolvedBaseDir, config.Main);
                     if (p != null) return p;
                 }
             }
             catch { }
 
-            return defaultPath;
+            return Fallback();
         }
 
         private static RuntimePackageConfig ParsePackageConfig(string packageJsonPath)
@@ -179,10 +215,16 @@ namespace __PROJECT_NAME__
         {
             if (string.IsNullOrWhiteSpace(scriptPath)) return null;
             var normalized = scriptPath.Replace('/', Path.DirectorySeparatorChar);
-            var direct = Path.IsPathRooted(normalized) ? normalized : Path.Combine(baseDir, normalized);
-            if (File.Exists(direct)) return direct;
-            var appPath = Path.Combine(baseDir, "App", normalized);
-            return File.Exists(appPath) ? appPath : null;
+            foreach (var candidate in new[] { normalized, normalized + ".js" })
+            {
+                var direct = Path.IsPathRooted(candidate) ? candidate : Path.Combine(baseDir, candidate);
+                if (File.Exists(direct)) return direct;
+                var appLower = Path.Combine(baseDir, "app", candidate);
+                if (File.Exists(appLower)) return appLower;
+                var appUpper = Path.Combine(baseDir, "App", candidate);
+                if (File.Exists(appUpper)) return appUpper;
+            }
+            return null;
         }
 
         public void Dispose()

package/framework/__PROJECT_NAME__/__PROJECT_NAME__.csproj

@@ -19,12 +19,20 @@
     <NSWindowsRoot>$(MSBuildProjectDirectory)\..</NSWindowsRoot>
   </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>
     <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\**\*">
+    <Content Include="app\**\*">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
 
@@ -33,18 +41,60 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
 
-    <!-- Debug: devtools-enabled runtime DLL -->
-    <Content Include="$(NSWindowsRoot)\libs\devtools\$(Platform)\nativescript.dll"
-             Condition="'$(Configuration)' == 'Debug'">
+    <!-- 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>
 
-    <!-- Release: production runtime DLL -->
-    <Content Include="$(NSWindowsRoot)\libs\$(Platform)\nativescript.dll"
-             Condition="'$(Configuration)' != 'Debug'">
+    <!-- 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>
+
   </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="high" />
+    <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\publish\%(RecursiveDir)%(Filename)%(Extension)')"
+          SkipUnchangedFiles="true" />
+  </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')" />
+
+  <!-- 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')" />
 </Project>

package/framework/dotnet-bridge/Bridge.cs

@@ -0,0 +1,353 @@
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NativeScriptBridge;
+
+/// <summary>
+/// Reflection-based .NET dispatch bridge — UTF-8 ABI edition.
+///
+/// Invoke() receives a UTF-8 byte slice (no string allocation on the Rust side),
+/// dispatches via reflection, and serialises the response directly to a UTF-8
+/// byte array via JsonSerializer.SerializeToUtf8Bytes().  This removes the
+/// UTF-16 encode/decode round-trip of the original char* ABI.
+///
+/// Request JSON schema
+/// -------------------
+///   Static call:    { "assembly": "System", "typeName": "System.Diagnostics.Stopwatch", "method": "StartNew", "args": [] }
+///   Constructor:    { "assembly": "System", "typeName": "System.Text.StringBuilder",    "method": ".ctor",    "args": [128] }
+///   Instance call:  { "handle": 3, "method": "Stop",          "args": [] }
+///   Property get:   { "assembly": "...", "typeName": "...",   "method": "get_Now",      "args": [] }
+///   Property set:   { "handle": 3, "method": "set_IsEnabled", "args": [true] }
+///   Release:        { "handle": 3, "method": "__release",     "args": [] }
+///
+/// Response JSON schema
+/// --------------------
+///   Primitive / string:   { "result": 42.5 }
+///   Managed object:       { "result": { "__handle": 7, "__type": "System.Diagnostics.Stopwatch" } }
+///   Array / enumerable:   { "result": [1, 2, 3] }
+///   Error:                { "error": "Method not found" }
+/// </summary>
+public static class Bridge
+{
+    private static readonly ConcurrentDictionary<int, object?> s_handles = new();
+    private static int s_nextHandle;
+
+    private static readonly ConcurrentDictionary<string, Type?> s_typeCache = new();
+    private static readonly ConcurrentDictionary<string, MethodInfo?> s_methodCache = new();
+    private static readonly ConcurrentDictionary<string, PropertyInfo?> s_propertyCache = new();
+
+    // ── exported entry points ────────────────────────────────────────────────
+
+    /// Called by the Rust runtime.  Request arrives as a raw UTF-8 byte slice;
+    /// response is written as a UTF-8 byte buffer allocated with Marshal.AllocHGlobal.
+    [UnmanagedCallersOnly(EntryPoint = "Invoke",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe int Invoke(
+        byte* requestPtr, int requestLen,
+        byte** responsePtr, int* responseLenPtr)
+    {
+        byte[] responseBytes;
+        try
+        {
+            var requestSpan = new ReadOnlySpan<byte>(requestPtr, requestLen);
+            var req = JsonSerializer.Deserialize<InvokeRequest>(requestSpan, JsonOptions.Default)!;
+            var result = Dispatch(req);
+            responseBytes = JsonSerializer.SerializeToUtf8Bytes(result, JsonOptions.Default);
+        }
+        catch (Exception ex)
+        {
+            var errResult = new InvokeResult(null, Unwrap(ex).Message);
+            responseBytes = JsonSerializer.SerializeToUtf8Bytes(errResult, JsonOptions.Default);
+        }
+
+        WriteResponse(responseBytes, responsePtr, responseLenPtr);
+        return 0;
+    }
+
+    /// Frees the response buffer allocated by Invoke.
+    [UnmanagedCallersOnly(EntryPoint = "Free",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe void Free(byte* ptr)
+    {
+        if (ptr != null)
+            Marshal.FreeHGlobal((IntPtr)ptr);
+    }
+
+    // ── dispatch ─────────────────────────────────────────────────────────────
+
+    private static InvokeResult Dispatch(InvokeRequest req)
+    {
+        if (req.Method == "__release" && req.Handle.HasValue)
+        {
+            s_handles.TryRemove(req.Handle.Value, out _);
+            return new InvokeResult(null, null);
+        }
+
+        // Return reflection metadata so JS can distinguish methods from properties.
+        if (req.Method == "__members__")
+        {
+            var t = req.Handle.HasValue
+                ? (s_handles.TryGetValue(req.Handle.Value, out var h) ? h?.GetType() : null)
+                : ResolveType(req.Assembly, req.TypeName);
+            if (t is null) return new InvokeResult(null, $"Type not found: {req.TypeName}");
+            var inst   = BindingFlags.Public | BindingFlags.Instance;
+            var stat   = BindingFlags.Public | BindingFlags.Static;
+            var members = new
+            {
+                methods          = t.GetMethods(inst).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
+                properties       = t.GetProperties(inst).Select(p => p.Name).Distinct().ToArray(),
+                staticMethods    = t.GetMethods(stat).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
+                staticProperties = t.GetProperties(stat).Select(p => p.Name).Distinct().ToArray(),
+            };
+            return new InvokeResult(JsonSerializer.SerializeToElement(members, JsonOptions.Default), null);
+        }
+
+        object? target = null;
+        Type? type = null;
+
+        if (req.Handle.HasValue)
+        {
+            if (!s_handles.TryGetValue(req.Handle.Value, out target))
+                return new InvokeResult(null, $"Invalid handle {req.Handle.Value}");
+            type = target?.GetType();
+        }
+        else
+        {
+            type = ResolveType(req.Assembly, req.TypeName);
+            if (type is null)
+                return new InvokeResult(null, $"Type not found: {req.TypeName}");
+        }
+
+        if (type is null)
+            return new InvokeResult(null, "Cannot determine target type");
+
+        var method = req.Method ?? throw new ArgumentException("Method is required");
+
+        // ── Constructor ──────────────────────────────────────────────────────
+        if (method == ".ctor")
+        {
+            var argElements = req.Args ?? [];
+            var ctors = type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
+            var ctor = ctors.FirstOrDefault(c => c.GetParameters().Length == argElements.Count)
+                    ?? ctors.FirstOrDefault();
+            if (ctor is null)
+                return new InvokeResult(null, $"No public constructor found on {type.FullName}");
+            var pars = ctor.GetParameters();
+            var ctorArgs = new object?[pars.Length];
+            for (int i = 0; i < pars.Length && i < argElements.Count; i++)
+                ctorArgs[i] = Coerce(argElements[i], pars[i].ParameterType);
+            return Box(ctor.Invoke(ctorArgs));
+        }
+
+        var isStatic = target is null;
+        var flags = (isStatic ? BindingFlags.Static : BindingFlags.Instance)
+                  | BindingFlags.Public;
+
+        // ── Property getter / setter ─────────────────────────────────────────
+        if (method.StartsWith("get_", StringComparison.Ordinal))
+        {
+            var prop = GetCachedProperty(type, method[4..], flags);
+            if (prop is not null)
+                return Box(prop.GetValue(target));
+        }
+        if (method.StartsWith("set_", StringComparison.Ordinal) && req.Args?.Count == 1)
+        {
+            var prop = GetCachedProperty(type, method[4..], flags);
+            if (prop is not null)
+            {
+                prop.SetValue(target, Coerce(req.Args[0], prop.PropertyType));
+                return new InvokeResult(null, null);
+            }
+        }
+
+        // ── Regular method ───────────────────────────────────────────────────
+        var argElems = req.Args ?? [];
+        var mi = FindMethod(type, method, argElems.Count, flags);
+        if (mi is null)
+            return new InvokeResult(null,
+                $"Method '{method}' ({argElems.Count} args) not found on {type.FullName}");
+
+        var parameters = mi.GetParameters();
+        var callArgs = new object?[parameters.Length];
+        for (int i = 0; i < parameters.Length && i < argElems.Count; i++)
+            callArgs[i] = Coerce(argElems[i], parameters[i].ParameterType);
+
+        return Box(AwaitIfTask(mi.Invoke(target, callArgs)));
+    }
+
+    // ── helpers ───────────────────────────────────────────────────────────────
+
+    private static object? AwaitIfTask(object? value)
+    {
+        if (value is null) return null;
+        var t = value.GetType();
+
+        if (value is Task task)
+        {
+            task.Wait();
+            if (task.IsFaulted)
+                throw task.Exception!.InnerException ?? task.Exception;
+            return t.GetProperty("Result")?.GetValue(value);
+        }
+
+        if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ValueTask<>))
+        {
+            var innerTask = (Task)t.GetMethod("AsTask")!.Invoke(value, null)!;
+            innerTask.Wait();
+            if (innerTask.IsFaulted)
+                throw innerTask.Exception!.InnerException ?? innerTask.Exception;
+            return innerTask.GetType().GetProperty("Result")?.GetValue(innerTask);
+        }
+
+        if (value is System.Threading.Tasks.ValueTask vt)
+        {
+            vt.AsTask().Wait();
+            return null;
+        }
+
+        return value;
+    }
+
+    private static Type? ResolveType(string? assemblyName, string? typeName)
+    {
+        if (string.IsNullOrEmpty(typeName)) return null;
+        var key = string.IsNullOrEmpty(assemblyName) ? typeName : $"{assemblyName}|{typeName}";
+        return s_typeCache.GetOrAdd(key, _ => ResolveTypeCore(assemblyName, typeName));
+    }
+
+    private static Type? ResolveTypeCore(string? assemblyName, string? typeName)
+    {
+        var fqn = string.IsNullOrEmpty(assemblyName) ? typeName! : $"{typeName}, {assemblyName}";
+        var t = Type.GetType(fqn);
+        if (t is not null) return t;
+
+        foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            t = asm.GetType(typeName!);
+            if (t is not null) return t;
+        }
+
+        if (!string.IsNullOrEmpty(assemblyName))
+        {
+            try
+            {
+                var asm = Assembly.Load(assemblyName);
+                t = asm.GetType(typeName!);
+                if (t is not null) return t;
+            }
+            catch { }
+        }
+
+        return null;
+    }
+
+    private static MethodInfo? FindMethod(Type type, string name, int argCount, BindingFlags flags)
+    {
+        var key = $"{type.FullName}|{name}|{argCount}|{(int)flags}";
+        return s_methodCache.GetOrAdd(key, _ => FindMethodCore(type, name, argCount, flags));
+    }
+
+    private static MethodInfo? FindMethodCore(Type type, string name, int argCount, BindingFlags flags)
+    {
+        var match = Array.Find(
+            type.GetMethods(flags),
+            m => m.Name == name && !m.IsGenericMethod && m.GetParameters().Length == argCount);
+        if (match is not null) return match;
+        return type.GetMethod(name, flags);
+    }
+
+    private static PropertyInfo? GetCachedProperty(Type type, string name, BindingFlags flags)
+    {
+        var key = $"{type.FullName}|{name}|{(int)flags}";
+        return s_propertyCache.GetOrAdd(key, _ => type.GetProperty(name, flags));
+    }
+
+    private static object? Coerce(JsonElement el, Type targetType)
+    {
+        if (el.ValueKind == JsonValueKind.Null) return null;
+        if (el.ValueKind == JsonValueKind.Object && el.TryGetProperty("__handle", out var h))
+        {
+            s_handles.TryGetValue(h.GetInt32(), out var obj);
+            return obj;
+        }
+        return JsonSerializer.Deserialize(el.GetRawText(), targetType, JsonOptions.Default);
+    }
+
+    private static InvokeResult Box(object? value)
+    {
+        if (value is null) return new InvokeResult(null, null);
+
+        var t = value.GetType();
+
+        if (t.IsPrimitive || t == typeof(string) || t == typeof(decimal)
+            || t == typeof(DateTime) || t == typeof(DateTimeOffset)
+            || t == typeof(TimeSpan) || t == typeof(Guid))
+        {
+            return new InvokeResult(
+                JsonSerializer.SerializeToElement(value, t, JsonOptions.Default), null);
+        }
+
+        // Arrays and IEnumerable — serialise as JSON arrays.
+        if (t.IsArray || (t != typeof(string) && value is IEnumerable enumerable))
+        {
+            try
+            {
+                var list = new List<object?>();
+                foreach (var item in (IEnumerable)value) list.Add(item);
+                return new InvokeResult(
+                    JsonSerializer.SerializeToElement(list, typeof(List<object?>), JsonOptions.Default),
+                    null);
+            }
+            catch { }
+        }
+
+        var id = Interlocked.Increment(ref s_nextHandle);
+        s_handles[id] = value;
+        return new InvokeResult(
+            JsonSerializer.SerializeToElement(
+                new { __handle = id, __type = t.FullName }, JsonOptions.Default),
+            null);
+    }
+
+    private static Exception Unwrap(Exception ex) =>
+        ex is TargetInvocationException { InnerException: { } inner } ? Unwrap(inner) : ex;
+
+    private static unsafe void WriteResponse(byte[] json, byte** responsePtr, int* responseLenPtr)
+    {
+        var ptr = (byte*)Marshal.AllocHGlobal(json.Length + 1);
+        Marshal.Copy(json, 0, (IntPtr)ptr, json.Length);
+        ptr[json.Length] = 0;
+        *responsePtr = ptr;
+        *responseLenPtr = json.Length;
+    }
+}
+
+// ── JSON types ────────────────────────────────────────────────────────────────
+
+internal sealed record InvokeRequest(
+    string? Assembly,
+    string? TypeName,
+    string? Method,
+    int? Handle,
+    List<JsonElement>? Args
+);
+
+internal sealed record InvokeResult(JsonElement? Result, string? Error);
+
+internal static class JsonOptions
+{
+    internal static readonly JsonSerializerOptions Default = new()
+    {
+        PropertyNameCaseInsensitive = true,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    };
+}

package/framework/dotnet-bridge/DotNetBridge.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <AssemblyName>DotNetBridge</AssemblyName>
+    <RootNamespace>NativeScriptBridge</RootNamespace>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <Nullable>enable</Nullable>
+    <Optimize>true</Optimize>
+    <!-- Regular class library — hostfxr loads it at runtime; no NativeAOT needed. -->
+    <OutputType>Library</OutputType>
+    <!-- Required: dotnet publish on a class library won't emit runtimeconfig.json by default. -->
+    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+    <!-- Allow hostfxr to load this assembly under net10+ without a re-publish.
+         Default (Minor) only accepts patch updates within major 9, which fails when the
+         host process is already running on net10. LatestMajor accepts any version >= 9. -->
+    <RollForward>LatestMajor</RollForward>
+  </PropertyGroup>
+
+</Project>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nativescript/windows",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.10",
   "description": "NativeScript for using Windows v8",
   "repository": {
         "type": "git",
@@ -8,7 +8,8 @@
   },
   "scripts": {
     "build": "pwsh -File build.ps1",
-    "build:x64": "pwsh -File build.ps1 -SkipArm64"
+    "build:x64": "pwsh -File build.ps1 -SkipArm64",
+    "build:nodotnet": "pwsh -File build.ps1 -SkipDotnet"
   },
   "keywords": ["nativescript", "windows", "winrt", "uwp"],
   "license": "Apache-2.0",

package/framework/__PROJECT_NAME__/App/main.js

@@ -1,12 +0,0 @@
-const page = new Windows.UI.Xaml.Controls.Page();
-const text = new Windows.UI.Xaml.Controls.TextBlock();
-text.Text = "Hello from NativeScript on Windows!";
-text.FontSize = 24;
-text.HorizontalAlignment = Windows.UI.Xaml.HorizontalAlignment.Center;
-text.VerticalAlignment = Windows.UI.Xaml.VerticalAlignment.Center;
-
-const grid = new Windows.UI.Xaml.Controls.Grid();
-grid.Children.Append(text);
-page.Content = grid;
-
-Windows.UI.Xaml.Window.Current.Content = page;