@nativescript/windows 0.1.0-alpha.4 → 0.1.0-alpha.41

package/framework/__PROJECT_NAME__/RuntimeHost.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text.Json;
 
@@ -26,6 +28,28 @@ namespace __PROJECT_NAME__
         [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_install_ctrlc_handler))]
         private static extern void runtime_install_ctrlc_handler(int exitCode);
 
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_set_local_folder))]
+        private static extern void runtime_set_local_folder([MarshalAs(UnmanagedType.LPUTF8Str)] string localFolder);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_get_last_js_error))]
+        private static extern IntPtr runtime_get_last_js_error();
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_free_js_error))]
+        private static extern void runtime_free_js_error(IntPtr ptr);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_has_devtools))]
+        private static extern bool runtime_has_devtools();
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_pump_timers))]
+        private static extern void runtime_pump_timers();
+
+        public void PumpTimers()
+        {
+            if (!_initialized) return;
+            try { runtime_pump_timers(); }
+            catch { }
+        }
+
 #if DEBUG
         [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_devtools_start))]
         private static extern IntPtr runtime_devtools_start(long runtime, ushort port);
@@ -38,9 +62,11 @@ namespace __PROJECT_NAME__
 
         public string DevtoolsFrontendUrl { get; private set; }
 
+        private bool _devtoolsAvailable;
+
         public void PumpDevtools()
         {
-            if (!_initialized) return;
+            if (!_initialized || !_devtoolsAvailable) return;
             try { runtime_devtools_pump(_runtime); }
             catch (Exception ex)
             {
@@ -50,6 +76,7 @@ namespace __PROJECT_NAME__
 
         private void StartDevtoolsSafely()
         {
+            if (!runtime_has_devtools()) return;
             IntPtr urlPtr = IntPtr.Zero;
             try
             {
@@ -60,7 +87,10 @@ namespace __PROJECT_NAME__
                     ? $"devtools://devtools/bundled/inspector.html?ws={wsUrl.Replace("ws://", "")}"
                     : null;
                 if (DevtoolsFrontendUrl != null)
+                {
+                    _devtoolsAvailable = true;
                     System.Diagnostics.Debug.WriteLine($"[NativeScript DevTools] {DevtoolsFrontendUrl}");
+                }
             }
             catch (Exception ex)
             {
@@ -82,6 +112,7 @@ namespace __PROJECT_NAME__
             if (_initialized) return;
             AttachConsole(ATTACH_PARENT_PROCESS);
             runtime_install_ctrlc_handler(0);
+            runtime_set_local_folder(Windows.Storage.ApplicationData.Current.LocalFolder.Path);
             _runtime = runtime_init(AppContext.BaseDirectory);
 #if DEBUG
             if (ConsumeDebugBreakMarker())
@@ -117,16 +148,38 @@ namespace __PROJECT_NAME__
                 throw new InvalidOperationException("Runtime must be initialized before running scripts.");
 
             var entryPath = ResolveEntryScriptPath();
-            var script = File.ReadAllText(Path.GetFullPath(entryPath));
-            try
+            if (entryPath == null)
             {
-                runtime_runscript(_runtime, script, Path.GetFileName(entryPath));
+                System.Diagnostics.Debug.WriteLine("[NativeScript Runtime] No entry script found — bundle missing from app directory.");
+                return;
             }
-            catch (Exception ex)
+
+            var dir = Path.GetDirectoryName(Path.GetFullPath(entryPath));
+            var chunks = new List<string>();
+            foreach (var chunkName in new[] { "runtime.js", "vendor.js" })
+            {
+                var chunkPath = Path.Combine(dir, chunkName);
+                if (File.Exists(chunkPath) &&
+                    !string.Equals(chunkPath, Path.GetFullPath(entryPath), StringComparison.OrdinalIgnoreCase))
+                {
+                    chunks.Add(chunkPath);
+                }
+            }
+            chunks.Add(entryPath);
+
+            foreach (var scriptPath in chunks)
             {
-                CrashDiagnostics.WriteExceptionReport("RuntimeHost.RunMainScript", ex, "EntryScript=" + entryPath);
-                System.Diagnostics.Debug.WriteLine($"[NativeScript Runtime] Script execution failed ({entryPath}): {ex}");
-                throw;
+                var script = File.ReadAllText(Path.GetFullPath(scriptPath));
+                try
+                {
+                    runtime_runscript(_runtime, script, Path.GetFileName(scriptPath));
+                }
+                catch (Exception ex)
+                {
+                    CrashDiagnostics.WriteExceptionReport("RuntimeHost.RunMainScript", ex, "Script=" + scriptPath);
+                    System.Diagnostics.Debug.WriteLine($"[NativeScript Runtime] Script execution failed ({scriptPath}): {ex}");
+                    throw;
+                }
             }
         }
 
@@ -139,30 +192,65 @@ namespace __PROJECT_NAME__
         private static string ResolveEntryScriptPath()
         {
             var baseDir = AppContext.BaseDirectory;
-            var defaultLower = Path.Combine(baseDir, "app", "main.js");
-            var defaultUpper = 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;
+
+            // 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;
+            }
 
-            if (!File.Exists(packageJsonPath))
-                return File.Exists(defaultLower) ? defaultLower : defaultUpper;
+            string Fallback() =>
+                appDirCandidates
+                    .SelectMany(d => new[] { Path.Combine(d, "bundle.js"), Path.Combine(d, "bundle.mjs") })
+                    .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 File.Exists(defaultLower) ? defaultLower : defaultUpper;
+            return Fallback();
         }
 
         private static RuntimePackageConfig ParsePackageConfig(string packageJsonPath)
@@ -181,12 +269,34 @@ 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 appLower = Path.Combine(baseDir, "app", normalized);
-            if (File.Exists(appLower)) return appLower;
-            var appUpper = Path.Combine(baseDir, "App", normalized);
-            return File.Exists(appUpper) ? appUpper : null;
+            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;
+                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;
+        }
+
+        /// Returns the last JavaScript error (message + stack trace) captured during
+        /// script execution, or null if no error was recorded since the last call.
+        public string GetLastJsError()
+        {
+            if (!_initialized) return null;
+            IntPtr ptr = IntPtr.Zero;
+            try
+            {
+                ptr = runtime_get_last_js_error();
+                return ptr == IntPtr.Zero ? null : Marshal.PtrToStringUTF8(ptr);
+            }
+            catch { return null; }
+            finally
+            {
+                if (ptr != IntPtr.Zero) runtime_free_js_error(ptr);
+            }
         }
 
         public void Dispose()

package/framework/__PROJECT_NAME__/__PROJECT_NAME__.csproj

@@ -25,6 +25,10 @@
     <NSLibPlatform Condition="'$(Platform)' != ''">$(Platform)</NSLibPlatform>
     <NSLibPlatform Condition="'$(NSLibPlatform)' == '' and '$(RuntimeIdentifier)' != ''">$([System.Text.RegularExpressions.Regex]::Replace('$(RuntimeIdentifier)','^win-',''))</NSLibPlatform>
     <NSLibPlatform Condition="'$(NSLibPlatform)' == ''">x64</NSLibPlatform>
+    <!-- Windows SDK .NET runtime pack location (resolved from NuGet cache) -->
+    <_WinSdkNetRefPkg>$(NuGetPackageRoot)microsoft.windows.sdk.net.ref</_WinSdkNetRefPkg>
+    <_WinSdkNetRefVer Condition="Exists('$(_WinSdkNetRefPkg)\10.0.26100.57')">10.0.26100.57</_WinSdkNetRefVer>
+    <_WinSdkNetRefLib Condition="'$(_WinSdkNetRefVer)' != ''">$(_WinSdkNetRefPkg)\$(_WinSdkNetRefVer)\lib\net8.0</_WinSdkNetRefLib>
   </PropertyGroup>
 
   <ItemGroup>
@@ -41,6 +45,29 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
 
+    <!-- UWP logo/splash assets required for Add-AppxPackage -Register -->
+    <Content Include="Assets\**\*" Condition="Exists('Assets')">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- Windows SDK .NET runtime pack assemblies — required when the dotnet workload
+         is not installed; copied from the NuGet package cache. -->
+    <Content Include="$(_WinSdkNetRefLib)\Microsoft.Windows.UI.Xaml.dll"
+             Condition="'$(_WinSdkNetRefLib)' != '' and Exists('$(_WinSdkNetRefLib)\Microsoft.Windows.UI.Xaml.dll')">
+      <Link>Microsoft.Windows.UI.Xaml.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(_WinSdkNetRefLib)\WinRT.Runtime.dll"
+             Condition="'$(_WinSdkNetRefLib)' != '' and Exists('$(_WinSdkNetRefLib)\WinRT.Runtime.dll')">
+      <Link>WinRT.Runtime.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(_WinSdkNetRefLib)\Microsoft.Windows.SDK.NET.dll"
+             Condition="'$(_WinSdkNetRefLib)' != '' and Exists('$(_WinSdkNetRefLib)\Microsoft.Windows.SDK.NET.dll')">
+      <Link>Microsoft.Windows.SDK.NET.dll</Link>
+      <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')">
@@ -55,21 +82,12 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
 
-    <!-- .NET bridge — published on first build by the target below; enables ns.dotnet.*
-         APIs from JavaScript. Must land at dotnet-bridge\publish\ relative to the
-         executable so the Rust runtime can locate DotNetBridge.dll via
-         AppContext.BaseDirectory. Condition guards against a missing source tree. -->
-    <Content Include="$(NSWindowsRoot)\dotnet-bridge\publish\**\*"
-             Condition="Exists('$(NSWindowsRoot)\dotnet-bridge\publish')">
-      <Link>dotnet-bridge\publish\%(RecursiveDir)%(Filename)%(Extension)</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
   </ItemGroup>
 
   <!--
-    Publishes DotNetBridge.dll before the app build so the Content glob above has
-    something to pick up.  Inputs/Outputs make this incremental: MSBuild skips the
-    Exec entirely when DotNetBridge.dll is newer than both source files.
+    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"
@@ -81,6 +99,25 @@
     <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')" />
 

package/framework/dotnet-bridge/BinaryProtocol.cs

@@ -0,0 +1,124 @@
+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;
+}
+
+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 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 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()),
+                _    => 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 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);
+    }
+}

