@code-yeongyu/senpi-agent-core 2026.10.27-2 → 2026.10.30-1

package/dist/transport/reliable-transport.js

@@ -0,0 +1,232 @@
+import { TransportClosedError, } from "./transport.js";
+function isReferencePacket(message) {
+    if (typeof message !== "object" || message === null)
+        return false;
+    const { kind, lane, seq } = message;
+    if (typeof lane !== "string" || typeof seq !== "number" || !Number.isSafeInteger(seq) || seq < 0)
+        return false;
+    if (kind === "ack")
+        return true;
+    return kind === "data" && message.payload instanceof Uint8Array;
+}
+/** The decoder a conformance host uses to watch the reference transport's wire. */
+export function decodeReferencePacket(message) {
+    return isReferencePacket(message) ? { kind: message.kind, lane: message.lane, seq: message.seq } : { kind: "other" };
+}
+/**
+ * The reference transport: per-lane send windows (backpressure), round-robin transmission across lanes (fairness),
+ * cumulative ACKs sent only after the receiver's handler settles, and go-back-N from each lane's last ACK on re-attach or
+ * on that lane's own retransmit timeout. A receiver drops anything that is not the next frame of its lane, so it delivers each frame
+ * once and in order over any carrier that may drop, lose, delay or reorder messages.
+ */
+export function createReliableTransport(options) {
+    const window = options.window ?? 32;
+    const retransmitMs = options.retransmitMs ?? 1000;
+    const outLanes = new Map();
+    const inLanes = new Map();
+    const order = [];
+    const ackDue = new Set();
+    let next = 0;
+    let connection;
+    let writable = false;
+    let closed = false;
+    let handler;
+    const outLane = (lane) => {
+        let state = outLanes.get(lane);
+        if (state === undefined) {
+            state = { nextSeq: 1, acked: 0, transmitted: 0, outbox: new Map(), waiters: [], cancelRetransmit: undefined };
+            outLanes.set(lane, state);
+            order.push(lane);
+        }
+        return state;
+    };
+    const inLane = (lane) => {
+        let state = inLanes.get(lane);
+        if (state === undefined) {
+            state = { received: 0, delivered: 0, busy: false, inbox: [] };
+            inLanes.set(lane, state);
+        }
+        return state;
+    };
+    const admit = (state) => {
+        while (state.nextSeq - 1 - state.acked < window) {
+            const waiter = state.waiters.shift();
+            if (waiter === undefined)
+                return;
+            state.outbox.set(state.nextSeq, waiter.payload);
+            state.nextSeq += 1;
+            waiter.resolve();
+        }
+    };
+    const emit = (packet) => {
+        if (connection === undefined || !writable)
+            return false;
+        if (connection.send(packet))
+            return true;
+        writable = false;
+        return false;
+    };
+    const disarm = (state) => {
+        state.cancelRetransmit?.();
+        state.cancelRetransmit = undefined;
+    };
+    const disarmAll = () => {
+        for (const state of outLanes.values())
+            disarm(state);
+    };
+    const arm = () => {
+        if (connection === undefined)
+            return;
+        for (const state of outLanes.values()) {
+            if (state.cancelRetransmit !== undefined || state.outbox.size === 0)
+                continue;
+            state.cancelRetransmit = options.clock.setTimer(() => {
+                state.cancelRetransmit = undefined;
+                state.transmitted = state.acked;
+                pump();
+            }, retransmitMs);
+        }
+    };
+    function pump() {
+        if (connection === undefined || !writable)
+            return;
+        for (const lane of [...ackDue]) {
+            if (!emit({ kind: "ack", lane, seq: inLane(lane).delivered }))
+                return;
+            ackDue.delete(lane);
+        }
+        for (let idle = 0; idle < order.length;) {
+            const lane = order[next % order.length];
+            if (lane === undefined)
+                return;
+            const state = outLane(lane);
+            const seq = state.transmitted + 1;
+            const payload = state.outbox.get(seq);
+            if (payload === undefined) {
+                next += 1;
+                idle += 1;
+                continue;
+            }
+            if (!emit({ kind: "data", lane, seq, payload }))
+                return;
+            state.transmitted = seq;
+            next += 1;
+            idle = 0;
+        }
+        arm();
+    }
+    async function deliver(state, lane) {
+        if (state.busy || handler === undefined)
+            return;
+        state.busy = true;
+        try {
+            for (let frame = state.inbox.shift(); frame !== undefined && !closed; frame = state.inbox.shift()) {
+                try {
+                    await handler(frame);
+                }
+                catch (error) {
+                    options.onHandlerError(error, frame);
+                }
+                state.delivered += 1;
+                ackDue.add(lane);
+                pump();
+            }
+        }
+        finally {
+            state.busy = false;
+        }
+    }
+    const onData = (packet) => {
+        const state = inLane(packet.lane);
+        if (packet.seq === state.received + 1) {
+            state.received = packet.seq;
+            state.inbox.push({ lane: packet.lane, payload: packet.payload });
+            void deliver(state, packet.lane);
+        }
+        else {
+            ackDue.add(packet.lane);
+        }
+        pump();
+    };
+    const onAck = (packet) => {
+        const state = outLanes.get(packet.lane);
+        if (state === undefined || packet.seq <= state.acked || packet.seq >= state.nextSeq)
+            return;
+        for (let seq = state.acked + 1; seq <= packet.seq; seq++)
+            state.outbox.delete(seq);
+        state.acked = packet.seq;
+        state.transmitted = Math.max(state.transmitted, state.acked);
+        disarm(state);
+        admit(state);
+        pump();
+    };
+    return {
+        send(lane, payload) {
+            if (closed)
+                return Promise.reject(new TransportClosedError());
+            const state = outLane(lane);
+            return new Promise((resolve, reject) => {
+                state.waiters.push({ payload, resolve, reject });
+                admit(state);
+                pump();
+            });
+        },
+        onFrame(frameHandler) {
+            handler = frameHandler;
+            for (const [lane, state] of inLanes)
+                void deliver(state, lane);
+        },
+        inFlight: (lane) => {
+            const state = outLanes.get(lane);
+            return state === undefined ? 0 : state.nextSeq - 1 - state.acked;
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            disarmAll();
+            for (const state of outLanes.values()) {
+                for (const waiter of state.waiters.splice(0))
+                    waiter.reject(new TransportClosedError());
+            }
+            const current = connection;
+            connection = undefined;
+            current?.close();
+        },
+        attached(newConnection) {
+            if (closed) {
+                newConnection.close();
+                return;
+            }
+            connection = newConnection;
+            writable = true;
+            for (const state of outLanes.values())
+                state.transmitted = state.acked;
+            for (const [lane, state] of inLanes)
+                if (state.delivered > 0)
+                    ackDue.add(lane);
+            disarmAll();
+            pump();
+        },
+        message(message) {
+            if (!isReferencePacket(message))
+                return;
+            if (message.kind === "data")
+                onData(message);
+            else
+                onAck(message);
+        },
+        writable() {
+            if (connection === undefined)
+                return;
+            writable = true;
+            pump();
+        },
+        detached() {
+            connection = undefined;
+            writable = false;
+            disarmAll();
+        },
+    };
+}
+//# sourceMappingURL=reliable-transport.js.map

