@gajae-code/tui 0.16.4 → 0.16.6

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [0.16.6] - 2026-09-07
+
+## [0.16.5] - 2026-09-07
+
+### Performance
+
+- Skip full-transcript resize-width scans on unchanged-width render frames while preserving the existing resize and forced-redraw checks.
+- Avoid copying unchanged terminal-control spans, reuse retained row widths, consume only the first grapheme for cursor operations, stop select-list width scans at their bounds, and avoid redundant background-row padding.
+
+### Fixed
+
+- Markdown cache ownership now finalizes after styling callbacks, so reentrant text replacement cannot inherit stale rejection hints and streaming completion releases local parse tokens. Cache diagnostics measure insertion-time payload sizes; returned render arrays are borrowed and must not be mutated.
+- Streaming Markdown retains only its current parse locally instead of publishing partial documents to the shared render/parse caches. Completed documents remain reusable, with 8 MiB render, 8 MiB parse and 4 MiB highlight accounted-payload budgets and per-entry limits. The render-cache diagnostic now includes UTF-16 keys, full token graphs, styled lines and anchors; it is not a live heap/RSS measurement.
+- Markdown reflow avoids redundant parse-cache admissions and repeated accounting of already rejected normalized content, without retaining completed parse tokens. Render payload accounting uses its owned layout schema, and oversized highlighting inputs are rejected earlier while preserving byte/line limits and guard ordering.
+
 ## [0.16.4] - 2026-09-05
 
 ### Added

package/dist/types/components/markdown.d.ts

@@ -1,8 +1,19 @@
 import type { SymbolTheme } from "../symbols";
 import type { Component } from "../tui";
 import { type ViewportAnchorSpan } from "../utils";
+/** Account retained payload, not live heap. Stop once admission is impossible. */
+export declare function getMarkdownCacheEntryAccountedSize(key: string, value: unknown, cap: number): number;
 /** Test-only clock seam for streaming throttle tests. */
 export declare function __setMarkdownNowForTest(now: (() => number) | undefined): void;
+export interface MarkdownCacheStats {
+    count: number;
+    accountedSize: number;
+    max: number;
+    maxSize: number;
+    maxEntrySize: number;
+}
+/** Detached diagnostics; exposes neither entries nor mutable budgets. */
+export declare function getMarkdownCacheStats(): Record<"render" | "parse" | "highlight", MarkdownCacheStats>;
 /** Test/diagnostic seam: number of synchronous highlight invocations since the last reset. */
 export declare function getMarkdownHighlightCallCount(): number;
 export declare function resetMarkdownHighlightCallCount(): void;
@@ -14,6 +25,10 @@ export declare const __markdownPerfCounters: {
 };
 /** Drop all L2 cache entries. Call on theme change to prevent stale styled output. */
 export declare function clearRenderCache(): void;
