wenay-react2 1.0.47 → 1.0.49

package/lib/common/demo/fakeRtcLoopback.d.ts

@@ -0,0 +1,17 @@
+/**
+ * In-process fake WebRTC runtime for the conference demo and its tests, ported from
+ * the wenay-common2 acceptance oracle (replay/route-webrtc.test.ts). SDP = pc id,
+ * ICE trickle is simulated, a datachannel is a pair of in-proc endpoints. It is
+ * injected exactly like a browser would inject `() => new RTCPeerConnection(cfg)`,
+ * so the demo can run where real WebRTC is unavailable (jsdom, sandboxed panes).
+ */
+import { Replay } from "wenay-common2";
+export declare function createFakeRtcNet(): {
+    pc: () => Replay.RtcPeerConnection;
+    stats: {
+        ice: number;
+        channels: number;
+    };
+    killLiveChannels: () => number;
+};
+export type FakeRtcNet = ReturnType<typeof createFakeRtcNet>;

package/lib/common/demo/fakeRtcLoopback.js

@@ -0,0 +1,108 @@
+export function createFakeRtcNet() {
+    let n = 0;
+    const pcs = new Map();
+    const stats = { ice: 0, channels: 0 };
+    const liveChannels = new Set();
+    function makeDcPair() {
+        let closed = false;
+        function side(other) {
+            const me = { onopen: null, onmessage: null, onclose: null, onerror: null };
+            me.send = (data) => {
+                if (closed)
+                    return;
+                setTimeout(function deliverDc() { if (!closed)
+                    other().onmessage?.({ data }); }, 0);
+            };
+            me.close = () => {
+                if (closed)
+                    return;
+                closed = true;
+                liveChannels.delete(me);
+                setTimeout(function closeDc() { me.onclose?.(); other().onclose?.(); }, 0);
+            };
+            return me;
+        }
+        let a, b;
+        a = side(() => b);
+        b = side(() => a);
+        liveChannels.add(a);
+        return [a, b];
+    }
+    function tryConnect(me) {
+        if (!me.local || !me.remote)
+            return;
+        const other = pcs.get(me.remote.sdp ?? "");
+        if (!other || !other.local || !other.remote || other.remote.sdp !== me.id)
+            return;
+        const initiator = me.pendingDcs.length ? me : other;
+        const responder = initiator === me ? other : me;
+        if (!initiator.pendingDcs.length || initiator.linked)
+            return;
+        initiator.linked = responder.linked = true;
+        for (const dc of initiator.pendingDcs) {
+            const [a, b] = makeDcPair();
+            // the pre-created local end is linked to its newborn twin
+            dc.attach(a);
+            stats.channels++;
+            setTimeout(function announceChannel() {
+                responder.pc.ondatachannel?.({ channel: b });
+                dc.fireOpen();
+            }, 0);
+        }
+        initiator.pendingDcs = [];
+    }
+    function pc() {
+        const id = "sdp-" + (++n);
+        const me = { id, local: null, remote: null, pendingDcs: [], linked: false, pc: null };
+        const api = {
+            createDataChannel() {
+                // the local end exists BEFORE the connection: methods delegate after attach
+                let real = null;
+                const shell = { onopen: null, onmessage: null, onclose: null, onerror: null };
+                shell.send = (data) => real?.send(data);
+                shell.close = () => real?.close();
+                me.pendingDcs.push({
+                    attach(a) {
+                        real = a;
+                        if (!a)
+                            return;
+                        a.onmessage = (ev) => shell.onmessage?.(ev);
+                        a.onclose = () => shell.onclose?.();
+                    },
+                    fireOpen() { shell.onopen?.(); },
+                });
+                return shell;
+            },
+            createOffer: async () => ({ type: "offer", sdp: id }),
+            createAnswer: async () => ({ type: "answer", sdp: id }),
+            setLocalDescription(d) {
+                me.local = d;
+                setTimeout(function trickleIce() { api.onicecandidate?.({ candidate: { via: id } }); }, 0);
+            },
+            setRemoteDescription(d) {
+                me.remote = d;
+                tryConnect(me);
+            },
+            addIceCandidate() { stats.ice++; },
+            close() {
+                for (const dc of me.pendingDcs)
+                    dc.attach(null);
+                me.pendingDcs = [];
+            },
+            onicecandidate: null,
+            ondatachannel: null,
+        };
+        me.pc = api;
+        pcs.set(id, me);
+        return api;
+    }
+    /** The "kill direct transport" drill: closing a live end fires onclose on both
+     *  sides, which the webrtc connector reports as a transport failure. */
+    function killLiveChannels() {
+        const doomed = [...liveChannels];
+        for (const dc of doomed)
+            dc.close();
+        return doomed.length;
+    }
+    return { pc, stats, killLiveChannels };
+}

