wenay-common2 1.0.61 → 1.0.63

package/lib/Common/events/replay-listen.d.ts

@@ -1,4 +1,4 @@
-import { Listener, ListenApi, ListenCurrent, ListenCurrentProvider, ListenOnBrand, ListenOptions, NormalizeTuple } from './Listen3';
+import { Listener, ListenApi, ListenCurrent, ListenCurrentProvider, ListenOnBrand, ListenOptions, NormalizeTuple } from './Listen';
 type key = string | symbol;
 type cbClose = () => void;
 export declare const IS_REPLAY_LISTEN: unique symbol;
@@ -32,99 +32,53 @@ type ReplayOnOptions<Z extends any[]> = {
 };
 export type ListenOnReplay<Z extends any[] = any[]> = ((cb: Listener<Z>, opts?: ReplayOnOptions<Z>) => (() => void)) & ListenOnBrand<Z>;
 export declare function withReplayListen<T>(base: ListenApi<T>, options?: ReplayListenOptions<NormalizeTuple<T>>): {
-    func: Listener<NormalizeTuple<T>>;
+    emit: Listener<NormalizeTuple<T>>;
     head: () => number;
     isStale: () => boolean;
     lastTs: () => number;
     close: () => void;
     getSince: (seq: number) => ReplayEvent<NormalizeTuple<T>>[] | undefined;
-    line: {
-        func: Listener<[ReplayEvent<NormalizeTuple<T>>]>;
-        isRun: () => boolean;
-        run: () => void;
-        close: () => void;
-        eventClose: (cb: () => void) => () => void;
-        onClose: (cb: () => void) => () => void;
-        removeEventClose: (cb: () => void) => void;
-        on: import("./Listen3").ListenOn<[ReplayEvent<NormalizeTuple<T>>]>;
-        off: (k: (string | symbol) | Listener<[ReplayEvent<NormalizeTuple<T>>]> | null) => void;
-        addListen: (cb: Listener<[ReplayEvent<NormalizeTuple<T>>]>, opts?: {
-            cbClose?: () => void;
-            key?: string | symbol;
-        }) => () => void;
-        removeListen: (k: (string | symbol) | Listener<[ReplayEvent<NormalizeTuple<T>>]> | null) => void;
-        once: (cb: Listener<[ReplayEvent<NormalizeTuple<T>>]>, opts?: {
-            key?: string | symbol;
-        }) => () => void;
-        count: () => number;
-        readonly getAllKeys: (string | symbol)[];
-    };
+    line: ListenApi<[ReplayEvent<NormalizeTuple<T>>]>;
     hasKeyframe: boolean;
     keyframe: () => ReplayEvent<NormalizeTuple<T>> | undefined;
     frame: (sinceSeq: number, hint?: unknown) => ReplayEvent<NormalizeTuple<T>>[];
     on: ListenOnReplay<NormalizeTuple<T>>;
-    addListen: (cb: Listener<NormalizeTuple<T>>, opts?: ReplayOnOptions<NormalizeTuple<T>>) => () => void;
-    removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => void;
     once: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>>;
     }) => () => void;
-    getAllKeys: key[];
-    isRun: () => boolean;
-    run: () => void;
-    eventClose: (cb: () => void) => () => void;
-    onClose: (cb: () => void) => () => void;
-    removeEventClose: (cb: () => void) => void;
-    off: (k: (string | symbol) | Listener<NormalizeTuple<T>> | null) => void;
-    count: () => number;
+    has(key: import("./Listen").ListenKey): boolean;
+    off(keyOrCallback: import("./Listen").ListenKey | Listener<NormalizeTuple<T>> | null): void;
+    count(): number;
+    keys(): import("./Listen").ListenKey[];
+    isRunning(): boolean;
+    run(): void;
+    onClose(cb: () => void): import("./Listen").ListenOff;
 };
 export type ListenReplayApi<T> = ReturnType<typeof withReplayListen<T>>;
 export type ReplayListenUseOptions<T> = ListenOptions<T> & ReplayListenOptions<NormalizeTuple<T>>;
