wenay-common2 1.0.69 → 1.0.73

package/replay/history.test.ts

@@ -0,0 +1,222 @@
+// ============================================================
+//  replay/history.test.ts
+//
+//  Слой C: архиватор (каданс keyframe'ов) + читатель истории.
+//  Часть 1 — seek по seq/ts, часть 2 — playback и дыра в архиве,
+//  часть 3 — handover архив → живой журнал → live, часть 4 —
+//  «перемотка на 12:00» с бесшовным доигрыванием до live,
+//  часть 5 — машина времени для стора, часть 6 — файловое
+//  хранилище (jsonl) как доказательство «лямбды = что угодно».
+//  Запуск:
+//      npx ts-node replay/history.test.ts
+// ============================================================
+
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import {applyStorePatch, createStore, StorePatch} from '../src/Common/Observe/store'
+import {flushReactive} from '../src/Common/Observe/reactive'
+import {replayListen, ReplayEvent} from '../src/Common/events/replay-index'
+import {archiveReplay, createMemoryReplayStorage, openHistory, ReplayStorage} from '../src/Common/events/replay-index'
+import {exposeStoreReplay, storeReplayAt} from '../src/Common/Observe/store-replay'
+
+let fails = 0
+const ok = (condition: any, message: string) => {
+    if (!condition) { fails++; console.log('  FAIL', message) }
+    else console.log('  OK  ', message)
+}
+const json = (v: any) => JSON.stringify(v)
+const ascendingUnique = (seqs: number[]) => seqs.every((s, i) => i == 0 || s > seqs[i - 1])
+
+type World = {
+    units: Record<string, {hp: number, x: number}>
+    tick: number
+}
+
+// счётчик-линия с подменяемыми часами: событие n = абсолютное значение n,
+// ts события n = 1000 + 1000*n → последний конверт = состояние
+function makeCounterLine(storage: ReplayStorage<[number]>, everyEvents: number, useAsJournal = false) {
+    let clock = 1000
+    let value = 0
+    const [emit, replay] = replayListen<[number]>({
+        current: () => [value],
+        // «память снаружи»: живой журнал = тот же архив → playback→live без скачка
+        ...(useAsJournal
+            ? {getSince: (s: number) => storage.getEvents(s, Infinity)}
+            : {history: 5}),
+        now: () => clock,
+    })
+    const arch = archiveReplay(replay, {storage, everyEvents})
+    const push = (n: number) => { value = n; clock = 1000 + 1000 * n; emit(n) }
+    return {replay, arch, push}
+}
+const lastValue = (envs: ReplayEvent<[number]>[] | undefined) => envs ? envs[envs.length - 1].event[0] : undefined
+
+async function main() {
+    console.log('\n[history] archiver cadence + seek by seq and ts')
+    {
+        const storage = createMemoryReplayStorage<[number]>()
+        const {arch, push} = makeCounterLine(storage, 10)
+        for (let n = 1; n <= 35; n++) push(n)
+        ok(storage.size().events == 35, 'every line event landed in the archive')
+        ok(storage.size().keyframes == 4, `base + one keyframe per 10 events (got ${storage.size().keyframes})`)
+
+        const h = openHistory(storage)
+        const at17 = h.at({seq: 17})
+        ok(lastValue(at17) == 17, 'seek by seq: keyframe + deltas reconstruct the state')
+        ok(at17![0].seq == 10 && at17!.length == 8, 'reconstruction starts at the NEAREST keyframe, not from zero')
+        ok(lastValue(h.at({ts: 1000 + 1000 * 12})) == 12, '«rewind to 12:00»: ts resolves to keyframe <= ts + deltas to ts')
+        ok(lastValue(h.at({seq: 3})) == 3, 'before the first cadence frame the base keyframe anchors the replay')
+        ok(lastValue(h.at()) == 35, 'no target = latest archived state')
+        arch.close()
+    }
+
+    console.log('\n[history] time-based cadence (GOP by wall clock)')
+    {
+        const storage = createMemoryReplayStorage<[number]>()
+        let clock = 0
+        let value = 0
+        const [emit, replay] = replayListen<[number]>({current: () => [value], history: 5, now: () => clock})
+        const arch = archiveReplay(replay, {storage, everyEvents: 1000, everyMs: 5000})
+        for (let n = 1; n <= 12; n++) { value = n; clock = n * 1000; emit(n) }
+        // кадры на ts 5000 и 10000 (+ базовый) — событий мало, время истекло
+        ok(arch.stats().keyframes == 3, `everyMs cuts keyframes by time when events are sparse (got ${arch.stats().keyframes})`)
+        arch.close()
+    }
+
+    console.log('\n[history] pure playback + hole in the archive')
+    {
+        const storage = createMemoryReplayStorage<[number]>()
+        const {arch, push} = makeCounterLine(storage, 10)
+        for (let n = 1; n <= 35; n++) push(n)
+        const h = openHistory(storage)
+
+        const got: number[] = []
+        const sub = h.subscribe(n => got.push(n), {since: 30})
+        ok(json(got) == json([31, 32, 33, 34, 35]), 'playback from since = pure tail, no keyframe')
+        ok(sub.seq() == 35, 'reader reports the reconnect point')
+        arch.close()
+
+        // архив с вытеснением: события 1..25 потеряны, keyframe'ы целы
+        const capped = createMemoryReplayStorage<[number]>({maxEvents: 10})
+        const line2 = makeCounterLine(capped, 10)
+        for (let n = 1; n <= 35; n++) line2.push(n)
+        const got2: number[] = []
+        openHistory(capped).subscribe(n => got2.push(n), {since: 5})
+        ok(got2[0] == 30, 'hole in the archive → fresh start from the latest keyframe (reset down allowed)')
+        ok(json(got2) == json([30, 31, 32, 33, 34, 35]), 'consistent tail after the keyframe, no state hole')
+        line2.arch.close()
+    }
+
+    console.log('\n[history] handover: archive replay → live journal → live')
+    {
+        const storage = createMemoryReplayStorage<[number]>()
+        const {replay, arch, push} = makeCounterLine(storage, 10)  // живой журнал: кольцо на 5
+        for (let n = 1; n <= 35; n++) push(n)
+
+        const got: number[] = []
+        const seqs: number[] = []
+        const h = openHistory(storage, replay)
+        const sub = h.subscribe(n => got.push(n), {since: 20, onSeq: s => seqs.push(s)})
+        ok(json(got) == json([21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]),
+            'archive covers what the live ring (5) evicted long ago')
+        push(36)
+        ok(got[got.length - 1] == 36, 'after catch-up the subscriber is LIVE on the same line')
+        ok(ascendingUnique(seqs), `no gap, no dup at the handover boundary: ${seqs.join(',')}`)
+        sub()
+        push(37)
+        ok(got[got.length - 1] == 36, 'off() disconnects the live part too')
+        arch.close()
+    }
+
+    console.log('\n[history] rewind to a moment, then play forward into live (no jump)')
+    {
+        const storage = createMemoryReplayStorage<[number]>()
+        // getSince линии смотрит в ЭТОТ ЖЕ архив → зазор архив→live закрыт по построению
+        const {replay, arch, push} = makeCounterLine(storage, 10, true)
+        for (let n = 1; n <= 35; n++) push(n)
+
+        const got: number[] = []
+        const seqs: number[] = []
+        const h = openHistory(storage, replay)
+        h.subscribe(n => got.push(n), {ts: 1000 + 1000 * 25, onSeq: s => seqs.push(s)})
+        ok(got[0] == 20 && got.includes(25), 'rewind: nearest keyframe <= ts, deltas up to ts')
+        ok(json(got.slice(got.indexOf(25))) == json([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]),
+            'played CONTINUOUSLY from ts to the head — no keyframe jump')
+        push(36)
+        ok(got[got.length - 1] == 36, '…and seamlessly into live')
+        ok(ascendingUnique(seqs), `seqs strictly ascending through both handovers: ${seqs.join(',')}`)
+        arch.close()
+    }
+
+    console.log('\n[history] store time machine: snapshot at any seq/ts from the patch archive')
+    {
+        let clock = 0
+        const backend = createStore<World>({units: {a: {hp: 100, x: 0}}, tick: 0}, {drain: 'micro'})
+        const exposed = exposeStoreReplay(backend, {history: 8, now: () => clock})
+        const storage = createMemoryReplayStorage<[StorePatch]>()
+        const arch = archiveReplay(exposed.replay, {storage, everyEvents: 7})
+
+        const snapAt: Record<number, string> = {}
+        const seqAt: Record<number, number> = {}
+        for (let i = 1; i <= 30; i++) {
+            clock = i * 1000
+            backend.state.tick = i
+            if (i % 10 == 0) backend.state.units['a'].hp = 100 - i
+            await flushReactive(backend.state)
+            snapAt[i] = json(backend.snapshot())
+            seqAt[i] = exposed.replay.head()
+        }
+        ok(json(storeReplayAt<World>(storage, {seq: seqAt[11]})) == snapAt[11], 'state at seq — bit-exact, though the live ring holds only 8')
+        ok(json(storeReplayAt<World>(storage, {ts: 23 * 1000})) == snapAt[23], 'state at ts («what did the world look like at 12:00»)')
+        ok(json(storeReplayAt<World>(storage)) == snapAt[30], 'no target = latest archived state')
+
+        // зеркало целиком из архива + живой хвост
+        const mirror = createStore<World>({units: {}, tick: -1})
+        const h = openHistory(storage, exposed.replay)
+        h.subscribe(function applyToMirror(patch) { applyStorePatch(mirror, patch) })
+        ok(json(mirror.state) == json(backend.snapshot()), 'mirror rebuilt from the archive matches the backend')
+        backend.state.tick = 31
+        await flushReactive(backend.state)
+        ok(mirror.state.tick == 31, 'and keeps following live')
+        arch.close()
+        exposed.close()
+    }
+
+    console.log('\n[history] file-backed storage: the lambda interface is enough')
+    {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'replay-history-'))
+        const evFile = path.join(dir, 'events.jsonl')
+        const kfFile = path.join(dir, 'keyframes.jsonl')
+        const readAll = (file: string): ReplayEvent<[number]>[] =>
+            fs.existsSync(file) ? fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map(l => JSON.parse(l)) : []
+        // наивный jsonl-архив: append на запись, полный скан на чтение — для оракула достаточно
+        const fileStorage: ReplayStorage<[number]> = {
+            putEvent: ev => fs.appendFileSync(evFile, JSON.stringify(ev) + '\n'),
+            putKeyframe: kf => fs.appendFileSync(kfFile, JSON.stringify(kf) + '\n'),
+            getKeyframe: (at = {}) => {
+                const all = readAll(kfFile)
+                const fits = all.filter(kf => at.ts != null ? kf.ts <= at.ts! : kf.seq <= (at.seq ?? Infinity))
+                return fits[fits.length - 1]
+            },
+            getEvents: (from, to) => readAll(evFile).filter(ev => ev.seq > from && ev.seq <= to),
+        }
+        try {
+            const {arch, push} = makeCounterLine(fileStorage, 5)
+            for (let n = 1; n <= 12; n++) push(n)
+            const h = openHistory(fileStorage)
+            ok(lastValue(h.at({seq: 8})) == 8, 'seek works over a file the same as over memory')
+            const got: number[] = []
+            h.subscribe(n => got.push(n), {since: 3})
+            ok(json(got) == json([4, 5, 6, 7, 8, 9, 10, 11, 12]), 'playback works over a file the same as over memory')
+            arch.close()
+        } finally {
+            fs.rmSync(dir, {recursive: true, force: true})
+        }
+    }
+
+    console.log(fails ? `\n${fails} FAILED` : '\nall passed')
+    if (fails) process.exit(1)
+}
+
+main().catch(e => { console.error(e); process.exit(1) })

