@quandev104/pi-style 0.2.1 → 0.2.2

package/extension-src/pi-style/features/messages/index.ts

@@ -20,6 +20,7 @@ type DecoratedRenderCacheEntry = {
 	nativeLines: readonly string[];
 	result: readonly string[];
 };
+type ChildrenScanState = { childrenRef: readonly unknown[]; length: number };
 type MessageDecorationTestState = {
 	decoratePasses: number;
 	cacheHits: number;
@@ -34,6 +35,15 @@ const MAX_LINE_ANALYSIS_ENTRIES = 4096;
 
 let renderCacheByInstance = new WeakMap<object, Map<string, DecoratedRenderCacheEntry>>();
 let lineAnalysisCache = new Map<string, LineAnalysis>();
+// Live iterator over the analysis cache's insertion (= recency) order, reused
+// across evictions: `keys().next()` allocates a fresh iterator (~1.4µs) each
+// call, which dominates the per-insert eviction cost during streaming. A live
+// Map iterator skips deleted entries and always hands back the current
+// least-recently-used key, so eviction choice is identical to a fresh iterator.
+let lineCacheEvictionCursor: Iterator<string, undefined, undefined> | undefined;
+// Per-assistant-message guard for the updateContent children scan: skips the
+// blank/interim scans when the contentContainer children array is unchanged.
+let childrenScanByInstance = new WeakMap<object, ChildrenScanState>();
 const messageDecorationTestState: MessageDecorationTestState = {
 	decoratePasses: 0,
 	cacheHits: 0,
@@ -59,7 +69,9 @@ function splitLeadingMarkers(line: string): { head: string; rest: string } {
 		if (end === -1) break;
 		index = end + 1;
 	}
-	return { head: line.slice(0, index), rest: line.slice(index) };
+	// Strings are immutable: with no markers, `rest` can alias the line itself
+	// instead of allocating a full copy on every analyzed line.
+	return index === 0 ? { head: "", rest: line } : { head: line.slice(0, index), rest: line.slice(index) };
 }
 
 /** Leading SGR escape sequence of a line ("" when none). */
@@ -74,47 +86,214 @@ function leadingSgr(line: string): string {
 	return "";
 }
 
-/** Whether an SGR sequence sets/resets the terminal background color. */
+/** Whether an SGR sequence sets/resets the terminal background color (allocation-free `Number`-equivalent parse). */
 function isBackgroundSgr(sequence: string): boolean {
 	if (!sequence.startsWith("\x1b[") || !sequence.endsWith("m")) return false;
-	for (const code of sequence.slice(2, -1).split(";")) {
-		const value = Number(code);
-		if (value === 48 || value === 49) return true;
-		if (value >= 40 && value <= 47) return true;
-		if (value >= 100 && value <= 107) return true;
+	// Splits on ";" and applies Number() per token: Number("") === 0, all-digit
+	// tokens parse as integers, anything else is NaN (matches no range).
+	let value = 0;
+	let empty = true;
+	let valid = true;
+	for (let index = 2; index < sequence.length - 1; index++) {
+		const code = sequence.charCodeAt(index);
+		if (code === 0x3b) {
+			if (valid && matchesBackgroundCode(empty ? 0 : value)) return true;
+			value = 0;
+			empty = true;
+			valid = true;
+			continue;
+		}
+		if (code < 0x30 || code > 0x39) {
+			valid = false;
+			continue;
+		}
+		value = value * 10 + (code - 0x30);
+		empty = false;
 	}
-	return false;
+	return valid && matchesBackgroundCode(empty ? 0 : value);
+}
+
+function matchesBackgroundCode(value: number): boolean {
+	return value === 48 || value === 49 || (value >= 40 && value <= 47) || (value >= 100 && value <= 107);
+}
+
+/**
+ * Width of a string whose visible content is printable ASCII carrying only
+ * escapes pi-tui recognizes (CSI ending in m/G/K/H/J, OSC/APC ending in BEL or
+ * ST) — computed in one scan, no Intl.Segmenter pass. Returns undefined whenever
+ * the string can leave that domain (tabs, controls, non-ASCII, or
+ * unrecognized/unterminated escapes); callers then delegate to `visibleWidth`,
+ * which makes the result provably identical to pi-tui's while skipping grapheme
+ * segmentation for the streaming-hot line shapes. The escape scan mirrors
+ * pi-tui's `extractAnsiCode` exactly (including tab-in-sequence handling, since
+ * pi-tui replaces tabs before scanning but still consumes the same sequence).
+ */
+function certifiedAsciiWidth(value: string): number | undefined {
+	let width = 0;
+	let index = 0;
+	const length = value.length;
+	while (index < length) {
+		const code = value.charCodeAt(index);
+		if (code === 0x1b) {
+			const next = index + 1 < length ? value.charCodeAt(index + 1) : -1;
+			if (next === 0x5b) {
+				// CSI: pi-tui consumes through the first m/G/K/H/J byte.
+				let scan = index + 2;
+				while (scan < length) {
+					const terminator = value.charCodeAt(scan);
+					if (
+						terminator === 0x6d || // m
+						terminator === 0x47 || // G
+						terminator === 0x4b || // K
+						terminator === 0x48 || // H
+						terminator === 0x4a // J
+					) {
+						index = scan + 1;
+						break;
+					}
+					scan++;
+				}
+				if (scan >= length) return undefined; // unterminated: pi-tui emits the ESC visibly
+				continue;
+			}
+			if (next === 0x5d || next === 0x5f) {
+				// OSC/APC: consumed through BEL or ST (ESC \).
+				let scan = index + 2;
+				let end = -1;
+				while (scan < length) {
+					const terminator = value.charCodeAt(scan);
+					if (terminator === 0x07) {
+						end = scan + 1;
+						break;
+					}
+					if (terminator === 0x1b && scan + 1 < length && value.charCodeAt(scan + 1) === 0x5c) {
+						end = scan + 2;
+						break;
+					}
+					scan++;
+				}
+				if (end < 0) return undefined; // unterminated: delegate
+				index = end;
+				continue;
+			}
+			return undefined; // any other escape form: delegate
+		}
+		if (code < 0x20 || code > 0x7e) return undefined; // tab/control/non-ASCII: delegate
+		width++;
+		index++;
+	}
+	return width;
+}
+
+/** visibleWidth with a single-scan fast path; identical results, cheaper for streaming-hot lines. */
+function certifiedVisibleWidth(value: string): number {
+	return certifiedAsciiWidth(value) ?? visibleWidth(value);
+}
+
+/**
+ * Memoized prefix width: the prefix (typically non-ASCII, e.g. "│ ") always
+ * delegates to pi-tui's visibleWidth, and the streaming-hot unique lines evict
+ * it from pi-tui's internal FIFO width cache, re-segmenting it every pass.
+ * visibleWidth is pure, so a one-entry memo is exactly equivalent.
+ */
+let prefixWidthMemo: { prefix: string; width: number } | undefined;
+function prefixWidthOf(prefix: string): number {
+	if (prefixWidthMemo?.prefix === prefix) return prefixWidthMemo.width;
+	const width = certifiedVisibleWidth(prefix);
+	prefixWidthMemo = { prefix, width };
+	return width;
 }
 
 function contentText(line: string): string {
+	// Fast path: every OSC133 marker contains ESC and the strip loop below copies
+	// every non-ESC char verbatim — an ESC-free line is its own content text.
+	if (!line.includes("\x1b")) return line;
+	// Slice-based build: one concatenation per escape span instead of per char.
 	let output = "";
+	let sliceStart = 0;
 	for (let index = 0; index < line.length; index++) {
-		if (line.charCodeAt(index) !== 27) {
-			output += line[index];
-			continue;
-		}
+		if (line.charCodeAt(index) !== 27) continue;
+		output += line.slice(sliceStart, index);
 		const next = line[index + 1];
 		if (next === "]") {
 			index += 2;
 			while (index < line.length && line.charCodeAt(index) !== 7) index++;
-			continue;
-		}
-		if (next === "[") {
+		} else if (next === "[") {
 			index += 2;
 			while (index < line.length && (line.charCodeAt(index) < 64 || line.charCodeAt(index) > 126)) index++;
 		}
+		sliceStart = index + 1;
+	}
+	output += line.slice(sliceStart);
+	// The strip above can never leave an ESC in the output (every ESC consumes at
+	// least itself, and both escape branches run to their terminator or end of
+	// line), so these marker removals are a provably-untaken safety net.
+	if (output.includes("\x1b]133;")) {
+		return output.replaceAll(OSC133_ZONE_START, "").replaceAll(OSC133_ZONE_END, "").replaceAll(OSC133_ZONE_FINAL, "");
 	}
-	return output.replaceAll(OSC133_ZONE_START, "").replaceAll(OSC133_ZONE_END, "").replaceAll(OSC133_ZONE_FINAL, "");
+	return output;
 }
 
+/** Whether a BMP code unit is whitespace with exact `\s` regex semantics (ECMAScript WhiteSpace + LineTerminator). */
+function isWhitespaceCode(code: number): boolean {
+	// Fast path: ASCII whitespace — space, \t, \n, \v, \f, \r.
+	if (code === 0x20 || (code >= 0x09 && code <= 0x0d)) return true;
+	if (code < 0x80) return false;
+	// The non-ASCII members of \s (no surrogates or astral code points are whitespace).
+	return (
+		code === 0x00a0 ||
+		code === 0x1680 ||
+		(code >= 0x2000 && code <= 0x200a) ||
+		code === 0x2028 ||
+		code === 0x2029 ||
+		code === 0x202f ||
+		code === 0x205f ||
+		code === 0x3000 ||
+		code === 0xfeff
+	);
+}
+
+/** Whether the line carries any non-whitespace content, in one ANSI-skipping scan (no content string built, no code-point array, no per-char regex). */
 function hasContent(line: string): boolean {
-	return [...contentText(line)].some((character) => !/\s/u.test(character));
+	const length = line.length;
+	let index = 0;
+	while (index < length) {
+		const code = line.charCodeAt(index);
+		if (code === 0x1b) {
+			// Skip exactly the spans contentText strips: OSC through BEL, CSI through
+			// its final byte; a lone ESC drops just itself.
+			const next = index + 1 < length ? line.charCodeAt(index + 1) : -1;
+			if (next === 0x5d) {
+				index += 2;
+				while (index < length && line.charCodeAt(index) !== 0x07) index++;
+			} else if (next === 0x5b) {
+				index += 2;
+				while (index < length) {
+					const inner = line.charCodeAt(index);
+					if (inner >= 64 && inner <= 126) break;
+					index++;
+				}
+			}
+			index++;
+			continue;
+		}
+		// Surrogate halves never match \s: an astral code point (or a lone surrogate)
+		// always counts as content, equivalent to the previous per-code-point regex.
+		if (code >= 0xd800 && code <= 0xdfff) return true;
+		if (!isWhitespaceCode(code)) return true;
+		index++;
+	}
+	return false;
 }
 
 function getLineAnalysis(line: string): LineAnalysis {
 	const cached = lineAnalysisCache.get(line);
 	if (cached) {
 		messageDecorationTestState.lineCacheHits++;
+		// True LRU: re-insert on hit so recency is refreshed; the eviction below then
+		// drops the least recently used entry instead of the oldest inserted one.
+		lineAnalysisCache.delete(line);
+		lineAnalysisCache.set(line, cached);
 		return cached;
 	}
 	messageDecorationTestState.lineCacheMisses++;
@@ -125,21 +304,30 @@ function getLineAnalysis(line: string): LineAnalysis {
 	const backgroundBody = isBackgroundWrapped
 		? leadingMarkers.rest.slice(backgroundAnsi.length, leadingMarkers.rest.length - BG_RESET.length)
 		: undefined;
+	const hasOscStart = line.startsWith(OSC133_ZONE_START);
 	const analysis: LineAnalysis = {
-		visibleWidth: visibleWidth(line),
+		visibleWidth: certifiedVisibleWidth(line),
 		hasContent: hasContent(line),
-		oscEnvelope: extractOscEnvelope(line),
-		hasOscStart: line.startsWith(OSC133_ZONE_START),
+		oscEnvelope: hasOscStart ? extractOscEnvelope(line) : undefined,
+		hasOscStart,
 		leadingMarkers,
 		isBackgroundWrapped,
 		backgroundAnsi,
 		backgroundBody,
-		backgroundBodyWidth: backgroundBody === undefined ? undefined : visibleWidth(backgroundBody),
+		backgroundBodyWidth: backgroundBody === undefined ? undefined : certifiedVisibleWidth(backgroundBody),
 	};
 	lineAnalysisCache.set(line, analysis);
 	if (lineAnalysisCache.size > MAX_LINE_ANALYSIS_ENTRIES) {
-		const oldestKey = lineAnalysisCache.keys().next().value;
-		if (oldestKey !== undefined) lineAnalysisCache.delete(oldestKey);
+		let cursor = lineCacheEvictionCursor;
+		if (cursor === undefined) cursor = lineAnalysisCache.keys();
+		let oldest = cursor.next();
+		if (oldest.done) {
+			// Every not-yet-visited entry was refreshed past the cursor; restart from the true LRU head.
+			cursor = lineAnalysisCache.keys();
+			oldest = cursor.next();
+		}
+		lineCacheEvictionCursor = cursor;
+		if (!oldest.done && oldest.value !== undefined) lineAnalysisCache.delete(oldest.value);
 	}
 	return analysis;
 }
@@ -175,11 +363,12 @@ function decorateMessageLine(
 		multilineEnvelope: boolean;
 		prefix: string;
 		prefixWidth: number;
+		continuationLead: string;
 	},
 	analysis = getLineAnalysis(line),
 ): string {
-	const { firstEnvelope, firstHasStart, multilineEnvelope, prefix, prefixWidth } = options;
-	const lead = index === contentIndex ? prefix : index > contentIndex ? " ".repeat(prefixWidth) : "";
+	const { firstEnvelope, firstHasStart, multilineEnvelope, prefix, prefixWidth, continuationLead } = options;
+	const lead = index === contentIndex ? prefix : index > contentIndex ? continuationLead : "";
 	const leadWidth = index < contentIndex ? 0 : prefixWidth;
 	if (index === contentIndex && firstEnvelope)
 		return `${firstEnvelope.start}${rebuildAtWidth(firstEnvelope.body, width, prefix, prefixWidth)}${firstEnvelope.end}`;
@@ -251,39 +440,65 @@ function prefixNative(lines: unknown, width: number, prefix: string): string[] |
 	if (!Array.isArray(lines) || lines.length === 0 || !lines.every((line) => typeof line === "string")) return undefined;
 	messageDecorationTestState.decoratePasses++;
 	const nativeLines = lines as string[];
-	const prefixWidth = visibleWidth(prefix);
+	const prefixWidth = prefixWidthOf(prefix);
 	if (width <= prefixWidth) return undefined;
 	const bodyWidth = width - prefixWidth;
-	const first = nativeLines[0] ?? "";
+	// One cache lookup per line per pass; every later consumer reuses this array
+	// instead of re-requesting analysis (and re-churning LRU recency) per line.
+	const analyses = nativeLines.map((line) => getLineAnalysis(line));
 	const last = nativeLines.at(-1) ?? "";
-	const lastAnalysis = getLineAnalysis(last);
+	const lastAnalysis = analyses[analyses.length - 1] ?? getLineAnalysis(last);
 	const multilineEnvelope = nativeLines.length > 1 && last.startsWith(OSC133_ZONE_END + OSC133_ZONE_FINAL);
 	// The last line is a content-start candidate only when the envelope is
 	// single-line, or when no earlier line carries content. Assistant messages
 	// with a single content line render as a multiline envelope whose only body
 	// sits on the final line ([OSC133_A, OSC133_END+FINAL+body]); excluding it
 	// would drop the prefix for every short assistant reply.
-	const firstContentIndex = nativeLines.findIndex((line, index) => {
-		if (index !== nativeLines.length - 1 || !multilineEnvelope) return getLineAnalysis(line).hasContent;
-		return (
-			!nativeLines.slice(0, index).some((earlier) => getLineAnalysis(earlier).hasContent) && lastAnalysis.hasContent
-		);
-	});
+	let firstContentIndex = -1;
+	for (let index = 0; index < nativeLines.length; index++) {
+		const analysis = analyses[index] ?? getLineAnalysis(nativeLines[index] ?? "");
+		if (index !== nativeLines.length - 1 || !multilineEnvelope) {
+			if (analysis.hasContent) {
+				firstContentIndex = index;
+				break;
+			}
+			continue;
+		}
+		let earlierHasContent = false;
+		for (let earlier = 0; earlier < index; earlier++) {
+			if ((analyses[earlier] ?? getLineAnalysis(nativeLines[earlier] ?? "")).hasContent) {
+				earlierHasContent = true;
+				break;
+			}
+		}
+		if (!earlierHasContent && lastAnalysis.hasContent) firstContentIndex = index;
+		break;
+	}
 	if (firstContentIndex < 0) return nativeLines;
-	const firstAnalysis = getLineAnalysis(first);
+	const firstAnalysis = analyses[0] ?? getLineAnalysis(nativeLines[0] ?? "");
 	const firstEnvelope = firstContentIndex === 0 ? firstAnalysis.oscEnvelope : undefined;
 	const firstHasStart = firstContentIndex === 0 && firstAnalysis.hasOscStart;
+	const continuationLead = " ".repeat(prefixWidth);
 	const decorated = nativeLines.map((line, index) =>
-		decorateMessageLine(line, index, nativeLines.length - 1, firstContentIndex, width, {
-			firstEnvelope,
-			firstHasStart,
-			multilineEnvelope,
-			prefix,
-			prefixWidth,
-		}),
+		decorateMessageLine(
+			line,
+			index,
+			nativeLines.length - 1,
+			firstContentIndex,
+			width,
+			{
+				firstEnvelope,
+				firstHasStart,
+				multilineEnvelope,
+				prefix,
+				prefixWidth,
+				continuationLead,
+			},
+			analyses[index],
+		),
 	);
-	if (!decorated.every((line) => visibleWidth(line) <= width)) return undefined;
-	if (!nativeLines.every((line) => getLineAnalysis(line).visibleWidth <= bodyWidth)) return undefined;
+	if (!decorated.every((line) => certifiedVisibleWidth(line) <= width)) return undefined;
+	if (!analyses.every((analysis) => analysis.visibleWidth <= bodyWidth)) return undefined;
 	return decorated;
 }
 
@@ -308,6 +523,8 @@ export function __resetMessageDecorationTestState(): void {
 	messageDecorationTestState.lineCacheMisses = 0;
 	renderCacheByInstance = new WeakMap<object, Map<string, DecoratedRenderCacheEntry>>();
 	lineAnalysisCache = new Map<string, LineAnalysis>();
+	lineCacheEvictionCursor = undefined;
+	childrenScanByInstance = new WeakMap<object, ChildrenScanState>();
 }
 
 export function decorateMessageRender(
@@ -325,7 +542,7 @@ export function decorateMessageRender(
 	const width = typeof args[0] === "number" ? args[0] : 0;
 	const prefix = snapshot.assistantPrefix;
 	if (!snapshot.assistantEnabled) return Reflect.apply(original, instance, args);
-	const prefixWidth = visibleWidth(prefix);
+	const prefixWidth = prefixWidthOf(prefix);
 	if (width <= prefixWidth) return Reflect.apply(original, instance, args);
 	// Exactly one native invocation. If the reduced render cannot be certified, the
 	// already-obtained result is the only safe fallback; retrying can mutate state.
@@ -383,11 +600,37 @@ function hasToolCallItems(message: unknown): boolean {
  * across that module boundary is unreliable.
  */
 function isBlankTextChild(child: unknown): boolean {
-	const candidate = child as { setCustomBgFn?: unknown; render?: (width: number) => string[] } | undefined;
+	const candidate = child as
+		| { setCustomBgFn?: unknown; render?: (width: number) => string[]; text?: unknown }
+		| undefined;
 	if (typeof candidate?.setCustomBgFn !== "function" || typeof candidate.render !== "function") return false;
+	// pi-tui's Text exposes its raw source text as a plain `.text` property (kept in
+	// sync by the constructor and setText). render(0) only wraps/pads that text with
+	// spaces and ANSI (both blank under contentText+trim), so the property check is
+	// equivalent — and avoids a full Text render per child on every updateContent pass
+	// (which would also pollute Text's own width-keyed render cache with width 0).
+	if (typeof candidate.text === "string") return contentText(candidate.text).trim() === "";
 	return contentText(candidate.render(0).join("\n")).trim() === "";
 }
 
+/**
+ * Skip the post-update children scans when nothing could have changed:
+ * `AssistantMessageComponent.updateContent` starts every pass with
+ * `contentContainer.clear()`, and pi-tui's `Container.clear()` assigns a fresh
+ * `children` array (children are REPLACED, never mutated in place across passes).
+ * An unchanged reference (and length) therefore means the native layout did not
+ * rebuild since this instance was last scanned, so the previous scan's collapse
+ * is still in effect. Kept per-instance via WeakMap so messages are GC-able.
+ */
+function childrenUnchangedSinceScan(instance: object, children: readonly unknown[]): boolean {
+	const state = childrenScanByInstance.get(instance);
+	return state !== undefined && state.childrenRef === children && state.length === children.length;
+}
+
+function markChildrenScanned(instance: object, children: readonly unknown[]): void {
+	childrenScanByInstance.set(instance, { childrenRef: children, length: children.length });
+}
+
 /**
  * Collapse Pi's hidden-thinking placeholder row to zero trace.
  *
@@ -419,11 +662,11 @@ export function decorateMessageUpdate(
 		hiddenThinkingLabel?: string;
 		contentContainer?: { children?: unknown[] };
 	};
-	// Only meaningful when Pi renders the hidden-block label (hideThinkingBlock)
-	// and the extension has blanked that label out ("" — the zero-trace mode).
-	if (snapshot.collapseHiddenThinking && target.hideThinkingBlock === true && target.hiddenThinkingLabel === "") {
-		const children = target.contentContainer?.children;
-		if (children) {
+	const children = target.contentContainer?.children;
+	if (children && !childrenUnchangedSinceScan(instance, children)) {
+		// Only meaningful when Pi renders the hidden-block label (hideThinkingBlock)
+		// and the extension has blanked that label out ("" — the zero-trace mode).
+		if (snapshot.collapseHiddenThinking && target.hideThinkingBlock === true && target.hiddenThinkingLabel === "") {
 			for (let index = children.length - 1; index >= 0; index--) {
 				if (!isBlankTextChild(children[index])) continue;
 				children.splice(index, 1);
@@ -432,21 +675,19 @@ export function decorateMessageUpdate(
 				if (isSpacerChild(children[index])) children.splice(index, 1);
 			}
 		}
-	}
-	// Interim narration: assistant messages that carry tool calls use their text
-	// only to narrate while working; the tool blocks tell the story. Hide the text
-	// so the feed shows the run's summary and the final answer. Deterministic per
-	// content — streaming, scroll-back, and resume behave identically. Errors and
-	// truncation notices are Text children and stay; if only spacers remain the
-	// message becomes zero-trace.
-	if (snapshot.hideInterimText && hasToolCallItems(args[0])) {
-		const children = target.contentContainer?.children;
-		if (children) {
+		// Interim narration: assistant messages that carry tool calls use their text
+		// only to narrate while working; the tool blocks tell the story. Hide the text
+		// so the feed shows the run's summary and the final answer. Deterministic per
+		// content — streaming, scroll-back, and resume behave identically. Errors and
+		// truncation notices are Text children and stay; if only spacers remain the
+		// message becomes zero-trace.
+		if (snapshot.hideInterimText && hasToolCallItems(args[0])) {
 			for (let index = children.length - 1; index >= 0; index--) {
 				if (isInterimTextChild(children[index])) children.splice(index, 1);
 			}
 			if (children.every((child) => isSpacerChild(child))) children.length = 0;
 		}
+		markChildrenScanned(instance, children);
 	}
 	return result;
 }

package/extension-src/pi-style/features/status-line/index.ts

@@ -110,6 +110,37 @@ function separatorsFor(config: NormalizedPiStyleConfig, theme: ResolvedTheme): s
 	return theme.apply("separator", style);
 }
 
+/** Per-(theme, config) derived values shared across status-line renders. */
+interface ThemeAssets {
+	readonly resolved: ResolvedTheme;
+	readonly separator: string;
+}
+/** Resolved theme + separator keyed by Pi theme identity then config identity; a fresh configure() object misses naturally. */
+const themeAssetsCache = new WeakMap<ActivePiTheme, WeakMap<NormalizedPiStyleConfig, ThemeAssets>>();
+function themeAssetsFor(activeTheme: ActivePiTheme, config: NormalizedPiStyleConfig): ThemeAssets {
+	let byConfig = themeAssetsCache.get(activeTheme);
+	if (!byConfig) {
+		byConfig = new WeakMap();
+		themeAssetsCache.set(activeTheme, byConfig);
+	}
+	let assets = byConfig.get(config);
+	if (!assets) {
+		const resolved = resolveTheme(
+			activeTheme.colors || activeTheme.fg
+				? {
+						...(activeTheme.colors ? { colors: activeTheme.colors } : {}),
+						// Call through the theme instance so `this` binds correctly inside Pi's fg().
+						...(activeTheme.fg ? { fg: (color: string, text: string) => activeTheme.fg?.(color, text) ?? text } : {}),
+					}
+				: undefined,
+			config,
+		);
+		assets = { resolved, separator: separatorsFor(config, resolved) };
+		byConfig.set(config, assets);
+	}
+	return assets;
+}
+
 export function installStatusLine(options: StatusLineInstallOptions): StatusLineInstallation {
 	const existing = installationMap(options.host).get(options.generation);
 	if (existing) return existing;
@@ -143,18 +174,9 @@ export function installStatusLine(options: StatusLineInstallOptions): StatusLine
 
 	const render = (activeTheme: ActivePiTheme, width: number, secondary: boolean): string[] => {
 		if (width <= 0 || !config.enabled || !config.statusLine.enabled) return [];
-		const resolved = resolveTheme(
-			activeTheme.colors || activeTheme.fg
-				? {
-						...(activeTheme.colors ? { colors: activeTheme.colors } : {}),
-						// Call through the theme instance so `this` binds correctly inside Pi's fg().
-						...(activeTheme.fg ? { fg: (color: string, text: string) => activeTheme.fg?.(color, text) ?? text } : {}),
-					}
-				: undefined,
-			config,
-		);
+		const { resolved, separator } = themeAssetsFor(activeTheme, config);
 		const result = renderStatus(config.statusLine.layout, effectiveSnapshot(snapshot), width, {
-			separator: separatorsFor(config, resolved),
+			separator,
 			segments,
 			theme: resolved,
 			options: {
@@ -241,12 +263,20 @@ export function installStatusLine(options: StatusLineInstallOptions): StatusLine
 		(secondary: boolean): WidgetFactory =>
 		(tui, theme) => {
 			const currentTheme = theme;
+			// Per-component render cache: Pi repaints widgets on every frame
+			// (keystrokes, streaming chunks, tickers). Same width without an
+			// invalidate() (snapshot update / configure / footer-branch change)
+			// means the previous lines are still current; return them as-is.
+			let renderCache: { width: number; lines: string[] } | undefined;
 			const component: RenderComponent = {
 				render(width) {
+					if (renderCache?.width === width) return renderCache.lines;
 					const lines = render(currentTheme, width, secondary);
+					renderCache = { width, lines };
 					return lines;
 				},
 				invalidate() {
+					renderCache = undefined;
 					// Pi supplies a fresh theme to the factory on theme replacement. Do not retain
 					// pre-rendered ANSI strings; the next render reads the current component theme.
 					primaryComponent = secondary ? primaryComponent : component;