wenay-common2 1.0.46 → 1.0.49

package/lib/Common/node_console.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.callerLines = exports.callerLine = void 0;
 exports.enable = enable;
 exports.disable = disable;
 exports.__LineFile = __LineFile;
@@ -9,78 +10,6 @@ const { self, window } = globalThis;
 let _enabled = false;
 function enable(flag = true) { _enabled = flag; }
 function disable() { _enabled = false; }
-let wrapCallSite;
-function setupLogs2() {
-    if (typeof self != 'object' && typeof window != "object") {
-        function moduleName(name) { return name; }
-        let inspector = require(moduleName('inspector'));
-        if (inspector.url() != undefined)
-            return;
-        try {
-            let module = require(moduleName('source-map-support'));
-            module.install();
-            wrapCallSite = module.wrapCallSite;
-        }
-        catch (e) {
-            console.warn(e);
-            return;
-        }
-        _enabled = true;
-        const origLogMethod = console.log;
-        const origErrorMethod = console.error;
-        let _callee;
-        for (let methodName of [
-            'debug', 'info', 'log', 'warn', 'error', 'group', 'groupCollapsed', 'table', 'timeLog', 'timeEnd',
-            'count', 'assert', 'dir', 'dirxml'
-        ]) {
-            const origMethod = console[methodName];
-            console[methodName] = ((...args) => {
-                if (!_enabled)
-                    return origMethod(...args);
-                const originalPrepareStackTrace = Error.prepareStackTrace;
-                Error.prepareStackTrace = (_, stack) => stack;
-                let callee = new Error().stack[1];
-                Error.prepareStackTrace = originalPrepareStackTrace;
-                if (!callee) {
-                    origErrorMethod("сallee is not found in node_console");
-                    _enabled = false;
-                    return origMethod(...args);
-                }
-                if (!methodName.match(/debug|info|log|warn|error|dirxml/)) {
-                    _callee ??= callee;
-                    return origMethod(...args);
-                }
-                if (_callee) {
-                    callee = _callee;
-                    _callee = undefined;
-                }
-                if (wrapCallSite)
-                    callee = wrapCallSite(callee);
-                const fileName = callee.getFileName();
-                if (fileName?.includes("source-map-support")) {
-                    origMethod(...args);
-                    return;
-                }
-                let fileAndLine = `${fileName}:${callee.getLineNumber()}:${callee.getColumnNumber()}  ` + callee.getFunctionName();
-                fileAndLine = fileAndLine.replaceAll("\\", "/");
-                fileAndLine = fileAndLine.replace("webpack:///", "");
-                fileAndLine = fileAndLine.replace("?", "");
-                if (!fileAndLine.startsWith("./"))
-                    if (!fileAndLine.toLowerCase().startsWith("file:///"))
-                        fileAndLine = "file:///" + fileAndLine;
-                let [firstArg, ...otherArgs] = args;
-                if (1)
-                    origMethod(...args, "", fileAndLine);
-                else if (typeof firstArg === 'string') {
-                    origMethod(fileAndLine + ' ' + firstArg, ...otherArgs);
-                }
-                else {
-                    origMethod(fileAndLine, ...args);
-                }
-            });
-        }
-    }
-}
 function setupLogs() {
     if (typeof self != 'object' && typeof window != "object") {
         function moduleName(name) { return name; }
@@ -153,8 +82,6 @@ function __LineFile2(lvl = 0) {
     const originalPrepareStackTrace = Error.prepareStackTrace;
     Error.prepareStackTrace = (_, stack) => stack;
     let e = new Error().stack[lvl + 1];
-    if (wrapCallSite)
-        e = wrapCallSite(e);
     Error.prepareStackTrace = originalPrepareStackTrace;
     return `${e.getFileName()}:${e.getLineNumber()}:${e.getColumnNumber()}  ` + e.getFunctionName();
 }
@@ -162,9 +89,9 @@ function __LineFiles(lvlStart = 0, lvlEnd = 5) {
     const originalPrepareStackTrace = Error.prepareStackTrace;
     Error.prepareStackTrace = (_, stack) => stack;
     let e = new Error().stack.slice(lvlStart + 1, lvlEnd);
-    if (wrapCallSite)
-        e = e.map(e => wrapCallSite(e));
     const msgs = e.map(e => `${e.getFileName()}:${e.getLineNumber()}:${e.getColumnNumber()}  ` + e.getFunctionName());
     Error.prepareStackTrace = originalPrepareStackTrace;
     return msgs;
 }
+exports.callerLine = __LineFile2;
+exports.callerLines = __LineFiles;

package/lib/Common/rcp/createRpcServerAutoWithProtocolDetection.d.ts

@@ -17,5 +17,7 @@ export declare function createRpcServerAuto2<T extends object>({ socket, object:
     getProtocol: () => ClientProtocol;
     getLegacySchema: () => any;
     getResolved: () => any;
+    dispose: (reason?: string) => void;
+    reset: () => void;
 };
 export {};

package/lib/Common/rcp/createRpcServerAutoWithProtocolDetection.js

@@ -8,42 +8,58 @@ const rpc_protocol_1 = require("./rpc-protocol");
 const old_ommonsServerMini_1 = require("./old\u0421ommonsServerMini");
 const rpc_dynamic_1 = require("./rpc-dynamic");
 const rpc_limits_1 = require("./rpc-limits");
-function createRpcServerAuto({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits }) {
-    const cache = new WeakMap();
-    function getListenSocket(parent, disconnectListen) {
-        let result = cache.get(parent);
-        if (!result) {
-            result = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
-            cache.set(parent, result);
-        }
-        return result;
-    }
-    (0, rpc_server_1.createRpcServer)({
-        socket, object: target, socketKey: key, debug, limits,
-        hooks: {
-            ...hooks,
-            resolveTransform: (obj) => {
-                if (!(0, Listen_1.isListenCallback)(obj))
-                    return obj;
-                return getListenSocket(obj, disconnectListen);
-            },
-        },
-    });
-}
 function createRpcServerAuto2({ socket, object: target, socketKey: key, debug = false, hooks, disconnectListen, limits, onProtocolDetect, }) {
     const cache = new WeakMap();
+    const listenSockets = new Set();
+    function unsubscribeAllActive() {
+        for (const w of [...listenSockets])
+            w.removeCallback();
+    }
     function getListenSocket(parent) {
         let result = cache.get(parent);
+        if (result)
+            listenSockets.add(result);
         if (!result) {
-            result = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
+            const subs = new Map();
+            function subscribe(z) {
+                if (typeof z !== "function")
+                    return Promise.reject(new TypeError("Listen callback expects a function"));
+                subs.get(z)?.removeCallback();
+                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
+                subs.set(z, w);
+                const done = w.callback(z);
+                done.then(() => { if (subs.get(z) == w)
+                    subs.delete(z); });
+                return done;
+            }
+            function subscribeOnce(z) {
+                if (typeof z !== "function")
+                    return Promise.reject(new TypeError("Listen once expects a function"));
+                subs.get(z)?.removeCallback();
+                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
+                subs.set(z, w);
+                const done = w.once(z);
+                done.then(() => { if (subs.get(z) == w)
+                    subs.delete(z); });
+                return done;
+            }
+            function unsubscribeAll() {
+                subs.forEach(w => w.removeCallback());
+                subs.clear();
+                return true;
+            }
+            result = { callback: subscribe, removeCallback: unsubscribeAll, on: subscribe, once: subscribeOnce, close: () => parent.close?.() };
+            listenSockets.add(result);
             cache.set(parent, result);
         }
         return result;
     }
     function resolveTransform(obj) {
-        if (!(0, Listen_1.isListenCallback)(obj))
-            return obj;
-        return getListenSocket(obj);
+        if ((0, Listen_1.isListenCallback)(obj))
+            return getListenSocket(obj);
+        if ((0, Listen_1.isListenOn)(obj))
+            return getListenSocket((0, Listen_1.getListenByOn)(obj));
+        return obj;
     }
     function transformTree(obj) {
         let current = obj;
@@ -61,7 +77,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
                 out[k] = v;
                 continue;
             }
-            out[k] = typeof v === 'function' ? v : (v != null && typeof v === 'object') ? transformTree(v) : v;
+            out[k] = typeof v === 'function' ? resolveTransform(v) : (v != null && typeof v === 'object') ? transformTree(v) : v;
         }
         return out;
     }
@@ -96,6 +112,8 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
     let protocol = null;
     let v2Handler = null;
     let legacyHandler = null;
+    let disposed = false;
+    let activeHandler = null;
     function isLegacyStrictRequest(msg) {
         return msg === '___STRICTLY';
     }
@@ -108,7 +126,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
     function isV2Message(msg) {
         if (msg === rpc_protocol_1.Pkt.STRICT)
             return true;
-        if (Array.isArray(msg) && (msg[0] === rpc_protocol_1.Pkt.CALL || msg[0] === rpc_protocol_1.Pkt.PIPE))
+        if (Array.isArray(msg) && (msg[0] === rpc_protocol_1.Pkt.CALL || msg[0] === rpc_protocol_1.Pkt.PIPE || msg[0] === rpc_protocol_1.Pkt.HELLO))
             return true;
         return false;
     }
@@ -143,6 +161,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
             limits,
             hooks: {
                 ...hooks,
+                onDispose: () => { unsubscribeAllActive(); hooks?.onDispose?.(); },
                 resolveTransform,
             },
         });
