@luan.sh/pi-libtui 0.3.8

package/test/pointer-components.test.ts

@@ -0,0 +1,151 @@
+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 { TabBar } from "../src/controls/tab.ts";
+import type { TuiMouseEvent } from "../src/mouse.ts";
+import { DialogOverlay } from "../src/overlay/dialog.ts";
+import { FullscreenOverlay } from "../src/overlay/fullscreen.ts";
+
+const theme = {
+	fg: (_color: string, text: string) => text,
+	bg: (_color: string, text: string) => `\x1b[7m${text}\x1b[27m`,
+} as Theme;
+
+function mouse(type: TuiMouseEvent["type"], row: number, col: number, button?: 0 | 1 | 2): TuiMouseEvent {
+	return {
+		type,
+		row,
+		col,
+		screenRow: row + 10,
+		screenCol: col + 20,
+		button,
+		wheel: undefined,
+		shift: false,
+		alt: false,
+		ctrl: false,
+	};
+}
+
+describe("structural pointer components", () => {
+	test("fullscreen overlay translates through its border and safely delegates to its child", () => {
+		const events: TuiMouseEvent[] = [];
+		const child = {
+			render: () => ["content"],
+			invalidate() {},
+			onMouse(event: TuiMouseEvent) {
+				events.push(event);
+				return true;
+			},
+		};
+		const overlay = new FullscreenOverlay(
+			{ terminal: { rows: 5 }, requestRender() {} } as never,
+			theme,
+			child,
+			"Title",
+		);
+		overlay.render(10);
+
+		expect(overlay.onMouse(mouse("move", 2, 3))).toBe(true);
+		expect(events[0]).toMatchObject({ row: 1, col: 2, screenRow: 12, screenCol: 23 });
+		expect(overlay.onMouse(mouse("move", 0, 3))).toBe(false);
+		expect(overlay.onMouse(mouse("press", 0, 3, 0))).toBe(true);
+		expect(events).toHaveLength(1);
+		expect(overlay.onMouse(mouse("leave", 0, 0))).toBe(true);
+		expect(events[1]).toMatchObject({ type: "leave", row: -1, col: -1 });
+
+		const brokenChild = {
+			render: () => [],
+			invalidate() {},
+			onMouse: () => {
+				throw new Error("boom");
+			},
+		};
+		const broken = new FullscreenOverlay({ terminal: { rows: 5 }, requestRender() {} } as never, theme, brokenChild);
+		broken.render(10);
+		expect(broken.onMouse(mouse("move", 1, 1))).toBe(false);
+		expect(broken.onMouse(mouse("press", 1, 1, 0))).toBe(true);
+		overlay.dispose();
+		broken.dispose();
+	});
+
+	test("dialog overlay translates pointer input through its frame", () => {
+		const events: TuiMouseEvent[] = [];
+		const child = {
+			render: () => ["one", "two"],
+			invalidate() {},
+			onMouse(event: TuiMouseEvent) {
+				events.push(event);
+				return true;
+			},
+		};
+		const dialog = new DialogOverlay(theme, child);
+		dialog.render(12);
+
+		expect(dialog.onMouse(mouse("move", 2, 4))).toBe(true);
+		expect(events[0]).toMatchObject({ row: 1, col: 3 });
+		expect(dialog.onMouse(mouse("move", 0, 4))).toBe(false);
+		expect(dialog.onMouse(mouse("move", 3, 4))).toBe(false);
+	});
+
+	test("tab bar uses exact visible spans for hover and primary-button release", () => {
+		const selected: string[] = [];
+		const tabs = new TabBar(
+			[
+				{ id: "a", label: "A" },
+				{ id: "b", label: "Longer" },
+			],
+			theme,
+		);
+		tabs.onChange = (tab) => selected.push(tab.id);
+		const initial = tabs.render(9)[0]!;
+
+		expect(visibleWidth(initial)).toBe(9);
+		expect(stripTerminalSequences(initial)).toContain("A");
+		expect(stripTerminalSequences(initial)).toContain("Long");
+		expect(tabs.onMouse(mouse("move", 0, 8))).toBe(true);
+		expect(tabs.render(9)[0]).not.toBe(initial);
+		expect(tabs.onMouse(mouse("release", 0, 8, 1))).toBe(true);
+		expect(selected).toEqual([]);
+		expect(tabs.onMouse(mouse("release", 0, 8, 0))).toBe(true);
+		expect(selected).toEqual(["b"]);
+		expect(tabs.onMouse(mouse("release", 0, 9, 0))).toBe(false);
+		expect(selected).toEqual(["b"]);
+		expect(tabs.onMouse(mouse("leave", 0, 0))).toBe(false);
+	});
+
+	test("tab bar closes tabs without confusing close with tab selection", () => {
+		const selected: string[] = [];
+		const closed: string[] = [];
+		const tabs = new TabBar([{ id: "side", label: "Side" }], theme);
+		tabs.onChange = (tab) => selected.push(tab.id);
+		tabs.onClose = (tab) => closed.push(tab.id);
+		tabs.render(20);
+
+		expect(tabs.onMouse(mouse("release", 0, 1, 0))).toBe(true);
+		expect(tabs.onMouse(mouse("release", 0, 6, 0))).toBe(true);
+		expect(selected).toEqual([]);
+		expect(closed).toEqual(["side"]);
+	});
+
+	test("tab bar drags tabs into a new order and highlights only the close foreground", () => {
+		const moved: Array<{ id: string; from: number; to: number }> = [];
+		const tabs = new TabBar(
+			[
+				{ id: "one", label: "One" },
+				{ id: "two", label: "Two" },
+			],
+			theme,
+		);
+		tabs.onMove = (tab, from, to) => moved.push({ id: tab.id, from, to });
+		tabs.onClose = () => {};
+		const normal = tabs.render(30)[0]!;
+		tabs.onMouse(mouse("move", 0, 5));
+		const closeHovered = tabs.render(30)[0]!;
+		expect(Bun.stripANSI(closeHovered)).toBe(Bun.stripANSI(normal));
+		expect(closeHovered).not.toBe(normal);
+		tabs.onMouse(mouse("press", 0, 2, 0));
+		tabs.onMouse({ ...mouse("drag", 0, 10, 0), button: 0 });
+		tabs.onMouse(mouse("release", 0, 10, 0));
+		expect(moved).toEqual([{ id: "one", from: 0, to: 1 }]);
+	});
+});

