@oh-my-pi/pi-tui 18.4.1 → 18.4.3

package/src/stdin-buffer.ts

@@ -424,11 +424,11 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	#rawPasteCandidate = "";
 	#rawPasteTimer?: NodeJS.Timeout;
 	// Unbracketed raw-paste classification is a fallback for terminals that do
-	// not wrap pastes in DECSET 2004 markers. When the terminal confirms mode
-	// 2004 support, a genuine paste always arrives bracketed, so the heuristic
-	// can only misfire on keystrokes an event-loop stall batched into one read
-	// (issue #12540) — Terminal disables it via `setRawPasteClassification`.
-	#rawPasteClassificationEnabled = true;
+	// not wrap pastes in DECSET 2004 markers. Once the terminal confirms mode
+	// 2004, Terminal installs this probe: an unmarked multiline burst is then
+	// an input-method commit (#13344) unless an event-loop stall batched the
+	// keystrokes into one read (#12540). See `setRawPasteStallProbe`.
+	#rawPasteStallProbe?: () => boolean;
 	#stringDiscardActive = false;
 	#stringDiscardBytes = 0;
 	#stringDiscardEscHeld = false;
@@ -491,14 +491,13 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			} else {
 				this.#rawPasteCandidate += str;
 				if (isRawMultilineBurst(this.#rawPasteCandidate)) {
-					this.#emitRawPasteCandidate();
+					this.#classifyRawPasteCandidate();
 				}
 				return;
 			}
 		}
 
 		if (
-			this.#rawPasteClassificationEnabled &&
 			this.#buffer.length === 0 &&
 			str.indexOf(ESC) === -1 &&
 			(str.indexOf("\r") !== -1 || str.indexOf("\n") !== -1)
@@ -508,7 +507,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			// Enter is replayed unchanged when the fixed window expires.
 			this.#rawPasteCandidate = str;
 			if (isRawMultilineBurst(str)) {
-				this.#emitRawPasteCandidate();
+				this.#classifyRawPasteCandidate();
 			} else {
 				this.#armRawPasteTimer();
 			}
@@ -649,18 +648,18 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	}
 
 	/**
-	 * Enable or disable unbracketed raw-paste classification. Terminal disables
-	 * it once DECRQM confirms bracketed-paste (mode 2004) support: a genuine
-	 * paste then always arrives wrapped, so the heuristic can only misfire on
-	 * keystrokes an event-loop stall batched into one read (issue #12540).
-	 * Disabling flushes any candidate already held by the classification window
-	 * as ordinary key events so no buffered input is lost.
+	 * Gate unbracketed raw-paste classification on event-loop responsiveness.
+	 * Terminal installs a probe once DECRQM confirms bracketed-paste (mode
+	 * 2004) support: a genuine paste then always arrives wrapped, so an
+	 * unmarked multiline burst is either an input-method commit — IME,
+	 * dictation, and emoji commits are typed input, never bracketed (#13344) —
+	 * or keystrokes an event-loop stall batched into one read (#12540). A burst
+	 * classified while `stalled()` reports a stall is replayed as the original
+	 * keys so every Enter submits; otherwise it is delivered as one paste.
+	 * `undefined` restores unconditional classification.
 	 */
-	setRawPasteClassification(enabled: boolean): void {
-		this.#rawPasteClassificationEnabled = enabled;
-		if (!enabled && this.#rawPasteCandidate.length > 0) {
-			this.#flushRawPasteCandidate();
-		}
+	setRawPasteStallProbe(stalled: (() => boolean) | undefined): void {
+		this.#rawPasteStallProbe = stalled;
 	}
 
 	/** Start one fixed window from the first break-bearing raw read. */
@@ -686,8 +685,15 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		return content;
 	}
 
-	/** Emit a classified raw multiline burst through the paste channel. */
-	#emitRawPasteCandidate(): void {
+	/**
+	 * Deliver a classified raw multiline burst: one paste, or the original
+	 * keys when the stall probe says a blocked loop batched typed input.
+	 */
+	#classifyRawPasteCandidate(): void {
+		if (this.#rawPasteStallProbe?.()) {
+			this.#flushRawPasteCandidate();
+			return;
+		}
 		const content = this.#takeRawPasteCandidate();
 		this.#pendingKittyPrintableCodepoint = undefined;
 		this.emit("paste", content);

