@xynogen/pix-pretty 1.19.0 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-pretty",
-	"version": "1.19.0",
+	"version": "1.20.0",
 	"description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, diff rendering, and FFF search",
 	"type": "module",
 	"main": "src/index.ts",
@@ -25,13 +25,15 @@
 		"./resize": "./src/resize.ts",
 		"./context": "./src/tools/context.ts",
 		"./gate-overlay": "./src/gate-overlay.ts",
-		"./modal-frame": "./src/modal-frame.ts"
+		"./modal-frame": "./src/modal-frame.ts",
+		"./test-utils": "./src/test-utils.ts"
 	},
 	"scripts": {
 		"test": "bun test"
 	},
 	"files": [
 		"src",
+		"!src/**/*.test.*",
 		"README.md",
 		"LICENSE"
 	],

package/src/test-utils.ts

@@ -0,0 +1,100 @@
+// Shared test harness for tool renderers. Test-only — every pix tool package
+// rebuilt these same mocks (MockTextComponent, capture-pi, theme, render ctx)
+// by hand; this collapses them to one import. Pure and Pi-host-agnostic.
+
+import type { CursorStore, FffState } from "./fff.js";
+import type { ToolContext } from "./tools/context.js";
+import type { PiPrettyApi, RenderContextLike, TextComponentCtor, ThemeLike } from "./types.js";
+
+/** In-memory TextComponent: stores text, splits on render. */
+export class MockTextComponent {
+	private text: string;
+	constructor(text = "") {
+		this.text = text;
+	}
+	setText(value: string): void {
+		this.text = value;
+	}
+	getText(): string {
+		return this.text;
+	}
+	render(_width?: number): string[] {
+		return this.text.split("\n");
+	}
+	invalidate(): void {}
+}
+
+/** The tool object a registrar hands to `registerTool`, with the render hooks tests poke. */
+export interface CapturedTool {
+	name?: string;
+	renderCall?: (...args: unknown[]) => MockTextComponent;
+	renderResult?: (...args: unknown[]) => MockTextComponent;
+	[key: string]: unknown;
+}
+
+/**
+ * A PiPrettyApi that captures every registered tool. `tool` is the last one
+ * registered (Object.assign'd so render hooks are directly callable); `names`
+ * lists all registered tool names in order.
+ */
+export function capturePi(): { pi: PiPrettyApi; tool: CapturedTool; names: string[] } {
+	const tool: CapturedTool = {};
+	const names: string[] = [];
+	const pi: PiPrettyApi = {
+		registerTool(t: unknown) {
+			const name = (t as { name?: string }).name;
+			if (name) names.push(name);
+			Object.assign(tool, t);
+		},
+		registerCommand() {},
+		on() {},
+	};
+	return { pi, tool, names };
+}
+
+/** Build the ToolContext every registrar expects; override any field. */
+export function makeToolContext(overrides: Partial<ToolContext> = {}): ToolContext {
+	return {
+		cwd: process.cwd(),
+		sp: (p: string) => p,
+		// SAFETY: MockTextComponent implements the setText/getText/render/invalidate surface
+		// TextComponentCtor requires; the ctor arity differs but callers only use `new C(text)`.
+		TextComponent: MockTextComponent as unknown as TextComponentCtor,
+		fffState: { module: null, finder: null, partialIndex: false, dbDir: null } as FffState,
+		// SAFETY: tool renderers only call store()/get() on the cursor store; this stub covers both.
+		cursorStore: { store: () => "", get: () => undefined } as unknown as CursorStore,
+		...overrides,
+	};
+}
+
+/**
+ * Theme mock. Default is passthrough (`fg`/`bold` return the raw value).
+ * Pass `tag: true` to wrap `dim`/`muted` foregrounds as `<key>value</key>`,
+ * which lets tests assert on visual-hierarchy roles.
+ */
+export function makeTheme({ tag = false }: { tag?: boolean } = {}): ThemeLike {
+	return {
+		fg: (key: string, value: string) =>
+			tag && (key === "dim" || key === "muted") ? `<${key}>${value}</${key}>` : value,
+		bold: (value: string) => value,
+	};
+}
+
+/**
+ * Build a RenderContextLike with sane defaults; override expanded/isError/state/etc.
+ * `state` is intentionally loose (`Record<string, unknown>`) because renderers stash
+ * booleans/numbers/timers there at runtime that the strict `state` type doesn't model.
+ */
+export function makeRenderCtx(
+	overrides: Partial<Omit<RenderContextLike, "state">> & { state?: Record<string, unknown> } = {},
+): RenderContextLike {
+	// SAFETY: loose state bag matches runtime renderer usage; the strict RenderContextLike
+	// state type only lists string keys, but renderers read/write timers and flags there.
+	return {
+		expanded: false,
+		isError: false,
+		invalidate: () => {},
+		state: {},
+		...overrides,
+	} as unknown as RenderContextLike;
+}