package/test/progress.test.ts

@@ -0,0 +1,54 @@
+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 { ActivityIndicator, ProgressBar, progressFrame } from "../src/decoration/status.ts";
+
+const theme = {
+	name: "progress-test",
+	getColorMode: () => "truecolor",
+	getFgAnsi: () => "\x1b[38;2;180;180;180m",
+	getBgAnsi: () => "\x1b[48;2;20;20;20m",
+} as never as Theme;
+
+describe("bounded progress rendering", () => {
+	test("rejects control and wide custom glyphs that break the cell contract", () => {
+		const frame = progressFrame(tuiTheme(theme), {
+			width: 4,
+			value: 0.5,
+			filled: "界",
+			empty: "\n",
+		});
+
+		expect(visibleWidth(frame)).toBe(4);
+		expect(stripTerminalSequences(frame)).toBe("━━──");
+	});
+
+	test("applies global animation speed to indeterminate progress", () => {
+		const colors = tuiTheme(theme);
+		const slow = progressFrame(colors, { width: 8, elapsedMs: 140, animationSpeed: "slow" });
+		const fast = progressFrame(colors, { width: 8, elapsedMs: 140, animationSpeed: "fast" });
+
+		expect(stripTerminalSequences(slow)).not.toBe(stripTerminalSequences(fast));
+		expect(visibleWidth(slow)).toBe(8);
+		expect(visibleWidth(fast)).toBe(8);
+	});
+
+	test("sanitizes activity and progress labels into one component row", () => {
+		const activity = new ActivityIndicator({
+			theme,
+			label: "build\nnext\x1b]52;c;secret\x07",
+			detail: "phase\r2",
+			spinnerFrames: ["界"],
+			requestRender() {},
+			reducedMotion: true,
+		});
+		const progress = new ProgressBar({ theme, value: 0.5, label: "one\ntwo" });
+
+		for (const line of [...activity.render(80), ...progress.render(80)]) {
+			expect(stripTerminalSequences(line)).not.toMatch(/[\n\r]/u);
+			expect(visibleWidth(line)).toBeLessThanOrEqual(80);
+		}
+		activity.dispose();
+	});
+});