@@ -152,7 +171,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
             onMsgCb(msg);
         };
     }
-    socket.on(key, (msg) => {
+    function handleMessage(msg) {
         if (debug) {
             console.log('[RPC-AUTO2 IN]', typeof msg === 'object' ? JSON.stringify(msg) : msg);
         }
@@ -197,10 +216,24 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
         }
         if (debug)
             console.warn('[RPC-AUTO2] Unknown message format, ignoring:', msg);
-    });
+    }
+    activeHandler = handleMessage;
+    socket.on(key, (msg) => activeHandler?.(msg));
+    function reset() { unsubscribeAllActive(); protocol = null; legacyHandler = null; v2Handler = null; }
+    function dispose(reason) {
+        if (disposed)
+            return;
+        disposed = true;
+        activeHandler = null;
+        reset();
+        if (debug)
+            console.log('[RPC-AUTO2] disposed', reason ?? '');
+    }
     return {
         getProtocol: () => protocol,
         getLegacySchema: () => legacySchema,
         getResolved: () => resolved,
+        dispose,
+        reset,
     };
 }

package/lib/Common/rcp/listen-deep.d.ts

@@ -1,4 +1,12 @@
-import { listenSocket, listenSocketFirst, listenSocketAll, listenSocketSmart } from "./listen-socket";
+import { type ListenOn } from "../events/Listen";
+import { listenSocket, listenSocketFirst, listenSocketAll, listenSocketSmart, type tSubHandle } from "./listen-socket";
+type WithSubHandle<R> = R extends {
+    callback: (...a: infer A) => any;
+} ? Omit<R, 'callback' | 'on' | 'once'> & {
+    callback: (...a: A) => tSubHandle & Promise<void>;
+    on: (...a: A) => tSubHandle & Promise<void>;
+    once: (...a: A) => tSubHandle & Promise<void>;
+} : R;
 type Obj = Record<string, any>;
 type InferArgs<T> = T extends {
     addListen: (cb: (...args: infer R) => void, ...rest: any[]) => any;
@@ -6,22 +14,22 @@ type InferArgs<T> = T extends {
 export type DeepSocketListen<T> = {
     [K in keyof T]: T[K] extends {
         addListen: Function;
-    } ? ReturnType<typeof listenSocket<InferArgs<T[K]>>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListen<T[K]> : T[K];
+    } ? WithSubHandle<ReturnType<typeof listenSocket<InferArgs<T[K]>>>> : T[K] extends ListenOn<infer Z> ? WithSubHandle<ReturnType<typeof listenSocket<Z>>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends Promise<any> ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListen<T[K]> : T[K];
 };
 export type DeepSocketListenFirst<T> = {
     [K in keyof T]: T[K] extends {
         addListen: Function;
-    } ? ReturnType<typeof listenSocketFirst<InferArgs<T[K]>>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListenFirst<T[K]> : T[K];
+    } ? ReturnType<typeof listenSocketFirst<InferArgs<T[K]>>> : T[K] extends ListenOn<infer Z> ? ReturnType<typeof listenSocketFirst<Z>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends Promise<any> ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListenFirst<T[K]> : T[K];
 };
 export type DeepSocketListenAll<T> = {
     [K in keyof T]: T[K] extends {
         addListen: Function;
-    } ? ReturnType<typeof listenSocketAll<InferArgs<T[K]>>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListenAll<T[K]> : T[K];
+    } ? ReturnType<typeof listenSocketAll<InferArgs<T[K]>>> : T[K] extends ListenOn<infer Z> ? ReturnType<typeof listenSocketAll<Z>> : T[K] extends (...a: any[]) => any ? T[K] : T[K] extends Promise<any> ? T[K] : T[K] extends typeof Promise ? T[K] : T[K] extends object ? DeepSocketListenAll<T[K]> : T[K];
 };
 export type DeepSocketListenSmart<T> = {
     [K in keyof T]: NonNullable<T[K]> extends {
         addListen: Function;
-    } ? ReturnType<typeof listenSocketSmart<InferArgs<NonNullable<T[K]>>>> | Extract<T[K], undefined | null> : NonNullable<T[K]> extends (...a: any[]) => any ? T[K] : NonNullable<T[K]> extends typeof Promise ? T[K] : NonNullable<T[K]> extends object ? DeepSocketListenSmart<T[K]> : T[K];
+    } ? ReturnType<typeof listenSocketSmart<InferArgs<NonNullable<T[K]>>>> | Extract<T[K], undefined | null> : NonNullable<T[K]> extends ListenOn<infer Z> ? ReturnType<typeof listenSocketSmart<Z>> : NonNullable<T[K]> extends (...a: any[]) => any ? T[K] : NonNullable<T[K]> extends Promise<any> ? T[K] : NonNullable<T[K]> extends typeof Promise ? T[K] : NonNullable<T[K]> extends object ? DeepSocketListenSmart<T[K]> : T[K];
 };
 export declare function matchKeys<T extends Obj, T2 extends Obj>(obj1: T, obj2: T2): boolean;
 export declare function matchKeysList<T extends Obj>(obj1: T, keys: string[]): boolean;

