@zenodinh/pi-render 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,296 @@
+// ported from pi-pretty-tui/src/tools/read.ts — survives because: the compact row (skill header, docs
+// label, short path, line count) and the numbered range body are drawing logic, and none of it needed
+// the registration, the execute wrapper, the injected details or the metrics wrapper it lived in; the
+// raw escapes it drew with move to project-time paint. Two port bugs die here: the predecessor numbered
+// lines from a 0-based offset (it echoed the host's `offset` untranslated) and counted the host's own
+// continuation notice as a source line.
+
+/**
+ * read.ts — the read row: a compact file summary, and the numbered range when expanded.
+ *
+ * Boundary: the result's content blocks, `details` and the tool arguments are host payloads; each is
+ * narrowed by a predicate below before a field is read, and a result with no text block returns
+ * "unknown" so the runtime degrades to its raw row instead of drawing a plausible-but-empty one.
+ *
+ * No highlighting: a shiki engine reaches a row only through an injected dependency, and RowSpec has no
+ * deps parameter. Async highlight belongs to the runtime's decorate seam (its invalidate + staleness
+ * token), which this spec leaves unclaimed — plain numbered content stays readable and keeps `project`
+ * synchronous and allocation-light, as it re-runs on every frame.
+ *
+ * shape: none — dispatch object does not apply: the spec is one fixed record of three functions, with
+ * no discriminator and no state to close over. ReadModel and HEADER below declare their own shapes.
+ */
+
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import type {
+	CallModel,
+	ModuleDescriptor,
+	RenderContext,
+	RowPaint,
+	RowSpec,
+	RowView,
+	ToolResult,
+} from "../../../core/types.ts";
+
+/** Which of the three header shapes the row draws. */
+type HeaderKind = "path" | "docs" | "skill";
+
+/** What build parsed once: a failed read's body, or a file range with its classified header. */
+// shape: type + object literals — trigger #7, two closed parse outcomes; a region one outcome lacks is
+// `T | undefined` (trigger #8) rather than a field the other outcome has to invent.
+type ReadModel =
+	| { kind: "error"; label: string; lines: string[] }
+	| {
+			kind: "file";
+			header: HeaderKind;
+			/** Skill name, docs label, or cwd-shortened path; "" when the host sent no path. */
+			label: string;
+			/** 1-indexed number of the first shown line. */
+			offset: number;
+			lines: string[];
+			/** The host's own continuation notice, when it cut the read short. */
+			notice: string | undefined;
+	  };
+
+type FileModel = Extract<ReadModel, { kind: "file" }>;
+type ErrorModel = Extract<ReadModel, { kind: "error" }>;
+
+/** One metadata line is the collapse-first contract; a longer message is the expanded body's job. */
+const SUMMARY_MAX = 120;
+
+/** The host's user-limit notice — the one trailer it appends with no details.truncation block (read.js:132-137). */
+const MORE_LINES_NOTICE = /^\[\d+ more lines in file\. Use offset=\d+ to continue\.\]$/;
+
+/** The lead text per classification, one stateless painter each. */
+// shape: dispatch object — trigger #1, three branches on `header`, handlers stateless.
+const HEADER: Record<HeaderKind, (paint: RowPaint) => string> = {
+	path: (paint) => paint.title("→ read"),
+	docs: (paint) => paint.title("→ read docs"),
+	skill: (paint) => paint.accent("[skill]"),
+};
+
+/**
+ * The call line is the tool name only: the predecessor's read call slot was intentionally blank (the
+ * summary is the result slot's job), and this spec draws that summary itself — a path here would print
+ * twice on every collapsed row.
+ */
+function buildCall(): CallModel {
+	return { title: "read" };
+}
+
+function build(result: ToolResult, ctx: RenderContext): ReadModel | "unknown" {
+	const path = argString(ctx.args, "path");
+	if (failed(result, ctx)) {
+		const lines = compact(textOf(result) ?? "");
+		return {
+			kind: "error",
+			label: path === undefined ? "" : shortPath(ctx.cwd, path),
+			lines: lines.length > 0 ? lines : ["failed"],
+		};
+	}
+	const text = textOf(result);
+	if (text === undefined) return "unknown";
+	const content = normalize(text);
+	const split = splitNotice(content, truncatedBody(result.details));
+	const classified = classify(path, ctx.cwd, content);
+	return {
+		kind: "file",
+		header: classified.header,
+		label: classified.label,
+		offset: argOffset(ctx.args),
+		lines: trimTrailing(split.body.split("\n")),
+		notice: split.notice,
+	};
+}
+
+function project(m: ReadModel, view: RowView, paint: RowPaint): string {
+	if (m.kind === "error") return view.expanded ? errorBody(m, paint) : errorSummary(m, paint);
+	return view.expanded ? fileBody(m, paint) : fileSummary(m, paint);
+}
+
+/** `→ read <label>` / `→ read docs <label>` / `[skill] <name>`, with the range when the read starts late. */
+function header(m: FileModel, paint: RowPaint): string {
+	const range = m.offset > 1 ? paint.muted(`:${m.offset}`) : "";
+	const label = m.label === "" ? "" : ` ${paint.title(m.label)}`;
+	return `${HEADER[m.header](paint)}${label}${range}`;
+}
+
+function fileSummary(m: FileModel, paint: RowPaint): string {
+	const lines = m.lines.length;
+	return `${header(m, paint)} ${paint.muted(`${lines} ${lines === 1 ? "line" : "lines"} — ctrl+o to expand`)}`;
+}
+
+function fileBody(m: FileModel, paint: RowPaint): string {
+	// A fixed gutter width keeps the numbers aligned across frames; 3 is the predecessor's floor.
+	const width = Math.max(3, String(m.offset + m.lines.length - 1).length);
+	const numbered = m.lines.map(
+		(line, index) =>
+			`${paint.gutter(String(m.offset + index).padStart(width, " "))} ${paint.muted("│")} ${paint.output(line)}`,
+	);
+	const hint = m.header === "skill" ? ` ${paint.muted("ctrl+o to collapse")}` : "";
+	const notice = m.notice === undefined ? [] : [paint.warning(m.notice)];
+	return [header(m, paint) + hint, ...numbered, ...notice].join("\n");
+}
+
+function errorSummary(m: ErrorModel, paint: RowPaint): string {
+	const first = m.lines.find((line) => line.trim() !== "") ?? "failed";
+	const message = first.length > SUMMARY_MAX ? `${first.slice(0, SUMMARY_MAX - 1)}…` : first;
+	const label = m.label === "" ? "" : ` ${paint.title(m.label)}`;
+	return `${paint.error("→ read")}${label} ${paint.error(message)}`;
+}
+
+function errorBody(m: ErrorModel, paint: RowPaint): string {
+	return m.lines.map((line) => (line === "" ? "" : paint.error(line))).join("\n");
+}
+
+/** The host flags a failed call on the result and on the render context; either one means an error row. */
+function failed(result: ToolResult, ctx: RenderContext): boolean {
+	return result.isError === true || ctx.isError === true;
+}
+
+/** boundary: arguments are host payloads; only a non-empty string is a path. */
+function argString(args: Record<string, unknown> | undefined, key: string): string | undefined {
+	const value = args?.[key];
+	return typeof value === "string" && value !== "" ? value : undefined;
+}
+
+/** boundary: offset is 1-indexed host input; anything else means the read started at line 1. */
+function argOffset(args: Record<string, unknown> | undefined): number {
+	const value = args?.offset;
+	return typeof value === "number" && Number.isInteger(value) && value > 1 ? value : 1;
+}
+
+/** boundary: a content block is a host payload; only a "text" block with a string body is readable. */
+function textBlock(value: unknown): string | undefined {
+	if (typeof value !== "object" || value === null) return undefined;
+	if (!("type" in value) || value.type !== "text") return undefined;
+	if (!("text" in value)) return "";
+	return typeof value.text === "string" ? value.text : "";
+}
+
+/** The joined text of the result's text blocks; undefined when the result carries none. */
+function textOf(result: ToolResult): string | undefined {
+	const blocks: unknown = result.content;
+	if (!isUnknownArray(blocks)) return undefined;
+	const texts: string[] = [];
+	for (const block of blocks) {
+		const text = textBlock(block);
+		if (text !== undefined) texts.push(text);
+	}
+	return texts.length === 0 ? undefined : texts.join("\n");
+}
+
+/** boundary: an array-shaped host payload stays `unknown[]`, so every element is narrowed on read. */
+function isUnknownArray(value: unknown): value is unknown[] {
+	return Array.isArray(value);
+}
+
+/** boundary: details is a host payload; the body the host cut is readable only as a string field. */
+function truncatedBody(details: unknown): string | undefined {
+	if (typeof details !== "object" || details === null) return undefined;
+	if (!("truncation" in details)) return undefined;
+	const truncation = details.truncation;
+	if (typeof truncation !== "object" || truncation === null) return undefined;
+	if (!("content" in truncation)) return undefined;
+	return typeof truncation.content === "string" ? truncation.content : undefined;
+}
+
+/**
+ * Separates the body from the host's trailing notice, so the notice is never numbered as a source line.
+ * `body` is the cut body from details when there is one; the user-limit notice has no details block and
+ * is recognized by its own wording.
+ */
+function splitNotice(text: string, body: string | undefined): { body: string; notice: string | undefined } {
+	if (body !== undefined && text.startsWith(body)) {
+		const notice = text.slice(body.length).trim();
+		return { body, notice: notice === "" ? undefined : notice };
+	}
+	const at = text.lastIndexOf("\n\n[");
+	const notice = at === -1 ? "" : text.slice(at + 2).trim();
+	return MORE_LINES_NOTICE.test(notice) ? { body: text.slice(0, at), notice } : { body: text, notice: undefined };
+}
+
+/** A trailing newline is a line terminator, not a last line. */
+function trimTrailing(lines: string[]): string[] {
+	let end = lines.length;
+	while (end > 0 && lines[end - 1] === "") end -= 1;
+	return end === lines.length ? lines : lines.slice(0, end);
+}
+
+/** CRLF files would otherwise leave a stray \r at every line end (P helpers.ts:12-14). */
+function normalize(text: string): string {
+	return text.replace(/\r\n?/g, "\n");
+}
+
+/** Runs of blank lines are noise on an error body; one blank line keeps paragraphs apart (P helpers.ts:63-72). */
+function compact(text: string): string[] {
+	const out: string[] = [];
+	for (const line of text.trim().split("\n")) {
+		if (line.trim() === "" && out[out.length - 1]?.trim() === "") continue;
+		out.push(line);
+	}
+	return trimTrailing(out);
+}
+
+/** The row's header text: a skill name, a docs label, or the shortened path (P read.ts:25-60). */
+function classify(
+	path: string | undefined,
+	cwd: string | undefined,
+	content: string,
+): { header: HeaderKind; label: string } {
+	if (path === undefined) return { header: "path", label: "" };
+	if (basename(path) === "SKILL.md") return { header: "skill", label: skillName(path, content) };
+	const docs = docsLabel(path, cwd);
+	return docs === undefined ? { header: "path", label: shortPath(cwd, path) } : { header: "docs", label: docs };
+}
+
+/**
+ * Inside the tree the tool ran in, the root README and `docs/`, `examples/` read as a docs row
+ * (P read.ts:25-33) — anchored at the tool's cwd here: the predecessor compared against the pi package
+ * root through `getReadmePath()`, a host import this render-only spec may not make.
+ */
+function docsLabel(path: string, cwd: string | undefined): string | undefined {
+	if (cwd === undefined) return undefined;
+	const inside = relative(cwd, resolve(cwd, path));
+	if (inside === "" || inside === ".." || inside.startsWith(`..${sep}`)) return undefined;
+	const label = inside.split(sep).join("/");
+	return label === "README.md" || label.startsWith("docs/") || label.startsWith("examples/") ? label : undefined;
+}
+
+/** SKILL.md's frontmatter `name:`, else its directory name (P read.ts:36-55). */
+function skillName(path: string, content: string): string {
+	const fallback = basename(dirname(path));
+	const lines = content.split("\n");
+	if (lines[0]?.trim() !== "---") return fallback;
+	const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+	for (const line of lines.slice(1, end === -1 ? 1 : end)) {
+		const match = /^name\s*:\s*(.+?)\s*$/.exec(line);
+		if (match === null) continue;
+		const value = (match[1] ?? "").trim();
+		const quoted = (value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"));
+		const name = quoted ? value.slice(1, -1).trim() : value;
+		return name === "" ? fallback : name;
+	}
+	return fallback;
+}
+
+/** The row shows a path the way the reader thinks of it: relative while the read is inside the tool's cwd. */
+function shortPath(cwd: string | undefined, path: string): string {
+	if (cwd === undefined) return path;
+	const absolute = resolve(cwd, path);
+	const inside = relative(cwd, absolute);
+	return inside !== "" && !inside.startsWith("..") && !isAbsolute(inside) ? inside : absolute;
+}
+
+/** The read row spec, keyed in the resolver's table by the host's own tool name. */
+// shape: none — one record of three fixed functions over the two parse outcomes above; no branch chain
+// is left for a dispatch object (the error/file split is the union, the header split is HEADER).
+export const readSpec: RowSpec<ReadModel> = { buildCall, build, project };
+
+/** The record T-28 composes: the table key, the spec, and the descriptor it registers. */
+// shape: object literal — trigger #7, the spec module record T-28 composes; fields are known statically.
+export const readRow: { name: string; spec: RowSpec<ReadModel>; descriptor: ModuleDescriptor } = {
+	name: "read",
+	spec: readSpec,
+	descriptor: { key: "row.read", name: "Read row", defaultEnabled: true, settings: [] },
+};

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

@@ -0,0 +1,325 @@
+// ported from pi-pretty-tui/src/core/fff-format.ts + src/renderers/find.ts + src/renderers/grep.ts —
+// survives because: pi-fff hands only text plus an untagged {totalMatched,totalFiles} details bag, so
+// the fingerprint parse and the grouped/highlighting projections are the whole renderer. The
+// predecessor's registrations, Proxy shim and prompt text do not port.
+
+/**
+ * search.ts — the find/grep/fffind/ffgrep row spec: parse pi-fff's text contract, step aside for the
+ * host builtin.
+ *
+ * Boundary: `result.details` is untrusted and narrowed by `isPidfffDetails` before any field is read.
+ * Only a bag carrying numeric totals is pi-fff — the one output this spec styles; a host builtin result
+ * (details absent or notice-shaped) returns "unknown" and the runtime draws the engine's raw text.
+ *
+ * shape: none — no module-level unit to shape: the name→spec table is data and the fingerprint table
+ * is constants. `createSearchSpec` declares its own shape below.
+ */
+
+import { basename, dirname } from "node:path";
+import type { ModuleDescriptor, RenderContext, RowPaint, RowSpec, RowView, ToolResult } from "../../../core/types.ts";
+
+/** pi-fff's empty strings; both are byte-identical to the host builtin's, so details decide engine. */
+const GREP_EMPTY = "No matches found";
+const FIND_EMPTY = "No files found matching pattern";
+
+/** ` 42: content` (match) or ` 12- content` (context) — one leading space, unpadded number. */
+const GREP_LINE_RE = /^ (\d+)([:-]) (.*)$/;
+/** A path's `  [annotation]` suffix; pi-fff indents the tag with two spaces. */
+const ANNOTATION_RE = /\s{2}\[([^\]]*)\]$/;
+/** pi-fff appends notices as `\n\n[a. b]`. */
+const NOTICE_TRAILER_RE = /\n\n\[([^\r\n]*)\]\s*$/;
+/** pi-fff prepends the fuzzy-fallback line as a bare bracket line, not a trailer. */
+const NOTICE_LEAD_RE = /^\[([^\]\r\n]*)\]\r?\n/;
+
+/** Rows rendered when expanded before the remainder is summarised; the predecessor's caps. */
+const MAX_FILES = 300;
+const MAX_BLOCKS = 200;
+
+/** Pi-fff's always-present totals bag — the only signal separating it from the host builtin. */
+interface PidfffDetails {
+	totalMatched: number;
+	totalFiles: number;
+}
+
+interface SearchEntry {
+	path: string;
+	annotation?: string;
+}
+
+interface SearchLine {
+	lineNo: number;
+	content: string;
+	/** false for a context line (` 12- `), true for the matched line (` 12: `). */
+	isMatch: boolean;
+}
+
+interface SearchBlock {
+	path: string;
+	annotation?: string;
+	lines: SearchLine[];
+}
+
+/** The parsed result. `files` is find-shaped (bare paths); `matches` is grep-shaped (numbered lines). */
+export type SearchModel =
+	| { kind: "empty"; noun: "files" | "matches"; notices: string[] }
+	| { kind: "files"; files: SearchEntry[]; notices: string[] }
+	| { kind: "matches"; blocks: SearchBlock[]; matchCount: number; notices: string[]; highlight: RegExp | null };
+
+/** The four names pi-fff and the host use for the two search tools. */
+export type SearchToolName = "find" | "grep" | "fffind" | "ffgrep";
+
+/** The contract-test surface: a pi-fff rename that drops a name must fail CI, not silently unstyle. */
+export const SEARCH_TOOL_NAMES: readonly SearchToolName[] = ["find", "grep", "fffind", "ffgrep"];
+
+/** One registry toggle governs all four names — per-name granularity is not worth four entries. */
+const SEARCH_DESCRIPTOR: ModuleDescriptor = {
+	key: "row.search",
+	name: "Search rows",
+	defaultEnabled: true,
+	settings: [],
+};
+
+export interface SearchSpecRecord {
+	name: SearchToolName;
+	spec: RowSpec<SearchModel>;
+	descriptor: ModuleDescriptor;
+}
+
+/** T-28 iterates this into the resolver table; one name-bound spec per entry. */
+export const SEARCH_SPECS: readonly SearchSpecRecord[] = SEARCH_TOOL_NAMES.map((name) => ({
+	name,
+	spec: createSearchSpec(name),
+	descriptor: SEARCH_DESCRIPTOR,
+}));
+
+/**
+ * shape: closure returning an object literal — trigger #4, one RowSpec bound to the captured tool name
+ * over a shared name-agnostic parse and projection.
+ */
+export function createSearchSpec(name: SearchToolName): RowSpec<SearchModel> {
+	return {
+		buildCall(args, ctx) {
+			return { title: callTitle(name, args, ctx) };
+		},
+		build(result, ctx) {
+			const model = parseSearch(textOf(result), result.details);
+			if (model === "unknown" || model.kind !== "matches") return model;
+			return { ...model, highlight: buildHighlight(ctx.args) };
+		},
+		project,
+	};
+}
+
+/** The args gate: until the host has delivered the full argument set the row shows the name only. */
+function callTitle(name: SearchToolName, args: Record<string, unknown>, ctx: RenderContext): string {
+	if (ctx.argsComplete !== true) return name;
+	const pattern = args.pattern == null ? "" : String(args.pattern);
+	const path = args.path == null ? "<missing>" : String(args.path);
+	switch (name) {
+		case "grep":
+		case "ffgrep": {
+			let title = `${name} /${pattern}/ in ${path}`;
+			if (args.glob != null) title += ` (${String(args.glob)})`;
+			if (args.limit != null) title += ` limit ${String(args.limit)}`;
+			if (args.literal === true) title += " (literal)";
+			if (args.ignoreCase === true) title += " (case-insensitive)";
+			return title;
+		}
+		default: {
+			let title = `${name} ${pattern} in ${path}`;
+			if (args.limit != null) title += ` limit ${String(args.limit)}`;
+			return title;
+		}
+	}
+}
+
+function textOf(result: ToolResult): string {
+	return (result.content ?? [])
+		.filter((c) => c.type === "text")
+		.map((c) => c.text ?? "")
+		.join("\n");
+}
+
+/** `in`-narrowed, no cast: a totalMatched field is what every pi-fff result carries and no host one does. */
+function isPidfffDetails(details: unknown): details is PidfffDetails {
+	if (typeof details !== "object" || details === null) return false;
+	if (!("totalMatched" in details) || !("totalFiles" in details)) return false;
+	return typeof details.totalMatched === "number" && typeof details.totalFiles === "number";
+}
+
+/** One notice per bracket: splitting on ". " fragments the weak-match notice, which contains sentence groups. */
+function splitNotices(text: string): { body: string; notices: string[] } {
+	const notices: string[] = [];
+	let body = text;
+	const trailer = NOTICE_TRAILER_RE.exec(body);
+	if (trailer) {
+		notices.push((trailer[1] ?? "").trim());
+		body = body.slice(0, trailer.index);
+	}
+	const lead = NOTICE_LEAD_RE.exec(body);
+	if (lead) {
+		notices.unshift((lead[1] ?? "").trim());
+		body = body.slice(lead[0].length);
+	}
+	return { body, notices };
+}
+
+function splitAnnotation(line: string): { path: string; annotation?: string } {
+	const m = ANNOTATION_RE.exec(line);
+	if (!m) return { path: line };
+	return { path: line.slice(0, m.index), annotation: m[1] ?? "" };
+}
+
+function parseSearch(text: string, details: unknown): SearchModel | "unknown" {
+	if (!isPidfffDetails(details)) return "unknown";
+	const totalFiles = details.totalFiles;
+	const { body, notices } = splitNotices(text.trim());
+
+	if (body.trim() === GREP_EMPTY) return { kind: "empty", noun: "matches", notices };
+	if (body.trim() === FIND_EMPTY) return { kind: "empty", noun: "files", notices };
+	if (body.trim() === "") return { kind: "empty", noun: "matches", notices };
+
+	const blocks: SearchBlock[] = [];
+	let current: SearchBlock | undefined;
+	let matchCount = 0;
+	let sawLine = false;
+	for (const line of body.split("\n")) {
+		if (line.trim() === "") continue; // pi-fff separates file blocks with a blank line.
+		const m = GREP_LINE_RE.exec(line);
+		if (m) {
+			// A numbered line with no preceding header means the format shifted under us.
+			if (!current) return "unknown";
+			sawLine = true;
+			const isMatch = m[2] === ":";
+			if (isMatch) matchCount++;
+			current.lines.push({ lineNo: Number(m[1] ?? 0), content: m[3] ?? "", isMatch });
+			continue;
+		}
+		const { path, annotation } = splitAnnotation(line);
+		current = annotation === undefined ? { path, lines: [] } : { path, annotation, lines: [] };
+		blocks.push(current);
+	}
+
+	if (sawLine) return { kind: "matches", blocks, matchCount, notices, highlight: null };
+
+	const files: SearchEntry[] = blocks.map((b) =>
+		b.annotation === undefined ? { path: b.path } : { path: b.path, annotation: b.annotation },
+	);
+	// A pi-fff find never lists more files than its totals report; the wildcard-guard message arrives
+	// as one such bare line, so this keeps it out of the file list instead of rendering a phantom row.
+	if (files.length > totalFiles) return "unknown";
+	return { kind: "files", files, notices };
+}
+
+/** Ported whole from the predecessor: a regex from args, degrading to literal, then to no highlighting. */
+function buildHighlight(args: Record<string, unknown> | undefined): RegExp | null {
+	const raw = args?.pattern;
+	if (typeof raw !== "string" || raw === "") return null;
+	const flags = args?.ignoreCase === true || args?.caseSensitive === false ? "gi" : "g";
+	const source = args?.literal === true ? escapeRegExp(raw) : raw;
+	try {
+		return new RegExp(`(${source})`, flags);
+	} catch {
+		try {
+			return new RegExp(`(${escapeRegExp(raw)})`, flags);
+		} catch {
+			return null;
+		}
+	}
+}
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function highlight(content: string, re: RegExp | null, paint: RowPaint): string {
+	if (!re) return paint.output(content);
+	return content.replace(re, (_match: string, group: string) => paint.match(group));
+}
+
+/** Grouped by directory, preserving pi-fff's frecency order within each group. */
+function renderFiles(files: readonly SearchEntry[], paint: RowPaint): string {
+	const groups = new Map<string, SearchEntry[]>();
+	for (const f of files) {
+		const dir = dirname(f.path) || ".";
+		const bucket = groups.get(dir);
+		if (bucket) bucket.push(f);
+		else groups.set(dir, [f]);
+	}
+
+	const out: string[] = [];
+	let shown = 0;
+	let hidden = 0;
+	for (const [dir, entries] of groups) {
+		if (shown >= MAX_FILES) {
+			hidden += entries.length;
+			continue;
+		}
+		if (out.length > 0) out.push("");
+		out.push(paint.accent(`${dir}/`));
+		for (const e of entries) {
+			if (shown >= MAX_FILES) {
+				hidden++;
+				continue;
+			}
+			out.push(`${paint.output(basename(e.path))}${annotation(e.annotation, paint)}`);
+			shown++;
+		}
+	}
+	if (hidden > 0) out.push(paint.muted(`… ${hidden} more files`));
+	return out.join("\n");
+}
+
+/** File blocks with a numbered gutter; matched lines highlight, context lines read as evidence. */
+function renderBlocks(blocks: readonly SearchBlock[], re: RegExp | null, paint: RowPaint): string {
+	let width = 3;
+	for (const b of blocks) {
+		for (const l of b.lines) width = Math.max(width, String(l.lineNo).length);
+	}
+
+	const out: string[] = [];
+	let shown = 0;
+	let hidden = 0;
+	for (const b of blocks) {
+		if (shown >= MAX_BLOCKS) {
+			hidden++;
+			continue;
+		}
+		if (out.length > 0) out.push("");
+		out.push(`${paint.accent(b.path)}${annotation(b.annotation, paint)}`);
+		for (const l of b.lines) {
+			const no = paint.muted(String(l.lineNo).padStart(width, " "));
+			const body = l.isMatch ? highlight(l.content, re, paint) : paint.muted(l.content);
+			out.push(`${no} ${paint.gutter(l.isMatch ? "│" : "┊")} ${body}`);
+		}
+		shown++;
+	}
+	if (hidden > 0) out.push(paint.muted(`… ${hidden} more files`));
+	return out.join("\n");
+}
+
+function annotation(value: string | undefined, paint: RowPaint): string {
+	return value === undefined ? "" : ` ${paint.muted(`[${value}]`)}`;
+}
+
+function project(m: SearchModel, view: RowView, paint: RowPaint): string {
+	const tail = m.notices.length ? `\n${paint.warning(`[${m.notices.join(". ")}]`)}` : "";
+	switch (m.kind) {
+		case "empty":
+			return `${paint.muted(`0 ${m.noun}`)}${tail}`;
+		case "files": {
+			const count = m.files.length;
+			const label = `${count} file${count === 1 ? "" : "s"}`;
+			if (!view.expanded) return `${paint.muted(label)}${tail}`;
+			return `${paint.muted(label)}\n${renderFiles(m.files, paint)}${tail}`;
+		}
+		case "matches": {
+			const fileCount = m.blocks.length;
+			const label = `${m.matchCount} match${m.matchCount === 1 ? "" : "es"} in ${fileCount} file${
+				fileCount === 1 ? "" : "s"
+			}`;
+			if (!view.expanded) return `${paint.muted(label)}${tail}`;
+			return `${paint.muted(label)}\n${renderBlocks(m.blocks, m.highlight, paint)}${tail}`;
+		}
+	}
+}