@nativescript/windows 0.1.0-alpha.8 → 0.1.0-alpha.81

package/framework/dotnet-bridge/Bridge.cs

@@ -1,353 +1,492 @@
 using System;
-using System.Collections;
+using System.Diagnostics;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.IO;
 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;
+using System.Runtime.InteropServices;
+using System.Runtime.Loader;
+using System.Text.Json;
+
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("DotNetBridgeTests")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("DotNetBridgeBenchmarks")]
 
 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
+public static partial class Bridge
 {
-    private static readonly ConcurrentDictionary<int, object?> s_handles = new();
-    private static int s_nextHandle;
+    internal static readonly ConcurrentDictionary<int, object?> s_handles = new();
+    internal static int s_nextHandle;
+
+    // Function pointer registered by the Rust runtime so managed delegates can
+    // call back into V8 without a JSON round-trip.
+    internal static unsafe delegate* unmanaged[Cdecl]<int, byte*, int, byte**, int*, void>
+        s_jsInvoker;
+
+    private static readonly ConcurrentDictionary<string, Type?> s_typeCache
+        = new(StringComparer.Ordinal);
+    private static readonly ConcurrentDictionary<MethodKey, DispatchEntry> s_methodCache = new();
+    private static readonly ConcurrentDictionary<PropKey, PropertyInfo?> s_propCache = new();
+    private static readonly ConcurrentDictionary<CtorKey, CtorEntry> s_ctorCache = new();
+    // Cache of attempted assembly loads (simple name -> Assembly or null if not found).
+    private static readonly ConcurrentDictionary<string, Assembly?> s_assemblyLoadCache
+        = new(StringComparer.OrdinalIgnoreCase);
+    // Directories to search for assemblies (initialized once in static ctor).
+    private static readonly string[] s_assemblySearchDirs;
+
+    private static readonly JsonSerializerOptions s_coerceOpts = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    };
 
-    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();
+    internal static void ClearCaches()
+    {
+        s_typeCache.Clear();
+        s_methodCache.Clear();
+        s_propCache.Clear();
+        s_ctorCache.Clear();
+        s_handles.Clear();
+        s_nativePtrs.Clear();
+        s_nextHandle = 0;
+    }
 
-    // ── exported entry points ────────────────────────────────────────────────
+    // Optional mapping from exported handle id -> native IUnknown pointer (Int64)
+    // Populated when a managed object can yield a native COM pointer via
+    // Marshal.GetIUnknownForObject. Cleared and released on __release.
+    internal static readonly ConcurrentDictionary<int, long> s_nativePtrs = new();
 