package/dist/transport/testing/fault-cases.d.ts

@@ -0,0 +1,6 @@
+import type { CaseImplementation } from "../../conformance/runner.ts";
+import { type TransportCaseAdapters } from "./transport-harness.ts";
+type FaultCase = CaseImplementation<TransportCaseAdapters>;
+export declare const FAULT_TRANSPORT_CASES: ReadonlyMap<string, FaultCase>;
+export {};
+//# sourceMappingURL=fault-cases.d.ts.map

package/dist/transport/testing/fault-cases.js

@@ -0,0 +1,30 @@
+import { createCarrierFault, FAULT_PROFILE_NAMES } from "./fault-transport.js";
+import { allDelivered, expectExactDelivery, openLink, range } from "./transport-harness.js";
+const LANES = ["a", "b", "c"];
+const FRAMES = 30;
+const PACE_MS = 20;
+const applied = {
+    slow: (stats) => stats.refused > 0,
+    lossy: (stats) => stats.lost > 0,
+    laggy: (stats) => stats.reordered > 0,
+    flap: (stats) => stats.drops >= 2,
+    "drop-reattach": (stats) => stats.drops >= 2,
+};
+const underProfile = (name) => async (adapters) => {
+    const stats = { refused: 0, lost: 0, reordered: 0, drops: 0 };
+    const link = openLink(adapters, createCarrierFault(name, stats));
+    const counts = Object.fromEntries(LANES.map((lane) => [lane, FRAMES]));
+    const sends = [];
+    for (const n of range(1, FRAMES)) {
+        sends.push(...LANES.map((lane) => link.send(lane, n)));
+        await link.advance(PACE_MS);
+    }
+    await link.runUntil(allDelivered(link, counts), `FAULT-TRANSPORT ${name}: every frame delivered`, 600_000);
+    await link.awaitAll(sends, `FAULT-TRANSPORT ${name}`);
+    await link.advance(2000);
+    expectExactDelivery(link, counts, `FAULT-TRANSPORT ${name}`);
+    if (!applied[name](stats))
+        throw new Error(`FAULT-TRANSPORT ${name}: the profile never acted (${JSON.stringify(stats)})`);
+};
+export const FAULT_TRANSPORT_CASES = new Map(FAULT_PROFILE_NAMES.map((name, index) => [`FAULT-TRANSPORT-0${index + 1}`, underProfile(name)]));
+//# sourceMappingURL=fault-cases.js.map