package/src/utils.ts

@@ -24,7 +24,7 @@ import type {
 } from "./types.js";
 
 export function renderToolError(error: string, theme: FgTheme): string {
-	return fillToolBackground(`\n${theme.fg("error", error)}`, BG_ERROR);
+	return fillToolBackground(theme.fg("error", error), BG_ERROR);
 }
 
 export function normalizeLineEndings(text: string): string {
@@ -324,8 +324,13 @@ export function renderCollapsedToolRow(
 	target: string,
 	meta = "",
 	status: CollapsedToolStatus = "success",
+	width?: number,
 ): string {
-	return fillToolBackground(formatCollapsedToolRow(theme, tool, target, meta, status));
+	return fillToolBackground(
+		formatCollapsedToolRow(theme, tool, target, meta, status),
+		BG_BASE,
+		width,
+	);
 }
 
 /** Hide renderCall after its paired result has auto-collapsed. */

package/src/ansi.test.ts

@@ -1,12 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as ansi from "./ansi.ts";
-import { resolveBaseBackground } from "./ansi.ts";
-
-describe("tool surfaces", () => {
-	test("always preserves terminal background", () => {
-		resolveBaseBackground({ getBgAnsi: () => "\x1b[48;2;10;20;30m" });
-		expect(ansi.BG_BASE).toBe("\x1b[49m");
-		expect(ansi.BG_ERROR).toBe("\x1b[49m");
-		expect(ansi.RST).toBe("\x1b[0m");
-	});
-});

package/src/dependency-security.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-const repoRoot = dirname(dirname(packageRoot));
-
-interface PackageManifest {
-	dependencies?: Record<string, string>;
-	overrides?: Record<string, string>;
-}
-
-function readManifest(path: string): PackageManifest {
-	try {
-		return JSON.parse(readFileSync(path, "utf8")) as PackageManifest;
-	} catch (cause) {
-		throw new Error(`Unable to read package manifest: ${path}`, { cause });
-	}
-}
-
-describe("dependency security floors", () => {
-	it("uses a jsdiff release without GHSA-73rr-hh4g-fpgx", () => {
-		const manifest = readManifest(join(packageRoot, "package.json"));
-		expect(manifest.dependencies?.diff).toBe("^8.0.3");
-	});
-
-	it("pins protobufjs above GHSA-j3f2-48v5-ccww", () => {
-		const manifest = readManifest(join(repoRoot, "package.json"));
-		expect(manifest.overrides?.protobufjs).toBe("7.6.5");
-	});
-});

package/src/diff.test.ts

@@ -1,117 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { parseDiff } from "./diff.js";
-import {
-	DEFAULT_DIFF_COLORS,
-	diffThemeCacheKey,
-	renderDiffSummary,
-	renderUnified,
-	resolveDiffColors,
-} from "./diff-render.js";
-
-const OLD = "line1\nline2\nline3";
-const NEW = "line1\nCHANGED\nline3";
-const ANSI_RE = /\x1b\[[0-9;]*m|<\/?syntax\w+>/g;
-
-describe("theme-derived diff rendering", () => {
-	const theme = {
-		fg: (key: string, text: string) => `<${key}>${text}</${key}>`,
-		getFgAnsi: (key: string) => {
-			if (key === "toolDiffAdded") return "\x1b[38;2;120;210;150m";
-			if (key === "toolDiffRemoved") return "\x1b[38;2;230;120;130m";
-			if (key === "toolDiffContext") return "\x1b[38;2;130;140;150m";
-			return "";
-		},
-	};
-
-	it("uses semantic foregrounds", () => {
-		const colors = resolveDiffColors(theme);
-		expect(colors.fgAdd).toBe("\x1b[38;2;120;210;150m");
-		expect(colors.fgDel).toBe("\x1b[38;2;230;120;130m");
-		expect(colors.fgCtx).toBe("\x1b[38;2;130;140;150m");
-	});
-
-	// Regression: these six slots were all set to BG_BASE (\x1b[49m), which
-	// dropped the faint green/red row tint and left only the gutter chips
-	// colored. A diff must read as add/remove bands at a glance.
-	it("gives changed rows a faint tint background", () => {
-		for (const colors of [DEFAULT_DIFF_COLORS, resolveDiffColors(theme)]) {
-			for (const key of [
-				"bgAdd",
-				"bgDel",
-				"bgAddHighlight",
-				"bgDelHighlight",
-				"bgGutterAdd",
-				"bgGutterDel",
-			] as const) {
-				expect(colors[key]).not.toBe("\x1b[49m");
-				expect(colors[key]).toMatch(/^\x1b\[48;2;\d+;\d+;\d+m$/);
-			}
-			// Word-diff emphasis must be distinguishable from the row tint.
-			expect(colors.bgAddHighlight).not.toBe(colors.bgAdd);
-			expect(colors.bgDelHighlight).not.toBe(colors.bgDel);
-			// Add and remove must never collide.
-			expect(colors.bgAdd).not.toBe(colors.bgDel);
-		}
-	});
-
-	it("includes semantic theme colors in cache identity", () => {
-		const changed = { ...theme, getFgAnsi: () => "\x1b[38;2;1;2;3m" };
-		expect(diffThemeCacheKey(theme)).not.toBe(diffThemeCacheKey(changed));
-	});
-
-	it("colors persisted plain summaries only at render time", () => {
-		expect(renderDiffSummary("+3 -2", theme)).toBe(
-			"<toolDiffAdded>+3</toolDiffAdded> <toolDiffRemoved>-2</toolDiffRemoved>",
-		);
-		expect(renderDiffSummary("no changes", theme)).toBe(
-			"<toolDiffContext>no changes</toolDiffContext>",
-		);
-	});
-
-	it("emits tint backgrounds on changed rows", async () => {
-		const rendered = await renderUnified(
-			parseDiff("const oldValue = 1;", "const newValue = 2;"),
-			"typescript",
-			80,
-			resolveDiffColors({ ...theme, fg: (_key, text) => text }),
-		);
-		const { bgAdd, bgDel } = resolveDiffColors(theme);
-		expect(rendered).toContain(bgDel);
-		expect(rendered).toContain(bgAdd);
-	});
-
-	it("keeps gutter numbering and rule layout intact", async () => {
-		const rendered = await renderUnified(
-			parseDiff("const oldValue = 1;", "const newValue = 2;"),
-			"typescript",
-			80,
-			resolveDiffColors({ ...theme, fg: (_key, text) => text }),
-		);
-		const lines = rendered.replace(ANSI_RE, "").split("\n");
-
-		expect(lines).toHaveLength(4);
-		expect(lines[0]).toMatch(/^─+$/);
-		expect(lines[1]).toMatch(/^▌\s+1- │ const oldValue = 1;\s*$/);
-		expect(lines[2]).toMatch(/^▌\s+1\+ │ const newValue = 2;\s*$/);
-		expect(lines[3]).toMatch(/^─+$/);
-		expect(rendered).toContain(theme.getFgAnsi("toolDiffRemoved"));
-		expect(rendered).toContain(theme.getFgAnsi("toolDiffAdded"));
-	});
-});
-
-describe("parseDiff baseLine", () => {
-	it("is snippet-relative when baseLine omitted (default 0)", () => {
-		const { lines } = parseDiff(OLD, NEW);
-		const del = lines.find((l) => l.type === "del");
-		expect(del?.oldNum).toBe(2); // line2 is the 2nd line of the snippet
-	});
-
-	it("shifts gutter numbers to absolute when baseLine given", () => {
-		// Snippet begins at file line 84 → snippet line 2 becomes file line 85.
-		const { lines } = parseDiff(OLD, NEW, 3, 84);
-		const del = lines.find((l) => l.type === "del");
-		const add = lines.find((l) => l.type === "add");
-		expect(del?.oldNum).toBe(85);
-		expect(add?.newNum).toBe(85);
-	});
-});

package/src/gate-overlay.test.ts

@@ -1,382 +0,0 @@
-import { describe, expect, jest, test } from "bun:test";
-import { type OverlayUI, showOverlay } from "./gate-overlay.ts";
-import { modalOverlayOptions } from "./modal-frame.ts";
-
-// ── Mock host ─────────────────────────────────────────────────────────────────
-//
-// Drive showOverlay deterministically without a real TUI. The mock invokes the
-// builder callback (so components initialise + wire their handlers), captures
-// the rendered lines, then hands a `drive(comp, done)` hook to the test which
-// triggers selectList.onSelect / maskedInput.onSubmit / etc via the real
-// component instances — exactly what real keyboard input would do.
-
-const theme = {
-	fg: (_c: string, t: string) => t,
-	bg: (_c: string, t: string) => t,
-	bold: (t: string) => t,
-};
-
-interface Wired {
-	render(w: number): string[];
-	invalidate(): void;
-	handleInput(d: string): void;
-}
-
-/**
- * Build a mock UI. `drive` receives the rendered lines and a `feed` fn that
- * pushes raw input strings into the component. To trigger a selection we feed
- * the SelectList keys; simpler: we expose the live component so the test can
- * call its handlers. We do the latter via the captured component ref.
- */
-function makeUI(
-	onReady: (comp: Wired, finish: (v: unknown) => void) => void,
-	onOptions?: (options: unknown) => void,
-	renderTheme = theme,
-): OverlayUI {
-	return {
-		custom: async <T>(
-			cb: (
-				tui: { requestRender(): void },
-				th: typeof theme,
-				kb: unknown,
-				done: (v: T) => void,
-			) => Wired,
-			options?: unknown,
-		): Promise<T | undefined> => {
-			onOptions?.(options);
-			let resolved: T | undefined;
-			const done = (v: T) => {
-				resolved = v;
-			};
-			const comp = cb({ requestRender: () => {} }, renderTheme, undefined, done);
-			comp.render(80); // initialise render path
-			onReady(comp, done as (v: unknown) => void);
-			return resolved;
-		},
-	};
-}
-
-// SelectList handles "\r" (enter) to select the highlighted item, and arrow
-// keys to move. The first item is highlighted by default.
-const ENTER = "\r";
-const DOWN = "\x1b[B";
-
-describe("showOverlay — confirm mode", () => {
-	test("uses configured global overlay bounds", async () => {
-		let options: unknown;
-		await showOverlay(
-			makeUI(
-				(comp) => comp.handleInput(ENTER),
-				(value) => {
-					options = value;
-				},
-			),
-			{ mode: "confirm", title: "T" },
-		);
-		expect(options).toEqual({ overlay: true, overlayOptions: modalOverlayOptions() });
-	});
-
-	test("selecting the approve choice (first) returns approved", async () => {
-		const result = await showOverlay(
-			makeUI((comp) => {
-				comp.handleInput(ENTER); // select item 0 = "yes"
-			}),
-			{ mode: "confirm", title: "T", timeoutMs: 0 },
-		);
-		expect(result.action).toBe("approved");
-		expect(result.password).toBeUndefined();
-	});
-
-	test("selecting the deny choice (second) returns denied", async () => {
-		const result = await showOverlay(
-			makeUI((comp) => {
-				comp.handleInput(DOWN); // move to item 1 = "no"
-				comp.handleInput(ENTER);
-			}),
-			{ mode: "confirm", title: "T", timeoutMs: 0 },
-		);
-		expect(result.action).toBe("denied");
-	});
-
-	test("deny-first ordering: item 0 is the deny choice when configured so", async () => {
-		const result = await showOverlay(
-			makeUI((comp) => {
-				comp.handleInput(ENTER); // select item 0
-			}),
-			{
-				mode: "confirm",
-				title: "Critical",
-				timeoutMs: 0,
-				approveValue: "yes",
-				choices: [
-					{ value: "no", label: "Block", description: "deny" },
-					{ value: "yes", label: "Allow", description: "approve" },
-				],
-			},
-		);
-		// item 0 = "no" => not the approveValue => denied
-		expect(result.action).toBe("denied");
-	});
-
-	test("renders title and body lines", async () => {
-		let captured: string[] = [];
-		await showOverlay(
-			makeUI((comp) => {
-				captured = comp.render(80);
-				comp.handleInput(ENTER);
-			}),
-			{
-				mode: "confirm",
-				title: "MY TITLE",
-				body: ["body-line-x"],
-				timeoutMs: 0,
-			},
-		);
-		const joined = captured.join("\n");
-		expect(joined).toContain("MY TITLE");
-		expect(joined).toContain("body-line-x");
-	});
-
-	test("uses semantic colors for transfer details", async () => {
-		const coloredTheme = {
-			fg: (color: string, text: string) => `<${color}>${text}</${color}>`,
-			bg: (_color: string, text: string) => text,
-			bold: (text: string) => text,
-		};
-		let captured: string[] = [];
-		await showOverlay(
-			makeUI(
-				(comp) => {
-					captured = comp.render(100);
-					comp.handleInput(ENTER);
-				},
-				undefined,
-				coloredTheme,
-			),
-			{
-				mode: "confirm",
-				title: "SSH FILE TRANSFER",
-				body: [
-					"Intent: Copy a release artifact",
-					"Command: scp app.tar.gz host:/tmp",
-					"Host: deploy@example.com",
-					"Direction: Download",
-					"From: /srv/releases/app.tar.gz",
-					"To: /tmp/app.tar.gz",
-					"Mode: Single item",
-					"Warning: existing destination may be overwritten",
-					"Auth: SSH key (no password)",
-				],
-				timeoutMs: 0,
-			},
-		);
-		const joined = captured.join("\n");
-		expect(joined).toContain("<dim>Intent:</dim> <text>Copy a release artifact</text>");
-		expect(joined).toContain("<dim>Command:</dim> <dim>scp app.tar.gz host:/tmp</dim>");
-		expect(joined).toContain("<dim>Host:</dim> <accent>deploy@example.com</accent>");
-		expect(joined).toContain("<dim>Direction:</dim> <warning>Download</warning>");
-		expect(joined).toContain("<dim>From:</dim> <text>/srv/releases/app.tar.gz</text>");
-		expect(joined).toContain("<dim>To:</dim> <accent>/tmp/app.tar.gz</accent>");
-		expect(joined).toContain("<warning>Warning: existing destination may be overwritten</warning>");
-		expect(joined).toContain("<dim>Auth:</dim> <success>SSH key (no password)</success>");
-	});
-
-	// Regression guard (readability fix, pix-pretty 1.18.4): Intent:/Command:
-	// lines must go through the label/value colour map — a <dim> label plus a
-	// semantic value — never a bare bright value with the label stripped off.
-	// Pre-1.18.4 they were sliced and dumped as bright <text> with no label,
-	// which was hard to read on the modal background. Command value must be <dim>.
-	test("Intent/Command body lines keep a dim label and never drop it", async () => {
-		const coloredTheme = {
-			fg: (color: string, text: string) => `<${color}>${text}</${color}>`,
-			bg: (_color: string, text: string) => text,
-			bold: (text: string) => text,
-		};
-		let captured: string[] = [];
-		await showOverlay(
-			makeUI(
-				(comp) => {
-					captured = comp.render(100);
-					comp.handleInput(ENTER);
-				},
-				undefined,
-				coloredTheme,
-			),
-			{
-				mode: "sudo",
-				title: "ROOT COMMAND REQUEST",
-				accent: "error",
-				body: ["Intent: install a package", "Command: apt install foo"],
-				timeoutMs: 0,
-			},
-		);
-		const joined = captured.join("\n");
-		// Command label + value both dim; intent value stays readable text but is
-		// always prefixed by a dim label (never a bare label-less value).
-		expect(joined).toContain("<dim>Command:</dim> <dim>apt install foo</dim>");
-		expect(joined).toContain("<dim>Intent:</dim> <text>install a package</text>");
-		// The pre-1.18.4 bug: label stripped, value dumped bright with no dim label.
-		expect(joined).not.toContain("<text>apt install foo</text>"); // command value is dim, not text
-	});
-
-	test("wraps a long body command instead of truncating it", async () => {
-		// A command far wider than any modal width — must survive in full, wrapped.
-		const longCmd = `echo ${"pix-gate-installed-or-linked ".repeat(8)}done`;
-		let captured: string[] = [];
-		await showOverlay(
-			makeUI((comp) => {
-				captured = comp.render(80);
-				comp.handleInput(ENTER);
-			}),
-			{ mode: "confirm", title: "T", body: [longCmd], timeoutMs: 0 },
-		);
-		// Every whitespace-delimited token of the command appears somewhere in the
-		// frame — nothing was dropped by truncation.
-		const joined = captured.join("\n");
-		for (const tok of longCmd.split(" ")) expect(joined).toContain(tok);
-	});
-});
-
-describe("showOverlay — sudo mode", () => {
-	test("approve then submit password returns approved + real password", async () => {
-		const result = await showOverlay(
-			makeUI((comp) => {
-				comp.handleInput(ENTER); // select item 0 = "yes" => switch to password stage
-				comp.handleInput("s3cret"); // type into MaskedInput
-				comp.handleInput(ENTER); // submit
-			}),
-			{ mode: "sudo", title: "ROOT", timeoutMs: 0 },
-		);
-		expect(result.action).toBe("approved");
-		expect(result.password).toBe("s3cret");
-	});
-
-	test("deny at select stage returns denied, never reaches password", async () => {
-		const result = await showOverlay(
-			makeUI((comp) => {
-				comp.handleInput(DOWN); // item 1 = "no"
-				comp.handleInput(ENTER);
-			}),
-			{ mode: "sudo", title: "ROOT", timeoutMs: 0 },
-		);
-		expect(result.action).toBe("denied");
-		expect(result.password).toBeUndefined();
-	});
-
-	test("wrong password retries inside the same overlay", async () => {
-		let component: Wired | undefined;
-		let overlayCount = 0;
-		const attempts: string[] = [];
-		const ui: OverlayUI = {
-			custom: <T>(cb: Parameters<OverlayUI["custom"]>[0]): Promise<T | undefined> => {
-				overlayCount += 1;
-				return new Promise((resolve) => {
-					component = cb({ requestRender: () => {} }, theme, undefined, (value) =>
-						resolve(value as T),
-					);
-				});
-			},
-		};
-
-		const pending = showOverlay(ui, {
-			mode: "sudo",
-			title: "ROOT",
-			timeoutMs: 0,
-			maxPasswordAttempts: 3,
-			validatePassword: async (password) => {
-				attempts.push(password);
-				return password === "correct";
-			},
-		});
-		component?.handleInput(ENTER);
-		component?.handleInput("wrong");
-		component?.handleInput(ENTER);
-		await new Promise((resolve) => setTimeout(resolve, 0));
-		expect(component?.render(80).join("\n")).toContain("Incorrect password — attempt 1 of 3");
-		component?.handleInput("correct");
-		component?.handleInput(ENTER);
-
-		expect(await pending).toEqual({ action: "approved", password: "correct" });
-		expect(attempts).toEqual(["wrong", "correct"]);
-		expect(overlayCount).toBe(1);
-	});
-
-	test("password is masked in render (● not plaintext)", async () => {
-		let pwFrame: string[] = [];
-		await showOverlay(
-			makeUI((comp) => {
-				comp.handleInput(ENTER); // to password stage
-				comp.handleInput("abc");
-				pwFrame = comp.render(80);
-				comp.handleInput(ENTER); // submit so the promise resolves
-			}),
-			{ mode: "sudo", title: "ROOT", timeoutMs: 0 },
-		);
-		const joined = pwFrame.join("\n");
-		expect(joined).not.toContain("abc");
-		expect(joined).toContain("●");
-	});
-});
-
-// ── Auto-deny timer (dead-man's switch) ───────────────────────────────────────
-//
-// Timer-aware mock: unlike makeUI, this keeps the promise pending and resolves
-// only when `done` fires — so a real setInterval expiry can drive the result.
-// `onReady` gets the live component to optionally feed input before expiry.
-function makeTimerUI(onReady?: (comp: Wired) => void): OverlayUI {
-	return {
-		custom: <T>(
-			cb: (
-				tui: { requestRender(): void },
-				th: typeof theme,
-				kb: unknown,
-				done: (v: T) => void,
-			) => Wired,
-		): Promise<T | undefined> =>
-			new Promise((resolve) => {
-				const comp = cb({ requestRender: () => {} }, theme, undefined, (v) => resolve(v));
-				comp.render(80);
-				onReady?.(comp);
-			}),
-	};
-}
-
-describe("showOverlay — auto-deny timer", () => {
-	test("expires to timeout when left untouched", async () => {
-		jest.useFakeTimers();
-		try {
-			const pending = showOverlay(makeTimerUI(), {
-				mode: "confirm",
-				title: "T",
-				timeoutMs: 1000, // ceil → 1s, fires on first tick
-			});
-			jest.advanceTimersByTime(1000); // fire the auto-deny tick without a real wait
-			const result = await pending;
-			expect(result.action).toBe("timeout");
-		} finally {
-			jest.useRealTimers();
-		}
-	});
-
-	test("first keypress cancels the timer (no auto-deny)", async () => {
-		jest.useFakeTimers();
-		try {
-			let live: Wired | undefined;
-			const pending = showOverlay(
-				makeTimerUI((comp) => {
-					live = comp;
-					comp.handleInput(DOWN); // any key — cancels the dead-man's switch
-				}),
-				{ mode: "confirm", title: "T", timeoutMs: 1000 },
-			);
-			// Advance well past the 1s window. A live timer would have resolved
-			// "timeout"; the keypress cancelled it, so the promise stays pending.
-			jest.advanceTimersByTime(1300);
-			live?.handleInput(ENTER); // now deny explicitly
-			const result = await pending;
-			expect(result.action).toBe("denied");
-		} finally {
-			jest.useRealTimers();
-		}
-	});
-});