wenay-common2 1.0.69 → 1.0.73

package/replay/route-webrtc.test.ts

@@ -0,0 +1,321 @@
+// Acceptance oracle for step 9 (webrtc-route-coordinator-tasks): signaling
+// adapter (offer/answer/ICE/session/revoke) over the existing control channel +
+// WebRTC direct connector under createRouteCoordinator. RTCPeerConnection is
+// faked in-process (the runtime factory is injected by design); the second
+// section drives the SAME signaling over a real Socket.IO/RPC wire.
+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 {listen as createListenPair} from '../src/Common/events/Listen'
+import {
+    acceptWebRtcDirect, createRouteCoordinator, createSignalHub, createWebRtcConnector,
+    exposeReplay, replayListen, RouteConnector, RtcDataChannel, RtcPeerConnection,
+    SignalPort, tConnectorState,
+} from '../src/Common/events/replay-index'
+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))
+const json = (v: any) => JSON.stringify(v)
+
+async function waitFor(label: string, cond: () => boolean) {
+    for (let i = 0; i < 200; i++) {
+        if (cond()) return
+        await delay(15)
+    }
+    throw new Error(`timeout: ${label}`)
+}
+
+// =====================================================================
+// Fake in-process WebRTC runtime: SDP = pc id, ICE trickle simulated,
+// datachannel = paired in-proc endpoints. Injected exactly like a browser
+// would inject () => new RTCPeerConnection(cfg).
+// =====================================================================
+
+function createFakeRtcNet() {
+    let n = 0
+    const pcs = new Map<string, any>()
+    const stats = {ice: 0, channels: 0}
+
+    function makeDcPair(): [RtcDataChannel, RtcDataChannel] {
+        let closed = false
+        function side(other: () => any): any {
+            const me: any = {onopen: null, onmessage: null, onclose: null, onerror: null}
+            me.send = (data: string) => {
+                if (closed) return
+                setTimeout(function deliverDc() { if (!closed2()) other().onmessage?.({data}) }, 0)
+            }
+            me.close = () => {
+                if (closed) return
+                closed = true
+                setTimeout(function closeDc() { me.onclose?.(); other().onclose?.() }, 0)
+            }
+            return me
+        }
+        const closed2 = () => closed
+        let a: any, b: any
+        a = side(() => b)
+        b = side(() => a)
+        return [a, b]
+    }
+
+    function tryConnect(me: any) {
+        if (!me.local || !me.remote) return
+        const other = pcs.get(me.remote.sdp)
+        if (!other || !other.local || !other.remote || other.remote.sdp != me.id) return
+        const initiator = me.pendingDcs.length ? me : other
+        const responder = initiator == me ? other : me
+        if (!initiator.pendingDcs.length || initiator.linked) return
+        initiator.linked = responder.linked = true
+        for (const dc of initiator.pendingDcs) {
+            const [a, b] = makeDcPair()
+            // связываем заранее созданный локальный конец с новорождённым твином
+            dc.attach(a)
+            stats.channels++
+            setTimeout(function announceChannel() {
+                responder.pc.ondatachannel?.({channel: b})
+                dc.fireOpen()
+            }, 0)
+        }
+        initiator.pendingDcs = []
+    }
+
+    function pc(): RtcPeerConnection {
+        const id = 'sdp-' + (++n)
+        const me: any = {id, local: null, remote: null, pendingDcs: [], linked: false}
+        const api: RtcPeerConnection = {
+            createDataChannel() {
+                // локальный конец создаётся ДО соединения: методы делегируются после attach
+                let real: any = null
+                const shell: any = {onopen: null, onmessage: null, onclose: null, onerror: null}
+                shell.send = (data: string) => real?.send(data)
+                shell.close = () => real?.close()
+                me.pendingDcs.push({
+                    attach(a: any) {
+                        real = a
+                        if (!a) return
+                        a.onmessage = (ev: any) => shell.onmessage?.(ev)
+                        a.onclose = () => shell.onclose?.()
+                    },
+                    fireOpen() { shell.onopen?.() },
+                })
+                return shell
+            },
+            createOffer: async () => ({type: 'offer', sdp: id}),
+            createAnswer: async () => ({type: 'answer', sdp: id}),
+            setLocalDescription(d) {
+                me.local = d
+                setTimeout(function trickleIce() { api.onicecandidate?.({candidate: {via: id}}) }, 0)
+            },
+            setRemoteDescription(d) {
+                me.remote = d
+                tryConnect(me)
+            },
+            addIceCandidate() { stats.ice++ },
+            close() {
+                for (const dc of me.pendingDcs) dc.attach?.(null)
+                me.pendingDcs = []
+            },
+            onicecandidate: null,
+            ondatachannel: null,
+        }
+        me.pc = api
+        pcs.set(id, me)
+        return api
+    }
+
+    return {pc, stats}
+}
+
+// простой relay-коннектор: прямой доступ к журналу с лагом (как в route-coordinator оракуле)
+function makeRelayConnector<Z extends any[]>(replay: any, lag = 5): RouteConnector<Z> {
+    let state: tConnectorState = 'idle'
+    return {
+        info: {label: 'relay', kind: 'relay', ordered: true, reliable: true},
+        open: async () => {
+            state = 'opening'
+            await delay(lag)
+            state = 'open'
+            return {
+                line: {on: (cb: any) => replay.line.on(cb)},
+                since: async (s: number) => { await delay(lag); return replay.getSince(s) ?? null },
+                keyframe: async () => { await delay(lag); return replay.keyframe() ?? null },
+                frame: async (s: number, hint?: unknown) => { await delay(lag); return replay.frame(s, hint) },
+            }
+        },
+        close: () => { state = 'closed' },
+        state: () => state,
+    }
+}
+
+async function main() {
+    console.log('\n[route-webrtc] in-proc signaling hub: offer/answer/ICE/session/revoke')
+    {
+        let state = 0
+        const [emit, replay] = replayListen<[number]>({current: () => [state], history: 100})
+        const envLog: string[] = []
+        let allowDirect = true
+        const hub = createSignalHub({authorize: env => { envLog.push(env.type); return allowDirect }})
+        const portA = hub.register('a')
+        const portB = hub.register('b')
+        const rtcNet = createFakeRtcNet()
+        const sess = {token: 'good'}
+        const stopAccept = acceptWebRtcDirect<[number]>({
+            port: portB,
+            rtc: rtcNet.pc,
+            self: 'b',
+            serve: () => exposeReplay(replay),
+            accept: env => (env.session as any)?.token == 'good',
+        })
+
+        const coord = createRouteCoordinator<[number]>({
+            connect: (ref, kind) => kind == 'relay'
+                ? makeRelayConnector<[number]>(replay)
+                : createWebRtcConnector<[number]>({
+                    port: portA, rtc: rtcNet.pc, self: 'a', peer: 'b',
+                    pair: ref.key, session: sess, openTimeoutMs: 1500,
+                }),
+        })
+        const link = coord.pair('a', 'b')
+        const got: number[] = []
+        const sub = link.subscribe(v => got.push(v))
+        await sub.ready
+        ok(json(got) == json([0]), 'relay baseline delivers the keyframe')
+
+        state = 1; emit(state)
+        const res = await link.promoteDirect()
+        ok(res.ok && link.state() == 'direct', 'promotion over webrtc signaling lands in direct')
+        ok(envLog.includes('offer') && envLog.includes('answer') && envLog.includes('ice'), `hub authorized offer/answer/ice (${json(envLog)})`)
+        ok(rtcNet.stats.ice > 0 && rtcNet.stats.channels == 1, 'ICE exchanged and exactly one datachannel established')
+        state = 2; emit(state)
+        state = 3; emit(state)
+        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')
+
+        // 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')
+
+        // сервер не раскрывает endpoint: offer отклонён ДО транспорта
+        allowDirect = false
+        const denied = await link.promoteDirect()
+        ok(!denied.ok && String(denied.reason).includes('endpoint'), 'hub authorize=false: offer rejected, direct not established')
+        ok(link.state() == 'fallback', 'denied endpoint leaves the pair on relay (fallback)')
+
+        // приёмная сторона бракует session-материал: revoke вместо таймаута
+        allowDirect = true
+        sess.token = 'bad'
+        const badSession = await link.promoteDirect()
+        ok(!badSession.ok && String(badSession.reason).includes('revoke'), `bad session material is rejected loudly by the peer (${String(badSession.reason)})`)
+
+        // и после всех отказов пара всё ещё может подняться в direct
+        sess.token = 'good'
+        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')
+
+        coord.close()
+        stopAccept()
+        hub.close()
+    }
+
+    console.log('\n[route-webrtc] signaling over the EXISTING socket/RPC control channel')
+    {
+        let state = 0
+        const [emit, replay] = replayListen<[number]>({current: () => [state], history: 100})
+        const hub = createSignalHub()
+        const rtcNet = createFakeRtcNet()
+
+        // сервер: обычный createRpcServerAuto; сигнальный порт = {send, signals} на соединение
+        const app = express()
+        const httpServer = createServer(app)
+        const ioServer = new SocketIOServer(httpServer)
+        ioServer.on('connection', socket => {
+            const account = String(socket.handshake.auth?.account)
+            const port = hub.register(account)
+            const [disconnect, disconnectListen] = createListenPair<[]>()
+            socket.on('disconnect', () => { disconnect(); port.close() })
+            createRpcServerAuto({
+                socket: {emit: (key, data) => socket.emit(key, data), on: (key, cb) => socket.on(key, cb)},
+                socketKey: 'signal',
+                object: {send: port.send, signals: port.signals},
+                disconnectListen,
+            })
+        })
+        await new Promise<void>((resolve, reject) => {
+            httpServer.once('error', reject)
+            httpServer.listen(0, '127.0.0.1', resolve)
+        })
+        const port = (httpServer.address() as AddressInfo).port
+
+        async function connectSignalPort(account: string): Promise<SignalPort & {closeSocket: () => void}> {
+            const clientHub = createRpcClientHub(
+                () => io(`http://127.0.0.1:${port}`, {transports: ['websocket'], forceNew: true, auth: {account}}),
+                r => ({api: r<any>('signal')}) as const,
+            )
+            const clients = await clientHub.setToken(null)
+            await clients.api.readyStrict()
+            const deep = clients.api.func
+            return {
+                send: (env: any) => deep.send(env),
+                signals: {on: (cb: any) => deep.signals.callback(cb)},
+                closeSocket: () => clientHub.socket?.disconnect?.(),
+            }
+        }
+
+        const portA = await connectSignalPort('a')
+        const portB = await connectSignalPort('b')
+        const stopAccept = acceptWebRtcDirect<[number]>({
+            port: portB, rtc: rtcNet.pc, self: 'b', serve: () => exposeReplay(replay),
+        })
+        const coord = createRouteCoordinator<[number]>({
+            connect: (ref, kind) => kind == 'relay'
+                ? makeRelayConnector<[number]>(replay)
+                : createWebRtcConnector<[number]>({
+                    port: portA, rtc: rtcNet.pc, self: 'a', peer: 'b',
+                    pair: ref.key, openTimeoutMs: 4000,
+                }),
+        })
+        const link = coord.pair('a', 'b')
+        const got: number[] = []
+        const sub = link.subscribe(v => got.push(v))
+        await sub.ready
+
+        const res = await link.promoteDirect()
+        ok(res.ok && link.state() == 'direct', 'promotion negotiated over a real Socket.IO/RPC signaling channel')
+        state = 1; emit(state)
+        state = 2; emit(state)
+        await waitFor('live over datachannel (rpc-signaled)', () => got.length >= 3)
+        ok(json(got) == json([0, 1, 2]), 'payload rides the direct channel, signaling rode the rpc wire')
+
+        hub.revoke(link.ref.key, ['a', 'b'], 'server policy')
+        await waitFor('revoke over rpc wire', () => link.state() == 'fallback')
+        state = 3; emit(state)
+        await waitFor('relay resume (rpc-signaled)', () => got.includes(3))
+        ok(json(got) == json([0, 1, 2, 3]), 'revoke over the rpc wire falls back to relay with no gap')
+
+        coord.close()
+        stopAccept()
+        portA.closeSocket()
+        portB.closeSocket()
+        hub.close()
+        ioServer.close()
+        await new Promise<void>(resolve => httpServer.close(() => resolve()))
+    }
+
+    console.log(fails ? `\n${fails} FAILED` : '\nall passed')
+    if (fails) process.exit(1)
+}
+
+main().catch(e => { console.error(e); process.exit(1) })

