@luan.sh/pi-libtui 0.3.8

package/test/select-pointer.test.ts

@@ -0,0 +1,369 @@
+import { describe, expect, test } from "bun:test";
+import { initTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import { KeybindingsManager, setKeybindings, stripTerminalSequences, TUI_KEYBINDINGS } from "@earendil-works/pi-tui";
+import { configureTuiAppearance, DEFAULT_TUI_APPEARANCE } from "../src/appearance.ts";
+import { tuiTheme } from "../src/color/theme.ts";
+import { MultiSelect } from "../src/controls/multi-select.ts";
+import { PickerPanel } from "../src/controls/picker-panel.ts";
+import { SearchableSelect } from "../src/controls/searchable-select.ts";
+import type { TuiMouseEvent, TuiMouseEventType } from "../src/mouse.ts";
+
+const theme = {
+	bold: (text: string) => text,
+	fg: (_color: string, text: string) => text,
+	bg: (_color: string, text: string) => text,
+	underline: (text: string) => text,
+} as Theme;
+
+function initializeTui(): void {
+	initTheme("dark", false);
+	setKeybindings(new KeybindingsManager(TUI_KEYBINDINGS));
+}
+
+function mouse(
+	type: TuiMouseEventType,
+	row: number,
+	col = 0,
+	properties: Partial<Pick<TuiMouseEvent, "button" | "wheel">> = {},
+): TuiMouseEvent {
+	return {
+		type,
+		row,
+		col,
+		screenRow: row,
+		screenCol: col,
+		button: undefined,
+		wheel: undefined,
+		shift: false,
+		alt: false,
+		ctrl: false,
+		...properties,
+	};
+}
+
+function click(component: { onMouse(event: TuiMouseEvent): boolean }, row: number, col = 0): void {
+	component.onMouse(mouse("press", row, col, { button: 0 }));
+	component.onMouse(mouse("release", row, col, { button: 0 }));
+}
+
+describe("shared select pointer behavior", () => {
+	test("searchable select clicks select without confirming and Save confirms", () => {
+		initializeTui();
+		const selected: string[] = [];
+		const select = new SearchableSelect({
+			title: "Mode",
+			description: "Choose a mode",
+			options: Array.from({ length: 15 }, (_, index) => ({ value: `mode-${index}`, label: `Mode ${index}` })),
+			theme,
+			onSelect: (value) => selected.push(value),
+			onCancel() {},
+		});
+
+		select.render(60);
+		// Title, description, and the persistent search field occupy rows 0-2.
+		expect(select.onMouse(mouse("move", 5))).toBe(true);
+		const rendered = select.render(60);
+		expect(stripTerminalSequences(rendered[3]!)).toStartWith("→ Mode 0");
+		expect(stripTerminalSequences(rendered[5]!)).toStartWith("  Mode 2");
+		expect(rendered[5]).toContain("\x1b[48;");
+		// Clicking the last visible row must not recenter or confirm it.
+		click(select, 14);
+		expect(selected).toEqual([]);
+		const lines = select.render(60);
+		expect(stripTerminalSequences(lines[14]!)).toStartWith("→ Mode 11");
+		const saveRow = lines.length - 1;
+		const saveColumn = stripTerminalSequences(lines[saveRow]!).indexOf("Save");
+		click(select, saveRow, saveColumn);
+		expect(selected).toEqual(["mode-11"]);
+
+		select.onMouse(mouse("wheel", 14, 0, { wheel: 1 }));
+		select.handleInput("\r");
+		expect(selected).toEqual(["mode-11", "mode-11"]);
+	});
+
+	test("searchable select keeps fixed pointer rows while filtering", () => {
+		initializeTui();
+		const selected: string[] = [];
+		const select = new SearchableSelect({
+			title: "Mode",
+			options: [
+				{ value: "default", label: "Default" },
+				{ value: "minimal", label: "Minimal minimum" },
+			],
+			theme,
+			onSelect: (value) => selected.push(value),
+			onCancel() {},
+		});
+		select.render(40);
+		click(select, 1);
+		for (const character of "min") select.handleInput(character);
+		const filtered = select.render(40);
+		// The search field remains row 1 and the filtered option remains row 2.
+		expect(stripTerminalSequences(filtered[1]!)).toContain("min");
+		expect(stripTerminalSequences(filtered[1]!)).not.toContain("> ");
+		expect(filtered[2]).toContain(tuiTheme(theme).fg("warning", "Min"));
+		expect(filtered[2]).toContain(tuiTheme(theme).fg("warning", "min"));
+		click(select, 2);
+		expect(selected).toEqual([]);
+		const lines = select.render(40);
+		const saveRow = lines.length - 1;
+		click(select, saveRow, stripTerminalSequences(lines[saveRow]!).indexOf("Save"));
+		expect(selected).toEqual(["minimal"]);
+	});
+
+	test("searchable select exposes a mouseable Cancel action", () => {
+		initializeTui();
+		let cancelled = 0;
+		const select = new SearchableSelect({
+			title: "Mode",
+			options: [{ value: "default", label: "Default" }],
+			theme,
+			onSelect() {},
+			onCancel: () => {
+				cancelled += 1;
+			},
+		});
+		const lines = select.render(40);
+		const buttonRow = lines.length - 1;
+		const cancelColumn = stripTerminalSequences(lines[buttonRow]!).indexOf("Cancel");
+		click(select, buttonRow, cancelColumn);
+		expect(cancelled).toBe(1);
+	});
+
+	test("picker panel delegates clipped row geometry, hover, wheel, and explicit Save", () => {
+		initializeTui();
+		const selected: string[] = [];
+		let cancelled = 0;
+		const picker = new PickerPanel({
+			tui: { terminal: { rows: 8 }, requestRender() {} },
+			theme,
+			keybindings: new KeybindingsManager(TUI_KEYBINDINGS),
+			title: "Roles",
+			options: Array.from({ length: 5 }, (_, index) => ({
+				value: `role-${index}`,
+				label: `Role ${index}`,
+				description: `Description ${index}`,
+			})),
+			maxVisible: 2,
+			onSelect: (value) => selected.push(value),
+			onCancel: () => {
+				cancelled += 1;
+			},
+		});
+
+		let lines = picker.render(48);
+		expect(lines).toHaveLength(6);
+		expect(stripTerminalSequences(lines[2]!)).toContain("│ › Role 0  Description 0");
+		expect(stripTerminalSequences(lines[3]!)).toContain("│   Role 1  Description 1");
+		const normalSecondRow = lines[3]!;
+		expect(picker.onMouse(mouse("move", 3, 20))).toBe(true);
+		lines = picker.render(48);
+		expect(lines[3]).not.toBe(normalSecondRow);
+
+		// A secondary-button release never activates a row, and a primary click only selects it.
+		picker.onMouse(mouse("press", 3, 20, { button: 1 }));
+		picker.onMouse(mouse("release", 3, 20, { button: 1 }));
+		expect(selected).toEqual([]);
+		click(picker, 3, 20);
+		expect(selected).toEqual([]);
+		expect(stripTerminalSequences(picker.render(48)[3]!)).toContain("│ › Role 1  Description 1");
+
+		// Wheel scrolls the viewport but leaves the clicked selection unchanged.
+		picker.onMouse(mouse("wheel", 3, 20, { wheel: 1 }));
+		lines = picker.render(48);
+		expect(stripTerminalSequences(lines[2]!)).toContain("│ › Role 1  Description 1");
+		expect(stripTerminalSequences(lines[3]!)).toContain("│   Role 2  Description 2");
+
+		const buttonRow = lines.length - 2;
+		const saveColumn = stripTerminalSequences(lines[buttonRow]!).indexOf("Save");
+		click(picker, buttonRow, saveColumn);
+		expect(selected).toEqual(["role-1"]);
+
+		const cancelColumn = stripTerminalSequences(lines[buttonRow]!).indexOf("Cancel");
+		click(picker, buttonRow, cancelColumn);
+		expect(cancelled).toBe(1);
+	});
+
+	test("picker panel keeps search geometry fixed and clears search before cancelling", () => {
+		initializeTui();
+		const selected: string[] = [];
+		let cancelled = 0;
+		const picker = new PickerPanel({
+			tui: { terminal: { rows: 12 }, requestRender() {} },
+			theme,
+			keybindings: new KeybindingsManager(TUI_KEYBINDINGS),
+			title: "Roles",
+			options: [
+				{ value: "default", label: "Default", description: "General purpose", searchText: "default general" },
+				{ value: "quick", label: "Quick", description: "Time-sensitive", searchText: "quick time-sensitive" },
+			],
+			onSelect: (value) => selected.push(value),
+			onCancel: () => {
+				cancelled += 1;
+			},
+		});
+		picker.focused = true;
+
+		let lines = picker.render(48);
+		click(picker, 1, 4);
+		for (const character of "time-sensitive") picker.handleInput(character);
+		lines = picker.render(48);
+		expect(stripTerminalSequences(lines[1]!)).toContain("time-sensitive");
+		expect(stripTerminalSequences(lines[2]!)).toContain("Quick");
+		expect(stripTerminalSequences(lines[2]!)).not.toContain("Default");
+		click(picker, 2, 20);
+		expect(selected).toEqual([]);
+
+		picker.handleInput("\x1b");
+		expect(stripTerminalSequences(picker.render(48)[2]!)).toContain("Default");
+		expect(cancelled).toBe(0);
+		picker.handleInput("\x1b");
+		expect(cancelled).toBe(1);
+	});
+
+	test("picker panel preserves keyboard parity and restores button destinations after keycaps", () => {
+		initializeTui();
+		const selected: string[] = [];
+		const picker = new PickerPanel({
+			tui: { terminal: { rows: 12 }, requestRender() {} },
+			theme,
+			keybindings: new KeybindingsManager(TUI_KEYBINDINGS),
+			title: "Roles",
+			options: [
+				{ value: "a", label: "Alpha" },
+				{ value: "b", label: "Beta" },
+				{ value: "c", label: "Gamma" },
+			],
+			onSelect: (value) => selected.push(value),
+			onCancel() {},
+		});
+
+		picker.handleInput("j");
+		picker.handleInput("\x1b[B");
+		picker.handleInput("\r");
+		expect(selected).toEqual(["c"]);
+
+		const lines = picker.render(48);
+		const buttonLine = lines.at(-2)!;
+		const colors = tuiTheme(theme);
+		expect(buttonLine).toContain(colors.bgAnsi("action.neutral"));
+		expect(buttonLine).toContain(colors.bgAnsi("action.positive"));
+	});
+
+	test("searchable select keeps help and semantic actions on one compact row", () => {
+		initializeTui();
+		configureTuiAppearance({ iconPack: "nerd-fonts" });
+		const select = new SearchableSelect({
+			title: "Mode",
+			showTitle: false,
+			options: [{ value: "default", label: "Default" }],
+			theme,
+			onSelect() {},
+			onCancel() {},
+		});
+		const lines = select.render(48).map(stripTerminalSequences);
+		expect(lines[0]).toContain(" Filter…");
+		expect(lines.at(-1)).toContain("󰜺 Cancel");
+		expect(lines.at(-1)).toContain(" Save");
+		configureTuiAppearance(DEFAULT_TUI_APPEARANCE);
+	});
+
+	test("multi-select hovers and toggles rendered rows, scrolls, and exposes Save", () => {
+		initializeTui();
+		const saved: string[][] = [];
+		const select = new MultiSelect({
+			title: "Models",
+			options: [
+				{ value: "a", label: "A" },
+				{ value: "b", label: "B" },
+				{ value: "c", label: "C" },
+				{ value: "d", label: "D" },
+				{ value: "e", label: "E" },
+			],
+			value: ["a"],
+			maxHeight: 7,
+			theme,
+			onSave: (value) => saved.push(value),
+			onCancel() {},
+		});
+
+		let lines = select.render(50);
+		const secondOptionRow = lines.findIndex((line) => stripTerminalSequences(line).includes("B"));
+		expect(select.onMouse(mouse("move", secondOptionRow))).toBe(true);
+		expect(stripTerminalSequences(select.render(50)[secondOptionRow]!)).toStartWith("›");
+		click(select, secondOptionRow);
+		select.onMouse(mouse("wheel", secondOptionRow, 0, { wheel: 1 }));
+		const scrolledOptions = select.render(50).slice(2, 5).map(stripTerminalSequences);
+		expect(scrolledOptions[0]).toStartWith("›");
+		expect(scrolledOptions[0]).toContain("B");
+		expect(scrolledOptions.join("\n")).not.toContain(" A");
+
+		lines = select.render(50);
+		const buttonRow = lines.length - 1;
+		const saveColumn = stripTerminalSequences(lines[buttonRow]!).indexOf("Save");
+		click(select, buttonRow, saveColumn);
+		expect(saved).toEqual([["a", "b"]]);
+	});
+
+	test("multi-select description lines share their option's pointer target", () => {
+		initializeTui();
+		const saved: string[][] = [];
+		const select = new MultiSelect({
+			title: "Tools",
+			options: [
+				{ value: "a", label: "Alpha", description: "First tool description." },
+				{ value: "b", label: "Beta", description: "Second tool description that wraps." },
+			],
+			value: [],
+			descriptionLayout: "below",
+			theme,
+			onSave: (value) => saved.push(value),
+			onCancel() {},
+		});
+
+		const lines = select.render(28).map(stripTerminalSequences);
+		const betaRow = lines.findIndex((line) => line.includes("Beta"));
+		const descriptionRow = betaRow + 1;
+		expect(descriptionRow).toBeGreaterThanOrEqual(0);
+		expect(lines.slice(descriptionRow, descriptionRow + 3).join(" ")).toContain("Second tool");
+		click(select, descriptionRow, 8);
+		select.handleInput("\r");
+		expect(saved).toEqual([["b"]]);
+	});
+
+	test("multi-select Cancel button preserves the unsaved-change warning", () => {
+		initializeTui();
+		let cancelled = 0;
+		const select = new MultiSelect({
+			title: "Models",
+			options: [
+				{ value: "a", label: "A" },
+				{ value: "b", label: "B" },
+			],
+			value: ["a"],
+			theme,
+			onSave() {},
+			onCancel: () => {
+				cancelled += 1;
+			},
+		});
+		const initial = select.render(50);
+		click(
+			select,
+			initial.findIndex((line) => stripTerminalSequences(line).includes("B")),
+		);
+
+		let lines = select.render(50);
+		let buttonRow = lines.length - 1;
+		let cancelColumn = stripTerminalSequences(lines[buttonRow]!).indexOf("Cancel");
+		click(select, buttonRow, cancelColumn);
+		expect(cancelled).toBe(0);
+		expect(stripTerminalSequences(select.render(50).join("\n"))).toContain("Unsaved changes");
+
+		lines = select.render(50);
+		buttonRow = lines.length - 1;
+		cancelColumn = stripTerminalSequences(lines[buttonRow]!).indexOf("Cancel");
+		click(select, buttonRow, cancelColumn);
+		expect(cancelled).toBe(1);
+	});
+});

package/test/selectable-list.test.ts

@@ -0,0 +1,258 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import { KeybindingsManager, setKeybindings, stripTerminalSequences, TUI_KEYBINDINGS } from "@earendil-works/pi-tui";
+import { SelectableList } from "../src/controls/selectable-list.ts";
+import type { TuiMouseEvent } from "../src/mouse.ts";
+
+function event(overrides: Partial<TuiMouseEvent>): TuiMouseEvent {
+	return {
+		type: "move",
+		row: 0,
+		col: 0,
+		screenRow: 0,
+		screenCol: 0,
+		button: undefined,
+		wheel: undefined,
+		shift: false,
+		alt: false,
+		ctrl: false,
+		...overrides,
+	};
+}
+
+describe("SelectableList", () => {
+	beforeEach(() => setKeybindings(new KeybindingsManager(TUI_KEYBINDINGS)));
+
+	test("renders multi-line items as complete targets with exact visible geometry", () => {
+		const list = new SelectableList({
+			items: ["Alpha", "Beta", "Gamma"],
+			selectedIndex: 1,
+			maxVisible: 3,
+			renderItem: (item, context) =>
+				context.index === 1 ? [`heading:${context.width}`, `${context.selected ? ">" : " "}${item}`] : item,
+			requestRender() {},
+			onActivate() {},
+		});
+
+		expect(list.render(24)).toEqual(["Alpha", "heading:24", ">Beta"]);
+		expect(list.getGeometry()).toEqual({
+			x: 0,
+			y: 0,
+			width: 24,
+			height: 3,
+			startIndex: 0,
+			startRow: 0,
+			totalRows: 4,
+			items: [
+				{ x: 0, y: 0, width: 24, height: 1, index: 0 },
+				{ x: 0, y: 1, width: 24, height: 2, index: 1 },
+			],
+		});
+	});
+
+	test("bounds rendered lines to the available width", () => {
+		const list = new SelectableList({
+			items: ["long"],
+			renderItem: () => ["123456", "abcdef"],
+			requestRender() {},
+			onActivate() {},
+		});
+
+		expect(list.render(3).map(stripTerminalSequences)).toEqual(["123", "abc"]);
+	});
+
+	test("keyboard wraps selection and confirms the selected item", () => {
+		const changes: Array<[string, number]> = [];
+		const activations: Array<[string, number]> = [];
+		let renders = 0;
+		const list = new SelectableList({
+			items: ["Alpha", "Beta", "Gamma"],
+			renderItem: (item) => item,
+			requestRender: () => {
+				renders += 1;
+			},
+			onSelectionChange: (item, index) => changes.push([item, index]),
+			onActivate: (item, index) => activations.push([item, index]),
+		});
+
+		list.handleInput("k");
+		list.handleInput("\r");
+		list.handleInput("j");
+		expect(changes).toEqual([
+			["Gamma", 2],
+			["Alpha", 0],
+		]);
+		expect(activations).toEqual([["Gamma", 2]]);
+		expect(renders).toBe(2);
+	});
+
+	test("hover and primary click use the full rendered item height", () => {
+		const contexts: Array<{ index: number; hovered: boolean; selected: boolean }> = [];
+		const activations: string[] = [];
+		const changes: string[] = [];
+		const list = new SelectableList({
+			items: ["Alpha", "Beta"],
+			renderItem: (item, context) => {
+				contexts.push({ index: context.index, hovered: context.hovered, selected: context.selected });
+				return item === "Alpha" ? ["Section", item] : item;
+			},
+			requestRender() {},
+			onSelectionChange: (item) => changes.push(item),
+			onActivate: (item) => activations.push(item),
+		});
+
+		list.render(20);
+		expect(list.onMouse(event({ type: "move", row: 1, col: 4 }))).toBe(true);
+		list.render(20);
+		expect(contexts.some((context) => context.index === 0 && context.hovered)).toBe(true);
+		expect(list.onMouse(event({ type: "press", row: 2, col: 4, button: 0 }))).toBe(true);
+		list.render(20);
+		expect(list.onMouse(event({ type: "release", row: 2, col: 4, button: 0 }))).toBe(true);
+		expect(changes).toEqual(["Beta"]);
+		expect(activations).toEqual(["Beta"]);
+	});
+
+	test("can make pointer clicks select-only while Enter still activates", () => {
+		const changes: string[] = [];
+		const activations: string[] = [];
+		const list = new SelectableList({
+			items: ["Alpha", "Beta"],
+			activateOnClick: false,
+			renderItem: (item) => item,
+			requestRender() {},
+			onSelectionChange: (item) => changes.push(item),
+			onActivate: (item) => activations.push(item),
+		});
+
+		list.render(20);
+		list.onMouse(event({ type: "press", row: 1, col: 4, button: 0 }));
+		list.onMouse(event({ type: "release", row: 1, col: 4, button: 0 }));
+		expect(changes).toEqual(["Beta"]);
+		expect(activations).toEqual([]);
+		list.handleInput("\r");
+		expect(activations).toEqual(["Beta"]);
+	});
+
+	test("excludes decorative lines and leading columns from a semantic row target", () => {
+		const activations: string[] = [];
+		const list = new SelectableList({
+			items: ["Terminal images"],
+			renderItem: (item) => ({
+				before: ["Terminal & Images | Terminal & Images"],
+				leading: "                    | ",
+				content: item,
+			}),
+			requestRender() {},
+			onActivate: (item) => activations.push(item),
+		});
+
+		expect(list.render(60)).toEqual(["Terminal & Images | Terminal & Images", "                    | Terminal images"]);
+		expect(list.getGeometry()?.items).toEqual([{ x: 22, y: 1, width: 38, height: 1, index: 0 }]);
+		expect(list.onMouse(event({ type: "move", row: 0, col: 2 }))).toBe(false);
+		expect(list.onMouse(event({ type: "press", row: 1, col: 2, button: 0 }))).toBe(false);
+		list.onMouse(event({ type: "press", row: 1, col: 24, button: 0 }));
+		list.onMouse(event({ type: "release", row: 1, col: 24, button: 0 }));
+		expect(activations).toEqual(["Terminal images"]);
+	});
+
+	test("keeps every content line in a structured row selectable", () => {
+		const activations: string[] = [];
+		const list = new SelectableList({
+			items: ["Theme"],
+			renderItem: (item) => ({
+				before: ["Appearance", "──────────"],
+				content: [item, "Color theme used by Pi."],
+			}),
+			requestRender() {},
+			onActivate: (item) => activations.push(item),
+		});
+
+		expect(list.render(30)).toEqual(["Appearance", "──────────", "Theme", "Color theme used by Pi."]);
+		expect(list.getGeometry()?.items).toEqual([{ x: 0, y: 2, width: 30, height: 2, index: 0 }]);
+		expect(list.onMouse(event({ type: "move", row: 1, col: 2 }))).toBe(false);
+		list.onMouse(event({ type: "press", row: 3, col: 2, button: 0 }));
+		list.onMouse(event({ type: "release", row: 3, col: 2, button: 0 }));
+		expect(activations).toEqual(["Theme"]);
+	});
+
+	test("can restrict pointer interaction to one control inside a multi-line row", () => {
+		const activations: string[] = [];
+		const list = new SelectableList({
+			items: ["Theme"],
+			renderItem: (item) => ({
+				before: ["──────────"],
+				content: [`${item}             Dark`, "Color theme used by Pi."],
+				target: { x: 18, y: 0, width: 4, height: 1 },
+			}),
+			requestRender() {},
+			onActivate: (item) => activations.push(item),
+		});
+
+		list.render(30);
+		expect(list.getGeometry()?.items).toEqual([{ x: 18, y: 1, width: 4, height: 1, index: 0 }]);
+		expect(list.onMouse(event({ type: "move", row: 2, col: 2 }))).toBe(false);
+		list.onMouse(event({ type: "press", row: 1, col: 19, button: 0 }));
+		list.onMouse(event({ type: "release", row: 1, col: 19, button: 0 }));
+		expect(activations).toEqual(["Theme"]);
+	});
+
+	test("wheel scrolls the line-budget viewport without changing selection", () => {
+		const changes: number[] = [];
+		const list = new SelectableList({
+			items: ["A", "B", "C", "D"],
+			maxVisible: 2,
+			renderItem: (item) => item,
+			requestRender() {},
+			onSelectionChange: (_item, index) => changes.push(index),
+			onActivate() {},
+		});
+
+		list.render(10);
+		list.onMouse(event({ type: "wheel", row: 0, col: 0, wheel: 1 }));
+		expect(list.render(10)).toEqual(["B", "C"]);
+		expect(list.getGeometry()?.startIndex).toBe(1);
+		list.onMouse(event({ type: "wheel", row: 1, col: 0, wheel: 1 }));
+		expect(list.render(10)).toEqual(["C", "D"]);
+		expect(list.getSelectedIndex()).toBe(0);
+		expect(changes).toEqual([]);
+
+		list.handleInput("j");
+		expect(list.render(10)).toEqual(["B", "C"]);
+		expect(list.getSelectedIndex()).toBe(1);
+		expect(changes).toEqual([1]);
+	});
+
+	test("external item and selection synchronization is silent", () => {
+		const changes: string[] = [];
+		let renders = 0;
+		const list = new SelectableList({
+			items: ["A", "B", "C"],
+			renderItem: (item) => item,
+			requestRender: () => {
+				renders += 1;
+			},
+			onSelectionChange: (item) => changes.push(item),
+			onActivate() {},
+		});
+
+		list.setSelectedIndex(2);
+		list.setItems(["X", "Y"], 1);
+		expect(list.getSelectedIndex()).toBe(1);
+		expect(list.getSelectedItem()).toBe("Y");
+		expect(changes).toEqual([]);
+		expect(renders).toBe(2);
+	});
+
+	test("updates its line budget for responsive parent layouts", () => {
+		const list = new SelectableList({
+			items: ["A", "B", "C"],
+			maxVisible: 3,
+			renderItem: (item) => item,
+			requestRender() {},
+			onActivate() {},
+		});
+
+		expect(list.render(10)).toEqual(["A", "B", "C"]);
+		list.setMaxVisible(2);
+		expect(list.render(10)).toEqual(["A", "B"]);
+	});
+});

package/test/selection/registry.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import { ensureSelectionRegistry } from "../../src/selection.ts";
+
+describe("selection registry", () => {
+	test("publishes to optional listeners and disposes by identity", () => {
+		const scope = Object.create(null) as typeof globalThis;
+		const registry = ensureSelectionRegistry(scope);
+		const rows: number[] = [];
+		const remove = registry.onSelectionCompleted((selection) => rows.push(selection.logical.start.row));
+		registry.publishSelectionCompleted({
+			text: "selected",
+			shape: "character",
+			logical: { start: { row: 3, col: 0 }, end: { row: 3, col: 8 } },
+			screen: { start: { row: 3, col: 0 }, end: { row: 3, col: 8 } },
+		});
+		expect(rows).toEqual([3]);
+		remove();
+		registry.publishSelectionCompleted({
+			text: "ignored",
+			shape: "line",
+			logical: { start: { row: 4, col: 0 }, end: { row: 4, col: 8 } },
+			screen: { start: { row: 4, col: 0 }, end: { row: 4, col: 8 } },
+		});
+		expect(rows).toEqual([3]);
+	});
+
+	test("isolates action listener failures and reports whether one handled the request", async () => {
+		const registry = ensureSelectionRegistry(Object.create(null) as typeof globalThis);
+		registry.onSelectionAction(() => {
+			throw new Error("optional listener failed");
+		});
+		registry.onSelectionAction(async () => true);
+
+		await expect(
+			registry.publishSelectionAction({
+				action: "selection.comment",
+				text: "selected",
+				shape: "character",
+				logical: { start: { row: 1, col: 0 }, end: { row: 1, col: 8 } },
+				screen: { start: { row: 1, col: 0 }, end: { row: 1, col: 8 } },
+			}),
+		).resolves.toBe(true);
+	});
+});