wenay-common2 1.0.67 → 1.0.68

package/doc/ROADMAP.md

@@ -119,9 +119,9 @@ Acceptance tests for 0.1:
 - account map uses `noStrict`, but all access checks live in policy/facade code;
 - `createStoreManager` starts/stops selected per-account mirrors without store-core changes.
 
-Open questions: signaling envelope; whether the relay sees payloads or only coordinates encrypted
-direct streams; backpressure across multi-hop and direct paths; group topology beyond a pair of
-accounts; `noStrict(accountMap)` / `createStoreManager` lifecycle integration for dynamic peer maps.
+Open questions: whether the relay sees payloads or only coordinates encrypted direct streams;
+backpressure across multi-hop and direct paths; group topology beyond a pair of accounts;
+`noStrict(accountMap)` / `createStoreManager` lifecycle integration for dynamic peer maps.
 
 Status: 🟡 partial (2026-07-09, v1.0.67). Core implemented as `Replay.createRouteCoordinator`
 (`src/Common/events/route-coordinator.ts`): `RouteConnector` contract (pure transport: open/close/state/
@@ -130,9 +130,15 @@ metrics/onFail/capabilities), all five policy hooks, the full state machine abov
 continuity through `replayRouteSubscribe`. Acceptance oracle: `replay/route-coordinator.test.ts` over
 fake in-process connectors — policy denial never touches transport, promotion keeps the old relay live,
 failed/slow direct falls back gap-free, re-interposition resumes from `seq`, shadow relay observes the
-switch window, revocation closes direct without facade changes, block is terminal. Still open: real
-signaling adapter + WebRTC connector (steps 9-10 of `doc/target/webrtc-route-coordinator-tasks.md`) and
-the account-map lifecycle integration.
+switch window, revocation closes direct without facade changes, block is terminal.
+v1.0.68 added step 9: `createSignalHub` (offer/answer/ICE/session/revoke over the EXISTING socket/RPC
+control channel; `authorize` = server-side `canExposeEndpoint`), `createWebRtcConnector` /
+`acceptWebRtcDirect` (RTCPeerConnection injected as a runtime factory, structural types, no lib.dom),
+and `serveReplayChannel`/`channelReplayRemote` (replay wire over any ordered channel — the datachannel
+path bypasses the RPC core by design). Oracle `replay/route-webrtc.test.ts` drives promotion, endpoint
+denial, session rejection, and server revoke over both an in-proc hub and a real Socket.IO/RPC wire.
+Still open: browser/Node WebRTC glue (step 10 — now a one-line `rtc` factory plus media re-emit) and
+the account-map lifecycle integration (step 7).
 
 ## 1. Connection hand-off — relay ↔ direct promotion ("port forwarding") 🟡
 
@@ -154,10 +160,13 @@ starts flowing on the new path.
   catch it up from the last delivered `seq`, then close the old route. This covers relay → direct
   promotion and direct → relay re-interposition for any ordered `ReplayRemote`; overlap is deduped by
   `seq`, and a failed replacement leaves the old route active.
-- Open questions: signaling channel that negotiates the direct endpoint; fallback if the direct path
-  never establishes (stay on relay); auth continuity across the swap; per-socketKey vs whole-connection
-  hand-off; policy trigger and catch-up boundary for direct → relay re-interposition.
-- Status: 🟡 partial. Route hand-off/resume helper is implemented and covered by `replay/route-handoff.test.ts`; signaling, direct endpoint negotiation, NAT/WebRTC adapter, auth-continuity policy, and trigger rules remain open.
+- Open questions: auth continuity across the swap; per-socketKey vs whole-connection hand-off;
+  policy trigger rules for direct → relay re-interposition beyond explicit calls and `onFail`.
+- Status: 🟡 mostly done. Route hand-off/resume: `replay/route-handoff.test.ts`. Route decisions +
+  state machine: `createRouteCoordinator` (v1.0.67). Signaling + direct endpoint negotiation over the
+  existing control channel and fallback-if-never-establishes: `createSignalHub` /
+  `createWebRtcConnector` / `acceptWebRtcDirect` (v1.0.68, `replay/route-webrtc.test.ts`). Remaining:
+  real NAT/WebRTC runtime glue (injected `rtc` factory) and auth-continuity policy.
 
 ## 2. Coordinated fan-out send to a large group 🧊
 

