@zenodinh/pi-render 0.1.0 → 0.1.3

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

@@ -1,209 +0,0 @@
-/**
- * table.test.ts — the table surface: banded geometry, theme-derived frame, contrast gate.
- *
- * Every test enters at the exported Surface (table.rewrite) with markdown in and markdown out, and
- * reads the frame through the marker paint double, so a leaked real escape — the #22 defect class —
- * is visible from the string alone. No host package is imported here.
- */
-
-// shape: none — dispatch object does not apply: one entry point and no discriminator, so the cases
-//   differ by fixture data and never by behavior.
-
-import { describe, expect, it } from "vitest";
-import { assertNoRealEscapes, markerPaint } from "../../../test/fakes/index.ts";
-import { createContentPaint } from "../../core/paint.ts";
-import type { TransformContext } from "../../core/types/host.ts";
-import { table } from "./table.ts";
-
-const ESC = String.fromCharCode(27);
-const ESCAPE = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
-
-type Rgb = readonly [number, number, number];
-
-/** One sRGB channel of a WCAG relative-luminance computation. */
-function channel(value: number): number {
-	const srgb = value / 255;
-	return srgb <= 0.04045 ? srgb / 12.92 : ((srgb + 0.055) / 1.055) ** 2.4;
-}
-
-function luminance([red, green, blue]: Rgb): number {
-	return 0.2126 * channel(red) + 0.7152 * channel(green) + 0.0722 * channel(blue);
-}
-
-/** WCAG 2.x contrast ratio, lighter over darker. */
-function contrastRatio(a: Rgb, b: Rgb): number {
-	const [lighter, darker]: [Rgb, Rgb] = luminance(a) >= luminance(b) ? [a, b] : [b, a];
-	return (luminance(lighter) + 0.05) / (luminance(darker) + 0.05);
-}
-
-const CTX: TransformContext = { messageType: "assistant", isStreaming: false, availableWidth: 60 };
-
-/** Painted through a sentinel, so the assertions compare against the fake's own pair, not a copy. */
-const SENTINEL = "\u0000";
-const [RULE_OPEN = "", RULE_CLOSE = ""] = markerPaint().rule(SENTINEL).split(SENTINEL);
-
-const plain = (text: string): string => text.replace(ESCAPE, "");
-
-/** One entry per markdown code span (the fence stripped); markers are kept for the escape assertions. */
-const splitRows = (output: string): string[] =>
-	output
-		.replace(/\n$/, "")
-		.split("  \n")
-		.map((row) => row.slice(1, -1));
-
-const rowsOf = (output: string): string[] => splitRows(output).map(plain);
-
-// invented: a canonical three-column GFM table with a wrapping cell; its plain rows were diffed
-// against the predecessor's renderTable output on the same token (probe, 2026-10-06) — identical.
-const CANONICAL = [
-	"| Tool | Purpose | Notes |",
-	"|---|---|---|",
-	"| bash | run a shell command in the working directory | collapses to a single line; ctrl+o expands the row |",
-	"| read | read a file | none |",
-	"",
-].join("\n");
-
-// recorded-from: pi-pretty-tui/src/features/canvas/table.test.ts (2026-10-06) — its long-cell case;
-// the path is one unbroken word, so it only fits by wrapping mid-token.
-const LONG_PATH =
-	"~/.pi/agent/pi-pretty-tui-cache/118fe853b8b6cf94b9300c0909baa93c9abadffb41e819fc52f60a1bd963d914.svg";
-const WIDE = [
-	"| Gate | State |",
-	"|---|---|",
-	`| sa-validate | PASS — 16/16, 495 lines (first run caught a real gap: ${LONG_PATH}) |`,
-	"",
-].join("\n");
-
-// invented: one cell per inline shape the host tokenizer emits, so each role's handling is pinned.
-const INLINE = ["| A | B |", "|---|---|", "| `bash` | **bold** and *em* and [link](http://x) |", ""].join("\n");
-
-/** the golden: the predecessor's banded geometry, pinned as literals (AC-1). */
-const GOLDEN_TOP = "┌────────┬────────────────────────┬────────────────────────┐";
-const GOLDEN_ROWS = [
-	GOLDEN_TOP,
-	"│ Tool   │ Purpose                │ Notes                  │",
-	"├────────┼────────────────────────┼────────────────────────┤",
-	"│ bash   │ run a shell command in │ collapses to a single  │",
-	"│        │ the working directory  │ line; ctrl+o expands   │",
-	"│        │                        │ the row                │",
-	"├────────┼────────────────────────┼────────────────────────┤",
-	"│ read   │ read a file            │ none                   │",
-	"└────────┴────────────────────────┴────────────────────────┘",
-];
-
-describe("table.rewrite — geometry", () => {
-	it("AC-1: the canonical table matches the golden banded layout", () => {
-		const output = table.rewrite(CANONICAL, CTX, markerPaint());
-		// fails_when: a rule, a column width, or a wrap regresses against the predecessor's table
-		expect(rowsOf(output)).toEqual(GOLDEN_ROWS);
-	});
-
-	it("AC-1: every row is emitted as one code span, so the host cannot reflow the box", () => {
-		const output = table.rewrite(CANONICAL, CTX, markerPaint());
-		// fails_when: raw box-drawing goes back into markdown, where the host reflows or recolors it
-		for (const row of plain(output).replace(/\n$/, "").split("  \n")) {
-			expect(row.startsWith("`")).toBe(true);
-			expect(row.endsWith("`")).toBe(true);
-		}
-		expect(plain(output).endsWith("`\n")).toBe(true);
-	});
-
-	it("AC-1: nothing is elided — a wrapped cell stays reachable in full", () => {
-		const output = table.rewrite(WIDE, CTX, markerPaint());
-		// fails_when: a cell is truncated instead of wrapped (geometry only survives if it wraps)
-		expect(plain(output)).not.toContain("...");
-		expect(plain(output)).toContain("963d914.svg");
-		expect(rowsOf(output)).toHaveLength(9);
-	});
-
-	it("AC-4: no row exceeds availableWidth", () => {
-		const wide = table.rewrite(WIDE, CTX, markerPaint());
-		const narrow = table.rewrite(CANONICAL, { ...CTX, availableWidth: 40 }, markerPaint());
-		// fails_when: an overflowing row reaches the terminal
-		for (const row of rowsOf(wide)) expect(row.length).toBeLessThanOrEqual(60);
-		for (const row of rowsOf(narrow)) expect(row.length).toBeLessThanOrEqual(40);
-	});
-
-	it("returns markdown that holds no table byte-identically", () => {
-		const paragraph = "A paragraph with a | pipe but no table row.\n";
-		// recorded-from: executed probe 2026-10-06 — Marked normalizes \r\n to \n, so joining the
-		// tokens' own raw text is NOT byte-exact; only the input itself preserves the bytes.
-		const crlf = "line one\r\nline two with | pipe\r\n";
-		// fails_when: a pipe-bearing block with no table is rebuilt from lexed tokens
-		expect(table.rewrite(paragraph, CTX, markerPaint())).toBe(paragraph);
-		expect(table.rewrite(crlf, CTX, markerPaint())).toBe(crlf);
-	});
-
-	it("rewrites the table block and leaves the surrounding blocks alone", () => {
-		const output = table.rewrite(`Before the table.\n\n${CANONICAL}\nAfter the table.\n`, CTX, markerPaint());
-		// fails_when: the surrounding blocks are dropped or rewritten
-		expect(plain(output).startsWith("Before the table.\n\n")).toBe(true);
-		expect(plain(output).endsWith("\n\nAfter the table.\n")).toBe(true);
-		expect(plain(output).split(GOLDEN_TOP).length - 1).toBe(1);
-	});
-});
-
-describe("table.rewrite — the #22 fix", () => {
-	it("AC-2: the frame is painted by the rule role and nothing else", () => {
-		const output = table.rewrite(CANONICAL, CTX, markerPaint());
-		const marked = splitRows(output);
-		// fails_when: a hardcoded frame color (a real escape survives the marker-only detector)
-		assertNoRealEscapes(output);
-		// fails_when: any escape in the frame that is not a rule marker
-		expect([...new Set(output.match(ESCAPE) ?? [])].sort()).toEqual([RULE_OPEN, RULE_CLOSE].sort());
-		for (const row of marked) {
-			if (row.includes("│")) {
-				// fails_when: a bar drawn outside a rule pair
-				expect(row.split(`${RULE_OPEN}│${RULE_CLOSE}`)).toHaveLength(row.split("│").length);
-			} else {
-				// fails_when: a rule line drawn outside a rule pair
-				expect(row.startsWith(RULE_OPEN)).toBe(true);
-				expect(row.endsWith(RULE_CLOSE)).toBe(true);
-			}
-		}
-	});
-
-	it("AC-2: every frame segment comes from the live theme's hr, never from a literal", () => {
-		const calls: string[] = [];
-		const paint = createContentPaint({
-			hr: (text) => {
-				calls.push(text);
-				return text;
-			},
-		});
-		const output = table.rewrite(CANONICAL, CTX, paint);
-		// fails_when: the frame carries a hardcoded color instead of the theme's own token
-		expect(rowsOf(output)).toEqual(GOLDEN_ROWS);
-		expect(output).not.toContain(ESC);
-		expect(calls).toContain("│");
-		expect(calls.filter((text) => text.includes("─"))).toHaveLength(4);
-	});
-
-	it("AC-2: inline code goes through the code role; emphasis keeps its text", () => {
-		const output = table.rewrite(INLINE, CTX, markerPaint());
-		const codePair = markerPaint().code(SENTINEL).split(SENTINEL);
-		assertNoRealEscapes(output);
-		// fails_when: inline code renders as its plain text (the role is never called)
-		expect(output).toContain(`${codePair[0]}bash${codePair[1]}`);
-		// fails_when: an emphasis wrapper leaks as a literal escape, or its text is dropped
-		expect(rowsOf(output)).toContain("│ bash   │ bold and em and link │");
-	});
-});
-
-describe("table.rewrite — the frame token's contrast (issue #22)", () => {
-	// recorded-from: sa-reviewer-delta-verdict.md point 7 (executed getResolvedThemeColors + WCAG
-	// computation, 2026-10-06) — mdHr resolves to #9da5a9 dark / #677176 light; the backgrounds are
-	// the pinned fixtures the design computes against (the terminal background is not reachable here).
-	const THEMES = ["dark", "light"] as const;
-	const RECORDED: Record<(typeof THEMES)[number], { mdHr: Rgb; background: Rgb; ratio: number }> = {
-		dark: { mdHr: [0x9d, 0xa5, 0xa9], background: [0x1e, 0x1e, 0x2e], ratio: 6.55 },
-		light: { mdHr: [0x67, 0x71, 0x76], background: [0xff, 0xff, 0xff], ratio: 5.0 },
-	};
-
-	it.each(THEMES)("AC-3: mdHr on the %s theme clears the 4.5:1 gate", (theme) => {
-		const { mdHr, background, ratio } = RECORDED[theme];
-		// fails_when: either theme measures below the gate — then the token, not the test, is wrong
-		expect(contrastRatio(mdHr, background)).toBeGreaterThanOrEqual(4.5);
-		expect(contrastRatio(mdHr, background)).toBeCloseTo(ratio, 1);
-	});
-});

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

