wenay-common2 1.0.70 → 1.0.73

package/lib/Common/media/media-source.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MEDIA_FRAME_HEADER_BYTES = exports.MEDIA_FRAME_VERSION = exports.MEDIA_FRAME_MAGIC = void 0;
+exports.toBytes = toBytes;
 exports.encodeMediaFrame = encodeMediaFrame;
 exports.decodeMediaFrame = decodeMediaFrame;
 exports.createAudioSource = createAudioSource;
@@ -356,7 +357,7 @@ function createAudioSource(opts = {}) {
     async function start() {
         try {
             ensureSocketTransport(transport);
-            if (!hasGetUserMedia()) {
+            if (!opts.stream && !hasGetUserMedia()) {
                 shell.setState('no-device');
                 return shell.state;
             }
@@ -364,7 +365,7 @@ function createAudioSource(opts = {}) {
             shell.setState('requesting');
             shell.stats.startedAt = nowMono();
             const constraints = { audio: { deviceId: deviceId ? { exact: deviceId } : undefined, channelCount: opts.channels, sampleRate: opts.sampleRate } };
-            stream = await globalThis.navigator.mediaDevices.getUserMedia(constraints);
+            stream = await resolveMediaStream(opts.stream, () => globalThis.navigator.mediaDevices.getUserMedia(constraints));
             if (opts.mode == 'record')
                 startRecord(stream);
             else
@@ -395,6 +396,50 @@ function createAudioSource(opts = {}) {
     };
     return attachControl([shell.emit, shell.listenApi], control);
 }
+async function resolveMediaStream(injected, fallback) {
+    if (!injected)
+        return fallback();
+    return typeof injected == 'function' ? await injected() : injected;
+}
+function videoEncodeWorkerCode() {
+    return `
+const canvas = new OffscreenCanvas(1, 1)
+const ctx = canvas.getContext('2d')
+onmessage = async function onEncodeRequest(ev) {
+    const req = ev.data
+    try {
+        canvas.width = req.w
+        canvas.height = req.h
+        ctx.drawImage(req.bitmap, 0, 0, req.w, req.h)
+        req.bitmap.close()
+        const blob = await canvas.convertToBlob({type: req.mime, quality: req.quality})
+        const buf = await blob.arrayBuffer()
+        postMessage({buf}, [buf])
+    } catch (e) {
+        postMessage({error: String((e && e.message) || e)})
+    }
+}
+`;
+}
+function startCaptureTicker(ms, tick, useWorker) {
+    const g = globalThis;
+    if (useWorker && g.Worker && g.Blob && g.URL) {
+        try {
+            const blob = new g.Blob([`setInterval(function () { postMessage(0) }, ${ms})`], { type: 'text/javascript' });
+            const url = g.URL.createObjectURL(blob);
+            const worker = new g.Worker(url);
+            worker.onmessage = function onCaptureTick() { tick(); };
+            return function stopWorkerTicker() {
+                worker.terminate();
+                g.URL.revokeObjectURL(url);
+            };
+        }
+        catch {
+        }
+    }
+    const timer = setInterval(tick, ms);
+    return function stopIntervalTicker() { clearInterval(timer); };
+}
 function mimeForVideo(codec) {
     if (codec == 'png')
         return 'image/png';
@@ -422,9 +467,37 @@ function createVideoSource(opts = {}) {
     let video = opts.video;
     let canvas = opts.canvas;
     let ctx = null;
-    let timer = null;
+    let stopTicker = null;
+    let imageCapture = null;
+    let encodeWorker = null;
     let busy = false;
     let seq = 0;
+    async function grabBitmap() {
+        if (imageCapture) {
+            try {
+                return await imageCapture.grabFrame();
+            }
+            catch { }
+        }
+        return null;
+    }
+    function emitVideoFrame(payload, codec, w, h) {
+        shell.emitFrame(encodeMediaFrame({
+            kind: 'video-frame',
+            codec,
+            seq: ++seq,
+            tMono: nowMono(),
+            width: w,
+            height: h,
+        }, payload), seq);
+    }
+    function encodeInWorker(bitmap, w, h, mime, quality) {
+        return new Promise(function encodeRoundtrip(resolve, reject) {
+            encodeWorker.onmessage = (ev) => ev.data?.error ? reject(new Error(ev.data.error)) : resolve(ev.data.buf);
+            encodeWorker.onerror = (e) => reject(new Error(String(e?.message ?? 'video encode worker error')));
+            encodeWorker.postMessage({ bitmap, w, h, mime, quality }, [bitmap]);
+        });
+    }
     async function captureOne() {
         if (busy || shell.state != 'live') {
             shell.stats.dropped++;
@@ -432,26 +505,40 @@ function createVideoSource(opts = {}) {
         }
         busy = true;
         try {
-            const w = opts.width ?? video.videoWidth ?? video.width ?? 0;
-            const h = opts.height ?? video.videoHeight ?? video.height ?? 0;
-            if (!w || !h)
+            const bitmap = await grabBitmap();
+            const srcW = (bitmap ? bitmap.width : video.videoWidth ?? video.width) ?? 0;
+            const srcH = (bitmap ? bitmap.height : video.videoHeight ?? video.height) ?? 0;
+            let w = opts.width ?? srcW;
+            let h = opts.height ?? srcH;
+            if (srcW && srcH) {
+                if (opts.width && opts.height == undefined) {
+                    w = Math.min(opts.width, srcW);
+                    h = Math.round(w * srcH / srcW);
+                }
+                else if (opts.height && opts.width == undefined) {
+                    h = Math.min(opts.height, srcH);
+                    w = Math.round(h * srcW / srcH);
+                }
+            }
+            if (!w || !h) {
+                bitmap?.close?.();
                 return;
+            }
+            const codec = opts.codec ?? 'jpeg';
+            const quality = opts.quality ?? 0.82;
+            if (encodeWorker && bitmap) {
+                const buf = await encodeInWorker(bitmap, w, h, mimeForVideo(codec), quality);
+                emitVideoFrame(new Uint8Array(buf), codec, w, h);
+                return;
+            }
             if (canvas.width != w)
                 canvas.width = w;
             if (canvas.height != h)
                 canvas.height = h;
-            ctx.drawImage(video, 0, 0, w, h);
-            const codec = opts.codec ?? 'jpeg';
-            const blob = await canvasToBlob(canvas, mimeForVideo(codec), opts.quality ?? 0.82);
-            const payload = new Uint8Array(await blob.arrayBuffer());
-            shell.emitFrame(encodeMediaFrame({
-                kind: 'video-frame',
-                codec,
-                seq: ++seq,
-                tMono: nowMono(),
-                width: w,
-                height: h,
-            }, payload), seq);
+            ctx.drawImage(bitmap ?? video, 0, 0, w, h);
+            bitmap?.close?.();
+            const blob = await canvasToBlob(canvas, mimeForVideo(codec), quality);
+            emitVideoFrame(new Uint8Array(await blob.arrayBuffer()), codec, w, h);
         }
         catch (e) {
             shell.setState('error', e);
@@ -461,10 +548,11 @@ function createVideoSource(opts = {}) {
         }
     }
     function stop() {
-        if (timer) {
-            clearInterval(timer);
-            timer = null;
-        }
+        stopTicker?.();
+        stopTicker = null;
+        imageCapture = null;
+        encodeWorker?.terminate?.();
+        encodeWorker = null;
         stopTracks(stream);
         stream = null;
         if (!opts.video && video) {
@@ -478,7 +566,7 @@ function createVideoSource(opts = {}) {
     async function start() {
         try {
             ensureSocketTransport(transport);
-            if (!hasGetUserMedia()) {
+            if (!opts.stream && !hasGetUserMedia()) {
                 shell.setState('no-device');
                 return shell.state;
             }
@@ -490,26 +578,47 @@ function createVideoSource(opts = {}) {
             stop();
             shell.setState('requesting');
             shell.stats.startedAt = nowMono();
-            stream = await globalThis.navigator.mediaDevices.getUserMedia({
+            stream = await resolveMediaStream(opts.stream, () => globalThis.navigator.mediaDevices.getUserMedia({
                 video: {
                     deviceId: deviceId ? { exact: deviceId } : undefined,
                     width: opts.width,
                     height: opts.height,
                 },
-            });
+            }));
             video = video ?? doc.createElement('video');
             video.muted = true;
             video.playsInline = true;
             video.srcObject = stream;
             await video.play?.();
-            canvas = canvas ?? doc.createElement('canvas');
+            const track = stream?.getVideoTracks?.()?.[0];
+            const ImageCaptureCtor = globalThis.ImageCapture;
+            try {
+                imageCapture = track && typeof ImageCaptureCtor == 'function' ? new ImageCaptureCtor(track) : null;
+            }
+            catch {
+                imageCapture = null;
+            }
+            const g = globalThis;
+            if (opts.worker != false && imageCapture && g.Worker && g.Blob && g.URL && g.OffscreenCanvas) {
+                try {
+                    const blob = new g.Blob([videoEncodeWorkerCode()], { type: 'text/javascript' });
+                    const url = g.URL.createObjectURL(blob);
+                    encodeWorker = new g.Worker(url);
+                    g.URL.revokeObjectURL(url);
+                }
+                catch {
+                    encodeWorker = null;
+                }
+            }
+            const OffscreenCanvasCtor = g.OffscreenCanvas;
+            canvas = canvas ?? (OffscreenCanvasCtor ? new OffscreenCanvasCtor(1, 1) : doc.createElement('canvas'));
             ctx = canvas.getContext('2d');
             if (!ctx)
                 throw new Error('2d canvas context is not available');
             shell.setState('live');
             const ms = Math.max(1, Math.round(1000 / (opts.fps ?? 3)));
             await captureOne();
-            timer = setInterval(captureOne, ms);
+            stopTicker = startCaptureTicker(ms, captureOne, opts.worker != false);
             return shell.state;
         }
         catch (e) {

package/lib/Common/media/media-view.d.ts

@@ -0,0 +1,42 @@
+type tMediaLine = {
+    on(cb: (frame: any, sentAt?: number) => void): () => void;
+};
+export type AttachVideoCanvasOpts = {
+    createBitmap?: (blob: any) => Promise<any>;
+    onError?: (e: unknown) => void;
+};
+export declare function attachVideoCanvas(line: tMediaLine, canvas: any, opts?: AttachVideoCanvasOpts): {
+    stats: () => {
+        frames: number;
+        drawn: number;
+        perSec: number;
+        ageMs: number;
+        width: number;
+        height: number;
+    };
+    off: () => void;
+};
+export type AttachAudioPlayerOpts = {
+    maxBacklogSec?: number;
+    audioContext?: () => any;
+    onError?: (e: unknown) => void;
+};
+export declare function attachAudioPlayer(line: tMediaLine, opts?: AttachAudioPlayerOpts): {
+    enable(): void;
+    disable(): void;
+    readonly enabled: boolean;
+    stats: () => {
+        frames: number;
+        played: number;
+        dropped: number;
+        perSec: number;
+        ageMs: number;
+    };
+    off: () => void;
+};
+export type PipeMediaPublishOpts = {
+    stamp?: boolean;
+    onError?: (e: unknown) => void;
+};
+export declare function pipeMediaPublish(line: tMediaLine, publish: (frame: Uint8Array, sentAt?: number) => unknown, opts?: PipeMediaPublishOpts): () => void;
+export {};

package/lib/Common/media/media-view.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachVideoCanvas = attachVideoCanvas;
+exports.attachAudioPlayer = attachAudioPlayer;
+exports.pipeMediaPublish = pipeMediaPublish;
+const media_source_1 = require("./media-source");
+function mimeForCodec(codec) {
+    if (codec == 'png')
+        return 'image/png';
+    if (codec == 'webp')
+        return 'image/webp';
+    return 'image/jpeg';
+}
+function createAgeMeter() {
+    let ageMs = 0;
+    return {
+        note(sentAt) {
+            if (typeof sentAt != 'number')
+                return;
+            const age = Date.now() - sentAt;
+            ageMs = ageMs ? Math.round(ageMs * 0.8 + age * 0.2) : age;
+        },
+        get ageMs() { return ageMs; },
+    };
+}
+function createRateMeter() {
+    let windowStart = 0;
+    let windowCount = 0;
+    let perSec = 0;
+    return {
+        note() {
+            const now = Date.now();
+            if (now - windowStart >= 1000) {
+                perSec = windowStart ? windowCount : 0;
+                windowStart = now;
+                windowCount = 0;
+            }
+            windowCount++;
+        },
+        get perSec() { return perSec; },
+    };
+}
+function attachVideoCanvas(line, canvas, opts = {}) {
+    const ctx = canvas.getContext('2d');
+    if (!ctx)
+        throw new Error('2d canvas context is not available');
+    const makeBitmap = opts.createBitmap ?? function defaultBitmap(blob) {
+        const create = globalThis.createImageBitmap;
+        if (typeof create != 'function')
+            throw new Error('createImageBitmap is not available');
+        return create(blob);
+    };
+    const age = createAgeMeter();
+    const rate = createRateMeter();
+    let frames = 0;
+    let drawn = 0;
+    let width = 0;
+    let height = 0;
+    let busy = false;
+    const off = line.on(async function onVideoFrame(raw, sentAt) {
+        frames++;
+        age.note(sentAt);
+        rate.note();
+        if (busy)
+            return;
+        busy = true;
+        try {
+            const f = (0, media_source_1.decodeMediaFrame)((0, media_source_1.toBytes)(raw));
+            if (f.kind != 'video-frame' || !f.width || !f.height)
+                return;
+            const bitmap = await makeBitmap(new Blob([f.payload.slice()], { type: mimeForCodec(f.codec) }));
+            if (canvas.width != f.width)
+                canvas.width = f.width;
+            if (canvas.height != f.height)
+                canvas.height = f.height;
+            ctx.drawImage(bitmap, 0, 0);
+            bitmap?.close?.();
+            width = f.width;
+            height = f.height;
+            drawn++;
+        }
+        catch (e) {
+            opts.onError?.(e);
+        }
+        finally {
+            busy = false;
+        }
+    });
+    return {
+        stats: () => ({ frames, drawn, perSec: rate.perSec, ageMs: age.ageMs, width, height }),
+        off,
+    };
+}
+function attachAudioPlayer(line, opts = {}) {
+    const maxBacklogSec = opts.maxBacklogSec ?? 0.35;
+    const age = createAgeMeter();
+    const rate = createRateMeter();
+    let audioCtx = null;
+    let playhead = 0;
+    let frames = 0;
+    let played = 0;
+    let dropped = 0;
+    function makeContext() {
+        if (opts.audioContext)
+            return opts.audioContext();
+        const Ctor = globalThis.AudioContext ?? globalThis.webkitAudioContext;
+        if (!Ctor)
+            throw new Error('AudioContext is not available');
+        return new Ctor();
+    }
+    function toSamples(codec, payload) {
+        const copy = payload.slice();
+        if (codec == 'float32')
+            return new Float32Array(copy.buffer);
+        if (codec != 'pcm16')
+            return null;
+        const pcm = new Int16Array(copy.buffer);
+        const out = new Float32Array(pcm.length);
+        for (let i = 0; i < pcm.length; i++)
+            out[i] = pcm[i] / 0x8000;
+        return out;
+    }
+    function push(raw) {
+        const f = (0, media_source_1.decodeMediaFrame)((0, media_source_1.toBytes)(raw));
+        if (f.kind != 'audio-pcm')
+            return;
+        const samples = toSamples(f.codec, f.payload);
+        if (!samples)
+            return;
+        const channels = f.channels || 1;
+        const sampleRate = f.sampleRate || 48000;
+        const nFrames = Math.floor(samples.length / channels);
+        if (!nFrames)
+            return;
+        if (playhead - audioCtx.currentTime > maxBacklogSec) {
+            playhead = audioCtx.currentTime + 0.05;
+            dropped++;
+        }
+        const buf = audioCtx.createBuffer(channels, nFrames, sampleRate);
+        for (let ch = 0; ch < channels; ch++) {
+            const chan = buf.getChannelData(ch);
+            for (let i = 0; i < nFrames; i++)
+                chan[i] = samples[i * channels + ch];
+        }
+        const node = audioCtx.createBufferSource();
+        node.buffer = buf;
+        node.connect(audioCtx.destination);
+        const at = Math.max(audioCtx.currentTime + 0.05, playhead);
+        node.start(at);
+        playhead = at + nFrames / sampleRate;
+        played++;
+    }
+    const off = line.on(function onAudioFrame(raw, sentAt) {
+        frames++;
+        age.note(sentAt);
+        rate.note();
+        if (!audioCtx)
+            return;
+        try {
+            push(raw);
+        }
+        catch (e) {
+            opts.onError?.(e);
+        }
+    });
+    return {
+        enable() {
+            audioCtx = audioCtx ?? makeContext();
+            playhead = 0;
+            void audioCtx.resume?.();
+        },
+        disable() {
+            void audioCtx?.close?.();
+            audioCtx = null;
+        },
+        get enabled() { return !!audioCtx; },
+        stats: () => ({ frames, played, dropped, perSec: rate.perSec, ageMs: age.ageMs }),
+        off,
+    };
+}
+function pipeMediaPublish(line, publish, opts = {}) {
+    return line.on(function publishFrame(frame) {
+        try {
+            Promise.resolve(publish(frame, opts.stamp == false ? undefined : Date.now()))
+                .catch(function onPublishFail(e) { opts.onError?.(e); });
+        }
+        catch (e) {
+            opts.onError?.(e);
+        }
+    });
+}

package/lib/Common/peer/peer-client.d.ts

@@ -2,7 +2,7 @@ import { StoreDrain, StorePatch } from '../Observe/store';
 import { ReplayRemote } from '../events/replay-wire';
 import { RoutePolicy } from '../events/route-coordinator';
 import { RtcPeerConnection, SignalEnvelope } from '../events/route-signal-webrtc';
-import { PatchEnvelope } from './peer-relay';
+import { PatchEnvelope, RelayPushResult, tRelayGap } from './peer-relay';
 export type PeerRemote = {
     signal: {
         send: (env: SignalEnvelope) => Promise<boolean | void>;
@@ -10,10 +10,13 @@ export type PeerRemote = {
             on: (cb: (env: SignalEnvelope) => void) => any;
         };
     };
-    publish: (env: PatchEnvelope) => Promise<boolean | void> | boolean | void;
-    peers: Record<string, ReplayRemote<[StorePatch]>>;
+    publish: (env: PatchEnvelope) => Promise<RelayPushResult | void> | RelayPushResult | void;
+    peers: Record<string, ReplayRemote<[StorePatch]> & {
+        seq?: () => number | Promise<number>;
+    }>;
 };
-export type PeerClientDeps<T extends object> = {
+export type tPublishRepair<J extends tRelayGap = 'resume'> = J extends 'sacred' ? 'tail' : 'tail' | 'keyframe';
+export type PeerClientDeps<T extends object, J extends tRelayGap = 'resume'> = {
     remote: PeerRemote;
     account: string;
     initial: T;
@@ -22,10 +25,13 @@ export type PeerClientDeps<T extends object> = {
     accept?: (env: SignalEnvelope) => boolean | Promise<boolean>;
     policy?: RoutePolicy;
     peerInitial?: () => T;
+    journal?: J;
+    repair?: tPublishRepair<J>;
+    onPublishError?: (e: unknown) => void;
     history?: number;
     drain?: StoreDrain;
 };
-export declare function createPeerClient<T extends object>(deps: PeerClientDeps<T>): {
+export declare function createPeerClient<T extends object, J extends tRelayGap = 'resume'>(deps: PeerClientDeps<T, J>): {
     store: import("../Observe/store").Store<T>;
     peer: (other: string) => {
         account: string;
@@ -41,6 +47,7 @@ export declare function createPeerClient<T extends object>(deps: PeerClientDeps<
         close(): void;
     };
     onRoute: (cb: (ev: import("../events/route-coordinator").RouteChangeEvent) => void) => import("../..").ListenOff;
+    resync: () => Promise<void>;
     close(): void;
 };
 export type PeerClient<T extends object> = ReturnType<typeof createPeerClient<T>>;

package/lib/Common/peer/peer-client.js

@@ -7,15 +7,64 @@ const replay_wire_1 = require("../events/replay-wire");
 const route_coordinator_1 = require("../events/route-coordinator");
 const route_signal_webrtc_1 = require("../events/route-signal-webrtc");
 function createPeerClient(deps) {
-    const { remote, account, initial, rtc, session, accept, policy, peerInitial = () => ({}), history, drain, } = deps;
+    const { remote, account, initial, rtc, session, accept, policy, peerInitial = () => ({}), history, drain, journal = 'resume', onPublishError, } = deps;
+    const repair = deps.repair ?? 'tail';
     const store = (0, store_1.createStore)(initial, drain !== undefined ? { drain } : {});
     const exposed = (0, store_replay_1.exposeStoreReplay)(store, history !== undefined ? { history } : {});
+    let repairing = null;
+    function repairEnvelopes(from) {
+        const line = exposed.replay;
+        if (repair == 'tail' && from >= 0) {
+            const tail = line.getSince(from);
+            if (tail)
+                return tail;
+            if (journal == 'sacred') {
+                throw new Error('peer publish: local journal evicted seq ' + from + ', sacred relay is unrepairable — raise {history}');
+            }
+        }
+        const kf = exposed.replay.keyframe();
+        return kf ? [kf] : [];
+    }
+    async function runRepair(from) {
+        for (const env of repairEnvelopes(from)) {
+            const res = await remote.publish(env);
+            if (res != null && typeof res == 'object') {
+                throw new Error('peer publish: repair rejected at relay seq ' + res.seq);
+            }
+        }
+    }
+    function queueRepair(from) {
+        if (repairing)
+            return;
+        repairing = runRepair(from)
+            .catch(function reportRepairError(e) {
+            if (onPublishError)
+                onPublishError(e);
+            else
+                setTimeout(function rethrowRepairError() { throw e; }, 0);
+        })
+            .finally(() => { repairing = null; });
+    }
+    function handleVerdict(res) {
+        if (res != null && typeof res == 'object' && typeof res.seq == 'number')
+            queueRepair(res.seq);
+    }
     const offPublish = exposed.replay.line.on(function publishEnvelope(env) {
-        void remote.publish(env);
+        Promise.resolve(remote.publish(env)).then(handleVerdict, function onPublishReject(e) {
+            onPublishError?.(e);
+        });
     });
     const warmup = exposed.replay.keyframe();
     if (warmup)
-        void remote.publish(warmup);
+        Promise.resolve(remote.publish(warmup)).then(handleVerdict, e => onPublishError?.(e));
+    async function resync() {
+        const node = remote.peers[account];
+        const relaySeq = Number(await node?.seq?.() ?? -1);
+        const localSeq = exposed.replay.keyframe()?.seq ?? -1;
+        if (relaySeq >= localSeq)
+            return;
+        await runRepair(relaySeq);
+    }
     const port = {
         send: env => remote.signal.send(env),
         signals: { on: cb => remote.signal.signals.on(cb) },
@@ -96,6 +145,7 @@ function createPeerClient(deps) {
         store,
         peer,
         onRoute: coord.onRoute,
+        resync,
         close() {
             for (const view of Array.from(views.values()))
                 view.close();

package/lib/Common/peer/peer-host.d.ts

@@ -1,10 +1,11 @@
 import { StorePatch } from '../Observe/store';
 import { ReplayRemote } from '../events/replay-wire';
 import { SignalEnvelope } from '../events/route-signal-webrtc';
-import { PatchEnvelope } from './peer-relay';
+import { PatchEnvelope, tRelayGap } from './peer-relay';
 export type PeerHostDeps = {
     authorize?: (env: SignalEnvelope) => boolean | Promise<boolean>;
     history?: number;
+    gap?: tRelayGap;
 };
 export declare function createPeerHost(deps?: PeerHostDeps): {
     connection: (account: string) => {
@@ -13,14 +14,17 @@ export declare function createPeerHost(deps?: PeerHostDeps): {
                 send: (env: SignalEnvelope) => Promise<boolean>;
                 signals: import("../..").ListenApi<[SignalEnvelope]>;
             };
-            publish: (env: PatchEnvelope) => boolean;
+            publish: (env: PatchEnvelope) => import("./peer-relay").RelayPushResult;
             peers: Record<string, ReplayRemote<[StorePatch]>>;
         };
         close: () => void;
     };
     relay: (account: string) => {
-        push: (env: PatchEnvelope) => boolean;
-        remote: ReplayRemote<[StorePatch]>;
+        push: (env: PatchEnvelope) => import("./peer-relay").RelayPushResult;
+        remote: ReplayRemote<[StorePatch]> & {
+            seq: () => number;
+        };
+        gap: tRelayGap;
         seq: () => number;
         snapshot: () => any;
         close: () => void;

package/lib/Common/peer/peer-host.js

@@ -5,14 +5,14 @@ const rpc_dynamic_1 = require("../rcp/rpc-dynamic");
 const route_signal_webrtc_1 = require("../events/route-signal-webrtc");
 const peer_relay_1 = require("./peer-relay");
 function createPeerHost(deps = {}) {
-    const { authorize, history } = deps;
+    const { authorize, history, gap } = deps;
     const hub = (0, route_signal_webrtc_1.createSignalHub)({ authorize });
     const relays = new Map();
     const peersView = (0, rpc_dynamic_1.noStrict)({});
     function ensureRelay(account) {
         let relay = relays.get(account);
         if (!relay) {
-            relay = (0, peer_relay_1.createPatchRelayJournal)({ history });
+            relay = (0, peer_relay_1.createPatchRelayJournal)({ history, gap });
             relays.set(account, relay);
             peersView[account] = relay.remote;
         }

package/lib/Common/peer/peer-relay.d.ts

@@ -2,11 +2,19 @@ import { ReplayEvent } from '../events/replay-listen';
 import { ReplayRemote } from '../events/replay-wire';
 import { StorePatch } from '../Observe/store';
 export type PatchEnvelope = ReplayEvent<[StorePatch]>;
+export type tRelayGap = 'resume' | 'sacred';
+export type RelayPushResult = boolean | {
+    seq: number;
+};
 export declare function createPatchRelayJournal(opts?: {
     history?: number;
+    gap?: tRelayGap;
 }): {
-    push: (env: PatchEnvelope) => boolean;
-    remote: ReplayRemote<[StorePatch]>;
+    push: (env: PatchEnvelope) => RelayPushResult;
+    remote: ReplayRemote<[StorePatch]> & {
+        seq: () => number;
+    };
+    gap: tRelayGap;
     seq: () => number;
     snapshot: () => any;
     close: () => void;