@zenodinh/pi-render 0.1.7 → 0.1.8

package/package.json

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

package/src/core/paint.ts

@@ -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),

package/src/core/types/paint.ts

@@ -26,7 +26,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;

package/src/renderers/content/table.ts

@@ -9,9 +9,10 @@
  *
  * 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.
+ * 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.
  *
  * 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.
@@ -165,7 +166,13 @@ function renderTable(token: TableToken, width: number, paint: ContentPaint): str
 				const unit = index < cells.length - 1 ? ` ${padded} ${bar}` : ` ${padded} `;
 				return banded(index) ? paint.headerBand(unit) : unit;
 			});
-			physical.push(`${bar}${parts.join("")}${bar}`);
+			// #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}`);
 		}
 	};
 

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);
 		}
 	};