wenay-common2 1.0.74 → 1.0.76

package/lib/Common/rcp/rpc-client.js

@@ -9,6 +9,7 @@ const rpc_limits_1 = require("./rpc-limits");
 const myThrow_1 = require("../../toError/myThrow");
 const rpc_off_1 = require("./rpc-off");
 const rpc_caps_1 = require("./rpc-caps");
+const transport_lifecycle_1 = require("../events/transport-lifecycle");
 const SHARED_POOLS = new WeakMap();
 function sharedPool(socket, key) {
     let byKey = SHARED_POOLS.get(socket);
@@ -53,6 +54,28 @@ function listenKeyArg(a) {
     }
     return a;
 }
+function createPathProxyCache() {
+    const values = new Map();
+    const registry = new FinalizationRegistry(function releaseProxy(entry) {
+        if (values.get(entry.key)?.token == entry.token)
+            values.delete(entry.key);
+    });
+    function get(path) {
+        const key = (0, rpc_path_1.rpcPathKey)(path);
+        const proxy = values.get(key)?.ref.deref();
+        if (!proxy)
+            values.delete(key);
+        return proxy;
+    }
+    function set(path, proxy) {
+        const key = (0, rpc_path_1.rpcPathKey)(path);
+        const token = {};
+        values.set(key, { ref: new WeakRef(proxy), token });
+        registry.register(proxy, { key, token });
+        return proxy;
+    }
+    return { get, set };
+}
 const IS_RPC_PIPE = Symbol.for("isRpcPipe");
 function createClient(socket, key, opts) {
     const limit = opts?.limit ?? 10000;
@@ -67,6 +90,7 @@ function createClient(socket, key, opts) {
     const zombies = new Set();
     const retire = (id) => { zombies.add(id); };
     let disposed = false;
+    const transport = (0, transport_lifecycle_1.createTransportLifecycle)(true);
     let disconnectCbs = [];
     let disconnectResolve = () => { };
     const disconnectPromise = new Promise(res => { disconnectResolve = res; });
@@ -77,6 +101,7 @@ function createClient(socket, key, opts) {
         return (0, rpc_off_1.makeOff)(disconnectPromise, offDisconnect);
     }
     const routeCache = {};
+    let schemaKnown = false;
     let strictData = {};
     let strictWaiters = [];
     let debug = false;
@@ -138,6 +163,8 @@ function createClient(socket, key, opts) {
                 break;
             }
             case rpc_protocol_1.Pkt.SHAPE: {
+                if (!callbacks.has(msg[1]))
+                    break;
                 let m = compactShapes.get(msg[1]);
                 if (!m) {
                     m = [];
@@ -181,15 +208,17 @@ function createClient(socket, key, opts) {
                 break;
             }
             case rpc_protocol_1.Pkt.MAP: {
+                schemaKnown = true;
                 if (msg[1]) {
                     for (const k of Object.keys(routeCache))
                         delete routeCache[k];
                     Object.assign(routeCache, msg[1]);
                 }
                 if (Array.isArray(msg[3])) {
-                    declaredListens ??= new Set();
-                    for (const p of msg[3])
-                        declaredListens.add(p);
+                    declaredListens = new Set(msg[3]);
+                    for (const sub of wireSubs.values()) {
+                        sub.recoverable = declaredListens.has((0, rpc_path_1.rpcPathKey)(sub.path.slice(0, -1)));
+                    }
                 }
                 if (msg[2]) {
                     for (const k of Object.keys(strictData))
@@ -212,7 +241,9 @@ function createClient(socket, key, opts) {
     });
     const sendPipe = (path, steps, wait) => {
         if (disposed)
-            return wait ? Promise.reject(new Error("RPC client disposed")) : Promise.resolve();
+            return wait ? Promise.reject(new Error('RPC client disposed')) : Promise.resolve();
+        if (!transport.api.connected())
+            return wait ? Promise.reject(new Error('RPC transport disconnected')) : Promise.resolve();
         const cbIds = [];
         const cleanSteps = steps.map(step => {
             if (step.type === 'call') {
@@ -225,15 +256,22 @@ function createClient(socket, key, opts) {
             socket.emit(key, [rpc_protocol_1.Pkt.PIPE, 0, ref, cleanSteps, false]);
             return Promise.resolve();
         }
-        return new Promise((resolve, reject) => {
-            if (pending.size >= limit)
-                return reject(new Error("RPC limit"));
+        let record;
+        const promise = new Promise(function trackPipe(resolve, reject) {
+            if (pending.size >= limit) {
+                reject(new Error('RPC limit'));
+                return;
+            }
             const reqId = pool.next();
-            pending.set(reqId, { ok: resolve, fail: reject, cbs: cbIds });
+            record = { ok: resolve, fail: reject, cbs: cbIds };
+            pending.set(reqId, record);
             if (debug)
-                console.log("[RPC PIPE]", path.join("."), "steps=", steps.length, "id=", reqId);
+                console.log('[RPC PIPE]', path.join('.'), 'steps=', steps.length, 'id=', reqId);
             socket.emit(key, [rpc_protocol_1.Pkt.PIPE, reqId, ref, cleanSteps]);
         });
+        if (record)
+            record.promise = promise;
+        return promise;
     };
     const buildPipeProxy = (path, steps, wait) => {
         const proxy = new Proxy(function () { }, {
@@ -276,134 +314,324 @@ function createClient(socket, key, opts) {
         });
         return proxy;
     };
-    const sendCallWire = (path, args, wait) => {
-        if (disposed)
-            return wait ? Promise.reject(new Error("RPC client disposed")) : Promise.resolve();
+    function createCallAttempt(path, args) {
+        if (disposed) {
+            return { promise: Promise.reject(new Error('RPC client disposed')), abandon: function abandonDisposed() { } };
+        }
+        if (!transport.api.connected()) {
+            return { promise: Promise.reject(new Error('RPC transport disconnected')), abandon: function abandonOffline() { } };
+        }
+        if (pending.size >= limit) {
+            return { promise: Promise.reject(new Error('RPC limit')), abandon: function abandonLimited() { } };
+        }
         const cbIds = [];
         const clean = (0, rpc_walk_1.pack)(args, pool, callbacks, cbIds);
         const ref = routeCache[(0, rpc_path_1.rpcPathKey)(path)] ?? path;
-        if (!wait) {
-            socket.emit(key, [rpc_protocol_1.Pkt.CALL, 0, ref, clean, false]);
-            return Promise.resolve();
-        }
-        return new Promise((resolve, reject) => {
-            if (pending.size >= limit)
-                return reject(new Error("RPC limit"));
-            const reqId = pool.next();
-            pending.set(reqId, { ok: resolve, fail: reject, cbs: cbIds });
-            if (debug)
-                console.log("[RPC]", path.join("."), "id=", reqId);
-            socket.emit(key, [rpc_protocol_1.Pkt.CALL, reqId, ref, clean]);
+        const reqId = pool.next();
+        let record;
+        const promise = new Promise(function trackCall(resolve, reject) {
+            record = { ok: resolve, fail: reject, cbs: cbIds };
+            pending.set(reqId, record);
         });
-    };
+        record.promise = promise;
+        if (debug)
+            console.log('[RPC]', path.join('.'), 'id=', reqId);
+        socket.emit(key, [rpc_protocol_1.Pkt.CALL, reqId, ref, clean]);
+        function abandon(reason) {
+            if (pending.get(reqId) != record)
+                return;
+            pending.delete(reqId);
+            for (const cbId of cbIds) {
+                callbacks.delete(cbId);
+                compactShapes.delete(cbId);
+            }
+            record.fail(new Error(reason));
+        }
+        return { promise, abandon };
+    }
+    function sendCallWire(path, args, wait) {
+        if (disposed)
+            return wait ? Promise.reject(new Error('RPC client disposed')) : Promise.resolve();
+        if (!transport.api.connected())
+            return wait ? Promise.reject(new Error('RPC transport disconnected')) : Promise.resolve();
+        if (wait)
+            return createCallAttempt(path, args).promise;
+        const cbIds = [];
+        const clean = (0, rpc_walk_1.pack)(args, pool, callbacks, cbIds);
+        const ref = routeCache[(0, rpc_path_1.rpcPathKey)(path)] ?? path;
+        socket.emit(key, [rpc_protocol_1.Pkt.CALL, 0, ref, clean, false]);
+        return Promise.resolve();
+    }
     const dedupe = opts?.dedupeListen ?? true;
     const wireSubs = new Map();
     let declaredListens = null;
+    function finishLogical(sub) {
+        if (sub.ended)
+            return;
+        sub.ended = true;
+        sub.attempt = null;
+        if (wireSubs.get(sub.key) == sub)
+            wireSubs.delete(sub.key);
+        for (const consumer of sub.consumers)
+            consumer.resolve();
+        sub.consumers.clear();
+    }
+    function finishAttempt(sub, attempt) {
+        if (sub.attempt != attempt)
+            return;
+        sub.attempt = null;
+        finishLogical(sub);
+    }
+    function startAttempt(sub) {
+        if (disposed || sub.ended || sub.attempt || sub.consumers.size == 0 || !transport.api.connected())
+            return;
+        const attempt = { call: createCallAttempt(sub.path, sub.realArgs) };
+        sub.attempt = attempt;
+        attempt.call.promise.then(function physicalListenEnded() { finishAttempt(sub, attempt); }, function physicalListenFailed() { finishAttempt(sub, attempt); });
+    }
+    function stopLogical(sub, socketAlive = transport.api.connected()) {
+        if (sub.ended)
+            return;
+        const attempt = sub.attempt;
+        sub.attempt = null;
+        if (wireSubs.get(sub.key) == sub)
+            wireSubs.delete(sub.key);
+        sub.ended = true;
+        if (socketAlive && transport.api.connected()) {
+            sendCallWire([...sub.path.slice(0, -1), 'removeCallback'], [], false);
+        }
+        else {
+            attempt?.call.abandon('RPC Listen stopped while transport is disconnected');
+        }
+        for (const consumer of sub.consumers)
+            consumer.resolve();
+        sub.consumers.clear();
+    }
     function subscribeShared(path, args) {
         if (disposed)
-            return Promise.reject(new Error("RPC client disposed"));
+            return Promise.reject(new Error('RPC client disposed'));
         const listenPathKey = (0, rpc_path_1.rpcPathKey)(path.slice(0, -1));
-        const skey = listenPathKey + "::" + JSON.stringify(args.map(listenKeyArg));
+        const skey = listenPathKey + '::' + JSON.stringify(args.map(listenKeyArg));
         let sub = wireSubs.get(skey);
         if (!sub) {
-            const created = { consumers: new Set(), stop: () => { } };
-            wireSubs.set(skey, created);
             let fnPos = 0;
-            const realArgs = args.map(a => {
-                if (typeof a != "function")
-                    return a;
-                const i = fnPos++;
-                return (...ev) => {
-                    let err;
-                    created.consumers.forEach(c => {
+            const created = {
+                key: skey,
+                path: [...path],
+                realArgs: [],
+                consumers: new Set(),
+                attempt: null,
+                recoverable: declaredListens?.has(listenPathKey) == true,
+                ended: false,
+                stop: function stopCreated(socketAlive) { stopLogical(created, socketAlive); },
+            };
+            created.realArgs = args.map(function buildMultiplexer(arg) {
+                if (typeof arg != 'function')
+                    return arg;
+                const index = fnPos++;
+                return function multicastListenEvent(...event) {
+                    let error;
+                    for (const consumer of created.consumers) {
                         try {
-                            c.fns[i]?.(...ev);
+                            consumer.fns[index]?.(...event);
                         }
-                        catch (e) {
-                            err ??= e;
+                        catch (caught) {
+                            error ??= caught;
                         }
-                    });
-                    if (err !== undefined)
-                        setTimeout(() => { throw err; }, 0);
+                    }
+                    if (error != undefined)
+                        setTimeout(function rethrowConsumerError() { throw error; }, 0);
                 };
             });
-            const finish = () => {
-                if (wireSubs.get(skey) == created)
-                    wireSubs.delete(skey);
-                created.consumers.forEach(c => c.resolve());
-                created.consumers.clear();
-            };
-            created.stop = () => {
-                sendCallWire([...path.slice(0, -1), "removeCallback"], [], false);
-                finish();
-            };
-            sendCallWire(path, realArgs, true).then(finish, finish);
+            wireSubs.set(skey, created);
             sub = created;
         }
-        const consumer = { fns: args.filter(a => typeof a == "function"), resolve: () => { } };
+        const consumer = {
+            fns: args.filter(a => typeof a == 'function'),
+            resolve: function resolveLater() { },
+        };
         sub.consumers.add(consumer);
-        const p = new Promise(res => { consumer.resolve = res; });
-        const unsub = function unsubscribe() {
+        const promise = new Promise(function waitForListenEnd(resolve) { consumer.resolve = resolve; });
+        startAttempt(sub);
+        function unsubscribe() {
             if (!sub.consumers.delete(consumer))
                 return;
             consumer.resolve();
             if (sub.consumers.size == 0)
                 sub.stop();
-        };
-        return (0, rpc_off_1.makeOff)(p, unsub, { off: unsub, unsubscribe: unsub, removeCallback: unsub });
+        }
+        return (0, rpc_off_1.makeOff)(promise, unsubscribe, { off: unsubscribe, unsubscribe, removeCallback: unsubscribe });
+    }
+    function abandonTransportGeneration(reason) {
+        for (const sub of [...wireSubs.values()]) {
+            const attempt = sub.attempt;
+            sub.attempt = null;
+            attempt?.call.abandon(reason);
+            if (!sub.recoverable)
+                finishLogical(sub);
+        }
+        const error = new Error(reason);
+        for (const [id, request] of [...pending]) {
+            pending.delete(id);
+            for (const cbId of request.cbs) {
+                callbacks.delete(cbId);
+                compactShapes.delete(cbId);
+            }
+            request.promise?.catch(function consumeAbandonedTransportReject() { });
+            request.fail(error);
+        }
+        callbacks.clear();
+        compactShapes.clear();
+    }
+    function transportDisconnected(reason) {
+        abandonTransportGeneration('RPC transport disconnected: ' + reason);
+        schemaKnown = false;
+        capsSent = false;
+        peerServerCaps = 0;
+        declaredListens = declaredListens ? new Set() : null;
+        for (const route of Object.keys(routeCache))
+            delete routeCache[route];
+        authStatus = undefined;
+        authPending = false;
+        const strict = strictWaiters;
+        strictWaiters = [];
+        for (const resolve of strict)
+            resolve(undefined);
+        const auths = authWaiters;
+        authWaiters = [];
+        for (const resolve of auths)
+            resolve({ ok: false, reason });
     }
+    function transportConnected() {
+        for (const sub of [...wireSubs.values()]) {
+            if (sub.recoverable)
+                startAttempt(sub);
+            else
+                finishLogical(sub);
+        }
+    }
+    transport.api.onDisconnect(transportDisconnected);
+    transport.api.onConnect(transportConnected);
     const sendCall = (path, args, wait) => {
         const last = path[path.length - 1];
         if (dedupe && wait && path.length > 1 && (last == "callback" || last == "on") && args.some(a => typeof a == "function")) {
+            if (!transport.api.connected())
+                return sendCallWire(path, args, wait);
             const isListen = declaredListens ? declaredListens.has((0, rpc_path_1.rpcPathKey)(path.slice(0, -1))) : true;
             if (isListen)
                 return subscribeShared(path, args);
         }
         return sendCallWire(path, args, wait);
     };
-    const buildProxy = (path, wait) => new Proxy(function () { }, {
-        get(_, p) {
-            if (p == "then" || p == "catch" || p == Symbol.toPrimitive)
-                return undefined;
-            return buildProxy([...path, String(p)], wait);
-        },
-        apply(_, __, args) {
-            const [fp, fa] = (0, rpc_walk_1.resolveCA)(path, args);
-            return sendCall(fp, fa, wait);
-        },
-    });
-    const buildStrict = (path, wait) => {
-        let tgt = strictData;
-        for (const seg of path) {
-            tgt = tgt?.[seg];
-            if (tgt == null || tgt == "null")
+    function lookupRpcMemberState(path, member) {
+        if (!schemaKnown)
+            return undefined;
+        const memberPath = [...path, member];
+        const memberKey = (0, rpc_path_1.rpcPathKey)(memberPath);
+        if (Object.prototype.hasOwnProperty.call(routeCache, memberKey))
+            return true;
+        if (declaredListens?.has(memberKey))
+            return true;
+        const target = resolveStrictTarget(memberPath);
+        if (target == 'dynamic')
+            return undefined;
+        return target != undefined && target != null && target != 'null';
+    }
+    function createRpcMemberLookup(path) {
+        const lookup = function lookupRpcMember(member) { return lookupRpcMemberState(path, member); };
+        Object.defineProperty(lookup, transport_lifecycle_1.RPC_MEMBER_LOOKUP, { value: true });
+        return lookup;
+    }
+    const proxyCaches = {
+        func: createPathProxyCache(),
+        space: createPathProxyCache(),
+        strict: createPathProxyCache(),
+    };
+    function buildProxy(path, wait, cache) {
+        const cached = cache.get(path);
+        if (cached)
+            return cached;
+        const proxy = new Proxy(function () { }, {
+            get(_, p) {
+                if (p == transport_lifecycle_1.RPC_MEMBER_LOOKUP)
+                    return createRpcMemberLookup(path);
+                if (p == transport_lifecycle_1.RPC_TRANSPORT_LIFECYCLE)
+                    return transport.api;
+                if (p == 'then' || p == 'catch' || p == Symbol.toPrimitive)
+                    return undefined;
+                return buildProxy([...path, String(p)], wait, cache);
+            },
+            apply(_, __, args) {
+                const [fp, fa] = (0, rpc_walk_1.resolveCA)(path, args);
+                return sendCall(fp, fa, wait);
+            },
+        });
+        return cache.set(path, proxy);
+    }
+    function resolveStrictTarget(path) {
+        let target = strictData;
+        for (const segment of path) {
+            if (target == 'dynamic')
+                return target;
+            target = target?.[segment];
+            if (target == null || target == 'null')
                 return undefined;
-            if (tgt == "dynamic")
-                return buildProxy([...path], wait);
         }
-        if (tgt == "dynamic")
-            return buildProxy(path, wait);
-        return new Proxy(tgt == "func" ? function () { } : {}, {
-            has: (_, p) => tgt?.[String(p)] !== "null",
-            ownKeys: () => tgt && typeof tgt == "object" ? Object.keys(tgt) : [],
+        return target;
+    }
+    function buildStrict(path, wait) {
+        const initialTarget = resolveStrictTarget(path);
+        if (initialTarget == null || initialTarget == 'null')
+            return undefined;
+        const cached = proxyCaches.strict.get(path);
+        if (cached)
+            return cached;
+        const target = () => { };
+        const proxy = new Proxy(target, {
+            has: (_, p) => {
+                const target = resolveStrictTarget(path);
+                return target == 'dynamic' || (target?.[String(p)] != 'null' && target?.[String(p)] != undefined);
+            },
+            ownKeys: () => {
+                const target = resolveStrictTarget(path);
+                return target && typeof target == 'object' ? Object.keys(target) : [];
+            },
             getOwnPropertyDescriptor: () => ({ enumerable: true, configurable: true }),
-            getPrototypeOf: () => !tgt || tgt == "null" ? Object.prototype : tgt == "func" ? Function.prototype : null,
+            getPrototypeOf: () => {
+                const target = resolveStrictTarget(path);
+                return target == 'func' || target == 'dynamic' ? Function.prototype : target ? null : Object.prototype;
+            },
             get(_, p) {
-                if (p == "then" || p == "catch" || p == Symbol.toPrimitive)
+                if (p == transport_lifecycle_1.RPC_MEMBER_LOOKUP)
+                    return createRpcMemberLookup(path);
+                if (p == transport_lifecycle_1.RPC_TRANSPORT_LIFECYCLE)
+                    return transport.api;
+                if (p == 'then' || p == 'catch' || p == Symbol.toPrimitive)
                     return undefined;
-                if (p == "call" && tgt == "func")
-                    return (_, ...args) => sendCall(path, args, wait);
-                if (tgt === "func")
+                const target = resolveStrictTarget(path);
+                if (p == 'call' && target == 'func') {
+                    return function strictCall(_, ...args) { return sendCall(path, args, wait); };
+                }
+                if (target == 'func')
                     return undefined;
-                const child = tgt?.[String(p)];
-                return child == "null" || child == undefined ? undefined : buildStrict([...path, String(p)], wait);
+                if (target != 'dynamic') {
+                    const child = target?.[String(p)];
+                    if (child == 'null' || child == undefined)
+                        return undefined;
+                }
+                return buildStrict([...path, String(p)], wait);
             },
             apply(_, __, args) {
+                const target = resolveStrictTarget(path);
+                if (target != 'func' && target != 'dynamic') {
+                    throw new TypeError('RPC strict path is not callable');
+                }
                 const [fp, fa] = (0, rpc_walk_1.resolveCA)(path, args);
                 return sendCall(fp, fa, wait);
             },
         });
-    };
+        return proxyCaches.strict.set(path, proxy);
+    }
     const releaseCbs = (fn) => {
         callbacks.forEach((cb, id) => { if (cb == fn) {
             callbacks.delete(id);
@@ -411,40 +639,41 @@ function createClient(socket, key, opts) {
         } });
     };
     function abortAll(reason) {
-        const err = { error: { name: "RPC_ABORT", message: reason } };
-        pending.forEach((p, id) => { retire(id); p.fail(err); });
+        const err = { error: { name: 'RPC_ABORT', message: reason } };
+        pending.forEach(function abortPending(p, id) {
+            retire(id);
+            for (const cbId of p.cbs)
+                compactShapes.delete(cbId);
+            p.fail(err);
+        });
         pending.clear();
-        callbacks.forEach((_, id) => retire(id));
+        callbacks.forEach(function abortCallback(_, id) { retire(id); });
         callbacks.clear();
+        compactShapes.clear();
     }
     function drainWireSubs(socketAlive) {
-        const subs = Array.from(wireSubs.values());
+        const subs = [...wireSubs.values()];
         wireSubs.clear();
-        for (const s of subs) {
-            if (socketAlive)
-                s.stop();
-            else {
-                s.consumers.forEach(c => c.resolve());
-                s.consumers.clear();
-            }
-        }
+        for (const sub of subs)
+            sub.stop(socketAlive);
     }
-    function dispose(reason = "RPC client disposed", opts) {
+    function dispose(reason = 'RPC client disposed', opts) {
         if (disposed)
             return;
         const socketAlive = opts?.socketAlive ?? true;
-        abortAll(reason);
         drainWireSubs(socketAlive);
+        abortAll(reason);
         disposed = true;
+        transport.control.close(reason);
         authPending = false;
         const sw = strictWaiters;
         strictWaiters = [];
-        for (const r of sw)
-            r(undefined);
+        for (const resolve of sw)
+            resolve(undefined);
         const aw = authWaiters;
         authWaiters = [];
-        for (const r of aw)
-            r({ ok: false, reason });
+        for (const resolve of aw)
+            resolve({ ok: false, reason });
         const dc = disconnectCbs;
         disconnectCbs = [];
         for (const cb of dc)
@@ -467,7 +696,9 @@ function createClient(socket, key, opts) {
         end: releaseCbs,
         subscriptions: () => Array.from(wireSubs, ([k, s]) => ({ key: k, consumers: s.consumers.size })),
     };
-    const func = buildProxy([], true);
+    const func = buildProxy([], true, proxyCaches.func);
+    const space = buildProxy([], false, proxyCaches.space);
+    const strict = buildStrict([], true);
     const pipe = buildPipeProxy([], [], true);
     const pipeStrict = buildPipeProxy([], [], true);
     let _ready = null;
@@ -475,6 +706,7 @@ function createClient(socket, key, opts) {
     const init = async (obj) => {
         if (obj) {
             strictData = obj;
+            schemaKnown = true;
             return;
         }
         if (authToken != null) {
@@ -486,7 +718,9 @@ function createClient(socket, key, opts) {
     };
     function reauth(token) {
         if (disposed)
-            return Promise.resolve({ ok: false, reason: "RPC client disposed" });
+            return Promise.resolve({ ok: false, reason: 'RPC client disposed' });
+        if (!transport.api.connected())
+            return Promise.resolve({ ok: false, reason: 'RPC transport disconnected' });
         authToken = token;
         authPending = true;
         socket.emit(key, [rpc_protocol_1.Pkt.HELLO, token]);
@@ -499,10 +733,11 @@ function createClient(socket, key, opts) {
         func,
         pipe,
         pipeStrict,
-        space: buildProxy([], false),
+        space,
         all: func,
-        strict: buildStrict([], true),
+        strict,
         api,
+        [transport_lifecycle_1.RPC_TRANSPORT_CONTROL]: transport.control,
         abortAll,
         dispose,
         close: dispose,

package/lib/Common/rcp/rpc-clientHub.d.ts

@@ -20,5 +20,7 @@ export declare function createRpcClientHub<T extends Record<string, RpcDescripto
     readonly socket: T2;
     onConnect: (func?: ((count: number) => void) | null) => void;
     onDisconnect: (func?: ((reason: string) => void) | null) => void;
+    connectListen: (cb: (count: number) => void) => () => void;
+    disconnectListen: (cb: (reason: string) => void) => () => void;
     connectCount: () => number;
 };