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

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

@@ -0,0 +1,216 @@
+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
+            {
+                var handleToRemove = r.ReadI32();
+                s_handles.TryRemove(handleToRemove, out _);
+                if (s_nativePtrs.TryRemove(handleToRemove, out var nativePtr))
+                {
+                    try
+                    {
+                        Marshal.Release(new IntPtr(nativePtr));
+                        try { System.Diagnostics.Debug.WriteLine($"[Bridge] Binary __release: Released native ptr for handle {handleToRemove} -> 0x{nativePtr:x}"); } catch { }
+                    }
+                    catch
+                    {
+                        // best-effort
+                    }
+                }
+                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} (assembly: {assembly})");
+            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();
+
+            if (method == "__dotnet_await__" && args.Length == 2
+                && args[0] is int resolveId && args[1] is int rejectId)
+            {
+                ScheduleTaskContinuation(handle, resolveId, rejectId);
+                return DispatchResult.Void;
+            }
+
+            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} (assembly: {assemblyS})");
+
+        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 is WinRtRef wr)
+        {
+            if (wr.Ptr == 0) return null;
+            var nativePtr = new IntPtr((long)wr.Ptr);
+            // 1. Typed QI first: works for COM/CsWinRT interface types that carry a
+            //    [Guid] attribute.  More precise than a generic RCW for strongly-typed
+            //    parameters such as Windows.UI.Xaml.UIElement.
+            if (targetType != typeof(object) && targetType.GUID != Guid.Empty)
+            {
+                try { return Marshal.GetTypedObjectForIUnknown(nativePtr, targetType); }
+                catch { }
+            }
+            // 2. Generic RCW: .NET WinRT interop calls IInspectable::GetRuntimeClassName
+            //    and projects to the appropriate CsWinRT type automatically.
+            //    Do NOT swallow the exception — a null return silently breaks the call
+            //    downstream; a thrown exception surfaces a meaningful error instead.
+            return Marshal.GetObjectForIUnknown(nativePtr);
+        }
+        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);
+    }
+}

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

