@oh-my-pi/pi-tui 17.3.8 → 17.4.1

package/src/tui.ts

@@ -216,6 +216,13 @@ export interface NativeScrollbackLiveRegion {
 	getNativeScrollbackLiveRegionStart(): number | undefined;
 	/** Keeps the mutable suffix viewport-local instead of recording frozen snapshots. */
 	isNativeScrollbackLiveRegionPinned?(): boolean;
+	/**
+	 * Local row where viewport pinning begins. When omitted, pinning (if
+	 * reported) starts at {@link getNativeScrollbackLiveRegionStart}. A nested
+	 * transcript uses this to keep an earlier unpinned live seam while still
+	 * capping commits at a later pinned dashboard (hub wait, todo snapshot).
+	 */
+	getNativeScrollbackLiveRegionPinnedStart?(): number | undefined;
 }
 
 export interface NativeScrollbackCommittedRows {
@@ -278,6 +285,13 @@ function getNativeScrollbackLiveRegionStart(component: Component): number | unde
 	return (component as Component & Partial<NativeScrollbackLiveRegion>).getNativeScrollbackLiveRegionStart?.();
 }
 
+function getNativeScrollbackLiveRegionPinnedStart(component: Component): number | undefined {
+	const start = (
+		component as Component & Partial<NativeScrollbackLiveRegion>
+	).getNativeScrollbackLiveRegionPinnedStart?.();
+	return start === undefined || !Number.isFinite(start) ? undefined : start;
+}
+
 /**
  * Opt-in stability report for components that mutate their returned render
  * array in place across frames (instead of returning a fresh array per
@@ -901,6 +915,8 @@ interface FrameSegment {
 	widthEpochRevision?: number;
 	liveLocalStart?: number;
 	liveRegionPinned: boolean;
+	/** Local pin start; when omitted, pinning begins at `liveLocalStart`. */
+	liveRegionPinnedStart?: number;
 }
 
 /** Depth-first identity search through `Container`-shaped children. */
