pi-zentui 0.29.1 → 0.29.3

package/docs/configuration.md

@@ -776,7 +776,7 @@ Rail, Tree, and Streaming share one private `AssistantMessageComponent` wrapper.
 
 Rail parses each native contiguous thinking run and shows every label in that run. Tree shows the latest five in each run; neither aggregates across intervening text or tool blocks. Both follow Pi's thinking visibility. Labels come from headings, top-level list items, and blank-line-separated prose. Complete strict 7-bit CSI SGR styling is stripped before parsing; every other terminal control, unsafe or unstructured content, malformed or over-limit input, unterminated fences/math, and unsupported structure leave that complete run native. Fenced code, Mermaid, display math, and indented nested content remain opaque bodies.
 
-Each selected SGR-free label is rendered as Markdown by a fresh Pi `Markdown` with the host child's exact theme, default `thinkingText`/italic style, and transform options. Native emphasis, code, links, HTML, LaTeX, and custom theme/transform callbacks therefore remain authoritative. Host horizontal padding is applied externally. Each label is exactly one terminal row; Pi TUI's ANSI/OSC/grapheme-aware width utilities crop the first rendered row and reserve one cell for `…` only when required. Empty, image, non-text, impossible-width, or throwing output restores the whole native run. Connectors are separate from Markdown and call the current `theme.fg("accent", connector)` every render, so custom themes directly control their appearance. Visible forms are:
+Each selected SGR-free label is rendered as Markdown by a fresh Pi `Markdown` with the host child's exact theme, default `thinkingText`/italic style, and transform options. Native emphasis, code, links, HTML, LaTeX, and custom theme/transform callbacks therefore remain authoritative. Host horizontal padding is applied externally. Each label is exactly one terminal row; Pi TUI's ANSI/OSC/grapheme-aware width utilities crop the first rendered row and reserve one cell for `…` only when required. Empty, image, non-text, impossible-width, or throwing output restores the whole native run. Connectors are separate from Markdown and call the current `theme.fg("accent", connector)` when building a layout, so custom themes directly control their appearance. Successful layouts are reused while width and connector-theme identity are unchanged; a width or theme identity change or invalidation refreshes them. Same-object theme mutations require invalidation. Visible forms are:
 
 ```text
 │ Thinking       ┆ Thinking

package/extensions/zentui/index.ts

@@ -336,9 +336,9 @@ export default function (pi: ExtensionAPI, host: ZentuiHost = {}) {
 			return undefined;
 		}
 	};
-	// Layered visibility is read-only recognition; installation ownership above stays exclusive.
-	// Data, demand, and timer consumers read the visible editor through these two helpers; anything
-	// that installs, restores, or mutates host UI must keep using ownsInstalledEditorFactory().
+	// Layered visibility does not grant installation ownership: editor install/restore stays exclusive.
+	// Data, demand, and timer consumers use these helpers; Working-line placement additionally
+	// requires focused, rendered border capability before its controller hides its own host row.
 	// Ownership counts before Pi constructs its editor; layered visibility requires the recorded
 	// instance to remain reachable through the current factory.
 	const layeredVisibleEditor = () => layeredEditor.editorVisibleThrough(currentEditorFactory());
@@ -402,17 +402,13 @@ export default function (pi: ExtensionAPI, host: ZentuiHost = {}) {
 		undefined,
 		(ctx) => {
 			if (!activeTuiContext || ctx.ui !== activeTuiContext.ui) return false;
-			if (!ownsInstalledEditorFactory()) {
-				activeEditor = undefined;
-				return false;
-			}
+			// Factory visibility alone is insufficient: the current focused editor must have
+			// rendered safe border geometry before the separately owned Working row can hide.
 			return Boolean(
-				activeEditor &&
-					sessionLifecycle.isCurrent(activeEditor.generation) &&
-					activeEditor.factory === installedEditorFactory &&
+				sessionLifecycle.isCurrent() &&
 					effectiveEditorEnabled() &&
 					currentConfig.components.editor.style !== "accent-rail" &&
-					activeEditor.editor.canEmbedWorkingLineBorder(),
+					visibleEditor()?.canEmbedWorkingLineBorder(),
 			);
 		},
 	);
@@ -939,10 +935,7 @@ export default function (pi: ExtensionAPI, host: ZentuiHost = {}) {
 		return observed;
 	};
 
-	// Exclusive: gates mutation of host UI such as the Working row.
-	const isActiveEditor = (editor: PolishedEditor | WrappedPolishedEditor, generation: number) =>
-		sessionLifecycle.isCurrent(generation) && activeEditor?.editor === editor;
-	// Read-only: also true for an editor still visible beneath a foreign wrapper.
+	// Also true for an editor still visible beneath a foreign wrapper; installation stays exclusive.
 	const isVisibleEditor = (editor: PolishedEditor | WrappedPolishedEditor, generation: number) =>
 		sessionLifecycle.isCurrent(generation) && visibleEditor() === editor;
 
@@ -950,7 +943,7 @@ export default function (pi: ExtensionAPI, host: ZentuiHost = {}) {
 		editor: PolishedEditor | WrappedPolishedEditor,
 		generation: number,
 	) => {
-		if (!isActiveEditor(editor, generation) || !activeTuiContext || !workingLineSessionReady)
+		if (!isVisibleEditor(editor, generation) || !activeTuiContext || !workingLineSessionReady)
 			return;
 		if (!host.skinOnly) workingLine.reconcile(activeTuiContext);
 		if (workingLine.isAvailable()) requestEditorRepaint();
@@ -966,10 +959,12 @@ export default function (pi: ExtensionAPI, host: ZentuiHost = {}) {
 	const editorWorkingLineFrame = (
 		editor: PolishedEditor | WrappedPolishedEditor,
 		generation: number,
-	) =>
-		!host.skinOnly && isActiveEditor(editor, generation)
-			? workingLine.currentWorkingLineFrame()
-			: undefined;
+	) => {
+		if (host.skinOnly || !sessionLifecycle.isCurrent(generation)) return undefined;
+		// Even a stale instance render must release a row whose current border disappeared.
+		const frame = workingLine.currentWorkingLineFrame();
+		return isVisibleEditor(editor, generation) ? frame : undefined;
+	};
 
 	/** Records a freshly constructed editor as owned (exclusive) or visible beneath a foreign wrapper. */
 	const registerConstructedEditor = (

package/extensions/zentui/layered-editor.ts

@@ -8,9 +8,9 @@
  * and redraw requests. The record is valid only while the outer factory observed at construction is
  * still the current editor factory, so any replacement of the chain invalidates it.
  *
- * Visibility is only evidence that a wrapper constructed the editor, not that its rows reach the
- * screen, so surfaces that mutate host UI (for example hiding the native Working row) must keep
- * requiring exclusive installation ownership instead of consulting this record.
+ * Construction alone cannot authorize hiding the Working row: its controller additionally requires
+ * a focused editor that has rendered safe border geometry. A wrapper that renders then discards those
+ * rows remains undetectable; supporting such wrappers requires an explicit host visibility contract.
  */
 export class LayeredEditorConsumer<Factory, Editor = unknown> {
 	private record?: {

package/extensions/zentui/minimalist-editor.ts

@@ -172,9 +172,11 @@ function renderTopLeft(
 	metadata: MinimalistEditorMetadata,
 	uiTheme: Theme,
 	config: ZentuiConfig,
+	renderBorder: (text: string) => string,
 	includeSessionName = true,
 ): string {
 	const source = config.components.editor.colorSource;
+	const separator = safeThemeFg(uiTheme, "muted", " · ");
 	const bashMode = bashModeLabel(inputText);
 	const parts: string[] = [];
 	if (bashMode) {
@@ -206,16 +208,20 @@ function renderTopLeft(
 		? sanitizeEditorMetadataText(metadata.sessionName ?? "")
 		: "";
 	if (config.components.editor.styles.minimalist.showSessionName && sessionName) {
-		parts.push(
-			renderStyleForSource(
-				uiTheme,
-				source,
-				componentColor(config, "editor", "sessionName"),
-				sessionName,
-			),
+		return joinStyled(
+			[
+				joinStyled(parts, separator),
+				renderStyleForSource(
+					uiTheme,
+					source,
+					componentColor(config, "editor", "sessionName"),
+					sessionName,
+				),
+			],
+			metadata.workingLineFrame ? renderBorder(" ─ ") : separator,
 		);
 	}
-	return joinStyled(parts, safeThemeFg(uiTheme, "muted", " · "));
+	return joinStyled(parts, separator);
 }
 
 function renderTopRight(
@@ -448,6 +454,7 @@ function renderTemplateBuiltin(
 				{ cwd: "", sessionName: metadata.sessionName },
 				uiTheme,
 				explicitConfig,
+				renderBorder,
 			);
 		case "turn_duration":
 			return renderTopLeft(
@@ -455,6 +462,7 @@ function renderTemplateBuiltin(
 				{ cwd: "", agentDurationMs: metadata.agentDurationMs, agentActive: metadata.agentActive },
 				uiTheme,
 				explicitConfig,
+				renderBorder,
 			);
 		case "model":
 			isolated.modelLabel = metadata.modelLabel;
@@ -693,8 +701,8 @@ export function renderMinimalistFrame({
 		if (!count || !/^[1-9]\d*$/.test(count)) return "";
 		return safeThemeFg(uiTheme, "muted", `${direction === "above" ? "↑" : "↓"} ${count} more`);
 	};
-	const topMetadata = renderTopLeft(inputText, metadata, uiTheme, config);
-	const topOperational = renderTopLeft(inputText, metadata, uiTheme, config, false);
+	const topMetadata = renderTopLeft(inputText, metadata, uiTheme, config, renderBorder);
+	const topOperational = renderTopLeft(inputText, metadata, uiTheme, config, renderBorder, false);
 	const topViewport = viewportLabel("above", viewport?.above);
 	const topLeft = joinStyled([topViewport, topMetadata], separator);
 	const topRightBudget = Math.max(0, width - 8 - visibleWidth(topLeft));
@@ -775,6 +783,7 @@ export function renderMinimalistFrame({
 									{ cwd: "", workingLineFrame: metadata.workingLineFrame },
 									uiTheme,
 									config,
+									renderBorder,
 									false,
 								)
 							: "";
@@ -784,13 +793,18 @@ export function renderMinimalistFrame({
 					if (visibleWidth(prefix) > budget) prefix = operational;
 					if (visibleWidth(prefix) > budget)
 						prefix = truncateToWidth(prefix, Math.max(0, budget), "…");
+					const metadataSeparator =
+						operational && metadata.workingLineFrame ? renderBorder(" ─ ") : separator;
 					rendered = renderMinimalistTemplate(
 						format,
 						resolve,
 						customNames,
-						Math.max(0, budget - visibleWidth(prefix) - (prefix ? visibleWidth(separator) : 0)),
+						Math.max(
+							0,
+							budget - visibleWidth(prefix) - (prefix ? visibleWidth(metadataSeparator) : 0),
+						),
 					);
-					return joinStyled([prefix, rendered], separator);
+					return joinStyled([prefix, rendered], metadataSeparator);
 				}
 				switch (slot) {
 					case "topLeft": {

package/extensions/zentui/thinking-experimental.ts

@@ -218,6 +218,8 @@ function croppedMarkdownRow(markdown: Markdown, source: string, width: number):
 /** A width-bounded private replacement for one native contiguous thinking run. */
 export class ThinkingStepsRows implements Component {
 	private readonly title: Markdown;
+	// Content and presentation are constructor-fixed; retain only the last successful layout.
+	private renderedCache: { width: number; theme: AccentTheme; rows: string[] } | undefined;
 	private readonly labels: Array<{ source: string; markdown: Markdown }>;
 
 	constructor(
@@ -246,12 +248,23 @@ export class ThinkingStepsRows implements Component {
 	}
 
 	private renderNative(width: number): string[] {
+		this.renderedCache = undefined;
 		this.onPresentation?.(false);
 		return this.native.render(width);
 	}
 
 	render(width: number): string[] {
 		try {
+			let theme: AccentTheme | undefined;
+			const cached = this.renderedCache;
+			if (cached?.width === width) {
+				// The host theme getter is a read-only lookup, including on cache hits.
+				theme = this.getTheme();
+				if (cached.theme === theme) {
+					this.onPresentation?.(true);
+					return [...cached.rows];
+				}
+			}
 			const outer = this.shape.paddingX;
 			const innerWidth = Math.floor(width) - outer * 2;
 			const titleConnector = this.mode === "rail" ? "│ " : "┆ ";
@@ -276,7 +289,7 @@ export class ThinkingStepsRows implements Component {
 				if (!label) return this.renderNative(width);
 				renderedLabels.push({ connector, label });
 			}
-			const theme = this.getTheme();
+			theme ??= this.getTheme();
 			const left = " ".repeat(outer);
 			const right = " ".repeat(outer);
 			const rows = [
@@ -286,14 +299,17 @@ export class ThinkingStepsRows implements Component {
 				),
 			];
 			if (!rows.every((row) => visibleWidth(row) <= width)) return this.renderNative(width);
+			this.renderedCache = { width, theme, rows };
 			this.onPresentation?.(true);
-			return rows;
+			// Containers and decorators may mutate their returned array.
+			return [...rows];
 		} catch {
 			return this.renderNative(width);
 		}
 	}
 
 	invalidate(): void {
+		this.renderedCache = undefined;
 		this.onInvalidate?.();
 		this.native.invalidate();
 		this.title.invalidate();

package/extensions/zentui/user-message.ts

@@ -54,7 +54,7 @@ function isNativeMarkdown(renderer: unknown): boolean {
 
 const sanitizedMarkdownCache = new WeakMap<
 	object,
-	{ lines: unknown; text: string; options: unknown }
+	{ lines: unknown; sourceText: string; text: string; options: unknown }
 >();
 
 // Framing eligibility is deliberately narrower than the source trust boundary.
@@ -74,7 +74,14 @@ function withSanitizedMarkdownSources<T>(instance: unknown, render: (adapted: bo
 			if (!isRecord(options.value)) return;
 			const transform = options.value.transform;
 			if (transform !== undefined && typeof transform !== "function") return;
-			const source = sanitizeUserMessageSourceText(text.value);
+			const cached = sanitizedMarkdownCache.get(value);
+			// Source sanitization depends only on the immutable raw string, not on
+			// width, theme, options or native output invalidation. Reuse just that
+			// result; the guarded native render and its cache checks still run.
+			const source =
+				cached && cached.sourceText === text.value
+					? cached.text
+					: sanitizeUserMessageSourceText(text.value);
 			const safeOptions = {
 				...options.value,
 				...(transform
@@ -86,7 +93,6 @@ function withSanitizedMarkdownSources<T>(instance: unknown, render: (adapted: bo
 						}
 					: {}),
 			};
-			const cached = sanitizedMarkdownCache.get(value);
 			restore.push(() => {
 				Object.defineProperty(value, "text", text);
 				Object.defineProperty(value, "options", options);
@@ -95,6 +101,7 @@ function withSanitizedMarkdownSources<T>(instance: unknown, render: (adapted: bo
 				// them normally, and cleanup needs no retained component references.
 				sanitizedMarkdownCache.set(value, {
 					lines: value.cachedText === source ? value.cachedLines : undefined,
+					sourceText: text.value,
 					text: source,
 					options: options.value,
 				});
@@ -172,18 +179,20 @@ function nativeMarkdown(instance: PatchableUserMessagePrototype):
 	}
 	const children = direct;
 	if (!Array.isArray(children) || children.length !== 1) return undefined;
-	const box = children[0];
-	if (!isRecord(box) || !Array.isArray(box.children) || box.children.length !== 1) return undefined;
-	const renderer = box.children[0];
+	// Pi >=1.0 holds the Markdown directly (it pads/colors itself); older Pi
+	// wrapped it in a Box. Accept both shapes.
+	let renderer = children[0];
+	const direct1 = isNativeMarkdown(renderer);
+	if (isRecord(renderer) && !direct1) {
+		const box = renderer;
+		if (!Array.isArray(box.children) || box.children.length !== 1) return undefined;
+		renderer = box.children[0];
+	}
 	if (!isNativeMarkdown(renderer)) return undefined;
 	const child = renderer as unknown as Record<string, unknown>;
-	if (
-		typeof child.text !== "string" ||
-		child.paddingX !== 0 ||
-		child.paddingY !== 0 ||
-		!isRecord(child.theme)
-	)
-		return undefined;
+	if (typeof child.text !== "string" || !isRecord(child.theme)) return undefined;
+	// Box-wrapped (older Pi) Markdown must be unpadded; Pi >=1.0 pads it itself.
+	if (!direct1 && (child.paddingX !== 0 || child.paddingY !== 0)) return undefined;
 	for (const key of [
 		"heading",
 		"link",
@@ -210,6 +219,8 @@ function nativeMarkdown(instance: PatchableUserMessagePrototype):
 	)
 		return undefined;
 	if (child.defaultTextStyle !== undefined && !isRecord(child.defaultTextStyle)) return undefined;
+	// Pi >=1.0 puts the message background in defaultTextStyle; Zentui frames draw their own.
+	const { bgColor: _bg, ...textStyle } = (child.defaultTextStyle ?? {}) as Record<string, unknown>;
 	return {
 		renderer: renderer as unknown as Markdown,
 		text: child.text,
@@ -217,9 +228,9 @@ function nativeMarkdown(instance: PatchableUserMessagePrototype):
 			theme: child.theme as unknown as NonNullable<
 				UserMessageStyleRenderInput["markdown"]
 			>["theme"],
-			defaultTextStyle: child.defaultTextStyle as NonNullable<
-				UserMessageStyleRenderInput["markdown"]
-			>["defaultTextStyle"],
+			defaultTextStyle: (child.defaultTextStyle === undefined
+				? undefined
+				: textStyle) as NonNullable<UserMessageStyleRenderInput["markdown"]>["defaultTextStyle"],
 			options: child.options as NonNullable<UserMessageStyleRenderInput["markdown"]>["options"],
 		},
 	};

package/extensions/zentui/working-line.ts

@@ -434,20 +434,26 @@ export function normalizeWorkingLineStyleSpec(value: ColorSpec | undefined): Col
 	return tokens.join(" ");
 }
 
-function renderTier(
+function workingLineTierRenderer(
 	theme: ThemeLike,
 	config: WorkingLineComponentConfig,
 	colors: PolishedTuiColors,
-	tier: Tier,
-	text: string,
-): string {
-	return renderStyleForSourceOrFallback(
-		theme,
-		config.colorSource,
-		normalizeWorkingLineStyleSpec(workingLineColor(config, colors, tier)),
-		WORKING_LINE_FALLBACKS[tier],
-		text,
-	);
+): (tier: Tier, text: string) => string {
+	// Palette validation is invariant within this build, but must not survive a
+	// metric/config/theme rebuild. Resolve lazily so unused tiers remain untouched.
+	const tierStyles = new Map<Tier, ColorSpec | undefined>();
+	return (tier, text) => {
+		if (!tierStyles.has(tier)) {
+			tierStyles.set(tier, normalizeWorkingLineStyleSpec(workingLineColor(config, colors, tier)));
+		}
+		return renderStyleForSourceOrFallback(
+			theme,
+			config.colorSource,
+			tierStyles.get(tier),
+			WORKING_LINE_FALLBACKS[tier],
+			text,
+		);
+	};
 }
 
 /** Resolve the fixed, nonanimated high-tier style used by persisted Turn summaries. */
@@ -484,9 +490,7 @@ export function snapshotWorkingLineHighStyle(
 }
 
 function renderAnimatedText(
-	theme: ThemeLike,
-	config: WorkingLineComponentConfig,
-	colors: PolishedTuiColors,
+	render: (tier: Tier, text: string) => string,
 	cells: GraphemeCell[],
 	width: number,
 	tick: number,
@@ -504,7 +508,7 @@ function renderAnimatedText(
 		if (previous?.tier === tier) previous.text += cell.text;
 		else runs.push({ tier, text: cell.text });
 	}
-	return runs.map((run) => renderTier(theme, config, colors, run.tier, run.text)).join("");
+	return runs.map((run) => render(run.tier, run.text)).join("");
 }
 
 export type WorkingLineRuntimeSegments = {
@@ -813,8 +817,7 @@ function spinnerRowCells(
 function renderWorkingLineSchedule(
 	definition: ScheduleDefinition,
 	config: WorkingLineComponentConfig,
-	colors: PolishedTuiColors,
-	theme: ThemeLike,
+	render: (tier: Tier, text: string) => string,
 	rowCells: GraphemeCell[],
 	spinnerCells: Map<string, GraphemeCell[]> | undefined,
 	width: number,
@@ -834,15 +837,7 @@ function renderWorkingLineSchedule(
 	const renderTextForTick = (tick: number): string => {
 		let cachedText = textRenderCache.get(tick);
 		if (cachedText === undefined) {
-			cachedText = renderAnimatedText(
-				theme,
-				config,
-				colors,
-				rowCells,
-				width,
-				tick,
-				config.textAnimation,
-			);
+			cachedText = renderAnimatedText(render, rowCells, width, tick, config.textAnimation);
 			textRenderCache.set(tick, cachedText);
 		}
 		return cachedText;
@@ -856,7 +851,7 @@ function renderWorkingLineSchedule(
 		let cachedSpinner = spinnerRenderCache.get(index);
 		if (cachedSpinner === undefined) {
 			const glyph = spinner.frames[index] ?? spinner.frames[0];
-			cachedSpinner = renderTier(theme, config, colors, "high", glyph);
+			cachedSpinner = render("high", glyph);
 			spinnerRenderCache.set(index, cachedSpinner);
 		}
 		return cachedSpinner;
@@ -874,9 +869,7 @@ function renderWorkingLineSchedule(
 			spinner.frames[state.spinnerTick % spinner.frames.length] ?? spinner.frames[0];
 		const frame = config.animateSpinnerColor
 			? `${renderAnimatedText(
-					theme,
-					config,
-					colors,
+					render,
 					spinnerCells?.get(spinnerGlyph) ?? rowCells,
 					width,
 					state.textTick,
@@ -934,6 +927,7 @@ function buildPreparedWorkingLineFrames(
 	const textOrigin = config.animateSpinnerColor ? 0 : spinnerWidth + 1;
 	const textCycle = textPeriod(config.textAnimation, animatedTextWidth);
 	const textPhase = normalizedPhaseTick(textStartTick, textCycle);
+	const render = workingLineTierRenderer(theme, config, colors);
 
 	if (config.textAnimation === "disabled") {
 		const frameStates = Array.from({ length: spinner.frames.length }, (_, index) => ({
@@ -943,7 +937,7 @@ function buildPreparedWorkingLineFrames(
 		let codeUnits = 0;
 		const frames = frameStates.map((state) => {
 			const glyph = spinner.frames[state.spinnerTick % spinner.frames.length] ?? spinner.frames[0];
-			const frame = `${renderTier(theme, config, colors, "mid", `${glyph} ${composed.row}`)}${SGR_RESET}`;
+			const frame = `${render("mid", `${glyph} ${composed.row}`)}${SGR_RESET}`;
 			codeUnits += frame.length;
 			if (codeUnits > MAX_WORKING_LINE_FRAME_CODE_UNITS)
 				throw new Error("Working-line animation exceeds its memory cap");
@@ -985,8 +979,7 @@ function buildPreparedWorkingLineFrames(
 		const rendered = renderWorkingLineSchedule(
 			exact,
 			config,
-			colors,
-			theme,
+			render,
 			rowCells,
 			spinnerCells,
 			animatedTextWidth,
@@ -1029,8 +1022,7 @@ function buildPreparedWorkingLineFrames(
 		const rendered = renderWorkingLineSchedule(
 			fallback,
 			config,
-			colors,
-			theme,
+			render,
 			rowCells,
 			spinnerCells,
 			animatedTextWidth,
@@ -1064,6 +1056,7 @@ export function buildWorkingLineSpinnerFrames(
 ): { frames: string[]; frameStates: WorkingLineFrameState[]; intervalMs: number } {
 	const spinner = WORKING_LINE_SPINNERS[config.spinner];
 	workingLineSpinnerWidth(config.spinner);
+	const render = workingLineTierRenderer(theme, config, colors);
 	const phase = Number.isFinite(startTick) ? Math.max(0, Math.floor(startTick)) : 0;
 	const frameStates = Array.from({ length: spinner.frames.length }, (_, index) => ({
 		spinnerTick: phase + index,
@@ -1071,7 +1064,7 @@ export function buildWorkingLineSpinnerFrames(
 	}));
 	const frames = frameStates.map((state) => {
 		const glyph = spinner.frames[state.spinnerTick % spinner.frames.length] ?? spinner.frames[0];
-		return `${renderTier(theme, config, colors, "high", glyph)}${SGR_RESET}`;
+		return `${render("high", glyph)}${SGR_RESET}`;
 	});
 	return { frames, frameStates, intervalMs: config.spinnerIntervalMs };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-zentui",
-	"version": "0.29.1",
+	"version": "0.29.3",
 	"description": "Modular UI components for Pi and Oh My Pi — customizable editors, messages, progress displays, and statuslines.",
 	"type": "module",
 	"license": "MIT",