wenay-common2 1.0.46 → 1.0.49

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

@@ -1,4 +1,7 @@
 import { type SocketTmpl } from "./rpc-protocol";
+import { type RpcLimits } from "./rpc-limits";
+import { makeOff } from "./rpc-off";
+import { type RpcOpt } from "./rpc-caps";
 type UnwrapPromise<T> = T extends Promise<infer R> ? R : T;
 export type DeepDataOnly<T> = T extends Function ? never : T extends Array<infer U> ? Array<DeepDataOnly<U>> : T extends object ? {
     [K in keyof T as T[K] extends Function ? never : K]: DeepDataOnly<T[K]>;
@@ -24,6 +27,10 @@ type ClientApiHandle = {
     clearCallbacks: () => void;
     remove: (fn: Function) => void;
     end: (fn: Function) => void;
+    subscriptions: () => {
+        key: string;
+        consumers: number;
+    }[];
 };
 export type RpcClientReturn<T extends object> = {
     func: ClientAPIAll<T>;
@@ -34,13 +41,28 @@ export type RpcClientReturn<T extends object> = {
     strict: ClientAPIStrict<T>;
     api: ClientApiHandle;
     abortAll: (reason: string) => void;
+    dispose: (reason?: string, opts?: {
+        socketAlive?: boolean;
+    }) => void;
+    close: (reason?: string, opts?: {
+        socketAlive?: boolean;
+    }) => void;
     schema: () => any;
     readyStrict: () => Promise<void>;
+    ready: () => Promise<void>;
     initStrict: (obj?: object) => Promise<void>;
+    init: (obj?: object) => Promise<void>;
+    reauth: (token: any) => Promise<any>;
+    auth: () => Promise<any>;
+    onDisconnect: (cb: (reason: string) => void) => ReturnType<typeof makeOff>;
 };
-export declare function createRpcClient<T extends object>({ socket, socketKey: key, limit }: {
+export declare function createRpcClient<T extends object>({ socket, socketKey: key, limit, limits, dedupeListen, token, opt }: {
     socket: SocketTmpl;
     socketKey: string;
     limit?: number;
+    limits?: RpcLimits;
+    dedupeListen?: boolean;
+    token?: any;
+    opt?: RpcOpt;
 }): RpcClientReturn<T>;
 export type { ClientApiHandle };

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

@@ -4,46 +4,192 @@ exports.createRpcClient = createRpcClient;
 const rpc_protocol_1 = require("./rpc-protocol");
 const id_pool_1 = require("../id-pool");
 const rpc_walk_1 = require("./rpc-walk");
+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 SHARED_POOLS = new WeakMap();
+function sharedPool(socket, key) {
+    let byKey = SHARED_POOLS.get(socket);
+    if (!byKey) {
+        byKey = new Map();
+        SHARED_POOLS.set(socket, byKey);
+    }
+    let pool = byKey.get(key);
+    if (!pool) {
+        pool = (0, id_pool_1.createIdPool)();
+        byKey.set(key, pool);
+    }
+    return pool;
+}
+const reviveErr = (o) => {
+    if (o == null || typeof o != "object" || typeof o.message != "string" || typeof o.name != "string")
+        return o;
+    const o2 = o.data !== undefined ? { ...o, data: (0, rpc_walk_1.unpackResult)(o.data) } : o;
+    const err = myThrow_1.MyError.fromWire(o2);
+    if (o.cause !== undefined)
+        err.cause = reviveErr(o.cause);
+    return err;
+};
+function listenKeyArg(a) {
+    if (typeof a == "function")
+        return "@fn";
+    if (typeof a == "bigint")
+        return { $_b: a.toString() };
+    if (a instanceof Date)
+        return { $_d: a.valueOf() };
+    if (a instanceof Map)
+        return { $_m: [...a.entries()].map(([k, v]) => [listenKeyArg(k), listenKeyArg(v)]) };
+    if (a instanceof Set)
+        return { $_s: [...a.values()].map(listenKeyArg) };
+    if (Array.isArray(a))
+        return a.map(listenKeyArg);
+    if (a && typeof a == "object") {
+        const out = {};
+        for (const k of Object.keys(a).sort())
+            out[k] = listenKeyArg(a[k]);
+        return out;
+    }
+    return a;
+}
 const IS_RPC_PIPE = Symbol.for("isRpcPipe");
 function createClient(socket, key, opts) {
     const limit = opts?.limit ?? 10000;
-    const pool = (0, id_pool_1.createIdPool)();
+    const lim = opts?.limits ? (0, rpc_limits_1.resolveLimits)(opts.limits) : undefined;
+    const pool = sharedPool(socket, key);
     const pending = new Map();
     const callbacks = new Map();
+    const compactShapes = new Map();
+    let capsSent = false;
+    const clientCaps = (0, rpc_caps_1.optToCaps)(opts?.opt);
+    let peerServerCaps = 0;
+    const zombies = new Set();
+    const retire = (id) => { zombies.add(id); };
+    let disposed = false;
+    let disconnectCbs = [];
+    let disconnectResolve = () => { };
+    const disconnectPromise = new Promise(res => { disconnectResolve = res; });
+    function onDisconnect(cb) {
+        disconnectCbs.push(cb);
+        function offDisconnect() { const i = disconnectCbs.indexOf(cb); if (i >= 0)
+            disconnectCbs.splice(i, 1); }
+        return (0, rpc_off_1.makeOff)(disconnectPromise, offDisconnect);
+    }
     const routeCache = {};
     let strictData = {};
     let strictWaiters = [];
     let debug = false;
+    let authToken = opts?.token ?? null;
+    let authStatus = undefined;
+    let authWaiters = [];
+    let authPending = false;
+    const drainAuth = (s) => { authPending = false; const w = authWaiters; authWaiters = []; for (const r of w)
+        r(s); };
+    const setAuthStatus = (s) => { authStatus = s; drainAuth(s); };
     socket.on(key, (msg) => {
         if (!Array.isArray(msg))
             return;
+        if (disposed) {
+            if ((msg[0] == rpc_protocol_1.Pkt.RESP || msg[0] == rpc_protocol_1.Pkt.CB_END) && zombies.delete(msg[1]))
+                pool.release(msg[1]);
+            return;
+        }
         switch (msg[0]) {
             case rpc_protocol_1.Pkt.RESP: {
                 const req = pending.get(msg[1]);
-                if (!req)
+                if (!req) {
+                    if (zombies.delete(msg[1]))
+                        pool.release(msg[1]);
                     break;
+                }
                 pending.delete(msg[1]);
                 pool.release(msg[1]);
                 for (const cbId of req.cbs) {
-                    callbacks.delete(cbId);
-                    pool.release(cbId);
+                    if (callbacks.delete(cbId))
+                        pool.release(cbId);
+                }
+                if (msg[3])
+                    req.fail(reviveErr(msg[3]));
+                else {
+                    try {
+                        req.ok((0, rpc_walk_1.unpackResult)(msg[2], lim));
+                    }
+                    catch (e) {
+                        req.fail(e);
+                    }
                 }
-                msg[3] ? req.fail(msg[3]) : req.ok((0, rpc_walk_1.unpackResult)(msg[2]));
                 break;
             }
             case rpc_protocol_1.Pkt.CB: {
-                callbacks.get(msg[1])?.(...(msg[2] || []).map(rpc_walk_1.unpackResult));
+                const cb = callbacks.get(msg[1]);
+                if (!cb)
+                    break;
+                let cbArgs;
+                try {
+                    cbArgs = (msg[2] || []).map((a) => (0, rpc_walk_1.unpackResult)(a, lim));
+                }
+                catch (e) {
+                    if (debug)
+                        console.log("[RPC CB] dropped:", e);
+                    break;
+                }
+                cb(...cbArgs);
+                break;
+            }
+            case rpc_protocol_1.Pkt.SHAPE: {
+                let m = compactShapes.get(msg[1]);
+                if (!m) {
+                    m = [];
+                    compactShapes.set(msg[1], m);
+                }
+                m[msg[2]] = msg[3];
+                break;
+            }
+            case rpc_protocol_1.Pkt.CBV: {
+                const cb = callbacks.get(msg[1]);
+                if (!cb)
+                    break;
+                const keys = compactShapes.get(msg[1])?.[msg[2]];
+                if (!keys)
+                    break;
+                const vals = msg[3] || [];
+                let obj;
+                try {
+                    obj = {};
+                    keys.forEach((k, i) => { obj[k] = (0, rpc_walk_1.unpackResult)(vals[i], lim); });
+                }
+                catch (e) {
+                    if (debug)
+                        console.log("[RPC CBV] dropped:", e);
+                    break;
+                }
+                cb(obj);
                 break;
             }
             case rpc_protocol_1.Pkt.CB_END: {
                 const cbId = msg[1];
-                callbacks.delete(cbId);
-                pool.release(cbId);
+                compactShapes.delete(cbId);
+                if (callbacks.delete(cbId))
+                    pool.release(cbId);
+                else if (zombies.delete(cbId))
+                    pool.release(cbId);
+                break;
+            }
+            case rpc_protocol_1.Pkt.CAPS: {
+                peerServerCaps = typeof msg[1] === "number" ? msg[1] : 0;
                 break;
             }
             case rpc_protocol_1.Pkt.MAP: {
-                if (msg[1])
+                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);
+                }
                 if (msg[2]) {
                     for (const k of Object.keys(strictData))
                         delete strictData[k];
@@ -52,11 +198,20 @@ function createClient(socket, key, opts) {
                         r(undefined);
                     strictWaiters = [];
                 }
+                if (msg.length > 4)
+                    setAuthStatus(msg[4]);
+                if (!capsSent) {
+                    capsSent = true;
+                    if (clientCaps)
+                        socket.emit(key, [rpc_protocol_1.Pkt.CAPS, clientCaps]);
+                }
                 break;
             }
         }
     });
     const sendPipe = (path, steps, wait) => {
+        if (disposed)
+            return wait ? Promise.reject(new Error("RPC client disposed")) : Promise.resolve();
         const cbIds = [];
         const cleanSteps = steps.map(step => {
             if (step.type === 'call') {
@@ -120,7 +275,9 @@ function createClient(socket, key, opts) {
         });
         return proxy;
     };
-    const sendCall = (path, args, wait) => {
+    const sendCallWire = (path, args, wait) => {
+        if (disposed)
+            return wait ? Promise.reject(new Error("RPC client disposed")) : Promise.resolve();
         const cbIds = [];
         const clean = (0, rpc_walk_1.pack)(args, pool, callbacks, cbIds);
         const ref = routeCache[path.join(".")] ?? path;
@@ -138,6 +295,70 @@ function createClient(socket, key, opts) {
             socket.emit(key, [rpc_protocol_1.Pkt.CALL, reqId, ref, clean]);
         });
     };
+    const dedupe = opts?.dedupeListen ?? true;
+    const wireSubs = new Map();
+    let declaredListens = null;
+    function subscribeShared(path, args) {
+        if (disposed)
+            return Promise.reject(new Error("RPC client disposed"));
+        const skey = path.slice(0, -1).join(".") + "::" + 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 => {
+                        try {
+                            c.fns[i]?.(...ev);
+                        }
+                        catch (e) {
+                            err ??= e;
+                        }
+                    });
+                    if (err !== undefined)
+                        setTimeout(() => { throw err; }, 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);
+            sub = created;
+        }
+        const consumer = { fns: args.filter(a => typeof a == "function"), resolve: () => { } };
+        sub.consumers.add(consumer);
+        const p = new Promise(res => { consumer.resolve = res; });
+        const unsub = 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, { unsubscribe: unsub, removeCallback: unsub });
+    }
+    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")) {
+            const isListen = declaredListens ? declaredListens.has(path.slice(0, -1).join(".")) : 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)
@@ -184,20 +405,65 @@ function createClient(socket, key, opts) {
     const releaseCbs = (fn) => {
         callbacks.forEach((cb, id) => { if (cb == fn) {
             callbacks.delete(id);
-            pool.release(id);
+            retire(id);
         } });
     };
+    function abortAll(reason) {
+        const err = { error: { name: "RPC_ABORT", message: reason } };
+        pending.forEach((p, id) => { retire(id); p.fail(err); });
+        pending.clear();
+        callbacks.forEach((_, id) => retire(id));
+        callbacks.clear();
+    }
+    function drainWireSubs(socketAlive) {
+        const subs = Array.from(wireSubs.values());
+        wireSubs.clear();
+        for (const s of subs) {
+            if (socketAlive)
+                s.stop();
+            else {
+                s.consumers.forEach(c => c.resolve());
+                s.consumers.clear();
+            }
+        }
+    }
+    function dispose(reason = "RPC client disposed", opts) {
+        if (disposed)
+            return;
+        const socketAlive = opts?.socketAlive ?? true;
+        abortAll(reason);
+        drainWireSubs(socketAlive);
+        disposed = true;
+        authPending = false;
+        const sw = strictWaiters;
+        strictWaiters = [];
+        for (const r of sw)
+            r(undefined);
+        const aw = authWaiters;
+        authWaiters = [];
+        for (const r of aw)
+            r({ ok: false, reason });
+        const dc = disconnectCbs;
+        disconnectCbs = [];
+        for (const cb of dc)
+            try {
+                cb(reason);
+            }
+            catch { }
+        disconnectResolve(reason);
+    }
     const api = {
         log: s => { debug = s; },
         pending: () => pending.size,
         callbacks: () => callbacks.size,
         clearPromises: (rej = true) => {
-            pending.forEach((p, id) => { pool.release(id); rej ? p.fail("promiseDeleteAll") : p.ok(undefined); });
+            pending.forEach((p, id) => { retire(id); rej ? p.fail("promiseDeleteAll") : p.ok(undefined); });
             pending.clear();
         },
-        clearCallbacks: () => { callbacks.forEach((_, id) => pool.release(id)); callbacks.clear(); },
+        clearCallbacks: () => { callbacks.forEach((_, id) => retire(id)); callbacks.clear(); },
         remove: releaseCbs,
         end: releaseCbs,
+        subscriptions: () => Array.from(wireSubs, ([k, s]) => ({ key: k, consumers: s.consumers.size })),
     };
     const func = buildProxy([], true);
     const pipe = buildPipeProxy([], [], true);
@@ -207,12 +473,26 @@ function createClient(socket, key, opts) {
     const init = async (obj) => {
         if (obj) {
             strictData = obj;
+            return;
         }
-        else {
-            socket.emit(key, rpc_protocol_1.Pkt.STRICT);
-            await new Promise(r => { strictWaiters.push(r); });
+        if (authToken != null) {
+            authPending = true;
+            socket.emit(key, [rpc_protocol_1.Pkt.HELLO, authToken]);
         }
+        socket.emit(key, rpc_protocol_1.Pkt.STRICT);
+        await new Promise(r => { strictWaiters.push(r); });
     };
+    function reauth(token) {
+        if (disposed)
+            return Promise.resolve({ ok: false, reason: "RPC client disposed" });
+        authToken = token;
+        authPending = true;
+        socket.emit(key, [rpc_protocol_1.Pkt.HELLO, token]);
+        return new Promise(res => authWaiters.push(res));
+    }
+    const auth = () => disposed
+        ? Promise.resolve(authStatus !== undefined ? authStatus : { ok: false, reason: "RPC client disposed" })
+        : (authStatus !== undefined && !authPending) ? Promise.resolve(authStatus) : new Promise(res => authWaiters.push(res));
     return {
         func,
         pipe,
@@ -221,18 +501,19 @@ function createClient(socket, key, opts) {
         all: func,
         strict: buildStrict([], true),
         api,
-        abortAll: (reason) => {
-            const err = { error: { name: "RPC_ABORT", message: reason } };
-            pending.forEach((p, id) => { pool.release(id); p.fail(err); });
-            pending.clear();
-            callbacks.forEach((_, id) => pool.release(id));
-            callbacks.clear();
-        },
+        abortAll,
+        dispose,
+        close: dispose,
         schema: () => strictData,
         readyStrict: ready,
+        ready,
         initStrict: init,
+        init,
+        reauth,
+        auth,
+        onDisconnect,
     };
 }
-function createRpcClient({ socket, socketKey: key, limit }) {
-    return createClient(socket, key, { limit });
+function createRpcClient({ socket, socketKey: key, limit, limits, dedupeListen, token, opt }) {
+    return createClient(socket, key, { limit, limits, dedupeListen, token, opt });
 }

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

@@ -1,5 +1,6 @@
 import { SocketTmpl } from "./rpc-protocol";
 import { DeepSocketListenSmart } from "./listen-deep";
+import { type RpcOpt } from "./rpc-caps";
 export interface RpcHubSocket extends SocketTmpl {
     disconnect?: () => void;
 }
@@ -8,11 +9,16 @@ export type RpcDescriptor<T extends object> = {
     __type?: T;
 };
 export declare function rpc<T extends object>(socketKey?: string): RpcDescriptor<T>;
-export declare function createRpcClientHub<T extends Record<string, RpcDescriptor<any>>, T2 extends RpcHubSocket>(createSocket: (token: string | null) => T2, schemaBuilder: (helper: typeof rpc) => T): {
+export declare function createRpcClientHub<T extends Record<string, RpcDescriptor<any>>, T2 extends RpcHubSocket>(createSocket: (token: string | null) => T2, schemaBuilder: (helper: typeof rpc) => T, hubOpts?: {
+    opt?: RpcOpt;
+}): {
     readonly promise: Promise<{ [K_1 in keyof { [K in keyof T]: T[K] extends RpcDescriptor<infer U extends object> ? import("./rpc-client").RpcClientReturn<DeepSocketListenSmart<U>> : never; }]: { [K in keyof T]: T[K] extends RpcDescriptor<infer U extends object> ? import("./rpc-client").RpcClientReturn<DeepSocketListenSmart<U>> : never; }[K_1]; }>;
     facade: { [K_1 in keyof { [K in keyof T]: T[K] extends RpcDescriptor<infer U extends object> ? import("./rpc-client").RpcClientReturn<DeepSocketListenSmart<U>> : never; }]: { [K in keyof T]: T[K] extends RpcDescriptor<infer U extends object> ? import("./rpc-client").RpcClientReturn<DeepSocketListenSmart<U>> : never; }[K_1]; };
     setToken: (token: string | null) => Promise<{ [K_1 in keyof { [K in keyof T]: T[K] extends RpcDescriptor<infer U extends object> ? import("./rpc-client").RpcClientReturn<DeepSocketListenSmart<U>> : never; }]: { [K in keyof T]: T[K] extends RpcDescriptor<infer U extends object> ? import("./rpc-client").RpcClientReturn<DeepSocketListenSmart<U>> : never; }[K_1]; }>;
+    connect: (token: string | null) => Promise<{ [K_1 in keyof { [K in keyof T]: T[K] extends RpcDescriptor<infer U extends object> ? import("./rpc-client").RpcClientReturn<DeepSocketListenSmart<U>> : never; }]: { [K in keyof T]: T[K] extends RpcDescriptor<infer U extends object> ? import("./rpc-client").RpcClientReturn<DeepSocketListenSmart<U>> : never; }[K_1]; }>;
+    reauth: (token: string | null) => Promise<any[]>;
     readonly socket: T2;
     onConnect: (func?: ((count: number) => void) | null) => void;
+    onDisconnect: (func?: ((reason: string) => void) | null) => void;
     connectCount: () => number;
 };

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

@@ -6,22 +6,32 @@ const rpc_client_1 = require("./rpc-client");
 function rpc(socketKey) {
     return { socketKey };
 }
-function createRpcClientHub(createSocket, schemaBuilder) {
+function createRpcClientHub(createSocket, schemaBuilder, hubOpts) {
     const schema = schemaBuilder(rpc);
     const facade = {};
     let socket = null;
+    let currentToken = null;
     let connectCount = 0;
     let onConnectCb = null;
+    let onDisconnectCb = null;
     let resolveFunc = null;
     let promise = new Promise((resolve) => {
         resolveFunc = resolve;
     });
     function setToken(token) {
+        const hadSocket = socket != null;
         socket?.disconnect?.();
+        for (const key in schema)
+            facade[key]?.dispose?.("token rotated", { socketAlive: false });
+        if (hadSocket)
+            onDisconnectCb?.("token rotated");
+        if (!resolveFunc)
+            promise = new Promise((resolve) => { resolveFunc = resolve; });
+        currentToken = token;
         socket = createSocket(token);
         for (const key in schema) {
             const targetSocketKey = schema[key].socketKey || key;
-            const client = (0, rpc_client_1.createRpcClient)({ socketKey: targetSocketKey, socket });
+            const client = (0, rpc_client_1.createRpcClient)({ socketKey: targetSocketKey, socket, token, opt: hubOpts?.opt });
             facade[key] = client;
         }
         function hi() {
@@ -44,12 +54,25 @@ function createRpcClientHub(createSocket, schemaBuilder) {
         });
         return promise;
     }
+    function reauth(token) {
+        currentToken = token;
+        const ps = [];
+        for (const key in schema) {
+            const client = facade[key];
+            if (client && typeof client.reauth === "function")
+                ps.push(client.reauth(token));
+        }
+        return Promise.all(ps);
+    }
     const result = {
         get promise() { return promise; },
         facade,
         setToken,
+        connect: setToken,
+        reauth,
         get socket() { return socket; },
         onConnect: (func) => { onConnectCb = func ?? null; },
+        onDisconnect: (func) => { onDisconnectCb = func ?? null; },
         connectCount: () => connectCount,
     };
     return result;

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

@@ -1,7 +1,9 @@
 export * from "./listen-socket";
+export * from "./rpc-off";
 export * from "./listen-deep";
 export * from "./rpc-dynamic";
 export * from "./rpc-protocol";
+export * from "./rpc-caps";
 export * from "./rpc-limits";
 export * from "./rpc-walk";
 export * from "./rpc-client";
@@ -10,3 +12,4 @@ export * from "./rpc-client-auto";
 export * from "./rpc-server-auto";
 export * from "./rpc-clientHub";
 export { createRpcServerAuto2 } from "./createRpcServerAutoWithProtocolDetection";
+export * from "./rpc-inproc";

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

@@ -16,9 +16,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRpcServerAuto2 = void 0;
 __exportStar(require("./listen-socket"), exports);
+__exportStar(require("./rpc-off"), exports);
 __exportStar(require("./listen-deep"), exports);
 __exportStar(require("./rpc-dynamic"), exports);
 __exportStar(require("./rpc-protocol"), exports);
+__exportStar(require("./rpc-caps"), exports);
 __exportStar(require("./rpc-limits"), exports);
 __exportStar(require("./rpc-walk"), exports);
 __exportStar(require("./rpc-client"), exports);
@@ -28,3 +30,4 @@ __exportStar(require("./rpc-server-auto"), exports);
 __exportStar(require("./rpc-clientHub"), exports);
 var createRpcServerAutoWithProtocolDetection_1 = require("./createRpcServerAutoWithProtocolDetection");
 Object.defineProperty(exports, "createRpcServerAuto2", { enumerable: true, get: function () { return createRpcServerAutoWithProtocolDetection_1.createRpcServerAuto2; } });
+__exportStar(require("./rpc-inproc"), exports);

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

@@ -0,0 +1,17 @@
+import { type RpcLimits, type RpcServerAuth, type RpcOpt } from './rpc-server';
+import type { SocketTmpl } from './rpc-protocol';
+import type { DeepSocketListen } from './listen-deep';
+export declare function createInProcSocketPair(): [SocketTmpl, SocketTmpl];
+export declare function createRpcInProc<T extends object>({ object: target, socketKey, listen, debug, hooks, limits, auth, token, throttle, maxPerListen, opt, }: {
+    object: T;
+    socketKey?: string;
+    listen?: boolean;
+    debug?: boolean;
+    hooks?: any;
+    limits?: RpcLimits;
+    auth?: RpcServerAuth;
+    token?: any;
+    throttle?: number;
+    maxPerListen?: number;
+    opt?: RpcOpt;
+}): import("./rpc-client").RpcClientReturn<DeepSocketListen<T>>;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInProcSocketPair = createInProcSocketPair;
+exports.createRpcInProc = createRpcInProc;
+const rpc_server_1 = require("./rpc-server");
+const rpc_server_auto_1 = require("./rpc-server-auto");
+const rpc_client_1 = require("./rpc-client");
+function createInProcSocketPair() {
+    const A = {};
+    const B = {};
+    const make = (mine, theirs) => ({
+        on: (e, cb) => { (mine[e] ??= []).push(cb); },
+        emit: (e, d) => {
+            const wire = d === undefined ? undefined : JSON.parse(JSON.stringify(d));
+            for (const cb of (theirs[e] ?? []))
+                queueMicrotask(() => cb(wire));
+        },
+    });
+    return [make(A, B), make(B, A)];
+}
+function createRpcInProc({ object: target, socketKey = 'rpc', listen = true, debug, hooks, limits, auth, token, throttle, maxPerListen, opt, }) {
+    const [clientSocket, serverSocket] = createInProcSocketPair();
+    if (listen) {
+        (0, rpc_server_auto_1.createRpcServerAuto)({ socket: serverSocket, object: target, socketKey, debug, hooks, limits, auth, throttle, maxPerListen, opt });
+    }
+    else {
+        (0, rpc_server_1.createRpcServer)({ socket: serverSocket, object: target, socketKey, debug, hooks: hooks, limits, auth, opt });
+    }
+    return (0, rpc_client_1.createRpcClient)({ socket: clientSocket, socketKey, limits, token, opt });
+}

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

@@ -0,0 +1,10 @@
+import { rpcEndCallback } from "./rpc-walk";
+export declare const endCallback: typeof rpcEndCallback;
+type tThenable<V> = {
+    then: Promise<V>['then'];
+    catch: Promise<V>['catch'];
+    finally: Promise<V>['finally'];
+};
+export type Off<V = void, X extends object = {}> = (() => void) & tThenable<V> & X;
+export declare function makeOff<V, X extends object = {}>(promise: Promise<V>, stop: () => void, extra?: X): Off<V, X>;
+export {};