package/doc/changes/1.0.68.md

@@ -0,0 +1,8 @@
+# 1.0.68
+
+- Add `Replay.createSignalHub`: WebRTC signaling (offer/answer/ICE/session/revoke envelopes) routed between accounts over the EXISTING socket/RPC control channel — the port shape `{send, signals}` is exposable by `createRpcServerAuto` as is; `authorize(env)` is the server-side `canExposeEndpoint` enforcement point, `from`-spoofing is cut at the port.
+- Add `Replay.createWebRtcConnector`: the direct `RouteConnector` for `createRouteCoordinator` — `open()` negotiates offer/answer/ICE through a signal port and returns a replay wire over the datachannel. `RTCPeerConnection` is NOT bundled: `rtc` is an injected runtime factory (browser `() => new RTCPeerConnection(cfg)`, Node werift/node-datachannel, tests an in-proc fake) over structural `RtcPeerConnection`/`RtcDataChannel` types (no lib.dom).
+- Add `Replay.acceptWebRtcDirect`: responder side — answers offers, serves `exposeReplay(...)` into the incoming datachannel; `accept(env)` validates opaque session material and rejects with a loud `revoke` so the initiator fails fast instead of timing out.
+- Add `Replay.serveReplayChannel` / `channelReplayRemote` / `channelFromDataChannel`: replay wire over any ordered string channel (datachannel/MessagePort/worker/pipe) via a tiny JSON sub/req/res protocol — no RPC core on the direct path; channel close surfaces as a non-envelope (loud `onError`), never silence.
+- Revoke/close signals and channel death during `open()` abort the pending promotion immediately (no `openTimeoutMs` wait); the coordinator auto-falls back to relay from the last `seq`.
+- Add oracle `replay/route-webrtc.test.ts`: fake in-proc RTC runtime + signaling hub (promotion, server-side endpoint denial, bad session revoke, server revoke fallback, recovery into direct) and the same signaling driven over a real Socket.IO/RPC wire.

package/doc/wenay-common2-rare.md

@@ -511,6 +511,31 @@ createRouteCoordinator({connect, policy?, shadow?, catchUpTimeoutMs?}) -> coordi
   // direct+shadowRelay: payload rides direct while deps.shadow(ref, ...ev) receives the relay audit copy,
   //   starting from the consumers' seq coordinate — the switch window never escapes the audit.
   // Acceptance oracle: replay/route-coordinator.test.ts (fake in-process relay/direct connectors).
