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

package/dist/testing/win32-sim.js

@@ -0,0 +1,197 @@
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+/** Node's Windows errno values (libuv `UV_E*` on win32). */
+const WIN32_ERRNO = { EBUSY: -4082, EPERM: -4048, ENOSYS: -4054 };
+const WIN32_ERROR_DESCRIPTION = {
+    EBUSY: "resource busy or locked",
+    EPERM: "operation not permitted",
+    ENOSYS: "function not implemented",
+};
+/** Builds the error Node throws on Windows for `code` from `syscall`. */
+export function win32Error(code, syscall, filePath, dest) {
+    let target = "";
+    if (filePath !== undefined)
+        target = dest === undefined ? ` '${filePath}'` : ` '${filePath}' -> '${dest}'`;
+    const error = new Error(`${code}: ${WIN32_ERROR_DESCRIPTION[code]}, ${syscall}${target}`);
+    error.code = code;
+    error.errno = WIN32_ERRNO[code];
+    error.syscall = syscall;
+    if (filePath !== undefined)
+        error.path = filePath;
+    if (dest !== undefined)
+        error.dest = dest;
+    return error;
+}
+/** Compares two Windows names (path segments, paths or pipe names) the way Windows does: case-insensitively. */
+export function win32NamesEqual(left, right) {
+    return left.toUpperCase() === right.toUpperCase();
+}
+const DRIVE_LETTER = /^[A-Za-z]$/;
+const DRIVE_PATH = /^([A-Za-z]):\\(.*)$/s;
+/** Turns a relative POSIX-style path (`dir/file`) into a drive-letter Windows path (`C:\dir\file`). */
+export function toWin32Path(relativePath, drive = "C") {
+    if (!DRIVE_LETTER.test(drive))
+        throw new RangeError(`win32 sim: drive must be one letter, got ${JSON.stringify(drive)}`);
+    if (relativePath.startsWith("/")) {
+        throw new RangeError(`win32 sim: expected a relative path, got ${JSON.stringify(relativePath)}`);
+    }
+    return path.win32.join(`${drive.toUpperCase()}:\\`, ...relativePath.split("/"));
+}
+/** True for an absolute drive-letter path such as `C:\dir` (forward slashes are accepted, as on Windows). */
+export function isWin32DrivePath(candidate) {
+    return DRIVE_PATH.test(path.win32.normalize(candidate));
+}
+export const WIN32_PIPE_PREFIX = "\\\\.\\pipe\\";
+/** Windows limits a full pipe name to 256 characters. */
+const WIN32_PIPE_MAX_LENGTH = 256;
+/** Builds the named-pipe endpoint (`\\.\pipe\<name>`) a Windows transport listens on instead of a socket file. */
+export function win32PipeEndpoint(name) {
+    if (name.length === 0 || name.includes("\\")) {
+        throw new RangeError(`win32 sim: a pipe name must be non-empty and contain no backslash, got ${JSON.stringify(name)}`);
+    }
+    const endpoint = `${WIN32_PIPE_PREFIX}${name}`;
+    if (endpoint.length > WIN32_PIPE_MAX_LENGTH) {
+        throw new RangeError(`win32 sim: a pipe endpoint is at most ${WIN32_PIPE_MAX_LENGTH} characters`);
+    }
+    return endpoint;
+}
+/** True when `endpoint` is a local named-pipe endpoint; the prefix is matched case-insensitively, as on Windows. */
+export function isWin32PipeEndpoint(endpoint) {
+    const name = endpoint.slice(WIN32_PIPE_PREFIX.length);
+    return (win32NamesEqual(endpoint.slice(0, WIN32_PIPE_PREFIX.length), WIN32_PIPE_PREFIX) &&
+        name.length > 0 &&
+        !name.includes("\\"));
+}
+function hasErrorCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}
+/**
+ * A filesystem that behaves like Windows over a backing directory: it takes only drive-letter paths, resolves every
+ * segment case-insensitively while keeping the case a name was created with, and refuses to rename or delete an open
+ * file with Windows errors.
+ */
+export class Win32SimFs {
+    #root;
+    #renameOpenFileError;
+    #deleteOpenFileError;
+    #openCounts = new Map();
+    constructor(options) {
+        this.#root = options.root;
+        this.#renameOpenFileError = options.renameOpenFileError ?? "EPERM";
+        this.#deleteOpenFileError = options.deleteOpenFileError ?? "EBUSY";
+    }
+    /** Maps a drive-letter path to its backing path, matching existing names case-insensitively. */
+    async resolve(win32Path) {
+        const match = DRIVE_PATH.exec(path.win32.normalize(win32Path));
+        if (match === null) {
+            throw new TypeError(`win32 sim: expected a drive-letter path such as C:\\dir\\file, got ${JSON.stringify(win32Path)}`);
+        }
+        const [, drive = "", rest = ""] = match;
+        const segments = rest.split("\\").filter((segment) => segment.length > 0);
+        let current = path.join(this.#root, drive.toUpperCase());
+        for (const [index, segment] of segments.entries()) {
+            let entries;
+            try {
+                entries = await fsp.readdir(current);
+            }
+            catch (error) {
+                if (hasErrorCode(error, "ENOENT") || hasErrorCode(error, "ENOTDIR")) {
+                    return path.join(current, ...segments.slice(index));
+                }
+                throw error;
+            }
+            current = path.join(current, entries.find((entry) => win32NamesEqual(entry, segment)) ?? segment);
+        }
+        return current;
+    }
+    async mkdir(win32Path) {
+        await fsp.mkdir(await this.resolve(win32Path), { recursive: true });
+    }
+    async writeFile(win32Path, data) {
+        await fsp.writeFile(await this.resolve(win32Path), data);
+    }
+    async readFile(win32Path) {
+        return fsp.readFile(await this.resolve(win32Path));
+    }
+    /** Names in a directory, in the case each was created with. */
+    async readdir(win32Path) {
+        return (await fsp.readdir(await this.resolve(win32Path))).sort();
+    }
+    async exists(win32Path) {
+        try {
+            await fsp.stat(await this.resolve(win32Path));
+            return true;
+        }
+        catch (error) {
+            if (hasErrorCode(error, "ENOENT"))
+                return false;
+            throw error;
+        }
+    }
+    /** Opens a file; until `close()` it cannot be renamed or deleted. */
+    async open(win32Path, flags = "r") {
+        const backing = await this.resolve(win32Path);
+        const handle = await fsp.open(backing, flags);
+        this.#openCounts.set(backing, (this.#openCounts.get(backing) ?? 0) + 1);
+        let closed = false;
+        return {
+            handle,
+            close: async () => {
+                if (closed)
+                    return;
+                closed = true;
+                const remaining = (this.#openCounts.get(backing) ?? 1) - 1;
+                if (remaining === 0)
+                    this.#openCounts.delete(backing);
+                else
+                    this.#openCounts.set(backing, remaining);
+                await handle.close();
+            },
+        };
+    }
+    /** Renames or replaces a file; a rename that only changes a name's case keeps one entry with the new case. */
+    async rename(from, to) {
+        const source = await this.resolve(from);
+        let target = await this.resolve(to);
+        if (this.#isOpen(source) || this.#isOpen(target))
+            throw win32Error(this.#renameOpenFileError, "rename", from, to);
+        if (target === source)
+            target = path.join(path.dirname(source), path.win32.basename(path.win32.normalize(to)));
+        await fsp.rename(source, target);
+    }
+    async unlink(win32Path) {
+        const backing = await this.resolve(win32Path);
+        if (this.#isOpen(backing))
+            throw win32Error(this.#deleteOpenFileError, "unlink", win32Path);
+        await fsp.unlink(backing);
+    }
+    /** Like `fs.rm` with `recursive`; fails with the delete error while any file at or under the path is open. */
+    async rm(win32Path) {
+        const backing = await this.resolve(win32Path);
+        const inside = `${backing}${path.sep}`;
+        for (const open of this.#openCounts.keys()) {
+            if (open === backing || open.startsWith(inside))
+                throw win32Error(this.#deleteOpenFileError, "rm", win32Path);
+        }
+        await fsp.rm(backing, { recursive: true });
+    }
+    #isOpen(backing) {
+        return this.#openCounts.has(backing);
+    }
+}
+/** The signals Node accepts on Windows; every one of them terminates the process outright. */
+const WIN32_KILL_SIGNALS = new Set(["SIGKILL", "SIGTERM", "SIGINT", "SIGQUIT"]);
+/**
+ * Sends `signal` with Windows semantics. Signal `0` only probes liveness. A supported signal terminates the process
+ * immediately, so no signal handler runs (the POSIX child is sent `SIGKILL` and reports it). Any other signal throws
+ * `ENOSYS` and leaves the process running.
+ */
+export function win32Kill(target, signal = "SIGTERM") {
+    if (signal !== 0 && !WIN32_KILL_SIGNALS.has(signal))
+        throw win32Error("ENOSYS", "kill");
+    const posixSignal = signal === 0 ? 0 : "SIGKILL";
+    if (typeof target === "number")
+        return process.kill(target, posixSignal);
+    return target.kill(posixSignal);
+}
+//# sourceMappingURL=win32-sim.js.map

package/dist/transport/in-process-carrier.d.ts

@@ -0,0 +1,19 @@
+import { type LocalEndpoint } from "./local-endpoint.ts";
+import type { CarrierSide } from "./transport.ts";
+/** One dialed link between two carrier sides; it can drop and re-attach. */
+export interface CarrierLink {
+    connect(): void;
+    drop(): void;
+    readonly connected: boolean;
+}
+export interface InProcessNetworkOptions {
+    /** Runs one message hand-off later; default `queueMicrotask`. Tests pass manual timers. */
+    readonly schedule?: (deliver: () => void) => void;
+}
+/** In-process carriers addressed by local endpoints, so fused and local runs need no socket. */
+export interface InProcessNetwork {
+    listen(endpoint: LocalEndpoint, side: CarrierSide): () => void;
+    dial(endpoint: LocalEndpoint, side: CarrierSide): CarrierLink;
+}
+export declare function createInProcessNetwork(options?: InProcessNetworkOptions): InProcessNetwork;
+//# sourceMappingURL=in-process-carrier.d.ts.map

package/dist/transport/in-process-carrier.js

@@ -0,0 +1,63 @@
+import { endpointKey } from "./local-endpoint.js";
+function createLink(a, b, schedule) {
+    let generation = 0;
+    let up = false;
+    const drop = () => {
+        if (!up)
+            return;
+        up = false;
+        generation += 1;
+        a.detached();
+        b.detached();
+    };
+    const half = (to, at) => ({
+        send: (message) => {
+            schedule(() => {
+                if (up && generation === at)
+                    to.message(message);
+            });
+            return true;
+        },
+        close: () => {
+            if (generation === at)
+                drop();
+        },
+    });
+    return {
+        connect() {
+            if (up)
+                return;
+            up = true;
+            generation += 1;
+            a.attached(half(b, generation));
+            b.attached(half(a, generation));
+        },
+        drop,
+        get connected() {
+            return up;
+        },
+    };
+}
+export function createInProcessNetwork(options = {}) {
+    const schedule = options.schedule ?? queueMicrotask;
+    const listeners = new Map();
+    return {
+        listen(endpoint, side) {
+            const key = endpointKey(endpoint);
+            if (listeners.has(key))
+                throw new Error(`in-process carrier: ${endpoint.address} already has a listener`);
+            listeners.set(key, { side, dialed: false });
+            return () => void listeners.delete(key);
+        },
+        dial(endpoint, side) {
+            const listener = listeners.get(endpointKey(endpoint));
+            if (listener === undefined)
+                throw new Error(`in-process carrier: no listener at ${endpoint.address}`);
+            if (listener.dialed)
+                throw new Error(`in-process carrier: ${endpoint.address} is already dialed`);
+            listener.dialed = true;
+            return createLink(side, listener.side, schedule);
+        },
+    };
+}
+//# sourceMappingURL=in-process-carrier.js.map

package/dist/transport/local-endpoint.d.ts

@@ -0,0 +1,13 @@
+/** Where a local transport listens: an owner-only Unix socket on POSIX, a named pipe (no file, no mode) on Windows. */
+export type LocalEndpoint = {
+    readonly kind: "unix-socket";
+    readonly address: string;
+    readonly mode: number;
+} | {
+    readonly kind: "named-pipe";
+    readonly address: string;
+};
+export declare function localEndpoint(platform: string, name: string, socketDir: string): LocalEndpoint;
+/** The identity of an endpoint: Windows pipe names compare case-insensitively, socket paths exactly. */
+export declare function endpointKey(endpoint: LocalEndpoint): string;
+//# sourceMappingURL=local-endpoint.d.ts.map

package/dist/transport/local-endpoint.js

@@ -0,0 +1,20 @@
+const PIPE_PREFIX = "\\\\.\\pipe\\";
+const PIPE_MAX_LENGTH = 256;
+const OWNER_ONLY = 0o600;
+export function localEndpoint(platform, name, socketDir) {
+    if (name.length === 0 || /[\\/]/.test(name)) {
+        throw new RangeError(`local endpoint: a name must be non-empty with no path separator, got ${JSON.stringify(name)}`);
+    }
+    if (platform === "win32") {
+        const address = `${PIPE_PREFIX}${name}`;
+        if (address.length > PIPE_MAX_LENGTH)
+            throw new RangeError(`local endpoint: a pipe name is at most ${PIPE_MAX_LENGTH} characters`);
+        return { kind: "named-pipe", address };
+    }
+    return { kind: "unix-socket", address: `${socketDir.replace(/\/+$/, "")}/${name}.sock`, mode: OWNER_ONLY };
+}
+/** The identity of an endpoint: Windows pipe names compare case-insensitively, socket paths exactly. */
+export function endpointKey(endpoint) {
+    return endpoint.kind === "named-pipe" ? endpoint.address.toUpperCase() : endpoint.address;
+}
+//# sourceMappingURL=local-endpoint.js.map

package/dist/transport/reliable-transport.d.ts

@@ -0,0 +1,40 @@
+import { type TransportClock, type TransportFrame, type TransportSide } from "./transport.ts";
+/** The reference transport's wire messages: per-lane sequence numbers from 1, and cumulative ACKs of delivered frames. */
+export type ReferencePacket = {
+    readonly kind: "data";
+    readonly lane: string;
+    readonly seq: number;
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "ack";
+    readonly lane: string;
+    readonly seq: number;
+};
+export interface ReliableTransportOptions {
+    readonly clock: TransportClock;
+    /** Frames per lane that may be sent and unacknowledged at once. Default 32. */
+    readonly window?: number;
+    /**
+     * Without ACK progress on a lane for this long, that lane's unacknowledged frames are sent again from its last ACK.
+     * Each lane keeps its own deadline, so progress on one lane never postpones another's retransmit. Default 1000.
+     */
+    readonly retransmitMs?: number;
+    /** A receiver that throws: the frame still counts as delivered (it is never delivered twice). */
+    readonly onHandlerError: (error: unknown, frame: TransportFrame) => void;
+}
+/** The decoder a conformance host uses to watch the reference transport's wire. */
+export declare function decodeReferencePacket(message: unknown): {
+    readonly kind: "data" | "ack";
+    readonly lane: string;
+    readonly seq: number;
+} | {
+    readonly 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 declare function createReliableTransport(options: ReliableTransportOptions): TransportSide;
+//# sourceMappingURL=reliable-transport.d.ts.map

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