@zenodinh/pi-render 0.1.0 → 0.1.3

package/src/renderers/content/artifacts/engines-extra.test.ts

@@ -1,556 +0,0 @@
-/**
- * engines-extra.test.ts — the artifacts engine seam's spawn paths (T-25 follow-up): the four form
- * dispatches, the PlantUML and HTML binary boundaries, and the cache interaction, driven entirely
- * through renderDiagram's injectable {engines, cache, prereqs, spawn, log} seam.
- *
- * Complements artifacts.test.ts (the ported cache tests plus the dedup and missing-binary contracts)
- * and leaves it untouched. Every test carries a spec + fails_when line; no test reaches past the seam,
- * and no test runs a real plantuml or browser.
- *
- * shape: none — test module, no runtime unit for DSG-1's trigger table to select a shape for.
- */
-
-import { existsSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
-import { beforeEach, describe, expect, it } from "vitest";
-import { createLogger } from "../../../core/log.ts";
-import { type ArtifactCache, type CacheMeta, createArtifactCache } from "./cache.ts";
-import { type Engine, renderDiagram, status, warmup } from "./engines.ts";
-import type { LocalSpawn, LocalSpawnResult } from "./local-binary.ts";
-
-// recorded-from: the 1x1 RGBA PNG fixture generated for the artifacts tests, 2026-10-03 (the same bytes
-// artifacts.test.ts uses).
-const PNG_BYTES = Buffer.from(
-	"89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c4890000000d49444154789c63300e5df51f0004230232e7bf98d60000000049454e44ae426082",
-	"hex",
-);
-
-// invented: absolute paths handed to the *injected* spawn; no real binary is ever executed.
-const FAKE_PLANTUML = "/opt/pi-render-test/bin/plantuml";
-const FAKE_BROWSER = "/opt/pi-render-test/chrome-headless-shell";
-const SOURCE = "@startuml\nAlice -> Bob\n@enduml";
-
-// invented: the canned result an exit-0 process reports; there is no upstream payload to record.
-const OK: LocalSpawnResult = { status: 0, signal: null, stdout: Buffer.alloc(0), stderr: Buffer.alloc(0) };
-
-interface SpawnCall {
-	cmd: string;
-	args: string[];
-}
-
-function only<T>(items: T[]): T {
-	const first = items[0];
-	if (first === undefined) throw new Error("test fixture: expected exactly one recorded item");
-	return first;
-}
-
-/** The thrown error's message; a non-throwing call is itself a failure. Exact-match assertions follow. */
-function messageOf(fn: () => unknown): string {
-	try {
-		fn();
-	} catch (error) {
-		return error instanceof Error ? error.message : String(error);
-	}
-	throw new Error("test fixture: expected the call to throw");
-}
-
-function argAfter(args: string[], flag: string): string {
-	const index = args.indexOf(flag);
-	const value = index === -1 ? undefined : args[index + 1];
-	if (value === undefined) throw new Error(`test fixture: no ${flag} in [${args.join(" ")}]`);
-	return value;
-}
-
-function argWithPrefix(args: string[], prefix: string): string {
-	const found = args.find((arg) => arg.startsWith(prefix));
-	if (found === undefined) throw new Error(`test fixture: no argument starting with ${prefix}`);
-	return found;
-}
-
-/**
- * invented: the recording spawn is the fixture — it captures cmd/argv/timeout and delegates to the
- * per-test behavior that writes whatever the real binary would have written.
- */
-function recorder(behavior?: (call: SpawnCall) => LocalSpawnResult) {
-	const calls: Array<SpawnCall & { timeoutMs: number }> = [];
-	const spawn: LocalSpawn = (cmd, args, opts) => {
-		calls.push({ cmd, args, timeoutMs: opts.timeoutMs });
-		return behavior?.({ cmd, args }) ?? OK;
-	};
-	return { calls, spawn };
-}
-
-/** invented: plantuml's observed behavior — it writes its output into the `-o` directory. */
-function plantumlOutput(name: string, body: string): (call: SpawnCall) => LocalSpawnResult {
-	return ({ args }) => {
-		writeFileSync(join(argAfter(args, "-o"), name), body);
-		return OK;
-	};
-}
-
-/** invented: the browser's observed behavior — it writes the file named by `--screenshot=`. */
-function screenshot(png: Buffer): (call: SpawnCall) => LocalSpawnResult {
-	return ({ args }) => {
-		writeFileSync(argWithPrefix(args, "--screenshot=").slice("--screenshot=".length), png);
-		return OK;
-	};
-}
-
-function spawnError(code: string): LocalSpawnResult {
-	return { status: null, signal: null, error: Object.assign(new Error(`spawn failed: ${code}`), { code }) };
-}
-
-function countingViz(runs: () => void): Engine {
-	return {
-		id: "viz",
-		warmup: async () => {},
-		status: () => true,
-		render: (source) => {
-			runs();
-			return { kind: "svg", svg: `<svg>${source}</svg>` };
-		},
-	};
-}
-
-/** A cache bound to its own fresh temp dir, so a render can never be answered by another one's write. */
-function freshCache(): ArtifactCache {
-	return createArtifactCache({ cacheDir: mkdtempSync(join(tmpdir(), "pi-render-engines-cache-")) });
-}
-
-let dir: string;
-let cacheDir: string;
-let cache: ArtifactCache;
-
-beforeEach(() => {
-	dir = mkdtempSync(join(tmpdir(), "pi-render-engines-extra-"));
-	cacheDir = mkdtempSync(join(tmpdir(), "pi-render-engines-cache-"));
-	cache = createArtifactCache({ cacheDir });
-});
-
-describe("engine pre-warm", () => {
-	// The default engine table is a module-level lazy singleton, so this block runs before the warmup()
-	// below; vitest runs one file's tests in declaration order.
-
-	// spec: before warmup(), the three wasm engines report not-ready and a dot fence throws the named
-	//   cold-engine error — the synchronous render seam never calls an uninitialised instance.
-	// fails_when: a cold engine renders, or the caller gets a TypeError instead of the named error.
-	it("a cold engine set reports not-ready and rejects a dot fence by name", () => {
-		expect(status()).toMatchObject({ viz: false, resvg: false, canvaskit: false });
-
-		expect(messageOf(() => renderDiagram("dot", "digraph { a -> b }", { cache }))).toBe("dot engine not warmed");
-	});
-
-	// spec: warmup() is what lets the synchronous render seam call the asynchronous engines: afterwards
-	//   they report ready and a dot fence renders to SVG through the default viz engine.
-	// fails_when: an engine is called cold, or a warm-up failure is thrown instead of reported.
-	it("warmup flips the wasm engines ready and a dot fence then renders", async () => {
-		const warmed = await warmup();
-
-		expect(warmed).toMatchObject({ viz: true, resvg: true, canvaskit: true });
-
-		const result = renderDiagram("dot", "digraph { a -> b }", { cache });
-		expect(result.kind).toBe("svg");
-		if (result.kind === "svg") expect(result.svg).toContain("<svg");
-	});
-});
-
-describe("plantuml form — the JVM spawn boundary", () => {
-	// spec: a plantuml fence writes its source to diagram.puml in the given workDir, spawns the pinned
-	//   absolute binary with `-tsvg -o <dir> <file>` under the 5s local timeout, and returns the .svg
-	//   file plantuml actually wrote.
-	// fails_when: the argv, the input file, or the output discovery drifts — the JVM then renders
-	//   nothing and every plantuml fence falls back to the raw fence.
-	it("renders through the pinned binary and reads the output it discovers", () => {
-		const { calls, spawn } = recorder(plantumlOutput("diagram.svg", "<svg>rendered</svg>"));
-
-		const result = renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn, cache, workDir: dir });
-
-		expect(result).toEqual({ kind: "svg", svg: "<svg>rendered</svg>" });
-		const call = only(calls);
-		expect(call.cmd).toBe(FAKE_PLANTUML);
-		expect(call.args).toEqual(["-tsvg", "-o", dir, join(dir, "diagram.puml")]);
-		expect(call.timeoutMs).toBe(5_000);
-		expect(readFileSync(join(dir, "diagram.puml"), "utf8")).toBe(SOURCE);
-	});
-
-	// spec: the output file is discovered by extension and picked deterministically, because plantuml
-	//   names it after the diagram title when the source has one.
-	// fails_when: the discovery takes an arbitrary match, so the same fence renders different bytes.
-	it("discovers the output by extension and picks it deterministically", () => {
-		const { spawn } = recorder(({ args }) => {
-			const target = argAfter(args, "-o");
-			writeFileSync(join(target, "zeta.svg"), "<svg>zeta</svg>");
-			writeFileSync(join(target, "alpha.svg"), "<svg>alpha</svg>");
-			return OK;
-		});
-
-		const result = renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn, cache });
-
-		expect(result).toEqual({ kind: "svg", svg: "<svg>alpha</svg>" });
-	});
-
-	// spec: text mode asks for `-tutxt`, returns the Unicode art, and never caches it — the art is a
-	//   view of the render, not an artifact.
-	// fails_when: text mode caches, or reuses, the font-dependent art of another terminal width.
-	it("renders text art with -tutxt and writes no artifact to the cache", () => {
-		const { calls, spawn } = recorder(plantumlOutput("diagram.utxt", "Alice -> Bob"));
-		const options = { plantumlPath: FAKE_PLANTUML, spawn, cache, mode: "text" as const };
-
-		expect(renderDiagram("plantuml", SOURCE, options)).toEqual({ kind: "text", art: "Alice -> Bob" });
-		expect(renderDiagram("plantuml", SOURCE, options)).toEqual({ kind: "text", art: "Alice -> Bob" });
-
-		expect(only(calls).args[0]).toBe("-tutxt");
-		expect(calls).toHaveLength(2);
-		expect(readdirSync(cacheDir)).toEqual([]);
-	});
-
-	// spec: a workDir the caller supplied is used as given and left in place for inspection; without one
-	//   the seam creates a temp dir and removes it.
-	// fails_when: a leaked temp dir per fence render, or a caller's dir deleted under it.
-	it("removes the temp dir it created and keeps the caller's workDir", () => {
-		const created = recorder(plantumlOutput("diagram.svg", "<svg/>"));
-		renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn: created.spawn, cache });
-		const mine = argAfter(only(created.calls).args, "-o");
-		expect(isAbsolute(mine)).toBe(true);
-		expect(existsSync(mine)).toBe(false);
-
-		const kept = recorder(plantumlOutput("diagram.svg", "<svg/>"));
-		// A fresh store: the identical fence would otherwise be answered by the first render's cache.
-		renderDiagram("plantuml", SOURCE, {
-			plantumlPath: FAKE_PLANTUML,
-			spawn: kept.spawn,
-			cache: freshCache(),
-			workDir: dir,
-		});
-		expect(existsSync(join(dir, "diagram.puml"))).toBe(true);
-	});
-
-	// spec: an include directive is rejected by name before any process starts — an include can read a
-	//   local file into the rendered image.
-	// fails_when: a hostile fence reaches the JVM, or the guard throws without naming the token.
-	it("rejects an include directive before any spawn", () => {
-		const { calls, spawn } = recorder();
-
-		const message = messageOf(() =>
-			renderDiagram("plantuml", "@startuml\n!include /etc/passwd\n@enduml", {
-				plantumlPath: FAKE_PLANTUML,
-				spawn,
-				cache,
-			}),
-		);
-
-		expect(message).toBe('plantuml: "!include" is rejected — includes can read local files');
-		expect(calls).toEqual([]);
-	});
-
-	// spec: an exit-0 run that wrote no output file is an error, never an empty artifact.
-	// fails_when: a silent JVM failure renders as an empty diagram.
-	it("errors when the run wrote no matching output", () => {
-		const { spawn } = recorder();
-
-		expect(messageOf(() => renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn, cache }))).toBe(
-			"plantuml: no .svg output was written",
-		);
-	});
-
-	// spec: a spawn failure names the missing binary.
-	// fails_when: a missing binary surfaces as an unhandled crash, or the message loses the command.
-	it("names the missing binary", () => {
-		const { spawn } = recorder(() => spawnError("ENOENT"));
-
-		expect(messageOf(() => renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn, cache }))).toBe(
-			`plantuml: "${FAKE_PLANTUML}" not found`,
-		);
-	});
-
-	// spec: a timed-out run reports the timeout the spawn was given.
-	// fails_when: a hung JVM reports as a generic failure, losing the bound that stopped it.
-	it("names the timeout it was given", () => {
-		const { calls, spawn } = recorder(() => spawnError("ETIMEDOUT"));
-
-		const message = messageOf(() =>
-			renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn, cache, timeoutMs: 1_234 }),
-		);
-
-		expect(message).toBe(`plantuml: "${FAKE_PLANTUML}" timed out after 1234ms`);
-		expect(only(calls).timeoutMs).toBe(1_234);
-	});
-
-	// spec: a run killed by SIGTERM is reported as a timeout of the default 5s.
-	// fails_when: the timeout kill surfaces as an unhandled status-less exit.
-	it("treats a SIGTERM'd run as a timeout", () => {
-		const { spawn } = recorder(() => ({ status: null, signal: "SIGTERM" }));
-
-		expect(messageOf(() => renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn, cache }))).toBe(
-			`plantuml: "${FAKE_PLANTUML}" timed out after 5000ms`,
-		);
-	});
-
-	// spec: a spawn-level error is reported with its own message even when the status looks like success.
-	// fails_when: an error beside status 0 is read as a successful render.
-	it("reports a spawn error even beside a zero exit status", () => {
-		const { spawn } = recorder(() => ({ status: 0, error: new Error("EACCES: permission denied") }));
-
-		expect(messageOf(() => renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn, cache }))).toBe(
-			`plantuml: "${FAKE_PLANTUML}" failed: EACCES: permission denied`,
-		);
-	});
-
-	// spec: a failing exit reports the first stderr line, not the whole multi-line dump.
-	// fails_when: the diagnostic is either lost or floods the single-line error contract.
-	it("reports the first stderr line of a failing exit", () => {
-		const { spawn } = recorder(() => ({ status: 1, signal: null, stderr: Buffer.from("Error one\nError two\n") }));
-
-		expect(messageOf(() => renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn, cache }))).toBe(
-			`plantuml: "${FAKE_PLANTUML}" exited 1: Error one`,
-		);
-	});
-
-	// spec: a failing exit with no stderr reports the status alone, with no trailing separator.
-	// fails_when: an empty stderr renders as "exited 1: " with a dangling colon.
-	it("reports a failing exit with no stderr by status alone", () => {
-		const { spawn } = recorder(() => ({ status: 3, signal: null, stderr: Buffer.alloc(0) }));
-
-		expect(messageOf(() => renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn, cache }))).toBe(
-			`plantuml: "${FAKE_PLANTUML}" exited 3`,
-		);
-	});
-
-	// spec: a status-less, error-less exit is reported as a signal rather than as exit 0/NaN.
-	// fails_when: the message reads "exited null" or "exited 0" for a process that was killed.
-	it("reports a status-less, error-less exit as a signal", () => {
-		const { spawn } = recorder(() => ({ status: null, signal: null }));
-
-		expect(messageOf(() => renderDiagram("plantuml", SOURCE, { plantumlPath: FAKE_PLANTUML, spawn, cache }))).toBe(
-			`plantuml: "${FAKE_PLANTUML}" exited on signal`,
-		);
-	});
-
-	// spec: the binary comes from the injected prereq probe when no explicit path is given, so an
-	//   installed plantuml is spawned from the absolute candidate the resolver picked.
-	// fails_when: the render ignores the probe and re-resolves (or reaches for PATH).
-	it("spawns the absolute candidate the injected probe resolved", () => {
-		const { calls, spawn } = recorder(plantumlOutput("diagram.svg", "<svg/>"));
-		// invented: a linux candidate list whose first entry exists — no real probe, no real binary.
-		const prereqs = { platform: "linux" as const, exists: (path: string) => path === "/usr/bin/plantuml" };
-
-		renderDiagram("plantuml", SOURCE, { prereqs, spawn, cache });
-
-		expect(only(calls).cmd).toBe("/usr/bin/plantuml");
-	});
-
-	// spec: a binary warmup() already resolved is the one spawned (no second probe), and on a machine
-	//   where warmup found none the render reports the install hint before any spawn site is reached.
-	// fails_when: a warmed absolute path is discarded for a fresh lookup, or a missing plantuml reaches a
-	//   spawn instead of the actionable hint.
-	it("spawns the path warmup resolved, or reports the install hint when there is none", () => {
-		const { calls, spawn } = recorder(plantumlOutput("diagram.svg", "<svg/>"));
-
-		// The branch this machine takes is the contract's two halves; both are asserted.
-		if (!status().plantuml) {
-			expect(messageOf(() => renderDiagram("plantuml", SOURCE, { spawn, cache }))).toMatch(
-				/^plantuml: not found — install with /,
-			);
-			expect(calls).toEqual([]);
-			return;
-		}
-
-		renderDiagram("plantuml", SOURCE, { spawn, cache });
-
-		const call = only(calls);
-		expect(isAbsolute(call.cmd)).toBe(true);
-		expect(call.cmd.endsWith("plantuml")).toBe(true);
-	});
-});
-
-describe("html form — the browser screenshot boundary", () => {
-	// spec: an html fence is wrapped in the dark shell with `default-src 'none'`, written to
-	//   fragment.html, and screenshotted by the pinned browser into a throwaway profile under the same
-	//   temp dir; the PNG bytes come back base64.
-	// fails_when: the CSP is dropped (a fragment may then fetch), the profile is the user's, or the
-	//   argv loses --headless/--screenshot and the browser never writes an image.
-	it("screenshots through the pinned browser into a throwaway profile", () => {
-		const { calls, spawn } = recorder(screenshot(PNG_BYTES));
-
-		const result = renderDiagram("html", "<h1>hi</h1>", {
-			browserPath: FAKE_BROWSER,
-			spawn,
-			cache,
-			workDir: dir,
-		});
-
-		expect(result).toEqual({ kind: "image", base64: PNG_BYTES.toString("base64") });
-		const call = only(calls);
-		expect(call.cmd).toBe(FAKE_BROWSER);
-		expect(call.args).toEqual([
-			"--headless",
-			"--disable-gpu",
-			`--user-data-dir=${join(dir, "browser-profile")}`,
-			"--no-first-run",
-			"--disable-background-networking",
-			"--hide-scrollbars",
-			`--screenshot=${join(dir, "screenshot.png")}`,
-			"--window-size=1200,800",
-			"--virtual-time-budget=3000",
-			`file://${join(dir, "fragment.html")}`,
-		]);
-		expect(call.timeoutMs).toBe(15_000);
-		const fragment = readFileSync(join(dir, "fragment.html"), "utf8");
-		expect(fragment).toContain(`content="default-src 'none'; style-src 'unsafe-inline'"`);
-		expect(fragment).toContain("<body><h1>hi</h1></body>");
-	});
-
-	// spec: the browser timeout is the pinned 15s by default and a caller override otherwise; the temp
-	//   dir a caller did not supply is removed after the render.
-	// fails_when: a hung browser pins the render forever, or a per-fence temp dir leaks.
-	it("uses the pinned 15s timeout, honors an override, and cleans up its temp dir", () => {
-		const defaulted = recorder(screenshot(PNG_BYTES));
-		renderDiagram("html", "<p>x</p>", { browserPath: FAKE_BROWSER, spawn: defaulted.spawn, cache });
-		const used = dirname(argWithPrefix(only(defaulted.calls).args, "--screenshot=").slice("--screenshot=".length));
-		expect(only(defaulted.calls).timeoutMs).toBe(15_000);
-		expect(existsSync(used)).toBe(false);
-
-		const overridden = recorder(screenshot(PNG_BYTES));
-		// A fresh store: the identical fence would otherwise be answered by the first render's cache.
-		renderDiagram("html", "<p>x</p>", {
-			browserPath: FAKE_BROWSER,
-			spawn: overridden.spawn,
-			cache: freshCache(),
-			timeoutMs: 250,
-		});
-		expect(only(overridden.calls).timeoutMs).toBe(250);
-	});
-
-	// spec: an exit-0 browser run that wrote no screenshot is an error, never an empty image.
-	// fails_when: the documented silent shell failure (the script flag) renders as a blank card.
-	it("errors when the browser wrote no screenshot", () => {
-		const { spawn } = recorder();
-
-		expect(messageOf(() => renderDiagram("html", "<p>x</p>", { browserPath: FAKE_BROWSER, spawn, cache }))).toBe(
-			"html: browser produced no screenshot",
-		);
-	});
-
-	// spec: with no pinned browser on the machine the form reports the install hint and spawns nothing.
-	// fails_when: a PATH lookup or a spawn is attempted for a browser that is not there.
-	it("reports the install hint and spawns nothing when no browser is pinned", () => {
-		const { calls, spawn } = recorder();
-		// invented: an empty candidate list on linux — the machine-independent "none installed" state.
-		const missing = { platform: "linux" as const, exists: () => false };
-
-		expect(messageOf(() => renderDiagram("html", "<p>x</p>", { prereqs: missing, spawn, cache }))).toMatch(
-			/^html: no pinned browser found — /,
-		);
-		expect(calls).toEqual([]);
-	});
-
-	// spec: a repeated html fence is served from the cached PNG without spawning the browser again.
-	// fails_when: every re-render of an answer launches a browser for the same fragment.
-	it("serves a repeated html fence from the cache with one spawn", () => {
-		const { calls, spawn } = recorder(screenshot(PNG_BYTES));
-		const options = { browserPath: FAKE_BROWSER, spawn, cache };
-
-		const first = renderDiagram("html", "<p>x</p>", options);
-		const second = renderDiagram("html", "<p>x</p>", options);
-
-		expect(calls).toHaveLength(1);
-		expect(second).toEqual(first);
-	});
-});
-
-describe("cache interaction at the seam", () => {
-	// spec: a cache that cannot be read is a miss, not a failed render — the engine still runs.
-	// fails_when: a cache read error propagates into the render path.
-	it("treats an unreadable cache as a miss", () => {
-		// invented: a store whose read throws is the fixture; no real directory is involved.
-		const unreadable: ArtifactCache = {
-			get: () => undefined,
-			put: () => {},
-			putVector: () => {},
-			vectorPath: () => {
-				throw new Error("EACCES: cache unreadable");
-			},
-			putSource: () => undefined,
-			evict: () => {},
-		};
-
-		const result = renderDiagram("dot", "digraph { a -> b }", {
-			cache: unreadable,
-			engines: { viz: countingViz(() => {}) },
-		});
-
-		expect(result).toEqual({ kind: "svg", svg: "<svg>digraph { a -> b }</svg>" });
-	});
-
-	// spec: a vector artifact is stored under the width-clamped key (a fence width below 1 clamps to 1)
-	//   with its mime, so a re-render at the clamped width is a file read.
-	// fails_when: the width reaches the key unclamped — a zero-width fence caches under a key no
-	//   re-render will look up.
-	it("stores the vector under a width-clamped key with its mime", () => {
-		const puts: Array<{ key: string; svg: string; meta: CacheMeta }> = [];
-		// invented: the recording store is the fixture — it captures the artifact the seam would persist.
-		const recording: ArtifactCache = {
-			get: () => undefined,
-			put: () => {},
-			putVector: (key, svg, meta) => puts.push({ key, svg, meta }),
-			vectorPath: () => undefined,
-			putSource: () => undefined,
-			evict: () => {},
-		};
-		const engine = countingViz(() => {});
-
-		renderDiagram("dot", "digraph { a -> b }", { cache: recording, engines: { viz: engine }, widthCells: 0 });
-		renderDiagram("dot", "digraph { a -> b }", { cache: recording, engines: { viz: engine }, widthCells: -4 });
-
-		expect(puts).toHaveLength(2);
-		expect(puts[0]?.key).toBe(puts[1]?.key);
-		expect(only(puts).meta).toMatchObject({ mime: "image/svg+xml", widthCells: 1, source: "dot", mode: "image" });
-	});
-
-	// spec: a text result is never written to the artifact cache, even when the mode asks for caching.
-	// fails_when: font-dependent Unicode art is persisted as if it were an artifact.
-	it("never caches a text result", () => {
-		// invented: an engine returning text under image mode is the fixture — no real JVM is involved.
-		const textEngine: Engine = {
-			id: "plantuml",
-			warmup: async () => {},
-			status: () => true,
-			render: () => ({ kind: "text", art: "Alice -> Bob" }),
-		};
-
-		const result = renderDiagram("plantuml", SOURCE, { engines: { plantuml: textEngine }, cache });
-
-		expect(result).toEqual({ kind: "text", art: "Alice -> Bob" });
-		expect(readdirSync(cacheDir)).toEqual([]);
-	});
-
-	// spec: a cache write failure is reported through the injected logger and the render still returns.
-	// fails_when: a full disk costs the artifact that just rendered, or the failure vanishes silently.
-	it("reports a failed cache write and still returns the artifact", () => {
-		const log = createLogger();
-		// invented: a store whose write throws is the fixture; no real directory is involved.
-		const broken: ArtifactCache = {
-			get: () => undefined,
-			put: () => {},
-			putVector: () => {
-				throw new Error("ENOSPC: no space left on device");
-			},
-			vectorPath: () => undefined,
-			putSource: () => undefined,
-			evict: () => {},
-		};
-
-		const result = renderDiagram("dot", "digraph { a -> b }", {
-			cache: broken,
-			engines: { viz: countingViz(() => {}) },
-			log,
-		});
-
-		expect(result.kind).toBe("svg");
-		const entries = log.drain();
-		expect(entries).toHaveLength(1);
-		expect(entries[0]?.scope).toBe("content.artifacts");
-		expect(entries[0]?.message).toMatch(/^artifact not cached: ENOSPC: no space left on device$/);
-	});
-});