wenay-common2 1.0.53 → 1.0.55

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conflateReplay = conflateReplay;
+const Listen3_1 = require("./Listen3");
+const replay_wire_1 = require("./replay-wire");
+function conflateReplay(replay, opts) {
+    const { pending, highWater, lowWater = 0, pollMs = 25, keyOf, maxKeys = 1024 } = opts;
+    if (!replay.hasKeyframe)
+        throw new TypeError('conflateReplay: нужен current-провайдер (keyframe recovery)');
+    const gate = (0, Listen3_1.funcListenCallbackBase)(() => { });
+    gate.run();
+    let conflating = false;
+    let closed = false;
+    let dropped = 0;
+    let keyframes = 0;
+    let coalesced = 0;
+    let flushes = 0;
+    let held = null;
+    let timer = null;
+    function stopPoll() {
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+    }
+    function startPoll() {
+        if (timer || closed)
+            return;
+        timer = setInterval(recoverIfDrained, pollMs);
+        timer.unref?.();
+    }
+    function recoverIfDrained() {
+        if (!conflating || closed)
+            return;
+        if (pending() > lowWater)
+            return;
+        conflating = false;
+        stopPoll();
+        if (held) {
+            const tail = [...held.values()];
+            held = null;
+            flushes++;
+            for (const ev of tail)
+                gate.func(ev);
+            return;
+        }
+        const kf = replay.keyframe();
+        if (kf) {
+            keyframes++;
+            gate.func(kf);
+        }
+    }
+    function absorb(ev) {
+        const k = keyOf(...ev.event);
+        if (k == null || (!held.has(k) && held.size >= maxKeys)) {
+            dropped += held.size + 1;
+            held = null;
+            return;
+        }
+        if (held.delete(k))
+            coalesced++;
+        held.set(k, ev);
+    }
+    const offLine = replay.line.on(function gateForward(ev) {
+        if (closed)
+            return;
+        if (!conflating && pending() > highWater) {
+            conflating = true;
+            held = keyOf ? new Map() : null;
+            startPoll();
+        }
+        if (conflating) {
+            if (held) {
+                absorb(ev);
+                recoverIfDrained();
+                return;
+            }
+            recoverIfDrained();
+            if (conflating)
+                dropped++;
+            return;
+        }
+        gate.func(ev);
+    });
+    function close() {
+        if (closed)
+            return;
+        closed = true;
+        held = null;
+        stopPoll();
+        offLine();
+        gate.close();
+    }
+    return {
+        api: { ...(0, replay_wire_1.exposeReplay)(replay), line: gate },
+        close,
+        stats: () => ({ conflating, dropped, keyframes, coalesced, flushes }),
+    };
+}

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

