wenay-common2 1.0.68 → 1.0.70

package/oracle/realsocket/shape.spec.ts

@@ -0,0 +1,124 @@
+// ============================================================
+//  oracle/realsocket/shape.spec.ts — DISPOSABLE real-socket oracle
+//  CATEGORY "shape": adaptive shape compaction (Pkt.SHAPE/CBV) over a REAL WebSocket.
+//
+//  Two server streams:
+//    monoStream — monomorphic high-freq object stream. After THRESHOLD(5) ticks of the
+//                 same shape the server standardizes it and switches to compact Pkt.CBV.
+//                 We assert ALL ticks (>=8) arrive intact incl. Date values, AND that
+//                 compaction actually engaged (CBV>0) by wrapping socket.emit in onServer.
+//    polyStream — polymorphic stream (changing shapes). Adaptive fallback: no shape ever
+//                 reaches threshold → no data loss; we also assert CBV stayed 0.
+// ============================================================
+import {startRealServer, startRealClient, makeChecker, delay} from './_rs'
+import {listen as createListenPair} from '../../src/Common/events/Listen'
+
+const PORT = 4107
+
+// captured server-side emit handles (filled when makeObject runs on the connection)
+let emitMono: ((v: any) => void) | null = null
+let emitPoly: ((v: any) => void) | null = null
+
+function makeObject() {
+    const [mono, monoListen] = createListenPair<any>()
+    const [poly, polyListen] = createListenPair<any>()
+    emitMono = mono
+    emitPoly = poly
+    return {monoStream: monoListen, polyStream: polyListen}
+}
+
+async function main() {
+    const {check, done} = makeChecker('shape')
+    const watchdog = setTimeout(() => { console.error('WATCHDOG timeout'); process.exit(3) }, 40000)
+
+    // counters of raw packet types seen on the REAL server socket
+    let cbvCount = 0     // Pkt.CBV = 9  (compact values tick)
+    let shapeCount = 0   // Pkt.SHAPE = 8 (shape declaration)
+    let cbCount = 0      // Pkt.CB = 2   (full callback tick)
+
+    const srv = await startRealServer({
+        port: PORT,
+        makeObject,
+        onServer: (_api, socket) => {
+            // wrap the genuine socket.emit BEFORE any tick is sent — the rpc-server
+            // adapter calls socket.emit(key, packetArray) at send time, so this sees
+            // every outgoing packet and lets us observe compaction on the real wire.
+            const orig = socket.emit.bind(socket)
+            socket.emit = (key: string, d: any) => {
+                if (Array.isArray(d)) {
+                    if (d[0] === 9) cbvCount++
+                    else if (d[0] === 8) shapeCount++
+                    else if (d[0] === 2) cbCount++
+                }
+                return orig(key, d)
+            }
+        },
+    })
+
+    const cli = await startRealClient({port: PORT})
+    const api = cli.api
+
+    // give the connection a moment so makeObject ran and emit handles are captured
+    await delay(50)
+    await check('emit handles captured', () => emitMono != null && emitPoly != null, true)
+
+    // ---------- monomorphic stream: subscribe, then fire many same-shape ticks ----------
+    const gotMono: any[] = []
+    const offMono = api.monoStream.callback((v: any) => gotMono.push(v))
+    await delay(60) // subscription round-trip + CAPS handshake over real socket
+
+    const N = 12
+    for (let i = 0; i < N; i++) {
+        emitMono!({a: i, when: new Date(i * 1000), tag: 'x'})
+        await delay(8)
+    }
+    await delay(120) // let all compact ticks land
+
+    await check('mono: all ticks arrived', () => gotMono.length, N)
+    await check('mono: first tick values intact', () => [gotMono[0].a, gotMono[0].tag, gotMono[0].when], [0, 'x', new Date(0)])
+    await check('mono: last tick values intact (Date)', () => [gotMono[N - 1].a, gotMono[N - 1].tag, gotMono[N - 1].when], [N - 1, 'x', new Date((N - 1) * 1000)])
+    // verify EVERY tick is correct and in order (no drop / corruption / reordering)
+    await check('mono: every tick exact + ordered', () => gotMono.map(v => [v.a, v.tag, v.when]),
+        Array.from({length: N}, (_v, i) => [i, 'x', new Date(i * 1000)]))
+    // compaction engaged: after THRESHOLD(5) of the same shape, server declared SHAPE once and sent CBV
+    await check('mono: SHAPE declared exactly once', () => shapeCount, 1)
+    await check('mono: compaction engaged (CBV>0)', () => cbvCount > 0, true)
+    // with threshold 5: ticks 1..5 full (the 5th triggers register→CBV), 6..12 compact.
+    // register sends SHAPE+CBV, then each later same-shape tick a CBV → CBV count = N - 4.
+    await check('mono: CBV count == N-4 (ticks after threshold)', () => cbvCount, N - 4)
+
+    offMono()
+    await delay(30)
+
+    // ---------- polymorphic stream: each tick a different shape → adaptive fallback ----------
+    const cbvBefore = cbvCount
+    const gotPoly: any[] = []
+    const offPoly = api.polyStream.callback((v: any) => gotPoly.push(v))
+    await delay(60)
+
+    // 8 ticks, each a distinct shape — no single shape ever reaches THRESHOLD(5)
+    emitPoly!({a: 1})
+    await delay(8); emitPoly!({b: 2})
+    await delay(8); emitPoly!({c: 3, d: 4})
+    await delay(8); emitPoly!({e: 5})
+    await delay(8); emitPoly!({f: 6, g: 7})
+    await delay(8); emitPoly!({h: 8})
+    await delay(8); emitPoly!({i: 9, j: 10, k: 11})
+    await delay(8); emitPoly!({l: 12})
+    await delay(120)
+
+    await check('poly: all 8 ticks arrived (no loss)', () => gotPoly.length, 8)
+    await check('poly: values intact across shapes', () => [gotPoly[0].a, gotPoly[1].b, gotPoly[2].c, gotPoly[2].d, gotPoly[6].i, gotPoly[6].k, gotPoly[7].l],
+        [1, 2, 3, 4, 9, 11, 12])
+    await check('poly: no compaction (no new CBV)', () => cbvCount - cbvBefore, 0)
+
+    offPoly()
+    await delay(30)
+
+    clearTimeout(watchdog)
+    cli.close()
+    await srv.close()
+    process.exit(done() === 0 ? 0 : 1)
+}
+
+main().catch(e => { console.error(e); process.exit(2) })