package/replay/rpc-auto.test.ts

@@ -0,0 +1,256 @@
+// ============================================================
+//  replay/rpc-auto.test.ts
+//
+//  Feature A+B (rev 2): replay-transparent RPC exposure.
+//  - легаси-подписка на replay-ключ = байт-в-байт plain Listen
+//  - replaySubscribe против merged-узла (since:0, no gaps/dups)
+//  - оба потребителя на ОДНОМ соединении
+//  - frame: мини-кадрик == fold полного хвоста (equivalence)
+//  - current:'last' — keyframe без ручного состояния
+//  - ворота лага (policy 'frame'): пропуск + восстановление кадром
+//  - негативная детекция: похожий объект НЕ replay
+//  - священная линия: frame бросает громко (in-proc)
+//  Запуск: npx ts-node replay/rpc-auto.test.ts
+// ============================================================
+
+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 {listen as createListenPair} from '../src/Common/events/Listen'
+import {replayListen, ReplayEvent} from '../src/Common/events/replay-listen'
+import {replaySubscribe, ReplayRemote} from '../src/Common/events/replay-wire'
+import {createRpcClientHub} from '../src/Common/rcp/rpc-clientHub'
+import {createRpcServerAuto, RpcReplayOpts} from '../src/Common/rcp/rpc-server-auto'
+import {Pkt} from '../src/Common/rcp/rpc-protocol'
+import {rpcPathKey} from '../src/Common/rcp/rpc-path'
+
+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))
+const json = (v: any) => JSON.stringify(v)
+
+async function waitFor(label: string, cond: () => boolean) {
+    for (let i = 0; i < 200; i++) {
+        if (cond()) return
+        await delay(25)
+    }
+    throw new Error(`timeout: ${label}`)
+}
+
+async function startRealServer(object: object, replayOpts?: RpcReplayOpts, captured?: {listenPaths?: string[]}) {
+    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) => {
+                    // негативная детекция проверяется по серверной декларации Pkt.MAP
+                    if (captured && Array.isArray(data) && data[0] === Pkt.MAP) captured.listenPaths = data[3]
+                    socket.emit(key, data)
+                },
+                on: (key, cb) => socket.on(key, cb),
+            },
+            socketKey: 'rpc-auto',
+            object,
+            disconnectListen,
+            replayOpts,
+        })
+    })
+    await new Promise<void>((resolve, reject) => {
+        httpServer.once('error', reject)
+        httpServer.listen(0, '127.0.0.1', resolve)
+    })
+    const port = (httpServer.address() as AddressInfo).port
+    return {
+        port,
+        close: () => new Promise<void>(resolve => {
+            ioServer.close()
+            httpServer.close(() => resolve())
+        }),
+    }
+}
+
+async function startRealClient<T extends object>(port: number) {
+    const hub = createRpcClientHub(
+        () => io(`http://127.0.0.1:${port}`, {transports: ['websocket'], forceNew: true}),
+        r => ({api: r<T>('rpc-auto')}) as const,
+    )
+    const clients = await hub.setToken(null)
+    await clients.api.readyStrict()
+    return {
+        client: clients.api,
+        close: () => hub.socket?.disconnect?.(),
+    }
+}
+
+// фасад: обычный Listen (baseline), одно-сущностная replay-линия, мульти-символьная
+// с уплотнителем, и обманка для негативной детекции
+function makeFacade() {
+    const [emitPlain, plain] = createListenPair<[number]>()
+    const [emitTicker, ticker] = replayListen<[number]>({history: 64, current: 'last'})
+    const [emitQuote, quotes] = replayListen<[string, number]>({
+        history: 256,
+        frame: function lastPerSymbol(tail) {
+            const held = new Map<string, ReplayEvent<[string, number]>>()
+            for (const ev of tail) { held.delete(ev.event[0]); held.set(ev.event[0], ev) }
+            return [...held.values()]
+        },
+    })
+    const fake = {line: {x: 1}, getSince: 1, keyframe: 'no'}
+    return {emitPlain, emitTicker, emitQuote, facade: {plain, ticker, quotes, fake}}
+}
+
+const foldQuotes = (envs: ReplayEvent<[string, number]>[]) => {
+    const m: Record<string, number> = {}
+    for (const ev of envs) m[ev.event[0]] = ev.event[1]
+    return m
+}
+
+async function main() {
+    console.log('\n[rpc-auto] replay-transparent exposure over a real Socket.IO wire')
+
+    // ============ in-proc: священная линия бросает громко ============
+    {
+        const [emit, sacred] = replayListen<[number]>({history: 2})
+        for (let i = 1; i <= 5; i++) emit(i)
+        let threw = false
+        try { sacred.frame(0) } catch { threw = true }
+        ok(threw, 'sacred line + evicted journal: frame(0) throws (no silent invention)')
+        ok(sacred.frame(4).length == 1 && sacred.frame(4)[0].event[0] == 5, 'sacred line + covered gap: exact tail')
+    }
+
+    // ============ in-proc: конец стрима (не-конверт) — громко в onError ============
+    {
+        let err: any = null
+        const remote: ReplayRemote<[number]> = {
+            line: {on: (cb: any) => { setTimeout(() => cb('___STOP'), 5); return () => {} }},
+            since: () => [],
+            keyframe: () => null,
+        }
+        replaySubscribe(remote, () => {}, {since: 0, onError: e => err = e})
+        await delay(30)
+        ok(err != null, 'non-envelope on line (RPC_STOP) surfaces via onError, not silence')
+    }
+
+    const world = makeFacade()
+    type Facade = typeof world.facade
+    const captured: {listenPaths?: string[]} = {}
+    const server = await startRealServer(world.facade, undefined, captured)
+    const c1 = await startRealClient<Facade>(server.port)
+    let gateServer: Awaited<ReturnType<typeof startRealServer>> | null = null
+    let c3: Awaited<ReturnType<typeof startRealClient<Facade>>> | null = null
+
+    try {
+        const deep = c1.client.func
+
+        // ============ декларация MAP: replay-узлы объявлены, обманка — нет ============
+        const lp = captured.listenPaths ?? []
+        const partsOf = (key: string) => {
+            try {
+                const parsed = JSON.parse(key)
+                if (Array.isArray(parsed)) return parsed.map(String)
+            } catch {}
+            return key.split('.')
+        }
+        const samePath = (key: string, path: string[]) => {
+            const parts = partsOf(key)
+            return parts.length == path.length && parts.every((p, i) => p == path[i])
+        }
+        const hasPath = (...path: string[]) => lp.includes(rpcPathKey(path)) || lp.some(k => samePath(k, path))
+        const startsWithPath = (key: string, path: string[]) => path.every((p, i) => partsOf(key)[i] == p)
+        ok(hasPath('ticker') && hasPath('quotes'), `replay keys declared as listen nodes (${json(lp)})`)
+        ok(hasPath('ticker', 'line') && hasPath('quotes', 'frameLine'), 'replay wire sub-lines declared additively in Pkt.MAP')
+        ok(hasPath('plain'), 'plain Listen declared as before (MAP grows additively)')
+        ok(!lp.some(p => startsWithPath(p, ['fake'])), 'object with line/getSince/keyframe props is NOT misdetected (brand)')
+
+        // ============ легаси-паритет: replay-ключ ведёт себя как plain Listen ============
+        const gotPlain: number[] = []
+        const gotTicker: number[] = []
+        deep.plain.callback((v: number) => gotPlain.push(v))
+        deep.ticker.callback((v: number) => gotTicker.push(v))
+        await delay(150) // подписки долетели
+        for (let i = 1; i <= 5; i++) { world.emitPlain(i); world.emitTicker(i) }
+        await waitFor('legacy live events', () => gotPlain.length >= 5 && gotTicker.length >= 5)
+        ok(json(gotTicker) == json(gotPlain), `legacy path: replay key delivers exactly what a plain Listen does (${json(gotTicker)})`)
+
+        // ============ replay-путь на ТОМ ЖЕ соединении (legacy + replay сосуществуют) ============
+        // merged-узел структурно совместим с ReplayRemote — deep.ticker уходит как есть
+        const seqs: number[] = []
+        const vals: number[] = []
+        const sub = replaySubscribe(deep.ticker, (v: number) => vals.push(v), {since: 0, onSeq: s => seqs.push(s)})
+        await sub.ready
+        ok(json(vals) == json([1, 2, 3, 4, 5]), `replaySubscribe since:0 folded journal, no gaps/dups (${json(vals)})`)
+        ok(seqs.every((s, i) => i == 0 || s == seqs[i - 1] + 1), 'seq strictly monotonic through catch-up')
+
+        world.emitTicker(6)
+        world.emitPlain(6)
+        await waitFor('live after catch-up on both consumers', () => vals.includes(6) && gotTicker.includes(6))
+        ok(true, 'legacy and replay subscriptions coexist live on ONE connection')
+
+        // ============ current:'last' — keyframe без ручного состояния ============
+        const kf = await deep.ticker.keyframe()
+        ok(kf && kf.event[0] == 6 && kf.seq == 6, `current:'last' keyframe = last envelope (${json(kf)})`)
+
+        // ============ frame equivalence: мини-кадрик == fold полного хвоста ============
+        world.emitQuote('AAPL', 100); world.emitQuote('AAPL', 101); world.emitQuote('MSFT', 300)
+        world.emitQuote('AAPL', 102); world.emitQuote('MSFT', 301)
+        const fullTail = await deep.quotes.since(0)
+        const mini = await deep.quotes.frame(0)
+        ok(fullTail.length == 5 && mini.length == 2, `mini-frame condensed 5 events into 2 (${mini.length})`)
+        ok(json(foldQuotes(mini)) == json(foldQuotes(fullTail)), 'apply(mini-frame) == apply(full tail) — state equivalent')
+        ok(mini.every((ev, i) => i == 0 || ev.seq > mini[i - 1].seq), 'mini-frame envelopes monotonic by seq')
+
+        // ============ ворота лага (Feature B): policy 'frame' ============
+        let fakePending = 0
+        gateServer = await startRealServer(world.facade, {pending: () => fakePending, highWater: 5, lowWater: 0, pollMs: 10})
+        c3 = await startRealClient<Facade>(gateServer.port)
+        const deep3 = c3.client.func
+        const gated: Record<string, number> = {}
+        let gatedDeliveries = 0
+        const gsub = replaySubscribe(deep3.quotes, (sym, px) => { gated[sym] = px; gatedDeliveries++ }, {
+            since: (await deep3.quotes.frame(0)).slice(-1)[0]?.seq ?? 0,
+            policy: 'frame',
+        })
+        await gsub.ready
+        world.emitQuote('AAPL', 110)
+        await waitFor('gated line live while drained', () => gated['AAPL'] == 110)
+        ok(true, 'frame policy: live pass-through while socket is drained')
+
+        fakePending = 100 // клиент «залип»
+        await delay(20)
+        const before = gatedDeliveries
+        for (let i = 0; i < 30; i++) world.emitQuote('AAPL', 200 + i)
+        for (let i = 0; i < 20; i++) world.emitQuote('MSFT', 400 + i)
+        await delay(120)
+        ok(gatedDeliveries == before, `lag: gate dropped everything, no queue (${gatedDeliveries - before} leaked)`)
+
+        fakePending = 0 // буфер слился
+        await waitFor('frame recovery after drain', () => gated['AAPL'] == 229 && gated['MSFT'] == 419)
+        ok(gatedDeliveries - before == 2, `recovery = mini-frame: 50 missed events arrived as 2 envelopes (${gatedDeliveries - before})`)
+
+        world.emitQuote('AAPL', 500)
+        await waitFor('live continues after recovery', () => gated['AAPL'] == 500)
+        ok(true, 'live stream continues after gate recovery')
+        gsub()
+        sub()
+
+        console.log(fails ? `\n${fails} FAILED` : '\nall passed')
+    } finally {
+        c1.close()
+        c3?.close()
+        await delay(20)
+        await server.close()
+        await gateServer?.close()
+    }
+    if (fails) process.exit(1)
+}
+
+main().catch(e => { console.error(e); process.exit(1) })