-    /// 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)
+    // Returns a JSON object mapping top-level namespace roots (e.g. "NativeScript")
+    // to the assembly simple-name that most likely contains that namespace's types.
+    // Reuses s_assemblySearchDirs so plugin and NuGet assemblies are included.
+    public static string GetNamespaceAssemblyMapJson()
     {
-        byte[] responseBytes;
+        var map = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         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);
+            foreach (var dir in s_assemblySearchDirs.Where(Directory.Exists))
+            {
+                try
+                {
+                    foreach (var file in Directory.EnumerateFiles(dir, "*.dll", SearchOption.TopDirectoryOnly))
+                    {
+                        try
+                        {
+                            var simple = Path.GetFileNameWithoutExtension(file);
+                            if (string.IsNullOrEmpty(simple)) continue;
+
+                            Assembly asm = AppDomain.CurrentDomain.GetAssemblies()
+                                .FirstOrDefault(a => string.Equals(a.GetName().Name, simple, StringComparison.OrdinalIgnoreCase));
+                            if (asm is null)
+                            {
+                                try { asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(file); }
+                                catch { continue; }
+                            }
+
+                            Type[] types;
+                            try { types = asm.GetExportedTypes(); }
+                            catch { types = Array.Empty<Type>(); }
+
+                            foreach (var t in types)
+                            {
+                                if (string.IsNullOrEmpty(t.Namespace)) continue;
+                                var root = t.Namespace.Split('.')[0];
+                                if (!map.ContainsKey(root)) map[root] = asm.GetName().Name;
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+            }
         }
-
-        WriteResponse(responseBytes, responsePtr, responseLenPtr);
-        return 0;
+        catch { }
+        try { return JsonSerializer.Serialize(map); } catch { return "{}"; }
     }
 
-    /// Frees the response buffer allocated by Invoke.
-    [UnmanagedCallersOnly(EntryPoint = "Free",
-        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
-    public static unsafe void Free(byte* ptr)
+    static Bridge()
     {
-        if (ptr != null)
-            Marshal.FreeHGlobal((IntPtr)ptr);
-    }
-
-    // ── dispatch ─────────────────────────────────────────────────────────────
-
-    private static InvokeResult Dispatch(InvokeRequest req)
-    {
-        if (req.Method == "__release" && req.Handle.HasValue)
+        try
         {
-            s_handles.TryRemove(req.Handle.Value, out _);
-            return new InvokeResult(null, null);
-        }
+            var baseDir = AppContext.BaseDirectory ?? AppDomain.CurrentDomain.BaseDirectory;
+            var dirs = new List<string> { baseDir };
 
-        // 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
+            // libs/ subtree relative to the bridge's own directory.
+            var libs = Path.Combine(baseDir, "libs");
+            if (Directory.Exists(libs))
             {
-                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);
-        }
+                dirs.Add(libs);
+                try { dirs.AddRange(Directory.GetDirectories(libs, "*", SearchOption.AllDirectories)); } catch { }
+            }
 
-        object? target = null;
-        Type? type = null;
+            // The bridge DLL lives at dotnet-bridge/publish/ inside the app output root.
+            // Plugin assemblies (added via plugin.props) land at plugins/**/*.dll and NuGet
+            // assemblies land at the app output root itself — both outside the bridge subtree.
+            // Use the host process directory to reach them.
+            try
+            {
+                var processDir = Path.GetDirectoryName(
+                    System.Diagnostics.Process.GetCurrentProcess().MainModule?.FileName);
+                if (!string.IsNullOrEmpty(processDir))
+                {
+                    dirs.Add(processDir);
+
+                    // plugins/ subtree: CLI-managed plugin DLLs live here.
+                    // Check both {processDir}/plugins and {processDir}/../plugins because
+                    // the NS CLI places plugins/ as a sibling of bin/, not inside it.
+                    var pluginsDir = Path.Combine(processDir, "plugins");
+                    if (Directory.Exists(pluginsDir))
+                        try { dirs.AddRange(Directory.GetDirectories(pluginsDir, "*", SearchOption.AllDirectories)); } catch { }
+
+                    var parentDir = Path.GetDirectoryName(processDir);
+                    if (!string.IsNullOrEmpty(parentDir))
+                    {
+                        var parentPlugins = Path.Combine(parentDir, "plugins");
+                        if (Directory.Exists(parentPlugins))
+                        {
+                            dirs.Add(parentPlugins);
+                            try { dirs.AddRange(Directory.GetDirectories(parentPlugins, "*", SearchOption.AllDirectories)); } catch { }
+                        }
+                    }
+
+                    // libs/ relative to the app root (alternative convention).
+                    var processLibs = Path.Combine(processDir, "libs");
+                    if (Directory.Exists(processLibs))
+                        try { dirs.AddRange(Directory.GetDirectories(processLibs, "*", SearchOption.AllDirectories)); } catch { }
+                }
+            }
+            catch { }
 
-        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();
+            s_assemblySearchDirs = dirs.Where(d => !string.IsNullOrEmpty(d)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
+            AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
         }
-        else
+        catch
         {
-            type = ResolveType(req.Assembly, req.TypeName);
-            if (type is null)
-                return new InvokeResult(null, $"Type not found: {req.TypeName}");
+            s_assemblySearchDirs = Array.Empty<string>();
         }
+    }
 
-        if (type is null)
-            return new InvokeResult(null, "Cannot determine target type");
-
-        var method = req.Method ?? throw new ArgumentException("Method is required");
+    public static object? RunOnUIThread(int callbackId)
+    {
+        var action = new Action(() =>
+        {
+            unsafe
+            {
+                if (s_jsInvoker == null) return;
+                byte* respPtr = null;
+                int respLen = 0;
+                s_jsInvoker(callbackId, null, 0, &respPtr, &respLen);
+                if (respPtr != null && respLen > 0) Marshal.FreeHGlobal((IntPtr)respPtr);
+            }
+        });
 
-        // ── Constructor ──────────────────────────────────────────────────────
-        if (method == ".ctor")
+        try
         {
-            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));
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                var coreAppType = asm.GetType("Windows.ApplicationModel.Core.CoreApplication");
+                if (coreAppType == null) continue;
+                var mainViewProp = coreAppType.GetProperty("MainView", BindingFlags.Public | BindingFlags.Static);
+                var mainView = mainViewProp?.GetValue(null);
+                if (mainView == null) continue;
+                var dispatcherProp = mainView.GetType().GetProperty("Dispatcher", BindingFlags.Public | BindingFlags.Instance);
+                var dispatcher = dispatcherProp?.GetValue(mainView);
+                if (dispatcher == null) continue;
+
+                var hasAccessProp = dispatcher.GetType().GetProperty("HasThreadAccess", BindingFlags.Public | BindingFlags.Instance);
+                if (hasAccessProp?.GetValue(dispatcher) is true)
+                {
+                    action();
+                    return null;
+                }
+
+                foreach (var m in dispatcher.GetType().GetMethods().Where(m => m.Name == "RunAsync"))
+                {
+                    var parameters = m.GetParameters();
+                    if (parameters.Length != 2) continue;
+                    var enumType = parameters[0].ParameterType;
+                    object priority = enumType.IsEnum ? Enum.ToObject(enumType, 0) : Activator.CreateInstance(enumType)!;
+                    var handlerType = parameters[1].ParameterType;
+                    var mre = new ManualResetEventSlim(false);
+                    var wrapped = new Action(() => { try { action(); } finally { mre.Set(); } });
+                    try
+                    {
+                        var d = Delegate.CreateDelegate(handlerType, wrapped.Target, wrapped.Method);
+                        m.Invoke(dispatcher, new object[] { priority, d });
+                        mre.Wait();
+                        return null;
+                    }
+                    catch { }
+                }
+                break;
+            }
         }
