@oh-my-pi/pi-tui 17.4.2 → 18.0.1

package/src/components/select-list.ts

@@ -27,6 +27,8 @@ export interface SelectItem {
 	value: string;
 	label: string;
 	description?: string;
+	/** Optional type-indicator glyph rendered in an aligned column before the label */
+	icon?: string;
 	/** Dim hint text shown inline after cursor when this item is selected */
 	hint?: string;
 }
@@ -38,6 +40,8 @@ export interface SelectListTheme {
 	scrollInfo: (text: string) => string;
 	noMatch: (text: string) => string;
 	symbols: SymbolTheme;
+	/** Style for the type-icon column on unselected rows. Defaults to plain text. */
+	icon?: (text: string) => string;
 	/** Hover band applied to the full row under the mouse pointer. */
 	hovered?: (text: string) => string;
 }
@@ -64,12 +68,18 @@ export interface SelectListLayoutOptions {
 	 * wrap unevenly.
 	 */
 	wrapDescription?: boolean;
+	/**
+	 * Cap wrapped descriptions at this many visual rows; the last kept row is
+	 * ellipsized. Only meaningful with `wrapDescription`.
+	 */
+	maxDescriptionRows?: number;
 }
 
 type SelectItemLayout =
 	| {
 			kind: "description";
 			prefix: string;
+			iconCell: string;
 			truncatedValue: string;
 			spacing: string;
 			descriptionSingleLine: string;
@@ -79,6 +89,7 @@ type SelectItemLayout =
 	| {
 			kind: "primary";
 			prefix: string;
+			iconCell: string;
 			truncatedValue: string;
 			spacing: "";
 	  };
@@ -172,6 +183,7 @@ export class SelectList implements Component, MouseRoutable {
 		}
 
 		const primaryColumnWidth = this.#getPrimaryColumnWidth();
+		const iconColumnWidth = this.#getIconColumnWidth();
 		const wrapEnabled = this.layout.wrapDescription === true;
 		// `maxVisible` is the picker's visual row budget. For non-wrap layouts
 		// every item is one row, so the budget matches the original item count.
@@ -190,7 +202,9 @@ export class SelectList implements Component, MouseRoutable {
 				rowCounts[i] = 0;
 				continue;
 			}
-			rowCounts[i] = wrapEnabled ? this.#computeItemRowCount(item, conservativeRowWidth, primaryColumnWidth) : 1;
+			rowCounts[i] = wrapEnabled
+				? this.#computeItemRowCount(item, conservativeRowWidth, primaryColumnWidth, iconColumnWidth)
+				: 1;
 			visualTotal += rowCounts[i];
 		}
 
@@ -211,7 +225,13 @@ export class SelectList implements Component, MouseRoutable {
 			const item = this.#filteredItems[i];
 			if (!item) continue;
 			const hovered = this.theme.hovered !== undefined && i === this.#hoveredIndex && i !== this.#selectedIndex;
-			const itemRows = this.#renderItem(item, i === this.#selectedIndex, rowWidth, primaryColumnWidth);
+			const itemRows = this.#renderItem(
+				item,
+				i === this.#selectedIndex,
+				rowWidth,
+				primaryColumnWidth,
+				iconColumnWidth,
+			);
 			for (const row of itemRows) {
 				if (rows.length >= visualBudget) break;
 				this.#hitRows[rows.length] = i;
@@ -280,25 +300,33 @@ export class SelectList implements Component, MouseRoutable {
 		}
 	}
 
