@zenodinh/pi-render 0.1.0 → 0.1.2

package/src/core/settings.test.ts

@@ -1,183 +0,0 @@
-// Fixture provenance — every document below is invented: pi-render itself writes this file, so there
-// is no upstream payload to record; the file bytes are the fixture. The log double and the fs mock are
-// local, so this ticket stays independent of T-06's logger implementation.
-
-// The `node:fs` ESM namespace is not configurable, so read/write/rename are wrapped to *observe* the
-// real syscalls without replacing them.
-vi.mock("node:fs", async (importOriginal) => {
-	const actual = await importOriginal<typeof import("node:fs")>();
-	return {
-		...actual,
-		readFileSync: vi.fn(actual.readFileSync),
-		writeFileSync: vi.fn(actual.writeFileSync),
-		renameSync: vi.fn(actual.renameSync),
-	};
-});
-
-// shape: none — test module: every behavior is asserted only through the createSettingsStore seam.
-import * as fs from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import type { LogEntry, Logger, SettingsDoc } from "../core/types.ts";
-import { createSettingsStore } from "./settings.ts";
-
-const DEFAULTS: SettingsDoc = { version: 1, modules: {} };
-
-function readCount(): number {
-	return vi.mocked(fs.readFileSync).mock.calls.length;
-}
-
-function createRecordingLogger(): Logger & { entries: LogEntry[] } {
-	const entries: LogEntry[] = [];
-	const push = (scope: string, message: string): void => {
-		entries.push({ scope, message, time: Date.now() });
-	};
-	return {
-		entries,
-		logLine: push,
-		logOnce: (_key, scope, message) => push(scope, message),
-		drain: () => entries.splice(0),
-	};
-}
-
-describe("core/settings — persisted settings document", () => {
-	let dir: string;
-	let path: string;
-
-	beforeEach(() => {
-		vi.clearAllMocks();
-		dir = fs.mkdtempSync(join(tmpdir(), "pi-render-settings-"));
-		path = join(dir, "settings.json");
-	});
-
-	afterEach(() => {
-		vi.unstubAllEnvs();
-		fs.rmSync(dir, { recursive: true, force: true });
-	});
-
-	test("default path: with no injected path the doc lands under the host agent dir", () => {
-		vi.stubEnv("PI_CODING_AGENT_DIR", dir);
-		const doc: SettingsDoc = { version: 1, modules: { "row.bash": { enabled: false } } };
-		createSettingsStore().save(doc);
-
-		expect(JSON.parse(fs.readFileSync(join(dir, "pi-render", "settings.json"), "utf8"))).toEqual(doc);
-	});
-
-	test("AC-1: after the first load every load is served from memory, not the disk", () => {
-		const store = createSettingsStore({ path });
-		expect(store.load()).toEqual(DEFAULTS);
-		expect(readCount()).toBe(1); // the one and only disk read
-
-		expect(store.load()).toEqual(DEFAULTS);
-		expect(store.load()).toEqual(DEFAULTS);
-		expect(readCount()).toBe(1); // a re-read per call is the #21 contributor returning
-
-		// A cache miss would be observable: the file now holds a different doc, yet the cached one reads back.
-		fs.writeFileSync(path, JSON.stringify({ version: 1, modules: { "row.bash": { enabled: false } } }));
-		expect(store.load()).toEqual(DEFAULTS);
-		expect(readCount()).toBe(1);
-	});
-
-	test("AC-1: save() reaches the disk and refreshes the cache without a read", () => {
-		const store = createSettingsStore({ path });
-		store.load();
-		const doc2: SettingsDoc = { version: 1, modules: { "row.bash": { enabled: false, settings: { collapseAt: 3 } } } };
-		store.save(doc2);
-
-		expect(readCount()).toBe(1); // save wrote; it did not read
-		expect(store.load()).toEqual(doc2);
-		expect(readCount()).toBe(1);
-		expect(createSettingsStore({ path }).load()).toEqual(doc2); // fresh store: the save is durable
-		expect(readCount()).toBe(2);
-
-		// Cached: replacing the file's content does not change what this store returns.
-		fs.writeFileSync(path, JSON.stringify({ version: 1, modules: {} }));
-		expect(store.load()).toEqual(doc2);
-		expect(readCount()).toBe(2);
-	});
-
-	test("AC-2: a malformed doc returns defaults with exactly one log line, no throw", () => {
-		fs.writeFileSync(path, "{ not json");
-		const log = createRecordingLogger();
-		const store = createSettingsStore({ path, logger: log });
-
-		expect(() => store.load()).not.toThrow();
-		expect(store.load()).toEqual(DEFAULTS);
-		expect(log.entries).toHaveLength(1);
-	});
-
-	test("AC-2: a parseable non-document returns defaults with exactly one log line, no throw", () => {
-		fs.writeFileSync(path, JSON.stringify({ version: 1, modules: "not-a-map" }));
-		const log = createRecordingLogger();
-		const store = createSettingsStore({ path, logger: log });
-
-		expect(() => store.load()).not.toThrow();
-		expect(store.load()).toEqual(DEFAULTS);
-		expect(log.entries).toHaveLength(1);
-	});
-
-	test("AC-2: an absent file is a first run, not a fault — defaults with no log line", () => {
-		const log = createRecordingLogger();
-		const store = createSettingsStore({ path, logger: log });
-
-		expect(store.load()).toEqual(DEFAULTS);
-		expect(log.entries).toHaveLength(0);
-	});
-
-	test("AC-3: an entry missing its fields reads defaults while the other entry persists", () => {
-		fs.writeFileSync(
-			path,
-			JSON.stringify({
-				modules: {
-					"row.bash": { enabled: false, settings: { collapseAt: 3 } },
-					"content.table": {},
-				},
-			}),
-		);
-
-		const doc = createSettingsStore({ path }).load();
-		expect(doc.version).toBe(1); // doc-level default filled
-		expect(doc.modules["row.bash"]).toEqual({ enabled: false, settings: { collapseAt: 3 } });
-		expect(doc.modules["content.table"]).toEqual({ enabled: true });
-	});
-
-	test("AC-3: a module key absent from the doc does not wipe the other keys", () => {
-		fs.writeFileSync(path, JSON.stringify({ version: 1, modules: { "row.bash": { enabled: false } } }));
-
-		const doc = createSettingsStore({ path }).load();
-		expect(doc.version).toBe(1);
-		expect(doc.modules["row.bash"]).toEqual({ enabled: false });
-		expect("content.table" in doc.modules).toBe(false); // absent here; the caller applies that module's defaults
-	});
-
-	test("AC-4: the final path is never written in place — only swapped by rename", () => {
-		const store = createSettingsStore({ path });
-		const doc1: SettingsDoc = { version: 1, modules: { "row.bash": { enabled: true } } };
-		const doc2: SettingsDoc = { version: 1, modules: { "content.table": { enabled: false } } };
-		store.save(doc1);
-
-		const writeSpy = vi.mocked(fs.writeFileSync);
-		const renameSpy = vi.mocked(fs.renameSync);
-		writeSpy.mockClear();
-		renameSpy.mockClear();
-		store.save(doc2);
-
-		// A write to `path` itself is the torn-write case: the final file is only ever complete.
-		expect(writeSpy.mock.calls.map(([file]) => String(file))).toEqual([`${path}.tmp`]);
-		expect(renameSpy.mock.calls.map(([from, to]) => [String(from), String(to)])).toEqual([[`${path}.tmp`, path]]);
-		expect(JSON.parse(fs.readFileSync(path, "utf8"))).toEqual(doc2);
-		expect(fs.existsSync(`${path}.tmp`)).toBe(false); // no leftover temp file
-	});
-
-	test("AC-4: a reader of the final path sees the old doc complete, then the new doc complete", () => {
-		const store = createSettingsStore({ path });
-		const doc1: SettingsDoc = { version: 1, modules: { "row.bash": { enabled: true } } };
-		const doc2: SettingsDoc = { version: 1, modules: { "content.table": { enabled: false } } };
-		store.save(doc1);
-		expect(JSON.parse(fs.readFileSync(path, "utf8"))).toEqual(doc1);
-
-		store.save(doc2);
-		expect(JSON.parse(fs.readFileSync(path, "utf8"))).toEqual(doc2);
-	});
-});