package/framework/dotnet-bridge/Bridge.BinaryDispatch.cs

@@ -0,0 +1,177 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace NativeScriptBridge;
+
+public static partial class Bridge
+{
+    [UnmanagedCallersOnly(EntryPoint = "InvokeBinary",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe int InvokeBinary(
+        byte* requestPtr, int requestLen,
+        byte** responsePtr, int* responseLenPtr)
+    {
+        try
+        {
+            var r   = new BinReader(new ReadOnlySpan<byte>(requestPtr, requestLen));
+            var res = DispatchBin(ref r);
+            var buf = new ArrayBufferWriter<byte>(128);
+            res.WriteAsBin(buf);
+            WriteUnmanaged(buf.WrittenSpan, responsePtr, responseLenPtr);
+        }
+        catch (Exception ex)
+        {
+            WriteBinError(Unwrap(ex).Message, responsePtr, responseLenPtr);
+        }
+        return 0;
+    }
+
+    internal static DispatchResult DispatchBin(ref BinReader r)
+    {
+        var op = r.ReadByte();
+
+        if (op == 0x04) // release
+        {
+            s_handles.TryRemove(r.ReadI32(), out _);
+            return DispatchResult.Void;
+        }
+
+        if (op == 0x05) // members by handle
+        {
+            var h = r.ReadI32();
+            if (!s_handles.TryGetValue(h, out var obj))
+                throw new KeyNotFoundException($"Invalid handle {h}");
+            return BuildMembersResult(
+                obj?.GetType() ?? throw new InvalidOperationException("Handle is null"));
+        }
+
+        if (op == 0x06) // members by type
+        {
+            var typeName = r.ReadString16();
+            var assembly = r.ReadString16();
+            var type = ResolveType(NullIfEmpty(assembly), typeName)
+                ?? throw new TypeLoadException($"Type not found: {typeName}");
+            return BuildMembersResult(type);
+        }
+
+        if (op == 0x01) // instance call
+        {
+            var handle = r.ReadI32();
+            if (!s_handles.TryGetValue(handle, out var target))
+                throw new KeyNotFoundException($"Invalid handle {handle}");
+            var type   = target?.GetType() ?? throw new InvalidOperationException("Handle is null");
+            var method = r.ReadString16();
+            var args   = r.ReadArgs();
+            return DispatchCallBin(target, type, method, args, isStatic: false);
+        }
+
+        if (op == 0x09) // create JS delegate
+        {
+            var delTypeName  = r.ReadString16(); // "" → System.Action
+            var callbackId   = r.ReadI32();
+            return CreateJsDelegate(delTypeName, callbackId);
+        }
+
+        // Static ops: 0x02 = call, 0x03 = constructor
+        var typeNameS = r.ReadString16();
+        var assemblyS = r.ReadString16();
+        var typeS = ResolveType(NullIfEmpty(assemblyS), typeNameS)
+            ?? throw new TypeLoadException($"Type not found: {typeNameS}");
+
+        if (op == 0x03) // constructor
+        {
+            var args  = r.ReadArgs();
+            var entry = GetCachedCtor(typeS, args.Length);
+            if (entry.Ctor is null)
+                throw new MissingMethodException(
+                    $"No public ctor on {typeS.FullName} for {args.Length} args");
+            // ConstructorInfo.Invoke requires exact arg count — build a precise array.
+            return Box(entry.Ctor.Invoke(BuildArgsBinExact(args, entry.Parameters)));
+        }
+
+        // op == 0x02: static call
+        var methodS = r.ReadString16();
+        var argsS   = r.ReadArgs();
+        return DispatchCallBin(null, typeS, methodS, argsS, isStatic: true);
+    }
+
+    private static DispatchResult DispatchCallBin(
+        object? target, Type type, string method, object?[] args, bool isStatic)
+    {
+        var flags = (isStatic ? BindingFlags.Static : BindingFlags.Instance) | BindingFlags.Public;
+
+        if (method.Length > 4
+            && method[0] == 'g' && method[1] == 'e' && method[2] == 't' && method[3] == '_')
+        {
+            var prop = GetCachedProp(type, method, 4, flags);
+            if (prop is not null) return Box(prop.GetValue(target));
+        }
+
+        if (method.Length > 4
+            && method[0] == 's' && method[1] == 'e' && method[2] == 't' && method[3] == '_'
+            && args.Length == 1)
+        {
+            var prop = GetCachedProp(type, method, 4, flags);
+            if (prop is not null)
+            {
+                prop.SetValue(target, CoerceBin(args[0], prop.PropertyType));
+                return DispatchResult.Void;
+            }
+        }
+
+        var entry = GetCachedMethod(type, method, args.Length, flags);
+        if (entry.Invoke is null)
+            throw new MissingMethodException(
+                $"Method '{method}' ({args.Length} args) not found on {type.FullName}");
+
+        var builtArgs = BuildArgsBin(args, entry.Parameters);
+        try   { return Box(AwaitIfTask(entry.Invoke(target, builtArgs))); }
+        finally { if (builtArgs.Length > 0) ReturnArgs(builtArgs); }
+    }
+
+    private static object?[] BuildArgsBin(object?[] binArgs, ParameterInfo[] parameters)
+    {
+        if (parameters.Length == 0) return [];
+        var result = ArrayPool<object?>.Shared.Rent(parameters.Length);
+        for (int i = 0; i < parameters.Length && i < binArgs.Length; i++)
+            result[i] = CoerceBin(binArgs[i], parameters[i].ParameterType);
+        return result;
+    }
+
+    private static object?[] BuildArgsBinExact(object?[] binArgs, ParameterInfo[] parameters)
+    {
+        if (parameters.Length == 0) return [];
+        var result = new object?[parameters.Length];
+        for (int i = 0; i < parameters.Length && i < binArgs.Length; i++)
+            result[i] = CoerceBin(binArgs[i], parameters[i].ParameterType);
+        return result;
+    }
+
+    private static object? CoerceBin(object? value, Type targetType)
+    {
+        if (value is null) return null;
+        if (value is HandleRef hr)
+        {
+            s_handles.TryGetValue(hr.Id, out var obj);
+            return obj;
+        }
+        if (value.GetType() == targetType) return value;
+        try { return Convert.ChangeType(value, targetType); }
+        catch { return value; }
+    }
+
+    private static string? NullIfEmpty(string s) => s.Length == 0 ? null : s;
+
+    private static unsafe void WriteBinError(string msg, byte** outPtr, int* outLen)
+    {
+        var msgBytes = System.Text.Encoding.UTF8.GetByteCount(msg);
+        var buf = new ArrayBufferWriter<byte>(5 + msgBytes);
+        var w   = new BinWriter(buf);
+        w.WriteByte(0xFF);
+        w.WriteString32(msg);
+        WriteUnmanaged(buf.WrittenSpan, outPtr, outLen);
+    }
+}