@zenodinh/pi-render 0.1.9 → 0.1.10

package/package.json

@@ -67,5 +67,5 @@
 		"typescript": "^7.0.2",
 		"vitest": "^5.0.3"
 	},
-	"version": "0.1.9"
+	"version": "0.1.10"
 }

package/src/core/paint.ts

@@ -75,7 +75,8 @@ export function createRowPaint(theme: HostTheme): RowPaint {
  * Region 2 — the content factory. `rule` degrades hr → quoteBorder → plain; every role ends in plain.
  *
  * The markdown theme's own closures supply the ink: `code` (`mdCode`) under `bold` for the table header,
- * `heading` (`mdHeading`, the accent purple) for the table body's cells, `bold`/`italic` for spans.
+ * `heading` (`mdHeading`, the accent purple) for a body cell's code-span highlight, `bold`/`italic` for
+ * spans.
  */
 // shape: closure returning an object literal — trigger #4, eight stateless content roles over the
 //   captured markdown theme.
@@ -94,6 +95,6 @@ export function createContentPaint(mdTheme: MarkdownTheme): ContentPaint {
 		strong: (text) => tryStyle(mdTheme.bold, text) ?? text,
 		em: (text) => tryStyle(mdTheme.italic, text) ?? text,
 		header,
-		cell: (text) => tryStyle(mdTheme.heading, text) ?? text,
+		cellHighlight: (text) => tryStyle(mdTheme.heading, text) ?? text,
 	};
 }

package/src/core/types/paint.ts

@@ -69,8 +69,9 @@ export interface ContentPaint {
 	 */
 	header(text: string): string;
 	/**
-	 * One table body cell: the theme's `heading` closure (`mdHeading`) wrapped around the whole cell, so
-	 * a code span inside adds no ink of its own. Degrades to plain text without the closure. Required.
+	 * One highlighted span inside a table BODY cell — a code span today: the theme's `heading` closure
+	 * (`mdHeading`, purple in `dracula-soft`). The cell's regular text stays the default ink (#64).
+	 * Degrades to plain text without the closure. Required.
 	 */
-	cell(text: string): string;
+	cellHighlight(text: string): string;
 }

package/src/renderers/content/table.ts

@@ -7,12 +7,12 @@
 /**
  * table.ts — the table surface: a markdown table becomes a boxed box with inked text.
  *
- * The header row's cells take the header ink — bold over `mdCode`; the body cells take the cell ink,
- * the theme's `mdHeading` purple. Each cell's whole text carries that one ink, so a code span inside a
- * cell adds no green or gray of its own. Nothing paints a background: the owner removed the full-bleed
- * band on a live look-check (2026-10-09, #62). When the header row is empty (`| | |`), that row and its
- * separator are dropped and the first column's labels take the header ink instead. `**strong**` and
- * `*em*` cells route through their own roles.
+ * The header row's cells take the header ink — bold over `mdCode`, over the whole cell, so a code span
+ * inside a header cell adds no ink of its own. A body cell's own text keeps the default ink; only a
+ * code span inside it takes the cell highlight — the theme's `mdHeading` purple (owner look-check,
+ * 2026-10-09, #64). Nothing paints a background: the band was removed the same day (#62). When the
+ * header row is empty (`| | |`), that row and its separator are dropped and the first column's labels
+ * take the header ink instead. `**strong**` and `*em*` cells route through their own roles.
  *
  * Boundary: lane-local. The transformer passes markdown in and splices the returned markdown back
  * out, so every escape in the output originates in the injected ContentPaint (T-08) — the #22 fix.
@@ -87,15 +87,15 @@ function inlineText(token: InlineToken, paint: ContentPaint): string {
 }
 
 /**
- * The cell's text with its inline spans composed. A code span adds no ink: its wrapper is the
- * identity, so the cell's own role wraps the whole composed text (owner ruling, #62).
+ * The cell's text with its inline spans composed, `codeSpanInk` drawing each code span. The caller picks
+ * it per region: the identity where the cell's own role inks the whole text (header cells, key-column
+ * labels), the highlight role where the text stays default and only the code span is inked (#64).
  */