@@ -0,0 +1,55 @@
+import { Listener, NormalizeTuple } from './Listen3';
+import { ListenOnReplay, ListenReplayApi, ReplayEvent } from './replay-listen';
+export type ReplayStorage<Z extends any[] = any[]> = {
+    putEvent: (ev: ReplayEvent<Z>) => void;
+    putKeyframe: (kf: ReplayEvent<Z>) => void;
+    getKeyframe: (at?: {
+        seq?: number;
+        ts?: number;
+    }) => ReplayEvent<Z> | undefined;
+    getEvents: (from: number, to: number) => ReplayEvent<Z>[];
+};
+export declare function createMemoryReplayStorage<Z extends any[] = any[]>(opts?: {
+    maxEvents?: number;
+    maxKeyframes?: number;
+}): {
+    putEvent: (ev: ReplayEvent<Z>) => void;
+    putKeyframe: (kf: ReplayEvent<Z>) => void;
+    getKeyframe: (at?: {
+        seq?: number;
+        ts?: number;
+    }) => ReplayEvent<Z>;
+    getEvents: (from: number, to: number) => ReplayEvent<Z>[];
+    size: () => {
+        events: number;
+        keyframes: number;
+    };
+};
+export type ArchiveReplayOpts<Z extends any[]> = {
+    storage: ReplayStorage<Z>;
+    everyEvents?: number;
+    everyMs?: number;
+};
+export declare function archiveReplay<T>(replay: ListenReplayApi<T>, opts: ArchiveReplayOpts<NormalizeTuple<T>>): {
+    close: () => void;
+    stats: () => {
+        events: number;
+        keyframes: number;
+    };
+};
+export type HistorySubscribeOpts = {
+    since?: number;
+    ts?: number;
+    onSeq?: (seq: number) => void;
+};
+export declare function openHistory<Z extends any[]>(storage: ReplayStorage<Z>, live?: {
+    on: ListenOnReplay<Z>;
+}): {
+    at: (where?: {
+        seq?: number;
+        ts?: number;
+    }) => ReplayEvent<Z>[] | undefined;
+    subscribe: (cb: Listener<Z>, opts?: HistorySubscribeOpts) => (() => void) & {
+        seq: () => number;
+    };
+};

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

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryReplayStorage = createMemoryReplayStorage;
+exports.archiveReplay = archiveReplay;
+exports.openHistory = openHistory;
+function upperBy(arr, k, v) {
+    let lo = 0;
+    let hi = arr.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (k(arr[mid]) <= v)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+const bySeq = (e) => e.seq;
+const byTs = (e) => e.ts;
+function createMemoryReplayStorage(opts = {}) {
+    const { maxEvents, maxKeyframes } = opts;
+    const events = [];
+    const keyframes = [];
+    return {
+        putEvent: (ev) => {
+            events.push(ev);
+            if (maxEvents && events.length > maxEvents)
+                events.shift();
+        },
+        putKeyframe: (kf) => {
+            keyframes.push(kf);
+            if (maxKeyframes && keyframes.length > maxKeyframes)
+                keyframes.shift();
+        },
+        getKeyframe: (at = {}) => {
+            const end = at.ts != null ? upperBy(keyframes, byTs, at.ts) : upperBy(keyframes, bySeq, at.seq ?? Infinity);
+            return keyframes[end - 1];
+        },
+        getEvents: (from, to) => events.slice(upperBy(events, bySeq, from), upperBy(events, bySeq, to)),
+        size: () => ({ events: events.length, keyframes: keyframes.length }),
+    };
+}
+function archiveReplay(replay, opts) {
+    const { storage, everyEvents = 64, everyMs } = opts;
+    if (!replay.hasKeyframe)
+        throw new TypeError('archiveReplay: нужен current-провайдер (keyframe)');
+    let events = 0;
+    let keyframes = 0;
+    let lastKfSeq = 0;
+    let lastKfTs = 0;
+    function takeKeyframe() {
+        const kf = replay.keyframe();
+        if (!kf)
+            return;
+        storage.putKeyframe(kf);
+        keyframes++;
+        lastKfSeq = kf.seq;
+        lastKfTs = kf.ts;
+    }
+    takeKeyframe();
+    const offLine = replay.line.on(function archiveLineEvent(ev) {
+        storage.putEvent(ev);
+        events++;
+        const due = ev.seq - lastKfSeq >= everyEvents || (everyMs != null && ev.ts - lastKfTs >= everyMs);
+        if (due)
+            takeKeyframe();
+    });
+    return {
+        close: () => offLine(),
+        stats: () => ({ events, keyframes }),
+    };
+}
+function openHistory(storage, live) {
+    function at(where = {}) {
+        const kf = storage.getKeyframe(where);
+        if (!kf)
+            return undefined;
+        let tail = storage.getEvents(kf.seq, where.seq ?? Infinity);
+        if (where.ts != null) {
+            const cut = tail.findIndex(ev => ev.ts > where.ts);
+            if (cut >= 0)
+                tail = tail.slice(0, cut);
+        }
+        return [kf, ...tail];
+    }
+    function subscribe(cb, opts = {}) {
+        const { since, ts, onSeq } = opts;
+        let last = since ?? 0;
+        function deliver(ev) {
+            if (ev.seq <= last)
+                return;
+            last = ev.seq;
+            cb(...ev.event);
+            onSeq?.(ev.seq);
+        }
+        function deliverFromKeyframe(envs) {
+            if (!envs)
+                return;
+            last = envs[0].seq - 1;
+            for (const ev of envs)
+                deliver(ev);
+        }
+        if (since != null) {
+            const tail = storage.getEvents(since, Infinity);
+            if (tail.length && tail[0].seq != since + 1)
+                deliverFromKeyframe(at({}));
+            else
+                for (const ev of tail)
+                    deliver(ev);
+        }
+        else {
+            deliverFromKeyframe(at(ts != null ? { ts } : {}));
+        }
+        let offLive = null;
+        if (live)
+            offLive = live.on(cb, { since: last, onSeq: function trackSeq(s) { last = s; onSeq?.(s); } });
+        function off() { offLive?.(); }
+        return Object.assign(off, {
+            seq: () => last,
+        });
+    }
+    return { at, subscribe };
+}

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

@@ -0,0 +1,4 @@
+export * from './replay-listen';
+export * from './replay-wire';
+export * from './replay-conflate';
+export * from './replay-history';

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./replay-listen"), exports);
+__exportStar(require("./replay-wire"), exports);
+__exportStar(require("./replay-conflate"), exports);
+__exportStar(require("./replay-history"), exports);

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

@@ -0,0 +1,114 @@
+import { Listener, ListenApi, ListenCurrent, ListenCurrentProvider, ListenOnBrand, ListenOptions, NormalizeTuple } from './Listen3';
+type key = string | symbol;
+type cbClose = () => void;
+export type ReplayEvent<Z extends any[] = any[]> = {
+    seq: number;
+    ts: number;
+    event: Z;
+};
+export type ReplayListenOptions<Z extends any[]> = {
+    current?: ListenCurrentProvider<Z>;
+    history?: number;
+    getSince?: (seq: number) => ReplayEvent<Z>[] | undefined;
+    onJournal?: (ev: ReplayEvent<Z>) => void;
+    now?: () => number;
+};
+type ReplayOnOptions<Z extends any[]> = {
+    cbClose?: cbClose;
+    key?: key;
+    current?: ListenCurrent<Z>;
+    since?: number;
+    onSeq?: (seq: number) => void;
+};
+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>>;
+    head: () => number;
+    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)[];
+    };
+    hasKeyframe: boolean;
+    keyframe: () => ReplayEvent<NormalizeTuple<T>> | undefined;
+    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;
+    close: () => void;
+    eventClose: (cb: () => void) => () => void;
+    onClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    off: (k: (string | symbol) | Listener<NormalizeTuple<T>> | null) => void;
+    count: () => number;
+};
+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>>;
+    head: () => number;
+    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)[];
+    };
+    hasKeyframe: boolean;
+    keyframe: () => ReplayEvent<NormalizeTuple<T>> | undefined;
+    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;
+    close: () => void;
+    eventClose: (cb: () => void) => () => void;
+    onClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    off: (k: (string | symbol) | Listener<NormalizeTuple<T>> | null) => void;
+    count: () => number;
+}];
+export {};

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withReplayListen = withReplayListen;
+exports.UseReplayListen = UseReplayListen;
+const Listen3_1 = require("./Listen3");
+function withReplayListen(base, options = {}) {
+    const { current, history = 0, getSince, onJournal, now = Date.now } = options;
+    let head = 0;
+    const ring = [];
+    let emitting = null;
+    const line = (0, Listen3_1.funcListenCallbackBase)(() => { });
+    line.run();
+    function journalSince(seq) {
+        if (getSince)
+            return getSince(seq);
+        if (seq > head)
+            return undefined;
+        if (seq == head)
+            return [];
+        const oldest = Math.max(1, head - history + 1);
+        if (seq + 1 < oldest)
+            return undefined;
+        const out = [];
+        for (let s = seq + 1; s <= head; s++)
+            out.push(ring[(s - 1) % history]);
+        return out;
+    }
+    function currentValue(c) {
+        if (typeof c == 'function')
+            return c();
+        return c ? current?.() : undefined;
+    }
+    const api = {
+        ...base,
+        func: function emitJournaled(...e) {
+            const ev = { seq: ++head, ts: now(), event: e };
+            if (history > 0)
+                ring[(ev.seq - 1) % history] = ev;
+            onJournal?.(ev);
+            line.func(ev);
+            const prev = emitting;
+            emitting = ev;
+            try {
+                base.func(...e);
+            }
+            finally {
+                emitting = prev;
+            }
+        },
+        head: () => head,
+        getSince: journalSince,
+        line,
+        hasKeyframe: current != null,
+        keyframe: () => {
+            const m = current?.();
+            return m ? { seq: head, ts: now(), event: m } : undefined;
+        },
+        on: ((cb, { cbClose, key, current: cur, since, onSeq } = {}) => {
+            if (since == null) {
+                const off = base.on(cb, { cbClose, key });
+                if (cur) {
+                    const m = currentValue(cur);
+                    if (m)
+                        cb(...m);
+                }
+                return off;
+            }
+            let lastDelivered = since;
+            let replaying = true;
+            const queue = [];
+            function deliver(ev) {
+                if (ev.seq <= lastDelivered)
+                    return;
+                lastDelivered = ev.seq;
+                cb(...ev.event);
+                onSeq?.(ev.seq);
+            }
+            const off = base.on(function liveTap(...e) {
+                const ev = emitting;
+                if (ev == null) {
+                    cb(...e);
+                    return;
+                }
+                if (replaying)
+                    queue.push(ev);
+                else
+                    deliver(ev);
+            }, { cbClose, key });
+            const tail = journalSince(since);
+            if (tail) {
+                for (const ev of tail)
+                    deliver(ev);
+            }
+            else {
+                const m = current?.();
+                lastDelivered = head;
+                if (m) {
+                    cb(...m);
+                    onSeq?.(head);
+                }
+            }
+            while (queue.length)
+                deliver(queue.shift());
+            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);
+                if (m) {
+                    cb(...m);
+                    return () => { };
+                }
+            }
+            let off = () => { };
+            off = base.on(((...e) => { off(); cb(...e); }), { key: opts.key });
+            return off;
+        },
+        get getAllKeys() { return base.getAllKeys; },
+    };
+    (0, Listen3_1.registerListenOn)(api.on, api);
+    return api;
+}
+function UseReplayListen(options = {}) {
+    const { current, history, getSince, onJournal, now, ...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 });
+    base.run();
+    t = listen.func;
+    return [t, listen];
+}

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

