@simon_he/vue-tui 1.0.1 → 1.0.2

package/dist/cli.js

@@ -3278,14 +3278,14 @@ function clamp(n, min, max) {
 	return Math.max(min, Math.min(max, n));
 }
 /**
-* Register a fingerprint function on the buffer. This enables SoA fingerprint
+* Register or clear 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) {
+	if (!fn || !len) {
 		buffer.soaFingerprints = null;
 		return;
 	}
@@ -3306,7 +3306,10 @@ function setFingerprintFn(buffer, fn) {
 */
 function getRowFingerprints(buffer, y) {
 	if (!buffer.soaFingerprints) return null;
-	const physY = physicalRowIndex(buffer, y);
+	if (buffer.rows <= 0 || buffer.cols <= 0) return null;
+	const yy = Math.floor(y);
+	if (!Number.isFinite(yy) || yy < 0 || yy >= buffer.rows) return null;
+	const physY = physicalRowIndex(buffer, yy);
 	const base = physY * buffer.cols;
 	return buffer.soaFingerprints.subarray(base, base + buffer.cols);
 }
@@ -4405,11 +4408,15 @@ function createTerminal(opts) {
 			},
 			setFingerprintFn(fn) {
 				assertNotDisposed();
-				base.setFingerprintFn(fn);
+				const state = getPlaneState(plane);
+				setFingerprintFn(state.buffer, fn);
 			},
 			getRowFingerprints(y) {
 				assertNotDisposed();
-				return base.getRowFingerprints(y);
+				const yy = Math.floor(y);
+				const state = getPlaneState(plane);
+				if (!Number.isFinite(yy) || yy < 0 || yy >= state.buffer.rows) throw new RangeError("Row out of bounds");
+				return getRowFingerprints(state.buffer, yy);
 			}
 		};
 		planeTerminals.set(plane, api);
