wenay-common2 1.0.66 → 1.0.68

package/lib/Common/events/route-coordinator.d.ts

@@ -0,0 +1,274 @@
+import { Listener } from './Listen';
+import { ReplayRemote } from './replay-wire';
+import { ReplayRouteSubscribeOpts } from './replay-route';
+export type tRouteKind = 'relay' | 'direct';
+export type tConnectorState = 'idle' | 'opening' | 'open' | 'closed' | 'failed';
+export type RouteConnectorInfo = {
+    label: string;
+    kind: tRouteKind;
+    binary?: boolean;
+    ordered?: boolean;
+    reliable?: boolean;
+};
+export type RouteConnectorMetrics = {
+    rtt?: number;
+    pending?: number;
+};
+export type RouteConnector<Z extends any[] = any[]> = {
+    info: RouteConnectorInfo;
+    open: () => Promise<ReplayRemote<Z>> | ReplayRemote<Z>;
+    close: () => void;
+    state: () => tConnectorState;
+    metrics?: () => RouteConnectorMetrics;
+    onFail?: {
+        on: (cb: (reason?: unknown) => void) => any;
+    };
+};
+export type RoutePairRef = {
+    a: string;
+    b: string;
+    key: string;
+};
+export type RoutePolicyCtx = RoutePairRef & {
+    state: tRouteState;
+    reason?: unknown;
+};
+type tPolicyHook = (ctx: RoutePolicyCtx) => boolean | Promise<boolean>;
+export type RoutePolicy = {
+    canDirect?: tPolicyHook;
+    mustRelay?: tPolicyHook;
+    mustShadowRelay?: tPolicyHook;
+    canExposeEndpoint?: tPolicyHook;
+    canReinterpose?: tPolicyHook;
+};
+export type tRouteState = 'relay' | 'direct:connecting' | 'direct' | 'direct+shadowRelay' | 'relay:reinterposing' | 'fallback' | 'blocked' | 'closed';
+export type RouteChangeEvent = RoutePairRef & {
+    from: tRouteState;
+    to: tRouteState;
+    reason?: unknown;
+};
+export type RouteOpResult = {
+    ok: boolean;
+    state: tRouteState;
+    reason?: unknown;
+};
+export type PromoteDirectOpts = {
+    timeoutMs?: number;
+    reason?: unknown;
+};
+export type RouteCoordinatorDeps<Z extends any[] = any[]> = {
+    policy?: RoutePolicy;
+    connect: (ref: RoutePairRef, kind: tRouteKind) => RouteConnector<Z>;
+    shadow?: (ref: RoutePairRef, ...ev: Z) => void;
+    catchUpTimeoutMs?: number;
+};
+export declare function createRouteCoordinator<Z extends any[] = any[]>(deps: RouteCoordinatorDeps<Z>): {
+    pair(a: string, b: string): {
+        ref: RoutePairRef;
+        state: () => tRouteState;
+        reason: () => unknown;
+        label: () => string;
+        metrics: () => {
+            relay: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+            direct: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+        };
+        subscribe: (cb: Listener<Z>, opts?: Omit<ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+            ready: Promise<void>;
+            seq: () => number;
+            label: () => string | undefined;
+            active: () => boolean;
+        };
+        promoteDirect: (opts?: PromoteDirectOpts) => Promise<RouteOpResult>;
+        reinterposeRelay: (reason?: unknown) => Promise<RouteOpResult>;
+        fallback: (reason?: unknown) => Promise<RouteOpResult>;
+        block: (reason?: unknown) => Promise<RouteOpResult>;
+        close: () => void;
+    };
+    state: (pairOrKey: {
+        ref: RoutePairRef;
+        state: () => tRouteState;
+        reason: () => unknown;
+        label: () => string;
+        metrics: () => {
+            relay: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+            direct: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+        };
+        subscribe: (cb: Listener<Z>, opts?: Omit<ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+            ready: Promise<void>;
+            seq: () => number;
+            label: () => string | undefined;
+            active: () => boolean;
+        };
+        promoteDirect: (opts?: PromoteDirectOpts) => Promise<RouteOpResult>;
+        reinterposeRelay: (reason?: unknown) => Promise<RouteOpResult>;
+        fallback: (reason?: unknown) => Promise<RouteOpResult>;
+        block: (reason?: unknown) => Promise<RouteOpResult>;
+        close: () => void;
+    } | RoutePairRef | string) => tRouteState;
+    promoteDirect: (pairOrKey: {
+        ref: RoutePairRef;
+        state: () => tRouteState;
+        reason: () => unknown;
+        label: () => string;
+        metrics: () => {
+            relay: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+            direct: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+        };
+        subscribe: (cb: Listener<Z>, opts?: Omit<ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+            ready: Promise<void>;
+            seq: () => number;
+            label: () => string | undefined;
+            active: () => boolean;
+        };
+        promoteDirect: (opts?: PromoteDirectOpts) => Promise<RouteOpResult>;
+        reinterposeRelay: (reason?: unknown) => Promise<RouteOpResult>;
+        fallback: (reason?: unknown) => Promise<RouteOpResult>;
+        block: (reason?: unknown) => Promise<RouteOpResult>;
+        close: () => void;
+    } | RoutePairRef | string, opts?: PromoteDirectOpts) => Promise<RouteOpResult>;
+    reinterposeRelay: (pairOrKey: {
+        ref: RoutePairRef;
+        state: () => tRouteState;
+        reason: () => unknown;
+        label: () => string;
+        metrics: () => {
+            relay: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+            direct: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+        };
+        subscribe: (cb: Listener<Z>, opts?: Omit<ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+            ready: Promise<void>;
+            seq: () => number;
+            label: () => string | undefined;
+            active: () => boolean;
+        };
+        promoteDirect: (opts?: PromoteDirectOpts) => Promise<RouteOpResult>;
+        reinterposeRelay: (reason?: unknown) => Promise<RouteOpResult>;
+        fallback: (reason?: unknown) => Promise<RouteOpResult>;
+        block: (reason?: unknown) => Promise<RouteOpResult>;
+        close: () => void;
+    } | RoutePairRef | string, reason?: unknown) => Promise<RouteOpResult>;
+    fallback: (pairOrKey: {
+        ref: RoutePairRef;
+        state: () => tRouteState;
+        reason: () => unknown;
+        label: () => string;
+        metrics: () => {
+            relay: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+            direct: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+        };
+        subscribe: (cb: Listener<Z>, opts?: Omit<ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+            ready: Promise<void>;
+            seq: () => number;
+            label: () => string | undefined;
+            active: () => boolean;
+        };
+        promoteDirect: (opts?: PromoteDirectOpts) => Promise<RouteOpResult>;
+        reinterposeRelay: (reason?: unknown) => Promise<RouteOpResult>;
+        fallback: (reason?: unknown) => Promise<RouteOpResult>;
+        block: (reason?: unknown) => Promise<RouteOpResult>;
+        close: () => void;
+    } | RoutePairRef | string, reason?: unknown) => Promise<RouteOpResult>;
+    block: (pairOrKey: {
+        ref: RoutePairRef;
+        state: () => tRouteState;
+        reason: () => unknown;
+        label: () => string;
+        metrics: () => {
+            relay: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+            direct: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+        };
+        subscribe: (cb: Listener<Z>, opts?: Omit<ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+            ready: Promise<void>;
+            seq: () => number;
+            label: () => string | undefined;
+            active: () => boolean;
+        };
+        promoteDirect: (opts?: PromoteDirectOpts) => Promise<RouteOpResult>;
+        reinterposeRelay: (reason?: unknown) => Promise<RouteOpResult>;
+        fallback: (reason?: unknown) => Promise<RouteOpResult>;
+        block: (reason?: unknown) => Promise<RouteOpResult>;
+        close: () => void;
+    } | RoutePairRef | string, reason?: unknown) => Promise<RouteOpResult>;
+    onRoute: (cb: (ev: RouteChangeEvent) => void) => import("./Listen").ListenOff;
+    pairs: () => {
+        ref: RoutePairRef;
+        state: () => tRouteState;
+        reason: () => unknown;
+        label: () => string;
+        metrics: () => {
+            relay: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+            direct: {
+                rtt?: number;
+                pending?: number;
+                state: tConnectorState;
+            } | null;
+        };
+        subscribe: (cb: Listener<Z>, opts?: Omit<ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+            ready: Promise<void>;
+            seq: () => number;
+            label: () => string | undefined;
+            active: () => boolean;
+        };
+        promoteDirect: (opts?: PromoteDirectOpts) => Promise<RouteOpResult>;
+        reinterposeRelay: (reason?: unknown) => Promise<RouteOpResult>;
+        fallback: (reason?: unknown) => Promise<RouteOpResult>;
+        block: (reason?: unknown) => Promise<RouteOpResult>;
+        close: () => void;
+    }[];
+    close(): void;
+};
+export type RouteCoordinator<Z extends any[] = any[]> = ReturnType<typeof createRouteCoordinator<Z>>;
+export type RouteLink<Z extends any[] = any[]> = ReturnType<RouteCoordinator<Z>['pair']>;
+export {};