package/test/pty-host.test.ts

@@ -0,0 +1,126 @@
+import { expect, test } from "bun:test";
+import type { TerminalBridgeClient } from "../src/terminal/bridge-client.ts";
+import { createPtyHost } from "../src/terminal/pty-host.ts";
+
+test("owns PTY execution without a feature-extension provider", async () => {
+	const requests: Record<string, unknown>[] = [];
+	let finishRead: ((response: unknown) => void) | undefined;
+	const bridge: TerminalBridgeClient = {
+		request<T>(request: Record<string, unknown>): Promise<T> {
+			requests.push(request);
+			if (request.op === "read")
+				return new Promise<T>((resolve) => {
+					finishRead = resolve as (response: unknown) => void;
+				});
+			if (request.op === "write") return Promise.resolve({ status: "accepted" } as T);
+			return Promise.resolve({} as T);
+		},
+		shutdown: async () => {},
+	};
+	const host = createPtyHost({
+		bridge,
+		createProcessId: () => "process-1",
+		environment: { PATH: "/test/bin" },
+	});
+	const processId = await host.spawn({ command: "pi --tui-mode fullscreen", cwd: "/tmp/project" });
+
+	expect(requests[0]).toMatchObject({
+		op: "exec",
+		process_id: processId,
+		argv: ["/bin/sh", "-c", "pi --tui-mode fullscreen"],
+		cwd: "/tmp/project",
+		tty: true,
+		pipe_stdin: true,
+		env: { PATH: "/test/bin", TERM: "xterm-256color", COLORTERM: "truecolor" },
+	});
+	expect(requests.find((request) => request.op === "read")?.wait_ms).toBe(30_000);
+	expect(await host.resize(processId, 120, 40)).toBe(true);
+	expect(await host.resize(processId, 120, 40)).toBe(true);
+	expect(await host.sendInput(processId, "hello")).toBe(true);
+	expect(requests).toContainEqual({ op: "resize", process_id: processId, rows: 40, cols: 120 });
+	expect(requests.filter((request) => request.op === "resize")).toHaveLength(1);
+	expect(requests).toContainEqual({
+		op: "write",
+		process_id: processId,
+		chunk: "hello",
+	});
+
+	const exited = new Promise<void>((resolve) => {
+		const unsubscribe = host.subscribe(processId, () => {
+			if (host.isRunning(processId)) return;
+			unsubscribe();
+			resolve();
+		});
+	});
+	finishRead?.({ chunks: [], nextSeq: 1, exited: true, closed: true });
+	await exited;
+	expect(host.isRunning(processId)).toBe(false);
+	await host.shutdown();
+});
+
+test("does not publish process completion before the projected tail is parsed", async () => {
+	const reads: Array<(response: unknown) => void> = [];
+	const bridge: TerminalBridgeClient = {
+		request<T>(request: Record<string, unknown>): Promise<T> {
+			if (request.op !== "read") return Promise.resolve({} as T);
+			return new Promise<T>((resolve) => reads.push(resolve as (response: unknown) => void));
+		},
+		shutdown: async () => {},
+	};
+	const host = createPtyHost({ bridge, createProcessId: () => "process-1", environment: {} });
+	const processId = await host.spawn({ command: "output", cwd: "/tmp" });
+	reads.shift()?.({
+		chunks: [{ seq: 1, stream: "pty", chunk: Buffer.from("prefix").toString("base64") }],
+		nextSeq: 2,
+		exited: false,
+		closed: false,
+	});
+	await Bun.sleep(0);
+	let completedTail: string | undefined;
+	const completed = new Promise<void>((resolve) => {
+		host.subscribe(processId, () => {
+			if (host.isRunning(processId)) return;
+			completedTail = host.render(processId, 24, false).join("\n");
+			resolve();
+		});
+	});
+	reads.shift()?.({
+		chunks: [{ seq: 2, stream: "pty", chunk: Buffer.from("-FINAL-MARKER").toString("base64") }],
+		nextSeq: 3,
+		exited: true,
+		closed: true,
+	});
+	await completed;
+
+	expect(completedTail).toContain("FINAL-MARKER");
+	await host.shutdown();
+});
+
+test("drains process closure before reaping an explicitly terminated PTY", async () => {
+	let finishRead: ((response: unknown) => void) | undefined;
+	const requests: Record<string, unknown>[] = [];
+	const host = createPtyHost({
+		bridge: {
+			request<T>(request: Record<string, unknown>): Promise<T> {
+				requests.push(request);
+				if (request.op === "read")
+					return new Promise<T>((resolve) => {
+						finishRead = resolve as (response: unknown) => void;
+					});
+				return Promise.resolve({} as T);
+			},
+			shutdown: async () => {},
+		},
+		createProcessId: () => "process-1",
+		environment: {},
+	});
+	const processId = await host.spawn({ command: "interactive", cwd: "/tmp" });
+	const terminating = host.terminate(processId);
+	await Promise.resolve();
+	expect(requests.some((request) => request.op === "reap")).toBe(false);
+
+	finishRead?.({ chunks: [], nextSeq: 1, exited: true, closed: true });
+	expect(await terminating).toBe(true);
+	expect(requests.map((request) => request.op)).toEqual(["exec", "read", "terminate", "reap"]);
+	await host.shutdown();
+});

