@linxiraos/pi-tui 1.1.26 → 1.2.0

package/src/utils.d.ts

@@ -26,6 +26,12 @@ export interface TextSizingOptions {
  */
 export declare function encodeTextSized(text: string, options?: TextSizingOptions): string;
 export declare function sliceWithWidth(line: string, startCol: number, length: number, strict?: boolean | null): SliceResult;
+/**
+ * Hard-wrap one literal terminal row without trimming spaces or splitting graphemes.
+ * An oversized grapheme is emitted intact even when it exceeds the requested width.
+ * Zero-cell rows remain one empty row, matching restored-terminal reflow.
+ */
+export declare function wrapLiteralLine(line: string, width: number): string[];
 export declare function truncateToWidth(text: string, maxWidth: number, ellipsisKind?: Ellipsis | null | "", pad?: boolean | null): string;
 export declare function wrapTextWithAnsi(text: string, width: number): string[];
 export declare function extractSegments(line: string, beforeEnd: number, afterStart: number, afterLen: number, strictAfter: boolean): ExtractSegmentsResult;

package/src/utils.ts

@@ -154,6 +154,25 @@ export function sliceWithWidth(line: string, startCol: number, length: number, s
 	return nativeSliceWithWidth(line, startCol, length, strict ?? null, DEFAULT_TAB_WIDTH);
 }
 
+/**
+ * Hard-wrap one literal terminal row without trimming spaces or splitting graphemes.
+ * An oversized grapheme is emitted intact even when it exceeds the requested width.
+ * Zero-cell rows remain one empty row, matching restored-terminal reflow.
+ */
+export function wrapLiteralLine(line: string, width: number): string[] {
+	const columns = Math.max(1, width);
+	const lineWidth = visibleWidth(line);
+	if (lineWidth === 0) return [""];
+	const rows: string[] = [];
+	for (let column = 0; column < lineWidth;) {
+		let slice = sliceWithWidth(line, column, columns, true);
+		if (slice.width === 0) slice = sliceWithWidth(line, column, columns);
+		rows.push(slice.text);
+		column += Math.max(1, slice.width);
+	}
+	return rows;
+}
+
 export function truncateToWidth(
 	text: string,
 	maxWidth: number,

package/src/vim.d.ts

@@ -8,8 +8,8 @@
  * This is a usable subset of Vim, not a reimplementation of it (see issue #3299): Normal and Visual
  * modes, the common motions, and operators built from those motions.
  */
-export type VimMode = "insert" | "normal" | "visual" | "visual-line";
-export type VimOperator = "d" | "y" | "c";
+export type VimMode = "insert" | "normal" | "visual" | "visual-line" | "replace";
+export type VimOperator = "d" | "y" | "c" | ">" | "<";
 export interface VimPosition {
     line: number;
     col: number;
@@ -50,6 +50,20 @@ export type VimCommand = {
     count: number;
 } | {
     kind: "undo";
+} | {
+    kind: "replace";
+    from: VimPosition;
+    to: VimPosition;
+    text: string;
+} | {
+    kind: "join";
+    fromLine: number;
+    lines: number;
+} | {
+    kind: "indent";
+    fromLine: number;
+    toLine: number;
+    out: boolean;
 };
 /** Start offset of the grapheme after `col`, clamped to `text.length`. */
 export declare function nextGraphemeStart(text: string, col: number): number;
@@ -62,11 +76,11 @@ export declare class VimState {
     mode: VimMode;
     /** Fixed end of a Visual selection; the cursor is the moving end. */
     anchor: VimPosition | null;
-    /** True while a count, operator, `g`, or text-object prefix is half-typed — Escape cancels it. */
+    /** True while a count, operator, `g`, text-object, find, or `r` prefix is half-typed — Escape cancels it. */
     get pending(): boolean;
     /**
-     * The half-typed command as Vim would echo it (`"2"`, `"d"`, `"2d"`, `"di"`) — empty when
-     * nothing is pending. Hosts render this next to the mode so a partially entered operator is
+     * The half-typed command as Vim would echo it (`"2"`, `"d"`, `"2d"`, `"di"`, `"df"`, `"r"`) — empty
+     * when nothing is pending. Hosts render this next to the mode so a partially entered operator is
      * visible instead of silently swallowing the next keystroke.
      */
     get pendingText(): string;

package/src/vim.ts

@@ -11,9 +11,9 @@ import { getSegmenter, moveWordLeft, moveWordRight } from "./utils";
  * modes, the common motions, and operators built from those motions.
  */
 
-export type VimMode = "insert" | "normal" | "visual" | "visual-line";
+export type VimMode = "insert" | "normal" | "visual" | "visual-line" | "replace";
 
-export type VimOperator = "d" | "y" | "c";
+export type VimOperator = "d" | "y" | "c" | ">" | "<";
 
 export interface VimPosition {
 	line: number;
@@ -38,7 +38,10 @@ export type VimCommand =
 	| { kind: "delete"; from: VimPosition; to: VimPosition; linewise: boolean; insert: boolean }
 	| { kind: "openLine"; below: boolean }
 	| { kind: "paste"; after: boolean; count: number }
-	| { kind: "undo" };
+	| { kind: "undo" }
+	| { kind: "replace"; from: VimPosition; to: VimPosition; text: string }
+	| { kind: "join"; fromLine: number; lines: number }
+	| { kind: "indent"; fromLine: number; toLine: number; out: boolean };
 
 const segmenter = getSegmenter();
 
@@ -75,6 +78,35 @@ function firstNonBlank(text: string): number {
 	}
 	return 0;
 }
+function findPendingKey(pending: { forward: boolean; till: boolean } | null): string {
+	if (!pending) return "";
+	return pending.till ? (pending.forward ? "t" : "T") : pending.forward ? "f" : "F";
+}
+
+/**
+ * Column of the `count`th grapheme equal to `target`, searching strictly after `fromCol` when
+ * `forward` and strictly before it otherwise. Line-local, like Vim's `f`/`F`.
+ */
+function findGrapheme(text: string, fromCol: number, target: string, forward: boolean, count: number): number | null {
+	if (count < 1 || target.length === 0) return null;
+	const segs = [...segmenter.segment(text)];
+	let here = -1;
+	for (let i = 0; i < segs.length; i++) {
+		if (segs[i]!.index <= fromCol) here = i;
+		else break;
+	}
+	let seen = 0;
+	if (forward) {
+		for (let i = here + 1; i < segs.length; i++) {
+			if (segs[i]!.segment === target && ++seen === count) return segs[i]!.index;
+		}
+	} else {
+		for (let i = here - 1; i >= 0; i--) {
+			if (segs[i]!.segment === target && ++seen === count) return segs[i]!.index;
+		}
+	}
+	return null;
+}
 
 /** Vim's `w`: `moveWordRight` stops at the end of the current word, so skip the gap that follows. */
 function wordForward(text: string, col: number): number {
@@ -157,11 +189,7 @@ function wordObject(text: string, col: number, around: boolean, big: boolean, co
  * leading run when there is none.
  */
 function quoteObject(text: string, col: number, quote: string, around: boolean): [number, number] | null {
-	const marks: number[] = [];
-	for (let i = 0; i < text.length; i++) {
-		if (text.charAt(i) === "\\") i++;
-		else if (text.charAt(i) === quote) marks.push(i);
-	}
+	const marks = quoteMarks(text, quote);
 	for (let p = 0; p + 1 < marks.length; p += 2) {
 		const open = marks[p]!;
 		const close = marks[p + 1]!;
@@ -254,6 +282,113 @@ function paragraphObject(buf: VimBuffer, around: boolean): TextObjectRange {
 	return { from: { line: first, col: 0 }, to: { line: end, col: (buf.lines[end] ?? "").length }, linewise: true };
 }
 
+const BRACKET_MATCH: Record<string, { mate: string; forward: boolean }> = {
+	"(": { mate: ")", forward: true },
+	")": { mate: "(", forward: false },
+	"[": { mate: "]", forward: true },
+	"]": { mate: "[", forward: false },
+	"{": { mate: "}", forward: true },
+	"}": { mate: "{", forward: false },
+};
+
+/** Quote columns, skipping a backslash and the character after it, same as `i"`/`a"`. */
+function quoteMarks(text: string, quote: string): number[] {
+	const marks: number[] = [];
+	for (let i = 0; i < text.length; i++) {
+		if (text.charAt(i) === "\\") i++;
+		else if (text.charAt(i) === quote) marks.push(i);
+	}
+	return marks;
+}
+
+function quoteMate(marks: readonly number[], col: number): number | null {
+	for (let p = 0; p + 1 < marks.length; p += 2) {
+		const open = marks[p]!;
+		const close = marks[p + 1]!;
+		if (col === open) return close;
+		if (col === close) return open;
+	}
+	return null;
+}
+
+/** Column of the match for `%`: the next bracket or quote on this line, then its pair. */
+function matchDelimiter(buf: VimBuffer): VimPosition | null {
+	const line = buf.lines[buf.cursorLine] ?? "";
+	const quotes = {
+		'"': quoteMarks(line, '"'),
+		"'": quoteMarks(line, "'"),
+	};
+	const quoteAt = (col: number): '"' | "'" | null =>
+		quotes['"'].includes(col) ? '"' : quotes["'"].includes(col) ? "'" : null;
+	let col = buf.cursorCol;
+	while (col < line.length && BRACKET_MATCH[line.charAt(col)] === undefined && quoteAt(col) === null) col++;
+	const quote = quoteAt(col);
+	if (quote) {
+		const mate = quoteMate(quotes[quote], col);
+		return mate === null ? null : { line: buf.cursorLine, col: mate };
+	}
+	const spec = BRACKET_MATCH[line.charAt(col)];
+	if (!spec) return null;
+	const { text, cursor } = flatten({ lines: buf.lines, cursorLine: buf.cursorLine, cursorCol: col });
+	const open = spec.forward ? line.charAt(col) : spec.mate;
+	const close = spec.forward ? spec.mate : line.charAt(col);
+	let depth = 0;
+	let match = -1;
+	if (spec.forward) {
+		for (let i = cursor + 1; i < text.length; i++) {
+			const ch = text.charAt(i);
+			if (ch === open) depth++;
+			else if (ch === close) {
+				if (depth === 0) {
+					match = i;
+					break;
+				}
+				depth--;
+			}
+		}
+	} else {
+		for (let i = cursor - 1; i >= 0; i--) {
+			const ch = text.charAt(i);
+			if (ch === close) depth++;
+			else if (ch === open) {
+				if (depth === 0) {
+					match = i;
+					break;
+				}
+				depth--;
+			}
+		}
+	}
+	return match < 0 ? null : offsetToPos(buf.lines, match);
+}
+
+function isParagraphBlank(lines: readonly string[], line: number): boolean {
+	return (lines[line] ?? "").trim() === "";
+}
+
+/** Line `{`/`}` land on. A missing boundary stays on the first or last line. */
+function paragraphBoundary(lines: readonly string[], line: number, forward: boolean): number {
+	const last = lines.length - 1;
+	if (last < 0) return 0;
+	let i = Math.max(0, Math.min(line, last));
+	if (forward) {
+		if (i < last && !isParagraphBlank(lines, i)) {
+			while (i < last && !isParagraphBlank(lines, i + 1)) i++;
+			return i < last ? i + 1 : last;
+		}
+		while (i < last && isParagraphBlank(lines, i)) i++;
+		while (i < last && !isParagraphBlank(lines, i)) i++;
+		return i;
+	}
+	if (i > 0 && !isParagraphBlank(lines, i)) {
+		while (i > 0 && !isParagraphBlank(lines, i - 1)) i--;
+		return i > 0 ? i - 1 : 0;
+	}
+	while (i > 0 && isParagraphBlank(lines, i)) i--;
+	while (i > 0 && !isParagraphBlank(lines, i - 1)) i--;
+	return i > 0 ? i - 1 : 0;
+}
+
 interface Motion {
 	to: VimPosition;
 	/** Inclusive motions cover the grapheme under `to` when used with an operator. */
@@ -271,6 +406,13 @@ export class VimState {
 	#pendingG = false;
 	/** `i` or `a` typed after an operator or in Visual mode — waiting for the object key. */
 	#textObject: "i" | "a" | null = null;
+	/** `f`/`F`/`t`/`T` waiting for the target grapheme. */
+	#findPending: { forward: boolean; till: boolean } | null = null;
+	/** Last find attempt, so `;` repeats it and `,` reverses it. */
+	#lastFind: { forward: boolean; till: boolean; target: string } | null = null;
+	/** `r` waiting for the replacement grapheme. */
+	#replaceChar = false;
+
 	/**
 	 * Vim's "desired column": `j`/`k` remember the column you started from, so descending through a
 	 * short line and back out returns to it instead of collapsing permanently. `null` means the
@@ -279,18 +421,25 @@ export class VimState {
 	 */
 	#desiredCol: number | null = null;
 
-	/** True while a count, operator, `g`, or text-object prefix is half-typed — Escape cancels it. */
+	/** True while a count, operator, `g`, text-object, find, or `r` prefix is half-typed — Escape cancels it. */
 	get pending(): boolean {
-		return this.#count.length > 0 || this.#operator !== null || this.#pendingG || this.#textObject !== null;
+		return (
+			this.#count.length > 0 ||
+			this.#operator !== null ||
+			this.#pendingG ||
+			this.#textObject !== null ||
+			this.#findPending !== null ||
+			this.#replaceChar
+		);
 	}
 
 	/**
-	 * The half-typed command as Vim would echo it (`"2"`, `"d"`, `"2d"`, `"di"`) — empty when
-	 * nothing is pending. Hosts render this next to the mode so a partially entered operator is
+	 * The half-typed command as Vim would echo it (`"2"`, `"d"`, `"2d"`, `"di"`, `"df"`, `"r"`) — empty
+	 * when nothing is pending. Hosts render this next to the mode so a partially entered operator is
 	 * visible instead of silently swallowing the next keystroke.
 	 */
 	get pendingText(): string {
-		return `${this.#count}${this.#operator ?? ""}${this.#pendingG ? "g" : ""}${this.#textObject ?? ""}`;
+		return `${this.#count}${this.#operator ?? ""}${this.#pendingG ? "g" : ""}${this.#textObject ?? ""}${findPendingKey(this.#findPending)}${this.#replaceChar ? "r" : ""}`;
 	}
 
 	get visual(): boolean {
@@ -302,6 +451,7 @@ export class VimState {
 		this.anchor = null;
 		this.#desiredCol = null;
 		this.#clearPending();
+		this.#lastFind = null;
 	}
 
 	#clearPending(): void {
@@ -309,6 +459,8 @@ export class VimState {
 		this.#operator = null;
 		this.#pendingG = false;
 		this.#textObject = null;
+		this.#findPending = null;
+		this.#replaceChar = false;
 	}
 
 	#takeCount(): number {
@@ -334,6 +486,46 @@ export class VimState {
 	handleKey(key: string, buf: VimBuffer): VimCommand[] | null {
 		if (key === "escape") return this.#handleEscape(buf);
 		if (this.mode === "insert") return null;
+		// The character after `f`/`t` is the target, including digits. Resolve it before the count prefix.
+		if (this.#findPending) {
+			const spec = this.#findPending;
+			this.#findPending = null;
+			this.#desiredCol = null;
+			this.#lastFind = { ...spec, target: key };
+			const count = this.#count.length > 0 ? Math.max(1, Number.parseInt(this.#count, 10)) : 1;
+			const motion = this.#seek(key, buf, spec, count);
+			if (!motion) {
+				this.#operator = null;
+				this.#count = "";
+				return [];
+			}
+			return this.#applyMotion(buf, motion);
+		}
+		if (this.#replaceChar) {
+			this.#replaceChar = false;
+			const count = this.#count.length > 0 ? Math.max(1, Number.parseInt(this.#count, 10)) : 1;
+			const line = buf.lines[buf.cursorLine] ?? "";
+			// One segmenter pass: stepping with `nextGraphemeStart` would rescan the line per grapheme.
+			let end = -1;
+			let taken = 0;
+			for (const seg of segmenter.segment(line)) {
+				if (seg.index < buf.cursorCol) continue;
+				if (++taken === count) {
+					end = seg.index + seg.segment.length;
+					break;
+				}
+			}
+			this.#count = "";
+			if (end < 0) return [];
+			return [
+				{
+					kind: "replace",
+					from: { line: buf.cursorLine, col: buf.cursorCol },
+					to: { line: buf.cursorLine, col: end },
+					text: key.repeat(count),
+				},
+			];
+		}
 
 		// Count prefix. `0` is the line-start motion unless it extends a count already being typed.
 		if ((key >= "1" && key <= "9") || (key === "0" && this.#count.length > 0)) {
@@ -364,6 +556,21 @@ export class VimState {
 			this.#textObject = key;
 			return [];
 		}
+		if (key === "f" || key === "F" || key === "t" || key === "T") {
+			this.#desiredCol = null;
+			this.#findPending = { forward: key === "f" || key === "t", till: key === "t" || key === "T" };
+			return [];
+		}
+		if ((key === "r" || key === "R") && this.#operator === null && !this.visual) {
+			this.#desiredCol = null;
+			if (key === "R") {
+				this.#takeCount();
+				this.mode = "replace";
+				return [{ kind: "mode", mode: "replace" }];
+			}
+			this.#replaceChar = true;
+			return [];
+		}
 
 		// Only consecutive `j`/`k` carry the desired column; anything else re-anchors it. Counts and
 		// the `g` prefix returned above, so `2j` still continues an established column.
@@ -388,7 +595,7 @@ export class VimState {
 				{ kind: "move", to: this.#clampNormal(buf, cursorOf(buf)) },
 			];
 		}
-		if (this.mode === "insert") {
+		if (this.mode === "insert" || this.mode === "replace") {
 			this.mode = "normal";
 			const text = buf.lines[buf.cursorLine] ?? "";
 			return [
@@ -454,6 +661,31 @@ export class VimState {
 				for (let i = 0; i < count; i++) col = wordEnd(line, col);
 				return { to: at(col), inclusive: true, linewise: false };
 			}
+			case "%": {
+				// `{count}%` jumps to that percentage of the buffer, linewise, like Vim.
+				if (this.#count.length > 0) {
+					if (count > 100) return null;
+					const target = Math.max(0, Math.floor((count * buf.lines.length + 99) / 100) - 1);
+					const text = buf.lines[target] ?? "";
+					return { to: { line: target, col: firstNonBlank(text) }, inclusive: false, linewise: true };
+				}
+				const to = matchDelimiter(buf);
+				return to === null ? null : { to, inclusive: true, linewise: false };
+			}
+			case "{":
+			case "}": {
+				let line = buf.cursorLine;
+				for (let n = 0; n < count; n++) {
+					const next = paragraphBoundary(buf.lines, line, key === "}");
+					if (next === line) break;
+					line = next;
+				}
+				const text = buf.lines[line] ?? "";
+				// No blank line ahead: Vim parks at the end of the buffer, not column 0. A bare move
+				// clamps back onto the last grapheme; an operator still covers the rest of the line.
+				const atBufferEnd = key === "}" && line === buf.lines.length - 1 && text.trim() !== "";
+				return { to: { line, col: atBufferEnd ? text.length : 0 }, inclusive: false, linewise: false };
+			}
 			case "G": {
 				const target = this.#count.length > 0 ? count - 1 : buf.lines.length - 1;
 				return {
@@ -462,23 +694,66 @@ export class VimState {
 					linewise: true,
 				};
 			}
+			case ";":
+			case ",":
+				return this.#repeatFind(key === ";", buf, count);
 			default:
 				return null;
 		}
 	}
 
+	#repeatFind(sameDirection: boolean, buf: VimBuffer, count: number): Motion | null {
+		const last = this.#lastFind;
+		if (!last) return null;
+		const forward = sameDirection ? last.forward : !last.forward;
+		const text = buf.lines[buf.cursorLine] ?? "";
+		// A till lands beside its target, so repeating from the cursor rediscovers that same target.
+		const fromCol = last.till
+			? forward
+				? nextGraphemeStart(text, buf.cursorCol)
+				: prevGraphemeStart(text, buf.cursorCol)
+			: buf.cursorCol;
+		return this.#seek(last.target, buf, { forward, till: last.till }, count, fromCol);
+	}
+
+	/**
+	 * `f`/`F` land on the match and include it. `t`/`T` land on the adjacent grapheme and include
+	 * that grapheme, so the operator stops short of the target. A till that would not move fails.
+	 */
+	#seek(
+		target: string,
+		buf: VimBuffer,
+		spec: { forward: boolean; till: boolean },
+		count: number,
+		fromCol = buf.cursorCol,
+	): Motion | null {
+		const text = buf.lines[buf.cursorLine] ?? "";
+		const match = findGrapheme(text, fromCol, target, spec.forward, count);
+		if (match === null) return null;
+		const land = spec.till ? (spec.forward ? prevGraphemeStart(text, match) : nextGraphemeStart(text, match)) : match;
+		if (land === buf.cursorCol) return null;
+		return { to: { line: buf.cursorLine, col: land }, inclusive: true, linewise: false };
+	}
+
 	/** Turn a resolved motion into either a cursor move, a selection extension, or an operator range. */
 	#applyMotion(buf: VimBuffer, motion: Motion): VimCommand[] {
 		const operator = this.#operator;
 		this.#operator = null;
 		this.#takeCount();
+		if (operator === ">" || operator === "<") {
+			const fromLine = Math.min(buf.cursorLine, motion.to.line);
+			const toLine = Math.max(buf.cursorLine, motion.to.line);
+			return [{ kind: "indent", fromLine, toLine, out: operator === "<" }];
+		}
 
 		if (operator === null) {
 			// `$` parks on the last grapheme in Normal mode but must still be able to select the
-			// final character in Visual mode, where the cursor is allowed one past it.
-			const to = this.visual
-				? { line: motion.to.line, col: Math.min(motion.to.col, (buf.lines[motion.to.line] ?? "").length) }
-				: this.#clampNormal(buf, motion.to);
+			// final character in Visual mode, where the cursor is allowed one past it. Replace mode
+			// may also sit past the end, so typing there appends instead of overwriting the last grapheme.
+			const to =
+				this.visual || this.mode === "replace"
+					? { line: motion.to.line, col: Math.min(motion.to.col, (buf.lines[motion.to.line] ?? "").length) }
+					: this.#clampNormal(buf, motion.to);
 			return [{ kind: "move", to }];
 		}
 
@@ -494,6 +769,11 @@ export class VimState {
 	}
 
 	#operate(operator: VimOperator, from: VimPosition, to: VimPosition, linewise: boolean): VimCommand[] {
+		if (operator === ">" || operator === "<") {
+			const fromLine = Math.min(from.line, to.line);
+			const toLine = Math.max(from.line, to.line);
+			return [{ kind: "indent", fromLine, toLine, out: operator === "<" }];
+		}
 		if (operator === "y") {
 			return [
 				{ kind: "yank", from, to, linewise },
@@ -683,6 +963,28 @@ export class VimState {
 			case "u":
 				this.#takeCount();
 				return [{ kind: "undo" }];
+			case "J": {
+				if (this.#operator !== null) {
+					this.#clearPending();
+					return [];
+				}
+				return [{ kind: "join", fromLine: buf.cursorLine, lines: Math.max(2, this.#takeCount()) }];
+			}
+			case ">":
+			case "<": {
+				if (this.#operator === key) {
+					const span = this.#takeCount();
+					const last = Math.min(buf.cursorLine + span - 1, buf.lines.length - 1);
+					this.#operator = null;
+					return [{ kind: "indent", fromLine: buf.cursorLine, toLine: last, out: key === "<" }];
+				}
+				if (this.#operator !== null) {
+					this.#clearPending();
+					return [];
+				}
+				this.#operator = key;
+				return [];
+			}
 			default:
 				// Normal mode swallows unknown printable keys rather than typing them into the buffer.
 				this.#clearPending();
@@ -727,6 +1029,19 @@ export class VimState {
 				const commands = this.#operate(operator, from, to, linewise);
 				return operator === "c" ? commands : [...commands, { kind: "mode", mode: "normal" }];
 			}
+			case ">":
+			case "<":
+			case "J": {
+				const { from, to } = visualRange(buf, anchor, linewise);
+				this.#clearPending();
+				this.anchor = null;
+				this.mode = "normal";
+				const edit: VimCommand =
+					key === "J"
+						? { kind: "join", fromLine: from.line, lines: Math.max(2, to.line - from.line + 1) }
+						: { kind: "indent", fromLine: from.line, toLine: to.line, out: key === "<" };
+				return [edit, { kind: "mode", mode: "normal" }];
+			}
 			default:
 				this.#clearPending();
 				return [];

package/src/windows-input-mode.d.ts

@@ -16,10 +16,26 @@
  * terminal sends; chords legacy encoding loses (modified Enter/Tab/Escape,
  * Ctrl+Shift+letter, …) translate to kitty CSI-u, which key matching already
  * parses.
+ *
+ * A host terminal that writes VT instead of key records (any ConPTY host
+ * besides Windows Terminal's native path) reaches us as one `Vk = 0` text
+ * record per byte: Alt+Up arrives as `ESC`, `[`, `1`, `;`, `3`, `A`. Those
+ * bytes are reassembled into the escape sequence they spell; delivering them
+ * one at a time turns every such key into a bare Escape plus typed garbage.
+ */
+/**
+ * Stateful decoder: joins UTF-16 surrogate halves that arrive as separate
+ * records, and reassembles VT escape sequences relayed as text records.
  */
-/** Stateful decoder: joins UTF-16 surrogate halves that arrive as separate records. */
 export declare class Win32InputModeDecoder {
     #private;
+    /** Whether relayed VT text is held waiting for the rest of its sequence. */
+    get hasPendingSequence(): boolean;
+    /**
+     * Release held VT text as-is. The caller invokes this once no further bytes
+     * arrived in time, so a lone relayed ESC still acts as the Escape key.
+     */
+    flushPendingSequence(): string[];
     /**
      * Translate one stdin sequence. Returns `undefined` when `data` is not a
      * win32-input-mode record (pass it through unchanged), otherwise the key
@@ -35,3 +51,19 @@ export declare class Win32InputModeDecoder {
      */
     decodePaste(content: string): string;
 }
+/**
+ * Restores paste delimiters that a Windows console host emitted as individual
+ * win32-input-mode key records before StdinBuffer searches for the delimiters.
+ * Non-matching records remain untouched for normal key and paste decoding.
+ */
+export declare class Win32PasteMarkerNormalizer {
+    #private;
+    /**
+     * `onExpired` runs after held records are released because their wait timed
+     * out, so a downstream holder can treat the same wait as already elapsed.
+     */
+    constructor(onInput: (data: string) => void, onExpired?: () => void);
+    process(data: string): void;
+    /** Release an incomplete marker as its original key records. */
+    flush(): void;
+}