package/lib/Common/rcp/listen-socket.d.ts

@@ -1,25 +1,43 @@
 import { funcListenCallbackBase, type Listener } from "../events/Listen";
+import { type Off } from "./rpc-off";
 type ListenCallbackResult<T extends any[] = any[]> = ReturnType<typeof funcListenCallbackBase<T>>;
+export type tSubHandle = Off<void, {
+    unsubscribe: () => void;
+    removeCallback: () => void;
+}>;
 export declare function listenSocket<Z extends any[] = any[]>(e: ListenCallbackResult<Z>, d?: {
     readonly status?: () => boolean;
     readonly addListenClose?: ListenCallbackResult<any>;
     readonly stop?: (x: Listener<Z>) => any;
     readonly paramsModify?: (...e: Z) => any[];
+    readonly throttle?: number;
 }): {
     callback: (z: Listener<Z>) => Promise<void>;
     removeCallback: () => boolean;
+    on: (z: Listener<Z>) => Promise<void>;
+    once: (z: Listener<Z>) => Promise<void>;
+    close: () => void;
 };
 export declare function listenSocketFirst<Z extends any[] = any[]>(e: ListenCallbackResult<Z>, options?: Omit<Parameters<typeof listenSocket>[1], "paramsModify">): {
-    callback: (z: (a: Z[0]) => void) => void;
+    callback: (z: (a: Z[0]) => void) => tSubHandle;
+    on: (z: (a: Z[0]) => void) => tSubHandle;
+    once: (z: (a: Z[0]) => void) => tSubHandle;
+    close: () => void;
     removeCallback: () => boolean;
 };
 export declare function listenSocketAll<Z extends any[] = any[]>(e: ListenCallbackResult<Z>, options?: Omit<Parameters<typeof listenSocket>[1], "paramsModify">): {
-    callback: (z: (...args: Z) => void) => void;
+    callback: (z: (...args: Z) => void) => tSubHandle;
+    on: (z: (...args: Z) => void) => tSubHandle;
+    once: (z: (...args: Z) => void) => tSubHandle;
+    close: () => void;
     removeCallback: () => boolean;
 };
 type SmartCallback<Z extends any[]> = Z extends [infer Single] ? (a: Single) => void : (...args: Z) => void;
 export declare function listenSocketSmart<Z extends any[] = any[]>(e: ListenCallbackResult<Z>, options?: Omit<Parameters<typeof listenSocket>[1], "paramsModify">): {
-    callback: (z: SmartCallback<Z>) => void;
+    callback: (z: SmartCallback<Z>) => tSubHandle;
+    on: (z: SmartCallback<Z>) => tSubHandle;
+    once: (z: SmartCallback<Z>) => tSubHandle;
+    close: () => void;
     removeCallback: () => boolean;
 };
 export {};

