wenay-common2 1.0.70 → 1.0.74

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

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMediaRelay = createMediaRelay;
+const replay_listen_1 = require("../events/replay-listen");
+const rpc_dynamic_1 = require("../rcp/rpc-dynamic");
+function createMediaRelay(deps) {
+    const { lines, videoHistory = 8, audioHistory = 64, canWatch } = deps;
+    const accounts = new Map();
+    const watch = (0, rpc_dynamic_1.noStrict)({});
+    function makeLine(kind) {
+        return kind == 'video'
+            ? (0, replay_listen_1.replayListen)({
+                history: videoHistory, current: 'last',
+                frame: function lastFrameOnly(tail) { return tail.length ? [tail[tail.length - 1]] : []; },
+            })
+            : (0, replay_listen_1.replayListen)({ history: audioHistory });
+    }
+    function linesOf(account) {
+        let entry = accounts.get(account);
+        if (!entry) {
+            entry = { emits: {}, view: (0, rpc_dynamic_1.noStrict)({}) };
+            for (const name of Object.keys(lines)) {
+                const [emit, api] = makeLine(lines[name]);
+                entry.emits[name] = emit;
+                entry.view[name] = api;
+            }
+            accounts.set(account, entry);
+            watch[account] = entry.view;
+        }
+        return entry;
+    }
+    function publishOf(account) {
+        linesOf(account);
+        return function publish(line, frame, sentAt) {
+            linesOf(account).emits[line]?.(frame, sentAt);
+        };
+    }
+    const watcherViews = new Map();
+    function allowed(watcher, owner, line) {
+        return canWatch ? canWatch(watcher, owner, line) : true;
+    }
+    function filteredLine(watcher, owner, name, source, cache) {
+        const [emit, filtered] = (0, replay_listen_1.replayListen)({
+            history: lines[name] == 'video' ? videoHistory : audioHistory,
+            current: function currentIfAllowed() {
+                return allowed(watcher, owner, name) ? source.keyframe()?.event : undefined;
+            },
+            ...(lines[name] == 'video' ? {
+                frame: function lastAllowedFrame(tail) {
+                    return tail.length ? [tail[tail.length - 1]] : [];
+                },
+            } : {}),
+        });
+        const offSource = source.on(function forwardAllowed(frame, sentAt) {
+            if (allowed(watcher, owner, name))
+                emit(frame, sentAt);
+        });
+        const closeFiltered = filtered.close;
+        filtered.close = function closePolicyLine() {
+            offSource();
+            closeFiltered();
+        };
+        cache.filtered.add(filtered);
+        return filtered;
+    }
+    function ownerViewFor(watcher, owner, cache) {
+        let view = cache.owners.get(owner);
+        if (view)
+            return view;
+        const entry = accounts.get(owner);
+        if (!entry)
+            return undefined;
+        const policyLines = {};
+        for (const name of Object.keys(lines))
+            policyLines[name] = filteredLine(watcher, owner, name, entry.view[name], cache);
+        view = (0, rpc_dynamic_1.noStrict)(new Proxy(policyLines, {
+            has(t, k) { return typeof k == 'string' && k in t && allowed(watcher, owner, k); },
+            get(t, k) {
+                if (typeof k != 'string')
+                    return t[k];
+                return k in t && allowed(watcher, owner, k) ? t[k] : undefined;
+            },
+        }));
+        cache.owners.set(owner, view);
+        return view;
+    }
+    function watchOf(watcher) {
+        let cached = watcherViews.get(watcher);
+        if (cached)
+            return cached.root;
+        const owners = new Map();
+        const filtered = new Set();
+        function visible(owner) {
+            return accounts.has(owner) && Object.keys(lines).some(name => allowed(watcher, owner, name));
+        }
+        const root = (0, rpc_dynamic_1.noStrict)(new Proxy({}, {
+            has(_t, k) { return typeof k == 'string' && visible(k); },
+            get(_t, k) {
+                if (typeof k != 'string')
+                    return undefined;
+                return visible(k) ? ownerViewFor(watcher, k, cached) : undefined;
+            },
+        }));
+        cached = { root, owners, filtered };
+        watcherViews.set(watcher, cached);
+        return root;
+    }
+    function dropLines(entry) {
+        for (const name of Object.keys(entry.view))
+            entry.view[name].close();
+    }
+    function closeWatcherCache(cache) {
+        for (const line of cache.filtered)
+            line.close();
+        cache.filtered.clear();
+        cache.owners.clear();
+    }
+    function dropAccount(account) {
+        const entry = accounts.get(account);
+        const ownCache = watcherViews.get(account);
+        if (ownCache)
+            closeWatcherCache(ownCache);
+        watcherViews.delete(account);
+        for (const cache of watcherViews.values()) {
+            const ownerView = cache.owners.get(account);
+            if (ownerView)
+                for (const line of Object.values(ownerView)) {
+                    line.close();
+                    cache.filtered.delete(line);
+                }
+            cache.owners.delete(account);
+        }
+        if (!entry)
+            return;
+        accounts.delete(account);
+        delete watch[account];
+        dropLines(entry);
+    }
+    return {
+        publishOf,
+        watch,
+        watchOf,
+        lines: (account) => linesOf(account).view,
+        accounts: () => Array.from(accounts.keys()),
+        dropAccount,
+        close() {
+            for (const cache of watcherViews.values())
+                closeWatcherCache(cache);
+            for (const entry of accounts.values())
+                dropLines(entry);
+            accounts.clear();
+            watcherViews.clear();
+        },
+    };
+}

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