package/lib/common/demo/peerConference.d.ts

@@ -0,0 +1,449 @@
+import { Peer, Replay } from "wenay-common2";
+export type ConfFrame = {
+    n: number;
+    at: number;
+    image: string;
+};
+export type ConfLine = [ConfFrame, number];
+export type ConferenceWorldOptions = {
+    /** Seat accounts; the FIRST one is the room host (places the star calls) and the focus viewer. */
+    accounts?: string[];
+    /** Injected WebRTC runtime, `() => new RTCPeerConnection(cfg)` in a browser. */
+    rtc?: () => Replay.RtcPeerConnection;
+    /** Transport-death drill; defaults to closing every RTCPeerConnection this world created. */
+    killTransport?: () => void;
+    /** Synthetic painter fps; 0 disables timers (drive frames via tick() in tests). */
+    fps?: number;
+    /** Frame factory override for environments without DOM/canvas semantics. */
+    frame?: (account: string, n: number) => ConfFrame;
+    room?: string;
+};
+export declare function createConferenceWorld(options?: ConferenceWorldOptions): {
+    accounts: string[];
+    hostAccount: string;
+    viewer: string;
+    room: string;
+    managers: Map<string, {
+        ready: Promise<void>;
+        call: (other: string, meta?: unknown) => {
+            id: string;
+            peer: string;
+            direction: "out" | "in";
+            meta: unknown;
+            state: () => Peer.tCallState;
+            reason: () => Peer.tCallEnd | null;
+            changed: import("wenay-common2").ListenApi<[Peer.tCallState]>;
+            ended: Promise<Peer.tCallEnd>;
+            accept(): void;
+            decline(why?: Peer.tCallEnd): void;
+            hangup(): void;
+        };
+        rings: import("wenay-common2").ListenApi<[{
+            id: string;
+            peer: string;
+            direction: "out" | "in";
+            meta: unknown;
+            state: () => Peer.tCallState;
+            reason: () => Peer.tCallEnd | null;
+            changed: import("wenay-common2").ListenApi<[Peer.tCallState]>;
+            ended: Promise<Peer.tCallEnd>;
+            accept(): void;
+            decline(why?: Peer.tCallEnd): void;
+            hangup(): void;
+        }]>;
+        active: () => {
+            id: string;
+            peer: string;
+            direction: "out" | "in";
+            meta: unknown;
+            state: () => Peer.tCallState;
+            reason: () => Peer.tCallEnd | null;
+            changed: import("wenay-common2").ListenApi<[Peer.tCallState]>;
+            ended: Promise<Peer.tCallEnd>;
+            accept(): void;
+            decline(why?: Peer.tCallEnd): void;
+            hangup(): void;
+        } | null;
+        close(): void;
+    }>;
+    relay: {
+        publishOf: (account: string) => (line: string, frame: unknown, sentAt: number) => void;
+        watch: Record<string, Record<string, {
+            emit: import("wenay-common2").Listener<[unknown, number]>;
+            head: () => number;
+            isStale: () => boolean;
+            lastTs: () => number;
+            close: () => void;
+            getSince: (seq: number) => Replay.ReplayEvent<[unknown, number]>[] | undefined;
+            line: import("wenay-common2").ListenApi<[Replay.ReplayEvent<[unknown, number]>]>;
+            hasKeyframe: boolean;
+            keyframe: () => Replay.ReplayEvent<[unknown, number]> | undefined;
+            frame: (sinceSeq: number, hint?: unknown) => Replay.ReplayEvent<[unknown, number]>[];
+            on: Replay.ListenOnReplay<[unknown, number]>;
+            once: (cb: import("wenay-common2").Listener<[unknown, number]>, opts?: {
+                key?: string | symbol;
+                current?: import("wenay-common2").ListenCurrent<[unknown, number]> | undefined;
+            } | undefined) => () => void;
+            has(key: import("wenay-common2").ListenKey): boolean;
+            off(keyOrCallback: import("wenay-common2").ListenKey | import("wenay-common2").Listener<[unknown, number]> | null): void;
+            count(): number;
+            keys(): import("wenay-common2").ListenKey[];
+            isRunning(): boolean;
+            run(): void;
+            onClose(cb: () => void): import("wenay-common2").ListenOff;
+        }>>;
+        watchOf: (watcher: string) => Record<string, Record<string, {
+            emit: import("wenay-common2").Listener<[unknown, number]>;
+            head: () => number;
+            isStale: () => boolean;
+            lastTs: () => number;
+            close: () => void;
+            getSince: (seq: number) => Replay.ReplayEvent<[unknown, number]>[] | undefined;
+            line: import("wenay-common2").ListenApi<[Replay.ReplayEvent<[unknown, number]>]>;
+            hasKeyframe: boolean;
+            keyframe: () => Replay.ReplayEvent<[unknown, number]> | undefined;
+            frame: (sinceSeq: number, hint?: unknown) => Replay.ReplayEvent<[unknown, number]>[];
+            on: Replay.ListenOnReplay<[unknown, number]>;
+            once: (cb: import("wenay-common2").Listener<[unknown, number]>, opts?: {
+                key?: string | symbol;
+                current?: import("wenay-common2").ListenCurrent<[unknown, number]> | undefined;
+            } | undefined) => () => void;
+            has(key: import("wenay-common2").ListenKey): boolean;
+            off(keyOrCallback: import("wenay-common2").ListenKey | import("wenay-common2").Listener<[unknown, number]> | null): void;
+            count(): number;
+            keys(): import("wenay-common2").ListenKey[];
+            isRunning(): boolean;
+            run(): void;
+            onClose(cb: () => void): import("wenay-common2").ListenOff;
+        }>>;
+        lines: (account: string) => Record<string, {
+            emit: import("wenay-common2").Listener<[unknown, number]>;
+            head: () => number;
+            isStale: () => boolean;
+            lastTs: () => number;
+            close: () => void;
+            getSince: (seq: number) => Replay.ReplayEvent<[unknown, number]>[] | undefined;
+            line: import("wenay-common2").ListenApi<[Replay.ReplayEvent<[unknown, number]>]>;
+            hasKeyframe: boolean;
+            keyframe: () => Replay.ReplayEvent<[unknown, number]> | undefined;
+            frame: (sinceSeq: number, hint?: unknown) => Replay.ReplayEvent<[unknown, number]>[];
+            on: Replay.ListenOnReplay<[unknown, number]>;
+            once: (cb: import("wenay-common2").Listener<[unknown, number]>, opts?: {
+                key?: string | symbol;
+                current?: import("wenay-common2").ListenCurrent<[unknown, number]> | undefined;
+            } | undefined) => () => void;
+            has(key: import("wenay-common2").ListenKey): boolean;
+            off(keyOrCallback: import("wenay-common2").ListenKey | import("wenay-common2").Listener<[unknown, number]> | null): void;
+            count(): number;
+            keys(): import("wenay-common2").ListenKey[];
+            isRunning(): boolean;
+            run(): void;
+            onClose(cb: () => void): import("wenay-common2").ListenOff;
+        }>;
+        accounts: () => string[];
+        dropAccount: (account: string) => void;
+        close(): void;
+    };
+    coordinator: {
+        pair(a: string, b: string): {
+            ref: Replay.RoutePairRef;
+            state: () => Replay.tRouteState;
+            reason: () => unknown;
+            label: () => string;
+            metrics: () => {
+                relay: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+                direct: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+            };
+            subscribe: (cb: import("wenay-common2").Listener<ConfLine>, opts?: Omit<Replay.ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+                ready: Promise<void>;
+                seq: () => number;
+                label: () => string | undefined;
+                active: () => boolean;
+            };
+            promoteDirect: (opts?: Replay.PromoteDirectOpts) => Promise<Replay.RouteOpResult>;
+            reinterposeRelay: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            fallback: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            block: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            close: () => void;
+        };
+        state: (pairOrKey: string | Replay.RoutePairRef | {
+            ref: Replay.RoutePairRef;
+            state: () => Replay.tRouteState;
+            reason: () => unknown;
+            label: () => string;
+            metrics: () => {
+                relay: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+                direct: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+            };
+            subscribe: (cb: import("wenay-common2").Listener<ConfLine>, opts?: Omit<Replay.ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+                ready: Promise<void>;
+                seq: () => number;
+                label: () => string | undefined;
+                active: () => boolean;
+            };
+            promoteDirect: (opts?: Replay.PromoteDirectOpts) => Promise<Replay.RouteOpResult>;
+            reinterposeRelay: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            fallback: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            block: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            close: () => void;
+        }) => Replay.tRouteState;
+        promoteDirect: (pairOrKey: string | Replay.RoutePairRef | {
+            ref: Replay.RoutePairRef;
+            state: () => Replay.tRouteState;
+            reason: () => unknown;
+            label: () => string;
+            metrics: () => {
+                relay: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+                direct: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+            };
+            subscribe: (cb: import("wenay-common2").Listener<ConfLine>, opts?: Omit<Replay.ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+                ready: Promise<void>;
+                seq: () => number;
+                label: () => string | undefined;
+                active: () => boolean;
+            };
+            promoteDirect: (opts?: Replay.PromoteDirectOpts) => Promise<Replay.RouteOpResult>;
+            reinterposeRelay: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            fallback: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            block: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            close: () => void;
+        }, opts?: Replay.PromoteDirectOpts) => Promise<Replay.RouteOpResult>;
+        reinterposeRelay: (pairOrKey: string | Replay.RoutePairRef | {
+            ref: Replay.RoutePairRef;
+            state: () => Replay.tRouteState;
+            reason: () => unknown;
+            label: () => string;
+            metrics: () => {
+                relay: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+                direct: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+            };
+            subscribe: (cb: import("wenay-common2").Listener<ConfLine>, opts?: Omit<Replay.ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+                ready: Promise<void>;
+                seq: () => number;
+                label: () => string | undefined;
+                active: () => boolean;
+            };
+            promoteDirect: (opts?: Replay.PromoteDirectOpts) => Promise<Replay.RouteOpResult>;
+            reinterposeRelay: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            fallback: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            block: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            close: () => void;
+        }, reason?: unknown) => Promise<Replay.RouteOpResult>;
+        fallback: (pairOrKey: string | Replay.RoutePairRef | {
+            ref: Replay.RoutePairRef;
+            state: () => Replay.tRouteState;
+            reason: () => unknown;
+            label: () => string;
+            metrics: () => {
+                relay: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+                direct: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+            };
+            subscribe: (cb: import("wenay-common2").Listener<ConfLine>, opts?: Omit<Replay.ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+                ready: Promise<void>;
+                seq: () => number;
+                label: () => string | undefined;
+                active: () => boolean;
+            };
+            promoteDirect: (opts?: Replay.PromoteDirectOpts) => Promise<Replay.RouteOpResult>;
+            reinterposeRelay: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            fallback: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            block: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            close: () => void;
+        }, reason?: unknown) => Promise<Replay.RouteOpResult>;
+        block: (pairOrKey: string | Replay.RoutePairRef | {
+            ref: Replay.RoutePairRef;
+            state: () => Replay.tRouteState;
+            reason: () => unknown;
+            label: () => string;
+            metrics: () => {
+                relay: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+                direct: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+            };
+            subscribe: (cb: import("wenay-common2").Listener<ConfLine>, opts?: Omit<Replay.ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+                ready: Promise<void>;
+                seq: () => number;
+                label: () => string | undefined;
+                active: () => boolean;
+            };
+            promoteDirect: (opts?: Replay.PromoteDirectOpts) => Promise<Replay.RouteOpResult>;
+            reinterposeRelay: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            fallback: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            block: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            close: () => void;
+        }, reason?: unknown) => Promise<Replay.RouteOpResult>;
+        onRoute: (cb: (ev: Replay.RouteChangeEvent) => void) => import("wenay-common2").ListenOff;
+        pairs: () => {
+            ref: Replay.RoutePairRef;
+            state: () => Replay.tRouteState;
+            reason: () => unknown;
+            label: () => string;
+            metrics: () => {
+                relay: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+                direct: {
+                    rtt?: number;
+                    pending?: number;
+                    state: Replay.tConnectorState;
+                } | null;
+            };
+            subscribe: (cb: import("wenay-common2").Listener<ConfLine>, opts?: Omit<Replay.ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+                ready: Promise<void>;
+                seq: () => number;
+                label: () => string | undefined;
+                active: () => boolean;
+            };
+            promoteDirect: (opts?: Replay.PromoteDirectOpts) => Promise<Replay.RouteOpResult>;
+            reinterposeRelay: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            fallback: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            block: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+            close: () => void;
+        }[];
+        close(): void;
+    };
+    focus: (owner: string) => {
+        ref: Replay.RoutePairRef;
+        state: () => Replay.tRouteState;
+        reason: () => unknown;
+        label: () => string;
+        metrics: () => {
+            relay: {
+                rtt?: number;
+                pending?: number;
+                state: Replay.tConnectorState;
+            } | null;
+            direct: {
+                rtt?: number;
+                pending?: number;
+                state: Replay.tConnectorState;
+            } | null;
+        };
+        subscribe: (cb: import("wenay-common2").Listener<ConfLine>, opts?: Omit<Replay.ReplayRouteSubscribeOpts, "label">) => (() => void) & {
+            ready: Promise<void>;
+            seq: () => number;
+            label: () => string | undefined;
+            active: () => boolean;
+        };
+        promoteDirect: (opts?: Replay.PromoteDirectOpts) => Promise<Replay.RouteOpResult>;
+        reinterposeRelay: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+        fallback: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+        block: (reason?: unknown) => Promise<Replay.RouteOpResult>;
+        close: () => void;
+    };
+    ring: (member: string) => {
+        id: string;
+        peer: string;
+        direction: "out" | "in";
+        meta: unknown;
+        state: () => Peer.tCallState;
+        reason: () => Peer.tCallEnd | null;
+        changed: import("wenay-common2").ListenApi<[Peer.tCallState]>;
+        ended: Promise<Peer.tCallEnd>;
+        accept(): void;
+        decline(why?: Peer.tCallEnd): void;
+        hangup(): void;
+    };
+    hostCalls: Map<string, {
+        id: string;
+        peer: string;
+        direction: "out" | "in";
+        meta: unknown;
+        state: () => Peer.tCallState;
+        reason: () => Peer.tCallEnd | null;
+        changed: import("wenay-common2").ListenApi<[Peer.tCallState]>;
+        ended: Promise<Peer.tCallEnd>;
+        accept(): void;
+        decline(why?: Peer.tCallEnd): void;
+        hangup(): void;
+    }>;
+    roster: () => string[];
+    inRoster: (account: string) => boolean;
+    changed: import("wenay-common2").ListenApi<[]>;
+    lineOf: (account: string) => {
+        emit: import("wenay-common2").Listener<ConfLine>;
+        head: () => number;
+        isStale: () => boolean;
+        lastTs: () => number;
+        close: () => void;
+        getSince: (seq: number) => Replay.ReplayEvent<ConfLine>[] | undefined;
+        line: import("wenay-common2").ListenApi<[Replay.ReplayEvent<ConfLine>]>;
+        hasKeyframe: boolean;
+        keyframe: () => Replay.ReplayEvent<ConfLine> | undefined;
+        frame: (sinceSeq: number, hint?: unknown) => Replay.ReplayEvent<ConfLine>[];
+        on: Replay.ListenOnReplay<ConfLine>;
+        once: (cb: import("wenay-common2").Listener<ConfLine>, opts?: {
+            key?: string | symbol;
+            current?: import("wenay-common2").ListenCurrent<ConfLine> | undefined;
+        } | undefined) => () => void;
+        has(key: import("wenay-common2").ListenKey): boolean;
+        off(keyOrCallback: import("wenay-common2").ListenKey | import("wenay-common2").Listener<ConfLine> | null): void;
+        count(): number;
+        keys(): import("wenay-common2").ListenKey[];
+        isRunning(): boolean;
+        run(): void;
+        onClose(cb: () => void): import("wenay-common2").ListenOff;
+    };
+    frameNumber: (account: string) => number;
+    tick: (only?: string) => void;
+    setForceRelay(on: boolean): void;
+    setAllowEndpoint(on: boolean): void;
+    getPolicy: () => {
+        forceRelay: boolean;
+        allowEndpoint: boolean;
+    };
+    revokeDirect: (owner: string) => void;
+    killDirect: () => void;
+    close: () => void;
+};
+export type ConferenceWorld = ReturnType<typeof createConferenceWorld>;
+export declare const ConferenceCallDemo: () => import("react/jsx-runtime").JSX.Element;