@@ -4585,7 +4592,9 @@ function createTerminal(opts) {
 		},
 		getRowFingerprints(y) {
 			assertNotDisposed();
-			return getRowFingerprints(compositeBuffer, y);
+			const yy = Math.floor(y);
+			if (!Number.isFinite(yy) || yy < 0 || yy >= compositeBuffer.rows) throw new RangeError("Row out of bounds");
+			return getRowFingerprints(compositeBuffer, yy);
 		}
 	};
 	base[TERMINAL_PLANE_INTERNALS] = {
@@ -8422,15 +8431,24 @@ const SYNC_START = "\x1B[?2026h";
 const SYNC_END = "\x1B[?2026l";
 const OSC8_OPEN = (href) => `\u001B]8;;${href}\u0007`;
 const OSC8_CLOSE = "\x1B]8;;\x07";
+const stdoutFingerprintOwners = new WeakMap();
 function createStdoutRenderer(terminal, options) {
 	const env = (process === null || process === void 0 ? void 0 : process.env) ?? {};
 	if (shouldInstallFileWriters(env)) installNodeFileWriters();
 	const output = (options === null || options === void 0 ? void 0 : options.output) ?? process.stdout;
 	if (!output) throw new Error("createStdoutRenderer requires a Node stdout-like output");
 	const out = output;
+	const outputFd = Number(out.fd);
+	const canUseSyncStdout = (options === null || options === void 0 ? void 0 : options.output) == null && Number.isInteger(outputFd) && outputFd === 1;
+	const fingerprintOwner = Symbol("stdout-renderer");
+	let ownsFingerprintFn = false;
+	const fingerprintTerminal = terminal;
+	const canInstallTerminalFingerprintFn = () => typeof fingerprintTerminal.setFingerprintFn === "function" && typeof fingerprintTerminal.getRowFingerprints === "function";
+	const outputIsTTY = Boolean(out.isTTY);
+	const outputAllowsOsc8Links = out.isTTY !== false;
 	const clear = (options === null || options === void 0 ? void 0 : options.clear) ?? true;
 	const hideCursor = (options === null || options === void 0 ? void 0 : options.hideCursor) ?? true;
-	const altScreen = (options === null || options === void 0 ? void 0 : options.altScreen) ?? Boolean(out.isTTY);
+	const altScreen = (options === null || options === void 0 ? void 0 : options.altScreen) ?? outputIsTTY;
 	let defaultBg = (options === null || options === void 0 ? void 0 : options.defaultBg) == null || (options === null || options === void 0 ? void 0 : options.defaultBg) === "transparent" ? void 0 : (options === null || options === void 0 ? void 0 : options.defaultBg) ?? "black";
 	let palette = (options === null || options === void 0 ? void 0 : options.palette) ?? null;
 	const trackResize = (options === null || options === void 0 ? void 0 : options.trackResize) ?? true;
@@ -8444,11 +8462,11 @@ function createStdoutRenderer(terminal, options) {
 	});
 	function resolveUseSyncOutput() {
 		if ((options === null || options === void 0 ? void 0 : options.useSyncOutput) != null) return options.useSyncOutput;
-		const term = String(env.TERM ?? "").toLowerCase();
+		const term$1 = String(env.TERM ?? "").toLowerCase();
 		const termProgram$1 = String(env.TERM_PROGRAM ?? "").toLowerCase();
 		const termProgramVersion = env.TERM_PROGRAM_VERSION;
 		const isGhostty$1 = "GHOSTTY_RESOURCES_DIR" in env;
-		const isProblematicTerminal = isGhostty$1 || termProgram$1.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$1.includes("iterm") && termProgramVersion && compareVersion(String(termProgramVersion), "3.5.0") >= 0;
 		if (isGoodTerminal) return true;
@@ -8475,10 +8493,90 @@ function createStdoutRenderer(terminal, options) {
 	const chunkThresholdBytes = 64 * 1024;
 	const syncMaxBytes = 128 * 1024;
 	const dirtyFullThreshold = .6;
+	const DIRTY_SPAN_MERGE_GAP_CELLS = 2;
+	const DIRTY_SPAN_MAX_PER_ROW = 12;
+	const DIRTY_SPAN_FULL_ROW_THRESHOLD = .7;
+	const EST_STYLE_SWITCH_BYTES = 8;
+	const EST_CLEAR_TO_EOL_BYTES = 3;
 	const disableCursorPos = false;
 	const termProgram = String(env.TERM_PROGRAM ?? "").trim().toLowerCase();
+	const term = String(env.TERM ?? "").trim().toLowerCase();
+	const isKitty = "KITTY_WINDOW_ID" in env || termProgram.includes("kitty") || term.includes("kitty");
+	const isAlacritty = "ALACRITTY_WINDOW_ID" in env || "ALACRITTY_LOG" in env || termProgram.includes("alacritty") || term.includes("alacritty");
+	const isWezTerm = "WEZTERM_PANE" in env || "WEZTERM_EXECUTABLE" in env || termProgram.includes("wezterm");
 	const isVscodeTerminal = termProgram === "vscode" || "VSCODE_PID" in env || "VSCODE_IPC_HOOK_CLI" in env;
-	const enableOsc8Links = out.isTTY !== false && !isVscodeTerminal;
+	const useConservativeDirtyRows = Boolean(outputIsTTY && (isGhostty || isKitty || isAlacritty || isWezTerm));
+	const normalizeDirtyRowPatchMode = (value) => {
+		const normalized = typeof value === "string" ? value.trim().toLowerCase() : value;
+		return normalized === "auto" || normalized === "row" || normalized === "span" ? normalized : null;
+	};
+	const normalizeColumnDiffMode = (value) => {
+		if (value === true) return "span";
+		if (value === false) return "row";
+		if (typeof value === "string" && value.trim().toLowerCase() === "auto") return "auto";
+		return null;
+	};
+	const firstValidDirtyRowPatchMode = (...values) => {
+		for (const value of values) {
+			const mode = normalizeDirtyRowPatchMode(value);
+			if (mode) return mode;
+		}
+		return null;
+	};
+	function resolveDirtyRowPatchMode() {
+		const explicitMode = options === null || options === void 0 ? void 0 : options.dirtyRowPatchMode;
+		if (explicitMode != null) {
+			const optionMode = normalizeDirtyRowPatchMode(explicitMode);
+			if (!optionMode) throw new Error(`Invalid dirtyRowPatchMode=${JSON.stringify(explicitMode)}; expected "auto", "row", or "span".`);
+			return optionMode;
+		}
+		const legacy = options === null || options === void 0 ? void 0 : options.columnDiff;
+		if (legacy !== void 0) {
+			const legacyMode = normalizeColumnDiffMode(legacy);
+			if (!legacyMode) throw new Error(`Invalid columnDiff=${JSON.stringify(legacy)}; expected boolean or "auto".`);
+			return legacyMode;
+		}
+		const envMode = firstValidDirtyRowPatchMode(env.VUE_TUI_DIRTY_ROW_PATCH_MODE, env.DIMCODE_TUI_DIRTY_ROW_RENDER_MODE, env.DIMCODE_TUI_DIRTY_ROW_PATCH_MODE);
+		if (envMode) return envMode;
+		return "auto";
+	}
+	const dirtyRowPatchMode = resolveDirtyRowPatchMode();
+	const dirtySpanConservativeMaxCells = (() => {
+		if ((options === null || options === void 0 ? void 0 : options.dirtySpanConservativeMaxCells) !== void 0) {
+			const raw$1 = options.dirtySpanConservativeMaxCells;
+			const value$1 = typeof raw$1 === "number" ? raw$1 : Number(raw$1);
+			if (!Number.isFinite(value$1) || value$1 <= 0) throw new Error(`Invalid dirtySpanConservativeMaxCells=${JSON.stringify(raw$1)}; expected a positive finite number.`);
+			return Math.floor(value$1);
+		}
+		const raw = firstNonEmptyEnv(env, "VUE_TUI_DIRTY_SPAN_MAX_CELLS", "DIMCODE_TUI_DIRTY_SPAN_MAX_CELLS");
+		const value = Number(raw);
+		return Number.isFinite(value) && value > 0 ? Math.floor(value) : 32;
+	})();
+	function resolveInternalColumnDiffMode() {
+		const value = options === null || options === void 0 ? void 0 : options.__columnDiffMode;
+		if (value == null) return "auto";
+		if (value === "auto" || value === "single-span" || value === "multi-span" || value === "full-row") return value;
+		throw new Error(`Invalid __columnDiffMode=${JSON.stringify(value)}; expected "auto", "single-span", "multi-span", or "full-row".`);
+	}
+	const columnDiffMode = resolveInternalColumnDiffMode();
+	function resolveEffectiveDirtyRowPatchMode() {
+		switch (columnDiffMode) {
+			case "full-row": return "row";
+			case "single-span": return "single-span";
+			case "multi-span": return "multi-span";
+			case "auto": break;
+		}
+		switch (dirtyRowPatchMode) {
+			case "row": return "row";
+			case "span":
+			case "auto": return "multi-span";
+		}
+	}
+	const effectiveDirtyRowPatchMode = resolveEffectiveDirtyRowPatchMode();
+	const shouldUseDirtySpans = () => effectiveDirtyRowPatchMode !== "row";
+	const shouldUseMultiDirtySpans = () => effectiveDirtyRowPatchMode === "multi-span";
+	const enableOsc8Links = outputAllowsOsc8Links && !isVscodeTerminal;
+	const renderedHref = (value) => enableOsc8Links ? normalizeHref(value) : null;
 	let disposed = false;
 	let lastFrameTime = 0;
 	let pendingRender = false;
@@ -8491,8 +8589,9 @@ function createStdoutRenderer(terminal, options) {
 	let accumulatedDirtyCount = 0;
 	let accumulatedDirtyMin = Number.POSITIVE_INFINITY;
 	let accumulatedDirtyMax = -1;
+	let accumulatedDirtyRowsRequireRepaint = false;
 	let accumulatedScrollOperations = null;
-	const MIN_FRAME_MS = !out.isTTY ? 0 : 16;
+	const MIN_FRAME_MS = outputIsTTY ? 16 : 0;
 	function clampCellToViewport(cell, size) {
 		const maxX = Math.max(0, Math.floor(size.cols) - 1);
 		const maxY = Math.max(0, Math.floor(size.rows) - 1);
@@ -8511,56 +8610,68 @@ function createStdoutRenderer(terminal, options) {
 		const env$1 = (process === null || process === void 0 ? void 0 : process.env) ?? {};
 		return detectTerminalColorCapability({
 			env: env$1,
-			isTTY: Boolean(out.isTTY),
+			isTTY: outputIsTTY,
 			platform: String((process === null || process === void 0 ? void 0 : process.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
-	};
-	const BUILTIN_COLOR_INDEX = { ...COLOR_INDEX };
-	let nextColorIdx = 17;
-	const MAX_COLOR_INDEX = 255;
-	function colorIndex(color) {
-		if (!color) return 0;
-		let idx = COLOR_INDEX[color];
-		if (idx !== void 0) return idx;
-		if (nextColorIdx > MAX_COLOR_INDEX) return MAX_COLOR_INDEX;
-		idx = nextColorIdx++;
-		COLOR_INDEX[color] = idx;
-		return idx;
-	}
 	let styleKeyCache = new WeakMap();
+	const styleKeyIndex = new Map();
+	let nextStyleKey = 1;
+	const MAX_STYLE_KEYS = 131072;
+	const MAX_UINT32_INTERN_ID = 4294967295;
+	const STYLE_KEY_SEP = "";
 	const normalizedHrefCache = new Map();
 	const MAX_HREF_CACHE = 2048;
-	const HREF_STYLE_FLAG = 1 << 21;
+	let fingerprintInternResetRequiresBaseline = false;
+	let fingerprintBaselineGeneration = 0;
+	let activeRenderBaselineGeneration = 0;
+	let terminalFingerprintFnDirty = false;
+	let fingerprintInstallBlockedByExternalProvider = false;
+	function invalidateFingerprintBaseline() {
+		fpPrevValid = false;
+		fingerprintInternResetRequiresBaseline = true;
+		fingerprintBaselineGeneration++;
+	}
+	const activeRenderBaselineChanged = () => activeRenderBaselineGeneration !== fingerprintBaselineGeneration;
+	function resetStyleKeyIndex(resetIds = false) {
+		styleKeyCache = new WeakMap();
+		styleKeyIndex.clear();
+		if (resetIds) nextStyleKey = 1;
+		terminalFingerprintFnDirty = true;
+		invalidateFingerprintBaseline();
+	}
+	function internStyleKey(signature) {
+		const cached = styleKeyIndex.get(signature);
+		if (cached !== void 0) return cached;
+		if (styleKeyIndex.size >= MAX_STYLE_KEYS) resetStyleKeyIndex();
+		if (nextStyleKey >= MAX_UINT32_INTERN_ID) resetStyleKeyIndex(true);
+		const key = nextStyleKey++;
+		styleKeyIndex.set(signature, key);
+		return key;
+	}
+	function styleSignature(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",
+			renderedHref(style.href) ? "1" : "0"
+		].join(STYLE_KEY_SEP);
+	}
 	function styleKey(style) {
 		const cached = styleKeyCache.get(style);
 		if (cached !== void 0) return cached;
-		const href = normalizeHref(style.href);
-		const key = colorIndex(style.fg) | colorIndex(style.bg ?? defaultBg) << 8 | (style.bold ? 65536 : 0) | (enableDim && style.dim ? 1 << 17 : 0) | (style.italic ? 1 << 18 : 0) | (style.underline ? 1 << 19 : 0) | (style.inverse ? 1 << 20 : 0) | (href ? HREF_STYLE_FLAG : 0);
+		const key = internStyleKey(styleSignature(style));
 		styleKeyCache.set(style, key);
 		return key;
 	}
 	function styleKeyFromParts(style) {
-		return colorIndex(style.fg) | colorIndex(style.bg ?? defaultBg) << 8 | (style.bold ? 65536 : 0) | (enableDim && style.dim ? 1 << 17 : 0) | (style.italic ? 1 << 18 : 0) | (style.underline ? 1 << 19 : 0) | (style.inverse ? 1 << 20 : 0) | (normalizeHref(style.href) ? HREF_STYLE_FLAG : 0);
+		return internStyleKey(styleSignature(style));
 	}
 	function normalizeHref(value) {
 		if (typeof value !== "string") return null;
@@ -8633,17 +8744,25 @@ function createStdoutRenderer(terminal, options) {
 	let prevFP = new Uint32Array(0);
 	let currentHrefIds = new Uint32Array(0);
 	let prevHrefIds = new Uint32Array(0);
+	let currentTextIds = new Uint32Array(0);
+	let prevTextIds = new Uint32Array(0);
 	let fpPrevValid = false;
+	let nextCellTextId = 1;
+	let blankTextId = 0;
+	let emptyTextId = 0;
+	let continuationTextId = 0;
+	const cellTextIdCache = new Map();
+	const MAX_CELL_TEXT_IDS = 131072;
 	let prevOverlayBlockedRows = [];
 	let prevOverlayPartialRows = [];
 	const hrefIndex = new Map();
 	let nextHrefId = 1;
 	const MAX_HREF_IDS = 8192;
 	let hrefIndexResetRequiresBaseline = false;
-	function resetHrefIndex() {
+	function resetHrefIndex(resetIds = false) {
 		hrefIndex.clear();
-		nextHrefId = 1;
-		fpPrevValid = false;
+		if (resetIds) nextHrefId = 1;
+		invalidateFingerprintBaseline();
 		hrefIndexResetRequiresBaseline = true;
 	}
 	function ensureFingerprints(cols, rows) {
@@ -8655,44 +8774,359 @@ function createStdoutRenderer(terminal, options) {
 		prevFP = new Uint32Array(len);
 		currentHrefIds = new Uint32Array(len);
 		prevHrefIds = new Uint32Array(len);
+		currentTextIds = new Uint32Array(len);
+		prevTextIds = new Uint32Array(len);
 		fpPrevValid = false;
 		prevOverlayBlockedRows = [];
 		prevOverlayPartialRows = [];
 	}
-	function charHash10(ch) {
-		if (ch.length <= 1) return (ch.charCodeAt(0) || 0) & 1023;
-		let h$1 = 33052;
-		for (let i = 0; i < ch.length; i++) {
-			h$1 ^= ch.charCodeAt(i);
-			h$1 = h$1 * 257 & 65535;
+	function cellFingerprintFromStyleKey(_ch, key) {
+		return key >>> 0;
+	}
+	function cellFingerprint(_ch, style) {
+		return styleKey(style) >>> 0;
+	}
+	function allocateCellTextId(text) {
+		const id = nextCellTextId++;
+		cellTextIdCache.set(text, id);
+		return id;
+	}
+	function resetCellTextIdCache(resetIds = false) {
+		cellTextIdCache.clear();
+		if (resetIds) nextCellTextId = 1;
+		blankTextId = allocateCellTextId(" ");
+		emptyTextId = allocateCellTextId("");
+		continuationTextId = nextCellTextId++;
+		invalidateFingerprintBaseline();
+	}
+	function cellIdentityTextId(cell) {
+		if (cell.continuation) return continuationTextId;
+		if (cell.ch === "") return emptyTextId;
+		return cellTextId(cell.ch);
+	}
+	function cellTextId(text) {
+		let cached = cellTextIdCache.get(text);
+		if (cached !== void 0) return cached;
+		const mustResetTextIds = nextCellTextId >= MAX_UINT32_INTERN_ID - 2;
+		if (cellTextIdCache.size >= MAX_CELL_TEXT_IDS || mustResetTextIds) {
+			resetCellTextIdCache(mustResetTextIds);
+			cached = cellTextIdCache.get(text);
+			if (cached !== void 0) return cached;
 		}
-		return h$1 & 1023;
+		return allocateCellTextId(text);
 	}
+	resetCellTextIdCache(true);
 	function hrefId(href) {
 		if (!href) return 0;
 		const cached = hrefIndex.get(href);
 		if (cached != null) return cached;
-		if (hrefIndex.size >= MAX_HREF_IDS || nextHrefId >= 4294967295) resetHrefIndex();
+		const mustResetHrefIds = nextHrefId >= MAX_UINT32_INTERN_ID;
+		if (hrefIndex.size >= MAX_HREF_IDS || mustResetHrefIds) resetHrefIndex(mustResetHrefIds);
 		const id = nextHrefId++;
 		hrefIndex.set(href, id);
 		return id;
 	}
-	function cellFingerprint(ch, style) {
-		return styleKey(style) << 10 | charHash10(ch);
+	const BLANK_STYLE = Object.freeze({});
+	const BLANK_CELL = Object.freeze({
+		ch: " ",
+		width: 1,
+		style: BLANK_STYLE
+	});
+	const cellAt = (row, x) => row[x] ?? BLANK_CELL;
+	function rowFingerprintsForThisRenderer(y) {
+		var _fingerprintTerminal$;
+		if (terminalFingerprintFnDirty) return null;
+		if (!ownsFingerprintFn || stdoutFingerprintOwners.get(terminal) !== fingerprintOwner) return null;
+		return ((_fingerprintTerminal$ = fingerprintTerminal.getRowFingerprints) === null || _fingerprintTerminal$ === void 0 ? void 0 : _fingerprintTerminal$.call(fingerprintTerminal, y)) ?? null;
+	}
+	function hasActiveExternalFingerprintProvider() {
+		if (!canInstallTerminalFingerprintFn()) return false;
+		if (stdoutFingerprintOwners.has(terminal)) return false;
+		try {
+			const rows = terminal.size().rows;
+			if (rows <= 0) return false;
+			return fingerprintTerminal.getRowFingerprints(0) != null;
+		} catch {
+			return false;
+		}
+	}
+	function shouldAttemptFingerprintInstall() {
+		return !fingerprintInstallBlockedByExternalProvider || !hasActiveExternalFingerprintProvider();
 	}
 	function fingerprintRow(row, y, cols) {
-		const rowFP = terminal.getRowFingerprints(y);
+		const rowFP = rowFingerprintsForThisRenderer(y);
 		const base = y * fpCols;
-		if (rowFP && rowFP.length >= cols) currentFP.set(rowFP.subarray(0, cols), base);
+		if (rowFP && rowFP.length >= cols && row.length >= cols) currentFP.set(rowFP.subarray(0, cols), base);
 		else for (let x = 0; x < cols; x++) {
-			const cell = row[x];
+			const cell = cellAt(row, x);
 			currentFP[base + x] = cellFingerprint(cell.ch, cell.style);
 		}
 		for (let x = 0; x < cols; x++) {
-			const cell = row[x];
-			currentHrefIds[base + x] = hrefId(normalizeHref(cell.style.href));
+			const cell = cellAt(row, x);
+			currentHrefIds[base + x] = hrefId(renderedHref(cell.style.href));
+			currentTextIds[base + x] = cellIdentityTextId(cell);
+		}
+	}
+	function snapshotRowFingerprints(row, y, cols) {
+		const fp = new Uint32Array(cols);
+		const hrefIds = new Uint32Array(cols);
+		const textIds = new Uint32Array(cols);
+		const rowFP = rowFingerprintsForThisRenderer(y);
+		if (rowFP && rowFP.length >= cols && row.length >= cols) fp.set(rowFP.subarray(0, cols));
+		else for (let x = 0; x < cols; x++) {
+			const cell = cellAt(row, x);
+			fp[x] = cellFingerprint(cell.ch, cell.style);
+		}
+		for (let x = 0; x < cols; x++) {
+			const cell = cellAt(row, x);
+			hrefIds[x] = hrefId(renderedHref(cell.style.href));
+			textIds[x] = cellIdentityTextId(cell);
 		}
+		return {
+			fp,
+			hrefIds,
+			textIds
+		};
 	}
+	const currentCellMatchesPrevious = (base, x) => {
+		return currentFP[base + x] === prevFP[base + x] && currentTextIds[base + x] === prevTextIds[base + x] && currentHrefIds[base + x] === prevHrefIds[base + x];
+	};
+	const cellMatchesPreviousAt = (currentBase, previousBase, x) => {
+		return currentFP[currentBase + x] === prevFP[previousBase + x] && currentTextIds[currentBase + x] === prevTextIds[previousBase + x] && currentHrefIds[currentBase + x] === prevHrefIds[previousBase + x];
+	};
+	const referenceCellMatchesCurrent = (row, rowFP, base, x, cols, referenceFP, referenceHrefIds, referenceTextIds) => {
+		const cell = cellAt(row, x);
+		const fingerprint = rowFP && rowFP.length >= cols && row.length >= cols ? rowFP[x] : cellFingerprint(cell.ch, cell.style);
+		return fingerprint === referenceFP[base + x] && cellIdentityTextId(cell) === referenceTextIds[base + x] && hrefId(renderedHref(cell.style.href)) === referenceHrefIds[base + x];
+	};
+	const fullRowDirtySpan = (cols) => {
+		return cols > 0 ? [{
+			startX: 0,
+			endXExclusive: cols
+		}] : [];
+	};
+	const dirtySpanWidth = (span) => Math.max(0, span.endXExclusive - span.startX);
+	const dirtySpanCoverage = (spans) => {
+		let total = 0;
+		for (const span of spans) total += dirtySpanWidth(span);
+		return total;
+	};
+	const estimatedCursorMoveBytes = (y, x) => {
+		return 3 + String(y + 1).length + 1 + String(x + 1).length + 1;
+	};
+	const estimatedRenderableTextBytes = (row, startX, endXExclusive, cols) => {
+		const start = Math.max(0, Math.min(cols, Math.floor(startX)));
+		const end = Math.max(start, Math.min(cols, Math.floor(endXExclusive)));
+		let bytes = 0;
+		for (let x = start; x < end; x++) {
+			const cell = cellAt(row, x);
+			if (cell.continuation) continue;
+			bytes += Buffer.byteLength(cell.ch || " ", "utf8");
+		}
+		return bytes;
+	};
+	const estimatedSpanPatchBytes = (row, spans, y, cols, clearToEol) => {
+		let bytes = 0;
+		for (const span of spans) {
+			bytes += estimatedCursorMoveBytes(y, span.startX);
+			bytes += estimatedRenderableTextBytes(row, span.startX, span.endXExclusive, cols);
+			bytes += EST_STYLE_SWITCH_BYTES;
+		}
+		if (clearToEol) bytes += EST_CLEAR_TO_EOL_BYTES;
+		return bytes;
+	};
+	const estimatedContiguousPatchBytes = (row, spans, y, cols, clearToEol) => {
+		if (!spans.length) return 0;
+		const first = spans[0];
+		const last = spans[spans.length - 1];
+		return estimatedCursorMoveBytes(y, first.startX) + estimatedRenderableTextBytes(row, first.startX, last.endXExclusive, cols) + EST_STYLE_SWITCH_BYTES + (clearToEol ? EST_CLEAR_TO_EOL_BYTES : 0);
+	};
+	const estimatedFullRowPatchBytes = (row, y, cols, clearToEol) => {
+		return estimatedCursorMoveBytes(y, 0) + EST_STYLE_SWITCH_BYTES + estimatedRenderableTextBytes(row, 0, cols, cols) + (clearToEol ? EST_CLEAR_TO_EOL_BYTES : 0);
+	};
+	const resolveDirtySpanRenderMode = (row, spans, y, cols, clearToEol) => {
+		if (spans.length <= 0) return "spans";
+		const forceSpanPatch = dirtyRowPatchMode === "span" || columnDiffMode === "single-span" || columnDiffMode === "multi-span";
+		const coverage = dirtySpanCoverage(spans);
+		const fullRowCoverageLimit = Math.max(1, Math.floor(cols * DIRTY_SPAN_FULL_ROW_THRESHOLD));
+		if (!forceSpanPatch && dirtyRowPatchMode === "auto" && useConservativeDirtyRows && coverage > dirtySpanConservativeMaxCells) return "row";
+		if (!forceSpanPatch && coverage >= fullRowCoverageLimit) return "row";
+		const fullRowCost = estimatedFullRowPatchBytes(row, y, cols, clearToEol);
+		if (spans.length === 1) {
+			const spanCost = estimatedSpanPatchBytes(row, spans, y, cols, clearToEol);
+			return forceSpanPatch || spanCost < fullRowCost ? "spans" : "row";
+		}
+		const multiCost = estimatedSpanPatchBytes(row, spans, y, cols, clearToEol);
+		const first = spans[0];
+		const last = spans[spans.length - 1];
+		const contiguousWidth = Math.max(0, last.endXExclusive - first.startX);
+		const canUseContiguous = forceSpanPatch || contiguousWidth < fullRowCoverageLimit;
+		const contiguousCost = canUseContiguous ? estimatedContiguousPatchBytes(row, spans, y, cols, clearToEol) : Number.POSITIVE_INFINITY;
+		const tooManySpans = !forceSpanPatch && spans.length > DIRTY_SPAN_MAX_PER_ROW;
+		const effectiveMultiCost = tooManySpans ? Number.POSITIVE_INFINITY : multiCost;
+		if (forceSpanPatch) return contiguousCost < multiCost ? "contiguous" : "spans";
+		if (contiguousCost < effectiveMultiCost && contiguousCost < fullRowCost) return "contiguous";
+		if (!tooManySpans && multiCost < fullRowCost) return "spans";
+		return "row";
+	};
+	const expandSpanStart = (row, startX, cols) => {
+		var _row$x;
+		let x = Math.max(0, Math.min(cols, Math.floor(startX)));
+		while (x > 0 && ((_row$x = row[x]) === null || _row$x === void 0 ? void 0 : _row$x.continuation)) x--;
+		const prev = row[x - 1];
+		if (prev && prev.width === 2 && !prev.continuation) x--;
+		return Math.max(0, x);
+	};
+	const expandSpanEnd = (row, endXExclusive, cols) => {
+		var _row$x2;
+		let x = Math.max(0, Math.min(cols, Math.floor(endXExclusive)));
+		const last = row[x - 1];
+		if (last && last.width === 2 && !last.continuation) x++;
+		while (x < cols && ((_row$x2 = row[x]) === null || _row$x2 === void 0 ? void 0 : _row$x2.continuation)) x++;
+		return Math.min(cols, x);
+	};
+	const previousCellLooksLikeWideContinuation = (referenceTextIds, base, x) => {
+		if (x <= 0 || x >= fpCols) return false;
+		return referenceTextIds[base + x] === continuationTextId;
+	};
+	const expandSpanForReferenceWideGlyphs = (span, referenceTextIds, base, cols) => {
+		let startX = span.startX;
+		let endXExclusive = span.endXExclusive;
+		const limit = Math.max(0, Math.min(cols, fpCols));
+		if (startX > 0) {
+			if (previousCellLooksLikeWideContinuation(referenceTextIds, base, startX)) startX--;
+			else if (previousCellLooksLikeWideContinuation(referenceTextIds, base, startX - 1)) startX = Math.max(0, startX - 2);
+		}
+		while (endXExclusive < limit) {
+			if (!previousCellLooksLikeWideContinuation(referenceTextIds, base, endXExclusive)) break;
+			endXExclusive++;
+		}
+		return {
+			startX,
+			endXExclusive
+		};
+	};
+	const widenSpanToCurrentGlyphBoundaries = (row, span, cols) => {
+		return {
+			startX: expandSpanStart(row, span.startX, cols),
+			endXExclusive: expandSpanEnd(row, span.endXExclusive, cols)
+		};
+	};
+	const expandSpansForReferenceWideGlyphs = (spans, row, y, cols, referenceTextIds) => {
+		if (!spans.length || !fpCols || y < 0 || y >= fpRows) return spans;
+		const base = y * fpCols;
+		const expanded = [];
+		for (const span of spans) {
+			const next = widenSpanToCurrentGlyphBoundaries(row, expandSpanForReferenceWideGlyphs(span, referenceTextIds, base, cols), cols);
+			const prev = expanded[expanded.length - 1];
+			if (prev && next.startX <= prev.endXExclusive + DIRTY_SPAN_MERGE_GAP_CELLS) {
+				expanded[expanded.length - 1] = {
+					startX: prev.startX,
+					endXExclusive: Math.max(prev.endXExclusive, next.endXExclusive)
+				};
+				continue;
+			}
+			expanded.push(next);
+		}
+		return expanded;
+	};
+	const pushDirtySpan = (spans, row, startX, endXExclusive, cols) => {
+		let expandedStart = Math.max(0, Math.min(cols, startX));
+		let expandedEnd = Math.max(expandedStart, Math.min(cols, endXExclusive));
+		if (expandedEnd <= expandedStart) return;
+		expandedStart = expandSpanStart(row, expandedStart, cols);
+		expandedEnd = expandSpanEnd(row, expandedEnd, cols);
+		expandedStart = Math.max(0, Math.min(cols, expandedStart));
+		expandedEnd = Math.max(expandedStart, Math.min(cols, expandedEnd));
+		if (expandedEnd <= expandedStart) return;
+		const prev = spans[spans.length - 1];
+		if (prev && expandedStart <= prev.endXExclusive + DIRTY_SPAN_MERGE_GAP_CELLS) {
+			spans[spans.length - 1] = {
+				startX: prev.startX,
+				endXExclusive: Math.max(prev.endXExclusive, expandedEnd)
+			};
+			return;
+		}
+		spans.push({
+			startX: expandedStart,
+			endXExclusive: expandedEnd
+		});
+	};
+	const collectChangedSpans = (row, cols, changedAt) => {
+		const limit = Math.max(0, cols);
+		if (limit <= 0) return [];
+		const spans = [];
+		let startX = -1;
+		for (let x = 0; x < limit; x++) {
+			if (changedAt(x)) {
+				if (startX < 0) startX = x;
+				continue;
+			}
+			if (startX >= 0) {
+				pushDirtySpan(spans, row, startX, x, cols);
+				startX = -1;
+			}
+		}
+		if (startX >= 0) pushDirtySpan(spans, row, startX, limit, cols);
+		return spans;
+	};
+	const resolveChangedSpans = (row, y, cols, nextSnapshot) => {
+		if (!fpCols || cols !== fpCols || y >= fpRows || !fpPrevValid) return fullRowDirtySpan(cols);
+		const base = y * fpCols;
+		let spans;
+		if (!nextSnapshot) spans = expandSpansForReferenceWideGlyphs(collectChangedSpans(row, cols, (x) => !currentCellMatchesPrevious(base, x)), row, y, cols, prevTextIds);
+		else spans = expandSpansForReferenceWideGlyphs(collectChangedSpans(row, cols, (x) => {
+			return nextSnapshot.fp[x] !== prevFP[base + x] || nextSnapshot.textIds[x] !== prevTextIds[base + x] || nextSnapshot.hrefIds[x] !== prevHrefIds[base + x];
+		}), row, y, cols, prevTextIds);
+		return activeRenderBaselineChanged() ? fullRowDirtySpan(cols) : spans;
+	};
+	const resolveChangedSpansAgainstFill = (row, y, cols, fillFingerprint, fillTextId = blankTextId, fillHrefId = 0) => {
+		if (!fpCols || cols !== fpCols || y >= fpRows) return fullRowDirtySpan(cols);
+		const base = y * fpCols;
+		const spans = collectChangedSpans(row, cols, (x) => {
+			return currentFP[base + x] !== fillFingerprint || currentTextIds[base + x] !== fillTextId || currentHrefIds[base + x] !== fillHrefId;
+		});
+		return activeRenderBaselineChanged() ? fullRowDirtySpan(cols) : spans;
+	};
+	const resolveChangedSpansAgainstReference = (row, y, cols, referenceFP, referenceHrefIds, referenceTextIds) => {
+		if (!fpCols || cols !== fpCols || y >= fpRows) return fullRowDirtySpan(cols);
+		const rowFP = rowFingerprintsForThisRenderer(y);
+		const base = y * fpCols;
+		const spans = expandSpansForReferenceWideGlyphs(collectChangedSpans(row, cols, (x) => {
+			return !referenceCellMatchesCurrent(row, rowFP, base, x, cols, referenceFP, referenceHrefIds, referenceTextIds);
+		}), row, y, cols, referenceTextIds);
+		return activeRenderBaselineChanged() ? fullRowDirtySpan(cols) : spans;
+	};
+	const isEolClearEquivalentBlankCell = (cell, defaultBlankStyleKey) => {
+		if (!cell) return true;
+		if (cell.continuation) return false;
+		const ch = cell.ch || " ";
+		if (ch !== " ") return false;
+		if (cell.width !== 1) return false;
+		if (renderedHref(cell.style.href)) return false;
+		return styleKey(cell.style) === defaultBlankStyleKey;
+	};
+	const lastExplicitPaintColumnInRow = (row, cols, defaultBlankStyleKey) => {
+		const limit = Math.max(0, cols);
+		for (let x = limit - 1; x >= 0; x--) {
+			const cell = cellAt(row, x);
+			if (!isEolClearEquivalentBlankCell(cell, defaultBlankStyleKey)) {
+				if (cell && !cell.continuation && cell.width === 2 && x + 1 < limit) return x + 1;
+				return x;
+			}
+		}
+		return -1;
+	};
+	const shouldRewriteRowTail = (row, y, cols, referenceFP, referenceHrefIds, referenceTextIds, defaultBlankStyleKey = styleKeyFromParts({ bg: defaultBg })) => {
+		if (!fpCols || y >= fpRows) return true;
+		const currentTailStart = Math.max(0, Math.min(cols, lastExplicitPaintColumnInRow(row, cols, defaultBlankStyleKey) + 1));
+		if (currentTailStart >= cols) return false;
+		const blankFP = cellFingerprintFromStyleKey(" ", defaultBlankStyleKey);
+		const base = y * fpCols;
+		const limit = Math.min(cols, fpCols);
+		for (let x = currentTailStart; x < limit; x++) if (referenceFP[base + x] !== blankFP || referenceTextIds[base + x] !== blankTextId || referenceHrefIds[base + x] !== 0) return true;
+		return false;
+	};
 	const rowCursorToCol1 = [];
 	const rowClearToEol = [];
 	const rowTextPartsScratch = [];
@@ -8755,12 +9189,12 @@ function createStdoutRenderer(terminal, options) {
 			rowClearToEol[y] = `\u001B[${y + 1};1H\u001B[K`;
 		}
 	};
-	const rowHasNonDefaultBlankCell = (source, y, cols) => {
+	const rowHasNonDefaultBlankCell = (sourceFP, sourceTextIds, sourceHrefIds, y, cols) => {
 		if (!fpCols || y < 0 || y >= fpRows) return false;
-		const blankFP = styleKeyFromParts({ bg: defaultBg }) << 10 | charHash10(" ");
+		const blankFP = cellFingerprintFromStyleKey(" ", styleKeyFromParts({ bg: defaultBg }));
 		const base = y * fpCols;
 		const limit = Math.min(cols, fpCols);
-		for (let x = 0; x < limit; x++) if (source[base + x] !== blankFP) return true;
+		for (let x = 0; x < limit; x++) if (sourceFP[base + x] !== blankFP || sourceTextIds[base + x] !== blankTextId || sourceHrefIds[base + x] !== 0) return true;
 		return false;
 	};
 	function overlayPlaneCoverageRows(totalRows) {
@@ -8781,7 +9215,7 @@ function createStdoutRenderer(terminal, options) {
 		const raw = String(firstNonEmptyEnv(env, "VUE_TUI_SCROLL_REGIONS", "DIMCODE_TUI_SCROLL_REGIONS") ?? "").trim();
 		if (raw === "0" || raw === "false") return false;
 		if (isGhostty || isVscodeTerminal) return false;
-		return out.isTTY !== false;
+		return outputIsTTY;
 	})();
 	function prepareExplicitScrollOperations(operations, blockedRows) {
 		if (!operations.length || !(blockedRows === null || blockedRows === void 0 ? void 0 : blockedRows.size)) return {
@@ -8904,13 +9338,13 @@ function createStdoutRenderer(terminal, options) {
 			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);
+				const informative = rowHasNonDefaultBlankCell(currentFP, currentTextIds, currentHrefIds, y, cols) || rowHasNonDefaultBlankCell(prevFP, prevTextIds, prevHrefIds, 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] || currentHrefIds[curBase + x] !== prevHrefIds[prevBase + x]) {
+				for (let x = 0; x < cols; x++) if (!cellMatchesPreviousAt(curBase, prevBase, x)) {
 					rowMatch = false;
 					break;
 				}
@@ -8935,7 +9369,7 @@ function createStdoutRenderer(terminal, options) {
 					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] || currentHrefIds[curBase + x] !== prevHrefIds[prevBase + x]) {
+					for (let x = 0; x < cols; x++) if (!cellMatchesPreviousAt(curBase, prevBase, x)) {
 						rowMatch = false;
 						break;
 					}
@@ -8953,45 +9387,83 @@ function createStdoutRenderer(terminal, options) {
 		}
 		return null;
 	}
+	const isHighSurrogate = (code) => code >= 55296 && code <= 56319;
+	const isLowSurrogate = (code) => code >= 56320 && code <= 57343;
+	const codePointEnd = (data, index) => {
+		const code = data.charCodeAt(index);
+		if (isHighSurrogate(code) && index + 1 < data.length) {
+			const next = data.charCodeAt(index + 1);
+			if (isLowSurrogate(next)) return index + 2;
+		}
+		return index + 1;
+	};
+	const codePointBefore = (data, index) => {
+		if (index <= 0) return null;
+		const prev = data.charCodeAt(index - 1);
+		if (isLowSurrogate(prev) && index - 2 >= 0) {
+			const high = data.charCodeAt(index - 2);
+			if (isHighSurrogate(high)) return data.codePointAt(index - 2) ?? null;
+		}
+		return data.codePointAt(index - 1) ?? null;
+	};
+	const isGraphemeContinuationCodePoint = (codePoint) => codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071 || codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999 || codePoint >= 127995 && codePoint <= 127999 || codePoint >= 917536 && codePoint <= 917631;
+	const shouldAttachToPreviousGrapheme = (data, index) => {
+		const codePoint = data.codePointAt(index);
+		if (codePoint == null) return false;
+		if (codePoint === 8205) return true;
+		if (codePointBefore(data, index) === 8205) return true;
+		return isGraphemeContinuationCodePoint(codePoint);
+	};
+	const safeChunkEnd = (data, start, maxBytes) => {
+		let end = start;
+		let bytes = 0;
+		const limit = Math.max(1, Math.floor(maxBytes));
+		while (end < data.length) {
+			const next = codePointEnd(data, end);
+			const partBytes = Buffer.byteLength(data.slice(end, next), "utf8");
+			if (end > start && bytes + partBytes > limit && !shouldAttachToPreviousGrapheme(data, end)) break;
+			bytes += partBytes;
+			end = next;
+			while (end < data.length && shouldAttachToPreviousGrapheme(data, end)) {
+				const attachedEnd = codePointEnd(data, end);
+				bytes += Buffer.byteLength(data.slice(end, attachedEnd), "utf8");
+				end = attachedEnd;
+			}
+			if (bytes >= limit && (end >= data.length || !shouldAttachToPreviousGrapheme(data, end))) break;
+		}
+		return end > start ? end : codePointEnd(data, start);
+	};
 	/**
 	* Write data in chunks to avoid overwhelming terminal buffers.
 	* This is especially important for ghostty which can hang on large writes.
-	*
-	* CRITICAL: In ghostty, setTimeout callbacks don't execute, so we must use
-	* synchronous chunked writes. We break large writes into smaller chunks to
-	* reduce the chance of terminal hangs.
 	*/
 	function writeChunked(data) {
-		if (!isGhostty) {
-			if (data.length <= chunkSize) {
-				out.write(data);
-				return;
-			}
-			for (let i = 0; i < data.length; i += chunkSize) {
-				const chunk = data.slice(i, i + chunkSize);
-				out.write(chunk);
-			}
+		if (Buffer.byteLength(data, "utf8") <= chunkSize) {
+			out.write(data);
 			return;
 		}
-		if (isDebugEnabled()) getDebugLog().render(`writeChunked: sync chunked write of ${data.length} bytes`);
+		if (isDebugEnabled()) getDebugLog().render(`writeChunked: sync chunked write of ${Buffer.byteLength(data, "utf8")} bytes`);
 		try {
-			if (data.length <= chunkSize) out.write(data);
-			else for (let i = 0; i < data.length; i += chunkSize) {
-				const chunk = data.slice(i, i + chunkSize);
-				out.write(chunk);
+			for (let start = 0; start < data.length;) {
+				const end = safeChunkEnd(data, start, chunkSize);
+				out.write(data.slice(start, end));
+				start = end;
 			}
 			if (isDebugEnabled()) getDebugLog().render(`writeChunked: chunked write completed`);
 		} catch (e) {
 			if (isDebugEnabled()) getDebugLog().error(`writeChunked: write error`, e);
+			throw e;
 		}
 	}
 	/**
 	* Internal function that actually renders the frame to stdout.
 	* When dirtyRows is provided, only those rows are repainted.
 	*/
-	function doRender(dirtyRows, scrollOperations) {
+	function doRender(dirtyRows, scrollOperations, forceDirtyRowsRepaint = false) {
 		if (isDebugEnabled()) getDebugLog().render(`doRender() START: dirtyRows=${(dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) ?? "null"}`);
 		if (disposed) return;
+		const currentFingerprintOwner = stdoutFingerprintOwners.get(terminal);
+		if ((!ownsFingerprintFn || terminalFingerprintFnDirty) && (!currentFingerprintOwner || currentFingerprintOwner === fingerprintOwner) && canInstallTerminalFingerprintFn() && shouldAttemptFingerprintInstall()) installFingerprintFn(terminalFingerprintFnDirty);
 		cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutRenderStart();
 		pendingRender = false;
 		accumulatedAllRows = false;
@@ -8999,6 +9471,7 @@ function createStdoutRenderer(terminal, options) {
 		accumulatedDirtyCount = 0;
 		accumulatedDirtyMin = Number.POSITIVE_INFINITY;
 		accumulatedDirtyMax = -1;
+		accumulatedDirtyRowsRequireRepaint = false;
 		accumulatedScrollOperations = null;
 		lastFrameTime = Date.now();
 		const renderStart = performance.now();
@@ -9008,10 +9481,15 @@ function createStdoutRenderer(terminal, options) {
 		const bgSeq = openBg(defaultBg);
 		const bgOnlyStyle = { bg: defaultBg };
 		const bgKey = styleKeyFromParts({ bg: defaultBg });
-		const blankFP = bgKey << 10 | charHash10(" ");
+		const blankFP = cellFingerprintFromStyleKey(" ", bgKey);
 		let dirtySorted = true;
-		const forceFullRender = hrefIndexResetRequiresBaseline;
-		if (forceFullRender) hrefIndexResetRequiresBaseline = false;
+		const forceFullRender = hrefIndexResetRequiresBaseline || fingerprintInternResetRequiresBaseline;
+		if (forceFullRender) {
+			hrefIndexResetRequiresBaseline = false;
+			fingerprintInternResetRequiresBaseline = false;
+			fpPrevValid = false;
+		}
+		activeRenderBaselineGeneration = fingerprintBaselineGeneration;
 		const normalizedScrollOperations = (() => {
 			if (!(scrollOperations === null || scrollOperations === void 0 ? void 0 : scrollOperations.length)) return null;
 			const outOps = [];
@@ -9030,8 +9508,9 @@ function createStdoutRenderer(terminal, options) {
 			return outOps;
 		})();
 		let rowsToRender = (() => {
-			if (forceFullRender) return null;
-			if (!dirtyRows || dirtyRows.length === 0) return null;
+			if (forceFullRender || !fpPrevValid) return null;
+			if (!dirtyRows) return null;
+			if (dirtyRows.length === 0) return [];
 			const outRows = [];
 			outRows.length = dirtyRows.length;
 			let outLen = 0;
@@ -9039,20 +9518,35 @@ function createStdoutRenderer(terminal, options) {
 			let prev = -1;
 			for (let i = 0; i < dirtyRows.length; i++) {
 				const y = Math.floor(dirtyRows[i] ?? -1);
-				if (y < 0 || y >= size.rows) continue;
+				if (!Number.isFinite(y) || y < 0 || y >= size.rows) continue;
 				if (y <= prev) sorted = false;
 				prev = y;
 				outRows[outLen++] = y;
 			}
 			outRows.length = outLen;
-			if (!outRows.length) return null;
+			if (!outRows.length) return [];
 			dirtySorted = sorted;
 			if (!sorted) outRows.sort((a, b) => a - b);
 			return outRows;
 		})();
+		if ((rowsToRender === null || rowsToRender === void 0 ? void 0 : rowsToRender.length) === 0 && !normalizedScrollOperations && !getImeAnchor) {
+			if (isDebugEnabled()) getDebugLog().render(" No valid dirty rows; frame skipped");
+			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutNoOutput();
+			return;
+		}
+		const dirtyRowSnapshots = fpPrevValid && rowsToRender ? new Map() : null;
+		const snapshotDirtyRowFingerprints = () => {
+			if (!dirtyRowSnapshots || !rowsToRender) return;
+			for (const y of rowsToRender) {
+				const row = terminal.getRow(y);
+				dirtyRowSnapshots.set(y, snapshotRowFingerprints(row, y, size.cols));
+			}
+		};
+		snapshotDirtyRowFingerprints();
 		if (fpPrevValid && rowsToRender) {
 			currentFP.set(prevFP);
 			currentHrefIds.set(prevHrefIds);
+			currentTextIds.set(prevTextIds);
 		}
 		const frameParts = [];
 		frameParts.push(!isGhostty && useSyncOutput ? SYNC_START : "");
@@ -9072,6 +9566,14 @@ function createStdoutRenderer(terminal, options) {
 			inverse: false,
 			href: null
 		};
+		const closeActiveHrefBeforeCursorMove = () => {
+			if (!enableOsc8Links || !activeStyle.href) return;
+			frameParts.push(OSC8_CLOSE);
+			activeStyle = {
+				...activeStyle,
+				href: null
+			};
+		};
 		const normalizeStyle$1 = (style) => {
 			return {
 				fg: style.fg ?? null,
@@ -9081,7 +9583,7 @@ function createStdoutRenderer(terminal, options) {
 				italic: Boolean(style.italic),
 				underline: Boolean(style.underline),
 				inverse: Boolean(style.inverse),
-				href: normalizeHref(style.href)
+				href: renderedHref(style.href)
 			};
 		};
 		const emitStyle = (nextStyle, nextKey) => {
@@ -9108,20 +9610,29 @@ function createStdoutRenderer(terminal, options) {
 			activeStyleKey = nextKey;
 			activeStyle = next;
 		};
-		const shouldEmitStyle = (style, key) => activeStyleKey !== key || activeStyle.href !== normalizeHref(style.href);
-		const renderRow = (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) return;
+		const shouldEmitStyle = (style, key) => activeStyleKey !== key || activeStyle.href !== renderedHref(style.href);
+		const renderRow = (y, row, startX = 0, endXExclusive = size.cols, clearToEol = true) => {
+			const spanStart = Math.max(0, Math.min(size.cols, Math.floor(startX)));
+			const spanEnd = Math.max(spanStart, Math.min(size.cols, Math.floor(endXExclusive)));
+			const shouldClearToEol = clearToEol && spanEnd < size.cols;
+			if (spanStart >= spanEnd && !shouldClearToEol) 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`);
+			const pushCursorFixAfterCell = (parts, cellX, cell) => {
+				const afterX = cellX + (cell.width ?? 1);
+				if (afterX >= size.cols) return;
+				parts.push(`\u001B[${y + 1};${afterX + 1}H`);
+			};
+			if (!disableCursorPos) {
+				closeActiveHrefBeforeCursorMove();
+				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;
 			currentTextParts.length = 0;
 			for (let x = spanStart; x < spanEnd; x++) {
-				const cell = row[x];
+				const cell = cellAt(row, x);
 				if (cell.continuation) continue;
 				const ch = cell.ch || " ";
 				const nextStyle = cell.style;
@@ -9130,17 +9641,12 @@ function createStdoutRenderer(terminal, options) {
 					currentKey = key;
 					currentStyle = nextStyle;
 					currentTextParts.push(ch);
-					if (needsCursorFix(cell, ch)) currentTextParts.push(`\u001B[${y + 1};${x + 1 + (cell.width ?? 1)}H`);
+					if (needsCursorFix(cell, ch)) pushCursorFixAfterCell(currentTextParts, x, cell);
 					continue;
 				}
-				if (key === currentKey && normalizeHref(nextStyle.href) === normalizeHref(
-					// 8-bit limit
-					// saturate to avoid overflow
-					// where this row's content came from in prev frame
-					currentStyle === null || currentStyle === void 0 ? void 0 : currentStyle.href
-)) {
+				if (key === currentKey && renderedHref(nextStyle.href) === renderedHref(currentStyle === null || currentStyle === void 0 ? void 0 : currentStyle.href)) {
 					currentTextParts.push(ch);
-					if (needsCursorFix(cell, ch)) currentTextParts.push(`\u001B[${y + 1};${x + 1 + (cell.width ?? 1)}H`);
+					if (needsCursorFix(cell, ch)) pushCursorFixAfterCell(currentTextParts, x, cell);
 					continue;
 				}
 				if (shouldEmitStyle(currentStyle, currentKey)) emitStyle(currentStyle, currentKey);
@@ -9149,18 +9655,82 @@ function createStdoutRenderer(terminal, options) {
 				currentStyle = nextStyle;
 				currentTextParts.length = 0;
 				currentTextParts.push(ch);
-				if (needsCursorFix(cell, ch)) currentTextParts.push(`\u001B[${y + 1};${x + 1 + (cell.width ?? 1)}H`);
+				if (needsCursorFix(cell, ch)) pushCursorFixAfterCell(currentTextParts, x, cell);
 			}
 			if (currentKey != null) {
 				if (shouldEmitStyle(currentStyle, currentKey)) emitStyle(currentStyle, currentKey);
 				frameParts.push(currentTextParts.join(""));
 			}
-			if (clearToEol) {
+			if (shouldClearToEol) {
 				if (activeStyleKey !== bgKey) emitStyle(bgOnlyStyle, bgKey);
 				frameParts.push("\x1B[K");
 			}
 			lastRenderedY = y;
-			lastRenderWasFullRow = spanStart === 0 && clearToEol;
+			lastRenderWasFullRow = spanStart === 0 && (spanEnd >= size.cols || shouldClearToEol);
+		};
+		const lastRenderableColumnInCurrentRow = (rowY, cols, blankFingerprint) => {
+			if (!fpCols || rowY < 0 || rowY >= fpRows) return -1;
+			const base = rowY * fpCols;
+			const limit = Math.min(cols, fpCols);
+			for (let x = limit - 1; x >= 0; x--) if (currentFP[base + x] !== blankFingerprint || currentTextIds[base + x] !== blankTextId || currentHrefIds[base + x] !== 0) return x;
+			return -1;
+		};
+		const resolveTailClearStartX = (rowY, cols, shouldRewriteTail, blankFingerprint) => {
+			if (!shouldRewriteTail) return null;
+			const lastRenderableX = lastRenderableColumnInCurrentRow(rowY, cols, blankFingerprint);
+			const clearStartX = Math.max(0, Math.min(cols, lastRenderableX + 1));
+			return clearStartX < cols ? clearStartX : null;
+		};
+		const renderDirtySpans = (rowY, row, rawSpans, rewriteTail) => {
+			if (!rawSpans.length && !rewriteTail) return;
+			const rowCols = size.cols;
+			const clearStartX = resolveTailClearStartX(rowY, rowCols, rewriteTail, blankFP);
+			const paintTailInsteadOfEscK = clearStartX != null && dirtyRowPatchMode === "auto" && useConservativeDirtyRows;
+			const spansToPaint = [];
+			for (const span of rawSpans) {
+				const startX = Math.max(0, Math.min(rowCols, span.startX));
+				const endXExclusive = Math.max(startX, Math.min(rowCols, span.endXExclusive));
+				if (endXExclusive <= startX) continue;
+				if (clearStartX != null && !paintTailInsteadOfEscK) {
+					if (startX >= clearStartX) continue;
+					const clippedEnd = Math.min(endXExclusive, clearStartX);
+					if (clippedEnd > startX) spansToPaint.push({
+						startX,
+						endXExclusive: clippedEnd
+					});
+					continue;
+				}
+				spansToPaint.push({
+					startX,
+					endXExclusive
+				});
+			}
+			if (paintTailInsteadOfEscK && clearStartX != null && clearStartX < rowCols) {
+				const prev = spansToPaint[spansToPaint.length - 1];
+				if (prev && clearStartX <= prev.endXExclusive + DIRTY_SPAN_MERGE_GAP_CELLS) spansToPaint[spansToPaint.length - 1] = {
+					startX: prev.startX,
+					endXExclusive: rowCols
+				};
+				else spansToPaint.push({
+					startX: clearStartX,
+					endXExclusive: rowCols
+				});
+			}
+			const clearToEolForCost = clearStartX != null && clearStartX < rowCols && !paintTailInsteadOfEscK;
+			const renderMode = !shouldUseMultiDirtySpans() && spansToPaint.length > 0 ? "contiguous" : resolveDirtySpanRenderMode(row, spansToPaint, rowY, rowCols, clearToEolForCost);
+			if (renderMode === "row") {
+				if (clearStartX != null && !paintTailInsteadOfEscK) renderRow(rowY, row, 0, clearStartX, true);
+				else renderRow(rowY, row, 0, rowCols, false);
+				return;
+			} else if (renderMode === "contiguous") {
+				const first = spansToPaint[0];
+				const last = spansToPaint[spansToPaint.length - 1];
+				if (first && last) {
+					const rewriteEnd = clearStartX == null || paintTailInsteadOfEscK ? last.endXExclusive : Math.min(last.endXExclusive, clearStartX);
+					if (rewriteEnd > first.startX) renderRow(rowY, row, first.startX, rewriteEnd, false);
+				}
+			} else for (const span of spansToPaint) renderRow(rowY, row, span.startX, span.endXExclusive, false);
+			if (clearStartX != null && !paintTailInsteadOfEscK) renderRow(rowY, row, clearStartX, clearStartX, true);
 		};
 		const overlayCoverage = overlayPlaneCoverageRows(size.rows);
 		const overlayRows = Array.from(new Set([...overlayCoverage.blockedRows, ...prevOverlayBlockedRows])).sort((a, b) => a - b);
@@ -9182,9 +9752,9 @@ function createStdoutRenderer(terminal, options) {
 				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);
+				const expandedRows$1 = new Set(rowsToRender ?? []);
+				for (const op of explicitScrollOperations) for (let y = op.startY; y < op.endY; y++) expandedRows$1.add(y);
+				rowsToRender = Array.from(expandedRows$1).sort((a, b) => a - b);
 				dirtySorted = true;
 				explicitScrollOperations = null;
 				hiddenExplicitDirtyRows = null;
@@ -9192,27 +9762,32 @@ function createStdoutRenderer(terminal, options) {
 			}
 		}
 		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++) {
+		const expandedRows = new Set(rowsToRender ?? []);
+		const includeRowsForPendingScrollOperations = (operations) => {
+			if (!(operations === null || operations === void 0 ? void 0 : operations.length)) return;
+			for (const op of operations) for (let y = op.startY; y < op.endY; y++) {
 				if (hiddenExplicitDirtyRows === null || hiddenExplicitDirtyRows === void 0 ? void 0 : hiddenExplicitDirtyRows.has(y)) continue;
 				expandedRows.add(y);
 			}
+		};
+		if (explicitScrollOperations && rowsToRender && (!enableScrollRegions || !fpPrevValid)) {
+			includeRowsForPendingScrollOperations(explicitScrollOperations);
 			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);
+		const denseDirtyRows = Boolean(rowsToRender && size.rows > 1 && 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;
+		const useScrollRegions = enableScrollRegions && fpPrevValid && scrollRowsCandidate && scrollRowsCandidate.length >= 3 && !forceDirtyRowsRepaint && allowInferredScrollRegions;
 		let scrollHandled = false;
 		if (enableScrollRegions && explicitScrollOperations && scrollRowsCandidate && fpPrevValid) {
 			if (currentFP.length === prevFP.length) {
 				currentFP.set(prevFP);
 				currentHrefIds.set(prevHrefIds);
+				currentTextIds.set(prevTextIds);
 			}
 			const explicitRowsToRender = new Set();
 			for (const y of scrollRowsCandidate) {
@@ -9232,6 +9807,7 @@ function createStdoutRenderer(terminal, options) {
 						for (let x = 0; x < size.cols; x++) {
 							currentFP[dstBase + x] = prevFP[srcBase + x];
 							currentHrefIds[dstBase + x] = prevHrefIds[srcBase + x];
+							currentTextIds[dstBase + x] = prevTextIds[srcBase + x];
 						}
 					}
 					for (let y = op.endY - op.delta; y < op.endY; y++) {
@@ -9240,6 +9816,7 @@ function createStdoutRenderer(terminal, options) {
 						for (let x = 0; x < size.cols; x++) {
 							currentFP[base + x] = blankFP;
 							currentHrefIds[base + x] = 0;
+							currentTextIds[base + x] = blankTextId;
 						}
 					}
 				} else {
@@ -9252,6 +9829,7 @@ function createStdoutRenderer(terminal, options) {
 						for (let x = 0; x < size.cols; x++) {
 							currentFP[dstBase + x] = prevFP[srcBase + x];
 							currentHrefIds[dstBase + x] = prevHrefIds[srcBase + x];
+							currentTextIds[dstBase + x] = prevTextIds[srcBase + x];
 						}
 					}
 					for (let y = op.startY; y < op.startY + absDelta; y++) {
@@ -9260,6 +9838,7 @@ function createStdoutRenderer(terminal, options) {
 						for (let x = 0; x < size.cols; x++) {
 							currentFP[base + x] = blankFP;
 							currentHrefIds[base + x] = 0;
+							currentTextIds[base + x] = blankTextId;
 						}
 					}
 				}
@@ -9268,10 +9847,28 @@ function createStdoutRenderer(terminal, options) {
 			const explicitDirtyRows = Array.from(explicitRowsToRender).sort((a, b) => a - b);
 			const overlayDirtyRows = overlayTouchedRowSet ? explicitDirtyRows.filter((y) => overlayTouchedRowSet.has(y)) : [];
 			const paintedExplicitRows = [];
+			const insertedRows = new Set();
+			for (const op of explicitScrollOperations) {
+				const absDelta = Math.abs(op.delta);
+				if (op.delta > 0) for (let y = op.endY - absDelta; y < op.endY; y++) insertedRows.add(y);
+				else for (let y = op.startY; y < op.startY + absDelta; y++) insertedRows.add(y);
+			}
 			for (const y of explicitDirtyRows) {
 				const row = terminal.getRow(y);
-				fingerprintRow(row, y, size.cols);
-				renderRow(y, row);
+				const overlayRow = overlayTouchedRowSet === null || overlayTouchedRowSet === void 0 ? void 0 : overlayTouchedRowSet.has(y);
+				if (forceDirtyRowsRepaint || !shouldUseDirtySpans() || overlayRow) {
+					fingerprintRow(row, y, size.cols);
+					renderRow(y, row);
+					paintedExplicitRows.push(y);
+					continue;
+				}
+				const insertedRow = insertedRows.has(y);
+				if (insertedRow) fingerprintRow(row, y, size.cols);
+				const spans = insertedRow ? resolveChangedSpansAgainstFill(row, y, size.cols, blankFP, blankTextId, 0) : resolveChangedSpansAgainstReference(row, y, size.cols, currentFP, currentHrefIds, currentTextIds);
+				if (!spans.length) continue;
+				const rewriteTail = !insertedRow && shouldRewriteRowTail(row, y, size.cols, currentFP, currentHrefIds, currentTextIds, bgKey);
+				if (!insertedRow) fingerprintRow(row, y, size.cols);
+				renderDirtySpans(y, row, spans, rewriteTail);
 				paintedExplicitRows.push(y);
 			}
 			if (isDebugEnabled() && overlayDirtyRows.length) getDebugLog().render(` Explicit scroll ops overlay rows: [${overlayDirtyRows.join(", ")}]`);
@@ -9284,6 +9881,7 @@ function createStdoutRenderer(terminal, options) {
 				if (currentFP.length === prevFP.length) {
 					currentFP.set(prevFP);
 					currentHrefIds.set(prevHrefIds);
+					currentTextIds.set(prevTextIds);
 				}
 				hasFrameOutput = true;
 				if (isDebugEnabled()) getDebugLog().render(` Scroll region: delta=${shift.delta}, region=${shift.regionStart}-${shift.regionEnd - 1}, new rows=${shift.newRowStart}-${shift.newRowEnd - 1}`);
@@ -9303,6 +9901,7 @@ function createStdoutRenderer(terminal, options) {
 						for (let x = 0; x < size.cols; x++) {
 							currentFP[dstBase + x] = prevFP[srcBase + x];
 							currentHrefIds[dstBase + x] = prevHrefIds[srcBase + x];
+							currentTextIds[dstBase + x] = prevTextIds[srcBase + x];
 						}
 					}
 					for (let y = shift.regionEnd - shift.delta; y < shift.regionEnd; y++) {
@@ -9310,6 +9909,7 @@ function createStdoutRenderer(terminal, options) {
 						for (let x = 0; x < size.cols; x++) {
 							currentFP[base + x] = blankFP;
 							currentHrefIds[base + x] = 0;
+							currentTextIds[base + x] = blankTextId;
 						}
 					}
 				} else {
@@ -9320,6 +9920,7 @@ function createStdoutRenderer(terminal, options) {
 						for (let x = 0; x < size.cols; x++) {
 							currentFP[dstBase + x] = prevFP[srcBase + x];
 							currentHrefIds[dstBase + x] = prevHrefIds[srcBase + x];
+							currentTextIds[dstBase + x] = prevTextIds[srcBase + x];
 						}
 					}
 					for (let y = shift.regionStart; y < shift.regionStart + absDelta; y++) {
@@ -9327,6 +9928,7 @@ function createStdoutRenderer(terminal, options) {
 						for (let x = 0; x < size.cols; x++) {
 							currentFP[base + x] = blankFP;
 							currentHrefIds[base + x] = 0;
+							currentTextIds[base + x] = blankTextId;
 						}
 					}
 				}
@@ -9338,6 +9940,17 @@ function createStdoutRenderer(terminal, options) {
 				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);
+					if (shouldUseDirtySpans()) {
+						const spans = resolveChangedSpansAgainstReference(row, y, size.cols, currentFP, currentHrefIds, currentTextIds);
+						if (!spans.length) {
+							fingerprintRow(row, y, size.cols);
+							continue;
+						}
+						const rewriteTail = shouldRewriteRowTail(row, y, size.cols, currentFP, currentHrefIds, currentTextIds, bgKey);
+						fingerprintRow(row, y, size.cols);
+						renderDirtySpans(y, row, spans, rewriteTail);
+						continue;
+					}
 					fingerprintRow(row, y, size.cols);
 					renderRow(y, row);
 				}
@@ -9363,11 +9976,18 @@ function createStdoutRenderer(terminal, options) {
 			}
 		} else {
 			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(", ")}])` : ""}`);
+			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);
 				fingerprintRow(row, y, size.cols);
-				renderRow(y, row);
+				if (forceDirtyRowsRepaint || !shouldUseDirtySpans()) {
+					renderRow(y, row);
+					continue;
+				}
+				const spans = resolveChangedSpans(row, y, size.cols, (dirtyRowSnapshots === null || dirtyRowSnapshots === void 0 ? void 0 : dirtyRowSnapshots.get(y)) ?? null);
+				if (!spans.length) continue;
+				const rewriteTail = shouldRewriteRowTail(row, y, size.cols, prevFP, prevHrefIds, prevTextIds, bgKey);
+				renderDirtySpans(y, row, spans, rewriteTail);
 			}
 		}
 		if (!rowsToRender && lastRenderedRows > size.rows) {
@@ -9381,16 +10001,22 @@ function createStdoutRenderer(terminal, options) {
 				frameParts.push(rowClearToEol[size.rows + i]);
 			}
 		}
-		if (!rowsToRender) lastRenderedRows = size.rows;
-		const tmpFP = prevFP;
-		prevFP = currentFP;
-		currentFP = tmpFP;
-		const tmpHrefIds = prevHrefIds;
-		prevHrefIds = currentHrefIds;
-		currentHrefIds = tmpHrefIds;
-		fpPrevValid = !hrefIndexResetRequiresBaseline;
-		prevOverlayBlockedRows = overlayCoverage.blockedRows;
-		prevOverlayPartialRows = overlayCoverage.partialRows;
+		const nextLastRenderedRows = !rowsToRender ? size.rows : lastRenderedRows;
+		const commitRenderBaseline = () => {
+			lastRenderedRows = nextLastRenderedRows;
+			const tmpFP = prevFP;
+			prevFP = currentFP;
+			currentFP = tmpFP;
+			const tmpHrefIds = prevHrefIds;
+			prevHrefIds = currentHrefIds;
+			currentHrefIds = tmpHrefIds;
+			const tmpTextIds = prevTextIds;
+			prevTextIds = currentTextIds;
+			currentTextIds = tmpTextIds;
+			fpPrevValid = !hrefIndexResetRequiresBaseline && !fingerprintInternResetRequiresBaseline;
+			prevOverlayBlockedRows = overlayCoverage.blockedRows;
+			prevOverlayPartialRows = overlayCoverage.partialRows;
+		};
 		let emittedCursorPos = null;
 		if (getImeAnchor) {
 			const anchor = getImeAnchor();
@@ -9402,11 +10028,13 @@ function createStdoutRenderer(terminal, options) {
 						x,
 						y
 					};
+					closeActiveHrefBeforeCursorMove();
 					frameParts.push(`\u001B[${y + 1};${x + 1}H`);
 				}
 			}
 		}
 		if (!hasFrameOutput) {
+			commitRenderBaseline();
 			if (isDebugEnabled()) getDebugLog().render(" No-op frame skipped");
 			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutNoOutput();
 			return;
@@ -9416,6 +10044,7 @@ function createStdoutRenderer(terminal, options) {
 		frameParts.push("\x1B[?7h");
 		frameParts.push(!isGhostty && useSyncOutput ? SYNC_END : "");
 		const frame = frameParts.join("");
+		const frameBytes = Buffer.byteLength(frame, "utf8");
 		if (profiler) profiler.recordRender({
 			durationMs: profiler.now() - renderStart,
 			rows: profiledRowCount,
@@ -9469,7 +10098,7 @@ function createStdoutRenderer(terminal, options) {
 				}
 				return count;
 			};
-			const frameSize = frame.length;
+			const frameSize = frameBytes;
 			const cursorSeqCount = countCursorMoves(frame);
 			const resetCount = countResets(frame);
 			const buildTime = (performance.now() - renderStart).toFixed(2);
@@ -9479,22 +10108,21 @@ function createStdoutRenderer(terminal, options) {
 		const writeStart = performance.now();
 		const resolveWriteMode = (frameSizeBytes) => {
 			if (isGhostty) return "chunked";
-			const canWriteSync = out.fd === 1;
 			const preferChunked = frameSizeBytes >= chunkThresholdBytes || writeEmaMs >= 24;
 			if (preferChunked) return "chunked";
-			if (canWriteSync && frameSizeBytes <= syncMaxBytes) return "sync";
+			if (canUseSyncStdout && frameSizeBytes <= syncMaxBytes) return "sync";
 			return "stream";
 		};
-		const writeMode = resolveWriteMode(frame.length);
+		const writeMode = resolveWriteMode(frameBytes);
 		if (isDebugEnabled()) getDebugLog().render(`Before write()`);
 		try {
 			if (writeMode === "chunked") {
 				if (isDebugEnabled()) getDebugLog().render(` Using chunked write (chunkSize=${chunkSize}, threshold=${chunkThresholdBytes}, emaMs=${writeEmaMs.toFixed(2)})`);
 				writeChunked(frame);
-			} else if (writeMode === "sync" && out.fd === 1) {
+			} else if (writeMode === "sync" && canUseSyncStdout) {
 				if (isDebugEnabled()) getDebugLog().render(` Using writeSync`);
 				try {
-					writeFdSync(1, frame);
+					writeFdSync(outputFd, frame);
 				} catch {
 					if (isDebugEnabled()) getDebugLog().render(` writeSync failed, falling back to stream write`);
 					out.write(frame);
@@ -9509,11 +10137,12 @@ function createStdoutRenderer(terminal, options) {
 			}
 		} catch (writeError) {
 			if (isDebugEnabled()) getDebugLog().error(`Write ERROR:`, writeError);
-			if (!isGhostty && useSyncOutput) try {
-				out.write(`\u001B[?7h${SYNC_END}`);
+			try {
+				out.write(`\u001B[?7h${!isGhostty && useSyncOutput ? SYNC_END : ""}`);
 			} catch {}
 			throw writeError;
 		}
+		commitRenderBaseline();
 		{
 			const writeMs = performance.now() - writeStart;
 			writeEmaMs = writeEmaMs === 0 ? writeMs : writeEmaMs * .85 + writeMs * .15;
@@ -9526,19 +10155,19 @@ function createStdoutRenderer(terminal, options) {
 			}
 			recordStdoutFrame({
 				at: Date.now(),
-				bytes: frame.length,
+				bytes: frameBytes,
 				writeMs,
 				writeEmaMs,
 				writeMode: writeMode === "sync" ? "sync" : writeMode === "chunked" ? "chunked" : "stream"
 			});
 			if (profiler) profiler.recordWrite({
 				durationMs: writeMs,
-				bytes: frame.length,
+				bytes: frameBytes,
 				mode: writeMode === "sync" ? "sync" : writeMode === "chunked" ? "chunked" : "stream"
 			});
 			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutWrite({
 				durationMs: writeMs,
-				bytes: frame.length,
+				bytes: frameBytes,
 				mode: writeMode === "sync" ? "sync" : writeMode === "chunked" ? "chunked" : "stream"
 			});
 		}
@@ -9644,6 +10273,7 @@ function createStdoutRenderer(terminal, options) {
 	}
 	function markScrollOperationDirty(op, rowCount) {
 		markAccumulatedDirtyRange(op.startY, op.endY, rowCount);
+		accumulatedDirtyRowsRequireRepaint = true;
 	}
 	function mergeScrollOperations(next) {
 		if (!(next === null || next === void 0 ? void 0 : next.length) || accumulatedAllRows) return;
@@ -9686,20 +10316,27 @@ function createStdoutRenderer(terminal, options) {
 	function render(dirtyRows, sync, scrollOperations) {
 		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`);
-		if (!dirtyRows || dirtyRows.length === 0) {
+		if (dirtyRows == null) {
 			accumulatedAllRows = true;
 			accumulatedDirtyBits = null;
 			accumulatedDirtyCount = 0;
 			accumulatedDirtyMin = Number.POSITIVE_INFINITY;
 			accumulatedDirtyMax = -1;
+			accumulatedDirtyRowsRequireRepaint = false;
 			accumulatedScrollOperations = null;
+		} else if (dirtyRows.length === 0) {
+			if (scrollOperations === null || scrollOperations === void 0 ? void 0 : scrollOperations.length) mergeScrollOperations(scrollOperations);
+			else if (!accumulatedAllRows && accumulatedDirtyCount === 0 && !getImeAnchor) {
+				cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutQueued(0);
+				return;
+			}
 		} else if (!accumulatedAllRows) {
 			const rowCount = terminal.size().rows;
 			mergeScrollOperations(scrollOperations);
 			const bits = ensureAccumulatedDirtyBits(rowCount);
 			for (let i = 0; i < dirtyRows.length; i++) {
 				const y = Math.floor(dirtyRows[i] ?? -1);
-				if (y < 0 || y >= rowCount) continue;
+				if (!Number.isFinite(y) || y < 0 || y >= rowCount) continue;
 				if (!bits[y]) {
 					bits[y] = 1;
 					accumulatedDirtyCount++;
@@ -9725,15 +10362,17 @@ function createStdoutRenderer(terminal, options) {
 			}
 			const rows = buildAccumulatedRows(dirtyRows);
 			const pendingScrolls = buildAccumulatedScrollOperations();
+			const forceDirtyRowsRepaint = accumulatedDirtyRowsRequireRepaint;
 			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutQueued(0);
-			doRender(rows, pendingScrolls);
+			doRender(rows, pendingScrolls, forceDirtyRowsRepaint);
 			return;
 		}
 		if (elapsed >= MIN_FRAME_MS) {
 			const rows = buildAccumulatedRows(dirtyRows);
 			const pendingScrolls = buildAccumulatedScrollOperations();
+			const forceDirtyRowsRepaint = accumulatedDirtyRowsRequireRepaint;
 			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutQueued(0);
-			doRender(rows, pendingScrolls);
+			doRender(rows, pendingScrolls, forceDirtyRowsRepaint);
 		} else {
 			pendingRender = true;
 			if (renderTimer) clearTimeout(renderTimer);
@@ -9742,19 +10381,62 @@ function createStdoutRenderer(terminal, options) {
 				if (!disposed) {
 					const rows = buildAccumulatedRows(dirtyRows);
 					const pendingScrolls = buildAccumulatedScrollOperations();
-					doRender(rows, pendingScrolls);
+					const forceDirtyRowsRepaint = accumulatedDirtyRowsRequireRepaint;
+					doRender(rows, pendingScrolls, forceDirtyRowsRepaint);
 				}
 			}, queuedDelayMs);
 			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutQueued(queuedDelayMs);
 		}
 	}
-	function installFingerprintFn() {
-		terminal.setFingerprintFn((ch, style) => {
+	function installFingerprintFn(force = false) {
+		if (!canInstallTerminalFingerprintFn()) {
+			if (ownsFingerprintFn && stdoutFingerprintOwners.get(terminal) === fingerprintOwner) {
+				stdoutFingerprintOwners.delete(terminal);
+				invalidateFingerprintBaseline();
+			}
+			ownsFingerprintFn = false;
+			terminalFingerprintFnDirty = true;
+			fingerprintInstallBlockedByExternalProvider = false;
+			return;
+		}
+		const currentOwner = stdoutFingerprintOwners.get(terminal);
+		if (!currentOwner && !ownsFingerprintFn && hasActiveExternalFingerprintProvider()) {
+			fingerprintInstallBlockedByExternalProvider = true;
+			ownsFingerprintFn = false;
+			terminalFingerprintFnDirty = false;
+			invalidateFingerprintBaseline();
+			return;
+		}
+		fingerprintInstallBlockedByExternalProvider = false;
+		if (currentOwner && currentOwner !== fingerprintOwner) {
+			if (ownsFingerprintFn) invalidateFingerprintBaseline();
+			ownsFingerprintFn = false;
+			return;
+		}
+		if (ownsFingerprintFn && currentOwner === fingerprintOwner && !force && !terminalFingerprintFnDirty) return;
+		stdoutFingerprintOwners.set(terminal, fingerprintOwner);
+		ownsFingerprintFn = true;
+		fingerprintTerminal.setFingerprintFn((ch, style) => {
 			return cellFingerprint(ch, style);
 		});
+		terminalFingerprintFnDirty = false;
+		invalidateFingerprintBaseline();
+	}
+	function releaseFingerprintFn() {
+		if (!ownsFingerprintFn) return;
+		if (stdoutFingerprintOwners.get(terminal) !== fingerprintOwner) {
+			ownsFingerprintFn = false;
+			return;
+		}
+		stdoutFingerprintOwners.delete(terminal);
+		ownsFingerprintFn = false;
+		try {
+			var _fingerprintTerminal$2;
+			(_fingerprintTerminal$2 = fingerprintTerminal.setFingerprintFn) === null || _fingerprintTerminal$2 === void 0 || _fingerprintTerminal$2.call(fingerprintTerminal, null);
+		} catch {}
 	}
 	installFingerprintFn();
-	if (altScreen && out.isTTY) out.write("\x1B[?1049h");
+	if (altScreen && outputIsTTY) 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, scrollOperations, sync }) => {
@@ -9762,7 +10444,7 @@ function createStdoutRenderer(terminal, options) {
 		render(dirtyRows, sync, scrollOperations);
 	});
 	const resizeSource = (options === null || options === void 0 ? void 0 : options.output) ?? process.stdout;
-	const canTrackResize = Boolean(trackResize && out.isTTY && typeof (resizeSource === null || resizeSource === void 0 ? void 0 : resizeSource.on) === "function");
+	const canTrackResize = Boolean(trackResize && outputIsTTY && 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);
 		const rows = Number(resizeSource === null || resizeSource === void 0 ? void 0 : resizeSource.rows);
@@ -9809,7 +10491,9 @@ function createStdoutRenderer(terminal, options) {
 		accumulatedDirtyCount = 0;
 		accumulatedDirtyMin = Number.POSITIVE_INFINITY;
 		accumulatedDirtyMax = -1;
+		accumulatedDirtyRowsRequireRepaint = false;
 		off();
+		releaseFingerprintFn();
 		if (canTrackResize && typeof (resizeSource === null || resizeSource === void 0 ? void 0 : resizeSource.off) === "function") try {
 			resizeSource.off("resize", onResize);
 		} catch {}
@@ -9817,7 +10501,7 @@ function createStdoutRenderer(terminal, options) {
 			resizeSource.removeListener("resize", onResize);
 		} catch {}
 		if (hideCursor) out.write("\x1B[?25h");
-		if (altScreen && out.isTTY) out.write("\x1B[?1049l");
+		if (altScreen && outputIsTTY) out.write("\x1B[?1049l");
 		profiler === null || profiler === void 0 || profiler.dispose();
 	}
 	const updateTheme = (next) => {
@@ -9827,10 +10511,8 @@ function createStdoutRenderer(terminal, options) {
 			if (nextBg !== defaultBg) defaultBg = nextBg;
 		}
 		if ("palette" in next) palette = next.palette ?? null;
-		styleKeyCache = new WeakMap();
-		for (const key of Object.keys(COLOR_INDEX)) if (!(key in BUILTIN_COLOR_INDEX)) delete COLOR_INDEX[key];
-		nextColorIdx = 17;
-		installFingerprintFn();
+		resetStyleKeyIndex();
+		installFingerprintFn(true);
 		fpRows = 0;
 		fpPrevValid = false;
 		prevOverlayBlockedRows = [];