@@ -1,254 +0,0 @@
-/**
- * transformer through its seam — createContentTransformer(registry, surfaces, deps), driven with fake
- * surfaces, a fake registry, the marker paint, and a recording logger.
- *
- * Every scenario's first meaningful action is a factory call; nothing below the seam is imported.
- *
- * invented: the fake surface / registry / logger doubles stand in for T-22..T-24, core/registry and
- * core/log — they satisfy the structural contracts and record every call.
- */
-import { describe, expect, test } from "vitest";
-import { markerPaint } from "../../../test/fakes/index.ts";
-import type { TransformContext } from "../../core/types/host.ts";
-import type { LogEntry, Logger } from "../../core/types/log.ts";
-import type { ContentPaint } from "../../core/types/paint.ts";
-import type { Registry } from "../../core/types/registry.ts";
-import { type ContentSurfaces, createContentTransformer } from "./index.ts";
-import type { Surface } from "./types.ts";
-
-const PAINT = markerPaint();
-const ASSISTANT: TransformContext = { messageType: "assistant", isStreaming: false, availableWidth: 80 };
-
-// invented: a two-row table and a one-line fence are the smallest inputs that name two different
-// surfaces; T-22/T-23 own the real table and panel shapes, and this ticket pins dispatch, not rendering.
-const TABLE = "| a | b |\n| - | - |\n| 1 | 2 |\n";
-const FENCE = "```ts\nconst x = 1;\n```\n";
-
-// recorded-from: @earendil-works/pi-coding-agent dist, createMermaidMarkdownTransformer({getMode: () =>
-// "unicode"}), width 100, executed 2026-10-07 — its output for "```mermaid\ngraph TD; A-->B;\n```".
-const HOST_MERMAID_ROWS = "` ┌───┐`  \n` │ A │`  \n` └─┬─┘`  \n`   │`  \n`   ▼`  \n` ┌───┐`  \n` │ B │`  \n` └───┘`\n";
-
-/** One recorded rewrite call. */
-interface SurfaceCall {
-	markdown: string;
-	ctx: TransformContext;
-	paint: ContentPaint;
-}
-
-interface FakeSurface extends Surface {
-	/** Every call this surface received, in order; a skipped surface leaves no entry. Required. */
-	readonly calls: SurfaceCall[];
-}
-
-function fakeSurface(transform: (markdown: string) => string): FakeSurface {
-	const calls: SurfaceCall[] = [];
-	return {
-		calls,
-		rewrite(markdown, ctx, paint) {
-			calls.push({ markdown, ctx, paint });
-			return transform(markdown);
-		},
-	};
-}
-
-function fakeRegistry(disabled: readonly string[]): Registry {
-	return {
-		defineModule: () => {},
-		isEnabled: (key) => !disabled.includes(key),
-		getSettings: () => ({}),
-		setSettings: () => {},
-	};
-}
-
-function fakeLog(): { log: Logger; entries: LogEntry[] } {
-	const entries: LogEntry[] = [];
-	const seen = new Set<string>();
-	return {
-		entries,
-		log: {
-			logLine(scope, message) {
-				entries.push({ scope, message, time: 0 });
-			},
-			logOnce(key, scope, message) {
-				if (seen.has(key)) return;
-				seen.add(key);
-				entries.push({ scope, message, time: 0 });
-			},
-			drain: () => entries.splice(0, entries.length),
-		},
-	};
-}
-
-type Slot = keyof ContentSurfaces;
-
-interface Harness {
-	readonly transformer: (markdown: string, ctx: TransformContext) => string;
-	readonly table: FakeSurface;
-	readonly codePanel: FakeSurface;
-	readonly jsonPanel: FakeSurface;
-	readonly imageCard: FakeSurface;
-	readonly artifacts: FakeSurface | undefined;
-	readonly entries: LogEntry[];
-}
-
-function harness(
-	config: {
-		/** Registry keys to disable, e.g. "content.table". */
-		disabled?: readonly string[];
-		/** Per-slot rewrites; a slot named here but absent from `rewrite` passes its input through. */
-		rewrite?: Partial<Record<Slot, (markdown: string) => string>>;
-		/** Slots whose rewrite throws — the never-throw path. */
-		throwing?: readonly Slot[];
-		/** Inject the artifacts fence pass, as T-28 will once T-25/T-26 land. */
-		withArtifacts?: boolean;
-	} = {},
-): Harness {
-	const { disabled = [], rewrite = {}, throwing = [], withArtifacts = false } = config;
-	const make = (slot: Slot): FakeSurface => {
-		if (throwing.includes(slot)) {
-			return fakeSurface(() => {
-				throw new Error(`${slot} exploded`);
-			});
-		}
-		return fakeSurface(rewrite[slot] ?? ((markdown) => markdown));
-	};
-
-	const table = make("table");
-	const codePanel = make("codePanel");
-	const jsonPanel = make("jsonPanel");
-	const imageCard = make("imageCard");
-	const artifacts = withArtifacts ? make("artifacts") : undefined;
-	const { log, entries } = fakeLog();
-	const surfaces: ContentSurfaces =
-		artifacts === undefined
-			? { table, codePanel, jsonPanel, imageCard }
-			: { table, codePanel, jsonPanel, imageCard, artifacts };
-
-	return {
-		table,
-		codePanel,
-		jsonPanel,
-		imageCard,
-		artifacts,
-		entries,
-		transformer: createContentTransformer(fakeRegistry(disabled), surfaces, { paint: PAINT, log }),
-	};
-}
-
-/** Every rewrite the transformer dispatched, across all slots — a gate or skip leaves none. */
-function allCalls(h: Harness): SurfaceCall[] {
-	return [h.table, h.codePanel, h.jsonPanel, h.imageCard, h.artifacts]
-		.filter((surface) => surface !== undefined)
-		.flatMap((surface) => surface.calls);
-}
-
-describe("content transformer", () => {
-	// spec: transformer(markdown, {messageType:"user"|"assistant-thinking"}) -> markdown, zero surface
-	//   calls; transformer(markdown, {isStreaming:true}) -> markdown, zero calls; transformer(markdown,
-	//   settled assistant) -> the table surface's output.
-	// fails_when: streaming or user content is transformed.
-	test("AC-1 the gate keeps every non-final-assistant message by reference", () => {
-		const h = harness({ rewrite: { table: (markdown) => markdown.replace(TABLE, "TABLE\n") } });
-		const markdown = TABLE;
-
-		expect(h.transformer(markdown, { ...ASSISTANT, messageType: "user" })).toBe(markdown);
-		expect(h.transformer(markdown, { ...ASSISTANT, messageType: "assistant-thinking" })).toBe(markdown);
-		expect(h.transformer(markdown, { ...ASSISTANT, isStreaming: true })).toBe(markdown);
-		expect(allCalls(h)).toEqual([]);
-
-		// The gate assertion above is not vacuous: the same markdown on a settled assistant pass rewrites.
-		expect(h.transformer(markdown, ASSISTANT)).toBe("TABLE\n");
-		expect(h.table.calls).toHaveLength(1);
-	});
-
-	// spec: registry disables content.table -> the table text passes through unchanged while
-	//   content.codePanel still rewrites the fence; enabling both rewrites both.
-	// fails_when: one disabled surface blocks the rest or transforms anyway.
-	test("AC-2 a disabled surface is skipped while the other surfaces still rewrite", () => {
-		const rewrite = {
-			table: (markdown: string) => markdown.replace(TABLE, "TABLE\n"),
-			codePanel: (markdown: string) => markdown.replace(FENCE, "PANEL\n"),
-		};
-		const markdown = TABLE + FENCE;
-
-		const disabled = harness({ disabled: ["content.table"], rewrite });
-		expect(disabled.transformer(markdown, ASSISTANT)).toBe(`${TABLE}PANEL\n`);
-		expect(disabled.table.calls).toEqual([]);
-		expect(disabled.codePanel.calls).toHaveLength(1);
-		expect(disabled.codePanel.calls[0]?.markdown).toBe(markdown);
-
-		// The enabled control is what makes the pass-through above meaningful.
-		const enabled = harness({ rewrite });
-		expect(enabled.transformer(markdown, ASSISTANT)).toBe("TABLE\nPANEL\n");
-		expect(enabled.table.calls[0]?.ctx).toBe(ASSISTANT);
-		expect(enabled.table.calls[0]?.paint).toBe(PAINT);
-	});
-
-	// spec: all four surfaces enabled, each returning its input by reference -> prose matching no
-	//   surface returns the same string while a table the table surface rewrites does not.
-	// fails_when: a no-op pass is turned into a rewrite (a changed string where nothing matched).
-	test("AC-3 markdown matching no surface returns the input unchanged", () => {
-		const h = harness({ rewrite: { table: (markdown) => markdown.replace(TABLE, "TABLE\n") } });
-		const prose = "Just prose: no table, no fence, no image reference.\n";
-
-		expect(h.transformer(prose, ASSISTANT)).toBe(prose);
-		// Every slot was dispatched: the identity survives a full pass, not a skipped one.
-		expect(allCalls(h).map((call) => call.markdown)).toEqual([prose, prose, prose, prose]);
-
-		expect(h.transformer(TABLE, ASSISTANT)).toBe("TABLE\n");
-	});
-
-	// spec: the content.codePanel surface throws -> the ORIGINAL input returns (the table surface's rewrite
-	//   is rolled back) and exactly one entry with scope "content" and message
-	//   "transform failed: codePanel exploded" is logged; a second failing pass logs nothing more.
-	// fails_when: a failing surface kills the answer render.
-	test("AC-4 a throwing surface returns the input unchanged with one keyed log line", () => {
-		const h = harness({
-			rewrite: { table: (markdown) => markdown.replace(TABLE, "TABLE\n") },
-			throwing: ["codePanel"],
-		});
-		const markdown = TABLE + FENCE;
-
-		expect(h.transformer(markdown, ASSISTANT)).toBe(markdown);
-		expect(h.entries).toEqual([{ scope: "content", message: "transform failed: codePanel exploded", time: 0 }]);
-
-		expect(h.transformer(markdown, ASSISTANT)).toBe(markdown);
-		expect(h.entries).toHaveLength(1);
-	});
-
-	// spec: input carrying the host's already-transformed mermaid rows alone -> the same string returns;
-	//   input carrying those rows plus a table -> the rows survive byte-for-byte and the table alone
-	//   rewrites, with the rows reaching the surface verbatim.
-	// fails_when: double-transformation of host-owned content.
-	test("AC-5 already-transformed mermaid passes through untouched", () => {
-		const untouched = harness();
-		expect(untouched.transformer(HOST_MERMAID_ROWS, ASSISTANT)).toBe(HOST_MERMAID_ROWS);
-
-		const h = harness({ rewrite: { table: (markdown) => markdown.replace(TABLE, "TABLE\n") } });
-		const message = `Diagram:\n\n${HOST_MERMAID_ROWS}${TABLE}`;
-
-		expect(h.transformer(message, ASSISTANT)).toBe(`Diagram:\n\n${HOST_MERMAID_ROWS}TABLE\n`);
-		expect(h.table.calls[0]?.markdown).toBe(message);
-	});
-
-	// spec: artifacts injected -> its rewrite runs AFTER the four surfaces (it receives their output) and
-	//   its card replaces the fence; content.artifacts disabled -> the fence pass is skipped and no call
-	//   lands.
-	// fails_when: the fence pass runs while disabled, or before the markdown surfaces.
-	test("the artifacts fence pass runs last, only while content.artifacts is enabled", () => {
-		const rewrite = {
-			table: (markdown: string) => markdown.replace(TABLE, "TABLE\n"),
-			artifacts: (markdown: string) => markdown.replace(FENCE, "CARD\n"),
-		};
-		const markdown = TABLE + FENCE;
-
-		const enabled = harness({ rewrite, withArtifacts: true });
-		expect(enabled.transformer(markdown, ASSISTANT)).toBe("TABLE\nCARD\n");
-		// Received the table surface's output, fence still raw: the pass runs last.
-		expect(enabled.artifacts?.calls[0]?.markdown).toBe(`TABLE\n${FENCE}`);
-
-		const disabled = harness({ disabled: ["content.artifacts"], rewrite, withArtifacts: true });
-		expect(disabled.transformer(markdown, ASSISTANT)).toBe(`TABLE\n${FENCE}`);
-		expect(disabled.artifacts?.calls).toEqual([]);
-	});
-});