package/replay/media-socket.test.ts

@@ -0,0 +1,157 @@
+// ============================================================
+//  replay/media-socket.test.ts
+//
+//  Media over socket smoke oracle:
+//  - fixed binary header + payload for audio/video frames
+//  - createAudioSource/createVideoSource are plain binary Listens
+//  - frames cross real Socket.IO/RPC as native binary, not a {0:...} object
+//  - browser capture absence returns typed state in Node, not throw
+// ============================================================
+
+import express from 'express'
+import {createServer} from 'http'
+import type {AddressInfo} from 'net'
+import {Server as SocketIOServer} from 'socket.io'
+import {io} from 'socket.io-client'
+import {
+    MEDIA_FRAME_HEADER_BYTES,
+    createAudioSource,
+    createVideoSource,
+    decodeMediaFrame,
+    encodeMediaFrame,
+} from '../src/Common/media/media-index'
+import {listen as createListenPair} from '../src/Common/events/Listen'
+import {createRpcClientHub} from '../src/Common/rcp/rpc-clientHub'
+import {createRpcServerAuto} from '../src/Common/rcp/rpc-server-auto'
+
+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 sameBytes(a: Uint8Array, b: Uint8Array) {
+    return a.byteLength == b.byteLength
+        && Buffer.compare(Buffer.from(a.buffer, a.byteOffset, a.byteLength), Buffer.from(b.buffer, b.byteOffset, b.byteLength)) == 0
+}
+
+function asBytes(v: any): Uint8Array {
+    if (v instanceof Uint8Array) return v
+    if (ArrayBuffer.isView(v)) return new Uint8Array(v.buffer, v.byteOffset, v.byteLength)
+    return new Uint8Array(v)
+}
+
+async function startRealServer(object: object) {
+    const app = express()
+    const httpServer = createServer(app)
+    const ioServer = new SocketIOServer(httpServer, {maxHttpBufferSize: 1e8})
+    ioServer.on('connection', socket => {
+        const [disconnect, disconnectListen] = createListenPair<[]>()
+        socket.on('disconnect', () => disconnect())
+        createRpcServerAuto({
+            socket: {
+                emit: (key, data) => socket.emit(key, data),
+                on: (key, cb) => socket.on(key, cb),
+            },
+            socketKey: 'media',
+            object,
+            disconnectListen,
+        })
+    })
+    await new Promise<void>((resolve, reject) => {
+        httpServer.once('error', reject)
+        httpServer.listen(0, '127.0.0.1', resolve)
+    })
+    return {
+        port: (httpServer.address() as AddressInfo).port,
+        close: () => new Promise<void>(resolve => {
+            ioServer.close()
+            httpServer.close(() => resolve())
+        }),
+    }
+}
+
+async function connectClient<T extends object>(port: number) {
+    const hub = createRpcClientHub(
+        () => io(`http://127.0.0.1:${port}`, {transports: ['websocket'], forceNew: true}),
+        r => ({api: r<T>('media')}) as const,
+    )
+    const clients = await hub.setToken(null)
+    await clients.api.readyStrict()
+    return {client: clients.api, close: () => hub.socket?.disconnect?.()}
+}
+
+async function waitFor(label: string, cond: () => boolean) {
+    for (let i = 0; i < 100; i++) {
+        if (cond()) return
+        await delay(20)
+    }
+    throw new Error(`timeout: ${label}`)
+}
+
+async function main() {
+    console.log('\n[media] fixed binary frames over a real Socket.IO wire')
+
+    const pcm = new Int16Array([0, 1000, -1000, 32767, -32768])
+    const audioFrame = encodeMediaFrame({
+        kind: 'audio-pcm',
+        codec: 'pcm16',
+        seq: 7,
+        tMono: 123.5,
+        sampleRate: 16000,
+        channels: 1,
+        nSamples: pcm.length,
+    }, new Uint8Array(pcm.buffer))
+    const decodedAudio = decodeMediaFrame(audioFrame)
+    ok(audioFrame.byteLength == MEDIA_FRAME_HEADER_BYTES + pcm.byteLength, 'audio frame is fixed header + raw PCM payload')
+    ok(decodedAudio.kind == 'audio-pcm' && decodedAudio.codec == 'pcm16', 'audio kind/codec decode from binary header')
+    ok(decodedAudio.sampleRate == 16000 && decodedAudio.nSamples == pcm.length, 'audio sample metadata decode from binary header')
+    ok(sameBytes(decodedAudio.payload, new Uint8Array(pcm.buffer)), 'audio payload stays byte-for-byte')
+
+    const jpg = new Uint8Array([0xff, 0xd8, 1, 2, 3, 0xff, 0xd9])
+    const videoFrame = encodeMediaFrame({
+        kind: 'video-frame',
+        codec: 'jpeg',
+        seq: 2,
+        tMono: 200,
+        width: 320,
+        height: 240,
+    }, jpg)
+    const decodedVideo = decodeMediaFrame(videoFrame)
+    ok(decodedVideo.width == 320 && decodedVideo.height == 240, 'video dimensions decode from binary header')
+    ok(sameBytes(decodedVideo.payload, jpg), 'video payload stays byte-for-byte')
+
+    const audio = createAudioSource({sourceId: 'mic'})
+    const video = createVideoSource({sourceId: 'cam'})
+    const replayVideo = createVideoSource({sourceId: 'cam-replay', replay: true})
+    ok(audio.kind == 'audio' && video.kind == 'video', 'media factories return control + [emit, listen] tuple')
+    ok(!!(replayVideo[1] as any).line && typeof (replayVideo[1] as any).frame == 'function', 'media replay:true returns replay-listen surface for RPC auto exposure')
+    ok(await audio.start() == 'no-device', 'Node without getUserMedia returns typed no-device state, not throw')
+    ok(await video.start() == 'no-device', 'video source also returns typed no-device state without browser globals')
+
+    const [emitAudio, audioListen] = audio
+    const server = await startRealServer({audio: audioListen})
+    const client = await connectClient<{audio: typeof audioListen}>(server.port)
+    try {
+        const got: Uint8Array[] = []
+        const deep = client.client.func as any
+        deep.audio.callback((frame: any) => got.push(asBytes(frame)))
+        await delay(100)
+        emitAudio(audioFrame)
+        await waitFor('binary media frame over rpc', () => got.length == 1)
+        const overWire = decodeMediaFrame(got[0])
+        ok(ArrayBuffer.isView(got[0]), 'RPC delivered media frame as native binary view')
+        ok(sameBytes(overWire.payload, decodedAudio.payload), 'RPC media payload survived byte-for-byte')
+        ok(overWire.seq == 7 && overWire.sampleRate == 16000, 'RPC media header survived byte-for-byte')
+    } finally {
+        client.close()
+        await delay(20)
+        await server.close()
+    }
+
+    console.log(fails ? `\n${fails} FAILED` : '\nall passed')
+    if (fails) process.exit(1)
+}
+
+main().catch(e => { console.error(e); process.exit(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() - 40)
+        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 >= 40, '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() - 25)
+        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 >= 25, '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) })