@zenodinh/pi-render 0.1.7 → 0.1.9

package/package.json

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

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`,
@@ -60,7 +60,9 @@ export function createRowPaint(theme: HostTheme): RowPaint {
 		accent: (text) => fgOrPlain(theme, "accent", text),
 		error: (text) => fgOrPlain(theme, "error", text),
 		warning: (text) => fgOrPlain(theme, "warning", text),
-		success: (text) => fgOrPlain(theme, "success", text),
+		// The settled ink is `muted` by owner pick (#58): the theme's green read too bright. The role
+		// keeps its name, so the three state call sites stay one expression.
+		success: (text) => fgOrPlain(theme, "muted", text),
 		gutter: (text) => fgOrPlain(theme, "muted", text),
 		match: (text) => matchOrAccent(theme, text),
 		diffAdded: (text) => fgOrPlain(theme, "toolDiffAdded", text),
@@ -69,33 +71,14 @@ 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 the table body's cells, `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.
@@ -111,6 +94,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)),
+		cell: (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 {
@@ -26,7 +25,10 @@ export interface RowPaint {
 	error(text: string): string;
 	/** Warning text for a degraded or partial result. Required. */
 	warning(text: string): string;
-	/** The success ink: a settled call that did not fail. Required. */
+	/**
+	 * The settled ink: a call that did not fail, drawn in the `muted` token (thinking's gray) by owner
+	 * pick (#58). The role keeps its name so the state call sites stay one expression. Required.
+	 */
 	success(text: string): string;
 	/** The row's left gutter marker. Required. */
 	gutter(text: string): string;
@@ -46,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. */
@@ -74,14 +63,14 @@ 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 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.
 	 */
-	headerBand(text: string): string;
+	cell(text: string): string;
 }

package/src/renderers/content/table.ts

@@ -1,17 +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) — or, when the header row is empty (`| | |`), that stamp moves onto the
- * first column so no blank band is spent. `**strong**` and `*em*` cells route through their own
- * roles.
+ * 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.
  *
  * 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.
@@ -85,11 +86,16 @@ 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).
+ */
 function cellText(cell: CellLike | undefined, paint: ContentPaint): 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, paint)).join("")
+			? tokens.map((token) => inlineText(token, uninked)).join("")
 			: (cell?.text ?? "");
 	// Soft wraps inside a cell are one logical line before the width solve.
 	return text.replace(/\s+/g, " ").trim();