package/src/renderers/content/artifacts/artifacts.test.ts

@@ -1,199 +0,0 @@
-/**
- * artifacts.test.ts — the artifacts seam: renderDiagram / warmup / status (engines.ts) and the cache
- * (cache.ts), driven through fake engines and temp cache directories only (T-25).
- *
- * The first describe block is the predecessor's cache test ported unchanged (AC-4 parity); the second
- * is this ticket's behavior spec: one engine run per repeated fence, a missing binary reported without a
- * spawn, and a bounded store that never fails a render.
- *
- * shape: none — test module, no runtime unit for DSG-1's trigger table to select a shape for.
- */
-
-import { existsSync, mkdtempSync, readdirSync, readFileSync, truncateSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { beforeEach, describe, expect, it } from "vitest";
-import {
-	type CacheMeta,
-	createArtifactCache,
-	evictIfNeeded,
-	getRenderedEntry,
-	putRenderedEntry,
-	putRenderedSource,
-} from "./cache.ts";
-import { type DiagramResult, type Engine, renderDiagram, status, warmup } from "./engines.ts";
-import type { LocalSpawn } from "./local-binary.ts";
-
-// recorded-from: generated 1x1 RGBA PNG fixture, 2026-10-03
-const PNG_BYTES = Buffer.from(
-	"89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c4890000000d49444154789c63300e5df51f0004230232e7bf98d60000000049454e44ae426082",
-	"hex",
-);
-
-let dir: string;
-
-beforeEach(() => {
-	dir = mkdtempSync(join(tmpdir(), "pretty-cache-"));
-});
-
-function meta(createdAt: string): CacheMeta {
-	return { source: "plantuml", mode: "image", mime: "image/png", rows: 4, widthCells: 40, createdAt };
-}
-
-describe("render cache", () => {
-	it("round-trips pairs, misses cleanly, and evicts oldest-first past the byte cap", () => {
-		putRenderedEntry("aaa", PNG_BYTES, meta("2026-10-02T00:00:00.000Z"), { cacheDir: dir });
-		putRenderedEntry("bbb", PNG_BYTES, meta("2026-10-02T00:01:00.000Z"), { cacheDir: dir });
-
-		const hit = getRenderedEntry("aaa", { cacheDir: dir });
-		expect(hit?.png.equals(PNG_BYTES)).toBe(true);
-		expect(hit?.meta).toEqual(meta("2026-10-02T00:00:00.000Z"));
-		expect(getRenderedEntry("missing", { cacheDir: dir })).toBeUndefined();
-		expect(existsSync(join(dir, "aaa.png.tmp"))).toBe(false);
-		expect(existsSync(join(dir, "aaa.meta.json.tmp"))).toBe(false);
-
-		// The saved source rides the same key, written atomically and evicted with
-		// its pair.
-		const sourcePath = putRenderedSource("aaa", "@startuml\nA -> B\n@enduml\n", "puml", { cacheDir: dir });
-		expect(sourcePath).toBe(join(dir, "aaa.src.puml"));
-		expect(readFileSync(sourcePath as string, "utf8")).toBe("@startuml\nA -> B\n@enduml\n");
-
-		// Seed 30 backdated entries whose PNGs are 10 MiB each (sparse): 300 MiB
-		// crosses the 256 MiB cap, so the oldest must leave while recent pairs stay.
-		for (let i = 0; i < 30; i++) {
-			const key = `seed${i.toString().padStart(2, "0")}`;
-			writeFileSync(
-				join(dir, `${key}.meta.json`),
-				JSON.stringify(meta(`2026-10-01T00:${String(i).padStart(2, "0")}:00.000Z`)),
-			);
-			const png = join(dir, `${key}.png`);
-			writeFileSync(png, Buffer.alloc(0));
-			truncateSync(png, 10 * 1024 * 1024);
-		}
-		writeFileSync(join(dir, "seed00.src.puml"), "stale source");
-
-		evictIfNeeded({ cacheDir: dir });
-
-		expect(existsSync(join(dir, "seed00.png"))).toBe(false);
-		expect(existsSync(join(dir, "seed00.meta.json"))).toBe(false);
-		expect(existsSync(join(dir, "seed00.src.puml"))).toBe(false);
-		expect(existsSync(join(dir, "seed29.meta.json"))).toBe(true);
-		expect(existsSync(join(dir, "aaa.png"))).toBe(true);
-		expect(existsSync(join(dir, "aaa.src.puml"))).toBe(true);
-	});
-});
-
-describe("artifact render seam", () => {
-	// spec: renderDiagram("dot", source, …) twice with the same source, mode and width runs the engine
-	//   once and returns the identical artifact — a repeated fence is a file read, not a render.
-	// fails_when: duplicate engine runs (every re-render of an answer re-spawns/re-renders).
-	it("AC-1 a repeated fence runs its engine exactly once and returns identical output", () => {
-		let calls = 0;
-		// invented: the counting engine is the whole fixture — there is no upstream payload to record.
-		const fakeViz: Engine = {
-			id: "viz",
-			warmup: async () => {},
-			status: () => true,
-			render: (source) => {
-				calls += 1;
-				return { kind: "svg", svg: `<svg>${source}</svg>` };
-			},
-		};
-		const cache = createArtifactCache({ cacheDir: dir });
-		const options = { cache, engines: { viz: fakeViz } };
-
-		const first: DiagramResult = renderDiagram("dot", "digraph { a -> b }", options);
-		const second: DiagramResult = renderDiagram("dot", "digraph { a -> b }", options);
-
-		expect(calls).toBe(1);
-		expect(second.kind).toBe("svg");
-		expect(second).toEqual(first);
-	});
-
-	// spec: on a machine whose plantuml candidate list holds no file, status() reports the form
-	//   unavailable and renderDiagram throws the install hint — the caller then keeps the raw fence.
-	// fails_when: a spawn is attempted for a binary that is known to be missing, or the render crashes.
-	it("AC-2 a missing plantuml binary reports unavailable and attempts no spawn", () => {
-		const spawned: string[] = [];
-		const spawn: LocalSpawn = (cmd) => {
-			spawned.push(cmd);
-			return { status: 0, signal: null, stdout: Buffer.alloc(0), stderr: Buffer.alloc(0) };
-		};
-		// invented: an empty candidate list on linux — the machine-independent "not installed" state.
-		const missing = { platform: "linux" as const, exists: () => false };
-
-		expect(status(missing).plantuml).toBe(false);
-		expect(() =>
-			renderDiagram("plantuml", "@startuml\nA -> B\n@enduml\n", {
-				cache: createArtifactCache({ cacheDir: dir }),
-				prereqs: missing,
-				spawn,
-			}),
-		).toThrow(/apt install plantuml/);
-		expect(spawned).toEqual([]);
-	});
-
-	// spec: a cache holding more entries than the 2048 cap loses its oldest entries on eviction.
-	// fails_when: the store grows without limit.
-	it("AC-3 eviction shrinks an over-cap store to the cap, oldest first", () => {
-		const total = 2050;
-		for (let i = 0; i < total; i++) {
-			const key = `e${i.toString().padStart(4, "0")}`;
-			writeFileSync(join(dir, `${key}.png`), Buffer.from("x"));
-			writeFileSync(
-				join(dir, `${key}.meta.json`),
-				JSON.stringify(meta(new Date(Date.UTC(2026, 9, 1, 0, 0, i)).toISOString())),
-			);
-		}
-
-		evictIfNeeded({ cacheDir: dir });
-
-		const entries = readdirSync(dir).filter((name) => name.endsWith(".meta.json"));
-		expect(entries.length).toBeLessThanOrEqual(2048);
-		expect(existsSync(join(dir, "e0000.meta.json"))).toBe(false);
-		expect(existsSync(join(dir, "e2049.meta.json"))).toBe(true);
-	});
-
-	// spec: an unusable cache directory (here: a path below a regular file) is a lost optimization, not a
-	//   failed artifact — the render still returns its result and eviction still returns quietly.
-	// fails_when: a cache write or eviction error propagates into the render path.
-	it("AC-3 a failing store never fails the render or throws from eviction", () => {
-		const blocker = join(dir, "blocker");
-		writeFileSync(blocker, "");
-		const cache = createArtifactCache({ cacheDir: join(blocker, "cache") });
-		// invented: the counting engine is the whole fixture — no upstream payload to record.
-		const fakeViz: Engine = {
-			id: "viz",
-			warmup: async () => {},
-			status: () => true,
-			render: () => ({ kind: "svg", svg: "<svg/>" }),
-		};
-
-		const result = renderDiagram("dot", "digraph { a -> b }", { cache, engines: { viz: fakeViz } });
-
-		expect(result.kind).toBe("svg");
-		expect(() => cache.evict()).not.toThrow();
-	});
-
-	// spec: warmup() is what lets the synchronous render seam call an asynchronous engine: after it, the
-	//   three wasm engines report ready.
-	// fails_when: an engine is called cold, or a warm-up failure is thrown instead of reported.
-	it("warmup reports the wasm engines ready", async () => {
-		const warmed = await warmup();
-
-		expect(warmed.resvg).toBe(true);
-		expect(warmed.viz).toBe(true);
-		expect(warmed.canvaskit).toBe(true);
-	});
-
-	// spec: a warmed viz engine turns a DOT fence into SVG through the same seam a fence uses.
-	// fails_when: the ported engine call cannot render, or the result kind drifts from vector.
-	it("a warmed viz engine renders a dot fence to SVG", async () => {
-		await warmup();
-
-		const result = renderDiagram("dot", "digraph { a -> b }", { cache: createArtifactCache({ cacheDir: dir }) });
-
-		expect(result.kind).toBe("svg");
-		if (result.kind === "svg") expect(result.svg).toContain("<svg");
-	});
-});

package/src/renderers/content/artifacts/cards.test.ts

@@ -1,216 +0,0 @@
-/**
- * cards.test.ts — the artifacts seam: createArtifactServer() (server.ts) and the card renderer
- * (cards.ts). The server tests start a REAL server on an ephemeral port and issue real HTTP requests;
- * the card tests drive the renderer with the marker paint double, so a wrong paint role is visible.
- *
- * shape: none — test module, no runtime unit for DSG-1's trigger table to select a shape for.
- */
-
-import { once } from "node:events";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { connect } from "node:net";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { visibleWidth } from "@earendil-works/pi-tui";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { markerPaint } from "../../../../test/fakes/index.ts";
-import { createLogger } from "../../../core/log.ts";
-import { artifactTitle, imageLineMetadata, renderArtifactCard } from "./cards.ts";
-import { type ArtifactListen, type ArtifactServer, createArtifactServer } from "./server.ts";
-
-// recorded-from: generated 1x1 RGBA PNG fixture, 2026-10-03 (the predecessor's emit.test.ts fixture)
-const PNG_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGMwDl31HwAEIwIy57+Y1gAAAABJRU5ErkJggg==";
-// invented: a tiny real SVG whose body and extension pin the served content-type.
-const SVG_BODY = '<svg xmlns="http://www.w3.org/2000/svg"><title>demo</title></svg>';
-
-let dir: string;
-let artifactPath: string;
-
-beforeAll(() => {
-	dir = mkdtempSync(join(tmpdir(), "pi-render-cards-"));
-	artifactPath = join(dir, "diagram.svg");
-	writeFileSync(artifactPath, SVG_BODY);
-});
-
-afterAll(() => {
-	rmSync(dir, { recursive: true, force: true });
-});
-
-async function started(): Promise<{ server: ArtifactServer; url: string }> {
-	const server = createArtifactServer();
-	const state = await server.start();
-	if (!state.ok) throw new Error(`server did not start: ${state.reason}`);
-	return { server, url: state.url };
-}
-
-describe("createArtifactServer", () => {
-	it("AC-1 binds 127.0.0.1 on an ephemeral port", async () => {
-		const { server, url } = await started();
-		try {
-			const address = new URL(url);
-			// fails_when: the bind is on another interface, or the port is not ephemeral.
-			expect(address.hostname).toBe("127.0.0.1");
-			expect(Number(address.port)).toBeGreaterThan(0);
-			expect(url.startsWith("http://127.0.0.1:")).toBe(true);
-			// A real request to that loopback address proves the listener answers there.
-			expect((await fetch(`${url}/a/nothing-carded`)).status).toBe(404);
-		} finally {
-			await server.stop();
-		}
-	});
-
-	it("AC-2 serves a carded path and 404s everything else with no listing", async () => {
-		const { server, url } = await started();
-		try {
-			const carded = server.urlFor(artifactPath);
-			expect(carded).toBeDefined();
-			expect(carded?.startsWith("http://127.0.0.1:")).toBe(true);
-			// One carded file keeps one opaque id, so the link is stable across re-renders.
-			expect(server.urlFor(artifactPath)).toBe(carded);
-
-			const ok = await fetch(carded as string);
-			expect(ok.status).toBe(200);
-			expect(ok.headers.get("content-type")).toBe("image/svg+xml");
-			expect(await ok.text()).toBe(SVG_BODY);
-
-			// fails_when: anything not carded is served — a listing, a request-named path, or a probe.
-			expect((await fetch(`${url}/`)).status).toBe(404);
-			expect((await fetch(`${url}/a/`)).status).toBe(404);
-			expect((await fetch(`${url}/a/unknown-id`)).status).toBe(404);
-			expect((await fetch(`${url}${artifactPath}`)).status).toBe(404);
-			expect((await fetch(`${url}/etc/passwd`)).status).toBe(404);
-		} finally {
-			await server.stop();
-		}
-	});
-
-	it("AC-3 a failed bind reports degraded state and renders the card on a file:// link", async () => {
-		const log = createLogger();
-		// invented: the injected listen is the whole fixture — a bind failure without an occupied port.
-		const listen: ArtifactListen = async () => {
-			throw new Error("EADDRINUSE: address already in use");
-		};
-		const server = createArtifactServer({ log, listen });
-
-		const state = await server.start();
-		expect(state.ok).toBe(false);
-		if (state.ok) return;
-		expect(state.reason).toContain("EADDRINUSE");
-
-		// invented: a short path so the degraded file:// target still fits the card line (the card only
-		// builds the URL; the served-path tests above use the real artifact).
-		const path = "/tmp/pi-render-degraded.svg";
-		const paint = markerPaint();
-		const spec = { typeLabel: "svg", title: "demo", path, width: 64 };
-		// fails_when: the failed bind breaks the card instead of degrading only the Open link.
-		const card = renderArtifactCard(server, spec, paint);
-		renderArtifactCard(server, spec, paint);
-		expect(card).toContain("demo");
-		expect(card).toContain("[Open (⌘click)](file:///tmp/pi-render-degraded.svg)");
-
-		// The cause is named exactly once, on the first click — not on every re-render.
-		const degraded = log.drain().filter((entry) => entry.message.includes("Open link degraded"));
-		expect(degraded).toHaveLength(1);
-	});
-
-	it("drops an idle request past the budget and logs the reason", async () => {
-		const log = createLogger();
-		const server = createArtifactServer({ log, requestTimeoutMs: 50 });
-		const state = await server.start();
-		if (!state.ok) throw new Error(state.reason);
-		const port = Number(new URL(state.url).port);
-		const socket = connect(port, "127.0.0.1");
-		await once(socket, "connect");
-		try {
-			// Nothing is sent: the server's own budget must close the socket.
-			await Promise.race([
-				once(socket, "close"),
-				new Promise((_, reject) => setTimeout(() => reject(new Error("socket was not dropped")), 2000)),
-			]);
-			const messages = log.drain().map((entry) => entry.message);
-			expect(messages.some((message) => message.includes("request dropped after 50ms"))).toBe(true);
-		} finally {
-			socket.destroy();
-			await server.stop();
-		}
-	});
-
-	it("stop() releases the port so the loopback URL stops answering", async () => {
-		const first = await started();
-		const url = first.url;
-		await first.server.stop();
-		// fails_when: stop() leaves the listener bound.
-		await expect(fetch(`${url}/a/x`)).rejects.toThrow();
-		const second = await started();
-		await second.server.stop();
-	});
-});
-
-describe("renderArtifactCard", () => {
-	it("renders the box with the server's Open link as the title-line action", async () => {
-		const { server } = await started();
-		try {
-			const paint = markerPaint();
-			const openUrl = server.urlFor(artifactPath) as string;
-			const out = renderArtifactCard(server, { typeLabel: "svg", title: "demo", path: artifactPath, width: 64 }, paint);
-
-			// Golden geometry at 64 columns: header run 56, content 60, bottom run 62; the frame carries
-			// the rule role and every text row the quote role. The temp path varies in length, so its
-			// pinned 60-column chunks are rebuilt here; the widths and row counts are literals.
-			const link = `[Open (⌘click)](${openUrl})`;
-			const titlePad = " ".repeat(60 - visibleWidth("demo") - visibleWidth(link));
-			const copyPad = " ".repeat(60 - visibleWidth("Copy path (⌥C)"));
-			const pathRows: string[] = [];
-			for (let at = 0; at < artifactPath.length; at += 60) pathRows.push(artifactPath.slice(at, at + 60));
-			const golden = [
-				paint.rule(`╭─ svg ${"─".repeat(56)}╮`),
-				`${paint.rule("│")} ${paint.quote("demo")}${titlePad}${link} ${paint.rule("│")}`,
-				`${paint.rule("│")} ${paint.quote("Copy path (⌥C)")}${copyPad} ${paint.rule("│")}`,
-				...pathRows.map(
-					(chunk) =>
-						`${paint.rule("│")} ${paint.quote(chunk)}${" ".repeat(60 - visibleWidth(chunk))} ${paint.rule("│")}`,
-				),
-				paint.rule(`╰${"─".repeat(62)}╯`),
-			].join("  \n");
-			// fails_when: the card geometry, the Open link, or the paint roles drift.
-			expect(out).toBe(`${golden}\n`);
-			// The field bug class: a line whose RAW width exceeds the card gets host-wrapped, breaking the link.
-			for (const line of out.split("\n")) expect(visibleWidth(line.trimEnd())).toBeLessThanOrEqual(64);
-		} finally {
-			await server.stop();
-		}
-	});
-
-	it("degrades the link to the plain label when the target cannot fit the line", async () => {
-		const log = createLogger();
-		const server = createArtifactServer({ log, listen: async () => Promise.reject(new Error("down")) });
-		await server.start();
-		// invented: a path long enough that its file:// URL outgrows the 60-column content line.
-		const longPath = `/${"x".repeat(120)}.svg`;
-		const out = renderArtifactCard(server, { typeLabel: "svg", title: "t", path: longPath, width: 64 }, markerPaint());
-		const titleLine = out.split("  \n")[1] ?? "";
-		// fails_when: an unfittable link is emitted anyway and the host wraps it into literal brackets.
-		expect(titleLine).toContain("Open (⌘click)");
-		expect(titleLine).not.toContain("](file://");
-		expect(visibleWidth(titleLine.trimEnd())).toBeLessThanOrEqual(64);
-	});
-});
-
-describe("artifactTitle", () => {
-	it("takes the artifact's own name where the source carries one, and the form otherwise", () => {
-		// invented: fence sources pinning the four title sources and the fallback.
-		expect(artifactTitle("plantuml", '@startuml "Payments"\nA -> B\n@enduml')).toBe("Payments");
-		expect(artifactTitle("plantuml", "@startuml\ntitle Order flow\nA -> B\n@enduml")).toBe("Order flow");
-		expect(artifactTitle("svg", "<svg><title>Logo</title></svg>")).toBe("Logo");
-		expect(artifactTitle("html", "<h1>Report</h1>")).toBe("Report");
-		expect(artifactTitle("dot", "digraph { a -> b }")).toBe("dot");
-	});
-});
-
-describe("imageLineMetadata", () => {
-	it("reports a PNG's transcript row count and one row for unparseable bytes", () => {
-		// The 1x1 PNG at the default 60-cell width fits as 30 rows (8x16 cell ratio).
-		expect(imageLineMetadata(PNG_BASE64)).toEqual({ rows: 30 });
-		expect(imageLineMetadata("not-a-png")).toEqual({ rows: 1 });
-	});
-});