-function cellText(cell: CellLike | undefined, paint: ContentPaint): string {
+function cellText(cell: CellLike | undefined, paint: ContentPaint, codeSpanInk: (text: string) => string): string {
 	const tokens = cell?.tokens;
-	const uninked: ContentPaint = { ...paint, code: (text) => text };
 	const text =
 		Array.isArray(tokens) && tokens.length > 0
-			? tokens.map((token) => inlineText(token, uninked)).join("")
+			? tokens.map((token) => inlineText(token, { ...paint, code: codeSpanInk })).join("")
 			: (cell?.text ?? "");
 	// Soft wraps inside a cell are one logical line before the width solve.
 	return text.replace(/\s+/g, " ").trim();
@@ -108,8 +108,16 @@ function padCell(content: string, width: number): string {
 
 /** shape: none — one greedy width solve plus a largest-remainder fill; a table is small and the rule is exact. */
 function renderTable(token: TableToken, width: number, paint: ContentPaint): string[] {
-	const header = token.header.map((cell) => cellText(cell, paint));
-	const rows = token.rows.map((row) => row.map((cell) => cellText(cell, paint)));
+	/** A label cell (the header row, or a key-column table's first column): the whole text takes the header ink. */
+	const label = (cell: CellLike | undefined): string => cellText(cell, paint, (text) => text);
+	/** A body cell: its text stays default, and a code span inside it takes the highlight ink. */
+	const body = (cell: CellLike | undefined): string => cellText(cell, paint, (text) => paint.cellHighlight(text));
+
+	const header = token.header.map(label);
+	// An all-empty header (`| | |`) means the table carries its labels in the first column: the blank
+	// header row and its separator are dropped, and those labels take the header ink instead.
+	const keyColumn = header.every((cell) => cell === "");
+	const rows = token.rows.map((row) => row.map((cell, index) => (keyColumn && index === 0 ? label(cell) : body(cell))));
 	const columns = Math.max(1, header.length);
 	const natural: number[] = [];
 	for (let index = 0; index < columns; index++) {
@@ -147,10 +155,6 @@ function renderTable(token: TableToken, width: number, paint: ContentPaint): str
 		}
 	}
 
-	// An all-empty header (`| | |`) means the table carries its labels in the first column: the blank
-	// header row and its separator are dropped, and those labels take the header ink instead.
-	const keyColumn = header.every((cell) => cell === "");
-
 	// A light box around and between everything: the frame is what keeps a wrapped cell visually
 	// inside the table instead of trailing off its right edge.
 	const ruleLine = (left: string, middle: string, right: string): string =>
@@ -158,7 +162,7 @@ function renderTable(token: TableToken, width: number, paint: ContentPaint): str
 	const bar = paint.rule("│");
 	const physical: string[] = [];
 
-	/** One logical row, wrapped into physical lines; `ink` picks the role each cell's text is drawn in. */
+	/** One logical row, wrapped into physical lines; `ink` wraps each cell's text line by line. */
 	const renderRow = (cells: string[], ink: (text: string, index: number) => string): void => {
 		const wrapped = cells.map((cell, index) => wrapTextWithAnsi(cell, widths[index] ?? MIN_COLUMN));
 		const height = Math.max(1, ...wrapped.map((lines) => lines.length));
@@ -174,14 +178,14 @@ function renderTable(token: TableToken, width: number, paint: ContentPaint): str
 	if (keyColumn) {
 		rows.forEach((row, index) => {
 			if (index > 0) physical.push(ruleLine("├", "┼", "┤"));
-			renderRow(row, (text, column) => (column === 0 ? paint.header(text) : paint.cell(text)));
+			renderRow(row, (text, column) => (column === 0 ? paint.header(text) : text));
 		});
 	} else {
 		renderRow(header, (text) => paint.header(text));
 		physical.push(ruleLine("├", "┼", "┤"));
 		rows.forEach((row, index) => {
 			if (index > 0) physical.push(ruleLine("├", "┼", "┤"));
-			renderRow(row, (text) => paint.cell(text));
+			renderRow(row, (text) => text);
 		});
 	}
 	physical.push(ruleLine("└", "┴", "┘"));