@gajae-code/tui 0.13.1 → 0.13.3

package/src/components/select-list.ts

@@ -39,6 +39,8 @@ export interface SelectListTheme {
 	symbols: SymbolTheme;
 }
 
+export type SelectListThemeSource = SelectListTheme | (() => SelectListTheme);
+
 export interface SelectListTruncatePrimaryContext {
 	text: string;
 	maxWidth: number;
@@ -67,7 +69,7 @@ export class SelectList implements Component {
 	constructor(
 		private readonly items: ReadonlyArray<SelectItem>,
 		private readonly maxVisible: number,
-		private readonly theme: SelectListTheme,
+		private readonly themeSource: SelectListThemeSource,
 		private readonly layout: SelectListLayoutOptions = {},
 	) {
 		this.#filteredItems = items;
@@ -114,11 +116,12 @@ export class SelectList implements Component {
 	}
 
 	render(width: number): string[] {
+		const theme = this.#theme();
 		const lines: string[] = [];
 
 		// If no items match filter, show message
 		if (this.#filteredItems.length === 0) {
-			lines.push(truncateToWidth(this.theme.noMatch("  No matching commands"), Math.max(0, width), Ellipsis.Omit));
+			lines.push(truncateToWidth(theme.noMatch("  No matching commands"), Math.max(0, width), Ellipsis.Omit));
 			return lines;
 		}
 
@@ -146,12 +149,16 @@ export class SelectList implements Component {
 			const position = this.#selectedIndex >= 0 ? `${this.#selectedIndex + 1}` : "-";
 			const scrollText = `  (${position}/${this.#filteredItems.length})`;
 			// Truncate if too long for terminal
-			lines.push(this.theme.scrollInfo(truncateToWidth(scrollText, width - 2, Ellipsis.Omit)));
+			lines.push(theme.scrollInfo(truncateToWidth(scrollText, width - 2, Ellipsis.Omit)));
 		}
 
 		return lines;
 	}
 
+	#theme(): SelectListTheme {
+		return typeof this.themeSource === "function" ? this.themeSource() : this.themeSource;
+	}
+
 	handleInput(keyData: string): void {
 		const kb = getKeybindings();
 		if (this.#filteredItems.length === 0) {
@@ -193,9 +200,8 @@ export class SelectList implements Component {
 		descriptionSingleLine: string | undefined,
 		primaryColumnWidth: number,
 	): string {
-		const prefix = isSelected
-			? `${this.theme.symbols.cursor} `
-			: padding(visibleWidth(this.theme.symbols.cursor) + 1);
+		const theme = this.#theme();
+		const prefix = isSelected ? `${theme.symbols.cursor} ` : padding(visibleWidth(theme.symbols.cursor) + 1);
 		const prefixWidth = visibleWidth(prefix);
 
 		if (descriptionSingleLine && width > 40) {
@@ -210,13 +216,13 @@ export class SelectList implements Component {
 			if (remainingWidth > MIN_DESCRIPTION_WIDTH) {
 				const truncatedDesc = truncateToWidth(descriptionSingleLine, remainingWidth, Ellipsis.Omit);
 				if (item.disabled) {
-					return this.theme.description(`${prefix}${truncatedValue}${spacing}${truncatedDesc}`);
+					return theme.description(`${prefix}${truncatedValue}${spacing}${truncatedDesc}`);
 				}
 				if (isSelected) {
-					return this.theme.selectedText(`${prefix}${truncatedValue}${spacing}${truncatedDesc}`);
+					return theme.selectedText(`${prefix}${truncatedValue}${spacing}${truncatedDesc}`);
 				}
 
-				const descText = this.theme.description(spacing + truncatedDesc);
+				const descText = theme.description(spacing + truncatedDesc);
 				return prefix + truncatedValue + descText;
 			}
 		}
@@ -224,10 +230,10 @@ export class SelectList implements Component {
 		const maxWidth = width - prefixWidth - 2;
 		const truncatedValue = this.#truncatePrimary(item, isSelected, maxWidth, maxWidth);
 		if (item.disabled) {
-			return this.theme.description(`${prefix}${truncatedValue}`);
+			return theme.description(`${prefix}${truncatedValue}`);
 		}
 		if (isSelected) {
-			return this.theme.selectedText(`${prefix}${truncatedValue}`);
+			return theme.selectedText(`${prefix}${truncatedValue}`);
 		}
 
 		return prefix + truncatedValue;

package/src/stdin-buffer.ts

@@ -278,12 +278,33 @@ function continuesAsStringTerminator(remaining: string, index: number): boolean
 	return afterEsc === undefined || afterEsc === "\\";
 }
 
-function extractCompleteSequences(buffer: string): { sequences: string[]; remainder: string } {
+/**
+ * A buffered run of nothing but ESC bytes is N real Escape key presses, not an
+ * Option-as-Meta prefix. Emitting the run as one sequence parses as the unbound
+ * `alt+escape` and silently swallows every press, so any path that gives up on a
+ * continuation must split the run first.
+ */
+function splitResolvedEscapeRun(buffer: string): string[] {
+	return /^\x1b{2,}$/.test(buffer) ? buffer.split("") : [buffer];
+}
+
+/**
+ * `knownEscapeRunLength` is the number of leading ESC bytes a previous call
+ * already measured and returned as an all-Escape remainder. Resuming the scan
+ * there keeps a run delivered across many small reads linear overall instead of
+ * re-walking the whole accumulated prefix on every chunk.
+ */
+function extractCompleteSequences(
+	buffer: string,
+	knownEscapeRunLength = 0,
+): { sequences: string[]; remainder: string; escapeRunRemainder: number } {
 	const sequences: string[] = [];
 	let pos = 0;
 
 	while (pos < buffer.length) {
-		const remaining = buffer.slice(pos);
+		// Slicing at 0 would copy the whole buffer on every call, which is the
+		// dominant cost when a long Escape run arrives as many single-byte reads.
+		const remaining = pos === 0 ? buffer : buffer.slice(pos);
 
 		// Try to extract a sequence starting at this position
 		if (remaining.startsWith(ESC)) {
@@ -299,6 +320,37 @@ function extractCompleteSequences(buffer: string): { sequences: string[]; remain
 				pos += 2;
 				continue;
 			}
+			// Measure the ESC run once. Testing the whole suffix on every iteration
+			// while the cut below advances only two bytes made a long run quadratic.
+			let runLength = pos === 0 ? Math.max(knownEscapeRunLength, 1) : 1;
+			while (runLength < remaining.length && remaining[runLength] === ESC) runLength++;
+			// A trailing run of nothing but ESC bytes is ambiguous: the next chunk
+			// may still deliver the continuation that turns its last ESC into a Meta
+			// prefix (ESC ESC ESC + "[A" is bare Escape then Option+Up). Splitting it
+			// now would emit an extra Escape and downgrade the wrapped key to a plain
+			// one, firing the destructive double-Escape gesture. Keep the whole run
+			// buffered; the flush timeout emits it as individual Escape presses.
+			if (runLength === remaining.length) {
+				// Only the last two bytes of the run are still ambiguous: a Meta prefix
+				// is at most ESC ESC, so any earlier ESC is already a settled press.
+				// Emitting them now keeps the retained buffer bounded; holding the whole
+				// run made every later read rescan it, which is quadratic for a long run
+				// delivered as many small chunks. Order of emitted presses is unchanged.
+				const settled = runLength - 2;
+				if (settled > 0) {
+					for (let index = 0; index < settled; index++) sequences.push(ESC);
+					return { sequences, remainder: remaining.slice(settled), escapeRunRemainder: 2 };
+				}
+				return { sequences, remainder: remaining, escapeRunRemainder: runLength };
+			}
+			// Only the final two ESC bytes can still form a Meta prefix for the
+			// continuation that follows the run; everything before them is a settled
+			// Escape press. Emitting them in one step keeps the walk linear.
+			if (runLength > 2) {
+				for (let index = 0; index < runLength - 2; index++) sequences.push(ESC);
+				pos += runLength - 2;
+				continue;
+			}
 			// Find the end of this escape sequence
 			let seqEnd = 1;
 			while (seqEnd <= remaining.length) {
@@ -315,7 +367,23 @@ function extractCompleteSequences(buffer: string): { sequences: string[]; remain
 					// here keeps an unterminated sequence from swallowing the next key.
 					// seqEnd === 1 is excluded so Meta sequences (ESC ESC) still parse.
 					if (remaining[seqEnd] === ESC && seqEnd >= 2 && !continuesAsStringTerminator(remaining, seqEnd)) {
-						sequences.push(candidate);
+						// A bare Escape may be followed in the same read by a Meta-wrapped
+						// sequence (ESC ESC ESC [ A). Keep the final Meta prefix intact;
+						// splitting all three ESC bytes would turn the wrapped arrow into a
+						// plain arrow after a destructive double-Escape gesture.
+						const trailing = remaining.slice(seqEnd);
+						if (/^\x1b+$/.test(candidate) && /^\x1b[^\x1b]/.test(trailing)) {
+							sequences.push(...candidate.slice(0, -1).split(""));
+							pos += seqEnd - 1;
+							break;
+						}
+						// A cut candidate of nothing but ESC bytes is real Escape key
+						// presses, not an Option-as-Meta prefix: a following ESC proves
+						// no continuation (like "[A") belongs to it. Emitting the pair
+						// as one sequence would parse as the unbound "alt+escape" and
+						// silently swallow both presses.
+						if (/^\x1b+$/.test(candidate)) sequences.push(...candidate.split(""));
+						else sequences.push(candidate);
 						pos += seqEnd;
 						break;
 					}
@@ -329,7 +397,7 @@ function extractCompleteSequences(buffer: string): { sequences: string[]; remain
 			}
 
 			if (seqEnd > remaining.length) {
-				return { sequences, remainder: remaining };
+				return { sequences, remainder: remaining, escapeRunRemainder: 0 };
 			}
 		} else {
 			// Not an escape sequence - take a single Unicode code point. Keep a
@@ -337,7 +405,7 @@ function extractCompleteSequences(buffer: string): { sequences: string[]; remain
 			// complete it.
 			const firstCodeUnit = remaining.charCodeAt(0);
 			if (isHighSurrogate(firstCodeUnit)) {
-				if (remaining.length === 1) return { sequences, remainder: remaining };
+				if (remaining.length === 1) return { sequences, remainder: remaining, escapeRunRemainder: 0 };
 				const secondCodeUnit = remaining.charCodeAt(1);
 				if (isLowSurrogate(secondCodeUnit)) {
 					sequences.push(remaining.slice(0, 2));
@@ -350,7 +418,7 @@ function extractCompleteSequences(buffer: string): { sequences: string[]; remain
 		}
 	}
 
-	return { sequences, remainder: "" };
+	return { sequences, remainder: "", escapeRunRemainder: 0 };
 }
 
 export type StdinBufferOptions = {
@@ -379,6 +447,9 @@ export type StdinBufferEventMap = {
  */
 export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	#buffer: string = "";
+	// Length of the leading all-Escape run already measured in #buffer, so a run
+	// arriving as many small reads is scanned once overall instead of per chunk.
+	#bufferedEscapeRunLength = 0;
 	#timeout?: NodeJS.Timeout;
 	readonly #timeoutMs: number;
 	#pasteMode: boolean = false;
@@ -486,6 +557,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		if (this.#pasteMode) {
 			this.#pasteBuffer += this.#buffer;
 			this.#buffer = "";
+			this.#bufferedEscapeRunLength = 0;
 
 			const endIndex = this.#pasteBuffer.indexOf(BRACKETED_PASTE_END);
 			if (endIndex !== -1) {
@@ -505,7 +577,11 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			return;
 		}
 
-		const startIndex = this.#buffer.indexOf(BRACKETED_PASTE_START);
+		// A known all-Escape prefix cannot contain the paste introducer, so start
+		// the scan just far enough back to catch a marker straddling the boundary.
+		// Rescanning the whole retained run on every read made a long run quadratic.
+		const pasteScanFrom = Math.max(0, this.#bufferedEscapeRunLength - BRACKETED_PASTE_START.length);
+		const startIndex = this.#buffer.indexOf(BRACKETED_PASTE_START, pasteScanFrom);
 		if (startIndex !== -1) {
 			if (startIndex > 0) {
 				const beforePaste = this.#buffer.slice(0, startIndex);
@@ -513,8 +589,12 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 				for (const sequence of result.sequences) {
 					this.#emitDataSequence(sequence);
 				}
+				// A bracketed paste start proves no Meta continuation is coming for a
+				// buffered Escape run, so resolve it into individual presses here too.
 				if (result.remainder.length > 0) {
-					this.#emitDataSequence(result.remainder);
+					for (const sequence of splitResolvedEscapeRun(result.remainder)) {
+						this.#emitDataSequence(sequence);
+					}
 				}
 			}
 
@@ -523,6 +603,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			this.#pasteMode = true;
 			this.#pasteBuffer = this.#buffer;
 			this.#buffer = "";
+			this.#bufferedEscapeRunLength = 0;
 
 			const endIndex = this.#pasteBuffer.indexOf(BRACKETED_PASTE_END);
 			if (endIndex !== -1) {
@@ -542,8 +623,11 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			return;
 		}
 
-		const result = extractCompleteSequences(this.#buffer);
+		const result = extractCompleteSequences(this.#buffer, this.#bufferedEscapeRunLength);
 		this.#buffer = result.remainder;
+		// Remember an all-Escape remainder so the next chunk resumes the run scan
+		// at its end rather than re-walking every byte received so far.
+		this.#bufferedEscapeRunLength = result.escapeRunRemainder;
 
 		for (const sequence of result.sequences) {
 			if (isSgrMousePrefix(sequence) && !isSgrMouseSequence(sequence)) continue;
@@ -574,11 +658,13 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			}
 			const remainder = suffix.slice(index);
 			this.#buffer = "";
+			this.#bufferedEscapeRunLength = 0;
 			this.#pendingKittyPrintableCodepoint = undefined;
 			if (remainder) this.process(remainder);
 			return;
 		}
 		this.#buffer = "";
+		this.#bufferedEscapeRunLength = 0;
 		this.#pendingKittyPrintableCodepoint = undefined;
 		this.#sgrQuarantine = true;
 		this.#sgrQuarantineBytes = suffix.length;
@@ -709,12 +795,23 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 
 		if (isSgrMousePrefix(this.#buffer)) {
 			this.#buffer = "";
+			this.#bufferedEscapeRunLength = 0;
 			this.#pendingKittyPrintableCodepoint = undefined;
 			return pendingMeta === undefined ? [] : [pendingMeta];
 		}
 
-		const sequences = pendingMeta === undefined ? [this.#buffer] : [pendingMeta, this.#buffer];
+		// A buffer of nothing but ESC bytes at flush time is N real Escape key
+		// presses that arrived faster than the flush window (tmux forwards a
+		// quick double-Esc as one "\x1b\x1b" chunk within escape-time). Keeping
+		// the pair atomic is only correct while a continuation can still turn it
+		// into an Option-as-Meta sequence (ESC ESC [ A); once the flush timeout
+		// fires, no continuation is coming, and emitting the pair as one
+		// sequence parses as the unbound "alt+escape" — silently swallowing
+		// both presses and breaking the double-Esc draft-clear gesture.
+		const flushedBuffer = splitResolvedEscapeRun(this.#buffer);
+		const sequences = pendingMeta === undefined ? flushedBuffer : [pendingMeta, ...flushedBuffer];
 		this.#buffer = "";
+		this.#bufferedEscapeRunLength = 0;
 		this.#pendingKittyPrintableCodepoint = undefined;
 		return sequences;
 	}
@@ -725,6 +822,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			this.#timeout = undefined;
 		}
 		this.#buffer = "";
+		this.#bufferedEscapeRunLength = 0;
 		this.#pasteMode = false;
 		this.#pasteBuffer = "";
 		this.#pendingKittyPrintableCodepoint = undefined;

package/src/terminal.ts

@@ -51,6 +51,10 @@ export function keyboardEnhancementEnabled(): boolean {
 	return $flag("GJC_TUI_KEYBOARD_PROTOCOL", true);
 }
 
+function isAppleTerminal(): boolean {
+	return $env.TERM_PROGRAM === "Apple_Terminal";
+}
+
 /**
  * Minimal terminal interface for TUI
  */
@@ -794,18 +798,18 @@ export class ProcessTerminal implements Terminal {
 		}
 		this.#safeWrite("\x1b[?u");
 		this.#stdinBuffer?.noteProbeIssued();
-		// Windows Terminal and conhost do not implement the Kitty keyboard
+		// Windows Terminal and Apple Terminal do not implement the Kitty keyboard
 		// protocol, so the query above never activates it there. They do honor the
-		// modifyOtherKeys fallback below — but that mode breaks Windows CJK/Hangul
-		// IME composition: Alt+Enter (and other chords) bypass the IME commit, so
-		// the syllable still being composed is never delivered to the app and the
+		// modifyOtherKeys fallback below — but that mode breaks CJK/Hangul IME
+		// composition: Alt+Enter (and other chords) bypass the IME commit, so the
+		// syllable still being composed is never delivered to the app and the
 		// action fires on empty text (e.g. queue-message no-ops unless the user
 		// types a trailing space to force a commit first). Skip the fallback on
-		// win32; legacy encodings still deliver Alt+Enter (ESC CR) and the newline
-		// chords, and IME composition works again. Opt back in with
+		// these terminals; legacy encodings still deliver Alt+Enter (ESC CR) and
+		// the newline chords, and IME composition works again. Opt back in with
 		// GJC_TUI_KEYBOARD_PROTOCOL=0 disabling all enhancement, or force-enable
-		// elsewhere if a Kitty-capable Windows terminal appears.
-		if (process.platform === "win32") {
+		// elsewhere if a Kitty-capable terminal appears.
+		if (process.platform === "win32" || isAppleTerminal()) {
 			return;
 		}
 		this.#modifyOtherKeysTimeout = setTimeout(() => {

package/src/tui.ts

@@ -349,15 +349,26 @@ export type SizeValue = number | `${number}%`;
 /** Parse a SizeValue into absolute value given a reference size */
 function parseSizeValue(value: SizeValue | undefined, referenceSize: number): number | undefined {
 	if (value === undefined) return undefined;
-	if (typeof value === "number") return value;
+	if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
 	// Parse percentage string like "50%"
 	const match = value.match(/^(\d+(?:\.\d+)?)%$/);
 	if (match) {
-		return Math.floor((referenceSize * parseFloat(match[1])) / 100);
+		const percent = Number.parseFloat(match[1]);
+		if (!Number.isFinite(percent)) return undefined;
+		const parsed = Math.floor((referenceSize * percent) / 100);
+		return Number.isFinite(parsed) ? parsed : undefined;
 	}
 	return undefined;
 }
 
+function finiteNumber(value: number | undefined, fallback: number): number {
+	return value !== undefined && Number.isFinite(value) ? value : fallback;
+}
+
+function finiteNonNegative(value: number | undefined, fallback = 0): number {
+	return Math.max(0, finiteNumber(value, fallback));
+}
+
 const DISABLED_ENV_VALUES = new Set(["0", "false", "off", "no"]);
 
 function envIsEnabled(value: string | undefined): boolean {
@@ -2480,10 +2491,10 @@ export class TUI extends Container {
 			typeof opt.margin === "number"
 				? { top: opt.margin, right: opt.margin, bottom: opt.margin, left: opt.margin }
 				: (opt.margin ?? {});
-		const marginTop = Math.max(0, margin.top ?? 0);
-		const marginRight = Math.max(0, margin.right ?? 0);
-		const marginBottom = Math.max(0, margin.bottom ?? 0);
-		const marginLeft = Math.max(0, margin.left ?? 0);
+		const marginTop = Math.min(finiteNonNegative(margin.top), Math.max(0, termHeight - 1));
+		const marginRight = Math.min(finiteNonNegative(margin.right), Math.max(0, termWidth - 1));
+		const marginBottom = Math.min(finiteNonNegative(margin.bottom), Math.max(0, termHeight - 1 - marginTop));
+		const marginLeft = Math.min(finiteNonNegative(margin.left), Math.max(0, termWidth - 1 - marginRight));
 
 		// Available space after margins
 		const availWidth = Math.max(1, termWidth - marginLeft - marginRight);
@@ -2492,14 +2503,15 @@ export class TUI extends Container {
 		// === Resolve width ===
 		let width = parseSizeValue(opt.width, termWidth) ?? Math.min(80, availWidth);
 		// Apply minWidth
-		if (opt.minWidth !== undefined) {
+		if (opt.minWidth !== undefined && Number.isFinite(opt.minWidth)) {
 			width = Math.max(width, opt.minWidth);
 		}
 		// Clamp to available space
 		width = Math.max(1, Math.min(width, availWidth));
 
 		// === Resolve maxHeight ===
-		let maxHeight = parseSizeValue(opt.maxHeight, termHeight);
+		const parsedMaxHeight = parseSizeValue(opt.maxHeight, termHeight);
+		let maxHeight = opt.maxHeight !== undefined && parsedMaxHeight === undefined ? availHeight : parsedMaxHeight;
 		// Clamp to available space
 		if (maxHeight !== undefined) {
 			maxHeight = Math.max(1, Math.min(maxHeight, availHeight));
@@ -2519,14 +2531,18 @@ export class TUI extends Container {
 				if (match) {
 					const maxRow = Math.max(0, availHeight - effectiveHeight);
 					const percent = parseFloat(match[1]) / 100;
-					row = marginTop + Math.floor(maxRow * percent);
+					row = Number.isFinite(percent)
+						? marginTop + Math.floor(maxRow * percent)
+						: this.#resolveAnchorRow(opt.anchor ?? "center", effectiveHeight, availHeight, marginTop);
 				} else {
 					// Invalid format, fall back to center
 					row = this.#resolveAnchorRow("center", effectiveHeight, availHeight, marginTop);
 				}
-			} else {
+			} else if (Number.isFinite(opt.row)) {
 				// Absolute row position
 				row = opt.row;
+			} else {
+				row = this.#resolveAnchorRow(opt.anchor ?? "center", effectiveHeight, availHeight, marginTop);
 			}
 		} else {
 			// Anchor-based (default: center)
@@ -2541,14 +2557,18 @@ export class TUI extends Container {
 				if (match) {
 					const maxCol = Math.max(0, availWidth - width);
 					const percent = parseFloat(match[1]) / 100;
-					col = marginLeft + Math.floor(maxCol * percent);
+					col = Number.isFinite(percent)
+						? marginLeft + Math.floor(maxCol * percent)
+						: this.#resolveAnchorCol(opt.anchor ?? "center", width, availWidth, marginLeft);
 				} else {
 					// Invalid format, fall back to center
 					col = this.#resolveAnchorCol("center", width, availWidth, marginLeft);
 				}
-			} else {
+			} else if (Number.isFinite(opt.col)) {
 				// Absolute column position
 				col = opt.col;
+			} else {
+				col = this.#resolveAnchorCol(opt.anchor ?? "center", width, availWidth, marginLeft);
 			}
 		} else {
 			// Anchor-based (default: center)
@@ -2557,8 +2577,8 @@ export class TUI extends Container {
 		}
 
 		// Apply offsets
-		if (opt.offsetY !== undefined) row += opt.offsetY;
-		if (opt.offsetX !== undefined) col += opt.offsetX;
+		row += finiteNumber(opt.offsetY, 0);
+		col += finiteNumber(opt.offsetX, 0);
 
 		// Clamp to terminal bounds (respecting margins)
 		row = Math.max(marginTop, Math.min(row, termHeight - marginBottom - effectiveHeight));
@@ -2648,6 +2668,9 @@ export class TUI extends Container {
 		// than the current content. Padding to it can cause the renderer to output hundreds/thousands of blank
 		// lines, effectively scrolling the terminal when an overlay is shown.
 		const workingHeight = Math.max(result.length, minLinesNeeded);
+		if (!Number.isFinite(workingHeight)) {
+			throw new Error("Overlay layout produced a non-finite working height");
+		}
 
 		// Extend result with empty lines if content is too short for overlay placement
 		while (result.length < workingHeight) {
@@ -4040,21 +4063,6 @@ export class TUI extends Container {
 			viewportRepaint(`content contraction changed viewport top (${prevViewportTop} -> ${nextLiveViewportTop})`);
 			return;
 		}
-		if (
-			appendedLines &&
-			nextLiveViewportTop > prevViewportTop &&
-			previousKittyPlacementSpans.some(placement =>
-				this.#kittyPlacementIntersectsRegion(placement, {
-					top: prevViewportTop,
-					bottom: prevViewportTop + height,
-				}),
-			)
-		) {
-			viewportRepaint(
-				`content append moved a Kitty placement viewport (${prevViewportTop} -> ${nextLiveViewportTop})`,
-			);
-			return;
-		}
 		if (distinctPostContractionRows) this.#scrollbackResumeViewportTop = undefined;
 		if (
 			appendedLines &&