@@ -0,0 +1,468 @@
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NativeScriptBridge;
+
+public static partial class Bridge
+{
+    internal static DispatchResult Dispatch(InvokeRequest req)
+    {
+        var method = req.Method ?? throw new ArgumentException("Method is required");
+
+            if (method == "__release" && req.Handle.HasValue)
+            {
+                var id = req.Handle.Value;
+                s_handles.TryRemove(id, out _);
+                if (s_nativePtrs.TryRemove(id, out var nativePtr))
+                {
+                    try
+                    {
+                        Marshal.Release(new IntPtr(nativePtr));
+                        try { System.Diagnostics.Debug.WriteLine($"[Bridge] __release: Released native ptr for handle {id} -> 0x{nativePtr:x}"); } catch { }
+                    }
+                    catch
+                    {
+                        // swallow - best-effort release
+                    }
+                }
+
+                return DispatchResult.Void;
+            }
+
+        object? target = null;
+        Type type;
+
+        if (req.Handle.HasValue)
+        {
+            if (!s_handles.TryGetValue(req.Handle.Value, out target))
+                throw new KeyNotFoundException($"Invalid handle {req.Handle.Value}");
+            type = target?.GetType() ?? throw new InvalidOperationException("Handle refers to null");
+        }
+        else
+        {
+            type = ResolveType(req.Assembly, req.TypeName)
+                ?? throw new TypeLoadException($"Type not found: {req.TypeName} (assembly: {req.Assembly})");
+        }
+
+        if (method == "__members__")
+            return BuildMembersResult(type);
+
+        if (method == "__dotnet_await__" && req.Handle.HasValue)
+        {
+            var a = req.Args ?? [];
+            if (a.Length >= 2)
+            {
+                var resolveId = (int)a[0].GetInt64();
+                var rejectId  = (int)a[1].GetInt64();
+                ScheduleTaskContinuation(req.Handle.Value, resolveId, rejectId);
+            }
+            return DispatchResult.Void;
+        }
+
+        if (method == ".ctor")
+        {
+            var argElems = req.Args ?? [];
+            var entry    = GetCachedCtor(type, argElems.Length);
+            if (entry.Ctor is null)
+                throw new MissingMethodException(
+                    $"No public constructor on {type.FullName} for {argElems.Length} args");
+            // ConstructorInfo.Invoke validates args.Length == paramCount exactly — no pool.
+            return Box(entry.Ctor.Invoke(BuildArgsExact(argElems, entry.Parameters)));
+        }
+
+        var isStatic = target is null;
+        var flags    = (isStatic ? BindingFlags.Static : BindingFlags.Instance) | BindingFlags.Public;
+
+        if (method.Length > 4)
+        {
+            if (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));
+            }
+            else if (method[0] == 's' && method[1] == 'e' && method[2] == 't' && method[3] == '_'
+                     && req.Args?.Length == 1)
+            {
+                var prop = GetCachedProp(type, method, 4, flags);
+                if (prop is not null)
+                {
+                    prop.SetValue(target, Coerce(req.Args[0], prop.PropertyType));
+                    return DispatchResult.Void;
+                }
+            }
+        }
+
+        var args      = req.Args ?? [];
+        var dispEntry = GetCachedMethod(type, method, args.Length, flags);
+        if (dispEntry.Invoke is null)
+            throw new MissingMethodException(
+                $"Method '{method}' ({args.Length} args) not found on {type.FullName}");
+
+        var builtArgs = BuildArgs(args, dispEntry.Parameters);
+        try   { return Box(AwaitIfTask(dispEntry.Invoke(target, builtArgs))); }
+        finally { if (builtArgs.Length > 0) ReturnArgs(builtArgs); }
+    }
+
+    private static DispatchEntry GetCachedMethod(Type type, string name, int argCount, BindingFlags flags)
+        => s_methodCache.GetOrAdd(
+            new MethodKey(type, name, argCount, flags),
+            static k => BuildDispatchEntry(k.Type, k.Name, k.ArgCount, k.Flags));
+
+    private static DispatchEntry BuildDispatchEntry(Type type, string name, int argCount, BindingFlags flags)
+    {
+        var mi = FindMethodCore(type, name, argCount, flags);
+        if (mi is null) return DispatchEntry.Empty;
+
+        var parameters = mi.GetParameters();
+
+        try
+        {
+            var targetParam = Expression.Parameter(typeof(object), "t");
+            var argsParam   = Expression.Parameter(typeof(object?[]), "a");
+
+            var typedArgs = parameters.Select((p, i) =>
+                (Expression)Expression.Convert(
+                    Expression.ArrayIndex(argsParam, Expression.Constant(i)),
+                    p.ParameterType)).ToArray();
+
+            Expression body = mi.IsStatic
+                ? Expression.Call(mi, typedArgs)
+                : Expression.Call(Expression.Convert(targetParam, type), mi, typedArgs);
+
+            if (body.Type == typeof(void))
+                body = Expression.Block(typeof(object), body, Expression.Constant(null, typeof(object)));
+            else if (body.Type != typeof(object))
+                body = Expression.Convert(body, typeof(object));
+
+            var fn = Expression.Lambda<Func<object?, object?[], object?>>(
+                body, targetParam, argsParam).Compile();
+
+            return new DispatchEntry(fn, parameters);
+        }
+        catch
+        {
+            // mi.Invoke validates args.Length == paramCount; slice the rented buffer if needed.
+            int pc = parameters.Length;
+            return new DispatchEntry(
+                (t, a) => mi.Invoke(t, a.Length == pc ? a : a[..pc]),
+                parameters);
+        }
+    }
+
+    private static CtorEntry GetCachedCtor(Type type, int argCount)
+        => s_ctorCache.GetOrAdd(new CtorKey(type, argCount), static k =>
+        {
+            var ctors = k.Type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
+            var ctor  = Array.Find(ctors, c => c.GetParameters().Length == k.ArgCount)
+                     ?? ctors.FirstOrDefault();
+            return new CtorEntry(ctor, ctor?.GetParameters() ?? []);
+        });
+
+    private static PropertyInfo? GetCachedProp(Type type, string method, int prefixLen, BindingFlags flags)
+        => s_propCache.GetOrAdd(
+            new PropKey(type, method[prefixLen..], flags),
+            static k => k.Type.GetProperty(k.Name, k.Flags));
+
+    // Pooled: rented array passed to the compiled delegate (which accesses by index,
+    // not by Length). Caller must return via ReturnArgs immediately after invoke.
+    private static object?[] BuildArgs(JsonElement[] elements, ParameterInfo[] parameters)
+    {
+        if (parameters.Length == 0) return [];
+        var args = ArrayPool<object?>.Shared.Rent(parameters.Length);
+        for (int i = 0; i < parameters.Length && i < elements.Length; i++)
+            args[i] = Coerce(elements[i], parameters[i].ParameterType);
+        return args;
+    }
+
+    // Exact: required by ConstructorInfo.Invoke / MethodInfo.Invoke which validate
+    // args.Length == paramCount and would throw on an oversized rented buffer.
+    private static object?[] BuildArgsExact(JsonElement[] elements, ParameterInfo[] parameters)
+    {
+        if (parameters.Length == 0) return [];
+        var args = new object?[parameters.Length];
+        for (int i = 0; i < parameters.Length && i < elements.Length; i++)
+            args[i] = Coerce(elements[i], parameters[i].ParameterType);
+        return args;
+    }
+
+    private static void ReturnArgs(object?[] args) =>
+        ArrayPool<object?>.Shared.Return(args, clearArray: true);
+
+    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 el.Deserialize(targetType, s_coerceOpts);
+    }
+
+    private static object? AwaitIfTask(object? value)
+    {
+        if (value is null) return null;
+
+        if (value is Task task)
+        {
+            task.GetAwaiter().GetResult();
+            return TaskResultCache.GetResult(task);
+        }
+
+        if (value is ValueTask vt)
+        {
+            vt.AsTask().GetAwaiter().GetResult();
+            return null;
+        }
+
+        var type = value.GetType();
+        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ValueTask<>))
+        {
+            var innerTask = ValueTaskAsTaskCache.AsTask(type, value);
+            innerTask.GetAwaiter().GetResult();
+            if (innerTask.IsFaulted) throw innerTask.Exception!.InnerException ?? innerTask.Exception;
+            return TaskResultCache.GetResult(innerTask);
+        }
+
+        return value;
+    }
+
+    private static DispatchResult Box(object? value)
+    {
+        if (value is null) return DispatchResult.Void;
+        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 DispatchResult.Primitive(value, t);
+
+        if (t.IsEnum)
+        {
+            var ut = Enum.GetUnderlyingType(t);
+            return DispatchResult.Primitive(Convert.ChangeType(value, ut), ut);
+        }
+
+        if (t.IsArray || (t != typeof(string) && value is IEnumerable))
+        {
+            try { return DispatchResult.Collection((IEnumerable)value); }
+            catch { }
+        }
+
+            var id = Interlocked.Increment(ref s_nextHandle);
+            s_handles[id] = value;
+
+            // Try to obtain a canonical IUnknown pointer for COM/WinRT objects so the
+            // runtime can call native vtable methods directly. We addref via
+            // Marshal.GetIUnknownForObject and store the raw pointer; it will be
+            // released on __release.
+            try
+            {
+                if (value != null)
+                {
+                    var p = Marshal.GetIUnknownForObject(value);
+                    if (p != IntPtr.Zero)
+                    {
+                        s_nativePtrs[id] = p.ToInt64();
+                        try { System.Diagnostics.Debug.WriteLine($"[Bridge] Box: handle {id}, type={t.FullName}, native=0x{p.ToInt64():x}"); } catch { }
+                    }
+                }
+            }
+            catch
+            {
+                // Not a COM object or failed to obtain native pointer; ignore.
+            }
+        var typeName = t.FullName ?? t.Name;
+        return IsAwaitable(value, t)
+            ? DispatchResult.TaskHandle(id, typeName)
+            : DispatchResult.Handle(id, typeName);
+    }
+
+    private static bool IsAwaitable(object value, Type t)
+    {
+        if (value is Task || value is ValueTask) return true;
+        if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ValueTask<>)) return true;
+        if ((t.FullName ?? "").StartsWith("Windows.Foundation.IAsync", StringComparison.Ordinal)) return true;
+        foreach (var iface in t.GetInterfaces())
+            if ((iface.FullName ?? "").StartsWith("Windows.Foundation.IAsync", StringComparison.Ordinal)) return true;
+        return t.GetMethod("GetAwaiter",
+                   BindingFlags.Public | BindingFlags.Instance,
+                   null, Type.EmptyTypes, null) is not null;
+    }
+
+    internal static DispatchResult BuildMembersResult(Type t)
+    {
+        const BindingFlags inst = BindingFlags.Public | BindingFlags.Instance;
+        const BindingFlags stat = BindingFlags.Public | BindingFlags.Static;
+
+        var instProps = t.GetProperties(inst);
+        var statProps = t.GetProperties(stat);
+
+        return DispatchResult.Members(
+            methods:               t.GetMethods(inst).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
+            props:                 instProps.Where(p => p.GetGetMethod() != null).Select(p => p.Name).Distinct().ToArray(),
+            staticMethods:         t.GetMethods(stat).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
+            staticProps:           statProps.Where(p => p.GetGetMethod() != null).Select(p => p.Name).Distinct().ToArray(),
+            readonlyProps:         instProps.Where(p => p.GetGetMethod() != null && p.GetSetMethod() == null).Select(p => p.Name).Distinct().ToArray(),
+            readonlyStaticProps:   statProps.Where(p => p.GetGetMethod() != null && p.GetSetMethod() == null).Select(p => p.Name).Distinct().ToArray(),
+            writeonlyProps:        instProps.Where(p => p.GetGetMethod() == null && p.GetSetMethod() != null).Select(p => p.Name).Distinct().ToArray(),
+            writeonlyStaticProps:  statProps.Where(p => p.GetGetMethod() == null && p.GetSetMethod() != null).Select(p => p.Name).Distinct().ToArray()
+        );
+    }
+
+    internal 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)
+    {
+        if (string.IsNullOrEmpty(typeName)) return null;
+
+        // Fast/normal lookup first (assembly-qualified or plain type name).
+        var fqn = string.IsNullOrEmpty(assemblyName) ? typeName! : $"{typeName}, {assemblyName}";
+        var t = Type.GetType(fqn);
+        if (t is not null) return t;
+
+        t = Type.GetType(typeName);
+        if (t is not null) return t;
+
+        // Last segment (type name without namespace) used for loose matching below.
+        var lastDot = typeName.LastIndexOf('.');
+        var shortName = lastDot >= 0 ? typeName[(lastDot + 1)..] : typeName;
+
+        // Search loaded assemblies quickly; prefer asm.GetType which is inexpensive.
+        foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            try
+            {
+                t = asm.GetType(typeName);
+                if (t is not null) return t;
+
+                // Fall back to scanning exported types only when necessary. Some
+                // assemblies throw on GetTypes() (ReflectionTypeLoadException) so
+                // we catch and continue.
+                foreach (var ty in asm.GetTypes())
+                {
+                    if (string.Equals(ty.FullName, typeName, StringComparison.Ordinal))
+                        return ty;
+                    // Short-name match only when input has no namespace prefix (e.g. "Stopwatch").
+                    // Guarding on lastDot < 0 prevents matching unrelated types in other namespaces
+                    // (e.g. "NativeScript.Widgets.FlexboxLayout" must not match a different
+                    //  FlexboxLayout that happens to live in another namespace).
+                    if (lastDot < 0 && string.Equals(ty.Name, shortName, StringComparison.Ordinal))
+                        return ty;
+                }
+            }
+            catch (ReflectionTypeLoadException) { }
+            catch { }
+        }
+
+        // If an assembly name was provided try loading it explicitly and repeat
+        // the above search inside that assembly only (less work than scanning all).
+        if (!string.IsNullOrEmpty(assemblyName))
+        {
+            try
+            {
+                var asm = Assembly.Load(assemblyName);
+                if (asm is not null)
+                {
+                    t = asm.GetType(typeName!);
+                    if (t is not null) return t;
+                    try
+                    {
+                        foreach (var ty in asm.GetTypes())
+                        {
+                            if (string.Equals(ty.FullName, typeName, StringComparison.Ordinal))
+                                return ty;
+                            if (lastDot < 0 && string.Equals(ty.Name, shortName, StringComparison.Ordinal))
+                                return ty;
+                        }
+                    }
+                    catch (ReflectionTypeLoadException) { }
+                }
+            }
+            catch { }
+        }
+
+        return null;
+    }
+
+    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);
+        return match ?? type.GetMethod(name, flags);
+    }
+
+    internal static Exception Unwrap(Exception ex) =>
+        ex is TargetInvocationException { InnerException: { } inner } ? Unwrap(inner) : ex;
+
+    // Used by benchmarks to give a fair end-to-end comparison of protocols.
+
+    internal static byte[] PipelineJson(ReadOnlySpan<byte> jsonRequest)
+    {
+        var req    = JsonSerializer.Deserialize(jsonRequest, BridgeJsonContext.Default.InvokeRequest)!;
+        var result = Dispatch(req);
+        var buf    = new ArrayBufferWriter<byte>(128);
+        using var w = new Utf8JsonWriter(buf);
+        w.WriteStartObject();
+        w.WritePropertyName("result"u8);
+        result.WriteTo(w, s_coerceOpts);
+        w.WriteEndObject();
+        w.Flush();
+        return buf.WrittenSpan.ToArray();
+    }
+
+    internal static byte[] PipelineBinary(ReadOnlySpan<byte> binRequest)
+    {
+        var r      = new BinReader(binRequest);
+        var result = DispatchBin(ref r);
+        var buf    = new ArrayBufferWriter<byte>(128);
+        result.WriteAsBin(buf);
+        return buf.WrittenSpan.ToArray();
+    }
+
+    private static unsafe void WriteResult(DispatchResult res, byte** outPtr, int* outLen)
+    {
+        var buf = new ArrayBufferWriter<byte>(256);
+        using var w = new Utf8JsonWriter(buf);
+        w.WriteStartObject();
+        w.WritePropertyName("result"u8);
+        res.WriteTo(w, s_coerceOpts);
+        w.WriteEndObject();
+        w.Flush();
+        WriteUnmanaged(buf.WrittenSpan, outPtr, outLen);
+    }
+
+    private static unsafe void WriteError(string msg, byte** outPtr, int* outLen)
+    {
+        var buf = new ArrayBufferWriter<byte>(128);
+        using var w = new Utf8JsonWriter(buf);
+        w.WriteStartObject();
+        w.WriteString("error"u8, msg);
+        w.WriteEndObject();
+        w.Flush();
+        WriteUnmanaged(buf.WrittenSpan, outPtr, outLen);
+    }
+
+    internal static unsafe void WriteUnmanaged(ReadOnlySpan<byte> bytes, byte** outPtr, int* outLen)
+    {
+        var p = (byte*)Marshal.AllocHGlobal(bytes.Length + 1);
+        bytes.CopyTo(new Span<byte>(p, bytes.Length));
+        p[bytes.Length] = 0;
+        *outPtr  = p;
+        *outLen  = bytes.Length;
+    }
+}