package/lib/Common/events/route-coordinator.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouteCoordinator = createRouteCoordinator;
+const Listen_1 = require("./Listen");
+const replay_route_1 = require("./replay-route");
+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 lazyRemote(connector) {
+    let opened = null;
+    const get = () => opened ??= Promise.resolve(connector.open());
+    function lazyLine(pick) {
+        return {
+            on(cb) {
+                let off = null;
+                let dead = false;
+                get().then(function attachLazyLine(r) { if (!dead)
+                    off = pick(r).on(cb); }, function swallowOpenError() { });
+                return function offLazyLine() { dead = true; unsubscribeHandle(off); };
+            },
+        };
+    }
+    return {
+        line: lazyLine(r => r.line),
+        frameLine: lazyLine(r => r.frameLine ?? r.line),
+        since: async (seq) => (await get()).since(seq),
+        keyframe: async () => (await get()).keyframe(),
+        frame: async (seq, hint) => {
+            const r = await get();
+            return r.frame ? r.frame(seq, hint) : null;
+        },
+    };
+}
+function createRouteCoordinator(deps) {
+    const { policy = {}, connect, shadow, catchUpTimeoutMs } = deps;
+    const links = new Map();
+    const [emitRoute, routeListen] = (0, Listen_1.listen)();
+    async function allowed(hook, ctx, absent = true) {
+        return hook ? !!(await hook(ctx)) : absent;
+    }
+    function pairKey(a, b) {
+        return a <= b ? a + '|' + b : b + '|' + a;
+    }
+    function createLink(a, b) {
+        const ref = { a, b, key: pairKey(a, b) };
+        let state = 'relay';
+        let lastReason;
+        let relayConn = null;
+        let relayRemote = null;
+        let directConn = null;
+        let directRemote = null;
+        let shadowSub = null;
+        const subs = new Set();
+        let opChain = Promise.resolve();
+        function chained(run) {
+            const p = opChain.then(run, run);
+            opChain = p.catch(() => { });
+            return p;
+        }
+        function setState(to, reason) {
+            if (state == 'closed')
+                return;
+            const from = state;
+            state = to;
+            lastReason = reason;
+            emitRoute({ ...ref, from, to, reason });
+        }
+        function ctx(reason) {
+            return { ...ref, state, reason };
+        }
+        function ensureRelay() {
+            if (!relayConn || relayConn.state() == 'closed' || relayConn.state() == 'failed') {
+                relayConn = connect(ref, 'relay');
+                relayRemote = lazyRemote(relayConn);
+                watchFail(relayConn, 'relay');
+            }
+            return relayRemote;
+        }
+        function watchFail(conn, kind) {
+            conn.onFail?.on(function onConnectorFail(reason) {
+                if (kind == 'relay') {
+                    if (conn == relayConn)
+                        emitRoute({ ...ref, from: state, to: state, reason });
+                    return;
+                }
+                if (conn == directConn && (state == 'direct' || state == 'direct+shadowRelay')) {
+                    demoteToRelay('fallback', reason).catch(() => { });
+                }
+            });
+        }
+        function currentRemote() {
+            const direct = (state == 'direct' || state == 'direct+shadowRelay') && directRemote;
+            return direct || ensureRelay();
+        }
+        function currentLabel() {
+            const direct = (state == 'direct' || state == 'direct+shadowRelay') && directConn;
+            return direct ? directConn.info.label : (relayConn?.info.label ?? 'relay');
+        }
+        async function switchSubs(remote, label, timeoutMs) {
+            const jobs = Array.from(subs, function switchOne(sub) { return sub.switch(remote, { label }); });
+            if (timeoutMs == null)
+                return Promise.all(jobs);
+            let timer;
+            const timeout = new Promise((_, reject) => {
+                timer = setTimeout(function catchUpTimeout() {
+                    reject(new Error('route catch-up timeout: ' + label));
+                }, timeoutMs);
+            });
+            try {
+                await Promise.race([Promise.all(jobs), timeout]);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        function resyncStraySubs() {
+            const remote = currentRemote();
+            const label = currentLabel();
+            for (const sub of subs) {
+                if (sub.label() != label)
+                    sub.switch(remote, { label }).catch(() => { });
+            }
+        }
+        function attachShadow() {
+            if (!shadow || shadowSub)
+                return;
+            const since = subs.size ? Math.min(...Array.from(subs, sub => sub.seq())) : -1;
+            shadowSub = (0, replay_route_1.replayRouteSubscribe)(ensureRelay(), function shadowTap(...ev) { shadow(ref, ...ev); }, { label: 'shadowRelay', since });
+        }
+        function dropShadow() {
+            shadowSub?.();
+            shadowSub = null;
+        }
+        function closeDirect() {
+            dropShadow();
+            directConn?.close();
+            directConn = null;
+            directRemote = null;
+        }
+        async function demoteToRelay(finalState, reason) {
+            return chained(async function demoteOp() {
+                if (state == 'blocked' || state == 'closed')
+                    return { ok: false, state, reason: state };
+                if (state != 'direct' && state != 'direct+shadowRelay') {
+                    if (finalState == 'fallback')
+                        setState('fallback', reason);
+                    return { ok: true, state };
+                }
+                if (finalState == 'relay' && !(await allowed(policy.canReinterpose, ctx(reason)))) {
+                    return { ok: false, state, reason: 'policy: canReinterpose' };
+                }
+                setState('relay:reinterposing', reason);
+                const remote = ensureRelay();
+                try {
+                    await switchSubs(remote, relayConn.info.label);
+                    closeDirect();
+                    setState(finalState, reason);
+                    resyncStraySubs();
+                    return { ok: true, state };
+                }
+                catch (e) {
+                    setState(shadowSub ? 'direct+shadowRelay' : 'direct', e);
+                    return { ok: false, state, reason: e };
+                }
+            });
+        }
+        async function promoteDirect(opts = {}) {
+            return chained(async function promoteOp() {
+                const { timeoutMs = catchUpTimeoutMs, reason } = opts;
+                if (state == 'blocked' || state == 'closed')
+                    return { ok: false, state, reason: state };
+                if (state == 'direct' || state == 'direct+shadowRelay')
+                    return { ok: true, state };
+                if (await allowed(policy.mustRelay, ctx(reason), false)) {
+                    return { ok: false, state, reason: 'policy: mustRelay' };
+                }
+                if (!(await allowed(policy.canDirect, ctx(reason)))) {
+                    return { ok: false, state, reason: 'policy: canDirect' };
+                }
+                if (!(await allowed(policy.canExposeEndpoint, ctx(reason)))) {
+                    return { ok: false, state, reason: 'policy: canExposeEndpoint' };
+                }
+                const wantShadow = await allowed(policy.mustShadowRelay, ctx(reason), false);
+                setState('direct:connecting', reason);
+                const conn = connect(ref, 'direct');
+                const remote = lazyRemote(conn);
+                try {
+                    await switchSubs(remote, conn.info.label, timeoutMs);
+                    directConn = conn;
+                    directRemote = remote;
+                    watchFail(conn, 'direct');
+                    if (wantShadow) {
+                        setState('direct+shadowRelay', reason);
+                        attachShadow();
+                    }
+                    else {
+                        relayConn?.close();
+                        relayConn = null;
+                        relayRemote = null;
+                        setState('direct', reason);
+                    }
+                    resyncStraySubs();
+                    return { ok: true, state };
+                }
+                catch (e) {
+                    conn.close();
+                    try {
+                        await switchSubs(ensureRelay(), relayConn.info.label);
+                    }
+                    catch { }
+                    setState('fallback', e);
+                    return { ok: false, state, reason: e };
+                }
+            });
+        }
+        function block(reason) {
+            return chained(async function blockOp() {
+                if (state == 'closed')
+                    return { ok: false, state, reason: state };
+                closeDirect();
+                relayConn?.close();
+                relayConn = null;
+                relayRemote = null;
+                for (const sub of Array.from(subs))
+                    sub();
+                subs.clear();
+                setState('blocked', reason);
+                return { ok: true, state };
+            });
+        }
+        function subscribe(cb, opts = {}) {
+            if (state == 'blocked' || state == 'closed') {
+                throw new Error('route coordinator: pair ' + ref.key + ' is ' + state);
+            }
+            const sub = (0, replay_route_1.replayRouteSubscribe)(currentRemote(), cb, { ...opts, label: currentLabel() });
+            subs.add(sub);
+            function off() {
+                subs.delete(sub);
+                sub();
+            }
+            return Object.assign(off, {
+                ready: sub.ready,
+                seq: sub.seq,
+                label: sub.label,
+                active: sub.active,
+            });
+        }
+        function close() {
+            if (state == 'closed')
+                return;
+            closeDirect();
+            relayConn?.close();
+            relayConn = null;
+            relayRemote = null;
+            for (const sub of Array.from(subs))
+                sub();
+            subs.clear();
+            links.delete(ref.key);
+            setState('closed');
+        }
+        const link = {
+            ref,
+            state: () => state,
+            reason: () => lastReason,
+            label: currentLabel,
+            metrics: () => ({
+                relay: relayConn ? { state: relayConn.state(), ...relayConn.metrics?.() } : null,
+                direct: directConn ? { state: directConn.state(), ...directConn.metrics?.() } : null,
+            }),
+            subscribe,
+            promoteDirect,
+            reinterposeRelay: (reason) => demoteToRelay('relay', reason),
+            fallback: (reason) => demoteToRelay('fallback', reason),
+            block,
+            close,
+        };
+        return link;
+    }
+    function resolve(pairOrKey) {
+        const key = typeof pairOrKey == 'string' ? pairOrKey
+            : 'ref' in pairOrKey ? pairOrKey.ref.key : pairOrKey.key;
+        const link = links.get(key);
+        if (!link)
+            throw new Error('route coordinator: unknown pair ' + key);
+        return link;
+    }
+    return {
+        pair(a, b) {
+            const key = pairKey(a, b);
+            let link = links.get(key);
+            if (!link || link.state() == 'closed') {
+                link = createLink(a, b);
+                links.set(key, link);
+            }
+            return link;
+        },
+        state: (pairOrKey) => resolve(pairOrKey).state(),
+        promoteDirect: (pairOrKey, opts) => resolve(pairOrKey).promoteDirect(opts),
+        reinterposeRelay: (pairOrKey, reason) => resolve(pairOrKey).reinterposeRelay(reason),
+        fallback: (pairOrKey, reason) => resolve(pairOrKey).fallback(reason),
+        block: (pairOrKey, reason) => resolve(pairOrKey).block(reason),
+        onRoute: (cb) => routeListen.on(cb),
+        pairs: () => Array.from(links.values()),
+        close() {
+            for (const link of Array.from(links.values()))
+                link.close();
+        },
+    };
+}

package/lib/Common/events/route-signal-webrtc.d.ts

@@ -0,0 +1,83 @@
+import { ReplayRemote } from './replay-wire';
+import { RouteConnector } from './route-coordinator';
+import { ReplayMessageChannel } from './replay-channel';
+export type tSignalType = 'offer' | 'answer' | 'ice' | 'revoke' | 'close';
+export type SignalEnvelope = {
+    type: tSignalType;
+    pair: string;
+    from: string;
+    to: string;
+    sdp?: string;
+    candidate?: unknown;
+    session?: unknown;
+    reason?: string;
+};
+export type SignalPort = {
+    send: (env: SignalEnvelope) => Promise<boolean | void> | boolean | void;
+    signals: {
+        on: (cb: (env: SignalEnvelope) => void) => any;
+    };
+};
+export declare function createSignalHub(deps?: {
+    authorize?: (env: SignalEnvelope) => boolean | Promise<boolean>;
+}): {
+    register: (account: string) => {
+        account: string;
+        send: (env: SignalEnvelope) => Promise<boolean>;
+        signals: import("./Listen").ListenApi<[SignalEnvelope]>;
+        close: () => void;
+    };
+    revoke: (pair: string, accounts: string[], reason?: string) => void;
+    accounts: () => string[];
+    close(): void;
+};
+export type SignalHub = ReturnType<typeof createSignalHub>;
+export type RtcSessionDescription = {
+    type: string;
+    sdp?: string;
+};
+export type RtcDataChannel = {
+    send: (data: string) => void;
+    close: () => void;
+    onopen?: ((ev?: unknown) => void) | null;
+    onmessage?: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onclose?: ((ev?: unknown) => void) | null;
+    onerror?: ((ev?: unknown) => void) | null;
+};
+export type RtcPeerConnection = {
+    createDataChannel: (label: string, opts?: unknown) => RtcDataChannel;
+    createOffer: () => Promise<RtcSessionDescription>;
+    createAnswer: () => Promise<RtcSessionDescription>;
+    setLocalDescription: (d: RtcSessionDescription) => Promise<unknown> | unknown;
+    setRemoteDescription: (d: RtcSessionDescription) => Promise<unknown> | unknown;
+    addIceCandidate: (c: unknown) => Promise<unknown> | unknown;
+    close: () => void;
+    onicecandidate?: ((ev: {
+        candidate?: unknown;
+    }) => void) | null;
+    ondatachannel?: ((ev: {
+        channel: RtcDataChannel;
+    }) => void) | null;
+};
+export declare function channelFromDataChannel(dc: RtcDataChannel): ReplayMessageChannel;
+export type WebRtcConnectorDeps = {
+    port: SignalPort;
+    rtc: () => RtcPeerConnection;
+    self: string;
+    peer: string;
+    pair: string;
+    session?: unknown;
+    label?: string;
+    openTimeoutMs?: number;
+};
+export declare function createWebRtcConnector<Z extends any[] = any[]>(deps: WebRtcConnectorDeps): RouteConnector<Z>;
+export type WebRtcAcceptDeps<Z extends any[]> = {
+    port: SignalPort;
+    rtc: () => RtcPeerConnection;
+    self: string;
+    serve: (env: SignalEnvelope) => ReplayRemote<Z> | null | Promise<ReplayRemote<Z> | null>;
+    accept?: (env: SignalEnvelope) => boolean | Promise<boolean>;
+};
+export declare function acceptWebRtcDirect<Z extends any[] = any[]>(deps: WebRtcAcceptDeps<Z>): () => void;