@luan.sh/pi-libtui 0.3.8

package/test/editor-theme.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { semanticEditorTheme } from "../src/editor.ts";
+import { tuiTheme } from "../src/index.ts";
+
+describe("semantic editor theme", () => {
+	test("maps every native editor role through pi-libtui tokens", () => {
+		// type-boundary: the test fixture supplies the Pi Theme methods read by tuiTheme.
+		type ThemeFixture = unknown;
+		const theme = {
+			name: "editor-test",
+			getColorMode: () => "truecolor",
+			getFgAnsi: (token: string) =>
+				({
+					accent: "\x1b[38;2;80;120;240m",
+					border: "\x1b[38;2;70;80;100m",
+					dim: "\x1b[38;2;60;65;75m",
+					muted: "\x1b[38;2;90;95;105m",
+					text: "\x1b[38;2;230;230;235m",
+				})[token] ?? "\x1b[39m",
+			getBgAnsi: () => "\x1b[48;2;20;22;28m",
+		} as ThemeFixture as Theme;
+		const colors = tuiTheme(theme);
+		const editor = semanticEditorTheme(theme);
+
+		expect(editor.borderColor("border")).toBe(colors.fg("border", "border"));
+		expect(editor.selectList.selectedPrefix("prefix")).toBe(colors.fg("accent", "prefix"));
+		expect(editor.selectList.selectedText("selected")).toBe(colors.fg("accent", "selected"));
+		expect(editor.selectList.description("description")).toBe(colors.fg("text.muted", "description"));
+		expect(editor.selectList.scrollInfo("scroll")).toBe(colors.fg("text.muted", "scroll"));
+		expect(editor.selectList.noMatch("empty")).toBe(colors.fg("text.muted", "empty"));
+	});
+});

