@simon_he/vue-tui 0.0.5 → 0.0.6

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({
@@ -1286,7 +1286,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");
@@ -1654,8 +1654,8 @@ function ctrlKeyFromChar(ch) {
 	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 enableMouse = options.enableMouse ?? true;
 	const enableMouseMotion = options.enableMouseMotion ?? false;
@@ -2511,12 +2511,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 +2622,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 +2649,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 +2711,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 +2751,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 +2838,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 +3014,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 +3068,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 +3085,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 +3206,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 +3368,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 +3548,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 +3630,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 +3645,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 +3666,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 +3723,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 +3743,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;
@@ -3719,7 +4078,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`);
@@ -5057,7 +5416,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);
@@ -5536,7 +5895,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 +6371,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 +6418,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 +6486,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 +6598,8 @@ function createRenderManager(terminal) {
 	return {
 		rootStack,
 		createStack,
+		invalidatePlane,
+		scrollPlane,
 		register,
 		update,
 		unregister,
@@ -6295,9 +6682,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 env = (process$1 === null || process$1 === void 0 ? void 0 : process$1.env) ?? {};
 	const isGhostty = "GHOSTTY_RESOURCES_DIR" in env;
 	const throttleMs = (() => {
 		const raw = env.DIMCODE_TUI_THROTTLE_MS;
@@ -6307,7 +6695,7 @@ 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;
+		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 isGhostty ? 24 : 16;
 	})();
 	function queueInvalidatePlane(plane) {
@@ -6330,16 +6718,23 @@ 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 });
+		terminal.commit({
+			planes: activePlanes,
+			sync
+		});
 		flushing = false;
 		lastFlushAtMs = Date.now();
 		scheduledAtMs = 0;
+		if (pendingInvalidateAfterFlush) {
+			pendingInvalidateAfterFlush = false;
+			flush(true);
+		}
 	}
 	function clearScheduledTimer() {
 		if (!timer) return;
@@ -6360,7 +6755,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 +6770,22 @@ function createTerminalApp(options) {
 		if (flushing) return;
 		clearScheduledTimer();
 		scheduled = false;
-		flush();
+		flush(true);
 	}
 	function invalidate(options$1) {
 		if (disposed) return;
-		if (flushing) return;
+		if (flushing) {
+			queueInvalidatePlane(options$1 === null || options$1 === void 0 ? void 0 : options$1.plane);
+			pendingInvalidateAfterFlush = true;
+			return;
+		}
 		const priority = (options$1 === null || options$1 === void 0 ? void 0 : options$1.priority) ?? "normal";
 		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 +6922,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 +7006,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;
@@ -6615,7 +7019,7 @@ function createStdoutRenderer(terminal, options) {
 	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();
@@ -6647,8 +7051,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 +7067,12 @@ 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 isVscodeTerminal = String(env.TERM_PROGRAM ?? "").trim().toLowerCase() === "vscode" || "VSCODE_PID" in env || "VSCODE_IPC_HOOK_CLI" in env;
 	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,11 +7080,15 @@ 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;
+	let accumulatedScrollOperations = null;
+	let accumulatedSkipUnchangedDirtyRows = true;
 	const MIN_FRAME_MS = !out.isTTY ? 0 : isGhostty ? 24 : 16;
 	function clampCellToViewport(cell, size) {
 		const maxX = Math.max(0, Math.floor(size.cols) - 1);
@@ -6697,25 +7105,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 +7173,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 +7229,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 +7245,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 < row.length; x++) {
-			if (row[x] === prevRow[x]) continue;
+		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 || 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 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 < cols; x++) {
+			if (currentFP[base + x] === fillFingerprint) 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 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,7 +7555,7 @@ 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;
 		pendingRender = false;
@@ -6858,15 +7564,50 @@ function createStdoutRenderer(terminal, options) {
 		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 +7628,13 @@ function createStdoutRenderer(terminal, options) {
 			if (!sorted) outRows.sort((a, b) => a - b);
 			return outRows;
 		})();
-		if (rowsToRender && rowsToRender.length >= size.rows * dirtyFullThreshold) rowsToRender = null;
 		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 +7685,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 +7706,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 +7727,233 @@ 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;
+		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 = overlayRowSet ? explicitDirtyRows.filter((y) => overlayRowSet.has(y)) : [];
+			const paintedExplicitRows = [];
+			for (const y of explicitDirtyRows) {
+				const row = terminal.getRow(y);
+				const overlayRow = overlayRowSet === null || overlayRowSet === void 0 ? void 0 : overlayRowSet.has(y);
+				if (overlayRow) {
+					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 = overlayRowSet === null || overlayRowSet === void 0 ? void 0 : overlayRowSet.has(y);
+					if (overlayRow) {
+						renderRow$1(y, row);
+						fingerprintRow(row, y, size.cols);
+						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 = overlayRowSet ? rowsToRender.filter((y) => overlayRowSet.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 = overlayRowSet === null || overlayRowSet === void 0 ? void 0 : overlayRowSet.has(y);
+				if (overlayRow) {
 					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 +7962,37 @@ 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");
+			return;
+		}
 		if (enableOsc8Links && activeStyle.href) frameParts.push(OSC8_CLOSE);
 		frameParts.push(SGR_RESET);
 		frameParts.push("\x1B[?7h");
@@ -7034,9 +8000,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 +8100,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,
@@ -7158,9 +8131,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 +8166,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 +8216,29 @@ function createStdoutRenderer(terminal, options) {
 					if (y > accumulatedDirtyMax) accumulatedDirtyMax = y;
 				}
 			}
+			mergeScrollOperations(scrollOperations);
+			accumulatedSkipUnchangedDirtyRows && (accumulatedSkipUnchangedDirtyRows = skipUnchangedDirtyRows);
 		}
-		if (pendingRender) return;
+		if (pendingRender && !sync) return;
 		const now$2 = Date.now();
 		const elapsed = now$2 - lastFrameTime;
+		if (sync) {
+			if (pendingRender) {
+				pendingRender = false;
+				if (renderTimer) {
+					clearTimeout(renderTimer);
+					renderTimer = null;
+				}
+			}
+			const rows = buildAccumulatedRows();
+			const pendingScrolls = buildAccumulatedScrollOperations();
+			doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
+			return;
+		}
 		if (elapsed >= MIN_FRAME_MS) {
 			const rows = buildAccumulatedRows();
-			doRender(rows);
+			const pendingScrolls = buildAccumulatedScrollOperations();
+			doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
 		} else {
 			pendingRender = true;
 			if (renderTimer) clearTimeout(renderTimer);
@@ -7215,19 +8246,23 @@ function createStdoutRenderer(terminal, options) {
 				renderTimer = null;
 				if (!disposed) {
 					const rows = buildAccumulatedRows();
-					doRender(rows);
+					const pendingScrolls = buildAccumulatedScrollOperations();
+					doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
 				}
 			}, MIN_FRAME_MS - elapsed);
 		}
 	}
+	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 +8290,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 +8325,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 {
@@ -7592,7 +8632,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 +8772,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 +8812,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 +8829,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 };
@@ -8981,6 +10037,8 @@ function createPromptMentionPlugin(options = {}) {
 		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 +10086,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;
@@ -9203,6 +10275,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 +10315,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 +10368,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 +12646,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 +12676,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 +12691,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 +12710,9 @@ const TerminalProvider = defineComponent({
 				raf = 0;
 			}
 			clearTimer();
-			flush();
+			holdNormalInvalidates = true;
+			scheduleNormalInvalidateRelease();
+			flush(true);
 		}
 		function invalidate(options) {
 			if (unmounting) return;
@@ -11603,6 +12723,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 +13269,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 +14199,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 +14219,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 +14338,11 @@ const TInput = defineComponent({
 				terminal,
 				scheduler,
 				defaultStyle,
-				render,
+				render: {
+					rootStack: render.rootStack,
+					createStack: render.createStack,
+					invalidatePlane: render.invalidatePlane
+				},
 				visible,
 				rawAbsRect,
 				eventZ,
@@ -13306,7 +14439,7 @@ const TInput = defineComponent({
 			emitMentions(nextMentions);
 			ensureCursorVisible();
 			syncImeAnchorNow();
-			scheduler.invalidate();
+			scheduler.flushNow();
 		}
 		function removePendingPasteImage(placeholderPath) {
 			const current = getCurrentMentions();
@@ -13966,10 +15099,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 +15342,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 +15375,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,19 +15994,23 @@ 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;
@@ -14888,7 +16029,7 @@ function createWheelScrollState() {
 		lastEdgeAt: 0
 	};
 }
-function applyWheelScroll(state, deltaY, scrollTop, maxTop, now$2 = Date.now()) {
+function applyWheelScroll(state, deltaY, scrollTop, maxTop, now$2 = Date.now(), deltaMode = "auto") {
 	if (!Number.isFinite(deltaY) || deltaY === 0 || maxTop <= 0) {
 		if (maxTop <= 0) {
 			state.accumulator = 0;
@@ -14902,7 +16043,7 @@ function applyWheelScroll(state, deltaY, scrollTop, maxTop, now$2 = Date.now())
 		};
 	}
 	const dt = state.lastAt ? now$2 - state.lastAt : Infinity;
-	const lineUnits = isLineUnitDelta(deltaY);
+	const lineUnits = isLineUnitDelta(deltaY, deltaMode);
 	if (lineUnits && dt !== Infinity && dt >= 0 && dt < MIN_TICK_INTERVAL_MS) return {
 		nextTop: scrollTop,
 		dir: 0,
@@ -14910,7 +16051,7 @@ function applyWheelScroll(state, deltaY, scrollTop, maxTop, now$2 = Date.now())
 	};
 	const accel = lineUnits ? 1 : state.lastAt ? accelFactor(now$2, state.lastAt) : 1;
 	state.lastAt = now$2;
-	state.accumulator += normalizeDelta(deltaY) * accel;
+	state.accumulator += normalizeDelta(deltaY, deltaMode) * accel;
 	const lines = Math.trunc(state.accumulator);
 	if (lines === 0) return {
 		nextTop: scrollTop,
@@ -14960,6 +16101,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 +16313,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 +16655,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 +17092,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;