@@ -0,0 +1,43 @@
+import { Listener } from './Listen3';
+import { ListenReplayApi, ReplayEvent } from './replay-listen';
+export declare function exposeReplay<T>(replay: ListenReplayApi<T>): {
+    line: {
+        func: Listener<[ReplayEvent<import("./Listen3").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<import("./Listen3").NormalizeTuple<T>>]>;
+        off: (k: (string | symbol) | Listener<[ReplayEvent<import("./Listen3").NormalizeTuple<T>>]> | null) => void;
+        addListen: (cb: Listener<[ReplayEvent<import("./Listen3").NormalizeTuple<T>>]>, opts?: {
+            cbClose?: () => void;
+            key?: string | symbol;
+        }) => () => void;
+        removeListen: (k: (string | symbol) | Listener<[ReplayEvent<import("./Listen3").NormalizeTuple<T>>]> | null) => void;
+        once: (cb: Listener<[ReplayEvent<import("./Listen3").NormalizeTuple<T>>]>, opts?: {
+            key?: string | symbol;
+        }) => () => void;
+        count: () => number;
+        readonly getAllKeys: (string | symbol)[];
+    };
+    since: (seq: number) => ReplayEvent<import("./Listen3").NormalizeTuple<T>>[] | null;
+    keyframe: () => ReplayEvent<import("./Listen3").NormalizeTuple<T>> | null;
+};
+export type ReplayRemote<Z extends any[] = any[]> = {
+    line: {
+        on: (cb: (ev: ReplayEvent<Z>) => void) => any;
+    };
+    since: (seq: number) => Promise<ReplayEvent<Z>[] | null | undefined> | ReplayEvent<Z>[] | null | undefined;
+    keyframe: () => Promise<ReplayEvent<Z> | null | undefined> | ReplayEvent<Z> | null | undefined;
+};
+export type ReplaySubscribeOpts = {
+    since?: number;
+    onSeq?: (seq: number) => void;
+    onError?: (e: any) => void;
+};
+export declare function replaySubscribe<Z extends any[]>(remote: ReplayRemote<Z>, cb: Listener<Z>, opts?: ReplaySubscribeOpts): (() => void) & {
+    ready: Promise<void>;
+    seq: () => number;
+};

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exposeReplay = exposeReplay;
+exports.replaySubscribe = replaySubscribe;
+function exposeReplay(replay) {
+    return {
+        line: replay.line,
+        since: (seq) => replay.getSince(seq) ?? null,
+        keyframe: () => replay.keyframe() ?? null,
+    };
+}
+function unsubscribeHandle(handle) {
+    if (typeof handle == 'function') {
+        handle();
+        return;
+    }
+    if (typeof handle?.off == 'function')
+        handle.off();
+    else if (typeof handle?.unsubscribe == 'function')
+        handle.unsubscribe();
+}
+function replaySubscribe(remote, cb, opts = {}) {
+    const { since = -1, onSeq, onError } = opts;
+    let lastDelivered = since;
+    let replaying = true;
+    let closed = false;
+    const queue = [];
+    function deliver(ev) {
+        if (closed || ev.seq <= lastDelivered)
+            return;
+        lastDelivered = ev.seq;
+        cb(...ev.event);
+        onSeq?.(ev.seq);
+    }
+    const handle = remote.line.on(function liveTap(ev) {
+        if (replaying)
+            queue.push(ev);
+        else
+            deliver(ev);
+    });
+    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);
+            }
+            else {
+                const kf = await remote.keyframe();
+                if (closed)
+                    return;
+                if (kf) {
+                    lastDelivered = kf.seq;
+                    cb(...kf.event);
+                    onSeq?.(kf.seq);
+                }
+            }
+        }
+        catch (e) {
+            if (onError)
+                onError(e);
+            else
+                setTimeout(function rethrowCatchUp() { throw e; }, 0);
+        }
+        finally {
+            while (queue.length)
+                deliver(queue.shift());
+            replaying = false;
+        }
+    }
+    const ready = catchUp();
+    function off() {
+        if (closed)
+            return;
+        closed = true;
+        unsubscribeHandle(handle);
+    }
+    return Object.assign(off, {
+        ready,
+        seq: () => lastDelivered,
+    });
+}

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

@@ -7,6 +7,7 @@ export type RpcLimits = {
     maxStringLen?: number;
     maxCallbacks?: number;
     maxPathLen?: number;
+    maxBinaryLen?: number;
 };
 export declare const resolveLimits: (opts?: RpcLimits) => Required<RpcLimits>;
 export declare class PayloadLimitError extends Error {