wenay-common2 1.0.46 → 1.0.49

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endCallback = void 0;
+exports.makeOff = makeOff;
+const rpc_walk_1 = require("./rpc-walk");
+exports.endCallback = rpc_walk_1.rpcEndCallback;
+function makeOff(promise, stop, extra) {
+    let done = false;
+    function off() {
+        if (done)
+            return;
+        done = true;
+        stop();
+    }
+    const handle = off;
+    handle.then = promise.then.bind(promise);
+    handle.catch = promise.catch.bind(promise);
+    handle.finally = promise.finally.bind(promise);
+    if (extra)
+        Object.assign(handle, extra);
+    return handle;
+}

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

@@ -6,7 +6,13 @@ export declare const Pkt: {
     readonly STRICT: 4;
     readonly CB_END: 5;
     readonly PIPE: 6;
+    readonly HELLO: 7;
+    readonly SHAPE: 8;
+    readonly CBV: 9;
+    readonly CAPS: 10;
 };
+export declare const RPC_STOP = "___STOP";
+export declare const IS_RPC_LISTEN: unique symbol;
 export type SocketTmpl = {
     emit: (e: string, d: any) => void;
     on: (e: string, cb: (d: any) => void) => void;

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

@@ -1,4 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pkt = void 0;
-exports.Pkt = { CALL: 0, RESP: 1, CB: 2, MAP: 3, STRICT: 4, CB_END: 5, PIPE: 6 };
+exports.IS_RPC_LISTEN = exports.RPC_STOP = exports.Pkt = void 0;
+exports.Pkt = { CALL: 0, RESP: 1, CB: 2, MAP: 3, STRICT: 4, CB_END: 5, PIPE: 6, HELLO: 7, SHAPE: 8, CBV: 9, CAPS: 10 };
+exports.RPC_STOP = "___STOP";
+exports.IS_RPC_LISTEN = Symbol.for("isRpcListen");

package/lib/Common/rcp/rpc-server-auto.d.ts

@@ -1,9 +1,9 @@
 import { funcListenCallbackBase } from "../events/Listen";
-import { type PromiseServerHooks, type RpcLimits } from "./rpc-server";
+import { type PromiseServerHooks, type RpcLimits, type RpcServerAuth, type RpcOpt } from "./rpc-server";
 import { DeepSocketListen } from "./listen-deep";
 import { SocketTmpl } from "./rpc-protocol";
 type ListenCallbackBase<T extends any[] = any[]> = ReturnType<typeof funcListenCallbackBase<T>>;
-export declare function createRpcServerAuto<T extends object>({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits }: {
+export declare function createRpcServerAuto<T extends object>({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits, auth, maxPerListen, throttle, opt }: {
     socket: SocketTmpl;
     object: T;
     socketKey: string;
@@ -11,5 +11,16 @@ export declare function createRpcServerAuto<T extends object>({ socket, object:
     hooks?: Omit<PromiseServerHooks<DeepSocketListen<T>>, "resolveTransform">;
     disconnectListen?: ListenCallbackBase<any>;
     limits?: RpcLimits;
-}): void;
+    auth?: RpcServerAuth;
+    maxPerListen?: number;
+    throttle?: number;
+    opt?: RpcOpt;
+}): {
+    api: {
+        subscriptions: () => {
+            key: string;
+            consumers: number;
+        }[];
+    };
+};
 export {};

package/lib/Common/rcp/rpc-server-auto.js

@@ -4,25 +4,100 @@ exports.createRpcServerAuto = createRpcServerAuto;
 const Listen_1 = require("../events/Listen");
 const listen_socket_1 = require("./listen-socket");
 const rpc_server_1 = require("./rpc-server");
-function createRpcServerAuto({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits }) {
+const rpc_protocol_1 = require("./rpc-protocol");
+function createRpcServerAuto({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits, auth, maxPerListen, throttle, opt }) {
     const cache = new WeakMap();
+    const registry = new Map();
+    function unsubscribeAllActive() {
+        for (const { subs } of registry.values()) {
+            subs.forEach(w => w.removeCallback());
+            subs.clear();
+        }
+        registry.clear();
+    }
     function getListenSocket(parent, disconnectListen) {
         let result = cache.get(parent);
         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"));
+                if (maxPerListen != null && subs.size >= maxPerListen)
+                    return Promise.resolve();
+                if (!registry.has(parent))
+                    registry.set(parent, { subs });
+                subs.get(z)?.removeCallback();
+                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen, throttle });
+                subs.set(z, w);
+                const done = w.callback(z);
+                done.then(() => {
+                    if (subs.get(z) == w)
+                        subs.delete(z);
+                    if (subs.size == 0)
+                        registry.delete(parent);
+                });
+                return done;
+            }
+            function subscribeOnce(z) {
+                if (typeof z !== "function")
+                    return Promise.reject(new TypeError("Listen once expects a function"));
+                if (maxPerListen != null && subs.size >= maxPerListen)
+                    return Promise.resolve();
+                if (!registry.has(parent))
+                    registry.set(parent, { subs });
+                subs.get(z)?.removeCallback();
+                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen, throttle });
+                let fired = false;
+                const oneShot = (...a) => {
+                    if (fired)
+                        return;
+                    fired = true;
+                    try {
+                        z(...a);
+                        z(rpc_protocol_1.RPC_STOP);
+                    }
+                    finally {
+                        w.removeCallback();
+                    }
+                };
+                subs.set(z, w);
+                const done = w.callback(oneShot);
+                done.then(() => { if (subs.get(z) == w)
+                    subs.delete(z); if (subs.size == 0)
+                    registry.delete(parent); });
+                return done;
+            }
+            function unsubscribeAll() {
+                subs.forEach(w => w.removeCallback());
+                subs.clear();
+                registry.delete(parent);
+                return true;
+            }
+            result = { callback: subscribe, removeCallback: unsubscribeAll, on: subscribe, once: subscribeOnce, close: () => parent.close?.() };
+            result[rpc_protocol_1.IS_RPC_LISTEN] = true;
             cache.set(parent, result);
         }
         return result;
     }