package/dist/transport/testing/fault-transport.d.ts

@@ -0,0 +1,44 @@
+import type { ManualTimers } from "../../durable/testing/manual-timers.ts";
+import type { CarrierFault } from "./transport-harness.ts";
+/**
+ * The five QX2 fault profiles as test parameters (not product settings). The plan fixes their shape; the numbers here are
+ * this suite's until M0 records final values in the gate's fault-profiles.json.
+ */
+declare const PROFILES: {
+    readonly slow: {
+        readonly perTick: 1;
+        readonly tickMs: 10;
+    };
+    readonly lossy: {
+        readonly lossRate: 0.2;
+        readonly seed: 7;
+    };
+    readonly laggy: {
+        readonly latencyMs: 40;
+        readonly jitterMs: 60;
+        readonly seed: 11;
+    };
+    readonly flap: {
+        readonly upMs: 100;
+        readonly downMs: 60;
+        readonly cycles: 8;
+    };
+    readonly "drop-reattach": {
+        readonly everyMessages: 9;
+        readonly reattachMs: 30;
+        readonly repetitions: 6;
+    };
+};
+export type FaultProfileName = keyof typeof PROFILES;
+export declare const FAULT_PROFILE_NAMES: readonly FaultProfileName[];
+/** How often the profile actually acted, so a case can refuse to pass on a fault that never happened. */
+export interface FaultStats {
+    refused: number;
+    lost: number;
+    reordered: number;
+    drops: number;
+}
+/** Builds one profile's fault for the link a case opens. */
+export declare function createCarrierFault(name: FaultProfileName, stats: FaultStats): (timers: ManualTimers) => CarrierFault;
+export {};
+//# sourceMappingURL=fault-transport.d.ts.map

package/dist/transport/testing/fault-transport.js