package/oracle/realsocket/slimv2.spec.ts

@@ -0,0 +1,116 @@
+// REAL-SOCKET slimv2: NEW slim Listen v2 (slimListen) — unit-surface + end-to-end wire. Port 4110.
+//
+// FINDING (verified against source, see notes in ##RESULT##):
+//   isListenCallback() in src/Common/events/Listen.ts identifies a "listen" by
+//   STRUCTURAL key-set equality against createListen's full api
+//   (func/isRun/run/close/onClose/on/off/count/keys()).
+//   A slim SlimListen exposes only {on, close, count}, so isListenCallback(slimListen) === false
+//   and rpc-server-auto's resolveTransform will NOT treat a bare SlimListen as a stream node.
+//   Therefore the WIRE part uses the FULL listen handle (the one slimListen wraps), while the
+//   SLIM surface (on/off/count/close) is unit-asserted directly. We also prove the slim view
+//   and the full handle share ONE underlying impl (count() agrees across both faces), so a
+//   slimListen stream interoperates with the RPC listen-socket layer exactly like listen —
+//   via its full handle.
+import {startRealServer, startRealClient, makeChecker, delay} from './_rs'
+import {slimListen, toSlimListen, createListen, isListenCallback, listen as createListenPair} from '../../src/Common/events/Listen'
+
+const PORT = 4110
+
+// emit fns + full handles created at module scope so makeObject (per-connection) can place
+// the FULL listen as the wire stream node while the spec drives emit / inspects slim surface.
+const [emitWire, fullWire] = createListenPair<number>()          // full handle → goes on the wire
+const slimWire = toSlimListen<number>(fullWire)              // slim VIEW over the SAME impl as fullWire
+
+function makeObject() {
+    // Wire a real stream node. isListenCallback only accepts the FULL listen, so place that.
+    // The slim SlimListen (slimWire) is a view over this very handle — same subscriber set.
+    return {
+        ticks: fullWire,
+    }
+}
+
+async function main() {
+    const {check, done} = makeChecker('slimv2')
+    const watchdog = setTimeout(() => { console.error('WATCHDOG timeout'); process.exit(3) }, 40000)
+
+    // ===== 0. Static finding: SlimListen is NOT detected as a listen by isListenCallback =====
+    const [, slimStandalone] = slimListen<number>()
+    await check('isListenCallback(full listen) === true', () => isListenCallback(fullWire), true)
+    await check('isListenCallback(slim SlimListen) === false', () => isListenCallback(slimStandalone as any), false)
+
+    // ===== 1. Slim surface unit tests (on/off/count/close) on a standalone slimListen =====
+    {
+        const [emit, listen] = slimListen<number>()
+        const got: number[] = []
+        await check('count() starts at 0', () => listen.count(), 0)
+
+        const off = listen.on(v => got.push(v))
+        await check('count() === 1 after on()', () => listen.count(), 1)
+        await check('on() returns a function (off)', () => typeof off, 'function')
+
+        emit(10); emit(20)
+        await check('on(cb) receives ticks', () => got.slice(), [10, 20])
+
+        off()
+        await check('count() === 0 after off()', () => listen.count(), 0)
+        emit(30)
+        await check('off() stops delivery', () => got.slice(), [10, 20])
+
+        // re-subscribe two, then close() tears everything down
+        const g2: number[] = []
+        listen.on(v => g2.push(v))
+        listen.on(v => g2.push(v))
+        await check('count() === 2 after two on()', () => listen.count(), 2)
+        emit(7)
+        await check('two subscribers each get tick', () => g2.slice(), [7, 7])
+        listen.close()
+        await check('count() === 0 after close()', () => listen.count(), 0)
+        emit(99)
+        await check('close() stops delivery', () => g2.slice(), [7, 7])
+    }
+
+    // ===== 2. Slim view interoperates with full handle (shared impl) =====
+    // slimWire is toSlimListen(fullWire); a subscription via the full handle must be visible
+    // through slim.count(), proving they are ONE Listen (the same impl slimListen wraps).
+    {
+        const offFull = fullWire.on(() => {})
+        await check('slim.count() reflects full.on', () => slimWire.count(), 1)
+        offFull()
+        await check('slim.count() reflects full off()', () => slimWire.count(), 0)
+    }
+
+    // ===== 3. END-TO-END wire: full handle (the one slimListen wraps) over a REAL socket =====
+    const srv = await startRealServer({port: PORT, makeObject})
+    const cli = await startRealClient({port: PORT})
+    const api = cli.api
+
+    const received: number[] = []
+    const sub: any = api.ticks.callback((v: number) => received.push(v))
+    await delay(150) // let the subscription round-trip over the real WebSocket
+
+    // server-side subscriber present (the wire created a listen-socket subscriber on fullWire)
+    await check('wire: server has >=1 subscriber on the listen', () => fullWire.count() >= 1, true)
+
+    emitWire(101)
+    emitWire(202)
+    emitWire(303)
+    await delay(200) // real WS latency for emitted ticks to arrive
+
+    await check('wire: ticks arrive end-to-end', () => received.slice(), [101, 202, 303])
+    // slim view sees the SAME live subscriber count as the full wire handle
+    await check('wire: slim view agrees with full handle count', () => slimWire.count(), fullWire.count())
+
+    // unsubscribe over the wire and confirm no further ticks
+    sub()
+    await delay(150)
+    emitWire(404)
+    await delay(150)
+    await check('wire: off() stops end-to-end delivery', () => received.slice(), [101, 202, 303])
+
+    clearTimeout(watchdog)
+    cli.close()
+    await srv.close()
+    process.exit(done() === 0 ? 0 : 1)
+}
+
+main().catch(e => { console.error(e); process.exit(2) })

