@zenodinh/pi-render 0.1.0 → 0.1.3

package/src/core/code-theme.test.ts

@@ -1,266 +0,0 @@
-/**
- * code-theme.test.ts — the spec of createCodeTheme at its seam, with a counting engine double.
- *
- * Spec: createCodeTheme(bindEngine, {registry, log}) resolves `codeTheme` to a bundled name (unknown →
- * dracula-soft + one log line), highlights once per theme+lang+code, never hands the engine an empty or
- * over-80k block, and returns plain source lines when the engine or the bind throws.
- */
-
-import { describe, expect, it } from "vitest";
-import { type BindHighlightEngine, CODE_THEME_MODULE, type CodeThemeName, createCodeTheme } from "./code-theme.ts";
-
-// invented: the engine is faked, so the block only has to be two stable lines.
-const CODE = "const a = 1;\nlet b = 2;";
-
-/** One engine invocation: the theme it was bound to, plus the block it was asked for. */
-interface EngineCall {
-	theme: CodeThemeName;
-	code: string;
-	lang: string;
-}
-
-/**
- * Engine double that counts: it records every call and stamps its bound theme into the lines, so the
- * resolved theme is visible in the output rather than only in the bind argument.
- */
-function countingEngine(options: { throwOnBind?: boolean; throwOnCall?: boolean } = {}): {
-	bind: BindHighlightEngine;
-	calls: EngineCall[];
-} {
-	const calls: EngineCall[] = [];
-	const bind: BindHighlightEngine = (theme) => {
-		if (options.throwOnBind) throw new Error("bind failed");
-		return (code, lang) => {
-			calls.push({ theme, code, lang });
-			if (options.throwOnCall) throw new Error("engine failed");
-			return code.split("\n").map((line) => `«${theme}»${line}`);
-		};
-	};
-	return { bind, calls };
-}
-
-/** Logger double: logOnce's once-per-key rule plus the readout, so "exactly one line" is observable. */
-function logDouble(): {
-	logOnce(key: string, scope: string, message: string): void;
-	entries: Array<{ key: string; scope: string; message: string }>;
-	attempts: number;
-} {
-	const entries: Array<{ key: string; scope: string; message: string }> = [];
-	const seen = new Set<string>();
-	const double = {
-		entries,
-		attempts: 0,
-		logOnce(key: string, scope: string, message: string): void {
-			double.attempts += 1;
-			if (seen.has(key)) return;
-			seen.add(key);
-			entries.push({ key, scope, message });
-		},
-	};
-	return double;
-}
-
-/**
- * Settings double over the injected contract. invented: the slice is contracted as
- * `Record<string, unknown>`, so any bag is a legal stored document; `set` models the registry's
- * "a write lands on the next read".
- */
-function registryDouble(initial: Record<string, unknown> = {}): {
-	getSettings(key: string): Record<string, unknown>;
-	set(patch: Record<string, unknown>): void;
-} {
-	const slices = new Map<string, Record<string, unknown>>([["codetheme", { ...initial }]]);
-	return {
-		getSettings: (key) => slices.get(key) ?? {},
-		set: (patch) => slices.set("codetheme", { ...(slices.get("codetheme") ?? {}), ...patch }),
-	};
-}
-
-describe("createCodeTheme — theme resolution", () => {
-	it("AC-1: an unknown codeTheme renders the default theme and logs exactly one line", async () => {
-		const engine = countingEngine();
-		const log = logDouble();
-		// invented: the setting is persisted JSON, so an out-of-set name is the exact input AC-1 names.
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "nope" }), log });
-
-		const first = await theme.highlight(CODE, "ts");
-		const second = await theme.highlight(CODE, "ts");
-		const joined = theme.highlightSync(CODE, "ts");
-
-		// fails_when: a crash, empty output, or one log line per call.
-		expect(first).toEqual(["«dracula-soft»const a = 1;", "«dracula-soft»let b = 2;"]);
-		expect([second, joined]).toEqual([first, first.join("\n")]);
-		expect(engine.calls.map((call) => call.theme)).toEqual(["dracula-soft"]);
-		expect(log.entries.map((entry) => entry.key)).toEqual(["theme:nope"]);
-		expect(log.entries[0]?.message).toContain("dracula-soft");
-		expect(log.attempts).toBe(3);
-	});
-
-	it("AC-1: a bundled non-default theme is rendered without a log line", async () => {
-		const engine = countingEngine();
-		const log = logDouble();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "one-dark-pro" }), log });
-
-		// fails_when: the setting is ignored and the default theme always renders.
-		expect(await theme.highlight(CODE, "ts")).toEqual(["«one-dark-pro»const a = 1;", "«one-dark-pro»let b = 2;"]);
-		expect(log.entries).toEqual([]);
-	});
-
-	it("AC-1: an absent setting reads the default theme silently", async () => {
-		const engine = countingEngine();
-		const log = logDouble();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble(), log });
-
-		// fails_when: a fresh install logs a fallback line on every render.
-		expect(await theme.highlight(CODE, "ts")).toEqual(["«dracula-soft»const a = 1;", "«dracula-soft»let b = 2;"]);
-		expect(log.entries).toEqual([]);
-	});
-
-	it("AC-1: the descriptor is exported for T-28, and the injected registry has no write route", async () => {
-		// The injected registry shape is read-only (getSettings only), so a registration here cannot compile.
-		expect(CODE_THEME_MODULE).toEqual({
-			key: "codetheme",
-			name: "Code theme",
-			defaultEnabled: true,
-			settings: [
-				{ name: "codeTheme", kind: "enum", values: ["dracula-soft", "one-dark-pro"], default: "dracula-soft" },
-			],
-		});
-	});
-});
-
-describe("createCodeTheme — cache", () => {
-	it("AC-2: the same theme+lang+code highlights once", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		const first = await theme.highlight(CODE, "ts");
-		const second = await theme.highlight(CODE, "ts");
-
-		// fails_when: every call re-highlights (the #21 defect class).
-		expect(second).toEqual(first);
-		expect(engine.calls).toHaveLength(1);
-	});
-
-	it("AC-2: lang and theme are part of the key", async () => {
-		const engine = countingEngine();
-		const registry = registryDouble({ codeTheme: "dracula-soft" });
-		const theme = createCodeTheme(engine.bind, { registry });
-
-		await theme.highlight(CODE, "ts");
-		await theme.highlight(CODE, "py");
-		registry.set({ codeTheme: "one-dark-pro" });
-		await theme.highlight(CODE, "ts");
-
-		// fails_when: the key ignores lang or theme and serves the previous theme's colours.
-		expect(engine.calls.map((call) => `${call.theme}:${call.lang}`)).toEqual([
-			"dracula-soft:ts",
-			"dracula-soft:py",
-			"one-dark-pro:ts",
-		]);
-	});
-
-	it("AC-2: highlightSync shares the cache with highlight", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		await theme.highlight(CODE, "ts");
-		const joined = theme.highlightSync(CODE, "ts");
-
-		// fails_when: the panel path keeps a second cache and highlights the same block again.
-		expect(joined).toBe("«dracula-soft»const a = 1;\n«dracula-soft»let b = 2;");
-		expect(engine.calls).toHaveLength(1);
-	});
-
-	it("AC-2: the cache is bounded at 128 entries and a hit counts as recent use", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		for (let i = 0; i < 128; i += 1) await theme.highlight(`line ${i}`, "ts");
-		await theme.highlight("line 0", "ts");
-		await theme.highlight("line 128", "ts");
-		expect(engine.calls).toHaveLength(129); // the 129th entry evicted the oldest untouched one
-
-		// fails_when: the cache grows without bound, or a hit does not count as recent use.
-		expect(await theme.highlight("line 0", "ts")).toEqual(["«dracula-soft»line 0"]);
-		expect(engine.calls).toHaveLength(129);
-		expect(await theme.highlight("line 1", "ts")).toEqual(["«dracula-soft»line 1"]);
-		expect(engine.calls).toHaveLength(130);
-	});
-});
-
-describe("createCodeTheme — what never reaches the engine", () => {
-	it("AC-3: a block past 80k characters returns its own plain lines", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-		// invented: one character past the ported 80_000 gate (P render.ts:86).
-		const over = `x${"y".repeat(80_000)}`;
-
-		// fails_when: a blob this size enters shiki.
-		expect(await theme.highlight(over, "ts")).toEqual([over]);
-		expect(engine.calls).toEqual([]);
-
-		// the gate is strict: exactly 80_000 characters reach the engine.
-		await theme.highlight("y".repeat(80_000), "ts");
-		expect(engine.calls).toHaveLength(1);
-	});
-
-	it("AC-3: empty code returns one empty line", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		// fails_when: an empty block enters shiki, or the panel path emits a stray newline.
-		expect(await theme.highlight("", "ts")).toEqual([""]);
-		expect(theme.highlightSync("", "ts")).toBe("");
-		expect(engine.calls).toEqual([]);
-	});
-});
-
-describe("createCodeTheme — degradation", () => {
-	it("AC-4: a throwing engine returns plain lines and nothing escapes", async () => {
-		const engine = countingEngine({ throwOnCall: true });
-		const log = logDouble();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }), log });
-
-		// fails_when: a shiki failure kills a render.
-		await expect(theme.highlight(CODE, "ts")).resolves.toEqual(["const a = 1;", "let b = 2;"]);
-		expect(theme.highlightSync(CODE, "ts")).toBe("const a = 1;\nlet b = 2;");
-		expect(log.entries.map((entry) => entry.key)).toEqual(["fail:ts"]);
-	});
-
-	it("AC-4: a throwing engine bind degrades the same way", async () => {
-		const engine = countingEngine({ throwOnBind: true });
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		// fails_when: a bind failure (shiki not loaded yet, a bad theme) escapes into the render path.
-		await expect(theme.highlight(CODE, "ts")).resolves.toEqual(["const a = 1;", "let b = 2;"]);
-	});
-
-	it("AC-4: an engine with no registry and no logger still highlights and still degrades", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind);
-
-		// fails_when: the optional collaborators are required, so a bare construction throws.
-		expect(await theme.highlight(CODE, "ts")).toEqual(["«dracula-soft»const a = 1;", "«dracula-soft»let b = 2;"]);
-	});
-});
-
-describe("createCodeTheme — contrast normalization (P render.ts:112-140)", () => {
-	it("drops a foreground below the readability floor and keeps the rest", async () => {
-		// invented: RGB triples chosen around the 72 luminance floor (20 below, 80 just above) and the
-		// indexed-black form P treated as dark.
-		const DIM = "\u001b[38;2;20;20;20m";
-		const INDEXED = "\u001b[38;5;0m";
-		const READABLE = "\u001b[38;2;80;80;80m";
-		const RESET = "\u001b[0m";
-		const bind: BindHighlightEngine = () => () => [
-			`${DIM}dim${RESET}`,
-			`${INDEXED}indexed${RESET}`,
-			`${READABLE}readable${RESET}`,
-		];
-		const theme = createCodeTheme(bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		// fails_when: an unreadable near-black token survives to the terminal.
-		expect(await theme.highlight("x", "ts")).toEqual([`dim${RESET}`, `indexed${RESET}`, `${READABLE}readable${RESET}`]);
-	});
-});

package/src/core/log.test.ts

@@ -1,127 +0,0 @@
-/**
- * log.test.ts — createLogger's behavior through its seam: logLine / logOnce in, drain() out (T-06).
- *
- * No module internals appear here; every assertion reads the entries a test or the future /render
- * panel would read back.
- *
- * shape: none — test module, no runtime unit for DSG-1's trigger table to select a shape for.
- */
-// invented fixtures: the keys, scopes, and messages below are plain strings with no upstream payload to
-// record; "tool:call-42" is the key shape named in src/core/types/log.ts.
-import { describe, expect, test, vi } from "vitest";
-import { createLogger } from "./log.ts";
-
-describe("createLogger", () => {
-	// spec: logOnce(key, …) appends one entry for a key; each distinct key appends its own.
-	// fails_when: a repeated key adds a duplicate entry, or a second key collides onto the first.
-	test("AC-1 logOnce keeps one entry per key, distinct keys do not collide", () => {
-		const logger = createLogger();
-
-		logger.logOnce("tool:call-42", "tool.bash", "first");
-		logger.logOnce("tool:call-42", "tool.bash", "repeat of the same key");
-		logger.logOnce("tool:call-43", "tool.bash", "a different key");
-
-		expect(logger.drain().map((entry) => entry.message)).toEqual(["first", "a different key"]);
-	});
-
-	// spec: any sequence of logging calls returns without throwing, including drain() on a logger with
-	//   no entries; the render path calls these, so a throw is a permanently broken row.
-	// fails_when: a logging call throws — the render path can be broken by its own diagnostics.
-	test("AC-2 no logging call throws, even on hostile text", () => {
-		const logger = createLogger();
-		const longText = "x".repeat(200_000);
-
-		expect(logger.drain()).toEqual([]);
-
-		expect(() => {
-			logger.logLine("", "");
-			logger.logLine("tool.bash", "line\nwith newlines\tand a 🖼 surrogate pair");
-			logger.logLine("tool.bash", longText);
-			logger.logOnce("tool:call-42", "tool.bash", longText);
-			logger.logOnce("tool:call-42", "tool.bash", "repeat");
-			logger.drain();
-		}).not.toThrow();
-
-		expect(logger.drain()).toEqual([]);
-	});
-
-	// spec: a logging call writes nothing to process.stdout or process.stderr — pi owns the terminal
-	//   for the TUI, so a write lands inside the rendered frame.
-	// fails_when: a diagnostic leaks to the terminal.
-	test("AC-3 logging writes neither stdout nor stderr", () => {
-		const logger = createLogger();
-		const stdout = vi.spyOn(process.stdout, "write").mockReturnValue(true);
-		const stderr = vi.spyOn(process.stderr, "write").mockReturnValue(true);
-
-		try {
-			logger.logLine("tool.bash", "line");
-			logger.logOnce("tool:call-42", "tool.bash", "once");
-			logger.logOnce("tool:call-42", "tool.bash", "once");
-			expect(logger.drain()).toHaveLength(2);
-			// Asserted before mockRestore(): restoring also discards the recorded calls.
-			expect(stdout).not.toHaveBeenCalled();
-			expect(stderr).not.toHaveBeenCalled();
-		} finally {
-			stdout.mockRestore();
-			stderr.mockRestore();
-		}
-	});
-
-	// spec: logLine(scope, message) leaves the entry attributable — that scope, that message, and a
-	//   capture time inside the call window.
-	// fails_when: entries cannot be attributed to the module that logged them.
-	test("AC-4 each entry keeps its scope, message, and capture time", () => {
-		const logger = createLogger();
-		const before = Date.now();
-
-		logger.logLine("find", "no matches");
-		logger.logOnce("tool:call-42", "tool.bash", "degraded row");
-
-		const after = Date.now();
-		const entries = logger.drain();
-
-		expect(entries.map((entry) => entry.scope)).toEqual(["find", "tool.bash"]);
-		expect(entries.map((entry) => entry.message)).toEqual(["no matches", "degraded row"]);
-		for (const entry of entries) {
-			expect(entry.time).toBeGreaterThanOrEqual(before);
-			expect(entry.time).toBeLessThanOrEqual(after);
-		}
-	});
-
-	// spec: past 256 entries the newest 256 survive in order and the oldest are dropped.
-	// fails_when: the buffer grows unbounded, or it drops the newest instead of the oldest.
-	test("AC-5 more than 256 entries keeps the newest 256 in order", () => {
-		const logger = createLogger();
-		for (let i = 0; i < 300; i += 1) logger.logLine("loop", `line-${i}`);
-
-		const messages = logger.drain().map((entry) => entry.message);
-
-		expect(messages).toHaveLength(256);
-		expect(messages.at(0)).toBe("line-44");
-		expect(messages.at(-1)).toBe("line-299");
-	});
-
-	// spec: drain() returns every captured entry in log order, and the buffer is empty afterwards.
-	// fails_when: a drained buffer still holds entries, so a panel re-shows the same lines.
-	test("drain() returns every captured entry and then empties the buffer", () => {
-		const logger = createLogger();
-		logger.logLine("tool.bash", "one");
-		logger.logLine("find", "two");
-
-		expect(logger.drain().map((entry) => entry.scope)).toEqual(["tool.bash", "find"]);
-		expect(logger.drain()).toEqual([]);
-	});
-
-	// spec: "at most one entry per key" is a property of the logger, not of the current buffer — a
-	//   panel that drains every frame must not re-emit a key's line.
-	// fails_when: drain() clears the dedup marks, so the same key logs again after a readout.
-	test("logOnce keeps a key spent across drain()", () => {
-		const logger = createLogger();
-		logger.logOnce("tool:call-42", "tool.bash", "once");
-		logger.drain();
-
-		logger.logOnce("tool:call-42", "tool.bash", "again");
-
-		expect(logger.drain()).toEqual([]);
-	});
-});