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

package/framework/dotnet-bridge/Bridge.cs

@@ -1,353 +1,77 @@
 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;
+
+[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();
+
+    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_nextHandle = 0;
+    }
 
-    // ── exported entry points ────────────────────────────────────────────────
+    [UnmanagedCallersOnly(EntryPoint = "RegisterJsCallback",
+        CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
+    public static unsafe int RegisterJsCallback(
+        delegate* unmanaged[Cdecl]<int, byte*, int, byte**, int*, void> callback)
+    {
+        s_jsInvoker = callback;
+        return 0;
+    }
 
-    /// 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);
+            var span = new ReadOnlySpan<byte>(requestPtr, requestLen);
+            var req  = JsonSerializer.Deserialize(span, BridgeJsonContext.Default.InvokeRequest)!;
+            WriteResult(Dispatch(req), responsePtr, responseLenPtr);
         }
         catch (Exception ex)
         {
-            var errResult = new InvokeResult(null, Unwrap(ex).Message);
-            responseBytes = JsonSerializer.SerializeToUtf8Bytes(errResult, JsonOptions.Default);
+            WriteError(Unwrap(ex).Message, responsePtr, responseLenPtr);
         }
-
-        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);
+        if (ptr != null) Marshal.FreeHGlobal((IntPtr)ptr);
     }
-
-    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/DispatchTypes.cs