package/src/terminal.ts

@@ -460,6 +460,15 @@ export interface TerminalStartOptions {
 	 * echoes even while module loading blocks the event loop.
 	 */
 	deferInput?: boolean;
+	/**
+	 * Reports whether the event loop is stalled or just recovered from a
+	 * stall. Once the terminal confirms bracketed paste, an unmarked multiline
+	 * burst is an input-method commit (IME, dictation) delivered as one paste
+	 * on a responsive loop, but keystrokes a stall batched into one read —
+	 * replayed as keys so Enter submits — while this returns true. Without a
+	 * probe every such burst is treated as an input-method commit.
+	 */
+	isLoopStalled?: () => boolean;
 }
 /** Identity of an accepted explicit terminal appearance refresh request. */
 export type TerminalAppearanceRequestToken = number;
@@ -717,6 +726,7 @@ export class ProcessTerminal implements Terminal {
 	#resizeHandler?: () => void;
 	/** True between a `deferInput` start() and enableInput(). */
 	#inputDeferred = false;
+	#isLoopStalled?: () => boolean;
 	#stdoutResizeListener?: () => void;
 	#kittyProtocolActive = false;
 	#kittyEnableSeq: string | null = null;
@@ -772,6 +782,10 @@ export class ProcessTerminal implements Terminal {
 	// enqueues frames and performs the blocking write(2) on its own thread;
 	// `pendingOutputBytes` exposes the backlog for render-side frame skipping.
 	#outputPump?: TtyWriter;
+	// Upper bound on the pump's backlog: the count its last enqueue or read
+	// reported. Only #safeWrite enqueues and the pump thread only drains, so
+	// the live backlog cannot exceed this until the next enqueue refreshes it.
+	#pumpBacklogBound = 0;
 
 	#windowsVTInputRestore?: () => void;
 	#xtermScrollToBottomRestoreModes = new Set<number>();
@@ -919,6 +933,7 @@ export class ProcessTerminal implements Terminal {
 		this.#inputHandler = onInput;
 		this.#resizeHandler = onResize;
 		this.#disconnectHandler = onDisconnect;
+		this.#isLoopStalled = options?.isLoopStalled;
 		// The host terminal's cursor visibility is unknown until we write it.
 		this.#cursorVisible = undefined;
 
@@ -940,6 +955,7 @@ export class ProcessTerminal implements Terminal {
 		if (process.platform !== "win32" && process.stdout.isTTY && !isBunTestRuntime() && !this.#outputPump) {
 			try {
 				this.#outputPump = new TtyWriter(1);
+				this.#pumpBacklogBound = 0;
 			} catch (err) {
 				logger.debug("tty output pump unavailable; using direct stdout writes", { err: String(err) });
 			}
@@ -1076,9 +1092,10 @@ export class ProcessTerminal implements Terminal {
 		this.#queryPrivateMode(2048);
 		this.#queryPrivateMode(2031);
 		// 2004 (bracketed paste) is queried only to confirm the terminal brackets
-		// pastes; once confirmed, the unbracketed raw-paste heuristic in
-		// StdinBuffer is disabled so keystrokes an event-loop stall batches into
-		// one read are never misclassified as a paste (#12540).
+		// pastes; once confirmed, StdinBuffer's unbracketed raw-paste heuristic
+		// consults the host's stall probe so keystrokes an event-loop stall
+		// batches into one read stay keys (#12540) while input-method commits
+		// still land as one paste (#13344).
 		this.#queryPrivateMode(2004);
 		for (const mode of XTERM_SCROLL_TO_BOTTOM_MODES) {
 			this.#queryPrivateMode(mode);
@@ -1769,15 +1786,17 @@ export class ProcessTerminal implements Terminal {
 		}
 		if (mode === 2048 && supported) this.#enableInBandResize();
 		if (mode === 2031) this.#syncWindowsTerminalAppearancePolling(supported);
-		// Confirmed bracketed-paste support makes the unbracketed raw-paste
-		// heuristic pure downside — turn it off so stall-batched keystrokes are
-		// not misread as a paste (#12540). `supported` is only true here after an
-		// explicit DECRPM reply (the DA1-sentinel fallback resolves unsupported).
+		// Confirmed bracketed-paste support means a genuine paste arrives
+		// wrapped, so an unmarked multiline burst is an input-method commit
+		// (#13344) unless an event-loop stall batched typed keys into one read
+		// (#12540). Let the host's stall probe decide per burst. `supported` is
+		// only true here after an explicit DECRPM reply (the DA1-sentinel
+		// fallback resolves unsupported).
 		if (mode === 2004 && supported) {
-			this.#stdinBuffer?.setRawPasteClassification(false);
+			this.#stdinBuffer?.setRawPasteStallProbe(this.#isLoopStalled);
 			// A terminal can reset this mode after the initial probe (for example,
 			// iTerm2's Terminal State toggle). Keep the mode asserted while we own
-			// the TTY, since the raw fallback is disabled after confirmation.
+			// the TTY, since a stalled loop now replays unmarked bursts as keys.
 			this.#bracketedPasteRefreshTimer ??= setInterval(() => {
 				if (this.#active && !this.#dead) this.#safeWrite("\x1b[?2004h");
 			}, 1000);
@@ -2135,19 +2154,27 @@ export class ProcessTerminal implements Terminal {
 		this.#trackCursorVisibility(data);
 		const pump = this.#outputPump;
 		if (pump) {
-			if (pump.dead) {
-				this.#markTerminalDisconnected("stdout failed; output pump died");
-				return;
-			}
+			let pending: number;
 			try {
-				// Feed the live backlog to the stall watchdog rather than tripping on
-				// the instantaneous byte count: a single large-but-draining frame (a
-				// resume repaint of many inline images) must open normally, while a
-				// never-draining reader is still torn down (#6854, #10430).
-				this.#trackStdoutBacklog(pump.write(data));
+				pending = pump.write(data);
 			} catch (err) {
 				this.#markTerminalDisconnected("stdout failed", err);
+				return;
+			}
+			// A live enqueue reports at least this chunk's UTF-8 size, never below
+			// its UTF-16 length; a dead pump enqueues nothing and reports only the
+			// remainder it is dropping (soon zero). Only a report that small can
+			// come from a dead pump, so the native `dead` read is skipped otherwise.
+			if ((pending < data.length || data.length === 0) && pump.dead) {
+				this.#markTerminalDisconnected("stdout failed; output pump died");
+				return;
 			}
+			this.#pumpBacklogBound = pending;
+			// Feed the live backlog to the stall watchdog rather than tripping on
+			// the instantaneous byte count: a single large-but-draining frame (a
+			// resume repaint of many inline images) must open normally, while a
+			// never-draining reader is still torn down (#6854, #10430).
+			this.#trackStdoutBacklog(pending);
 			return;
 		}
 		// A console-sharing child process may have flipped the console codepage
@@ -2190,8 +2217,19 @@ export class ProcessTerminal implements Terminal {
 		if (this.#inBandResizeActive && this.#reportedColumns) return this.#reportedColumns;
 		return process.stdout.columns || Number(Bun.env.COLUMNS) || 80;
 	}
+	/**
+	 * With the output pump, a backlog bound at or below
+	 * {@link STDOUT_BACKLOG_CLEAR_BYTES} is reported as-is instead of re-read:
+	 * both consumers (the render gate and the stall watchdog) act only on a
+	 * backlog above that level, so the bound already decides them and spares a
+	 * native read on every frame.
+	 */
 	get pendingOutputBytes(): number {
-		if (this.#outputPump) return this.#outputPump.pending();
+		const pump = this.#outputPump;
+		if (pump) {
+			if (this.#pumpBacklogBound > STDOUT_BACKLOG_CLEAR_BYTES) this.#pumpBacklogBound = pump.pending();
+			return this.#pumpBacklogBound;
+		}
 		// Stream fallback: bytes queued past the high-water mark by refused writes.
 		return process.stdout.writableLength ?? 0;
 	}
@@ -2296,7 +2334,9 @@ export class ProcessTerminal implements Terminal {
 			if (final === 0x68 /* h */ || final === 0x6c /* l */) break;
 			idx = idx === 0 ? -1 : data.lastIndexOf("\x1b[?25", idx - 1);
 		}
-		if (data.lastIndexOf("\x1b[?1049") > idx) {
+		// Only a switch after the last cursor sequence matters: search that tail
+		// rather than the whole frame.
+		if (data.indexOf("\x1b[?1049", idx + 1) !== -1) {
 			this.#cursorVisible = undefined;
 			return;
 		}

package/src/theme/color.ts

@@ -18,12 +18,27 @@ export function detectColorMode(env: NodeJS.ProcessEnv = Bun.env): ColorMode {
 	return terminal.trueColor ? "truecolor" : "256color";
 }
 
+const ANSI_COLOR_CACHE_LIMIT = 256;
+const ANSI_COLOR_CACHE_MAX_LENGTH = 128;
+const ansiColorCaches: Record<ColorMode, Map<string, string>> = {
+	truecolor: new Map(),
+	"256color": new Map(),
+};
+
+/** Convert a theme color to foreground SGR at the requested depth; throws for invalid colors. */
 export function colorToAnsi(color: string, mode: ColorMode): string {
+	const cache = color.length <= ANSI_COLOR_CACHE_MAX_LENGTH ? ansiColorCaches[mode] : undefined;
+	const cached = cache?.get(color);
+	if (cached !== undefined) return cached;
 	const format = mode === "truecolor" ? "ansi-16m" : "ansi-256";
 	const ansi = Bun.color(color, format);
 	if (ansi === null) {
 		throw new Error(`Invalid color value: ${color}`);
 	}
+	if (cache) {
+		if (cache.size >= ANSI_COLOR_CACHE_LIMIT) cache.clear();
+		cache.set(color, ansi);
+	}
 	return ansi;
 }
 

package/src/theme/mermaid-cache.ts

@@ -1,4 +1,5 @@
 import type { MermaidRenderOptions } from "@oh-my-pi/pi-natives";
+import { LRUCache } from "@oh-my-pi/pi-utils/lru";
 import * as mermaidAscii from "@oh-my-pi/pi-utils/mermaid-ascii";
 
 /**
@@ -19,7 +20,15 @@ export interface MermaidResolveOptions extends MermaidRenderOptions {
 // Memoizes rendered ASCII (and failures) keyed on the render options + the
 // layout-direction variant + source. Width selection happens per call against
 // the cached renders, so a terminal resize re-decides without re-rendering.
-const cache = new Map<string, string | null>();
+// Bounded by entry count and by UTF-16 length of key (which embeds the whole
+// source) plus rendered ASCII, so long sessions cannot pin every diagram.
+const MERMAID_CACHE_MAX = 256;
+const MERMAID_CACHE_MAX_SIZE = 4 * 1024 * 1024;
+const cache = new LRUCache<string, string | null>({
+	max: MERMAID_CACHE_MAX,
+	maxSize: MERMAID_CACHE_MAX_SIZE,
+	sizeCalculation: (ascii, key) => key.length + (ascii?.length ?? 0),
+});
 
 /** Display columns, ignoring ANSI so themed diagrams are measured as drawn. */
 const DISPLAY_WIDTH = { countAnsiEscapeCodes: false } as const;

package/src/theme/session-color.ts

@@ -145,11 +145,11 @@ const LIGHT_HUE_INTERVALS: readonly HueInterval[] = [[195, 330]];
 /** Theme-derived inputs for {@link getSessionAccentHex}; see `Theme.sessionAccentInputs`. */
 export interface SessionAccentTheme {
 	/** Theme accent hex; the session accent adopts its OKLCH lightness and chroma. */
-	accentHex: string;
+	readonly accentHex: string;
 	/** Major theme color hexes checked for hue collision. */
-	colorHexes: string[];
+	readonly colorHexes: readonly string[];
 	/** WCAG luminance of the status-line surface on light themes; undefined on dark themes. */
-	surfaceLuminance?: number;
+	readonly surfaceLuminance?: number;
 }
 
 /**
@@ -180,6 +180,22 @@ export interface SessionAccentTheme {
  * @param theme — accent hex, collision colors, and surface luminance of the active theme.
  */
 export function getSessionAccentHex(name: string, theme: SessionAccentTheme): string {
+	// Pure function of its inputs; keyed by value so structurally equal inputs
+	// share an entry. Bounded: sessions × themes stays tiny in practice.
+	const key = `${name}\0${theme.accentHex}\0${theme.surfaceLuminance}\0${theme.colorHexes.join(",")}`;
+	const cached = accentHexCache.get(key);
+	if (cached !== undefined) return cached;
+	const hex = computeSessionAccentHex(name, theme);
+	if (accentHexCache.size >= ACCENT_CACHE_LIMIT) accentHexCache.clear();
+	accentHexCache.set(key, hex);
+	return hex;
+}
+
+const ACCENT_CACHE_LIMIT = 256;
+const accentHexCache = new Map<string, string>();
+const accentAnsiCache = new Map<string, string | undefined>();
+
+function computeSessionAccentHex(name: string, theme: SessionAccentTheme): string {
 	// 1. Pick hue range based on theme mode
 	const isDark = theme.surfaceLuminance === undefined;
 	const intervals = isDark ? DARK_HUE_INTERVALS : LIGHT_HUE_INTERVALS;
@@ -249,5 +265,11 @@ export function getSessionAccentHex(name: string, theme: SessionAccentTheme): st
  */
 export function getSessionAccentAnsi(hex: string | undefined): string | undefined {
 	if (!hex) return undefined;
-	return Bun.color(hex, TERMINAL.trueColor ? "ansi-16m" : "ansi-256") ?? undefined;
+	const trueColor = TERMINAL.trueColor;
+	const key = trueColor ? hex : `256:${hex}`;
+	if (accentAnsiCache.has(key)) return accentAnsiCache.get(key);
+	const ansi = Bun.color(hex, trueColor ? "ansi-16m" : "ansi-256") ?? undefined;
+	if (accentAnsiCache.size >= ACCENT_CACHE_LIMIT) accentAnsiCache.clear();
+	accentAnsiCache.set(key, ansi);
+	return ansi;
 }

package/src/theme/shimmer.ts

@@ -27,7 +27,7 @@ const BOLD_OPEN = "\x1b[1m";
 const BOLD_CLOSE = "\x1b[22m";
 
 type ShimmerTheme = Pick<Theme, "bold" | "fg" | "getFgAnsi">;
-/** Sweep style for animated shimmer text; `disabled` renders every tier as the low color. */
+/** Sweep style for animated shimmer text; `disabled` renders every tier as the mid color. */
 export type ShimmerMode = "classic" | "kitt" | "disabled";
 
 let activeMode: ShimmerMode = "classic";
@@ -114,13 +114,8 @@ function compile(theme: ShimmerTheme, palette: ShimmerPalette): CompiledPalette
 
 // ─── Intensity profiles ──────────────────────────────────────────────────────
 /** Smooth cosine bump sweeping left → right with edge padding. */
-function classicIntensity(time: number, index: number, length: number): number {
-	const period = length + CLASSIC_PADDING * 2;
-	// Fixed-velocity, un-floored band position: advancing at a constant
-	// cells/second (not period / fixed-sweep) keeps the per-frame step ≤1 cell at
-	// the default cadence for any length, so long messages are no steppier.
-	const pos = ((time / 1000) * SHIMMER_SPEED_CELLS_PER_S) % period;
-	const dist = Math.abs(index + CLASSIC_PADDING - pos);
+function classicIntensity(index: number, position: number): number {
+	const dist = Math.abs(index + CLASSIC_PADDING - position);
 	if (dist >= CLASSIC_BAND_HALF_WIDTH) return 0;
 	return 0.5 * (1 + Math.cos((Math.PI * dist) / CLASSIC_BAND_HALF_WIDTH));
 }
@@ -130,16 +125,7 @@ function classicIntensity(time: number, index: number, length: number): number {
  * bar with a quadratic-decay trail behind it. No leading glow — LEDs don't
  * predict the future.
  */
-function kittIntensity(time: number, index: number, length: number): number {
-	const range = length - 1;
-	if (range <= 0) return 1;
-	// Fixed head velocity: a triangle ping-pong over a 2*range round trip at a
-	// constant cells/second, so the bright head advances ≤1 cell per frame at the
-	// default cadence regardless of bar length. Round-trip duration scales with length.
-	const cycleCells = 2 * range;
-	const sweep = ((time / 1000) * SHIMMER_SPEED_CELLS_PER_S) % cycleCells;
-	const goingRight = sweep < range;
-	const head = goingRight ? sweep : cycleCells - sweep;
+function kittIntensity(index: number, head: number, goingRight: boolean): number {
 	const delta = index - head;
 	const abs = delta < 0 ? -delta : delta;
 	if (abs <= KITT_HEAD_HALF) return 1;
@@ -181,46 +167,66 @@ export function shimmerEnabled(): boolean {
 export function shimmerSegments(segments: readonly ShimmerSegment[], theme: ShimmerTheme): string {
 	const mode = activeMode;
 
-	// Pre-scan: total code-point count (positions the band) and resolved palette.
-	// The per-segment string is kept verbatim — iterating UTF-16 units with a
-	// surrogate-pair guard produces the same code points as `Array.from(text)`
-	// at zero per-frame allocation (previously the #1 hotspot at ~10% of profiled
-	// CPU during streaming — the working message is shimmered every animation
-	// frame at 30fps and `Array.from` reallocated the code-point array each tick).
-	let total = 0;
-	const perSeg: { text: string; palette: ShimmerPalette }[] = [];
-	for (const seg of segments) {
-		total += countCodePoints(seg.text);
-		perSeg.push({ text: seg.text, palette: seg.palette ?? DEFAULT_SHIMMER_PALETTE });
-	}
-	if (total === 0) return "";
-
-	// Disabled: no animation, no per-char work. Paint each segment in its mid
-	// tier so the working line stays legible without movement.
+	// Disabled: no animation or code-point scan. Preserve the all-empty result,
+	// but include empty segments' ANSI pairs when any segment has text.
 	if (mode === "disabled") {
+		let hasText = false;
+		for (const { text } of segments) {
+			if (text.length > 0) {
+				hasText = true;
+				break;
+			}
+		}
+		if (!hasText) return "";
 		let out = "";
-		for (const { text, palette } of perSeg) {
-			const seq = compile(theme, palette).mid;
+		for (const { text, palette } of segments) {
+			const seq = compile(theme, palette ?? DEFAULT_SHIMMER_PALETTE).mid;
 			out += `${seq.open}${text}${seq.close}`;
 		}
 		return out;
 	}
 
-	const time = Date.now();
-	const intensityFn = mode === "kitt" ? kittIntensity : classicIntensity;
+	// Position the band in code points without copying the segments or splitting
+	// their strings. Surrogate pairs are counted independently in each segment.
+	let total = 0;
+	for (const { text } of segments) total += countCodePoints(text);
+	if (total === 0) return "";
+
+	// Fixed velocity keeps the per-frame step independent of message length.
+	// Share the frame's phase/head between the window and every active character.
+	const travel = (Date.now() / 1000) * SHIMMER_SPEED_CELLS_PER_S;
+	const isKitt = mode === "kitt";
+	let position: number;
+	let goingRight = true;
+	let bandLo: number;
+	let bandHi: number;
+	if (isKitt) {
+		const range = total - 1;
+		if (range <= 0) {
+			position = 0;
+		} else {
+			const cycleCells = 2 * range;
+			const sweep = travel % cycleCells;
+			goingRight = sweep < range;
+			position = goingRight ? sweep : cycleCells - sweep;
+		}
+		// Only the head and its direction-dependent trailing cells can light up.
+		bandLo = goingRight ? position - KITT_HEAD_HALF - KITT_TRAIL_LEN : position - KITT_HEAD_HALF;
+		bandHi = goingRight ? position + KITT_HEAD_HALF : position + KITT_HEAD_HALF + KITT_TRAIL_LEN;
+	} else {
+		position = travel % (total + CLASSIC_PADDING * 2);
+		bandLo = position - CLASSIC_PADDING - CLASSIC_BAND_HALF_WIDTH;
+		bandHi = position - CLASSIC_PADDING + CLASSIC_BAND_HALF_WIDTH;
+	}
 
-	// Fast-path window: outside `[bandLo, bandHi]` the intensity is guaranteed
-	// zero (tier "low"), so we can skip `intensityFn` + `tierFor` entirely for
-	// the prefix/suffix of every segment. On the typical ~60-char working
-	// message the classic band spans ~12 cells, so ~80% of the per-char loop
-	// disappears — the intensity call and the tier compare were the residual
-	// per-frame cost after #4353 removed the allocation hotspot (issue #4377).
-	const { lo: bandLo, hi: bandHi } = activeBand(mode, time, total);
+	// Outside this window intensity is zero, so skip the intensity and tier
+	// calculations for the low-tier prefix/suffix of every segment.
+	const intensityFn = isKitt ? kittIntensity : classicIntensity;
 
 	let out = "";
 	let index = 0;
-	for (const { text, palette } of perSeg) {
-		const compiled = compile(theme, palette);
+	for (const { text, palette } of segments) {
+		const compiled = compile(theme, palette ?? DEFAULT_SHIMMER_PALETTE);
 		let runTier: Tier | null = null;
 		let runStart = 0;
 		let runEnd = 0;
@@ -234,7 +240,8 @@ export function shimmerSegments(segments: readonly ShimmerSegment[], theme: Shim
 				const c2 = text.charCodeAt(i + 1);
 				if (c2 >= 0xdc00 && c2 <= 0xdfff) step = 2;
 			}
-			const tier: Tier = index < bandLo || index > bandHi ? "low" : tierFor(intensityFn(time, index, total));
+			const tier: Tier =
+				index < bandLo || index > bandHi ? "low" : tierFor(intensityFn(index, position, goingRight));
 			if (tier !== runTier) {
 				if (runTier !== null && runEnd > runStart) {
 					const seq = compiled[runTier];
@@ -255,34 +262,6 @@ export function shimmerSegments(segments: readonly ShimmerSegment[], theme: Shim
 	return out;
 }
 
-/**
- * Sweep window (code-point indices) outside which the intensity is guaranteed
- * zero for `mode` at `time` over `total` cells. Widening the window is safe —
- * the per-char intensity call still runs inside the window and reports 0 for
- * off-band code points — but narrower windows skip more of the per-char loop.
- */
-function activeBand(mode: "classic" | "kitt", time: number, total: number): { lo: number; hi: number } {
-	if (mode === "classic") {
-		const period = total + CLASSIC_PADDING * 2;
-		const pos = ((time / 1000) * SHIMMER_SPEED_CELLS_PER_S) % period;
-		return {
-			lo: pos - CLASSIC_PADDING - CLASSIC_BAND_HALF_WIDTH,
-			hi: pos - CLASSIC_PADDING + CLASSIC_BAND_HALF_WIDTH,
-		};
-	}
-	const range = total - 1;
-	if (range <= 0) return { lo: 0, hi: total };
-	const cycleCells = 2 * range;
-	const sweep = ((time / 1000) * SHIMMER_SPEED_CELLS_PER_S) % cycleCells;
-	const goingRight = sweep < range;
-	const head = goingRight ? sweep : cycleCells - sweep;
-	// The trail always lies behind the head for the current direction — chars
-	// ahead of the head are dark. See {@link kittIntensity} for the exact rule.
-	return goingRight
-		? { lo: head - KITT_HEAD_HALF - KITT_TRAIL_LEN, hi: head + KITT_HEAD_HALF }
-		: { lo: head - KITT_HEAD_HALF, hi: head + KITT_HEAD_HALF + KITT_TRAIL_LEN };
-}
-
 function countCodePoints(text: string): number {
 	let n = 0;
 	let i = 0;

package/src/theme/theme-class.ts

@@ -132,6 +132,14 @@ const LANG_BRAND_COLORS: Partial<Record<SymbolKey, string>> = {
 const BACKGROUND_RESET_PATTERN = /\x1b\[(?:0|49)m/g;
 const FOREGROUND_RESET_PATTERN = /\x1b\[(?:0|39)m/g;
 
+// Prebuilt stylers: each `chalk.<style>` access builds a fresh builder. Builders share the
+// root chalk context, so later `chalk.level` changes still apply.
+const boldStyler = chalk.bold;
+const italicStyler = chalk.italic;
+const underlineStyler = chalk.underline;
+const strikethroughStyler = chalk.strikethrough;
+const inverseStyler = chalk.inverse;
+
 export class Theme {
 	#fgColors: Record<ThemeColor, string>;
 	#bgColors: Record<ThemeBg, string>;
@@ -139,6 +147,10 @@ export class Theme {
 	readonly #hexFgColors: Record<ThemeColor, string>;
 	/** Resolved hex strings for background colors — populated at construction. */
 	readonly #hexBgColors: Record<ThemeBg, string>;
+	/** Lazily resolved `fgResolved` ANSI per color; colors and mode are fixed per instance. */
+	readonly #resolvedFgColors = new Map<ThemeColor, string>();
+	/** Lazily built, frozen `sessionAccentInputs`; every input it reads is fixed per instance. */
+	#sessionAccentInputs: SessionAccentTheme | undefined;
 	#symbols: SymbolMap;
 	#spinnerFramesOverrides: Partial<Record<SpinnerType, string[]>>;
 	/**
@@ -279,14 +291,15 @@ export class Theme {
 	 * Theme-derived inputs for `getSessionAccentHex`: the accent hex whose
 	 * OKLCH weight session accents adopt, the major colors they must not
 	 * hue-collide with, and the light-theme surface luminance to contrast
-	 * against.
+	 * against. Built once per instance and frozen; callers share the object.
 	 */
 	get sessionAccentInputs(): SessionAccentTheme {
-		return {
+		this.#sessionAccentInputs ??= Object.freeze({
 			accentHex: this.getAccentColorHex(),
-			colorHexes: this.getMajorThemeColorHexes(),
+			colorHexes: Object.freeze(this.getMajorThemeColorHexes()),
 			surfaceLuminance: this.accentSurfaceLuminance,
-		};
+		});
+		return this.#sessionAccentInputs;
 	}
 
 	fg(color: ThemeColor, text: string): string {
@@ -297,9 +310,13 @@ export class Theme {
 
 	/** Apply a foreground, replacing terminal-default tokens with the theme's contrast-safe fallback. */
 	fgResolved(color: ThemeColor, text: string): string {
-		const ansi = this.#fgColors[color];
-		if (!ansi) throw new Error(`Unknown theme color: ${color}`);
-		const resolved = ansi === "\x1b[39m" ? colorToAnsi(this.getColorHex(color), this.mode) : ansi;
+		let resolved = this.#resolvedFgColors.get(color);
+		if (resolved === undefined) {
+			const ansi = this.#fgColors[color];
+			if (!ansi) throw new Error(`Unknown theme color: ${color}`);
+			resolved = ansi === "\x1b[39m" ? colorToAnsi(this.getColorHex(color), this.mode) : ansi;
+			this.#resolvedFgColors.set(color, resolved);
+		}
 		return `${resolved}${text.replace(FOREGROUND_RESET_PATTERN, `$&${resolved}`)}\x1b[39m`;
 	}
 
@@ -332,23 +349,23 @@ export class Theme {
 	}
 
 	bold(text: string): string {
-		return chalk.bold(text);
+		return boldStyler(text);
 	}
 
 	italic(text: string): string {
-		return chalk.italic(text);
+		return italicStyler(text);
 	}
 
 	underline(text: string): string {
-		return chalk.underline(text);
+		return underlineStyler(text);
 	}
 
 	strikethrough(text: string): string {
-		return chalk.strikethrough(text);
+		return strikethroughStyler(text);
 	}
 
 	inverse(text: string): string {
-		return chalk.inverse(text);
+		return inverseStyler(text);
 	}
 
 	getFgAnsi(color: ThemeColor): string {

package/src/theme/tui-adapters.ts

@@ -59,7 +59,20 @@ function getHighlightColors(t: Theme): NativeHighlightColors {
  * the 33ms frame budget and starving the spinner/render timers (the "TUI freeze").
  */
 const HIGHLIGHT_CACHE_MAX = 256;
-const highlightCache = new LRUCache<string, string>({ max: HIGHLIGHT_CACHE_MAX });
+// Size-bound like markdown's render cache: a streaming block (bash command,
+// eval cell) inserts one full `code + highlighted` pair per growth frame, so a
+// count cap alone would retain 256 near-copies of a large payload. Sizes are
+// UTF-16 code units of key + value (ANSI output runs several times the source
+// length). The per-entry cap stays generous so a large but settled code body
+// repainting every frame still hits; only payloads past it re-highlight.
+const HIGHLIGHT_CACHE_MAX_SIZE = 8 * 1024 * 1024;
+const HIGHLIGHT_CACHE_MAX_ENTRY_SIZE = 1024 * 1024;
+const highlightCache = new LRUCache<string, string>({
+	max: HIGHLIGHT_CACHE_MAX,
+	maxSize: HIGHLIGHT_CACHE_MAX_SIZE,
+	maxEntrySize: HIGHLIGHT_CACHE_MAX_ENTRY_SIZE,
+	sizeCalculation: (value, key) => Math.max(1, key.length + value.length),
+});
 let highlightCacheTheme: Theme | undefined;
 
 function highlightCached(code: string, validLang: string | undefined, highlightTheme: Theme): string | null {