+/**
+ * Insertion-time UTF-16 accounting of global keys/tokens/lines/anchors, not heap or RSS.
+ * Rendered arrays are borrowed cache payloads: callers must not mutate them.
+ */
 export declare function getRenderCacheRetainedBytes(): number;
 /**
  * Default text styling for markdown content.

package/dist/types/tui.d.ts

@@ -361,6 +361,7 @@ type TuiRenderCounterSnapshot = {
     debugRedrawEnvReads: number;
     debugRedrawAppendWrites: number;
     differentialGuardVisibleWidthCalls: number;
+    widthReflowScanRows: number;
 };
 /**
  * TUI - Main class for managing terminal UI with differential rendering

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/tui",
-	"version": "0.16.4",
+	"version": "0.16.6",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -36,8 +36,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@gajae-code/natives": "0.16.4",
-		"@gajae-code/utils": "0.16.4",
+		"@gajae-code/natives": "0.16.6",
+		"@gajae-code/utils": "0.16.6",
 		"lru-cache": "11.3.6",
 		"marked": "18.0.6"
 	},

package/src/components/box.ts

@@ -161,13 +161,13 @@ export class Box implements Component {
 	}
 
 	#applyBg(line: string, width: number): string {
+		if (this.#bgFn) {
+			return applyBackgroundToLine(line, width, this.#bgFn);
+		}
 		const visLen = visibleWidth(line);
 		const padNeeded = Math.max(0, width - visLen);
 		const padded = line + padding(padNeeded);
 
-		if (this.#bgFn) {
-			return applyBackgroundToLine(padded, width, this.#bgFn);
-		}
 		return padded;
 	}
 }

package/src/components/editor.ts

@@ -1061,8 +1061,7 @@ export class Editor implements Component, Focusable {
 				if (after.length > 0) {
 					// Cursor is on a character (grapheme) - replace it with highlighted version
 					// Get the first grapheme from 'after'
-					const afterGraphemes = [...segmenter.segment(after)];
-					const firstGrapheme = afterGraphemes[0]?.segment || "";
+					const firstGrapheme = segmenter.segment(after)[Symbol.iterator]().next().value?.segment || "";
 					const restAfter = after.slice(firstGrapheme.length);
 					const cursor = `\x1b[7m${firstGrapheme}\x1b[0m`;
 					displayText = before + marker + cursor + restAfter;
@@ -2643,8 +2642,7 @@ export class Editor implements Component, Focusable {
 			const afterCursor = currentLine.slice(this.#state.cursorCol);
 
 			// Find the first grapheme at cursor
-			const graphemes = [...segmenter.segment(afterCursor)];
-			const firstGrapheme = graphemes[0];
+			const firstGrapheme = segmenter.segment(afterCursor)[Symbol.iterator]().next().value;
 			const graphemeLength = firstGrapheme ? firstGrapheme.segment.length : 1;
 
 			const before = currentLine.slice(0, this.#state.cursorCol);
@@ -2762,8 +2760,7 @@ export class Editor implements Component, Focusable {
 						this.#setCursorCol(this.#state.cursorCol + 1);
 					} else {
 						const afterCursor = currentLine.slice(this.#state.cursorCol);
-						const graphemes = [...segmenter.segment(afterCursor)];
-						const firstGrapheme = graphemes[0];
+						const firstGrapheme = segmenter.segment(afterCursor)[Symbol.iterator]().next().value;
 						this.#setCursorCol(this.#state.cursorCol + (firstGrapheme ? firstGrapheme.segment.length : 1));
 					}
 				} else if (this.#state.cursorLine < this.#state.lines.length - 1) {

package/src/components/input.ts

@@ -156,8 +156,7 @@ export class Input implements Component, Focusable {
 			this.#lastAction = null;
 			if (this.#cursor < this.#value.length) {
 				const afterCursor = this.#value.slice(this.#cursor);
-				const graphemes = [...segmenter.segment(afterCursor)];
-				const firstGrapheme = graphemes[0];
+				const firstGrapheme = segmenter.segment(afterCursor)[Symbol.iterator]().next().value;
 				this.#cursor += firstGrapheme ? firstGrapheme.segment.length : 1;
 			}
 			return;
@@ -231,8 +230,7 @@ export class Input implements Component, Focusable {
 		this.#pushUndo();
 
 		const afterCursor = this.#value.slice(this.#cursor);
-		const graphemes = [...segmenter.segment(afterCursor)];
-		const firstGrapheme = graphemes[0];
+		const firstGrapheme = segmenter.segment(afterCursor)[Symbol.iterator]().next().value;
 		const graphemeLength = firstGrapheme ? firstGrapheme.segment.length : 1;
 
 		this.#value = this.#value.slice(0, this.#cursor) + this.#value.slice(this.#cursor + graphemeLength);
@@ -442,8 +440,7 @@ export class Input implements Component, Focusable {
 
 		// Build line with fake cursor
 		// Insert cursor character at cursor position
-		const graphemes = [...segmenter.segment(visibleText.slice(cursorDisplay))];
-		const cursorGrapheme = graphemes[0];
+		const cursorGrapheme = segmenter.segment(visibleText.slice(cursorDisplay))[Symbol.iterator]().next().value;
 
 		const beforeCursor = visibleText.slice(0, cursorDisplay);
 		const atCursor = cursorGrapheme?.segment ?? " ";

package/src/components/markdown.ts

@@ -46,14 +46,95 @@ markdownParser.setOptions({
 // (Rust FFI) work for content/layout combinations already seen this session.
 
 const RENDER_CACHE_MAX = 256; // sane cap: ~256 distinct message × width combos
-const renderCache = new LRUCache<
-	string,
-	{ source: string; lines: string[]; anchorSpans?: Array<ViewportAnchorSpan | null> }
->({
+const DOCUMENT_CACHE_SIZE = 8 * 1024 * 1024;
+const DOCUMENT_ENTRY_SIZE = 1024 * 1024;
+
+/** Account retained payload, not live heap. Stop once admission is impossible. */
+export function getMarkdownCacheEntryAccountedSize(key: string, value: unknown, cap: number): number {
+	let size = 64 + key.length * 2;
+	const visited = new Set<object>();
+	const pending: Iterator<unknown>[] = [[value][Symbol.iterator]()];
+	function* objects(object: object, array: boolean): Generator<object> {
+		for (const name in object) {
+			if (!Object.hasOwn(object, name)) continue;
+			// Array indices are canonical uint32 strings, excluding 2^32 - 1.
+			const index = array ? Number(name) >>> 0 : 0;
+			if (!array || index === 0xffffffff || String(index) !== name) {
+				size += 16 + name.length * 2;
+				if (size > cap) return;
+			}
+			const child = (object as Record<string, unknown>)[name];
+			if (typeof child === "string") size += child.length * 2;
+			else if (typeof child === "number") size += 8;
+			else if (typeof child === "boolean") size += 4;
+			else if (child !== null && typeof child === "object") yield child;
+			if (size > cap) return;
+		}
+	}
+	while (pending.length && size <= cap) {
+		const next = pending[pending.length - 1].next();
+		if (next.done) {
+			pending.pop();
+			continue;
+		}
+		const item = next.value;
+		if (typeof item === "string") size += item.length * 2;
+		else if (typeof item === "number") size += 8;
+		else if (typeof item === "boolean") size += 4;
+		else if (item !== null && typeof item === "object" && !visited.has(item)) {
+			visited.add(item);
+			const array = Array.isArray(item);
+			size += array ? 24 + item.length * 8 : 32;
+			if (size <= cap) pending.push(objects(item, array));
+		}
+	}
+	return size > cap ? cap + 1 : size;
+}
+
+interface MarkdownRenderCacheEntry {
+	source: string;
+	lines: string[];
+	anchorSpans?: Array<ViewportAnchorSpan | null>;
+}
+
+const RENDER_ENTRY_BASE_SIZE = 64 + 32 + 16 + "source".length * 2 + 16 + "lines".length * 2 + 24;
+const ANCHOR_SPAN_SIZE =
+	32 + 4 * 16 + 4 * 8 + 2 * ("graphemeStart".length + "graphemeEnd".length + "cellStart".length + "cellEnd".length);
+
+function renderCacheEntrySize(entry: MarkdownRenderCacheEntry, key: string): number {
+	// These arrays and distinct span records are constructed exclusively by #render,
+	// with no custom properties, sharing or cycles. Account that owned schema without
+	// allocating the generic token-graph traversal machinery.
+	let size = RENDER_ENTRY_BASE_SIZE + key.length * 2 + entry.source.length * 2 + entry.lines.length * 8;
+	if (size > DOCUMENT_ENTRY_SIZE) return DOCUMENT_ENTRY_SIZE + 1;
+	for (const line of entry.lines) {
+		size += line.length * 2;
+		if (size > DOCUMENT_ENTRY_SIZE) return DOCUMENT_ENTRY_SIZE + 1;
+	}
+	if (entry.anchorSpans) {
+		size += 16 + "anchorSpans".length * 2 + 24 + entry.anchorSpans.length * 8;
+		if (size > DOCUMENT_ENTRY_SIZE) return DOCUMENT_ENTRY_SIZE + 1;
+		for (const span of entry.anchorSpans) {
+			if (span) size += ANCHOR_SPAN_SIZE;
+			if (size > DOCUMENT_ENTRY_SIZE) return DOCUMENT_ENTRY_SIZE + 1;
+		}
+	}
+	return size;
+}
+
+const renderCache = new LRUCache<string, MarkdownRenderCacheEntry>({
 	max: RENDER_CACHE_MAX,
+	maxSize: DOCUMENT_CACHE_SIZE,
+	maxEntrySize: DOCUMENT_ENTRY_SIZE,
+	sizeCalculation: renderCacheEntrySize,
 });
 const PARSE_CACHE_MAX = 128;