+createSignalHub({authorize?}) -> {register(account) -> {send, signals, close}, revoke(pair, accounts, reason?), accounts(), close()}
+  // WebRTC signaling over the EXISTING control channel: the port shape {send, signals} is a function +
+  //   Listen — exactly what createRpcServerAuto exposes, so the relay socket IS the signaling wire
+  //   (per connection: const port = hub.register(account); object = {send: port.send, signals: port.signals}).
+  // authorize(env) is the SERVER-side canExposeEndpoint point — endpoint/session material is revealed only
+  //   past it; client-side coordinator policy stays advisory. from-spoofing is cut at the port.
+  // SignalEnvelope = {type: 'offer'|'answer'|'ice'|'revoke'|'close', pair, from, to, sdp?, candidate?,
+  //   session?, reason?} — session is opaque auth material (the wire never looks inside).
+createWebRtcConnector({port, rtc, self, peer, pair, session?, label?, openTimeoutMs?}) -> RouteConnector
+  // the direct connector for createRouteCoordinator: open() drives offer/answer/ICE through the signal
+  //   port, waits for the datachannel, returns a replay wire over it. RTCPeerConnection is NOT bundled:
+  //   rtc is a runtime factory — browser `() => new RTCPeerConnection(cfg)`, Node werift/node-datachannel,
+  //   tests an in-proc fake (RtcPeerConnection/RtcDataChannel are structural types, no lib.dom).
+  //   revoke/close signals and channel death (incl. DURING open) fail loudly -> coordinator auto-fallback.
+acceptWebRtcDirect({port, rtc, self, serve, accept?}) -> close()
+  // responder side: on offer, negotiates answer/ICE and serves serve(env) (exposeReplay(...) as is) into
+  //   the incoming datachannel; accept(env) validates session material and rejects with a loud revoke
+  //   (the initiator fails fast, not by timeout). Repeated offer for a pair recreates the session.
+serveReplayChannel(source, channel) <-> channelReplayRemote(channel) -> ReplayRemote
+  // replay wire over ANY ordered string channel (datachannel/MessagePort/worker/pipe): tiny JSON
+  //   sub/req/res protocol, no RPC core — a direct channel lives OUTSIDE the main rpc connection.
+  //   Channel close = non-envelope (null) on the line: replay subscribers report onError, never silence.
+  //   ReplayMessageChannel = {send, onMessage, onClose?, close?}; channelFromDataChannel(dc) adapts a
+  //   datachannel (and owns its handlers). Oracle: replay/route-webrtc.test.ts (fake RTC runtime +
+  //   in-proc hub + the same signaling over a real Socket.IO/RPC wire).
 exposeStoreReplay(store, opts?)  <->  syncStoreReplay(mirror, remote, opts?)            // layer B: patch line; keyframe = root patch ({path: [], value: snapshot})
 syncStoreReplayRoute(mirror, remote, opts?) -> off & {ready, switch(nextRemote, opts), seq(), label(), active()}   // same patch fold, but route-replaceable for relay/direct promotion
 syncStoreReplayEach<T>(remote, cb, opts?) -> off & {store, ready, seq(), isStale(), lastTs()}   // one-call per-key fold over the patch line (mirror + syncStoreReplay + store.each()); most-used surface — full contract + example in wenay-common2.md

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