-export declare function UseReplayListen<T>(options?: ReplayListenUseOptions<T>): readonly [(...a: NormalizeTuple<T>) => void, {
-    func: Listener<NormalizeTuple<T>>;
+export declare function replayListen<T>(options?: ReplayListenUseOptions<T>): readonly [(...a: NormalizeTuple<T>) => void, {
+    emit: Listener<NormalizeTuple<T>>;
     head: () => number;
     isStale: () => boolean;
     lastTs: () => number;
     close: () => void;
     getSince: (seq: number) => ReplayEvent<NormalizeTuple<T>>[] | undefined;
-    line: {
-        func: Listener<[ReplayEvent<NormalizeTuple<T>>]>;
-        isRun: () => boolean;
-        run: () => void;
-        close: () => void;
-        eventClose: (cb: () => void) => () => void;
-        onClose: (cb: () => void) => () => void;
-        removeEventClose: (cb: () => void) => void;
-        on: import("./Listen3").ListenOn<[ReplayEvent<NormalizeTuple<T>>]>;
-        off: (k: (string | symbol) | Listener<[ReplayEvent<NormalizeTuple<T>>]> | null) => void;
-        addListen: (cb: Listener<[ReplayEvent<NormalizeTuple<T>>]>, opts?: {
-            cbClose?: () => void;
-            key?: string | symbol;
-        }) => () => void;
-        removeListen: (k: (string | symbol) | Listener<[ReplayEvent<NormalizeTuple<T>>]> | null) => void;
-        once: (cb: Listener<[ReplayEvent<NormalizeTuple<T>>]>, opts?: {
-            key?: string | symbol;
-        }) => () => void;
-        count: () => number;
-        readonly getAllKeys: (string | symbol)[];
-    };
+    line: ListenApi<[ReplayEvent<NormalizeTuple<T>>]>;
     hasKeyframe: boolean;
     keyframe: () => ReplayEvent<NormalizeTuple<T>> | undefined;
     frame: (sinceSeq: number, hint?: unknown) => ReplayEvent<NormalizeTuple<T>>[];
     on: ListenOnReplay<NormalizeTuple<T>>;
-    addListen: (cb: Listener<NormalizeTuple<T>>, opts?: ReplayOnOptions<NormalizeTuple<T>>) => () => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     once: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>> | undefined;
     }) => () => void;
-    getAllKeys: key[];
-    isRun: () => boolean;
-    run: () => void;
-    eventClose: (cb: () => void) => () => void;
-    onClose: (cb: () => void) => () => void;
-    removeEventClose: (cb: () => void) => void;
-    off: (k: (string | symbol) | Listener<NormalizeTuple<T>> | null) => void;
-    count: () => number;
+    has(key: import("./Listen").ListenKey): boolean;
+    off(keyOrCallback: import("./Listen").ListenKey | Listener<NormalizeTuple<T>> | null): void;
+    count(): number;
+    keys(): import("./Listen").ListenKey[];
+    isRunning(): boolean;
+    run(): void;
+    onClose(cb: () => void): import("./Listen").ListenOff;
 }];
 export {};

package/lib/Common/events/replay-listen.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IS_REPLAY_LISTEN = void 0;
 exports.isReplayListen = isReplayListen;
 exports.withReplayListen = withReplayListen;