@@ -0,0 +1,144 @@
+/**
+ * The five QX2 fault profiles as test parameters (not product settings). The plan fixes their shape; the numbers here are
+ * this suite's until M0 records final values in the gate's fault-profiles.json.
+ */
+const PROFILES = {
+    slow: { perTick: 1, tickMs: 10 },
+    lossy: { lossRate: 0.2, seed: 7 },
+    laggy: { latencyMs: 40, jitterMs: 60, seed: 11 },
+    flap: { upMs: 100, downMs: 60, cycles: 8 },
+    "drop-reattach": { everyMessages: 9, reattachMs: 30, repetitions: 6 },
+};
+export const FAULT_PROFILE_NAMES = ["slow", "lossy", "laggy", "flap", "drop-reattach"];
+const mulberry32 = (seed) => {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+};
+function wrapWith(send) {
+    return (side) => {
+        let current;
+        return {
+            attached: (connection) => {
+                current = connection;
+                const live = () => current === connection;
+                side.attached({
+                    send: (message) => send(connection, side, message, live),
+                    close: () => connection.close(),
+                });
+            },
+            message: (message) => side.message(message),
+            writable: () => side.writable(),
+            detached: () => {
+                current = undefined;
+                side.detached();
+            },
+        };
+    };
+}
+function slow(timers, stats) {
+    const { perTick, tickMs } = PROFILES.slow;
+    const used = new WeakMap();
+    return (inner, side, message, live) => {
+        const tick = Math.floor(timers.now() / tickMs);
+        const state = used.get(side) ?? { tick, count: 0, waiting: false };
+        if (state.tick !== tick)
+            Object.assign(state, { tick, count: 0 });
+        used.set(side, state);
+        if (state.count < perTick) {
+            state.count += 1;
+            return inner.send(message);
+        }
+        stats.refused += 1;
+        if (!state.waiting) {
+            state.waiting = true;
+            timers.setTimer(() => {
+                state.waiting = false;
+                if (live())
+                    side.writable();
+            }, (tick + 1) * tickMs - timers.now());
+        }
+        return false;
+    };
+}
+function lossy(stats) {
+    const random = mulberry32(PROFILES.lossy.seed);
+    return (inner, _side, message) => {
+        if (random() < PROFILES.lossy.lossRate) {
+            stats.lost += 1;
+            return true;
+        }
+        return inner.send(message);
+    };
+}
+function laggy(timers, stats) {
+    const { latencyMs, jitterMs, seed } = PROFILES.laggy;
+    const random = mulberry32(seed);
+    const order = new WeakMap();
+    return (inner, side, message, live) => {
+        const state = order.get(side) ?? { sent: 0, highest: 0 };
+        order.set(side, state);
+        state.sent += 1;
+        const index = state.sent;
+        timers.setTimer(() => {
+            if (!live())
+                return;
+            if (index < state.highest)
+                stats.reordered += 1;
+            state.highest = Math.max(state.highest, index);
+            inner.send(message);
+        }, latencyMs + Math.floor(random() * jitterMs));
+        return true;
+    };
+}
+function flap(timers, stats, link) {
+    const { upMs, downMs, cycles } = PROFILES.flap;
+    for (let cycle = 0; cycle < cycles; cycle++) {
+        const start = timers.now() + cycle * (upMs + downMs);
+        timers.setTimer(() => {
+            stats.drops += 1;
+            link.drop();
+        }, start + upMs - timers.now());
+        timers.setTimer(() => link.connect(), start + upMs + downMs - timers.now());
+    }
+}
+/** Builds one profile's fault for the link a case opens. */
+export function createCarrierFault(name, stats) {
+    return (timers) => {
+        let link;
+        const passThrough = (inner, _side, message) => inner.send(message);
+        let sent = 0;
+        const dropReattach = (inner, _side, message) => {
+            const { everyMessages, reattachMs, repetitions } = PROFILES["drop-reattach"];
+            sent += 1;
+            if (sent % everyMessages === 0 && stats.drops < repetitions && link !== undefined) {
+                const target = link;
+                stats.drops += 1;
+                timers.setTimer(() => target.drop(), 0);
+                timers.setTimer(() => target.connect(), reattachMs);
+            }
+            return inner.send(message);
+        };
+        const sends = {
+            slow: slow(timers, stats),
+            lossy: lossy(stats),
+            laggy: laggy(timers, stats),
+            flap: passThrough,
+            "drop-reattach": dropReattach,
+        };
+        return {
+            wrap: wrapWith(sends[name]),
+            start(started) {
+                link = started;
+                if (name === "flap")
+                    flap(timers, stats, started);
+            },
+        };
+    };
+}
+//# sourceMappingURL=fault-transport.js.map

