tmux-ide 2.9.2 → 2.9.4

package/packages/daemon/dist/lib/__tests__/installed-recovery-fixture.js

@@ -1,400 +0,0 @@
-/**
- * Private fleet fixture for the installed-artifact recovery and authority
- * live tests. One fixture owns one private tmux server, one private state
- * home and every CLI child it spawns, and retires all of them on `cleanup`.
- *
- * Socket unification: the CLI's plain `tmux` paths (adopt, restore, polling
- * wait) resolve `$TMUX_TMPDIR/tmux-<uid>/default`, while the daemon pins its
- * server by `TMUX_IDE_TMUX_SOCKET_PATH` and strips `TMUX_TMPDIR` from its
- * pinned client. Pointing the pinned path at exactly the resolved default
- * path makes both paths reach the same private server, which the fixture
- * proves with `assertUnifiedSocket` before any scenario runs.
- *
- * CLI under test: `TMUX_IDE_QUALIFY_CLI` (absolute path to an installed
- * `tmux-ide` executable or its `cli.js`) qualifies a packed installation;
- * otherwise the fixture bundles `bin/cli.ts` from this checkout.
- */
-import { build } from "esbuild";
-import { execFileSync, spawn, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { appendFileSync, chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync, } from "node:fs";
-import { userInfo } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import WsWebSocket from "ws";
-export const repoRoot = fileURLToPath(new URL("../../../../../", import.meta.url));
-export const tmuxAvailable = spawnSync("tmux", ["-V"], { stdio: "ignore" }).status === 0;
-function evidencePath() {
-    const dir = process.env.TMUX_IDE_STAGE6_EVIDENCE_DIR;
-    if (!dir)
-        return null;
-    mkdirSync(dir, { recursive: true });
-    return join(dir, "evidence.jsonl");
-}
-async function resolveCli(root) {
-    const configured = process.env.TMUX_IDE_QUALIFY_CLI;
-    if (configured) {
-        const path = realpathSync(configured);
-        return { path, label: `installed:${path}` };
-    }
-    const bundle = join(root, "cli.mjs");
-    await build({
-        entryPoints: [join(repoRoot, "bin/cli.ts")],
-        outfile: bundle,
-        bundle: true,
-        platform: "node",
-        format: "esm",
-        target: "node20",
-        logLevel: "silent",
-        plugins: [
-            {
-                name: "external-dependencies",
-                setup(builder) {
-                    builder.onResolve({ filter: /.*/ }, (args) => {
-                        if (args.kind === "entry-point" ||
-                            args.path.startsWith(".") ||
-                            args.path.startsWith("/") ||
-                            args.path.startsWith("@tmux-ide/") ||
-                            args.path === "@xterm/addon-unicode11")
-                            return;
-                        return { external: true };
-                    });
-                },
-            },
-        ],
-    });
-    return { path: bundle, label: "checkout-bundle" };
-}
-export async function createPrivateFleet(prefix) {
-    // A short root keeps the unix socket path well under the platform limit.
-    const root = mkdtempSync(`/tmp/ti-${prefix}-`);
-    const stateDir = join(root, "state");
-    const home = join(root, "home");
-    const tmuxTmpDir = join(root, "tmux");
-    const socketDir = join(tmuxTmpDir, `tmux-${userInfo().uid}`);
-    const socketPath = join(socketDir, "default");
-    const binDir = join(root, "bin");
-    for (const dir of [stateDir, home, tmuxTmpDir, socketDir, binDir])
-        mkdirSync(dir, { mode: 0o700 });
-    chmodSync(tmuxTmpDir, 0o700);
-    chmodSync(socketDir, 0o700);
-    if (!process.env.TMUX_IDE_QUALIFY_CLI) {
-        // The checkout bundle resolves its externals from this repo's node_modules.
-        execFileSync("ln", ["-s", join(repoRoot, "node_modules"), join(root, "node_modules")]);
-    }
-    const cliResolved = await resolveCli(root);
-    const tmuxPath = realpathSync(execFileSync("/bin/sh", ["-c", "command -v tmux"], { encoding: "utf8" }).trim());
-    // The chrome updater session runs `exec tmux-ide chrome-updater` from the
-    // server's PATH; this shim routes it to the CLI under test.
-    writeFileSync(join(binDir, "tmux-ide"), `#!/bin/sh\nexec ${JSON.stringify(process.execPath)} ${JSON.stringify(cliResolved.path)} "$@"\n`, { mode: 0o755 });
-    const env = {
-        ...Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("TMUX_IDE_") &&
-            key !== "TMUX" &&
-            key !== "TMUX_PANE" &&
-            key !== "TMUX_TMPDIR")),
-        PATH: `${binDir}:${dirname(process.execPath)}:${process.env.PATH ?? ""}`,
-        HOME: home,
-        TMUX: "",
-        TMUX_TMPDIR: tmuxTmpDir,
-        TMUX_IDE_HOME: stateDir,
-        TMUX_IDE_DAEMON_INFO_DIR: stateDir,
-        TMUX_IDE_REGISTRY_DIR: stateDir,
-        TMUX_IDE_SETTINGS_DIR: stateDir,
-        TMUX_IDE_CONFIG: join(stateDir, "config.json"),
-        TMUX_IDE_TMUX_BIN: tmuxPath,
-        TMUX_IDE_TMUX_SOCKET_PATH: socketPath,
-        NO_COLOR: "1",
-    };
-    const infoPath = join(stateDir, "daemon.json");
-    const children = new Set();
-    const exits = new Map();
-    const sockets = new Set();
-    const tmux = (...args) => execFileSync(tmuxPath, ["-S", socketPath, ...args], {
-        env,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "pipe"],
-    }).trimEnd();
-    const tmuxStatus = (...args) => spawnSync(tmuxPath, ["-S", socketPath, ...args], { env, stdio: "ignore" }).status ?? -1;
-    const cli = (args) => {
-        const child = spawn(process.execPath, [cliResolved.path, ...args], {
-            cwd: root,
-            env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        children.add(child);
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (chunk) => {
-            stdout = (stdout + chunk).slice(-64000);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr = (stderr + chunk).slice(-64000);
-        });
-        exits.set(child, new Promise((resolve, reject) => {
-            child.once("error", reject);
-            child.once("close", (code, signal) => resolve({ code, signal, stdout, stderr }));
-        }));
-        return child;
-    };
-    const exit = (child) => exits.get(child);
-    const bounded = async (promise, label, ms = 20000) => {
-        let timer;
-        try {
-            return await Promise.race([
-                promise,
-                new Promise((_resolve, reject) => {
-                    timer = setTimeout(() => reject(new Error(`${label} exceeded ${ms}ms`)), ms);
-                }),
-            ]);
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    };
-    const until = async (read, label, ms = 15000) => {
-        const deadline = Date.now() + ms;
-        while (Date.now() < deadline) {
-            const value = read();
-            if (value !== null)
-                return value;
-            await new Promise((resolve) => setTimeout(resolve, 25));
-        }
-        throw new Error(`Timed out after ${ms}ms: ${label}`);
-    };
-    const info = () => {
-        try {
-            return JSON.parse(readFileSync(infoPath, "utf8"));
-        }
-        catch {
-            return null;
-        }
-    };
-    const startDaemon = async () => {
-        const child = cli(["--headless", "--json"]);
-        const published = await Promise.race([
-            until(() => {
-                const value = info();
-                return value?.pid === child.pid ? value : null;
-            }, "daemon record publication"),
-            exit(child).then((result) => {
-                throw new Error(`Daemon exited before publication: ${result.stdout} ${result.stderr}`);
-            }),
-        ]);
-        // The record publishes before the HTTP accept loop is guaranteed up.
-        await until(() => {
-            const probe = spawnSync("curl", [
-                "-s",
-                "-o",
-                "/dev/null",
-                "-w",
-                "%{http_code}",
-                `http://127.0.0.1:${published.port}/health`,
-            ], { encoding: "utf8" });
-            return probe.stdout === "200" ? true : null;
-        }, "daemon health");
-        return { child, info: published };
-    };
-    const headers = (info) => info.authToken ? { authorization: `Bearer ${info.authToken}` } : {};
-    const fetchJson = async (info, path, init = {}) => {
-        const response = await fetch(`http://127.0.0.1:${info.port}${path}`, {
-            ...init,
-            headers: { ...headers(info), "content-type": "application/json", ...(init.headers ?? {}) },
-            signal: AbortSignal.timeout(5000),
-        });
-        return response.json();
-    };
-    const eventsClient = (info) => {
-        const socket = new WsWebSocket(`ws://127.0.0.1:${info.port}/ws/events`, {
-            headers: headers(info),
-        });
-        sockets.add(socket);
-        const frames = [];
-        let resolveReady;
-        let rejectReady;
-        const ready = new Promise((resolve, reject) => {
-            resolveReady = resolve;
-            rejectReady = reject;
-        });
-        ready.catch(() => undefined);
-        const closed = new Promise((resolve) => {
-            socket.once("close", (code) => {
-                sockets.delete(socket);
-                rejectReady(new Error(`events socket closed (${code}) before ready`));
-                resolve(code);
-            });
-        });
-        socket.on("error", (error) => rejectReady(error));
-        socket.on("message", (data) => {
-            let frame;
-            try {
-                frame = JSON.parse(String(data));
-            }
-            catch {
-                return;
-            }
-            frames.push(frame);
-            if (frame.type === "hello") {
-                socket.send(JSON.stringify({
-                    type: "subscribe",
-                    sessions: [],
-                    legacyEvents: true,
-                    interests: [{ resource: "fleet-catalog", workspaceName: null }],
-                    interestRevision: 1,
-                }));
-            }
-            else if (frame.type === "resource.interests-ack") {
-                resolveReady();
-            }
-        });
-        return {
-            frames,
-            ready,
-            closed,
-            close: () => {
-                try {
-                    socket.close();
-                }
-                catch {
-                    // already gone
-                }
-            },
-        };
-    };
-    const logBackfill = async (info) => {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 4000);
-        const entries = [];
-        try {
-            const response = await fetch(`http://127.0.0.1:${info.port}/api/logs/daemon`, {
-                headers: headers(info),
-                signal: controller.signal,
-            });
-            const reader = response.body.getReader();
-            let buffer = "";
-            let sawBookmark = false;
-            while (!sawBookmark) {
-                const { value, done } = await reader.read();
-                if (done)
-                    break;
-                buffer += new TextDecoder().decode(value);
-                let index = buffer.indexOf("\n\n");
-                while (index !== -1) {
-                    const block = buffer.slice(0, index);
-                    buffer = buffer.slice(index + 2);
-                    const event = /^event: (.*)$/mu.exec(block)?.[1];
-                    const data = block
-                        .split("\n")
-                        .filter((line) => line.startsWith("data:"))
-                        .map((line) => line.slice(5).trimStart())
-                        .join("\n");
-                    if (event === "bookmark")
-                        sawBookmark = true;
-                    else if (data) {
-                        try {
-                            const parsed = JSON.parse(data);
-                            if (Array.isArray(parsed))
-                                entries.push(...parsed);
-                            else
-                                entries.push(parsed);
-                        }
-                        catch {
-                            entries.push({ raw: data, event });
-                        }
-                    }
-                    index = buffer.indexOf("\n\n");
-                }
-            }
-            controller.abort();
-        }
-        catch {
-            // aborted after the bookmark or on the deadline; return what arrived
-        }
-        finally {
-            clearTimeout(timer);
-        }
-        return entries;
-    };
-    const stampAgent = (paneId, state) => {
-        tmux("set-option", "-p", "-t", paneId, "@agent_state", `${state}:${Math.floor(Date.now() / 1000)}`);
-    };
-    const evidenceFile = evidencePath();
-    const evidence = (record) => {
-        if (!evidenceFile)
-            return;
-        appendFileSync(evidenceFile, JSON.stringify({ at: new Date().toISOString(), cli: cliResolved.label, ...record }) + "\n");
-    };
-    const cleanup = async () => {
-        for (const socket of sockets) {
-            try {
-                socket.terminate();
-            }
-            catch {
-                // already closed
-            }
-        }
-        const current = info();
-        if (current) {
-            await fetch(`http://127.0.0.1:${current.port}/api/v2/action/daemon.shutdown`, {
-                method: "POST",
-                headers: { ...headers(current), "content-type": "application/json" },
-                body: JSON.stringify({
-                    reason: "live fixture cleanup",
-                    expectedInstanceId: current.instanceId,
-                }),
-                signal: AbortSignal.timeout(5000),
-            }).catch(() => undefined);
-        }
-        for (const child of children)
-            if (child.exitCode === null && child.signalCode === null)
-                child.kill("SIGTERM");
-        await Promise.all([...children].map(async (child) => {
-            try {
-                await bounded(exit(child), "fixture child exit", 10000);
-            }
-            catch {
-                child.kill("SIGKILL");
-                await exit(child).catch(() => undefined);
-            }
-        }));
-        spawnSync(tmuxPath, ["-S", socketPath, "kill-server"], { env, stdio: "ignore" });
-        rmSync(root, { recursive: true, force: true });
-        if (existsSync(root))
-            throw new Error(`fixture root survived cleanup: ${root}`);
-    };
-    return {
-        root,
-        stateDir,
-        socketPath,
-        cliPath: cliResolved.path,
-        cliLabel: cliResolved.label,
-        env,
-        tmux,
-        tmuxStatus,
-        cli,
-        exit,
-        bounded,
-        until,
-        info,
-        startDaemon,
-        eventsClient,
-        fetchJson,
-        logBackfill,
-        stampAgent,
-        evidence,
-        cleanup,
-    };
-}
-/**
- * Prove the plain-`tmux` CLI path and the daemon's pinned socket path name
- * the same server. Requires a running server on the fixture socket.
- */
-export function assertUnifiedSocket(fleet) {
-    const plain = execFileSync("tmux", ["display-message", "-p", "#{socket_path}"], {
-        env: fleet.env,
-        encoding: "utf8",
-    }).trim();
-    const pinned = fleet.tmux("display-message", "-p", "#{socket_path}");
-    if (plain !== fleet.socketPath || pinned !== fleet.socketPath)
-        throw new Error(`socket split: plain=${plain} pinned=${pinned} expected=${fleet.socketPath}`);
-}
-export const uniqueName = (prefix) => `${prefix}-${randomUUID().slice(0, 8)}`;

