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

package/src/terminal.ts

@@ -772,6 +772,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>();
@@ -940,6 +944,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) });
 			}
@@ -2135,19 +2140,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 +2203,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 +2320,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/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 {