-const parseCache = new LRUCache<string, { source: string; tokens: Token[] }>({ max: PARSE_CACHE_MAX });
+const parseCache = new LRUCache<string, { source: string; tokens: Token[] }>({
+	max: PARSE_CACHE_MAX,
+	maxSize: DOCUMENT_CACHE_SIZE,
+	maxEntrySize: DOCUMENT_ENTRY_SIZE,
+	sizeCalculation: (value, key) => getMarkdownCacheEntryAccountedSize(key, value, DOCUMENT_ENTRY_SIZE),
+});
 const MARKDOWN_STREAM_THROTTLE_MS = 64;
 let markdownNow = (): number => performance.now();
 
@@ -76,20 +157,44 @@ export function __setMarkdownNowForTest(now: (() => number) | undefined): void {
 // appends only highlight new/changed blocks instead of re-highlighting the whole
 // prefix on every chunk. Bounded LRU; cleared on theme change via clearRenderCache().
 const HIGHLIGHT_CACHE_MAX = 512;
-const highlightCache = new LRUCache<string, string[]>({ max: HIGHLIGHT_CACHE_MAX });
+const HIGHLIGHT_ENTRY_SIZE = 512 * 1024;
+interface MarkdownHighlightCacheEntry {
+	lang: string;
+	code: string;
+	lines: string[];
+}
+
+const highlightCache = new LRUCache<string, MarkdownHighlightCacheEntry>({
+	max: HIGHLIGHT_CACHE_MAX,
+	maxSize: 4 * 1024 * 1024,
+	maxEntrySize: HIGHLIGHT_ENTRY_SIZE,
+	sizeCalculation: (value, key) => getMarkdownCacheEntryAccountedSize(key, value, HIGHLIGHT_ENTRY_SIZE),
+});
 
-function renderedLinesBytes(lines: readonly string[]): number {
-	let bytes = 0;
-	for (const line of lines) bytes += Buffer.byteLength(line, "utf8");
-	return bytes;
+export interface MarkdownCacheStats {
+	count: number;
+	accountedSize: number;
+	max: number;
+	maxSize: number;
+	maxEntrySize: number;
 }
 
-function anchorSpansBytes(spans: readonly (ViewportAnchorSpan | null)[]): number {
-	let bytes = spans.length * 8; // Array element references
-	for (const span of spans) {
-		if (span) bytes += 4 * 8; // Four numeric offsets
-	}
-	return bytes;
+/** Detached diagnostics; exposes neither entries nor mutable budgets. */
+export function getMarkdownCacheStats(): Record<"render" | "parse" | "highlight", MarkdownCacheStats> {
+	const snapshot = (cache: {
+		size: number;
+		calculatedSize: number;
+		max: number;
+		maxSize: number;
+		maxEntrySize: number;
+	}): MarkdownCacheStats => ({
+		count: cache.size,
+		accountedSize: cache.calculatedSize,
+		max: cache.max,
+		maxSize: cache.maxSize,
+		maxEntrySize: cache.maxEntrySize,
+	});
+	return { render: snapshot(renderCache), parse: snapshot(parseCache), highlight: snapshot(highlightCache) };
 }
 
 // F18: cap synchronous (Rust FFI) syntax highlighting so a single huge fenced block
@@ -133,16 +238,12 @@ export function clearRenderCache(): void {
 	highlightCache.clear();
 }
 
+/**
+ * Insertion-time UTF-16 accounting of global keys/tokens/lines/anchors, not heap or RSS.
+ * Rendered arrays are borrowed cache payloads: callers must not mutate them.
+ */
 export function getRenderCacheRetainedBytes(): number {
-	let bytes = 0;
-	for (const entry of renderCache.values()) {
-		bytes += Buffer.byteLength(entry.source, "utf8");
-		bytes += renderedLinesBytes(entry.lines);
-		if (entry.anchorSpans) bytes += anchorSpansBytes(entry.anchorSpans);
-	}
-	for (const entry of parseCache.values()) bytes += Buffer.byteLength(entry.source, "utf8");
-	for (const lines of highlightCache.values()) bytes += renderedLinesBytes(lines);
-	return bytes;
+	return renderCache.calculatedSize + parseCache.calculatedSize + highlightCache.calculatedSize;
 }
 
 // Stable numeric IDs for structural theme/style objects (no ID field on type).
@@ -267,6 +368,8 @@ export class Markdown implements Component {
 	#cachedWidth?: number;
 	#cachedLines?: string[];
 	#cachedAnchorSpans?: Array<ViewportAnchorSpan | null>;
+	#currentParse?: { source: string; tokens: Token[] };
+	#rejectedParseKey?: string;
 
 	#streaming = false;
 	#lastFullParseAt = 0;
@@ -297,6 +400,7 @@ export class Markdown implements Component {
 		if (options?.streaming !== undefined) {
 			this.setStreaming(options.streaming);
 		}
+		if (this.#text !== text) this.#rejectedParseKey = undefined;
 		this.#text = text;
 		if (this.#streaming) {
 			return;
@@ -336,6 +440,8 @@ export class Markdown implements Component {
 
 	dispose(): void {
 		this.#clearStaleThrottleTimer();
+		this.#currentParse = undefined;
+		this.#rejectedParseKey = undefined;
 	}
 
 	invalidate(): void {
@@ -346,14 +452,17 @@ export class Markdown implements Component {
 	}
 
 	#exceedsHighlightCap(code: string): boolean {
+		// UTF-8 requires at least one byte per UTF-16 code unit, including lone
+		// surrogates. Reject obviously oversized input without scanning or hashing it.
+		if (code.length > MAX_HIGHLIGHT_BYTES) return true;
+		// Check UTF-8 bytes before the JavaScript line scan so oversized Unicode
+		// blocks do not pay for a scan whose result cannot change rejection.
+		if (Buffer.byteLength(code, "utf8") > MAX_HIGHLIGHT_BYTES) return true;
 		let newlines = 0;
 		for (let i = 0; i < code.length; i++) {
-			if (code.charCodeAt(i) === 10) newlines += 1;
+			if (code.charCodeAt(i) === 10 && ++newlines >= MAX_HIGHLIGHT_LINES) return true;
 		}
-		if (newlines + 1 > MAX_HIGHLIGHT_LINES) return true;
-		// UTF-8 byte length (not UTF-16 code-unit count) so a non-ASCII block cannot
-		// exceed the advertised byte cap and still reach the synchronous highlighter.
-		return Buffer.byteLength(code, "utf8") > MAX_HIGHLIGHT_BYTES;
+		return false;
 	}
 
 	#highlightCodeBlock(code: string, lang: string): string[] | null {
@@ -361,10 +470,10 @@ export class Markdown implements Component {
 		if (this.#exceedsHighlightCap(code)) return null;
 		const key = `${objectId(this.#theme)}\x00${lang}\x00${code}`;
 		const cached = highlightCache.get(key);
-		if (cached) return cached;
+		if (cached?.lang === lang && cached.code === code) return cached.lines;
 		highlightCallCount += 1;
 		const result = this.#theme.highlightCode(code, lang || undefined);
-		highlightCache.set(key, result);
+		highlightCache.set(key, { lang, code, lines: result });
 		return result;
 	}
 
@@ -421,6 +530,7 @@ export class Markdown implements Component {
 
 		// Don't render anything if there's no actual text
 		if (!this.#text || this.#text.trim() === "") {
+			this.#currentParse = undefined;
 			const result: string[] = [];
 			// Update per-instance cache
 			this.#cachedText = this.#text;
@@ -430,8 +540,9 @@ export class Markdown implements Component {
 			return { lines: result, spans: this.#cachedAnchorSpans };
 		}
 
-		// Replace tabs with 3 spaces for consistent rendering
-		const normalizedText = replaceTabs(this.#text);
+		// Normalize tabs using the current configured indentation width.
+		const renderedText = this.#text;
+		const normalizedText = replaceTabs(renderedText);
 		this.#clearStaleThrottleTimer();
 		const contentKey = markdownContentKey(normalizedText);
 
@@ -450,10 +561,11 @@ export class Markdown implements Component {
 			(!includeAnchors || cached.anchorSpans !== undefined)
 		) {
 			// Populate L1 so subsequent calls from this instance are O(1) map lookup.
-			this.#cachedText = this.#text;
+			this.#cachedText = renderedText;
 			this.#cachedWidth = width;
 			this.#cachedLines = cached.lines;
 			this.#cachedAnchorSpans = cached.anchorSpans;
+			if (!this.#streaming || this.#currentParse?.source !== normalizedText) this.#currentParse = undefined;
 			return { lines: cached.lines, spans: cached.anchorSpans };
 		}
 
@@ -462,13 +574,17 @@ export class Markdown implements Component {
 		// final wrapped output must differ by width.
 		const cachedParse = parseCache.get(contentKey);
 		let tokens: Token[];
-		if (cachedParse !== undefined && cachedParse.source === normalizedText) {
+		if (this.#currentParse?.source === normalizedText) {
+			tokens = this.#currentParse.tokens;
+		} else if (cachedParse !== undefined && cachedParse.source === normalizedText) {
 			tokens = cachedParse.tokens;
 		} else {
 			__markdownPerfCounters.lexerInvocations += 1;
 			__markdownPerfCounters.lexedBytes += normalizedText.length;
 			tokens = markdownParser.lexer(normalizedText);
-			parseCache.set(contentKey, { source: normalizedText, tokens });
+		}
+		if (this.#streaming && this.#text === renderedText) {
+			this.#currentParse = { source: normalizedText, tokens };
 		}
 
 		// Convert tokens to styled terminal output. When anchoring, record each
@@ -615,8 +731,24 @@ export class Markdown implements Component {
 		const result = rawResult.length > 0 ? rawResult : [""];
 		const anchorSpans = rawResult.length > 0 ? rawAnchorSpans : wrappedSpans ? [null] : undefined;
 
+		// Styling callbacks may replace text or end streaming. Publish ownership
+		// only after they finish, and never attach an old rejection to new text.
+		if (!this.#streaming && this.#text === renderedText) {
+			const completedParse = parseCache.get(contentKey);
+			// Reparse rejected documents on reflow without retaining their tokens.
+			// Occupied collisions still retry admission to preserve replacement rules.
+			if (
+				completedParse?.source !== normalizedText &&
+				(this.#rejectedParseKey !== contentKey || completedParse !== undefined)
+			) {
+				parseCache.set(contentKey, { source: normalizedText, tokens });
+				this.#rejectedParseKey = parseCache.has(contentKey) ? undefined : contentKey;
+			}
+		}
+		if (!this.#streaming || this.#text !== renderedText) this.#currentParse = undefined;
+
 		// Update L1 per-instance cache
-		this.#cachedText = this.#text;
+		this.#cachedText = renderedText;
 		this.#cachedWidth = width;
 		this.#cachedLines = result;
 		this.#cachedAnchorSpans = anchorSpans;
@@ -624,7 +756,9 @@ export class Markdown implements Component {
 
 		// Update L2 module-level LRU so future instances with the same key skip
 		// the marked.lexer + highlightCode (Rust FFI) work entirely.
-		renderCache.set(cacheKey, { source: normalizedText, lines: result, ...(anchorSpans ? { anchorSpans } : {}) });
+		if (!this.#streaming) {
+			renderCache.set(cacheKey, { source: normalizedText, lines: result, ...(anchorSpans ? { anchorSpans } : {}) });
+		}
 
 		return { lines: result, spans: anchorSpans };
 	}

package/src/components/select-list.ts

@@ -241,9 +241,12 @@ export class SelectList implements Component {
 
 	#getPrimaryColumnWidth(): number {
 		const { min, max } = this.#getPrimaryColumnBounds();
-		const widestPrimary = this.#filteredItems.reduce((widest, item) => {
-			return Math.max(widest, visibleWidth(this.#getDisplayValue(item)) + PRIMARY_COLUMN_GAP);
-		}, 0);
+		if (min === max) return min;
+		let widestPrimary = 0;
+		for (const item of this.#filteredItems) {
+			widestPrimary = Math.max(widestPrimary, visibleWidth(this.#getDisplayValue(item)) + PRIMARY_COLUMN_GAP);
+			if (widestPrimary >= max) return max;
+		}
 
 		return clamp(widestPrimary, min, max);
 	}

package/src/tui.ts

@@ -147,15 +147,17 @@ function csiEnd(bytes: string, start: number): number | undefined {
  */
 function stripTerminalEraseControls(bytes: string): string {
 	let sanitized = "";
+	let spanStart = 0;
 	for (let index = 0; index < bytes.length; index += 1) {
 		const value = bytes.charCodeAt(index);
 		const isEscapeCsi = value === 0x1b && bytes.charCodeAt(index + 1) === 0x5b;
 		const isEightBitCsi = value === 0x9b;
-		if (value === 0x1b && index === bytes.length - 1) break;
-		if (!isEscapeCsi && !isEightBitCsi) {
-			sanitized += bytes[index];
-			continue;
+		if (value === 0x1b && index === bytes.length - 1) {
+			sanitized += bytes.slice(spanStart, index);
+			spanStart = bytes.length;
+			break;
 		}
+		if (!isEscapeCsi && !isEightBitCsi) continue;
 
 		const start = isEightBitCsi ? index + 1 : index + 2;
 		const end = csiEnd(bytes, start);
@@ -168,16 +170,19 @@ function stripTerminalEraseControls(bytes: string): string {
 				if (!CSI_PARAMETER(nextValue) && !CSI_INTERMEDIATE(nextValue)) break;
 				next += 1;
 			}
+			sanitized += bytes.slice(spanStart, index);
+			spanStart = next;
 			index = next - 1;
 			continue;
 		}
 		const final = bytes.charCodeAt(end);
-		if (final !== 0x4a && final !== 0x4b) {
-			sanitized += bytes.slice(index, end + 1);
+		if (final === 0x4a || final === 0x4b) {
+			sanitized += bytes.slice(spanStart, index);
+			spanStart = end + 1;
 		}
 		index = end;
 	}
-	return sanitized;
+	return spanStart === 0 ? bytes : sanitized + bytes.slice(spanStart);
 }
 type InputListenerResult = { consume?: boolean; data?: string } | undefined;
 type InputListener = (data: string) => InputListenerResult;
@@ -813,6 +818,7 @@ type TuiRenderCounterSnapshot = {
 	debugRedrawEnvReads: number;
 	debugRedrawAppendWrites: number;
 	differentialGuardVisibleWidthCalls: number;
+	widthReflowScanRows: number;
 };
 type RenderCommitWaiter = {
 	resolve: (committed: boolean) => void;
@@ -1176,6 +1182,7 @@ export class TUI extends Container {
 		debugRedrawEnvReads: 0,
 		debugRedrawAppendWrites: 0,
 		differentialGuardVisibleWidthCalls: 0,
+		widthReflowScanRows: 0,
 	};
 
 	static resetRenderCountersForTest(): void {
@@ -1183,6 +1190,7 @@ export class TUI extends Container {
 			debugRedrawEnvReads: 0,
 			debugRedrawAppendWrites: 0,
 			differentialGuardVisibleWidthCalls: 0,
+			widthReflowScanRows: 0,
 		};
 	}
 
@@ -4040,6 +4048,7 @@ export class TUI extends Container {
 	#normalizeLinesForEmit(lines: string[], width: number, start = 0): string[] {
 		const widthCheckIndexes: number[] = [];
 		const widthCheckLines: string[] = [];
+		const retainedWidths: (number | undefined)[] = [];
 		for (let i = start; i < lines.length; i++) {
 			const line = lines[i];
 			if (TERMINAL.isImageLine(line)) continue;
@@ -4052,19 +4061,21 @@ export class TUI extends Container {
 				continue;
 			}
 			widthCheckIndexes.push(i);
-			widthCheckLines.push(normalized);
+			retainedWidths.push(entry.width);
+			if (entry.width === undefined) widthCheckLines.push(normalized);
 		}
 
 		const widths = widthCheckLines.length === 0 ? [] : visibleWidths(widthCheckLines);
 		const truncateIndexes: number[] = [];
 		const truncateLines: string[] = [];
+		let measuredIndex = 0;
 		for (let i = 0; i < widthCheckIndexes.length; i++) {
 			const lineIndex = widthCheckIndexes[i];
-			const normalized = widthCheckLines[i];
-			const measuredWidth = widths[i] ?? 0;
+			const entry = this.#normalizeLineForRender(lines[lineIndex]);
+			const { normalized } = entry;
+			const measuredWidth = retainedWidths[i] ?? widths[measuredIndex++] ?? 0;
+			entry.width = measuredWidth;
 			if (measuredWidth <= width) {
-				const entry = this.#normalizeLineForRender(lines[lineIndex]);
-				entry.width = measuredWidth;
 				this.#lineEmitWidthCache.set(entry.terminated, measuredWidth);
 				lines[lineIndex] = entry.terminated;
 				continue;
@@ -4073,7 +4084,9 @@ export class TUI extends Container {
 			const key = `${width}\0${normalized}`;
 			const cached = this.#lineTruncationCache.get(key);
 			if (cached !== undefined) {
-				this.#lineEmitWidthCache.set(cached, visibleWidth(cached));
+				if (!this.#lineEmitWidthCache.has(cached)) {
+					this.#lineEmitWidthCache.set(cached, visibleWidth(cached));
+				}
 				lines[lineIndex] = cached;
 				continue;
 			}
@@ -5074,10 +5087,12 @@ export class TUI extends Container {
 		}
 		const useViewportRepaintPath = this.#viewportRepaintHost();
 		const widthReflowRequired =
+			widthChanged &&
 			this.#previousWidth > 0 &&
-			rawLines.some(
-				line => !TERMINAL.isImageLine(line) && visibleWidth(line) > Math.min(this.#previousWidth, width),
-			);
+			rawLines.some(line => {
+				TUI.#renderCounters.widthReflowScanRows += 1;
+				return !TERMINAL.isImageLine(line) && visibleWidth(line) > Math.min(this.#previousWidth, width);
+			});
 		if (
 			widthChanged &&
 			!this.#legacyMultiplexerFullRender &&