wenay-common2 1.0.75 → 1.0.76

package/doc/ROADMAP.md

@@ -139,12 +139,13 @@ control channel; `authorize` = server-side `canExposeEndpoint`), `createWebRtcCo
 `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). Media-side candidates (2026-07-10, after the demo
-stand stress test): a real `transport:'webrtc'` media track — SDP over the existing signal hub,
-media bypassing the socket relay for call-grade smoothness; and `MediaStreamTrackProcessor` capture
-for true 30fps (`grabFrame`'s ~50ms serial latency caps snapshot capture at ~15-20fps).
+denial, session rejection, server revoke, and an encoded `Media` `Uint8Array` frame over both the
+direct datachannel and relay fallback. v1.0.76 completes step 10 with a portable binary replay codec
+and the browser/Node `rtc` factory seam; it also completes step 7 with the app-level
+`noStrict(accountMap)` + `createStoreManager` selected-mirror lifecycle oracle. Media-side candidates
+remain a real `transport:'webrtc'` native media track/SFU for call-grade smoothness and
+`MediaStreamTrackProcessor` capture for true 30fps (`grabFrame`'s ~50ms serial latency caps snapshot
+capture at ~15-20fps); they are performance adapters, not route-coordinator prerequisites.
 
 Consumption-layer candidates (2026-07-10, author's ask):
 - ✅ **Call system** — SHIPPED in v1.0.74: `Peer.createCallManager` (ring/accept/decline/hangup as

package/doc/changes/1.0.75.md

@@ -7,4 +7,4 @@
 - Replay subscribers on RPC remotes recover automatically from their own last delivered `seq`: live is restored first, racing envelopes queue, then frame/since catch-up is ordered and deduplicated. Queue policy keeps an ungated live line; producer-declared mini-frames/keyframes may cover a raw seq jump without a logical data gap.
 - Sacred queues remain exact: a retained journal replays every missing envelope, while eviction/no-keyframe is a terminal `onError`; queued events after the hole are never emitted as a false continuation.
 - Hard boundaries stay hard: `close()` / `dispose()` and hub `connect()` / `setToken()` terminate the old generation. Pending or attempted ordinary RPC/pipe calls fail on disconnect and are never retried, avoiding duplicated side effects.
-- Add real Socket.IO reconnect coverage for stable proxy identity, deduped multi-consumer recovery, repeated reconnect generations, sacred eviction, offline dispose, token rotation, and multicast lifecycle listeners.
+- Add real Socket.IO reconnect coverage for stable proxy identity, deduped multi-consumer recovery, repeated reconnect generations, sacred eviction, offline dispose, token rotation, and multicast lifecycle listeners.

package/doc/changes/1.0.76.md

@@ -0,0 +1,4 @@
+# 1.0.76
+
+- Complete the route-coordinator account lifecycle target: `noStrict` runtime account maps compose with `Observe.createStoreManager` to start/stop selected replay mirrors independently; add the focused oracle.
+- Preserve `Uint8Array` payloads in replay-over-datachannel with a portable binary codec, so encoded `Media` frames survive relay → direct WebRTC → relay hand-offs byte-for-byte; extend the real signaling oracle.

package/doc/wenay-common2-rare.md

@@ -551,9 +551,11 @@ createSignalHub({authorize?}) -> {register(account) -> {send, signals, close}, r
   //   one server-side policy point for endpoint material AND calls.
 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).
+  //   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).
+  //   The replay channel encodes Uint8Array explicitly, preserving Media frames byte-for-byte instead
+  //   of JSON's numeric-key object conversion; native tracks/SFU are optional performance adapters.
   //   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

package/doc/wenay-common2.md

@@ -195,8 +195,11 @@ 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 uncovered loss or duplicate delivery. Late joiners
-get a keyframe folded server-side even while the owner is offline.
-Reconnect correctness is self-healing: a publisher gap makes the relay reject the push WITH its last
+get a keyframe folded server-side even while the owner is offline.
+The same replay datachannel preserves `Media` `Uint8Array` frames byte-for-byte, so a direct route
+can feed existing `Media` Listen/replay consumers; native WebRTC tracks/SFU are optional future
+performance adapters, not a second media semantic.
+Reconnect correctness is self-healing: a publisher gap makes the relay reject the push WITH its last
 seq, and the client repairs from that coordinate automatically (`repair: 'tail'` lossless (default)
 | `'keyframe'` cheap reset for ephemeral state). Server declares journal semantics
 (`createPeerHost({gap: 'resume' | 'sacred'})`); a declared `journal: 'sacred'` TYPE-forbids the cheap

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

@@ -2,6 +2,55 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serveReplayChannel = serveReplayChannel;
 exports.channelReplayRemote = channelReplayRemote;
+const BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const REPLAY_BYTES = '__wenayReplayBytes';
+function bytesToBase64(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length; i += 3) {
+        const a = bytes[i];
+        const b = bytes[i + 1];
+        const c = bytes[i + 2];
+        out += BASE64[a >> 2];
+        out += BASE64[((a & 3) << 4) | ((b ?? 0) >> 4)];
+        out += b == null ? '=' : BASE64[((b & 15) << 2) | ((c ?? 0) >> 6)];
+        out += c == null ? '=' : BASE64[c & 63];
+    }
+    return out;
+}
+function base64ToBytes(text) {
+    const clean = text.replace(/=+$/, '');
+    const out = new Uint8Array(Math.floor(clean.length * 3 / 4));
+    let bits = 0;
+    let nBits = 0;
+    let at = 0;
+    for (const char of clean) {
+        const n = BASE64.indexOf(char);
+        if (n < 0)
+            throw new Error('replay channel: invalid binary payload');
+        bits = (bits << 6) | n;
+        nBits += 6;
+        if (nBits < 8)
+            continue;
+        nBits -= 8;
+        out[at++] = (bits >> nBits) & 255;
+    }
+    return out;
+}
+function stringifyMessage(value) {
+    return JSON.stringify(value, function encodeReplayBytes(_key, item) {
+        if (item instanceof Uint8Array)
+            return { [REPLAY_BYTES]: bytesToBase64(item) };
+        return item;
+    });
+}
+function parseMessage(raw) {
+    return JSON.parse(raw, function decodeReplayBytes(_key, item) {
+        if (item != null && typeof item == 'object' && Object.keys(item).length == 1 && typeof item[REPLAY_BYTES] == 'string') {
+            return base64ToBytes(item[REPLAY_BYTES]);
+        }
+        return item;
+    });
+}
 function unsubscribeHandle(handle) {
     if (typeof handle == 'function') {
         handle();
@@ -22,11 +71,11 @@ function serveReplayChannel(source, channel) {
                     : 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 }));
+                channel.send(stringifyMessage({ 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) }));
+                channel.send(stringifyMessage({ t: 'res', id: msg.id, ok: false, e: String(e) }));
         }
     }
     const offMsg = channel.onMessage(function onReplayChannelMessage(raw) {
@@ -34,7 +83,7 @@ function serveReplayChannel(source, channel) {
             return;
         let msg;
         try {
-            msg = JSON.parse(raw);
+            msg = parseMessage(raw);
         }
         catch {
             return;
@@ -42,7 +91,7 @@ function serveReplayChannel(source, channel) {
         if (msg?.t == 'sub' && !lineOff) {
             lineOff = source.line.on(function forwardEnvelope(ev) {
                 if (!closed)
-                    channel.send(JSON.stringify({ t: 'ev', ev }));
+                    channel.send(stringifyMessage({ t: 'ev', ev }));
             });
             return;
         }
@@ -70,7 +119,7 @@ function channelReplayRemote(channel) {
     channel.onMessage(function onRemoteChannelMessage(raw) {
         let msg;
         try {
-            msg = JSON.parse(raw);
+            msg = parseMessage(raw);
         }
         catch {
             return;
@@ -108,7 +157,7 @@ function channelReplayRemote(channel) {
         return new Promise((resolve, reject) => {
             const id = nextId++;
             pending.set(id, { resolve, reject });
-            channel.send(JSON.stringify({ t: 'req', id, m, a }));
+            channel.send(stringifyMessage({ t: 'req', id, m, a }));
         });
     }
     return {

package/observe/store-manager.test.ts

@@ -7,6 +7,7 @@ import {
     flushReactive,
     managedStore,
 } from '../src/Common/Observe'
+import {isNoStrict, noStrict} from '../src/Common/rcp/rpc-dynamic'
 
 let fails = 0
 const ok = (condition: any, message: string) => {
@@ -111,8 +112,49 @@ async function main() {
         ok(manager.handles.rows.status().state == 'stopped', 'stopAll closes offline resource')
     }
 
+    console.log('\n[store-manager] dynamic account-map lifecycle')
+    {
+        const sources = new Map<string, ReturnType<typeof createStore<Market>>>()
+        const remotes = noStrict(new Proxy({} as Record<string, any>, {
+            get(_target, key) {
+                if (typeof key != 'string') return undefined
+                let source = sources.get(key)
+                if (!source) {
+                    source = createStore<Market>({data: {BTC: key.length}, meta: {status: 'relay'}}, {drain: 'micro'})
+                    sources.set(key, source)
+                }
+                return exposeStoreReplay(source, {history: 20}).api.replay
+            },
+        }))
+        function accountResource(account: string) {
+            return managedStore.replay<Market>({
+                remote: remotes[account],
+                initial: {data: {}, meta: {}},
+                storeOpts: {drain: 'micro'},
+            })
+        }
+        const manager = createStoreManager({
+            alice: accountResource('alice'),
+            bob: accountResource('bob'),
+        })
+
+        ok(isNoStrict(remotes), 'runtime account map is explicitly noStrict, not a fixed schema')
+        const alice = await manager.start('alice')
+        ok(alice.state.data.BTC == 5 && manager.get('bob') == null, 'start selects one account mirror without materializing its peers')
+
+        const source = sources.get('alice')!
+        source.state.meta.status = 'direct'
+        await settle(source.state)
+        ok(alice.state.meta.status == 'direct', 'selected account mirror follows its replay route')
+
+        manager.stop('alice')
+        ok(manager.handles.alice.status().state == 'stopped' && manager.get('alice') != null,
+            'stopping a selected account detaches its route while retaining its local mirror for reuse')
+        manager.stopAll()
+    }
+
     console.log(`\n${fails == 0 ? 'ALL GREEN' : fails + ' FAILURE(S)'}`)
     process.exit(fails == 0 ? 0 : 1)
 }
 
-main().catch(e => { console.error(e); process.exit(1) })
+main().catch(e => { console.error(e); process.exit(1) })

package/package.json

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

package/replay/route-webrtc.test.ts

@@ -16,6 +16,7 @@ import {
 } from '../src/Common/events/replay-index'
 import {createRpcClientHub} from '../src/Common/rcp/rpc-clientHub'
 import {createRpcServerAuto} from '../src/Common/rcp/rpc-server-auto'
+import {decodeMediaFrame, encodeMediaFrame} from '../src/Common/media/media-source'
 
 let fails = 0
 const ok = (condition: any, message: string) => {
@@ -199,12 +200,24 @@ async function main() {
         await waitFor('datachannel live events', () => got.length >= 4)
         ok(json(got) == json([0, 1, 2, 3]), 'replay wire over the datachannel is gap-free and dup-free')
 
+        // A direct media route uses the same replay wire. Binary frames must stay
+        // Uint8Array end-to-end — JSON's default numeric-key object is unusable by Media.
+        const mediaFrame = encodeMediaFrame({
+            kind: 'video-frame', codec: 'jpeg', seq: 4, tMono: 40, width: 2, height: 2,
+        }, new Uint8Array([77, 101, 100, 105, 97]))
+        emit(mediaFrame as any)
+        await waitFor('binary frame over datachannel', () => got.length >= 5)
+        const deliveredFrame = got[4] as any
+        const decodedFrame = deliveredFrame instanceof Uint8Array ? decodeMediaFrame(deliveredFrame) : null
+        ok(decodedFrame?.kind == 'video-frame' && json([...decodedFrame.payload]) == json([77, 101, 100, 105, 97]),
+            'direct replay preserves an encoded Media Uint8Array frame byte-for-byte')
+
         // server-side revoke: policy изменилась — direct закрывается, relay продолжает с seq
         hub.revoke(link.ref.key, ['a', 'b'], 'policy change')
         await waitFor('revoke fallback', () => link.state() == 'fallback')
         state = 4; emit(state)
         await waitFor('relay after revoke', () => got.includes(4))
-        ok(json(got) == json([0, 1, 2, 3, 4]), 'server revoke: relay resumes from seq, no gap')
+        ok(json(got.filter(v => typeof v == 'number')) == json([0, 1, 2, 3, 4]), 'server revoke: relay resumes from seq, no gap')
 
         // сервер не раскрывает endpoint: offer отклонён ДО транспорта
         allowDirect = false
@@ -223,7 +236,7 @@ async function main() {
         const retry = await link.promoteDirect()
         state = 5; emit(state)
         await waitFor('direct again', () => got.includes(5))
-        ok(retry.ok && link.state() == 'direct' && json(got) == json([0, 1, 2, 3, 4, 5]), 'pair recovers into direct after denials, still gap-free')
+        ok(retry.ok && link.state() == 'direct' && json(got.filter(v => typeof v == 'number')) == json([0, 1, 2, 3, 4, 5]), 'pair recovers into direct after denials, still gap-free')
 
         coord.close()
         stopAccept()

package/doc/changes/1.0.66.md

@@ -1,8 +0,0 @@
-# 1.0.66
-
-- Add `Media.createAudioSource` and `Media.createVideoSource` browser capture helpers that expose media as ordinary binary `Listen` sources.
-- Add fixed-header media frame helpers: `Media.encodeMediaFrame` and `Media.decodeMediaFrame` (`Uint8Array` header + raw payload, no JSON envelope).
-- Add optional `replay:true` media source mode so `createRpcServerAuto` can expose media listeners with legacy + replay surfaces under the same key.
-- Add `wenay-common2/media` package export and root `Media` namespace export.
-- Add `replay/media-socket.test.ts` covering media binary frame headers, no-device typed state, replay media source shape, and real Socket.IO/RPC binary delivery.
-- Document media-over-socket backpressure defaults and reserve WebRTC as a future explicit SFU/signaling opt-in, not the default transport.