package/dist/transport/testing/multi-cases.d.ts

@@ -0,0 +1,6 @@
+import type { CaseImplementation } from "../../conformance/runner.ts";
+import { type TransportCaseAdapters } from "./transport-harness.ts";
+type MultiCase = CaseImplementation<TransportCaseAdapters>;
+export declare const MULTI_CASES: ReadonlyMap<string, MultiCase>;
+export {};
+//# sourceMappingURL=multi-cases.d.ts.map

package/dist/transport/testing/multi-cases.js

@@ -0,0 +1,113 @@
+import { createCarrierFault } from "./fault-transport.js";
+import { allDelivered, expectExactDelivery, openLink, range, } from "./transport-harness.js";
+const manyLanes = async (adapters) => {
+    const link = openLink(adapters);
+    const lanes = range(1, 8).map((n) => `scope-${n}`);
+    const counts = Object.fromEntries(lanes.map((lane) => [lane, 25]));
+    const sends = range(1, 25).flatMap((n) => lanes.map((lane) => link.send(lane, n)));
+    await link.runUntil(allDelivered(link, counts), "MULTI-LANE-01 every scope delivered");
+    await link.awaitAll(sends, "MULTI-LANE-01");
+    await link.advance(1000);
+    expectExactDelivery(link, counts, "MULTI-LANE-01");
+    const lanesInLog = link.log.map((entry) => entry.slice(0, entry.indexOf(":")));
+    for (const lane of lanes) {
+        const first = lanesInLog.indexOf(lane);
+        const lastOfOthers = Math.min(...lanes.filter((other) => other !== lane).map((other) => lanesInLog.lastIndexOf(other)));
+        if (first > lastOfOthers)
+            throw new Error(`MULTI-LANE-01: ${lane} started only after another scope had finished`);
+    }
+};
+const stalledLaneDoesNotHoldOthers = async (adapters) => {
+    const link = openLink(adapters);
+    const release = link.gate("A");
+    const aSends = range(1, 100).map((n) => link.send("A", n));
+    const bSends = range(1, 10).map((n) => link.send("B", n));
+    await link.runUntil(allDelivered(link, { B: 10 }), "MULTI-FAIR-01 B delivered while A's receiver is stalled", 20_000);
+    await link.awaitAll(bSends, "MULTI-FAIR-01 B");
+    if (link.delivered("A").length > 0)
+        throw new Error("MULTI-FAIR-01: A delivered through a stalled receiver");
+    release();
+    await link.runUntil(allDelivered(link, { A: 100 }), "MULTI-FAIR-01 A delivered after release");
+    await link.awaitAll(aSends, "MULTI-FAIR-01 A");
+    await link.advance(1000);
+    expectExactDelivery(link, { A: 100, B: 10 }, "MULTI-FAIR-01 stalled lane");
+};
+const MAX_A_FRAMES_BEFORE_B = 4;
+const longLaneDoesNotStarveAnother = async (adapters) => {
+    const stats = { refused: 0, lost: 0, reordered: 0, drops: 0 };
+    const link = openLink(adapters, createCarrierFault("slow", stats));
+    const aSends = range(1, 300).map((n) => link.send("A", n));
+    await link.runUntil(() => link.delivered("A").length >= 20, "MULTI-FAIR-01 A's long lane under way");
+    const before = link.delivered("A").length;
+    const bSend = link.send("B", 1);
+    await link.runUntil(allDelivered(link, { B: 1 }), "MULTI-FAIR-01 B delivered behind A's long lane");
+    const aheadOfB = link.delivered("A").length - before;
+    if (aheadOfB > MAX_A_FRAMES_BEFORE_B) {
+        throw new Error(`MULTI-FAIR-01: ${aheadOfB} of A's frames went ahead of B's one frame (at most ${MAX_A_FRAMES_BEFORE_B})`);
+    }
+    await link.runUntil(allDelivered(link, { A: 300 }), "MULTI-FAIR-01 A's long lane delivered", 600_000);
+    await link.awaitAll([...aSends, bSend], "MULTI-FAIR-01 long lane");
+    await link.advance(1000);
+    expectExactDelivery(link, { A: 300, B: 1 }, "MULTI-FAIR-01 long lane");
+    if (stats.refused === 0)
+        throw new Error("MULTI-FAIR-01: the slow carrier never pushed back");
+};
+const fairness = async (adapters) => {
+    await stalledLaneDoesNotHoldOthers(adapters);
+    await longLaneDoesNotStarveAnother(adapters);
+};
+/** Loses the first data message of `lane`#`seq` on the carrier, once; every other message passes. */
+function loseOnce(decode, lane, seq, stats) {
+    return {
+        wrap: (side) => ({
+            attached: (connection) => side.attached({
+                send: (message) => {
+                    const view = decode(message);
+                    if (stats.lost === 0 && view.kind === "data" && view.lane === lane && view.seq === seq) {
+                        stats.lost += 1;
+                        return true;
+                    }
+                    return connection.send(message);
+                },
+                close: () => connection.close(),
+            }),
+            message: (message) => side.message(message),
+            writable: () => side.writable(),
+            detached: () => side.detached(),
+        }),
+        start: () => { },
+    };
+}
+const LONG_LANE_FRAMES = 400;
+const LONG_LANE_PACE_MS = 10;
+/**
+ * B's only frame is lost while A's paced receiver keeps acknowledging A's long lane. B's resend must not wait for A: the
+ * loss is recovered on B's own deadline, before half of A's frames have gone ahead of it.
+ */
+const lossOnOneLaneIsNotHeldByAnother = async (adapters) => {
+    const stats = { refused: 0, lost: 0, reordered: 0, drops: 0 };
+    const decode = (message) => adapters.transport.decode(message);
+    const link = openLink(adapters, () => loseOnce(decode, "B", 1, stats));
+    link.pace("A", LONG_LANE_PACE_MS);
+    const aSends = range(1, LONG_LANE_FRAMES).map((n) => link.send("A", n));
+    await link.runUntil(() => link.delivered("A").length >= 10, "MULTI-FAIR-02 A's long lane under way");
+    const before = link.delivered("A").length;
+    const bSend = link.send("B", 1);
+    await link.runUntil(allDelivered(link, { B: 1 }), "MULTI-FAIR-02 B delivered after its loss", 600_000);
+    if (stats.lost !== 1)
+        throw new Error(`MULTI-FAIR-02: B#1 was not lost on the carrier (${JSON.stringify(stats)})`);
+    const aheadOfB = link.delivered("A").length - before;
+    if (aheadOfB >= LONG_LANE_FRAMES / 2) {
+        throw new Error(`MULTI-FAIR-02: B's lost frame was resent only after ${aheadOfB} of A's frames (fewer than ${LONG_LANE_FRAMES / 2})`);
+    }
+    await link.runUntil(allDelivered(link, { A: LONG_LANE_FRAMES }), "MULTI-FAIR-02 A delivered", 600_000);
+    await link.awaitAll([...aSends, bSend], "MULTI-FAIR-02");
+    await link.advance(2000);
+    expectExactDelivery(link, { A: LONG_LANE_FRAMES, B: 1 }, "MULTI-FAIR-02");
+};
+export const MULTI_CASES = new Map([
+    ["MULTI-LANE-01", manyLanes],
+    ["MULTI-FAIR-01", fairness],
+    ["MULTI-FAIR-02", lossOnOneLaneIsNotHeldByAnother],
+]);
+//# sourceMappingURL=multi-cases.js.map