package/test/pty-pane.test.ts

@@ -0,0 +1,62 @@
+import { expect, test } from "bun:test";
+import type { TUI } from "@earendil-works/pi-tui";
+import type { TerminalBridgeClient } from "../src/terminal/bridge-client.ts";
+import { createPtyHost } from "../src/terminal/pty-host.ts";
+import { PtyPane, PtyProcess } from "../src/terminal/pty-pane.ts";
+
+test("runs an interactive PTY at its rendered size without redundant work or frames", async () => {
+	const requests: Record<string, unknown>[] = [];
+	let finishRead: ((response: unknown) => void) | undefined;
+	const bridge: TerminalBridgeClient = {
+		request: <T>(request: Record<string, unknown>) => {
+			requests.push(request);
+			if (request.op === "read")
+				return new Promise<T>((resolve) => {
+					finishRead = resolve as (response: unknown) => void;
+				});
+			if (request.op === "write") return Promise.resolve({ status: "accepted" } as T);
+			return Promise.resolve({} as T);
+		},
+		shutdown: async () => {},
+	};
+	const host = createPtyHost({ bridge, createProcessId: () => "process-1", environment: {} });
+	const scope = Object.create(null) as typeof globalThis;
+	Reflect.set(scope, Symbol.for("pi-libtui/pty-host/v2"), host);
+	const process = new PtyProcess({
+		label: "test",
+		command: "pi",
+		context: { cwd: "/tmp", ui: { notify() {} } } as never,
+		onExit() {},
+		scope,
+	});
+
+	process.render(120, 40, false);
+	await Promise.resolve();
+	expect(requests.find((request) => request.op === "exec")).toMatchObject({ rows: 40, cols: 120 });
+	process.render(100, 30, false);
+	process.render(110, 35, false);
+	for (const data of "abc") process.sendInput(data);
+	await Bun.sleep(0);
+	expect(requests.filter((request) => request.op === "resize" || request.op === "write")).toEqual([
+		{ op: "resize", process_id: "process-1", rows: 35, cols: 110 },
+		{ op: "write", process_id: "process-1", chunk: "abc" },
+	]);
+
+	let immediateRenders = 0;
+	const tui = {
+		requestImmediateRender: () => (immediateRenders += 1),
+	} as never as TUI;
+	const pane = new PtyPane(process, { tui, rows: () => 35, requestRender() {} });
+	finishRead?.({
+		chunks: [{ seq: 1, stream: "pty", chunk: Buffer.from("abc").toString("base64") }],
+		nextSeq: 2,
+		exited: false,
+		closed: false,
+	});
+	await Bun.sleep(0);
+	expect(immediateRenders).toBe(1);
+
+	pane.dispose();
+	process.dispose();
+	await host.shutdown();
+});