-exports.UseReplayListen = UseReplayListen;
-const Listen3_1 = require("./Listen3");
+exports.replayListen = replayListen;
+const Listen_1 = require("./Listen");
 exports.IS_REPLAY_LISTEN = Symbol.for('isReplayListen');
 function isReplayListen(obj) {
     return !!obj && typeof obj == 'object' && Object.prototype.hasOwnProperty.call(obj, exports.IS_REPLAY_LISTEN);
@@ -16,7 +16,7 @@ function withReplayListen(base, options = {}) {
     let head = 0;
     const ring = [];
     let emitting = null;
-    const line = (0, Listen3_1.funcListenCallbackBase)(() => { });
+    const line = (0, Listen_1.createListen)(() => { });
     line.run();
     function journalSince(seq) {
         if (getSince)
@@ -78,7 +78,7 @@ function withReplayListen(base, options = {}) {
     }
     const api = {
         ...base,
-        func: function emitJournaled(...e) {
+        emit: function emitJournaled(...e) {
             const ev = { seq: ++head, ts: now(), event: e };
             if (history > 0)
                 ring[(ev.seq - 1) % history] = ev;
@@ -86,11 +86,11 @@ function withReplayListen(base, options = {}) {
                 lastEv = ev;
             onJournal?.(ev);
             touchStale(ev.ts);
-            line.func(ev);
+            line.emit(ev);
             const prev = emitting;
             emitting = ev;
             try {
-                base.func(...e);
+                base.emit(...e);
             }
             finally {
                 emitting = prev;
@@ -165,8 +165,6 @@ function withReplayListen(base, options = {}) {
             replaying = false;
             return off;
         }),
-        addListen: (cb, opts = {}) => api.on(cb, opts),
-        removeListen: (k) => api.off(k),
         once: (cb, opts = {}) => {
             if (opts.current) {
                 const m = currentValue(opts.current);
@@ -179,18 +177,17 @@ function withReplayListen(base, options = {}) {
             off = base.on(((...e) => { off(); cb(...e); }), { key: opts.key });
             return off;
         },
-        get getAllKeys() { return base.getAllKeys; },
     };
     Object.defineProperty(api, exports.IS_REPLAY_LISTEN, { value: true });
-    (0, Listen3_1.registerListenOn)(api.on, api);
+    (0, Listen_1.registerListenOn)(api.on, api);
     return api;
 }
-function UseReplayListen(options = {}) {
+function replayListen(options = {}) {
     const { current, frame, history, getSince, onJournal, now, staleMs, onStale, ...listenOptions } = options;
     let t;
-    const base = (0, Listen3_1.funcListenCallbackBase)((e) => { t = e; }, { fast: true, ...listenOptions });
+    const base = (0, Listen_1.createListen)((e) => { t = e; }, { fast: true, ...listenOptions });
     const listen = withReplayListen(base, { current, frame, history, getSince, onJournal, now, staleMs, onStale });
     base.run();
-    t = listen.func;
+    t = listen.emit;
     return [t, listen];
 }

package/lib/Common/events/replay-wire.d.ts

@@ -1,4 +1,4 @@
-import { Listener, NormalizeTuple } from './Listen3';
+import { Listener, NormalizeTuple } from './Listen';
 import { ListenReplayApi, ReplayEvent, StaleInfo } from './replay-listen';
 import { conflateReplay, ConflateOpts } from './replay-conflate';
 export type ReplayExpose<T> = {

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

@@ -1,10 +1,10 @@
-import { funcListenCallbackBase } from "../events/Listen";
+import { createListen } from "../events/Listen";
 import { type PromiseServerHooks, type RpcLimits } from "./rpc-server";
 import { DeepSocketListen } from "./listen-deep";
 import { type SocketTmpl } from "./rpc-protocol";
-type ListenCallbackBase<T extends any[] = any[]> = ReturnType<typeof funcListenCallbackBase<T>>;
+type ListenCallbackBase<T extends any[] = any[]> = ReturnType<typeof createListen<T>>;
 type ClientProtocol = 'v2' | 'legacy' | null;
-export declare function createRpcServerAuto2<T extends object>({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits, onProtocolDetect, }: {
+export declare function createRpcServerAutoDetect<T extends object>({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits, onProtocolDetect, }: {
     socket: SocketTmpl;
     object: T;
     socketKey: string;

package/lib/Common/rcp/createRpcServerAutoWithProtocolDetection.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRpcServerAuto2 = createRpcServerAuto2;
+exports.createRpcServerAutoDetect = createRpcServerAutoDetect;
 const Listen_1 = require("../events/Listen");
 const listen_socket_1 = require("./listen-socket");
 const rpc_server_1 = require("./rpc-server");
@@ -8,7 +8,7 @@ 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 createRpcServerAuto2({ socket, object: target, socketKey: key, debug = false, hooks, disconnectListen, limits, onProtocolDetect, }) {
+function createRpcServerAutoDetect({ socket, object: target, socketKey: key, debug = false, hooks, disconnectListen, limits, onProtocolDetect, }) {
     const cache = new WeakMap();
     const listenSockets = new Set();
     function unsubscribeAllActive() {
@@ -25,7 +25,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
                 if (typeof z !== "function")
                     return Promise.reject(new TypeError("Listen callback expects a function"));
                 subs.get(z)?.off();
-                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
+                const w = (0, listen_socket_1.listenSocket)(parent, { closeOn: disconnectListen });
                 subs.set(z, w);
                 const done = w.on(z);
                 done.then(() => { if (subs.get(z) == w)
@@ -36,7 +36,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
                 if (typeof z !== "function")
                     return Promise.reject(new TypeError("Listen once expects a function"));
                 subs.get(z)?.off();
-                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen });
+                const w = (0, listen_socket_1.listenSocket)(parent, { closeOn: disconnectListen });
                 subs.set(z, w);
                 const done = w.once(z);
                 done.then(() => { if (subs.get(z) == w)
@@ -173,7 +173,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
     }
     function handleMessage(msg) {
         if (debug) {
-            console.log('[RPC-AUTO2 IN]', typeof msg === 'object' ? JSON.stringify(msg) : msg);
+            console.log('[RPC-AUTO-DETECT IN]', typeof msg === 'object' ? JSON.stringify(msg) : msg);
         }
         if (protocol === 'legacy') {
             if (isLegacyStrictRequest(msg)) {
@@ -190,7 +190,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
         if (isLegacyStrictRequest(msg)) {
             protocol = 'legacy';
             if (debug)
-                console.log('[RPC-AUTO2] Protocol detected: legacy (___STRICTLY)');
+                console.log('[RPC-AUTO-DETECT] Protocol detected: legacy (___STRICTLY)');
             onProtocolDetect?.('legacy');
             initLegacy();
             socket.emit(key, { STRICTLY: legacySchema });
@@ -199,7 +199,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
         if (isLegacyMessage(msg)) {
             protocol = 'legacy';
             if (debug)
-                console.log('[RPC-AUTO2] Protocol detected: legacy (mapId message)');
+                console.log('[RPC-AUTO-DETECT] Protocol detected: legacy (mapId message)');
             onProtocolDetect?.('legacy');
             initLegacy();
             legacyHandler(msg);
@@ -208,14 +208,14 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
         if (isV2Message(msg)) {
             protocol = 'v2';
             if (debug)
-                console.log('[RPC-AUTO2] Protocol detected: v2');
+                console.log('[RPC-AUTO-DETECT] Protocol detected: v2');
             onProtocolDetect?.('v2');
             initV2();
             v2Handler(msg);
             return;
         }
         if (debug)
-            console.warn('[RPC-AUTO2] Unknown message format, ignoring:', msg);
+            console.warn('[RPC-AUTO-DETECT] Unknown message format, ignoring:', msg);
     }
     activeHandler = handleMessage;
     socket.on(key, (msg) => activeHandler?.(msg));
@@ -227,7 +227,7 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
         activeHandler = null;
         reset();
         if (debug)
-            console.log('[RPC-AUTO2] disposed', reason ?? '');
+            console.log('[RPC-AUTO-DETECT] disposed', reason ?? '');
     }
     return {
         getProtocol: () => protocol,

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

@@ -1,16 +1,16 @@
 import { type ListenOn } from "../events/Listen";
 import type { ReplayEvent } from "../events/replay-listen";
-import { listenSocket, listenSocketFirst, listenSocketAll, listenSocketSmart, type tSubHandle } from "./listen-socket";
+import { listenSocket, listenSocketFirst, listenSocketAll, listenSocketSmart, type SubscriptionHandle } 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>;
+    callback: (...a: A) => SubscriptionHandle & Promise<void>;
+    on: (...a: A) => SubscriptionHandle & Promise<void>;
+    once: (...a: A) => SubscriptionHandle & Promise<void>;
 } : R;
 type Obj = Record<string, any>;
 export type InferArgs<T> = T extends {
-    addListen: (cb: (...args: infer R) => void, ...rest: any[]) => any;
+    on: (cb: (...args: infer R) => void, ...rest: any[]) => any;
 } ? R : never;
 export type ReplaySocketListen<Z extends any[]> = WithSubHandle<ReturnType<typeof listenSocket<Z>>> & {
     line: WithSubHandle<ReturnType<typeof listenSocket<[ReplayEvent<Z>]>>>;
@@ -20,29 +20,29 @@ export type ReplaySocketListen<Z extends any[]> = WithSubHandle<ReturnType<typeo
     frame: (seq: number, hint?: unknown) => Promise<ReplayEvent<Z>[]>;
 };
 export type IsReplayMember<V> = V extends {
-    addListen: Function;
     getSince: Function;
     keyframe: Function;
     line: object;
+    on: Function;
 } ? true : false;
 export type DeepSocketListen<T> = {
     [K in keyof T]: IsReplayMember<T[K]> extends true ? ReplaySocketListen<InferArgs<T[K]>> : T[K] extends {
-        addListen: Function;
+        on: Function;
     } ? 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;
+        on: Function;
     } ? 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;
+        on: Function;
     } ? 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]: IsReplayMember<NonNullable<T[K]>> extends true ? ReplaySocketListen<InferArgs<NonNullable<T[K]>>> | Extract<T[K], undefined | null> : NonNullable<T[K]> extends {
-        addListen: Function;
+        on: Function;
     } ? 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;

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

@@ -32,7 +32,7 @@ function deepMapByKeysList(obj1, keys, func) {
 function deepMapByKeys(obj1, obj2, func) {
     return deepMapByKeysList(obj1, Object.keys(obj2), func);
 }
-const NOOP_LISTEN = (0, Listen_1.funcListenCallbackBase)((_e) => { });
+const NOOP_LISTEN = (0, Listen_1.createListen)((_e) => { });
 function deepListenFirst(obj, data) {
     return deepMapByKeys(obj, NOOP_LISTEN, (e) => (0, listen_socket_1.listenSocketFirst)(e, data));
 }

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

@@ -1,14 +1,14 @@
-import { funcListenCallbackBase, type Listener } from "../events/Listen";
+import { createListen, 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, {
+type ListenCallbackResult<T extends any[] = any[]> = ReturnType<typeof createListen<T>>;
+export type SubscriptionHandle = Off<void, {
     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 closeOn?: ListenCallbackResult<any>;
     readonly stop?: (x: Listener<Z>) => any;
     readonly paramsModify?: (...e: Z) => any[];
     readonly throttle?: number;
@@ -21,26 +21,26 @@ export declare function listenSocket<Z extends any[] = any[]>(e: ListenCallbackR
     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) => tSubHandle;
-    on: (z: (a: Z[0]) => void) => tSubHandle;
-    once: (z: (a: Z[0]) => void) => tSubHandle;
+    callback: (z: (a: Z[0]) => void) => SubscriptionHandle;
+    on: (z: (a: Z[0]) => void) => SubscriptionHandle;
+    once: (z: (a: Z[0]) => void) => SubscriptionHandle;
     close: () => void;
     off: () => boolean;
     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) => tSubHandle;
-    on: (z: (...args: Z) => void) => tSubHandle;
-    once: (z: (...args: Z) => void) => tSubHandle;
+    callback: (z: (...args: Z) => void) => SubscriptionHandle;
+    on: (z: (...args: Z) => void) => SubscriptionHandle;
+    once: (z: (...args: Z) => void) => SubscriptionHandle;
     close: () => void;
     off: () => boolean;
     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>) => tSubHandle;
-    on: (z: SmartCallback<Z>) => tSubHandle;
-    once: (z: SmartCallback<Z>) => tSubHandle;
+    callback: (z: SmartCallback<Z>) => SubscriptionHandle;
+    on: (z: SmartCallback<Z>) => SubscriptionHandle;
+    once: (z: SmartCallback<Z>) => SubscriptionHandle;
     close: () => void;
     off: () => boolean;
     removeCallback: () => boolean;

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

@@ -43,9 +43,10 @@ function createThrottleLatest(ms, sink) {
     return { push, cancel };
 }
 function listenSocket(e, d) {
-    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));
+    const { stop, status, paramsModify, throttle } = d ?? {};
+    const closeOn = d?.closeOn;
+    const subscribe = (cb, opts) => e.on(cb, opts);
+    const subscribeClose = closeOn && ((cb) => closeOn.on(cb));
     let last = null;
     let active = null;
     let activeOff = null;

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

@@ -1,10 +1,10 @@
-import { funcListenCallbackBase } from "../events/Listen";
+import { createListen } from "../events/Listen";
 import type { DeepSocketListen } from "./listen-deep";
 import type { ClientAPIStrict } from "./rpc-client";
 type ClientAutoOptions = {
     readonly mode?: "smart" | "first" | "all";
     readonly status?: () => boolean;
-    readonly addListenClose?: ReturnType<typeof funcListenCallbackBase<any>>;
+    readonly closeOn?: ReturnType<typeof createListen<any>>;
 };
 export type ClientAutoResult<T> = DeepSocketListen<T>;
 export type AutoClientAPI<T> = ClientAPIStrict<DeepSocketListen<T>>;

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

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRpcClientAuto = createRpcClientAuto;
 const listen_deep_1 = require("./listen-deep");
 function createRpcClientAuto(api, options) {
-    const { mode = "smart", status, addListenClose } = options ?? {};
+    const { mode = "smart", status } = options ?? {};
+    const closeOn = options?.closeOn;
     const listenOptions = {
         ...(status ? { status } : {}),
-        ...(addListenClose ? { addListenClose } : {}),
+        ...(closeOn ? { closeOn } : {}),
     };
     switch (mode) {
         case "first":

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRpcClient = createRpcClient;
 const rpc_protocol_1 = require("./rpc-protocol");
+const rpc_path_1 = require("./rpc-path");
 const id_pool_1 = require("../id-pool");
 const rpc_walk_1 = require("./rpc-walk");
 const rpc_limits_1 = require("./rpc-limits");
@@ -219,7 +220,7 @@ function createClient(socket, key, opts) {
             }
             return step;
         });
-        const ref = routeCache[path.join(".")] ?? path;
+        const ref = routeCache[(0, rpc_path_1.rpcPathKey)(path)] ?? path;
         if (!wait) {
             socket.emit(key, [rpc_protocol_1.Pkt.PIPE, 0, ref, cleanSteps, false]);
             return Promise.resolve();
@@ -280,7 +281,7 @@ function createClient(socket, key, opts) {
             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;
+        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();
@@ -301,7 +302,8 @@ function createClient(socket, key, opts) {
     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));
+        const listenPathKey = (0, rpc_path_1.rpcPathKey)(path.slice(0, -1));
+        const skey = listenPathKey + "::" + JSON.stringify(args.map(listenKeyArg));
         let sub = wireSubs.get(skey);
         if (!sub) {
             const created = { consumers: new Set(), stop: () => { } };
@@ -353,7 +355,7 @@ function createClient(socket, key, opts) {
     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;
+            const isListen = declaredListens ? declaredListens.has((0, rpc_path_1.rpcPathKey)(path.slice(0, -1))) : true;
             if (isListen)
                 return subscribeShared(path, args);
         }

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

@@ -3,6 +3,7 @@ export * from "./rpc-off";
 export * from "./listen-deep";
 export * from "./rpc-dynamic";
 export * from "./rpc-protocol";
+export * from "./rpc-path";
 export * from "./rpc-caps";
 export * from "./rpc-limits";
 export * from "./rpc-walk";
@@ -11,5 +12,5 @@ export * from "./rpc-server";
 export * from "./rpc-client-auto";
 export * from "./rpc-server-auto";
 export * from "./rpc-clientHub";
-export { createRpcServerAuto2 } from "./createRpcServerAutoWithProtocolDetection";
+export { createRpcServerAutoDetect } from "./createRpcServerAutoWithProtocolDetection";
 export * from "./rpc-inproc";

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

@@ -14,12 +14,13 @@ 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.createRpcServerAuto2 = void 0;
+exports.createRpcServerAutoDetect = 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-path"), exports);
 __exportStar(require("./rpc-caps"), exports);
 __exportStar(require("./rpc-limits"), exports);
 __exportStar(require("./rpc-walk"), exports);
@@ -29,5 +30,5 @@ __exportStar(require("./rpc-client-auto"), exports);
 __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; } });
+Object.defineProperty(exports, "createRpcServerAutoDetect", { enumerable: true, get: function () { return createRpcServerAutoWithProtocolDetection_1.createRpcServerAutoDetect; } });
 __exportStar(require("./rpc-inproc"), exports);

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

@@ -0,0 +1 @@
+export declare function rpcPathKey(path: readonly string[]): string;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rpcPathKey = rpcPathKey;
+function rpcPathKey(path) {
+    return JSON.stringify(path);
+}

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

@@ -1,8 +1,8 @@
-import { funcListenCallbackBase } from "../events/Listen";
+import { createListen } from "../events/Listen";
 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>>;
+type ListenCallbackBase<T extends any[] = any[]> = ReturnType<typeof createListen<T>>;
 export type RpcReplayOpts = {
     pending?: () => number;
     highWater?: number;