package/dist/transport/testing/transport-cases.d.ts

@@ -0,0 +1,6 @@
+import type { CaseImplementation } from "../../conformance/runner.ts";
+import { type TransportCaseAdapters } from "./transport-harness.ts";
+type TransportCase = CaseImplementation<TransportCaseAdapters>;
+export declare const TRANSPORT_CASES: ReadonlyMap<string, TransportCase>;
+export {};
+//# sourceMappingURL=transport-cases.d.ts.map

package/dist/transport/testing/transport-cases.js

@@ -0,0 +1,60 @@
+import { expectEqual } from "../../durable/testing/store-harness.js";
+import { allDelivered, expectExactDelivery, openLink, range } from "./transport-harness.js";
+const order = async (adapters) => {
+    const link = openLink(adapters);
+    const counts = { a: 40, b: 40, c: 40 };
+    const sends = range(1, 40).flatMap((n) => ["a", "b", "c"].map((lane) => link.send(lane, n)));
+    await link.runUntil(allDelivered(link, counts), "TRANSPORT-01 every frame delivered");
+    await link.awaitAll(sends, "TRANSPORT-01");
+    await link.advance(1000);
+    expectExactDelivery(link, counts, "TRANSPORT-01");
+};
+const resume = async (adapters) => {
+    const link = openLink(adapters);
+    const counts = { a: 30, b: 30 };
+    const sends = range(1, 10).flatMap((n) => [link.send("a", n), link.send("b", n)]);
+    await link.runUntil(() => link.delivered("a").length >= 4, "TRANSPORT-02 first frames delivered");
+    link.link.drop();
+    sends.push(...range(11, 20).flatMap((n) => [link.send("a", n), link.send("b", n)]));
+    await link.advance(500);
+    if (link.sender.inFlight("a") + link.sender.inFlight("b") === 0) {
+        throw new Error("TRANSPORT-02: expected unacknowledged frames while the carrier is down");
+    }
+    link.link.connect();
+    await link.runUntil(() => link.delivered("a").length >= 15, "TRANSPORT-02 resumed after the first re-attach");
+    link.link.drop();
+    sends.push(...range(21, 30).flatMap((n) => [link.send("a", n), link.send("b", n)]));
+    link.link.connect();
+    await link.runUntil(allDelivered(link, counts), "TRANSPORT-02 every frame delivered after two re-attaches");
+    await link.awaitAll(sends, "TRANSPORT-02");
+    await link.advance(1000);
+    expectExactDelivery(link, counts, "TRANSPORT-02");
+};
+const backpressure = async (adapters) => {
+    const link = openLink(adapters);
+    const release = link.gate("slow");
+    const resolved = [];
+    const sends = range(1, 200).map((n) => link.send("slow", n).then(() => void resolved.push(n)));
+    await link.advance(2000);
+    const admitted = resolved.length;
+    if (admitted === 0 || admitted >= 200) {
+        throw new Error(`TRANSPORT-03: a stalled receiver must bound the senders, but ${admitted} of 200 sends resolved`);
+    }
+    await link.advance(2000);
+    expectEqual(resolved.length, admitted, "TRANSPORT-03 the bound holds while the receiver stays stalled");
+    expectEqual(link.delivered("slow"), [], "TRANSPORT-03 nothing delivered while the receiver is stalled");
+    if (link.sender.inFlight("slow") > admitted)
+        throw new Error("TRANSPORT-03: more in flight than admitted");
+    release();
+    await link.runUntil(allDelivered(link, { slow: 200 }), "TRANSPORT-03 every frame delivered after release");
+    await link.awaitAll(sends, "TRANSPORT-03");
+    expectEqual(resolved, range(1, 200), "TRANSPORT-03 sends resolve in send order");
+    await link.advance(1000);
+    expectExactDelivery(link, { slow: 200 }, "TRANSPORT-03");
+};
+export const TRANSPORT_CASES = new Map([
+    ["TRANSPORT-01", order],
+    ["TRANSPORT-02", resume],
+    ["TRANSPORT-03", backpressure],
+]);
+//# sourceMappingURL=transport-cases.js.map