package/oracle/realsocket/stress.spec.ts

@@ -0,0 +1,132 @@
+// REAL-SOCKET stress: MASS / volume over a genuine WebSocket. Port 4111.
+//  (1) 500+ concurrent CALLs — id-pool integrity, no dropped/mismatched RESP.
+//  (2) 50+ concurrent subscribers + 100+ high-freq ticks — no loss, clean teardown to 0.
+//  (3) mixed concurrent calls + streams.
+import {startRealServer, startRealClient, makeChecker, delay} from './_rs'
+import {listen as createListenPair} from '../../src/Common/events/Listen'
+
+const PORT = 4111
+
+// ===================================================================
+//  facade — captured emit handles (single client connection ⇒ makeObject
+//  runs once; we stash the per-connection emitters at module scope).
+// ===================================================================
+let emitTick: ((n: number) => void) | null = null   // stream A: high-frequency ticks
+let emitMix: ((n: number) => void) | null = null     // stream B: used in the mixed test
+
+function makeObject() {
+    const [tick, tickListen] = createListenPair<number>()
+    const [mix, mixListen] = createListenPair<number>()
+    emitTick = tick
+    emitMix = mix
+    return {
+        // identity call — server echoes the request index back; lets us assert
+        // every one of N concurrent responses landed on the right promise.
+        idn: async (i: number) => i,
+        // arithmetic so a mismatched correlation would produce a wrong value, not just a wrong tag.
+        sq: async (i: number) => i * i,
+        ticks: tickListen,
+        mixStream: mixListen,
+    }
+}
+
+async function main() {
+    const {check, done} = makeChecker('stress')
+    const watchdog = setTimeout(() => { console.error('WATCHDOG timeout'); process.exit(3) }, 40000)
+
+    // capture the per-connection server api (for subscriptions() leak checks)
+    let srvApi: any = null
+    const srv = await startRealServer({port: PORT, makeObject, onServer: (api) => { srvApi = api }})
+    const cli = await startRealClient<ReturnType<typeof makeObject>>({port: PORT})
+    const api = cli.api
+
+    // =============================================================
+    //  (1) MASS CALLs — 600 concurrent, assert every result correct
+    // =============================================================
+    const N = 600
+    const idxs = Array.from({length: N}, (_, i) => i)
+    const results = await Promise.all(idxs.map(i => api.idn(i)))
+    // every response matches its request index (no mismatched correlation)
+    await check('mass: 600 idn results in order', () => results, idxs)
+    await check('mass: zero mismatches', () => results.filter((v, i) => v !== i).length, 0)
+
+    // a second wave through the SAME id-pool — proves released ids are reusable & clean
+    const sqResults = await Promise.all(idxs.map(i => api.sq(i)))
+    await check('mass: 600 sq second wave', () => sqResults.filter((v, i) => v !== i * i).length, 0)
+    // id-pool fully drained back: no pending requests left hanging
+    await delay(50)
+    await check('mass: pending drained to 0', () => (cli.client.api as any).pending(), 0)
+
+    // =============================================================
+    //  (2) MASS SUBSCRIBERS — 60 subscribers, 120 high-freq ticks
+    // =============================================================
+    const SUBS = 60
+    const TICKS = 120
+    const buckets: number[][] = Array.from({length: SUBS}, () => [])
+    // NB: callback() returns a callable off-handle (a thenable that resolves only
+    // when the STREAM ENDS) — do NOT await it, or Promise.all would block forever.
+    const offs = buckets.map((b) => (api.ticks as any).callback((v: number) => b.push(v)))
+    // give every subscription a round-trip to register on the server
+    await delay(120)
+
+    // Client-side dedup (on by default): 60 identical `ticks.callback(fn)` subscribers
+    // collapse to ONE wire subscription; the 60-way fan-out happens locally. So:
+    //   • client subscriptions(): one entry, consumers == 60 (all local consumers)
+    //   • server subscriptions(): one node, consumers == 1 (the single wire callback)
+    await check('subs: client one wire sub, 60 local consumers', () => {
+        const list = (cli.client.api as any).subscriptions() as {consumers: number}[]
+        return [list.length, list[0]?.consumers]
+    }, [1, SUBS])
+    await check('subs: server sees one wire consumer (dedup)', () => {
+        const subsList = srvApi.subscriptions() as {consumers: number}[]
+        return [subsList.length, subsList.reduce((a, e) => a + e.consumers, 0)]
+    }, [1, 1])
+
+    // high-frequency burst: no awaits between emits
+    for (let i = 0; i < TICKS; i++) emitTick!(i)
+    // generous drain for the real socket to deliver every CB
+    await delay(400)
+
+    // every subscriber received every tick — no loss, no dup
+    const expectedSeq = Array.from({length: TICKS}, (_, i) => i)
+    await check('subs: every bucket has all 120 ticks', () => buckets.filter(b => b.length !== TICKS).length, 0)
+    await check('subs: total CBs == 60*120', () => buckets.reduce((a, b) => a + b.length, 0), SUBS * TICKS)
+    await check('subs: bucket #0 exact sequence', () => buckets[0], expectedSeq)
+    await check('subs: bucket #59 exact sequence', () => buckets[SUBS - 1], expectedSeq)
+
+    // clean teardown — off() each, then both client and server registries empty
+    for (const off of offs) off()
+    await delay(200)
+    await check('subs: client wireSubs back to 0', () => (cli.client.api as any).subscriptions().length, 0)
+    await check('subs: server subscriptions back to 0', () => srvApi.subscriptions().length, 0)
+
+    // post-teardown ticks must reach nobody (no leak / dangling consumer)
+    const before = buckets.reduce((a, b) => a + b.length, 0)
+    for (let i = 0; i < 30; i++) emitTick!(999)
+    await delay(150)
+    await check('subs: no delivery after teardown', () => buckets.reduce((a, b) => a + b.length, 0), before)
+
+    // =============================================================
+    //  (3) MIXED — concurrent calls + a fresh stream burst together
+    // =============================================================
+    const mixBuckets: number[][] = Array.from({length: 10}, () => [])
+    const mixOffs = mixBuckets.map(b => (api.mixStream as any).callback((v: number) => b.push(v)))
+    await delay(80)
+    // fire 200 calls AND 50 ticks interleaved
+    const callP = Promise.all(Array.from({length: 200}, (_, i) => api.sq(i)))
+    for (let i = 0; i < 50; i++) emitMix!(i)
+    const mixCalls = await callP
+    await delay(250)
+    await check('mixed: 200 calls all correct under stream load', () => mixCalls.filter((v, i) => v !== i * i).length, 0)
+    await check('mixed: each of 10 subs got all 50 ticks', () => mixBuckets.filter(b => b.length !== 50).length, 0)
+    for (const off of mixOffs) off()
+    await delay(150)
+    await check('mixed: server subscriptions back to 0', () => srvApi.subscriptions().length, 0)
+
+    clearTimeout(watchdog)
+    cli.close()
+    await srv.close()
+    process.exit(done() === 0 ? 0 : 1)
+}
+
+main().catch(e => { console.error(e); process.exit(2) })