@@ -142,7 +148,7 @@ 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.
+	// 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
@@ -152,20 +158,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` picks the role each cell's text is drawn in. */
+	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;
-			});
-			physical.push(`${bar}${parts.join("")}${bar}`);
+			const parts = wrapped.map(
+				(lines, index) => ` ${padCell(ink(lines[line] ?? "", index), widths[index] ?? MIN_COLUMN)} `,
+			);
+			physical.push(`${bar}${parts.join(bar)}${bar}`);
 		}
 	};
 
@@ -173,14 +174,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) : paint.cell(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) => paint.cell(text));
 		});
 	}
 	physical.push(ruleLine("└", "┴", "┘"));

package/src/renderers/tool/runtime.ts

@@ -15,6 +15,7 @@
  * renderCall/renderResult methods, with no subclassing.
  */
 
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type {
 	HostTheme,
 	RenderContext,
@@ -166,6 +167,11 @@ interface PaddedText extends UiComponent {
 	setText(body: string): void;
 	/** Re-reads the row's indent, so a host padding change lands on the next frame. Required. */
 	setPad(pad: number): void;
+	/**
+	 * Sets how an over-wide line is spent: false cuts it to the budget with an ellipsis, true reflows it.
+	 * Required: one component serves both row states, so the mode must follow the frame.
+	 */
+	setWrap(wrap: boolean): void;
 }
 
 /** `in`-narrowed, never cast: a recorded component is the host's until it answers this protocol. */
@@ -180,7 +186,8 @@ function textComponent(body: string): UiComponent {
 		render(_width: number): string[] {
 			// One entry per line; an empty body still yields one line, so a degraded row never vanishes.
 			// Width is the component's own: renderResult receives none, so nothing here is width-keyed.
-			// The offer minus the indent is handed down by the pad wrapper around this component.
+			// The offer minus the indent is handed down by the pad wrapper, which also spends what comes back —
+			// cut when collapsed, reflowed when expanded.
 			return current.split("\n");
 		},
 		invalidate(): void {
@@ -193,22 +200,39 @@ function textComponent(body: string): UiComponent {
 }
 
 /**
- * The pad wrapper: every line the inner component draws takes the indent, and the inner component gets
- * the offer minus it.
+ * The pad wrapper: the inner component gets the offer minus the indent, every line it draws takes the
+ * indent, and every line is fitted to the budget — an inner is told the budget, not obliged to spend it.
  *
  * Both halves are ours because a row asks the host for the "self" shell (#51), and that shell skips the
  * Box(1,1) which used to indent each line and render its child at `width - paddingX * 2` (pi-tui
  * box.js:83 → :91 → :115). The budget half is what a reused host `Text` needs: it wraps at the width it
  * is given (pi-tui text.js:53-56), so a full-width title would wrap at the whole offer and then be
- * pushed one column past it by the indent.
+ * pushed one column past it by the indent. Spending is the other half of the same duty (#56): our own
+ * text component ignores the width it is handed, so an over-wide title used to run past the offer.
  *
- * shape: closure returning an object literal — trigger #4: one stored pad behind render/setPad.
+ * How an over-wide line is spent follows the row's state — the owner's review on #59: an expansion must
+ * show the FULL request and result. Collapsed cuts to the budget, ellipsis-marked: one logical line is the
+ * collapse contract. Expanded reflows with pi-tui's `wrapTextWithAnsi` — the call the table and code-panel
+ * surfaces already spend their cells with — while truncation stays only as the backstop for a slice that
+ * no width can hold (table.ts:187's rule). A line within budget passes through untouched either way.
+ *
+ * shape: closure returning an object literal — trigger #4: one stored pad and one spending mode behind
+ * render/setPad/setWrap.
  */
-function padComponent(inner: UiComponent, pad: number): PaddedText {
+function padComponent(inner: UiComponent, pad: number, wrap: boolean): PaddedText {
 	let indent = pad;
+	let wrapping = wrap;
 	return {
 		render(width: number): string[] {
-			const lines = inner.render(Math.max(0, width - indent));
+			const budget = Math.max(0, width - indent);
+			const lines = inner.render(budget).flatMap((line) => {
+				if (visibleWidth(line) <= budget) return [line];
+				// Collapsed cuts, expanded reflows (see the block comment): only an over-wide line is spent.
+				const spent = wrapping && budget > 0 ? wrapTextWithAnsi(line, budget) : [truncateToWidth(line, budget, "…")];
+				// Backstop: a wrapped slice can still exceed the budget (a wide grapheme), and a line no
+				// width can hold is cut rather than left to run past the edge (#56).
+				return spent.map((piece) => (visibleWidth(piece) > budget ? truncateToWidth(piece, budget, "…") : piece));
+			});
 			if (indent === 0) return lines;
 			const spaces = " ".repeat(indent);
 			return lines.map((line) => spaces + line);
@@ -222,10 +246,13 @@ function padComponent(inner: UiComponent, pad: number): PaddedText {
 		setPad(value: number): void {
 			indent = value;
 		},
+		setWrap(value: boolean): void {
+			wrapping = value;
+		},
 	};
 }
 
-function textFor(ctx: RenderContext, body: string): UiComponent {
+function textFor(ctx: RenderContext, body: string, wrap: boolean): UiComponent {
 	const pad = padOf(ctx);
 	const reuse = ctx.lastComponent;
 	// Only a component this runtime wrapped can be told a new pad, so it is the only one it reuses. A
@@ -234,6 +261,7 @@ function textFor(ctx: RenderContext, body: string): UiComponent {
 	if (reuse !== undefined && isPaddedText(reuse)) {
 		reuse.setText(body);
 		reuse.setPad(pad);
+		reuse.setWrap(wrap);
 		return reuse;
 	}
 	// A host text component in the slot is still worth mutating in place: it caches its own frame, and
@@ -241,9 +269,9 @@ function textFor(ctx: RenderContext, body: string): UiComponent {
 	const setText = reuse?.setText;
 	if (reuse !== undefined && setText !== undefined) {
 		setText.call(reuse, body);
-		return padComponent(reuse, pad);
+		return padComponent(reuse, pad, wrap);
 	}
-	return padComponent(textComponent(body), pad);
+	return padComponent(textComponent(body), pad, wrap);
 }
 
 /**
@@ -374,11 +402,13 @@ export function createRowRenderers(spec: RowSpec, deps: { paint: RowPaintFactory
 			const ink = ctx.isError === true ? paint.error : ctx.isPartial === true ? paint.dim : paint.success;
 			const title = ink(model.title);
 			// Collapsed rows are one line: the summary the result slot settled rides this title line.
-			const summary = ctx.expanded === true ? undefined : readSummary(ctx);
-			return textFor(ctx, summary === undefined ? title : `${title} · ${summary}`);
+			// Expanded reflows, so a long title stays readable in full; collapsed cuts to its one line.
+			const expanded = ctx.expanded === true;
+			const summary = expanded ? undefined : readSummary(ctx);
+			return textFor(ctx, summary === undefined ? title : `${title} · ${summary}`, expanded);
 		} catch (err) {
 			logFailure(deps.log, ctx, err);
-			return textFor(ctx, "");
+			return textFor(ctx, "", ctx.expanded === true);
 		}
 	};
 
@@ -391,10 +421,11 @@ export function createRowRenderers(spec: RowSpec, deps: { paint: RowPaintFactory
 		try {
 			const paint = deps.paint(theme);
 			const model = modelFor(result, ctx);
-			// A degraded row keeps today's one raw line and settles no summary for the call slot to adopt.
-			if (model === UNKNOWN) return textFor(ctx, rawBody(result, paint));
+			// A degraded row keeps the raw one-line body and settles no summary for the call slot to adopt;
+			// an expanded frame spends that line by the same reflow rule as any other.
+			if (model === UNKNOWN) return textFor(ctx, rawBody(result, paint), options.expanded === true);
 			const body = spec.project(model, viewOf(options, ctx), paint);
-			if (options.expanded) return textFor(ctx, body);
+			if (options.expanded) return textFor(ctx, body, true);
 			// Collapsed: hand the one-line summary to the call slot through the shared state bag and draw no
 			// line here. Redraw only when it changed — an unchanged summary is not a new frame.
 			if (readSummary(ctx) !== body) {
@@ -405,7 +436,7 @@ export function createRowRenderers(spec: RowSpec, deps: { paint: RowPaintFactory
 		} catch (err) {
 			// The paint may itself be the thrower, so the degraded row is built without it.
 			logFailure(deps.log, ctx, err);
-			return textFor(ctx, rawBody(result, undefined));
+			return textFor(ctx, rawBody(result, undefined), options.expanded === true);
 		}
 	};