package/test/public-surface.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from "bun:test";
+
+const PUBLIC_ENTRYPOINTS = [
+	"@luan.sh/pi-libtui",
+	"@luan.sh/pi-libtui/diff",
+	"@luan.sh/pi-libtui/editor",
+	"@luan.sh/pi-libtui/folding",
+	"@luan.sh/pi-libtui/mouse",
+	"@luan.sh/pi-libtui/selection",
+	"@luan.sh/pi-libtui/stream",
+	"@luan.sh/pi-libtui/terminal",
+	"@luan.sh/pi-libtui/tool",
+] as const;
+
+const CAPABILITY_KEYS = [
+	Symbol.for("pi-libtui/editor/registry/v1"),
+	Symbol.for("pi-libtui/folding/registry/v2"),
+	Symbol.for("pi-libtui/mouse/registry/v1"),
+	Symbol.for("pi-libtui/selection/v1"),
+	Symbol.for("pi-libtui/split-panes/v2"),
+	Symbol.for("pi-libtui.motionScheduler.v1"),
+] as const;
+
+describe("public module boundaries", () => {
+	test("loads every documented public entrypoint without loading the host extension", async () => {
+		const before = CAPABILITY_KEYS.map((key) => Object.hasOwn(globalThis, key));
+		for (const entrypoint of PUBLIC_ENTRYPOINTS) {
+			const module = await import(entrypoint);
+			expect(typeof module).toBe("object");
+		}
+		const after = CAPABILITY_KEYS.map((key) => Object.hasOwn(globalThis, key));
+		expect(after).toEqual(before);
+		const mouse = await import("@luan.sh/pi-libtui/mouse");
+		expect(Object.keys(mouse).sort()).toEqual([
+			"FULLSCREEN_LAYOUT_CAPABILITY_KEY",
+			"FULLSCREEN_LAYOUT_PROTOCOL",
+			"MOUSE_PROTOCOL",
+			"MOUSE_REGISTRY_KEY",
+			"TEXT_INTERACTION_TARGET",
+			"ensureMouseRegistry",
+			"getFullscreenLayoutCapability",
+			"preserveViewportOnResize",
+			"publishFullscreenLayoutCapability",
+			"registerModalPointerShield",
+			"resolveFullscreenLayout",
+		]);
+		const editor = await import("@luan.sh/pi-libtui/editor");
+		expect(Object.keys(editor).sort()).toEqual([
+			"EDITOR_PROTOCOL",
+			"EDITOR_REGISTRY_KEY",
+			"SemanticEditor",
+			"composeEditorStatus",
+			"dispatchEditorPaste",
+			"dispatchEditorRender",
+			"editorCompositionCadenceMs",
+			"editorCompositionContentWidth",
+			"editorStatusSeparator",
+			"ensureEditorRegistry",
+			"installEditorLayer",
+			"installEditorMinimumRows",
+			"renderEditorComposition",
+			"renderEditorCompositionPreview",
+			"renderEditorCompositionStatus",
+			"semanticEditorTheme",
+		]);
+	});
+
+	test("keeps extension activation explicit", async () => {
+		const before = CAPABILITY_KEYS.map((key) => Object.hasOwn(globalThis, key));
+		const extension = await import("../src/extension.ts");
+		expect(typeof extension.default).toBe("function");
+		const after = CAPABILITY_KEYS.map((key) => Object.hasOwn(globalThis, key));
+		expect(after).toEqual(before);
+	});
+});

package/test/render-cache.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { RenderedLinesCache } from "../src/render-cache.ts";
+
+describe("RenderedLinesCache", () => {
+	test("uses exact width and revision keys with bounded widths", () => {
+		const cache = new RenderedLinesCache({ maxWidths: 3, maxContentKeysPerWidth: 2 });
+		const first = cache.get(80, "r1", () => ["same"]);
+		expect(cache.get(80, "r1", () => ["other"])).toBe(first);
+		cache.get(80, "r2", () => ["second"]);
+		cache.get(80, "r3", () => ["third"]);
+		expect(cache.get(80, "r1", () => ["new first"])).not.toBe(first);
+		for (let width = 1; width < 1_000; width++) cache.get(width, "r", () => [String(width)]);
+		expect(cache.widthCount).toBe(3);
+	});
+
+	test("normalizes non-finite width and content limits", () => {
+		const cache = new RenderedLinesCache({ maxWidths: Number.NaN, maxContentKeysPerWidth: Number.POSITIVE_INFINITY });
+		for (let width = 0; width < 100; width++) {
+			for (let revision = 0; revision < 10; revision++) {
+				cache.get(width, String(revision), () => [`${width}:${revision}`]);
+			}
+		}
+		expect(cache.widthCount).toBe(4);
+	});
+});