package/oracle/regression/_clientapiall-replay.fixture.ts

@@ -0,0 +1,57 @@
+// Compile-only fixture (checked by clientapiall-replay-types.spec.ts via `tsc --noEmit`).
+// Contract: replay-listen members of an rpc<T>() client project into the client replay
+// surface (ReplaySocketListen) in BOTH typed paths (func/strict) — so
+// `replaySubscribe(client.func.key, cb)` needs NO casts. Never executed at runtime.
+
+import {createRpcClient} from '../../src/Common/rcp/rpc-client'
+import type {ListenReplayApi, ReplayEvent} from '../../src/Common/events/replay-listen'
+import {replaySubscribe} from '../../src/Common/events/replay-wire'
+
+type tMsg = {text: string, n: number}
+type tApi = {
+    hello(name: string): string
+    listenMsg: ListenReplayApi<[tMsg]>
+    nested: {inner: ListenReplayApi<[number, string]>}
+}
+
+// exact-type equality (invariant check, not just assignability)
+type Eq<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false
+
+declare const socket: any
+
+export function compileCase() {
+    const client = createRpcClient<tApi>({socket, socketKey: 'x'})
+
+    // the projected member carries the exact envelope type on its line
+    type tProjectedEv = Parameters<Parameters<typeof client.func.listenMsg.line.on>[0]>[0]
+    const evExact: Eq<tProjectedEv, ReplayEvent<[tMsg]>> = true
+    void evExact
+
+    // inferred subscribe — no casts, cb args typed from the API shape
+    const sub = replaySubscribe(client.func.listenMsg, function onMsg(msg) {
+        const text: string = msg.text
+        void text
+    })
+    const seq: number = sub.seq()
+    void seq
+    sub()
+
+    // explicit generic — remote param accepted with no casts
+    const sub2 = replaySubscribe<[number, string]>(client.func.nested.inner, function onPair(n, s) {
+        const a: number = n
+        const b: string = s
+        void a; void b
+    })
+    sub2()
+
+    // strict path projects the same way
+    const sub3 = replaySubscribe(client.strict.listenMsg, function onMsg2(msg) {
+        const n: number = msg.n
+        void n
+    })
+    sub3()
+
+    // plain functions are untouched by the replay arm
+    const p: Promise<string> = client.func.hello('x')
+    void p
+}

