@selesai/code 0.13.11 → 0.13.13

package/dist/extensions/pi-zentui/test/editor-viewport-indicators.test.ts

@@ -1,1286 +0,0 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { describe, expect, it, vi } from "vitest";
-import {
-	defaultConfig,
-	type EditorStyle,
-	type PolishedTuiConfig,
-} from "../extensions/zentui/config";
-import {
-	PolishedEditor,
-	renderWithAutocompleteCapture,
-	WrappedPolishedEditor,
-} from "../extensions/zentui/ui";
-
-function theme(): Theme {
-	return {
-		fg(_color: string, text: string) {
-			return text;
-		},
-		bold: (text: string) => text,
-		italic: (text: string) => text,
-		underline: (text: string) => text,
-		strikethrough: (text: string) => text,
-		inverse: (text: string) => text,
-	} as Theme;
-}
-
-type EditorOptions = Partial<PolishedTuiConfig["features"]> & {
-	style?: EditorStyle;
-	completionMenu?: "native" | "palette";
-};
-
-function config(
-	options: EditorOptions = {},
-	editorBorderColorMode: PolishedTuiConfig["editorBorderColorMode"] = "static",
-): PolishedTuiConfig {
-	return {
-		...defaultConfig,
-		icons: { ...defaultConfig.icons, mode: "nerd" },
-		components: {
-			...defaultConfig.components,
-			editor: {
-				...defaultConfig.components.editor,
-				enabled: true,
-				style: options.style ?? defaultConfig.components.editor.style,
-				borderColorMode: editorBorderColorMode,
-				viewportIndicators: options.viewportIndicators ?? true,
-				styles: {
-					...defaultConfig.components.editor.styles,
-					opencode: {
-						...defaultConfig.components.editor.styles.opencode,
-						completionMenu: options.completionMenu ?? "palette",
-					},
-					"opencode-copy-friendly": {
-						...defaultConfig.components.editor.styles["opencode-copy-friendly"],
-						completionMenu: options.completionMenu ?? "palette",
-					},
-				},
-			},
-		},
-		features: {
-			...defaultConfig.features,
-			...(options.editor === undefined ? {} : { editor: options.editor }),
-			...(options.statusLine === undefined ? {} : { statusLine: options.statusLine }),
-			...(options.viewportIndicators === undefined
-				? {}
-				: { viewportIndicators: options.viewportIndicators }),
-		},
-	};
-}
-
-function withEditorStyle(
-	base: PolishedTuiConfig,
-	style: PolishedTuiConfig["components"]["editor"]["style"],
-): PolishedTuiConfig {
-	return {
-		...base,
-		components: {
-			...base.components,
-			editor: { ...base.components.editor, style },
-		},
-	};
-}
-
-function nativeBorder(
-	width: number,
-	direction: "above" | "below",
-	count?: number,
-	ansi = false,
-): string {
-	const plain = count
-		? `─── ${direction === "above" ? "↑" : "↓"} ${count} more ${"─".repeat(
-				Math.max(0, width - `─── ↑ ${count} more `.length),
-			)}`
-		: "─".repeat(width);
-	return ansi ? `\x1b[90m${plain}\x1b[0m` : plain;
-}
-
-function baseEditor(options: {
-	above?: number;
-	below?: number;
-	ansi?: boolean;
-	malformedTop?: string;
-	autocomplete?: string[];
-}) {
-	const autocomplete = options.autocomplete ?? [];
-	const autocompleteList = {
-		filteredItems: autocomplete.map((value) => ({ value })),
-		selectedIndex: 0,
-		maxVisible: Math.max(1, autocomplete.length),
-		render: (_width?: number) => autocomplete,
-	};
-	return {
-		render(width: number) {
-			return [
-				options.malformedTop ?? nativeBorder(width, "above", options.above, options.ansi),
-				"typed text",
-				nativeBorder(width, "below", options.below, options.ansi),
-				...(autocomplete.length > 0 ? autocompleteList.render(width) : []),
-			];
-		},
-		invalidate() {},
-		handleInput() {},
-		getText: () => "typed text",
-		setText() {},
-		isShowingAutocomplete: () => autocomplete.length > 0,
-		autocompleteList,
-	};
-}
-
-function wrapped(
-	base: ReturnType<typeof baseEditor> | WrappedPolishedEditor,
-	features: EditorOptions = {},
-	editorBorderColorMode: PolishedTuiConfig["editorBorderColorMode"] = "static",
-): WrappedPolishedEditor {
-	return new WrappedPolishedEditor(
-		base as never,
-		theme(),
-		() => config(features, editorBorderColorMode),
-		() => ({ modelLabel: "model", providerLabel: "provider" }),
-		() => "off",
-	);
-}
-
-function standalone(style: EditorStyle = "opencode"): PolishedEditor {
-	const editor = new PolishedEditor(
-		{ requestRender() {}, terminal: { rows: 24, cols: 80 } } as never,
-		{ borderColor: (text: string) => text, selectList: {} } as never,
-		{} as never,
-		theme(),
-		() => config({ style }),
-		() => ({ modelLabel: "model", providerLabel: "provider" }),
-		() => "off",
-	);
-	editor.setText("typed text");
-	return editor;
-}
-
-const thinkingLevels = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
-type SemanticBorderState = (typeof thinkingLevels)[number] | "shell";
-
-const semanticBorderCodes: Record<SemanticBorderState, number> = {
-	off: 30,
-	minimal: 31,
-	low: 32,
-	medium: 33,
-	high: 34,
-	xhigh: 35,
-	max: 37,
-	shell: 36,
-};
-
-function semanticTheme(): Theme {
-	const base = theme();
-	return {
-		...base,
-		getThinkingBorderColor(level) {
-			const code = semanticBorderCodes[level as (typeof thinkingLevels)[number]] ?? 37;
-			return (text: string) => `\x1b[${code}m${text}\x1b[0m`;
-		},
-		getBashModeBorderColor() {
-			return (text: string) => `\x1b[${semanticBorderCodes.shell}m${text}\x1b[0m`;
-		},
-	} as Theme;
-}
-
-describe("adaptive editor border colors", () => {
-	it("keeps static wrapped-editor rendering independent of Pi's callback", () => {
-		const editor = wrapped(baseEditor({ above: 2, below: 3 }));
-		editor.borderColor = (text) => `\x1b[35m${text}\x1b[0m`;
-
-		const lines = editor.render(80);
-		expect(lines[0]).not.toContain("\x1b[35m");
-		expect(lines.at(-1)).not.toContain("\x1b[35m");
-		expect(lines[0]).toContain("↑ 2 more");
-		expect(lines.at(-1)).toContain("↓ 3 more");
-	});
-
-	it.each(["standalone", "wrapped"] as const)(
-		"follows Pi thinking and shell callback transitions in the %s editor path",
-		(editorKind) => {
-			const piTheme = semanticTheme();
-			let thinkingLevel: (typeof thinkingLevels)[number] = "off";
-			const editor =
-				editorKind === "standalone"
-					? new PolishedEditor(
-							{ requestRender() {}, terminal: { rows: 24, cols: 80 } } as never,
-							{ borderColor: (text: string) => text, selectList: {} } as never,
-							{} as never,
-							piTheme,
-							() => config({}, "adaptive"),
-							() => ({ modelLabel: "model", providerLabel: "provider" }),
-							() => thinkingLevel,
-						)
-					: new WrappedPolishedEditor(
-							baseEditor({ above: 2, below: 3 }) as never,
-							piTheme,
-							() => config({}, "adaptive"),
-							() => ({ modelLabel: "model", providerLabel: "provider" }),
-							() => thinkingLevel,
-						);
-			if (editorKind === "standalone") editor.setText("draft");
-
-			const transitions: SemanticBorderState[] = [...thinkingLevels, "shell", "xhigh", "off"];
-			for (const state of transitions) {
-				if (state === "shell") {
-					editor.borderColor = piTheme.getBashModeBorderColor();
-				} else {
-					thinkingLevel = state;
-					editor.borderColor = piTheme.getThinkingBorderColor(state);
-				}
-
-				const lines = editor.render(80);
-				const expectedCode = semanticBorderCodes[state];
-				for (const border of [lines[0] ?? "", lines.at(-1) ?? ""]) {
-					expect(border).toMatch(new RegExp(`^\\x1b\\[${expectedCode}m`));
-					for (const code of Object.values(semanticBorderCodes)) {
-						if (code !== expectedCode) expect(border).not.toContain(`\x1b[${code}m`);
-					}
-				}
-				expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
-			}
-		},
-	);
-
-	it("does not double-apply adaptive colors through nested branded frames", () => {
-		const inner = wrapped(baseEditor({ above: 3, below: 8 }), {}, "adaptive");
-		inner.borderColor = (text) => `\x1b[32m${text}\x1b[0m`;
-		const outer = wrapped(inner, {}, "adaptive");
-
-		const rendered = outer.render(80).join("\n");
-		expect(rendered.match(/\x1b\[32m/g)).toHaveLength(2);
-		expect(rendered.match(/↑ 3 more/g)).toHaveLength(1);
-		expect(rendered.match(/↓ 8 more/g)).toHaveLength(1);
-		expect(rendered.match(/model/g)).toHaveLength(1);
-	});
-
-	it("preserves low-rail polished viewport layout, clamping, and static fallback", () => {
-		const editor = wrapped(
-			baseEditor({ above: 123456, below: 654321, ansi: true }),
-			{ style: "opencode-copy-friendly" },
-			"adaptive",
-		);
-		editor.borderColor = () => {
-			throw new Error("theme callback failed");
-		};
-
-		const lines = editor.render(12);
-		expect(lines[0]).toContain("↑");
-		expect(lines.at(-1)).toContain("↓");
-		expect(lines.join("\n")).not.toContain("│");
-		expect(lines.every((line) => visibleWidth(line) <= 12)).toBe(true);
-	});
-});
-
-describe("editor viewport indicators", () => {
-	it.each([
-		[7, undefined, "↑ 7 more", undefined],
-		[undefined, 11, undefined, "↓ 11 more"],
-		[7, 11, "↑ 7 more", "↓ 11 more"],
-	] as const)(
-		"preserves top and bottom native counts (above=%s, below=%s)",
-		(above, below, topText, bottomText) => {
-			const lines = wrapped(baseEditor({ above, below, ansi: true })).render(80);
-			if (topText) expect(lines[0]).toContain(topText);
-			else expect(lines[0]).not.toContain("more");
-			if (bottomText) expect(lines.at(-1)).toContain(bottomText);
-			else expect(lines.at(-1)).not.toContain("more");
-		},
-	);
-
-	it("preserves large counts at ample width and clamps them at narrow ANSI-aware widths", () => {
-		const count = 123456789;
-		const editor = wrapped(baseEditor({ above: count, below: count, ansi: true }));
-
-		const ampleLines = editor.render(80);
-		expect(ampleLines[0]).toContain(`↑ ${count} more`);
-		expect(ampleLines.at(-1)).toContain(`↓ ${count} more`);
-
-		const narrowLines = editor.render(12);
-		expect(visibleWidth(narrowLines[0] ?? "")).toBe(12);
-		expect(visibleWidth(narrowLines.at(-1) ?? "")).toBe(12);
-		expect(narrowLines[0]).toContain("↑");
-		expect(narrowLines.at(-1)).toContain("↓");
-		expect(narrowLines[0]).not.toContain(`${count} more`);
-		expect(narrowLines.at(-1)).not.toContain(`${count} more`);
-	});
-
-	it("uses plain polished borders when viewport indicators are disabled", () => {
-		const lines = wrapped(baseEditor({ above: 4, below: 9 }), {
-			viewportIndicators: false,
-		}).render(80);
-		expect(lines[0]).not.toContain("more");
-		expect(lines.at(-1)).not.toContain("more");
-		expect(lines[0]).toMatch(/^─+$/);
-		expect(lines.at(-1)).toMatch(/^─+$/);
-	});
-
-	it("carries counts through nested polished wrappers without double-framing", () => {
-		const inner = wrapped(baseEditor({ above: 3, below: 8 }));
-		const lines = wrapped(inner).render(80);
-		const rendered = lines.join("\n");
-		expect(rendered.match(/↑ 3 more/g)).toHaveLength(1);
-		expect(rendered.match(/↓ 8 more/g)).toHaveLength(1);
-		expect(lines.filter((line) => line.startsWith("───") || /^─+$/.test(line))).toHaveLength(2);
-		expect(rendered.match(/model/g)).toHaveLength(1);
-
-		const narrowLines = wrapped(inner).render(8);
-		expect(narrowLines).toHaveLength(6);
-		expect(narrowLines[0]).toContain("↑");
-		expect(narrowLines.at(-1)).toContain("↓");
-	});
-
-	it.each(["opencode", "opencode-copy-friendly"] as const)(
-		"renders one completion palette through nested %s wrappers",
-		(style) => {
-			const base = baseEditor({ autocomplete: ["→ suggestion-one", "  suggestion-two"] });
-			const renderAutocomplete = base.autocompleteList.render;
-			let calls = 0;
-			base.autocompleteList.render = (width) => {
-				calls += 1;
-				return renderAutocomplete(width);
-			};
-			const inner = wrapped(base, { style });
-			const lines = wrapped(inner, { style }).render(50);
-			const rendered = lines.join("\n");
-			expect(calls).toBe(1);
-			expect(rendered.match(/suggestion-one/g)).toHaveLength(1);
-			expect(rendered.match(/suggestion-two/g)).toHaveLength(1);
-			expect(rendered.match(/↑↓ Navigate/g)).toHaveLength(1);
-			expect(rendered).not.toContain("→ suggestion-one");
-		},
-	);
-
-	it.each(["opencode", "opencode-copy-friendly"] as const)(
-		"keeps ANSI, Unicode, and native count autocomplete rows raw after the terminal bottom border in %s",
-		(style) => {
-			const suggestions = [
-				"\x1b[31msuggestion-one\x1b[0m",
-				"emoji 😀 e\u0301 界",
-				"\x1b[90m (1/47) \x1b[0m",
-			];
-			const lines = wrapped(baseEditor({ below: 5, autocomplete: suggestions }), {
-				style,
-				completionMenu: "native",
-			}).render(80);
-			const bottom = lines.findIndex((line) => line.includes("↓ 5 more"));
-			expect(lines.some((line) => line.includes("├") || line.includes("┤"))).toBe(false);
-			expect(bottom).toBe(lines.length - suggestions.length - 1);
-			expect(lines.slice(bottom + 1)).toEqual(suggestions);
-			expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
-		},
-	);
-
-	it.each(["opencode", "opencode-copy-friendly"] as const)(
-		"renders the default completion palette once without the native count row in %s",
-		(style) => {
-			const suggestions = ["\x1b[1m→ settings\x1b[0m", "  files", "\x1b[90m (1/47) \x1b[0m"];
-			const lines = wrapped(baseEditor({ autocomplete: suggestions }), { style }).render(40);
-			const plain = lines.map((line) => line.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, ""));
-			expect(plain).toContain("  settings".padEnd(40));
-			expect(plain).toContain("  files".padEnd(40));
-			expect(plain.some((line) => line.includes("→"))).toBe(false);
-			expect(plain.some((line) => line.includes("(1/47)"))).toBe(false);
-			expect(plain.at(-1)).toContain("↑↓ Navigate");
-			expect(plain.filter((line) => /^─+$/.test(line.trim()))).toHaveLength(3);
-			expect(lines.every((line) => visibleWidth(line) <= 40)).toBe(true);
-		},
-	);
-
-	it.each(["opencode", "accent-rail"] as const)(
-		"fails open from the same render when a third-party %s editor rewrites captured autocomplete rows",
-		(style) => {
-			for (const mutation of ["replace", "reorder"] as const) {
-				const suggestions = ["→ original-one", "  original-two"];
-				const base = baseEditor({ autocomplete: suggestions });
-				const nativeRender = base.render.bind(base);
-				const widths: number[] = [];
-				let lastOutput: string[] = [];
-				base.render = (width: number) => {
-					widths.push(width);
-					const rendered = nativeRender(width);
-					const editorRows = rendered.slice(0, -suggestions.length);
-					const autocompleteRows = rendered.slice(-suggestions.length);
-					const mutatedRows =
-						mutation === "replace"
-							? ["replacement-one", "replacement-two"]
-							: [...autocompleteRows].reverse();
-					lastOutput = [...editorRows, ...mutatedRows];
-					return lastOutput;
-				};
-
-				const lines = wrapped(base, { style }).render(40);
-				expect(lines).toEqual(lastOutput);
-				expect(widths).toHaveLength(1);
-				expect(widths[0]).toBeLessThan(40);
-				expect(lines.join("\n")).not.toContain("↑↓ Navigate");
-				expect(lines.some((line) => line.startsWith("▎"))).toBe(false);
-			}
-		},
-	);
-
-	it.each([
-		["ASCII spaces", "   ", true],
-		["a tab", "\t", false],
-		["a newline", "\n", false],
-		["a non-breaking space", "\u00a0", false],
-		["a Unicode em space", "\u2003", false],
-	] as const)("treats trailing %s as %s autocomplete padding", (_label, trailing, accepted) => {
-		const suggestions = ["→ original-one", "  original-two"];
-		const base = baseEditor({ autocomplete: suggestions });
-		const nativeRender = base.render.bind(base);
-		const widths: number[] = [];
-		let sameRenderRows: string[] = [];
-		base.render = (width: number) => {
-			widths.push(width);
-			const rendered = nativeRender(width);
-			const editorRows = rendered.slice(0, -suggestions.length);
-			sameRenderRows = [
-				...editorRows,
-				...rendered.slice(-suggestions.length).map((line) => `${line}${trailing}`),
-			];
-			return sameRenderRows;
-		};
-
-		const lines = wrapped(base, { style: "opencode" }).render(40);
-		expect(widths).toHaveLength(1);
-		if (accepted) {
-			expect(lines.join("\n")).toContain("↑↓ Navigate");
-		} else {
-			expect(lines).toEqual(sameRenderRows);
-			expect(lines.join("\n")).not.toContain("↑↓ Navigate");
-		}
-	});
-
-	it.each(["opencode", "accent-rail"] as const)(
-		"preserves same-render %s rows when autocomplete ownership changes during rendering",
-		(style) => {
-			const suggestions = ["→ original-one", "  original-two"];
-			const base = baseEditor({ autocomplete: suggestions });
-			const nativeRender = base.render.bind(base);
-			const replacement = vi.fn(() => ["replacement"]);
-			const widths: number[] = [];
-			let sameRenderRows: string[] = [];
-			base.render = (width: number) => {
-				widths.push(width);
-				sameRenderRows = nativeRender(width);
-				base.autocompleteList.render = replacement;
-				return sameRenderRows;
-			};
-
-			const lines = wrapped(base, { style }).render(40);
-			expect(lines).toEqual(sameRenderRows);
-			expect(widths).toHaveLength(1);
-			expect(replacement).not.toHaveBeenCalled();
-			expect(base.autocompleteList.render).toBe(replacement);
-			expect(lines.join("\n")).not.toContain("↑↓ Navigate");
-			expect(lines.some((line) => line.startsWith("▎"))).toBe(false);
-		},
-	);
-
-	it.each(["opencode", "opencode-copy-friendly"] as const)(
-		"keeps exact no-autocomplete output in %s",
-		(style) => {
-			const ordinary = baseEditor({ below: 2 });
-			const guarded = baseEditor({ below: 2 });
-			guarded.autocompleteList.render = () => {
-				throw new Error("must not inspect an inactive menu");
-			};
-			expect(wrapped(guarded, { style }).render(80)).toEqual(
-				wrapped(ordinary, { style }).render(80),
-			);
-		},
-	);
-
-	it.each(["opencode", "opencode-copy-friendly"] as const)(
-		"keeps raw trailing autocomplete width-safe at widths 5 and 4 in %s",
-		(style) => {
-			for (const width of [5, 4]) {
-				const lines = wrapped(baseEditor({ autocomplete: ["界😀e\u0301"] }), {
-					style,
-					completionMenu: "native",
-				}).render(width);
-				expect(lines.some((line) => line.includes("├") || line.includes("┤"))).toBe(false);
-				expect(lines.at(-2)).toMatch(/^─+$/);
-				expect(visibleWidth(lines.at(-1) ?? "")).toBeLessThanOrEqual(width);
-				expect(lines.every((line) => visibleWidth(line) <= width)).toBe(true);
-			}
-		},
-	);
-
-	it("rerenders standalone Opencode at caller width when reduced-width autocomplete rendering throws", () => {
-		const editor = standalone();
-		let calls = 0;
-		Object.assign(editor as unknown as Record<string, unknown>, {
-			autocompleteState: {},
-			autocompleteList: {
-				render() {
-					calls += 1;
-					if (calls === 1) throw new Error("reduced-width autocomplete failed");
-					return ["caller-width-suggestion"];
-				},
-			},
-		});
-		const lines = editor.render(80);
-		expect(calls).toBe(2);
-		expect(lines.some((line) => line.includes("├"))).toBe(false);
-		expect(lines).toContain("caller-width-suggestion".padEnd(80));
-		expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
-	});
-
-	it("captures standalone Opencode autocomplete from the base render without an extra render", () => {
-		const editor = standalone("opencode-copy-friendly");
-		let calls = 0;
-		Object.assign(editor as unknown as Record<string, unknown>, {
-			autocompleteState: {},
-			autocompleteList: {
-				render() {
-					calls += 1;
-					return calls === 2 ? [] : ["caller-width-suggestion"];
-				},
-			},
-		});
-		const lines = editor.render(80);
-		expect(calls).toBe(1);
-		expect(lines.some((line) => line.includes("├"))).toBe(false);
-		expect(lines.some((line) => line.includes("caller-width-suggestion"))).toBe(true);
-		expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
-	});
-
-	it.each(["opencode", "accent-rail"] as const)(
-		"keeps standalone %s autocomplete to one render when ownership changes",
-		(style) => {
-			const editor = standalone(style);
-			const replacement = vi.fn(() => ["replacement"]);
-			let calls = 0;
-			const autocompleteList = {
-				filteredItems: [{ value: "original" }],
-				selectedIndex: 0,
-				maxVisible: 1,
-				render() {
-					calls += 1;
-					autocompleteList.render = replacement;
-					return ["→ original"];
-				},
-			};
-			Object.assign(editor as unknown as Record<string, unknown>, {
-				autocompleteState: {},
-				autocompleteList,
-			});
-
-			const lines = editor.render(80);
-			expect(calls).toBe(1);
-			expect(replacement).not.toHaveBeenCalled();
-			expect(autocompleteList.render).toBe(replacement);
-			expect(lines.some((line) => line.includes("→ original"))).toBe(true);
-			expect(lines.join("\n")).not.toContain("↑↓ Navigate");
-			expect(lines.some((line) => line.startsWith("▎"))).toBe(false);
-		},
-	);
-
-	it.each([
-		"── ↑ 7 more ─────────",
-		"─── ↓ 7 more ─────────",
-		"─── ↑ 07 more ─────────",
-		"prefix ─── ↑ 7 more ─────────",
-		"[muted]─── ↑ 7 more ─────────[/muted]",
-	])("fails open for an unknown top border form: %s", (malformedTop) => {
-		const lines = wrapped(baseEditor({ below: 2, malformedTop })).render(80);
-		expect(lines[0]).toBe(malformedTop);
-		expect(lines).toContain("typed text");
-		expect(lines.at(-1)).toContain("↓ 2 more");
-	});
-
-	it("preserves every row from a minimal public-contract third-party editor", () => {
-		let text = "draft";
-		const inputs: string[] = [];
-		const base = {
-			render: () => ["third-party header", text, "third-party help"],
-			invalidate() {},
-			handleInput(data: string) {
-				inputs.push(data);
-				text += data;
-			},
-			getText: () => text,
-			setText(next: string) {
-				text = next;
-			},
-		};
-		const editor = wrapped(base as never);
-
-		expect(editor.render(80)).toEqual(["third-party header", "draft", "third-party help"]);
-		editor.handleInput("!");
-		expect(editor.getText()).toBe("draft!");
-		expect(inputs).toEqual(["!"]);
-	});
-
-	it("preserves autocomplete rows when Pi-private inspection fields are absent", () => {
-		const base = {
-			render: (width: number) => [
-				nativeBorder(width, "above"),
-				"typed text",
-				nativeBorder(width, "below"),
-				"suggestion-one",
-				"suggestion-two",
-			],
-			invalidate() {},
-			handleInput() {},
-			getText: () => "typed text",
-			setText() {},
-		};
-
-		const lines = wrapped(base as never).render(80);
-		expect(lines).toContain("typed text");
-		expect(lines).toContain("suggestion-one");
-		expect(lines).toContain("suggestion-two");
-		expect(lines).toHaveLength(5);
-	});
-
-	it.each(["visibility method", "autocomplete getter", "autocomplete render"])(
-		"returns base rows when %s throws",
-		(failure) => {
-			const rendered = ["header", "typed text", "suggestion"];
-			const base: Record<string, unknown> = {
-				render: () => rendered,
-				invalidate() {},
-				handleInput() {},
-				getText: () => "typed text",
-				setText() {},
-			};
-			if (failure === "visibility method") {
-				base.isShowingAutocomplete = () => {
-					throw new Error("visibility failed");
-				};
-			} else {
-				base.isShowingAutocomplete = () => true;
-				if (failure === "autocomplete getter") {
-					Object.defineProperty(base, "autocompleteList", {
-						get() {
-							throw new Error("getter failed");
-						},
-					});
-				} else {
-					base.autocompleteList = {
-						render() {
-							throw new Error("render failed");
-						},
-					};
-				}
-			}
-
-			expect(wrapped(base as never).render(80)).toEqual(rendered);
-		},
-	);
-
-	it("does not trust or invoke a generic editor's spoofed polished-frame splitter", () => {
-		const widths: number[] = [];
-		const spoofedSplit = vi.fn(() => ({
-			editorLines: ["spoofed"],
-			trailingLines: [],
-			viewport: {},
-		}));
-		const base = {
-			render(width: number) {
-				widths.push(width);
-				return [nativeBorder(width, "above"), "typed text", nativeBorder(width, "below")];
-			},
-			invalidate() {},
-			handleInput() {},
-			getText: () => "typed text",
-			setText() {},
-			[Symbol.for("pi-zentui.polished-frame")]: spoofedSplit,
-		};
-		expect(wrapped(base as never).render(80)).toEqual([
-			nativeBorder(78, "above"),
-			"typed text",
-			nativeBorder(78, "below"),
-		]);
-		expect(widths).toEqual([78]);
-		expect(spoofedSplit).not.toHaveBeenCalled();
-	});
-
-	it("fails open for polished-looking rows without exact module-owned array provenance", () => {
-		const trusted = wrapped(baseEditor({ above: 2, below: 3 })).render(80);
-		const staleClone = trusted.slice();
-		const base = {
-			render: () => staleClone,
-			invalidate() {},
-			handleInput() {},
-			getText: () => "typed text",
-			setText() {},
-		};
-
-		const lines = wrapped(base as never).render(80);
-		expect(lines).toEqual(staleClone);
-		expect(lines.join("\n").match(/model/g)).toHaveLength(1);
-	});
-
-	it("rejects in-place mutation of an otherwise provenance-owned rendered array", () => {
-		const rendered = wrapped(baseEditor({ above: 2, below: 3 })).render(80);
-		rendered[1] = "changed-row";
-		rendered.splice(2, 0, "added-row");
-		const base = {
-			render: () => rendered,
-			invalidate() {},
-			handleInput() {},
-			getText: () => "typed text",
-			setText() {},
-		};
-
-		const lines = wrapped(base as never).render(80);
-		expect(lines).toEqual(rendered);
-		expect(lines).toContain("changed-row");
-		expect(lines).toContain("added-row");
-	});
-
-	it("falls back to caller-width rendering when the inner-width probe throws", () => {
-		const widths: number[] = [];
-		const base = {
-			render(width: number) {
-				widths.push(width);
-				if (width < 80) throw new Error("inner-width render failed");
-				return ["caller-width-header", "x".repeat(width + 4), "caller-width-help"];
-			},
-			invalidate() {},
-			handleInput() {},
-			getText: () => "typed text",
-			setText() {},
-		};
-
-		const lines = wrapped(base as never).render(80);
-		expect(widths).toEqual([78, 80]);
-		expect(lines[0]).toBe("caller-width-header");
-		expect(lines.at(-1)).toBe("caller-width-help");
-		expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
-	});
-
-	it("returns unknown third-party output from the completed same-width probe", () => {
-		const widths: number[] = [];
-		const base = {
-			render(width: number) {
-				widths.push(width);
-				return [`header-${width}`, "x".repeat(width + 5), `help-${width}`];
-			},
-			invalidate() {},
-			handleInput() {},
-			getText: () => "typed text",
-			setText() {},
-		};
-
-		const lines = wrapped(base as never).render(80);
-		expect(widths).toEqual([78]);
-		expect(lines[0]).toBe("header-78");
-		expect(lines.at(-1)).toBe("help-78");
-		expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
-	});
-
-	it("only exposes optional editor methods implemented by the base", () => {
-		const withoutCapabilities = wrapped({
-			render: () => ["plain"],
-			invalidate() {},
-			handleInput() {},
-			getText: () => "",
-			setText() {},
-		} as never);
-		for (const method of [
-			"addToHistory",
-			"insertTextAtCursor",
-			"setAutocompleteProvider",
-			"setPaddingX",
-			"setAutocompleteMaxVisible",
-		]) {
-			expect(method in withoutCapabilities).toBe(false);
-		}
-
-		const calls: string[] = [];
-		const withCapabilities = wrapped({
-			render: () => ["plain"],
-			invalidate() {},
-			handleInput() {},
-			getText: () => "",
-			setText() {},
-			addToHistory: () => calls.push("history"),
-			insertTextAtCursor: () => calls.push("insert"),
-			setAutocompleteProvider: () => calls.push("autocomplete"),
-			setPaddingX: () => calls.push("padding"),
-			setAutocompleteMaxVisible: () => calls.push("max-visible"),
-		} as never);
-		withCapabilities.addToHistory?.("history");
-		withCapabilities.insertTextAtCursor?.("insert");
-		withCapabilities.setAutocompleteProvider?.({} as never);
-		withCapabilities.setPaddingX?.(1);
-		withCapabilities.setAutocompleteMaxVisible?.(5);
-		expect(calls).toEqual(["history", "insert", "autocomplete", "padding", "max-visible"]);
-	});
-
-	it("keeps every rendered line within narrow ANSI-aware widths in both chrome modes", () => {
-		for (const style of ["opencode", "opencode-copy-friendly"] as const) {
-			for (const width of [3, 8, 12, 16]) {
-				const lines = wrapped(baseEditor({ above: 12, below: 34, ansi: true }), {
-					style,
-				}).render(width);
-				expect(lines.every((line) => visibleWidth(line) <= width)).toBe(true);
-			}
-		}
-	});
-
-	it("matches Pi's complete native form rather than reconstructing a truncated count", () => {
-		const truncatedNativeTop = truncateToWidth("─── ↑ 12 more ", 10, "");
-		const lines = wrapped(baseEditor({ below: 1, malformedTop: truncatedNativeTop })).render(40);
-		expect(lines[0]).toBe(truncatedNativeTop);
-	});
-});
-
-describe("same-render autocomplete capture", () => {
-	function source(render: (width: number) => string[]) {
-		return {
-			isShowingAutocomplete: () => true,
-			autocompleteList: {
-				filteredItems: [{ value: "one" }],
-				selectedIndex: 0,
-				maxVisible: 1,
-				render,
-			},
-		};
-	}
-
-	it("restores the exact predecessor after descriptor flags mutate", () => {
-		const predecessor = vi.fn(() => ["one"]);
-		const autocomplete = source(predecessor);
-		const original = Object.getOwnPropertyDescriptor(autocomplete.autocompleteList, "render");
-		const result = renderWithAutocompleteCapture(autocomplete as never, () => {
-			const rows = autocomplete.autocompleteList.render(20);
-			const wrapper = autocomplete.autocompleteList.render;
-			Object.defineProperty(autocomplete.autocompleteList, "render", {
-				value: wrapper,
-				configurable: true,
-				enumerable: false,
-				writable: false,
-			});
-			return rows;
-		});
-		expect(result.capture?.compatible).toBe(false);
-		expect(Object.getOwnPropertyDescriptor(autocomplete.autocompleteList, "render")).toEqual(
-			original,
-		);
-		expect(predecessor).toHaveBeenCalledTimes(1);
-	});
-
-	it("preserves a synchronous third-party replacement and suppresses metadata", () => {
-		const autocomplete = source(vi.fn(() => ["one"]));
-		const replacement = vi.fn(() => ["replacement"]);
-		const result = renderWithAutocompleteCapture(autocomplete as never, () => {
-			const rows = autocomplete.autocompleteList.render(20);
-			autocomplete.autocompleteList.render = replacement;
-			return rows;
-		});
-		expect(result.capture?.compatible).toBe(false);
-		expect(autocomplete.autocompleteList.render).toBe(replacement);
-	});
-
-	it("restores through a cleanup descriptor trap when the wrapper is still owned", () => {
-		const predecessor = vi.fn(() => ["one"]);
-		const target = source(predecessor).autocompleteList;
-		let descriptorReads = 0;
-		const proxy = new Proxy(target, {
-			getOwnPropertyDescriptor(current, property) {
-				descriptorReads++;
-				if (descriptorReads === 2) throw new Error("descriptor trap");
-				return Reflect.getOwnPropertyDescriptor(current, property);
-			},
-		});
-		const result = renderWithAutocompleteCapture(
-			{ isShowingAutocomplete: () => true, autocompleteList: proxy } as never,
-			() => proxy.render(20),
-		);
-		expect(result.capture?.compatible).toBe(false);
-		expect(target.render).toBe(predecessor);
-		expect(predecessor).toHaveBeenCalledTimes(1);
-	});
-
-	it.each(["opencode", "accent-rail"] as const)(
-		"fails open from one %s render when inherited-renderer cleanup is rejected",
-		(style) => {
-			const predecessor = vi.fn((_width: number) => ["→ original"]);
-			const target = Object.assign(
-				Object.create({ render: predecessor }) as {
-					render: (width: number) => string[];
-					filteredItems: Array<{ value: string }>;
-					selectedIndex: number;
-					maxVisible: number;
-				},
-				{
-					filteredItems: [{ value: "original" }],
-					selectedIndex: 0,
-					maxVisible: 1,
-				},
-			);
-			const autocompleteList = new Proxy(target, {
-				deleteProperty: () => false,
-			});
-			let renderCalls = 0;
-			let sameRenderRows: string[] = [];
-			const base = {
-				render(width: number) {
-					renderCalls++;
-					sameRenderRows = [
-						nativeBorder(width, "above"),
-						"typed text",
-						nativeBorder(width, "below"),
-						...autocompleteList.render(width),
-					];
-					return sameRenderRows;
-				},
-				invalidate() {},
-				handleInput() {},
-				getText: () => "typed text",
-				setText() {},
-				isShowingAutocomplete: () => true,
-				autocompleteList,
-			};
-
-			const lines = wrapped(base as never, { style }).render(40);
-			expect(lines).toEqual(sameRenderRows);
-			expect(renderCalls).toBe(1);
-			expect(predecessor).toHaveBeenCalledTimes(1);
-			expect(Object.hasOwn(target, "render")).toBe(true);
-			expect(lines.join("\n")).not.toContain("↑↓ Navigate");
-			expect(lines.some((line) => line.startsWith("▎"))).toBe(false);
-		},
-	);
-
-	it("restores after throwing and supports nested capture without extra renders", () => {
-		const predecessor = vi.fn(() => ["one"]);
-		const autocomplete = source(predecessor);
-		const original = autocomplete.autocompleteList.render;
-		expect(() =>
-			renderWithAutocompleteCapture(autocomplete as never, () => {
-				autocomplete.autocompleteList.render(20);
-				throw new Error("render failed");
-			}),
-		).toThrow("render failed");
-		expect(autocomplete.autocompleteList.render).toBe(original);
-
-		predecessor.mockClear();
-		const outer = renderWithAutocompleteCapture(autocomplete as never, () =>
-			renderWithAutocompleteCapture(autocomplete as never, () =>
-				autocomplete.autocompleteList.render(20),
-			),
-		);
-		expect(predecessor).toHaveBeenCalledTimes(1);
-		expect(outer.capture).toMatchObject({ compatible: true, called: 1 });
-		expect(outer.value.capture).toMatchObject({ compatible: true, called: 1 });
-		expect(autocomplete.autocompleteList.render).toBe(original);
-	});
-});
-
-describe("accent rail editor integration", () => {
-	it("decorates trusted wrapped input and autocomplete rows", () => {
-		const editor = wrapped(baseEditor({ autocomplete: ["one", "two"] }), {
-			style: "accent-rail",
-		});
-		const lines = editor.render(24);
-		expect(lines).toHaveLength(3);
-		expect(lines[0]).toMatch(/^▎ typed text/);
-		expect(lines.every((line) => visibleWidth(line) === 24)).toBe(true);
-		expect(lines.slice(1).map((line) => line.trimEnd())).toEqual(["one", "two"]);
-	});
-
-	it("fails open from the reduced same-render rows for untrusted third-party output", () => {
-		const base = baseEditor({ malformedTop: "third-party header" });
-		const editor = wrapped(base, { style: "accent-rail" });
-		const lines = editor.render(24);
-		expect(lines).toEqual(base.render(22));
-		expect(lines.join("\n")).not.toContain("▎");
-	});
-
-	it("renders the standalone editor with the same accent rail", () => {
-		const lines = standalone("accent-rail").render(24);
-		expect(lines.some((line) => line.startsWith("▎ "))).toBe(true);
-		expect(lines.every((line) => visibleWidth(line) <= 24)).toBe(true);
-	});
-});
-
-describe("minimalist editor integration", () => {
-	it("switches renderer modes without replacing the wrapped editor", () => {
-		let current = config();
-		const base = baseEditor({});
-		const editor = new WrappedPolishedEditor(
-			base as never,
-			theme(),
-			() => current,
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-			() => ({ cwd: "/tmp/project", modelLabel: "model", costLabel: "$0.100" }),
-		);
-
-		expect(editor.render(80)[0]).toMatch(/^─+$/);
-		current = withEditorStyle(current, "minimalist");
-		const minimalist = editor.render(80);
-		expect(minimalist[0]).toMatch(/^╭.*╮$/);
-		expect(minimalist.at(-1)).toMatch(/^╰.*╯$/);
-		expect(minimalist.join("\n")).toContain("$0.100 – model");
-	});
-
-	it("cycles one wrapped adapter through every style without nesting owned chrome", () => {
-		let current = config({ style: "opencode" });
-		const rawWidths: number[] = [];
-		const raw = baseEditor({});
-		const rawRender = raw.render.bind(raw);
-		raw.render = (width: number) => {
-			rawWidths.push(width);
-			return rawRender(width);
-		};
-		const inner = new WrappedPolishedEditor(
-			raw as never,
-			theme(),
-			() => config({ style: "opencode" }),
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-		);
-		const decoration = vi.fn();
-		const editor = new WrappedPolishedEditor(
-			inner as never,
-			theme(),
-			() => current,
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-			() => ({ cwd: "/tmp/project", modelLabel: "model", costLabel: "$0.100" }),
-			decoration,
-		);
-
-		const polished = editor.render(40);
-		current = withEditorStyle(current, "opencode-copy-friendly");
-		const lowRail = editor.render(40);
-		current = withEditorStyle(current, "accent-rail");
-		const accentRail = editor.render(40);
-		current = withEditorStyle(current, "minimalist");
-		const minimalist = editor.render(40);
-		current = withEditorStyle(current, "opencode");
-		const polishedAgain = editor.render(40);
-
-		expect(rawWidths).toEqual([36, 38, 36, 34, 36]);
-		expect(polished.join("\n").match(/provider/g)).toHaveLength(1);
-		expect(lowRail.join("\n").match(/provider/g)).toHaveLength(1);
-		expect(accentRail[0]).toMatch(/^▎ typed text/);
-		expect(accentRail.join("\n")).not.toContain("provider");
-		expect(minimalist[0]).toMatch(/^╭.*╮$/);
-		expect(minimalist.at(-1)).toMatch(/^╰.*╯$/);
-		expect(polishedAgain.join("\n").match(/provider/g)).toHaveLength(1);
-		expect(polishedAgain.join("\n")).not.toContain("╭");
-		expect(decoration.mock.calls.map(([active]) => active)).toEqual([
-			false,
-			false,
-			false,
-			true,
-			false,
-		]);
-	});
-
-	it("places native viewport counts at the far left before minimalist metadata", () => {
-		const editor = new WrappedPolishedEditor(
-			baseEditor({ above: 7, below: 11 }) as never,
-			theme(),
-			() => withEditorStyle(config(), "minimalist"),
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-			() => ({
-				cwd: "/tmp/project",
-				branch: "main",
-				ahead: 2,
-				behind: 1,
-				agentDurationMs: 5000,
-			}),
-		);
-
-		const lines = editor.render(80);
-		expect(lines[0]).toMatch(/^╭─ ↑ 7 more · 5s/);
-		expect(lines.at(-1)).toMatch(/^╰─ ↓ 11 more · main ↑2 ↓1/);
-	});
-
-	it("honors the shared viewport indicator toggle in minimalist mode", () => {
-		const editor = new WrappedPolishedEditor(
-			baseEditor({ above: 7, below: 11 }) as never,
-			theme(),
-			() => withEditorStyle(config({ viewportIndicators: false }), "minimalist"),
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-			() => ({ cwd: "/tmp/project" }),
-		);
-
-		expect(editor.render(80).join("\n")).not.toContain("more");
-	});
-
-	it("keeps known autocomplete rows inside the minimalist frame", () => {
-		const base = baseEditor({ below: 5, autocomplete: ["one", "two"] });
-		const editor = new WrappedPolishedEditor(
-			base as never,
-			theme(),
-			() => withEditorStyle(config(), "minimalist"),
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-			() => ({ cwd: "/tmp" }),
-		);
-		const lines = editor.render(40);
-		expect(lines.some((line) => /^├─+┤$/.test(line))).toBe(true);
-		expect(lines.findIndex((line) => line.includes("one"))).toBeGreaterThan(
-			lines.findIndex((line) => line.startsWith("├")),
-		);
-		expect(lines.findIndex((line) => line.includes("one"))).toBeLessThan(lines.length - 1);
-		expect(lines.at(-1)).toContain("↓ 5 more");
-		expect(lines.at(-1)).toMatch(/^╰.*╯$/);
-	});
-
-	it("fails open from the reduced same-render rows for unknown third-party output", () => {
-		const widths: number[] = [];
-		const decoration = vi.fn();
-		const base = {
-			render(width: number) {
-				widths.push(width);
-				return [`header-${width}`, "body", `help-${width}`];
-			},
-			invalidate() {},
-			handleInput() {},
-			getText: () => "body",
-			setText() {},
-		};
-		const editor = new WrappedPolishedEditor(
-			base as never,
-			theme(),
-			() => withEditorStyle(config(), "minimalist"),
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-			() => ({ cwd: "/tmp" }),
-			decoration,
-		);
-		expect(editor.render(40)).toEqual(["header-36", "body", "help-36"]);
-		expect(widths).toEqual([36]);
-		expect(decoration).toHaveBeenLastCalledWith(false);
-	});
-
-	it("unwraps module-owned polished chrome, viewport counts, and autocomplete", () => {
-		const inner = wrapped(baseEditor({ above: 3, below: 8, autocomplete: ["one", "two"] }));
-		const outer = new WrappedPolishedEditor(
-			inner as never,
-			theme(),
-			() => withEditorStyle(config(), "minimalist"),
-			() => ({ modelLabel: "outer", providerLabel: "provider" }),
-			() => "off",
-			() => ({ cwd: "/tmp", modelLabel: "minimal-model" }),
-		);
-
-		const lines = outer.render(80);
-		const rendered = lines.join("\n");
-		expect(lines[0]).toMatch(/^╭.*╮$/);
-		expect(lines.at(-1)).toMatch(/^╰.*╯$/);
-		expect(rendered).toContain("minimal-model");
-		expect(rendered).not.toContain("provider");
-		expect(rendered.match(/minimal-model/g)).toHaveLength(1);
-		expect(rendered.match(/↑ 3 more/g)).toHaveLength(1);
-		expect(rendered.match(/↓ 8 more/g)).toHaveLength(1);
-		expect(lines.some((line) => /^├─+┤$/.test(line))).toBe(true);
-		expect(lines.filter((line) => line.includes("one") || line.includes("two"))).toHaveLength(2);
-	});
-
-	it("rejects mutated module-owned polished provenance in minimalist mode", () => {
-		const owned = wrapped(baseEditor({ above: 2, below: 3 })).render(36);
-		owned[1] = "mutated-row";
-		const base = {
-			render: () => owned,
-			invalidate() {},
-			handleInput() {},
-			getText: () => "typed text",
-			setText() {},
-		};
-		const decoration = vi.fn();
-		const editor = new WrappedPolishedEditor(
-			base as never,
-			theme(),
-			() => withEditorStyle(config(), "minimalist"),
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-			() => ({ cwd: "/tmp" }),
-			decoration,
-		);
-
-		expect(editor.render(40)).toEqual(owned);
-		expect(decoration).toHaveBeenLastCalledWith(false);
-	});
-
-	it("falls back at four columns and decorates after resizing to five", () => {
-		const widths: number[] = [];
-		const decoration = vi.fn();
-		const base = baseEditor({});
-		const renderBase = base.render.bind(base);
-		base.render = (width: number) => {
-			widths.push(width);
-			return renderBase(width);
-		};
-		const editor = new WrappedPolishedEditor(
-			base as never,
-			theme(),
-			() => withEditorStyle(config(), "minimalist"),
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-			() => ({ cwd: "/tmp" }),
-			decoration,
-		);
-
-		const narrow = editor.render(4);
-		expect(narrow[0]).not.toContain("╭");
-		expect(narrow.every((line) => visibleWidth(line) <= 4)).toBe(true);
-		const decorated = editor.render(5);
-		expect(decorated[0]).toMatch(/^╭.*╮$/);
-		expect(decorated.every((line) => visibleWidth(line) <= 5)).toBe(true);
-		expect(widths).toEqual([4, 1]);
-		expect(decoration.mock.calls.map(([active]) => active)).toEqual([false, true]);
-	});
-
-	it("preserves empty, multiline, blank, and inverse-video editor rows", () => {
-		const inverseCursor = "\x1b[7m \x1b[0m";
-		const base = {
-			render: (width: number) => [
-				nativeBorder(width, "above"),
-				"",
-				inverseCursor,
-				"second line",
-				nativeBorder(width, "below"),
-			],
-			invalidate() {},
-			handleInput() {},
-			getText: () => "\nsecond line",
-			setText() {},
-		};
-		const editor = new WrappedPolishedEditor(
-			base as never,
-			theme(),
-			() => withEditorStyle(config(), "minimalist"),
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-			() => ({ cwd: "/tmp" }),
-		);
-		const lines = editor.render(40);
-		expect(lines[1]).toMatch(/^│\s+│$/);
-		expect(lines.join("\n")).toContain(inverseCursor);
-		expect(lines.join("\n")).toContain("second line");
-
-		const empty = new WrappedPolishedEditor(
-			{
-				render: (width: number) => [nativeBorder(width, "above"), nativeBorder(width, "below")],
-				invalidate() {},
-				handleInput() {},
-				getText: () => "",
-				setText() {},
-			} as never,
-			theme(),
-			() => withEditorStyle(config(), "minimalist"),
-			() => ({ modelLabel: "model", providerLabel: "provider" }),
-			() => "off",
-			() => ({ cwd: "/tmp" }),
-		).render(40);
-		expect(empty).toHaveLength(2);
-		expect(empty[0]).toMatch(/^╭.*╮$/);
-		expect(empty[1]).toMatch(/^╰.*╯$/);
-	});
-});