-	#renderItem(item: SelectItem, isSelected: boolean, width: number, primaryColumnWidth: number): string[] {
-		const layout = this.#computeItemLayout(item, isSelected, width, primaryColumnWidth);
+	#renderItem(
+		item: SelectItem,
+		isSelected: boolean,
+		width: number,
+		primaryColumnWidth: number,
+		iconColumnWidth: number,
+	): string[] {
+		const layout = this.#computeItemLayout(item, isSelected, width, primaryColumnWidth, iconColumnWidth);
 		const { prefix, truncatedValue, spacing } = layout;
+		const iconCell =
+			layout.iconCell && !isSelected && this.theme.icon ? this.theme.icon(layout.iconCell) : layout.iconCell;
 
 		if (layout.kind === "description") {
 			const { descriptionSingleLine, descriptionStart, remainingWidth } = layout;
 			if (this.layout.wrapDescription) {
-				const wrapped = wrapTextWithAnsi(descriptionSingleLine, remainingWidth);
+				const wrapped = this.#wrapDescription(descriptionSingleLine, remainingWidth);
 				if (wrapped.length === 0) wrapped.push("");
 				const indent = padding(descriptionStart);
 				const first = wrapped[0] ?? "";
 				if (isSelected) {
-					const rows = [this.theme.selectedText(`${prefix}${truncatedValue}${spacing}${first}`)];
+					const rows = [this.theme.selectedText(`${prefix}${iconCell}${truncatedValue}${spacing}${first}`)];
 					for (let i = 1; i < wrapped.length; i++) {
 						rows.push(this.theme.selectedText(`${indent}${wrapped[i]}`));
 					}
 					return rows;
 				}
-				const rows = [prefix + truncatedValue + this.theme.description(spacing + first)];
+				const rows = [prefix + iconCell + truncatedValue + this.theme.description(spacing + first)];
 				for (let i = 1; i < wrapped.length; i++) {
 					rows.push(this.theme.description(`${indent}${wrapped[i]}`));
 				}
@@ -307,25 +335,34 @@ export class SelectList implements Component, MouseRoutable {
 
 			const truncatedDesc = truncateToWidth(descriptionSingleLine, remainingWidth, Ellipsis.Omit);
 			if (isSelected) {
-				return [this.theme.selectedText(`${prefix}${truncatedValue}${spacing}${truncatedDesc}`)];
+				return [this.theme.selectedText(`${prefix}${iconCell}${truncatedValue}${spacing}${truncatedDesc}`)];
 			}
-			return [prefix + truncatedValue + this.theme.description(spacing + truncatedDesc)];
+			return [prefix + iconCell + truncatedValue + this.theme.description(spacing + truncatedDesc)];
 		}
 
 		if (isSelected) {
-			return [this.theme.selectedText(`${prefix}${truncatedValue}`)];
+			return [this.theme.selectedText(`${prefix}${iconCell}${truncatedValue}`)];
 		}
-		return [prefix + truncatedValue];
+		return [prefix + iconCell + truncatedValue];
 	}
 
-	#computeItemRowCount(item: SelectItem, width: number, primaryColumnWidth: number): number {
+	#computeItemRowCount(item: SelectItem, width: number, primaryColumnWidth: number, iconColumnWidth: number): number {
 		// Selection style does not change row count; pass isSelected=false to
 		// keep the cheap path uniform for items outside the visible window.
-		const layout = this.#computeItemLayout(item, false, width, primaryColumnWidth);
+		const layout = this.#computeItemLayout(item, false, width, primaryColumnWidth, iconColumnWidth);
 		if (layout.kind !== "description") return 1;
-		const wrapped = wrapTextWithAnsi(layout.descriptionSingleLine, layout.remainingWidth);
+		const wrapped = this.#wrapDescription(layout.descriptionSingleLine, layout.remainingWidth);
 		return Math.max(1, wrapped.length);
 	}
+	/** Wrap a description, capping it at `maxDescriptionRows` with a trailing ellipsis. */
+	#wrapDescription(description: string, width: number): string[] {
+		const wrapped = wrapTextWithAnsi(description, width);
+		const cap = this.layout.maxDescriptionRows;
+		if (cap === undefined || cap < 1 || wrapped.length <= cap) return wrapped;
+		const kept = wrapped.slice(0, cap);
+		kept[cap - 1] = truncateToWidth(`${kept[cap - 1]} …`, width, Ellipsis.Unicode);
+		return kept;
+	}
 
 	/**
 	 * Pick a contiguous window of items containing `selectedIndex` such that
@@ -380,10 +417,15 @@ export class SelectList implements Component, MouseRoutable {
 		isSelected: boolean,
 		width: number,
 		primaryColumnWidth: number,
+		iconColumnWidth: number,
 	): SelectItemLayout {
 		const cursor = this.theme.symbols?.cursor ?? DEFAULT_CURSOR_SYMBOL;
 		const prefix = isSelected ? `${cursor} ` : padding(visibleWidth(cursor) + 1);
-		const prefixWidth = visibleWidth(prefix);
+		// Icon column: every row reserves the same width so labels stay aligned
+		// whether or not an individual item carries an icon.
+		const iconWidth = item.icon ? visibleWidth(item.icon) : 0;
+		const iconCell = iconColumnWidth > 0 ? (item.icon ?? "") + padding(iconColumnWidth - iconWidth + 1) : "";
+		const prefixWidth = visibleWidth(prefix) + (iconColumnWidth > 0 ? iconColumnWidth + 1 : 0);
 		const descriptionSingleLine = item.description ? sanitizeSingleLine(item.description) : undefined;
 
 		if (descriptionSingleLine && width > 40) {
@@ -399,6 +441,7 @@ export class SelectList implements Component, MouseRoutable {
 				return {
 					kind: "description",
 					prefix,
+					iconCell,
 					truncatedValue,
 					spacing,
 					descriptionSingleLine,
@@ -413,11 +456,20 @@ export class SelectList implements Component, MouseRoutable {
 		return {
 			kind: "primary",
 			prefix,
+			iconCell,
 			truncatedValue,
 			spacing: "",
 		};
 	}
 
+	#getIconColumnWidth(): number {
+		let widest = 0;
+		for (const item of this.#filteredItems) {
+			if (item.icon) widest = Math.max(widest, visibleWidth(item.icon));
+		}
+		return widest;
+	}
+
 	#getPrimaryColumnWidth(): number {
 		const { min, max } = this.#getPrimaryColumnBounds();
 		const widestPrimary = this.#filteredItems.reduce((widest, item) => {

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/keybindings.ts

@@ -27,6 +27,7 @@ export interface Keybindings {
 	"tui.editor.yank": true;
 	"tui.editor.yankPop": true;
 	"tui.editor.undo": true;
+	"tui.editor.spellingSuggestions": true;
 	// Generic input actions
 	"tui.input.newLine": true;
 	"tui.input.submit": true;
@@ -118,6 +119,10 @@ export const TUI_KEYBINDINGS = {
 	"tui.editor.yank": { defaultKeys: "ctrl+y", description: "Yank" },
 	"tui.editor.yankPop": { defaultKeys: "alt+y", description: "Yank pop" },
 	"tui.editor.undo": { defaultKeys: ["ctrl+-", "ctrl+_"], description: "Undo" },
+	"tui.editor.spellingSuggestions": {
+		defaultKeys: "ctrl+.",
+		description: "Show spelling replacements",
+	},
 	"tui.input.newLine": { defaultKeys: ["shift+enter", "ctrl+j"], description: "Insert newline" },
 	"tui.input.submit": { defaultKeys: "enter", description: "Submit input" },
 	"tui.input.tab": { defaultKeys: "tab", description: "Tab / autocomplete" },

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;