package/oracle/regression/async-queues.spec.ts

@@ -0,0 +1,254 @@
+import {
+    createAsyncQueue,
+    createReadyGate,
+    createThrottle,
+    enhancedQueueRun,
+} from "../../src/Common/async/waitRun";
+import {promiseProgress} from "../../src/Common/async/promiseProgress";
+
+type Test = {
+    name: string;
+    fn: () => void | Promise<void>;
+};
+
+const tests: Test[] = [];
+
+function test(name: string, fn: Test["fn"]) {
+    tests.push({name, fn});
+}
+
+function assert(condition: unknown, message: string): asserts condition {
+    if (!condition) throw new Error(message);
+}
+
+function assertEq<T>(actual: T, expected: T, message: string) {
+    if (actual !== expected) {
+        throw new Error(`${message}: expected ${String(expected)}, got ${String(actual)}`);
+    }
+}
+
+async function assertRejects(promise: Promise<unknown>, expected: unknown, message: string) {
+    try {
+        await promise;
+    } catch (error) {
+        assert(error === expected, message);
+        return;
+    }
+    throw new Error(`${message}: promise resolved`);
+}
+
+function assertThrows(fn: () => unknown, message: string) {
+    try {
+        fn();
+    } catch {
+        return;
+    }
+    throw new Error(`${message}: function did not throw`);
+}
+
+function sleep(ms = 0) {
+    return new Promise<void>(resolve => setTimeout(resolve, ms));
+}
+
+test("createAsyncQueue rejects concurrency 0", () => {
+    assertThrows(() => createAsyncQueue(0), "concurrency 0 throws");
+});
+
+test("createAsyncQueue resolves, rejects, limits concurrency, and onIdle waits", async () => {
+    const queue = createAsyncQueue(2);
+    const failure = new Error("queue failure");
+    const events: string[] = [];
+    let active = 0;
+    let maxActive = 0;
+
+    const makeTask = (name: string, ms: number, value: string, reject = false) => async () => {
+        events.push(`start:${name}`);
+        active++;
+        maxActive = Math.max(maxActive, active);
+        await sleep(ms);
+        active--;
+        events.push(`end:${name}`);
+        if (reject) throw failure;
+        return value;
+    };
+
+    const first = queue.add(makeTask("first", 8, "one"));
+    const second = queue.add(makeTask("second", 3, "two", true));
+    const third = queue.add(makeTask("third", 1, "three"));
+    const secondRejected = assertRejects(second, failure, "rejected task rejects add promise");
+
+    assertEq(queue.size, 1, "third task is queued while first two are active");
+    assertEq(await first, "one", "resolved task returns its value");
+    await secondRejected;
+    assertEq(await third, "three", "queue continues after rejected task");
+    await queue.onIdle();
+
+    assertEq(queue.size, 0, "queue is empty after onIdle");
+    assertEq(active, 0, "no tasks remain active after onIdle");
+    assert(maxActive <= 2, "queue never exceeds configured concurrency");
+    assert(events.includes("start:third"), "queued task eventually starts");
+});
+
+test("createThrottle survives rejected throttled task", async () => {
+    const throttle = createThrottle();
+    const events: string[] = [];
+
+    throttle.throttle(0, async () => {
+        events.push("first");
+        throw new Error("ignored");
+    });
+
+    await sleep(5);
+
+    throttle.throttle(0, async () => {
+        events.push("second");
+    });
+
+    await sleep(5);
+    assertEq(events.join(","), "first,second", "throttle runs after a rejected task");
+});
+
+test("enhancedQueueRun keeps draining after rejected tasks", async () => {
+    const queue = enhancedQueueRun(1);
+    const failure = new Error("enhanced failure");
+    const events: string[] = [];
+
+    queue.enqueue(async () => {
+        events.push("fire-and-forget reject");
+        throw failure;
+    });
+    queue.enqueue(async () => {
+        events.push("after fire-and-forget");
+    });
+
+    await queue.runAll();
+
+    await assertRejects(
+        queue.enqueueAndRun(async () => {
+            events.push("reported reject");
+            throw failure;
+        }),
+        failure,
+        "enqueueAndRun reports task rejection",
+    );
+
+    await queue.enqueueAndRun(async () => {
+        events.push("after reported reject");
+    });
+    await queue.runAll();
+
+    assertEq(
+        events.join(","),
+        "fire-and-forget reject,after fire-and-forget,reported reject,after reported reject",
+        "enhancedQueueRun continues after both swallowed and reported rejections",
+    );
+    assertEq(queue.queueSize, 0, "enhancedQueueRun queue is empty after runAll");
+});
+
+test("promiseProgress all returns values and emits ok events", async () => {
+    const listened = promiseProgress<string>([
+        () => Promise.resolve("alpha"),
+        async () => {
+            await sleep(1);
+            return "beta";
+        },
+    ]);
+    const okEvents: string[] = [];
+    const errorEvents: string[] = [];
+
+    listened.onOk((data, i, ok, errors, count) => {
+        okEvents.push(`${i}:${data}:${ok}:${errors}:${count}`);
+    });
+    listened.onError(error => {
+        errorEvents.push(String(error));
+    });
+
+    const values = await listened.all();
+
+    assertEq(values.join(","), "alpha,beta", "promiseProgress all resolves values in input order");
+    assertEq(okEvents.join("|"), "0:alpha:1:0:2|1:beta:2:0:2", "ok events fire with counts");
+    assertEq(errorEvents.length, 0, "no error events fire for successful all");
+    assertEq(listened.stats().ok, 2, "status tracks ok count");
+});
+
+test("promiseProgress all rejects on errors while events fire", async () => {
+    const failure = new Error("listen failure");
+    const listened = promiseProgress<string>([
+        () => Promise.resolve("alpha"),
+        () => Promise.reject(failure),
+        async () => {
+            await sleep(1);
+            return "gamma";
+        },
+    ]);
+    const okEvents: string[] = [];
+    const errorEvents: string[] = [];
+
+    listened.onOk((data, i, ok, errors, count) => {
+        okEvents.push(`${i}:${data}:${ok}:${errors}:${count}`);
+    });
+    listened.onError((error, i, ok, errors, count) => {
+        errorEvents.push(`${i}:${error === failure}:${ok}:${errors}:${count}`);
+    });
+
+    await assertRejects(listened.all(), failure, "promiseProgress all rejects with task error");
+    await Promise.allSettled(listened.items());
+
+    assertEq(errorEvents.join("|"), "1:true:1:1:3", "error event fires with counts");
+    assertEq(okEvents.join("|"), "0:alpha:1:0:3|2:gamma:2:1:3", "ok events still fire around rejection");
+    assertEq(listened.stats().error, 1, "status tracks error count");
+    assertEq(listened.stats().ok, 2, "status tracks successful count after rejection");
+});
+
+test("ReadyGate continues after thrown task and clears queued tasks", async () => {
+    const gate = createReadyGate();
+    const failure = new Error("ready failure");
+    const events: string[] = [];
+
+    gate.add(() => {
+        events.push("first");
+        throw failure;
+    });
+    gate.add(async () => {
+        await sleep(1);
+        events.push("second");
+    });
+
+    assertEq(gate.tasks().length, 2, "gate stores tasks before ready");
+    await assertRejects(gate.ready(), failure, "ready reports first thrown task");
+
+    assertEq(events.join(","), "first,second", "ready continues after thrown task");
+    assertEq(gate.tasks().length, 0, "ready clears queued tasks");
+    assert(gate.isReady(), "gate remains ready after thrown task");
+
+    gate.add(() => {
+        events.push("after-ready");
+    });
+    assertEq(events.join(","), "first,second,after-ready", "tasks added after ready run immediately");
+});
+
+async function main() {
+    let failed = 0;
+
+    for (const {name, fn} of tests) {
+        try {
+            await fn();
+            console.log(`ok - ${name}`);
+        } catch (error) {
+            failed++;
+            console.error(`not ok - ${name}`);
+            console.error(error);
+        }
+    }
+
+    if (failed > 0) {
+        throw new Error(`${failed} async queue regression test(s) failed`);
+    }
+
+    console.log(`${tests.length} async queue regression tests passed`);
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exit(1);
+});