@@ -2,11 +2,19 @@ import { ReplayEvent } from '../events/replay-listen';
 import { ReplayRemote } from '../events/replay-wire';
 import { StorePatch } from '../Observe/store';
 export type PatchEnvelope = ReplayEvent<[StorePatch]>;
+export type tRelayGap = 'resume' | 'sacred';
+export type RelayPushResult = boolean | {
+    seq: number;
+};
 export declare function createPatchRelayJournal(opts?: {
     history?: number;
+    gap?: tRelayGap;
 }): {
-    push: (env: PatchEnvelope) => boolean;
-    remote: ReplayRemote<[StorePatch]>;
+    push: (env: PatchEnvelope) => RelayPushResult;
+    remote: ReplayRemote<[StorePatch]> & {
+        seq: () => number;
+    };
+    gap: tRelayGap;
     seq: () => number;
     snapshot: () => any;
     close: () => void;

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

@@ -16,37 +16,51 @@ function condensePatchTail(tail) {
     return Array.from(held.values());
 }
 function createPatchRelayJournal(opts = {}) {
-    const { history = 1024 } = opts;
+    const { history = 1024, gap = 'resume' } = opts;
+    const folding = gap != 'sacred';
     const [emitLine, line] = (0, Listen_1.listen)();
-    const fold = (0, store_1.createStore)({}, { drain: 'micro' });
+    const fold = folding ? (0, store_1.createStore)({}, { drain: 'micro' }) : null;
     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;
+    function accept(env, reset) {
+        if (reset)
             ring = [];
-        }
         last = env.seq;
         lastTs = env.ts ?? lastTs;
         hasState = true;
-        (0, store_1.applyStorePatch)(fold, patch);
+        if (fold)
+            (0, store_1.applyStorePatch)(fold, env.event[0]);
         ring.push(env);
         if (ring.length > history)
             ring.splice(0, ring.length - history);
         emitLine(env);
         return true;
     }
+    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 (folding && isRoot && env.seq < last)
+                return accept(env, true);
+            return true;
+        }
+        if (hasState && env.seq > last + 1) {
+            if (folding && isRoot)
+                return accept(env, true);
+            return { seq: last };
+        }
+        if (folding && !hasState && !isRoot)
+            return { seq: -1 };
+        return accept(env, false);
+    }
     function keyframe() {
-        if (!hasState)
+        if (!fold || !hasState)
             return null;
         return { seq: last, ts: lastTs, event: [{ path: [], exists: true, value: fold.snapshot() }] };
     }
@@ -64,14 +78,22 @@ function createPatchRelayJournal(opts = {}) {
         if (tail)
             return condensePatchTail(tail);
         const kf = keyframe();
-        return kf ? [kf] : null;
+        if (kf)
+            return [kf];
+        if (!folding && hasState)
+            throw new Error('sacred relay journal: tail evicted, no keyframe to invent');
+        return null;
     }