@@ -0,0 +1,9 @@
+import { ReplayRemote } from './replay-wire';
+export type ReplayMessageChannel = {
+    send: (data: string) => void;
+    onMessage: (cb: (data: string) => void) => (() => void) | void;
+    onClose?: (cb: () => void) => (() => void) | void;
+    close?: () => void;
+};
+export declare function serveReplayChannel<Z extends any[]>(source: ReplayRemote<Z>, channel: ReplayMessageChannel): () => void;
+export declare function channelReplayRemote<Z extends any[]>(channel: ReplayMessageChannel): ReplayRemote<Z>;

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveReplayChannel = serveReplayChannel;
+exports.channelReplayRemote = channelReplayRemote;
+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 serveReplayChannel(source, channel) {
+    let lineOff = null;
+    let closed = false;
+    async function handleRequest(msg) {
+        try {
+            const v = msg.m == 'since' ? await source.since(msg.a[0])
+                : msg.m == 'keyframe' ? await source.keyframe()
+                    : msg.m == 'frame' ? (source.frame ? await source.frame(msg.a[0], msg.a[1]) : null)
+                        : undefined;
+            if (!closed)
+                channel.send(JSON.stringify({ t: 'res', id: msg.id, ok: true, v: v ?? null }));
+        }
+        catch (e) {
+            if (!closed)
+                channel.send(JSON.stringify({ t: 'res', id: msg.id, ok: false, e: String(e) }));
+        }
+    }
+    const offMsg = channel.onMessage(function onReplayChannelMessage(raw) {
+        if (closed)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (msg?.t == 'sub' && !lineOff) {
+            lineOff = source.line.on(function forwardEnvelope(ev) {
+                if (!closed)
+                    channel.send(JSON.stringify({ t: 'ev', ev }));
+            });
+            return;
+        }
+        if (msg?.t == 'req')
+            void handleRequest(msg);
+    });
+    function close() {
+        if (closed)
+            return;
+        closed = true;
+        unsubscribeHandle(lineOff);
+        lineOff = null;
+        if (typeof offMsg == 'function')
+            offMsg();
+    }
+    channel.onClose?.(close);
+    return close;
+}
+function channelReplayRemote(channel) {
+    let nextId = 1;
+    let subscribed = false;
+    let closed = false;
+    const pending = new Map();
+    const lineCbs = new Set();
+    channel.onMessage(function onRemoteChannelMessage(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (msg?.t == 'ev') {
+            for (const cb of Array.from(lineCbs))
+                cb(msg.ev);
+            return;
+        }
+        if (msg?.t == 'res') {
+            const p = pending.get(msg.id);
+            pending.delete(msg.id);
+            if (!p)
+                return;
+            if (msg.ok)
+                p.resolve(msg.v);
+            else
+                p.reject(new Error(msg.e ?? 'replay channel request failed'));
+        }
+    });
+    channel.onClose?.(function onRemoteChannelClosed() {
+        if (closed)
+            return;
+        closed = true;
+        for (const [, p] of pending)
+            p.reject(new Error('replay channel closed'));
+        pending.clear();
+        for (const cb of Array.from(lineCbs))
+            cb(null);
+        lineCbs.clear();
+    });
+    function req(m, a) {
+        if (closed)
+            return Promise.reject(new Error('replay channel closed'));
+        return new Promise((resolve, reject) => {
+            const id = nextId++;
+            pending.set(id, { resolve, reject });
+            channel.send(JSON.stringify({ t: 'req', id, m, a }));
+        });
+    }
+    return {
+        line: {
+            on(cb) {
+                lineCbs.add(cb);
+                if (!subscribed && !closed) {
+                    subscribed = true;
+                    channel.send(JSON.stringify({ t: 'sub' }));
+                }
+                return function offChannelLine() { lineCbs.delete(cb); };
+            },
+        },
+        since: seq => req('since', [seq]),
+        keyframe: () => req('keyframe', []),
+        frame: (seq, hint) => req('frame', [seq, hint]),
+    };
+}

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

@@ -4,3 +4,5 @@ export * from './replay-conflate';
 export * from './replay-history';
 export * from './replay-route';
 export * from './route-coordinator';
+export * from './replay-channel';
+export * from './route-signal-webrtc';

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

@@ -20,3 +20,5 @@ __exportStar(require("./replay-conflate"), exports);
 __exportStar(require("./replay-history"), exports);
 __exportStar(require("./replay-route"), exports);
 __exportStar(require("./route-coordinator"), exports);
+__exportStar(require("./replay-channel"), exports);
+__exportStar(require("./route-signal-webrtc"), exports);

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;

