@nativescript/windows 0.1.0-alpha.2 → 0.1.0-alpha.21

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);
+    }
+}

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

@@ -0,0 +1,348 @@
+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)
+        {
+            s_handles.TryRemove(req.Handle.Value, out _);
+            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}");
+        }
+
+        if (method == "__members__")
+            return BuildMembersResult(type);
+
+        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); }
+    }
+
+    // ── compiled dispatch cache ───────────────────────────────────────────────
+
+    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));
+
+    // ── argument coercion ─────────────────────────────────────────────────────
+
+    // 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);
+    }
+
+    // ── async unwrapping ──────────────────────────────────────────────────────
+
+    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;
+    }
+
+    // ── result boxing ─────────────────────────────────────────────────────────
+
+    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.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;
+        return DispatchResult.Handle(id, t.FullName ?? t.Name);
+    }
+
+    // ── type/member resolution ────────────────────────────────────────────────
+
+    internal static DispatchResult BuildMembersResult(Type t)
+    {
+        const BindingFlags inst = BindingFlags.Public | BindingFlags.Instance;
+        const BindingFlags stat = BindingFlags.Public | BindingFlags.Static;
+        return DispatchResult.Members(
+            t.GetMethods(inst).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
+            t.GetProperties(inst).Select(p => p.Name).Distinct().ToArray(),
+            t.GetMethods(stat).Where(m => !m.IsSpecialName).Select(m => m.Name).Distinct().ToArray(),
+            t.GetProperties(stat).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)
+    {
+        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 { t = Assembly.Load(assemblyName).GetType(typeName!); } catch { }
+        }
+        return t;
+    }
+
+    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;
+
+    // ── full-pipeline helpers (parse + dispatch + serialise) ──────────────────
+    // 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();
+    }
+
+    // ── JSON response writers ─────────────────────────────────────────────────
+
+    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;
+    }
+}