wenay-common2 1.0.57 → 1.0.61

package/lib/Common/ObserveAll2/store-replay.d.ts

@@ -1,5 +1,5 @@
-import { Store, StorePatch } from './store';
-import { ReplayListenOptions } from '../events/replay-listen';
+import { Store, StorePatch, StoreDrain, StoreEachCtx } from './store';
+import { ReplayListenOptions, ReplayEvent } from '../events/replay-listen';
 import { ReplayRemote, ReplaySubscribeOpts } from '../events/replay-wire';
 import { ReplayStorage } from '../events/replay-history';
 export type StoreReplayOpts = Pick<ReplayListenOptions<[StorePatch]>, 'history' | 'getSince' | 'onJournal' | 'now'>;
@@ -22,30 +22,31 @@ export declare function exposeStoreReplay<T extends object>(store: Store<T>, opt
         isStale: () => boolean;
         lastTs: () => number;
         close: () => void;
-        getSince: (seq: number) => import("../events/replay-listen").ReplayEvent<[StorePatch]>[] | undefined;
+        getSince: (seq: number) => ReplayEvent<[StorePatch]>[] | undefined;
         line: {
-            func: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>;
+            func: import("../..").Listener<[ReplayEvent<[StorePatch]>]>;
             isRun: () => boolean;
             run: () => void;
             close: () => void;
             eventClose: (cb: () => void) => () => void;
             onClose: (cb: () => void) => () => void;
             removeEventClose: (cb: () => void) => void;
-            on: import("../..").ListenOn<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>;
-            off: (k: (string | symbol) | import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]> | null) => void;
-            addListen: (cb: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>, opts?: {
+            on: import("../..").ListenOn<[ReplayEvent<[StorePatch]>]>;
+            off: (k: (string | symbol) | import("../..").Listener<[ReplayEvent<[StorePatch]>]> | null) => void;
+            addListen: (cb: import("../..").Listener<[ReplayEvent<[StorePatch]>]>, opts?: {
                 cbClose?: () => void;
                 key?: string | symbol;
             }) => () => void;
-            removeListen: (k: (string | symbol) | import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]> | null) => void;
-            once: (cb: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>, opts?: {
+            removeListen: (k: (string | symbol) | import("../..").Listener<[ReplayEvent<[StorePatch]>]> | null) => void;
+            once: (cb: import("../..").Listener<[ReplayEvent<[StorePatch]>]>, opts?: {
                 key?: string | symbol;
             }) => () => void;
             count: () => number;
             readonly getAllKeys: (string | symbol)[];
         };
         hasKeyframe: boolean;
-        keyframe: () => import("../events/replay-listen").ReplayEvent<[StorePatch]> | undefined;
+        keyframe: () => ReplayEvent<[StorePatch]> | undefined;
+        frame: (sinceSeq: number, hint?: unknown) => ReplayEvent<[StorePatch]>[];
         on: import("../events/replay-listen").ListenOnReplay<[StorePatch]>;
         addListen: (cb: import("../..").Listener<[StorePatch]>, opts?: {
             cbClose?: () => void;
@@ -54,7 +55,7 @@ export declare function exposeStoreReplay<T extends object>(store: Store<T>, opt
             since?: number;
             onSeq?: (seq: number) => void;
         }) => () => void;
-        removeListen: (k: import("../..").Listener<[StorePatch]> | (string | symbol) | null) => void;
+        removeListen: (k: (string | symbol) | import("../..").Listener<[StorePatch]> | null) => void;
         once: (cb: import("../..").Listener<[StorePatch]>, opts?: {
             key?: string | symbol;
             current?: import("../..").ListenCurrent<[StorePatch]> | undefined;
@@ -76,6 +77,16 @@ export declare function syncStoreReplay<T extends object>(store: Store<T>, remot
     isStale: () => boolean;
     lastTs: () => number;
 };
+export declare function syncStoreReplayEach<T extends object>(remote: ReplayRemote<[StorePatch]>, cb: (key: string, value: T[keyof T] | undefined, ctx: StoreEachCtx) => void, opts?: ReplaySubscribeOpts & {
+    drain?: StoreDrain;
+    initial?: T;
+}): (() => void) & {
+    store: Store<T>;
+    ready: Promise<void>;
+    seq: () => number;
+    isStale: () => boolean;
+    lastTs: () => number;
+};
 export declare function storeReplayAt<T extends object>(storage: ReplayStorage<[StorePatch]>, at?: {
     seq?: number;
     ts?: number;

package/lib/Common/ObserveAll2/store-replay.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.storePatchKey = storePatchKey;
 exports.exposeStoreReplay = exposeStoreReplay;
 exports.syncStoreReplay = syncStoreReplay;
+exports.syncStoreReplayEach = syncStoreReplayEach;
 exports.storeReplayAt = storeReplayAt;
 const store_1 = require("./store");
 const replay_listen_1 = require("../events/replay-listen");
@@ -21,9 +22,21 @@ function storePatchKey(patch) {
             return null;
     return JSON.stringify(patch.path);
 }
+function condensePatchTail(tail) {
+    const held = new Map();
+    for (const ev of tail) {
+        const k = storePatchKey(ev.event[0]);
+        if (k == null)
+            return tail;
+        held.delete(k);
+        held.set(k, ev);
+    }
+    return [...held.values()];
+}
 function exposeStoreReplay(store, opts = {}) {
     const [emitPatch, lineApi] = (0, replay_listen_1.UseReplayListen)({
         current: () => [{ path: [], exists: true, value: store.snapshot() }],
+        frame: condensePatchTail,
         history: opts.getSince ? undefined : (opts.history ?? 1024),
         getSince: opts.getSince,
         onJournal: opts.onJournal,
@@ -42,6 +55,20 @@ function exposeStoreReplay(store, opts = {}) {
 function syncStoreReplay(store, remote, opts = {}) {
     return (0, replay_wire_1.replaySubscribe)(remote, function applyLine(patch) { (0, store_1.applyStorePatch)(store, patch); }, opts);
 }
+function syncStoreReplayEach(remote, cb, opts = {}) {
+    const { drain, initial, ...wireOpts } = opts;
+    const store = (0, store_1.createStore)((initial ?? {}), drain !== undefined ? { drain } : {});
+    const offEach = store.each().on(cb);
+    const sub = syncStoreReplay(store, remote, wireOpts);
+    function off() { offEach(); sub(); }
+    return Object.assign(off, {
+        store,
+        ready: sub.ready,
+        seq: sub.seq,
+        isStale: sub.isStale,
+        lastTs: sub.lastTs,
+    });
+}
 function storeReplayAt(storage, at = {}) {
     const envelopes = (0, replay_history_1.openHistory)(storage).at(at);
     if (!envelopes)

package/lib/Common/ObserveAll2/store.d.ts

@@ -1,3 +1,4 @@
+import { funcListenCallbackBase } from "../events/Listen";
 import { listenUpdate, listenUpdatePaths, reactive, ReactiveChange } from "./reactive2";
 export type StorePath = readonly PropertyKey[];
 export type StoreDrain = "micro" | "immediate" | number | ((flush: () => void) => void);
@@ -67,6 +68,12 @@ export type StoreSelectionCtx<T, M> = {
     mask: M;
     paths: PropertyKey[][];
 };
+export type StoreEachOpts = {
+    depth?: number;
+};
+export type StoreEachCtx = {
+    path: PropertyKey[];
+};
 export type Store<T extends object> = {
     readonly state: T;
     readonly node: StoreNode<T>;
@@ -76,6 +83,7 @@ export type Store<T extends object> = {
     on(cb: (value: T, ctx: StoreCtx<T>) => void, opts?: StoreSubOpts): () => void;
     once(cb: (value: T, ctx: StoreCtx<T>) => void, opts?: StoreSubOpts): () => void;
     update<M extends StoreMask<T>>(mask: M, opts?: StoreSubOpts): StoreSelection<T, M>;
+    each(opts?: StoreEachOpts): ReturnType<typeof funcListenCallbackBase<[key: string, value: T[keyof T] | undefined, ctx: StoreEachCtx]>>;
     listen(): ReturnType<typeof listenUpdate>;
     listenPaths(): ReturnType<typeof listenUpdatePaths>;
     count(): number;

package/lib/Common/ObserveAll2/store.js

@@ -307,6 +307,48 @@ function createPatchesListen(store) {
         },
     });
 }
+function createEachListen(store, opts = {}) {
+    if (opts.depth != null && opts.depth != 1)
+        throw new Error("store.each: only depth 1 is supported (reserved option)");
+    return (0, Listen_1.funcListenCallbackBase)((emit) => {
+        const known = new Set(Reflect.ownKeys((0, reactive2_1.toRaw)(store.state)));
+        function emitKey(key) {
+            const raw = (0, reactive2_1.toRaw)(store.state);
+            const exists = isObj(raw) && key in raw;
+            if (exists)
+                known.add(key);
+            else
+                known.delete(key);
+            emit(key, exists ? store.state[key] : undefined, { path: [key] });
+        }
+        const off = store.listenPaths().on(function eachStoreChange(change) {
+            const keys = new Set();
+            let root = false;
+            for (const path of change.paths) {
+                if (path.length == 0)
+                    root = true;
+                else
+                    keys.add(path[0]);
+            }
+            if (root) {
+                for (const key of Reflect.ownKeys((0, reactive2_1.toRaw)(store.state)))
+                    keys.add(key);
+                for (const key of known)
+                    keys.add(key);
+            }
+            for (const key of keys)
+                emitKey(key);
+        });
+        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) => {
@@ -458,6 +500,7 @@ function getNode(store, path) {
     store._nodeCache.set(k, proxy);
     return proxy;
 }
+let warnedRootOnEach = false;
 function createSelection(store, base, mask, defaults = {}) {
     const fullPaths = maskPaths(mask, base);
     const rootNode = getNode(store, base);
@@ -486,6 +529,10 @@ function createSelection(store, base, mask, defaults = {}) {
             return off;
         },
         onEach(cb, opts = {}) {
+            if (fullPaths.some(p => p.length == base.length) && !warnedRootOnEach) {
+                warnedRootOnEach = true;
+                console.warn("store: update(true).onEach fires ONCE per drain window with the WHOLE value (per selected path, not per key). For per-changed-key delivery use store.each(); for a subset — an explicit key mask.");
+            }
             const o = { ...defaults, ...opts };
             const offs = fullPaths.map(p => subscribePath(store, p, cb, o, false));
             return () => { for (const off of offs)
@@ -508,6 +555,7 @@ function createStore(initial, opts = {}) {
         on: (cb, opts) => getNode(store, []).on(cb, opts),
         once: (cb, opts) => getNode(store, []).once(cb, opts),
         update: (mask, opts) => createSelection(store, [], mask, opts),
+        each: (opts) => createEachListen(store, 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),

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

@@ -33,6 +33,7 @@ export declare function conflateReplay<T>(replay: ListenReplayApi<T>, opts: Conf
         };
         since: (seq: number) => ReplayEvent<NormalizeTuple<T>>[] | null;
         keyframe: () => ReplayEvent<NormalizeTuple<T>> | null;
+        frame: (seq: number, hint?: unknown) => ReplayEvent<NormalizeTuple<T>>[];
     };
     close: () => void;
     stats: () => {

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

@@ -95,6 +95,7 @@ function conflateReplay(replay, opts) {
             line: gate,
             since: (seq) => replay.getSince(seq) ?? null,
             keyframe: () => replay.keyframe() ?? null,
+            frame: (seq, hint) => replay.frame(seq, hint),
         },
         close,
         stats: () => ({ conflating, dropped, keyframes, coalesced, flushes }),

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

@@ -1,6 +1,8 @@
 import { Listener, ListenApi, ListenCurrent, ListenCurrentProvider, ListenOnBrand, ListenOptions, NormalizeTuple } from './Listen3';
 type key = string | symbol;
 type cbClose = () => void;
+export declare const IS_REPLAY_LISTEN: unique symbol;
+export declare function isReplayListen(obj: any): obj is ListenReplayApi<any>;
 export type ReplayEvent<Z extends any[] = any[]> = {
     seq: number;
     ts: number;
@@ -12,7 +14,8 @@ export type StaleInfo = {
     age: number;
 };
 export type ReplayListenOptions<Z extends any[]> = {
-    current?: ListenCurrentProvider<Z>;
+    current?: ListenCurrentProvider<Z> | 'last';
+    frame?: (tail: ReplayEvent<Z>[], hint?: unknown) => ReplayEvent<Z>[];
     history?: number;
     getSince?: (seq: number) => ReplayEvent<Z>[] | undefined;
     onJournal?: (ev: ReplayEvent<Z>) => void;
@@ -58,6 +61,7 @@ export declare function withReplayListen<T>(base: ListenApi<T>, options?: Replay
     };
     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;
@@ -106,6 +110,7 @@ export declare function UseReplayListen<T>(options?: ReplayListenUseOptions<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;

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

@@ -1,10 +1,18 @@
 "use strict";
 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.IS_REPLAY_LISTEN = Symbol.for('isReplayListen');
+function isReplayListen(obj) {
+    return !!obj && typeof obj == 'object' && Object.prototype.hasOwnProperty.call(obj, exports.IS_REPLAY_LISTEN);
+}
 function withReplayListen(base, options = {}) {
-    const { current, history = 0, getSince, onJournal, now = Date.now, staleMs, onStale } = options;
+    const { current: currentOpt, frame: condense, history = 0, getSince, onJournal, now = Date.now, staleMs, onStale } = options;
+    let lastEv;
+    const current = currentOpt == 'last' ? () => lastEv?.event : currentOpt;
     let head = 0;
     const ring = [];
     let emitting = null;
@@ -74,6 +82,8 @@ function withReplayListen(base, options = {}) {
             const ev = { seq: ++head, ts: now(), event: e };
             if (history > 0)
                 ring[(ev.seq - 1) % history] = ev;
+            if (currentOpt == 'last')
+                lastEv = ev;
             onJournal?.(ev);
             touchStale(ev.ts);
             line.func(ev);
@@ -97,6 +107,15 @@ function withReplayListen(base, options = {}) {
             const m = current?.();
             return m ? { seq: head, ts: now(), event: m } : undefined;
         },
+        frame: function frameSince(sinceSeq, hint) {
+            const tail = journalSince(sinceSeq);
+            if (tail)
+                return condense ? condense(tail, hint) : tail;
+            const m = current?.();
+            if (m)
+                return [{ seq: head, ts: now(), event: m }];
+            throw new Error(`replay frame(${sinceSeq}): journal evicted and no keyframe (sacred line)`);
+        },
         on: ((cb, { cbClose, key, current: cur, since, onSeq } = {}) => {
             if (since == null) {
                 const off = base.on(cb, { cbClose, key });
@@ -162,14 +181,15 @@ function withReplayListen(base, options = {}) {
         },
         get getAllKeys() { return base.getAllKeys; },
     };
+    Object.defineProperty(api, exports.IS_REPLAY_LISTEN, { value: true });
     (0, Listen3_1.registerListenOn)(api.on, api);
     return api;
 }
 function UseReplayListen(options = {}) {
-    const { current, history, getSince, onJournal, now, staleMs, onStale, ...listenOptions } = 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 listen = withReplayListen(base, { current, history, getSince, onJournal, now, staleMs, onStale });
+    const listen = withReplayListen(base, { current, frame, history, getSince, onJournal, now, staleMs, onStale });
     base.run();
     t = listen.func;
     return [t, listen];

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

@@ -5,6 +5,7 @@ export type ReplayExpose<T> = {
     line: ListenReplayApi<T>['line'];
     since: (seq: number) => ReplayEvent<NormalizeTuple<T>>[] | null;
     keyframe: () => ReplayEvent<NormalizeTuple<T>> | null;
+    frame: ListenReplayApi<T>['frame'];
 };
 export declare function exposeReplay<T>(replay: ListenReplayApi<T>): ReplayExpose<T>;
 export declare function exposeReplay<T>(replay: ListenReplayApi<T>, opts: {
@@ -19,6 +20,10 @@ export type ReplayRemote<Z extends any[] = any[]> = {
     };
     since: (seq: number) => Promise<ReplayEvent<Z>[] | null | undefined> | ReplayEvent<Z>[] | null | undefined;
     keyframe: () => Promise<ReplayEvent<Z> | null | undefined> | ReplayEvent<Z> | null | undefined;
+    frame?: (seq: number, hint?: unknown) => Promise<ReplayEvent<Z>[] | null | undefined> | ReplayEvent<Z>[] | null | undefined;
+    frameLine?: {
+        on: (cb: (ev: ReplayEvent<Z>) => void) => any;
+    };
 };
 export type ReplaySubscribeOpts = {
     since?: number;
@@ -28,6 +33,8 @@ export type ReplaySubscribeOpts = {
     onStale?: (info: StaleInfo) => void;
     skewMs?: number;
     now?: () => number;
+    policy?: 'queue' | 'frame';
+    hint?: unknown;
 };
 export declare function replaySubscribe<Z extends any[]>(remote: ReplayRemote<Z>, cb: Listener<Z>, opts?: ReplaySubscribeOpts): (() => void) & {
     ready: Promise<void>;

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

@@ -8,6 +8,7 @@ function exposeReplayPlain(replay) {
         line: replay.line,
         since: (seq) => replay.getSince(seq) ?? null,
         keyframe: () => replay.keyframe() ?? null,
+        frame: (seq, hint) => replay.frame(seq, hint),
     };
 }
 function exposeReplay(replay, opts) {
@@ -27,7 +28,7 @@ function unsubscribeHandle(handle) {
         handle.unsubscribe();
 }
 function replaySubscribe(remote, cb, opts = {}) {
-    const { since = -1, onSeq, onError, staleMs, onStale, skewMs = 0, now = Date.now } = opts;
+    const { since = -1, onSeq, onError, staleMs, onStale, skewMs = 0, now = Date.now, policy = 'queue', hint } = opts;
     let lastDelivered = since;
     let replaying = true;
     let closed = false;
@@ -94,7 +95,19 @@ function replaySubscribe(remote, cb, opts = {}) {
         if (!replaying)
             assessStale();
     }
-    const handle = remote.line.on(function liveTap(ev) {
+    const liveLine = policy == 'frame' && remote.frameLine ? remote.frameLine : remote.line;
+    const handle = liveLine.on(function liveTap(ev) {
+        if (ev == null || typeof ev.seq != 'number') {
+            if (closed)
+                return;
+            const err = new Error('replaySubscribe: line ended by server (' + String(ev) + ')');
+            off();
+            if (onError)
+                onError(err);
+            else
+                setTimeout(function rethrowLineEnd() { throw err; }, 0);
+            return;
+        }
         lastArrival = now();
         if (replaying)
             queue.push(ev);
@@ -103,23 +116,39 @@ function replaySubscribe(remote, cb, opts = {}) {
     });
     async function catchUp() {
         try {
-            const tail = since >= 0 ? await remote.since(since) : null;
-            if (closed)
-                return;
-            if (tail) {
-                for (const ev of tail)
-                    deliver(ev);
+            let done = false;
+            if (since >= 0 && remote.frame) {
+                const envs = await remote.frame(since, hint);
+                if (closed)
+                    return;
+                if (envs) {
+                    if (envs.length) {
+                        lastDelivered = envs[0].seq - 1;
+                        for (const ev of envs)
+                            deliver(ev);
+                    }
+                    done = true;
+                }
             }
-            else {
-                const kf = await remote.keyframe();
+            if (!done) {
+                const tail = since >= 0 ? await remote.since(since) : null;
                 if (closed)
                     return;
-                if (kf) {
-                    lastDelivered = kf.seq;
-                    lastTs = kf.ts;
-                    lastArrival = now();
-                    cb(...kf.event);
-                    onSeq?.(kf.seq);
+                if (tail) {
+                    for (const ev of tail)
+                        deliver(ev);
+                }
+                else {
+                    const kf = await remote.keyframe();
+                    if (closed)
+                        return;
+                    if (kf) {
+                        lastDelivered = kf.seq;
+                        lastTs = kf.ts;
+                        lastArrival = now();
+                        cb(...kf.event);
+                        onSeq?.(kf.seq);
+                    }
                 }
             }
         }

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

@@ -1,4 +1,5 @@
 import { type ListenOn } from "../events/Listen";
+import type { ReplayEvent } from "../events/replay-listen";
 import { listenSocket, listenSocketFirst, listenSocketAll, listenSocketSmart, type tSubHandle } from "./listen-socket";
 type WithSubHandle<R> = R extends {
     callback: (...a: infer A) => any;
@@ -8,11 +9,24 @@ type WithSubHandle<R> = R extends {
     once: (...a: A) => tSubHandle & Promise<void>;
 } : R;
 type Obj = Record<string, any>;
-type InferArgs<T> = T extends {
+export type InferArgs<T> = T extends {
     addListen: (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>]>>>;
+    frameLine: WithSubHandle<ReturnType<typeof listenSocket<[ReplayEvent<Z>]>>>;
+    since: (seq: number) => Promise<ReplayEvent<Z>[] | null>;
+    keyframe: () => Promise<ReplayEvent<Z> | null>;
+    frame: (seq: number, hint?: unknown) => Promise<ReplayEvent<Z>[]>;
+};
+export type IsReplayMember<V> = V extends {
+    addListen: Function;
+    getSince: Function;
+    keyframe: Function;
+    line: object;
+} ? true : false;
 export type DeepSocketListen<T> = {
-    [K in keyof T]: T[K] extends {
+    [K in keyof T]: IsReplayMember<T[K]> extends true ? ReplaySocketListen<InferArgs<T[K]>> : T[K] extends {
         addListen: 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];
 };
@@ -27,7 +41,7 @@ export type DeepSocketListenAll<T> = {
     } ? 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 {
+    [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;
     } ? 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];
 };

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

@@ -2,16 +2,19 @@ import { type SocketTmpl } from "./rpc-protocol";
 import { type RpcLimits } from "./rpc-limits";
 import { makeOff } from "./rpc-off";
 import { type RpcOpt } from "./rpc-caps";
+import type { IsReplayMember, InferArgs, ReplaySocketListen } from "./listen-deep";
 type UnwrapPromise<T> = T extends Promise<infer R> ? R : T;
-export type DeepDataOnly<T> = T extends Function ? never : T extends Array<infer U> ? Array<DeepDataOnly<U>> : T extends object ? {
+export type DeepDataOnly<T> = T extends Function ? never : T extends readonly any[] ? {
+    [I in keyof T]: DeepDataOnly<T[I]>;
+} : T extends object ? {
     [K in keyof T as T[K] extends Function ? never : K]: DeepDataOnly<T[K]>;
 } : T;
 export type ClientAPIAll<T> = {
-    [K in keyof T as T[K] extends Function ? K : T[K] extends object ? K : never]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<DeepDataOnly<UnwrapPromise<R>>> : T[K] extends object ? ClientAPIAll<T[K]> : never;
+    [K in keyof T as T[K] extends Function ? K : T[K] extends object ? K : never]: IsReplayMember<T[K]> extends true ? ReplaySocketListen<InferArgs<T[K]>> : T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<DeepDataOnly<UnwrapPromise<R>>> : T[K] extends object ? ClientAPIAll<T[K]> : never;
 };
 type NonFalsy<T> = Exclude<T, false | null | 0 | "" | undefined>;
 export type ClientAPIStrict<T> = {
-    [K in keyof T as NonFalsy<T[K]> extends Function ? K : NonFalsy<T[K]> extends object ? K : never]: NonFalsy<T[K]> extends (...args: infer A) => infer R ? (...args: A) => Promise<DeepDataOnly<UnwrapPromise<R>>> : NonFalsy<T[K]> extends object ? ClientAPIStrict<NonFalsy<T[K]>> : never;
+    [K in keyof T as NonFalsy<T[K]> extends Function ? K : NonFalsy<T[K]> extends object ? K : never]: IsReplayMember<NonFalsy<T[K]>> extends true ? ReplaySocketListen<InferArgs<NonFalsy<T[K]>>> : NonFalsy<T[K]> extends (...args: infer A) => infer R ? (...args: A) => Promise<DeepDataOnly<UnwrapPromise<R>>> : NonFalsy<T[K]> extends object ? ClientAPIStrict<NonFalsy<T[K]>> : never;
 };
 export interface PipeArrayAPI<T> extends Promise<DeepDataOnly<T[]>> {
     [index: number]: PipeAPI<T>;

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

@@ -3,7 +3,13 @@ import { type PromiseServerHooks, type RpcLimits, type RpcServerAuth, type RpcOp
 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, auth, maxPerListen, throttle, opt }: {
+export type RpcReplayOpts = {
+    pending?: () => number;
+    highWater?: number;
+    lowWater?: number;
+    pollMs?: number;
+};
+export declare function createRpcServerAuto<T extends object>({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits, auth, maxPerListen, throttle, opt, replay, replayOpts }: {
     socket: SocketTmpl;
     object: T;
     socketKey: string;
@@ -15,6 +21,8 @@ export declare function createRpcServerAuto<T extends object>({ socket, object:
     maxPerListen?: number;
     throttle?: number;
     opt?: RpcOpt;
+    replay?: false | "auto" | "force";
+    replayOpts?: RpcReplayOpts;
 }): {
     api: {
         subscriptions: () => {

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

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRpcServerAuto = createRpcServerAuto;
 const Listen_1 = require("../events/Listen");
+const replay_listen_1 = require("../events/replay-listen");
 const listen_socket_1 = require("./listen-socket");
 const rpc_server_1 = require("./rpc-server");
 const rpc_protocol_1 = require("./rpc-protocol");
-function createRpcServerAuto({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits, auth, maxPerListen, throttle, opt }) {
+function createRpcServerAuto({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits, auth, maxPerListen, throttle, opt, replay = "auto", replayOpts }) {
     const cache = new WeakMap();
     const registry = new Map();
     function unsubscribeAllActive() {
@@ -15,7 +16,8 @@ function createRpcServerAuto({ socket, object: target, socketKey: key, debug, ho
         }
         registry.clear();
     }
-    function getListenSocket(parent, disconnectListen) {
+    function getListenSocket(parent, disconnectListen, nodeOpt) {
+        const nodeThrottle = nodeOpt ? nodeOpt.throttle : throttle;
         let result = cache.get(parent);
         if (!result) {
             const subs = new Map();
@@ -27,7 +29,7 @@ function createRpcServerAuto({ socket, object: target, socketKey: key, debug, ho
                 if (!registry.has(parent))
                     registry.set(parent, { subs });
                 subs.get(z)?.off();
-                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen, throttle });
+                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen, throttle: nodeThrottle });
                 subs.set(z, w);
                 const done = w.on(z);
                 done.then(() => {
@@ -46,7 +48,7 @@ function createRpcServerAuto({ socket, object: target, socketKey: key, debug, ho
                 if (!registry.has(parent))
                     registry.set(parent, { subs });
                 subs.get(z)?.off();
-                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen, throttle });
+                const w = (0, listen_socket_1.listenSocket)(parent, { addListenClose: disconnectListen, throttle: nodeThrottle });
                 let fired = false;
                 const oneShot = (...a) => {
                     if (fired)
@@ -79,6 +81,137 @@ function createRpcServerAuto({ socket, object: target, socketKey: key, debug, ho
         }
         return result;
     }
+    function isReplayNode(obj) {
+        if (replay == false || obj == null || typeof obj != "object")
+            return false;
+        if (Object.prototype.hasOwnProperty.call(obj, replay_listen_1.IS_REPLAY_LISTEN))
+            return true;
+        return replay == "force"
+            && (0, Listen_1.isListenCallback)(obj)
+            && typeof obj.getSince == "function"
+            && typeof obj.keyframe == "function"
+            && !!obj.line && typeof obj.line == "object";
+    }
+    function lineFrame(parent, seq, hint) {
+        if (typeof parent.frame == "function")
+            return parent.frame(seq, hint);
+        const tail = parent.getSince(seq);
+        if (tail)
+            return tail;
+        const kf = parent.keyframe();
+        if (kf)
+            return [kf];
+        throw new Error(`replay frame(${seq}): journal evicted and no keyframe (sacred line)`);
+    }
+    const gateClosers = new Set();
+    function closeAllGates() { for (const c of [...gateClosers])
+        c(); }
+    let gatesHooked = false;
+    function hookGateTeardown() {
+        if (gatesHooked || !disconnectListen)
+            return;
+        gatesHooked = true;
+        const dl = disconnectListen;
+        if (typeof dl.on == "function")
+            dl.on(closeAllGates);
+        else
+            dl.addListen(closeAllGates);
+    }
+    function gatedLineNode(parent) {
+        const { pending: pendingOpt, highWater = Infinity, lowWater = 0, pollMs = 25 } = replayOpts ?? {};
+        const pending = pendingOpt ?? (() => socket?.conn?.writeBuffer?.length ?? 0);
+        const out = (0, Listen_1.funcListenCallbackBase)(() => { });
+        out.run();
+        let lastSent = typeof parent.head == "function" ? parent.head() : 0;
+        let gated = false;
+        let closed = false;
+        let timer = null;
+        function stopPoll() { if (timer) {
+            clearInterval(timer);
+            timer = null;
+        } }
+        function startPoll() {
+            if (timer || closed)
+                return;
+            timer = setInterval(recoverIfDrained, pollMs);
+            timer.unref?.();
+        }
+        function close() {
+            if (closed)
+                return;
+            closed = true;
+            stopPoll();
+            offLine();
+            gateClosers.delete(close);
+        }
+        function fail(e) {
+            if (debug)
+                console.error("[rpc replay gate] frame recovery failed:", e);
+            const emitStop = !closed;
+            close();
+            if (emitStop)
+                out.func(rpc_protocol_1.RPC_STOP);
+            out.close?.();
+        }
+        function recoverIfDrained() {
+            if (!gated || closed)
+                return;
+            if (pending() > lowWater)
+                return;
+            gated = false;
+            stopPoll();
+            let envs;
+            try {
+                envs = lineFrame(parent, lastSent);
+            }
+            catch (e) {
+                fail(e);
+                return;
+            }
+            for (const ev of envs) {
+                if (ev.seq > lastSent)
+                    lastSent = ev.seq;
+                out.func(ev);
+            }
+        }
+        const offLine = parent.line.on(function gateForward(ev) {
+            if (closed)
+                return;
+            if (!gated && pending() > highWater) {
+                gated = true;
+                startPoll();
+            }
+            if (gated) {
+                recoverIfDrained();
+                return;
+            }
+            lastSent = ev.seq;
+            out.func(ev);
+        });
+        gateClosers.add(close);
+        hookGateTeardown();
+        return getListenSocket(out, disconnectListen, { throttle: undefined });
+    }
+    const replayCache = new WeakMap();
+    function getReplayExpose(parent) {
+        let node = replayCache.get(parent);
+        if (node)
+            return node;
+        const legacy = getListenSocket(parent, disconnectListen);
+        const lineNode = getListenSocket(parent.line, disconnectListen, { throttle: undefined });
+        const frameLineNode = replayOpts?.highWater != null ? gatedLineNode(parent) : lineNode;
+        node = {
+            ...legacy,
+            line: lineNode,
+            frameLine: frameLineNode,
+            since: (seq) => parent.getSince(seq) ?? null,
+            keyframe: () => parent.keyframe() ?? null,
+            frame: (seq, hint) => lineFrame(parent, seq, hint),
+        };
+        node[rpc_protocol_1.IS_RPC_LISTEN] = true;
+        replayCache.set(parent, node);
+        return node;
+    }
     const api = {
         subscriptions: () => Array.from(registry, ([parent, e], i) => ({
             key: parent?.constructor?.name ? `${parent.constructor.name}#${i}` : `listen#${i}`,
@@ -89,12 +222,16 @@ function createRpcServerAuto({ socket, object: target, socketKey: key, debug, ho
         socket, object: target, socketKey: key, debug, limits, auth, opt,
         hooks: {
             ...hooks,
-            onDispose: () => { unsubscribeAllActive(); hooks?.onDispose?.(); },
+            onDispose: () => { closeAllGates(); unsubscribeAllActive(); hooks?.onDispose?.(); },
             resolveTransform: (obj) => {
+                if (isReplayNode(obj))
+                    return getReplayExpose(obj);
                 if ((0, Listen_1.isListenCallback)(obj))
                     return getListenSocket(obj, disconnectListen);
-                if ((0, Listen_1.isListenOn)(obj))
-                    return getListenSocket((0, Listen_1.getListenByOn)(obj), disconnectListen);
+                if ((0, Listen_1.isListenOn)(obj)) {
+                    const byOn = (0, Listen_1.getListenByOn)(obj);
+                    return isReplayNode(byOn) ? getReplayExpose(byOn) : getListenSocket(byOn, disconnectListen);
+                }
                 return obj;
             },
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common2",
-  "version": "1.0.57",
+  "version": "1.0.61",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",