package/lib/Common/rcp/listen-socket.js

@@ -4,12 +4,54 @@ exports.listenSocket = listenSocket;
 exports.listenSocketFirst = listenSocketFirst;
 exports.listenSocketAll = listenSocketAll;
 exports.listenSocketSmart = listenSocketSmart;
+const rpc_protocol_1 = require("./rpc-protocol");
+const rpc_off_1 = require("./rpc-off");
+function createThrottleLatest(ms, sink) {
+    let timer = null;
+    let pending = null;
+    let killed = false;
+    function flush() {
+        timer = null;
+        if (pending) {
+            const a = pending;
+            pending = null;
+            emit(...a);
+        }
+    }
+    function emit(...a) {
+        sink(...a);
+        if (!killed)
+            timer = setTimeout(flush, ms);
+    }
+    function push(...a) {
+        if (killed)
+            return;
+        if (timer) {
+            pending = a;
+            return;
+        }
+        emit(...a);
+    }
+    function cancel() {
+        killed = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        pending = null;
+    }
+    return { push, cancel };
+}
 function listenSocket(e, d) {
-    const { stop, addListenClose, status, paramsModify } = d ?? {};
-    const { addListen, removeListen, eventClose, removeEventClose } = e;
+    const { stop, addListenClose, status, paramsModify, throttle } = d ?? {};
+    const subscribe = (cb, opts) => typeof e.on == "function" ? e.on(cb, opts) : e.addListen(cb, opts);
+    const subscribeClose = addListenClose && ((cb) => typeof addListenClose.on == "function" ? addListenClose.on(cb) : addListenClose.addListen(cb));
     let last = null;
     let active = null;
+    let activeOff = null;
+    let closeSignalOff = null;
     let resolveWait = null;
+    let throttleCh = null;
     function finish() {
         if (resolveWait) {
             resolveWait();
@@ -17,23 +59,41 @@ function listenSocket(e, d) {
         }
     }
     function removeCallback() {
+        if (throttleCh) {
+            throttleCh.cancel();
+            throttleCh = null;
+        }
         if (last) {
             stop?.(last);
             last = null;
         }
-        if (active) {
-            removeListen(active);
+        if (activeOff) {
+            activeOff();
+            activeOff = null;
             active = null;
         }
-        addListenClose?.removeListen(removeCallback);
+        if (closeSignalOff) {
+            closeSignalOff();
+            closeSignalOff = null;
+        }
         finish();
         return true;
     }
-    async function callback(z) {
+    function callback(z) {
+        if (typeof z !== "function") {
+            throw new TypeError("listenSocket.callback expects a function");
+        }
         if (last)
             stop?.(last);
-        if (active)
-            removeListen(active);
+        if (activeOff) {
+            activeOff();
+            activeOff = null;
+            active = null;
+        }
+        if (closeSignalOff) {
+            closeSignalOff();
+            closeSignalOff = null;
+        }
         if (resolveWait) {
             resolveWait();
             resolveWait = null;
@@ -53,31 +113,71 @@ function listenSocket(e, d) {
                     removeCallback();
             };
         }
-        const inner = handler;
+        let inner = handler;
+        if (throttle) {
+            if (throttleCh)
+                throttleCh.cancel();
+            const ch = createThrottleLatest(throttle, (...a) => handler(...a));
+            throttleCh = ch;
+            inner = (...a) => ch.push(...a);
+        }
         active = (...a) => {
-            if (a[0] === "___STOP") {
+            if (a[0] === rpc_protocol_1.RPC_STOP) {
+                if (throttleCh) {
+                    throttleCh.cancel();
+                    throttleCh = null;
+                }
                 z(...a);
                 if (last) {
                     stop?.(last);
                 }
                 last = null;
-                if (active) {
-                    removeListen(active);
+                if (activeOff) {
+                    activeOff();
+                    activeOff = null;
                     active = null;
                 }
-                addListenClose?.removeListen(removeCallback);
+                if (closeSignalOff) {
+                    closeSignalOff();
+                    closeSignalOff = null;
+                }
                 finish();
                 return;
             }
             inner(...a);
         };
-        addListen(active, { cbClose: removeCallback });
-        addListenClose?.addListen(removeCallback);
-        return new Promise((resolve) => {
+        activeOff = subscribe(active, { cbClose: removeCallback });
+        closeSignalOff = subscribeClose?.(removeCallback) ?? null;
+        const wait = new Promise((resolve) => {
             resolveWait = () => { resolve(); };
         });
+        return (0, rpc_off_1.makeOff)(wait, removeCallback, { unsubscribe: removeCallback, removeCallback });
+    }
+    function once(z) {
+        if (typeof z !== "function") {
+            throw new TypeError("listenSocket.once expects a function");
+        }
+        let fired = false;
+        const oneShot = ((...a) => {
+            if (a[0] === rpc_protocol_1.RPC_STOP) {
+                removeCallback();
+                return;
+            }
+            if (fired)
+                return;
+            fired = true;
+            try {
+                z(...a);
+            }
+            finally {
+                (0, rpc_off_1.endCallback)(z);
+                removeCallback();
+            }
+        });
+        return callback(oneShot);
     }
-    return { callback, removeCallback };
+    function closeStream() { e.close?.(); }
+    return { callback, removeCallback, on: callback, once, close: closeStream };
 }
 function listenSocketFirst(e, options) {
     const r = listenSocket(e, {
@@ -86,6 +186,9 @@ function listenSocketFirst(e, options) {
     });
     return {
         callback: r.callback,
+        on: r.callback,
+        once: r.once,
+        close: r.close,
         removeCallback: r.removeCallback,
     };
 }
@@ -93,6 +196,9 @@ function listenSocketAll(e, options) {
     const r = listenSocket(e, { ...options });
     return {
         callback: r.callback,
+        on: r.callback,
+        once: r.once,
+        close: r.close,
         removeCallback: r.removeCallback,
     };
 }
@@ -100,6 +206,9 @@ function listenSocketSmart(e, options) {
     const r = listenSocket(e, { ...options });
     return {
         callback: r.callback,
+        on: r.callback,
+        once: r.once,
+        close: r.close,
         removeCallback: r.removeCallback,
     };
 }

package/lib/Common/rcp/oldCommonsServer.d.ts

@@ -101,7 +101,7 @@ export declare function CreatAPIFacadeClientOld<T extends object>({ socketKey, s
     infoStrictly(): any;
     strictlyInit(obj?: object): Promise<unknown>;
 };
-export declare function CreatAPIFacadeServerOld<T extends object>({ object, socket, socketKey, debug }: {
+export declare function CreatAPIFacadeServerOld<T extends object>(params: {
     socket: tSocket;
     object: T;
     socketKey: string;

package/lib/Common/rcp/oldCommonsServer.js

@@ -9,7 +9,11 @@ exports.CreatAPIFacadeClientOld = CreatAPIFacadeClientOld;
 exports.CreatAPIFacadeServerOld = CreatAPIFacadeServerOld;
 exports.fMiniTest = fMiniTest;
 const common_1 = require("../core/common");
+const old_ommonsServerMini_1 = require("./old\u0421ommonsServerMini");
 function funcPromiseServer(data, obj) {
+    return (0, old_ommonsServerMini_1.promiseServer)(data, obj);
+}
+function funcPromiseServerOld(data, obj) {
     const buf = data;
     data.api({
         onMessage: async (datum) => {
@@ -86,6 +90,9 @@ function funcPromiseServer2(sendMessage, obj) {
     };
 }
 function funcForWebSocket(data) {
+    return (0, old_ommonsServerMini_1.wsWrapper)(data);
+}
+function funcForWebSocketOld(data) {
     const limit = data.limit;
     const sendMessage = data.sendMessage;
     const free = (() => {
@@ -122,6 +129,7 @@ function funcForWebSocket(data) {
                 if (data.data == "___STOP") {
                     callbackMany.delete(mapId);
                     free.numsSet(mapId);
+                    return;
                 }
                 buf?.(data.data);
             }
@@ -188,6 +196,9 @@ function funcForWebSocket(data) {
     };
 }
 function funcScreenerClient2(data, wait) {
+    return (0, old_ommonsServerMini_1.createClientProxy)(data, wait);
+}
+function funcScreenerClient2Old(data, wait) {
     const tr = (address) => new Proxy((() => { }), {
         get(target, p, receiver) {
             address.push(p);
@@ -328,7 +339,10 @@ function CreatAPIFacadeClientOld({ socketKey, socket, limit }) {
         }
     };
 }
-function CreatAPIFacadeServerOld({ object, socket, socketKey, debug = false }) {
+function CreatAPIFacadeServerOld(params) {
+    return (0, old_ommonsServerMini_1.createAPIFacadeServer)(params);
+}
+function CreatAPIFacadeServerOldImpl({ object, socket, socketKey, debug = false }) {
     function ff(obj) {
         return Object.fromEntries(Object.entries(obj).map(([k, v]) => {
             return [

package/lib/Common/rcp/old/320/241ommonsServerMini.js

@@ -150,6 +150,7 @@ function wsWrapper(soc) {
                 if (msg.data === "___STOP") {
                     cbsMap.delete(id);
                     pool.release(id);
+                    return;
                 }
                 cb(msg.data);
             }

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

@@ -0,0 +1,10 @@
+export declare const Caps: {
+    readonly COMPACT: number;
+};
+export type tCaps = number;
+export declare const CAPS_ALL: tCaps;
+export declare const hasCap: (caps: tCaps, c: number) => boolean;
+export type RpcOpt = {
+    compact?: boolean;
+};
+export declare function optToCaps(opt?: RpcOpt): tCaps;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasCap = exports.CAPS_ALL = exports.Caps = void 0;
+exports.optToCaps = optToCaps;
+exports.Caps = {
+    COMPACT: 1 << 0,
+};
+exports.CAPS_ALL = exports.Caps.COMPACT;
+const hasCap = (caps, c) => (caps & c) === c;
+exports.hasCap = hasCap;
+function optToCaps(opt) {
+    let c = exports.CAPS_ALL;
+    if (opt?.compact === false)
+        c &= ~exports.Caps.COMPACT;
+    return c;
+}