package/lib/Common/events/route-signal-webrtc.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignalHub = createSignalHub;
+exports.channelFromDataChannel = channelFromDataChannel;
+exports.createWebRtcConnector = createWebRtcConnector;
+exports.acceptWebRtcDirect = acceptWebRtcDirect;
+const Listen_1 = require("./Listen");
+const replay_channel_1 = require("./replay-channel");
+function createSignalHub(deps = {}) {
+    const { authorize } = deps;
+    const ports = new Map();
+    function register(account) {
+        const [emit, signals] = (0, Listen_1.listen)();
+        ports.set(account, emit);
+        async function send(env) {
+            if (env == null || env.from != account)
+                return false;
+            if (authorize && !(await authorize(env)))
+                return false;
+            const target = ports.get(env.to);
+            if (!target)
+                return false;
+            target(env);
+            return true;
+        }
+        function close() {
+            if (ports.get(account) == emit)
+                ports.delete(account);
+            signals.close();
+        }
+        return { account, send, signals, close };
+    }
+    function revoke(pair, accounts, reason) {
+        for (const account of accounts) {
+            ports.get(account)?.({ type: 'revoke', pair, from: '', to: account, reason });
+        }
+    }
+    return {
+        register,
+        revoke,
+        accounts: () => Array.from(ports.keys()),
+        close() {
+            ports.clear();
+        },
+    };
+}
+function channelFromDataChannel(dc) {
+    const msgCbs = new Set();
+    const closeCbs = new Set();
+    let closed = false;
+    function fireClose() {
+        if (closed)
+            return;
+        closed = true;
+        for (const cb of Array.from(closeCbs))
+            cb();
+    }
+    dc.onmessage = function onDcMessage(ev) {
+        const data = String(ev.data);
+        for (const cb of Array.from(msgCbs))
+            cb(data);
+    };
+    dc.onclose = fireClose;
+    dc.onerror = fireClose;
+    return {
+        send: data => dc.send(data),
+        onMessage: cb => { msgCbs.add(cb); return () => msgCbs.delete(cb); },
+        onClose: cb => { closeCbs.add(cb); return () => closeCbs.delete(cb); },
+        close: () => { dc.close(); fireClose(); },
+    };
+}
+function createWebRtcConnector(deps) {
+    const { port, rtc, self, peer, pair, session, label = 'direct', openTimeoutMs = 10_000 } = deps;
+    let state = 'idle';
+    let pc = null;
+    let channel = null;
+    let offSignals = null;
+    let abortOpen = null;
+    const [emitFail, failListen] = (0, Listen_1.listen)();
+    function teardown(next) {
+        state = next;
+        if (typeof offSignals == 'function')
+            offSignals();
+        else
+            offSignals?.off?.();
+        offSignals = null;
+        channel?.close?.();
+        channel = null;
+        pc?.close();
+        pc = null;
+    }
+    function fail(reason) {
+        if (state == 'closed' || state == 'failed')
+            return;
+        const abort = abortOpen;
+        abortOpen = null;
+        teardown('failed');
+        abort?.(reason instanceof Error ? reason : new Error(String(reason)));
+        emitFail(reason);
+    }
+    async function open() {
+        state = 'opening';
+        const me = rtc();
+        pc = me;
+        const dc = me.createDataChannel('replay');
+        let openTimer = null;
+        const opened = new Promise((resolve, reject) => {
+            abortOpen = reject;
+            dc.onopen = () => resolve();
+            openTimer = setTimeout(function webRtcOpenTimeout() {
+                reject(new Error('webrtc direct open timeout: ' + pair));
+            }, openTimeoutMs);
+        });
+        opened.catch(() => { });
+        offSignals = port.signals.on(function onSignal(env) {
+            if (env == null || env.pair != pair || env.to != self || pc != me)
+                return;
+            if (env.type == 'answer' && env.sdp != null) {
+                void Promise.resolve(me.setRemoteDescription({ type: 'answer', sdp: env.sdp }))
+                    .catch(fail);
+                return;
+            }
+            if (env.type == 'ice' && env.candidate != null) {
+                void Promise.resolve(me.addIceCandidate(env.candidate)).catch(fail);
+                return;
+            }
+            if (env.type == 'revoke' || env.type == 'close') {
+                fail(new Error('direct route ' + env.type + (env.reason ? ': ' + env.reason : '')));
+            }
+        });
+        me.onicecandidate = function onIce(ev) {
+            if (ev?.candidate != null) {
+                void port.send({ type: 'ice', pair, from: self, to: peer, candidate: ev.candidate });
+            }
+        };
+        try {
+            const offer = await me.createOffer();
+            await me.setLocalDescription(offer);
+            const accepted = await port.send({ type: 'offer', pair, from: self, to: peer, sdp: offer.sdp, session });
+            if (accepted == false)
+                throw new Error('signaling rejected offer (endpoint not exposed): ' + pair);
+            await opened;
+        }
+        catch (e) {
+            teardown('failed');
+            throw e;
+        }
+        finally {
+            clearTimeout(openTimer);
+            abortOpen = null;
+        }
+        state = 'open';
+        channel = channelFromDataChannel(dc);
+        channel.onClose?.(function onDirectChannelDied() {
+            if (state == 'open')
+                fail(new Error('direct channel closed: ' + pair));
+        });
+        return (0, replay_channel_1.channelReplayRemote)(channel);
+    }
+    return {
+        info: { label, kind: 'direct', binary: false, ordered: true, reliable: true },
+        open,
+        close() {
+            if (state == 'closed')
+                return;
+            void port.send({ type: 'close', pair, from: self, to: peer });
+            teardown('closed');
+        },
+        state: () => state,
+        onFail: { on: cb => failListen.on(cb) },
+    };
+}
+function acceptWebRtcDirect(deps) {
+    const { port, rtc, self, serve, accept } = deps;
+    const sessions = new Map();
+    let closed = false;
+    function dropSession(key) {
+        const s = sessions.get(key);
+        if (!s)
+            return;
+        sessions.delete(key);
+        s.stop?.();
+        s.pc.close();
+    }
+    async function onOffer(env) {
+        const key = env.pair + '|' + env.from;
+        if (accept && !(await accept(env))) {
+            void port.send({ type: 'revoke', pair: env.pair, from: self, to: env.from, reason: 'offer rejected' });
+            return;
+        }
+        const source = await serve(env);
+        if (!source) {
+            void port.send({ type: 'revoke', pair: env.pair, from: self, to: env.from, reason: 'nothing to serve' });
+            return;
+        }
+        dropSession(key);
+        const pc = rtc();
+        const session = { pc, stop: null };
+        sessions.set(key, session);
+        pc.ondatachannel = function onIncomingChannel(ev) {
+            session.stop = (0, replay_channel_1.serveReplayChannel)(source, channelFromDataChannel(ev.channel));
+        };
+        pc.onicecandidate = function onIce(ev) {
+            if (ev?.candidate != null) {
+                void port.send({ type: 'ice', pair: env.pair, from: self, to: env.from, candidate: ev.candidate });
+            }
+        };
+        try {
+            await pc.setRemoteDescription({ type: 'offer', sdp: env.sdp });
+            const answer = await pc.createAnswer();
+            await pc.setLocalDescription(answer);
+            void port.send({ type: 'answer', pair: env.pair, from: self, to: env.from, sdp: answer.sdp });
+        }
+        catch {
+            dropSession(key);
+            void port.send({ type: 'revoke', pair: env.pair, from: self, to: env.from, reason: 'negotiation failed' });
+        }
+    }
+    const offSignals = port.signals.on(function onAcceptSignal(env) {
+        if (closed || env == null || env.to != self)
+            return;
+        if (env.type == 'offer') {
+            void onOffer(env);
+            return;
+        }
+        const key = env.pair + '|' + env.from;
+        if (env.type == 'ice' && env.candidate != null) {
+            void Promise.resolve(sessions.get(key)?.pc.addIceCandidate(env.candidate)).catch(() => dropSession(key));
+            return;
+        }
+        if (env.type == 'close' || env.type == 'revoke')
+            dropSession(key);
+    });
+    return function closeAccept() {
+        if (closed)
+            return;
+        closed = true;
+        if (typeof offSignals == 'function')
+            offSignals();
+        else
+            offSignals?.off?.();
+        for (const key of Array.from(sessions.keys()))
+            dropSession(key);
+    };
+}

package/package.json

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