@zenodinh/pi-render 0.1.0 → 0.1.3

package/src/core/paint.test.ts

@@ -1,322 +0,0 @@
-/**
- * paint.test.ts — the two painting seams: role → host token, and the degrade-to-plain contract.
- *
- * Tests enter at createRowPaint / createContentPaint only, and every theme is a plain object, so no
- * host package is imported (AC-4).
- */
-
-// shape: table-driven data + closures — trigger #4, two host-shape stand-ins parameterized by an
-//   escape table; a class or a fixture framework would be ceremony over one fg lookup.
-import { describe, expect, it } from "vitest";
-import { createContentPaint, createRowPaint } from "./paint.ts";
-import type { HostTheme, MarkdownTheme } from "./types/host.ts";
-
-// Fixture provenance — host theme shape: recorded-from @earendil-works/pi-coding-agent@1.0.4,
-//   dist/modes/interactive/theme/theme.js:201-216 (read 2026-10-06): fg() returns `<open>text\x1b[39m`,
-//   and throws `Unknown theme color: <token>` when the active theme lacks the token.
-// Fixture provenance — dark palette: recorded-from themes/dracula-soft.json (2026-10-06), vars resolved
-//   to truecolor RGB — toolTitle #f6f6f4, toolOutput/muted/searchMatchText/mdHr/mdQuote/mdQuoteBorder/
-//   mdCodeBlockBorder #7b7f8b, accent #bf9eee, error #ee6666, warning #ffb86c, mdCode #62e884.
-// Fixture provenance — light + system: invented — the indexed and terminal-default escape forms the
-//   host emits in those modes, each token distinct so a leaked escape names itself; pi-render reads no
-//   palette, so only the escape form is contract-relevant.
-
-const TEXT = "bash";
-const FG_CLOSE = "\x1b[39m";
-
-/** One escape per host token; typed so a fixture cannot silently omit a token paint reads. */
-type EscapeTable = {
-	toolTitle: string;
-	toolOutput: string;
-	muted: string;
-	accent: string;
-	error: string;
-	warning: string;
-	searchMatchText: string;
-	hr: string;
-	quote: string;
-	quoteBorder: string;
-	code: string;
-	codeBlockBorder: string;
-};
-
-const DARK_OPEN: EscapeTable = {
-	toolTitle: "\x1b[38;2;246;246;244m",
-	toolOutput: "\x1b[38;2;123;127;139m",
-	muted: "\x1b[38;2;123;127;139m",
-	accent: "\x1b[38;2;191;158;238m",
-	error: "\x1b[38;2;238;102;102m",
-	warning: "\x1b[38;2;255;184;108m",
-	searchMatchText: "\x1b[38;2;123;127;139m",
-	hr: "\x1b[38;2;123;127;139m",
-	quote: "\x1b[38;2;123;127;139m",
-	quoteBorder: "\x1b[38;2;123;127;139m",
-	code: "\x1b[38;2;98;232;132m",
-	codeBlockBorder: "\x1b[38;2;123;127;139m",
-};
-
-const LIGHT_OPEN: EscapeTable = {
-	toolTitle: "\x1b[38;5;61m",
-	toolOutput: "\x1b[38;5;240m",
-	muted: "\x1b[38;5;240m",
-	accent: "\x1b[38;5;134m",
-	error: "\x1b[38;5;167m",
-	warning: "\x1b[38;5;179m",
-	searchMatchText: "\x1b[38;5;135m",
-	hr: "\x1b[38;5;240m",
-	quote: "\x1b[38;5;242m",
-	quoteBorder: "\x1b[38;5;241m",
-	code: "\x1b[38;5;71m",
-	codeBlockBorder: "\x1b[38;5;239m",
-};
-
-/** An empty theme token renders the terminal default — the host uses `\x1b[39m` for every such token. */
-const DEFAULT_OPEN: EscapeTable = Object.fromEntries(
-	Object.keys(DARK_OPEN).map((token) => [token, "\x1b[39m"]),
-) as EscapeTable;
-
-const FORMS: ReadonlyArray<[string, EscapeTable]> = [
-	["truecolor (dark)", DARK_OPEN],
-	["indexed (light)", LIGHT_OPEN],
-	["terminal default (system)", DEFAULT_OPEN],
-];
-
-/** Mirrors Theme.fg: `<open>text\x1b[39m`, throwing on a token the fixture theme does not carry. */
-function hostFg(open: Record<string, string>): (key: string, text: string) => string {
-	return (key, text) => {
-		const sequence = open[key];
-		if (sequence === undefined) throw new Error(`Unknown theme color: ${key}`);
-		return `${sequence}${text}${FG_CLOSE}`;
-	};
-}
-
-function themeWith(open: Record<string, string>): HostTheme {
-	return { fg: hostFg(open), bold: (text) => text };
-}
-
-/** Mirrors getMarkdownTheme(): each member closes over the live theme's fg for its md* token. */
-function markdownThemeWith(open: Record<string, string>): MarkdownTheme {
-	const fg = hostFg(open);
-	return {
-		hr: (text) => fg("hr", text),
-		quote: (text) => fg("quote", text),
-		quoteBorder: (text) => fg("quoteBorder", text),
-		code: (text) => fg("code", text),
-		codeBlockBorder: (text) => fg("codeBlockBorder", text),
-	};
-}
-
-/** Marker stand-in: no escapes at all, so the recorded token list is the only signal paint can leak. */
-function recorder(): { fg: (key: string, text: string) => string; tokens: string[] } {
-	const tokens: string[] = [];
-	return {
-		tokens,
-		fg: (key, text) => {
-			tokens.push(key);
-			return `«${key}»${text}«/${key}»`;
-		},
-	};
-}
-
-// biome-ignore lint/suspicious/noControlCharactersInRegex: the ESC introducer is exactly what we scan for
-const ESCAPE_SEQUENCE = /\x1b\[[0-9;]*m/g;
-const escapesIn = (text: string): string[] => text.match(ESCAPE_SEQUENCE) ?? [];
-
-describe("createRowPaint — region 1", () => {
-	it("AC-1: every row role wraps through its own host token", () => {
-		const marker = recorder();
-		const paint = createRowPaint({ fg: marker.fg, bold: (text) => text });
-		const wrapped = [
-			paint.title(TEXT),
-			paint.output(TEXT),
-			paint.muted(TEXT),
-			paint.accent(TEXT),
-			paint.error(TEXT),
-			paint.warning(TEXT),
-			paint.gutter(TEXT),
-			paint.match(TEXT),
-		];
-		// fails_when: a role reads the wrong token, or returns its text unwrapped
-		expect(marker.tokens).toEqual([
-			"toolTitle",
-			"toolOutput",
-			"muted",
-			"accent",
-			"error",
-			"warning",
-			"muted",
-			"searchMatchText",
-		]);
-		expect(wrapped).toEqual([
-			"«toolTitle»bash«/toolTitle»",
-			"«toolOutput»bash«/toolOutput»",
-			"«muted»bash«/muted»",
-			"«accent»bash«/accent»",
-			"«error»bash«/error»",
-			"«warning»bash«/warning»",
-			"«muted»bash«/muted»",
-			"«searchMatchText»bash«/searchMatchText»",
-		]);
-	});
-
-	it.each(FORMS)("AC-1: %s escapes reach every role byte-exact", (_form, open) => {
-		const paint = createRowPaint(themeWith(open));
-		const outputs = [
-			paint.title(TEXT),
-			paint.output(TEXT),
-			paint.muted(TEXT),
-			paint.accent(TEXT),
-			paint.error(TEXT),
-			paint.warning(TEXT),
-			paint.gutter(TEXT),
-			paint.match(TEXT),
-		];
-		// fails_when: paint rewrites, drops, or double-wraps the theme's own escape
-		expect(outputs).toEqual([
-			`${open.toolTitle}${TEXT}${FG_CLOSE}`,
-			`${open.toolOutput}${TEXT}${FG_CLOSE}`,
-			`${open.muted}${TEXT}${FG_CLOSE}`,
-			`${open.accent}${TEXT}${FG_CLOSE}`,
-			`${open.error}${TEXT}${FG_CLOSE}`,
-			`${open.warning}${TEXT}${FG_CLOSE}`,
-			`${open.muted}${TEXT}${FG_CLOSE}`,
-			`${open.searchMatchText}${TEXT}${FG_CLOSE}`,
-		]);
-	});
-
-	it("AC-1: a token the active theme lacks degrades that role, not the frame", () => {
-		const paint = createRowPaint(themeWith({ toolTitle: "\x1b[38;2;246;246;244m" }));
-		// fails_when: an exotic theme crashes paint (host fg throws `Unknown theme color`)
-		expect(paint.title(TEXT)).toBe("\x1b[38;2;246;246;244mbash\x1b[39m");
-		expect([paint.output(TEXT), paint.muted(TEXT), paint.error(TEXT), paint.match(TEXT)]).toEqual([
-			"bash",
-			"bash",
-			"bash",
-			"bash",
-		]);
-	});
-
-	it("AC-4: a plain two-member object satisfies the seam with no host package", () => {
-		const bolded: string[] = [];
-		const theme = {
-			fg: (key: string, text: string): string => `«${key}»${text}«/${key}»`,
-			bold: (text: string): string => {
-				bolded.push(text);
-				return `«bold»${text}«/bold»`;
-			},
-		};
-		const paint = createRowPaint(theme);
-		// fails_when: paint requires the host Theme instance rather than the structural shape
-		expect(paint.title(TEXT)).toBe("«toolTitle»bash«/toolTitle»");
-		expect(bolded).toEqual([]);
-	});
-
-	it("reads the theme live on every call — no cache to invalidate", () => {
-		const theme = themeWith({ toolTitle: "\x1b[38;2;1;2;3m" });
-		const paint = createRowPaint(theme);
-		expect(paint.title(TEXT)).toBe("\x1b[38;2;1;2;3mbash\x1b[39m");
-		theme.fg = hostFg({ toolTitle: "\x1b[38;2;4;5;6m" }); // a theme switch swaps the host proxy in place
-		// fails_when: the factory memoizes the escape, so the next frame paints the old theme
-		expect(paint.title(TEXT)).toBe("\x1b[38;2;4;5;6mbash\x1b[39m");
-	});
-});
-
-describe("createContentPaint — region 2", () => {
-	it("AC-2: rule uses hr when the theme carries it", () => {
-		const paint = createContentPaint(markdownThemeWith(LIGHT_OPEN));
-		// fails_when: rule prefers the quoteBorder fallback while hr is available
-		expect(paint.rule(TEXT)).toBe("\x1b[38;5;240mbash\x1b[39m");
-	});
-
-	it("AC-2: rule falls back to quoteBorder when the theme lacks hr", () => {
-		const paint = createContentPaint({ quoteBorder: (text) => `«quoteBorder»${text}«/quoteBorder»` });
-		// fails_when: a missing hr throws or returns the text unstyled instead of using the fallback
-		expect(paint.rule(TEXT)).toBe("«quoteBorder»bash«/quoteBorder»");
-	});
-
-	it("AC-2: rule degrades to plain text with zero escapes when both tokens are missing", () => {
-		const rule = createContentPaint({}).rule(TEXT);
-		// fails_when: a missing token throws, or paint substitutes a literal fallback color
-		expect(rule).toBe("bash");
-		expect(rule).not.toContain("\x1b");
-	});
-
-	it("AC-2: a throwing hr falls through to quoteBorder", () => {
-		const paint = createContentPaint({
-			hr: () => {
-				throw new Error("Unknown theme color: mdHr");
-			},
-			quoteBorder: (text) => `«quoteBorder»${text}«/quoteBorder»`,
-		});
-		// fails_when: a live-proxy throw during a theme switch takes the frame down
-		expect(paint.rule(TEXT)).toBe("«quoteBorder»bash«/quoteBorder»");
-	});
-
-	it("AC-1: quote, code and codeBlockBorder use their own token, and degrade to plain when absent", () => {
-		const styled = createContentPaint(markdownThemeWith(LIGHT_OPEN));
-		expect([styled.quote(TEXT), styled.code(TEXT), styled.codeBlockBorder(TEXT)]).toEqual([
-			"\x1b[38;5;242mbash\x1b[39m",
-			"\x1b[38;5;71mbash\x1b[39m",
-			"\x1b[38;5;239mbash\x1b[39m",
-		]);
-		const bare = createContentPaint({});
-		// fails_when: a missing md token throws or paints a literal color
-		expect([bare.rule(TEXT), bare.quote(TEXT), bare.code(TEXT), bare.codeBlockBorder(TEXT)]).toEqual([
-			"bash",
-			"bash",
-			"bash",
-			"bash",
-		]);
-	});
-
-	it("AC-1: a markdown theme whose members all throw degrades every role to plain", () => {
-		const boom = (): string => {
-			throw new Error("Unknown theme color: mdHr");
-		};
-		const paint = createContentPaint({ hr: boom, quote: boom, quoteBorder: boom, code: boom, codeBlockBorder: boom });
-		// fails_when: an exotic markdown theme crashes paint
-		expect([paint.rule(TEXT), paint.quote(TEXT), paint.code(TEXT), paint.codeBlockBorder(TEXT)]).toEqual([
-			"bash",
-			"bash",
-			"bash",
-			"bash",
-		]);
-	});
-
-	it("reads the markdown closures live on every call — no cache to invalidate", () => {
-		const mdTheme: MarkdownTheme = { hr: (text) => `«hr:1»${text}` };
-		const paint = createContentPaint(mdTheme);
-		expect(paint.rule(TEXT)).toBe("«hr:1»bash");
-		mdTheme.hr = (text) => `«hr:2»${text}`;
-		// fails_when: the factory captures the closure once, so a theme switch does not repaint
-		expect(paint.rule(TEXT)).toBe("«hr:2»bash");
-	});
-});
-
-describe("createRowPaint / createContentPaint — the escape boundary", () => {
-	it("AC-3: every escape in the output is one the theme itself emitted", () => {
-		const rows = createRowPaint(themeWith(LIGHT_OPEN));
-		const content = createContentPaint(markdownThemeWith(LIGHT_OPEN));
-		const outputs = [
-			rows.title(TEXT),
-			rows.output(TEXT),
-			rows.muted(TEXT),
-			rows.accent(TEXT),
-			rows.error(TEXT),
-			rows.warning(TEXT),
-			rows.gutter(TEXT),
-			rows.match(TEXT),
-			content.rule(TEXT),
-			content.quote(TEXT),
-			content.code(TEXT),
-			content.codeBlockBorder(TEXT),
-		];
-		const allowed = new Set([...Object.values(LIGHT_OPEN), FG_CLOSE]);
-		const emitted = outputs.flatMap(escapesIn);
-		// 12 roles × (token open + fg close): keeps the leak scan below from passing on an empty set
-		expect(emitted).toHaveLength(24);
-		const leaks = emitted.filter((sequence) => !allowed.has(sequence));
-		// fails_when: paint adds an escape of its own — a hardcoded color or a reset
-		expect(leaks).toEqual([]);
-	});
-});

package/src/core/registry.test.ts

@@ -1,307 +0,0 @@
-/**
- * registry through its seam — createRegistry(store, log), driven with a fake store and fake logger.
- *
- * Every scenario's first meaningful action is a createRegistry call; nothing below the seam (the Map,
- * the validators, readEntry) is imported.
- *
- * invented: the two doubles stand in for T-07 core/settings and T-06 core/log, which land in the same
- * wave; they satisfy the structural contracts and record every call in order.
- * invented: settings documents are hand-built to the SA §3 literal (version + modules map) — T-07 owns
- * the on-disk file, so there is no recorded payload to reuse here.
- */
-import { describe, expect, test } from "vitest";
-import { createRegistry } from "./registry.ts";
-import type { LogEntry, Logger } from "./types/log.ts";
-import type { ModuleDescriptor, SettingSpec } from "./types/registry.ts";
-import type { SettingsDoc, SettingsStore } from "./types/settings.ts";
-
-const EMPTY_DOC: SettingsDoc = { version: 1, modules: {} };
-
-const COLLAPSE_AT: SettingSpec = { name: "collapseAt", kind: "number", default: 5 };
-const COMPACT: SettingSpec = { name: "compact", kind: "toggle", default: false };
-const CODE_THEME: SettingSpec = {
-	name: "codeTheme",
-	kind: "enum",
-	values: ["dracula-soft", "one-dark-pro"],
-	default: "dracula-soft",
-};
-
-const BASH: ModuleDescriptor = { key: "row.bash", name: "Bash row", defaultEnabled: true, settings: [COLLAPSE_AT] };
-const TABLE: ModuleDescriptor = {
-	key: "content.table",
-	name: "Table",
-	defaultEnabled: true,
-	settings: [COLLAPSE_AT, COMPACT],
-};
-const CODETHEME: ModuleDescriptor = {
-	key: "codetheme",
-	name: "Code theme",
-	defaultEnabled: true,
-	settings: [CODE_THEME],
-};
-
-interface FakeStore extends SettingsStore {
-	/** Every store interaction in call order — a read-path disk touch shows up here. Required. */
-	readonly calls: string[];
-	/** Documents handed to save(), in order. Required. */
-	readonly saved: SettingsDoc[];
-}
-
-function fakeStore(initial: SettingsDoc): FakeStore {
-	const calls: string[] = [];
-	const saved: SettingsDoc[] = [];
-	// The store owns its document (T-07 parses the file per instance), so a write cannot leak between tests.
-	let doc = structuredClone(initial);
-	return {
-		calls,
-		saved,
-		load() {
-			calls.push("load");
-			return doc; // cached, like T-07: a re-read must come from an explicit load call, not implicitly
-		},
-		save(next) {
-			calls.push("save");
-			doc = next;
-			saved.push(next);
-		},
-	};
-}
-
-interface FakeLog {
-	readonly log: Logger;
-	readonly entries: LogEntry[];
-}
-
-function fakeLog(): FakeLog {
-	const entries: LogEntry[] = [];
-	const seen = new Set<string>();
-	const log: Logger = {
-		logLine(scope, message) {
-			entries.push({ scope, message, time: 0 });
-		},
-		logOnce(key, scope, message) {
-			if (seen.has(key)) return;
-			seen.add(key);
-			entries.push({ scope, message, time: 0 });
-		},
-		drain() {
-			return entries.splice(0, entries.length);
-		},
-	};
-	return { log, entries };
-}
-
-describe("registry", () => {
-	// spec: defineModule(row.bash, defaultEnabled true); setSettings("row.bash", { enabled: false }) ->
-	//   the NEXT isEnabled("row.bash") is false and the saved doc carries enabled: false.
-	// fails_when: a disable never reaches the next read (the predecessor's toggle freeze).
-	test("AC-1 a settings write lands on the next isEnabled read", () => {
-		const store = fakeStore(EMPTY_DOC);
-		const registry = createRegistry(store, fakeLog().log);
-		registry.defineModule(BASH);
-
-		expect(registry.isEnabled("row.bash")).toBe(true);
-
-		registry.setSettings("row.bash", { enabled: false });
-
-		expect(registry.isEnabled("row.bash")).toBe(false);
-		expect(store.saved).toHaveLength(1);
-		expect(store.saved[0]?.modules["row.bash"]?.enabled).toBe(false);
-	});
-
-	// spec: isEnabled("row.nope") -> false; getSettings("row.nope") -> {}; neither throws.
-	// fails_when: a lookup for a key nothing registered throws.
-	test("AC-2 an unknown key reads false and {} without throwing", () => {
-		const registry = createRegistry(fakeStore(EMPTY_DOC), fakeLog().log);
-
-		expect(registry.isEnabled("row.nope")).toBe(false);
-		expect(registry.getSettings("row.nope")).toEqual({});
-	});
-
-	// spec: defineModule(BASH) then two more descriptors under "row.bash" -> the first name/default/
-	//   settings survive and exactly one log entry fires.
-	// fails_when: a later descriptor overwrites the first, or each duplicate logs again.
-	test("AC-3 a duplicate define keeps the first descriptor and logs exactly once", () => {
-		const store = fakeStore(EMPTY_DOC);
-		const { log, entries } = fakeLog();
-		const registry = createRegistry(store, log);
-
-		registry.defineModule(BASH);
-		registry.defineModule({ ...BASH, name: "Impostor", defaultEnabled: false });
-		registry.defineModule({
-			...BASH,
-			name: "Impostor again",
-			settings: [{ name: "other", kind: "toggle", default: false }],
-		});
-
-		expect(registry.isEnabled("row.bash")).toBe(true);
-		expect(registry.getSettings("row.bash")).toEqual({ collapseAt: 5 });
-		expect(entries).toHaveLength(1);
-		expect(entries[0]?.message).toContain("row.bash");
-	});
-
-	// spec: stored row.bash.settings = { collapseAt: "3" } (a string under a number spec) with
-	//   content.table.settings = { collapseAt: 7, ghost: 1 } -> row.bash reads the default 5, content.table
-	//   reads 7 with the unspec'd "ghost" dropped.
-	// fails_when: one malformed key corrupts the others (or the malformed value is handed to a renderer).
-	test("AC-4 a malformed stored value reads its default while other keys read stored values", () => {
-		const store = fakeStore({
-			version: 1,
-			modules: {
-				"row.bash": { enabled: true, settings: { collapseAt: "3" } },
-				"content.table": { enabled: false, settings: { collapseAt: 7, ghost: 1 } },
-			},
-		});
-		const { log, entries } = fakeLog();
-		const registry = createRegistry(store, log);
-		registry.defineModule(BASH);
-		registry.defineModule(TABLE);
-
-		expect(registry.getSettings("row.bash")).toEqual({ collapseAt: 5 });
-		expect(registry.getSettings("content.table")).toEqual({ collapseAt: 7, compact: false });
-		expect(registry.isEnabled("content.table")).toBe(false);
-		expect(entries).toHaveLength(1);
-	});
-
-	// spec: stored row.bash = 7 (not a slice) -> row.bash reads defaultEnabled true plus spec defaults
-	//   while content.table still reads its stored enabled: false and collapseAt: 7.
-	// fails_when: a malformed module entry poisons its neighbours or throws at boot.
-	test("AC-4 a malformed stored entry reads that module's defaults while other keys read stored values", () => {
-		const incomplete = {
-			version: 1,
-			modules: { "row.bash": 7, "content.table": { enabled: false, settings: { collapseAt: 7 } } },
-		};
-		const store = fakeStore(incomplete as unknown as SettingsDoc); // boundary: the disk can hold any JSON
-		const { log, entries } = fakeLog();
-		const registry = createRegistry(store, log);
-		registry.defineModule(BASH);
-		registry.defineModule(TABLE);
-
-		expect(registry.isEnabled("row.bash")).toBe(true);
-		expect(registry.getSettings("row.bash")).toEqual({ collapseAt: 5 });
-		expect(registry.isEnabled("content.table")).toBe(false);
-		expect(registry.getSettings("content.table")).toEqual({ collapseAt: 7, compact: false });
-		expect(entries).toHaveLength(1);
-	});
-
-	// spec: one createRegistry (one store.load), 5 read invocations, one setSettings -> the store saw
-	//   exactly ["load", "save"]; the reads logged nothing.
-	// fails_when: the registry reaches outside its seam — a per-render disk read or a pushed write.
-	test("AC-5 every call stays inside the injected store and logger seam", () => {
-		const store = fakeStore(EMPTY_DOC);
-		const { log, entries } = fakeLog();
-		const registry = createRegistry(store, log);
-		registry.defineModule(CODETHEME);
-
-		for (let i = 0; i < 5; i++) {
-			registry.isEnabled("codetheme");
-			registry.getSettings("codetheme");
-		}
-		expect(store.calls).toEqual(["load"]);
-		expect(entries).toEqual([]);
-
-		registry.setSettings("codetheme", { codeTheme: "one-dark-pro" });
-
-		expect(store.calls).toEqual(["load", "save"]);
-		expect(registry.getSettings("codetheme")).toEqual({ codeTheme: "one-dark-pro" });
-		expect(store.calls).toEqual(["load", "save"]);
-	});
-
-	// spec: setSettings("content.table", { collapseAt: 9, compact: true }) -> both land on the next read
-	//   and both are in the saved doc.
-	// fails_when: a patch is validated but never applied or never persisted.
-	test("a valid patch merges into the stored settings and persists", () => {
-		const store = fakeStore(EMPTY_DOC);
-		const registry = createRegistry(store, fakeLog().log);
-		registry.defineModule(TABLE);
-
-		registry.setSettings("content.table", { collapseAt: 9, compact: true });
-
-		expect(registry.getSettings("content.table")).toEqual({ collapseAt: 9, compact: true });
-		expect(store.saved[0]?.modules["content.table"]?.settings).toEqual({ collapseAt: 9, compact: true });
-	});
-
-	// spec: setSettings("row.bash", { collapseAt: "3" }) -> no throw, the stored settings stay at the
-	//   default 5, enabled is untouched, exactly one log entry.
-	// fails_when: an invalid patch value is stored, throws, or logs a line per frame it is seen.
-	test("an invalid patch value is rejected with one log entry and never throws", () => {
-		const store = fakeStore(EMPTY_DOC);
-		const { log, entries } = fakeLog();
-		const registry = createRegistry(store, log);
-		registry.defineModule(BASH);
-
-		registry.setSettings("row.bash", { collapseAt: "3" });
-
-		expect(registry.getSettings("row.bash")).toEqual({ collapseAt: 5 });
-		expect(registry.isEnabled("row.bash")).toBe(true);
-		expect(entries).toHaveLength(1);
-		expect(entries[0]?.message).toBe("ignored invalid value for row.bash.collapseAt");
-	});
-
-	// spec: a patch naming a setting no spec declares -> rejected with one log entry and absent from the
-	//   effective settings.
-	// fails_when: an unvalidatable key is written into the doc and handed back to a renderer.
-	test("a patch naming an unknown setting is rejected with one log entry", () => {
-		const store = fakeStore(EMPTY_DOC);
-		const { log, entries } = fakeLog();
-		const registry = createRegistry(store, log);
-		registry.defineModule(BASH);
-
-		registry.setSettings("row.bash", { nope: 1 });
-
-		expect(registry.getSettings("row.bash")).toEqual({ collapseAt: 5 });
-		expect(entries).toHaveLength(1);
-		expect(entries[0]?.message).toBe("ignored invalid value for row.bash.nope");
-	});
-
-	// spec: setSettings("codetheme", { codeTheme: "solarized" }) -> rejected, default kept, one log entry;
-	//   then { codeTheme: "one-dark-pro" } -> accepted.
-	// fails_when: an enum value outside the spec's list reaches the code that uses it.
-	test("an enum value outside the spec is rejected while an allowed value lands", () => {
-		const store = fakeStore(EMPTY_DOC);
-		const { log, entries } = fakeLog();
-		const registry = createRegistry(store, log);
-		registry.defineModule(CODETHEME);
-
-		registry.setSettings("codetheme", { codeTheme: "solarized" });
-		expect(registry.getSettings("codetheme")).toEqual({ codeTheme: "dracula-soft" });
-		expect(entries).toHaveLength(1);
-
-		registry.setSettings("codetheme", { codeTheme: "one-dark-pro" });
-		expect(registry.getSettings("codetheme")).toEqual({ codeTheme: "one-dark-pro" });
-	});
-
-	// spec: setSettings("row.nope", { collapseAt: 9 }) and a non-object patch both no-op with one log
-	//   entry each and never throw or save.
-	// fails_when: a stale panel target or an erased-type patch corrupts the doc.
-	test("a write for an unknown key or a non-object patch is ignored, never throws", () => {
-		const store = fakeStore(EMPTY_DOC);
-		const { log, entries } = fakeLog();
-		const registry = createRegistry(store, log);
-		registry.defineModule(BASH);
-
-		registry.setSettings("row.nope", { collapseAt: 9 });
-		registry.setSettings("row.bash", "collapseAt" as unknown as object); // boundary: TS types are erased
-
-		expect(registry.isEnabled("row.nope")).toBe(false);
-		expect(registry.getSettings("row.bash")).toEqual({ collapseAt: 5 });
-		expect(store.saved).toHaveLength(0);
-		expect(entries).toHaveLength(2);
-	});
-
-	// spec: a stored enabled that is not a boolean ("yes") falls back to spec defaultEnabled (false) and
-	//   logs once, rather than being read as a truthy string.
-	// fails_when: a malformed enabled flag is trusted and a module turns itself on.
-	test("a malformed stored enabled falls back to the default and logs once", () => {
-		const store = fakeStore({
-			version: 1,
-			modules: { "row.bash": { enabled: "yes", settings: {} } },
-		} as unknown as SettingsDoc); // boundary: the disk can hold any JSON
-		const { log, entries } = fakeLog();
-		const registry = createRegistry(store, log);
-		registry.defineModule({ ...BASH, defaultEnabled: false });
-
-		expect(registry.isEnabled("row.bash")).toBe(false);
-		expect(entries).toHaveLength(1);
-	});
-});