package/packages/daemon/dist/terminal/__tests__/MockPtyAdapter.js

@@ -1,182 +0,0 @@
-/**
- * MockPtyAdapter — scripted PTY backend for tests (T087).
- *
- * Mirrors the `PtyAdapter` contract but spawns no real processes. Every
- * call to {@link MockPtyAdapter.spawn} or {@link MockPtyAdapter.spawnSync}
- * returns a fresh {@link MockPtyProcess} the test then drives manually via
- * {@link MockPtyProcess.pushOutput} / {@link MockPtyProcess.emitExit}.
- *
- * Drop-in for any layer that takes a `PtyAdapter`. The adapter also keeps
- * a `spawnLog` of every `PtySpawnInput` so tests can assert wiring without
- * inspecting node-pty internals.
- *
- * Why this lives under `__tests__/`: it is purely test infrastructure and
- * MUST NOT be bundled into the production daemon. Vitest's `include`
- * pulls it in implicitly when sibling tests import it.
- */
-import { PtySpawnError, } from "../PtyAdapter.js";
-import { DEFAULT_PTY_INPUT_LIMITS, MonotonicPtyInput } from "../MonotonicPtyInput.js";
-export class MockPtyProcess {
-    pid;
-    /** Append-only log of every `write(...)` call so tests can assert input. */
-    writeLog = [];
-    /** Frames accepted through the fail-closed monotonic capability. */
-    boundedWriteLog = [];
-    /** Append-only log of every `resize(...)` call. */
-    resizeLog = [];
-    /** Records the last signal observed by `kill(...)`. */
-    killed = null;
-    exited = false;
-    dataListeners = new Set();
-    exitListeners = new Set();
-    _input;
-    boundedInput;
-    constructor(pid, input, listeners = {}, inputLimits = DEFAULT_PTY_INPUT_LIMITS) {
-        this.pid = pid;
-        this._input = input;
-        this.boundedInput = new MonotonicPtyInput(inputLimits, (frame) => {
-            this.boundedWriteLog.push(Buffer.from(frame));
-        });
-        if (listeners.onData)
-            this.dataListeners.add(listeners.onData);
-        if (listeners.onExit)
-            this.exitListeners.add(listeners.onExit);
-    }
-    /** Original spawn input — handy for assertions. */
-    get spawnInput() {
-        return this._input;
-    }
-    write(data) {
-        if (this.exited)
-            return;
-        this.writeLog.push(data);
-    }
-    resize(cols, rows) {
-        if (this.exited)
-            return;
-        this.resizeLog.push({ cols, rows });
-    }
-    paused = false;
-    pause() {
-        if (!this.exited)
-            this.paused = true;
-    }
-    resume() {
-        if (!this.exited)
-            this.paused = false;
-    }
-    kill(signal) {
-        if (this.exited)
-            return;
-        this.killed = signal ?? "SIGTERM";
-        this.boundedInput.close();
-        // Synthesize an exit so subscribers detach cleanly — matches the
-        // node-pty fallback inside NodePtyAdapter.
-        this.emitExit({ exitCode: 0, signal: typeof signal === "number" ? signal : null });
-    }
-    onData(callback) {
-        this.dataListeners.add(callback);
-        return () => {
-            this.dataListeners.delete(callback);
-        };
-    }
-    onExit(callback) {
-        if (this.exited)
-            return () => undefined;
-        this.exitListeners.add(callback);
-        return () => {
-            this.exitListeners.delete(callback);
-        };
-    }
-    // ------------------------------------------------------------------
-    // Test-only drivers — never called by production code.
-    // ------------------------------------------------------------------
-    /** Push synthetic PTY output bytes to every `onData` subscriber. */
-    pushOutput(data) {
-        if (this.exited)
-            return;
-        const buf = data instanceof Buffer
-            ? data
-            : typeof data === "string"
-                ? Buffer.from(data, "utf8")
-                : Buffer.from(data);
-        for (const listener of this.dataListeners)
-            listener(buf);
-    }
-    /** Fire the terminal exit event (idempotent — subsequent calls are no-ops). */
-    emitExit(event) {
-        if (this.exited)
-            return;
-        this.exited = true;
-        this.boundedInput.close();
-        const listeners = [...this.exitListeners];
-        this.dataListeners.clear();
-        this.exitListeners.clear();
-        for (const listener of listeners)
-            listener(event);
-    }
-    /** Number of currently attached data listeners — handy for leak assertions. */
-    get dataListenerCount() {
-        return this.dataListeners.size;
-    }
-    /** Number of currently attached exit listeners. */
-    get exitListenerCount() {
-        return this.exitListeners.size;
-    }
-}
-export class MockPtyAdapter {
-    id = "mock";
-    spawnLog = [];
-    spawned = [];
-    nextPid;
-    _failNext;
-    syncUnsupported;
-    boundedInputLimits;
-    constructor(options = {}) {
-        this.nextPid = options.startingPid ?? 100_000;
-        this._failNext = options.failNext;
-        this.syncUnsupported = options.syncUnsupported ?? false;
-        this.boundedInputLimits = options.boundedInputLimits ?? DEFAULT_PTY_INPUT_LIMITS;
-    }
-    /** Arm the next spawn to throw a typed error. */
-    failNext(code, message) {
-        this._failNext = { code, message };
-    }
-    async spawn(input, listeners) {
-        if (this._failNext) {
-            const err = this._failNext;
-            this._failNext = undefined;
-            throw new PtySpawnError({ adapter: this.id, code: err.code, message: err.message });
-        }
-        this.spawnLog.push(input);
-        const proc = new MockPtyProcess(this.nextPid++, input, listeners, this.boundedInputLimits);
-        this.spawned.push(proc);
-        return proc;
-    }
-    spawnSync(input, listeners) {
-        if (this.syncUnsupported) {
-            throw new PtySpawnError({
-                adapter: this.id,
-                code: "sync_unsupported",
-                message: "MockPtyAdapter is configured with syncUnsupported=true",
-            });
-        }
-        if (this._failNext) {
-            const err = this._failNext;
-            this._failNext = undefined;
-            throw new PtySpawnError({ adapter: this.id, code: err.code, message: err.message });
-        }
-        this.spawnLog.push(input);
-        const proc = new MockPtyProcess(this.nextPid++, input, listeners, this.boundedInputLimits);
-        this.spawned.push(proc);
-        return proc;
-    }
-    /** Read-only view of all spawns so tests can assert wiring. */
-    get spawnCount() {
-        return this.spawnLog.length;
-    }
-    /** The most recently spawned mock process, or `null` if there were none. */
-    lastSpawned() {
-        return this.spawned.at(-1) ?? null;
-    }
-}