-    const remote = { line, since, keyframe, frame };
+    const remote = {
+        line, since, keyframe, frame,
+        seq: () => last,
+    };
     return {
         push,
         remote,
+        gap,
         seq: () => last,
-        snapshot: () => fold.snapshot(),
+        snapshot: () => fold?.snapshot(),
         close: () => { line.close(); },
     };
 }

package/observe/listen-core.test.ts

@@ -62,5 +62,4 @@ async function main() {
     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.70",
+  "version": "1.0.74",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",
@@ -42,8 +42,5 @@
     "./package.json": "./package.json",
     "./media": "./lib/Common/media/media-index.js",
     "./peer": "./lib/Common/peer/peer-index.js"
-  },
-  "dependencies": {
-    "express": "^5.2.1"
   }
 }

package/replay/media-view.test.ts

@@ -0,0 +1,164 @@
+// ============================================================
+//  replay/media-view.test.ts
+//
+//  Media viewer helpers oracle (Node, no browser):
+//  - attachAudioPlayer: PCM decode, sequential playhead, live
+//    backlog drop, enable/disable, non-audio frames ignored
+//  - attachVideoCanvas: injected bitmap decoder, sizing follows
+//    frames, busy-skip keeps latest, stats
+//  - pipeMediaPublish: sentAt stamp, onError on rejection
+// ============================================================
+
+import {listen} from '../src/Common/events/Listen'
+import {
+    attachAudioPlayer,
+    attachVideoCanvas,
+    encodeMediaFrame,
+    pipeMediaPublish,
+} from '../src/Common/media/media-index'
+
+let fails = 0
+const ok = (condition: any, message: string) => {
+    if (!condition) { fails++; console.log('  FAIL', message) }
+    else console.log('  OK  ', message)
+}
+const delay = (ms: number) => new Promise<void>(r => setTimeout(r, ms))
+
+function pcmFrame(seq: number, nSamples = 480, sampleRate = 48000) {
+    const pcm = new Int16Array(nSamples)
+    for (let i = 0; i < nSamples; i++) pcm[i] = (i % 2 ? 1 : -1) * 1000
+    return encodeMediaFrame({kind: 'audio-pcm', codec: 'pcm16', seq, tMono: seq, sampleRate, channels: 1, nSamples}, new Uint8Array(pcm.buffer))
+}
+
+function videoFrame(seq: number, width: number, height: number) {
+    return encodeMediaFrame({kind: 'video-frame', codec: 'jpeg', seq, tMono: seq, width, height}, new Uint8Array([1, 2, 3]))
+}
+
+function createFakeAudioContext() {
+    const scheduled: {at: number, frames: number}[] = []
+    const ctx = {
+        currentTime: 0,
+        destination: {},
+        resumed: 0,
+        closed: 0,
+        resume() { ctx.resumed++ },
+        close() { ctx.closed++ },
+        createBuffer: (_ch: number, frames: number, _rate: number) => ({
+            frames,
+            getChannelData: () => new Float32Array(frames),
+        }),
+        createBufferSource: () => {
+            const node: any = {connect: () => {}, start: (at: number) => scheduled.push({at, frames: node.buffer.frames})}
+            return node
+        },
+        scheduled,
+    }
+    return ctx
+}
+
+async function main() {
+    console.log('\n[media-view] audio player: sequential playhead + live backlog drop')
+    {
+        const [emit, line] = listen<[Uint8Array, number]>()
+        const ctx = createFakeAudioContext()
+        const player = attachAudioPlayer(line as any, {audioContext: () => ctx as any})
+
+        emit(pcmFrame(1), Date.now())
+        ok(player.stats().frames == 1 && player.stats().played == 0, 'disabled player counts frames but schedules nothing')
+
+        player.enable()
+        ok(player.enabled && ctx.resumed == 1, 'enable() builds the injected context and resumes it')
+
+        emit(pcmFrame(2), Date.now() - 100)
+        ok(player.stats().played == 1 && ctx.scheduled.length == 1, 'enabled player schedules a decoded pcm16 buffer')
+        ok(ctx.scheduled[0].frames == 480, 'sample count survives decode (480 frames)')
+        ok(player.stats().ageMs >= 80, 'sentAt stamp turns into a real age measurement')
+
+        const before = ctx.scheduled.length
+        emit(videoFrame(3, 320, 240), Date.now())
+        ok(ctx.scheduled.length == before && player.stats().frames == 3, 'video frames on an audio player are counted, not scheduled')
+
+        // 40 x 10ms chunks pushed instantly = 0.4s of queued audio while currentTime stays 0
+        for (let i = 0; i < 40; i++) emit(pcmFrame(10 + i), Date.now())
+        ok(player.stats().dropped > 0, 'backlog past maxBacklogSec is dropped (live policy), not queued forever')
+        const last = ctx.scheduled[ctx.scheduled.length - 1]
+        ok(last.at <= 0.45, `playhead rebased near "now" after the drop (last at=${last.at.toFixed(2)}s)`)
+
+        player.disable()
+        ok(!player.enabled && ctx.closed == 1, 'disable() closes the context')
+        player.off()
+    }
+
+    console.log('\n[media-view] video canvas: sizing follows frames, busy-skip keeps latest')
+    {
+        const [emit, line] = listen<[Uint8Array, number]>()
+        const drawnImages: any[] = []
+        const canvas: any = {
+            width: 0,
+            height: 0,
+            getContext: () => ({drawImage: (img: any) => drawnImages.push(img)}),
+        }
+        let decodeDelay = 0
+        const view = attachVideoCanvas(line as any, canvas, {
+            createBitmap: async blob => {
+                if (decodeDelay) await delay(decodeDelay)
+                return {size: blob.size, close: () => {}}
+            },
+        })
+
+        emit(videoFrame(1, 640, 480), Date.now() - 100)
+        await delay(10)
+        ok(view.stats().drawn == 1 && drawnImages.length == 1, 'video frame decoded via injected bitmap factory and drawn')
+        ok(canvas.width == 640 && canvas.height == 480, 'canvas takes the frame size')
+        ok(view.stats().width == 640 && view.stats().ageMs >= 80, 'stats expose frame size and age')
+
+        emit(pcmFrame(2), Date.now())
+        await delay(10)
+        ok(view.stats().drawn == 1 && view.stats().frames == 2, 'audio frame on a video canvas is counted, not drawn')
+
+        decodeDelay = 30
+        emit(videoFrame(3, 1280, 720), Date.now())
+        emit(videoFrame(4, 1280, 720), Date.now())   // arrives while frame 3 decodes -> skipped
+        await delay(60)
+        ok(view.stats().frames == 4 && view.stats().drawn == 2, 'busy-skip: overlapping frame dropped, not queued')
+        ok(canvas.width == 1280 && canvas.height == 720, 'canvas resized to the new resolution')
+
+        view.off()
+        emit(videoFrame(5, 320, 240), Date.now())
+        await delay(10)
+        ok(view.stats().frames == 4, 'off() unsubscribes the line')
+    }
+
+    console.log('\n[media-view] publish pipe: stamp + onError')
+    {
+        const [emit, line] = listen<[Uint8Array]>()
+        const sent: {frame: Uint8Array, sentAt?: number}[] = []
+        const errors: unknown[] = []
+        const off = pipeMediaPublish(line as any, (frame, sentAt) => {
+            sent.push({frame, sentAt})
+            return frame.byteLength == 0 ? Promise.reject(new Error('boom')) : Promise.resolve(true)
+        }, {onError: e => errors.push(e)})
+
+        emit(pcmFrame(1))
+        ok(sent.length == 1 && typeof sent[0].sentAt == 'number', 'frames are published with a wall-clock stamp by default')
+
+        emit(new Uint8Array(0))
+        await delay(10)
+        ok(errors.length == 1, 'publish rejection lands in onError, capture loop survives')
+
+        off()
+        emit(pcmFrame(2))
+        ok(sent.length == 2, 'off() stops publishing')
+
+        const noStamp: (number | undefined)[] = []
+        const [emit2, line2] = listen<[Uint8Array]>()
+        pipeMediaPublish(line2 as any, (_f, sentAt) => { noStamp.push(sentAt) }, {stamp: false})
+        emit2(pcmFrame(3))
+        ok(noStamp.length == 1 && noStamp[0] == undefined, 'stamp:false publishes without a timestamp')
+    }
+
+    console.log(fails ? `\n${fails} FAILED` : '\nall passed')
+    if (fails) process.exit(1)
+}
+
+main().catch(e => { console.error(e); process.exit(1) })