wenay-common2 1.0.68 → 1.0.70

package/observe/store.test.ts

@@ -0,0 +1,235 @@
+import {createStore, createStoreMirror, exposeStore} from './store'
+import {flushReactive} from './reactive'
+
+type Market = {
+    data: { BTC?: number; ETH?: number; SOL?: number }
+    meta: { status?: string }
+}
+
+let fails = 0
+const ok = (c: any, m: string) => { if (!c) { fails++; console.log('  FAIL', m) } else console.log('  OK  ', m) }
+const tick = () => new Promise<void>(resolve => setTimeout(resolve, 0))
+
+async function main() {
+    console.log('\n[store] primitive node current/on/once')
+    {
+        const store = createStore<Market>({data: {BTC: 1, ETH: 2}, meta: {status: 'ok'}}, {drain: 'micro'})
+        let current = 0
+        store.node.data.BTC.on(v => { current = v ?? 0 }, {current: true})
+        ok(current == 1, 'primitive leaf on(current) reads value')
+        const seen: any[] = []
+        store.node.data.BTC.once(v => seen.push(v), {current: true})
+        store.state.data.BTC = 3
+        await flushReactive(store.state)
+        ok(JSON.stringify(seen) == '[1]', 'primitive once(current) uses current store value')
+    }
+
+    console.log('\n[store] path survives branch replacement')
+    {
+        const store = createStore<Market>({data: {BTC: 1, ETH: 2}, meta: {}}, {drain: 'micro'})
+        const got: any[] = []
+        store.node.data.BTC.on(v => got.push(v))
+        store.state.data = {BTC: 10, SOL: 5}
+        await flushReactive(store.state)
+        store.state.data.BTC = 11
+        await flushReactive(store.state)
+        ok(JSON.stringify(got) == '[10,11]', 'leaf subscription follows same path after whole branch replace: ' + JSON.stringify(got))
+    }
+
+    console.log('\n[store] branch drain and current')
+    {
+        const store = createStore<Market>({data: {BTC: 1, ETH: 2}, meta: {}}, {drain: 'micro'})
+        const got: any[] = []
+        store.node.data.on(v => got.push({...v}), {current: true, drain: 'micro'})
+        store.state.data.BTC = 3
+        store.state.data.ETH = 4
+        await flushReactive(store.state)
+        await tick()
+        ok(got.length == 2 && got[0].BTC == 1 && got[1].BTC == 3 && got[1].ETH == 4, 'branch current + drained snapshot')
+    }
+
+    console.log('\n[store] typed mask selection and routes')
+    {
+        const store = createStore<Market>({data: {BTC: 1, ETH: 2, SOL: 3}, meta: {status: 'ok'}}, {drain: 'micro'})
+        const sel = store.update({data: {BTC: true, ETH: true}, meta: {status: true}}, {current: true})
+        const snaps: any[] = []
+        const each: string[] = []
+        sel.on(v => snaps.push(v))
+        sel.onEach((v, ctx) => each.push(ctx.pathString + '=' + v))
+        store.state.data.BTC = 10
+        store.state.meta.status = 'warn'
+        await flushReactive(store.state)
+        await tick()
+        ok(snaps.length == 2 && snaps[0].data.BTC == 1 && snaps[1].data.BTC == 10 && snaps[1].meta.status == 'warn', 'selection sends current + one coalesced update')
+        ok(each.includes('data.BTC=10') && each.includes('meta.status=warn'), 'onEach exposes route strings: ' + JSON.stringify(each))
+    }
+
+    console.log('\n[store] exposeStore + createStoreMirror sync')
+    {
+        const server = createStore<Market>({data: {BTC: 1, ETH: 2, SOL: 3}, meta: {status: 'ok'}}, {drain: 'micro'})
+        const api = exposeStore(server)
+        const mirror = createStoreMirror<Market>(api as any, {data: {}, meta: {}}, {drain: 'micro'})
+        await mirror.sync({data: {BTC: true}, meta: {status: true}}, {current: true, drain: 'micro'})
+        ok(mirror.state.data.BTC == 1 && mirror.state.data.ETH === undefined && mirror.state.meta.status == 'ok', 'initial masked mirror snapshot')
+        let btc = 0
+        mirror.node.data.BTC.on(v => { btc = v ?? 0 }, {current: true})
+        server.state.data.BTC = 9
+        server.state.data.ETH = 20
+        server.state.meta.status = 'warn'
+        await flushReactive(server.state)
+        await tick(); await tick()
+        ok(mirror.state.data.BTC == 9 && mirror.state.data.ETH === undefined && mirror.state.meta.status == 'warn', 'mirror updates only selected paths')
+        ok(btc == 9, 'mirror local node subscription fires from sync')
+    }
+
+    console.log('\n[store] changedPaths lets mirror pull only dirty selected paths')
+    {
+        const server = createStore<any>({strategies: {a: {status: false}}, meta: {status: 'ok'}}, {drain: 'micro'})
+        const exposed = exposeStore(server) as any
+        const masks: any[] = []
+        const api = {...exposed, get: (mask?: any) => { masks.push(mask); return exposed.get(mask) }}
+        const mirror = createStoreMirror<any>(api, {strategies: {}, meta: {}}, {drain: 'micro'})
+        await mirror.sync({strategies: true, meta: {status: true}}, {current: true, drain: 'micro'})
+        masks.length = 0
+
+        server.state.strategies.a.status = true
+        await flushReactive(server.state)
+        await tick(); await tick()
+        ok(mirror.state.strategies.a.status === true, 'deep strategy update reaches mirror')
+        ok(JSON.stringify(masks[masks.length - 1]) == '{"strategies":{"a":{"status":true}}}', 'deep update pulled dirty path only: ' + JSON.stringify(masks[masks.length - 1]))
+
+        server.state.strategies.b = {status: true}
+        await flushReactive(server.state)
+        await tick(); await tick()
+        ok(mirror.state.strategies.b.status === true, 'added strategy reaches mirror')
+        ok(JSON.stringify(masks[masks.length - 1]) == '{"strategies":{"b":true}}', 'add pulled added branch only: ' + JSON.stringify(masks[masks.length - 1]))
+
+        delete server.state.strategies.b
+        await flushReactive(server.state)
+        await tick(); await tick()
+        ok(!('b' in mirror.state.strategies), 'removed strategy is deleted from mirror')
+        ok(JSON.stringify(masks[masks.length - 1]) == '{"strategies":{"b":true}}', 'delete pulled removed branch only: ' + JSON.stringify(masks[masks.length - 1]))
+
+        server.state.meta.status = 'warn'
+        await flushReactive(server.state)
+        await tick(); await tick()
+        ok(mirror.state.meta.status == 'warn', 'non-strategy selected path still syncs')
+        ok(JSON.stringify(masks[masks.length - 1]) == '{"meta":{"status":true}}', 'meta update pulled selected leaf only: ' + JSON.stringify(masks[masks.length - 1]))
+    }
+
+    console.log('\n[store] optional push patches sync')
+    {
+        const server = createStore<Market>({data: {BTC: 1, ETH: 2, SOL: 3}, meta: {status: 'ok'}}, {drain: 'micro'})
+        const exposed = exposeStore(server, {push: true}) as any
+        const pulls: any[] = []
+        const api = {...exposed, get: (mask?: any) => { pulls.push(mask); return exposed.get(mask) }}
+        const mirror = createStoreMirror<Market>(api, {data: {}, meta: {}}, {drain: 'micro'})
+        await mirror.syncPatches({data: {BTC: true}, meta: {status: true}}, {current: true, drain: 'micro'})
+        ok(mirror.state.data.BTC == 1 && mirror.state.data.ETH === undefined && mirror.state.meta.status == 'ok', 'patch sync initial masked snapshot')
+        pulls.length = 0
+
+        server.state.data = {BTC: 7, ETH: 8, SOL: 9}
+        await flushReactive(server.state)
+        await tick(); await tick()
+        ok(mirror.state.data.BTC == 7 && mirror.state.data.ETH === undefined && mirror.state.data.SOL === undefined, 'patch branch replace applies only selected leaves')
+        ok(pulls.length == 0, 'patch sync does not pull after push event')
+
+        delete server.state.meta.status
+        await flushReactive(server.state)
+        await tick(); await tick()
+        ok(!('status' in mirror.state.meta), 'patch delete removes selected leaf')
+    }
+
+    console.log('\n[store] optional changedData sync')
+    {
+        const server = createStore<Market>({data: {BTC: 1, ETH: 2}, meta: {status: 'ok'}}, {drain: 'micro'})
+        const exposed = exposeStore(server, {push: true}) as any
+        const pulls: any[] = []
+        const api = {...exposed, get: (mask?: any) => { pulls.push(mask); return exposed.get(mask) }}
+        const mirror = createStoreMirror<Market>(api, {data: {}, meta: {}}, {drain: 'micro'})
+        await mirror.syncChangedData({data: {BTC: true}}, {current: true, drain: 'micro'})
+        pulls.length = 0
+
+        server.state.data = {BTC: 5, ETH: 10}
+        await flushReactive(server.state)
+        await tick(); await tick()
+        ok(mirror.state.data.BTC == 5 && mirror.state.data.ETH === undefined, 'changedData branch replace respects selected mask')
+        ok(pulls.length == 0, 'changedData sync does not pull after push event')
+
+        server.state.data.BTC = 6
+        server.state.meta.status = 'warn'
+        await flushReactive(server.state)
+        await tick(); await tick()
+        ok(mirror.state.data.BTC == 6 && mirror.state.meta.status === undefined, 'changedData ignores unselected dirty paths')
+    }
+    console.log('\n[store] node identity handles dotted keys, symbols, and once(current)')
+    {
+        const store = createStore<any>({data: {BTC: 1}}, {drain: 'micro'})
+        const symA = Symbol('x')
+        const symB = Symbol('x')
+        ok(store.node.at('a.b') !== store.node.at('a').at('b'), 'internal node cache separates dotted key from nested path')
+        ok(store.node.at(symA) !== store.node.at(symB), 'internal node cache separates distinct symbols with same description')
+
+        let hits = 0
+        const off = store.update({data: {BTC: true}}, {current: true}).once(() => hits++, {current: true})
+        store.state.data.BTC = 2
+        await flushReactive(store.state)
+        await tick()
+        off()
+        ok(hits == 1, 'selection.once(current) fires once and unsubscribes')
+    }
+
+    console.log('\n[store] snapshot: circular Map/Set and shared references')
+    {
+        const m = new Map<any, any>()
+        m.set('self', m)
+        const s = new Set<any>()
+        s.add(s)
+        const shared = new Map<any, any>([['x', 1]])
+        const store = createStore<any>({m, s, a: {shared}, b: {shared}}, {drain: 'micro'})
+        const snap = store.snapshot()
+        ok(snap.m instanceof Map && snap.m.get('self') === snap.m, 'self-containing Map snapshots as a cycle, no infinite recursion')
+        ok(snap.s instanceof Set && snap.s.has(snap.s), 'self-containing Set snapshots as a cycle')
+        ok(snap.a.shared === snap.b.shared && snap.a.shared.get('x') == 1, 'shared Map keeps ONE copy identity in the snapshot')
+        ok(snap.m !== m && snap.a.shared !== shared, 'snapshot copies, does not alias the originals')
+    }
+
+    console.log('\n[store] mirror sync error path: failed pull reports, chain survives')
+    {
+        const settle = async () => { for (let i = 0; i < 5; i++) await tick() }
+        const server = createStore<Market>({data: {BTC: 1, ETH: 2}, meta: {status: 'ok'}}, {drain: 'micro'})
+        const exposed = exposeStore(server) as any
+        let failNext = false
+        const api = {...exposed, get: (mask?: any) => {
+            if (failNext) throw new Error('pull boom')
+            return exposed.get(mask)
+        }}
+        const mirror = createStoreMirror<Market>(api, {data: {}, meta: {}}, {drain: 'micro'})
+        const errors: any[] = []
+        const stop = await mirror.sync({data: {BTC: true}}, {current: true, drain: 'micro', onError: e => errors.push(e)})
+        ok(mirror.state.data.BTC == 1, 'initial pull ok')
+
+        failNext = true
+        server.state.data.BTC = 2
+        await flushReactive(server.state)
+        await settle()
+        ok(errors.length == 1 && String(errors[0]).includes('pull boom'), 'failed re-pull lands in onError, not as an unhandled rejection')
+
+        failNext = false
+        server.state.data.BTC = 3
+        await flushReactive(server.state)
+        await settle()
+        ok(mirror.state.data.BTC == 3, 'sync chain survives the failure and catches up on the next change')
+        stop()
+
+        failNext = true
+        let threw = false
+        try { await mirror.sync({data: {BTC: true}}, {current: true}) } catch { threw = true }
+        ok(threw, 'initial pull failure rejects the awaited sync() itself')
+    }
+
+    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) })