+        catch { }
 
-        var isStatic = target is null;
-        var flags = (isStatic ? BindingFlags.Static : BindingFlags.Instance)
-                  | BindingFlags.Public;
-
-        // ── Property getter / setter ─────────────────────────────────────────
-        if (method.StartsWith("get_", StringComparison.Ordinal))
+        try
         {
-            var prop = GetCachedProperty(type, method[4..], flags);
-            if (prop is not null)
-                return Box(prop.GetValue(target));
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                var dqType = asm.GetType("Microsoft.UI.Dispatching.DispatcherQueue");
+                if (dqType == null) continue;
+                var getForCurrent = dqType.GetMethod("GetForCurrentThread", BindingFlags.Public | BindingFlags.Static);
+                var dq = getForCurrent?.Invoke(null, null);
+                if (dq == null) continue;
+
+                if (dq.GetType().GetProperty("HasThreadAccess")?.GetValue(dq) is true)
+                {
+                    action();
+                    return null;
+                }
+                break;
+            }
         }
-        if (method.StartsWith("set_", StringComparison.Ordinal) && req.Args?.Count == 1)
+        catch { }
+
+        try
         {
-            var prop = GetCachedProperty(type, method[4..], flags);
-            if (prop is not null)
+            var wpfDispatcherType = AppDomain.CurrentDomain.GetAssemblies()
+                .Select(a => a.GetType("System.Windows.Threading.Dispatcher"))
+                .FirstOrDefault(t => t != null);
+            if (wpfDispatcherType != null)
             {
-                prop.SetValue(target, Coerce(req.Args[0], prop.PropertyType));
-                return new InvokeResult(null, null);
+                var currentDispatcherProp = wpfDispatcherType.GetProperty("CurrentDispatcher", BindingFlags.Public | BindingFlags.Static);
+                var dispatcher = currentDispatcherProp?.GetValue(null);
+                if (dispatcher != null)
+                {
+                    var checkAccess = dispatcher.GetType().GetMethod("CheckAccess");
+                    if (checkAccess?.Invoke(dispatcher, null) is true)
+                    {
+                        action();
+                        return null;
+                    }
+                    var beginInvoke = dispatcher.GetType().GetMethod("BeginInvoke", new[] { typeof(Action) })
+                        ?? dispatcher.GetType().GetMethods().FirstOrDefault(m => m.Name == "BeginInvoke" && m.GetParameters().Length == 1);
+                    if (beginInvoke != null)
+                    {
+                        var mre = new ManualResetEventSlim(false);
+                        beginInvoke.Invoke(dispatcher, new object[] { new Action(() => { try { action(); } finally { mre.Set(); } }) });
+                        mre.Wait();
+                        return null;
+                    }
+                }
             }
         }