+    const api = {
+        subscriptions: () => Array.from(registry, ([parent, e], i) => ({
+            key: parent?.constructor?.name ? `${parent.constructor.name}#${i}` : `listen#${i}`,
+            consumers: e.subs.size,
+        })),
+    };
     (0, rpc_server_1.createRpcServer)({
-        socket, object: target, socketKey: key, debug, limits,
+        socket, object: target, socketKey: key, debug, limits, auth, opt,
         hooks: {
             ...hooks,
+            onDispose: () => { unsubscribeAllActive(); hooks?.onDispose?.(); },
             resolveTransform: (obj) => {
-                if (!(0, Listen_1.isListenCallback)(obj))
-                    return obj;
-                return getListenSocket(obj, disconnectListen);
+                if ((0, Listen_1.isListenCallback)(obj))
+                    return getListenSocket(obj, disconnectListen);
+                if ((0, Listen_1.isListenOn)(obj))
+                    return getListenSocket((0, Listen_1.getListenByOn)(obj), disconnectListen);
+                return obj;
             },
         },
     });
+    return { api };
 }

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

@@ -1,5 +1,6 @@
 import { type RpcLimits } from "./rpc-limits";
 import { type SocketTmpl } from "./rpc-protocol";
+import { type RpcOpt } from "./rpc-caps";
 type Func = (...args: any[]) => any;
 type PromiseServerHooks<T> = {
     onRequest?: (ctx: {
@@ -15,13 +16,27 @@ type PromiseServerHooks<T> = {
         error?: any;
     }) => void | Promise<void>;
     resolveTransform?: (value: any) => any;
+    onDispose?: () => void;
 };
-export declare function createRpcServer<T extends object>({ socket, object: target, socketKey: key, debug, hooks, limits }: {
+type RpcServerAuth = {
+    resolveAuth: (token: any) => {
+        object?: any;
+        ack?: any;
+    } | Promise<{
+        object?: any;
+        ack?: any;
+    }>;
+    gate?: boolean;
+};
+export declare function createRpcServer<T extends object>({ socket, object: target, socketKey: key, debug, hooks, limits, auth, opt }: {
     socket: SocketTmpl;
     object: T;
     socketKey: string;
     debug?: boolean;
     hooks?: PromiseServerHooks<T>;
     limits?: RpcLimits;
+    auth?: RpcServerAuth;
+    opt?: RpcOpt;
 }): void;
-export type { PromiseServerHooks, RpcLimits };
+export type { PromiseServerHooks, RpcLimits, RpcServerAuth };
+export type { RpcOpt } from "./rpc-caps";

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

@@ -4,12 +4,14 @@ exports.createRpcServer = createRpcServer;
 const rpc_dynamic_1 = require("./rpc-dynamic");
 const rpc_limits_1 = require("./rpc-limits");
 const rpc_walk_1 = require("./rpc-walk");
+const rpc_shape_1 = require("./rpc-shape");
 const rpc_protocol_1 = require("./rpc-protocol");
-function createServer(socket, key, target, hooks, limits) {
+const rpc_caps_1 = require("./rpc-caps");
+const myThrow_1 = require("../../toError/myThrow");
+const SERVERS = new WeakMap();
+function createServer(socket, key, target, hooks, limits, auth, opt) {
     const lim = (0, rpc_limits_1.resolveLimits)(limits);
-    const methods = [];
-    const contexts = [];
-    const routeMap = {};
+    const IS_RPC_PIPE = Symbol.for("isRpcPipe");
     function transformTree(obj) {
         let current = obj;
         if (hooks?.resolveTransform && !(0, rpc_dynamic_1.isNoStrict)(current)) {
@@ -18,6 +20,8 @@ function createServer(socket, key, target, hooks, limits) {
         if (current == null || typeof current != "object" || (0, rpc_dynamic_1.isNoStrict)(current))
             return current;
         const out = {};
+        if (current[rpc_protocol_1.IS_RPC_LISTEN])
+            out[rpc_protocol_1.IS_RPC_LISTEN] = true;
         for (const k of Object.keys(current)) {
             if (!(0, rpc_limits_1.isSafeKey)(k))
                 continue;
@@ -26,27 +30,11 @@ function createServer(socket, key, target, hooks, limits) {
                 out[k] = v;
                 continue;
             }
-            out[k] = typeof v == "function" ? v : v != null && typeof v == "object" ? transformTree(v) : v;
+            out[k] = typeof v == "function" ? (hooks?.resolveTransform ? hooks.resolveTransform(v) : v)
+                : v != null && typeof v == "object" ? transformTree(v) : v;
         }
         return out;
     }
-    const resolved = transformTree(target);
-    function index(obj, prefix) {
-        for (const k of Object.keys(obj)) {
-            if (!(0, rpc_limits_1.isSafeKey)(k))
-                continue;
-            const v = obj[k];
-            const path = prefix ? prefix + "." + k : k;
-            if (typeof v == "function") {
-                routeMap[path] = methods.length;
-                methods.push(v);
-                contexts.push(obj);
-            }
-            else if (v && typeof v == "object" && !(0, rpc_dynamic_1.isNoStrict)(v))
-                index(v, path);
-        }
-    }
-    index(resolved, "");
     function serialize(obj) {
         const out = {};
         for (const k of Object.keys(obj)) {
@@ -73,13 +61,110 @@ function createServer(socket, key, target, hooks, limits) {
         }
         return out;
     }
-    const strictSchema = serialize(resolved);
+    let methods = [];
+    let contexts = [];
+    let routeMap = {};
+    let listenPaths = [];
+    let strictSchema = {};
+    let currentTarget = target;
+    function buildDispatch(t) {
+        const m = [], cx = [], rm = {}, lp = [];
+        const resolved = transformTree(t);
+        (function index(obj, prefix) {
+            for (const k of Object.keys(obj)) {
+                if (!(0, rpc_limits_1.isSafeKey)(k))
+                    continue;
+                const v = obj[k];
+                const path = prefix ? prefix + "." + k : k;
+                if (typeof v == "function") {
+                    rm[path] = m.length;
+                    m.push(v);
+                    cx.push(obj);
+                }
+                else if (v && typeof v == "object" && !(0, rpc_dynamic_1.isNoStrict)(v)) {
+                    if (v[rpc_protocol_1.IS_RPC_LISTEN])
+                        lp.push(path);
+                    index(v, path);
+                }
+            }
+        })(resolved, "");
+        methods = m;
+        contexts = cx;
+        routeMap = rm;
+        listenPaths = lp;
+        strictSchema = serialize(resolved);
+        currentTarget = t;
+    }
+    buildDispatch(target);
     const send = (d) => socket.emit(key, d);
-    const IS_RPC_PIPE = Symbol.for("isRpcPipe");
-    send([rpc_protocol_1.Pkt.MAP, routeMap, strictSchema]);
+    const serverCaps = (0, rpc_caps_1.optToCaps)(opt);
+    let peerCaps = 0;
+    const compactOn = () => (0, rpc_caps_1.hasCap)(serverCaps & peerCaps, rpc_caps_1.Caps.COMPACT);
+    const cbShapes = (0, rpc_shape_1.createCbShapeServer)();
+    const sendCb = (cbId, cbArgs) => {
+        if (compactOn() && cbArgs.length == 1 && (0, rpc_shape_1.isPlainObject)(cbArgs[0])) {
+            const obj = cbArgs[0];
+            const r = cbShapes.offer(cbId, obj);
+            if (r.mode == "register") {
+                send([rpc_protocol_1.Pkt.SHAPE, cbId, r.shapeId, r.keys]);
+                send([rpc_protocol_1.Pkt.CBV, cbId, r.shapeId, r.keys.map(k => (0, rpc_walk_1.packResult)(obj[k]))]);
+                return;
+            }
+            if (r.mode == "compact") {
+                send([rpc_protocol_1.Pkt.CBV, cbId, r.shapeId, r.keys.map(k => (0, rpc_walk_1.packResult)(obj[k]))]);
+                return;
+            }
+        }
+        send([rpc_protocol_1.Pkt.CB, cbId, cbArgs.map(rpc_walk_1.packResult)]);
+    };
+    const sendCbEnd = (cbId) => { cbShapes.drop(cbId); send([rpc_protocol_1.Pkt.CB_END, cbId]); };
+    let authed = !auth?.gate;
+    let authAck = undefined;
+    const sendMap = () => send(authAck !== undefined
+        ? [rpc_protocol_1.Pkt.MAP, routeMap, strictSchema, listenPaths, authAck]
+        : [rpc_protocol_1.Pkt.MAP, routeMap, strictSchema, listenPaths]);
+    sendMap();
+    if (serverCaps)
+        send([rpc_protocol_1.Pkt.CAPS, serverCaps]);
+    let detached = false;
+    let byKey = SERVERS.get(socket);
+    if (!byKey) {
+        byKey = new Map();
+        SERVERS.set(socket, byKey);
+    }
+    const detachPrev = byKey.get(key);
+    if (detachPrev) {
+        detachPrev();
+        console.warn(`[RPC] createRpcServer: повторная инициализация на socket+key "${key}" — предыдущий сервер отцеплен`);
+    }
+    byKey.set(key, () => { detached = true; hooks?.onDispose?.(); });
     socket.on(key, async (msg) => {
+        if (detached)
+            return;
         if (msg == rpc_protocol_1.Pkt.STRICT) {
-            send([rpc_protocol_1.Pkt.MAP, routeMap, strictSchema]);
+            sendMap();
+            return;
+        }
+        if (Array.isArray(msg) && msg[0] === rpc_protocol_1.Pkt.CAPS) {
+            peerCaps = typeof msg[1] === "number" ? msg[1] : rpc_caps_1.Caps.COMPACT;
+            return;
+        }
+        if (Array.isArray(msg) && msg[0] === rpc_protocol_1.Pkt.HELLO) {
+            if (!auth?.resolveAuth) {
+                send([rpc_protocol_1.Pkt.MAP, routeMap, strictSchema, listenPaths, null]);
+                return;
+            }
+            try {
+                const r = await auth.resolveAuth(msg[1]);
+                if (r && r.object !== undefined)
+                    buildDispatch(r.object);
+                authAck = r && r.ack !== undefined ? r.ack : { ok: true };
+                authed = authAck?.ok !== false;
+                sendMap();
+            }
+            catch (e) {
+                send([rpc_protocol_1.Pkt.MAP, routeMap, strictSchema, listenPaths, { ok: false, reason: e?.message ?? String(e) }]);
+            }
             return;
         }
         if (!Array.isArray(msg) || (msg[0] !== rpc_protocol_1.Pkt.CALL && msg[0] !== rpc_protocol_1.Pkt.PIPE))
@@ -91,6 +176,11 @@ function createServer(socket, key, target, hooks, limits) {
             hooks?.onInvalid?.({ reason: "invalid_payload", key: ref, request: rawArgsOrSteps, error: "reqId is not a valid number" });
             return;
         }
+        if (!authed) {
+            if (wait)
+                send([rpc_protocol_1.Pkt.RESP, reqId, null, (0, rpc_walk_1.errToObj)(new myThrow_1.MyError("Unauthorized", "E_UNAUTHORIZED"))]);
+            return;
+        }
         if (typeof ref !== "number" && !Array.isArray(ref)) {
             hooks?.onInvalid?.({ reason: "invalid_payload", key: ref, request: rawArgsOrSteps, error: "ref must be number or string[]" });
             if (wait)
@@ -116,13 +206,19 @@ function createServer(socket, key, target, hooks, limits) {
                         send([rpc_protocol_1.Pkt.RESP, reqId, null, (0, rpc_walk_1.errToObj)(new Error("Forbidden path segment"))]);
                     return;
                 }
+                if (ref.length > lim.maxPathLen) {
+                    hooks?.onInvalid?.({ reason: "invalid_payload", key: ref, request: rawArgsOrSteps, error: "path too long" });
+                    if (wait)
+                        send([rpc_protocol_1.Pkt.RESP, reqId, null, (0, rpc_walk_1.errToObj)(new rpc_limits_1.PayloadLimitError("path too long"))]);
+                    return;
+                }
                 const idx = routeMap[ref.join(".")];
                 if (idx !== undefined) {
                     fn = methods[idx];
                     ctx = contexts[idx];
                 }
                 else {
-                    let curr = target;
+                    let curr = currentTarget;
                     for (let i = 0; i < ref.length - 1; i++) {
                         const seg = ref[i];
                         if (curr == null || typeof curr !== "object" || !(seg in curr)) {
@@ -178,7 +274,7 @@ function createServer(socket, key, target, hooks, limits) {
                     else if (step.type === 'call') {
                         if (typeof current !== "function")
                             throw new Error("Attempted to call a non-function in pipe");
-                        const stepArgs = (0, rpc_walk_1.unpack)(step.args, (cbId, cbArgs) => send([rpc_protocol_1.Pkt.CB, cbId, cbArgs]), (cbId) => send([rpc_protocol_1.Pkt.CB_END, cbId]), lim);
+                        const stepArgs = (0, rpc_walk_1.unpack)(step.args, sendCb, sendCbEnd, lim);
                         current = current(...stepArgs);
                     }
                 }
@@ -189,7 +285,7 @@ function createServer(socket, key, target, hooks, limits) {
                     send([rpc_protocol_1.Pkt.RESP, reqId, (0, rpc_walk_1.packResult)(current)]);
             }
             else {
-                const args = (0, rpc_walk_1.unpack)(rawArgsOrSteps, (cbId, cbArgs) => send([rpc_protocol_1.Pkt.CB, cbId, cbArgs.map(rpc_walk_1.packResult)]), (cbId) => send([rpc_protocol_1.Pkt.CB_END, cbId]), lim);
+                const args = (0, rpc_walk_1.unpack)(rawArgsOrSteps, sendCb, sendCbEnd, lim);
                 const res = await fn.apply(ctx, args);
                 if (wait)
                     send([rpc_protocol_1.Pkt.RESP, reqId, (0, rpc_walk_1.packResult)(res)]);
@@ -201,10 +297,10 @@ function createServer(socket, key, target, hooks, limits) {
         }
     });
 }
-function createRpcServer({ socket, object: target, socketKey: key, debug = false, hooks, limits }) {
+function createRpcServer({ socket, object: target, socketKey: key, debug = false, hooks, limits, auth, opt }) {
     if (debug) {
         const origOn = socket.on.bind(socket);
         socket.on = (e, cb) => origOn(e, (d) => { console.log("[RPC IN]", typeof d == "object" ? JSON.stringify(d) : d); cb(d); });
     }
-    createServer(socket, key, target, hooks, limits);
+    createServer(socket, key, target, hooks, limits, auth, opt);
 }

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

@@ -0,0 +1,17 @@
+export declare function isPlainObject(v: any): boolean;
+export declare function createCbShapeServer(threshold?: number, maxShapes?: number): {
+    offer: (cbId: number, obj: any) => {
+        mode: "compact";
+        shapeId: number;
+        keys: string[];
+    } | {
+        mode: "register";
+        shapeId: number;
+        keys: string[];
+    } | {
+        mode: "full";
+        shapeId?: undefined;
+        keys?: undefined;
+    };
+    drop: (cbId: number) => void;
+};

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = isPlainObject;
+exports.createCbShapeServer = createCbShapeServer;
+const THRESHOLD = 5;
+const MAX_SHAPES = 5;
+function isPlainObject(v) {
+    if (v == null || typeof v != "object")
+        return false;
+    if (Array.isArray(v) || v instanceof Date || v instanceof Map || v instanceof Set || v instanceof RegExp)
+        return false;
+    const p = Object.getPrototypeOf(v);
+    return p == null || p == Object.prototype;
+}
+function createCbShapeServer(threshold = THRESHOLD, maxShapes = MAX_SHAPES) {
+    const byCb = new Map();
+    function offer(cbId, obj) {
+        const keys = Object.keys(obj);
+        const sig = keys.slice().sort().join("\x00");
+        let st = byCb.get(cbId);
+        if (!st) {
+            st = { shapes: [], nextId: 0 };
+            byCb.set(cbId, st);
+        }
+        const sh = st.shapes.find(s => s.sig == sig);
+        if (sh) {
+            sh.count++;
+            if (sh.shapeId >= 0)
+                return { mode: "compact", shapeId: sh.shapeId, keys: sh.keys };
+            if (sh.count >= threshold) {
+                sh.shapeId = st.nextId++;
+                return { mode: "register", shapeId: sh.shapeId, keys: sh.keys };
+            }
+            return { mode: "full" };
+        }
+        if (st.shapes.length < maxShapes)
+            st.shapes.push({ sig, keys, count: 1, shapeId: -1 });
+        return { mode: "full" };
+    }
+    function drop(cbId) { byCb.delete(cbId); }
+    return { offer, drop };
+}

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

@@ -8,6 +8,7 @@ exports.rpcEndCallback = rpcEndCallback;
 exports.unpack = unpack;
 exports.unpackResult = unpackResult;
 const rpc_limits_1 = require("./rpc-limits");
+const rpc_protocol_1 = require("./rpc-protocol");
 const FN_MARKER = "$_f";
 const DATE_MARKER = "$_d";
 const MAP_MARKER = "$_m";
@@ -15,17 +16,19 @@ const SET_MARKER = "$_s";
 const REGEXP_MARKER = "$_r";
 const BIGINT_MARKER = "$_b";
 const ALL_MARKERS = new Set([FN_MARKER, DATE_MARKER, MAP_MARKER, SET_MARKER, REGEXP_MARKER, BIGINT_MARKER]);
+const deepSerialize = (v) => walk(v, serializeLeaf);
+const deepDeserialize = (v, lim) => walk(v, l => deserializeLeaf(l, undefined, lim), lim);
 const DESERIALIZERS = {
     [DATE_MARKER]: (v) => new Date(v),
-    [MAP_MARKER]: (v) => new Map(v),
-    [SET_MARKER]: (v) => new Set(v),
+    [MAP_MARKER]: (v, lim) => new Map(v.map(([k, val]) => [deepDeserialize(k, lim), deepDeserialize(val, lim)])),
+    [SET_MARKER]: (v, lim) => new Set(v.map((x) => deepDeserialize(x, lim))),
     [REGEXP_MARKER]: (v) => new RegExp(v.source, v.flags),
     [BIGINT_MARKER]: (v) => BigInt(v),
 };
 const SERIALIZERS = [
     (v) => v instanceof Date ? [DATE_MARKER, v.valueOf()] : null,
-    (v) => v instanceof Map ? [MAP_MARKER, Array.from(v.entries())] : null,
-    (v) => v instanceof Set ? [SET_MARKER, Array.from(v.values())] : null,
+    (v) => v instanceof Map ? [MAP_MARKER, Array.from(v.entries(), ([k, val]) => [deepSerialize(k), deepSerialize(val)])] : null,
+    (v) => v instanceof Set ? [SET_MARKER, Array.from(v.values(), (x) => deepSerialize(x))] : null,
     (v) => v instanceof RegExp ? [REGEXP_MARKER, { source: v.source, flags: v.flags }] : null,
     (v) => typeof v === "bigint" ? [BIGINT_MARKER, v.toString()] : null,
 ];
@@ -40,7 +43,8 @@ function walk(val, onLeaf, lim, depth = 0) {
         return onLeaf(val);
     if (val instanceof Date || val instanceof Map || val instanceof Set || val instanceof RegExp)
         return onLeaf(val);
-    if (ALL_MARKERS.has(Object.keys(val)[0]))
+    const ks0 = Object.keys(val);
+    if (ks0.length === 1 && ALL_MARKERS.has(ks0[0]))
         return onLeaf(val);
     if (Array.isArray(val)) {
         if (lim && val.length > lim.maxArrayLen)
@@ -56,7 +60,7 @@ function walk(val, onLeaf, lim, depth = 0) {
             o[k] = walk(val[k], onLeaf, lim, depth + 1);
     return o;
 }
-function deserializeLeaf(leaf, onCallback) {
+function deserializeLeaf(leaf, onCallback, lim) {
     if (leaf == null || typeof leaf !== "object")
         return leaf;
     const key = Object.keys(leaf)[0];
@@ -66,7 +70,7 @@ function deserializeLeaf(leaf, onCallback) {
         return onCallback?.(leaf[FN_MARKER]) ?? leaf;
     }
     const deserialize = DESERIALIZERS[key];
-    return deserialize ? deserialize(leaf[key]) : leaf;
+    return deserialize ? deserialize(leaf[key], lim) : leaf;
 }
 function serializeLeaf(leaf) {
     for (const serializer of SERIALIZERS) {
@@ -95,6 +99,8 @@ function rpcEndCallback(fn) {
     _stopRegistry.get(fn)?.();
 }
 function unpack(args, sender, onEnd, lim) {
+    if (lim && args.length > lim.maxArgs)
+        throw new rpc_limits_1.PayloadLimitError("too many args");
     let cbCount = 0;
     return args.map(v => walk(v, leaf => {
         if (leaf != null && typeof leaf == "object" && leaf[FN_MARKER] !== undefined) {
@@ -104,7 +110,7 @@ function unpack(args, sender, onEnd, lim) {
             if (typeof id !== "number" || !Number.isFinite(id))
                 throw new rpc_limits_1.PayloadLimitError("invalid callback id");
             const wrapper = (...a) => {
-                if (a[0] == "___STOP") {
+                if (a[0] == rpc_protocol_1.RPC_STOP) {
                     onEnd(id);
                     return;
                 }
@@ -113,13 +119,25 @@ function unpack(args, sender, onEnd, lim) {
             _stopRegistry.set(wrapper, () => onEnd(id));
             return wrapper;
         }
-        return deserializeLeaf(leaf);
+        return deserializeLeaf(leaf, undefined, lim);
     }, lim));
 }
 function unpackResult(value, lim) {
-    return walk(value, leaf => deserializeLeaf(leaf), lim);
+    return walk(value, leaf => deserializeLeaf(leaf, undefined, lim), lim);
 }
-const errToObj = (e) => e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : e;
+const errToObj = (e) => {
+    if (!(e instanceof Error))
+        return e;
+    const o = { name: e.name, message: e.message, stack: e.stack };
+    const { code, data, cause } = e;
+    if (code !== undefined)
+        o.code = code;
+    if (data !== undefined)
+        o.data = packResult(data);
+    if (cause !== undefined)
+        o.cause = (0, exports.errToObj)(cause);
+    return o;
+};
 exports.errToObj = errToObj;
 const resolveCA = (path, args) => {
     const last = path[path.length - 1];

package/lib/Exchange/Bars.d.ts

@@ -131,6 +131,8 @@ export declare abstract class CBarsMutableBase extends CBarsBase {
     updateLast(bar: CBar): void;
     AddTick(tick: ITick): boolean;
     AddTicks(ticks: readonly ITick[]): boolean;
+    addTick(tick: ITick): boolean;
+    addTicks(ticks: readonly ITick[]): boolean;
 }
 export declare class CBarsMutable extends CBarsMutableBase {
     readonly Mutable = true;
@@ -141,6 +143,7 @@ export declare class CBarsMutableExt extends CBarsMutable implements IBarsExt {
 }
 export declare function CreateRandomBars(tf: TF, startTime: const_Date, endTime: const_Date, startPrice?: number, volatility?: number | `${number}%`, ticksize?: number): CBars;
 export declare function CreateRandomBars(tf: TF, startTime: const_Date, barsCount: number, startPrice?: number, volatility?: number | `${number}%`, ticksize?: number): CBars;
+export declare const createRandomBars: typeof CreateRandomBars;
 export type TimeValue<T> = {
     readonly time: const_Date;
     readonly value: T;

package/lib/Exchange/Bars.js

@@ -36,7 +36,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CTimeSeries = exports.CTimeSeriesBase = exports.CBarsMutableExt = exports.CBarsMutable = exports.CBarsMutableBase = exports.CBars = exports.CBarsBase = exports.IBars = exports.CTick = exports.CBar = exports.CBarBase = exports.OHLC = void 0;
+exports.CTimeSeries = exports.CTimeSeriesBase = exports.createRandomBars = exports.CBarsMutableExt = exports.CBarsMutable = exports.CBarsMutableBase = exports.CBars = exports.CBarsBase = exports.IBars = exports.CTick = exports.CBar = exports.CBarBase = exports.OHLC = void 0;
 exports.CreateRandomBars = CreateRandomBars;
 exports.findBarsShallow = findBarsShallow;
 const lib = __importStar(require("../Common/core/common"));
@@ -357,6 +357,8 @@ class CBarsMutableBase extends CBarsBase {
     AddTicks(ticks) { for (let tick of ticks)
         if (!this.AddTick(tick))
             return false; return true; }
+    addTick(tick) { return this.AddTick(tick); }
+    addTicks(ticks) { return this.AddTicks(ticks); }
 }
 exports.CBarsMutableBase = CBarsMutableBase;
 class CBarsMutable extends CBarsMutableBase {
@@ -403,6 +405,7 @@ function CreateRandomBars(tf, startTime, endTimeOrCount, startPrice = 100, volat
     }
     return new CBars(tf, bars);
 }
+exports.createRandomBars = CreateRandomBars;
 class CTimeSeriesBase {
     time(i) { return this.points[i]?.time ?? (() => { throw "Wrong index i=" + i + " of " + this.length; })(); }
     value(i) { return this.points[i]?.value ?? (() => { throw "Wrong index i=" + i + " of " + this.length; })(); }