wenay-common2 1.0.52 → 1.0.55

package/lib/Common/ObserveAll2/store.js

@@ -1,13 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyStoreMask = applyStoreMask;
+exports.applyStorePatch = applyStorePatch;
+exports.applyStorePatches = applyStorePatches;
 exports.createStore = createStore;
 exports.exposeStore = exposeStore;
 exports.createStoreMirror = createStoreMirror;
+const Listen_1 = require("../events/Listen");
 const reactive2_1 = require("./reactive2");
 const hasSetImmediate = typeof setImmediate == "function";
-function pathKey(path) {
+function pathText(path) {
     return path.map(String).join(".");
 }
+const symbolIds = new Map();
+let nextSymbolId = 1;
+function symbolKey(k) {
+    let id = symbolIds.get(k);
+    if (id == null) {
+        id = nextSymbolId++;
+        symbolIds.set(k, id);
+    }
+    return id;
+}
+function pathKey(path) {
+    return JSON.stringify(path.map(k => typeof k == "symbol" ? ["symbol", symbolKey(k)] : ["key", String(k)]));
+}
 function schedule(drain, flush) {
     if (drain == null) {
         flush();
@@ -102,6 +119,7 @@ function setAt(root, path, value) {
     p[path[path.length - 1]] = value;
 }
 function snapshotValue(value, seen = new WeakMap()) {
+    value = (0, reactive2_1.toRaw)(value);
     if (!isObj(value))
         return value;
     if (value instanceof Date)
@@ -135,26 +153,176 @@ function maskPaths(mask, base = []) {
     if (!isObj(mask))
         return [base];
     const out = [];
-    for (const k of Object.keys(mask))
+    for (const k of Reflect.ownKeys(mask))
         out.push(...maskPaths(mask[k], [...base, k]));
     return out;
 }
 function pickSnapshot(root, mask, base = []) {
+    root = (0, reactive2_1.toRaw)(root);
     if (mask === true || mask == null)
         return snapshotValue(getAt(root, base));
     const out = {};
-    for (const k of Object.keys(mask))
+    for (const k of Reflect.ownKeys(mask))
         out[k] = pickSnapshot(root, mask[k], [...base, k]);
     return out;
 }
+function deleteAt(root, path) {
+    if (path.length == 0) {
+        replaceRoot(root, {});
+        return;
+    }
+    const parent = getAt(root, path.slice(0, -1));
+    if (isObj(parent))
+        delete parent[path[path.length - 1]];
+}
 function applyMask(root, mask, data, base = []) {
     if (mask === true || mask == null) {
-        setAt(root, base, snapshotValue(data));
+        if (data === undefined && base.length)
+            deleteAt(root, base);
+        else
+            setAt(root, base, snapshotValue(data));
         return;
     }
-    for (const k of Object.keys(mask))
+    for (const k of Reflect.ownKeys(mask))
         applyMask(root, mask[k], data?.[k], [...base, k]);
 }
+function applyStoreMask(store, mask, data) {
+    applyMask(store.state, mask ?? true, data);
+}
+function applyStorePatch(store, patch) {
+    if (patch.exists === false)
+        deleteAt(store.state, patch.path);
+    else
+        setAt(store.state, patch.path, snapshotValue(patch.value));
+}
+function applyStorePatches(store, patches) {
+    for (const patch of patches)
+        applyStorePatch(store, patch);
+}
+function pathToMask(path) {
+    let out = true;
+    for (let i = path.length - 1; i >= 0; i--)
+        out = { [path[i]]: out };
+    return out;
+}
+function hasMaskKey(mask, key) {
+    return isObj(mask) && Reflect.ownKeys(mask).some(k => Object.is(k, key));
+}
+function mergeMasks(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    if (a === true || a == null || b === true || b == null)
+        return true;
+    if (!isObj(a) || !isObj(b))
+        return true;
+    const out = {};
+    for (const k of Reflect.ownKeys(a))
+        out[k] = a[k];
+    for (const k of Reflect.ownKeys(b)) {
+        out[k] = hasMaskKey(a, k) ? mergeMasks(a[k], b[k]) : b[k];
+    }
+    return out;
+}
+function startsWithPath(path, prefix) {
+    return prefix.length <= path.length && prefix.every((k, i) => Object.is(k, path[i]));
+}
+function intersectMaskWithPaths(mask, dirtyPaths) {
+    const baseMask = mask ?? true;
+    if (!Array.isArray(dirtyPaths))
+        return baseMask;
+    if (dirtyPaths.length == 0)
+        return undefined;
+    const selected = maskPaths(baseMask);
+    let out = undefined;
+    for (const dirty of dirtyPaths) {
+        if (!Array.isArray(dirty))
+            continue;
+        if (dirty.length == 0) {
+            out = mergeMasks(out, baseMask);
+            continue;
+        }
+        for (const selectedPath of selected) {
+            if (startsWithPath(dirty, selectedPath))
+                out = mergeMasks(out, pathToMask(dirty));
+            else if (startsWithPath(selectedPath, dirty))
+                out = mergeMasks(out, pathToMask(selectedPath));
+        }
+    }
+    return out;
+}
+function maskFromPaths(paths) {
+    let out = undefined;
+    for (const path of paths)
+        out = mergeMasks(out, pathToMask(path));
+    return out ?? true;
+}
+function makePatch(root, path) {
+    root = (0, reactive2_1.toRaw)(root);
+    const exists = hasAt(root, path);
+    return {
+        path: [...path],
+        exists,
+        value: exists ? snapshotValue(getAt(root, path)) : undefined,
+    };
+}
+function patchesForMask(patch, mask) {
+    const selected = maskPaths(mask ?? true);
+    const out = [];
+    let emittedWholePatch = false;
+    for (const selectedPath of selected) {
+        if (startsWithPath(patch.path, selectedPath)) {
+            if (!emittedWholePatch) {
+                out.push(patch);
+                emittedWholePatch = true;
+            }
+            continue;
+        }
+        if (!startsWithPath(selectedPath, patch.path))
+            continue;
+        const rel = selectedPath.slice(patch.path.length);
+        const exists = patch.exists && hasAt(patch.value, rel);
+        out.push({
+            path: [...selectedPath],
+            exists,
+            value: exists ? snapshotValue(getAt(patch.value, rel)) : undefined,
+        });
+    }
+    return out;
+}
+function createPatchesListen(store) {
+    return (0, Listen_1.funcListenCallbackBase)((emit) => {
+        const off = store.listenPaths().on((change) => {
+            for (const path of change.paths)
+                emit(makePatch(store.state, path));
+        });
+        return off;
+    }, {
+        event: (type, count, api) => {
+            if (type == "add" && count == 1 && !api.isRun())
+                api.run();
+            if (type == "remove" && count == 0 && api.isRun())
+                api.close();
+        },
+    });
+}
+function createChangedDataListen(store) {
+    return (0, Listen_1.funcListenCallbackBase)((emit) => {
+        const off = store.listenPaths().on((change) => {
+            const mask = maskFromPaths(change.paths);
+            emit({ mask, data: pickSnapshot(store.state, mask) });
+        });
+        return off;
+    }, {
+        event: (type, count, api) => {
+            if (type == "add" && count == 1 && !api.isRun())
+                api.run();
+            if (type == "remove" && count == 0 && api.isRun())
+                api.close();
+        },
+    });
+}
 function watchTarget(root, path) {
     let cur = root;
     let lastReactive = root;
@@ -183,7 +351,7 @@ function makeCtx(store, path) {
         store,
         node: getNode(store, path),
         path: [...path],
-        pathString: pathKey(path),
+        pathString: pathText(path),
         exists: hasAt(store._state, path),
     };
 }
@@ -259,7 +427,7 @@ function getNode(store, path) {
         return cached;
     const api = {
         get path() { return [...path]; },
-        get pathString() { return pathKey(path); },
+        get pathString() { return pathText(path); },
         get: () => getAt(store._state, path),
         has: () => hasAt(store._state, path),
         snapshot: () => snapshotValue(getAt(store._state, path)),
@@ -309,8 +477,12 @@ function createSelection(store, base, mask, defaults = {}) {
                 off(); };
         },
         once(cb, opts = {}) {
+            let done = false;
             let off = () => { };
-            off = this.on((v, c) => { off(); cb(v, c); }, { ...opts, current: opts.current ?? defaults.current });
+            off = this.on(function fireOnce(v, c) { if (done)
+                return; done = true; off(); cb(v, c); }, { ...opts, current: opts.current ?? defaults.current });
+            if (done)
+                off();
             return off;
         },
         onEach(cb, opts = {}) {
@@ -337,13 +509,15 @@ function createStore(initial, opts = {}) {
         once: (cb, opts) => getNode(store, []).once(cb, opts),
         update: (mask, opts) => createSelection(store, [], mask, opts),
         listen: () => (0, reactive2_1.listenUpdate)(state),
+        listenPaths: () => (0, reactive2_1.listenUpdatePaths)(state),
         count: () => Array.from(store._counts.values()).reduce((a, b) => a + b, 0),
     };
     return store;
 }
-function exposeStore(store) {
-    return {
-        get: (mask) => mask ? store.update(mask).get() : store.snapshot(),
+function exposeStore(store, opts = {}) {
+    const get = ((mask) => mask ? store.update(mask).get() : store.snapshot());
+    const api = {
+        get,
         set: (path, value) => {
             let node = store.node;
             for (const k of path)
@@ -357,25 +531,127 @@ function exposeStore(store) {
             node.replace(value);
         },
         changed: store.listen(),
+        changedPaths: store.listenPaths(),
+    };
+    if (opts.push) {
+        api.patches = createPatchesListen(store);
+        api.changedData = createChangedDataListen(store);
+    }
+    return api;
+}
+function isRemoteListen(listen) {
+    return typeof listen?.on == "function" || typeof listen?.addListen == "function";
+}
+function subscribeRemote(listen, cb) {
+    let handle;
+    if (typeof listen?.on == "function")
+        handle = listen.on(cb);
+    else if (typeof listen?.addListen == "function")
+        handle = listen.addListen(cb);
+    else
+        return () => { };
+    return () => {
+        if (typeof handle == "function")
+            handle();
+        else if (typeof handle?.off == "function")
+            handle.off();
+        else if (typeof listen?.off == "function")
+            listen.off(cb);
+        else if (typeof listen?.removeListen == "function")
+            listen.removeListen(cb);
     };
 }
 function createStoreMirror(remote, initial = {}, opts = {}) {
     const store = createStore(initial, opts);
+    const makeReport = (subOpts) => (error) => {
+        if (subOpts.onError)
+            subOpts.onError(error);
+        else
+            setTimeout(() => { throw error; }, 0);
+    };
+    async function pull(mask) {
+        const snap = await remote.get(mask);
+        applyMask(store.state, mask, snap);
+    }
     async function sync(mask, subOpts = { current: true }) {
-        async function pull() {
-            const snap = await remote.get(mask);
-            applyMask(store.state, mask, snap);
-        }
+        const baseMask = mask ?? true;
+        const report = makeReport(subOpts);
+        if (subOpts.current !== false)
+            await pull(baseMask);
+        let pendingMask = undefined;
+        let chain = Promise.resolve();
+        const drained = createDrained(() => {
+            const nextMask = pendingMask === undefined ? baseMask : pendingMask;
+            pendingMask = undefined;
+            chain = chain.then(() => pull(nextMask)).catch(report);
+        }, subOpts.drain);
+        const queue = (nextMask) => {
+            pendingMask = pendingMask === undefined ? nextMask : mergeMasks(pendingMask, nextMask);
+            drained.push();
+        };
+        const changedPaths = remote.changedPaths;
+        const usePaths = subOpts.partial !== false && isRemoteListen(changedPaths);
+        const off = usePaths
+            ? subscribeRemote(changedPaths, (change) => {
+                const nextMask = intersectMaskWithPaths(baseMask, change?.paths);
+                if (nextMask !== undefined)
+                    queue(nextMask);
+            })
+            : subscribeRemote(remote.changed, () => queue(baseMask));
+        return () => { drained.close(); off(); };
+    }
+    async function syncPatches(mask, subOpts = { current: true }) {
+        if (!isRemoteListen(remote.patches))
+            throw new Error("createStoreMirror.syncPatches: remote.patches is not exposed");
+        const baseMask = mask ?? true;
+        const report = makeReport(subOpts);
         if (subOpts.current !== false)
-            await pull();
-        const drained = createDrained(() => { void pull(); }, subOpts.drain);
-        const changed = remote.changed;
-        const off = typeof changed?.on == "function"
-            ? changed.on(() => drained.push())
-            : typeof changed?.addListen == "function"
-                ? changed.addListen(() => drained.push())
-                : (() => { });
-        return () => { drained.close(); off?.(); };
+            await pull(baseMask);
+        const pending = [];
+        const drained = createDrained(() => {
+            const batch = pending.splice(0);
+            try {
+                applyStorePatches(store, batch);
+            }
+            catch (e) {
+                report(e);
+            }
+        }, subOpts.drain);
+        const off = subscribeRemote(remote.patches, (patch) => {
+            const next = patchesForMask(patch, baseMask);
+            if (next.length == 0)
+                return;
+            pending.push(...next);
+            drained.push();
+        });
+        return () => { drained.close(); off(); };
+    }
+    async function syncChangedData(mask, subOpts = { current: true }) {
+        if (!isRemoteListen(remote.changedData))
+            throw new Error("createStoreMirror.syncChangedData: remote.changedData is not exposed");
+        const baseMask = mask ?? true;
+        const report = makeReport(subOpts);
+        if (subOpts.current !== false)
+            await pull(baseMask);
+        const pending = [];
+        const drained = createDrained(() => {
+            const batch = pending.splice(0);
+            try {
+                for (const change of batch) {
+                    const nextMask = intersectMaskWithPaths(baseMask, maskPaths(change?.mask ?? true));
+                    if (nextMask !== undefined)
+                        applyMask(store.state, nextMask, change.data);
+                }
+            }
+            catch (e) {
+                report(e);
+            }
+        }, subOpts.drain);
+        const off = subscribeRemote(remote.changedData, (change) => {
+            pending.push(change);
+            drained.push();
+        });
+        return () => { drained.close(); off(); };
     }
-    return Object.assign(store, { sync });
+    return Object.assign(store, { sync, syncPatches, syncChangedData });
 }

package/lib/Common/events/Listen3.d.ts

@@ -33,10 +33,15 @@ export type ListenStoreOptions<T> = ListenOptions<T> & {
 };
 export declare function getListenByOn(fn: any): any;
 export declare function isListenOn(fn: any): boolean;
+export declare function registerListenOn(on: Function, api: any): void;
+export type ListenOnBrand<Z extends any[] = any[]> = {
+    readonly [LISTEN_ON_BRAND]: Z;
+};
 export declare function funcListenCore<T>(options?: ListenCoreOptions<T>): {
     func: Listener<NormalizeTuple<T>>;
     has: (k: key) => boolean;
     on: ListenOn<NormalizeTuple<T>>;
+    off: (k: Listener<NormalizeTuple<T>> | null | key) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
     }) => () => void;
@@ -58,11 +63,12 @@ export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
     on: ListenOn<NormalizeTuple<T>>;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
         cbClose?: cbClose;
         key?: key;
     }) => () => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => void;
     once: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
     }) => () => void;
@@ -79,6 +85,7 @@ export declare function funcListenCallbackFast<T>(a: (e: (Listener<NormalizeTupl
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
     on: ListenOn<NormalizeTuple<T>>;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
         cbClose?: cbClose;
         key?: key;
@@ -100,6 +107,7 @@ export declare function UseListen<T>(data?: ListenOptions<T>): readonly [(...a:
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
     on: ListenOn<NormalizeTuple<T>>;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     addListen: (cb: Listener<NormalizeTuple<T>>, opts?: {
         cbClose?: cbClose;
         key?: key;
@@ -118,6 +126,7 @@ export declare function withStoreListen<T>(base: ListenApi<T>, currentProvider:
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>>;
     }) => () => void;
+    removeListen: (k: Listener<NormalizeTuple<T>> | null | key) => void;
     once: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>>;
@@ -130,7 +139,7 @@ export declare function withStoreListen<T>(base: ListenApi<T>, currentProvider:
     eventClose: (cb: cbClose) => () => void;
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     count: () => number;
 };
 export type ListenStoreApi<T> = ReturnType<typeof withStoreListen<T>>;
@@ -141,6 +150,7 @@ export declare function funcListenCallbackStore<T>(b: (e: Listener<NormalizeTupl
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>> | undefined;
     }) => () => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     once: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>> | undefined;
@@ -153,7 +163,7 @@ export declare function funcListenCallbackStore<T>(b: (e: Listener<NormalizeTupl
     eventClose: (cb: cbClose) => () => void;
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     count: () => number;
 };
 export declare function UseListenStore<T>(data: ListenStoreOptions<T>): readonly [(...a: NormalizeTuple<T>) => void, {
@@ -163,6 +173,7 @@ export declare function UseListenStore<T>(data: ListenStoreOptions<T>): readonly
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>> | undefined;
     }) => () => void;
+    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     once: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
         current?: ListenCurrent<NormalizeTuple<T>> | undefined;
@@ -175,13 +186,14 @@ export declare function UseListenStore<T>(data: ListenStoreOptions<T>): readonly
     eventClose: (cb: cbClose) => () => void;
     onClose: (cb: cbClose) => () => void;
     removeEventClose: (cb: cbClose) => void;
-    removeListen: (k: key | Listener<NormalizeTuple<T>> | null) => void;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     count: () => number;
 }];
 export declare function toListen2<T>(full: ListenApi<T>): {
     on: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
     }) => () => void;
+    off: (k: Listener<NormalizeTuple<T>> | null | key) => void;
     close: () => void;
     count: () => number;
 };
@@ -190,6 +202,7 @@ export declare function UseListen2<T>(data?: ListenOptions<T>): readonly [(...a:
     on: (cb: Listener<NormalizeTuple<T>>, opts?: {
         key?: key;
     } | undefined) => () => void;
+    off: (k: key | Listener<NormalizeTuple<T>> | null) => void;
     close: () => void;
     count: () => number;
 }];

package/lib/Common/events/Listen3.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.funcListenCallback = void 0;
 exports.getListenByOn = getListenByOn;
 exports.isListenOn = isListenOn;
+exports.registerListenOn = registerListenOn;
 exports.funcListenCore = funcListenCore;
 exports.funcListenCallbackBase = funcListenCallbackBase;
 exports.funcListenCallbackFast = funcListenCallbackFast;
@@ -16,6 +17,7 @@ exports.isListenCallback = isListenCallback;
 const listenByOn = new WeakMap();
 function getListenByOn(fn) { return typeof fn == 'function' ? listenByOn.get(fn) : undefined; }
 function isListenOn(fn) { return typeof fn == 'function' && listenByOn.has(fn); }
+function registerListenOn(on, api) { listenByOn.set(on, api); }
 function funcListenCore(options = {}) {
     const { fast = true, onRemove, event } = options;
     const subs = new Map();
@@ -68,8 +70,7 @@ function funcListenCore(options = {}) {
             event?.('add', subs.size, api);
             return function off() { removeOne(k); };
         }),
-        addListen: (cb, opts = {}) => api.on(cb, opts),
-        removeListen: (k) => {
+        off: (k) => {
             if (typeof k == 'function') {
                 for (const [kk, cb] of [...subs])
                     if (cb === k)
@@ -79,6 +80,8 @@ function funcListenCore(options = {}) {
             if (k != null)
                 removeOne(k);
         },
+        addListen: (cb, opts = {}) => api.on(cb, opts),
+        removeListen: (k) => api.off(k),
         once: (cb, opts = {}) => {
             let off = () => { };
             off = api.on(((...e) => { off(); cb(...e); }), opts);
@@ -151,8 +154,9 @@ function funcListenCallbackBase(b, options = {}) {
             event?.('add', core.count(), api);
             return off;
         }),
+        off: core.off,
         addListen: (cb, opts = {}) => api.on(cb, opts),
-        removeListen: core.removeListen,
+        removeListen: (k) => api.off(k),
         once: (cb, opts = {}) => {
             let off = () => { };
             off = api.on(((...e) => { off(); cb(...e); }), opts);
@@ -193,6 +197,7 @@ function withStoreListen(base, currentProvider) {
             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);
@@ -226,6 +231,7 @@ function UseListenStore(data) {
 function toListen2(full) {
     return {
         on: (cb, opts) => full.on(cb, opts),
+        off: (k) => full.off(k),
         close: () => full.close(),
         count: () => full.count(),
     };

package/lib/Common/events/SocketBuffer.d.ts

@@ -33,6 +33,7 @@ export declare function funcListenCallbackSnapshot<T extends realSocket2<any | a
         onClose: (cb: () => void) => () => void;
         removeEventClose: (cb: () => void) => void;
         on: import("./Listen3").ListenOn<[data: getTypeCallback<T>, memo: T3]>;
+        off: (k: (string | symbol) | import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]> | null) => void;
         addListen: (cb: import("./Listen3").Listener<[data: getTypeCallback<T>, memo: T3]>, opts?: {
             cbClose?: () => void;
             key?: string | symbol;

package/lib/Common/events/SocketServerHook.d.ts

@@ -13,6 +13,7 @@ export declare function SocketServerHook(opt?: {
             onClose: (cb: () => void) => () => void;
             removeEventClose: (cb: () => void) => void;
             on: import("./Listen3").ListenOn<[unknown]>;
+            off: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
             addListen: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
                 cbClose?: () => void;
                 key?: string | symbol;
@@ -34,6 +35,7 @@ export declare function SocketServerHook(opt?: {
         onClose: (cb: () => void) => () => void;
         removeEventClose: (cb: () => void) => void;
         on: import("./Listen3").ListenOn<[unknown]>;
+        off: (k: (string | symbol) | import("./Listen3").Listener<[unknown]> | null) => void;
         addListen: (cb: import("./Listen3").Listener<[unknown]>, opts?: {
             cbClose?: () => void;
             key?: string | symbol;
@@ -55,6 +57,7 @@ export declare function WebSocketServerHook(s: ReturnType<typeof SocketServerHoo
             on: (z: (...args: any[]) => void) => import("../rcp/listen-socket").tSubHandle;
             once: (z: (...args: any[]) => void) => import("../rcp/listen-socket").tSubHandle;
             close: () => void;
+            off: () => boolean;
             removeCallback: () => boolean;
         };
     };

package/lib/Common/events/UseListenTransform.d.ts

@@ -10,6 +10,7 @@ export declare function UseListenTransform<TSource extends any[], TTarget extend
     onClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
     on: import("./Listen3").ListenOn<NormalizeTuple<TTarget>>;
+    off: (k: (string | symbol) | Listener<NormalizeTuple<TTarget>> | null) => void;
     addListen: (cb: Listener<NormalizeTuple<TTarget>>, opts?: {
         cbClose?: () => void;
         key?: string | symbol;

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

@@ -0,0 +1,45 @@
+import { NormalizeTuple } from './Listen3';
+import { ListenReplayApi, ReplayEvent } from './replay-listen';
+export type ConflateOpts<Z extends any[] = any[]> = {
+    pending: () => number;
+    highWater: number;
+    lowWater?: number;
+    pollMs?: number;
+    keyOf?: (...event: Z) => PropertyKey | null | undefined;
+    maxKeys?: number;
+};
+export declare function conflateReplay<T>(replay: ListenReplayApi<T>, opts: ConflateOpts<NormalizeTuple<T>>): {
+    api: {
+        line: {
+            func: import("./Listen3").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) | import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]> | null) => void;
+            addListen: (cb: import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]>, opts?: {
+                cbClose?: () => void;
+                key?: string | symbol;
+            }) => () => void;
+            removeListen: (k: (string | symbol) | import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]> | null) => void;
+            once: (cb: import("./Listen3").Listener<[ReplayEvent<NormalizeTuple<T>>]>, opts?: {
+                key?: string | symbol;
+            }) => () => void;
+            count: () => number;
+            readonly getAllKeys: (string | symbol)[];
+        };
+        since: (seq: number) => ReplayEvent<NormalizeTuple<T>>[] | null;
+        keyframe: () => ReplayEvent<NormalizeTuple<T>> | null;
+    };
+    close: () => void;
+    stats: () => {
+        conflating: boolean;
+        dropped: number;
+        keyframes: number;
+        coalesced: number;
+        flushes: number;
+    };
+};