+        catch { }
 
-        // ── 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)));
+        action();
+        return null;
     }
 
-    // ── helpers ───────────────────────────────────────────────────────────────
-
-    private static object? AwaitIfTask(object? value)
+    private static Assembly? OnAssemblyResolve(object? sender, ResolveEventArgs args)
     {
-        if (value is null) return null;
-        var t = value.GetType();
-
-        if (value is Task task)
+        try
         {
-            task.Wait();
-            if (task.IsFaulted)
-                throw task.Exception!.InnerException ?? task.Exception;
-            return t.GetProperty("Result")?.GetValue(value);
-        }
+            var requested = new AssemblyName(args.Name).Name;
+            if (string.IsNullOrEmpty(requested)) return null;
 
-        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 (s_assemblyLoadCache.TryGetValue(requested, out var cached)) return cached;
 
-        if (value is System.Threading.Tasks.ValueTask vt)
-        {
-            vt.AsTask().Wait();
-            return null;
-        }
+            // Check already-loaded assemblies first (avoid recursive Assembly.Load).
+            var loadedAsm = AppDomain.CurrentDomain.GetAssemblies()
+                .FirstOrDefault(a => string.Equals(a.GetName().Name, requested, StringComparison.OrdinalIgnoreCase));
+            if (loadedAsm is not null)
+            {
+                s_assemblyLoadCache[requested] = loadedAsm;
+                return loadedAsm;
+            }
 
-        return value;
+            // Try to locate a matching dll in known search directories.
+            foreach (var dir in s_assemblySearchDirs)
+            {
+                try
+                {
+                    var candidate = Path.Combine(dir, requested + ".dll");
+                    if (File.Exists(candidate))
+                    {
+                        try
+                        {
+                            var asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(candidate);
+                            s_assemblyLoadCache[requested] = asm;
+                            return asm;
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+            }
+
+            s_assemblyLoadCache[requested] = null;
+        }
+        catch { }
+        return null;
     }
 
-    private static Type? ResolveType(string? assemblyName, string? typeName)
+    [UnmanagedCallersOnly(EntryPoint = "RegisterJsCallback",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe int RegisterJsCallback(
+        delegate* unmanaged[Cdecl]<int, byte*, int, byte**, int*, void> callback)
     {
-        if (string.IsNullOrEmpty(typeName)) return null;
-        var key = string.IsNullOrEmpty(assemblyName) ? typeName : $"{assemblyName}|{typeName}";
-        return s_typeCache.GetOrAdd(key, _ => ResolveTypeCore(assemblyName, typeName));
+        s_jsInvoker = callback;
+        return 0;
     }
 
-    private static Type? ResolveTypeCore(string? assemblyName, string? typeName)
+    // Callback id registered by the runtime/JS that should receive unhandled
+    // managed exceptions and unobserved task exceptions.
+    private static int s_unhandledExceptionCallbackId = -1;
+
+    // Called from JS/Rust to request that managed unhandled exceptions be
+    // forwarded to the registered JS callback id.  The callback id must have
+    // been created on the Rust side and point to a JS function stored in the
+    // runtime's `DOTNET_JS_CALLBACKS` map.
+    public static int RegisterUnhandledExceptionCallback(int callbackId)
     {
-        var fqn = string.IsNullOrEmpty(assemblyName) ? typeName! : $"{typeName}, {assemblyName}";
-        var t = Type.GetType(fqn);
-        if (t is not null) return t;
+        s_unhandledExceptionCallbackId = callbackId;
 
-        foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+        // Subscribe once (idempotent).
+        try
         {
-            t = asm.GetType(typeName!);
-            if (t is not null) return t;
-        }
+            AppDomain.CurrentDomain.UnhandledException -= OnAppDomainUnhandledException;
+            AppDomain.CurrentDomain.UnhandledException += OnAppDomainUnhandledException;
 
-        if (!string.IsNullOrEmpty(assemblyName))
-        {
-            try
+            TaskScheduler.UnobservedTaskException -= OnUnobservedTaskException;
+            TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;
+
+            // Try to subscribe to Windows.CoreApplication.UnhandledErrorDetected if available
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
             {
-                var asm = Assembly.Load(assemblyName);
-                t = asm.GetType(typeName!);
-                if (t is not null) return t;
+                var coreAppType = asm.GetType("Windows.ApplicationModel.Core.CoreApplication");
+                if (coreAppType == null) continue;
+                var ev = coreAppType.GetEvent("UnhandledErrorDetected");
+                if (ev == null) continue;
+                try
+                {
+                    var handlerType = ev.EventHandlerType;
+                    var method = typeof(Bridge).GetMethod(nameof(CoreApplicationUnhandledErrorHandler), BindingFlags.NonPublic | BindingFlags.Static);
+                    if (method != null)
+                    {
+                        var del = Delegate.CreateDelegate(handlerType, method);
+                        ev.AddEventHandler(null, del);
+                    }
+                }
+                catch { }
             }
-            catch { }
         }
+        catch { }
 
-        return null;
+        return 0;
     }
 
-    private static MethodInfo? FindMethod(Type type, string name, int argCount, BindingFlags flags)
+    // Return a canonical native pointer (IUnknown / IInspectable) for an
+    // exported handle id. Returns 0 when no pointer is available. If a
+    // pointer isn't already cached in `s_nativePtrs`, attempt to obtain one
+    // via `Marshal.GetIUnknownForObject` and cache it for subsequent calls.
+    public static long GetNativePtrForHandle(int handleId)
     {
-        var key = $"{type.FullName}|{name}|{argCount}|{(int)flags}";
-        return s_methodCache.GetOrAdd(key, _ => FindMethodCore(type, name, argCount, flags));
-    }
+        if (handleId <= 0) return 0;
+        if (s_nativePtrs.TryGetValue(handleId, out var p)) {
+            try { Debug.WriteLine($"[Bridge] GetNativePtrForHandle({handleId}) -> 0x{p:x} (cached)"); } catch { }
+            return p;
+        }
 
-    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);
+        if (!s_handles.TryGetValue(handleId, out var obj) || obj == null)
+            return 0;
+
+        try
+        {
+            var ip = Marshal.GetIUnknownForObject(obj);
+            if (ip != IntPtr.Zero)
+            {
+                var val = ip.ToInt64();
+                s_nativePtrs[handleId] = val;
+                try { Debug.WriteLine($"[Bridge] GetNativePtrForHandle({handleId}) -> 0x{val:x} (new)"); } catch { }
+                return val;
+            }
+        }
+        catch (Exception ex)
+        {
+            try { Debug.WriteLine($"[Bridge] GetNativePtrForHandle({handleId}) threw: {ex}"); } catch { }
+        }
+
+        try { Debug.WriteLine($"[Bridge] GetNativePtrForHandle({handleId}) -> 0 (none)"); } catch { }
+        return 0;
     }
 
-    private static PropertyInfo? GetCachedProperty(Type type, string name, BindingFlags flags)
+    private static void OnAppDomainUnhandledException(object? sender, UnhandledExceptionEventArgs e)
     {
-        var key = $"{type.FullName}|{name}|{(int)flags}";
-        return s_propertyCache.GetOrAdd(key, _ => type.GetProperty(name, flags));
+        try
+        {
+            var ex = e.ExceptionObject as Exception;
+            var msg = ex?.ToString() ?? e.ExceptionObject?.ToString() ?? "(unknown)";
+            SendUnhandledToJs("unhandled", msg);
+        }
+        catch { }
     }
 
-    private static object? Coerce(JsonElement el, Type targetType)
+    private static void OnUnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
     {
-        if (el.ValueKind == JsonValueKind.Null) return null;
-        if (el.ValueKind == JsonValueKind.Object && el.TryGetProperty("__handle", out var h))
+        try
         {
-            s_handles.TryGetValue(h.GetInt32(), out var obj);
-            return obj;
+            var msg = e.Exception?.ToString() ?? "(unobserved task exception)";
+            SendUnhandledToJs("unobservedTask", msg);
         }
-        return JsonSerializer.Deserialize(el.GetRawText(), targetType, JsonOptions.Default);
+        catch { }
     }
 
-    private static InvokeResult Box(object? value)
+    // Fallback handler for platform-specific CoreApplication unhandled events.
+    private static void CoreApplicationUnhandledErrorHandler(object? sender, object? args)
     {
-        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))
+        try
         {
-            return new InvokeResult(
-                JsonSerializer.SerializeToElement(value, t, JsonOptions.Default), null);
+            var msg = args?.ToString() ?? "(core unhandled)";
+            SendUnhandledToJs("coreUnhandled", msg);
         }
+        catch { }
+    }
 
