@zenodinh/pi-render 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,248 @@
+/**
+ * codemode.ts — the codemode row: a one-line call count plus status, or the nested calls and output.
+ *
+ * Boundary: `details` and `args` are host data typed `unknown` here, so every field is narrowed by a
+ * predicate before it is read; color arrives only through the `paint` argument — no escape is emitted.
+ *
+ * shape: fixed-shape record — trigger #7, the exported RowSpec's fields are known statically and hold no
+ * state; STATUS_ICON below declares its own dispatch shape.
+ *
+ * ported from pi-pretty-tui/src/features/codemode-collapse/render.ts — survives because: the collapsed
+ * count/status summary, the per-call line, and the rule that a streaming script withholds its output are
+ * what that renderer got right. Its registration, its background-fill wrapper, and its cast sites carry
+ * claims pi-render does not make.
+ */
+
+import type { ModuleDescriptor, RowPaint, RowSpec, RowView, ToolResult } from "../../../core/types.ts";
+
+/** The tool name this spec renders, exactly as the host spells it. */
+export const name = "codemode";
+
+/** Registry descriptor; T-28 owns the defineModule call, this file only declares it. */
+export const descriptor: ModuleDescriptor = {
+	key: "row.codemode",
+	name: "Codemode row",
+	defaultEnabled: true,
+	settings: [],
+};
+
+type CallStatus = "running" | "ok" | "error" | "cancelled";
+
+/** One nested call; `status` stays verbatim so an unrecognized value reports "?" rather than "ok". */
+interface NestedCall {
+	name: string;
+	args: string;
+	status: string;
+	durationMs?: number;
+	cost?: number;
+	error?: string;
+}
+
+/** The parsed result: the nested calls, plus the script's output with the host's header removed. */
+interface CodemodeModel {
+	calls: NestedCall[];
+	output: string;
+	/** A "Script failed" header with successful calls still reads as a failure. */
+	failed: boolean;
+	fullOutputPath?: string;
+}
+
+const MAX_ARGS_PREVIEW = 80;
+const MAX_ERROR_SUMMARY = 80;
+
+/** The host writes the header as its own text block, ending at "Output:" — dist/extensions/codemode/renderer.js:14. */
+const SCRIPT_HEADER = /^Script (completed|failed)\nWall time [\d.]+ seconds\nOutput:\n/;
+
+// shape: dispatch object — trigger #1, four stateless icon handlers on one status discriminator.
+// `accent` carries "ok": RowPaint has no success role, and `muted` would read as metadata.
+const STATUS_ICON: Record<CallStatus, (paint: RowPaint) => string> = {
+	running: (paint) => paint.warning("…"),
+	ok: (paint) => paint.accent("✓"),
+	error: (paint) => paint.error("✗"),
+	cancelled: (paint) => paint.muted("⊘"),
+};
+
+// shape: fixed-shape record — trigger #7, three pure stages over the model above, no state.
+export const spec: RowSpec<CodemodeModel> = {
+	buildCall(args, ctx) {
+		const code = typeof args.code === "string" ? args.code : "";
+		// Fail closed: no argument-derived output until the host affirms its args are complete.
+		if (ctx.argsComplete !== true || code === "") return { title: name };
+		const lines = code.trimEnd().split("\n").length;
+		return { title: `${name} · ${lines} line${lines === 1 ? "" : "s"}` };
+	},
+
+	build(result) {
+		const details = result.details;
+		const record = isRecord(details) ? details : undefined;
+		const blocks = textBlocks(result);
+		if (record === undefined && blocks.length === 0) return "unknown";
+		const parsed = parseOutput(blocks);
+		const fullOutputPath = record?.fullOutputPath;
+		return {
+			calls: parseCalls(record),
+			output: parsed.output,
+			failed: parsed.failed,
+			fullOutputPath: typeof fullOutputPath === "string" ? fullOutputPath : undefined,
+		};
+	},
+
+	project(model, view, paint) {
+		if (view.isError) return errorRow(model, view, paint);
+		if (!view.expanded) return collapsedRow(model, view, paint);
+		return expandedBody(model, view, paint);
+	},
+};
+
+/* ── parse ─────────────────────────────────────────────────────────────────── */
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function textBlocks(result: ToolResult): string[] {
+	const blocks = result.content ?? [];
+	const texts: string[] = [];
+	for (const block of blocks) {
+		if (block.type === "text" && typeof block.text === "string") texts.push(block.text);
+	}
+	return texts;
+}
+
+/** Splits the header off the first block, wherever the host put the output that follows it. */
+function parseOutput(blocks: string[]): { output: string; failed: boolean } {
+	const first = blocks[0];
+	if (first === undefined) return { output: "", failed: false };
+	const header = SCRIPT_HEADER.exec(first);
+	if (header === null) return { output: blocks.join("\n").trimEnd(), failed: false };
+	const rest = [first.slice(header[0].length), ...blocks.slice(1)].filter((part) => part !== "");
+	return { output: rest.join("\n").trimEnd(), failed: header[1] === "failed" };
+}
+
+function parseCalls(details: Record<string, unknown> | undefined): NestedCall[] {
+	const raw = details?.calls;
+	if (!Array.isArray(raw)) return [];
+	const calls: NestedCall[] = [];
+	for (const item of raw) {
+		if (!isRecord(item)) continue;
+		const call: NestedCall = {
+			name: typeof item.name === "string" ? item.name : "",
+			args: typeof item.args === "string" ? item.args : "",
+			status: typeof item.status === "string" ? item.status : "",
+		};
+		if (typeof item.durationMs === "number" && Number.isFinite(item.durationMs)) call.durationMs = item.durationMs;
+		if (typeof item.cost === "number" && Number.isFinite(item.cost)) call.cost = item.cost;
+		if (typeof item.error === "string" && item.error !== "") call.error = item.error;
+		calls.push(call);
+	}
+	return calls;
+}
+
+/* ── project ───────────────────────────────────────────────────────────────── */
+
+function collapsedRow(model: CodemodeModel, view: RowView, paint: RowPaint): string {
+	const icon = statusIcon(aggregateStatus(model, view.isPartial), paint);
+	return `${paint.muted(countLabel(model.calls.length))} ${paint.muted("·")} ${icon}${pathSuffix(model, paint)}`;
+}
+
+function errorRow(model: CodemodeModel, view: RowView, paint: RowPaint): string {
+	const first = firstLine(model.output);
+	if (!view.expanded) {
+		const summary = first === "" ? countLabel(model.calls.length) : clip(first, MAX_ERROR_SUMMARY);
+		return `${paint.error(`✗ ${summary}`)}${pathSuffix(model, paint)}`;
+	}
+	if (first === "") return collapsedRow(model, view, paint);
+	return paintLines(model.output, paint.error).join("\n");
+}
+
+function expandedBody(model: CodemodeModel, view: RowView, paint: RowPaint): string {
+	const rows: string[] = [];
+	for (const call of model.calls) rows.push(...callLines(call, paint));
+	// A streaming script's output is not final: its calls stream, its body waits (the host's contract).
+	const output = view.isPartial ? "" : model.output;
+	if (output !== "") {
+		if (rows.length > 0) rows.push("");
+		rows.push(...paintLines(output, paint.output));
+	}
+	const path = model.fullOutputPath;
+	if (path !== undefined) rows.push(paint.muted(`Full output: ${path}`));
+	return rows.join("\n");
+}
+
+function callLines(call: NestedCall, paint: RowPaint): string[] {
+	let line = `${statusIcon(call.status, paint)} ${paint.title(call.name)}`;
+	if (call.args !== "") line += ` ${paint.muted(clip(call.args, MAX_ARGS_PREVIEW))}`;
+	const duration = formatDuration(call.durationMs);
+	if (duration !== "") line += ` ${paint.muted(duration)}`;
+	const cost = formatCost(call.cost);
+	if (cost !== "") line += ` ${paint.muted(cost)}`;
+	if (call.error === undefined) return [line];
+	// The host hangs a failed call's message under its own line, indented.
+	return [
+		line,
+		paint.error(
+			call.error
+				.split("\n")
+				.map((part) => `    ${part}`)
+				.join("\n"),
+		),
+	];
+}
+
+/* ── helpers ───────────────────────────────────────────────────────────────── */
+
+function aggregateStatus(model: CodemodeModel, isPartial: boolean): CallStatus {
+	if (model.calls.some((call) => call.status === "running")) return "running";
+	if (model.failed || model.calls.some((call) => call.status === "error")) return "error";
+	if (model.calls.some((call) => call.status === "cancelled")) return "cancelled";
+	return isPartial ? "running" : "ok";
+}
+
+function statusIcon(status: string, paint: RowPaint): string {
+	return isCallStatus(status) ? STATUS_ICON[status](paint) : paint.muted("?");
+}
+
+/** A switch, not a table lookup: an inherited member such as "toString" must not read as a status. */
+function isCallStatus(status: string): status is CallStatus {
+	switch (status) {
+		case "running":
+		case "ok":
+		case "error":
+		case "cancelled":
+			return true;
+		default:
+			return false;
+	}
+}
+
+function countLabel(count: number): string {
+	return `${count} tool call${count === 1 ? "" : "s"}`;
+}
+
+function pathSuffix(model: CodemodeModel, paint: RowPaint): string {
+	const path = model.fullOutputPath;
+	return path === undefined ? "" : ` ${paint.muted("·")} ${paint.muted(`Full output: ${path}`)}`;
+}
+
+function paintLines(text: string, role: (line: string) => string): string[] {
+	return text.split("\n").map((line) => role(line));
+}
+
+function formatDuration(ms: number | undefined): string {
+	if (ms === undefined) return "";
+	return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+
+function formatCost(cost: number | undefined): string {
+	if (cost === undefined || cost === 0) return "";
+	return `$${cost >= 0.01 ? cost.toFixed(2) : cost.toPrecision(2)}`;
+}
+
+function firstLine(text: string): string {
+	const end = text.indexOf("\n");
+	return (end === -1 ? text : text.slice(0, end)).trim();
+}
+
+function clip(text: string, max: number): string {
+	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}

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

@@ -0,0 +1,213 @@
+// ported from pi-pretty-tui/src/features/edit-write-collapse/render.ts (EDIT half) — survives because:
+// the host builtin edit already returns `details.diff` (recorded: @earendil-works/pi-coding-agent@1.0.4,
+// dist/core/tools/edit.js:132), so the collapsed count summary and the expanded diff need no
+// registration; the registration, its execute wrapper and its model instructions stay behind.
+
+/**
+ * edit.ts — the `edit` row: collapsed changed-line counts, expanded diff.
+ *
+ * Boundary: `details` and the result content blocks are host payloads, so both are narrowed by
+ * `isRecord` before a field is read; args are read as strings, and only once `argsComplete`.
+ *
+ * shape: none — dispatch object does not apply: one tool name, no discriminator. The export below is
+ * trigger #7 (fixed-shape record, fields known statically); `TONE_ROLE` declares its own shape.
+ */
+
+import { relative } from "node:path";
+import type {
+	CallModel,
+	ModuleDescriptor,
+	RenderContext,
+	RowPaint,
+	RowSpec,
+	RowView,
+	ToolResult,
+} from "../../../core/types.ts";
+
+const TOOL = "edit";
+const PENDING = "pending";
+const UNAVAILABLE = "diff unavailable";
+const ADDED_MARK = "+";
+/** U+2212: a hyphen would read as diff-body text, not as a count. */
+const REMOVED_MARK = "−";
+const ERROR_MARK = "✗";
+const ELLIPSIS = "…";
+const MAX_ERROR_SUMMARY = 80;
+
+type DiffTone = "added" | "removed" | "context";
+
+interface DiffLine {
+	tone: DiffTone;
+	/** The host's line verbatim, sign and line number included. */
+	text: string;
+}
+
+interface DiffModel {
+	lines: readonly DiffLine[];
+	added: number;
+	removed: number;
+}
+
+interface EditModel {
+	/** Result text blocks joined; the error body and the diff-less fallback read it. */
+	text: string;
+	/** Absent when the result carried no diff — the host streams none until the edit lands. */
+	diff?: DiffModel;
+}
+
+/** Diff tones map straight onto the host toolDiff* tokens (paint exposes them as roles). */
+// shape: dispatch object — trigger #1, three tones → three stateless role lookups.
+const TONE_ROLE = {
+	added: "diffAdded",
+	removed: "diffRemoved",
+	context: "diffContext",
+} as const satisfies Record<DiffTone, keyof RowPaint>;
+
+// shape: none — one straight-line parse; the branch is a boundary check, not a discriminator.
+function build(result: ToolResult): EditModel {
+	const text = resultText(result);
+	const diff = diffOf(result.details);
+	return diff === undefined ? { text } : { text, diff: parseDiff(diff) };
+}
+
+// shape: none — one pass; the tone branch is a two-value classification of the line's first character.
+function parseDiff(diff: string): DiffModel {
+	const lines: DiffLine[] = [];
+	let added = 0;
+	let removed = 0;
+	for (const raw of normalizeLineEndings(diff).split("\n")) {
+		const tone = toneOf(raw);
+		if (tone === "added") added += 1;
+		else if (tone === "removed") removed += 1;
+		lines.push({ tone, text: raw });
+	}
+	return { lines, added, removed };
+}
+
+function toneOf(line: string): DiffTone {
+	if (line.startsWith("+")) return "added";
+	if (line.startsWith("-")) return "removed";
+	return "context";
+}
+
+/** The host's own edit call line is name + short path; the args gate keeps a half-streamed path out. */
+// shape: none — single collapsed-title builder; no dispatch over a discriminator.
+function buildCall(args: Record<string, unknown>, ctx: RenderContext): CallModel {
+	const path = ctx.argsComplete === false ? undefined : pathOf(args);
+	return { title: path === undefined ? TOOL : `${TOOL}: ${displayPath(ctx.cwd, path)}` };
+}
+
+// shape: none — three view-state branches of straight-line text; no dispatch over a discriminator value.
+function project(m: EditModel, view: RowView, paint: RowPaint): string {
+	if (view.isError) {
+		const lines = errorLines(m.text);
+		return view.expanded ? errorBody(lines, paint) : errorSummary(lines, paint);
+	}
+	const diff = m.diff;
+	// A diff-less result reads pending collapsed (the predecessor's port) but shows its text expanded.
+	if (diff === undefined) return view.expanded ? fallbackBody(m.text, paint) : pendingSuffix(paint);
+	return view.expanded ? diffBody(diff.lines, paint) : countsSuffix(diff, paint);
+}
+
+/** The runtime draws this body on its own line under the call line; the one-space lead is the
+    predecessor's tool-body indent (TOOL_RESULT_INDENT), so the counts read as the title's subordinate. */
+function countsSuffix(diff: DiffModel, paint: RowPaint): string {
+	return ` ${paint.diffAdded(`${ADDED_MARK}${diff.added}`)} ${paint.diffRemoved(`${REMOVED_MARK}${diff.removed}`)}`;
+}
+
+function pendingSuffix(paint: RowPaint): string {
+	return ` ${paint.muted(`· ${PENDING}`)}`;
+}
+
+function errorSummary(lines: readonly string[], paint: RowPaint): string {
+	const first = (lines.find((line) => line.trim() !== "") ?? "Error").trim();
+	const summary = first.length > MAX_ERROR_SUMMARY ? `${first.slice(0, MAX_ERROR_SUMMARY - 1)}${ELLIPSIS}` : first;
+	return ` ${paint.error(`${ERROR_MARK} ${summary}`)}`;
+}
+
+function errorBody(lines: readonly string[], paint: RowPaint): string {
+	return lines.map((line) => (line === "" ? "" : paint.error(line))).join("\n");
+}
+
+function diffBody(lines: readonly DiffLine[], paint: RowPaint): string {
+	return lines.map((line) => paint[TONE_ROLE[line.tone]](line.text)).join("\n");
+}
+
+function fallbackBody(text: string, paint: RowPaint): string {
+	const rows = [paint.muted(UNAVAILABLE)];
+	const raw = normalizeLineEndings(text).trim();
+	if (raw !== "") rows.push(...raw.split("\n").map((line) => paint.output(line)));
+	return rows.join("\n");
+}
+
+/** `details` is a host payload: the diff is read only when it is a string. */
+function diffOf(details: unknown): string | undefined {
+	if (!isRecord(details)) return undefined;
+	const diff = details.diff;
+	return typeof diff === "string" ? diff : undefined;
+}
+
+/** Only text blocks with a string body contribute; a malformed block is skipped, never thrown on. */
+function resultText(result: ToolResult): string {
+	const blocks = result.content;
+	if (!Array.isArray(blocks)) return "";
+	const parts: string[] = [];
+	for (const block of blocks) {
+		if (isRecord(block) && block.type === "text" && typeof block.text === "string") parts.push(block.text);
+	}
+	return parts.join("\n");
+}
+
+/** The host builtin's schema is `path`; `file_path` is the predecessor's legacy spelling. */
+function pathOf(args: Record<string, unknown> | undefined): string | undefined {
+	return stringArg(args, "path") ?? stringArg(args, "file_path");
+}
+
+function stringArg(args: Record<string, unknown> | undefined, key: string): string | undefined {
+	const value = args?.[key];
+	return typeof value === "string" && value !== "" ? value : undefined;
+}
+
+/** The predecessor's shortPath without its HOME arm: a spec reads no env, so only cwd shortens. */
+function displayPath(cwd: string | undefined, raw: string): string {
+	if (cwd === undefined) return raw;
+	const rel = relative(cwd, raw);
+	return rel === "" || rel.startsWith("..") ? raw : rel;
+}
+
+/**
+ * Predecessor renderToolError: CRLF normalized, outer blanks trimmed, blank runs collapsed; a payload
+ * with no text reads "Error" so a failed call never renders blank.
+ */
+function errorLines(text: string): readonly string[] {
+	const lines: string[] = [];
+	for (const line of normalizeLineEndings(text).trim().split("\n")) {
+		if (line === "" && lines[lines.length - 1] === "") continue;
+		lines.push(line);
+	}
+	return lines[0] === "" ? ["Error"] : lines;
+}
+
+function normalizeLineEndings(text: string): string {
+	return text.replace(/\r\n?/g, "\n");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+const descriptor: ModuleDescriptor = {
+	key: "row.edit",
+	name: "Edit row",
+	defaultEnabled: true,
+	settings: [],
+};
+
+// shape: object literal satisfying the lane's fixed-shape record — trigger #7; the spec holds no
+//   closure state, so trigger #4 does not apply.
+export const editRow = {
+	name: TOOL,
+	// An `edit` result is either a diff or text and both render, so build never returns "unknown".
+	spec: { buildCall, build, project } satisfies RowSpec<EditModel>,
+	descriptor,
+};

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: [] },
+};