package/test/render-epoch.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { configureTuiAppearance, DEFAULT_TUI_APPEARANCE } from "../src/appearance.ts";
+import { BackgroundSurface } from "../src/background-surface.ts";
+import { rgb } from "../src/color/palette.ts";
+import { MarkdownText } from "../src/content/text.ts";
+import { parseUnifiedDiff } from "../src/diff/index.ts";
+import { RenderedLinesCache } from "../src/render-cache.ts";
+import { type MeasuredTerminalColors, terminalColorsRegistry } from "../src/terminal-colors.ts";
+import { ToolActivity } from "../src/tool/activity.ts";
+
+const theme = { name: "harmonious", bold: (text: string) => text, getColorMode: () => "truecolor" } as Theme;
+
+afterEach(() => {
+	configureTuiAppearance(DEFAULT_TUI_APPEARANCE);
+	terminalColorsRegistry().publish(undefined);
+});
+
+describe("shared render epoch", () => {
+	test("invalidates rendered-line caches after an effective appearance change", () => {
+		configureTuiAppearance({ iconPack: "unicode" });
+		const cache = new RenderedLinesCache();
+		let renders = 0;
+		const first = cache.get(20, "stable", () => {
+			renders += 1;
+			return ["first"];
+		});
+
+		configureTuiAppearance({ iconPack: "emoji" });
+		const second = cache.get(20, "stable", () => {
+			renders += 1;
+			return ["second"];
+		});
+
+		expect(renders).toBe(2);
+		expect(second).not.toBe(first);
+		expect(cache.get(20, "stable", () => ["third"])).toBe(second);
+	});
+
+	test("repaints a background surface after terminal colors change", () => {
+		const registry = terminalColorsRegistry();
+		registry.publish(terminalProfile(10));
+		const surface = new BackgroundSurface({
+			theme,
+			component: staticComponent("same content"),
+			background: "surface.inset",
+		});
+
+		const first = surface.render(40);
+		registry.publish(terminalProfile(180));
+		const second = surface.render(40);
+
+		expect(second).not.toBe(first);
+		expect(second).not.toEqual(first);
+		registry.publish(terminalProfile(180));
+		expect(surface.render(40)).toBe(second);
+	});
+
+	test("refreshes ToolActivity diff themes when terminal colors change", () => {
+		const registry = terminalColorsRegistry();
+		registry.publish(terminalProfile(10));
+		const activity = new ToolActivity({
+			theme,
+			requestRender() {},
+			view: {
+				action: { verb: "edit", status: "succeeded" },
+				payload: { kind: "diff", model: parseUnifiedDiff("--- a/file\n+++ b/file\n@@ -1 +1 @@\n-old\n+new") },
+			},
+		});
+
+		const firstLine = activity.render(60).find((line) => line.includes("new"));
+		registry.publish(terminalProfile(180));
+		const secondLine = activity.render(60).find((line) => line.includes("new"));
+
+		expect(firstLine).toBeDefined();
+		expect(secondLine).toBeDefined();
+		expect(secondLine).not.toBe(firstLine);
+		activity.dispose();
+	});
+
+	test("rerenders Markdown at the same width after the render epoch changes", () => {
+		let marker = "first";
+		const markdown = new MarkdownText({
+			theme: {
+				...theme,
+				bold: (text: string) => `${marker}:${text}`,
+			} as Theme,
+			text: "**content**",
+		});
+
+		const first = markdown.render(40);
+		marker = "second";
+		terminalColorsRegistry().publish(terminalProfile(10));
+		const second = markdown.render(40);
+
+		expect(first.join("\n")).toContain("first:content");
+		expect(second.join("\n")).toContain("second:content");
+		expect(second).not.toBe(first);
+	});
+});
+
+function staticComponent(text: string): Component {
+	return {
+		render: () => [text],
+		invalidate() {},
+	};
+}
+
+function terminalProfile(seed: number): MeasuredTerminalColors {
+	const base16 = Array.from({ length: 16 }, (_, index) => rgb(seed + index, seed + index * 2, seed + index * 3));
+	return {
+		defaultBackground: base16[0],
+		defaultForeground: base16[15],
+		ansiBase16: base16,
+		indexedPalette: "custom",
+		scheme: "dark",
+	};
+}