-        // Arrays and IEnumerable — serialise as JSON arrays.
-        if (t.IsArray || (t != typeof(string) && value is IEnumerable enumerable))
+    private static unsafe void SendUnhandledToJs(string kind, string message)
+    {
+        try
         {
-            try
+            if (s_jsInvoker == null || s_unhandledExceptionCallbackId <= 0) return;
+            var payload = JsonSerializer.Serialize(new { kind = kind, message = message });
+            var bytes = System.Text.Encoding.UTF8.GetBytes(payload);
+            fixed (byte* p = bytes)
             {
-                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);
+                byte* respPtr = null;
+                int respLen = 0;
+                s_jsInvoker(s_unhandledExceptionCallbackId, p, bytes.Length, &respPtr, &respLen);
+                if (respPtr != null && respLen > 0) Marshal.FreeHGlobal((IntPtr)respPtr);
             }
-            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);
+        catch { }
     }
 
-    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)
+    [UnmanagedCallersOnly(EntryPoint = "Invoke",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe int Invoke(
+        byte* requestPtr, int requestLen,
+        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;
+        try
+        {
+            var span = new ReadOnlySpan<byte>(requestPtr, requestLen);
+            var req  = JsonSerializer.Deserialize(span, BridgeJsonContext.Default.InvokeRequest)!;
+            WriteResult(Dispatch(req), responsePtr, responseLenPtr);
+        }
+        catch (Exception ex)
+        {
+            WriteError(Unwrap(ex).Message, responsePtr, responseLenPtr);
+        }
+        return 0;
     }
-}
-
-// ── 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()
+    [UnmanagedCallersOnly(EntryPoint = "Free",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe void Free(byte* ptr)
     {
-        PropertyNameCaseInsensitive = true,
-        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-    };
+        if (ptr != null) Marshal.FreeHGlobal((IntPtr)ptr);
+    }
 }