package/test/editor-token-pill.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { parseBackgroundAnsi, tuiTheme } from "../src/color/theme.ts";
+import { renderEditorPasteMarkerPills, renderEditorTokenPills } from "../src/decoration/editor-pills.ts";
+
+const theme = {
+	name: "editor-token-test",
+	getColorMode: () => "truecolor",
+	getFgAnsi: () => "\x1b[38;2;220;220;220m",
+	getBgAnsi: () => "\x1b[48;2;30;34;42m",
+} as never as Theme;
+
+describe("editor token pills", () => {
+	test("chooses a subdued pill surface distinct from a dark editor destination", () => {
+		const destination = "\x1b[48;2;30;34;42m";
+		const rendered = renderEditorPasteMarkerPills([`${destination}[paste #1 +30 lines]\x1b[49m`], 40, theme).lines[0]!;
+		const backgrounds = [...rendered.matchAll(/\x1b\[48;2;\d+;\d+;\d+m/gu)].map((match) => match[0]);
+		expect(backgrounds).toContain(destination);
+		expect(backgrounds).toContain("\x1b[48;2;68;71;78m");
+		expect(stripTerminalSequences(rendered)).toContain("paste #1 +30 lines");
+		expect(parseBackgroundAnsi(backgrounds.find((background) => background !== destination) ?? "")).toBeDefined();
+	});
+
+	test("chooses a subdued pill surface distinct from a light editor destination", () => {
+		const lightTheme = {
+			name: "light-editor-token-test",
+			getColorMode: () => "truecolor",
+			getFgAnsi: () => "\x1b[38;2;25;25;25m",
+			getBgAnsi: () => "\x1b[48;2;235;235;235m",
+		} as never as Theme;
+		const destination = "\x1b[48;2;235;235;235m";
+		const rendered = renderEditorPasteMarkerPills([`${destination}[paste #1 +30 lines]\x1b[49m`], 40, lightTheme)
+			.lines[0]!;
+
+		expect(rendered).toContain("\x1b[48;2;193;193;193m");
+	});
+
+	test("renders a private atomic token without changing the cursor text around it", () => {
+		const token = "\ue100";
+		const rendered = renderEditorTokenPills([`before \x1b[7m${token}\x1b[0m after`], 40, theme, [
+			{ token, label: "Image #1", icon: "view-image", iconTone: { hue: "magenta", shade: 2 } },
+		]).lines[0]!;
+		const plain = stripTerminalSequences(rendered);
+		expect(plain).toContain("before ");
+		expect(plain).toContain("Image #1");
+		expect(plain).toContain(" after");
+		expect(rendered).not.toContain(token);
+		expect(rendered).toContain(tuiTheme(theme).fgAnsi({ hue: "magenta", shade: 2 }));
+		expect(rendered).toContain("\x1b[48;2;68;71;78m");
+	});
+
+	test("lets a feature renderer preserve inverse and destination state", () => {
+		const token = "\ue101";
+		const contexts: Array<{ inverse: boolean; destination: string }> = [];
+		const destination = "\x1b[48;5;22m";
+		const result = renderEditorTokenPills([`${destination}before \x1b[7m${token}\x1b[0m after`], 40, theme, [
+			{
+				token,
+				icon: false,
+				label: "Token",
+				render: ({ content, destinationBackgroundAnsi, inverse }) => {
+					contexts.push({ inverse, destination: destinationBackgroundAnsi });
+					return content.label;
+				},
+			},
+		]);
+		expect(contexts).toEqual([{ inverse: true, destination }]);
+		expect(result.pills).toEqual([{ line: 0, x: 7, width: 5, token }]);
+		expect(stripTerminalSequences(result.lines[0]!)).toContain("before Token after");
+	});
+});

package/test/floating-overlay.test.ts

@@ -0,0 +1,57 @@
+import { expect, test } from "bun:test";
+import { type Component, stripTerminalSequences } from "@earendil-works/pi-tui";
+import { FloatingOverlay } from "../src/overlay/floating.ts";
+
+test("floating overlays own placement and pointer translation", () => {
+	const baseEvents: number[] = [];
+	const overlayEvents: number[] = [];
+	const base = {
+		render: () => ["abcdefgh"],
+		invalidate() {},
+		onMouse: (event: { col: number }) => {
+			baseEvents.push(event.col);
+			return true;
+		},
+	} as Component;
+	const overlay = {
+		render: () => ["XY"],
+		invalidate() {},
+		onMouse: (event: { col: number }) => {
+			overlayEvents.push(event.col);
+			return true;
+		},
+	} as Component;
+	const floating = new FloatingOverlay({ base, overlay, overlayWidth: () => 2 });
+
+	expect(floating.render(8).map(stripTerminalSequences)).toEqual(["abcdefXY"]);
+	expect(floating.onMouse({ type: "press", row: 0, col: 7, button: 0 } as never)).toBe(true);
+	expect(floating.onMouse({ type: "press", row: 0, col: 2, button: 0 } as never)).toBe(true);
+	expect(overlayEvents).toEqual([1]);
+	expect(baseEvents).toEqual([2]);
+});
+
+test("floating overlays can consume outside presses for dismissal", () => {
+	let dismissed = 0;
+	let basePresses = 0;
+	const component = {
+		render: () => ["abcdefgh"],
+		invalidate() {},
+		onMouse: () => {
+			basePresses += 1;
+			return true;
+		},
+	} as Component;
+	const floating = new FloatingOverlay({
+		base: component,
+		overlay: { render: () => ["XY"], invalidate() {} },
+		overlayWidth: () => 2,
+		onOutsidePress: () => {
+			dismissed += 1;
+		},
+	});
+
+	floating.render(8);
+	expect(floating.onMouse({ type: "press", row: 0, col: 2, button: 0 } as never)).toBe(true);
+	expect(dismissed).toBe(1);
+	expect(basePresses).toBe(0);
+});

package/test/folding.test.ts

@@ -0,0 +1,147 @@
+import { expect, test } from "bun:test";
+import { runInNewContext } from "node:vm";
+import {
+	clearFoldingCurrent,
+	ensureFoldingRegistry,
+	FOLD_TARGET_AT_ROW,
+	FOLDING_REGISTRY_KEY,
+	type FoldingRegistry,
+	type FoldTarget,
+	foldTargetAt,
+} from "../src/folding.ts";
+
+function target(): FoldTarget & { openCount: number; closeCount: number; folded: boolean } {
+	return {
+		folded: true,
+		openCount: 0,
+		closeCount: 0,
+		isFolded() {
+			return this.folded;
+		},
+		open() {
+			this.folded = false;
+			this.openCount += 1;
+		},
+		close() {
+			this.folded = true;
+			this.closeCount += 1;
+		},
+	};
+}
+
+test("applies Vim fold operations to an explicitly resolved target and all registered targets", () => {
+	const registry = ensureFoldingRegistry({} as typeof globalThis);
+	const first = target();
+	const second = target();
+	const removeFirst = registry.register(first);
+	const removeSecond = registry.register(second);
+	expect(registry.apply("open", first)).toBe(true);
+	expect(first.folded).toBe(false);
+	expect(second.folded).toBe(true);
+	expect(registry.apply("close-all")).toBe(true);
+	expect(first.closeCount).toBe(1);
+	expect(second.closeCount).toBe(1);
+	expect(registry.apply("open-all")).toBe(true);
+	expect(first.openCount).toBe(2);
+	expect(second.openCount).toBe(1);
+
+	removeFirst();
+	removeSecond();
+	expect(registry.apply("open")).toBe(false);
+});
+
+test("reuses structurally valid hidden state from another JavaScript realm", () => {
+	// type-boundary: node:vm returns values from an isolated realm; the folding registry validator narrows it.
+	type ForeignRealmValue = unknown;
+	const foreignRegistry = runInNewContext(`
+		const state = { targets: [], current: undefined };
+		const registry = {
+			protocol: "pi-libtui/folding/registry/v2",
+			version: 2,
+			register(target) { state.targets.push(target); return () => state.targets.splice(state.targets.indexOf(target), 1); },
+			setCurrent(target) { state.current = state.targets.includes(target) ? target : undefined; },
+			get current() { return state.current; },
+			has(target) { return state.targets.includes(target); },
+			apply(operation, target) {
+				const targets = operation.endsWith("-all") ? [...state.targets] : target ? [target] : state.current ? [state.current] : [];
+				for (const item of targets) operation.startsWith("open") ? item.open() : item.close();
+				return targets.length > 0;
+			},
+		};
+		Object.defineProperty(registry, Symbol.for("pi-libtui/folding/registry-state/v2"), { value: state });
+		registry;
+	`) as ForeignRealmValue as FoldingRegistry;
+	const scope = Object.create(null) as Record<PropertyKey, ForeignRealmValue>;
+	scope[FOLDING_REGISTRY_KEY] = foreignRegistry;
+	const registry = ensureFoldingRegistry(scope as typeof globalThis);
+	const owned = target();
+
+	registry.register(owned);
+	expect(registry).toBe(foreignRegistry);
+	expect(registry.apply("open-all")).toBe(true);
+	expect(owned.folded).toBe(false);
+});
+
+test("replaces a compatible-looking registry with malformed hidden state", () => {
+	const scope = Object.create(null) as Record<PropertyKey, unknown>;
+	const malformed = {
+		protocol: "pi-libtui/folding/registry/v2",
+		version: 2,
+		register: () => () => {},
+		setCurrent() {},
+		has: () => false,
+		apply: () => false,
+	};
+	Object.defineProperty(malformed, Symbol.for("pi-libtui/folding/registry-state/v2"), {
+		value: { targets: [null] },
+	});
+	scope[FOLDING_REGISTRY_KEY] = malformed;
+
+	const registry = ensureFoldingRegistry(scope as typeof globalThis);
+	expect(registry).not.toBe(malformed);
+	expect(registry.apply("open-all")).toBe(false);
+});
+
+test("never guesses a current row from registration order", () => {
+	const registry = ensureFoldingRegistry({} as typeof globalThis);
+	const first = target();
+	const second = target();
+	const removeFirst = registry.register(first);
+	const removeSecond = registry.register(second);
+	expect(registry.current).toBeUndefined();
+	expect(registry.apply("open")).toBe(false);
+	expect(first.openCount).toBe(0);
+	expect(second.openCount).toBe(0);
+	removeFirst();
+	removeSecond();
+});
+
+test("resolves a fold only through explicit rendered-row ownership", () => {
+	const owned = target();
+	const component = {
+		[FOLD_TARGET_AT_ROW](row: number) {
+			return row === 2 ? owned : undefined;
+		},
+	};
+	expect(foldTargetAt(component, 2)).toBe(owned);
+	expect(foldTargetAt(component, 1)).toBeUndefined();
+	expect(foldTargetAt({}, 2)).toBeUndefined();
+});
+
+test("clears only the target that still owns the current row", () => {
+	const scope = {} as typeof globalThis;
+	const registry = ensureFoldingRegistry(scope);
+	const first = target();
+	const second = target();
+	const removeFirst = registry.register(first);
+	const removeSecond = registry.register(second);
+
+	registry.setCurrent(second);
+	clearFoldingCurrent(first, scope);
+	expect(registry.current).toBe(second);
+	clearFoldingCurrent(second, scope);
+	expect(registry.current).toBeUndefined();
+
+	removeFirst();
+	removeSecond();
+});

package/test/harmonious-theme.test.ts

@@ -0,0 +1,23 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { rgb } from "../src/color/palette.ts";
+import { tuiTheme } from "../src/color/theme.ts";
+import { terminalColorsRegistry } from "../src/terminal-colors.ts";
+
+afterEach(() => terminalColorsRegistry().publish(undefined));
+
+describe("harmonious theme", () => {
+	test("generates colors from a measured custom base16 palette", () => {
+		const base16 = Array.from({ length: 16 }, (_, index) => rgb(index * 16, index * 8, index * 4));
+		terminalColorsRegistry().publish({
+			scheme: "dark",
+			indexedPalette: "custom",
+			defaultBackground: base16[0],
+			defaultForeground: base16[15],
+			ansiBase16: base16,
+		});
+		const colors = tuiTheme({ name: "harmonious", getColorMode: () => "truecolor" } as Theme);
+		expect(colors.bgAnsi("surface.base")).toContain("0;0;0m");
+		expect(colors.fgAnsi("accent")).toMatch(/^\x1b\[38;2;/);
+	});
+});

package/test/interaction.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "bun:test";
+import { PointerInteractionController } from "../src/decoration/pointer-interaction.ts";
+import type { TuiMouseEvent, TuiMouseEventType } from "../src/mouse.ts";
+
+interface Target {
+	id: string;
+	text: string;
+	box: { x: number; y: number; width: number; height: number };
+}
+
+function mouse(type: TuiMouseEventType, row: number, col: number, button?: 0 | 1 | 2): TuiMouseEvent {
+	return {
+		type,
+		row,
+		col,
+		screenRow: row,
+		screenCol: col,
+		button,
+		wheel: undefined,
+		shift: false,
+		alt: false,
+		ctrl: false,
+	};
+}
+
+describe("PointerInteractionController", () => {
+	test("tracks current targets and computes their union bounds", () => {
+		const controller = new PointerInteractionController<Target>({
+			key: (target) => target.id,
+			rect: (target) => target.box,
+		});
+		const targets: Target[] = [
+			{ id: "one", text: "one", box: { x: 2, y: 1, width: 3, height: 1 } },
+			{ id: "two", text: "two", box: { x: 8, y: 2, width: 2, height: 2 } },
+		];
+		controller.setTargets(targets);
+
+		expect(controller.targetAt(3, 1)).toBe(targets[0]);
+		expect(controller.targetAt(7, 1)).toBeUndefined();
+		expect(controller.getBounds()).toEqual({ x: 2, y: 1, width: 8, height: 3 });
+	});
+
+	test("activates only a primary click that stays on the pressed target", () => {
+		const controller = new PointerInteractionController<Target>({
+			key: (target) => target.id,
+			rect: (target) => target.box,
+		});
+		const targets: Target[] = [
+			{ id: "one", text: "one", box: { x: 0, y: 0, width: 3, height: 1 } },
+			{ id: "two", text: "two", box: { x: 4, y: 0, width: 3, height: 1 } },
+		];
+		controller.setTargets(targets);
+		const activated: string[] = [];
+		const hover: string[] = [];
+		const handlers = {
+			onHoverChange: (target: Target | undefined) => hover.push(target?.id ?? "none"),
+			onActivate: (target: Target) => activated.push(target.id),
+		};
+
+		expect(controller.handleMouse(mouse("enter", 0, 1), handlers)).toBe(true);
+		controller.handleMouse(mouse("press", 0, 1, 0), handlers);
+		controller.handleMouse(mouse("release", 0, 5, 0), handlers);
+		controller.handleMouse(mouse("press", 0, 1, 1), handlers);
+		controller.handleMouse(mouse("release", 0, 1, 1), handlers);
+		controller.handleMouse(mouse("press", 0, 1, 0), handlers);
+		controller.handleMouse(mouse("release", 0, 1, 0), handlers);
+
+		expect(hover).toEqual(["one"]);
+		expect(activated).toEqual(["one"]);
+	});
+
+	test("clears hover and captured presses when targets leave the frame", () => {
+		const controller = new PointerInteractionController<Target>({
+			key: (target) => target.id,
+			rect: (target) => target.box,
+		});
+		const target: Target = { id: "one", text: "one", box: { x: 0, y: 0, width: 3, height: 1 } };
+		controller.setTargets([target]);
+		controller.handleMouse(mouse("enter", 0, 1));
+		controller.handleMouse(mouse("press", 0, 1, 0));
+		controller.setTargets([]);
+
+		expect(controller.hoveredTarget()).toBeUndefined();
+		expect(controller.getBounds()).toBeUndefined();
+		const activated: string[] = [];
+		controller.handleMouse(mouse("release", 0, 1, 0), { onActivate: (value) => activated.push(value.id) });
+		expect(activated).toEqual([]);
+	});
+
+	test("activates with the target geometry captured on press", () => {
+		const controller = new PointerInteractionController<Target>({
+			key: (target) => target.id,
+			rect: (target) => target.box,
+		});
+		const pressed: Target = { id: "one", text: "pressed", box: { x: 2, y: 1, width: 3, height: 1 } };
+		controller.setTargets([pressed]);
+		controller.handleMouse(mouse("press", 1, 3, 0));
+		controller.setTargets([{ id: "one", text: "rerendered", box: { x: 4, y: 1, width: 3, height: 1 } }]);
+		const activated: Target[] = [];
+		controller.handleMouse(mouse("release", 1, 5, 0), { onActivate: (target) => activated.push(target) });
+
+		expect(activated).toEqual([pressed]);
+	});
+});

package/test/key-icons.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences, visibleWidth } from "@earendil-works/pi-tui";
+import { tuiTheme } from "../src/color/theme.ts";
+import { keyIcon, renderKeyHint } from "../src/decoration/glyphs.ts";
+
+// type-boundary: The test fixture implements only the Theme methods consumed by tuiTheme.
+const theme = {
+	name: "dark",
+	getColorMode: () => "256color",
+	getFgAnsi: () => "\x1b[38;5;245m",
+	getBgAnsi: () => "\x1b[48;5;16m",
+} as unknown as Theme;
+
+describe("key icons", () => {
+	test("maps letters, modifiers, and named keys through Nerd Font glyphs", () => {
+		expect(keyIcon("a", "nerd-fonts")).toBe("󰬈");
+		expect(keyIcon("c", "nerd-fonts")).toBe("󰬊");
+		expect(keyIcon("z", "nerd-fonts")).toBe("󰬡");
+		expect(keyIcon("ctrl+super+alt+shift+c", "nerd-fonts")).toBe("󰘴 󰘳 󰘵 󰘶 󰬊");
+		expect(keyIcon("space", "nerd-fonts")).toBe("󱁐");
+		expect(keyIcon("tab", "nerd-fonts")).toBe("󰌒");
+		expect(keyIcon("return", "nerd-fonts")).toBe("󰌑");
+		expect(keyIcon("backspace", "nerd-fonts")).toBe("󰁮");
+		expect(keyIcon("escape", "nerd-fonts")).toBe("⎋");
+	});
+
+	test("maps portable Unicode hints and keeps unsupported bases literal", () => {
+		expect(keyIcon("a", "unicode")).toBe("🅰");
+		expect(keyIcon("z", "unicode")).toBe("🆉");
+		expect(keyIcon("ctrl+super+alt+shift+c", "unicode")).toBe("⌃ ⌘ ⌥ ⇧ 🅲");
+		expect(keyIcon("space", "unicode")).toBe("␣");
+		expect(keyIcon("f12", "unicode")).toBe("f12");
+		expect(stripTerminalSequences(renderKeyHint(theme, "c", "unicode"))).toBe("🅲︎");
+	});
+
+	test("uses a subdued semantic keycap, contrast foreground, and destination reset", () => {
+		const colors = tuiTheme(theme);
+		const dark = renderKeyHint(theme, "enter", "unicode", colors.color("surface.base"));
+		const light = renderKeyHint(theme, "enter", "unicode", colors.color("text.primary"));
+		expect(stripTerminalSequences(dark)).toBe("⏎");
+		expect(stripTerminalSequences(light)).toBe("⏎");
+		expect(dark).toContain(colors.bgAnsi("badge.neutral"));
+		expect(light).toContain(colors.bgAnsi("badge.neutral"));
+		expect(dark).toContain(colors.bgAnsi(colors.color("surface.base")));
+		expect(dark).toEndWith(colors.bgAnsi(colors.color("surface.base")));
+		expect(light).toEndWith(colors.bgAnsi(colors.color("text.primary")));
+		expect(visibleWidth(dark)).toBe(1);
+		expect(dark).not.toBe(light);
+		for (const destination of [
+			"surface.selected",
+			"badge.neutral",
+			"diff.added",
+			"diff.removed",
+			"diff.hunk",
+		] as const) {
+			const rendered = renderKeyHint(theme, "c", "unicode", colors.color(destination));
+			expect(rendered).toEndWith(colors.bgAnsi(destination));
+			expect(visibleWidth(rendered)).toBe(1);
+		}
+	});
+});

package/test/markdown-code.test.ts

@@ -0,0 +1,24 @@
+import { expect, test } from "bun:test";
+import { markdownCodeRanges } from "../src/content/markdown-code.ts";
+
+test("finds fenced and inline Markdown code without hiding ordinary text", () => {
+	expect(
+		markdownCodeRanges([
+			"before `$inline` after",
+			"```ts",
+			"$fenced",
+			"``` still fenced",
+			"```",
+			"$ordinary",
+			String.raw`escaped \`$ordinary`,
+		]),
+	).toEqual([
+		[{ start: 7, end: 16 }],
+		[{ start: 0, end: 5 }],
+		[{ start: 0, end: 7 }],
+		[{ start: 0, end: 16 }],
+		[{ start: 0, end: 3 }],
+		[],
+		[],
+	]);
+});

package/test/modal-overlay-mount.test.ts

@@ -0,0 +1,94 @@
+import { expect, test } from "bun:test";
+import type { ModalOverlayComponent, ModalOverlayMouseEvent } from "../src/index.ts";
+import { ensureMouseRegistry, getMouseRegistryState } from "../src/mouse/registry.ts";
+import { mountModalOverlay } from "../src/overlay/modal-mount.ts";
+
+test("modal mounts route local component input and own registration disposal", () => {
+	const registry = ensureMouseRegistry(Object.create(null) as typeof globalThis);
+	const pointerEvents: ModalOverlayMouseEvent[] = [];
+	const inputs: string[] = [];
+	let invalidations = 0;
+	let disposals = 0;
+	const component: ModalOverlayComponent = {
+		focused: false,
+		render: (width) => [`width:${width}`],
+		invalidate: () => invalidations++,
+		handleInput: (data) => inputs.push(data),
+		handleMouse: (event) => {
+			pointerEvents.push(event);
+			return true;
+		},
+		dispose: () => disposals++,
+	};
+	const mounted = mountModalOverlay(component, {
+		registry,
+		id: "test.dialog",
+		getRect: () => ({ x: 12, y: 4, width: 20, height: 6 }),
+		getShieldRect: () => ({ x: 0, y: 0, width: 80, height: 24 }),
+	});
+
+	expect(getMouseRegistryState(registry).regions.map(({ id, priority }) => ({ id, priority }))).toEqual([
+		{ id: "test.dialog", priority: 10_000 },
+		{ id: "test.dialog.shield", priority: 9_999 },
+	]);
+	const region = getMouseRegistryState(registry).regions[0]!;
+	expect(
+		region.onMouse({
+			type: "press",
+			row: 2,
+			col: 3,
+			screenRow: 6,
+			screenCol: 15,
+			button: 0,
+			wheel: undefined,
+			shift: false,
+			alt: false,
+			ctrl: false,
+		}),
+	).toBe(true);
+	expect(pointerEvents).toEqual([{ type: "press", row: 2, col: 3, button: 0 }]);
+
+	mounted.focused = true;
+	mounted.handleInput("x");
+	expect(component.focused).toBe(true);
+	expect(mounted.render(17)).toEqual(["width:17"]);
+	mounted.invalidate();
+	expect(inputs).toEqual(["x"]);
+	expect(invalidations).toBe(1);
+
+	mounted.dispose();
+	mounted.dispose();
+	expect(getMouseRegistryState(registry).regions).toEqual([]);
+	expect(disposals).toBe(1);
+});
+
+test("modal mounts leave unsupported pointer phases to the shield", () => {
+	const registry = ensureMouseRegistry(Object.create(null) as typeof globalThis);
+	const component: ModalOverlayComponent = {
+		focused: false,
+		render: () => [],
+		invalidate() {},
+		handleInput() {},
+		handleMouse: () => true,
+	};
+	mountModalOverlay(component, {
+		registry,
+		id: "test.dialog",
+		getRect: () => ({ x: 10, y: 5, width: 20, height: 6 }),
+		getShieldRect: () => ({ x: 0, y: 0, width: 80, height: 24 }),
+	});
+	const [region, shield] = getMouseRegistryState(registry).regions;
+	const event = {
+		row: 1,
+		col: 1,
+		screenRow: 6,
+		screenCol: 11,
+		button: 0 as const,
+		wheel: undefined,
+		shift: false,
+		alt: false,
+		ctrl: false,
+	};
+	expect(region!.onMouse({ ...event, type: "drag" })).toBe(false);
+	expect(shield!.onMouse({ ...event, type: "drag" })).toBe(true);
+});