package/observe/store.ts

@@ -0,0 +1 @@
+export * from '../src/Common/Observe/store';

package/observe/usage-real-socket.ts

@@ -0,0 +1,174 @@
+// ============================================================
+//  observe/usage-real-socket.ts
+//
+//  Тот же store mirror add/delete, но через настоящий Socket.IO
+//  localhost WebSocket, а не in-memory loopback.
+//  Запуск:
+//      npx tsx observe/usage-real-socket.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 {createRpcClientHub} from '../src/Common/rcp/rpc-clientHub'
+import {createRpcServerAuto} from '../src/Common/rcp/rpc-server-auto'
+import type {DeepSocketListen} from '../src/Common/rcp/listen-deep'
+import {createStore, createStoreMirror, exposeStore} from './store'
+import {flushReactive} from './reactive'
+
+type Strategy = {
+    status: boolean
+    limit: number
+}
+
+type StrategyStore = {
+    strategies: Record<string, Strategy>
+    meta: {status: string}
+}
+
+const delay = (ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms))
+const keys = (state: StrategyStore) => Object.keys(state.strategies).sort()
+const json = (v: any) => JSON.stringify(v)
+
+function scenario(title: string, expected: string) {
+    console.log(`\n  ${title}`)
+    console.log(`  ожидаем: ${expected}`)
+}
+
+function expectEq(label: string, got: any, expected: any) {
+    const g = json(got)
+    const e = json(expected)
+    console.log(`  ${label}:`, g)
+    if (g !== e) throw new Error(`${label}: expected ${e}, got ${g}`)
+    console.log('  OK')
+}
+
+async function waitFor(label: string, ok: () => boolean) {
+    for (let i = 0; i < 80; i++) {
+        if (ok()) return
+        await delay(25)
+    }
+    throw new Error(`timeout: ${label}`)
+}
+
+async function startRealServer(object: object) {
+    const app = express()
+    const httpServer = createServer(app)
+    const ioServer = new SocketIOServer(httpServer, {maxHttpBufferSize: 1e8})
+
+    ioServer.on('connection', socket => {
+        console.log('  [server] client connected')
+        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: 'store2',
+            object,
+            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
+    console.log(`  [server] listening on 127.0.0.1:${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>('store2')}) as const,
+    )
+    const clients = await hub.setToken(null)
+    await clients.api.readyStrict()
+    console.log('  [client] connected and schema is ready')
+    return {
+        client: clients.api,
+        close: () => hub.socket?.disconnect?.(),
+    }
+}
+
+async function main() {
+    console.log('\n[real socket] Observe store mirror add/delete')
+
+    const backend = createStore<StrategyStore>({
+        strategies: {alpha: {status: false, limit: 100}},
+        meta: {status: 'ok'},
+    }, {drain: 'micro'})
+
+    const exposed = exposeStore(backend)
+    const pulls: any[] = []
+    const facade = {
+        ...exposed,
+        get(mask?: any) {
+            pulls.push(mask)
+            console.log('  [server] get mask =', json(mask))
+            return exposed.get(mask)
+        },
+    }
+
+    let server: Awaited<ReturnType<typeof startRealServer>> | null = null
+    let client: Awaited<ReturnType<typeof startRealClient<typeof facade>>> | null = null
+
+    try {
+        server = await startRealServer(facade)
+        client = await startRealClient<typeof facade>(server.port)
+
+        const listen = client.client.func as unknown as DeepSocketListen<typeof facade>
+        const remote = {
+            get: (mask?: any) => client!.client.func.get(mask),
+            changed: listen.changed,
+            changedPaths: listen.changedPaths,
+        }
+
+        const mirror = createStoreMirror<StrategyStore>(remote, {strategies: {}, meta: {status: ''}}, {drain: 'micro'})
+        const stopSync = await mirror.sync({strategies: true}, {current: true, drain: 'micro'})
+        await waitFor('initial mirror sync over socket', () => 'alpha' in mirror.state.strategies)
+        await delay(80) // даем сетевой подписке changedPaths точно встать
+        pulls.length = 0
+
+        scenario('case A: server добавляет beta', 'client mirror увидит alpha,beta; по сети уйдет pull mask {strategies:{beta:true}}')
+        backend.state.strategies.beta = {status: true, limit: 200}
+        await flushReactive(backend.state)
+        await waitFor('client mirror got beta', () => 'beta' in mirror.state.strategies)
+        expectEq('client mirror keys после add', keys(mirror.state), ['alpha', 'beta'])
+        expectEq('server last get mask после add', pulls[pulls.length - 1], {strategies: {beta: true}})
+
+        scenario('case B: server удаляет beta', 'client mirror удалит beta; по сети уйдет pull mask {strategies:{beta:true}}')
+        pulls.length = 0
+        delete backend.state.strategies.beta
+        await flushReactive(backend.state)
+        await waitFor('client mirror removed beta', () => !('beta' in mirror.state.strategies))
+        expectEq('client mirror keys после delete', keys(mirror.state), ['alpha'])
+        expectEq('server last get mask после delete', pulls[pulls.length - 1], {strategies: {beta: true}})
+
+        stopSync()
+        console.log('\nALL OK: real socket usage example passed')
+    } finally {
+        client?.close()
+        await delay(20)
+        await server?.close()
+    }
+}
+
+main().catch(e => {
+    console.error(e)
+    process.exit(1)
+})

package/observe/usage.ts

@@ -0,0 +1,200 @@
+// ============================================================
+//  observe/usage.ts
+//
+//  Локальные self-check примеры для Observe / reactive.
+//  Запуск:
+//      npx tsx observe/usage.ts
+// ============================================================
+
+import {flushReactive, onUpdate, onUpdatePaths, reactive} from './reactive'
+import {createStore, createStoreMirror, exposeStore} from './store'
+
+type Coin = 'BTC' | 'ETH' | 'SOL' | 'DOT' | 'ADA'
+
+type Position = {
+    qty: number
+    entry: number
+}
+
+type AccountState = {
+    account: {
+        balances: Partial<Record<Coin, number>>
+        positions: Partial<Record<Coin, Position>>
+    }
+}
+
+type Strategy = {
+    status: boolean
+    limit: number
+}
+
+type StrategyStore = {
+    strategies: Record<string, Strategy>
+    meta: {status: string}
+}
+
+const tick = () => new Promise<void>(resolve => setTimeout(resolve, 0))
+const coinKeys = (positions: Partial<Record<Coin, Position>>) => Object.keys(positions).sort()
+const strategyKeys = (state: StrategyStore) => Object.keys(state.strategies).sort()
+const pathText = (path: PropertyKey[]) => path.map(String).join('.') || '<self>'
+const json = (v: any) => JSON.stringify(v)
+
+function section(title: string) {
+    console.log(`\n${title}`)
+}
+
+function scenario(title: string, expected: string) {
+    console.log(`\n  ${title}`)
+    console.log(`  ожидаем: ${expected}`)
+}
+
+function expectEq(label: string, got: any, expected: any) {
+    const g = json(got)
+    const e = json(expected)
+    console.log(`  ${label}:`, g)
+    if (g !== e) throw new Error(`${label}: expected ${e}, got ${g}`)
+    console.log('  OK')
+}
+
+function expectThrow(label: string, fn: () => void, expectedPart: string) {
+    console.log(`\n  ${label}`)
+    console.log(`  ожидаем: ошибка содержит "${expectedPart}"`)
+    let message = ''
+    try { fn() }
+    catch (e: any) { message = String(e?.message ?? e) }
+    console.log('  получили:', message || '<ошибки не было>')
+    if (!message.includes(expectedPart)) throw new Error(`${label}: expected error containing ${expectedPart}, got ${message}`)
+    console.log('  OK')
+}
+
+async function waitFor(label: string, ok: () => boolean) {
+    for (let i = 0; i < 50; i++) {
+        if (ok()) return
+        await tick()
+    }
+    throw new Error(`timeout: ${label}`)
+}
+
+async function localReactiveAddDelete() {
+    section('[1] Локально: add/delete в reactive object')
+
+    const state = reactive<AccountState>({
+        account: {
+            balances: {BTC: 100},
+            positions: {BTC: {qty: 0.5, entry: 60000}},
+        },
+    }, {drain: 'micro'})
+
+    let positionsEvents = 0
+    let lastPaths: string[] = []
+
+    onUpdate(state.account.positions, () => {
+        positionsEvents++
+        console.log('  событие positions, keys =', coinKeys(state.account.positions).join(',') || '-')
+    })
+    onUpdatePaths(state.account.positions, change => {
+        lastPaths = change.paths.map(pathText).sort()
+        console.log('  dirty paths =', lastPaths.join(',') || '-')
+    })
+
+    scenario('case A: добавляем SOL', 'keys = BTC,SOL; dirty path = SOL; positionsEvents = 1')
+    positionsEvents = 0
+    lastPaths = []
+    state.account.positions.SOL = {qty: 10, entry: 130}
+    await flushReactive(state)
+    expectEq('keys после add', coinKeys(state.account.positions), ['BTC', 'SOL'])
+    expectEq('dirty paths после add', lastPaths, ['SOL'])
+    expectEq('events после add', positionsEvents, 1)
+
+    scenario('case B: удаляем BTC', 'keys = SOL; dirty path = BTC; positionsEvents = 1')
+    positionsEvents = 0
+    lastPaths = []
+    delete state.account.positions.BTC
+    await flushReactive(state)
+    expectEq('keys после delete', coinKeys(state.account.positions), ['SOL'])
+    expectEq('dirty paths после delete', lastPaths, ['BTC'])
+    expectEq('events после delete', positionsEvents, 1)
+}
+
+async function localMirrorAddDelete() {
+    section('[2] Локально: backend store -> mirror store без сети')
+
+    const backend = createStore<StrategyStore>({
+        strategies: {alpha: {status: false, limit: 100}},
+        meta: {status: 'ok'},
+    }, {drain: 'micro'})
+
+    const exposed = exposeStore(backend)
+    const pulls: any[] = []
+    const api = {
+        ...exposed,
+        get(mask?: any) {
+            pulls.push(mask)
+            console.log('  mirror pull mask =', json(mask))
+            return exposed.get(mask)
+        },
+    }
+
+    const mirror = createStoreMirror<StrategyStore>(api, {strategies: {}, meta: {status: ''}}, {drain: 'micro'})
+    const stopSync = await mirror.sync({strategies: true}, {current: true, drain: 'micro'})
+    await waitFor('initial mirror sync', () => 'alpha' in mirror.state.strategies)
+    pulls.length = 0
+
+    const stopUi = mirror.node.strategies.on(() => {
+        console.log('  UI видит strategies keys =', strategyKeys(mirror.state).join(',') || '-')
+    }, {current: true, drain: 'micro'})
+
+    scenario('case A: backend добавляет beta', 'mirror увидит alpha,beta; подтянется только mask {strategies:{beta:true}}')
+    backend.state.strategies.beta = {status: true, limit: 200}
+    await flushReactive(backend.state)
+    await waitFor('mirror got beta', () => 'beta' in mirror.state.strategies)
+    await flushReactive(mirror.state)
+    expectEq('mirror keys после add', strategyKeys(mirror.state), ['alpha', 'beta'])
+    expectEq('последний pull mask после add', pulls[pulls.length - 1], {strategies: {beta: true}})
+
+    scenario('case B: backend удаляет beta', 'mirror удалит beta; подтянется тот же точечный mask {strategies:{beta:true}}')
+    pulls.length = 0
+    delete backend.state.strategies.beta
+    await flushReactive(backend.state)
+    await waitFor('mirror removed beta', () => !('beta' in mirror.state.strategies))
+    await flushReactive(mirror.state)
+    expectEq('mirror keys после delete', strategyKeys(mirror.state), ['alpha'])
+    expectEq('последний pull mask после delete', pulls[pulls.length - 1], {strategies: {beta: true}})
+
+    stopUi()
+    stopSync()
+}
+
+function missingKeyCases() {
+    section('[3] Если обращаемся туда, чего нет')
+
+    const state = reactive<AccountState>({
+        account: {
+            balances: {},
+            positions: {},
+        },
+    })
+
+    expectThrow('case A: onUpdate(state.account.positions.BTC!, ...)', () => {
+        onUpdate(state.account.positions.BTC!, () => {})
+    }, 'onUpdate: not a reactive object')
+
+    expectThrow('case B: state.account.positions.BTC!.qty = 0.7', () => {
+        state.account.positions.BTC!.qty = 0.7
+    }, "Cannot set properties of undefined")
+
+    console.log('\n  вывод: `!` не создает объект. Если ключ может отсутствовать, сначала делаем:')
+    console.log('  state.account.positions.BTC = {qty: 0.7, entry: 60000}')
+}
+
+async function main() {
+    await localReactiveAddDelete()
+    await localMirrorAddDelete()
+    missingKeyCases()
+    console.log('\nALL OK: local usage examples passed')
+}
+
+main().catch(e => {
+    console.error(e)
+    process.exit(1)
+})

package/oracle/PASSED.md

@@ -0,0 +1,27 @@
+# Passed oracles — marks for deleted disposable tests & completed plan items
+
+Format: `date · task · verified by · result / consumer caveats`
+
+- 2026-06-12 · ByteStream int24/48/64 + dates (P0) · pre-folder oracle · PASS. ⚠️ data written by the OLD corrupt code now reads back differently (it was already corrupt).
+- 2026-06-12 · Rate-limiter byWeight ban-bug (`?? 0` → `?? arr[i][0]`) · pre-folder oracle · PASS.
+- 2026-06-12 · RPC: `pipeStrict` honesty JSDoc note (≡ `pipe` for now) · harness (permanent) · green.
+- 2026-06-12 · RPC: `errToObj` code/data/cause + client `reviveErr` → `MyError` · harness · green. ⚠️ rejected RPC promises now fail with an `Error` instance (was: plain object); `message`/`name`/`stack` reads unchanged.
+- 2026-06-12 · RPC: rich values nested in `Map`/`Set` packed/revived recursively (NEW finding, was not in plan) · harness · green. ⚠️ new server + old client → nested values arrive as marker objects (was: silently mangled strings).
+- 2026-06-12 · RPC: PIPE callback args `packResult`-ed like CALL (rpc-server:169) · harness · green.
+- 2026-06-12 · RPC: opt-in `limits` option on client (`unpackResult` with `lim`); fixed `.map(unpackResult)` passing index as `lim`; over-limit RESP rejects that request, malformed CB dropped · harness · green.
+- 2026-06-12 · RPC: `maxArgs`/`maxPathLen` enforced (unpack / string-ref validation) · harness · green. ⚠️ >64 args or >16 non-routeMap path segments now rejected with `PayloadLimitError` (previously accepted).
+- 2026-06-12 · `WebSocketServerHook`: memoized per-tag wrapper (was: fresh wrapper per proxy access → duplicate listeners on re-subscribe) · `socket-server-hook-memo.oracle.ts` (deleted) · PASS 2/2. ⚠️ `get.tag` is now reference-stable across accesses.
+- 2026-06-12 · `node_console`: removed PRIVATE dead `setupLogs2` + never-assigned `wrapCallSite` and its dead branches; exported `__LineFile2`/`__LineFiles` kept & documented (positions mapped by the runtime) · `node-console-cleanup.oracle.ts` (deleted) · PASS 4/4, behavior unchanged.
+- 2026-06-12 · `CParams`: top-level executable scratch (incl. `GetSimpleParams(new Test())` running on every import) wrapped into never-called `_typeCheck_*` functions — type assertions still compile, zero import side effects; private `function test()` left as-is (declaration only, no side effect) · `cparams-import-sideeffect.oracle.ts` (deleted) · PASS 3/3.
+- 2026-06-12 · `Time.durationToStr`: characterized — compound output WORKS ("1д 23ч"); the <1.1→smaller-unit ("65м") and >10→single-unit ("25ч") heuristics are deliberate and PRESERVED byte-for-byte. Fixed only the real defect: second-unit rounding overflow ("1д 24ч" → now "2д") · `duration-to-str.oracle.ts` (deleted) · PASS 10/10. ⚠️ output changes ONLY for durations where the second unit rounded up to a full first unit.
+- 2026-06-12 · RPC P0 id-reuse: aborted/cleared request ids now go to a zombie set and return to the pool only on their late RESP/CB_END — a reused id can no longer deliver a stale response to a new caller; stray CB_END no longer releases foreign ids · harness (permanent) · green.
+- 2026-06-12 · RPC double-init: second `createRpcServer` on same socket+key detaches the previous handler (console.warn; SocketTmpl has no `off`); second `createRpcClient` on same socket+key now SHARES the id pool → concurrent clients coexist without reqId collisions · harness · green. ⚠️ duplicate-server re-init now last-wins (was: both handlers fired, side effects doubled).
+- 2026-06-12 · RPC `dispose(reason?)` added to client (additive API): rejects pending, ignores further packets (still recycles zombie ids to the shared pool), rejects new calls · harness · green.
+- 2026-06-12 · `rpc-server-auto`: per-subscriber multiplexer — a second RPC subscription to the same server `Listen` no longer clobbers the first (each subscriber gets its own `listenSocket`; entries pruned when a subscription ends) · harness · green. ⚠️ re-subscribe semantics changed from "replace previous" to "coexist".
+- 2026-06-12 · `rpc-clientHub.setToken`: now `dispose`s previous facade clients (pending rejected with "token rotated") and issues a FRESH `promise` when the old one already resolved — awaiting after rotation waits for the new connect · harness · green.
+- 2026-06-12 · `"___STOP"` unified into `RPC_STOP` const in `rpc-protocol.ts` (string, NOT Symbol — it crosses the JSON wire; value unchanged); `isRpcPipe` was already `Symbol.for` · harness · green.
+- 2026-06-12 · `listen-deep`: `extends typeof Promise` (constructor-only) → added `extends Promise<any>` so Promise-valued fields pass through unmangled (type-level only); `listen-socket` lazy unsubscribe documented as by-design (no status-change event exists; cleans on next emission) · tsc + harness · green.
+- 2026-06-12 · `WebHook3`: Express-5-safe client unsubscribe — one persistent route per path + tag→handler map instead of `app._router.stack` mutation; re-subscribe no longer stacks duplicate handlers; `subscribers.json` saved atomically (temp+rename) · `webhook-unsubscribe.oracle.ts` (deleted) · PASS 4/4. ⚠️ after unsubscribe the route stays mounted and answers 404.
+- 2026-06-12 · `createSignatureFunction`: investigated — no internal caller; the HTTP query is built by CONSUMERS, so reordering keys library-side would break live signatures. Insertion-order contract documented in JSDoc; no code change (correct resolution).
+- 2026-06-12 · RPC subscription dedupe v1 (`dedupeListen`, default ON): one wire subscription per client per Listen address (`*.callback` path + non-callback args); local fan-out for extra consumers; `.unsubscribe()` on the subscribe promise (refcount; wire `removeCallback` after the last leaves); `api.subscriptions()` stats · harness (permanent, 8 cases) · green. ⚠️ default-ON changes behavior: repeated identical subscribes now share one wire stream (each callback still fires); set `dedupeListen: false` to restore raw per-call subscriptions.
+- 2026-06-12 · Dedupe exact addressing: server declares Listen addresses as the additive 4th element of `Pkt.MAP` (`IS_RPC_LISTEN` symbol mark, survives `transformTree` copy); client dedupes ONLY declared addresses, heuristic kept as fallback for old servers · harness (incl. concurrent non-Listen `callback`-named method case) · green 44/44.

package/oracle/README.md

@@ -0,0 +1,12 @@
+# oracle/ — disposable test oracles
+
+Convention (see PLAN.md "Working agreement"):
+
+- One file per task being verified: `oracle/<task-slug>.oracle.ts`.
+- Log-based: prints `PASS`/`FAIL` lines, exits non-zero on failure.
+  Run: `node node_modules/ts-node/dist/bin.js --transpile-only oracle/<name>.oracle.ts`
+- **Disposable**: after the fix goes green, the oracle file is DELETED and a one-line
+  mark is appended to `PASSED.md`. The completed task is then removed from PLAN.md/PLAN_ru.md
+  (history lives in git).
+- The only PERMANENT test in the repo is the RPC harness: `src/Common/rcp/rpc.harness.spec.ts`.
+- This folder is excluded from the published build (not under `src/`).