package/packages/daemon/dist/terminal/mirror/__tests__/scripted-channel.js

@@ -1,98 +0,0 @@
-import { FIXTURE, SimulatedChannel, fixtureAutoReply, fixtureState, } from "./simulated-channel.js";
-/**
- * Scripted wrapper around the real control protocol simulator. It owns the
- * asynchronous capture/cursor choreography and exposes only bounded settling;
- * a broken bootstrap fails immediately instead of leaking a Vitest worker.
- */
-export class ScriptedChannelDriver {
-    channel;
-    #seedLines;
-    #cursorLine;
-    #cursorLinesByPane;
-    #maxTurns;
-    #handledWrites = 0;
-    deferredCommands = [];
-    constructor(handlers, options = {}) {
-        const state = options.state ?? fixtureState();
-        this.#seedLines = options.seedLines ?? ["ready"];
-        this.#cursorLine = options.cursorLine ?? "0 0 100 50";
-        this.#cursorLinesByPane = options.cursorLinesByPane ?? {};
-        this.#maxTurns = options.maxTurns ?? 100;
-        const basic = fixtureAutoReply(state);
-        this.channel = new SimulatedChannel(handlers, (command) => {
-            if (command.startsWith('display-message -p "#{qa:session_name}')) {
-                return basic(command) ?? [];
-            }
-            // This scalar observation is not a deferred cursor probe. Answer it
-            // before an automatic inventory reply can consume its pending FIFO slot.
-            if (isHistorySizeProbe(command))
-                return ["0"];
-            if (command.includes("capture-pane") || command.startsWith("display-message"))
-                return null;
-            return basic(command) ?? [];
-        });
-    }
-    /** Complete every scripted probe written since the prior turn. */
-    pump() {
-        for (let index = this.#handledWrites; index < this.channel.written.length; index += 1) {
-            const command = this.channel.written[index];
-            if (command.startsWith('display-message -p "#{qa:session_name}') ||
-                isHistorySizeProbe(command))
-                continue;
-            if (command.includes("capture-pane") || command.startsWith("display-message")) {
-                this.deferredCommands.push(command);
-            }
-        }
-        this.#handledWrites = this.channel.written.length;
-        while (this.deferredCommands.length > 0) {
-            const command = this.deferredCommands.shift();
-            if (command.includes("capture-pane -p -R"))
-                // The default scripted driver models stock tmux, not malformed native
-                // data. Only explicit unsupported evidence may select portable capture.
-                this.channel.reply(["command capture-pane: unknown flag -R"], false);
-            else if (command.includes("capture-pane"))
-                this.channel.reply([...this.#seedLines]);
-            else {
-                const pane = /-t (%\d+)/u.exec(command)?.[1];
-                this.channel.reply([
-                    pane ? (this.#cursorLinesByPane[pane] ?? this.#cursorLine) : this.#cursorLine,
-                ]);
-            }
-        }
-    }
-    output(runtimePaneId, escapedControlBytes) {
-        this.channel.output(runtimePaneId, escapedControlBytes);
-    }
-    exit(reason = "detached") {
-        this.channel.feedLines(`%exit ${reason}`);
-    }
-    async settleUntil(predicate, label) {
-        for (let turn = 0; turn < this.#maxTurns; turn += 1) {
-            this.pump();
-            // The real replica intentionally defers its first xterm write with a
-            // zero-delay timer. Yielding only through the check phase (`setImmediate`)
-            // can starve that timer for every bounded turn on Linux CI, making a
-            // settled simulator look stuck with no pending control replies. Advance
-            // both timer and check phases so this driver models a complete event-loop
-            // turn rather than relying on platform-specific queue ordering.
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            await new Promise((resolve) => setImmediate(resolve));
-            if (predicate())
-                return;
-        }
-        throw new Error(`Scripted channel did not settle ${label} within ${this.#maxTurns} turns; pending=${this.channel.core.pendingCount}; writes=${this.channel.written.join(" | ")}`);
-    }
-}
-export function standardScriptedChannel(handlers, options) {
-    return new ScriptedChannelDriver(handlers, {
-        state: options?.state ?? {
-            truthRows: [...FIXTURE.truthRows],
-            windowRows: FIXTURE.windowRows(FIXTURE.layoutW1, FIXTURE.layoutW2),
-            descriptorRows: [...FIXTURE.descriptorRows],
-        },
-        ...options,
-    });
-}
-function isHistorySizeProbe(command) {
-    return /^display-message -p -t %\d+ "#\{history_size\}"$/u.test(command);
-}