@nativescript/windows-hermes 0.1.0-alpha.0

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

@@ -0,0 +1,573 @@
+using System;
+using System.Buffers;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Globalization;
+
+namespace NativeScriptBridge;
+
+public static partial class Bridge
+{
+    // Cache for dynamically generated proxy types (dev-only fallback). Keyed by base type PLUS
+    // the exact set of interfaces/members a given JS `overrides` object asked for, so different
+    // JS subclasses of the same base type (different override sets) get distinct emitted types.
+    private readonly record struct ProxyTypeKey(Type BaseType, string InterfaceKey, string MemberKey);
+    private static readonly ConcurrentDictionary<ProxyTypeKey, Type> s_dynamicProxyCache = new();
+    private static int s_dynamicProxyTypeCounter = 0;
+    private static readonly AssemblyBuilder? s_dynamicAssembly = CreateDynamicAssembly();
+    private static readonly ModuleBuilder? s_dynamicModule   = CreateDynamicModule(s_dynamicAssembly);
+
+    private static AssemblyBuilder? CreateDynamicAssembly()
+    {
+        try
+        {
+            var an = new AssemblyName("NSWinRTDynamicProxies");
+            var asm = AssemblyBuilder.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);
+            
+            return asm;
+        }
+        catch { return null; }
+    }
+
+    private static ModuleBuilder? CreateDynamicModule(AssemblyBuilder? asm)
+    {
+            try {
+                var m = asm?.DefineDynamicModule("NSWinRTDynamicProxiesModule");
+                return m;
+            } catch { return null; }
+    }
+
+    // Public helpers callable from runtime-generated types. Nested type so it can
+    // access Bridge's private proxy helpers (ProxyInvokeMethod, etc.) while
+    // exposing a stable public API for emitted proxies.
+    public static class ProxyRuntime
+    {
+        public static T InvokeMethodTyped<T>(object instance, string methodName, object[] args)
+        {
+            var result = ProxyInvokeMethod(instance, methodName, args);
+            if (result is null) return default!;
+            if (result is T t) return t;
+            return (T)Convert.ChangeType(result, typeof(T), CultureInfo.InvariantCulture);
+        }
+
+        public static object? InvokeMethod(object instance, string methodName, object[] args)
+        {
+            return ProxyInvokeMethod(instance, methodName, args);
+        }
+
+        public static void InvokeVoid(object instance, string methodName, object[] args)
+        {
+            ProxyInvokeVoid(instance, methodName, args);
+        }
+
+        public static T GetProperty<T>(object instance, string propertyName)
+        {
+            var result = ProxyGetProperty(instance, propertyName);
+            if (result is null) return default!;
+            if (result is T t) return t;
+            return (T)Convert.ChangeType(result, typeof(T), CultureInfo.InvariantCulture);
+        }
+
+        public static void SetProperty(object instance, string propertyName, object? value)
+        {
+            ProxySetProperty(instance, propertyName, value);
+        }
+    }
+    private sealed class ProxyCallbackHolder { public int CallbackId; public int HandleId; public ProxyCallbackHolder(int cb) { CallbackId = cb; HandleId = 0; } }
+
+    private static readonly ConditionalWeakTable<object, ProxyCallbackHolder> s_proxyCallbacks = new();
+    private static readonly ThreadLocal<int?> s_pendingProxyCallbackId = new(() => null);
+    private static readonly object s_proxyRegisterLock = new();
+    private static bool s_proxyDispatcherRegistered = false;
+
+    private static void EnsureProxyDispatcherCallbacksRegistered()
+    {
+        if (s_proxyDispatcherRegistered) return;
+        lock (s_proxyRegisterLock)
+        {
+            if (s_proxyDispatcherRegistered) return;
+
+            Type? pdType = null;
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                try
+                {
+                    pdType = asm.GetType("NativeScriptGeneratedProxies.ProxyDispatcher")
+                          ?? asm.GetType("NSWinRTProxies.ProxyDispatcher")
+                          ?? asm.GetType("NativeScriptGeneratedProxies.ProxyDispatcher");
+                    if (pdType != null) break;
+                }
+                catch { }
+            }
+
+            if (pdType != null)
+            {
+                // Properties generated by SBG
+                var p1 = pdType.GetProperty("JsInvokeMethod", BindingFlags.Public | BindingFlags.Static);
+                p1?.SetValue(null, new Func<object, string, object[], object?>(ProxyInvokeMethod));
+
+                var p2 = pdType.GetProperty("JsInvokeVoid", BindingFlags.Public | BindingFlags.Static);
+                p2?.SetValue(null, new Action<object, string, object[]>(ProxyInvokeVoid));
+
+                var p3 = pdType.GetProperty("JsGetProperty", BindingFlags.Public | BindingFlags.Static);
+                p3?.SetValue(null, new Func<object, string, object?>(ProxyGetProperty));
+
+                var p4 = pdType.GetProperty("JsSetProperty", BindingFlags.Public | BindingFlags.Static);
+                p4?.SetValue(null, new Action<object, string, object?>(ProxySetProperty));
+
+                var p5 = pdType.GetProperty("JsInitializeInstance", BindingFlags.Public | BindingFlags.Static);
+                p5?.SetValue(null, new Action<object, string>(ProxyInitializeInstance));
+            }
+
+            s_proxyDispatcherRegistered = true;
+        }
+    }
+
+    private static bool DynamicProxiesEnabled()
+    {
+        // Always allow dynamic proxies in dev when Reflection.Emit is available.
+        return s_dynamicModule != null;
+    }
+
+    private static Type? FindGeneratedProxyType(string typeName)
+    {
+        if (string.IsNullOrEmpty(typeName)) return null;
+        var lastDot = typeName.LastIndexOf('.');
+        var shortName = lastDot >= 0 ? typeName[(lastDot + 1)..] : typeName;
+        foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            try
+            {
+                // Only consider assemblies that look like generated proxy assemblies
+                var asmName = asm.GetName().Name ?? "";
+                if (!string.Equals(asmName, "NativeScriptGeneratedProxies", StringComparison.Ordinal)
+                    && !string.Equals(asmName, "NSWinRTProxies", StringComparison.Ordinal))
+                {
+                    // Also check for candidate full-type names in any assembly
+                    var candidates = new[] { $"NativeScriptGeneratedProxies.{shortName}", $"NSWinRTProxies.{shortName}" };
+                    foreach (var cn in candidates)
+                    {
+                        var t = asm.GetType(cn);
+                        if (t is not null) return t;
+                    }
+                    continue;
+                }
+
+                // If this is a generated proxies assembly, look up the proxy type name.
+                var genCandidates = new[] { $"NativeScriptGeneratedProxies.{shortName}", $"NSWinRTProxies.{shortName}" };
+                foreach (var cn in genCandidates)
+                {
+                    var t = asm.GetType(cn);
+                    if (t is not null) return t;
+                }
+            }
+            catch { }
+        }
+        return null;
+    }
+
+    private static Type GetOrCreateDynamicProxyType(Type baseType, string[] interfaceNames, string[] memberNames)
+    {
+        var interfaceKey = string.Join(",", interfaceNames.OrderBy(n => n, StringComparer.Ordinal));
+        var memberKey = string.Join(",", memberNames.OrderBy(n => n, StringComparer.Ordinal));
+        var key = new ProxyTypeKey(baseType, interfaceKey, memberKey);
+        return s_dynamicProxyCache.GetOrAdd(key, _ => CreateDynamicProxyType(baseType, interfaceNames, memberNames));
+    }
+
+    private static Type CreateDynamicProxyType(Type baseType, string[] interfaceNames, string[] memberNames)
+    {
+
+        if (s_dynamicModule == null)
+            throw new InvalidOperationException("Dynamic proxy generation not available in this environment");
+
+        if (baseType.IsSealed)
+            throw new InvalidOperationException($"Cannot derive from sealed type {baseType.FullName}");
+
+        var interfaceTypes = interfaceNames
+            .Select(n => ResolveType(null, n) ?? throw new TypeLoadException($"Interface type not found: {n}"))
+            .ToArray();
+
+        // Members JS actually overrides. Only base virtuals in this set get an IL override
+        // emitted — anything else is left alone so the real base implementation stays live in
+        // the vtable (no "call base" IL needed, the base method was simply never touched).
+        var memberSet = new HashSet<string>(memberNames, StringComparer.Ordinal);
+
+        var safeName = (baseType.FullName ?? Guid.NewGuid().ToString()).Replace('.', '_');
+        var uniqueSuffix = Interlocked.Increment(ref s_dynamicProxyTypeCounter);
+        var typeName = $"NSWinRTDynamicProxies.{safeName}_JsProxy_{uniqueSuffix}";
+
+        var tb = s_dynamicModule.DefineType(typeName, TypeAttributes.Public | TypeAttributes.Class, baseType);
+
+        // Mirror public base constructors and ensure at least a parameterless
+        // ctor exists on the derived type. If the base type has no parameterless
+        // ctor, emit a parameterless ctor that forwards default(T) values to the
+        // first available base ctor (dev-only convenience).
+        var baseCtors = baseType.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
+                        .Where(c => !c.IsGenericMethod)
+                        .ToArray();
+
+        ConstructorInfo? chosenBaseForDefault = null;
+        foreach (var bc in baseCtors)
+        {
+            var parameters = bc.GetParameters();
+            if (parameters.Any(p => p.ParameterType.IsByRef)) continue;
+            chosenBaseForDefault ??= bc;
+
+            // Define a matching ctor on the derived type that forwards args to base.
+            var paramTypes = parameters.Select(p => p.ParameterType).ToArray();
+            var derivedCtor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, paramTypes);
+            var ilg = derivedCtor.GetILGenerator();
+            // Load 'this'
+            ilg.Emit(OpCodes.Ldarg_0);
+            // Load each argument and forward
+            for (int i = 0; i < paramTypes.Length; i++)
+            {
+                // ldarg_1..n
+                switch (i + 1)
+                {
+                    case 1: ilg.Emit(OpCodes.Ldarg_1); break;
+                    case 2: ilg.Emit(OpCodes.Ldarg_2); break;
+                    case 3: ilg.Emit(OpCodes.Ldarg_3); break;
+                    default: ilg.Emit(OpCodes.Ldarg, i + 1); break;
+                }
+            }
+            ilg.Emit(OpCodes.Call, bc);
+            ilg.Emit(OpCodes.Ret);
+        }
+
+        // If we didn't define a parameterless ctor, emit one that forwards
+        // default(T) values to the chosen base ctor (if any), otherwise call
+        // System.Object..ctor.
+        if (!baseCtors.Any(c => c.GetParameters().Length == 0))
+        {
+            var paramless = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
+            var ilg = paramless.GetILGenerator();
+            if (chosenBaseForDefault is not null)
+            {
+                ilg.Emit(OpCodes.Ldarg_0);
+                var parameters = chosenBaseForDefault.GetParameters();
+                // For each param, emit default value (null for ref types, initobj local for value types)
+                for (int i = 0; i < parameters.Length; i++)
+                {
+                    var ptype = parameters[i].ParameterType;
+                    if (ptype.IsByRef) throw new InvalidOperationException("Cannot forward byref parameters in dynamic ctor");
+                    if (ptype.IsValueType)
+                    {
+                        var temp = ilg.DeclareLocal(ptype);
+                        ilg.Emit(OpCodes.Ldloca_S, temp);
+                        ilg.Emit(OpCodes.Initobj, ptype);
+                        ilg.Emit(OpCodes.Ldloc, temp);
+                    }
+                    else
+                    {
+                        ilg.Emit(OpCodes.Ldnull);
+                    }
+                }
+                ilg.Emit(OpCodes.Call, chosenBaseForDefault);
+                ilg.Emit(OpCodes.Ret);
+            }
+            else
+            {
+                // No public base ctors (rare); call Object..ctor
+                var objCtor = typeof(object).GetConstructor(Type.EmptyTypes)!;
+                ilg.Emit(OpCodes.Ldarg_0);
+                ilg.Emit(OpCodes.Call, objCtor);
+                ilg.Emit(OpCodes.Ret);
+            }
+        }
+
+        // Shared by both loops below, keyed by "Name(Param1FullName,Param2FullName,...)" so a
+        // member that's both an overridden base virtual and a requested interface member (e.g.
+        // the base class already implements that interface) reuses one emitted body instead of
+        // tripping a "duplicate member" TypeBuilder error.
+        var definedSignatures = new Dictionary<string, MethodBuilder>(StringComparer.Ordinal);
+        static string SignatureKey(string name, Type[] paramTypes) =>
+            name + "(" + string.Join(",", paramTypes.Select(p => p.FullName)) + ")";
+
+        // Override only the base virtuals JS actually asked for (memberSet). Anything not in
+        // that set is simply never touched, so the base implementation stays live in the vtable —
+        // no "call base" IL needed. (Skip ref/out and generic methods — unsupported.)
+        var virtualMethods = baseType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
+            .Where(m => m.IsVirtual && !m.IsFinal && !m.IsGenericMethod && !m.IsConstructor && memberSet.Contains(m.Name))
+            .ToArray();
+
+        foreach (var mi in virtualMethods)
+        {
+            var parameters = mi.GetParameters();
+            if (parameters.Any(p => p.ParameterType.IsByRef)) continue;
+
+            var paramTypes = parameters.Select(p => p.ParameterType).ToArray();
+            var sigKey = SignatureKey(mi.Name, paramTypes);
+            if (!definedSignatures.TryGetValue(sigKey, out var mb))
+            {
+                mb = EmitProxyMethodBody(tb, mi.Name,
+                    MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig,
+                    mi.CallingConvention, mi.ReturnType, paramTypes, mi.Name);
+                definedSignatures[sigKey] = mb;
+            }
+
+            tb.DefineMethodOverride(mb, mi);
+        }
+
+        // Interfaces: every requested interface (plus any interfaces *those* extend, since
+        // AddInterfaceImplementation only registers the interface named, not its ancestors) must
+        // have every member implemented — the CLR requires it, unlike base-class virtuals where
+        // skipping is fine. Members JS doesn't override fall back to default/no-op via the same
+        // generic dispatcher (ProxyRuntime.InvokeMethodTyped/InvokeVoid already do this).
+        if (interfaceTypes.Length > 0)
+        {
+            var allInterfaceTypes = new List<Type>();
+            void CollectInterfaces(Type t)
+            {
+                if (allInterfaceTypes.Contains(t)) return;
+                allInterfaceTypes.Add(t);
+                foreach (var parent in t.GetInterfaces()) CollectInterfaces(parent);
+            }
+            foreach (var ifaceType in interfaceTypes) CollectInterfaces(ifaceType);
+
+            foreach (var ifaceType in allInterfaceTypes) tb.AddInterfaceImplementation(ifaceType);
+
+            foreach (var ifaceType in allInterfaceTypes)
+            {
+                foreach (var mi in ifaceType.GetMethods())
+                {
+                    var parameters = mi.GetParameters();
+                    if (parameters.Any(p => p.ParameterType.IsByRef)) continue;
+
+                    var paramTypes = parameters.Select(p => p.ParameterType).ToArray();
+                    var sigKey = SignatureKey(mi.Name, paramTypes);
+                    if (!definedSignatures.TryGetValue(sigKey, out var mb))
+                    {
+                        mb = EmitProxyMethodBody(tb, mi.Name,
+                            MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Final
+                                | MethodAttributes.HideBySig | MethodAttributes.NewSlot,
+                            mi.CallingConvention, mi.ReturnType, paramTypes, mi.Name);
+                        definedSignatures[sigKey] = mb;
+                    }
+
+                    tb.DefineMethodOverride(mb, mi);
+                }
+            }
+        }
+
+        return tb.CreateTypeInfo()!.AsType();
+    }
+
+    // Shared IL body for both base-virtual overrides and interface-member implementations: box
+    // args into an object[], forward to ProxyRuntime.InvokeVoid/InvokeMethodTyped<T> by name.
+    private static MethodBuilder EmitProxyMethodBody(
+        TypeBuilder tb, string emittedName, MethodAttributes attrs, CallingConventions callingConvention,
+        Type returnType, Type[] paramTypes, string dispatchName)
+    {
+        var mb = tb.DefineMethod(emittedName, attrs, callingConvention, returnType, paramTypes);
+        var ilg = mb.GetILGenerator();
+        var argsLocal = ilg.DeclareLocal(typeof(object[]));
+        ilg.Emit(OpCodes.Ldc_I4, paramTypes.Length);
+        ilg.Emit(OpCodes.Newarr, typeof(object));
+        ilg.Emit(OpCodes.Stloc, argsLocal);
+
+        for (int i = 0; i < paramTypes.Length; i++)
+        {
+            ilg.Emit(OpCodes.Ldloc, argsLocal);
+            ilg.Emit(OpCodes.Ldc_I4, i);
+            ilg.Emit(OpCodes.Ldarg, i + 1);
+            if (paramTypes[i].IsValueType) ilg.Emit(OpCodes.Box, paramTypes[i]);
+            ilg.Emit(OpCodes.Stelem_Ref);
+        }
+
+        if (returnType == typeof(void))
+        {
+            var invokeVoid = typeof(Bridge).GetNestedType("ProxyRuntime", BindingFlags.Public | BindingFlags.Static)!.GetMethod("InvokeVoid", BindingFlags.Public | BindingFlags.Static)!;
+            ilg.Emit(OpCodes.Ldarg_0);
+            ilg.Emit(OpCodes.Ldstr, dispatchName);
+            ilg.Emit(OpCodes.Ldloc, argsLocal);
+            ilg.Emit(OpCodes.Call, invokeVoid);
+            ilg.Emit(OpCodes.Ret);
+        }
+        else
+        {
+            var proxyRuntimeType = typeof(Bridge).GetNestedType("ProxyRuntime", BindingFlags.Public | BindingFlags.Static)!;
+            var gm = proxyRuntimeType.GetMethod("InvokeMethodTyped", BindingFlags.Public | BindingFlags.Static)!.MakeGenericMethod(returnType);
+            ilg.Emit(OpCodes.Ldarg_0);
+            ilg.Emit(OpCodes.Ldstr, dispatchName);
+            ilg.Emit(OpCodes.Ldloc, argsLocal);
+            ilg.Emit(OpCodes.Call, gm);
+            ilg.Emit(OpCodes.Ret);
+        }
+
+        return mb;
+    }
+
+    private static DispatchResult CreateJsSubclass(
+        string? assemblyName, string typeName, int callbackId, string[] interfaceNames, string[] memberNames)
+    {
+        EnsureProxyDispatcherCallbacksRegistered();
+
+        s_pendingProxyCallbackId.Value = callbackId;
+
+        // Try to find a statically-generated proxy type first (Mechanism A: sbg-compiled into
+        // the app itself — already has any requested interfaces baked into real C# source).
+        Type? t = FindGeneratedProxyType(typeName);
+        if (t is null)
+        {
+            // When typeName is an auto-generated proxy name (com.tns.gen.winrt.*),
+            // the caller puts the real base type name in assemblyName so we can
+            // look up or dynamically emit a proxy for the correct base class.
+            string? resolveFrom = typeName;
+            if (!string.IsNullOrEmpty(assemblyName)
+                && typeName != null
+                && typeName.StartsWith("com.tns.gen.winrt.", StringComparison.Ordinal))
+            {
+                resolveFrom = assemblyName;
+            }
+
+            // Resolve the WinRT/base type and optionally emit a dynamic proxy (Mechanism B fallback).
+            var baseType = ResolveType(null, resolveFrom)
+                ?? ResolveType(assemblyName, typeName)
+                ?? throw new TypeLoadException($"Type not found: {resolveFrom} (proxy: {typeName}, assembly: {assemblyName})");
+
+            if (baseType.IsClass && !baseType.IsSealed)
+            {
+                try { t = GetOrCreateDynamicProxyType(baseType, interfaceNames, memberNames); }
+                catch (Exception) { t = baseType; }
+            }
+            else
+            {
+                t = baseType;
+            }
+        }
+
+        // Create the managed instance. Generated classes should call
+        // ProxyDispatcher.InitializeInstance(this, typeName) in their constructor,
+        // which will invoke our ProxyInitializeInstance and capture the pending callback id.
+        object? instance = Activator.CreateInstance(t);
+        if (instance is null)
+            throw new InvalidOperationException($"Failed to instantiate proxy type {t.FullName}.");
+
+        // Ensure there's a mapping for this instance immediately to avoid any
+        // early virtual calls from constructors reaching the JS side before
+        // the handle is registered. Call our initializer directly to register
+        // the pending callback id when dynamic proxies don't call it.
+        try { ProxyInitializeInstance(instance, typeName); } catch { }
+
+        // Force COM CCW vtable creation for any implemented WinRT interfaces now, rather than
+        // relying on it happening implicitly the first time the instance crosses the ABI boundary.
+        // Best-effort/reflection-only — no-ops cleanly when CsWinRT isn't loaded (e.g. xunit host).
+        if (interfaceNames.Length > 0)
+        {
+            TryActivateWinRTInterfaces(instance);
+        }
+
+        // Box the instance into a handle to return to the runtime.
+        var result = Box(instance);
+
+        // Populate holder with handle id now that a handle exists.
+        if (s_proxyCallbacks.TryGetValue(instance, out var holder))
+        {
+            try { holder.HandleId = result.HandleId(); } catch { holder.HandleId = 0; }
+        }
+        else
+        {
+            // If the generated proxy did not call InitializeInstance, create mapping now.
+            int hid = 0;
+            try { hid = result.HandleId(); } catch { hid = 0; }
+            var newHolder = new ProxyCallbackHolder(callbackId) { HandleId = hid };
+            s_proxyCallbacks.Add(instance, newHolder);
+        }
+
+        s_pendingProxyCallbackId.Value = null;
+        return result;
+    }
+
+    // Locates CsWinRT's ComWrappersSupport via reflection (same style as the WinRT.IWinRTObject
+    // lookup in ObtainNativePtr — no compile-time reference needed, since DotNetBridge.csproj is a
+    // dependency-free net9.0 library and CsWinRT is only ever loaded into the process by the WinUI
+    // app itself) and asks it to build a real COM CCW for the instance's implemented WinRT
+    // interfaces now, via CsWinRT's JIT reflection-fallback vtable path (works for types it never
+    // saw at compile time — see plan doc for the CsWinRT version/AOT caveats). Best-effort: no-ops
+    // when CsWinRT isn't loaded, e.g. the xunit test host has no WinUI/CsWinRT at all.
+    private static void TryActivateWinRTInterfaces(object instance)
+    {
+        try
+        {
+            Type? supportType = null;
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                try
+                {
+                    supportType = asm.GetType("WinRT.ComWrappersSupport");
+                    if (supportType != null) break;
+                }
+                catch { }
+            }
+            if (supportType == null) return;
+
+            foreach (var name in new[] { "CreateCCWForObject", "GetOrCreateComInterfaceForObject" })
+            {
+                foreach (var candidate in supportType.GetMethods(BindingFlags.Public | BindingFlags.Static)
+                                                      .Where(m => m.Name == name))
+                {
+                    try
+                    {
+                        var target = candidate.IsGenericMethodDefinition
+                            ? candidate.MakeGenericMethod(instance.GetType())
+                            : candidate;
+                        var ps = target.GetParameters();
+                        if (ps.Length == 1) { target.Invoke(null, [instance]); return; }
+                        if (ps.Length == 2 && ps[1].ParameterType == typeof(Guid)) { target.Invoke(null, [instance, Guid.Empty]); return; }
+                    }
+                    catch { /* try the next overload/name */ }
+                }
+            }
+        }
+        catch { /* best-effort only */ }
+    }
+
+    private static void ProxyInitializeInstance(object instance, string typeName)
+    {
+        var cb = s_pendingProxyCallbackId.Value;
+        if (cb.HasValue)
+        {
+            var holder = new ProxyCallbackHolder(cb.Value);
+            s_proxyCallbacks.Add(instance, holder);
+        }
+    }
+
+    private static object? ProxyInvokeMethod(object instance, string methodName, object[] args)
+    {
+        if (!s_proxyCallbacks.TryGetValue(instance, out var holder)) throw new InvalidOperationException("No JS callback registered for proxy instance.");
+        var payload = new object?[] { new HandleRef(holder.HandleId), methodName, args };
+        return CallJsCallback(holder.CallbackId, payload);
+    }
+
+    private static void ProxyInvokeVoid(object instance, string methodName, object[] args)
+    {
+        if (!s_proxyCallbacks.TryGetValue(instance, out var holder)) throw new InvalidOperationException("No JS callback registered for proxy instance.");
+        
+        var payload = new object?[] { new HandleRef(holder.HandleId), methodName, args };
+        CallJsCallback(holder.CallbackId, payload);
+    }
+
+    private static object? ProxyGetProperty(object instance, string propertyName)
+    {
+        if (!s_proxyCallbacks.TryGetValue(instance, out var holder)) throw new InvalidOperationException("No JS callback registered for proxy instance.");
+        // Tag "get:" prefix so the JS dispatcher can distinguish getter from method call.
+        var payload = new object?[] { new HandleRef(holder.HandleId), "get:" + propertyName };
+        return CallJsCallback(holder.CallbackId, payload);
+    }
+
+    private static void ProxySetProperty(object instance, string propertyName, object? value)
+    {
+        if (!s_proxyCallbacks.TryGetValue(instance, out var holder)) throw new InvalidOperationException("No JS callback registered for proxy instance.");
+        // Tag "set:" prefix so the JS dispatcher can distinguish setter from method call.
+        var payload = new object?[] { new HandleRef(holder.HandleId), "set:" + propertyName, value };
+        CallJsCallback(holder.CallbackId, payload);
+    }
+}
+