@@ -1372,6 +1388,13 @@ export class TUI extends Container {
 	#multiplexerResizeTimer: RenderTimer | undefined;
 	#deferredForcedClearScrollback = false;
 	#multiplexerResizeHasPendingRender = false;
+	// Rows a mux pane pushed into its own scrollback on a height-only shrink
+	// without the engine committing them, plus the commit seam at push time.
+	// A later height grow pulls the pane's scrollback tail back into the grid:
+	// the pushed rows come out first — but only while no commit has buried
+	// them — and only the remainder of the pull removes committed rows.
+	#muxPushedRows = 0;
+	#muxPushSeam = 0;
 	// True from the first SIGWINCH of a non-multiplexer drag until the settle
 	// timer fires. While set, every `#doRender` short-circuits to the viewport
 	// fast path (`#renderResizeViewport`) instead of an authoritative full
@@ -1661,12 +1684,14 @@ export class TUI extends Container {
 			let childLines: readonly string[];
 			let liveLocalStart: number | undefined;
 			let liveRegionPinned = false;
+			let liveRegionPinnedStart: number | undefined;
 			let widthEpochRevision: number | undefined;
 			let reported: number | undefined;
 			if (reuse) {
 				childLines = previous.lines;
 				liveLocalStart = previous.liveLocalStart;
 				liveRegionPinned = previous.liveRegionPinned;
+				liveRegionPinnedStart = previous.liveRegionPinnedStart;
 				widthEpochRevision = previous.widthEpochRevision;
 			} else {
 				// Feed the engine's committed-row claim (from the previous frame's
@@ -1697,6 +1722,15 @@ export class TUI extends Container {
 					liveRegionPinned =
 						(child as Component & Partial<NativeScrollbackLiveRegion>).isNativeScrollbackLiveRegionPinned?.() ===
 						true;
+					if (liveRegionPinned) {
+						const pinStart = getNativeScrollbackLiveRegionPinnedStart(child);
+						if (pinStart !== undefined) {
+							liveRegionPinnedStart = Math.max(
+								liveLocalStart,
+								Math.min(childLines.length, Math.trunc(pinStart)),
+							);
+						}
+					}
 				}
 				// Consume the stability report unconditionally for implementers:
 				// reading re-bases the component's baseline to the state this
@@ -1722,7 +1756,7 @@ export class TUI extends Container {
 				// even when an earlier unpinned seam won the topmost merge above:
 				// its rows (a growing anchored panel) must never reach scrollback.
 				if (liveRegionPinned && this.#nativeScrollbackPinnedBoundary === undefined) {
-					this.#nativeScrollbackPinnedBoundary = start;
+					this.#nativeScrollbackPinnedBoundary = offset + (liveRegionPinnedStart ?? liveLocalStart);
 				}
 			}
 			if (chainStable) {
@@ -1754,6 +1788,7 @@ export class TUI extends Container {
 				widthEpochRevision,
 				liveLocalStart,
 				liveRegionPinned,
+				liveRegionPinnedStart,
 			};
 			offset += childLines.length;
 		}
@@ -3761,6 +3796,37 @@ export class TUI extends Container {
 			!isMultiplexerSession() &&
 			(committedRowsResynced || frameLength <= this.#committedRows);
 		const fullPaint = firstPaint || replaceRequested || geometryRebuild || divergenceRebuild;
+		// Height-only mux resizes move rows between the pane's scrollback and its
+		// grid. A shrink with a full grid pushes the grid-top rows into pane
+		// scrollback without a commit; a grow pulls the scrollback tail back into
+		// the grid, where the forced in-place window rewrite overwrites it — gone
+		// from history. The scrollback is a stack: pushed rows sit at the tail
+		// only until the next commit buries them, so they shield a pull only
+		// while the commit seam has not moved since the push. The unshielded
+		// remainder removes committed rows — drop the commit seam by it and let
+		// the next chunk re-commit them. A short frame gains blank rows instead
+		// of pulling.
+		if (fullPaint || widthChanged) {
+			this.#muxPushedRows = 0;
+		} else if (
+			geometryChanged &&
+			this.#previousHeight > 0 &&
+			this.#previousFrameLength - this.#windowTopRow >= this.#previousHeight
+		) {
+			if (this.#committedRows !== this.#muxPushSeam) this.#muxPushedRows = 0;
+			if (height < this.#previousHeight) {
+				this.#muxPushedRows += this.#previousHeight - height;
+				this.#muxPushSeam = this.#committedRows;
+			} else if (height > this.#previousHeight) {
+				const pull = height - this.#previousHeight;
+				const fromPushed = Math.min(pull, this.#muxPushedRows);
+				this.#muxPushedRows -= fromPushed;
+				const fromCommitted = Math.min(pull - fromPushed, this.#committedRows);
+				this.#committedRows -= fromCommitted;
+				this.#committedPrefix.length = this.#committedRows;
+				this.#muxPushSeam = this.#committedRows;
+			}
+		}
 		let windowTop: number;
 		let chunkTo: number;
 		let widthEpochAppendFrom = 0;
@@ -3828,11 +3894,23 @@ export class TUI extends Container {
 			// the viewport. Rebase the commit seam to that exposed frame tail before
 			// the forced rewrite; flooring at the old seam would paint only the live
 			// suffix followed by blanks, then preserve that gap on every stream tick.
-			committedPrefixResliced = true;
 			windowTop = Math.max(0, frameLength - height);
 			chunkTo = windowTop;
 			this.#committedRows = windowTop;
-			this.#committedPrefix = rawFrame.slice(0, windowTop);
+			if (widthChanged) {
+				// A rewrap invalidated the recorded bytes: re-base the audit prefix
+				// at the new width so the accepted wrap drift does not read as a
+				// violation on the next ordinary frame.
+				committedPrefixResliced = true;
+				this.#committedPrefix = rawFrame.slice(0, windowTop);
+			} else {
+				// Height-only reflow: the pane did not rewrap, so the recorded
+				// bytes are still the true tape record. Truncate instead of
+				// reslicing from the current frame — replacing the record with
+				// live content would bless drifted frozen snapshots as verified
+				// and skip their finalize-time recommit (rows lost from history).
+				this.#committedPrefix.length = Math.min(this.#committedPrefix.length, windowTop);
+			}
 		} else {
 			// Re-anchor to the frame tail, floored at the committed boundary: a
 			// shrink (or overlay close) pulls the window back down, but never
@@ -3845,15 +3923,15 @@ export class TUI extends Container {
 			// record; nothing that was painted may vanish. Overlays freeze
 			// commits: composited rows must never enter history, and the hidden
 			// gap backfills via the chunk once the overlay closes. A multiplexer
-			// resize also commits nothing — the pane keeps its own (old-wrap)
-			// history — and re-bases the audit prefix at the new width so the
+			// resize also commits nothing — the pane keeps its own history — and
+			// a width rewrap re-bases the audit prefix at the new width so the
 			// accepted wrap drift does not read as a violation on the next
 			// ordinary frame.
 			chunkTo =
 				hasVisibleOverlay || geometryChanged
 					? this.#committedRows
 					: Math.min(windowTop, Math.max(this.#committedRows, commitCeiling));
-			if (geometryChanged) {
+			if (widthChanged) {
 				committedPrefixResliced = true;
 				this.#committedPrefix = rawFrame.slice(0, this.#committedRows);
 			}

package/src/utils.ts

@@ -225,9 +225,7 @@ export function getSegmenter(): Intl.Segmenter {
 // added back so width matches the native truncate/slice/wrap helpers.
 const OSC66_SPAN_REGEX = /\x1b\]66;([^;]*);([\s\S]*?)(?:\x07|\x1b\\)/g;
 const OSC66_PREFIX = "\x1b]66;";
-const ESC = "\x1b";
-const TAB = "\t";
-const LONG_WIDTH_FAST_PATH_MIN = 128;
+const PRINTABLE_ASCII_REGEX = /^[\u0020-\u007e]*$/;
 
 // Pin Bun.stringWidth semantics to the native width engine and guard against Bun
 // default drift: strip ANSI/OSC (don't count escape bytes) and treat
@@ -243,8 +241,6 @@ const STRING_WIDTH_OPTS = { countAnsiEscapeCodes: false, ambiguousIsNarrow: true
 // `setHangulCompatibilityJamoWidth`; mirror the same correction here so the TS
 // width stays in parity with the native truncate/slice/wrap model — and so the
 // hardware cursor column lands on the actual glyph during Korean IME input.
-const HANGUL_COMPAT_JAMO_REGEX = /[\u3131-\u318e]/;
-const HANGUL_COMPAT_JAMO_GLOBAL_REGEX = /[\u3131-\u318e]/g;
 const HANGUL_FILLER_CODE_POINT = 0x3164;
 // `Bun.stringWidth` counts every code point in the Compatibility Jamo block as
 // 2 cells (even the U+3164 filler that `unicode-width` treats as zero-width).
@@ -274,19 +270,28 @@ function hangulCompatibilityJamoTargetWidth(): 1 | 2 | null {
 // crates/pi-natives/src/text.rs, including the rule that the zero-width filler
 // (U+3164) is never widened past the narrow correction (a wide terminal still
 // renders it at its Unicode width of 0).
-function correctHangulCompatibilityJamoWidth(width: number, str: string): number {
-	if (!HANGUL_COMPAT_JAMO_REGEX.test(str)) return width;
+function correctHangulCompatibilityJamoWidth(
+	width: number,
+	compatibilityJamoCount: number,
+	fillerCount: number,
+): number {
+	if (compatibilityJamoCount === 0) return width;
 	const target = hangulCompatibilityJamoTargetWidth();
-	let corrected = width;
-	HANGUL_COMPAT_JAMO_GLOBAL_REGEX.lastIndex = 0;
-	for (let m = HANGUL_COMPAT_JAMO_GLOBAL_REGEX.exec(str); m !== null; m = HANGUL_COMPAT_JAMO_GLOBAL_REGEX.exec(str)) {
-		const unicodeWidth = m[0].codePointAt(0) === HANGUL_FILLER_CODE_POINT ? 0 : 2;
-		const finalWidth = target === null || (unicodeWidth === 0 && target > 1) ? unicodeWidth : target;
-		corrected += finalWidth - HANGUL_COMPAT_JAMO_BUN_WIDTH;
-	}
-	return corrected;
+	return target === 1 ? width - compatibilityJamoCount : width - fillerCount * HANGUL_COMPAT_JAMO_BUN_WIDTH;
 }
 
+// Terminal redraws re-measure the same visible lines every frame, usually as
+// the same string objects (JSC caches their hashes, so repeat lookups are
+// O(1) — cheaper than even the ASCII fast scan). Strings longer than the
+// length gate skip the cache entirely: hashing them costs as much as measuring
+// them, and retaining them would pin large render buffers. Worst-case
+// retention is MAX * MAX_LEN UTF-16 units (~2 MiB); cleared when the width
+// configuration epoch changes.
+const VISIBLE_WIDTH_CACHE_MAX = 2048;
+const VISIBLE_WIDTH_CACHE_MAX_LEN = 512;
+const visibleWidthCache = new Map<string, number>();
+let visibleWidthCacheEpoch = widthConfigEpoch;
+
 /**
  * Visible width of a string in terminal columns, excluding ANSI/OSC escapes.
  *
@@ -296,65 +301,51 @@ function correctHangulCompatibilityJamoWidth(width: number, str: string): number
  */
 export function visibleWidth(str: string): number {
 	if (!str) return 0;
-
-	// Long non-escape text is faster through Bun's native scanner than through
-	// a JS printable-ASCII prepass. Escape-bearing strings stay on the scanner
-	// below so CSI/OSC-heavy render output can still bail out at the first ESC.
-	if (str.length >= LONG_WIDTH_FAST_PATH_MIN && !str.includes(ESC)) {
-		let width = Bun.stringWidth(str, STRING_WIDTH_OPTS);
-		let tabCount = 0;
-		for (let tabIndex = str.indexOf(TAB); tabIndex !== -1; tabIndex = str.indexOf(TAB, tabIndex + 1)) {
-			tabCount++;
+	const cacheable = str.length <= VISIBLE_WIDTH_CACHE_MAX_LEN;
+	if (cacheable) {
+		if (visibleWidthCacheEpoch !== widthConfigEpoch) {
+			visibleWidthCache.clear();
+			visibleWidthCacheEpoch = widthConfigEpoch;
 		}
-		if (tabCount > 0) width += tabCount * DEFAULT_TAB_WIDTH;
-		return correctHangulCompatibilityJamoWidth(width, str);
+		const cached = visibleWidthCache.get(str);
+		if (cached !== undefined) return cached;
 	}
 
-	let tabCount = 0;
-	let i = 0;
-	for (; i < str.length; i++) {
-		const code = str.charCodeAt(i);
-		if (code < 0x20 || code > 0x7e) {
-			if (code === 0x09) {
-				tabCount++;
-				continue;
-			}
-			break;
+	// This regex compiles to a native ASCII scan, cheaper than Bun's width
+	// scanner for the overwhelmingly common source-code path.
+	if (PRINTABLE_ASCII_REGEX.test(str)) {
+		if (cacheable) {
+			if (visibleWidthCache.size >= VISIBLE_WIDTH_CACHE_MAX) visibleWidthCache.clear();
+			visibleWidthCache.set(str, str.length);
 		}
-	}
-	if (i === str.length) {
-		return tabCount === 0 ? str.length : str.length + tabCount * (DEFAULT_TAB_WIDTH - 1);
+		return str.length;
 	}
 
-	if (tabCount === 0) {
-		let tabIndex = str.indexOf(TAB, i + 1);
-		if (tabIndex !== -1) {
-			tabCount = 1;
-			for (tabIndex = str.indexOf(TAB, tabIndex + 1); tabIndex !== -1; tabIndex = str.indexOf(TAB, tabIndex + 1)) {
-				tabCount++;
-			}
-		}
-	} else {
-		for (let tabIndex = str.indexOf(TAB, i + 1); tabIndex !== -1; tabIndex = str.indexOf(TAB, tabIndex + 1)) {
+	let tabCount = 0;
+	let compatibilityJamoCount = 0;
+	let fillerCount = 0;
+	let hasEsc = false;
+	for (let i = 0; i < str.length; i++) {
+		const code = str.charCodeAt(i);
+		if (code === 0x09) {
 			tabCount++;
+		} else if (code === 0x1b) {
+			hasEsc = true;
+		} else if (code >= 0x3131 && code <= 0x318e) {
+			compatibilityJamoCount++;
+			if (code === HANGUL_FILLER_CODE_POINT) fillerCount++;
 		}
 	}
 
-	// `Bun.stringWidth` is a JSC builtin (no per-call N-API number box, unlike
-	// the native scanner that traps under Bun 1.3.x GC/N-API load). It strips
-	// CSI/OSC to zero cells and shares the native engine's UAX#11 width tables.
 	let width = Bun.stringWidth(str, STRING_WIDTH_OPTS);
 	if (tabCount > 0) width += tabCount * DEFAULT_TAB_WIDTH;
 
-	// OSC 66: add back each stripped span as `scale * (explicit w ?? payload
-	// width)`. Matched rather than replaced to avoid reallocating the string.
-	if (str.includes(OSC66_PREFIX, i)) {
+	if (hasEsc && str.includes(OSC66_PREFIX)) {
 		OSC66_SPAN_REGEX.lastIndex = 0;
 		for (let m = OSC66_SPAN_REGEX.exec(str); m !== null; m = OSC66_SPAN_REGEX.exec(str)) {
 			let scale = 1;
 			let explicit: number | undefined;
 			for (const part of m[1].split(":")) {
-				// metadata keys are single chars, e.g. `s=2`, `w=5`
 				if (part.indexOf("=") !== 1) continue;
 				const value = Number.parseInt(part.slice(2), 10);
 				if (!Number.isFinite(value)) continue;
@@ -368,11 +359,15 @@ export function visibleWidth(str: string): number {
 		}
 	}
 
-	return correctHangulCompatibilityJamoWidth(width, str);
+	width = correctHangulCompatibilityJamoWidth(width, compatibilityJamoCount, fillerCount);
+	if (cacheable) {
+		if (visibleWidthCache.size >= VISIBLE_WIDTH_CACHE_MAX) visibleWidthCache.clear();
+		visibleWidthCache.set(str, width);
+	}
+	return width;
 }
 
 /**
- * True when a row carries a Kitty OSC 66 text-sizing span (`\x1b]66;…`).
  * Scaled spans must bypass wrapping/padding and, when scaled up, reserve the
  * terminal rows their multicell glyphs flow into.
  */