@simon_he/vue-tui 0.0.5 → 0.0.7

package/dist/index.js

@@ -1,9 +1,9 @@
 import { isAbsolutePath, normalizePath, parsePathQuery, resolvePath, resolveUserPath as resolveUserPath$1, resolveUserPath$1 as resolveUserPath, stripTrailingSlash, suggestPaths, suggestPaths$1 } from "./path-suggest-CZQYJIIg.js";
-import process from "node:process";
+import process$1 from "node:process";
 import { appendFileSync, writeFileSync } from "node:fs";
 import { Buffer } from "node:buffer";
 import { EventEmitter } from "node:events";
-import { computed, createRenderer, defineComponent, effectScope, h, inject, onBeforeUnmount, onMounted, onScopeDispose, onUnmounted, provide, reactive, ref, shallowReactive, shallowRef, toRef, vShow, watch, watchEffect } from "vue";
+import { computed, createRenderer, defineComponent, effectScope, h, inject, nextTick, onBeforeUnmount, onMounted, onScopeDispose, onUnmounted, provide, reactive, ref, shallowReactive, shallowRef, toRef, vShow, watch, watchEffect } from "vue";
 
 //#region src/core/ansi-palette.ts
 const ANSI_PALETTE_HEX = Object.freeze({
@@ -380,6 +380,308 @@ function ansiColors(level) {
 	return ANSI256_COLORS;
 }
 
+//#endregion
+//#region src/observability/cli-latency.ts
+const EVENT_OP_ID = Symbol("dimcode.cliLatencyOpId");
+const DEFAULT_LOG_PATH = "/tmp/dimcode-cli-latency.jsonl";
+const INVALIDATE_ASSOCIATION_WINDOW_MS = 32;
+const MAX_OP_AGE_MS = 5e3;
+let nextOpId = 1;
+let singleton;
+function now$2() {
+	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function diffMs(end, start) {
+	if (end == null || start == null) return null;
+	return Math.max(0, end - start);
+}
+function parseEnabled$1(value) {
+	const raw = String(value ?? "").trim().toLowerCase();
+	return raw === "1" || raw === "true" || raw === "yes";
+}
+function isTrackedEventType(type) {
+	return type === "keydown" || type === "beforeinput" || type === "input" || type === "paste";
+}
+function defineOpId(target, id) {
+	try {
+		Object.defineProperty(target, EVENT_OP_ID, {
+			configurable: true,
+			enumerable: false,
+			writable: true,
+			value: id
+		});
+	} catch {}
+}
+function readOpId(target) {
+	const value = target === null || target === void 0 ? void 0 : target[EVENT_OP_ID];
+	return typeof value === "number" ? value : null;
+}
+function createDisabledProfiler() {
+	return null;
+}
+function createProfiler() {
+	var _process$once;
+	const env = (process$1 === null || process$1 === void 0 ? void 0 : process$1.env) ?? {};
+	if (!parseEnabled$1(env.DIMCODE_PROFILE_INPUT_LATENCY)) return createDisabledProfiler();
+	const logPath = String(env.DIMCODE_PROFILE_INPUT_LATENCY_LOG_PATH ?? DEFAULT_LOG_PATH).trim() || DEFAULT_LOG_PATH;
+	const ops = new Map();
+	const pendingCommitIds = new Set();
+	const pendingWriteIds = new Set();
+	let currentDispatchOpId = null;
+	let lastDispatchOpId = null;
+	let lastDispatchEndedAt = null;
+	let currentFlushIds = [];
+	let lastRawInputAt = null;
+	const emit = (record) => {
+		try {
+			appendFileSync(logPath, `${JSON.stringify(record)}\n`);
+		} catch {}
+	};
+	const cleanupOp = (id) => {
+		ops.delete(id);
+		pendingCommitIds.delete(id);
+		pendingWriteIds.delete(id);
+		if (currentDispatchOpId === id) currentDispatchOpId = null;
+		if (lastDispatchOpId === id) {
+			lastDispatchOpId = null;
+			lastDispatchEndedAt = null;
+		}
+		if (currentFlushIds.includes(id)) currentFlushIds = currentFlushIds.filter((value) => value !== id);
+	};
+	const flushOp = (op, outcome) => {
+		const totalStart = op.rawInputAt ?? op.stdinDispatchAt ?? op.dispatchStartAt;
+		emit({
+			ts: op.createdAtIso,
+			id: op.id,
+			event: {
+				type: op.eventType,
+				key: op.key,
+				code: op.code,
+				defaultPrevented: op.defaultPrevented,
+				parser: op.parser
+			},
+			operation: op.operation,
+			stages: {
+				rawInputAt: op.rawInputAt,
+				stdinDispatchAt: op.stdinDispatchAt,
+				dispatchStartAt: op.dispatchStartAt,
+				dispatchEndAt: op.dispatchEndAt,
+				invalidateAt: op.invalidateAt,
+				flushStartAt: op.flushStartAt,
+				flushEndAt: op.flushEndAt,
+				commitAt: op.commitAt,
+				stdoutRenderStartAt: op.stdoutRenderStartAt,
+				writeStartAt: op.writeStartAt,
+				writeEndAt: op.writeEndAt
+			},
+			timingsMs: {
+				inputParseWait: diffMs(op.stdinDispatchAt, op.rawInputAt),
+				eventDispatch: diffMs(op.dispatchEndAt, op.dispatchStartAt),
+				dispatchToInvalidate: diffMs(op.invalidateAt, op.dispatchEndAt),
+				dispatchToFlush: diffMs(op.flushStartAt, op.dispatchEndAt),
+				flushToCommitDone: diffMs(op.flushEndAt, op.flushStartAt),
+				commitToRender: diffMs(op.stdoutRenderStartAt, op.commitAt),
+				renderToWriteStart: diffMs(op.writeStartAt, op.stdoutRenderStartAt),
+				write: op.writeDurationMs,
+				totalToWrite: diffMs(op.writeEndAt, totalStart)
+			},
+			scheduler: {
+				invalidatePriority: op.invalidatePriority,
+				invalidatePlane: op.invalidatePlane,
+				commitSync: op.commitSync,
+				commitPlaneCount: op.commitPlaneCount,
+				commitDirtyRows: op.commitDirtyRows,
+				stdoutQueuedDelayMs: op.stdoutQueuedDelayMs,
+				writeMode: op.writeMode,
+				writeBytes: op.writeBytes
+			},
+			outcome
+		});
+		cleanupOp(op.id);
+	};
+	const expireOldOps = () => {
+		const currentTime = now$2();
+		for (const op of ops.values()) {
+			if (currentTime - op.createdAt < MAX_OP_AGE_MS) continue;
+			flushOp(op, op.writeEndAt != null ? "completed" : "timeout");
+		}
+	};
+	const flushPendingOps = (outcome) => {
+		for (const op of Array.from(ops.values())) flushOp(op, op.writeEndAt != null ? "completed" : outcome);
+	};
+	const ensureOp = (event) => {
+		const type = String((event === null || event === void 0 ? void 0 : event.type) ?? "");
+		if (!isTrackedEventType(type)) return null;
+		const existingId = readOpId(event);
+		if (existingId != null) return ops.get(existingId) ?? null;
+		const id = nextOpId++;
+		const op = {
+			id,
+			createdAt: now$2(),
+			createdAtIso: new Date().toISOString(),
+			eventType: type,
+			key: String((event === null || event === void 0 ? void 0 : event.key) ?? ""),
+			code: String((event === null || event === void 0 ? void 0 : event.code) ?? ""),
+			operation: null,
+			rawInputAt: null,
+			stdinDispatchAt: null,
+			dispatchStartAt: null,
+			dispatchEndAt: null,
+			invalidateAt: null,
+			invalidatePriority: null,
+			invalidatePlane: null,
+			flushStartAt: null,
+			flushEndAt: null,
+			commitAt: null,
+			commitSync: null,
+			commitPlaneCount: null,
+			commitDirtyRows: null,
+			stdoutQueuedDelayMs: null,
+			stdoutRenderStartAt: null,
+			writeStartAt: null,
+			writeEndAt: null,
+			writeDurationMs: null,
+			writeMode: null,
+			writeBytes: null,
+			defaultPrevented: null,
+			parser: null
+		};
+		ops.set(id, op);
+		defineOpId(event, id);
+		expireOldOps();
+		return op;
+	};
+	const forIds = (ids, fn) => {
+		for (const id of ids) {
+			const op = ops.get(id);
+			if (!op) continue;
+			fn(op);
+		}
+	};
+	const resolveActiveOp = () => {
+		if (currentDispatchOpId != null) return ops.get(currentDispatchOpId) ?? null;
+		if (lastDispatchOpId != null && lastDispatchEndedAt != null && now$2() - lastDispatchEndedAt <= INVALIDATE_ASSOCIATION_WINDOW_MS) return ops.get(lastDispatchOpId) ?? null;
+		return null;
+	};
+	process$1 === null || process$1 === void 0 || (_process$once = process$1.once) === null || _process$once === void 0 || _process$once.call(process$1, "exit", () => {
+		flushPendingOps("process-exit");
+	});
+	return {
+		enabled: true,
+		recordRawInput(_info) {
+			lastRawInputAt = now$2();
+			expireOldOps();
+		},
+		recordStdinDispatch(event, info) {
+			const op = ensureOp(event);
+			if (!op) return;
+			if (op.rawInputAt == null && lastRawInputAt != null) op.rawInputAt = lastRawInputAt;
+			if (op.stdinDispatchAt == null) op.stdinDispatchAt = now$2();
+			if (!op.parser && (info === null || info === void 0 ? void 0 : info.parser)) op.parser = String(info.parser);
+		},
+		recordEventDispatchStart(event) {
+			const op = ensureOp(event);
+			if (!op) return;
+			currentDispatchOpId = op.id;
+			if (op.dispatchStartAt == null) op.dispatchStartAt = now$2();
+		},
+		recordEventDispatchEnd(event, info) {
+			const op = ensureOp(event);
+			if (!op) return;
+			op.defaultPrevented = Boolean(info.defaultPrevented);
+			if (op.dispatchEndAt == null) op.dispatchEndAt = now$2();
+			currentDispatchOpId = currentDispatchOpId === op.id ? null : currentDispatchOpId;
+			lastDispatchOpId = op.id;
+			lastDispatchEndedAt = op.dispatchEndAt;
+		},
+		recordSchedulerInvalidate(info) {
+			const op = resolveActiveOp();
+			if (!op) return;
+			if (op.invalidateAt == null) op.invalidateAt = now$2();
+			if (!op.invalidatePriority && (info === null || info === void 0 ? void 0 : info.priority)) op.invalidatePriority = String(info.priority);
+			if (!op.invalidatePlane && (info === null || info === void 0 ? void 0 : info.plane)) op.invalidatePlane = String(info.plane);
+			pendingCommitIds.add(op.id);
+		},
+		recordFlushStart(info) {
+			currentFlushIds = Array.from(pendingCommitIds);
+			if (!currentFlushIds.length) return;
+			const flushTime = now$2();
+			forIds(currentFlushIds, (op) => {
+				if (op.flushStartAt == null) op.flushStartAt = flushTime;
+				if (op.commitSync == null && (info === null || info === void 0 ? void 0 : info.sync) != null) op.commitSync = Boolean(info.sync);
+				if (op.commitPlaneCount == null && Array.isArray(info === null || info === void 0 ? void 0 : info.activePlanes)) op.commitPlaneCount = info.activePlanes.length;
+			});
+		},
+		recordFlushEnd() {
+			if (!currentFlushIds.length) return;
+			const flushTime = now$2();
+			forIds(currentFlushIds, (op) => {
+				if (op.flushEndAt == null) op.flushEndAt = flushTime;
+			});
+			currentFlushIds = [];
+		},
+		recordCommit(info) {
+			if (!pendingCommitIds.size) return;
+			const commitTime = now$2();
+			const ids = Array.from(pendingCommitIds);
+			pendingCommitIds.clear();
+			forIds(ids, (op) => {
+				if (op.flushEndAt == null && op.flushStartAt != null) op.flushEndAt = commitTime;
+				if (op.commitAt == null) op.commitAt = commitTime;
+				op.commitSync = (info === null || info === void 0 ? void 0 : info.sync) == null ? op.commitSync : Boolean(info.sync);
+				op.commitPlaneCount = Array.isArray(info === null || info === void 0 ? void 0 : info.planes) ? info.planes.length : op.commitPlaneCount;
+				op.commitDirtyRows = Array.isArray(info === null || info === void 0 ? void 0 : info.dirtyRows) ? info.dirtyRows.length : (info === null || info === void 0 ? void 0 : info.dirtyRows) === null ? null : op.commitDirtyRows;
+				pendingWriteIds.add(op.id);
+			});
+		},
+		recordStdoutQueued(delayMs) {
+			if (!pendingWriteIds.size) return;
+			forIds(pendingWriteIds, (op) => {
+				if (op.stdoutQueuedDelayMs == null) op.stdoutQueuedDelayMs = Math.max(0, delayMs);
+			});
+		},
+		recordStdoutRenderStart() {
+			if (!pendingWriteIds.size) return;
+			const renderTime = now$2();
+			forIds(pendingWriteIds, (op) => {
+				if (op.stdoutRenderStartAt == null) op.stdoutRenderStartAt = renderTime;
+			});
+		},
+		recordStdoutNoOutput() {
+			if (!pendingWriteIds.size) return;
+			const ids = Array.from(pendingWriteIds);
+			pendingWriteIds.clear();
+			forIds(ids, (op) => flushOp(op, "no-output"));
+		},
+		recordStdoutWrite(info) {
+			if (!pendingWriteIds.size) return;
+			const writeEndTime = now$2();
+			const ids = Array.from(pendingWriteIds);
+			pendingWriteIds.clear();
+			forIds(ids, (op) => {
+				op.writeEndAt = writeEndTime;
+				op.writeDurationMs = Math.max(0, info.durationMs);
+				op.writeStartAt = writeEndTime - op.writeDurationMs;
+				op.writeMode = String(info.mode ?? "");
+				op.writeBytes = Math.max(0, Math.floor(info.bytes));
+				flushOp(op, "completed");
+			});
+		},
+		markOperation(operation) {
+			const nextOperation = String(operation ?? "").trim();
+			if (!nextOperation) return;
+			const op = resolveActiveOp();
+			if (!op) return;
+			op.operation = nextOperation;
+		}
+	};
+}
+function getCliLatencyProfiler() {
+	if (singleton !== void 0) return singleton;
+	singleton = createProfiler();
+	return singleton;
+}
+
 //#endregion
 //#region src/utils/newlines.ts
 function normalizeNewlines(text) {
@@ -1286,7 +1588,7 @@ function parseMouseSgr(sequence) {
 		handled: false,
 		event: null
 	};
-	const env = (process === null || process === void 0 ? void 0 : process.env) ?? {};
+	const env = (process$1 === null || process$1 === void 0 ? void 0 : process$1.env) ?? {};
 	const invertWheel = String(env.DIMCODE_WHEEL_INVERT ?? env.VUE_TUI_WHEEL_INVERT ?? "") === "1";
 	const mouseDebugEnabled = String(env.DIMCODE_MOUSE_DEBUG ?? env.VUE_TUI_MOUSE_DEBUG ?? "") === "1";
 	const mouseDebugPath = String(env.DIMCODE_MOUSE_DEBUG_PATH ?? env.VUE_TUI_MOUSE_DEBUG_PATH ?? "/tmp/goatchain-mouse-debug.log");
@@ -1422,6 +1724,7 @@ function parseMouseSequence(sequence) {
 const ESC$1 = "\x1B";
 const BRACKETED_PASTE_START = "\x1B[200~";
 const BRACKETED_PASTE_END = "\x1B[201~";
+const ESC_CONTINUATION_RESCUE_WINDOW_MS = 64;
 function looksLikeQuotedPathPaste(value) {
 	if (!value) return false;
 	if (value.includes(ESC$1)) return false;
@@ -1524,6 +1827,11 @@ function extractCompleteSequences(buffer) {
 		remainder: ""
 	};
 }
+function looksLikeSplitEscapeContinuation(value) {
+	const first = value[0];
+	if (first !== "[" && first !== "]" && first !== "P" && first !== "_" && first !== "O") return false;
+	return isCompleteSequence(`${ESC$1}${value}`) !== "not-escape";
+}
 var StdinBuffer = class extends EventEmitter {
 	constructor(options = {}) {
 		super();
@@ -1531,6 +1839,7 @@ var StdinBuffer = class extends EventEmitter {
 		this.timeout = null;
 		this.timeoutMs = void 0;
 		this.escTimeoutMs = void 0;
+		this.pendingEscContinuationAt = null;
 		this.pasteMode = false;
 		this.pasteBuffer = "";
 		this.timeoutMs = options.timeout ?? 10;
@@ -1547,6 +1856,11 @@ var StdinBuffer = class extends EventEmitter {
 			str = `\x1B${String.fromCharCode(byte)}`;
 		} else str = data.toString();
 		else str = data;
+		if (this.pendingEscContinuationAt != null) {
+			const canRescue = Date.now() - this.pendingEscContinuationAt <= ESC_CONTINUATION_RESCUE_WINDOW_MS;
+			this.pendingEscContinuationAt = null;
+			if (canRescue && looksLikeSplitEscapeContinuation(str)) str = `${ESC$1}${str}`;
+		}
 		if (str.length === 0 && this.buffer.length === 0) {
 			this.emit("data", "");
 			return;
@@ -1600,7 +1914,9 @@ var StdinBuffer = class extends EventEmitter {
 		if (this.buffer.length > 0) {
 			const timeoutMs = this.buffer === ESC$1 ? this.escTimeoutMs : this.timeoutMs;
 			this.timeout = setTimeout(() => {
+				const rescuableLoneEsc = this.buffer === ESC$1;
 				const flushed = this.flush();
+				if (rescuableLoneEsc && flushed.length === 1 && flushed[0] === ESC$1) this.pendingEscContinuationAt = Date.now();
 				for (const sequence of flushed) this.emit("data", sequence);
 			}, timeoutMs);
 		}
@@ -1621,6 +1937,7 @@ var StdinBuffer = class extends EventEmitter {
 			this.timeout = null;
 		}
 		this.buffer = "";
+		this.pendingEscContinuationAt = null;
 		this.pasteMode = false;
 		this.pasteBuffer = "";
 	}
@@ -1634,6 +1951,10 @@ var StdinBuffer = class extends EventEmitter {
 
 //#endregion
 //#region src/cli/input.ts
+const KITTY_KEYBOARD_PROTOCOL_ENABLE = "\x1B[>1u";
+const KITTY_KEYBOARD_PROTOCOL_DISABLE = "\x1B[<u";
+const XTERM_MODIFY_OTHER_KEYS_ENABLE = "\x1B[>4;2m";
+const XTERM_MODIFY_OTHER_KEYS_DISABLE = "\x1B[>4n";
 function isPrintable(ch) {
 	if (ch.length === 0) return false;
 	if (ch.length === 1) {
@@ -1653,12 +1974,54 @@ function ctrlKeyFromChar(ch) {
 	if (code >= 1 && code <= 26) return String.fromCharCode(code + 96);
 	return null;
 }
+function isUnhandledCtrlC(event) {
+	return event.type === "keydown" && (event.key === "c" || event.key === "C") && event.ctrlKey === true && event.metaKey !== true && event.altKey !== true && event.shiftKey !== true;
+}
+function parseKeyboardProtocol(value) {
+	const normalized = String(value ?? "").trim().toLowerCase();
+	if (normalized === "auto" || normalized === "kitty" || normalized === "xterm" || normalized === "off") return normalized;
+	return null;
+}
+function detectKeyboardProtocol(env) {
+	const termProgram = String(env.TERM_PROGRAM ?? "").trim().toLowerCase();
+	const term = String(env.TERM ?? "").trim().toLowerCase();
+	const hasKittyProtocolTerminal = "GHOSTTY_RESOURCES_DIR" in env || "WEZTERM_PANE" in env || "KITTY_WINDOW_ID" in env || "KITTY_INSTALLATION_DIR" in env || "ALACRITTY_WINDOW_ID" in env || "ALACRITTY_LOG" in env || termProgram.includes("ghostty") || termProgram.includes("wezterm") || termProgram.includes("kitty") || termProgram.includes("alacritty");
+	if (hasKittyProtocolTerminal) return "kitty";
+	const isScreenLike = "TMUX" in env || term.includes("screen") || term.includes("tmux");
+	const hasXtermKeyboardTerminal = termProgram.includes("iterm") || termProgram.includes("apple_terminal") || termProgram.includes("vscode") || term.includes("xterm") && !isScreenLike;
+	return hasXtermKeyboardTerminal ? "xterm" : "off";
+}
+function resolveKeyboardProtocol(options) {
+	var _options$env;
+	const configured = parseKeyboardProtocol(options.keyboardProtocol) ?? "auto";
+	if (configured !== "auto") return configured;
+	const envOverride = parseKeyboardProtocol((_options$env = options.env) === null || _options$env === void 0 ? void 0 : _options$env.DIMCODE_KEYBOARD_PROTOCOL);
+	if (envOverride && envOverride !== "auto") return envOverride;
+	return detectKeyboardProtocol(options.env ?? {});
+}
+function getKeyboardProtocolSequences(protocol) {
+	if (protocol === "kitty") return {
+		enable: KITTY_KEYBOARD_PROTOCOL_ENABLE,
+		disable: KITTY_KEYBOARD_PROTOCOL_DISABLE
+	};
+	if (protocol === "xterm") return {
+		enable: XTERM_MODIFY_OTHER_KEYS_ENABLE,
+		disable: XTERM_MODIFY_OTHER_KEYS_DISABLE
+	};
+	return null;
+}
 function createStdinDriver(options) {
-	const stdin = options.stdin ?? process.stdin;
-	const stdout = options.stdout ?? process.stdout;
+	const stdin = options.stdin ?? process$1.stdin;
+	const stdout = options.stdout ?? process$1.stdout;
 	if (!stdin || !stdout) throw new Error("createStdinDriver requires Node process.stdin/stdout");
+	const env = options.env ?? process$1.env ?? {};
 	const enableMouse = options.enableMouse ?? true;
 	const enableMouseMotion = options.enableMouseMotion ?? false;
+	const keyboardProtocol = resolveKeyboardProtocol({
+		keyboardProtocol: options.keyboardProtocol,
+		env
+	});
+	const keyboardProtocolSequences = getKeyboardProtocolSequences(keyboardProtocol);
 	let disposed = false;
 	let swallowNextLF = false;
 	let lastMouseDown = null;
@@ -1668,55 +2031,61 @@ function createStdinDriver(options) {
 	});
 	const stdinBuffer = new StdinBuffer({
 		timeout: 50,
-		escTimeout: enableMouse ? 80 : 20
+		escTimeout: enableMouse ? 8 : 6
 	});
+	const latency = getCliLatencyProfiler();
+	const dispatchEvent = (event, parser) => {
+		var _options$onExit;
+		latency === null || latency === void 0 || latency.recordStdinDispatch(event, { parser });
+		const prevented = Boolean(options.dispatch(event));
+		if (isUnhandledCtrlC(event) && !prevented) (_options$onExit = options.onExit) === null || _options$onExit === void 0 || _options$onExit.call(options);
+		return prevented;
+	};
 	const handlePlainChar = (ch) => {
 		if (swallowNextLF) {
 			swallowNextLF = false;
 			if (ch === "\n") return;
 		}
 		if (ch === "") {
-			var _options$onExit;
-			const prevented = Boolean(options.dispatch(keyEvent("c", "", { ctrlKey: true })));
-			if (!prevented) (_options$onExit = options.onExit) === null || _options$onExit === void 0 || _options$onExit.call(options);
+			dispatchEvent(keyEvent("c", "", { ctrlKey: true }), "plain");
 			return;
 		}
 		if (ch === "\r") {
 			swallowNextLF = true;
-			options.dispatch(keyEvent("Enter", "Enter"));
+			dispatchEvent(keyEvent("Enter", "Enter"), "plain");
 			return;
 		}
 		if (ch === "\n") {
-			options.dispatch({
+			dispatchEvent({
 				type: "input",
 				data: "\n",
 				inputType: "insertLineBreak",
 				text: "\n"
-			});
+			}, "plain");
 			return;
 		}
 		const ctrlKey = ctrlKeyFromChar(ch);
 		if (ctrlKey) {
 			if (ctrlKey === "i") {
-				options.dispatch(keyEvent("Tab", "Tab"));
+				dispatchEvent(keyEvent("Tab", "Tab"), "plain");
 				return;
 			}
 			if (ctrlKey === "h") {
-				options.dispatch(keyEvent("Backspace", "Backspace"));
+				dispatchEvent(keyEvent("Backspace", "Backspace"), "plain");
 				return;
 			}
-			options.dispatch(keyEvent(ctrlKey, "", { ctrlKey: true }));
+			dispatchEvent(keyEvent(ctrlKey, "", { ctrlKey: true }), "plain");
 			return;
 		}
 		if (ch === "") {
-			options.dispatch(keyEvent("Backspace", "Backspace"));
+			dispatchEvent(keyEvent("Backspace", "Backspace"), "plain");
 			return;
 		}
 		if (ch === "	") {
-			options.dispatch(keyEvent("Tab", "Tab"));
+			dispatchEvent(keyEvent("Tab", "Tab"), "plain");
 			return;
 		}
-		if (isPrintable(ch)) options.dispatch(keyEvent(ch));
+		if (isPrintable(ch)) dispatchEvent(keyEvent(ch), "plain");
 	};
 	const handleMouseEvent = (event) => {
 		const ev = event;
@@ -1789,21 +2158,21 @@ function createStdinDriver(options) {
 		}
 		const kitty = parseKittySequence(sequence);
 		if (kitty.handled) {
-			if (kitty.event) options.dispatch(kitty.event);
+			if (kitty.event) dispatchEvent(kitty.event, "kitty");
 			return;
 		}
 		const legacy = parseLegacySequence(sequence);
 		if (legacy.handled) {
-			if (legacy.event) options.dispatch(legacy.event);
+			if (legacy.event) dispatchEvent(legacy.event, "legacy");
 			return;
 		}
 		if (sequence.startsWith("\x1B")) {
 			if (sequence.length === 2 && isPrintable(sequence[1])) {
-				options.dispatch(keyEvent(sequence[1], "", { altKey: true }));
+				dispatchEvent(keyEvent(sequence[1], "", { altKey: true }), "alt");
 				return;
 			}
 			if (sequence === "\x1B") {
-				options.dispatch(keyEvent("Escape", "Escape"));
+				dispatchEvent(keyEvent("Escape", "Escape"), "escape");
 				return;
 			}
 			return;
@@ -1813,10 +2182,10 @@ function createStdinDriver(options) {
 	stdinBuffer.on("data", handleSequence);
 	stdinBuffer.on("paste", (data) => {
 		const pastedText = normalizeNewlines(data);
-		if (pastedText) options.dispatch({
+		if (pastedText) dispatchEvent({
 			type: "paste",
 			text: pastedText
-		});
+		}, "paste");
 	});
 	const decodeBytes = (bytes) => {
 		if (bytes.length === 1 && bytes[0] > 127) {
@@ -1829,6 +2198,7 @@ function createStdinDriver(options) {
 	};
 	const onData = (chunk) => {
 		if (disposed) return;
+		latency === null || latency === void 0 || latency.recordRawInput();
 		if (typeof chunk === "string") {
 			stdinBuffer.process(chunk);
 			return;
@@ -1854,6 +2224,7 @@ function createStdinDriver(options) {
 	if (stdout.isTTY) {
 		stdout.write("\x1B[?2004h");
 		stdout.write("\x1B[?1004h");
+		if (keyboardProtocolSequences) stdout.write(keyboardProtocolSequences.enable);
 		if (enableMouse) {
 			stdout.write("\x1B[?1007h");
 			if (enableMouseMotion) stdout.write("\x1B[?1000h\x1B[?1003h\x1B[?1006h");
@@ -1876,6 +2247,7 @@ function createStdinDriver(options) {
 		if (stdout.isTTY) {
 			stdout.write("\x1B[?2004l");
 			stdout.write("\x1B[?1004l");
+			if (keyboardProtocolSequences) stdout.write(keyboardProtocolSequences.disable);
 			if (enableMouse) {
 				stdout.write("\x1B[?1007l");
 				if (enableMouseMotion) stdout.write("\x1B[?1000l\x1B[?1003l\x1B[?1006l");
@@ -2511,12 +2883,59 @@ function createGridBuffer(cols, rows) {
 		cursorStyle: DEFAULT_STYLE,
 		scrollback: [],
 		scrollbackLimit: 1e3,
-		rowPool: []
+		rowPool: [],
+		soaFingerprints: null,
+		fingerprintFn: null
 	};
 }
 function clamp$7(n, min, max) {
 	return Math.max(min, Math.min(max, n));
 }
+/**
+* Register a fingerprint function on the buffer. This enables SoA fingerprint
+* pre-computation: cell writes will update fingerprints inline, and the renderer
+* can read them via getRowFingerprints() instead of per-cell hash computation.
+*/
+function setFingerprintFn(buffer, fn) {
+	buffer.fingerprintFn = fn;
+	const len = buffer.rows * buffer.cols;
+	if (!len) {
+		buffer.soaFingerprints = null;
+		return;
+	}
+	buffer.soaFingerprints = new Uint32Array(len);
+	for (let y = 0; y < buffer.rows; y++) {
+		const row = getBufferRow(buffer, y);
+		const physY = physicalRowIndex(buffer, y);
+		const base = physY * buffer.cols;
+		for (let x = 0; x < buffer.cols; x++) {
+			const cell = row[x];
+			buffer.soaFingerprints[base + x] = fn(cell.ch, cell.style);
+		}
+	}
+}
+/**
+* Get pre-computed fingerprints for a logical row as a TypedArray slice.
+* Returns null if fingerprinting is not enabled on this buffer.
+*/
+function getRowFingerprints(buffer, y) {
+	if (!buffer.soaFingerprints) return null;
+	const physY = physicalRowIndex(buffer, y);
+	const base = physY * buffer.cols;
+	return buffer.soaFingerprints.subarray(base, base + buffer.cols);
+}
+/** Update the SoA fingerprint for a single cell (called inline from putCell/fillRect). */
+function updateCellFingerprint(buffer, physY, x, ch, style) {
+	if (!buffer.soaFingerprints || !buffer.fingerprintFn) return;
+	buffer.soaFingerprints[physY * buffer.cols + x] = buffer.fingerprintFn(ch, style);
+}
+/** Update SoA fingerprints for a range of cells in a physical row. */
+function updateRangeFingerprint(buffer, physY, x0, x1, ch, style) {
+	if (!buffer.soaFingerprints || !buffer.fingerprintFn) return;
+	const fp = buffer.fingerprintFn(ch, style);
+	const base = physY * buffer.cols;
+	for (let x = x0; x < x1; x++) buffer.soaFingerprints[base + x] = fp;
+}
 function physicalRowIndex(buffer, y) {
 	return (buffer.gridStart + y) % buffer.rows;
 }
@@ -2575,8 +2994,14 @@ function putCell(buffer, x, y, ch, style) {
 		markDirty(buffer, y);
 		return;
 	}
-	row[x] = createCell(ch, style);
+	const cell = createCell(ch, style);
+	row[x] = cell;
 	if (width === 2 && x + 1 < buffer.cols) row[x + 1] = createContinuationCell(style);
+	if (buffer.soaFingerprints) {
+		const physY = physicalRowIndex(buffer, y);
+		updateCellFingerprint(buffer, physY, x, cell.ch, cell.style);
+		if (width === 2 && x + 1 < buffer.cols) updateCellFingerprint(buffer, physY, x + 1, "", cell.style);
+	}
 	markDirty(buffer, y);
 }
 function fillRect(buffer, x, y, w, h$1, ch = " ", style) {
@@ -2596,6 +3021,10 @@ function fillRect(buffer, x, y, w, h$1, ch = " ", style) {
 			if ((_row$x = row[x0]) === null || _row$x === void 0 ? void 0 : _row$x.continuation) clearWideIfOverwriting(row, x0);
 			row.fill(fillCell, x0, x1);
 			if (x1 < buffer.cols && ((_row$x2 = row[x1]) === null || _row$x2 === void 0 ? void 0 : _row$x2.continuation)) row[x1] = blank;
+			if (buffer.soaFingerprints) {
+				const physY = physicalRowIndex(buffer, yy);
+				updateRangeFingerprint(buffer, physY, x0, x1, fillCell.ch, fillCell.style);
+			}
 			markDirty(buffer, yy);
 		}
 		return;
@@ -2654,6 +3083,18 @@ function blankRow(buffer) {
 	for (let x = 0; x < buffer.cols; x++) pooled[x] = blank;
 	return pooled;
 }
+function recomputeFingerprintsForRows(buffer, startY, endY) {
+	if (!buffer.soaFingerprints || !buffer.fingerprintFn) return;
+	for (let y = startY; y < endY; y++) {
+		const row = getBufferRow(buffer, y);
+		const physY = physicalRowIndex(buffer, y);
+		const base = physY * buffer.cols;
+		for (let x = 0; x < buffer.cols; x++) {
+			const cell = row[x];
+			buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
+		}
+	}
+}
 function scrollBuffer(buffer, lines) {
 	const n = Math.trunc(lines);
 	if (n === 0 || buffer.rows === 0) return;
@@ -2682,6 +3123,63 @@ function scrollBuffer(buffer, lines) {
 	markAllDirty(buffer);
 	buffer.cursorY = clamp$7(buffer.cursorY - n, 0, Math.max(0, buffer.rows - 1));
 }
+function scrollBufferRegion(buffer, startY, endY, lines) {
+	const n = Math.trunc(lines);
+	if (n === 0 || buffer.rows === 0) return [];
+	const start = clamp$7(Math.floor(startY), 0, buffer.rows);
+	const end = clamp$7(Math.floor(endY), 0, buffer.rows);
+	const height = end - start;
+	if (height <= 0) return [];
+	const absDelta = Math.abs(n);
+	const insertedRows = [];
+	const replaceRegionWithBlankRows = () => {
+		for (let y = start; y < end; y++) {
+			const physY = physicalRowIndex(buffer, y);
+			buffer.rowPool.push(buffer.grid[physY]);
+			buffer.grid[physY] = blankRow(buffer);
+			markDirty(buffer, y);
+			insertedRows.push(y);
+		}
+	};
+	if (absDelta >= height) {
+		replaceRegionWithBlankRows();
+		recomputeFingerprintsForRows(buffer, start, end);
+		if (buffer.cursorY >= start && buffer.cursorY < end) buffer.cursorY = clamp$7(buffer.cursorY - n, start, Math.max(start, end - 1));
+		return insertedRows;
+	}
+	const regionRows = [];
+	for (let y = start; y < end; y++) regionRows.push(getBufferRow(buffer, y));
+	const nextRows = Array.from({ length: height }, () => []);
+	if (n > 0) {
+		const movedCount = height - n;
+		for (let i = 0; i < movedCount; i++) nextRows[i] = regionRows[i + n];
+		for (let i = 0; i < n; i++) {
+			buffer.rowPool.push(regionRows[i]);
+			const y = end - n + i;
+			nextRows[movedCount + i] = blankRow(buffer);
+			markDirty(buffer, y);
+			insertedRows.push(y);
+		}
+	} else {
+		const insertedCount = -n;
+		const movedCount = height - insertedCount;
+		for (let i = 0; i < insertedCount; i++) {
+			buffer.rowPool.push(regionRows[height - insertedCount + i]);
+			const y = start + i;
+			nextRows[i] = blankRow(buffer);
+			markDirty(buffer, y);
+			insertedRows.push(y);
+		}
+		for (let i = 0; i < movedCount; i++) nextRows[insertedCount + i] = regionRows[i];
+	}
+	for (let i = 0; i < height; i++) {
+		const physY = physicalRowIndex(buffer, start + i);
+		buffer.grid[physY] = nextRows[i];
+	}
+	recomputeFingerprintsForRows(buffer, start, end);
+	if (buffer.cursorY >= start && buffer.cursorY < end) buffer.cursorY = clamp$7(buffer.cursorY - n, start, Math.max(start, end - 1));
+	return insertedRows;
+}
 function resizeBuffer(buffer, cols, rows) {
 	const nextCols = Math.max(0, Math.floor(cols));
 	const nextRows = Math.max(0, Math.floor(rows));
@@ -2712,6 +3210,20 @@ function resizeBuffer(buffer, cols, rows) {
 	buffer.dirtyAll = nextRows > 0;
 	buffer.cursorX = clamp$7(buffer.cursorX, 0, Math.max(0, nextCols));
 	buffer.cursorY = clamp$7(buffer.cursorY, 0, Math.max(0, nextRows - 1));
+	if (buffer.fingerprintFn) {
+		const len = nextRows * nextCols;
+		if (len > 0) {
+			buffer.soaFingerprints = new Uint32Array(len);
+			for (let y = 0; y < nextRows; y++) {
+				const row = nextGrid[y];
+				const base = y * nextCols;
+				for (let x = 0; x < nextCols; x++) {
+					const cell = row[x];
+					buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
+				}
+			}
+		} else buffer.soaFingerprints = null;
+	}
 }
 function snapshotText(buffer) {
 	const out = [];
@@ -2874,6 +3386,32 @@ function scrollPlaneCoverage(state, lines) {
 	state.coverage.splice(rows + n, -n);
 	for (let i = 0; i < -n; i++) state.coverage.unshift(new Uint8Array(cols));
 }
+function scrollPlaneCoverageRegion(state, startY, endY, lines) {
+	const n = Math.trunc(lines);
+	if (n === 0 || state.coverage.length === 0) return;
+	const start = Math.max(0, Math.min(state.coverage.length, Math.floor(startY)));
+	const end = Math.max(0, Math.min(state.coverage.length, Math.floor(endY)));
+	const height = end - start;
+	if (height <= 0) return;
+	const cols = state.buffer.cols;
+	if (Math.abs(n) >= height) {
+		for (let y = start; y < end; y++) state.coverage[y] = new Uint8Array(cols);
+		return;
+	}
+	const region = state.coverage.slice(start, end);
+	const next = Array.from({ length: height }, () => new Uint8Array(0));
+	if (n > 0) {
+		const movedCount = height - n;
+		for (let i = 0; i < movedCount; i++) next[i] = region[i + n];
+		for (let i = 0; i < n; i++) next[movedCount + i] = new Uint8Array(cols);
+	} else {
+		const insertedCount = -n;
+		const movedCount = height - insertedCount;
+		for (let i = 0; i < insertedCount; i++) next[i] = new Uint8Array(cols);
+		for (let i = 0; i < movedCount; i++) next[insertedCount + i] = region[i];
+	}
+	for (let i = 0; i < height; i++) state.coverage[start + i] = next[i];
+}
 function resizePlaneState(state, cols, rows) {
 	resizeBuffer(state.buffer, cols, rows);
 	state.coverage = resizeCoverage(state.coverage, state.buffer.cols, state.buffer.rows);
@@ -2902,6 +3440,14 @@ function resetPlaneRowsForRender(terminal, plane, dirtyRows) {
 	const internals = terminal[TERMINAL_PLANE_INTERNALS];
 	internals === null || internals === void 0 || internals.resetRowsForRender(plane, dirtyRows);
 }
+function getPlaneRowCoverageKind(terminal, plane, y) {
+	const internals = terminal[TERMINAL_PLANE_INTERNALS];
+	return (internals === null || internals === void 0 ? void 0 : internals.getRowCoverageKind(plane, y)) ?? 0;
+}
+function scrollPlaneRows(terminal, plane, startY, endY, lines) {
+	const internals = terminal[TERMINAL_PLANE_INTERNALS];
+	internals === null || internals === void 0 || internals.scrollRows(plane, startY, endY, lines);
+}
 function createTerminal(opts) {
 	const emitter = new Emitter();
 	const compositeBuffer = createGridBuffer(opts.cols, opts.rows);
@@ -2911,6 +3457,7 @@ function createTerminal(opts) {
 	let pendingCommit = false;
 	let pendingCommitAllPlanes = false;
 	let pendingCommitPlanes = null;
+	const pendingPlaneScrollOps = new Map();
 	const planeTerminals = new Map();
 	let base;
 	compositeBuffer.cursorVisible = false;
@@ -3031,8 +3578,145 @@ function createTerminal(opts) {
 		scrollBuffer(state.buffer, lines);
 		scrollPlaneCoverage(state, lines);
 	}
+	function normalizeScrollOperation(startY, endY, delta, totalRows) {
+		const start = Math.max(0, Math.min(totalRows, Math.floor(startY)));
+		const end = Math.max(0, Math.min(totalRows, Math.floor(endY)));
+		const height = end - start;
+		const lines = Math.trunc(delta);
+		if (height <= 0 || lines === 0 || Math.abs(lines) >= height) return null;
+		return {
+			startY: start,
+			endY: end,
+			delta: lines
+		};
+	}
+	function recordPendingScrollOp(plane, op) {
+		const prev = pendingPlaneScrollOps.get(plane);
+		if (prev && prev.startY === op.startY && prev.endY === op.endY) {
+			const nextDelta = prev.delta + op.delta;
+			if (nextDelta === 0) {
+				pendingPlaneScrollOps.delete(plane);
+				return;
+			}
+			const next = normalizeScrollOperation(op.startY, op.endY, nextDelta, compositeBuffer.rows);
+			if (!next) {
+				pendingPlaneScrollOps.delete(plane);
+				return;
+			}
+			pendingPlaneScrollOps.set(plane, next);
+			return;
+		}
+		pendingPlaneScrollOps.set(plane, op);
+	}
+	function takePendingScrollOps(planes) {
+		const planesToTake = (planes === null || planes === void 0 ? void 0 : planes.length) ? planes : TERMINAL_RENDER_PLANES;
+		const out = [];
+		for (const plane of planesToTake) {
+			const op = pendingPlaneScrollOps.get(plane);
+			if (!op) continue;
+			pendingPlaneScrollOps.delete(plane);
+			out.push({
+				plane,
+				...op
+			});
+		}
+		return out.length ? out : null;
+	}
+	function higherPlanesFor(plane) {
+		const planeIndex = TERMINAL_RENDER_PLANES.indexOf(plane);
+		if (planeIndex < 0) return [];
+		return TERMINAL_RENDER_PLANES.slice(planeIndex + 1);
+	}
+	function higherPlaneCoverageKind(plane, y) {
+		const higherPlanes = higherPlanesFor(plane);
+		if (!higherPlanes.length || y < 0 || y >= compositeBuffer.rows) return 0;
+		let covered = 0;
+		for (let x = 0; x < compositeBuffer.cols; x++) {
+			let cellCovered = false;
+			for (const higherPlane of higherPlanes) {
+				var _state$coverage$y2;
+				const state = planeStates.get(higherPlane);
+				if (state === null || state === void 0 || (_state$coverage$y2 = state.coverage[y]) === null || _state$coverage$y2 === void 0 ? void 0 : _state$coverage$y2[x]) {
+					cellCovered = true;
+					break;
+				}
+			}
+			if (cellCovered) covered++;
+		}
+		if (covered === 0) return 0;
+		if (covered >= compositeBuffer.cols) return 2;
+		return 1;
+	}
+	function prepareCompositeScrollOps(pendingOps) {
+		if (!(pendingOps === null || pendingOps === void 0 ? void 0 : pendingOps.length)) return {
+			scrollOperations: null,
+			extraDirtyRows: []
+		};
+		const scrollOperations = [];
+		const extraDirtyRows = new Set();
+		for (const pending of pendingOps) {
+			const blockedRows = new Set();
+			const partiallyBlockedRows = new Set();
+			for (let y = pending.startY; y < pending.endY; y++) {
+				const coverageKind = higherPlaneCoverageKind(pending.plane, y);
+				if (coverageKind === 0) continue;
+				blockedRows.add(y);
+				if (coverageKind === 1) partiallyBlockedRows.add(y);
+			}
+			if (!blockedRows.size) {
+				scrollOperations.push({
+					startY: pending.startY,
+					endY: pending.endY,
+					delta: pending.delta
+				});
+				continue;
+			}
+			const absDelta = Math.abs(pending.delta);
+			for (let y = pending.startY; y < pending.endY; y++) if (partiallyBlockedRows.has(y)) extraDirtyRows.add(y);
+			let bandStart = -1;
+			const flushBand = (bandEnd) => {
+				if (bandStart < 0 || bandEnd <= bandStart) return;
+				const bandHeight = bandEnd - bandStart;
+				if (absDelta >= bandHeight) {
+					for (let y = bandStart; y < bandEnd; y++) extraDirtyRows.add(y);
+					bandStart = -1;
+					return;
+				}
+				scrollOperations.push({
+					startY: bandStart,
+					endY: bandEnd,
+					delta: pending.delta
+				});
+				if (pending.delta > 0) for (let y = bandEnd - absDelta; y < bandEnd; y++) extraDirtyRows.add(y);
+				else for (let y = bandStart; y < bandStart + absDelta; y++) extraDirtyRows.add(y);
+				bandStart = -1;
+			};
+			for (let y = pending.startY; y < pending.endY; y++) {
+				if (blockedRows.has(y)) {
+					flushBand(y);
+					continue;
+				}
+				if (bandStart < 0) bandStart = y;
+			}
+			flushBand(pending.endY);
+		}
+		return {
+			scrollOperations: scrollOperations.length ? scrollOperations : null,
+			extraDirtyRows: Array.from(extraDirtyRows).sort((a, b) => a - b)
+		};
+	}
+	function scrollRowsForPlane(plane, startY, endY, lines) {
+		const state = getPlaneState(plane);
+		const op = normalizeScrollOperation(startY, endY, lines, state.buffer.rows);
+		if (!op) return;
+		scrollBufferRegion(state.buffer, op.startY, op.endY, op.delta);
+		scrollPlaneCoverageRegion(state, op.startY, op.endY, op.delta);
+		recordPendingScrollOp(plane, op);
+	}
 	function composeRows(rows) {
 		const blank = createBlankCell();
+		const fpFn = compositeBuffer.fingerprintFn;
+		const fpArr = compositeBuffer.soaFingerprints;
 		const rowList = rows ?? Array.from({ length: compositeBuffer.rows }, (_, index) => index);
 		for (const y of rowList) {
 			if (y < 0 || y >= compositeBuffer.rows) continue;
@@ -3056,6 +3740,14 @@ function createTerminal(opts) {
 					if (x === 0 || dst[x - 1].width !== 2 || dst[x - 1].continuation) dst[x] = blank;
 				}
 			}
+			if (fpFn && fpArr) {
+				const physY = (compositeBuffer.gridStart + y) % compositeBuffer.rows;
+				const base$1 = physY * cols;
+				for (let x = 0; x < cols; x++) {
+					const cell = dst[x];
+					fpArr[base$1 + x] = fpFn(cell.ch, cell.style);
+				}
+			}
 			markDirty(compositeBuffer, y);
 		}
 	}
@@ -3228,6 +3920,14 @@ function createTerminal(opts) {
 				const all = state.buffer.scrollback.map((row) => row.map((cell) => cell.continuation ? " " : cell.ch || " ").join(""));
 				if (count == null) return all;
 				return all.slice(Math.max(0, all.length - Math.max(0, Math.floor(count))));
+			},
+			setFingerprintFn(fn) {
+				assertNotDisposed();
+				base.setFingerprintFn(fn);
+			},
+			getRowFingerprints(y) {
+				assertNotDisposed();
+				return base.getRowFingerprints(y);
 			}
 		};
 		planeTerminals.set(plane, api);
@@ -3302,6 +4002,9 @@ function createTerminal(opts) {
 				return pendingDirtyRowsForPlanes((meta === null || meta === void 0 ? void 0 : meta.planes) ?? null);
 			}
 			const planesToCompose = (meta === null || meta === void 0 || (_meta$planes2 = meta.planes) === null || _meta$planes2 === void 0 ? void 0 : _meta$planes2.length) ? meta.planes : TERMINAL_RENDER_PLANES;
+			const pendingScrollOps = takePendingScrollOps(planesToCompose);
+			const preparedScroll = prepareCompositeScrollOps(pendingScrollOps);
+			const scrollOperations = preparedScroll.scrollOperations;
 			let composeAllRows = false;
 			const dirtyRows = new Set();
 			for (const plane of planesToCompose) {
@@ -3314,13 +4017,17 @@ function createTerminal(opts) {
 				}
 				for (const y of rows) dirtyRows.add(y);
 			}
+			for (const y of preparedScroll.extraDirtyRows) dirtyRows.add(y);
 			const normalizedDirtyRows = composeAllRows ? null : Array.from(dirtyRows).sort((a, b) => a - b);
+			if (scrollOperations) for (const op of scrollOperations) scrollBufferRegion(compositeBuffer, op.startY, op.endY, op.delta);
 			if (normalizedDirtyRows !== null && normalizedDirtyRows.length === 0) {
 				const pendingCompositeRows = collectAndClearDirtyRows(compositeBuffer);
 				if (pendingCompositeRows !== null && pendingCompositeRows.length === 0) return pendingCompositeRows;
 				emitter.emit("commit", {
 					dirtyRows: pendingCompositeRows,
-					planes: (meta === null || meta === void 0 ? void 0 : meta.planes) ?? null
+					planes: (meta === null || meta === void 0 ? void 0 : meta.planes) ?? null,
+					sync: meta === null || meta === void 0 ? void 0 : meta.sync,
+					scrollOperations
 				});
 				return pendingCompositeRows;
 			}
@@ -3331,7 +4038,9 @@ function createTerminal(opts) {
 			if (committedRows !== null && committedRows.length === 0) return committedRows;
 			emitter.emit("commit", {
 				dirtyRows: committedRows,
-				planes: (meta === null || meta === void 0 ? void 0 : meta.planes) ?? null
+				planes: (meta === null || meta === void 0 ? void 0 : meta.planes) ?? null,
+				sync: meta === null || meta === void 0 ? void 0 : meta.sync,
+				scrollOperations
 			});
 			return committedRows;
 		},
@@ -3386,6 +4095,14 @@ function createTerminal(opts) {
 			const all = state.buffer.scrollback.map((row) => row.map((cell) => cell.continuation ? " " : cell.ch || " ").join(""));
 			if (count == null) return all;
 			return all.slice(Math.max(0, all.length - Math.max(0, Math.floor(count))));
+		},
+		setFingerprintFn(fn) {
+			assertNotDisposed();
+			setFingerprintFn(compositeBuffer, fn);
+		},
+		getRowFingerprints(y) {
+			assertNotDisposed();
+			return getRowFingerprints(compositeBuffer, y);
 		}
 	};
 	base[TERMINAL_PLANE_INTERNALS] = {
@@ -3398,6 +4115,20 @@ function createTerminal(opts) {
 				return;
 			}
 			for (const y of rows) clearPlaneCoverageRow(state, y);
+		},
+		getRowCoverageKind(plane, y) {
+			const state = getPlaneState(plane);
+			if (y < 0 || y >= state.coverage.length) return 0;
+			const row = state.coverage[y];
+			if (!(row === null || row === void 0 ? void 0 : row.length)) return 0;
+			let covered = 0;
+			for (let x = 0; x < row.length; x++) if (row[x]) covered++;
+			if (covered === 0) return 0;
+			if (covered >= row.length) return 2;
+			return 1;
+		},
+		scrollRows(plane, startY, endY, lines) {
+			scrollRowsForPlane(plane, startY, endY, lines);
 		}
 	};
 	return base;
@@ -3542,6 +4273,7 @@ function createCliEventManager(options) {
 	let hoverPath = [];
 	const record = options === null || options === void 0 ? void 0 : options.record;
 	const onFocusChange = options === null || options === void 0 ? void 0 : options.onFocusChange;
+	const latency = getCliLatencyProfiler();
 	const MODAL_FOCUS_Z_THRESHOLD = 100;
 	const MODAL_ROOT_MIN_AREA = 40;
 	function focusLockTarget() {
@@ -3719,7 +4451,7 @@ function createCliEventManager(options) {
 			handler(event);
 		} catch (err) {
 			try {
-				const env = process === null || process === void 0 ? void 0 : process.env;
+				const env = process$1 === null || process$1 === void 0 ? void 0 : process$1.env;
 				if ((env === null || env === void 0 ? void 0 : env.DIMCODE_DEBUG) === "1") {
 					const timestamp = new Date().toISOString().split("T")[1].slice(0, -1);
 					appendFileSync("/tmp/goatchain-debug.log", `[${timestamp}] [EVENT-MGR] ERROR in handler ${node.id}.${handlerKey}: ${err}\n`);
@@ -3921,51 +4653,65 @@ function createCliEventManager(options) {
 		},
 		dispatch(event) {
 			record === null || record === void 0 || record(event);
-			if (event.type === "keydown" || event.type === "keyup") return dispatchToFocused(event.type, event);
-			if (event.type === "pointerdown" || event.type === "pointermove" || event.type === "pointerup" || event.type === "click" || event.type === "dblclick" || event.type === "contextmenu" || event.type === "wheel") {
-				if (event.type === "pointerdown") {
-					const list = candidatesAt(event.cellX, event.cellY);
-					const target = pickTarget(list);
-					if (target === null || target === void 0 ? void 0 : target.focusable) setFocus(target.id);
-					capturedId = (target === null || target === void 0 ? void 0 : target.id) ?? null;
-					updateHover(target, event);
-					dispatchPointerEvent("pointerdown", event, target);
-					return false;
-				}
-				if (event.type === "pointermove" && capturedId) {
-					const target = nodes.get(capturedId) ?? null;
-					if (!target) return false;
-					updateHover(target, event);
-					const path = ancestorsForTarget(target);
-					const ev = buildPointerEvent("pointermove", path, event);
-					dispatchWithPhases("pointermove", path, target, ev);
-					return ev.defaultPrevented;
-				}
-				if (event.type === "pointermove") {
-					const list = candidatesAt(event.cellX, event.cellY);
-					const target = pickTarget(list);
-					updateHover(target, event);
-					dispatchPointerEvent("pointermove", event, target);
-					return false;
+			latency === null || latency === void 0 || latency.recordEventDispatchStart(event);
+			let prevented = false;
+			try {
+				if (event.type === "keydown" || event.type === "keyup") {
+					prevented = dispatchToFocused(event.type, event);
+					return prevented;
 				}
-				if (event.type === "pointerup" && capturedId) {
-					const target = nodes.get(capturedId) ?? null;
-					const path = target ? ancestorsForTarget(target) : [];
-					const ev = buildPointerEvent("pointerup", path, event);
-					dispatchWithPhases("pointerup", path, target, ev);
-					capturedId = null;
-					return ev.defaultPrevented;
+				if (event.type === "pointerdown" || event.type === "pointermove" || event.type === "pointerup" || event.type === "click" || event.type === "dblclick" || event.type === "contextmenu" || event.type === "wheel") {
+					if (event.type === "pointerdown") {
+						const list = candidatesAt(event.cellX, event.cellY);
+						const target = pickTarget(list);
+						if (target === null || target === void 0 ? void 0 : target.focusable) setFocus(target.id);
+						capturedId = (target === null || target === void 0 ? void 0 : target.id) ?? null;
+						updateHover(target, event);
+						dispatchPointerEvent("pointerdown", event, target);
+						return prevented;
+					}
+					if (event.type === "pointermove" && capturedId) {
+						const target = nodes.get(capturedId) ?? null;
+						if (!target) return prevented;
+						updateHover(target, event);
+						const path = ancestorsForTarget(target);
+						const ev = buildPointerEvent("pointermove", path, event);
+						dispatchWithPhases("pointermove", path, target, ev);
+						prevented = ev.defaultPrevented;
+						return prevented;
+					}
+					if (event.type === "pointermove") {
+						const list = candidatesAt(event.cellX, event.cellY);
+						const target = pickTarget(list);
+						updateHover(target, event);
+						dispatchPointerEvent("pointermove", event, target);
+						return prevented;
+					}
+					if (event.type === "pointerup" && capturedId) {
+						const target = nodes.get(capturedId) ?? null;
+						const path = target ? ancestorsForTarget(target) : [];
+						const ev = buildPointerEvent("pointerup", path, event);
+						dispatchWithPhases("pointerup", path, target, ev);
+						capturedId = null;
+						prevented = ev.defaultPrevented;
+						return prevented;
+					}
+					if (event.type === "pointerup") {
+						dispatchPointerEvent("pointerup", event);
+						capturedId = null;
+						return prevented;
+					}
+					dispatchPointerEvent(event.type, event);
+					return prevented;
 				}
-				if (event.type === "pointerup") {
-					dispatchPointerEvent("pointerup", event);
-					capturedId = null;
-					return false;
+				if (event.type === "beforeinput" || event.type === "input" || event.type === "compositionstart" || event.type === "compositionupdate" || event.type === "compositionend" || event.type === "paste") {
+					prevented = dispatchToFocusedText(event.type, event);
+					return prevented;
 				}
-				dispatchPointerEvent(event.type, event);
-				return false;
+				return prevented;
+			} finally {
+				latency === null || latency === void 0 || latency.recordEventDispatchEnd(event, { defaultPrevented: prevented });
 			}
-			if (event.type === "beforeinput" || event.type === "input" || event.type === "compositionstart" || event.type === "compositionupdate" || event.type === "compositionend" || event.type === "paste") return dispatchToFocusedText(event.type, event);
-			return false;
 		},
 		debugNodes() {
 			return Array.from(nodes.values()).map((n) => ({
@@ -5057,7 +5803,7 @@ function formatClockTime(ms) {
 }
 function createTuiProfiler(name) {
 	var _unref;
-	const env = process === null || process === void 0 ? void 0 : process.env;
+	const env = process$1 === null || process$1 === void 0 ? void 0 : process$1.env;
 	if (!parseEnabled(env === null || env === void 0 ? void 0 : env.DIMCODE_PROFILE_TUI)) return null;
 	const format = parseLogFormat(env === null || env === void 0 ? void 0 : env.DIMCODE_PROFILE_TUI_FORMAT);
 	const logDest = parseLogDest(env === null || env === void 0 ? void 0 : env.DIMCODE_PROFILE_TUI_LOG_DEST);
@@ -5080,8 +5826,8 @@ function createTuiProfiler(name) {
 	const invalidatePlaneCounts = new Map();
 	const renderPlaneCounts = new Map();
 	const logEveryMs = Number((env === null || env === void 0 ? void 0 : env.DIMCODE_PROFILE_TUI_LOG_EVERY_MS) ?? 1e3);
-	const now$2 = defaultNow;
-	let lastLogAt = now$2();
+	const now$3 = defaultNow;
+	let lastLogAt = now$3();
 	function incrementPlaneCount(target, key) {
 		const normalized = String(key ?? "all").trim() || "all";
 		target.set(normalized, (target.get(normalized) ?? 0) + 1);
@@ -5094,7 +5840,7 @@ function createTuiProfiler(name) {
 		if (dest === "stdout" || dest === "both") console.log(line);
 	}
 	function flushLog() {
-		const at = now$2();
+		const at = now$3();
 		const elapsed = at - lastLogAt;
 		if (elapsed <= 0) return;
 		lastLogAt = at;
@@ -5165,7 +5911,7 @@ function createTuiProfiler(name) {
 	const timer = setInterval(flushLog, Number.isFinite(logEveryMs) ? Math.max(100, logEveryMs) : 1e3);
 	(_unref = timer.unref) === null || _unref === void 0 || _unref.call(timer);
 	return {
-		now: now$2,
+		now: now$3,
 		recordInvalidate(info) {
 			invalidates++;
 			incrementPlaneCount(invalidatePlaneCounts, (info === null || info === void 0 ? void 0 : info.plane) ?? "all");
@@ -5536,7 +6282,7 @@ function write(data) {
 * Check if debug logging is enabled via environment variable
 */
 function isDebugEnabled() {
-	const env = process === null || process === void 0 ? void 0 : process.env;
+	const env = process$1 === null || process$1 === void 0 ? void 0 : process$1.env;
 	return (env === null || env === void 0 ? void 0 : env.DIMCODE_DEBUG) === "1" || (env === null || env === void 0 ? void 0 : env.DEBUG) === "1";
 }
 
@@ -6012,6 +6758,26 @@ function createRenderManager(terminal) {
 			if (y > state.dirtyMaxY) state.dirtyMaxY = y;
 		}
 	}
+	function markRows(plane, rows) {
+		if (!rows.length) return;
+		const state = getDirtyState(plane);
+		for (let i = 0; i < rows.length; i++) {
+			const y = Math.floor(rows[i] ?? -1);
+			if (y < 0 || y >= terminalRows) continue;
+			if (state.dirtyRowBits[y] === 0) {
+				state.dirtyRowBits[y] = 1;
+				state.dirtyRowCount++;
+				if (y < state.dirtyMinY) state.dirtyMinY = y;
+				if (y > state.dirtyMaxY) state.dirtyMaxY = y;
+			}
+		}
+	}
+	function scrollPlane(plane, startY, endY, delta) {
+		scrollPlaneRows(terminal, plane, startY, endY, delta);
+	}
+	function invalidatePlane(plane) {
+		getDirtyState(plane).allRowsDirty = true;
+	}
 	function register(node) {
 		const id = `r${nextNodeId++}`;
 		const rect = node.rect ?? null;
@@ -6039,8 +6805,13 @@ function createRenderManager(terminal) {
 		const nextPlane = next.plane ?? prev.plane;
 		const nextRect = next.rect ?? prev.rect;
 		const { y0, y1 } = rectToYBounds(nextRect);
-		markRect(prev.plane, prev.rect);
-		markRect(nextPlane, nextRect);
+		const dirtyRowsHint = next.dirtyRowsHint;
+		const canUseDirtyRowsHint = nextPlane === prev.plane && dirtyRowsHint != null && dirtyRowsHint.length > 0;
+		if (canUseDirtyRowsHint) markRows(nextPlane, dirtyRowsHint);
+		else {
+			markRect(prev.plane, prev.rect);
+			markRect(nextPlane, nextRect);
+		}
 		const full = Object.freeze({
 			...prev,
 			stack: next.stack ?? prev.stack,
@@ -6102,10 +6873,11 @@ function createRenderManager(terminal) {
 		return false;
 	}
 	function render(options) {
+		var _process;
 		const renderStart = profiler === null || profiler === void 0 ? void 0 : profiler.now();
 		const activePlanes = (options === null || options === void 0 ? void 0 : options.activePlanes) ?? null;
 		const requestedPlanes = activePlanes ?? TERMINAL_RENDER_PLANES;
-		const env = process === null || process === void 0 ? void 0 : process.env;
+		const env = (_process = process) === null || _process === void 0 ? void 0 : _process.env;
 		if ((env === null || env === void 0 ? void 0 : env.DIMCODE_DEBUG) === "1") renderMgrDebugLog.render("[RENDER-MANAGER] render() called");
 		if (!hasPendingDirtyWork(requestedPlanes)) {
 			if ((env === null || env === void 0 ? void 0 : env.DIMCODE_DEBUG) === "1") renderMgrDebugLog.render("[RENDER-MANAGER] render() skipped (no dirty rows)");
@@ -6213,6 +6985,8 @@ function createRenderManager(terminal) {
 	return {
 		rootStack,
 		createStack,
+		invalidatePlane,
+		scrollPlane,
 		register,
 		update,
 		unregister,
@@ -6257,6 +7031,7 @@ function createTerminalApp(options) {
 		rows: options.rows
 	});
 	const trace = createTraceStore({ enabled: Boolean(globalThis.__VT_DEBUG_TRACE__) });
+	const latency = getCliLatencyProfiler();
 	const profiler = createTuiProfiler("cli-scheduler");
 	const events = createCliEventManager({
 		record: (event) => {
@@ -6278,7 +7053,12 @@ function createTerminalApp(options) {
 		}
 	});
 	const render = createRenderManager(terminal);
-	const offCommit = terminal.on("commit", ({ dirtyRows, planes }) => {
+	const offCommit = terminal.on("commit", ({ dirtyRows, planes, sync }) => {
+		latency === null || latency === void 0 || latency.recordCommit({
+			dirtyRows,
+			planes,
+			sync
+		});
 		if (!trace.enabled.value) return;
 		trace.push({
 			type: "commit",
@@ -6295,10 +7075,10 @@ function createTerminalApp(options) {
 	let lastFlushAtMs = 0;
 	let scheduledAtMs = 0;
 	let timer = null;
+	let pendingInvalidateAfterFlush = false;
 	let pendingInvalidateAllPlanes = false;
 	const pendingInvalidatePlanes = new Set();
-	const env = (process === null || process === void 0 ? void 0 : process.env) ?? {};
-	const isGhostty = "GHOSTTY_RESOURCES_DIR" in env;
+	const env = (process$1 === null || process$1 === void 0 ? void 0 : process$1.env) ?? {};
 	const throttleMs = (() => {
 		const raw = env.DIMCODE_TUI_THROTTLE_MS;
 		if (!raw) return 0;
@@ -6307,8 +7087,8 @@ function createTerminalApp(options) {
 	})();
 	const frameThrottleMs = (() => {
 		var _process$stdout;
-		if (!(process === null || process === void 0 || (_process$stdout = process.stdout) === null || _process$stdout === void 0 ? void 0 : _process$stdout.isTTY)) return 0;
-		return isGhostty ? 24 : 16;
+		if (!(process$1 === null || process$1 === void 0 || (_process$stdout = process$1.stdout) === null || _process$stdout === void 0 ? void 0 : _process$stdout.isTTY)) return 0;
+		return 16;
 	})();
 	function queueInvalidatePlane(plane) {
 		if (!plane) {
@@ -6330,16 +7110,31 @@ function createTerminalApp(options) {
 		pendingInvalidatePlanes.clear();
 		return activePlanes;
 	}
-	function flush() {
+	function flush(sync) {
 		if (disposed) return;
 		scheduled = false;
 		flushing = true;
 		const activePlanes = takeActivePlanes();
-		render.render({ activePlanes });
-		terminal.commit({ planes: activePlanes });
-		flushing = false;
-		lastFlushAtMs = Date.now();
-		scheduledAtMs = 0;
+		latency === null || latency === void 0 || latency.recordFlushStart({
+			sync,
+			activePlanes
+		});
+		try {
+			render.render({ activePlanes });
+			terminal.commit({
+				planes: activePlanes,
+				sync
+			});
+		} finally {
+			latency === null || latency === void 0 || latency.recordFlushEnd();
+			flushing = false;
+			lastFlushAtMs = Date.now();
+			scheduledAtMs = 0;
+		}
+		if (pendingInvalidateAfterFlush) {
+			pendingInvalidateAfterFlush = false;
+			flush(true);
+		}
 	}
 	function clearScheduledTimer() {
 		if (!timer) return;
@@ -6360,7 +7155,7 @@ function createTerminalApp(options) {
 		}
 		clearScheduledTimer();
 		scheduledAtMs = nowMs;
-		if (typeof process.nextTick === "function") process.nextTick(() => {
+		if (typeof process$1.nextTick === "function") process$1.nextTick(() => {
 			flush();
 		});
 		else if (typeof globalThis.setImmediate === "function") globalThis.setImmediate(() => {
@@ -6375,14 +7170,26 @@ function createTerminalApp(options) {
 		if (flushing) return;
 		clearScheduledTimer();
 		scheduled = false;
-		flush();
+		flush(true);
 	}
 	function invalidate(options$1) {
 		if (disposed) return;
-		if (flushing) return;
 		const priority = (options$1 === null || options$1 === void 0 ? void 0 : options$1.priority) ?? "normal";
+		latency === null || latency === void 0 || latency.recordSchedulerInvalidate({
+			priority,
+			plane: (options$1 === null || options$1 === void 0 ? void 0 : options$1.plane) ?? null
+		});
+		if (flushing) {
+			queueInvalidatePlane(options$1 === null || options$1 === void 0 ? void 0 : options$1.plane);
+			pendingInvalidateAfterFlush = true;
+			return;
+		}
 		queueInvalidatePlane(options$1 === null || options$1 === void 0 ? void 0 : options$1.plane);
 		profiler === null || profiler === void 0 || profiler.recordInvalidate({ plane: (options$1 === null || options$1 === void 0 ? void 0 : options$1.plane) ?? null });
+		if (priority === "high") {
+			flushNow();
+			return;
+		}
 		const nowMs = Date.now();
 		const throttleDelayMs = throttleMs > 0 ? Math.max(0, lastFlushAtMs + throttleMs - nowMs) : 0;
 		const laneDelayMs = priority === "low" ? Math.max(throttleDelayMs, frameThrottleMs || 16) : priority === "normal" ? Math.max(throttleDelayMs, frameThrottleMs) : 0;
@@ -6519,6 +7326,7 @@ function createTerminalApp(options) {
 		dispose() {
 			if (disposed) return;
 			disposed = true;
+			clearScheduledTimer();
 			if (mounted) app.unmount();
 			offResize === null || offResize === void 0 || offResize();
 			offCommit === null || offCommit === void 0 || offCommit();
@@ -6602,7 +7410,7 @@ function parseWriteMode(raw) {
 }
 function createStdoutRenderer(terminal, options) {
 	var _ref3;
-	const output = (options === null || options === void 0 ? void 0 : options.output) ?? process.stdout;
+	const output = (options === null || options === void 0 ? void 0 : options.output) ?? process$1.stdout;
 	if (!output) throw new Error("createStdoutRenderer requires a Node stdout-like output");
 	const out = output;
 	const clear = (options === null || options === void 0 ? void 0 : options.clear) ?? true;
@@ -6612,22 +7420,23 @@ function createStdoutRenderer(terminal, options) {
 	let palette = options === null || options === void 0 ? void 0 : options.palette;
 	const trackResize = (options === null || options === void 0 ? void 0 : options.trackResize) ?? true;
 	const getImeAnchor = options === null || options === void 0 ? void 0 : options.getImeAnchor;
+	const cliLatency = getCliLatencyProfiler();
 	const profiler = createTuiProfiler("stdout-renderer");
 	function resolveUseSyncOutput() {
 		if ((options === null || options === void 0 ? void 0 : options.useSyncOutput) != null) return options.useSyncOutput;
-		const env$1 = (process === null || process === void 0 ? void 0 : process.env) ?? {};
+		const env$1 = (process$1 === null || process$1 === void 0 ? void 0 : process$1.env) ?? {};
 		const envValue = env$1.DIMCODE_SYNC_OUTPUT;
 		if (envValue != null) {
 			const v = String(envValue).trim().toLowerCase();
 			return v === "1" || v === "true" || v === "yes";
 		}
-		const term = String(env$1.TERM ?? "").toLowerCase();
-		const termProgram = String(env$1.TERM_PROGRAM ?? "").toLowerCase();
+		const term$1 = String(env$1.TERM ?? "").toLowerCase();
+		const termProgram$1 = String(env$1.TERM_PROGRAM ?? "").toLowerCase();
 		const termProgramVersion = env$1.TERM_PROGRAM_VERSION;
 		const isGhostty$1 = "GHOSTTY_RESOURCES_DIR" in env$1;
-		const isProblematicTerminal = isGhostty$1 || termProgram.includes("apple_terminal") || term.includes("screen") && !term.includes("tmux");
+		const isProblematicTerminal = isGhostty$1 || termProgram$1.includes("apple_terminal") || term$1.includes("screen") && !term$1.includes("tmux");
 		if (isProblematicTerminal) return false;
-		const isGoodTerminal = termProgram.includes("iterm") && termProgramVersion && compareVersion(String(termProgramVersion), "3.5.0") >= 0;
+		const isGoodTerminal = termProgram$1.includes("iterm") && termProgramVersion && compareVersion(String(termProgramVersion), "3.5.0") >= 0;
 		if (isGoodTerminal) return true;
 		return false;
 	}
@@ -6647,8 +7456,8 @@ function createStdoutRenderer(terminal, options) {
 		return 0;
 	}
 	const useSyncOutput = resolveUseSyncOutput();
-	const isGhostty = "GHOSTTY_RESOURCES_DIR" in ((process === null || process === void 0 ? void 0 : process.env) ?? {});
-	const env = (process === null || process === void 0 ? void 0 : process.env) ?? {};
+	const isGhostty = "GHOSTTY_RESOURCES_DIR" in ((process$1 === null || process$1 === void 0 ? void 0 : process$1.env) ?? {});
+	const env = (process$1 === null || process$1 === void 0 ? void 0 : process$1.env) ?? {};
 	const forcedWriteMode = parseWriteMode(env.DIMCODE_TUI_WRITE_MODE ?? env.VUE_TUI_WRITE_MODE);
 	const forcedChunkSize = Number(env.DIMCODE_TUI_CHUNK_SIZE ?? env.VUE_TUI_CHUNK_SIZE);
 	const chunkSize = Number.isFinite(forcedChunkSize) ? Math.max(512, Math.floor(forcedChunkSize)) : 8 * 1024;
@@ -6663,12 +7472,15 @@ function createStdoutRenderer(terminal, options) {
 		if (Number.isFinite(n)) return Math.min(1, Math.max(.05, n));
 		return .6;
 	})();
-	const disableCursorPos = isGhostty && (process === null || process === void 0 || (_ref3 = process.env) === null || _ref3 === void 0 ? void 0 : _ref3.DIMCODE_DISABLE_CURSOR_POS) === "1";
-	const overlayTerminal = getPlaneTerminal(terminal, "overlay");
+	const disableCursorPos = isGhostty && (process$1 === null || process$1 === void 0 || (_ref3 = process$1.env) === null || _ref3 === void 0 ? void 0 : _ref3.DIMCODE_DISABLE_CURSOR_POS) === "1";
+	const termProgram = String(env.TERM_PROGRAM ?? "").trim().toLowerCase();
+	const term = String(env.TERM ?? "").trim().toLowerCase();
+	const isVscodeTerminal = termProgram === "vscode" || "VSCODE_PID" in env || "VSCODE_IPC_HOOK_CLI" in env;
+	const useConservativeDirtyRowRendering = out.isTTY !== false && !isVscodeTerminal && (isGhostty || "KITTY_WINDOW_ID" in env || "ALACRITTY_WINDOW_ID" in env || "ALACRITTY_LOG" in env || "WEZTERM_PANE" in env || "WEZTERM_EXECUTABLE" in env || termProgram.includes("kitty") || termProgram.includes("alacritty") || termProgram.includes("wezterm") || term.includes("kitty") || term.includes("alacritty"));
 	const enableOsc8Links = (() => {
 		if (!out.isTTY) return false;
 		const raw = String(env.DIMCODE_TUI_LINKS ?? "").trim().toLowerCase();
-		if (!raw) return !(String(env.TERM_PROGRAM ?? "").trim().toLowerCase() === "vscode" || "VSCODE_PID" in env || "VSCODE_IPC_HOOK_CLI" in env);
+		if (!raw) return !isVscodeTerminal;
 		return !(raw === "0" || raw === "false" || raw === "no");
 	})();
 	let disposed = false;
@@ -6676,12 +7488,16 @@ function createStdoutRenderer(terminal, options) {
 	let pendingRender = false;
 	let renderTimer = null;
 	let writeEmaMs = 0;
+	let lastCursorX = null;
+	let lastCursorY = null;
 	let accumulatedAllRows = false;
 	let accumulatedDirtyBits = null;
 	let accumulatedDirtyCount = 0;
 	let accumulatedDirtyMin = Number.POSITIVE_INFINITY;
 	let accumulatedDirtyMax = -1;
-	const MIN_FRAME_MS = !out.isTTY ? 0 : isGhostty ? 24 : 16;
+	let accumulatedScrollOperations = null;
+	let accumulatedSkipUnchangedDirtyRows = true;
+	const MIN_FRAME_MS = !out.isTTY ? 0 : 16;
 	function clampCellToViewport(cell, size) {
 		const maxX = Math.max(0, Math.floor(size.cols) - 1);
 		const maxY = Math.max(0, Math.floor(size.rows) - 1);
@@ -6697,25 +7513,43 @@ function createStdoutRenderer(terminal, options) {
 	function resolveColorMode() {
 		const opt = (options === null || options === void 0 ? void 0 : options.colorMode) ?? "auto";
 		if (opt !== "auto") return opt;
-		const env$1 = (process === null || process === void 0 ? void 0 : process.env) ?? {};
+		const env$1 = (process$1 === null || process$1 === void 0 ? void 0 : process$1.env) ?? {};
 		return detectTerminalColorCapability({
 			env: env$1,
 			isTTY: Boolean(out.isTTY),
-			platform: String((process === null || process === void 0 ? void 0 : process.platform) ?? "")
+			platform: String((process$1 === null || process$1 === void 0 ? void 0 : process$1.platform) ?? "")
 		}).mode;
 	}
 	const colorMode = resolveColorMode();
 	const enableDim = colorMode === "truecolor";
+	const COLOR_INDEX = {
+		black: 1,
+		red: 2,
+		green: 3,
+		yellow: 4,
+		blue: 5,
+		magenta: 6,
+		cyan: 7,
+		white: 8,
+		blackBright: 9,
+		redBright: 10,
+		greenBright: 11,
+		yellowBright: 12,
+		blueBright: 13,
+		magentaBright: 14,
+		cyanBright: 15,
+		whiteBright: 16
+	};
 	let styleKeyCache$1 = new WeakMap();
 	function styleKey$1(style) {
 		const cached = styleKeyCache$1.get(style);
-		if (cached) return cached;
-		const key = `${style.fg ?? ""}|${style.bg ?? defaultBg}|${style.bold ? 1 : 0}|${enableDim && style.dim ? 1 : 0}|${style.italic ? 1 : 0}|${style.underline ? 1 : 0}|${style.inverse ? 1 : 0}|${style.href ?? ""}`;
+		if (cached !== void 0) return cached;
+		const key = (COLOR_INDEX[style.fg] ?? 0) | (COLOR_INDEX[style.bg ?? defaultBg] ?? 0) << 5 | (style.bold ? 1024 : 0) | (enableDim && style.dim ? 2048 : 0) | (style.italic ? 4096 : 0) | (style.underline ? 8192 : 0) | (style.inverse ? 16384 : 0) | (style.href ? 32768 : 0);
 		styleKeyCache$1.set(style, key);
 		return key;
 	}
 	function styleKeyFromParts(style) {
-		return `${style.fg ?? ""}|${style.bg ?? defaultBg}|${style.bold ? 1 : 0}|${enableDim && style.dim ? 1 : 0}|${style.italic ? 1 : 0}|${style.underline ? 1 : 0}|${style.inverse ? 1 : 0}|${style.href ?? ""}`;
+		return (COLOR_INDEX[style.fg] ?? 0) | (COLOR_INDEX[style.bg ?? defaultBg] ?? 0) << 5 | (style.bold ? 1024 : 0) | (enableDim && style.dim ? 2048 : 0) | (style.italic ? 4096 : 0) | (style.underline ? 8192 : 0) | (style.inverse ? 16384 : 0) | (style.href ? 32768 : 0);
 	}
 	function openColor(fg) {
 		if (!fg) return "";
@@ -6747,7 +7581,45 @@ function createStdoutRenderer(terminal, options) {
 		return result;
 	}
 	let lastRenderedRows = 0;
-	let renderedRowCache = [];
+	let fpCols = 0;
+	let fpRows = 0;
+	let currentFP = new Uint32Array(0);
+	let prevFP = new Uint32Array(0);
+	let fpPrevValid = false;
+	let prevOverlayBlockedRows = [];
+	let prevOverlayPartialRows = [];
+	function ensureFingerprints(cols, rows) {
+		if (cols === fpCols && rows === fpRows) return;
+		fpCols = cols;
+		fpRows = rows;
+		const len = cols * rows;
+		currentFP = new Uint32Array(len);
+		prevFP = new Uint32Array(len);
+		fpPrevValid = false;
+		prevOverlayBlockedRows = [];
+		prevOverlayPartialRows = [];
+	}
+	function charHash16(ch) {
+		if (ch.length <= 1) return ch.charCodeAt(0) || 0;
+		let h$1 = 33052;
+		for (let i = 0; i < ch.length; i++) {
+			h$1 ^= ch.charCodeAt(i);
+			h$1 = h$1 * 257 & 65535;
+		}
+		return h$1;
+	}
+	function fingerprintRow(row, y, cols) {
+		const rowFP = terminal.getRowFingerprints(y);
+		if (rowFP && rowFP.length >= cols) {
+			currentFP.set(rowFP.subarray(0, cols), y * fpCols);
+			return;
+		}
+		const base = y * fpCols;
+		for (let x = 0; x < cols; x++) {
+			const cell = row[x];
+			currentFP[base + x] = styleKey$1(cell.style) << 16 | charHash16(cell.ch);
+		}
+	}
 	const rowCursorToCol1 = [];
 	const rowClearToEol = [];
 	const rowTextPartsScratch = [];
@@ -6765,13 +7637,6 @@ function createStdoutRenderer(terminal, options) {
 			rowClearToEol[y] = `\u001B[${y + 1};1H\u001B[K`;
 		}
 	};
-	const ensureRenderedRowCache = (rows) => {
-		if (renderedRowCache.length > rows) {
-			renderedRowCache.length = rows;
-			return;
-		}
-		while (renderedRowCache.length < rows) renderedRowCache.push([]);
-	};
 	const expandSpanStart = (row, startX) => {
 		var _row$x;
 		let x = Math.max(0, Math.min(row.length, startX));
@@ -6788,30 +7653,279 @@ function createStdoutRenderer(terminal, options) {
 		}
 		return x;
 	};
-	const resolveChangedSpan = (row, prevRow) => {
-		if (!prevRow || prevRow.length !== row.length) return row.length ? {
+	const resolveChangedSpan = (row, y, cols) => {
+		if (!fpCols || y >= fpRows || !fpPrevValid) return row.length ? {
+			startX: 0,
+			endXExclusive: row.length
+		} : null;
+		const base = y * fpCols;
+		let startX = -1;
+		let endXExclusive = -1;
+		for (let x = 0; x < cols; x++) {
+			if (currentFP[base + x] === prevFP[base + x]) continue;
+			if (startX === -1) startX = x;
+			endXExclusive = x + 1;
+		}
+		if (startX === -1) return null;
+		const expandedStart = expandSpanStart(row, startX);
+		const expandedEnd = expandSpanEnd(row, endXExclusive);
+		return expandedEnd > expandedStart ? {
+			startX: expandedStart,
+			endXExclusive: expandedEnd
+		} : null;
+	};
+	const resolveChangedSpanAgainstFill = (row, y, cols, fillFingerprint) => {
+		if (!fpCols || y >= fpRows) return row.length ? {
 			startX: 0,
 			endXExclusive: row.length
 		} : null;
+		const base = y * fpCols;
 		let startX = -1;
 		let endXExclusive = -1;
-		for (let x = 0; x < row.length; x++) {
-			if (row[x] === prevRow[x]) continue;
+		for (let x = 0; x < cols; x++) {
+			if (currentFP[base + x] === fillFingerprint) continue;
 			if (startX === -1) startX = x;
 			endXExclusive = x + 1;
 		}
-		if (startX === -1 || endXExclusive === -1) return null;
-		const expandedStart = Math.min(expandSpanStart(row, startX), expandSpanStart(prevRow, startX));
-		const expandedEnd = Math.max(expandSpanEnd(row, endXExclusive), expandSpanEnd(prevRow, endXExclusive));
+		if (startX === -1) return null;
+		const expandedStart = expandSpanStart(row, startX);
+		const expandedEnd = expandSpanEnd(row, endXExclusive);
 		return expandedEnd > expandedStart ? {
 			startX: expandedStart,
 			endXExclusive: expandedEnd
 		} : null;
 	};
-	function overlayPlaneHasVisibleContent() {
-		const lines = overlayTerminal.snapshot().lines;
-		for (const line of lines) for (let i = 0; i < line.length; i++) if (line.charCodeAt(i) !== 32) return true;
+	const resolveChangedSpanAgainstReference = (row, y, cols) => {
+		if (!fpCols || y >= fpRows) return row.length ? {
+			startX: 0,
+			endXExclusive: row.length
+		} : null;
+		const rowFP = terminal.getRowFingerprints(y);
+		const base = y * fpCols;
+		let startX = -1;
+		let endXExclusive = -1;
+		for (let x = 0; x < cols; x++) {
+			const fingerprint = rowFP && rowFP.length >= cols ? rowFP[x] : styleKey$1(row[x].style) << 16 | charHash16(row[x].ch);
+			if (fingerprint === currentFP[base + x]) continue;
+			if (startX === -1) startX = x;
+			endXExclusive = x + 1;
+		}
+		if (startX === -1) return null;
+		const expandedStart = expandSpanStart(row, startX);
+		const expandedEnd = expandSpanEnd(row, endXExclusive);
+		return expandedEnd > expandedStart ? {
+			startX: expandedStart,
+			endXExclusive: expandedEnd
+		} : null;
+	};
+	const rowMatchesPreviousFrame = (y, cols) => {
+		if (!fpCols || y < 0 || y >= fpRows || !fpPrevValid) return false;
+		const rowFP = terminal.getRowFingerprints(y);
+		const row = rowFP && rowFP.length >= cols ? null : terminal.getRow(y);
+		const base = y * fpCols;
+		for (let x = 0; x < cols; x++) {
+			const fingerprint = rowFP && rowFP.length >= cols ? rowFP[x] : styleKey$1(row[x].style) << 16 | charHash16(row[x].ch);
+			if (fingerprint !== prevFP[base + x]) return false;
+		}
+		return true;
+	};
+	const rowHasNonDefaultBlankCell = (source, y, cols) => {
+		if (!fpCols || y < 0 || y >= fpRows) return false;
+		const blankFP = styleKeyFromParts({ bg: defaultBg }) << 16 | charHash16(" ");
+		const base = y * fpCols;
+		const limit = Math.min(cols, fpCols);
+		for (let x = 0; x < limit; x++) if (source[base + x] !== blankFP) return true;
 		return false;
+	};
+	function overlayPlaneCoverageRows(totalRows) {
+		const blockedRows = [];
+		const partialRows = [];
+		for (let y = 0; y < totalRows; y++) {
+			const kind = getPlaneRowCoverageKind(terminal, "overlay", y);
+			if (!kind) continue;
+			blockedRows.push(y);
+			if (kind === 1) partialRows.push(y);
+		}
+		return {
+			blockedRows,
+			partialRows
+		};
+	}
+	const enableScrollRegions = (() => {
+		const raw = String(env.DIMCODE_TUI_SCROLL_REGIONS ?? "").trim();
+		if (raw === "0" || raw === "false") return false;
+		if (isGhostty || isVscodeTerminal) return false;
+		return out.isTTY !== false;
+	})();
+	function prepareExplicitScrollOperations(operations, blockedRows) {
+		if (!operations.length || !(blockedRows === null || blockedRows === void 0 ? void 0 : blockedRows.size)) return {
+			operations,
+			hiddenRows: new Set(),
+			trimmed: false,
+			blockedInterior: false
+		};
+		const hiddenRows = new Set();
+		const prepared = [];
+		let trimmed = false;
+		for (const op of operations) {
+			let startY = op.startY;
+			let endY = op.endY;
+			while (startY < endY && blockedRows.has(startY)) {
+				hiddenRows.add(startY);
+				startY++;
+				trimmed = true;
+			}
+			while (endY > startY && blockedRows.has(endY - 1)) {
+				hiddenRows.add(endY - 1);
+				endY--;
+				trimmed = true;
+			}
+			for (let y = startY; y < endY; y++) {
+				if (!blockedRows.has(y)) continue;
+				return {
+					operations: null,
+					hiddenRows,
+					trimmed,
+					blockedInterior: true
+				};
+			}
+			if (endY <= startY || Math.abs(op.delta) >= endY - startY) return {
+				operations: null,
+				hiddenRows,
+				trimmed,
+				blockedInterior: false
+			};
+			prepared.push(startY === op.startY && endY === op.endY ? op : {
+				startY,
+				endY,
+				delta: op.delta
+			});
+		}
+		return {
+			operations: prepared,
+			hiddenRows,
+			trimmed,
+			blockedInterior: false
+		};
+	}
+	/**
+	* Detect if the current frame represents a pure vertical scroll by comparing
+	* current fingerprints against previous fingerprints with various shift offsets.
+	* Returns the shift delta and which rows are newly revealed, or null if no
+	* scroll pattern is detected.
+	*/
+	function largestDirtyBand(rows, blockedRows) {
+		if (rows.length === 0) return null;
+		const blocked = (blockedRows === null || blockedRows === void 0 ? void 0 : blockedRows.length) ? new Set(blockedRows) : null;
+		let bestStart = -1;
+		let bestEnd = -1;
+		let bandStart = -1;
+		let prev = -1;
+		for (let i = 0; i < rows.length; i++) {
+			const y = rows[i];
+			if (blocked === null || blocked === void 0 ? void 0 : blocked.has(y)) {
+				if (bandStart !== -1 && prev + 1 - bandStart > bestEnd - bestStart) {
+					bestStart = bandStart;
+					bestEnd = prev + 1;
+				}
+				bandStart = -1;
+				prev = -1;
+				continue;
+			}
+			if (bandStart === -1) {
+				bandStart = y;
+				prev = y;
+				if (bestStart === -1) {
+					bestStart = y;
+					bestEnd = y + 1;
+				}
+				continue;
+			}
+			if (y === prev + 1) {
+				prev = y;
+				continue;
+			}
+			if (prev + 1 - bandStart > bestEnd - bestStart) {
+				bestStart = bandStart;
+				bestEnd = prev + 1;
+			}
+			bandStart = y;
+			prev = y;
+		}
+		if (bandStart !== -1 && prev + 1 - bandStart > bestEnd - bestStart) {
+			bestStart = bandStart;
+			bestEnd = prev + 1;
+		}
+		if (bestStart === -1) return null;
+		const outsideRows = [];
+		for (const y of rows) if ((blocked === null || blocked === void 0 ? void 0 : blocked.has(y)) || y < bestStart || y >= bestEnd) outsideRows.push(y);
+		return {
+			start: bestStart,
+			end: bestEnd,
+			outsideRows
+		};
+	}
+	function detectScrollShift(cols, dirtyRows, blockedRows) {
+		if (!fpPrevValid || !fpCols || cols !== fpCols) return null;
+		const band = largestDirtyBand(dirtyRows, blockedRows);
+		if (!band || band.end - band.start < 3) return null;
+		const maxDelta = Math.min(12, Math.max(5, band.end - band.start - 1));
+		for (let delta = -maxDelta; delta <= maxDelta; delta++) {
+			if (delta === 0) continue;
+			let matches = 0;
+			let checked = 0;
+			let mismatches = 0;
+			for (let y = band.start; y < band.end; y++) {
+				const srcY = y + delta;
+				if (srcY < band.start || srcY >= band.end) continue;
+				const informative = rowHasNonDefaultBlankCell(currentFP, y, cols) || rowHasNonDefaultBlankCell(prevFP, srcY, cols);
+				if (!informative) continue;
+				checked++;
+				const curBase = y * fpCols;
+				const prevBase = srcY * fpCols;
+				let rowMatch = true;
+				for (let x = 0; x < cols; x++) if (currentFP[curBase + x] !== prevFP[prevBase + x]) {
+					rowMatch = false;
+					break;
+				}
+				if (rowMatch) matches++;
+				else mismatches++;
+			}
+			if (checked > 0 && matches >= 3 && mismatches <= Math.ceil(checked * .2)) {
+				const absDelta = Math.abs(delta);
+				let newRowStart;
+				let newRowEnd;
+				if (delta > 0) {
+					newRowStart = Math.max(band.start, band.end - absDelta);
+					newRowEnd = band.end;
+				} else {
+					newRowStart = band.start;
+					newRowEnd = Math.min(band.end, band.start + absDelta);
+				}
+				const extraDirty = [...band.outsideRows];
+				for (let y = band.start; y < band.end; y++) {
+					const srcY = y + delta;
+					if (srcY < band.start || srcY >= band.end) continue;
+					const curBase = y * fpCols;
+					const prevBase = srcY * fpCols;
+					let rowMatch = true;
+					for (let x = 0; x < cols; x++) if (currentFP[curBase + x] !== prevFP[prevBase + x]) {
+						rowMatch = false;
+						break;
+					}
+					if (!rowMatch) extraDirty.push(y);
+				}
+				return {
+					regionStart: band.start,
+					regionEnd: band.end,
+					delta,
+					newRowStart,
+					newRowEnd,
+					extraDirtyRows: extraDirty
+				};
+			}
+		}
+		return null;
 	}
 	/**
 	* Write data in chunks to avoid overwhelming terminal buffers.
@@ -6849,24 +7963,60 @@ function createStdoutRenderer(terminal, options) {
 	* Internal function that actually renders the frame to stdout.
 	* When dirtyRows is provided, only those rows are repainted.
 	*/
-	function doRender(dirtyRows) {
+	function doRender(dirtyRows, scrollOperations, skipUnchangedDirtyRows = false) {
 		if (isDebugEnabled()) getDebugLog().render(`doRender() START: dirtyRows=${(dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) ?? "null"}`);
 		if (disposed) return;
+		cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutRenderStart();
 		pendingRender = false;
 		accumulatedAllRows = false;
 		accumulatedDirtyBits = null;
 		accumulatedDirtyCount = 0;
 		accumulatedDirtyMin = Number.POSITIVE_INFINITY;
 		accumulatedDirtyMax = -1;
+		accumulatedScrollOperations = null;
+		accumulatedSkipUnchangedDirtyRows = true;
 		lastFrameTime = Date.now();
 		const renderStart = performance.now();
 		const size = terminal.size();
 		ensureRowEscapes(Math.max(size.rows, lastRenderedRows));
-		ensureRenderedRowCache(size.rows);
+		ensureFingerprints(size.cols, size.rows);
 		const bgSeq = openBg(defaultBg);
 		const bgOnlyStyle = { bg: defaultBg };
 		const bgKey = styleKeyFromParts({ bg: defaultBg });
+		const blankFP = bgKey << 16 | charHash16(" ");
+		const cellFingerprint = (cell) => styleKey$1(cell.style) << 16 | charHash16(cell.ch);
+		const lastOccupiedColumnInRow = (row, cols) => {
+			const limit = Math.min(row.length, cols);
+			for (let x = limit - 1; x >= 0; x--) if (cellFingerprint(row[x]) !== blankFP) return x;
+			return -1;
+		};
+		const lastOccupiedColumnInReference = (source, y, cols) => {
+			if (!fpCols || y < 0 || y >= fpRows) return -1;
+			const limit = Math.min(fpCols, cols);
+			const base = y * fpCols;
+			for (let x = limit - 1; x >= 0; x--) if (source[base + x] !== blankFP) return x;
+			return -1;
+		};
+		const shouldRewriteRowTail = (row, y, cols, reference) => lastOccupiedColumnInRow(row, cols) < lastOccupiedColumnInReference(reference, y, cols);
 		let dirtySorted = true;
+		const normalizedScrollOperations = (() => {
+			if (!(scrollOperations === null || scrollOperations === void 0 ? void 0 : scrollOperations.length)) return null;
+			const outOps = [];
+			for (const op of scrollOperations) {
+				const startY = Math.max(0, Math.min(size.rows, Math.floor(op.startY)));
+				const endY = Math.max(0, Math.min(size.rows, Math.floor(op.endY)));
+				const delta = Math.trunc(op.delta);
+				if (endY <= startY || delta === 0 || Math.abs(delta) >= endY - startY) continue;
+				outOps.push({
+					startY,
+					endY,
+					delta
+				});
+			}
+			if (!outOps.length) return null;
+			outOps.sort((a, b) => a.startY - b.startY);
+			return outOps;
+		})();
 		let rowsToRender = (() => {
 			if (!dirtyRows || dirtyRows.length === 0) return null;
 			const outRows = [];
@@ -6887,11 +8037,14 @@ function createStdoutRenderer(terminal, options) {
 			if (!sorted) outRows.sort((a, b) => a - b);
 			return outRows;
 		})();
-		if (rowsToRender && rowsToRender.length >= size.rows * dirtyFullThreshold) rowsToRender = null;
+		if (fpPrevValid && rowsToRender) currentFP.set(prevFP);
 		const frameParts = [];
 		frameParts.push(!isGhostty && useSyncOutput ? SYNC_START : "");
 		frameParts.push("\x1B[?7l");
 		frameParts.push(SGR_RESET, bgSeq);
+		let lastRenderedY = -1;
+		let lastRenderWasFullRow = false;
+		let hasFrameOutput = false;
 		let activeStyleKey = null;
 		let activeStyle = {
 			fg: null,
@@ -6942,11 +8095,10 @@ function createStdoutRenderer(terminal, options) {
 		const renderRow$1 = (y, row, startX = 0, endXExclusive = row.length, clearToEol = true) => {
 			const spanStart = Math.max(0, Math.min(row.length, Math.floor(startX)));
 			const spanEnd = Math.max(spanStart, Math.min(row.length, Math.floor(endXExclusive)));
-			if (spanStart >= spanEnd && !clearToEol) {
-				renderedRowCache[y] = row.slice();
-				return;
-			}
-			if (!disableCursorPos) frameParts.push(spanStart === 0 ? rowCursorToCol1[y] : `\u001B[${y + 1};${spanStart + 1}H`);
+			if (spanStart >= spanEnd && !clearToEol) return;
+			hasFrameOutput = true;
+			if (!disableCursorPos) if (spanStart === 0 && lastRenderWasFullRow && y === lastRenderedY + 1) frameParts.push("\r\n");
+			else frameParts.push(spanStart === 0 ? rowCursorToCol1[y] : `\u001B[${y + 1};${spanStart + 1}H`);
 			let currentKey = null;
 			let currentStyle = null;
 			const currentTextParts = rowTextPartsScratch;
@@ -6964,7 +8116,7 @@ function createStdoutRenderer(terminal, options) {
 					if (needsWideCursorFix(cell, ch)) currentTextParts.push(`\u001B[${y + 1};${x + 1 + (cell.width ?? 1)}H`);
 					continue;
 				}
-				if (key === currentKey) {
+				if (key === currentKey && !(key & 32768 && nextStyle.href !== (currentStyle === null || currentStyle === void 0 ? void 0 : currentStyle.href))) {
 					currentTextParts.push(ch);
 					if (needsWideCursorFix(cell, ch)) currentTextParts.push(`\u001B[${y + 1};${x + 1 + (cell.width ?? 1)}H`);
 					continue;
@@ -6985,29 +8137,237 @@ function createStdoutRenderer(terminal, options) {
 				if (activeStyleKey !== bgKey) emitStyle(bgOnlyStyle, bgKey);
 				frameParts.push("\x1B[K");
 			}
-			renderedRowCache[y] = row.slice();
+			lastRenderedY = y;
+			lastRenderWasFullRow = spanStart === 0 && clearToEol;
 		};
-		if (!rowsToRender) {
+		const overlayCoverage = overlayPlaneCoverageRows(size.rows);
+		const overlayRows = Array.from(new Set([...overlayCoverage.blockedRows, ...prevOverlayBlockedRows])).sort((a, b) => a - b);
+		const overlayRowSet = overlayRows.length ? new Set(overlayRows) : null;
+		const overlayPartialRows = Array.from(new Set([...overlayCoverage.partialRows, ...prevOverlayPartialRows])).sort((a, b) => a - b);
+		const overlayPartialRowSet = overlayPartialRows.length ? new Set(overlayPartialRows) : null;
+		const overlayTouchedRowSet = (() => {
+			if (!overlayRowSet && !overlayPartialRowSet) return null;
+			return new Set([...overlayRowSet ? Array.from(overlayRowSet) : [], ...overlayPartialRowSet ? Array.from(overlayPartialRowSet) : []]);
+		})();
+		let explicitScrollOperations = normalizedScrollOperations;
+		let hiddenExplicitDirtyRows = null;
+		let allowInferredScrollRegions = true;
+		if (explicitScrollOperations && overlayRows.length) {
+			const preparedExplicit = prepareExplicitScrollOperations(explicitScrollOperations, overlayRowSet);
+			hiddenExplicitDirtyRows = preparedExplicit.hiddenRows.size ? preparedExplicit.hiddenRows : null;
+			if (preparedExplicit.operations) {
+				explicitScrollOperations = preparedExplicit.operations;
+				if (preparedExplicit.trimmed && isDebugEnabled()) getDebugLog().render(` Explicit scroll ops clipped around overlay rows: ${normalizedScrollOperations.map((op, index) => `${op.startY}-${op.endY - 1}:${op.delta}->${explicitScrollOperations[index].startY}-${explicitScrollOperations[index].endY - 1}:${explicitScrollOperations[index].delta}`).join(", ")}`);
+			} else {
+				allowInferredScrollRegions = false;
+				const expandedRows = new Set(rowsToRender ?? []);
+				for (const op of explicitScrollOperations) for (let y = op.startY; y < op.endY; y++) expandedRows.add(y);
+				rowsToRender = Array.from(expandedRows).sort((a, b) => a - b);
+				dirtySorted = true;
+				explicitScrollOperations = null;
+				hiddenExplicitDirtyRows = null;
+				if (isDebugEnabled()) getDebugLog().render(preparedExplicit.blockedInterior ? " Explicit scroll ops split by interior overlay rows; falling back to region repaint" : " Explicit scroll ops could not be clipped safely; falling back to region repaint");
+			}
+		}
+		const scrollRowsCandidate = rowsToRender;
+		if (explicitScrollOperations && rowsToRender && (!enableScrollRegions || !fpPrevValid)) {
+			const expandedRows = new Set(rowsToRender);
+			for (const op of explicitScrollOperations) for (let y = op.startY; y < op.endY; y++) {
+				if (hiddenExplicitDirtyRows === null || hiddenExplicitDirtyRows === void 0 ? void 0 : hiddenExplicitDirtyRows.has(y)) continue;
+				expandedRows.add(y);
+			}
+			rowsToRender = Array.from(expandedRows).sort((a, b) => a - b);
+			dirtySorted = true;
+			explicitScrollOperations = null;
+			hiddenExplicitDirtyRows = null;
+			if (isDebugEnabled()) getDebugLog().render(enableScrollRegions ? " Explicit scroll ops fell back to region repaint because previous fingerprints are unavailable" : " Explicit scroll ops fell back to region repaint because scroll regions are disabled");
+		}
+		const denseDirtyRows = Boolean(rowsToRender && rowsToRender.length >= size.rows * dirtyFullThreshold);
+		if (denseDirtyRows) rowsToRender = null;
+		let profiledRowCount = rowsToRender ? rowsToRender.length : size.rows;
+		const useScrollRegions = enableScrollRegions && fpPrevValid && scrollRowsCandidate && scrollRowsCandidate.length >= 3 && allowInferredScrollRegions;
+		let scrollHandled = false;
+		if (enableScrollRegions && explicitScrollOperations && scrollRowsCandidate && fpPrevValid) {
+			if (currentFP.length === prevFP.length) currentFP.set(prevFP);
+			const insertedRows = new Set();
+			const explicitRowsToRender = new Set();
+			for (const y of scrollRowsCandidate) {
+				if (hiddenExplicitDirtyRows === null || hiddenExplicitDirtyRows === void 0 ? void 0 : hiddenExplicitDirtyRows.has(y)) continue;
+				explicitRowsToRender.add(y);
+			}
+			if (isDebugEnabled()) getDebugLog().render(` Explicit scroll ops: ${explicitScrollOperations.map((op) => `${op.startY}-${op.endY - 1}:${op.delta}`).join(", ")}`);
+			for (const op of explicitScrollOperations) {
+				hasFrameOutput = true;
+				frameParts.push(`\u001B[${op.startY + 1};${op.endY}r`);
+				if (op.delta > 0) {
+					frameParts.push(`\u001B[${op.endY};1H`);
+					frameParts.push(`\u001B[${op.delta}S`);
+					for (let y = op.startY; y < op.endY - op.delta; y++) {
+						const dstBase = y * fpCols;
+						const srcBase = (y + op.delta) * fpCols;
+						for (let x = 0; x < size.cols; x++) currentFP[dstBase + x] = prevFP[srcBase + x];
+					}
+					for (let y = op.endY - op.delta; y < op.endY; y++) {
+						const base = y * fpCols;
+						insertedRows.add(y);
+						explicitRowsToRender.add(y);
+						for (let x = 0; x < size.cols; x++) currentFP[base + x] = blankFP;
+					}
+				} else {
+					const absDelta = -op.delta;
+					frameParts.push(`\u001B[${op.startY + 1};1H`);
+					frameParts.push(`\u001B[${absDelta}T`);
+					for (let y = op.endY - 1; y >= op.startY + absDelta; y--) {
+						const dstBase = y * fpCols;
+						const srcBase = (y - absDelta) * fpCols;
+						for (let x = 0; x < size.cols; x++) currentFP[dstBase + x] = prevFP[srcBase + x];
+					}
+					for (let y = op.startY; y < op.startY + absDelta; y++) {
+						const base = y * fpCols;
+						insertedRows.add(y);
+						explicitRowsToRender.add(y);
+						for (let x = 0; x < size.cols; x++) currentFP[base + x] = blankFP;
+					}
+				}
+				frameParts.push("\x1B[r");
+			}
+			const explicitDirtyRows = Array.from(explicitRowsToRender).sort((a, b) => a - b);
+			const overlayDirtyRows = overlayTouchedRowSet ? explicitDirtyRows.filter((y) => overlayTouchedRowSet.has(y)) : [];
+			const paintedExplicitRows = [];
+			for (const y of explicitDirtyRows) {
+				const row = terminal.getRow(y);
+				const overlayRow = overlayTouchedRowSet === null || overlayTouchedRowSet === void 0 ? void 0 : overlayTouchedRowSet.has(y);
+				if (overlayRow || useConservativeDirtyRowRendering) {
+					fingerprintRow(row, y, size.cols);
+					renderRow$1(y, row);
+					paintedExplicitRows.push(y);
+					continue;
+				}
+				const span = (() => {
+					if (insertedRows.has(y)) {
+						fingerprintRow(row, y, size.cols);
+						return resolveChangedSpanAgainstFill(row, y, size.cols, blankFP);
+					}
+					return resolveChangedSpanAgainstReference(row, y, size.cols);
+				})();
+				if (!span) {
+					if (!skipUnchangedDirtyRows) fingerprintRow(row, y, size.cols);
+					if (!skipUnchangedDirtyRows) {
+						renderRow$1(y, row);
+						paintedExplicitRows.push(y);
+					}
+					continue;
+				}
+				const rewriteTail = !insertedRows.has(y) && shouldRewriteRowTail(row, y, size.cols, currentFP);
+				fingerprintRow(row, y, size.cols);
+				renderRow$1(y, row, span.startX, rewriteTail ? row.length : span.endXExclusive, rewriteTail || span.endXExclusive >= row.length);
+				paintedExplicitRows.push(y);
+			}
+			if (isDebugEnabled() && overlayDirtyRows.length) getDebugLog().render(` Explicit scroll ops overlay rows: [${overlayDirtyRows.join(", ")}]`);
+			profiledRowCount = explicitDirtyRows.length;
+			scrollHandled = true;
+		} else if (useScrollRegions && scrollRowsCandidate) {
+			for (let y = 0; y < size.rows; y++) fingerprintRow(terminal.getRow(y), y, size.cols);
+			const shift = detectScrollShift(size.cols, scrollRowsCandidate, overlayRows);
+			if (shift) {
+				if (currentFP.length === prevFP.length) currentFP.set(prevFP);
+				hasFrameOutput = true;
+				if (isDebugEnabled()) getDebugLog().render(` Scroll region: delta=${shift.delta}, region=${shift.regionStart}-${shift.regionEnd - 1}, new rows=${shift.newRowStart}-${shift.newRowEnd - 1}`);
+				frameParts.push(`\u001B[${shift.regionStart + 1};${shift.regionEnd}r`);
+				if (shift.delta > 0) {
+					frameParts.push(`\u001B[${shift.regionEnd};1H`);
+					frameParts.push(`\u001B[${shift.delta}S`);
+				} else {
+					frameParts.push(`\u001B[${shift.regionStart + 1};1H`);
+					frameParts.push(`\u001B[${-shift.delta}T`);
+				}
+				frameParts.push("\x1B[r");
+				if (shift.delta > 0) {
+					for (let y = shift.regionStart; y < shift.regionEnd - shift.delta; y++) {
+						const dstBase = y * fpCols;
+						const srcBase = (y + shift.delta) * fpCols;
+						for (let x = 0; x < size.cols; x++) currentFP[dstBase + x] = prevFP[srcBase + x];
+					}
+					for (let y = shift.regionEnd - shift.delta; y < shift.regionEnd; y++) {
+						const base = y * fpCols;
+						for (let x = 0; x < size.cols; x++) currentFP[base + x] = blankFP;
+					}
+				} else {
+					const absDelta = -shift.delta;
+					for (let y = shift.regionEnd - 1; y >= shift.regionStart + absDelta; y--) {
+						const dstBase = y * fpCols;
+						const srcBase = (y - absDelta) * fpCols;
+						for (let x = 0; x < size.cols; x++) currentFP[dstBase + x] = prevFP[srcBase + x];
+					}
+					for (let y = shift.regionStart; y < shift.regionStart + absDelta; y++) {
+						const base = y * fpCols;
+						for (let x = 0; x < size.cols; x++) currentFP[base + x] = blankFP;
+					}
+				}
+				for (let y = shift.newRowStart; y < shift.newRowEnd; y++) {
+					const row = terminal.getRow(y);
+					fingerprintRow(row, y, size.cols);
+					renderRow$1(y, row);
+				}
+				const extraDirtyRows = overlayRowSet ? shift.extraDirtyRows.filter((y) => !overlayRowSet.has(y) || Boolean(overlayPartialRowSet === null || overlayPartialRowSet === void 0 ? void 0 : overlayPartialRowSet.has(y))) : shift.extraDirtyRows;
+				for (const y of extraDirtyRows) {
+					const row = terminal.getRow(y);
+					const overlayRow = overlayTouchedRowSet === null || overlayTouchedRowSet === void 0 ? void 0 : overlayTouchedRowSet.has(y);
+					if (overlayRow || useConservativeDirtyRowRendering) {
+						fingerprintRow(row, y, size.cols);
+						renderRow$1(y, row);
+						continue;
+					}
+					const span = resolveChangedSpanAgainstReference(row, y, size.cols);
+					if (!span) {
+						if (!skipUnchangedDirtyRows) {
+							fingerprintRow(row, y, size.cols);
+							renderRow$1(y, row);
+						}
+						continue;
+					}
+					const rewriteTail = shouldRewriteRowTail(row, y, size.cols, currentFP);
+					renderRow$1(y, row, span.startX, rewriteTail ? row.length : span.endXExclusive, rewriteTail || span.endXExclusive >= row.length);
+					fingerprintRow(row, y, size.cols);
+				}
+				for (let y = shift.newRowStart; y < shift.newRowEnd; y++) fingerprintRow(terminal.getRow(y), y, size.cols);
+				const renderedRows = new Set();
+				for (let y = shift.newRowStart; y < shift.newRowEnd; y++) renderedRows.add(y);
+				for (const y of extraDirtyRows) renderedRows.add(y);
+				profiledRowCount = renderedRows.size;
+				scrollHandled = true;
+			}
+		}
+		if (!scrollHandled && denseDirtyRows && scrollRowsCandidate && useScrollRegions) {
+			rowsToRender = scrollRowsCandidate;
+			profiledRowCount = rowsToRender.length;
+			if (isDebugEnabled()) getDebugLog().render(` Dense dirty rows fell back to partial render: ${rowsToRender.length} rows`);
+		}
+		if (scrollHandled) {} else if (!rowsToRender) {
 			if (isDebugEnabled()) getDebugLog().render(` Full render: ${size.rows} rows`);
 			for (let y = 0; y < size.rows; y++) {
 				const row = terminal.getRow(y);
+				fingerprintRow(row, y, size.cols);
 				renderRow$1(y, row);
 			}
 		} else {
-			const repaintFullDirtyRows = overlayPlaneHasVisibleContent();
-			if (isDebugEnabled()) getDebugLog().render(` Partial render: ${rowsToRender.length} dirty rows: [${rowsToRender.join(", ")}]${repaintFullDirtyRows ? " (overlay-full-row)" : ""}`);
+			const overlayDirtyRows = overlayTouchedRowSet ? rowsToRender.filter((y) => overlayTouchedRowSet.has(y)) : [];
+			if (isDebugEnabled()) getDebugLog().render(` Partial render: ${rowsToRender.length} dirty rows: [${rowsToRender.join(", ")}]${overlayDirtyRows.length ? ` (overlay-full-row: [${overlayDirtyRows.join(", ")}])` : ""}`);
 			for (const y of rowsToRender) {
 				const row = terminal.getRow(y);
-				if (repaintFullDirtyRows) {
+				fingerprintRow(row, y, size.cols);
+				const overlayRow = overlayTouchedRowSet === null || overlayTouchedRowSet === void 0 ? void 0 : overlayTouchedRowSet.has(y);
+				if (overlayRow || useConservativeDirtyRowRendering) {
 					renderRow$1(y, row);
 					continue;
 				}
-				const span = resolveChangedSpan(row, renderedRowCache[y]);
+				const span = resolveChangedSpan(row, y, size.cols);
 				if (!span) {
-					renderRow$1(y, row);
+					if (!skipUnchangedDirtyRows) renderRow$1(y, row);
 					continue;
 				}
-				renderRow$1(y, row, span.startX, span.endXExclusive, span.endXExclusive >= row.length);
+				const rewriteTail = shouldRewriteRowTail(row, y, size.cols, prevFP);
+				renderRow$1(y, row, span.startX, rewriteTail ? row.length : span.endXExclusive, rewriteTail || span.endXExclusive >= row.length);
 			}
 		}
 		if (!rowsToRender && lastRenderedRows > size.rows) {
@@ -7016,17 +8376,38 @@ function createStdoutRenderer(terminal, options) {
 				frameParts.push(SGR_RESET, bgSeq);
 				activeStyleKey = bgKey;
 			}
-			for (let i = 0; i < extraRows; i++) frameParts.push(rowClearToEol[size.rows + i]);
+			for (let i = 0; i < extraRows; i++) {
+				hasFrameOutput = true;
+				frameParts.push(rowClearToEol[size.rows + i]);
+			}
 		}
 		if (!rowsToRender) lastRenderedRows = size.rows;
-		if (!rowsToRender || renderedRowCache.length !== size.rows) renderedRowCache.length = size.rows;
+		const tmpFP = prevFP;
+		prevFP = currentFP;
+		currentFP = tmpFP;
+		fpPrevValid = true;
+		prevOverlayBlockedRows = overlayCoverage.blockedRows;
+		prevOverlayPartialRows = overlayCoverage.partialRows;
+		let emittedCursorPos = null;
 		if (getImeAnchor) {
 			const anchor = getImeAnchor();
 			if (anchor) {
 				const { x, y } = clampCellToViewport(anchor, size);
-				frameParts.push(`\u001B[${y + 1};${x + 1}H`);
+				if (hasFrameOutput || x !== lastCursorX || y !== lastCursorY) {
+					hasFrameOutput = true;
+					emittedCursorPos = {
+						x,
+						y
+					};
+					frameParts.push(`\u001B[${y + 1};${x + 1}H`);
+				}
 			}
 		}
+		if (!hasFrameOutput) {
+			if (isDebugEnabled()) getDebugLog().render(" No-op frame skipped");
+			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutNoOutput();
+			return;
+		}
 		if (enableOsc8Links && activeStyle.href) frameParts.push(OSC8_CLOSE);
 		frameParts.push(SGR_RESET);
 		frameParts.push("\x1B[?7h");
@@ -7034,9 +8415,9 @@ function createStdoutRenderer(terminal, options) {
 		const frame = frameParts.join("");
 		if (profiler) profiler.recordRender({
 			durationMs: profiler.now() - renderStart,
-			rows: rowsToRender ? rowsToRender.length : size.rows,
+			rows: profiledRowCount,
 			nodes: 0,
-			fullRepaint: !rowsToRender,
+			fullRepaint: !rowsToRender && !scrollHandled,
 			sorted: dirtySorted
 		});
 		if (isDebugEnabled()) {
@@ -7134,6 +8515,13 @@ function createStdoutRenderer(terminal, options) {
 		{
 			const writeMs = performance.now() - writeStart;
 			writeEmaMs = writeEmaMs === 0 ? writeMs : writeEmaMs * .85 + writeMs * .15;
+			if (emittedCursorPos) {
+				lastCursorX = emittedCursorPos.x;
+				lastCursorY = emittedCursorPos.y;
+			} else {
+				lastCursorX = null;
+				lastCursorY = null;
+			}
 			recordStdoutFrame({
 				at: Date.now(),
 				bytes: frame.length,
@@ -7146,6 +8534,11 @@ function createStdoutRenderer(terminal, options) {
 				bytes: frame.length,
 				mode: writeMode === "sync" ? "sync" : writeMode === "chunked" ? "chunked" : "stream"
 			});
+			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutWrite({
+				durationMs: writeMs,
+				bytes: frame.length,
+				mode: writeMode === "sync" ? "sync" : writeMode === "chunked" ? "chunked" : "stream"
+			});
 		}
 		if (isDebugEnabled()) {
 			const totalTime = (performance.now() - renderStart).toFixed(2);
@@ -7158,9 +8551,20 @@ function createStdoutRenderer(terminal, options) {
 	* Prevents excessive renders that cause flickering in Bun binaries.
 	* Accumulates dirty rows while waiting for next frame to ensure no updates are lost.
 	*/
-	function render(dirtyRows) {
+	function render(dirtyRows, sync, scrollOperations, skipUnchangedDirtyRows = false) {
 		if (disposed) return;
 		if (isDebugEnabled()) getDebugLog().render(`render() called: dirtyRows=${(dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) ?? "null"}, pending=${pendingRender}, elapsed=${Date.now() - lastFrameTime}ms`);
+		const isSmallSyncPatch = Boolean(sync && (dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) && dirtyRows.length <= 12 && !(scrollOperations === null || scrollOperations === void 0 ? void 0 : scrollOperations.length));
+		if (isSmallSyncPatch) skipUnchangedDirtyRows = false;
+		if ((dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) && skipUnchangedDirtyRows && fpPrevValid && !(scrollOperations === null || scrollOperations === void 0 ? void 0 : scrollOperations.length) && dirtyRows.length < terminal.size().rows) {
+			const cols = terminal.size().cols;
+			const nextDirtyRows = dirtyRows.filter((y) => !rowMatchesPreviousFrame(y, cols));
+			if (nextDirtyRows.length === 0) {
+				if (isDebugEnabled()) getDebugLog().render(`Skipped unchanged dirty commit: ${dirtyRows.length} rows`);
+				return;
+			}
+			dirtyRows = nextDirtyRows;
+		}
 		const ensureDirtyBits = (rowCount) => {
 			if (!accumulatedDirtyBits || accumulatedDirtyBits.length !== rowCount) {
 				accumulatedDirtyBits = new Uint8Array(rowCount);
@@ -7182,12 +8586,43 @@ function createStdoutRenderer(terminal, options) {
 			out$1.length = outLen;
 			return outLen ? out$1 : null;
 		};
+		const buildAccumulatedScrollOperations = () => {
+			return (accumulatedScrollOperations === null || accumulatedScrollOperations === void 0 ? void 0 : accumulatedScrollOperations.length) ? accumulatedScrollOperations : null;
+		};
+		const mergeScrollOperations = (next) => {
+			if (!(next === null || next === void 0 ? void 0 : next.length) || accumulatedAllRows) return;
+			const merged = accumulatedScrollOperations ? accumulatedScrollOperations.slice() : [];
+			for (const op of next) {
+				const startY = Math.floor(op.startY);
+				const endY = Math.floor(op.endY);
+				const delta = Math.trunc(op.delta);
+				if (endY <= startY || delta === 0) continue;
+				const existingIndex = merged.findIndex((existing) => existing.startY === startY && existing.endY === endY);
+				if (existingIndex >= 0) {
+					const existing = merged[existingIndex];
+					const nextDelta = existing.delta + delta;
+					if (nextDelta === 0) merged.splice(existingIndex, 1);
+					else merged[existingIndex] = {
+						startY,
+						endY,
+						delta: nextDelta
+					};
+				} else merged.push({
+					startY,
+					endY,
+					delta
+				});
+			}
+			accumulatedScrollOperations = merged.length ? merged : null;
+		};
 		if (!dirtyRows || dirtyRows.length === 0) {
 			accumulatedAllRows = true;
 			accumulatedDirtyBits = null;
 			accumulatedDirtyCount = 0;
 			accumulatedDirtyMin = Number.POSITIVE_INFINITY;
 			accumulatedDirtyMax = -1;
+			accumulatedScrollOperations = null;
+			accumulatedSkipUnchangedDirtyRows = false;
 		} else if (!accumulatedAllRows) {
 			const rowCount = terminal.size().rows;
 			const bits = ensureDirtyBits(rowCount);
@@ -7201,13 +8636,35 @@ function createStdoutRenderer(terminal, options) {
 					if (y > accumulatedDirtyMax) accumulatedDirtyMax = y;
 				}
 			}
+			mergeScrollOperations(scrollOperations);
+			accumulatedSkipUnchangedDirtyRows && (accumulatedSkipUnchangedDirtyRows = skipUnchangedDirtyRows);
+		}
+		const now$3 = Date.now();
+		const elapsed = now$3 - lastFrameTime;
+		const queuedDelayMs = Math.max(0, MIN_FRAME_MS - elapsed);
+		if (pendingRender && !sync) {
+			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutQueued(queuedDelayMs);
+			return;
+		}
+		if (sync) {
+			if (pendingRender) {
+				pendingRender = false;
+				if (renderTimer) {
+					clearTimeout(renderTimer);
+					renderTimer = null;
+				}
+			}
+			const rows = buildAccumulatedRows();
+			const pendingScrolls = buildAccumulatedScrollOperations();
+			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutQueued(0);
+			doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
+			return;
 		}
-		if (pendingRender) return;
-		const now$2 = Date.now();
-		const elapsed = now$2 - lastFrameTime;
 		if (elapsed >= MIN_FRAME_MS) {
 			const rows = buildAccumulatedRows();
-			doRender(rows);
+			const pendingScrolls = buildAccumulatedScrollOperations();
+			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutQueued(0);
+			doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
 		} else {
 			pendingRender = true;
 			if (renderTimer) clearTimeout(renderTimer);
@@ -7215,19 +8672,24 @@ function createStdoutRenderer(terminal, options) {
 				renderTimer = null;
 				if (!disposed) {
 					const rows = buildAccumulatedRows();
-					doRender(rows);
+					const pendingScrolls = buildAccumulatedScrollOperations();
+					doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
 				}
-			}, MIN_FRAME_MS - elapsed);
+			}, queuedDelayMs);
+			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutQueued(queuedDelayMs);
 		}
 	}
+	terminal.setFingerprintFn((ch, style) => {
+		return styleKey$1(style) << 16 | charHash16(ch);
+	});
 	if (altScreen && out.isTTY) out.write("\x1B[?1049h");
 	if (hideCursor) out.write("\x1B[?25l");
 	if (clear) out.write(`${SGR_RESET}${openBg(defaultBg)}\u001B[2J\u001B[H${SGR_RESET}`);
-	const off = terminal.on("commit", ({ dirtyRows }) => {
-		if (isDebugEnabled()) getDebugLog().render(`Commit event: dirtyRows=${(dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) ?? "null"}, rows=${(dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.join(",")) ?? "all"}`);
-		render(dirtyRows);
+	const off = terminal.on("commit", ({ dirtyRows, scrollOperations, sync }) => {
+		if (isDebugEnabled()) getDebugLog().render(`Commit event: dirtyRows=${(dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) ?? "null"}, rows=${(dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.join(",")) ?? "all"}${(scrollOperations === null || scrollOperations === void 0 ? void 0 : scrollOperations.length) ? `, scrollOps=${scrollOperations.map((op) => `${op.startY}-${op.endY - 1}:${op.delta}`).join("|")}` : ""}${sync ? " (sync)" : ""}`);
+		render(dirtyRows, sync, scrollOperations, true);
 	});
-	const resizeSource = (options === null || options === void 0 ? void 0 : options.output) ?? process.stdout;
+	const resizeSource = (options === null || options === void 0 ? void 0 : options.output) ?? process$1.stdout;
 	const canTrackResize = Boolean(trackResize && out.isTTY && typeof (resizeSource === null || resizeSource === void 0 ? void 0 : resizeSource.on) === "function");
 	const onResize = () => {
 		const cols = Number(resizeSource === null || resizeSource === void 0 ? void 0 : resizeSource.columns);
@@ -7255,6 +8717,8 @@ function createStdoutRenderer(terminal, options) {
 			rows: size.rows
 		});
 		out.write(`\u001B[${cy + 1};${cx + 1}H`);
+		lastCursorX = cx;
+		lastCursorY = cy;
 	}
 	/** Show or hide the terminal cursor */
 	function showCursor(visible) {
@@ -7288,7 +8752,10 @@ function createStdoutRenderer(terminal, options) {
 		if (next.defaultBg && next.defaultBg !== defaultBg) defaultBg = next.defaultBg;
 		if ("palette" in next) palette = next.palette;
 		styleKeyCache$1 = new WeakMap();
-		renderedRowCache = [];
+		fpRows = 0;
+		fpPrevValid = false;
+		prevOverlayBlockedRows = [];
+		prevOverlayPartialRows = [];
 		render();
 	};
 	return {
@@ -7486,12 +8953,22 @@ const rowCache = new WeakMap();
 function segmentsToKey(segments) {
 	return segments.map((s) => `${s.key}:${s.text}:${s.cols}:${s.wide}`).join("|");
 }
+function isPlainStyle(style) {
+	return !style.fg && !style.bg && !style.bold && !style.dim && !style.italic && !style.underline && !style.inverse && !style.href;
+}
+function isTransparentBlankRow(segments) {
+	return segments.length === 1 && isPlainStyle(segments[0].style) && segments[0].text.trim().length === 0;
+}
 function renderRow(terminal, metrics$1, wideScaleX, y, lineEl) {
 	const segments = computeRowSegments(terminal, y);
 	const newKey = segmentsToKey(segments);
 	const cachedKey = rowCache.get(lineEl);
 	if (cachedKey === newKey) return;
 	rowCache.set(lineEl, newKey);
+	if (isTransparentBlankRow(segments)) {
+		lineEl.replaceChildren();
+		return;
+	}
 	const fragment = document.createDocumentFragment();
 	for (const seg of segments) {
 		const span = document.createElement("span");
@@ -7512,6 +8989,7 @@ function createDomRenderer(terminal, container) {
 	container.style.whiteSpace = "pre";
 	container.style.display = "inline-block";
 	container.style.overflow = "hidden";
+	container.style.position = "relative";
 	container.style.userSelect = "text";
 	container.style.outline = "none";
 	container.style.contain = "layout style";
@@ -7519,21 +8997,93 @@ function createDomRenderer(terminal, container) {
 	installAnsiPaletteCssVars(container);
 	let metrics$1 = measureCell(container);
 	let wideScaleX = 1;
-	let lineEls = [];
+	const planeLayers = new Map();
 	let raf = 0;
-	const pending = new Set();
+	const pending = new Map();
 	let disposed = false;
+	function applyPlaneOffset(plane, offsetPx) {
+		const layer = planeLayers.get(plane);
+		if (!layer) return;
+		const next = Number.isFinite(offsetPx) ? offsetPx : 0;
+		if (layer.offsetPx === next) return;
+		layer.offsetPx = next;
+		layer.contentEl.style.transform = next ? `translateY(${next}px)` : "translateY(0px)";
+	}
+	function applyPlaneViewport(plane, viewport) {
+		const layer = planeLayers.get(plane);
+		if (!layer) return;
+		const totalHeight = terminal.size().rows * metrics$1.cellHeight;
+		if (!viewport) {
+			layer.viewportTopPx = 0;
+			layer.viewportHeightPx = null;
+			layer.el.style.clipPath = "none";
+			return;
+		}
+		const topPx = Math.max(0, Math.min(totalHeight, Math.floor(viewport.topPx)));
+		const heightPx = Math.max(0, Math.min(totalHeight - topPx, Math.floor(viewport.heightPx)));
+		layer.viewportTopPx = topPx;
+		layer.viewportHeightPx = heightPx;
+		if (topPx === 0 && heightPx >= totalHeight) {
+			layer.el.style.clipPath = "none";
+			return;
+		}
+		const bottomPx = Math.max(0, totalHeight - topPx - heightPx);
+		layer.el.style.clipPath = `inset(${topPx}px 0px ${bottomPx}px 0px)`;
+	}
 	function rebuildLines() {
 		const { rows, cols } = terminal.size();
 		container.style.width = `${cols * metrics$1.cellWidth}px`;
 		container.style.height = `${rows * metrics$1.cellHeight}px`;
 		const fragment = document.createDocumentFragment();
-		lineEls = Array.from({ length: rows }, () => {
-			const line = document.createElement("div");
-			line.style.cssText = `height:${metrics$1.cellHeight}px;width:${cols * metrics$1.cellWidth}px;overflow:hidden;contain:layout style`;
-			fragment.appendChild(line);
-			return line;
-		});
+		for (let i = 0; i < TERMINAL_RENDER_PLANES.length; i++) {
+			const plane = TERMINAL_RENDER_PLANES[i];
+			const planeTerminal = getPlaneTerminal(terminal, plane);
+			let layer = planeLayers.get(plane);
+			if (!layer) {
+				const el = document.createElement("div");
+				const contentEl = document.createElement("div");
+				el.dataset.vtPlane = plane;
+				el.style.pointerEvents = "none";
+				contentEl.style.position = "absolute";
+				contentEl.style.left = "0";
+				contentEl.style.top = "0";
+				layer = {
+					el,
+					contentEl,
+					lines: [],
+					offsetPx: 0,
+					terminal: planeTerminal,
+					viewportTopPx: 0,
+					viewportHeightPx: null
+				};
+				planeLayers.set(plane, layer);
+			}
+			layer.terminal = planeTerminal;
+			layer.el.style.position = "absolute";
+			layer.el.style.left = "0";
+			layer.el.style.top = "0";
+			layer.el.style.width = `${cols * metrics$1.cellWidth}px`;
+			layer.el.style.height = `${rows * metrics$1.cellHeight}px`;
+			layer.el.style.overflow = "hidden";
+			layer.el.style.zIndex = String(i);
+			layer.contentEl.style.width = `${cols * metrics$1.cellWidth}px`;
+			layer.contentEl.style.height = `${rows * metrics$1.cellHeight}px`;
+			applyPlaneOffset(plane, layer.offsetPx);
+			applyPlaneViewport(plane, layer.viewportHeightPx == null ? null : {
+				topPx: layer.viewportTopPx,
+				heightPx: layer.viewportHeightPx
+			});
+			const lineFragment = document.createDocumentFragment();
+			layer.lines = Array.from({ length: rows }, () => {
+				const line = document.createElement("div");
+				line.style.cssText = `height:${metrics$1.cellHeight}px;width:${cols * metrics$1.cellWidth}px;overflow:hidden;contain:layout style`;
+				lineFragment.appendChild(line);
+				return line;
+			});
+			layer.contentEl.replaceChildren(lineFragment);
+			layer.el.replaceChildren(layer.contentEl);
+			fragment.appendChild(layer.el);
+		}
 		container.replaceChildren(fragment);
 	}
 	function refresh() {
@@ -7542,22 +9092,46 @@ function createDomRenderer(terminal, container) {
 		wideScaleX = wideW > 0 ? Math.max(1, Math.min(2, metrics$1.cellWidth * 2 / wideW)) : 1;
 		rebuildLines();
 		const size = terminal.size();
-		for (let y = 0; y < size.rows; y++) renderRow(terminal, metrics$1, wideScaleX, y, lineEls[y]);
+		for (const plane of TERMINAL_RENDER_PLANES) {
+			const layer = planeLayers.get(plane);
+			if (!layer) continue;
+			for (let y = 0; y < size.rows; y++) renderRow(layer.terminal, metrics$1, wideScaleX, y, layer.lines[y]);
+		}
 	}
 	function flushPending() {
 		raf = 0;
 		if (disposed) return;
-		for (const y of pending) {
-			const line = lineEls[y];
-			if (line) renderRow(terminal, metrics$1, wideScaleX, y, line);
+		for (const plane of TERMINAL_RENDER_PLANES) {
+			const layer = planeLayers.get(plane);
+			const rows = pending.get(plane);
+			if (!layer || !(rows === null || rows === void 0 ? void 0 : rows.size)) continue;
+			for (const y of rows) {
+				const line = layer.lines[y];
+				if (line) renderRow(layer.terminal, metrics$1, wideScaleX, y, line);
+			}
+			rows.clear();
 		}
-		pending.clear();
 	}
-	const offCommit = terminal.on("commit", ({ dirtyRows }) => {
+	const offCommit = terminal.on("commit", ({ dirtyRows, planes }) => {
+		const activePlanes = (planes === null || planes === void 0 ? void 0 : planes.length) ? planes : TERMINAL_RENDER_PLANES;
 		if (dirtyRows === null) {
 			const size = terminal.size();
-			for (let y = 0; y < size.rows; y++) pending.add(y);
-		} else for (const y of dirtyRows) pending.add(y);
+			for (const plane of activePlanes) {
+				let rows = pending.get(plane);
+				if (!rows) {
+					rows = new Set();
+					pending.set(plane, rows);
+				}
+				for (let y = 0; y < size.rows; y++) rows.add(y);
+			}
+		} else for (const plane of activePlanes) {
+			let rows = pending.get(plane);
+			if (!rows) {
+				rows = new Set();
+				pending.set(plane, rows);
+			}
+			for (const y of dirtyRows) rows.add(y);
+		}
 		if (!raf) {
 			raf = -1;
 			const id = requestAnimationFrame(() => {
@@ -7583,7 +9157,14 @@ function createDomRenderer(terminal, container) {
 			offResize();
 			if (raf > 0) cancelAnimationFrame(raf);
 			pending.clear();
+			planeLayers.clear();
 			container.replaceChildren();
+		},
+		setPlaneOffset(plane, offsetPx) {
+			applyPlaneOffset(plane, offsetPx);
+		},
+		setPlaneViewport(plane, viewport) {
+			applyPlaneViewport(plane, viewport);
 		}
 	};
 }
@@ -7592,7 +9173,7 @@ function createDomRenderer(terminal, container) {
 //#region src/runtime/index.ts
 function isNodeLike() {
 	var _process$versions;
-	return typeof (process === null || process === void 0 || (_process$versions = process.versions) === null || _process$versions === void 0 ? void 0 : _process$versions.node) === "string";
+	return typeof (process$1 === null || process$1 === void 0 || (_process$versions = process$1.versions) === null || _process$versions === void 0 ? void 0 : _process$versions.node) === "string";
 }
 function detectEnv() {
 	const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
@@ -7732,26 +9313,39 @@ function useTerminal() {
 //#endregion
 //#region src/vue/composables/use-render-node.ts
 const pendingInvalidateByScheduler = new WeakMap();
-function requestBatchedInvalidate(scheduler, plane) {
+function mergePriority(prev, next) {
+	if (prev === "high" || next === "high") return "high";
+	if (prev === "normal" || next === "normal") return "normal";
+	return "low";
+}
+function requestBatchedInvalidate(scheduler, plane, priority) {
 	let state = pendingInvalidateByScheduler.get(scheduler);
 	if (!state) {
 		state = {
 			queued: false,
-			plane: null
+			plane: null,
+			priority: "low"
 		};
 		pendingInvalidateByScheduler.set(scheduler, state);
 	}
 	if (state.queued) {
 		state.plane = state.plane == null || state.plane === plane ? plane : null;
+		state.priority = mergePriority(state.priority, priority);
 		return;
 	}
 	state.plane = plane;
+	state.priority = priority;
 	state.queued = true;
 	queueMicrotask(() => {
 		state.queued = false;
 		const queuedPlane = state.plane;
+		const queuedPriority = state.priority;
 		state.plane = null;
-		scheduler.invalidate(queuedPlane ? { plane: queuedPlane } : void 0);
+		state.priority = "low";
+		scheduler.invalidate(queuedPlane || queuedPriority !== "normal" ? {
+			plane: queuedPlane ?? void 0,
+			priority: queuedPriority
+		} : void 0);
 	});
 }
 function useRenderNode(getOptions) {
@@ -7759,11 +9353,13 @@ function useRenderNode(getOptions) {
 	const parentStack = useRenderStack();
 	const plane = inject(RenderPlaneContextKey, ref("default"));
 	const id = ref(null);
+	const lastPlane = ref(plane.value);
 	const options = computed(() => getOptions());
 	const stop = watchEffect(() => {
 		const opt = options.value;
 		opt.deps;
 		const stack = opt.stack ?? parentStack.value;
+		lastPlane.value = plane.value;
 		if (!stack) return;
 		if (!id.value) {
 			const node = render.register({
@@ -7774,23 +9370,24 @@ function useRenderNode(getOptions) {
 				paint: opt.paint
 			});
 			id.value = node.id;
-			requestBatchedInvalidate(scheduler, plane.value);
+			requestBatchedInvalidate(scheduler, plane.value, opt.priority ?? "normal");
 			return;
 		}
 		render.update(id.value, {
 			stack,
 			zIndex: opt.zIndex ?? 0,
 			rect: opt.rect ?? null,
+			dirtyRowsHint: opt.dirtyRowsHint,
 			plane: plane.value,
 			paint: opt.paint
 		});
-		requestBatchedInvalidate(scheduler, plane.value);
+		requestBatchedInvalidate(scheduler, plane.value, opt.priority ?? "normal");
 	});
 	onBeforeUnmount(() => {
 		stop();
 		if (id.value) {
 			render.unregister(id.value);
-			requestBatchedInvalidate(scheduler, plane.value);
+			requestBatchedInvalidate(scheduler, lastPlane.value, "normal");
 		}
 	});
 	return { id };
@@ -8976,11 +10573,14 @@ function mentionIndexAt$1(value, mentionToken, index) {
 	return countMentionTokens$1(value, mentionToken, index);
 }
 function createPromptMentionPlugin(options = {}) {
+	const latency = getCliLatencyProfiler();
 	return {
 		name: "promptMention",
 		install: (ctx) => {
 			const getProps = () => ctx.getProps();
 			const promptOverlayStack = ctx.render.createStack(ctx.render.rootStack, 1e4);
+			let lastTopClampedRect = null;
+			let lastPromptRect = null;
 			const derivedStyleCache = new WeakMap();
 			const reactiveProps = reactive({
 				promptSuggestions: getProps().promptSuggestions,
@@ -9028,6 +10628,20 @@ function createPromptMentionPlugin(options = {}) {
 				multilineToken: "",
 				mentionToken: ctx.mentionToken
 			});
+			watch(() => {
+				if (!ctx.visible.value || !promptMention.promptVisible.value) return null;
+				const rect = promptMention.promptRect.value;
+				return [
+					Math.floor(rect.x),
+					Math.floor(rect.y),
+					Math.floor(rect.w),
+					Math.floor(rect.h)
+				].join(":");
+			}, (nextRectKey, prevRectKey) => {
+				if (!prevRectKey || nextRectKey === prevRectKey) return;
+				ctx.render.invalidatePlane("default");
+				ctx.scheduler.invalidate({ priority: "high" });
+			});
 			ctx.registerChipStyleProvider({
 				getStyle: (baseStyle, chip) => {
 					if (chip.kind !== "mention") return null;
@@ -9105,6 +10719,12 @@ function createPromptMentionPlugin(options = {}) {
 						query: ctx0.query
 					});
 					if (handled !== false) {
+						const value = ctx.getValue();
+						const before$1 = value.slice(0, ctx0.tokenStart);
+						const after$1 = value.slice(ctx0.tokenEnd);
+						const nextValue$1 = `${before$1}${after$1}`;
+						ctx.pushUndoSnapshot(nextValue$1);
+						ctx.applyEdit(nextValue$1, ctx0.tokenStart);
 						promptMention.promptSuppressedKey.value = ctx0.key;
 						ctx.scheduler.invalidate();
 						return;
@@ -9141,8 +10761,17 @@ function createPromptMentionPlugin(options = {}) {
 			}
 			function handlePromptKeydown(e) {
 				if (!promptMention.promptVisible.value) return false;
+				const markPromptOperation = (suffix) => {
+					const ctx0 = promptMention.activeContext.value;
+					const mentionTrigger = getProps().mentionTrigger || "@";
+					const skillTrigger = getProps().skillTrigger || "";
+					const tokenText = String((ctx0 === null || ctx0 === void 0 ? void 0 : ctx0.tokenText) ?? "");
+					const scope = tokenText.startsWith(mentionTrigger) ? "prompt.mention" : skillTrigger && tokenText.startsWith(skillTrigger) ? "prompt.skill" : "prompt.command";
+					latency === null || latency === void 0 || latency.markOperation(`${scope}.${suffix}`);
+				};
 				const len = promptMention.promptMatches.value.length;
 				if (e.key === "ArrowDown") {
+					markPromptOperation("navigate.next");
 					e.preventDefault();
 					if (len <= 0) promptMention.promptActive.value = 0;
 					else if (promptMention.promptActive.value >= len - 1) promptMention.promptActive.value = 0;
@@ -9151,6 +10780,7 @@ function createPromptMentionPlugin(options = {}) {
 					return true;
 				}
 				if (e.key === "ArrowUp") {
+					markPromptOperation("navigate.prev");
 					e.preventDefault();
 					if (len <= 0) promptMention.promptActive.value = 0;
 					else if (promptMention.promptActive.value <= 0) promptMention.promptActive.value = len - 1;
@@ -9172,11 +10802,13 @@ function createPromptMentionPlugin(options = {}) {
 						const typed = String((ctx0 === null || ctx0 === void 0 ? void 0 : ctx0.tokenText) ?? "");
 						const candidate = String((match === null || match === void 0 || (_match$item = match.item) === null || _match$item === void 0 ? void 0 : _match$item.value) ?? "");
 						if (!typed || !candidate.startsWith(typed)) return false;
+						markPromptOperation("accept");
 						e.preventDefault();
 						acceptPrompt(promptMention.promptActive.value);
 						return true;
 					}
 					if (e.key === "Tab" && (isMention || isSkill)) {
+						markPromptOperation("accept");
 						e.preventDefault();
 						if (len === 0) return true;
 						const list = promptMention.promptMatches.value;
@@ -9186,12 +10818,14 @@ function createPromptMentionPlugin(options = {}) {
 						return true;
 					}
 					if (len === 0) return false;
+					markPromptOperation("accept");
 					e.preventDefault();
 					acceptPrompt(promptMention.promptActive.value);
 					return true;
 				}
 				if (e.key === "Escape") {
 					var _promptMention$active;
+					markPromptOperation("dismiss");
 					e.preventDefault();
 					promptMention.promptSuppressedKey.value = ((_promptMention$active = promptMention.activeContext.value) === null || _promptMention$active === void 0 ? void 0 : _promptMention$active.key) ?? null;
 					ctx.scheduler.invalidate();
@@ -9203,6 +10837,20 @@ function createPromptMentionPlugin(options = {}) {
 			useRenderNode(() => ({
 				zIndex: getProps().zIndex + 5,
 				stack: promptOverlayStack,
+				dirtyRowsHint: (() => {
+					const currentRect = ctx.visible.value && promptMention.promptVisible.value ? {
+						y: Math.floor(promptMention.promptRect.value.y),
+						h: Math.max(0, Math.floor(promptMention.promptRect.value.h))
+					} : null;
+					const rects = [lastPromptRect, currentRect].filter(Boolean);
+					if (!rects.length) return void 0;
+					const maxRows = ctx.terminal.size().rows;
+					const start = Math.max(0, Math.min(...rects.map((rect) => rect.y)) - 1);
+					const end = Math.min(maxRows, Math.max(...rects.map((rect) => rect.y + rect.h)) + 1);
+					if (end <= start) return void 0;
+					return Array.from({ length: end - start }, (_, index) => start + index);
+				})(),
+				priority: "high",
 				rect: ctx.visible.value && promptMention.promptVisible.value ? promptMention.promptRect.value : {
 					x: 0,
 					y: 0,
@@ -9229,6 +10877,10 @@ function createPromptMentionPlugin(options = {}) {
 					if (!ctx.visible.value || !promptMention.promptVisible.value) return;
 					const r = promptMention.promptRect.value;
 					if (r.w < 3 || r.h < 3) return;
+					lastPromptRect = {
+						y: Math.floor(r.y),
+						h: Math.max(0, Math.floor(r.h))
+					};
 					const base = getProps().style ?? ctx.defaultStyle.value;
 					const selectedOverride = { bg: "blue" };
 					const styleKey$1 = base && typeof base === "object" ? base : null;
@@ -9278,6 +10930,19 @@ function createPromptMentionPlugin(options = {}) {
 					const contentW = Math.max(0, innerW - sidePad * 2);
 					const contentX = x0 + 1 + sidePad;
 					const borderStyle = derived.borderStyle;
+					if (lastTopClampedRect && y0 > 0) {
+						ctx.terminal.write(spaces(lastTopClampedRect.w), {
+							x: lastTopClampedRect.x,
+							y: 0,
+							style: getProps().style ?? ctx.defaultStyle.value
+						});
+						lastTopClampedRect = null;
+					}
+					if (y0 === 0) lastTopClampedRect = {
+						x: x0,
+						w
+					};
+					else lastTopClampedRect = null;
 					ctx.terminal.write(`┌${repeatChar("─", innerW)}┐`, {
 						x: x0,
 						y: y0,
@@ -11543,6 +13208,8 @@ const TerminalProvider = defineComponent({
 		let rafToken = 0;
 		let pendingInvalidate = false;
 		let timer = null;
+		let holdNormalInvalidates = false;
+		let holdReleaseToken = 0;
 		let pendingInvalidateAllPlanes = false;
 		const pendingInvalidatePlanes = new Set();
 		let imeComposing = false;
@@ -11571,11 +13238,14 @@ const TerminalProvider = defineComponent({
 			pendingInvalidatePlanes.clear();
 			return activePlanes;
 		}
-		function flush() {
+		function flush(sync = false) {
 			if (unmounting) return;
 			const activePlanes = takeActivePlanes();
 			render.render({ activePlanes });
-			terminal.commit({ planes: activePlanes });
+			terminal.commit({
+				planes: activePlanes,
+				sync
+			});
 			updateImePositionAfterFlush === null || updateImePositionAfterFlush === void 0 || updateImePositionAfterFlush();
 		}
 		function clearTimer() {
@@ -11583,6 +13253,16 @@ const TerminalProvider = defineComponent({
 			clearTimeout(timer);
 			timer = null;
 		}
+		function scheduleNormalInvalidateRelease() {
+			const token = ++holdReleaseToken;
+			nextTick(() => {
+				if (token !== holdReleaseToken) return;
+				holdNormalInvalidates = false;
+				if (unmounting || !pendingInvalidate) return;
+				pendingInvalidate = false;
+				invalidate({ priority: "normal" });
+			});
+		}
 		function flushNow() {
 			if (unmounting) return;
 			pendingInvalidate = false;
@@ -11592,7 +13272,9 @@ const TerminalProvider = defineComponent({
 				raf = 0;
 			}
 			clearTimer();
-			flush();
+			holdNormalInvalidates = true;
+			scheduleNormalInvalidateRelease();
+			flush(true);
 		}
 		function invalidate(options) {
 			if (unmounting) return;
@@ -11603,6 +13285,10 @@ const TerminalProvider = defineComponent({
 				flushNow();
 				return;
 			}
+			if (holdNormalInvalidates) {
+				pendingInvalidate = true;
+				return;
+			}
 			if (priority === "low") {
 				if (timer || raf) return;
 				profiler === null || profiler === void 0 || profiler.recordInvalidate({ plane: (options === null || options === void 0 ? void 0 : options.plane) ?? null });
@@ -12145,6 +13831,8 @@ const TerminalProvider = defineComponent({
 		onBeforeUnmount(() => {
 			unmounting = true;
 			offCommit === null || offCommit === void 0 || offCommit();
+			clearTimer();
+			holdReleaseToken++;
 			if (raf > 0) cancelAnimationFrame(raf);
 			raf = 0;
 			scope.stop();
@@ -13073,7 +14761,10 @@ const TInput = defineComponent({
 			emit("update:modelValue", nextValue);
 			emit("input", nextValue);
 			if (commit) emit("change", nextValue);
-			scheduler.invalidate();
+			scheduler.flushNow();
+			nextTick(() => {
+				scheduler.flushNow();
+			});
 		}
 		function applyMove(nextCursor, extend) {
 			const prev = cursor.value;
@@ -13090,7 +14781,7 @@ const TInput = defineComponent({
 			} else desiredCol.value = indexToLineCellColInline(value, props.multilineTexts, props.mentions, cursor.value).col;
 			ensureCursorVisible();
 			syncImeAnchorNow();
-			scheduler.invalidate();
+			scheduler.flushNow();
 		}
 		watch([
 			() => absRect.value.w,
@@ -13209,7 +14900,11 @@ const TInput = defineComponent({
 				terminal,
 				scheduler,
 				defaultStyle,
-				render,
+				render: {
+					rootStack: render.rootStack,
+					createStack: render.createStack,
+					invalidatePlane: render.invalidatePlane
+				},
 				visible,
 				rawAbsRect,
 				eventZ,
@@ -13306,7 +15001,7 @@ const TInput = defineComponent({
 			emitMentions(nextMentions);
 			ensureCursorVisible();
 			syncImeAnchorNow();
-			scheduler.invalidate();
+			scheduler.flushNow();
 		}
 		function removePendingPasteImage(placeholderPath) {
 			const current = getCurrentMentions();
@@ -13966,10 +15661,12 @@ const TInput = defineComponent({
 					clearAll();
 					return;
 				}
-				focused.value = false;
-				anchor.value = null;
-				emit("blur");
-				scheduler.invalidate();
+				const manager = events.value;
+				if (manager && manager.getFocused()) {
+					manager.focus(null);
+					return;
+				}
+				applyBlur();
 				return;
 			}
 			if (isPrintableKey(e)) {
@@ -14207,6 +15904,7 @@ const TInput = defineComponent({
 			var _chipStyleProvider$va;
 			return {
 				zIndex: props.zIndex,
+				priority: pendingValue.value != null ? "high" : "normal",
 				rect: visible.value ? absRect.value : {
 					x: 0,
 					y: 0,
@@ -14239,6 +15937,7 @@ const TInput = defineComponent({
 					blinkOn.value,
 					defaultStyle.value,
 					((_chipStyleProvider$va = chipStyleProvider.value) === null || _chipStyleProvider$va === void 0 ? void 0 : _chipStyleProvider$va.version.value) ?? 0,
+					pendingValue.value,
 					props.skillHighlightStyle,
 					props.skillTrigger
 				],
@@ -14857,25 +16556,29 @@ const TJsonEditor = defineComponent({
 //#endregion
 //#region src/vue/utils/wheel-scroll.ts
 const LINE_UNIT_THRESHOLD = 3;
-const PIXELS_PER_LINE = 100;
+const PIXELS_PER_LINE = .75;
 const ACCEL_WINDOW_MS = 120;
-const MAX_ACCEL = 2.5;
+const MAX_ACCEL = 26;
 const EDGE_BOUNCE_MS = 120;
 const MIN_TICK_INTERVAL_MS = 6;
 function clamp$3(n, min, max) {
 	return Math.max(min, Math.min(max, n));
 }
-function isLineUnitDelta(deltaY) {
+function isLineUnitDelta(deltaY, mode = "auto") {
+	if (mode === "line") return true;
+	if (mode === "pixel") return false;
 	const abs = Math.abs(deltaY);
 	return abs > 0 && abs <= LINE_UNIT_THRESHOLD && Number.isInteger(deltaY);
 }
-function normalizeDelta(deltaY) {
+function normalizeDelta(deltaY, mode = "auto") {
+	if (mode === "line") return deltaY;
+	if (mode === "pixel") return deltaY / PIXELS_PER_LINE;
 	const abs = Math.abs(deltaY);
 	if (abs <= LINE_UNIT_THRESHOLD && Number.isInteger(deltaY)) return deltaY;
 	return deltaY / PIXELS_PER_LINE;
 }
-function accelFactor(now$2, lastAt) {
-	const dt = now$2 - lastAt;
+function accelFactor(now$3, lastAt) {
+	const dt = now$3 - lastAt;
 	if (!Number.isFinite(dt) || dt <= 0 || dt > ACCEL_WINDOW_MS) return 1;
 	const t = 1 - dt / ACCEL_WINDOW_MS;
 	return 1 + t * (MAX_ACCEL - 1);
@@ -14885,15 +16588,17 @@ function createWheelScrollState() {
 		accumulator: 0,
 		lastAt: 0,
 		lastEdgeDir: 0,
-		lastEdgeAt: 0
+		lastEdgeAt: 0,
+		lastLineUnitDir: 0
 	};
 }
-function applyWheelScroll(state, deltaY, scrollTop, maxTop, now$2 = Date.now()) {
+function applyWheelScroll(state, deltaY, scrollTop, maxTop, now$3 = Date.now(), deltaMode = "auto", options = {}) {
 	if (!Number.isFinite(deltaY) || deltaY === 0 || maxTop <= 0) {
 		if (maxTop <= 0) {
 			state.accumulator = 0;
 			state.lastEdgeDir = 0;
 			state.lastEdgeAt = 0;
+			state.lastLineUnitDir = 0;
 		}
 		return {
 			nextTop: scrollTop,
@@ -14901,16 +16606,18 @@ function applyWheelScroll(state, deltaY, scrollTop, maxTop, now$2 = Date.now())
 			lines: 0
 		};
 	}
-	const dt = state.lastAt ? now$2 - state.lastAt : Infinity;
-	const lineUnits = isLineUnitDelta(deltaY);
-	if (lineUnits && dt !== Infinity && dt >= 0 && dt < MIN_TICK_INTERVAL_MS) return {
+	const dt = state.lastAt ? now$3 - state.lastAt : Infinity;
+	const lineUnits = isLineUnitDelta(deltaY, deltaMode);
+	const inputDir = Math.sign(normalizeDelta(deltaY, deltaMode));
+	if (lineUnits && dt !== Infinity && dt >= 0 && dt < MIN_TICK_INTERVAL_MS && inputDir === state.lastLineUnitDir) return {
 		nextTop: scrollTop,
 		dir: 0,
 		lines: 0
 	};
-	const accel = lineUnits ? 1 : state.lastAt ? accelFactor(now$2, state.lastAt) : 1;
-	state.lastAt = now$2;
-	state.accumulator += normalizeDelta(deltaY) * accel;
+	state.lastLineUnitDir = lineUnits ? inputDir : 0;
+	const accel = lineUnits ? 1 : options.disableAcceleration ? 1 : state.lastAt ? accelFactor(now$3, state.lastAt) : 1;
+	state.lastAt = now$3;
+	state.accumulator += normalizeDelta(deltaY, deltaMode) * accel;
 	const lines = Math.trunc(state.accumulator);
 	if (lines === 0) return {
 		nextTop: scrollTop,
@@ -14923,7 +16630,7 @@ function applyWheelScroll(state, deltaY, scrollTop, maxTop, now$2 = Date.now())
 	const atBottom = scrollTop >= maxTop;
 	if (dir < 0 && atTop || dir > 0 && atBottom) {
 		state.lastEdgeDir = dir;
-		state.lastEdgeAt = now$2;
+		state.lastEdgeAt = now$3;
 		state.accumulator = 0;
 		return {
 			nextTop: scrollTop,
@@ -14931,7 +16638,7 @@ function applyWheelScroll(state, deltaY, scrollTop, maxTop, now$2 = Date.now())
 			lines: 0
 		};
 	}
-	if (state.lastEdgeDir !== 0 && now$2 - state.lastEdgeAt < EDGE_BOUNCE_MS && dir === -state.lastEdgeDir && (atTop || atBottom)) return {
+	if (state.lastEdgeDir !== 0 && now$3 - state.lastEdgeAt < EDGE_BOUNCE_MS && dir === -state.lastEdgeDir && (atTop || atBottom)) return {
 		nextTop: scrollTop,
 		dir: 0,
 		lines: 0
@@ -14960,6 +16667,26 @@ function applyWheelScroll(state, deltaY, scrollTop, maxTop, now$2 = Date.now())
 function clamp$2(n, min, max) {
 	return Math.max(min, Math.min(max, n));
 }
+function getWheelScrollInput$1(e) {
+	const deltaY = Number(e.deltaY ?? 0);
+	const deltaMode = typeof e.deltaMode === "number" ? e.deltaMode : void 0;
+	if (Number.isInteger(deltaY) && deltaY !== 0 && Math.abs(deltaY) >= 100 && Math.abs(deltaY) % 100 === 0 && (deltaMode == null || deltaMode === 0)) return {
+		deltaY: deltaY / 100,
+		mode: "line"
+	};
+	if (deltaMode === 1) return {
+		deltaY,
+		mode: "line"
+	};
+	if (deltaMode === 0) return {
+		deltaY,
+		mode: "pixel"
+	};
+	return {
+		deltaY,
+		mode: "auto"
+	};
+}
 const TList = defineComponent({
 	name: "TList",
 	props: {
@@ -15152,11 +16879,12 @@ const TList = defineComponent({
 					if (idx >= 0 && idx < props.items.length) commit(idx);
 				},
 				wheel: (e) => {
-					const delta = e.deltaY ?? 0;
+					const { deltaY, mode } = getWheelScrollInput$1(e);
+					const delta = deltaY;
 					if (!delta) return;
 					const h$1 = Math.max(0, props.h);
 					const maxTop = Math.max(0, props.items.length - h$1);
-					const { nextTop, dir } = applyWheelScroll(wheelState, delta, scrollTop.value, maxTop);
+					const { nextTop, dir } = applyWheelScroll(wheelState, delta, scrollTop.value, maxTop, Date.now(), mode);
 					if (!dir || nextTop === scrollTop.value) return;
 					scrollTop.value = nextTop;
 					const visibleStart = nextTop;
@@ -15493,6 +17221,26 @@ const TMultilineModal = defineComponent({
 function clamp$1(n, min, max) {
 	return Math.max(min, Math.min(max, n));
 }
+function getWheelScrollInput(e) {
+	const deltaY = Number(e.deltaY ?? 0);
+	const deltaMode = typeof e.deltaMode === "number" ? e.deltaMode : void 0;
+	if (Number.isInteger(deltaY) && deltaY !== 0 && Math.abs(deltaY) >= 100 && Math.abs(deltaY) % 100 === 0 && (deltaMode == null || deltaMode === 0)) return {
+		deltaY: deltaY / 100,
+		mode: "line"
+	};
+	if (deltaMode === 1) return {
+		deltaY,
+		mode: "line"
+	};
+	if (deltaMode === 0) return {
+		deltaY,
+		mode: "pixel"
+	};
+	return {
+		deltaY,
+		mode: "auto"
+	};
+}
 function isCtrlLike(e) {
 	return Boolean(e.ctrlKey || e.metaKey);
 }
@@ -15910,11 +17658,12 @@ const TPathPicker = defineComponent({
 					await trySelect(s.absPath);
 				},
 				wheel: (e) => {
-					const delta = e.deltaY ?? 0;
+					const { deltaY, mode } = getWheelScrollInput(e);
+					const delta = deltaY;
 					if (!delta) return;
 					const h$1 = Math.max(0, listH.value);
 					const maxTop = Math.max(0, suggestions.value.length - h$1);
-					const { nextTop, dir } = applyWheelScroll(wheelState, delta, scrollTop.value, maxTop);
+					const { nextTop, dir } = applyWheelScroll(wheelState, delta, scrollTop.value, maxTop, Date.now(), mode);
 					if (!dir || nextTop === scrollTop.value) return;
 					scrollTop.value = nextTop;
 					const visibleStart = nextTop;
@@ -16986,4 +18735,4 @@ const TRouterView = defineComponent({
 });
 
 //#endregion
-export { ANSI16_COLORS, ANSI256_COLORS, ANSI8_COLORS, SGR_RESET, TAnchor, TBox, TDebugOverlay, TDialog, TERMINAL_RENDER_PLANES, TFlow, TInput, TInputBox, TInputPluginsContextKey, TJsonEditor, TList, TMultilineModal, TPathPicker, TRenderLayer, TRenderPlane, TRouterView, TSelect, TText, TTransition, TView, TerminalProvider, ansiColors, ansiStyles, applyWheelScroll, charCellWidth, clearTextCaches, createCliEventManager, createDefaultTInputHostAdapter, createDomRenderer, createEventManager, createNodeMentionPathProvider, createNodePathPickerProvider, createPromptMentionPlugin, createRuntime, createStdinDriver, createStdoutRenderer, createTInputHostPlugin, createTerminal, createTerminalApp, createTerminalRouter, createTextRestrictionPlugin, createTraceStore, createWheelScrollState, defaultTInputHostPlugin, detectTerminalColorCapability, formatInlineCellLine, getStdoutRendererMetrics, lintJsonText, normalizeNewlines, padEndByCells, parseAnsiSgr, readEventLog, resolveUserPath$1 as resolveUserPath, rgbToAnsi256, sanitizeInlineText, sanitizeTextBlock, sliceByCells, sliceByCellsRange, spaces, suggestPaths, textCellWidth, truecolorBgOpen, truecolorFgOpen, useLayout, useRenderNode, useRoute, useRouter, useTerminal, useTerminalNode, useTerminalRuntime, useVisibility, wrapByCells, writeEventLog, writeSnapshot };
+export { ANSI16_COLORS, ANSI256_COLORS, ANSI8_COLORS, SGR_RESET, TAnchor, TBox, TDebugOverlay, TDialog, TERMINAL_RENDER_PLANES, TFlow, TInput, TInputBox, TInputPluginsContextKey, TJsonEditor, TList, TMultilineModal, TPathPicker, TRenderLayer, TRenderPlane, TRouterView, TSelect, TText, TTransition, TView, TerminalProvider, ansiColors, ansiStyles, applyWheelScroll, charCellWidth, clearTextCaches, createCliEventManager, createDefaultTInputHostAdapter, createDomRenderer, createEventManager, createNodeMentionPathProvider, createNodePathPickerProvider, createPromptMentionPlugin, createRuntime, createStdinDriver, createStdoutRenderer, createTInputHostPlugin, createTerminal, createTerminalApp, createTerminalRouter, createTextRestrictionPlugin, createTraceStore, createWheelScrollState, defaultTInputHostPlugin, detectTerminalColorCapability, formatInlineCellLine, getCliLatencyProfiler, getStdoutRendererMetrics, lintJsonText, normalizeNewlines, padEndByCells, parseAnsiSgr, readEventLog, resolveUserPath$1 as resolveUserPath, rgbToAnsi256, sanitizeInlineText, sanitizeTextBlock, sliceByCells, sliceByCellsRange, spaces, suggestPaths, textCellWidth, truecolorBgOpen, truecolorFgOpen, useLayout, useRenderNode, useRoute, useRouter, useTerminal, useTerminalNode, useTerminalRuntime, useVisibility, wrapByCells, writeEventLog, writeSnapshot };