@oh-my-pi/pi-tui 18.0.0 → 18.0.3

package/src/components/text.ts

@@ -25,14 +25,11 @@ export class Text implements Component {
 	#paddingY: number; // Top/bottom padding
 	#customBgFn?: (text: string) => string;
 	#styleFn?: (text: string) => string;
-	#widthEpochRevision = 0;
-
 	#ignoreTight = false;
 
 	setIgnoreTight(ignore: boolean): this {
 		if (this.#ignoreTight === ignore) return this;
 		this.#ignoreTight = ignore;
-		this.#widthEpochRevision++;
 		this.invalidate();
 		return this;
 	}
@@ -40,7 +37,7 @@ export class Text implements Component {
 	// Cache for rendered output
 	#cachedText?: string;
 	#cachedWidth?: number;
-	#cachedWidthEpoch?: number;
+	#cachedWidthConfigEpoch?: number;
 	#cachedLines?: string[];
 
 	constructor(text: string = "", paddingX: number = 1, paddingY: number = 1, customBgFn?: (text: string) => string) {
@@ -61,23 +58,17 @@ export class Text implements Component {
 		this.#text = text;
 		this.#cachedText = undefined;
 		this.#cachedWidth = undefined;
-		this.#cachedWidthEpoch = undefined;
+		this.#cachedWidthConfigEpoch = undefined;
 		this.#cachedLines = undefined;
-		this.#widthEpochRevision++;
 		return true;
 	}
 
-	getNativeScrollbackWidthEpochRevision(): number {
-		return this.#widthEpochRevision;
-	}
-
 	setCustomBgFn(customBgFn?: (text: string) => string): void {
 		this.#customBgFn = customBgFn;
 		this.#cachedText = undefined;
 		this.#cachedWidth = undefined;
-		this.#cachedWidthEpoch = undefined;
+		this.#cachedWidthConfigEpoch = undefined;
 		this.#cachedLines = undefined;
-		this.#widthEpochRevision++;
 	}
 
 	/**
@@ -90,16 +81,15 @@ export class Text implements Component {
 		this.#styleFn = styleFn;
 		this.#cachedText = undefined;
 		this.#cachedWidth = undefined;
-		this.#cachedWidthEpoch = undefined;
+		this.#cachedWidthConfigEpoch = undefined;
 		this.#cachedLines = undefined;
-		this.#widthEpochRevision++;
 		return this;
 	}
 
 	invalidate(): void {
 		this.#cachedText = undefined;
 		this.#cachedWidth = undefined;
-		this.#cachedWidthEpoch = undefined;
+		this.#cachedWidthConfigEpoch = undefined;
 		this.#cachedLines = undefined;
 	}
 
@@ -109,7 +99,7 @@ export class Text implements Component {
 			this.#cachedLines &&
 			this.#cachedText === this.#text &&
 			this.#cachedWidth === width &&
-			this.#cachedWidthEpoch === getWidthConfigEpoch()
+			this.#cachedWidthConfigEpoch === getWidthConfigEpoch()
 		) {
 			return this.#cachedLines;
 		}
@@ -119,7 +109,7 @@ export class Text implements Component {
 			const result: string[] = [];
 			this.#cachedText = this.#text;
 			this.#cachedWidth = width;
-			this.#cachedWidthEpoch = getWidthConfigEpoch();
+			this.#cachedWidthConfigEpoch = getWidthConfigEpoch();
 			this.#cachedLines = result;
 			return result;
 		}
@@ -175,7 +165,7 @@ export class Text implements Component {
 		// Update cache
 		this.#cachedText = this.#text;
 		this.#cachedWidth = width;
-		this.#cachedWidthEpoch = getWidthConfigEpoch();
+		this.#cachedWidthConfigEpoch = getWidthConfigEpoch();
 		this.#cachedLines = result;
 
 		return result.length > 0 ? result : [""];

package/src/fuzzy.ts

@@ -42,6 +42,16 @@ const ALPHANUMERIC_SWAP_PENALTY = 5;
 const COMPACT_PHRASE_BONUS = 1200;
 const PHRASE_BONUS = 1000;
 
+/**
+ * Shortest needle worth scanning past its leading occurrence for.
+ *
+ * One or two characters sit mid-word in nearly every candidate — "im" is inside
+ * "experimental" — so rescanning that short would hand the word-start bonus to
+ * the whole corpus at once and reshuffle the list on the opening keystrokes of a
+ * search instead of narrowing it. Shadowing only misleads for real phrases.
+ */
+const MIN_SHADOW_RESCAN_LENGTH = 3;
+
 function normalizeForSearch(value: string): string {
 	return value
 		.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
@@ -172,6 +182,53 @@ function isWordBoundaryPhrase(normalized: string, index: number, length: number)
 	return before && after;
 }
 
+/**
+ * Offset of the first whole-word occurrence of `phrase` in `normalized`, or -1.
+ *
+ * A bare `indexOf` reports only the leading occurrence, so a qualifying match is
+ * dropped whenever an earlier non-qualifying one shadows it — the whole word
+ * "image" in "reimage image provider" loses to the "image" inside "reimage".
+ * Occurrences are scanned left to right, so the first qualifying hit is also the
+ * best-scoring one: the caller's position tiebreak grows with the offset.
+ *
+ * Only a hit buried inside a word can shadow. A leading hit that already starts
+ * a word is an ordinary prefix match — the query is "image" and the text says
+ * "images" — and it is scored exactly as before rather than borrowing a
+ * whole-word bonus from some later occurrence; `findCompactWordStart` treats its
+ * leading word-start hit the same way. The rescan is additionally limited to
+ * {@link MIN_SHADOW_RESCAN_LENGTH} and longer needles.
+ */
+function findWordBoundaryPhrase(normalized: string, phrase: string): number {
+	if (phrase.length === 0) return -1;
+	const first = normalized.indexOf(phrase);
+	if (first < 0) return -1;
+	if (isWordBoundaryPhrase(normalized, first, phrase.length)) return first;
+	if (first === 0 || normalized[first - 1] === " ") return -1;
+	if (phrase.length < MIN_SHADOW_RESCAN_LENGTH) return -1;
+	for (let at = normalized.indexOf(phrase, first + 1); at >= 0; at = normalized.indexOf(phrase, at + 1)) {
+		if (isWordBoundaryPhrase(normalized, at, phrase.length)) return at;
+	}
+	return -1;
+}
+
+/**
+ * Offset of the first occurrence of `needle` that starts a word in `index.compact`,
+ * or -1. Same shadowing hazard, and the same length floor, as
+ * {@link findWordBoundaryPhrase}.
+ */
+function findCompactWordStart(index: SearchIndex, needle: string): number {
+	if (needle.length === 0) return -1;
+	const { compact, compactWordStarts } = index;
+	const first = compact.indexOf(needle);
+	if (first < 0) return -1;
+	if (compactWordStarts.has(first)) return first;
+	if (needle.length < MIN_SHADOW_RESCAN_LENGTH) return -1;
+	for (let at = compact.indexOf(needle, first + 1); at >= 0; at = compact.indexOf(needle, at + 1)) {
+		if (compactWordStarts.has(at)) return at;
+	}
+	return -1;
+}
+
 function scoreTokenAgainstWord(token: string, word: SearchWord): FuzzyMatch | null {
 	if (word.text === token) {
 		return { matches: true, score: withPosition(-200, word.index) };
@@ -230,8 +287,8 @@ function scoreTokenDirect(token: string, index: SearchIndex): FuzzyMatch {
 	if (token.length === 0) return { matches: true, score: 0 };
 
 	let best: FuzzyMatch | null = null;
-	const compactIndex = index.compact.indexOf(token);
-	if (compactIndex >= 0 && index.compactWordStarts.has(compactIndex)) {
+	const compactIndex = findCompactWordStart(index, token);
+	if (compactIndex >= 0) {
 		best = { matches: true, score: withPosition(-140, compactIndex) };
 	}
 
@@ -290,14 +347,14 @@ function fuzzyMatchCore(pq: PreparedQuery | null, index: SearchIndex): FuzzyMatc
 	}
 
 	let totalScore = 0;
-	const phraseIndex = index.normalized.indexOf(pq.normalized);
-	if (phraseIndex >= 0 && isWordBoundaryPhrase(index.normalized, phraseIndex, pq.normalized.length)) {
+	const phraseIndex = findWordBoundaryPhrase(index.normalized, pq.normalized);
+	if (phraseIndex >= 0) {
 		totalScore -= PHRASE_BONUS;
 		totalScore += phraseIndex * 0.01;
 	}
 
-	const compactPhraseIndex = index.compact.indexOf(pq.compact);
-	if (compactPhraseIndex >= 0 && index.compactWordStarts.has(compactPhraseIndex)) {
+	const compactPhraseIndex = findCompactWordStart(index, pq.compact);
+	if (compactPhraseIndex >= 0) {
 		totalScore -= COMPACT_PHRASE_BONUS;
 		totalScore += compactPhraseIndex * 0.01;
 	}

package/src/stdin-buffer.ts

@@ -56,6 +56,17 @@ const PARTIAL_HOLD_MAX_MS = 150;
 // so the string-terminator cap is generous.
 const MAX_CSI_BYTES = 4096;
 const MAX_STRING_SEQ_BYTES = 16 * 1024 * 1024;
+// Torn-string discard bounds. When a capped or timeout-expired OSC/DCS/APC
+// partial is dropped, the bytes that follow are mid-string payload (base64
+// clipboard data, Sixel, …) up to the next ST/BEL. Replaying them as
+// keystrokes types kilobytes of garbage into the focused component (kitty
+// OSC 5522 image paste spam), so discard mode swallows the tail until a
+// terminator — bounded by a byte budget for a terminator-less stream and an
+// inactivity watchdog for a stream that simply stops.
+const STRING_DISCARD_MAX_BYTES = 2 * MAX_STRING_SEQ_BYTES;
+const STRING_DISCARD_INACTIVITY_MS = 1000;
+// Partial that can only be the head of an OSC/DCS/APC string sequence.
+const STRING_SEQ_PARTIAL = /^\x1b[\]P_]/;
 
 // SGR mouse report bodies live between `<` and the terminating `M`/`m`.
 // Matched only when the trailing byte is a valid terminator, so the regex
@@ -110,7 +121,8 @@ function isRawMultilineBurst(text: string): boolean {
  *   `end > pos`  — complete sequence, exclusive end index.
  *   `-1`         — incomplete, still under the per-type cap; buffer for more.
  *   `-2`         — incomplete and the prefix already spans the per-type cap;
- *                  the caller flushes it as raw bytes to guarantee progress.
+ *                  the caller cap-flushes CSI as raw bytes; string types
+ *                  (OSC/DCS/APC) are dropped and their tail discarded.
  */
 function resolveEscapeEnd(buffer: string, pos: number, length: number, resumeSearchFrom: number): number {
 	if (pos + 1 >= length) return -1;
@@ -211,17 +223,6 @@ function resolveEscapeEnd(buffer: string, pos: number, length: number, resumeSea
 	}
 }
 
-/**
- * Per-type cap used to flush the incomplete prefix when `resolveEscapeEnd`
- * returns -2. The cap keeps issue-4073's malformed streamed CSI/OSC/…
- * bounded in both work and memory.
- */
-function escapeCapFor(next: number): number {
-	// OSC/DCS/APC carry the large payloads (image paste, Sixel); CSI stays
-	// tight because real CSI keys/mouse/responses fit comfortably below 4 KiB.
-	return next === 0x5d || next === 0x50 || next === 0x5f ? MAX_STRING_SEQ_BYTES : MAX_CSI_BYTES;
-}
-
 /**
  * Split accumulated buffer into complete sequences
  */
@@ -236,7 +237,7 @@ function parseUnmodifiedKittyPrintableCodepoint(sequence: string): number | unde
 function extractCompleteSequences(
 	buffer: string,
 	resumeSearchFrom: number,
-): { sequences: string[]; remainder: string; resumeSearchFrom: number } {
+): { sequences: string[]; remainder: string; resumeSearchFrom: number; discardFrom?: number } {
 	const sequences: string[] = [];
 	const length = buffer.length;
 	let pos = 0;
@@ -295,8 +296,8 @@ function extractCompleteSequences(
 				return { sequences, remainder: buffer.slice(pos), resumeSearchFrom: 0 };
 			}
 			if (innerEnd === -2) {
-				const cap = escapeCapFor(third);
-				const flushEnd = Math.min(length, pos + cap);
+				// `third` is CSI/SS3 here, never a string type.
+				const flushEnd = Math.min(length, pos + MAX_CSI_BYTES);
 				sequences.push(buffer.slice(pos, flushEnd));
 				pos = flushEnd;
 				hint = 0;
@@ -331,8 +332,14 @@ function extractCompleteSequences(
 		}
 		if (end === -2) {
 			const next = buffer.charCodeAt(pos + 1);
-			const cap = escapeCapFor(next);
-			const flushEnd = Math.min(length, pos + cap);
+			if (next === 0x5d || next === 0x50 || next === 0x5f) {
+				// Unterminated string sequence at the cap (issue #4073 case A):
+				// the head is junk and everything after it is mid-string
+				// payload. Hand both to the caller's discard mode instead of
+				// flushing the payload as per-character typed text.
+				return { sequences, remainder: "", resumeSearchFrom: 0, discardFrom: pos };
+			}
+			const flushEnd = Math.min(length, pos + MAX_CSI_BYTES);
 			sequences.push(buffer.slice(pos, flushEnd));
 			pos = flushEnd;
 			hint = 0;
@@ -399,6 +406,10 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	#escapeSearchOffset = 0;
 	#rawPasteCandidate = "";
 	#rawPasteTimer?: NodeJS.Timeout;
+	#stringDiscardActive = false;
+	#stringDiscardBytes = 0;
+	#stringDiscardEscHeld = false;
+	#stringDiscardWatchdog?: NodeJS.Timeout;
 
 	constructor(options: StdinBufferOptions = {}) {
 		super();
@@ -422,6 +433,12 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		} else {
 			str = data;
 		}
+		if (this.#stringDiscardActive) {
+			// Mid torn-string: swallow payload up to the terminator; only what
+			// follows the terminator re-enters normal parsing.
+			str = this.#consumeStringDiscard(str);
+			if (str.length === 0) return;
+		}
 
 		if (this.#flushDeferral && this.#isFreshEscapeAfterDeferredFlush(str)) {
 			// The buffered partial already hit its flush timeout. A new escape is
@@ -500,6 +517,18 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		}
 
 		const result = extractCompleteSequences(this.#buffer, this.#escapeSearchOffset);
+		if (result.discardFrom !== undefined) {
+			const junk = this.#buffer.slice(result.discardFrom);
+			this.#buffer = "";
+			this.#escapeSearchOffset = 0;
+			for (const sequence of result.sequences) {
+				this.#emitDataSequence(sequence);
+			}
+			this.#enterStringDiscard();
+			const after = this.#consumeStringDiscard(junk);
+			if (after.length > 0) this.process(after);
+			return;
+		}
 		this.#buffer = result.remainder;
 		this.#escapeSearchOffset = result.resumeSearchFrom;
 
@@ -662,7 +691,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			this.#timeout = undefined;
 			this.#flushDeferral = setTimeout(() => {
 				this.#flushDeferral = undefined;
-				this.#flushExpired();
+				this.#flushExpired(true);
 			});
 		}, this.#timeoutMs);
 	}
@@ -710,7 +739,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	}
 
 	/** Timeout-driven flush: hold unambiguous partials (bounded), else deliver. */
-	#flushExpired(): void {
+	#flushExpired(fromTimer = false): void {
 		if (this.#buffer.length === 0) {
 			this.#partialHoldStartMs = 0;
 			return;
@@ -723,12 +752,16 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			}
 		}
 		this.#partialHoldStartMs = 0;
-		for (const sequence of this.flush()) {
+		for (const sequence of this.#drainBuffered(fromTimer)) {
 			this.#emitDataSequence(sequence);
 		}
 	}
 
 	flush(): string[] {
+		return this.#drainBuffered(false);
+	}
+
+	#drainBuffered(discardTornString: boolean): string[] {
 		this.#clearFlushTimer();
 
 		const rawCandidate = this.#takeRawPasteCandidate();
@@ -750,16 +783,93 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		// split in `extractCompleteSequences` and deliver two ESC events.
 		if (buffered === `${ESC}${ESC}`) {
 			sequences.push(ESC, ESC);
+		} else if (isKittyProtocolActive() && STRING_SEQ_PARTIAL.test(buffered)) {
+			// Torn OSC/DCS/APC head. Under the kitty keyboard protocol no key
+			// ever arrives as a bare `\x1b]`/`\x1bP`/`\x1b_`, so this is always
+			// terminal protocol data (kitty OSC 5522 clipboard read, graphics
+			// reply) whose tail is still in flight. Never deliver the head as a
+			// key; on a timeout flush also swallow the tail up to its
+			// terminator so kilobytes of base64 are not typed into the focused
+			// component (image paste spam).
+			if (discardTornString) this.#enterStringDiscard();
 		} else {
 			sequences.push(buffered);
 		}
 		return sequences;
 	}
 
+	/** Enter torn-string discard: swallow mid-string bytes until ST/BEL. */
+	#enterStringDiscard(): void {
+		this.#stringDiscardActive = true;
+		this.#stringDiscardBytes = 0;
+		this.#stringDiscardEscHeld = false;
+		this.#armStringDiscardWatchdog();
+	}
+
+	#exitStringDiscard(): void {
+		this.#stringDiscardActive = false;
+		this.#stringDiscardBytes = 0;
+		this.#stringDiscardEscHeld = false;
+		if (this.#stringDiscardWatchdog) {
+			clearTimeout(this.#stringDiscardWatchdog);
+			this.#stringDiscardWatchdog = undefined;
+		}
+	}
+
+	/**
+	 * Swallow mid-string bytes; returns the input remaining after the string
+	 * terminator (empty while still inside the torn string). A trailing ESC is
+	 * held across calls so an `ESC \` split between reads is still detected.
+	 * The byte budget bounds a terminator-less stream; the inactivity watchdog
+	 * recovers a stream that stops without ever terminating.
+	 */
+	#consumeStringDiscard(str: string): string {
+		if (this.#stringDiscardEscHeld) {
+			this.#stringDiscardEscHeld = false;
+			if (str.charCodeAt(0) === 0x5c /* \ */) {
+				this.#exitStringDiscard();
+				return str.slice(1);
+			}
+		}
+		for (let i = 0; i < str.length; i++) {
+			const code = str.charCodeAt(i);
+			if (code === 0x07 /* BEL */) {
+				this.#exitStringDiscard();
+				return str.slice(i + 1);
+			}
+			if (code === 0x1b /* ESC */) {
+				if (i + 1 === str.length) {
+					this.#stringDiscardEscHeld = true;
+					break;
+				}
+				if (str.charCodeAt(i + 1) === 0x5c /* \ */) {
+					this.#exitStringDiscard();
+					return str.slice(i + 2);
+				}
+			}
+		}
+		this.#stringDiscardBytes += str.length;
+		if (this.#stringDiscardBytes > STRING_DISCARD_MAX_BYTES) {
+			this.#exitStringDiscard();
+			return "";
+		}
+		this.#armStringDiscardWatchdog();
+		return "";
+	}
+
+	#armStringDiscardWatchdog(): void {
+		if (this.#stringDiscardWatchdog) clearTimeout(this.#stringDiscardWatchdog);
+		this.#stringDiscardWatchdog = setTimeout(() => {
+			this.#stringDiscardWatchdog = undefined;
+			this.#exitStringDiscard();
+		}, STRING_DISCARD_INACTIVITY_MS);
+	}
+
 	clear(): void {
 		this.#clearFlushTimer();
 		this.#clearPasteWatchdog();
 		this.#clearRawPasteTimer();
+		this.#exitStringDiscard();
 		this.#buffer = "";
 		this.#rawPasteCandidate = "";
 		this.#pasteMode = false;

package/src/terminal-capabilities.ts

@@ -105,7 +105,7 @@ export class TerminalInfo {
 		public readonly deccara: boolean = false,
 		readonly supportsScreenToScrollback: boolean = false,
 		/** Renders the Kitty OSC 66 text-sizing protocol (scaled spans). Kitty only. */
-		public readonly textSizing: boolean = false,
+		public readonly supportsTextSizing: boolean = false,
 		/**
 		 * Hangul Compatibility Jamo (U+3131..=U+318E) cell width. Ghostty follows
 		 * UAX#11 (2 cells); Warp paints 1; "platform" keeps the OS default
@@ -557,11 +557,14 @@ export interface RuntimeTerminal extends TerminalInfo {
 	hyperlinks: boolean;
 	deccara: boolean;
 	supportsScreenToScrollback: boolean;
+	/** Whether OSC 66 text sizing is currently enabled. */
 	textSizing: boolean;
 }
 
 export const TERMINAL: RuntimeTerminal = (() => {
 	const resolved = getTerminalInfo(TERMINAL_ID).clone();
+	// Detection records support; hosts opt into OSC 66 separately.
+	resolved.textSizing = false;
 
 	const forcedImageProtocol = getForcedImageProtocol();
 	if (forcedImageProtocol !== undefined) {
@@ -618,7 +621,7 @@ export function setTerminalScreenToScrollback(enabled: boolean): void {
 
 /**
  * Enable/disable OSC 66 text-sizing at runtime. The coding-agent calls this from
- * the `tui.textSizing` setting (gated on the terminal's static `textSizing`
+ * the `tui.textSizing` setting (gated on the terminal's static `supportsTextSizing`
  * capability); tests flip it directly to exercise the scaled-heading path.
  */
 export function setTerminalTextSizing(enabled: boolean): void {
@@ -831,6 +834,14 @@ export function encodeKittyPlacementLine(options: {
 export function encodeKittyDeleteImage(imageId: number): string {
 	return wrapTmuxPassthroughIfNeeded(`\x1b_Ga=d,d=I,i=${imageId},q=2\x1b\\`);
 }
+/**
+ * Delete every Kitty image and placement in the terminal. Used only by an
+ * explicit destructive display reset: text erases leave untracked placements
+ * painted, so per-image bookkeeping cannot guarantee a clean viewport.
+ */
+export function encodeKittyDeleteAllImages(): string {
+	return wrapTmuxPassthroughIfNeeded("\x1b_Ga=d,d=A,q=2\x1b\\");
+}
 
 /**
  * Delete a single placement of an image (`d=i`, lowercase): removes its cells

package/src/terminal.ts

@@ -231,6 +231,20 @@ function registerPostmortemTerminalRestore(): void {
 export function setAltScreenActive(active: boolean): void {
 	altScreenActive = active;
 }
+/**
+ * Route an out-of-band escape sequence (e.g. an OSC title update) through the
+ * active terminal's output path. While a TUI owns stdout, frame paints go
+ * through the off-thread write pump and can split across multiple write(2)
+ * calls; a direct main-thread `process.stdout.write` can land between two of
+ * them — mid escape sequence — and the host terminal then prints the payload
+ * as literal text at the cursor position. Returns false when no terminal has
+ * started, in which case the caller owns stdout and may write directly.
+ */
+export function writeThroughActiveTerminal(data: string): boolean {
+	if (!activeTerminal) return false;
+	activeTerminal.write(data);
+	return true;
+}
 
 const stdoutErrorHandlers = new Set<(err: Error) => void>();
 let stdoutErrorListenerInstalled = false;