wenay-common2 1.0.67 → 1.0.69

package/README.md

@@ -1,5 +1,7 @@
 # wenay-common2
 
+[![CI](https://github.com/wenayr/wenay-common2/actions/workflows/ci.yml/badge.svg)](https://github.com/wenayr/wenay-common2/actions/workflows/ci.yml)
+
 ## Documentation
 
 - Brief API cheat sheet: [`doc/wenay-common2.md`](doc/wenay-common2.md)

package/doc/ROADMAP.md

@@ -5,7 +5,10 @@
 > `createStoreMirror`, and the replay `seq` / `keyframe` / `frame` contract. None of it requires
 > changing the store core; the store stays single-authority (one `seq` sequencer, last-writer-wins
 > per path), and these features are layers or adapters above that.
-> Status: 🔴 not started · 🟡 partial / ongoing · 🧊 deliberately shelved.
+> Status: 🔴 not started · 🟡 partial / ongoing · 🧊 deferred (super-low priority, not forbidden).
+>
+> Current focus is NOT more transport: see `doc/target/library-uplift-tasks.md` (showcase, SDK facade,
+> vertical demo app). Transport items below stay available but rank below everything in that plan.
 
 ## 0. Distributed Runtime Model
 
@@ -119,9 +122,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 +133,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 +163,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 🧊
 
@@ -186,7 +198,9 @@ source of truth. Decompose by write topology:
   silently drop a concurrent write. This is the one case that genuinely needs CRDT/OT. Design lead:
   wrap a Yjs/Automerge doc as a `RemoteStore`-shaped source and mirror from it — the store↔transport
   decoupling makes this a small adapter, not a rewrite.
-- Status: 🔴 prediction layer + CRDT adapter not started; partitioned-authority already expressible.
+- Status: 🧊 deferred, super-low priority. Prediction layer waits for the demo app to demand and shape
+  it (`doc/target/library-uplift-tasks.md` task 4); CRDT adapter reopens only on a real co-write need.
+  Partitioned-authority already expressible today.
 
 ## 4. Data-transfer optimization backlog (ongoing) 🟡
 
@@ -194,4 +208,5 @@ Open-ended transfer/perf work, especially for backend-heavy models. Never "done"
 
 - Candidates: tighter `frame` condensation per line; delta/patch minimization; binary framing for hot
   paths; batching heuristics beyond the current `pipe` / `space` modes.
-- Status: 🟡 ongoing; pick items as real bottlenecks surface, not speculatively.
+- Status: 🧊 deferred, super-low priority; pick items only as real bottlenecks surface in the SDK/demo
+  consumers, not speculatively.

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/changes/1.0.69.md

@@ -0,0 +1,11 @@
+# 1.0.69
+
+- Fix `createWebRtcConnector` / `acceptWebRtcDirect`: `RTCIceCandidate` now rides the signaling wire as its `toJSON()` init — real browser candidate class instances were mangled by transport serialization, so direct never established (caught by the live demo stand, invisible to fakes).
+- Add the demo stand `demo/` (`npm run demo`): shared cursors in two browser tabs over the Peer SDK next to a legacy rpc key — relay mirroring, "Go direct" (real `RTCPeerConnection`), "Back to relay" re-interposition, signaling/route event log. Verified live in Chrome: seq continues across both hand-offs, no keyframe reset, cursor never jumps.
+
+- Add the `Peer` namespace (`wenay-common2/peer`) — the one-call SDK over rpc + store + replay + route coordinator, legacy-friendly by design: the server side is an object fragment spread into an EXISTING `createRpcServerAuto` object (old keys untouched), the client side rides the existing connection's deep proxy.
+- `Peer.createPeerHost({authorize?, history?})`: per-account signaling ports + relay journals + a `noStrict` dynamic `peers` feed; `authorize` is the server-side `canExposeEndpoint`; `revoke(pair, accounts)` pushes both parties back to relay.
+- `Peer.createPeerClient({remote, account, initial, rtc?, ...})`: own store published as a patch line; `peer(account)` returns a live mirrored store + route control (`promoteDirect/reinterposeRelay/fallback/block`, `route()`, `ready`, `seq()`); mirrors survive any route change; omitting `rtc` gives a relay-only client.
+- `Peer.createPatchRelayJournal({history?})`: server-side journal of OWNER-sequenced envelopes — relay and direct share the owner's seq space, so a relay <-> direct hand-off is a plain seq resume (no keyframe reset); keyframe is folded server-side, late joiners work while the owner is offline.
+- Add GitHub Actions CI (build + publish gate + full oracle suite on windows-latest) and a README badge.
+- Add oracle `replay/peer-sdk.test.ts`: two accounts over a real Socket.IO/RPC wire next to a legacy rpc key — relay mirroring, direct promotion via injected fake WebRTC runtime, same-seq-space hand-off assertion, server revoke fallback, late joiner from the folded keyframe, loud refusal of `promoteDirect` without an `rtc` factory.

package/doc/wenay-common2-rare.md

@@ -511,6 +511,39 @@ 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.
+Peer.createPatchRelayJournal({history?}) -> {push(env), remote, seq(), snapshot(), close()}
+  // server-side mirror of an OWNER-sequenced patch line: push() takes the owner's envelopes VERBATIM
+  //   (dedup by seq; a root patch with a LOWER seq = owner restart, legitimate reset point), keyframe is
+  //   folded server-side (late joiners don't need the owner online), frame condenses last-patch-per-path.
+  //   Owner seq space is the point: relay and direct routes share coordinates -> hand-off is a seq resume.
+  //   remote is ReplayRemote-shaped and rpc-exposable as is (line is a REAL Listen — the rpc layer detects
+  //   listen nodes by registry, a hand-rolled {on: cb => ...} wrapper would not stream).
+  // The full SDK on top (createPeerHost/createPeerClient) is most-used surface -> wenay-common2.md.
+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/doc/wenay-common2.md

@@ -136,8 +136,8 @@ l.ticks.once(v => console.log(v))                         // one event, then aut
 const [tick, ticks] = replayListen<[number]>({history: 1024, current: 'last'})    // after — same facade, same key
 // legacy subscribers unchanged (byte-for-byte). Replay consumers now also get:
 const sub = replaySubscribe(l.ticks, v => {}, {since: saved, onSeq: s => saved = s})  // catch-up + live, no gaps/dups
-const sub2 = replaySubscribe(c.math.func.ticks, v => {})  // replay members project on func/strict directly — no cast needed
-const routed = replayRouteSubscribe(l.ticks, v => {}, {label: 'relay'})
+const sub2 = replaySubscribe(c.math.func.ticks, v => {})  // replay members project on func/strict directly — no cast needed
+const routed = replayRouteSubscribe(l.ticks, v => {}, {label: 'relay'})
 await routed.switch(nextRemoteTicks, {label: 'direct'})  // relay/direct hand-off: old route closes after catch-up
 await l.ticks.frame(mySeq)                                // pull at YOUR pace (50ms timer etc.) — server condenses via the line's frame lambda
 // full guide + examples → rpc.md; frame model / lag policies → 🎞️ recipe below and rare docs
@@ -152,8 +152,44 @@ Media.createVideoSource({fps? = 3, codec? = 'jpeg', quality?, replay?}) -> [emit
 control: start() -> Promise<'idle'|'requesting'|'live'|'denied'|'no-device'|'error'> · stop() · getStats() · setDevice(id) · listDevices() · state
 Media.encodeMediaFrame(meta, payload) / Media.decodeMediaFrame(frame)     // one Uint8Array = 40-byte fixed header + raw payload
 ```
-Audio default is PCM frames from `AudioWorklet` where available (`mode:'record'` uses MediaRecorder chunks). Video default is camera snapshots (`video->canvas`, JPEG, low fps for vision). Put `listen` into `createRpcServerAuto` like any other Listen; with `replay:true`, the returned listen is a replay line, so RPC auto exposes legacy + replay surfaces under the same key. Backpressure policy: audio is lossless queue; video `replay:true` defaults to keep-latest frame recovery. `transport:'webrtc'` is reserved for a future SFU/signaling adapter; socket binary is the default today.
-
+Audio default is PCM frames from `AudioWorklet` where available (`mode:'record'` uses MediaRecorder chunks). Video default is camera snapshots (`video->canvas`, JPEG, low fps for vision). Put `listen` into `createRpcServerAuto` like any other Listen; with `replay:true`, the returned listen is a replay line, so RPC auto exposes legacy + replay surfaces under the same key. Backpressure policy: audio is lossless queue; video `replay:true` defaults to keep-latest frame recovery. `transport:'webrtc'` is reserved for a future SFU/signaling adapter; socket binary is the default today.
+
+## 🤝 Peer — accounts see each other's stores (one-call SDK)
+> `import { Peer } from "wenay-common2"` or `import * as Peer from "wenay-common2/peer"`.
+> The happy-path facade over rpc + store + replay + route coordinator. Legacy-friendly by design:
+> the server side is a FRAGMENT spread into your EXISTING `createRpcServerAuto` object, the client
+> side rides your existing connection — old keys keep working untouched.
+```
+// SERVER — next to your legacy object:
+const host = Peer.createPeerHost({authorize?, history?})   // authorize(env) = server-side canExposeEndpoint
+io.on('connection', socket => {
+    const peer = host.connection(accountOf(socket))        // per-account signal port + relay journal
+    createRpcServerAuto({socket, socketKey, object: {...legacyObject, peer: peer.fragment}, disconnectListen})
+    disconnectListen.on(peer.close)
+})
+host: connection(account) · relay(account) · accounts() · revoke(pair, accounts, reason?) · close()
+
+// CLIENT — the whole happy path:
+const me = Peer.createPeerClient<World>({
+    remote: c.app.func.peer,        // deep proxy of the fragment — rest of the connection is yours
+    account: 'a',
+    initial: {...},                 // own store: write me.store.state — others see it
+    rtc?: () => new RTCPeerConnection(cfg),   // omit = relay-only (promoteDirect unavailable)
+})
+const bob = me.peer('b')            // mirror + route control for another account
+await bob.ready                     // keyframe/tail landed
+bob.store.state                     // live mirror — reads survive ANY route change
+await bob.promoteDirect()           // relay -> WebRTC direct; {ok, state, reason?} result, not a throw
+bob.route()                         // 'relay' | 'direct' · bob.reinterposeRelay() · bob.fallback() · bob.block()
+me.onRoute(ev => {})                // route transitions for metrics/UI
+```
+Key property: the relay journal stores the owner's envelopes VERBATIM (owner seq space), so a
+relay <-> direct hand-off is a plain seq resume — no keyframe reset, no gaps, no dups. Late joiners
+get a keyframe folded server-side even while the owner is offline. Policy/session material:
+`createPeerClient({session, accept, policy})` + host `authorize` — see rare docs for the envelope
+contract and the underlying primitives (`createRouteCoordinator`, `createSignalHub`,
+`createWebRtcConnector`). Oracle: `replay/peer-sdk.test.ts`.
+
 ## 🔁 Observe — reactive state + store/mirror API
 > `import { Observe } from "wenay-common2"` or `import * as Observe from "wenay-common2/observe"`.
 > This is the documented v2 reactive/store surface.
@@ -199,8 +235,8 @@ Observe.exposeStoreReplay(store, {history? = 1024}) -> { api /* spread into the
 Observe.syncStoreReplay(mirror, remote /*{line, since, keyframe, frame?} of api.replay*/, {since?, onSeq?}) -> off
   // off.ready (catch-up done) · off.seq() (save for reconnect: syncStoreReplay(..., {since: prev.seq()}))
   // lagging/late client NEVER gets a backlog: evicted seq -> ONE fresh keyframe + live
-  // freshness is an option, not consumer boilerplate: {staleMs, onStale} flags a silent line / stale keyframe (edge-triggered both ways; 🎞️ in rare docs)
-Observe.syncStoreReplayRoute(mirror, remote, {label?}) -> off & {switch(nextRemote, opts), ready, seq(), label(), active()}
+  // freshness is an option, not consumer boilerplate: {staleMs, onStale} flags a silent line / stale keyframe (edge-triggered both ways; 🎞️ in rare docs)
+Observe.syncStoreReplayRoute(mirror, remote, {label?}) -> off & {switch(nextRemote, opts), ready, seq(), label(), active()}
   // relay/direct promotion and re-interposition: replacement route catches up by seq before the old route closes
 Observe.syncStoreReplayEach<T>(remote, (key, value, ctx) => {}, opts?) -> off & {store, ready, seq(), isStale(), lastTs()}
   // one-call remote fold: mirror store + syncStoreReplay + store.each() — the callback fires per CHANGED

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,247 @@
+"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) {
+                const c = ev.candidate;
+                void port.send({ type: 'ice', pair, from: self, to: peer, candidate: c?.toJSON ? c.toJSON() : c });
+            }
+        };
+        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) {
+                const c = ev.candidate;
+                void port.send({ type: 'ice', pair: env.pair, from: self, to: env.from, candidate: c?.toJSON ? c.toJSON() : c });
+            }
+        };
+        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/lib/Common/peer/peer-client.d.ts

@@ -0,0 +1,46 @@
+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';
+export type PeerRemote = {
+    signal: {
+        send: (env: SignalEnvelope) => Promise<boolean | void>;
+        signals: {
+            on: (cb: (env: SignalEnvelope) => void) => any;
+        };
+    };
+    publish: (env: PatchEnvelope) => Promise<boolean | void> | boolean | void;
+    peers: Record<string, ReplayRemote<[StorePatch]>>;
+};
+export type PeerClientDeps<T extends object> = {
+    remote: PeerRemote;
+    account: string;
+    initial: T;
+    rtc?: () => RtcPeerConnection;
+    session?: unknown;
+    accept?: (env: SignalEnvelope) => boolean | Promise<boolean>;
+    policy?: RoutePolicy;
+    peerInitial?: () => T;
+    history?: number;
+    drain?: StoreDrain;
+};
+export declare function createPeerClient<T extends object>(deps: PeerClientDeps<T>): {
+    store: import("../Observe/store").Store<T>;
+    peer: (other: string) => {
+        account: string;
+        store: import("../Observe/store").Store<T>;
+        ready: Promise<void>;
+        seq: () => number;
+        route: () => string;
+        state: () => import("../events/route-coordinator").tRouteState;
+        promoteDirect: (opts?: import("../events/route-coordinator").PromoteDirectOpts) => Promise<import("../events/route-coordinator").RouteOpResult>;
+        reinterposeRelay: (reason?: unknown) => Promise<import("../events/route-coordinator").RouteOpResult>;
+        fallback: (reason?: unknown) => Promise<import("../events/route-coordinator").RouteOpResult>;
+        block: (reason?: unknown) => Promise<import("../events/route-coordinator").RouteOpResult>;
+        close(): void;
+    };
+    onRoute: (cb: (ev: import("../events/route-coordinator").RouteChangeEvent) => void) => import("../..").ListenOff;
+    close(): void;
+};
+export type PeerClient<T extends object> = ReturnType<typeof createPeerClient<T>>;

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPeerClient = createPeerClient;
+const store_1 = require("../Observe/store");
+const store_replay_1 = require("../Observe/store-replay");
+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 store = (0, store_1.createStore)(initial, drain !== undefined ? { drain } : {});
+    const exposed = (0, store_replay_1.exposeStoreReplay)(store, history !== undefined ? { history } : {});
+    const offPublish = exposed.replay.line.on(function publishEnvelope(env) {
+        void remote.publish(env);
+    });
+    const warmup = exposed.replay.keyframe();
+    if (warmup)
+        void remote.publish(warmup);
+    const port = {
+        send: env => remote.signal.send(env),
+        signals: { on: cb => remote.signal.signals.on(cb) },
+    };
+    const stopAccept = rtc
+        ? (0, route_signal_webrtc_1.acceptWebRtcDirect)({
+            port, rtc, self: account,
+            serve: () => (0, replay_wire_1.exposeReplay)(exposed.replay),
+            ...(accept ? { accept } : {}),
+        })
+        : null;
+    function relayConnector(other) {
+        let state = 'idle';
+        return {
+            info: { label: 'relay', kind: 'relay', ordered: true, reliable: true },
+            open() {
+                const node = remote.peers[other];
+                state = 'open';
+                return {
+                    line: { on: (cb) => node.line.on(cb) },
+                    since: (seq) => node.since(seq),
+                    keyframe: () => node.keyframe(),
+                    frame: (seq, hint) => node.frame(seq, hint),
+                };
+            },
+            close: () => { state = 'closed'; },
+            state: () => state,
+        };
+    }
+    const coord = (0, route_coordinator_1.createRouteCoordinator)({
+        ...(policy ? { policy } : {}),
+        connect(ref, kind) {
+            const other = ref.a == account ? ref.b : ref.a;
+            if (kind == 'relay')
+                return relayConnector(other);
+            if (!rtc)
+                throw new Error('peer client: promoteDirect needs an rtc factory (deps.rtc)');
+            return (0, route_signal_webrtc_1.createWebRtcConnector)({
+                port, rtc, self: account, peer: other, pair: ref.key, session,
+            });
+        },
+    });
+    const views = new Map();
+    function makeView(other) {
+        const link = coord.pair(account, other);
+        const mirror = (0, store_1.createStore)(peerInitial(), drain !== undefined ? { drain } : {});
+        const sub = link.subscribe(function mirrorPatch(patch) {
+            (0, store_1.applyStorePatch)(mirror, patch);
+        });
+        const view = {
+            account: other,
+            store: mirror,
+            ready: sub.ready,
+            seq: sub.seq,
+            route: link.label,
+            state: link.state,
+            promoteDirect: link.promoteDirect,
+            reinterposeRelay: link.reinterposeRelay,
+            fallback: link.fallback,
+            block: link.block,
+            close() {
+                views.delete(other);
+                sub();
+                link.close();
+            },
+        };
+        return view;
+    }
+    function peer(other) {
+        const existing = views.get(other);
+        if (existing)
+            return existing;
+        const view = makeView(other);
+        views.set(other, view);
+        return view;
+    }
+    return {
+        store,
+        peer,
+        onRoute: coord.onRoute,
+        close() {
+            for (const view of Array.from(views.values()))
+                view.close();
+            coord.close();
+            stopAccept?.();
+            offPublish();
+            exposed.close();
+        },
+    };
+}

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

@@ -0,0 +1,32 @@
+import { StorePatch } from '../Observe/store';
+import { ReplayRemote } from '../events/replay-wire';
+import { SignalEnvelope } from '../events/route-signal-webrtc';
+import { PatchEnvelope } from './peer-relay';
+export type PeerHostDeps = {
+    authorize?: (env: SignalEnvelope) => boolean | Promise<boolean>;
+    history?: number;
+};
+export declare function createPeerHost(deps?: PeerHostDeps): {
+    connection: (account: string) => {
+        fragment: {
+            signal: {
+                send: (env: SignalEnvelope) => Promise<boolean>;
+                signals: import("../..").ListenApi<[SignalEnvelope]>;
+            };
+            publish: (env: PatchEnvelope) => boolean;
+            peers: Record<string, ReplayRemote<[StorePatch]>>;
+        };
+        close: () => void;
+    };
+    relay: (account: string) => {
+        push: (env: PatchEnvelope) => boolean;
+        remote: ReplayRemote<[StorePatch]>;
+        seq: () => number;
+        snapshot: () => any;
+        close: () => void;
+    };
+    accounts: () => string[];
+    revoke: (pair: string, accounts: string[], reason?: string) => void;
+    close(): void;
+};
+export type PeerHost = ReturnType<typeof createPeerHost>;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPeerHost = createPeerHost;
+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 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 });
+            relays.set(account, relay);
+            peersView[account] = relay.remote;
+        }
+        return relay;
+    }
+    function connection(account) {
+        const port = hub.register(account);
+        const mine = ensureRelay(account);
+        return {
+            fragment: {
+                signal: { send: port.send, signals: port.signals },
+                publish: (env) => mine.push(env),
+                peers: peersView,
+            },
+            close: () => port.close(),
+        };
+    }
+    return {
+        connection,
+        relay: ensureRelay,
+        accounts: () => Array.from(relays.keys()),
+        revoke: hub.revoke,
+        close() {
+            hub.close();
+            for (const relay of relays.values())
+                relay.close();
+            relays.clear();
+        },
+    };
+}

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

@@ -0,0 +1,3 @@
+export * from './peer-relay';
+export * from './peer-host';
+export * from './peer-client';

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

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./peer-relay"), exports);
+__exportStar(require("./peer-host"), exports);
+__exportStar(require("./peer-client"), exports);

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

@@ -0,0 +1,14 @@
+import { ReplayEvent } from '../events/replay-listen';
+import { ReplayRemote } from '../events/replay-wire';
+import { StorePatch } from '../Observe/store';
+export type PatchEnvelope = ReplayEvent<[StorePatch]>;
+export declare function createPatchRelayJournal(opts?: {
+    history?: number;
+}): {
+    push: (env: PatchEnvelope) => boolean;
+    remote: ReplayRemote<[StorePatch]>;
+    seq: () => number;
+    snapshot: () => any;
+    close: () => void;
+};
+export type PatchRelayJournal = ReturnType<typeof createPatchRelayJournal>;

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPatchRelayJournal = createPatchRelayJournal;
+const Listen_1 = require("../events/Listen");
+const store_1 = require("../Observe/store");
+const store_replay_1 = require("../Observe/store-replay");
+function condensePatchTail(tail) {
+    const held = new Map();
+    for (const ev of tail) {
+        const k = (0, store_replay_1.storePatchKey)(ev.event[0]);
+        if (k == null)
+            return tail;
+        held.delete(k);
+        held.set(k, ev);
+    }
+    return Array.from(held.values());
+}
+function createPatchRelayJournal(opts = {}) {
+    const { history = 1024 } = opts;
+    const [emitLine, line] = (0, Listen_1.listen)();
+    const fold = (0, store_1.createStore)({}, { drain: 'micro' });
+    let ring = [];
+    let last = -1;
+    let lastTs = 0;
+    let hasState = false;
+    function push(env) {
+        if (env == null || typeof env.seq != 'number')
+            return false;
+        const patch = env.event?.[0];
+        if (patch == null || !Array.isArray(patch.path))
+            return false;
+        const isRoot = patch.path.length == 0;
+        if (env.seq <= last) {
+            if (!isRoot || env.seq == last)
+                return false;
+            ring = [];
+        }
+        last = env.seq;
+        lastTs = env.ts ?? lastTs;
+        hasState = true;
+        (0, store_1.applyStorePatch)(fold, patch);
+        ring.push(env);
+        if (ring.length > history)
+            ring.splice(0, ring.length - history);
+        emitLine(env);
+        return true;
+    }
+    function keyframe() {
+        if (!hasState)
+            return null;
+        return { seq: last, ts: lastTs, event: [{ path: [], exists: true, value: fold.snapshot() }] };
+    }
+    function since(seq) {
+        if (!hasState)
+            return null;
+        if (seq >= last)
+            return [];
+        if (!ring.length || seq < ring[0].seq - 1)
+            return null;
+        return ring.filter(ev => ev.seq > seq);
+    }
+    function frame(seq, _hint) {
+        const tail = since(seq);
+        if (tail)
+            return condensePatchTail(tail);
+        const kf = keyframe();
+        return kf ? [kf] : null;
+    }
+    const remote = { line, since, keyframe, frame };
+    return {
+        push,
+        remote,
+        seq: () => last,
+        snapshot: () => fold.snapshot(),
+        close: () => { line.close(); },
+    };
+}

package/lib/index.d.ts

@@ -35,3 +35,4 @@ export * as Color from "./Common/Color";
 export * as Observe from "./Common/Observe";
 export * as Replay from "./Common/events/replay-index";
 export * as Media from "./Common/media/media-index";
+export * as Peer from "./Common/peer/peer-index";

package/lib/index.js

@@ -36,7 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Media = exports.Replay = exports.Observe = exports.Color = exports.Time = exports.Params = exports.Bars = exports.Math = void 0;
+exports.Peer = exports.Media = exports.Replay = exports.Observe = exports.Color = exports.Time = exports.Params = exports.Bars = exports.Math = void 0;
 __exportStar(require("./Common/node_console"), exports);
 __exportStar(require("./Common/core/Decorator"), exports);
 __exportStar(require("./Common/core/BaseTypes"), exports);
@@ -74,3 +74,4 @@ exports.Color = __importStar(require("./Common/Color"));
 exports.Observe = __importStar(require("./Common/Observe"));
 exports.Replay = __importStar(require("./Common/events/replay-index"));
 exports.Media = __importStar(require("./Common/media/media-index"));
+exports.Peer = __importStar(require("./Common/peer/peer-index"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common2",
-  "version": "1.0.67",
+  "version": "1.0.69",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",
@@ -35,7 +35,8 @@
     "./client": "./lib/client.js",
     "./server": "./lib/server.js",
     "./package.json": "./package.json",
-    "./media": "./lib/Common/media/media-index.js"
+    "./media": "./lib/Common/media/media-index.js",
+    "./peer": "./lib/Common/peer/peer-index.js"
   },
   "dependencies": {
     "express": "^5.2.1"