@@ -0,0 +1,281 @@
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NativeScriptBridge;
+
+// ── JSON source-gen context ───────────────────────────────────────────────────
+
+[JsonSerializable(typeof(InvokeRequest))]
+[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
+internal partial class BridgeJsonContext : JsonSerializerContext { }
+
+// ── JSON wire type ────────────────────────────────────────────────────────────
+
+internal sealed record InvokeRequest(
+    string?        Assembly,
+    string?        TypeName,
+    string?        Method,
+    int?           Handle,
+    JsonElement[]? Args
+);
+
+// ── cache key structs ─────────────────────────────────────────────────────────
+//
+// Using Type as the key field (rather than Type.FullName) is correct and faster:
+// Type instances are singletons within an AssemblyLoadContext, so reference
+// equality and reference hash codes are sufficient and allocation-free.
+
+internal readonly record struct MethodKey(Type Type, string Name, int ArgCount, BindingFlags Flags);
+internal readonly record struct PropKey(Type Type, string Name, BindingFlags Flags);
+internal readonly record struct CtorKey(Type Type, int ArgCount);
+
+// ── cache value types ─────────────────────────────────────────────────────────
+
+internal readonly struct DispatchEntry(Func<object?, object?[], object?>? invoke, ParameterInfo[] parameters)
+{
+    public readonly Func<object?, object?[], object?>? Invoke     = invoke;
+    public readonly ParameterInfo[]                    Parameters = parameters;
+    public static readonly DispatchEntry Empty = new(null, []);
+}
+
+internal readonly struct CtorEntry(ConstructorInfo? ctor, ParameterInfo[] parameters)
+{
+    public readonly ConstructorInfo? Ctor       = ctor;
+    public readonly ParameterInfo[]  Parameters = parameters;
+}
+
+// ── dispatch result ───────────────────────────────────────────────────────────
+
+internal enum DispatchKind : byte { Void, Primitive, Handle, Collection, Members }
+
+internal readonly struct DispatchResult
+{
+    public static readonly DispatchResult Void =
+        new(DispatchKind.Void, null, null, 0, null, null, null, null, null);
+
+    private readonly DispatchKind _kind;
+    private readonly object?      _value;
+    private readonly Type?        _type;
+    private readonly int          _handle;
+    private readonly string?      _typeName;
+    private readonly string[]?    _methods;
+    private readonly string[]?    _properties;
+    private readonly string[]?    _staticMethods;
+    private readonly string[]?    _staticProperties;
+
+    private DispatchResult(DispatchKind kind, object? value, Type? type, int handle,
+        string? typeName, string[]? methods, string[]? props,
+        string[]? staticMethods, string[]? staticProps)
+    {
+        _kind = kind; _value = value; _type = type; _handle = handle;
+        _typeName = typeName; _methods = methods; _properties = props;
+        _staticMethods = staticMethods; _staticProperties = staticProps;
+    }
+
+    public static DispatchResult Primitive(object value, Type type)
+        => new(DispatchKind.Primitive, value, type, 0, null, null, null, null, null);
+
+    public static DispatchResult Handle(int id, string typeName)
+        => new(DispatchKind.Handle, null, null, id, typeName, null, null, null, null);
+
+    public static DispatchResult Collection(IEnumerable items)
+        => new(DispatchKind.Collection, items, null, 0, null, null, null, null, null);
+
+    public static DispatchResult Members(
+        string[] methods, string[] props, string[] staticMethods, string[] staticProps)
+        => new(DispatchKind.Members, null, null, 0, null, methods, props, staticMethods, staticProps);
+
+    internal int HandleId() => _handle;
+
+    // ── JSON serialisation ────────────────────────────────────────────────────
+
+    public void WriteTo(Utf8JsonWriter w, JsonSerializerOptions opts)
+    {
+        switch (_kind)
+        {
+            case DispatchKind.Void:
+                w.WriteNullValue();
+                break;
+
+            case DispatchKind.Primitive:
+                JsonSerializer.Serialize(w, _value, _type!, opts);
+                break;
+
+            case DispatchKind.Handle:
+                w.WriteStartObject();
+                w.WriteNumber("__handle"u8, _handle);
+                w.WriteString("__type"u8,   _typeName);
+                w.WriteEndObject();
+                break;
+
+            case DispatchKind.Collection:
+                w.WriteStartArray();
+                foreach (var item in (IEnumerable)_value!)
+                    JsonSerializer.Serialize(w, item, item?.GetType() ?? typeof(object), opts);
+                w.WriteEndArray();
+                break;
+
+            case DispatchKind.Members:
+                w.WriteStartObject();
+                WriteStringArray(w, "methods"u8,          _methods!);
+                WriteStringArray(w, "properties"u8,       _properties!);
+                WriteStringArray(w, "staticMethods"u8,    _staticMethods!);
+                WriteStringArray(w, "staticProperties"u8, _staticProperties!);
+                w.WriteEndObject();
+                break;
+        }
+    }
+
+    private static void WriteStringArray(Utf8JsonWriter w, ReadOnlySpan<byte> name, string[] arr)
+    {
+        w.WriteStartArray(name);
+        foreach (var s in arr) w.WriteStringValue(s);
+        w.WriteEndArray();
+    }
+
+    // ── binary serialisation ──────────────────────────────────────────────────
+    //
+    // Response tags:
+    //   0x00 = null   0x01 = false   0x02 = true
+    //   0x03 = i32[4]   0x04 = f64[8]   0x05 = string[u32+utf8]
+    //   0x06 = handle[i32 + u16+utf8 type]
+    //   0x07 = array[u32 count + N tagged items]
+    //   0x08 = members{ methods, props, staticMethods, staticProps }
+    //   0xFF = error[u32+utf8]
+
+    public void WriteAsBin(ArrayBufferWriter<byte> outBuf)
+    {
+        var w = new BinWriter(outBuf);
+        switch (_kind)
+        {
+            case DispatchKind.Void:
+                w.WriteByte(0x00);
+                break;
+
+            case DispatchKind.Primitive:
+                WritePrimitiveBin(ref w, _value!);
+                break;
+
+            case DispatchKind.Handle:
+                w.WriteByte(0x06);
+                w.WriteI32(_handle);
+                w.WriteString16(_typeName ?? "");
+                break;
+
+            case DispatchKind.Collection:
+                var items = new List<object?>();
+                foreach (var item in (IEnumerable)_value!) items.Add(item);
+                w.WriteByte(0x07);
+                w.WriteU32((uint)items.Count);
+                foreach (var item in items) WriteValueBin(ref w, item);
+                break;
+
+            case DispatchKind.Members:
+                w.WriteByte(0x08);
+                WriteStringArrayBin(ref w, _methods!);
+                WriteStringArrayBin(ref w, _properties!);
+                WriteStringArrayBin(ref w, _staticMethods!);
+                WriteStringArrayBin(ref w, _staticProperties!);
+                break;
+        }
+    }
+
+    private static void WritePrimitiveBin(ref BinWriter w, object value)
+    {
+        switch (value)
+        {
+            case bool    b: w.WriteByte(b ? (byte)0x02 : (byte)0x01); break;
+            case sbyte   v: w.WriteByte(0x03); w.WriteI32(v); break;
+            case byte    v: w.WriteByte(0x03); w.WriteI32(v); break;
+            case short   v: w.WriteByte(0x03); w.WriteI32(v); break;
+            case ushort  v: w.WriteByte(0x03); w.WriteI32(v); break;
+            case int     v: w.WriteByte(0x03); w.WriteI32(v); break;
+            case uint    v: w.WriteByte(0x04); w.WriteF64(v); break;
+            case long    v: w.WriteByte(0x04); w.WriteF64(v); break;
+            case ulong   v: w.WriteByte(0x04); w.WriteF64(v); break;
+            case float   v: w.WriteByte(0x04); w.WriteF64(v); break;
+            case double  v: w.WriteByte(0x04); w.WriteF64(v); break;
+            case decimal v: w.WriteByte(0x04); w.WriteF64((double)v); break;
+            case string  s: w.WriteByte(0x05); w.WriteString32(s); break;
+            default:        w.WriteByte(0x05); w.WriteString32(value.ToString() ?? ""); break;
+        }
+    }
+
+    private static void WriteValueBin(ref BinWriter w, object? value)
+    {
+        if (value is null) { w.WriteByte(0x00); return; }
+        var t = value.GetType();
+        if (t.IsPrimitive || t == typeof(string) || t == typeof(decimal))
+        {
+            WritePrimitiveBin(ref w, value);
+            return;
+        }
+        if (value is IEnumerable enumerable)
+        {
+            var items = new List<object?>();
+            foreach (var item in enumerable) items.Add(item);
+            w.WriteByte(0x07);
+            w.WriteU32((uint)items.Count);
+            foreach (var item in items) WriteValueBin(ref w, item);
+            return;
+        }
+        var id = Interlocked.Increment(ref Bridge.s_nextHandle);
+        Bridge.s_handles[id] = value;
+        w.WriteByte(0x06);
+        w.WriteI32(id);
+        w.WriteString16(t.FullName ?? t.Name);
+    }
+
+    private static void WriteStringArrayBin(ref BinWriter w, string[] arr)
+    {
+        w.WriteU16((ushort)arr.Length);
+        foreach (var s in arr) w.WriteString16(s);
+    }
+}
+
+// ── async result helpers ──────────────────────────────────────────────────────
+
+internal static class TaskResultCache
+{
+    private static readonly ConcurrentDictionary<Type, Func<Task, object?>> s_cache = new();
+
+    public static object? GetResult(Task task)
+    {
+        var taskType = task.GetType();
+        if (!taskType.IsGenericType) return null;
+        var fn = s_cache.GetOrAdd(taskType, static t =>
+        {
+            var param = Expression.Parameter(typeof(Task));
+            Expression body = Expression.Property(Expression.Convert(param, t), "Result");
+            if (body.Type.IsValueType) body = Expression.Convert(body, typeof(object));
+            return Expression.Lambda<Func<Task, object?>>(body, param).Compile();
+        });
+        return fn(task);
+    }
+}
+
+internal static class ValueTaskAsTaskCache
+{
+    private static readonly ConcurrentDictionary<Type, Func<object, Task>> s_cache = new();
+
+    public static Task AsTask(Type valueTaskType, object vt)
+    {
+        var fn = s_cache.GetOrAdd(valueTaskType, static t =>
+        {
+            var param = Expression.Parameter(typeof(object));
+            var cast  = Expression.Convert(param, t);
+            var call  = Expression.Call(cast, t.GetMethod("AsTask")!);
+            return Expression.Lambda<Func<object, Task>>(call, param).Compile();
+        });
+        return fn(vt);
+    }
+}