@zenodinh/pi-render 0.0.0-stage → 0.1.0

package/src/renderers/tool/specs/ls.ts

@@ -0,0 +1,136 @@
+// ported from pi-pretty-tui/src/tools/ls.ts — survives because: the collapsed entry count and the
+// expanded tree are pure projections of the result text. The predecessor's registration, execute
+// wrapper and injected `entryCount` (tools/metrics.ts) die with it — the count is parsed from the
+// content lines, so the row needs no wrapper to know what it drew.
+// Two deliberate deviations: file-type icon glyphs are dropped (the predecessor's tables hold
+// hardcoded RGB escapes and paint owns every escape), and `process.env.HOME` becomes `homedir()` so
+// no raw environment read crosses this boundary.
+
+/**
+ * ls.ts — the ls row spec: a collapsed entry count, an expanded directory tree.
+ *
+ * Boundary: the host result is a structural shape, never a validated one — content blocks narrow
+ * field by field, and `result.details` is never read. Argument values stay behind the argsComplete
+ * gate: an unread argument can never be rendered as a guessed one.
+ *
+ * shape: object literal implementing RowSpec — trigger #7, the three contract fields are fixed-shape
+ * functions with no per-row state of their own, so a closure or class would be ceremony.
+ */
+
+import { homedir } from "node:os";
+import { isAbsolute, relative } from "node:path";
+import type { ToolResult } from "../../../core/types/host.ts";
+import type { RowPaint } from "../../../core/types/paint.ts";
+import type { ModuleDescriptor } from "../../../core/types/registry.ts";
+import type { RowSpec } from "../types.ts";
+
+const INDENT = "  ";
+const HINT = "ctrl+o to expand";
+/** Entries past this fold into a "… N more entries" line; the predecessor's 80-line preview cap. */
+const TREE_PREVIEW_LINES = 80;
+
+/** The parsed ls result: the entry lines, plus the raw text the error rows render from. */
+export interface LsModel {
+	/** Content-derived entry lines in host order; a directory keeps its trailing "/". */
+	entries: string[];
+	/** The result text verbatim — never re-derived, so an error body renders unedited. */
+	text: string;
+}
+
+/** boundary: a result block is unvalidated at runtime; each field is checked before it is read. */
+function resultText(result: ToolResult): string {
+	const blocks = result.content;
+	if (!Array.isArray(blocks)) return "";
+	const parts: string[] = [];
+	for (const block of blocks) {
+		if (typeof block !== "object" || block === null) continue;
+		if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
+	}
+	return parts.join("\n");
+}
+
+/** Inside cwd: relative. Outside: home-shortened. A relative argument already reads as written. */
+function shortPath(cwd: string | undefined, path: string): string {
+	if (path.length === 0) return "";
+	if (!isAbsolute(path)) return path;
+	if (cwd === undefined || cwd.length === 0) return path;
+	const rel = relative(cwd, path);
+	if (!rel.startsWith("..")) return rel;
+	const home = homedir();
+	return home.length > 1 && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+
+/** Blank-run collapse only: one blank line survives, consecutive ones fold — an error body stays legible. */
+function compactLines(text: string): string[] {
+	const out: string[] = [];
+	let blank = false;
+	for (const line of text.replaceAll("\r\n", "\n").replaceAll("\r", "\n").trim().split("\n")) {
+		const isBlank = line.trim().length === 0;
+		if (isBlank && blank) continue;
+		out.push(line);
+		blank = isBlank;
+	}
+	return out;
+}
+
+/** Collapsed: the error's first line, then the hint. Expanded: the compacted body, indented. */
+function errorBody(text: string, expanded: boolean, paint: RowPaint): string {
+	const [first = "Error", ...rest] = compactLines(text);
+	if (!expanded) return `${paint.error(first)}${paint.muted(` · ${HINT}`)}`;
+	return [first, ...rest].map((line) => (line.trim().length === 0 ? "" : `${INDENT}${paint.error(line)}`)).join("\n");
+}
+
+/** One line per entry: the connector from the gutter role, a directory name from accent. */
+function tree(entries: string[], paint: RowPaint): string {
+	const shown = entries.slice(0, TREE_PREVIEW_LINES);
+	const lines = shown.map((entry, index) => {
+		const isDir = entry.endsWith("/");
+		const name = isDir ? entry.slice(0, -1) : entry;
+		// Only a fully-shown list ends in "└──"; a truncated list ends in its own "… more" line.
+		const last = index === shown.length - 1 && entries.length <= TREE_PREVIEW_LINES;
+		return `${INDENT}${paint.gutter(last ? "└── " : "├── ")}${isDir ? paint.accent(name) : name}`;
+	});
+	if (entries.length > TREE_PREVIEW_LINES) {
+		const hidden = entries.length - TREE_PREVIEW_LINES;
+		lines.push(`${INDENT}${paint.gutter("└── ")}${paint.muted(`… ${hidden} more entries`)}`);
+	}
+	return lines.join("\n");
+}
+
+const spec: RowSpec<LsModel> = {
+	buildCall(args, ctx) {
+		// argsComplete is the gate: the host streams arguments, and a guessed value is worse than none.
+		if (ctx.argsComplete !== true) return { title: "ls" };
+		const rawPath = args.path;
+		const path = typeof rawPath === "string" ? shortPath(ctx.cwd, rawPath) : "";
+		const limit = typeof args.limit === "number" && Number.isFinite(args.limit) ? args.limit : undefined;
+		return { title: `ls${path.length > 0 ? ` ${path}` : ""}${limit === undefined ? "" : ` (limit ${limit})`}` };
+	},
+
+	build(result) {
+		const text = resultText(result);
+		if (text.trim().length === 0) return "unknown";
+		return {
+			text,
+			entries: text
+				.split("\n")
+				.map((line) => line.trim())
+				.filter((line) => line.length > 0),
+		};
+	},
+
+	project(model, view, paint) {
+		if (view.isError) return errorBody(model.text, view.expanded, paint);
+		const count = model.entries.length;
+		const summary = `${count} ${count === 1 ? "entry" : "entries"}`;
+		if (!view.expanded) return paint.muted(`${summary} · ${HINT}`);
+		return [paint.muted(summary), "", tree(model.entries, paint)].join("\n");
+	},
+};
+
+// shape: object literal — trigger #7, the spec module record T-28 composes; fields are known statically.
+export const lsRow: { name: string; spec: RowSpec<LsModel>; descriptor: ModuleDescriptor } = {
+	name: "ls",
+	spec,
+	descriptor: { key: "row.ls", name: "Ls row", defaultEnabled: true, settings: [] },
+};

package/src/renderers/tool/specs/read.test.ts

@@ -0,0 +1,340 @@
+/**
+ * read.test.ts — the read spec at its seam: buildCall, build and project, with the marker paint double.
+ *
+ * Spec basis (from the captured host payloads below, not from the implementation):
+ *   buildCall(incomplete args)      -> { title: "read" } — the tool name only.
+ *   build(complete text read)       -> a file model: the cwd-relative label, the 1-indexed offset, the
+ *                                      content's lines without the trailing terminator, no notice.
+ *   build(offset/limit read)        -> the same, with the host's own continuation notice kept apart
+ *                                      from the lines, and the numbering starting at the offset.
+ *   build(details.truncation)       -> the body comes from the cut body in details, not from the text.
+ *   build(no text block)            -> "unknown" (the runtime draws its raw row).
+ *   build(isError)                  -> the compacted failure body, labelled with the path.
+ *   project(model, {expanded: false}) -> one summary line: header, range, count, expand hint.
+ *   project(model, {expanded: true})  -> the header, the numbered lines, then the notice when one exists.
+ */
+
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { assertNoRealEscapes, markerPaint, testRenderContext } from "../../../../test/fakes/index.ts";
+import type { RenderContext, RowSpec, RowView, ToolResult } from "../../../core/types.ts";
+import { readRow, readSpec } from "./read.ts";
+
+const PAINT = markerPaint();
+const COLLAPSED: RowView = { expanded: false, isError: false, isPartial: false };
+const EXPANDED: RowView = { expanded: true, isError: false, isPartial: false };
+
+/** The results below are captured read-tool payloads; only the harness varies between tests. */
+const ctxOf = (args: Record<string, unknown>): RenderContext =>
+	testRenderContext({ args, cwd: "/work", argsComplete: true });
+
+/** The spec's parse for one result, with "unknown" ruled out by the caller's fixture choice. */
+function modelOf(result: ToolResult, ctx: RenderContext) {
+	const model = readSpec.build(result, ctx);
+	if (model === "unknown") throw new Error("fixture parsed as unknown");
+	return model;
+}
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+/**
+ * recorded-from: executed @earendil-works/pi-coding-agent@1.0.4 `createReadTool(tmp).execute(…)` 2026-10-06 —
+ * a complete text read returns `{ content: [{ type: "text", text }] }` with no `details` key at all, and the
+ * text carries the file's trailing newline verbatim. The five file lines are the probe's own fixture file.
+ */
+const FILE_RESULT: ToolResult = {
+	content: [{ type: "text", text: "const a = 1;\nlet b = 2;\nfunction f(): number {\n\treturn a + b;\n}\n" }],
+};
+
+/**
+ * recorded-from: same probe, `{ path, offset: 3, limit: 2 }` — the host stops at the caller's limit and appends
+ * its own notice after a blank line, with NO details block (read.js:132-137). Only the path is replaced.
+ */
+const LIMIT_RESULT: ToolResult = {
+	content: [
+		{
+			type: "text",
+			text: "function f(): number {\n\treturn a + b;\n\n[2 more lines in file. Use offset=5 to continue.]",
+		},
+	],
+};
+
+/**
+ * recorded-from: same probe, a 4200-line file read from line 1 — the host cut it at the line limit and reported
+ * the cut in `details.truncation`, whose `content` is the body WITHOUT the notice. Body and the notice's range
+ * are scaled down (2000 -> 2 lines) so the fixture stays readable; totals, limits, flags and the notice wording
+ * are the capture's, and no key was dropped.
+ */
+const TRUNCATED_RESULT: ToolResult = {
+	content: [{ type: "text", text: "line 1\nline 2\n\n[Showing lines 1-2 of 4200. Use offset=3 to continue.]" }],
+	details: {
+		truncation: {
+			content: "line 1\nline 2",
+			truncated: true,
+			truncatedBy: "lines",
+			totalLines: 4200,
+			totalBytes: 40892,
+			outputLines: 2,
+			outputBytes: 12,
+			lastLinePartial: false,
+			firstLineExceedsLimit: false,
+			maxLines: 2000,
+			maxBytes: 51200,
+		},
+	},
+};
+
+/**
+ * recorded-from: ~/.agents/skills/typescript-coding/SKILL.md (read 2026-10-06), trimmed to its frontmatter and
+ * first heading — the YAML `name:` is what the skill header shows, and the closing `---` is what ends the scan.
+ */
+const SKILL_RESULT: ToolResult = {
+	content: [{ type: "text", text: "---\nname: typescript-coding\ndescription: Dev+test standard\n---\n\n# Mission\n" }],
+};
+
+// invented: the docs label keys on the path, not the body, so three stable lines are enough here.
+const DOCS_RESULT: ToolResult = { content: [{ type: "text", text: "# Usage\n\nRun it.\n" }] };
+
+/**
+ * recorded-from: the host's read tool threw `ENOENT: no such file or directory, access '<path>'` for a missing
+ * path (probe 2026-10-06); a failure reaches a renderer as a result with the message in a text block and the
+ * error flag set (agent-session.js:390-397). The path is the probe's own fixture name, cwd-relative.
+ */
+const ERROR_RESULT: ToolResult = {
+	content: [{ type: "text", text: "ENOENT: no such file or directory, access '/work/src/gone.ts'" }],
+	isError: true,
+};
+
+// invented: the multi-line failure shape the predecessor compacted (P helpers.ts:63-72) — consecutive blanks
+// collapse to one, a single blank line survives.
+const MULTILINE_ERROR: ToolResult = {
+	content: [{ type: "text", text: "Error: read failed\n\n\n  at read (gone.ts:1)\n" }],
+	isError: true,
+};
+
+// invented: the message the collapse cap exists for; the path is long enough to pass the limit.
+const LONG_ERROR = `ENOENT: no such file or directory, access '${"/nested".repeat(20)}'`;
+
+// invented: a result whose only block is not text — the shape a future content kind would have (the declared
+// ToolResultContent carries no image fields, so the block stays at its minimal shape).
+const NO_TEXT_RESULT: ToolResult = { content: [{ type: "image" }] };
+
+// ---------------------------------------------------------------------------
+// AC-4 — the call line
+// ---------------------------------------------------------------------------
+
+describe("buildCall — the args gate", () => {
+	it("AC-4: an incomplete argument set yields the tool name only", () => {
+		const ctx = testRenderContext({ args: {}, argsComplete: false });
+		// fails_when: the call line invents an argument value before the host has delivered the arguments
+		expect(readSpec.buildCall({}, ctx).title).toBe("read");
+	});
+
+	it("AC-4: no argument value ever reaches the call line", () => {
+		const ctx = ctxOf({ path: "secret/gone.ts", offset: 7, limit: 2 });
+		// fails_when: the path or range is fabricated into the title (the summary line is where they belong)
+		expect(readSpec.buildCall({ path: "secret/gone.ts", offset: 7, limit: 2 }, ctx).title).toBe("read");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// AC-1 — the golden rows
+// ---------------------------------------------------------------------------
+
+describe("project — the file row", () => {
+	it("AC-1: a complete read summarises the file, and numbers it from line 1 when expanded", () => {
+		const model = modelOf(FILE_RESULT, ctxOf({ path: "src/small.ts" }));
+		// fails_when: the summary renders a wrong path or count, or the content loses the trailing newline's trim
+		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
+			`${PAINT.title("→ read")} ${PAINT.title("src/small.ts")} ${PAINT.muted("5 lines — ctrl+o to expand")}`,
+		);
+		expect(readSpec.project(model, EXPANDED, PAINT)).toBe(
+			[
+				`${PAINT.title("→ read")} ${PAINT.title("src/small.ts")}`,
+				`${PAINT.gutter("  1")} ${PAINT.muted("│")} ${PAINT.output("const a = 1;")}`,
+				`${PAINT.gutter("  2")} ${PAINT.muted("│")} ${PAINT.output("let b = 2;")}`,
+				`${PAINT.gutter("  3")} ${PAINT.muted("│")} ${PAINT.output("function f(): number {")}`,
+				`${PAINT.gutter("  4")} ${PAINT.muted("│")} ${PAINT.output("\treturn a + b;")}`,
+				`${PAINT.gutter("  5")} ${PAINT.muted("│")} ${PAINT.output("}")}`,
+			].join("\n"),
+		);
+	});
+
+	it("AC-1: an offset read numbers from the offset and keeps the host's notice out of the lines", () => {
+		const model = modelOf(LIMIT_RESULT, ctxOf({ path: "src/small.ts", offset: 3, limit: 2 }));
+		// fails_when: the numbering starts at 1 (the predecessor's 0-based leak), or the notice is numbered as a line
+		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
+			`${PAINT.title("→ read")} ${PAINT.title("src/small.ts")}${PAINT.muted(":3")} ${PAINT.muted("2 lines — ctrl+o to expand")}`,
+		);
+		expect(readSpec.project(model, EXPANDED, PAINT)).toBe(
+			[
+				`${PAINT.title("→ read")} ${PAINT.title("src/small.ts")}${PAINT.muted(":3")}`,
+				`${PAINT.gutter("  3")} ${PAINT.muted("│")} ${PAINT.output("function f(): number {")}`,
+				`${PAINT.gutter("  4")} ${PAINT.muted("│")} ${PAINT.output("\treturn a + b;")}`,
+				PAINT.warning("[2 more lines in file. Use offset=5 to continue.]"),
+			].join("\n"),
+		);
+	});
+
+	it("AC-1: a truncated read takes its body from details and warns on the cut", () => {
+		const model = modelOf(TRUNCATED_RESULT, ctxOf({ path: "src/many.txt" }));
+		// fails_when: the displayed body comes from the notice-bearing text (so the notice becomes line 3), or
+		//            a cut read renders silently
+		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
+			`${PAINT.title("→ read")} ${PAINT.title("src/many.txt")} ${PAINT.muted("2 lines — ctrl+o to expand")}`,
+		);
+		expect(readSpec.project(model, EXPANDED, PAINT)).toBe(
+			[
+				`${PAINT.title("→ read")} ${PAINT.title("src/many.txt")}`,
+				`${PAINT.gutter("  1")} ${PAINT.muted("│")} ${PAINT.output("line 1")}`,
+				`${PAINT.gutter("  2")} ${PAINT.muted("│")} ${PAINT.output("line 2")}`,
+				PAINT.warning("[Showing lines 1-2 of 4200. Use offset=3 to continue.]"),
+			].join("\n"),
+		);
+	});
+
+	it("AC-1: a SKILL.md read draws the skill header from the frontmatter name", () => {
+		const model = modelOf(SKILL_RESULT, ctxOf({ path: ".agents/skills/typescript-coding/SKILL.md" }));
+		// fails_when: the frontmatter name is missed (a directory name or a path appears instead), or the expanded
+		//            header loses its collapse hint
+		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
+			`${PAINT.accent("[skill]")} ${PAINT.title("typescript-coding")} ${PAINT.muted("6 lines — ctrl+o to expand")}`,
+		);
+		const expanded = readSpec.project(model, EXPANDED, PAINT).split("\n");
+		expect(expanded[0]).toBe(
+			`${PAINT.accent("[skill]")} ${PAINT.title("typescript-coding")} ${PAINT.muted("ctrl+o to collapse")}`,
+		);
+		expect(expanded.slice(1)).toEqual([
+			`${PAINT.gutter("  1")} ${PAINT.muted("│")} ${PAINT.output("---")}`,
+			`${PAINT.gutter("  2")} ${PAINT.muted("│")} ${PAINT.output("name: typescript-coding")}`,
+			`${PAINT.gutter("  3")} ${PAINT.muted("│")} ${PAINT.output("description: Dev+test standard")}`,
+			`${PAINT.gutter("  4")} ${PAINT.muted("│")} ${PAINT.output("---")}`,
+			`${PAINT.gutter("  5")} ${PAINT.muted("│")} ${PAINT.output("")}`,
+			`${PAINT.gutter("  6")} ${PAINT.muted("│")} ${PAINT.output("# Mission")}`,
+		]);
+	});
+
+	it("AC-1: only docs paths read as documents", () => {
+		const docs = modelOf(DOCS_RESULT, ctxOf({ path: "docs/usage.md" }));
+		// fails_when: every path is labelled a docs row, or a docs path is not
+		expect(readSpec.project(docs, COLLAPSED, PAINT)).toBe(
+			`${PAINT.title("→ read docs")} ${PAINT.title("docs/usage.md")} ${PAINT.muted("3 lines — ctrl+o to expand")}`,
+		);
+		const other = modelOf(DOCS_RESULT, ctxOf({ path: "src/notes.md" }));
+		expect(readSpec.project(other, COLLAPSED, PAINT)).toBe(
+			`${PAINT.title("→ read")} ${PAINT.title("src/notes.md")} ${PAINT.muted("3 lines — ctrl+o to expand")}`,
+		);
+	});
+
+	it("AC-1: the count follows the content, including the empty and single-line cases", () => {
+		const empty = modelOf({ content: [{ type: "text", text: "" }] }, ctxOf({ path: "src/empty.ts" }));
+		const single = modelOf({ content: [{ type: "text", text: "only\n" }] }, ctxOf({ path: "src/one.ts" }));
+		// fails_when: an empty file reports a phantom line, or a one-line file reads "1 lines"
+		expect(readSpec.project(empty, COLLAPSED, PAINT)).toBe(
+			`${PAINT.title("→ read")} ${PAINT.title("src/empty.ts")} ${PAINT.muted("0 lines — ctrl+o to expand")}`,
+		);
+		expect(readSpec.project(single, COLLAPSED, PAINT)).toBe(
+			`${PAINT.title("→ read")} ${PAINT.title("src/one.ts")} ${PAINT.muted("1 line — ctrl+o to expand")}`,
+		);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// AC-2 — error rows
+// ---------------------------------------------------------------------------
+
+describe("project — the error row", () => {
+	it("AC-2: a failed read carries its message on the collapsed line and its body when expanded", () => {
+		const model = modelOf(ERROR_RESULT, ctxOf({ path: "src/gone.ts" }));
+		// fails_when: an error row renders blank, loses the path, or shows the whole body collapsed
+		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
+			`${PAINT.error("→ read")} ${PAINT.title("src/gone.ts")} ${PAINT.error("ENOENT: no such file or directory, access '/work/src/gone.ts'")}`,
+		);
+		expect(readSpec.project(model, EXPANDED, PAINT)).toBe(
+			PAINT.error("ENOENT: no such file or directory, access '/work/src/gone.ts'"),
+		);
+	});
+
+	it("AC-2: a multi-line failure compacts to one blank separator and keeps a blank line blank", () => {
+		const model = modelOf(MULTILINE_ERROR, ctxOf({ path: "src/gone.ts" }));
+		// fails_when: the collapsed line shows a blank first line, or the body paints blank lines
+		expect(readSpec.project(model, COLLAPSED, PAINT)).toBe(
+			`${PAINT.error("→ read")} ${PAINT.title("src/gone.ts")} ${PAINT.error("Error: read failed")}`,
+		);
+		expect(readSpec.project(model, EXPANDED, PAINT)).toBe(
+			[PAINT.error("Error: read failed"), "", PAINT.error("  at read (gone.ts:1)")].join("\n"),
+		);
+	});
+
+	it("AC-2: a failure with no body still renders a row, and a long message stays one line", () => {
+		const empty = modelOf({ content: [], isError: true }, ctxOf({ path: "src/gone.ts" }));
+		const long = modelOf(
+			{ content: [{ type: "text", text: LONG_ERROR }], isError: true },
+			ctxOf({ path: "src/gone.ts" }),
+		);
+		// fails_when: an empty error body renders a driverless blank line, or the collapsed line grows past one line
+		expect(readSpec.project(empty, COLLAPSED, PAINT)).toBe(
+			`${PAINT.error("→ read")} ${PAINT.title("src/gone.ts")} ${PAINT.error("failed")}`,
+		);
+		expect(readSpec.project(long, COLLAPSED, PAINT)).toBe(
+			`${PAINT.error("→ read")} ${PAINT.title("src/gone.ts")} ${PAINT.error(`${LONG_ERROR.slice(0, 119)}…`)}`,
+		);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Degradation and the seam's structural contract
+// ---------------------------------------------------------------------------
+
+describe("the read spec's degradation and exports", () => {
+	it("degrades to unknown when the result carries no text block", () => {
+		// fails_when: a content kind the spec cannot read is drawn as an empty file row instead of the raw row
+		expect(readSpec.build(NO_TEXT_RESULT, ctxOf({ path: "shot.png" }))).toBe("unknown");
+	});
+
+	it("AC-3: the source carries no execution, registration or prompt text", () => {
+		const source = readFileSync(new URL("./read.ts", import.meta.url), "utf8");
+		// fails_when: an execute wrapper, a tool registration, or model-facing prompt text comes back in
+		for (const pattern of [
+			/registerTool/,
+			/\bexecute\s*[:(=]/,
+			/promptSnippet|promptGuidelines/,
+			/\bdescription\s*:/,
+			/\bparameters\s*:/,
+			/as unknown as/,
+		]) {
+			expect(source).not.toMatch(pattern);
+		}
+	});
+
+	it("AC-5: every escape a row draws is a paint marker", () => {
+		const ctx = ctxOf({ path: "src/small.ts" });
+		const outputs = [
+			readSpec.project(modelOf(FILE_RESULT, ctx), COLLAPSED, PAINT),
+			readSpec.project(modelOf(FILE_RESULT, ctx), EXPANDED, PAINT),
+			readSpec.project(modelOf(SKILL_RESULT, ctxOf({ path: "s/SKILL.md" })), COLLAPSED, PAINT),
+			readSpec.project(modelOf(ERROR_RESULT, ctxOf({ path: "src/gone.ts" })), COLLAPSED, PAINT),
+			readSpec.project(modelOf(ERROR_RESULT, ctxOf({ path: "src/gone.ts" })), EXPANDED, PAINT),
+		];
+		for (const output of outputs) {
+			// fails_when: a hardcoded color or reset leaks past paint
+			assertNoRealEscapes(output);
+			// Non-vacuity: a row always carries the marker paint's own codes (200..231), never an empty string.
+			expect(output).toMatch(/\[38;5;2[0-3]\dm/);
+		}
+		const source = readFileSync(new URL("./read.ts", import.meta.url), "utf8");
+		// fails_when: an escape literal appears in the source, painting around the paint seam
+		expect(source).not.toMatch(/\\x1b|\\u001b|\\033|\[38;5;/);
+	});
+
+	it("exports the record T-28 composes, and erases into the resolver's unknown-typed table", () => {
+		const table: Record<string, RowSpec> = { [readRow.name]: readRow.spec };
+		// fails_when: the table key, the descriptor or the RowSpec<M> erasure stops matching the seam map
+		expect(readRow.name).toBe("read");
+		expect(readRow.spec).toBe(readSpec);
+		expect(readRow.descriptor).toEqual({ key: "row.read", name: "Read row", defaultEnabled: true, settings: [] });
+		expect(table.read).toBe(readSpec);
+	});
+});