@zenodinh/pi-render 0.1.8 → 0.1.10

package/package.json

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

package/src/core/paint.ts

@@ -3,11 +3,11 @@
  *
  * Boundary: renderers call role methods and never emit an escape (AGENTS: every escape originates
  * here); both theme inputs are structural, so a plain-object fixture drives either factory with no
- * host import. The band's background ink is the one input that arrives late — through the theme
- * holder — so it is read per call and falls back to reverse video when nothing was fed.
+ * host import. Every content role is a live lookup over the markdown theme's own closures, so a theme
+ * switch repaints on the next call.
  *
  * shape: none at module level — a role is a token lookup with no discriminator. The two closure
- * factories and the band-style dispatch inside the second one declare their own shape.
+ * factories declare their own shape.
  *
  * ported from pi-pretty-tui/src/config.ts:71-100 — survives because: "read the theme token, degrade to
  * default when it is absent" is what resolveBaseBackground did; its dead links (`toolBg`,
@@ -71,33 +71,15 @@ export function createRowPaint(theme: HostTheme): RowPaint {
 	};
 }
 
-/**
- * The header band: the header ink with its cell's foreground and background swapped — SGR reverse video.
- * Reversal is what makes the band safe on any theme: it preserves the theme's own ink-on-background
- * contrast ratio instead of pairing an ink with a fill that was picked for something else, and it keeps
- * the band theme-driven, because the header ink is the theme's own. No token, no construction-time
- * choice (owner ruling 2026-10-09; issue #52).
- */
-/**
- * SGR reverse video, on and off — the ONE escape pair that originates here rather than in a theme.
- * Reverse video needs no token, so it works on any theme and on a frame rendered before one arrives.
- */
-const REVERSE_ON = "\x1b[7m";
-const REVERSE_OFF = "\x1b[27m";
-
-/** The band: reverse video over the header ink — the cell's own ink and background swapped. */
-function reverseBand(text: string): string {
-	return `${REVERSE_ON}${text}${REVERSE_OFF}`;
-}
-
 /**
  * Region 2 — the content factory. `rule` degrades hr → quoteBorder → plain; every role ends in plain.
  *
- * The markdown theme's own closures supply the emphasis ink: `bold`/`italic` for inline spans, and its
- * `code` closure (the `mdCode` token, identical to `accent` in both stock themes) for the header ink.
+ * The markdown theme's own closures supply the ink: `code` (`mdCode`) under `bold` for the table header,
+ * `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, band style and theme holder.
+//   captured markdown theme.
 export function createContentPaint(mdTheme: MarkdownTheme): ContentPaint {
 	// The header ink: the theme's `code` closure under its `bold` closure. Each link is optional and
 	// degrades on its own, so a theme missing one still stamps whatever the other gives.
@@ -113,6 +95,6 @@ export function createContentPaint(mdTheme: MarkdownTheme): ContentPaint {
 		strong: (text) => tryStyle(mdTheme.bold, text) ?? text,
 		em: (text) => tryStyle(mdTheme.italic, text) ?? text,
 		header,
-		headerBand: (text) => reverseBand(header(text)),
+		cellHighlight: (text) => tryStyle(mdTheme.heading, text) ?? text,
 	};
 }

package/src/core/types/host.ts

@@ -20,18 +20,6 @@ export interface HostTheme {
 	bold(text: string): string;
 }
 
-/**
- * The background-capable theme slice the header band reads. Structural host shape: the host's live
- * theme is a proxy over the active theme, so any object answering `bg` qualifies.
- *
- * Declared apart from {@link HostTheme} on purpose — that type is what every row renderer and every
- * golden fixture constructs, so a background member there would break call sites that draw no band.
- */
-export interface HostBackgroundTheme {
-	/** Wraps text in a background token's escape, e.g. bg("selectedBg", "x"). Required. */
-	bg(key: string, text: string): string;
-}
-
 /** Live markdown-theme closures the content painter wraps. Structural host shape — no host import. */
 export interface MarkdownTheme {
 	/** Horizontal-rule escape wrapper. Optional: a host without this token degrades to plain text. */
@@ -44,6 +32,8 @@ export interface MarkdownTheme {
 	code?(text: string): string;
 	/** Fenced-code-block border wrapper. Optional. */
 	codeBlockBorder?(text: string): string;
+	/** Heading wrapper (the theme's `mdHeading` ink); the table body's cell ink reads it. Optional. */
+	heading?(text: string): string;
 	/** Bold wrapper for `**strong**` spans — the host markdown theme's own `bold` closure. Optional. */
 	bold?(text: string): string;
 	/** Italic wrapper for `*em*` spans — the host markdown theme's own `italic` closure. Optional. */
@@ -175,10 +165,5 @@ export interface EventContext {
 	ui?: {
 		/** Collapses (false) / expands (true) every tool row. The collapse-first default rides this. Optional. */
 		setToolsExpanded?(expanded: boolean): void;
-		/**
-		 * The live theme handle — a getter over the host's theme proxy, so one read sees every later
-		 * switch. Optional: it is the band ink's only reach, and the extension API carries no theme.
-		 */
-		theme?: HostBackgroundTheme;
 	};
 }

package/src/core/types/paint.ts

@@ -1,6 +1,5 @@
 /**
- * paint.ts — the painting contract: the two role sets every renderer draws through, plus the theme
- * reach the header band reads.
+ * paint.ts — the painting contract: the two role sets every renderer draws through.
  *
  * Boundary: region 1 is the tool row, region 2 is markdown content. Renderers call role methods
  * and never emit an escape sequence themselves (AGENTS: escapes originate in core/paint.ts).
@@ -8,7 +7,7 @@
  * shape: none — declaration-only module (no runtime unit), so no DSG-1 shape trigger applies.
  */
 
-import type { HostBackgroundTheme, HostTheme } from "./host.ts";
+import type { HostTheme } from "./host.ts";
 
 /** Region 1 — the tool-row roles. Text in, theme-derived escape-wrapped text out. */
 export interface RowPaint {
@@ -49,19 +48,6 @@ export type RowPaintFactory = (
 	theme: HostTheme,
 ) => RowPaint;
 
-/**
- * The band's theme reach: one long-lived handle, fed from the per-event UI context and read per frame.
- *
- * The HANDLE is what travels, never a resolved colour: the host's theme is a proxy over the active
- * theme, so a cached escape would freeze the band on the theme selected at load.
- */
-export interface ThemeHolder {
-	/** Stores a live theme handle; a value that cannot paint a background is stored as no theme. */
-	set(theme: unknown): void;
-	/** The handle for this frame, or undefined when none was fed — the band's fallback state. */
-	get(): HostBackgroundTheme | undefined;
-}
-
 /** Region 2 — the markdown-content roles. */
 export interface ContentPaint {
 	/** Horizontal rule; falls back hr → quoteBorder → plain rather than throw. Required. */
@@ -77,14 +63,15 @@ export interface ContentPaint {
 	/** An `*em*` inline span, drawn in the theme's italic. Required. */
 	em(text: string): string;
 	/**
-	 * One stamped header cell: the accent ink under bold. The ink is the markdown theme's `code` closure
-	 * (`mdCode`, identical to `accent` in both stock themes) and the weight its `bold` closure. Required.
+	 * One stamped header cell: the accent ink under bold — the table header's only ink. The ink is the
+	 * markdown theme's `code` closure (`mdCode`, identical to `accent` in both stock themes) and the
+	 * weight its `bold` closure. No background: the owner removed the band on review (#62). Required.
 	 */
 	header(text: string): string;
 	/**
-	 * One header-band cell: {@link header} carrying the band's own background ink, read from the ACTIVE
-	 * theme through the holder and therefore refreshed per render. Reverse video is the fallback for a
-	 * frame with no theme reachable. 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.
 	 */
-	headerBand(text: string): string;
+	cellHighlight(text: string): string;
 }

package/src/renderers/content/table.ts

@@ -1,18 +1,18 @@
-// ported from pi-pretty-tui/src/features/canvas/table.ts — survives because: the banded layout,
-// the column-width solver and the cell wrapping are the reading experience this requirement keeps.
-// Only the escape source changed: frame and bars go through paint.rule, inline code through
-// paint.code, and the predecessor's own bold/italic literals are dropped because no escape may
-// originate outside core/paint.ts.
+// ported from pi-pretty-tui/src/features/canvas/table.ts — survives because: the boxed layout, the
+// column-width solver and the cell wrapping are the reading experience this requirement keeps.
+// Only the escape source changed: frame and bars go through paint.rule, the header through
+// paint.header, body cells through paint.cell; the predecessor's own bold/italic literals are dropped
+// because no escape may originate outside core/paint.ts.
 
 /**
- * table.ts — the table surface: a markdown table becomes a banded box.
+ * table.ts — the table surface: a markdown table becomes a boxed box with inked text.
  *
- * The header row is stamped through the header-band role — bold over the accent ink inside a
- * full-bleed band spanning each cell's whole interior plus its trailing separator, so the header
- * reads as one bar (FP-11); where the band abuts the outer frame, the frame column joins it too
- * (#57), so the field reaches the border. When the header row is empty (`| | |`), that stamp moves
- * onto the first column instead of spending a blank band. `**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.
@@ -86,11 +86,16 @@ function inlineText(token: InlineToken, paint: ContentPaint): string {
 	}
 }
 
-function cellText(cell: CellLike | undefined, paint: ContentPaint): string {
+/**
+ * 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, codeSpanInk: (text: string) => string): string {
 	const tokens = cell?.tokens;
 	const text =
 		Array.isArray(tokens) && tokens.length > 0
-			? tokens.map((token) => inlineText(token, paint)).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();
@@ -103,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++) {
@@ -142,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 the band moves onto that first column 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 =>
@@ -153,26 +162,15 @@ function renderTable(token: TableToken, width: number, paint: ContentPaint): str
 	const bar = paint.rule("│");
 	const physical: string[] = [];
 
-	/** One logical row, wrapped into physical lines; `banded` picks the cells drawn through headerBand. */
-	const renderRow = (cells: string[], banded: (index: number) => boolean): void => {
+	/** 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));
 		for (let line = 0; line < height; line++) {
-			const parts = wrapped.map((lines, index) => {
-				const padded = padCell(lines[line] ?? "", widths[index] ?? MIN_COLUMN);
-				// Full-bleed unit (FP-11): the cell's whole interior — both padding columns — plus its
-				// trailing separator (the bar keeps its rule ink inside the band), so banded cells form one
-				// unbroken bar; the last cell has no trailing separator, so its band ends at its own padding.
-				const unit = index < cells.length - 1 ? ` ${padded} ${bar}` : ` ${padded} `;
-				return banded(index) ? paint.headerBand(unit) : unit;
-			});
-			// #57 (owner pick): the band reaches the outer frame where it abuts it — a banded first cell
-			// takes the left frame column into the band, a banded last cell the right one. The frame glyph
-			// joins the band's own style (dark-on-green), not the rule ink, so no unbanded sliver remains
-			// between the field and the border.
-			const left = banded(0) ? paint.headerBand("│") : bar;
-			const right = banded(cells.length - 1) ? paint.headerBand("│") : bar;
-			physical.push(`${left}${parts.join("")}${right}`);
+			const parts = wrapped.map(
+				(lines, index) => ` ${padCell(ink(lines[line] ?? "", index), widths[index] ?? MIN_COLUMN)} `,
+			);
+			physical.push(`${bar}${parts.join(bar)}${bar}`);
 		}
 	};
 
@@ -180,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, (index) => index === 0);
+			renderRow(row, (text, column) => (column === 0 ? paint.header(text) : text));
 		});
 	} else {
-		renderRow(header, () => true);
+		renderRow(header, (text) => paint.header(text));
 		physical.push(ruleLine("├", "┼", "┤"));
 		rows.forEach((row, index) => {
 			if (index > 0) physical.push(ruleLine("├", "┼", "┤"));
-			renderRow(row, () => false);
+			renderRow(row, (text) => text);
 		});
 	}
 	physical.push(ruleLine("└", "┴", "┘"));