@simon_he/vue-tui 1.0.2 → 1.1.1

package/dist/cli.js

@@ -20,7 +20,7 @@ function envFlag(env, primary, legacy) {
 	const raw = String(firstNonEmptyEnv(env, primary, legacy) ?? "").trim().toLowerCase();
 	return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
 }
-function envString(env, primary, legacy, fallback = "") {
+function envString$1(env, primary, legacy, fallback = "") {
 	return String(firstNonEmptyEnv(env, primary, legacy) ?? fallback).trim() || fallback;
 }
 
@@ -33,7 +33,7 @@ const MAX_OP_AGE_MS = 5e3;
 const GLOBAL_PROFILER_KEY = "__vueTuiCliLatencyProfiler";
 let nextOpId = 1;
 let singleton;
-function now$1() {
+function now$2() {
 	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
 }
 function diffMs(end, start) {
@@ -68,7 +68,7 @@ function createProfiler() {
 	const processLike = process;
 	const env = (processLike === null || processLike === void 0 ? void 0 : processLike.env) ?? {};
 	if (!envFlag(env, "VUE_TUI_PROFILE_INPUT_LATENCY", "DIMCODE_PROFILE_INPUT_LATENCY")) return createDisabledProfiler();
-	const logPath = envString(env, "VUE_TUI_PROFILE_INPUT_LATENCY_LOG_PATH", "DIMCODE_PROFILE_INPUT_LATENCY_LOG_PATH", defaultCliLatencyLogPath());
+	const logPath = envString$1(env, "VUE_TUI_PROFILE_INPUT_LATENCY_LOG_PATH", "DIMCODE_PROFILE_INPUT_LATENCY_LOG_PATH", defaultCliLatencyLogPath());
 	const ops = new Map();
 	const pendingCommitIds = new Set();
 	const pendingWriteIds = new Set();
@@ -146,7 +146,7 @@ function createProfiler() {
 		cleanupOp(op.id);
 	};
 	const expireOldOps = () => {
-		const currentTime = now$1();
+		const currentTime = now$2();
 		for (const op of ops.values()) {
 			if (currentTime - op.createdAt < MAX_OP_AGE_MS) continue;
 			flushOp(op, op.writeEndAt != null ? "completed" : "timeout");
@@ -163,7 +163,7 @@ function createProfiler() {
 		const id = nextOpId++;
 		const op = {
 			id,
-			createdAt: now$1(),
+			createdAt: now$2(),
 			createdAtIso: new Date().toISOString(),
 			eventType: type,
 			key: String((event === null || event === void 0 ? void 0 : event.key) ?? ""),
@@ -206,7 +206,7 @@ function createProfiler() {
 	};
 	const resolveActiveOp = () => {
 		if (currentDispatchOpId != null) return ops.get(currentDispatchOpId) ?? null;
-		if (lastDispatchOpId != null && lastDispatchEndedAt != null && now$1() - lastDispatchEndedAt <= INVALIDATE_ASSOCIATION_WINDOW_MS) return ops.get(lastDispatchOpId) ?? null;
+		if (lastDispatchOpId != null && lastDispatchEndedAt != null && now$2() - lastDispatchEndedAt <= INVALIDATE_ASSOCIATION_WINDOW_MS) return ops.get(lastDispatchOpId) ?? null;
 		return null;
 	};
 	processLike === null || processLike === void 0 || (_processLike$once = processLike.once) === null || _processLike$once === void 0 || _processLike$once.call(processLike, "exit", () => {
@@ -215,27 +215,27 @@ function createProfiler() {
 	return {
 		enabled: true,
 		recordRawInput(_info) {
-			lastRawInputAt = now$1();
+			lastRawInputAt = now$2();
 			expireOldOps();
 		},
 		recordStdinDispatch(event, info) {
 			const op = ensureOp(event);
 			if (!op) return;
 			if (op.rawInputAt == null && lastRawInputAt != null) op.rawInputAt = lastRawInputAt;
-			if (op.stdinDispatchAt == null) op.stdinDispatchAt = now$1();
+			if (op.stdinDispatchAt == null) op.stdinDispatchAt = now$2();
 			if (!op.parser && (info === null || info === void 0 ? void 0 : info.parser)) op.parser = String(info.parser);
 		},
 		recordEventDispatchStart(event) {
 			const op = ensureOp(event);
 			if (!op) return;
 			currentDispatchOpId = op.id;
-			if (op.dispatchStartAt == null) op.dispatchStartAt = now$1();
+			if (op.dispatchStartAt == null) op.dispatchStartAt = now$2();
 		},
 		recordEventDispatchEnd(event, info) {
 			const op = ensureOp(event);
 			if (!op) return;
 			op.defaultPrevented = Boolean(info.defaultPrevented);
-			if (op.dispatchEndAt == null) op.dispatchEndAt = now$1();
+			if (op.dispatchEndAt == null) op.dispatchEndAt = now$2();
 			currentDispatchOpId = currentDispatchOpId === op.id ? null : currentDispatchOpId;
 			lastDispatchOpId = op.id;
 			lastDispatchEndedAt = op.dispatchEndAt;
@@ -243,7 +243,7 @@ function createProfiler() {
 		recordSchedulerInvalidate(info) {
 			const op = resolveActiveOp();
 			if (!op) return;
-			if (op.invalidateAt == null) op.invalidateAt = now$1();
+			if (op.invalidateAt == null) op.invalidateAt = now$2();
 			if (!op.invalidatePriority && (info === null || info === void 0 ? void 0 : info.priority)) op.invalidatePriority = String(info.priority);
 			if (!op.invalidatePlane && (info === null || info === void 0 ? void 0 : info.plane)) op.invalidatePlane = String(info.plane);
 			pendingCommitIds.add(op.id);
@@ -251,7 +251,7 @@ function createProfiler() {
 		recordFlushStart(info) {
 			currentFlushIds = Array.from(pendingCommitIds);
 			if (!currentFlushIds.length) return;
-			const flushTime = now$1();
+			const flushTime = now$2();
 			forIds(currentFlushIds, (op) => {
 				if (op.flushStartAt == null) op.flushStartAt = flushTime;
 				if (op.commitSync == null && (info === null || info === void 0 ? void 0 : info.sync) != null) op.commitSync = Boolean(info.sync);
@@ -260,7 +260,7 @@ function createProfiler() {
 		},
 		recordFlushEnd() {
 			if (!currentFlushIds.length) return;
-			const flushTime = now$1();
+			const flushTime = now$2();
 			forIds(currentFlushIds, (op) => {
 				if (op.flushEndAt == null) op.flushEndAt = flushTime;
 			});
@@ -268,7 +268,7 @@ function createProfiler() {
 		},
 		recordCommit(info) {
 			if (!pendingCommitIds.size) return;
-			const commitTime = now$1();
+			const commitTime = now$2();
 			const ids = Array.from(pendingCommitIds);
 			pendingCommitIds.clear();
 			forIds(ids, (op) => {
@@ -288,7 +288,7 @@ function createProfiler() {
 		},
 		recordStdoutRenderStart() {
 			if (!pendingWriteIds.size) return;
-			const renderTime = now$1();
+			const renderTime = now$2();
 			forIds(pendingWriteIds, (op) => {
 				if (op.stdoutRenderStartAt == null) op.stdoutRenderStartAt = renderTime;
 			});
@@ -301,7 +301,7 @@ function createProfiler() {
 		},
 		recordStdoutWrite(info) {
 			if (!pendingWriteIds.size) return;
-			const writeEndTime = now$1();
+			const writeEndTime = now$2();
 			const ids = Array.from(pendingWriteIds);
 			pendingWriteIds.clear();
 			forIds(ids, (op) => {
@@ -966,7 +966,7 @@ function setDebugFileWriter(writer) {
 	if (!writer) initializedDebugLogPaths.clear();
 }
 function resolveDebugLogPath(env, fallback = DEFAULT_LOG_FILE) {
-	return envString(env, "VUE_TUI_DEBUG_LOG_PATH", "DIMCODE_DEBUG_LOG_PATH", fallback);
+	return envString$1(env, "VUE_TUI_DEBUG_LOG_PATH", "DIMCODE_DEBUG_LOG_PATH", fallback);
 }
 function setDebugLogDefaultPath(path) {
 	debugLogDefaultPath = path || DEFAULT_LOG_FILE;
@@ -1076,7 +1076,7 @@ function createTuiProfiler(name, options = {}) {
 	if (!envFlag(env, "VUE_TUI_PROFILE", "DIMCODE_PROFILE_TUI")) return null;
 	const format = parseLogFormat(firstNonEmptyEnv(env, "VUE_TUI_PROFILE_FORMAT", "DIMCODE_PROFILE_TUI_FORMAT")) ?? (String(firstNonEmptyEnv(env, "VUE_TUI_PROFILE_LOG_PATH", "DIMCODE_PROFILE_TUI_LOG_PATH") ?? "").trim().endsWith(".jsonl") ? "json" : "text");
 	const logDest = parseLogDest(firstNonEmptyEnv(env, "VUE_TUI_PROFILE_LOG_DEST", "DIMCODE_PROFILE_TUI_LOG_DEST")) ?? options.defaultLogDest ?? "stdout";
-	const logPath = envString(env, "VUE_TUI_PROFILE_LOG_PATH", "DIMCODE_PROFILE_TUI_LOG_PATH") || options.defaultLogPath || "";
+	const logPath = envString$1(env, "VUE_TUI_PROFILE_LOG_PATH", "DIMCODE_PROFILE_TUI_LOG_PATH") || options.defaultLogPath || "";
 	let invalidates = 0;
 	let renders = 0;
 	let fullRenders = 0;
@@ -1095,8 +1095,8 @@ function createTuiProfiler(name, options = {}) {
 	const invalidatePlaneCounts = new Map();
 	const renderPlaneCounts = new Map();
 	const logEveryMs = parseLogEveryMs(firstNonEmptyEnv(env, "VUE_TUI_PROFILE_LOG_EVERY_MS", "DIMCODE_PROFILE_TUI_LOG_EVERY_MS")) ?? 1e3;
-	const now$2 = defaultNow;
-	let lastLogAt = now$2();
+	const now$3 = defaultNow;
+	let lastLogAt = now$3();
 	let disposed = false;
 	function incrementPlaneCount(target, key) {
 		const normalized = String(key ?? "all").trim() || "all";
@@ -1117,7 +1117,7 @@ function createTuiProfiler(name, options = {}) {
 	function flushLog(force = false) {
 		if (disposed) return;
 		if (!hasPendingSamples()) return;
-		const at = now$2();
+		const at = now$3();
 		const elapsedRaw = at - lastLogAt;
 		if (!force && elapsedRaw <= 0) return;
 		const elapsed = Math.max(1, elapsedRaw);
@@ -1189,7 +1189,7 @@ function createTuiProfiler(name, options = {}) {
 	const timer = setInterval(flushLog, Number.isFinite(logEveryMs) ? Math.max(100, logEveryMs) : 1e3);
 	(_unref = timer.unref) === null || _unref === void 0 || _unref.call(timer);
 	return {
-		now: now$2,
+		now: now$3,
 		recordInvalidate(info) {
 			if (disposed) return;
 			invalidates++;
@@ -1247,7 +1247,7 @@ function legacyDebugFlag(env) {
 	return String((env === null || env === void 0 ? void 0 : env.DEBUG) ?? "").trim() === "1";
 }
 function shouldInstallFileWriters(env) {
-	const profileLogDest = envString(env, "VUE_TUI_PROFILE_LOG_DEST", "DIMCODE_PROFILE_TUI_LOG_DEST").toLowerCase();
+	const profileLogDest = envString$1(env, "VUE_TUI_PROFILE_LOG_DEST", "DIMCODE_PROFILE_TUI_LOG_DEST").toLowerCase();
 	return envFlag(env, "VUE_TUI_DEBUG", "DIMCODE_DEBUG") || legacyDebugFlag(env) || profileLogDest === "file" || profileLogDest === "both";
 }
 function installNodeFileWriters(options = {}) {
@@ -1277,7 +1277,7 @@ function parseMouseSgr(sequence) {
 	const env = (process === null || process === void 0 ? void 0 : process.env) ?? {};
 	const invertWheel = envFlag(env, "VUE_TUI_WHEEL_INVERT", "DIMCODE_WHEEL_INVERT");
 	const mouseDebugEnabled = envFlag(env, "VUE_TUI_MOUSE_DEBUG", "DIMCODE_MOUSE_DEBUG");
-	const mouseDebugPath = envString(env, "VUE_TUI_MOUSE_DEBUG_PATH", "DIMCODE_MOUSE_DEBUG_PATH", defaultVueTuiMouseDebugLogPath());
+	const mouseDebugPath = envString$1(env, "VUE_TUI_MOUSE_DEBUG_PATH", "DIMCODE_MOUSE_DEBUG_PATH", defaultVueTuiMouseDebugLogPath());
 	const debug = (msg) => {
 		if (!mouseDebugEnabled) return;
 		try {
@@ -1696,13 +1696,13 @@ function parseXtermSequence(sequence) {
 
 //#endregion
 //#region src/cli/stdin-buffer.ts
-const ESC$2 = "\x1B";
+const ESC$3 = "\x1B";
 const BRACKETED_PASTE_START = "\x1B[200~";
 const BRACKETED_PASTE_END = "\x1B[201~";
 const ESC_CONTINUATION_RESCUE_WINDOW_MS = 64;
 function looksLikeQuotedPathPaste(value) {
 	if (!value) return false;
-	if (value.includes(ESC$2)) return false;
+	if (value.includes(ESC$3)) return false;
 	if (value.length < 12) return false;
 	if (!/['"]/.test(value)) return false;
 	if (!/[\\/]/.test(value)) return false;
@@ -1712,7 +1712,7 @@ function looksLikeQuotedPathPaste(value) {
 	return false;
 }
 function isCompleteSequence(data) {
-	if (!data.startsWith(ESC$2)) return "not-escape";
+	if (!data.startsWith(ESC$3)) return "not-escape";
 	if (data.length === 1) return "incomplete";
 	const afterEsc = data.slice(1);
 	if (afterEsc.startsWith("[")) {
@@ -1727,7 +1727,7 @@ function isCompleteSequence(data) {
 	return "complete";
 }
 function isCompleteCsiSequence(data) {
-	if (!data.startsWith(`${ESC$2}[`)) return "complete";
+	if (!data.startsWith(`${ESC$3}[`)) return "complete";
 	if (data.length < 3) return "incomplete";
 	const payload = data.slice(2);
 	const lastChar = payload[payload.length - 1];
@@ -1745,19 +1745,35 @@ function isCompleteCsiSequence(data) {
 	}
 	return "incomplete";
 }
+function isPotentialSgrMousePayloadPrefix(payload) {
+	if (!payload.startsWith("<")) return false;
+	let semicolons = 0;
+	for (let i = 1; i < payload.length; i++) {
+		const c = payload.charCodeAt(i);
+		if (c >= 48 && c <= 57) continue;
+		if (payload[i] === ";") {
+			semicolons++;
+			if (semicolons > 2) return false;
+			continue;
+		}
+		if (payload[i] === "M" || payload[i] === "m") return semicolons === 2;
+		return false;
+	}
+	return true;
+}
 function isCompleteOscSequence(data) {
-	if (!data.startsWith(`${ESC$2}]`)) return "complete";
-	if (data.endsWith(`${ESC$2}\\`) || data.endsWith("\x07")) return "complete";
+	if (!data.startsWith(`${ESC$3}]`)) return "complete";
+	if (data.endsWith(`${ESC$3}\\`) || data.endsWith("\x07")) return "complete";
 	return "incomplete";
 }
 function isCompleteDcsSequence(data) {
-	if (!data.startsWith(`${ESC$2}P`)) return "complete";
-	if (data.endsWith(`${ESC$2}\\`)) return "complete";
+	if (!data.startsWith(`${ESC$3}P`)) return "complete";
+	if (data.endsWith(`${ESC$3}\\`)) return "complete";
 	return "incomplete";
 }
 function isCompleteApcSequence(data) {
-	if (!data.startsWith(`${ESC$2}_`)) return "complete";
-	if (data.endsWith(`${ESC$2}\\`)) return "complete";
+	if (!data.startsWith(`${ESC$3}_`)) return "complete";
+	if (data.endsWith(`${ESC$3}\\`)) return "complete";
 	return "incomplete";
 }
 function extractCompleteSequences(buffer) {
@@ -1765,9 +1781,9 @@ function extractCompleteSequences(buffer) {
 	let pos = 0;
 	while (pos < buffer.length) {
 		const remaining = buffer.slice(pos);
-		if (remaining.startsWith(ESC$2)) {
-			if (remaining.length >= 2 && remaining[1] === ESC$2) {
-				sequences.push(ESC$2);
+		if (remaining.startsWith(ESC$3)) {
+			if (remaining.length >= 2 && remaining[1] === ESC$3) {
+				sequences.push(ESC$3);
 				pos += 1;
 				continue;
 			}
@@ -1802,17 +1818,24 @@ function extractCompleteSequences(buffer) {
 		remainder: ""
 	};
 }
-function looksLikeSplitEscapeContinuation(value) {
+function looksLikeSplitEscapeContinuation(value, prefix = ESC$3) {
+	if (prefix.startsWith(`${ESC$3}[`) && isPotentialSgrMousePayloadPrefix(`${prefix.slice(2)}${value}`)) return true;
 	const first = value[0];
 	if (first !== "[" && first !== "]" && first !== "P" && first !== "_" && first !== "O") return false;
-	return isCompleteSequence(`${ESC$2}${value}`) !== "not-escape";
+	return prefix === ESC$3 && isCompleteSequence(`${ESC$3}${value}`) !== "not-escape";
+}
+function rescuableEscapePrefix(value) {
+	if (value === ESC$3) return ESC$3;
+	if (value === `${ESC$3}[`) return value;
+	if (value.startsWith(`${ESC$3}[`) && isPotentialSgrMousePayloadPrefix(value.slice(2))) return value;
+	return null;
 }
 var StdinBuffer = class extends EventEmitter {
 	buffer = "";
 	timeout = null;
 	timeoutMs;
 	escTimeoutMs;
-	pendingEscContinuationAt = null;
+	pendingEscContinuation = null;
 	pasteMode = false;
 	pasteBuffer = "";
 	constructor(options = {}) {
@@ -1831,10 +1854,11 @@ var StdinBuffer = class extends EventEmitter {
 			str = `\x1B${String.fromCharCode(byte)}`;
 		} else str = data.toString();
 		else str = data;
-		if (this.pendingEscContinuationAt != null) {
-			const canRescue = Date.now() - this.pendingEscContinuationAt <= ESC_CONTINUATION_RESCUE_WINDOW_MS;
-			this.pendingEscContinuationAt = null;
-			if (canRescue && looksLikeSplitEscapeContinuation(str)) str = `${ESC$2}${str}`;
+		if (this.pendingEscContinuation != null) {
+			const pending = this.pendingEscContinuation;
+			const canRescue = Date.now() - pending.at <= ESC_CONTINUATION_RESCUE_WINDOW_MS;
+			this.pendingEscContinuation = null;
+			if (canRescue && looksLikeSplitEscapeContinuation(str, pending.prefix)) str = `${pending.prefix}${str}`;
 		}
 		if (str.length === 0 && this.buffer.length === 0) {
 			this.emit("data", "");
@@ -1887,11 +1911,14 @@ var StdinBuffer = class extends EventEmitter {
 		this.buffer = result.remainder;
 		for (const sequence of result.sequences) this.emit("data", sequence);
 		if (this.buffer.length > 0) {
-			const timeoutMs = this.buffer === ESC$2 ? this.escTimeoutMs : this.timeoutMs;
+			const timeoutMs = this.buffer === ESC$3 ? this.escTimeoutMs : this.timeoutMs;
 			this.timeout = setTimeout(() => {
-				const rescuableLoneEsc = this.buffer === ESC$2;
+				const prefix = rescuableEscapePrefix(this.buffer);
 				const flushed = this.flush();
-				if (rescuableLoneEsc && flushed.length === 1 && flushed[0] === ESC$2) this.pendingEscContinuationAt = Date.now();
+				if (prefix && flushed.length === 1 && flushed[0] === prefix) this.pendingEscContinuation = {
+					prefix,
+					at: Date.now()
+				};
 				for (const sequence of flushed) this.emit("data", sequence);
 			}, timeoutMs);
 		}
@@ -1912,7 +1939,7 @@ var StdinBuffer = class extends EventEmitter {
 			this.timeout = null;
 		}
 		this.buffer = "";
-		this.pendingEscContinuationAt = null;
+		this.pendingEscContinuation = null;
 		this.pasteMode = false;
 		this.pasteBuffer = "";
 	}
@@ -2649,7 +2676,7 @@ function segmentedGraphemes(text) {
 
 //#endregion
 //#region src/core/ansi/sgr.ts
-const ESC$1 = "\x1B";
+const ESC$2 = "\x1B";
 function ansi16ToColorName(code) {
 	switch (code) {
 		case 30: return "black";
@@ -2922,7 +2949,7 @@ function parseAnsiSgr(input, baseStyle = {}) {
 	let style = { ...baseStyle };
 	let lastIndex = 0;
 	for (let i = 0; i < input.length; i++) {
-		if (input[i] !== ESC$1 || input[i + 1] !== "[") continue;
+		if (input[i] !== ESC$2 || input[i + 1] !== "[") continue;
 		let j = i + 2;
 		while (j < input.length) {
 			const c = input.charCodeAt(j);
@@ -2951,17 +2978,131 @@ function parseAnsiSgr(input, baseStyle = {}) {
 }
 
 //#endregion
-//#region src/core/buffer/width.ts
+//#region src/core/buffer/eaw-ranges-unicode-17.ts
 const fullWidthRanges = [
 	[4352, 4447],
+	[8986, 8987],
 	[9001, 9002],
-	[11904, 42191],
+	[9193, 9196],
+	[9200, 9200],
+	[9203, 9203],
+	[9725, 9726],
+	[9748, 9749],
+	[9776, 9783],
+	[9800, 9811],
+	[9855, 9855],
+	[9866, 9871],
+	[9875, 9875],
+	[9889, 9889],
+	[9898, 9899],
+	[9917, 9918],
+	[9924, 9925],
+	[9934, 9934],
+	[9940, 9940],
+	[9962, 9962],
+	[9970, 9971],
+	[9973, 9973],
+	[9978, 9978],
+	[9981, 9981],
+	[9989, 9989],
+	[9994, 9995],
+	[10024, 10024],
+	[10060, 10060],
+	[10062, 10062],
+	[10067, 10069],
+	[10071, 10071],
+	[10133, 10135],
+	[10160, 10160],
+	[10175, 10175],
+	[11035, 11036],
+	[11088, 11088],
+	[11093, 11093],
+	[11904, 11929],
+	[11931, 12019],
+	[12032, 12245],
+	[12272, 12350],
+	[12353, 12438],
+	[12441, 12543],
+	[12549, 12591],
+	[12593, 12686],
+	[12688, 12773],
+	[12783, 12830],
+	[12832, 12871],
+	[12880, 42124],
+	[42128, 42182],
+	[43360, 43388],
 	[44032, 55203],
 	[63744, 64255],
 	[65040, 65049],
-	[65072, 65135],
-	[65280, 65376],
-	[65504, 65510]
+	[65072, 65106],
+	[65108, 65126],
+	[65128, 65131],
+	[65281, 65376],
+	[65504, 65510],
+	[94176, 94180],
+	[94192, 94198],
+	[94208, 101589],
+	[101631, 101662],
+	[101760, 101874],
+	[110576, 110579],
+	[110581, 110587],
+	[110589, 110590],
+	[110592, 110882],
+	[110898, 110898],
+	[110928, 110930],
+	[110933, 110933],
+	[110948, 110951],
+	[110960, 111355],
+	[119552, 119638],
+	[119648, 119670],
+	[126980, 126980],
+	[127183, 127183],
+	[127374, 127374],
+	[127377, 127386],
+	[127488, 127490],
+	[127504, 127547],
+	[127552, 127560],
+	[127568, 127569],
+	[127584, 127589],
+	[127744, 127776],
+	[127789, 127797],
+	[127799, 127868],
+	[127870, 127891],
+	[127904, 127946],
+	[127951, 127955],
+	[127968, 127984],
+	[127988, 127988],
+	[127992, 128062],
+	[128064, 128064],
+	[128066, 128252],
+	[128255, 128317],
+	[128331, 128334],
+	[128336, 128359],
+	[128378, 128378],
+	[128405, 128406],
+	[128420, 128420],
+	[128507, 128591],
+	[128640, 128709],
+	[128716, 128716],
+	[128720, 128722],
+	[128725, 128728],
+	[128732, 128735],
+	[128747, 128748],
+	[128756, 128764],
+	[128992, 129003],
+	[129008, 129008],
+	[129292, 129338],
+	[129340, 129349],
+	[129351, 129535],
+	[129648, 129660],
+	[129664, 129674],
+	[129678, 129734],
+	[129736, 129736],
+	[129741, 129756],
+	[129759, 129770],
+	[129775, 129784],
+	[131072, 196605],
+	[196608, 262141]
 ];
 const ambiguousWidthRanges = [
 	[161, 161],
@@ -3017,6 +3158,7 @@ const ambiguousWidthRanges = [
 	[728, 731],
 	[733, 733],
 	[735, 735],
+	[768, 879],
 	[913, 929],
 	[931, 937],
 	[945, 961],
@@ -3024,7 +3166,8 @@ const ambiguousWidthRanges = [
 	[1025, 1025],
 	[1040, 1103],
 	[1105, 1105],
-	[8208, 8213],
+	[8208, 8208],
+	[8211, 8214],
 	[8216, 8217],
 	[8220, 8221],
 	[8224, 8226],
@@ -3086,7 +3229,8 @@ const ambiguousWidthRanges = [
 	[8895, 8895],
 	[8978, 8978],
 	[9312, 9449],
-	[9451, 9471],
+	[9451, 9547],
+	[9552, 9587],
 	[9600, 9615],
 	[9618, 9621],
 	[9632, 9633],
@@ -3112,14 +3256,40 @@ const ambiguousWidthRanges = [
 	[9831, 9834],
 	[9836, 9837],
 	[9839, 9839],
+	[9886, 9887],
+	[9919, 9919],
+	[9926, 9933],
+	[9935, 9939],
+	[9941, 9953],
+	[9955, 9955],
+	[9960, 9961],
+	[9963, 9969],
+	[9972, 9972],
+	[9974, 9977],
+	[9979, 9980],
+	[9982, 9983],
 	[10045, 10045],
 	[10102, 10111],
-	[11094, 11094],
+	[11094, 11097],
+	[12872, 12879],
 	[57344, 63743],
-	[65533, 65533]
+	[65024, 65039],
+	[65533, 65533],
+	[127232, 127242],
+	[127248, 127277],
+	[127280, 127337],
+	[127344, 127373],
+	[127375, 127376],
+	[127387, 127404],
+	[917760, 917999],
+	[983040, 1048573],
+	[1048576, 1114109]
 ];
+
+//#endregion
+//#region src/core/buffer/width.ts
 function isFullWidthCodePoint(codePoint) {
-	if (codePoint < 4352 || codePoint > 65510) return false;
+	if (codePoint < 4352) return false;
 	for (const [start, end] of fullWidthRanges) {
 		if (codePoint < start) return false;
 		if (codePoint <= end) return true;
@@ -3127,13 +3297,22 @@ function isFullWidthCodePoint(codePoint) {
 	return false;
 }
 function isAmbiguousWidthCodePoint(codePoint) {
-	if (codePoint < 161 || codePoint > 65533) return false;
+	const first = ambiguousWidthRanges[0];
+	const last = ambiguousWidthRanges[ambiguousWidthRanges.length - 1];
+	if (!first || !last) return false;
+	if (codePoint < first[0] || codePoint > last[1]) return false;
 	for (const [start, end] of ambiguousWidthRanges) {
 		if (codePoint < start) return false;
 		if (codePoint <= end) return true;
 	}
 	return false;
 }
+function isVariationSelectorCodePoint(codePoint) {
+	return codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999;
+}
+function isCombiningMarkCodePoint(codePoint) {
+	return codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071 || codePoint >= 12330 && codePoint <= 12335 || codePoint >= 12441 && codePoint <= 12442 || codePoint === 94180;
+}
 function isEmojiLike(codePoint) {
 	return codePoint >= 127744 && codePoint <= 129791 || codePoint >= 127462 && codePoint <= 127487;
 }
@@ -3168,6 +3347,8 @@ function charCellWidth(text, provider = "default") {
 	const codePoint = text.codePointAt(0);
 	if (codePoint == null) return 1;
 	const hasVs16 = text.includes("️");
+	if (isVariationSelectorCodePoint(codePoint) || isCombiningMarkCodePoint(codePoint)) return 1;
+	if (codePoint >= 9472 && codePoint <= 9599) return 1;
 	if (isFullWidthCodePoint(codePoint)) return 2;
 	if (provider === "cjk" && isAmbiguousWidthCodePoint(codePoint)) return 2;
 	if (isEmojiLike(codePoint)) return 2;
@@ -3601,9 +3782,12 @@ function resizeBuffer(buffer, cols, rows) {
 	const nextCols = Math.max(0, Math.floor(cols));
 	const nextRows = Math.max(0, Math.floor(rows));
 	if (nextCols === buffer.cols && nextRows === buffer.rows) return;
+	const prevRows = buffer.rows;
+	const prevDirtyAll = buffer.dirtyAll;
+	const prevDirtyBits = buffer.dirtyBits;
 	const blank = createBlankCell();
 	const nextGrid = Array.from({ length: nextRows }, () => Array.from({ length: nextCols }, () => blank));
-	const copyRows = Math.min(buffer.rows, nextRows);
+	const copyRows = Math.min(prevRows, nextRows);
 	const copyCols = Math.min(buffer.cols, nextCols);
 	for (let y = 0; y < copyRows; y++) {
 		const src = getBufferRow(buffer, y);
@@ -3629,10 +3813,21 @@ function resizeBuffer(buffer, cols, rows) {
 	buffer.cols = nextCols;
 	buffer.rows = nextRows;
 	buffer.dirtyBits = new Uint8Array(nextRows);
-	buffer.dirtyCount = nextRows || 0;
-	buffer.dirtyMin = nextRows ? 0 : Number.POSITIVE_INFINITY;
-	buffer.dirtyMax = nextRows ? nextRows - 1 : -1;
-	buffer.dirtyAll = nextRows > 0;
+	buffer.dirtyCount = 0;
+	buffer.dirtyMin = Number.POSITIVE_INFINITY;
+	buffer.dirtyMax = -1;
+	buffer.dirtyAll = prevDirtyAll && nextRows > 0;
+	if (buffer.dirtyAll) {
+		buffer.dirtyCount = nextRows;
+		buffer.dirtyMin = 0;
+		buffer.dirtyMax = nextRows - 1;
+	} else for (let y = 0; y < copyRows; y++) {
+		if (prevDirtyBits[y] !== 1) continue;
+		buffer.dirtyBits[y] = 1;
+		buffer.dirtyCount++;
+		if (y < buffer.dirtyMin) buffer.dirtyMin = y;
+		if (y > buffer.dirtyMax) buffer.dirtyMax = y;
+	}
 	buffer.cursorX = clamp(buffer.cursorX, 0, Math.max(0, nextCols));
 	buffer.cursorY = clamp(buffer.cursorY, 0, Math.max(0, nextRows - 1));
 	if (buffer.fingerprintFn) {
@@ -3705,6 +3900,10 @@ function mergePlanes(prev, next) {
 	return Array.from(merged);
 }
 const TERMINAL_PLANE_INTERNALS = Symbol.for("@simon_he/vue-tui:v1:terminal-plane-internals");
+const TERMINAL_ROOT = Symbol.for("@simon_he/vue-tui:v1:terminal-root");
+function getRootTerminal(terminal) {
+	return terminal[TERMINAL_ROOT] ?? terminal;
+}
 function createCoverage(cols, rows) {
 	return Array.from({ length: rows }, () => new Uint8Array(cols));
 }
@@ -3789,6 +3988,8 @@ function markPlaneCoverageRange(state, x0, y0, x1, y1, value) {
 	}
 }
 function markPlaneCoverageForPut(state, x, y, ch, prevCell) {
+	if (!Number.isSafeInteger(x) || !Number.isSafeInteger(y)) return;
+	if (x < 0 || x >= state.buffer.cols || y < 0 || y >= state.buffer.rows) return;
 	const row = state.coverage[y];
 	if (!row) return;
 	if ((prevCell === null || prevCell === void 0 ? void 0 : prevCell.continuation) && x > 0) row[x - 1] = 1;
@@ -3912,10 +4113,14 @@ function createTerminal(opts) {
 	}
 	function putForPlane(plane, x, y, ch, style) {
 		const state = getPlaneState(plane);
-		if (y < 0 || y >= state.buffer.rows || x < 0 || x >= state.buffer.cols) return;
-		const prevCell = getBufferCell(state.buffer, x, y);
-		putCell(state.buffer, x, y, ch, style);
-		markPlaneCoverageForPut(state, x, y, ch, prevCell);
+		if (typeof x !== "number" || typeof y !== "number") return;
+		const cellX = Math.floor(x);
+		const cellY = Math.floor(y);
+		if (!Number.isFinite(cellX) || !Number.isFinite(cellY)) return;
+		if (cellY < 0 || cellY >= state.buffer.rows || cellX < 0 || cellX >= state.buffer.cols) return;
+		const prevCell = getBufferCell(state.buffer, cellX, cellY);
+		putCell(state.buffer, cellX, cellY, ch, style);
+		markPlaneCoverageForPut(state, cellX, cellY, ch, prevCell);
 	}
 	function writeAtForPlane(plane, text, x, y, style) {
 		const state = getPlaneState(plane);
@@ -4419,6 +4624,7 @@ function createTerminal(opts) {
 				return getRowFingerprints(state.buffer, yy);
 			}
 		};
+		api[TERMINAL_ROOT] = base;
 		planeTerminals.set(plane, api);
 		return api;
 	}
@@ -4502,7 +4708,7 @@ function createTerminal(opts) {
 				const rows = collectAndClearDirtyRows(state.buffer);
 				if (rows === null) {
 					composeAllRows = true;
-					break;
+					continue;
 				}
 				for (const y of rows) dirtyRows.add(y);
 			}
@@ -4624,6 +4830,7 @@ function createTerminal(opts) {
 			scrollRowsForPlane(plane, startY, endY, lines);
 		}
 	};
+	base[TERMINAL_ROOT] = base;
 	return base;
 }
 
@@ -4650,7 +4857,7 @@ function sameRect$1(a, b) {
 function isVisible(node) {
 	return node.visible !== false;
 }
-function now() {
+function now$1() {
 	return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
 function rectRowRange(rect) {
@@ -4830,7 +5037,7 @@ function createCliEventManager(options) {
 			bubbles: true,
 			cancelable: true,
 			defaultPrevented: false,
-			timeStamp: typeof time === "number" ? time : now(),
+			timeStamp: typeof time === "number" ? time : now$1(),
 			__stopped: false,
 			stopPropagation() {
 				this.__stopped = true;
@@ -5196,6 +5403,94 @@ const FRAME_PERF_REASON_PRIORITY = {
 	scroll: 6,
 	input: 7
 };
+const EMPTY_METRIC_STATS = Object.freeze({
+	avg: 0,
+	max: 0,
+	min: 0
+});
+function metricStats(values) {
+	if (!values.length) return EMPTY_METRIC_STATS;
+	let sum = 0;
+	let max = Number.NEGATIVE_INFINITY;
+	let min = Number.POSITIVE_INFINITY;
+	for (const value of values) {
+		sum += value;
+		if (value > max) max = value;
+		if (value < min) min = value;
+	}
+	return {
+		avg: sum / values.length,
+		max,
+		min
+	};
+}
+function summarizeFramePerf(samples) {
+	const durationMs = [];
+	const renderManagerMs = [];
+	const commitMs = [];
+	const domFlushMs = [];
+	const stdoutFlushMs = [];
+	const dirtyRows = [];
+	const scannedNodes = [];
+	const paintedNodes = [];
+	const reasons = {};
+	const activePlanes = {};
+	let fullDirtyFrames = 0;
+	let coalescedInvalidates = 0;
+	let coalescedFrameTasks = 0;
+	let droppedUpdates = 0;
+	let maxQueueDepth = 0;
+	let rowBucketFallbacks = 0;
+	for (const sample of samples) {
+		var _sample$rowBucketFall;
+		durationMs.push(sample.durationMs);
+		renderManagerMs.push(sample.renderManagerMs);
+		commitMs.push(sample.commitMs);
+		scannedNodes.push(sample.scannedNodes);
+		paintedNodes.push(sample.paintedNodes);
+		if (sample.domFlushMs != null) domFlushMs.push(sample.domFlushMs);
+		if (sample.stdoutFlushMs != null) stdoutFlushMs.push(sample.stdoutFlushMs);
+		if (sample.dirtyRows == null) fullDirtyFrames++;
+		else dirtyRows.push(sample.dirtyRows);
+		reasons[sample.reason] = (reasons[sample.reason] ?? 0) + 1;
+		const planes = sample.activePlanes;
+		if (!planes) activePlanes.all = (activePlanes.all ?? 0) + 1;
+		else for (const plane of planes) activePlanes[plane] = (activePlanes[plane] ?? 0) + 1;
+		coalescedInvalidates += sample.coalescedInvalidates;
+		coalescedFrameTasks += sample.coalescedFrameTasks;
+		droppedUpdates += sample.droppedUpdates;
+		if (sample.queueDepth > maxQueueDepth) maxQueueDepth = sample.queueDepth;
+		rowBucketFallbacks += ((_sample$rowBucketFall = sample.rowBucketFallbacks) === null || _sample$rowBucketFall === void 0 ? void 0 : _sample$rowBucketFall.length) ?? 0;
+	}
+	const first = samples[0] ?? null;
+	const latest = samples[samples.length - 1] ?? null;
+	return {
+		frames: samples.length,
+		firstFrameId: (first === null || first === void 0 ? void 0 : first.frameId) ?? null,
+		latestFrameId: (latest === null || latest === void 0 ? void 0 : latest.frameId) ?? null,
+		windowMs: first && latest ? Math.max(0, latest.startedAt - first.startedAt) : 0,
+		durationMs: metricStats(durationMs),
+		renderManagerMs: metricStats(renderManagerMs),
+		commitMs: metricStats(commitMs),
+		domFlushMs: metricStats(domFlushMs),
+		stdoutFlushMs: metricStats(stdoutFlushMs),
+		dirtyRows: {
+			avg: dirtyRows.length ? dirtyRows.reduce((sum, value) => sum + value, 0) / dirtyRows.length : 0,
+			max: dirtyRows.length ? Math.max(...dirtyRows) : 0,
+			sampledFrames: dirtyRows.length,
+			fullFrames: fullDirtyFrames
+		},
+		scannedNodes: metricStats(scannedNodes),
+		paintedNodes: metricStats(paintedNodes),
+		coalescedInvalidates,
+		coalescedFrameTasks,
+		droppedUpdates,
+		maxQueueDepth,
+		rowBucketFallbacks,
+		reasons,
+		activePlanes
+	};
+}
 function framePerfNow() {
 	const p = globalThis.performance;
 	if (p && typeof p.now === "function") return p.now();
@@ -5336,6 +5631,9 @@ function createFramePerfStore(limit = 120, opts) {
 	function list() {
 		return samples.slice();
 	}
+	function summary() {
+		return summarizeFramePerf(samples);
+	}
 	function clear() {
 		samples.length = 0;
 	}
@@ -5348,6 +5646,7 @@ function createFramePerfStore(limit = 120, opts) {
 		addSink,
 		latest,
 		list,
+		summary,
 		clear
 	};
 }
@@ -5463,6 +5762,9 @@ function clampPointToRect(point, rect) {
 		y: Math.max(rect.y, Math.min(rect.y + Math.max(0, rect.h - 1), Math.floor(point.y)))
 	};
 }
+function clipboardCanWrite$1(api) {
+	return api.canWrite ?? api.supported;
+}
 function createTerminalSelectionController(options) {
 	const state = shallowRef(EMPTY_STATE);
 	let range = null;
@@ -5664,7 +5966,7 @@ function createTerminalSelectionController(options) {
 			const text = state.value.text || selectedText();
 			if (!text) return false;
 			setResolvedText(text);
-			if (!options.clipboard.supported) {
+			if (!clipboardCanWrite$1(options.clipboard)) {
 				var _options$onCopy;
 				(_options$onCopy = options.onCopy) === null || _options$onCopy === void 0 || _options$onCopy.call(options, copyPayload(text, false, new Error("Clipboard unavailable")));
 				return false;
@@ -5769,16 +6071,19 @@ function createOsc52ClipboardProvider(options = {}) {
 		var _stdout$write;
 		stdout === null || stdout === void 0 || (_stdout$write = stdout.write) === null || _stdout$write === void 0 || _stdout$write.call(stdout, sequence);
 	});
-	const supported = options.supported ?? Boolean(options.write || (stdout === null || stdout === void 0 ? void 0 : stdout.write) && stdout.isTTY);
+	const canWrite = options.supported ?? Boolean(options.write || (stdout === null || stdout === void 0 ? void 0 : stdout.write) && stdout.isTTY);
+	const canRead = typeof options.readText === "function";
 	const target = normalizeOsc52Target(options.target);
 	return {
-		supported,
+		supported: canWrite,
+		canRead,
+		canWrite,
 		async readText() {
-			if (!options.readText) throw new Error("Clipboard read not available in this runtime");
+			if (!canRead) throw new Error("Clipboard read not available in this runtime");
 			return options.readText();
 		},
 		async writeText(text) {
-			if (!supported) throw new Error("Clipboard not available in this runtime");
+			if (!canWrite) throw new Error("Clipboard not available in this runtime");
 			const bytes = encodeTextBytes(text);
 			const maxBytes = resolveMaxBytes(options.maxBytes, 100 * 1024);
 			if (bytes.byteLength > maxBytes) throw new Error(`OSC52 clipboard payload too large: ${bytes.byteLength} bytes`);
@@ -6133,6 +6438,120 @@ function normalizeTerminalLinkOpener(opener) {
 	return opener;
 }
 
+//#endregion
+//#region src/renderer/terminal-graphics-trace.ts
+const metrics$1 = {
+	requests: 0,
+	skippedHidden: 0,
+	skippedScrolling: 0,
+	cacheHits: 0,
+	cacheMisses: 0,
+	cacheStores: 0,
+	rendererRuns: 0,
+	rendererAborts: 0,
+	rendererErrors: 0,
+	queued: 0,
+	queueWaits: 0,
+	queueDeduped: 0,
+	cleared: 0,
+	bytesQueued: 0,
+	totalRendererMs: 0,
+	totalValidateMs: 0,
+	totalQueueWaitMs: 0,
+	maxQueueWaitMs: 0,
+	maxActiveRenders: 0,
+	maxWaitingRenders: 0,
+	maxCacheEntries: 0,
+	maxCacheBytes: 0,
+	scrollStarts: 0,
+	scrollMarks: 0,
+	scrollIdles: 0,
+	totalScrollMs: 0,
+	maxScrollMs: 0
+};
+const subscribers = new Set();
+function nowTerminalGraphicTraceTime() {
+	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function recordTerminalGraphicTrace(event) {
+	const normalized = {
+		...event,
+		timestamp: event.timestamp ?? nowTerminalGraphicTraceTime()
+	};
+	switch (normalized.type) {
+		case "request":
+			metrics$1.requests++;
+			break;
+		case "skip-hidden":
+			metrics$1.skippedHidden++;
+			break;
+		case "skip-scrolling":
+			metrics$1.skippedScrolling++;
+			break;
+		case "cache-hit":
+			metrics$1.cacheHits++;
+			break;
+		case "cache-miss":
+			metrics$1.cacheMisses++;
+			break;
+		case "cache-store":
+			metrics$1.cacheStores++;
+			break;
+		case "renderer-start":
+			metrics$1.rendererRuns++;
+			break;
+		case "renderer-end":
+			metrics$1.totalRendererMs += normalized.durationMs ?? 0;
+			break;
+		case "renderer-abort":
+			metrics$1.rendererAborts++;
+			break;
+		case "renderer-error":
+			metrics$1.rendererErrors++;
+			break;
+		case "validate-end":
+			metrics$1.totalValidateMs += normalized.durationMs ?? 0;
+			break;
+		case "queue":
+			metrics$1.queued++;
+			metrics$1.bytesQueued += normalized.bytes ?? 0;
+			break;
+		case "queue-wait": {
+			const durationMs = normalized.durationMs ?? 0;
+			metrics$1.queueWaits++;
+			metrics$1.totalQueueWaitMs += durationMs;
+			metrics$1.maxQueueWaitMs = Math.max(metrics$1.maxQueueWaitMs, durationMs);
+			break;
+		}
+		case "queue-dedupe":
+			metrics$1.queueDeduped++;
+			break;
+		case "clear":
+			metrics$1.cleared++;
+			break;
+		case "scroll-start":
+			metrics$1.scrollStarts++;
+			break;
+		case "scroll-mark":
+			metrics$1.scrollMarks++;
+			break;
+		case "scroll-idle": {
+			const durationMs = normalized.durationMs ?? 0;
+			metrics$1.scrollIdles++;
+			metrics$1.totalScrollMs += durationMs;
+			metrics$1.maxScrollMs = Math.max(metrics$1.maxScrollMs, durationMs);
+			break;
+		}
+	}
+	if (normalized.active != null && Number.isFinite(normalized.active)) metrics$1.maxActiveRenders = Math.max(metrics$1.maxActiveRenders, Math.max(0, normalized.active));
+	if (normalized.waiting != null && Number.isFinite(normalized.waiting)) metrics$1.maxWaitingRenders = Math.max(metrics$1.maxWaitingRenders, Math.max(0, normalized.waiting));
+	if (normalized.cacheEntries != null && Number.isFinite(normalized.cacheEntries)) metrics$1.maxCacheEntries = Math.max(metrics$1.maxCacheEntries, Math.max(0, normalized.cacheEntries));
+	if (normalized.cacheBytes != null && Number.isFinite(normalized.cacheBytes)) metrics$1.maxCacheBytes = Math.max(metrics$1.maxCacheBytes, Math.max(0, normalized.cacheBytes));
+	for (const subscriber of subscribers) try {
+		subscriber(normalized);
+	} catch {}
+}
+
 //#endregion
 //#region src/vue/context.ts
 const TerminalContextKey = injectionKey("TerminalContext");
@@ -6143,6 +6562,7 @@ const RenderPlaneContextKey = injectionKey("RenderPlane");
 const ImeAnchorContextKey = injectionKey("ImeAnchor");
 const TInputPluginsContextKey = injectionKey("TInputPlugins");
 const TPathPickerProviderContextKey = injectionKey("TPathPickerProvider");
+const TerminalGraphicsActivityKey = injectionKey("TerminalGraphicsActivity");
 const DialogContextKey = injectionKey("DialogContext");
 
 //#endregion
@@ -6293,6 +6713,10 @@ function sameRect(a, b) {
 	if (!a || !b) return false;
 	return a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
 }
+function rectsIntersect(a, b) {
+	if (isEmptyRect(a) || isEmptyRect(b)) return false;
+	return a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
+}
 function createRenderManager(terminal, options = {}) {
 	const widthProvider = options.widthProvider ?? "default";
 	const withRenderTextPass = (fn) => withTextRenderPass(fn, widthProvider);
@@ -6300,6 +6724,7 @@ function createRenderManager(terminal, options = {}) {
 	const nodes = new Map();
 	const planeDirtyStates = new Map();
 	const initialSize = terminal.size();
+	let terminalCols = initialSize.cols;
 	let terminalRows = initialSize.rows;
 	let allRows = Array.from({ length: terminalRows }, (_, index) => index);
 	let sortedNodes = [];
@@ -6320,19 +6745,37 @@ function createRenderManager(terminal, options = {}) {
 	let disposed = false;
 	const stackPathCache = new WeakMap();
 	const profiler = createTuiProfiler("render-manager", options.profiler);
-	const offResize = terminal.on("resize", ({ rows }) => {
+	const offResize = terminal.on("resize", ({ cols, rows }) => {
 		if (disposed) return;
+		const colsChanged = cols !== terminalCols;
+		const prevRows = terminalRows;
+		terminalCols = cols;
 		terminalRows = rows;
 		allRows = Array.from({ length: terminalRows }, (_, index) => index);
 		for (const state of planeDirtyStates.values()) {
-			state.allRowsDirty = true;
+			const prevBits = state.dirtyRowBits;
 			state.dirtyRowBits = new Uint8Array(terminalRows);
 			state.dirtyRowCount = 0;
 			state.dirtyMinY = Number.POSITIVE_INFINITY;
 			state.dirtyMaxY = -1;
+			const limit = Math.min(terminalRows, prevBits.length);
+			for (let y = 0; y < limit; y++) {
+				if (prevBits[y] !== 1) continue;
+				state.dirtyRowBits[y] = 1;
+				state.dirtyRowCount++;
+				if (y < state.dirtyMinY) state.dirtyMinY = y;
+				if (y > state.dirtyMaxY) state.dirtyMaxY = y;
+			}
+			for (let y = prevRows; y < terminalRows; y++) {
+				if (state.dirtyRowBits[y] === 1) continue;
+				state.dirtyRowBits[y] = 1;
+				state.dirtyRowCount++;
+				if (y < state.dirtyMinY) state.dirtyMinY = y;
+				if (y > state.dirtyMaxY) state.dirtyMaxY = y;
+			}
 		}
 		rebuildRowBuckets();
-		clearTextCaches();
+		if (colsChanged) clearTextCaches();
 	});
 	const rootStack = Object.freeze({
 		id: `s${nextStackId++}`,
@@ -6531,6 +6974,33 @@ function createRenderManager(terminal, options = {}) {
 			if (y > state.dirtyMaxY) state.dirtyMaxY = y;
 		}
 	}
+	function markLowerPlanesForRect(plane, rect) {
+		const planeIndex = TERMINAL_RENDER_PLANES.indexOf(plane);
+		if (planeIndex <= 0) return;
+		for (let i = 0; i < planeIndex; i++) markRect(TERMINAL_RENDER_PLANES[i], rect);
+	}
+	function markRowRange(plane, startY, endY) {
+		const state = getDirtyState(plane);
+		const start = Math.max(0, Math.min(terminalRows, Math.floor(startY)));
+		const end = Math.max(start, Math.min(terminalRows, Math.floor(endY)));
+		for (let y = start; y < end; y++) {
+			if (state.dirtyRowBits[y] === 1) continue;
+			state.dirtyRowBits[y] = 1;
+			state.dirtyRowCount++;
+			if (y < state.dirtyMinY) state.dirtyMinY = y;
+			if (y > state.dirtyMaxY) state.dirtyMaxY = y;
+		}
+	}
+	function markRectHeightDelta(plane, prev, next) {
+		if (!prev || !next) return false;
+		if (prev.x !== next.x || prev.y !== next.y || prev.w !== next.w) return false;
+		const prevBounds = rectToYBounds(prev);
+		const nextBounds = rectToYBounds(next);
+		if (prevBounds.y0 !== nextBounds.y0) return false;
+		if (nextBounds.y1 > prevBounds.y1) markRowRange(plane, prevBounds.y1, nextBounds.y1);
+		else if (prevBounds.y1 > nextBounds.y1) markRowRange(plane, nextBounds.y1, prevBounds.y1);
+		return true;
+	}
 	function markRowsForNode(node, rows) {
 		if (!rows.length) return false;
 		warnIfRowsLookLocal(node, rows);
@@ -6578,6 +7048,7 @@ function createRenderManager(terminal, options = {}) {
 		nodes.set(id, full);
 		addToRowBuckets(full);
 		markRect(full.plane, full.rect);
+		markLowerPlanesForRect(full.plane, full.rect);
 		sortedDirty = true;
 		return full;
 	}
@@ -6589,6 +7060,7 @@ function createRenderManager(terminal, options = {}) {
 		const nextPlane = next.plane ?? prev.plane;
 		const planeChanged = nextPlane !== prev.plane;
 		const hasRect = Object.prototype.hasOwnProperty.call(next, "rect");
+		const paintChanged = Object.prototype.hasOwnProperty.call(next, "paint");
 		const nextRect = hasRect ? next.rect ?? null : prev.rect;
 		const rectChanged = !sameRect(prev.rect, nextRect);
 		const bucketChanged = planeChanged || rectChanged;
@@ -6596,10 +7068,12 @@ function createRenderManager(terminal, options = {}) {
 		const dirtyRowsHint = next.dirtyRowsHint;
 		const canUseDirtyRowsHint = !sortChanged && !rectChanged && nextPlane === prev.plane && dirtyRowsHint != null && dirtyRowsHint.length > 0;
 		if (canUseDirtyRowsHint) markRowsForNode(prev, dirtyRowsHint);
-		else {
+		else if (rectChanged && !paintChanged && !sortChanged && !planeChanged && markRectHeightDelta(prev.plane, prev.rect, nextRect)) {} else {
 			markRect(prev.plane, prev.rect);
 			markRect(nextPlane, nextRect);
 		}
+		markLowerPlanesForRect(prev.plane, prev.rect);
+		markLowerPlanesForRect(nextPlane, nextRect);
 		if (bucketChanged) removeFromRowBuckets(prev);
 		const full = Object.freeze({
 			...prev,
@@ -6629,11 +7103,41 @@ function createRenderManager(terminal, options = {}) {
 		if (!node) return false;
 		return markRowsForNode(node, rows);
 	}
+	function isRectCoveredByHigherNode(id, rect, options$1 = {}) {
+		return higherNodeCoverageRects(id, rect, options$1).length > 0;
+	}
+	function higherNodeCoverageRects(id, rect, options$1 = {}) {
+		if (disposed || isEmptyRect(rect)) return [];
+		const owner = nodes.get(id);
+		if (!owner) return [];
+		const ownerPlaneIndex = TERMINAL_RENDER_PLANES.indexOf(owner.plane);
+		if (ownerPlaneIndex < 0) return [];
+		const out = [];
+		for (const candidate of nodes.values()) {
+			if (candidate.id === id || !candidate.rect || isEmptyRect(candidate.rect)) continue;
+			if (!rectsIntersect(rect, candidate.rect)) continue;
+			const candidatePlaneIndex = TERMINAL_RENDER_PLANES.indexOf(candidate.plane);
+			const covered = candidatePlaneIndex > ownerPlaneIndex || !options$1.ignoreSamePlane && candidatePlaneIndex === ownerPlaneIndex && compareNodes(owner, candidate) < 0;
+			if (!covered) continue;
+			const x0 = Math.max(rect.x, candidate.rect.x);
+			const y0 = Math.max(rect.y, candidate.rect.y);
+			const x1 = Math.min(rect.x + rect.w, candidate.rect.x + candidate.rect.w);
+			const y1 = Math.min(rect.y + rect.h, candidate.rect.y + candidate.rect.h);
+			if (x1 > x0 && y1 > y0) out.push({
+				x: x0,
+				y: y0,
+				w: x1 - x0,
+				h: y1 - y0
+			});
+		}
+		return out;
+	}
 	function unregister(id) {
 		if (disposed) return;
 		const prev = nodes.get(id);
 		if (prev) {
 			markRect(prev.plane, prev.rect);
+			markLowerPlanesForRect(prev.plane, prev.rect);
 			removeFromRowBuckets(prev);
 			warnedLocalDirtyRows.delete(id);
 		}
@@ -6849,6 +7353,8 @@ function createRenderManager(terminal, options = {}) {
 		register,
 		update,
 		markDirtyRows,
+		isRectCoveredByHigherNode,
+		higherNodeCoverageRects,
 		unregister,
 		render,
 		dispose() {
@@ -7247,6 +7753,8 @@ function resolveSelectionConfig(config) {
 }
 const unsupportedClipboard = {
 	supported: false,
+	canRead: false,
+	canWrite: false,
 	async readText() {
 		return "";
 	},
@@ -7254,6 +7762,12 @@ const unsupportedClipboard = {
 		throw new Error("Clipboard unavailable");
 	}
 };
+function clipboardCanRead(api) {
+	return api.canRead ?? api.supported;
+}
+function clipboardCanWrite(api) {
+	return api.canWrite ?? api.supported;
+}
 function isPlainObject(v) {
 	if (!v || typeof v !== "object") return false;
 	const proto = Object.getPrototypeOf(v);
@@ -7285,10 +7799,12 @@ function shallowEqualRecord(a, b) {
 function createTerminalApp(options) {
 	const env = (process === null || process === void 0 ? void 0 : process.env) ?? {};
 	if (shouldInstallFileWriters(env)) installNodeFileWriters();
+	const debugEnabled = isDebugEnabled();
+	const debugLog$1 = createDebugLogger(debugEnabled);
 	const widthProvider = options.widthProvider ?? "default";
 	const profileEnabled = envFlag(env, "VUE_TUI_PROFILE", "DIMCODE_PROFILE_TUI");
-	const profileLogPath = envString(env, "VUE_TUI_PROFILE_LOG_PATH", "DIMCODE_PROFILE_TUI_LOG_PATH");
-	const framePerfLogPath = envString(env, "VUE_TUI_FRAME_PERF_LOG_PATH", "DIMCODE_TUI_PERF_LOG") || (profileLogPath.endsWith(".jsonl") ? profileLogPath : defaultVueTuiFramePerfLogPath());
+	const profileLogPath = envString$1(env, "VUE_TUI_PROFILE_LOG_PATH", "DIMCODE_PROFILE_TUI_LOG_PATH");
+	const framePerfLogPath = envString$1(env, "VUE_TUI_FRAME_PERF_LOG_PATH", "DIMCODE_TUI_PERF_LOG") || (profileLogPath.endsWith(".jsonl") ? profileLogPath : defaultVueTuiFramePerfLogPath());
 	const framePerfSink = profileEnabled ? createJsonlPerfSink({
 		file: framePerfLogPath,
 		fileWriter: nodeProfilerFileWriter,
@@ -7339,6 +7855,10 @@ function createTerminalApp(options) {
 		}
 	});
 	const offCommit = terminal.on("commit", ({ dirtyRows, planes, sync }) => {
+		if (debugEnabled) {
+			const size = terminal.size();
+			debugLog$1.render(`app commit: size=${size.cols}x${size.rows}, dirtyRows=${(dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) ?? "null"}, planes=${(planes === null || planes === void 0 ? void 0 : planes.join(",")) ?? "all"}${sync ? ", sync" : ""}`);
+		}
 		latency === null || latency === void 0 || latency.recordCommit({
 			dirtyRows,
 			planes,
@@ -7431,6 +7951,10 @@ function createTerminalApp(options) {
 		scheduled = false;
 		flushing = true;
 		const activePlanes = takeActivePlanes();
+		if (debugEnabled) {
+			const size = terminal.size();
+			debugLog$1.render(`app flush start: size=${size.cols}x${size.rows}, activePlanes=${(activePlanes === null || activePlanes === void 0 ? void 0 : activePlanes.join(",")) ?? "all"}, sync=${sync ? "true" : "false"}, frameTasks=${frameTasks.frameTaskCount}`);
+		}
 		latency === null || latency === void 0 || latency.recordFlushStart({
 			sync,
 			activePlanes
@@ -7556,6 +8080,10 @@ function createTerminalApp(options) {
 	function invalidate(options$1) {
 		if (disposed) return;
 		const priority = (options$1 === null || options$1 === void 0 ? void 0 : options$1.priority) ?? "normal";
+		if (debugEnabled) {
+			const size = terminal.size();
+			debugLog$1.render(`app invalidate: size=${size.cols}x${size.rows}, reason=${(options$1 === null || options$1 === void 0 ? void 0 : options$1.reason) ?? "unknown"}, priority=${priority}, plane=${(options$1 === null || options$1 === void 0 ? void 0 : options$1.plane) ?? "all"}, scheduled=${scheduled}, flushing=${flushing}, queueDepth=${queueDepth()}`);
+		}
 		noteFrameReason(options$1 === null || options$1 === void 0 ? void 0 : options$1.reason);
 		latency === null || latency === void 0 || latency.recordSchedulerInvalidate({
 			priority,
@@ -7640,6 +8168,7 @@ function createTerminalApp(options) {
 		invalidate({ plane: portal.plane });
 		return handle;
 	} };
+	const clipboard = options.clipboard ?? unsupportedClipboard;
 	const rootLayout = shallowReactive({
 		originX: 0,
 		originY: 0,
@@ -7679,10 +8208,11 @@ function createTerminalApp(options) {
 		"chrome"
 	];
 	let selectionRenderNodeId = null;
+	const selectionRenderRect = () => null;
 	const selection = createTerminalSelectionController({
 		terminal,
 		overlayTerminal: selectionOverlay,
-		clipboard: options.clipboard ?? unsupportedClipboard,
+		clipboard,
 		getRow: (y) => readTerminalRowForPlanes(terminal, y, selectionReadPlanes),
 		getTextProviders: () => Array.from(selectionTextProviders.values()),
 		getOptions: () => {
@@ -7728,12 +8258,7 @@ function createTerminalApp(options) {
 			stack: render.rootStack,
 			plane: "overlay",
 			zIndex: -1e4,
-			rect: {
-				x: 0,
-				y: 0,
-				w: options.cols,
-				h: options.rows
-			},
+			rect: selectionRenderRect(),
 			paint: selection.paint
 		});
 		selectionRenderNodeId = selectionRenderNode.id;
@@ -7848,19 +8373,17 @@ function createTerminalApp(options) {
 		...createDefaultTInputHostAdapter(),
 		isTerminalLike: true,
 		async readClipboardText() {
-			var _options$clipboard;
-			if (!((_options$clipboard = options.clipboard) === null || _options$clipboard === void 0 ? void 0 : _options$clipboard.supported)) return "";
+			if (!clipboardCanRead(clipboard)) return "";
 			try {
-				return await options.clipboard.readText();
+				return await clipboard.readText();
 			} catch {
 				return "";
 			}
 		},
 		async writeClipboardText(text) {
-			var _options$clipboard2;
-			if (!text || !((_options$clipboard2 = options.clipboard) === null || _options$clipboard2 === void 0 ? void 0 : _options$clipboard2.supported)) return false;
+			if (!text || !clipboardCanWrite(clipboard)) return false;
 			try {
-				await options.clipboard.writeText(text);
+				await clipboard.writeText(text);
 				return true;
 			} catch {
 				return false;
@@ -7869,6 +8392,7 @@ function createTerminalApp(options) {
 	}))] : [defaultTInputHostPlugin]);
 	const linkOpener = ref(normalizeTerminalLinkOpener(options.linkOpener));
 	const offResize = terminal.on("resize", ({ cols, rows }) => {
+		if (debugEnabled) debugLog$1.render(`app resize event: size=${cols}x${rows}, scheduled=${scheduled}, flushing=${flushing}, queueDepth=${queueDepth()}`);
 		rootLayout.clipRect = {
 			x: 0,
 			y: 0,
@@ -7876,12 +8400,7 @@ function createTerminalApp(options) {
 			h: rows
 		};
 		selection.clear();
-		if (selectionRenderNodeId) render.update(selectionRenderNodeId, { rect: {
-			x: 0,
-			y: 0,
-			w: cols,
-			h: rows
-		} });
+		if (selectionRenderNodeId) render.update(selectionRenderNodeId, { rect: selectionRenderRect() });
 		invalidate({ reason: "resize" });
 	});
 	schedulerApi = {
@@ -7902,6 +8421,7 @@ function createTerminalApp(options) {
 		events: shallowRef(events),
 		scheduler: schedulerApi,
 		runtime,
+		clipboard,
 		observability: {
 			trace,
 			framePerf
@@ -7975,7 +8495,11 @@ const metrics = {
 	writeEmaMs: 0,
 	writeMode: "stream",
 	fps: 0,
-	bytesPerSec: 0
+	bytesPerSec: 0,
+	terminalGraphicsDraws: 0,
+	terminalGraphicsClears: 0,
+	terminalGraphicsBytes: 0,
+	terminalGraphicsActive: 0
 };
 let bucketStart = 0;
 let bucketFrames = 0;
@@ -8009,6 +8533,291 @@ function recordStdoutFrame(info) {
 		bucketBytes = 0;
 	}
 }
+function recordStdoutTerminalGraphics(info) {
+	metrics.terminalGraphicsDraws += Math.max(0, Math.floor(Number(info.draws) || 0));
+	metrics.terminalGraphicsClears += Math.max(0, Math.floor(Number(info.clears) || 0));
+	metrics.terminalGraphicsBytes += Math.max(0, Math.floor(Number(info.bytes) || 0));
+	metrics.terminalGraphicsActive = Math.max(0, Math.floor(Number(info.active) || 0));
+}
+
+//#endregion
+//#region src/renderer/terminal-graphic-render-queue.ts
+const CACHE_MISS = Symbol("terminal-graphic-cache-miss");
+function now() {
+	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function createAbortError() {
+	const error = new Error("Terminal graphic render aborted");
+	error.name = "AbortError";
+	return error;
+}
+function positiveFiniteInt(value, fallback) {
+	const n = Number(value);
+	if (!Number.isFinite(n)) return fallback;
+	const int = Math.floor(n);
+	return int > 0 ? int : fallback;
+}
+function throwIfAborted(signal) {
+	if (signal === null || signal === void 0 ? void 0 : signal.aborted) throw createAbortError();
+}
+function raceAbort(promise, signal) {
+	if (!signal) return promise;
+	if (signal.aborted) return Promise.reject(createAbortError());
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(createAbortError());
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+function createTerminalGraphicRenderQueue(options = {}) {
+	const maxConcurrency = positiveFiniteInt(options.maxConcurrency, 2);
+	const maxEntries = positiveFiniteInt(options.maxEntries, 128);
+	const maxBytes = positiveFiniteInt(options.maxBytes, 32 * 1024 * 1024);
+	const ttlMs = positiveFiniteInt(options.ttlMs, 5 * 6e4);
+	const dedupeInflight = options.dedupeInflight ?? false;
+	let active = 0;
+	let cacheBytes = 0;
+	let generation = 0;
+	const waiters = [];
+	const cache = new Map();
+	const inflight = new Map();
+	function traceQueueState(event) {
+		recordTerminalGraphicTrace({
+			...event,
+			active,
+			waiting: waiters.length,
+			cacheEntries: cache.size,
+			cacheBytes
+		});
+	}
+	function evictUntilBudget() {
+		while (cache.size > maxEntries || cacheBytes > maxBytes) {
+			const oldestKey = cache.keys().next().value;
+			if (!oldestKey) break;
+			const entry = cache.get(oldestKey);
+			cache.delete(oldestKey);
+			if (entry) {
+				var _options$onMetric;
+				cacheBytes -= entry.bytes;
+				(_options$onMetric = options.onMetric) === null || _options$onMetric === void 0 || _options$onMetric.call(options, {
+					type: "evict",
+					key: oldestKey,
+					bytes: entry.bytes
+				});
+			}
+		}
+	}
+	function setCache(key, value, bytes) {
+		var _options$onMetric2;
+		const prev = cache.get(key);
+		if (prev) {
+			cache.delete(key);
+			cacheBytes -= prev.bytes;
+		}
+		if (bytes > maxBytes) return;
+		cache.set(key, {
+			value,
+			bytes,
+			expiresAt: Date.now() + ttlMs
+		});
+		cacheBytes += bytes;
+		(_options$onMetric2 = options.onMetric) === null || _options$onMetric2 === void 0 || _options$onMetric2.call(options, {
+			type: "cache-store",
+			key,
+			bytes
+		});
+		traceQueueState({
+			type: "cache-store",
+			id: key,
+			key,
+			bytes
+		});
+		evictUntilBudget();
+	}
+	function getCache(key) {
+		var _options$onMetric3;
+		const entry = cache.get(key);
+		if (!entry) return CACHE_MISS;
+		if (entry.expiresAt < Date.now()) {
+			cache.delete(key);
+			cacheBytes -= entry.bytes;
+			return CACHE_MISS;
+		}
+		cache.delete(key);
+		cache.set(key, entry);
+		(_options$onMetric3 = options.onMetric) === null || _options$onMetric3 === void 0 || _options$onMetric3.call(options, {
+			type: "cache-hit",
+			key
+		});
+		traceQueueState({
+			type: "cache-hit",
+			id: key,
+			key,
+			bytes: entry.bytes
+		});
+		return entry.value;
+	}
+	function release() {
+		active = Math.max(0, active - 1);
+		pump();
+	}
+	function once(fn) {
+		let called = false;
+		return () => {
+			if (called) return;
+			called = true;
+			fn();
+		};
+	}
+	function observeActiveRenderAbort(key, signal) {
+		if (!signal) return () => void 0;
+		const onAbort = () => {
+			var _options$onMetric4;
+			(_options$onMetric4 = options.onMetric) === null || _options$onMetric4 === void 0 || _options$onMetric4.call(options, {
+				type: "render-abort",
+				key
+			});
+			traceQueueState({
+				type: "renderer-abort",
+				id: key,
+				key
+			});
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		return () => signal.removeEventListener("abort", onAbort);
+	}
+	function pump() {
+		while (active < maxConcurrency && waiters.length > 0) {
+			const waiter = waiters.shift();
+			active++;
+			traceQueueState({
+				type: "queue-depth",
+				id: waiter.key,
+				key: waiter.key
+			});
+			waiter.start();
+		}
+	}
+	function acquire(key, signal) {
+		throwIfAborted(signal);
+		if (active < maxConcurrency) {
+			active++;
+			traceQueueState({
+				type: "queue-depth",
+				id: key,
+				key
+			});
+			return Promise.resolve(release);
+		}
+		const waitStartedAt = now();
+		return new Promise((resolve, reject) => {
+			let onAbort = () => void 0;
+			const cleanup = () => {
+				signal === null || signal === void 0 || signal.removeEventListener("abort", onAbort);
+			};
+			const waiter = {
+				key,
+				start: () => {
+					var _options$onMetric5;
+					cleanup();
+					const waitMs = now() - waitStartedAt;
+					(_options$onMetric5 = options.onMetric) === null || _options$onMetric5 === void 0 || _options$onMetric5.call(options, {
+						type: "queue-wait",
+						key,
+						waitMs
+					});
+					traceQueueState({
+						type: "queue-wait",
+						id: key,
+						key,
+						durationMs: waitMs
+					});
+					resolve(release);
+				},
+				reject: (error) => {
+					cleanup();
+					reject(error);
+				}
+			};
+			onAbort = () => {
+				const index = waiters.indexOf(waiter);
+				if (index >= 0) waiters.splice(index, 1);
+				cleanup();
+				reject(createAbortError());
+			};
+			signal === null || signal === void 0 || signal.addEventListener("abort", onAbort, { once: true });
+			waiters.push(waiter);
+			traceQueueState({
+				type: "queue-depth",
+				id: key,
+				key
+			});
+		});
+	}
+	async function cached(key, signal, render, estimateBytes = () => 0, cachedOptions = {}) {
+		throwIfAborted(signal);
+		const cachedValue = getCache(key);
+		if (cachedValue !== CACHE_MISS) return cachedValue;
+		traceQueueState({
+			type: "cache-miss",
+			id: key,
+			key
+		});
+		const shouldDedupeInflight = cachedOptions.dedupeInflight ?? dedupeInflight;
+		const existing = shouldDedupeInflight ? inflight.get(key) : void 0;
+		if (existing) return raceAbort(existing, signal);
+		let promise;
+		promise = (async () => {
+			let releaseSlot = null;
+			let removeAbortObserver = null;
+			const renderGeneration = generation;
+			try {
+				releaseSlot = once(await acquire(key, signal));
+				removeAbortObserver = observeActiveRenderAbort(key, signal);
+				throwIfAborted(signal);
+				const cachedAfterWait = getCache(key);
+				if (cachedAfterWait !== CACHE_MISS) return cachedAfterWait;
+				const value = await render();
+				throwIfAborted(signal);
+				const rawBytes = Math.floor(Number(estimateBytes(value)));
+				const bytes = Number.isFinite(rawBytes) && rawBytes > 0 ? rawBytes : 0;
+				if (renderGeneration === generation) setCache(key, value, bytes);
+				return value;
+			} finally {
+				removeAbortObserver === null || removeAbortObserver === void 0 || removeAbortObserver();
+				releaseSlot === null || releaseSlot === void 0 || releaseSlot();
+				if (shouldDedupeInflight && inflight.get(key) === promise) inflight.delete(key);
+			}
+		})();
+		if (shouldDedupeInflight) inflight.set(key, promise);
+		return raceAbort(promise, signal);
+	}
+	return {
+		cached,
+		clear() {
+			generation++;
+			cache.clear();
+			inflight.clear();
+			const pending = waiters.splice(0);
+			for (const waiter of pending) waiter.reject(createAbortError());
+			cacheBytes = 0;
+		},
+		stats() {
+			return {
+				active,
+				waiting: waiters.length,
+				cacheEntries: cache.size,
+				cacheBytes
+			};
+		}
+	};
+}
 
 //#endregion
 //#region src/core/ansi-palette.ts
@@ -8172,13 +8981,13 @@ const ANSI16_COLOR_NAMES = Object.freeze([
 	"cyanBright",
 	"whiteBright"
 ]);
-const ESC = "\x1B[";
-const SGR_RESET = `${ESC}0m`;
-const SGR_BOLD = `${ESC}1m`;
-const SGR_DIM = `${ESC}2m`;
-const SGR_ITALIC = `${ESC}3m`;
-const SGR_UNDERLINE = `${ESC}4m`;
-const SGR_INVERSE = `${ESC}7m`;
+const ESC$1 = "\x1B[";
+const SGR_RESET = `${ESC$1}0m`;
+const SGR_BOLD = `${ESC$1}1m`;
+const SGR_DIM = `${ESC$1}2m`;
+const SGR_ITALIC = `${ESC$1}3m`;
+const SGR_UNDERLINE = `${ESC$1}4m`;
+const SGR_INVERSE = `${ESC$1}7m`;
 function toAnsi8ColorName(name) {
 	switch (name) {
 		case "black":
@@ -8238,32 +9047,32 @@ const ANSI16_BG_CODE = Object.freeze({
 function ansi8FgOpen(name) {
 	const base = toAnsi8ColorName(name);
 	const idx = ANSI8_COLOR_NAMES.indexOf(base);
-	return `${ESC}${30 + (idx < 0 ? 7 : idx)}m`;
+	return `${ESC$1}${30 + (idx < 0 ? 7 : idx)}m`;
 }
 function ansi8BgOpen(name) {
 	const base = toAnsi8ColorName(name);
 	const idx = ANSI8_COLOR_NAMES.indexOf(base);
-	return `${ESC}${40 + (idx < 0 ? 0 : idx)}m`;
+	return `${ESC$1}${40 + (idx < 0 ? 0 : idx)}m`;
 }
 function ansi16FgOpen(name) {
-	return `${ESC}${ANSI16_FG_CODE[name]}m`;
+	return `${ESC$1}${ANSI16_FG_CODE[name]}m`;
 }
 function ansi16BgOpen(name) {
-	return `${ESC}${ANSI16_BG_CODE[name]}m`;
+	return `${ESC$1}${ANSI16_BG_CODE[name]}m`;
 }
 function ansi256FgOpen(index) {
 	const n = clampAnsiIndex(index);
-	return `${ESC}38;5;${n}m`;
+	return `${ESC$1}38;5;${n}m`;
 }
 function ansi256BgOpen(index) {
 	const n = clampAnsiIndex(index);
-	return `${ESC}48;5;${n}m`;
+	return `${ESC$1}48;5;${n}m`;
 }
 function truecolorFgOpen(rgb) {
-	return `${ESC}38;2;${clampByte(rgb.r)};${clampByte(rgb.g)};${clampByte(rgb.b)}m`;
+	return `${ESC$1}38;2;${clampByte(rgb.r)};${clampByte(rgb.g)};${clampByte(rgb.b)}m`;
 }
 function truecolorBgOpen(rgb) {
-	return `${ESC}48;2;${clampByte(rgb.r)};${clampByte(rgb.g)};${clampByte(rgb.b)}m`;
+	return `${ESC$1}48;2;${clampByte(rgb.r)};${clampByte(rgb.g)};${clampByte(rgb.b)}m`;
 }
 function ansi256ToRgb(index) {
 	const n = clampAnsiIndex(index);
@@ -8417,6 +9226,623 @@ function sanitizeTerminalHref(value, options = {}) {
 	return null;
 }
 
+//#endregion
+//#region src/renderer/terminal-graphics.ts
+const TERMINAL_GRAPHICS_PROTOCOL_PRIORITY = [
+	"kitty",
+	"iterm2",
+	"sixel"
+];
+const ESC = "\x1B";
+const BEL = "\x07";
+const ST = `${ESC}\\`;
+const ESC_RE = "\\u001B";
+const BEL_RE = "\\u0007";
+const CSI_RE = new RegExp(`${ESC_RE}\\[[0-?]*[ -/]*[@-~]`, "g");
+const OSC_RE = new RegExp(`${ESC_RE}\\][\\s\\S]*?(?:${BEL_RE}|${ESC_RE}\\\\)`, "g");
+const DCS_RE = new RegExp(`${ESC_RE}P[\\s\\S]*?${ESC_RE}\\\\`, "g");
+const APC_RE = new RegExp(`${ESC_RE}_[\\s\\S]*?${ESC_RE}\\\\`, "g");
+const C1_CSI_RE = new RegExp("\\u009B[0-?]*[ -/]*[@-~]", "g");
+const C1_OSC_RE = new RegExp(`\\u009D[\\s\\S]*?(?:${BEL_RE}|\\u009C)`, "g");
+const C1_DCS_RE = new RegExp("\\u0090[\\s\\S]*?\\u009C", "g");
+const C1_APC_RE = new RegExp("\\u009F[\\s\\S]*?\\u009C", "g");
+const MAX_TERMINAL_GRAPHICS_SEQUENCE_CHARS = 16 * 1024 * 1024;
+const MAX_TERMINAL_GRAPHICS_FALLBACK_CHARS = 16384;
+const MAX_TERMINAL_GRAPHIC_CELLS = 1e4;
+const TERMINAL_GRAPHICS_REGISTRY = Symbol.for("@simon_he/vue-tui:v1:terminal-graphics");
+const terminalGraphicsGlobal = globalThis;
+const terminalGraphicsRegistry = terminalGraphicsGlobal[TERMINAL_GRAPHICS_REGISTRY] ?? {
+	outputs: new WeakMap(),
+	outputVersions: new WeakMap(),
+	outputListeners: new WeakMap()
+};
+terminalGraphicsGlobal[TERMINAL_GRAPHICS_REGISTRY] = terminalGraphicsRegistry;
+const terminalGraphicsOutputs = terminalGraphicsRegistry.outputs;
+const terminalGraphicsOutputVersions = terminalGraphicsRegistry.outputVersions;
+const terminalGraphicsOutputListeners = terminalGraphicsRegistry.outputListeners;
+function notifyTerminalGraphicsOutputChange(terminal) {
+	const version = (terminalGraphicsOutputVersions.get(terminal) ?? 0) + 1;
+	terminalGraphicsOutputVersions.set(terminal, version);
+	const listeners = terminalGraphicsOutputListeners.get(terminal);
+	if (!listeners) return;
+	for (const listener of listeners) listener();
+}
+function registerTerminalGraphicsOutput(terminal, output) {
+	const rootTerminal = getRootTerminal(terminal);
+	terminalGraphicsOutputs.set(rootTerminal, output);
+	notifyTerminalGraphicsOutputChange(rootTerminal);
+	return () => {
+		if (terminalGraphicsOutputs.get(rootTerminal) === output) {
+			terminalGraphicsOutputs.delete(rootTerminal);
+			notifyTerminalGraphicsOutputChange(rootTerminal);
+		}
+	};
+}
+function envString(env, key) {
+	const value = env[key];
+	return value == null ? void 0 : String(value);
+}
+function truthy(value) {
+	if (value == null) return false;
+	return /^(1|true|yes|on)$/i.test(String(value));
+}
+function readStdoutIsTTY() {
+	var _maybeProcess$stdout;
+	const maybeProcess = globalThis.process;
+	return Boolean(maybeProcess === null || maybeProcess === void 0 || (_maybeProcess$stdout = maybeProcess.stdout) === null || _maybeProcess$stdout === void 0 ? void 0 : _maybeProcess$stdout.isTTY);
+}
+function readProcessEnv() {
+	const maybeProcess = globalThis.process;
+	return (maybeProcess === null || maybeProcess === void 0 ? void 0 : maybeProcess.env) ?? {};
+}
+function normalizeMode(value) {
+	const raw = String(value ?? "auto").trim().toLowerCase();
+	if (raw === "auto" || raw === "off" || raw === "none" || raw === "kitty" || raw === "iterm2" || raw === "sixel" || raw === "unicode") return raw === "off" ? "none" : raw;
+	return "auto";
+}
+function isTerminalGraphicsProtocol(value) {
+	return value === "kitty" || value === "iterm2" || value === "sixel";
+}
+function uniqueProtocols(protocols) {
+	return [...new Set(protocols)];
+}
+function pickBestTerminalGraphicsProtocol(protocols) {
+	const available = new Set(protocols);
+	for (const protocol of TERMINAL_GRAPHICS_PROTOCOL_PRIORITY) if (available.has(protocol)) return protocol;
+	return null;
+}
+function detectCandidates(env) {
+	const candidates = [];
+	const term = String(envString(env, "TERM") ?? "").toLowerCase();
+	const termProgram = String(envString(env, "TERM_PROGRAM") ?? "").toLowerCase();
+	const termProgramVersion = String(envString(env, "TERM_PROGRAM_VERSION") ?? "").toLowerCase();
+	if (envString(env, "KITTY_WINDOW_ID") || envString(env, "GHOSTTY_RESOURCES_DIR") || /(?:^|-)kitty(?:-|$)/i.test(term) || term.includes("ghostty") || termProgram.includes("ghostty")) candidates.push("kitty");
+	if (termProgram.includes("iterm") || termProgram.includes("wezterm") || envString(env, "WEZTERM_PANE") || envString(env, "WEZTERM_EXECUTABLE")) candidates.push("iterm2");
+	if (truthy(envString(env, "VUE_TUI_SIXEL")) || truthy(envString(env, "VUE_TUI_GRAPHICS_SIXEL")) || String(envString(env, "TERMINAL_GRAPHICS") ?? "").toLowerCase().includes("sixel") || /\bsixel\b/i.test(`${term} ${termProgram} ${termProgramVersion}`)) candidates.push("sixel");
+	return uniqueProtocols(candidates);
+}
+function capabilitiesFor(protocol, input) {
+	const supported = protocol === "kitty" || protocol === "iterm2" || protocol === "sixel";
+	const candidates = uniqueProtocols([...input.candidates ?? (supported ? [protocol] : [])]);
+	return {
+		supported,
+		kitty: protocol === "kitty" || candidates.includes("kitty"),
+		iterm2: protocol === "iterm2" || candidates.includes("iterm2"),
+		sixel: protocol === "sixel" || candidates.includes("sixel"),
+		preferredProtocol: supported ? protocol : null,
+		protocol,
+		candidates,
+		stdoutIsTTY: input.stdoutIsTTY,
+		insideTmux: input.insideTmux,
+		insideScreen: input.insideScreen,
+		insideZellij: input.insideZellij,
+		multiplexer: input.multiplexer,
+		passthrough: input.passthrough,
+		forced: input.forced,
+		reason: input.reason
+	};
+}
+function detectTerminalGraphicsCapabilities(options = {}) {
+	const env = options.env ?? readProcessEnv();
+	const stdoutIsTTY = options.stdoutIsTTY ?? options.isTTY ?? readStdoutIsTTY();
+	const term = String(envString(env, "TERM") ?? "").toLowerCase();
+	const insideTmux = Boolean(envString(env, "TMUX")) || term.includes("tmux");
+	const insideScreen = Boolean(envString(env, "STY")) || term.startsWith("screen");
+	const insideZellij = Boolean(envString(env, "ZELLIJ") || envString(env, "ZELLIJ_SESSION_NAME")) || term.includes("zellij");
+	const multiplexer = insideTmux ? "tmux" : insideScreen ? "screen" : insideZellij ? "zellij" : null;
+	const passthroughRequested = options.passthrough ?? (truthy(envString(env, "VUE_TUI_TERMINAL_GRAPHICS_PASSTHROUGH")) || truthy(envString(env, "VUE_TUI_GRAPHICS_TMUX_PASSTHROUGH")));
+	const passthroughSupported = !multiplexer || multiplexer === "tmux";
+	const passthrough = passthroughRequested && passthroughSupported;
+	const protocolOptionProvided = options.protocol != null;
+	const mode = normalizeMode(options.protocol ?? envString(env, "VUE_TUI_TERMINAL_GRAPHICS") ?? envString(env, "VUE_TUI_GRAPHICS_PROTOCOL"));
+	const forceFromOption = options.force === true;
+	const force = options.force ?? truthy(envString(env, "VUE_TUI_GRAPHICS_FORCE"));
+	const base = {
+		stdoutIsTTY,
+		insideTmux,
+		insideScreen,
+		insideZellij,
+		multiplexer,
+		passthrough,
+		forced: force
+	};
+	if (mode === "none") return capabilitiesFor("none", {
+		...base,
+		reason: protocolOptionProvided ? "disabled-by-option" : "disabled-by-env"
+	});
+	if (!stdoutIsTTY && !force) return capabilitiesFor("unicode", {
+		...base,
+		reason: "stdout-is-not-tty"
+	});
+	if (truthy(envString(env, "CI")) && !force) return capabilitiesFor("unicode", {
+		...base,
+		reason: "ci"
+	});
+	if (multiplexer && passthroughRequested && !passthroughSupported && !force) return capabilitiesFor("unicode", {
+		...base,
+		reason: `${multiplexer}-passthrough-not-implemented`
+	});
+	if (multiplexer && !passthrough && !force) return capabilitiesFor("unicode", {
+		...base,
+		reason: `${multiplexer}-without-passthrough`
+	});
+	if (mode === "kitty" || mode === "iterm2" || mode === "sixel") return capabilitiesFor(mode, {
+		...base,
+		candidates: [mode],
+		reason: force ? forceFromOption ? "forced-by-option" : "forced-by-env" : protocolOptionProvided ? "selected-by-option" : "selected-by-env"
+	});
+	if (mode === "unicode") return capabilitiesFor("unicode", {
+		...base,
+		reason: protocolOptionProvided ? "unicode-forced-by-option" : "unicode-forced-by-env"
+	});
+	const candidates = detectCandidates(env);
+	const preferredProtocol = pickBestTerminalGraphicsProtocol(candidates);
+	const protocol = preferredProtocol ?? "unicode";
+	return capabilitiesFor(protocol, {
+		...base,
+		candidates,
+		reason: protocol === "unicode" ? "no-supported-graphics-protocol-detected" : "auto-detected"
+	});
+}
+function hashTerminalGraphicsString(input) {
+	let hash = 2166136261;
+	for (let index = 0; index < input.length; index += 1) {
+		hash ^= input.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function stableId(input) {
+	return `tg_${hashTerminalGraphicsString(input)}`;
+}
+function positiveGraphicInt(value, max) {
+	const n = Math.trunc(Number(value));
+	if (!Number.isFinite(n) || n <= 0) return null;
+	return Math.min(max, n);
+}
+function normalizeTerminalGraphicSize(width, height) {
+	const w = positiveGraphicInt(width, MAX_TERMINAL_GRAPHIC_CELLS);
+	const h$1 = positiveGraphicInt(height, MAX_TERMINAL_GRAPHIC_CELLS);
+	if (w == null || h$1 == null) return null;
+	if (w * h$1 > MAX_TERMINAL_GRAPHIC_CELLS) return null;
+	return {
+		width: w,
+		height: h$1
+	};
+}
+function withoutNestedEscapes(body) {
+	return !body.includes(ESC) && !body.includes(BEL);
+}
+function isBase64ish(value) {
+	return /^[A-Za-z0-9+/=]*$/.test(value);
+}
+function parseKittyControls(raw) {
+	const out = new Map();
+	if (!/^[A-Za-z0-9_,=+.\-:]*$/.test(raw)) return null;
+	for (const part of raw.split(",")) {
+		if (!part) continue;
+		const eq = part.indexOf("=");
+		if (eq <= 0) return null;
+		const key = part.slice(0, eq);
+		const value = part.slice(eq + 1);
+		if (!/^[A-Za-z]$/.test(key)) return null;
+		if (!/^[A-Za-z0-9+.\-:]*$/.test(value)) return null;
+		out.set(key, value);
+	}
+	return out;
+}
+function parseKittyPackets(sequence) {
+	const packets = [];
+	let index = 0;
+	while (index < sequence.length) {
+		if (!sequence.startsWith(`${ESC}_G`, index)) return null;
+		const end = sequence.indexOf(ST, index + 3);
+		if (end < 0) return null;
+		const body = sequence.slice(index + 3, end);
+		if (!withoutNestedEscapes(body)) return null;
+		const semicolon = body.indexOf(";");
+		const rawControls = semicolon >= 0 ? body.slice(0, semicolon) : body;
+		const payload = semicolon >= 0 ? body.slice(semicolon + 1) : "";
+		const controls = parseKittyControls(rawControls);
+		if (!controls) return null;
+		if (payload && !isBase64ish(payload)) return null;
+		packets.push({
+			controls,
+			payload
+		});
+		index = end + ST.length;
+	}
+	return packets.length ? packets : null;
+}
+const KITTY_DRAW_FIRST_CONTROL_KEYS = new Set([
+	"a",
+	"f",
+	"q",
+	"C",
+	"i",
+	"I",
+	"p",
+	"c",
+	"r",
+	"x",
+	"y",
+	"w",
+	"h",
+	"z",
+	"m",
+	"t"
+]);
+const KITTY_DRAW_CONTINUATION_CONTROL_KEYS = new Set([
+	"a",
+	"q",
+	"m"
+]);
+const KITTY_CLEAR_CONTROL_KEYS = new Set([
+	"a",
+	"d",
+	"i",
+	"I",
+	"p",
+	"q"
+]);
+function kittyControlsUseOnly(controls, allowed) {
+	for (const key of controls.keys()) if (!allowed.has(key)) return false;
+	return true;
+}
+const KITTY_UINT32_MAX = 4294967295;
+const KITTY_INT32_MIN = -2147483648;
+const KITTY_INT32_MAX = 2147483647;
+function kittyControlIsUint32(controls, key, min = 0) {
+	const value = controls.get(key);
+	if (value == null) return true;
+	if (!/^\d+$/.test(value)) return false;
+	const n = Number(value);
+	return Number.isSafeInteger(n) && n >= min && n <= KITTY_UINT32_MAX;
+}
+function kittyControlIsInt32(controls, key) {
+	const value = controls.get(key);
+	if (value == null) return true;
+	if (!/^-?\d+$/.test(value)) return false;
+	const n = Number(value);
+	return Number.isSafeInteger(n) && n >= KITTY_INT32_MIN && n <= KITTY_INT32_MAX;
+}
+function kittyControlPositiveInt(controls, key, fallback) {
+	const value = controls.get(key);
+	if (value == null) return fallback;
+	if (!/^\d+$/.test(value)) return null;
+	const n = Number(value);
+	return Number.isSafeInteger(n) && n >= 1 ? n : null;
+}
+function kittyControlIsTerminalGraphicCellsBounded(controls) {
+	const columns = kittyControlPositiveInt(controls, "c", 1);
+	const rows = kittyControlPositiveInt(controls, "r", 1);
+	return columns != null && rows != null && columns * rows <= MAX_TERMINAL_GRAPHIC_CELLS;
+}
+function validateKittySharedSafeControls(controls) {
+	const q = controls.get("q");
+	if (q != null && !/^[0-2]$/.test(q)) return false;
+	const cursorMove = controls.get("C");
+	if (cursorMove != null && !/^[01]$/.test(cursorMove)) return false;
+	for (const key of [
+		"i",
+		"I",
+		"p"
+	]) if (!kittyControlIsUint32(controls, key)) return false;
+	for (const key of ["c", "r"]) if (!kittyControlIsUint32(controls, key, 1)) return false;
+	if (!kittyControlIsTerminalGraphicCellsBounded(controls)) return false;
+	for (const key of ["x", "y"]) if (!kittyControlIsUint32(controls, key)) return false;
+	for (const key of ["w", "h"]) if (!kittyControlIsUint32(controls, key, 1)) return false;
+	if (!kittyControlIsInt32(controls, "z")) return false;
+	const transmissionMedium = controls.get("t");
+	if (transmissionMedium != null && transmissionMedium !== "d") return false;
+	return true;
+}
+function validateKittySequence(sequence, op = "draw") {
+	const packets = parseKittyPackets(sequence);
+	if (!packets) return false;
+	if (op === "clear") {
+		if (packets.length !== 1) return false;
+		const packet = packets[0];
+		if (!kittyControlsUseOnly(packet.controls, KITTY_CLEAR_CONTROL_KEYS)) return false;
+		if (!validateKittySharedSafeControls(packet.controls)) return false;
+		if (packet.payload) return false;
+		if (packet.controls.get("a") !== "d") return false;
+		const d = packet.controls.get("d");
+		return d == null || /^[aAcCiI]$/.test(d);
+	}
+	const first = packets[0];
+	if (!kittyControlsUseOnly(first.controls, KITTY_DRAW_FIRST_CONTROL_KEYS)) return false;
+	if (!validateKittySharedSafeControls(first.controls)) return false;
+	if (first.controls.get("a") === "p") {
+		if (packets.length !== 1) return false;
+		if (first.payload) return false;
+		if (!first.controls.has("i") && !first.controls.has("I")) return false;
+		return true;
+	}
+	if (first.controls.get("a") !== "T") return false;
+	if (!first.payload) return false;
+	const f = first.controls.get("f");
+	if (f != null && f !== "24" && f !== "32" && f !== "100") return false;
+	const firstMore = first.controls.get("m");
+	if (firstMore != null && firstMore !== "0" && firstMore !== "1") return false;
+	if (packets.length > 1 && firstMore !== "1") return false;
+	for (let i = 1; i < packets.length; i++) {
+		const packet = packets[i];
+		if (!kittyControlsUseOnly(packet.controls, KITTY_DRAW_CONTINUATION_CONTROL_KEYS)) return false;
+		if (!validateKittySharedSafeControls(packet.controls)) return false;
+		const action = packet.controls.get("a");
+		if (action != null && action !== "T") return false;
+		const m = packet.controls.get("m");
+		if (m !== "0" && m !== "1") return false;
+		if (!packet.payload && !(i === packets.length - 1 && m === "0")) return false;
+	}
+	if (packets.length > 1 && packets[packets.length - 1].controls.get("m") === "1") return false;
+	return true;
+}
+function validateIterm2Dimension(value) {
+	return /^auto$/i.test(value) || /^(?:[1-9]\d{0,4})(?:px|%)?$/.test(value);
+}
+function validateIterm2Params(params) {
+	const seen = new Set();
+	let inline = false;
+	for (const part of params.split(";").filter(Boolean)) {
+		const eq = part.indexOf("=");
+		if (eq <= 0) return false;
+		const key = part.slice(0, eq);
+		const value = part.slice(eq + 1);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		switch (key) {
+			case "inline":
+				if (value !== "1") return false;
+				inline = true;
+				break;
+			case "width":
+			case "height":
+				if (!validateIterm2Dimension(value)) return false;
+				break;
+			case "preserveAspectRatio":
+			case "doNotMoveCursor":
+				if (!/^[01]$/.test(value)) return false;
+				break;
+			default: return false;
+		}
+	}
+	return inline;
+}
+function validateIterm2Sequence(sequence, op = "draw") {
+	if (op === "clear") return false;
+	let index = 0;
+	while (index < sequence.length) {
+		const prefix = `${ESC}]1337;File=`;
+		if (!sequence.startsWith(prefix, index)) return false;
+		const belEnd = sequence.indexOf(BEL, index + prefix.length);
+		const stEnd = sequence.indexOf(ST, index + prefix.length);
+		const end = belEnd >= 0 && stEnd >= 0 ? Math.min(belEnd, stEnd) : belEnd >= 0 ? belEnd : stEnd;
+		if (end < 0) return false;
+		const body = sequence.slice(index + `${ESC}]1337;`.length, end);
+		if (!body.startsWith("File=")) return false;
+		if (!withoutNestedEscapes(body)) return false;
+		const colon = body.indexOf(":");
+		if (colon < 0) return false;
+		const params = body.slice(5, colon);
+		const payload = body.slice(colon + 1);
+		if (!/^[A-Za-z0-9_=;,.%+\-:]*$/.test(params)) return false;
+		if (!payload || !isBase64ish(payload)) return false;
+		if (!validateIterm2Params(params)) return false;
+		index = end + (end === stEnd ? ST.length : BEL.length);
+	}
+	return sequence.length > 0;
+}
+function validateSixelSequence(sequence, op = "draw") {
+	if (op === "clear") return false;
+	let index = 0;
+	while (index < sequence.length) {
+		if (!sequence.startsWith(`${ESC}P`, index)) return false;
+		const end = sequence.indexOf(ST, index + 2);
+		if (end < 0) return false;
+		const body = sequence.slice(index + 2, end);
+		if (!withoutNestedEscapes(body)) return false;
+		for (let i = 0; i < body.length; i++) {
+			const code = body.charCodeAt(i);
+			if (code < 32 || code > 126) return false;
+		}
+		const q = body.indexOf("q");
+		if (q < 0 || q > 32) return false;
+		const introducer = body.slice(0, q);
+		if (!/^[0-9;?]*$/.test(introducer)) return false;
+		const data = body.slice(q + 1);
+		if (!data.length) return false;
+		index = end + ST.length;
+	}
+	return sequence.length > 0;
+}
+function stripTerminalControlChars(value) {
+	let out = "";
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code === 127 || code >= 128 && code <= 159) continue;
+		out += value[index];
+	}
+	return out;
+}
+function sanitizeTerminalFallbackText(text) {
+	return stripTerminalControlChars(String(text ?? "").replace(OSC_RE, "").replace(CSI_RE, "").replace(DCS_RE, "").replace(APC_RE, "").replace(C1_OSC_RE, "").replace(C1_CSI_RE, "").replace(C1_DCS_RE, "").replace(C1_APC_RE, "")).slice(0, MAX_TERMINAL_GRAPHICS_FALLBACK_CHARS);
+}
+function validateTerminalGraphicFrame(frame) {
+	const startedAt = nowTerminalGraphicTraceTime();
+	const protocol = isTerminalGraphicsProtocol(frame.protocol) ? frame.protocol : void 0;
+	const recordValidation = () => {
+		recordTerminalGraphicTrace({
+			type: "validate-end",
+			id: frame.id ?? "",
+			protocol,
+			durationMs: nowTerminalGraphicTraceTime() - startedAt,
+			bytes: typeof frame.sequence === "string" ? frame.sequence.length : void 0
+		});
+	};
+	if (!protocol) {
+		recordValidation();
+		return null;
+	}
+	const sequence = String(frame.sequence ?? "");
+	if (sequence.length <= 0 || sequence.length > MAX_TERMINAL_GRAPHICS_SEQUENCE_CHARS) {
+		recordValidation();
+		return null;
+	}
+	const size = normalizeTerminalGraphicSize(frame.width, frame.height);
+	if (!size) {
+		recordValidation();
+		return null;
+	}
+	const ok = protocol === "kitty" ? validateKittySequence(sequence, "draw") : protocol === "iterm2" ? validateIterm2Sequence(sequence, "draw") : validateSixelSequence(sequence, "draw");
+	if (!ok) {
+		recordValidation();
+		return null;
+	}
+	recordValidation();
+	return {
+		...frame,
+		protocol,
+		id: frame.id || stableId(`${protocol}:${sequence.slice(0, 4096)}`),
+		sequence,
+		fallbackText: sanitizeTerminalFallbackText(frame.fallbackText),
+		width: size.width,
+		height: size.height
+	};
+}
+function isSafeTerminalGraphicsSequence(sequence, protocol, op = "draw") {
+	if (!isTerminalGraphicsProtocol(protocol)) return false;
+	if (!sequence || sequence.length > MAX_TERMINAL_GRAPHICS_SEQUENCE_CHARS) return false;
+	return protocol === "kitty" ? validateKittySequence(sequence, op) : protocol === "iterm2" ? validateIterm2Sequence(sequence, op) : validateSixelSequence(sequence, op);
+}
+function validateTerminalGraphicsPayload(payload, capabilities) {
+	if (!payload.id.trim()) return false;
+	if (!Number.isFinite(payload.x) || !Number.isFinite(payload.y)) return false;
+	if (!normalizeTerminalGraphicSize(payload.w ?? 1, payload.h ?? 1)) return false;
+	if (!capabilities.supported) return false;
+	if (!isTerminalGraphicsProtocol(payload.protocol)) return false;
+	if (payload.protocol !== capabilities.preferredProtocol) return false;
+	return isSafeTerminalGraphicsSequence(payload.sequence, payload.protocol, payload.op ?? "draw");
+}
+function uint32Control(key, value, min = 0) {
+	if (value == null) return "";
+	const n = Math.floor(value);
+	return Number.isSafeInteger(n) && n >= min && n <= KITTY_UINT32_MAX ? `${key}=${n}` : "";
+}
+function int32Control(key, value) {
+	if (value == null) return "";
+	const n = Math.floor(value);
+	return Number.isSafeInteger(n) && n >= KITTY_INT32_MIN && n <= KITTY_INT32_MAX ? `${key}=${n}` : "";
+}
+function sanitizeBase64(value) {
+	const data = String(value ?? "").replace(/\s+/g, "");
+	return isBase64ish(data) ? data : "";
+}
+function kittyGraphicCellControls(columns, rows) {
+	if (columns == null && rows == null) return [];
+	const size = normalizeTerminalGraphicSize(columns ?? 1, rows ?? 1);
+	if (!size) return [];
+	return [columns == null ? "" : `c=${size.width}`, rows == null ? "" : `r=${size.height}`];
+}
+function kittyGraphicSourceControls(sourceX, sourceY, sourceWidth, sourceHeight) {
+	return [
+		uint32Control("x", sourceX),
+		uint32Control("y", sourceY),
+		uint32Control("w", sourceWidth, 1),
+		uint32Control("h", sourceHeight, 1)
+	];
+}
+function chunkBase64(value, chunkSize) {
+	const normalizedSize = Math.max(4, Math.floor(chunkSize / 4) * 4);
+	const chunks = [];
+	for (let index = 0; index < value.length; index += normalizedSize) chunks.push(value.slice(index, index + normalizedSize));
+	return chunks.length ? chunks : [""];
+}
+function createKittyGraphicsSequence(base64Png, options = {}) {
+	const data = sanitizeBase64(base64Png);
+	if (!data) return "";
+	const chunks = chunkBase64(data, options.chunkSize ?? 4096);
+	const baseControls = [
+		"a=T",
+		"f=100",
+		options.quiet === false ? "" : "q=2",
+		options.noCursorMove === false ? "" : "C=1",
+		uint32Control("i", options.imageId),
+		uint32Control("I", options.imageNumber),
+		uint32Control("p", options.placementId),
+		...kittyGraphicCellControls(options.columns, options.rows),
+		...kittyGraphicSourceControls(options.sourceX, options.sourceY, options.sourceWidth, options.sourceHeight),
+		int32Control("z", options.zIndex)
+	].filter(Boolean);
+	return chunks.map((chunk, index) => {
+		const last = index === chunks.length - 1;
+		const controls = index === 0 ? [...baseControls, chunks.length > 1 ? `m=${last ? 0 : 1}` : ""] : [options.quiet === false ? "" : "q=2", `m=${last ? 0 : 1}`].filter(Boolean);
+		return `${ESC}_G${controls.filter(Boolean).join(",")};${chunk}${ST}`;
+	}).join("");
+}
+function createKittyDeleteGraphicsSequence(options = {}) {
+	const controls = ["a=d"];
+	if (options.allVisible) controls.push(`d=${options.freeImageData ? "A" : "a"}`);
+	else if (options.imageId != null) {
+		const imageId = uint32Control("i", options.imageId);
+		const placementId = uint32Control("p", options.placementId);
+		if (!imageId || options.placementId != null && !placementId) return "";
+		controls.push(`d=${options.freeImageData ? "I" : "i"}`);
+		controls.push(imageId);
+		controls.push(placementId);
+	} else if (options.currentCell) controls.push(`d=${options.freeImageData ? "C" : "c"}`);
+	else return "";
+	if (options.quiet !== false) controls.push("q=2");
+	return `${ESC}_G${controls.filter(Boolean).join(",")}${ST}`;
+}
+function createIterm2InlineImageSequence(base64Data, options = {}) {
+	const data = sanitizeBase64(base64Data);
+	if (!data) return "";
+	const params = [
+		"inline=1",
+		options.width != null ? `width=${formatItermDimension(options.width)}` : "",
+		options.height != null ? `height=${formatItermDimension(options.height)}` : "",
+		`preserveAspectRatio=${options.preserveAspectRatio === false ? 0 : 1}`,
+		options.doNotMoveCursor === false ? "" : "doNotMoveCursor=1"
+	].filter(Boolean);
+	return `${ESC}]1337;File=${params.join(";")}:${data}${BEL}`;
+}
+function formatItermDimension(value) {
+	if (typeof value === "number") {
+		const n = Math.floor(value);
+		if (!Number.isFinite(n)) return "auto";
+		return String(Math.min(99999, Math.max(1, n)));
+	}
+	const raw = String(value ?? "").trim();
+	return validateIterm2Dimension(raw) ? raw : "auto";
+}
+function wrapTerminalGraphicsForMultiplexer(sequence, capabilities) {
+	if (!capabilities.passthrough) return sequence;
+	if (capabilities.multiplexer === "tmux") return `${ESC}Ptmux;${sequence.split(ESC).join(`${ESC}${ESC}`)}${ST}`;
+	return sequence;
+}
+
 //#endregion
 //#region src/renderer/cli/stdout-renderer.ts
 let debugLog = null;
@@ -8431,7 +9857,27 @@ 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 CURSOR_SAVE = "\x1B7";
+const CURSOR_RESTORE = "\x1B8";
+const CURSOR_HOME = "\x1B[H";
 const stdoutFingerprintOwners = new WeakMap();
+function isTerminalGraphicsCapabilities(value) {
+	return typeof value === "object" && value !== null && "supported" in value && "protocol" in value && "preferredProtocol" in value && "candidates" in value;
+}
+function resolveTerminalGraphicsCapabilities(options, env, outputIsTTY) {
+	const terminalGraphics = options === null || options === void 0 ? void 0 : options.terminalGraphics;
+	if (terminalGraphics === false) return detectTerminalGraphicsCapabilities({
+		env,
+		isTTY: outputIsTTY,
+		protocol: "none"
+	});
+	if (isTerminalGraphicsCapabilities(terminalGraphics)) return terminalGraphics;
+	return detectTerminalGraphicsCapabilities({
+		env,
+		isTTY: outputIsTTY,
+		...terminalGraphics ?? {}
+	});
+}
 function createStdoutRenderer(terminal, options) {
 	const env = (process === null || process === void 0 ? void 0 : process.env) ?? {};
 	if (shouldInstallFileWriters(env)) installNodeFileWriters();
@@ -8449,6 +9895,7 @@ function createStdoutRenderer(terminal, options) {
 	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) ?? outputIsTTY;
+	const keepLineWrapDisabled = 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;
@@ -8581,6 +10028,7 @@ function createStdoutRenderer(terminal, options) {
 	let lastFrameTime = 0;
 	let pendingRender = false;
 	let renderTimer = null;
+	let rowsOnlyResizeRepaintTimer = null;
 	let writeEmaMs = 0;
 	let lastCursorX = null;
 	let lastCursorY = null;
@@ -8591,7 +10039,381 @@ function createStdoutRenderer(terminal, options) {
 	let accumulatedDirtyMax = -1;
 	let accumulatedDirtyRowsRequireRepaint = false;
 	let accumulatedScrollOperations = null;
+	let allowNextGraphicsOnlyRenderWithoutBaseline = false;
+	let preserveNextRowsOnlyResizeBaseline = false;
+	let deferGraphicsFlushUntilResizeCommit = false;
+	const graphicsCapabilities = resolveTerminalGraphicsCapabilities(options, env, outputIsTTY);
+	const pendingGraphics = new Map();
+	const pendingGraphicClears = new Set();
+	const activeGraphics = new Map();
+	const pendingGraphicSignatures = new Map();
+	const activeGraphicSignatures = new Map();
+	const retainedGraphics = new Map();
+	const terminalResizeDirtyGraphics = new Set();
+	let nextGraphicsOrder = 0;
+	let terminalGraphicsFlushTimer = null;
+	const hasPendingTerminalGraphics = () => pendingGraphics.size > 0 || pendingGraphicClears.size > 0;
+	function canUseTerminalGraphicsProtocol(protocol, capabilities) {
+		return capabilities.supported && isTerminalGraphicsProtocol(protocol) && protocol === capabilities.preferredProtocol;
+	}
+	function requestTerminalGraphicsFlush(defer = false) {
+		if (disposed) return;
+		if (deferGraphicsFlushUntilResizeCommit) {
+			if (isDebugEnabled()) getDebugLog().render("terminal graphics flush deferred until resize commit");
+			return;
+		}
+		if (!defer) {
+			render([], false);
+			return;
+		}
+		if (terminalGraphicsFlushTimer) return;
+		terminalGraphicsFlushTimer = setTimeout(() => {
+			terminalGraphicsFlushTimer = null;
+			if (!disposed) render([], false);
+		}, 0);
+	}
+	function terminalGraphicsPayloadSignature(payload) {
+		return [
+			payload.id,
+			payload.protocol,
+			payload.x,
+			payload.y,
+			payload.w ?? "",
+			payload.h ?? "",
+			hashTerminalGraphicsString(payload.sequence),
+			hashTerminalGraphicsString(payload.resizeSequence ?? ""),
+			hashTerminalGraphicsString(payload.clearSequence ?? "")
+		].join(":");
+	}
+	function kittyClearSequenceKeepsImageData(sequence) {
+		let index = 0;
+		while (index < sequence.length) {
+			const start = sequence.indexOf("\x1B_G", index);
+			if (start < 0) return false;
+			const end = sequence.indexOf("\x1B\\", start + 3);
+			if (end < 0) return false;
+			const body = sequence.slice(start + 3, end);
+			const controls = body.slice(0, body.indexOf(";") < 0 ? body.length : body.indexOf(";"));
+			const parts = controls.split(",");
+			if (parts.includes("a=d") && parts.includes("d=i")) return true;
+			index = end + 2;
+		}
+		return false;
+	}
+	function retainTerminalGraphic(id, active, signature, options$1 = {}) {
+		if (!signature || active.protocol !== "kitty" || !active.resizeSequence || !active.clearSequence || !kittyClearSequenceKeepsImageData(active.clearSequence)) {
+			retainedGraphics.delete(id);
+			return;
+		}
+		retainedGraphics.set(id, {
+			active,
+			signature,
+			autoRedrawOnResize: Boolean(options$1.autoRedrawOnResize)
+		});
+	}
+	function kittyPlacementKey(sequence) {
+		if (!sequence) return null;
+		const start = sequence.indexOf("\x1B_G");
+		if (start < 0) return null;
+		const end = sequence.indexOf("\x1B\\", start + 3);
+		if (end < 0) return null;
+		const body = sequence.slice(start + 3, end);
+		const controlsRaw = body.slice(0, body.indexOf(";") < 0 ? body.length : body.indexOf(";"));
+		const controls = new Map();
+		for (const part of controlsRaw.split(",")) {
+			const eq = part.indexOf("=");
+			if (eq <= 0) continue;
+			controls.set(part.slice(0, eq), part.slice(eq + 1));
+		}
+		const imageId = controls.get("i");
+		const placementId = controls.get("p");
+		if (controls.get("a") !== "p" || !imageId || !placementId) return null;
+		if (imageId === "0" || placementId === "0") return null;
+		return `${imageId}:${placementId}`;
+	}
+	function canReplaceKittyPlacementWithoutClear(previous, payload) {
+		if (payload.terminalResizeRedraw) return false;
+		if (!payload.resizeRedraw || previous.protocol !== "kitty" || payload.protocol !== "kitty") return false;
+		const nextKey = kittyPlacementKey(payload.resizeSequence ?? payload.sequence);
+		if (!nextKey) return false;
+		return kittyPlacementKey(previous.resizeSequence ?? previous.sequence) === nextKey && (payload.placementMoveWithoutClear || sameGraphicRect(previous, {
+			x: payload.x,
+			y: payload.y,
+			w: payload.w ?? previous.w,
+			h: payload.h ?? previous.h
+		}));
+	}
+	function queueTerminalGraphicClear(id) {
+		if (disposed) return false;
+		const removedPendingDraw = pendingGraphics.delete(`${id}:draw`);
+		pendingGraphicSignatures.delete(id);
+		terminalResizeDirtyGraphics.delete(id);
+		const active = activeGraphics.get(id);
+		if (!active) {
+			retainedGraphics.delete(id);
+			return removedPendingDraw;
+		}
+		if (active.clearSequence) {
+			const payload = {
+				id,
+				x: active.x,
+				y: active.y,
+				w: active.w,
+				h: active.h,
+				protocol: active.protocol,
+				sequence: active.clearSequence,
+				op: "clear",
+				order: nextGraphicsOrder++
+			};
+			if (validateTerminalGraphicsPayload(payload, graphicsCapabilities)) {
+				pendingGraphics.set(`${id}:clear`, payload);
+				recordTerminalGraphicTrace({
+					type: "clear",
+					id,
+					protocol: payload.protocol
+				});
+				requestTerminalGraphicsFlush();
+				return true;
+			}
+		}
+		pendingGraphicClears.add(id);
+		recordTerminalGraphicTrace({
+			type: "clear",
+			id
+		});
+		requestTerminalGraphicsFlush();
+		return true;
+	}
+	function queueTerminalGraphicsForResizeRedraw(size) {
+		if (isDebugEnabled()) getDebugLog().render(`graphics resize redraw queue: size=${size.cols}x${size.rows}, activeGraphics=${activeGraphics.size}, pendingGraphics=${pendingGraphics.size}, pendingClears=${pendingGraphicClears.size}`);
+		for (const [id, active] of activeGraphics) {
+			terminalResizeDirtyGraphics.add(id);
+			pendingGraphics.delete(`${id}:draw`);
+			const anchored = anchoredGraphicRectInViewport(active, size);
+			if (anchored && !active.resizeSequence) {
+				if (isDebugEnabled()) getDebugLog().render(`terminal graphic resize active: id=${id}, x=${active.x}, y=${active.y}, w=${active.w}, h=${active.h}, viewport=${size.cols}x${size.rows}, anchored=true, skipped=no-resize-sequence`);
+				continue;
+			}
+			const signature = activeGraphicSignatures.get(id);
+			const sequence = active.resizeSequence ?? active.sequence;
+			pendingGraphics.set(`${id}:draw`, {
+				id,
+				x: active.x,
+				y: active.y,
+				w: active.w,
+				h: active.h,
+				protocol: active.protocol,
+				sequence,
+				resizeSequence: active.resizeSequence,
+				clearSequence: active.clearSequence,
+				op: "draw",
+				order: nextGraphicsOrder++,
+				resizeRedraw: true,
+				terminalResizeRedraw: true
+			});
+			if (signature) pendingGraphicSignatures.set(id, signature);
+			if (isDebugEnabled()) getDebugLog().render(`terminal graphic resize active: id=${id}, x=${active.x}, y=${active.y}, w=${active.w}, h=${active.h}, viewport=${size.cols}x${size.rows}, anchored=${anchored ? "true" : "false"}, bytes=${sequence.length}`);
+		}
+		for (const [id, retained] of retainedGraphics) {
+			if (activeGraphics.has(id) || !retained.autoRedrawOnResize) continue;
+			const { active, signature } = retained;
+			if (!anchoredGraphicRectInViewport(active, size)) continue;
+			retainedGraphics.delete(id);
+			activeGraphics.set(id, active);
+			activeGraphicSignatures.set(id, signature);
+			pendingGraphicClears.delete(id);
+			pendingGraphics.delete(`${id}:clear`);
+			pendingGraphics.set(`${id}:draw`, {
+				id,
+				x: active.x,
+				y: active.y,
+				w: active.w,
+				h: active.h,
+				protocol: active.protocol,
+				sequence: active.resizeSequence ?? active.sequence,
+				resizeSequence: active.resizeSequence,
+				clearSequence: active.clearSequence,
+				op: "draw",
+				order: nextGraphicsOrder++,
+				resizeRedraw: true,
+				terminalResizeRedraw: true
+			});
+			pendingGraphicSignatures.set(id, signature);
+			if (isDebugEnabled()) getDebugLog().render(`terminal graphic retained resize redraw: id=${id}, x=${active.x}, y=${active.y}, w=${active.w}, h=${active.h}, bytes=${(active.resizeSequence ?? active.sequence).length}`);
+		}
+	}
+	const graphicsOutput = {
+		capabilities: graphicsCapabilities,
+		isActive(id) {
+			if (pendingGraphicClears.has(id) || pendingGraphics.has(`${id}:clear`)) return false;
+			return activeGraphics.has(id) || retainedGraphics.has(id) || pendingGraphics.has(`${id}:draw`);
+		},
+		queue(payload) {
+			if (disposed) return false;
+			const x = Math.floor(payload.x);
+			const y = Math.floor(payload.y);
+			const op = payload.op ?? "draw";
+			const normalized = {
+				...payload,
+				x,
+				y,
+				w: payload.w == null ? void 0 : Math.floor(payload.w),
+				h: payload.h == null ? void 0 : Math.floor(payload.h),
+				op,
+				order: nextGraphicsOrder++
+			};
+			if (!normalized.id.trim()) return false;
+			if (!Number.isFinite(normalized.x) || !Number.isFinite(normalized.y)) return false;
+			if (!canUseTerminalGraphicsProtocol(normalized.protocol, graphicsCapabilities)) return false;
+			if (op === "draw") {
+				const frame = validateTerminalGraphicFrame({
+					id: normalized.id,
+					protocol: normalized.protocol,
+					sequence: normalized.sequence,
+					fallbackText: normalized.fallbackText,
+					width: normalized.w ?? 1,
+					height: normalized.h ?? 1
+				});
+				if (!frame) return false;
+				if (isDebugEnabled()) {
+					const size = terminal.size();
+					getDebugLog().render(`terminal graphic queue draw request: id=${frame.id}, x=${normalized.x}, y=${normalized.y}, w=${frame.width}, h=${frame.height}, viewport=${size.cols}x${size.rows}`);
+				}
+				if (!anchoredGraphicRectInViewport({
+					x: normalized.x,
+					y: normalized.y,
+					w: frame.width,
+					h: frame.height
+				}, terminal.size())) {
+					if (isDebugEnabled()) {
+						const size = terminal.size();
+						getDebugLog().render(`terminal graphic queue draw rejected offscreen: id=${frame.id}, x=${normalized.x}, y=${normalized.y}, w=${frame.width}, h=${frame.height}, viewport=${size.cols}x${size.rows}`);
+					}
+					queueTerminalGraphicClear(frame.id);
+					return false;
+				}
+				const clearSequence = normalized.clearSequence && isSafeTerminalGraphicsSequence(normalized.clearSequence, normalized.protocol, "clear") ? normalized.clearSequence : void 0;
+				const resizeSequence = normalized.resizeSequence && isSafeTerminalGraphicsSequence(normalized.resizeSequence, normalized.protocol, "draw") ? normalized.resizeSequence : void 0;
+				const signature = terminalGraphicsPayloadSignature({
+					...normalized,
+					id: frame.id,
+					w: frame.width,
+					h: frame.height,
+					sequence: frame.sequence,
+					resizeSequence,
+					clearSequence
+				});
+				const forceTerminalResizeRedraw = terminalResizeDirtyGraphics.has(frame.id);
+				const removedPendingGraphicClear = pendingGraphics.delete(`${frame.id}:clear`);
+				const removedPendingClear = pendingGraphicClears.delete(frame.id);
+				const canceledPendingClear = removedPendingGraphicClear || removedPendingClear;
+				if (!forceTerminalResizeRedraw && !normalized.forceDraw && !canceledPendingClear && (pendingGraphicSignatures.get(frame.id) === signature || activeGraphicSignatures.get(frame.id) === signature)) {
+					recordTerminalGraphicTrace({
+						type: "queue-dedupe",
+						id: frame.id,
+						protocol: normalized.protocol
+					});
+					if (isDebugEnabled()) getDebugLog().render(`terminal graphic queue draw dedupe: id=${frame.id}, x=${normalized.x}, y=${normalized.y}, w=${frame.width}, h=${frame.height}`);
+					return true;
+				}
+				if (!forceTerminalResizeRedraw && !normalized.forceDraw && canceledPendingClear && activeGraphicSignatures.get(frame.id) === signature) {
+					recordTerminalGraphicTrace({
+						type: "queue-dedupe",
+						id: frame.id,
+						protocol: normalized.protocol
+					});
+					if (isDebugEnabled()) getDebugLog().render(`terminal graphic queue draw canceled clear: id=${frame.id}, x=${normalized.x}, y=${normalized.y}, w=${frame.width}, h=${frame.height}`);
+					return true;
+				}
+				const retained = retainedGraphics.get(frame.id);
+				const retainedCanReplacePlacement = retained && resizeSequence && canReplaceKittyPlacementWithoutClear(retained.active, {
+					...normalized,
+					id: frame.id,
+					w: frame.width,
+					h: frame.height,
+					sequence: resizeSequence,
+					resizeSequence,
+					clearSequence,
+					fallbackText: frame.fallbackText,
+					resizeRedraw: true,
+					placementMoveWithoutClear: true
+				});
+				if (!canceledPendingClear && retained && resizeSequence && (retained.signature === signature || retainedCanReplacePlacement)) {
+					activeGraphics.set(frame.id, retained.active);
+					activeGraphicSignatures.set(frame.id, retained.signature);
+					retainedGraphics.delete(frame.id);
+					pendingGraphics.set(`${frame.id}:draw`, {
+						...normalized,
+						id: frame.id,
+						w: frame.width,
+						h: frame.height,
+						sequence: resizeSequence,
+						resizeSequence,
+						clearSequence,
+						fallbackText: frame.fallbackText,
+						resizeRedraw: true,
+						placementMoveWithoutClear: true,
+						terminalResizeRedraw: forceTerminalResizeRedraw
+					});
+					pendingGraphicSignatures.set(frame.id, signature);
+					if (isDebugEnabled()) getDebugLog().render(`terminal graphic retained resize redraw: id=${frame.id}, x=${retained.active.x}, y=${retained.active.y}, w=${retained.active.w}, h=${retained.active.h}, bytes=${resizeSequence.length}`);
+					recordTerminalGraphicTrace({
+						type: "queue",
+						id: frame.id,
+						protocol: normalized.protocol,
+						bytes: resizeSequence.length
+					});
+					requestTerminalGraphicsFlush(Boolean(normalized.deferFlush));
+					return true;
+				}
+				retainedGraphics.delete(frame.id);
+				pendingGraphics.set(`${frame.id}:draw`, {
+					...normalized,
+					id: frame.id,
+					w: frame.width,
+					h: frame.height,
+					sequence: frame.sequence,
+					resizeSequence,
+					clearSequence,
+					fallbackText: frame.fallbackText,
+					terminalResizeRedraw: forceTerminalResizeRedraw
+				});
+				pendingGraphicSignatures.set(frame.id, signature);
+				if (isDebugEnabled()) getDebugLog().render(`terminal graphic queue draw accepted: id=${frame.id}, x=${normalized.x}, y=${normalized.y}, w=${frame.width}, h=${frame.height}, bytes=${frame.sequence.length}`);
+				recordTerminalGraphicTrace({
+					type: "queue",
+					id: frame.id,
+					protocol: normalized.protocol,
+					bytes: frame.sequence.length
+				});
+				requestTerminalGraphicsFlush(Boolean(normalized.deferFlush));
+				return true;
+			}
+			if (!validateTerminalGraphicsPayload(normalized, graphicsCapabilities)) return false;
+			pendingGraphics.delete(`${normalized.id}:draw`);
+			pendingGraphicSignatures.delete(normalized.id);
+			retainedGraphics.delete(normalized.id);
+			pendingGraphics.set(`${normalized.id}:clear`, {
+				...normalized,
+				w: normalized.w,
+				h: normalized.h
+			});
+			if (isDebugEnabled()) getDebugLog().render(`terminal graphic queue clear accepted: id=${normalized.id}, x=${normalized.x}, y=${normalized.y}, w=${normalized.w ?? 1}, h=${normalized.h ?? 1}`);
+			recordTerminalGraphicTrace({
+				type: "clear",
+				id: normalized.id,
+				protocol: normalized.protocol
+			});
+			requestTerminalGraphicsFlush(Boolean(normalized.deferFlush));
+			return true;
+		},
+		clear(id) {
+			return queueTerminalGraphicClear(id);
+		}
+	};
+	const unregisterGraphicsOutput = registerTerminalGraphicsOutput(terminal, graphicsOutput);
 	const MIN_FRAME_MS = outputIsTTY ? 16 : 0;
+	const ROWS_ONLY_RESIZE_REPAINT_DELAY_MS = 500;
 	function clampCellToViewport(cell, size) {
 		const maxX = Math.max(0, Math.floor(size.cols) - 1);
 		const maxY = Math.max(0, Math.floor(size.rows) - 1);
@@ -8604,6 +10426,92 @@ function createStdoutRenderer(terminal, options) {
 			y
 		};
 	}
+	function normalizeGraphicRect(rect) {
+		const x0 = Math.floor(rect.x);
+		const y0 = Math.floor(rect.y);
+		const w0 = Math.floor(rect.w);
+		const h0 = Math.floor(rect.h);
+		if (!Number.isFinite(x0) || !Number.isFinite(y0) || !Number.isFinite(w0) || !Number.isFinite(h0)) return null;
+		const size = normalizeTerminalGraphicSize(w0, h0);
+		if (!size) return null;
+		return {
+			x: x0,
+			y: y0,
+			w: size.width,
+			h: size.height
+		};
+	}
+	function clipGraphicRectToViewport(rect, size) {
+		const cols = Math.max(0, Math.floor(size.cols));
+		const rows = Math.max(0, Math.floor(size.rows));
+		if (cols <= 0 || rows <= 0) return null;
+		const normalized = normalizeGraphicRect(rect);
+		if (!normalized) return null;
+		const x0 = normalized.x;
+		const y0 = normalized.y;
+		const w0 = normalized.w;
+		const h0 = normalized.h;
+		const left = Math.max(0, x0);
+		const top = Math.max(0, y0);
+		const right = Math.min(cols, x0 + w0);
+		const bottom = Math.min(rows, y0 + h0);
+		if (right <= left || bottom <= top) return null;
+		return {
+			x: left,
+			y: top,
+			w: right - left,
+			h: bottom - top
+		};
+	}
+	function anchoredGraphicRectInViewport(rect, size) {
+		const cols = Math.max(0, Math.floor(size.cols));
+		const rows = Math.max(0, Math.floor(size.rows));
+		if (cols <= 0 || rows <= 0) return null;
+		const normalized = normalizeGraphicRect(rect);
+		if (!normalized) return null;
+		return normalized.x >= 0 && normalized.y >= 0 && normalized.x < cols && normalized.y < rows ? normalized : null;
+	}
+	function clearGraphicRect(rect) {
+		const blank = " ".repeat(Math.max(0, rect.w));
+		let out$1 = "";
+		for (let row = 0; row < rect.h; row++) out$1 += `\u001B[${rect.y + row + 1};${rect.x + 1}H${blank}`;
+		return out$1;
+	}
+	function sameGraphicRect(a, b) {
+		return Boolean(a && a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h);
+	}
+	function maybeWrapTerminalGraphic(sequence) {
+		return wrapTerminalGraphicsForMultiplexer(sequence, graphicsCapabilities);
+	}
+	function kittyClearTargetsCurrentCell(sequence) {
+		const prefix = "\x1B_G";
+		const terminator = "\x1B\\";
+		let index = 0;
+		while (index < sequence.length) {
+			if (!sequence.startsWith(prefix, index)) return false;
+			const end = sequence.indexOf(terminator, index + prefix.length);
+			if (end < 0) return false;
+			const body = sequence.slice(index + prefix.length, end);
+			const semicolon = body.indexOf(";");
+			const controlsText = semicolon < 0 ? body : body.slice(0, semicolon);
+			let action = "";
+			let deleteMode = "";
+			for (const part of controlsText.split(",")) {
+				const eq = part.indexOf("=");
+				if (eq <= 0) continue;
+				const key = part.slice(0, eq);
+				const value = part.slice(eq + 1);
+				if (key === "a") action = value;
+				else if (key === "d") deleteMode = value;
+			}
+			if (action === "d" && (deleteMode === "c" || deleteMode === "C")) return true;
+			index = end + terminator.length;
+		}
+		return false;
+	}
+	function clearSequenceNeedsVisibleCell(sequence, protocol) {
+		return protocol === "kitty" && kittyClearTargetsCurrentCell(sequence);
+	}
 	function resolveColorMode() {
 		const opt = (options === null || options === void 0 ? void 0 : options.colorMode) ?? "auto";
 		if (opt !== "auto") return opt;
@@ -8755,6 +10663,7 @@ function createStdoutRenderer(terminal, options) {
 	const MAX_CELL_TEXT_IDS = 131072;
 	let prevOverlayBlockedRows = [];
 	let prevOverlayPartialRows = [];
+	let prevOverlayVisibleSpans = new Map();
 	const hrefIndex = new Map();
 	let nextHrefId = 1;
 	const MAX_HREF_IDS = 8192;
@@ -8779,6 +10688,7 @@ function createStdoutRenderer(terminal, options) {
 		fpPrevValid = false;
 		prevOverlayBlockedRows = [];
 		prevOverlayPartialRows = [];
+		prevOverlayVisibleSpans = new Map();
 	}
 	function cellFingerprintFromStyleKey(_ch, key) {
 		return key >>> 0;
@@ -9476,12 +11386,46 @@ function createStdoutRenderer(terminal, options) {
 		lastFrameTime = Date.now();
 		const renderStart = performance.now();
 		const size = terminal.size();
+		const rowsOnlyResizeBaseline = preserveNextRowsOnlyResizeBaseline && fpPrevValid && fpCols === size.cols ? {
+			cols: fpCols,
+			rows: fpRows,
+			fp: prevFP.slice(),
+			hrefIds: prevHrefIds.slice(),
+			textIds: prevTextIds.slice()
+		} : null;
+		preserveNextRowsOnlyResizeBaseline = false;
+		const pendingGraphicClearsToRender = new Set(pendingGraphicClears);
+		let graphicsClearsToRender = Array.from(pendingGraphicClearsToRender);
+		let graphicsEntriesToRender = Array.from(pendingGraphics.entries()).sort(([, a], [, b]) => {
+			const opA = a.op === "clear" ? 0 : 1;
+			const opB = b.op === "clear" ? 0 : 1;
+			return opA - opB || a.order - b.order;
+		});
+		let graphicsToRender = graphicsEntriesToRender.map(([, payload]) => payload);
+		const allowGraphicsOnlyWithoutBaseline = allowNextGraphicsOnlyRenderWithoutBaseline && (dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) === 0 && !(scrollOperations === null || scrollOperations === void 0 ? void 0 : scrollOperations.length) && (graphicsClearsToRender.length > 0 || graphicsToRender.length > 0);
+		allowNextGraphicsOnlyRenderWithoutBaseline = false;
+		if (isDebugEnabled()) getDebugLog().render(`doRender state: size=${size.cols}x${size.rows}, dirtyRows=${(dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) ?? "null"}, scrollOps=${(scrollOperations === null || scrollOperations === void 0 ? void 0 : scrollOperations.length) ?? 0}, rowsOnlyBaseline=${rowsOnlyResizeBaseline ? "true" : "false"}, allowGraphicsOnlyWithoutBaseline=${allowGraphicsOnlyWithoutBaseline ? "true" : "false"}, activeGraphics=${activeGraphics.size}, pendingGraphics=${graphicsToRender.length}, pendingGraphicClears=${graphicsClearsToRender.length}`);
+		let terminalGraphicsBlockScrollRegions = false;
 		ensureRowEscapes(Math.max(size.rows, lastRenderedRows));
 		ensureFingerprints(size.cols, size.rows);
 		const bgSeq = openBg(defaultBg);
 		const bgOnlyStyle = { bg: defaultBg };
 		const bgKey = styleKeyFromParts({ bg: defaultBg });
 		const blankFP = cellFingerprintFromStyleKey(" ", bgKey);
+		if (rowsOnlyResizeBaseline && rowsOnlyResizeBaseline.cols === size.cols) {
+			prevFP.fill(blankFP);
+			prevHrefIds.fill(0);
+			prevTextIds.fill(blankTextId);
+			const rowsToCopy = Math.min(size.rows, rowsOnlyResizeBaseline.rows);
+			for (let y = 0; y < rowsToCopy; y++) {
+				const start = y * size.cols;
+				const end = start + size.cols;
+				prevFP.set(rowsOnlyResizeBaseline.fp.subarray(start, end), start);
+				prevHrefIds.set(rowsOnlyResizeBaseline.hrefIds.subarray(start, end), start);
+				prevTextIds.set(rowsOnlyResizeBaseline.textIds.subarray(start, end), start);
+			}
+			fpPrevValid = true;
+		}
 		let dirtySorted = true;
 		const forceFullRender = hrefIndexResetRequiresBaseline || fingerprintInternResetRequiresBaseline;
 		if (forceFullRender) {
@@ -9507,7 +11451,171 @@ function createStdoutRenderer(terminal, options) {
 			if (!outOps.length) return null;
 			return outOps;
 		})();
+		const terminalGraphicsAffectedRows = new Set();
+		const terminalGraphicTextPreserveSpans = new Map();
+		const addTerminalGraphicRows = (rect) => {
+			if (!rect) return;
+			const visible = clipGraphicRectToViewport(rect, size);
+			if (!visible) return;
+			for (let y = visible.y; y < visible.y + visible.h; y++) terminalGraphicsAffectedRows.add(y);
+		};
+		const addTerminalGraphicTextPreserveSpans = (rect) => {
+			if (!rect) return;
+			const visible = clipGraphicRectToViewport(rect, size);
+			if (!visible) return;
+			const start = Math.max(0, Math.min(size.cols, visible.x));
+			const end = Math.max(start, Math.min(size.cols, visible.x + visible.w));
+			if (end <= start) return;
+			for (let y = visible.y; y < visible.y + visible.h; y++) {
+				const spans = terminalGraphicTextPreserveSpans.get(y);
+				if (spans) spans.push({
+					start,
+					end
+				});
+				else terminalGraphicTextPreserveSpans.set(y, [{
+					start,
+					end
+				}]);
+			}
+		};
+		const payloadRect = (payload) => ({
+			x: payload.x,
+			y: payload.y,
+			w: payload.w ?? 1,
+			h: payload.h ?? 1
+		});
+		const intersectsScrollOperations = (rect) => {
+			if (!rect || !(normalizedScrollOperations === null || normalizedScrollOperations === void 0 ? void 0 : normalizedScrollOperations.length)) return false;
+			const top = rect.y;
+			const bottom = rect.y + rect.h;
+			for (const op of normalizedScrollOperations) if (top < op.endY && bottom > op.startY) return true;
+			return false;
+		};
+		const graphicRectVisible = (rect) => Boolean(rect && clipGraphicRectToViewport(rect, size));
+		const pendingGraphicIds = new Set(graphicsToRender.map((payload) => payload.id));
+		const explicitGraphicClears = new Set(graphicsClearsToRender);
+		if ((normalizedScrollOperations === null || normalizedScrollOperations === void 0 ? void 0 : normalizedScrollOperations.length) && activeGraphics.size > 0) for (const [id, active] of activeGraphics) {
+			if (explicitGraphicClears.has(id) || pendingGraphicIds.has(id)) continue;
+			if (!intersectsScrollOperations(active)) continue;
+			const signature = activeGraphicSignatures.get(id);
+			graphicsToRender.push({
+				id,
+				x: active.x,
+				y: active.y,
+				w: active.w,
+				h: active.h,
+				protocol: active.protocol,
+				sequence: active.sequence,
+				resizeSequence: active.resizeSequence,
+				clearSequence: active.clearSequence,
+				op: "draw",
+				order: nextGraphicsOrder++
+			});
+			if (signature) pendingGraphicSignatures.set(id, signature);
+			pendingGraphicIds.add(id);
+		}
+		for (const [id, active] of activeGraphics) {
+			if (explicitGraphicClears.has(id)) continue;
+			if (pendingGraphicIds.has(id)) continue;
+			if (intersectsScrollOperations(active)) continue;
+			addTerminalGraphicTextPreserveSpans(active);
+		}
+		if ((normalizedScrollOperations === null || normalizedScrollOperations === void 0 ? void 0 : normalizedScrollOperations.length) && activeGraphics.size > 0) for (const active of activeGraphics.values()) {
+			if (!intersectsScrollOperations(active)) continue;
+			terminalGraphicsBlockScrollRegions = true;
+			addTerminalGraphicRows(active);
+		}
+		for (const id of graphicsClearsToRender) {
+			const active = activeGraphics.get(id);
+			addTerminalGraphicRows(active);
+			if (intersectsScrollOperations(active)) terminalGraphicsBlockScrollRegions = true;
+		}
+		for (const payload of graphicsToRender) {
+			const active = activeGraphics.get(payload.id);
+			if (payload.op === "clear") {
+				const rect = active ?? payloadRect(payload);
+				addTerminalGraphicRows(rect);
+				if (intersectsScrollOperations(rect)) terminalGraphicsBlockScrollRegions = true;
+				continue;
+			}
+			const next = payloadRect(payload);
+			if (!payload.allowTextOverlay) addTerminalGraphicTextPreserveSpans(next);
+			addTerminalGraphicRows(active);
+			addTerminalGraphicRows(next);
+			if (intersectsScrollOperations(active) || intersectsScrollOperations(next)) terminalGraphicsBlockScrollRegions = true;
+		}
+		if (!terminalGraphicsBlockScrollRegions && (Array.from(activeGraphics.values()).some(graphicRectVisible) || graphicsClearsToRender.some((id) => graphicRectVisible(activeGraphics.get(id))) || graphicsToRender.some((payload) => payload.op === "clear" ? graphicRectVisible(activeGraphics.get(payload.id) ?? payloadRect(payload)) : graphicRectVisible(anchoredGraphicRectInViewport({
+			x: payload.x,
+			y: payload.y,
+			w: payload.w ?? 1,
+			h: payload.h ?? 1
+		}, size))))) terminalGraphicsBlockScrollRegions = true;
+		let forceDirtyRowsRepaintForFrame = forceDirtyRowsRepaint;
+		const forceTerminalGraphicsRowRepaint = (y) => forceDirtyRowsRepaintForFrame || terminalGraphicsAffectedRows.has(y) || terminalGraphicTextPreserveSpans.has(y);
+		for (const [y, spans] of terminalGraphicTextPreserveSpans) {
+			spans.sort((a, b) => a.start - b.start || a.end - b.end);
+			const merged = [];
+			for (const span of spans) {
+				const previous = merged[merged.length - 1];
+				if (previous && span.start <= previous.end) previous.end = Math.max(previous.end, span.end);
+				else merged.push({ ...span });
+			}
+			terminalGraphicTextPreserveSpans.set(y, merged);
+		}
+		const mergeSpans = (spans) => {
+			if (!spans.length) return [];
+			const sorted = [...spans].sort((a, b) => a.start - b.start || a.end - b.end);
+			const merged = [];
+			for (const span of sorted) {
+				const start = Math.max(0, Math.min(size.cols, span.start));
+				const end = Math.max(start, Math.min(size.cols, span.end));
+				if (end <= start) continue;
+				const previous = merged[merged.length - 1];
+				if (previous && start <= previous.end) previous.end = Math.max(previous.end, end);
+				else merged.push({
+					start,
+					end
+				});
+			}
+			return merged;
+		};
+		const overlayVisibleSpansForRows = (rows) => {
+			const overlay = getPlaneTerminal(terminal, "overlay");
+			const result = new Map();
+			for (const y of rows) {
+				if (y < 0 || y >= size.rows) continue;
+				const row = overlay.getRow(y);
+				const spans = [];
+				let start = null;
+				let end = 0;
+				for (let x = 0; x < size.cols; x++) {
+					const cell = row[x];
+					const visible = cell != null && !cell.continuation && (cell.ch !== " " || styleKey(cell.style) !== bgKey || renderedHref(cell.style.href) != null);
+					if (visible) {
+						if (start == null) start = x;
+						end = Math.max(end, Math.min(size.cols, x + Math.max(1, cell.width ?? 1)));
+						continue;
+					}
+					if (start != null && x >= end) {
+						spans.push({
+							start,
+							end
+						});
+						start = null;
+					}
+				}
+				if (start != null) spans.push({
+					start,
+					end: Math.max(end, start + 1)
+				});
+				if (spans.length) result.set(y, mergeSpans(spans));
+			}
+			return result;
+		};
+		const overlayCoverage = overlayPlaneCoverageRows(size.rows);
+		const overlayVisibleSpans = overlayVisibleSpansForRows(overlayCoverage.blockedRows);
 		let rowsToRender = (() => {
+			if (allowGraphicsOnlyWithoutBaseline) return [];
 			if (forceFullRender || !fpPrevValid) return null;
 			if (!dirtyRows) return null;
 			if (dirtyRows.length === 0) return [];
@@ -9529,7 +11637,7 @@ function createStdoutRenderer(terminal, options) {
 			if (!sorted) outRows.sort((a, b) => a - b);
 			return outRows;
 		})();
-		if ((rowsToRender === null || rowsToRender === void 0 ? void 0 : rowsToRender.length) === 0 && !normalizedScrollOperations && !getImeAnchor) {
+		if ((rowsToRender === null || rowsToRender === void 0 ? void 0 : rowsToRender.length) === 0 && !normalizedScrollOperations && !getImeAnchor && graphicsClearsToRender.length === 0 && graphicsToRender.length === 0) {
 			if (isDebugEnabled()) getDebugLog().render(" No valid dirty rows; frame skipped");
 			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutNoOutput();
 			return;
@@ -9548,10 +11656,13 @@ function createStdoutRenderer(terminal, options) {
 			currentHrefIds.set(prevHrefIds);
 			currentTextIds.set(prevTextIds);
 		}
+		const frameHasTerminalGraphics = activeGraphics.size > 0 || graphicsClearsToRender.length > 0 || graphicsToRender.length > 0;
+		const useFrameSyncOutput = useSyncOutput || isGhostty && frameHasTerminalGraphics;
 		const frameParts = [];
-		frameParts.push(!isGhostty && useSyncOutput ? SYNC_START : "");
-		frameParts.push("\x1B[?7l");
+		frameParts.push(useFrameSyncOutput ? SYNC_START : "");
+		frameParts.push(allowGraphicsOnlyWithoutBaseline || keepLineWrapDisabled ? "" : "\x1B[?7l");
 		frameParts.push(SGR_RESET, bgSeq);
+		if (hideCursor && !getImeAnchor) frameParts.push(CURSOR_HOME);
 		let lastRenderedY = -1;
 		let lastRenderWasFullRow = false;
 		let hasFrameOutput = false;
@@ -9566,6 +11677,7 @@ function createStdoutRenderer(terminal, options) {
 			inverse: false,
 			href: null
 		};
+		let overlayTouchedRowSet = null;
 		const closeActiveHrefBeforeCursorMove = () => {
 			if (!enableOsc8Links || !activeStyle.href) return;
 			frameParts.push(OSC8_CLOSE);
@@ -9668,6 +11780,65 @@ function createStdoutRenderer(terminal, options) {
 			lastRenderedY = y;
 			lastRenderWasFullRow = spanStart === 0 && (spanEnd >= size.cols || shouldClearToEol);
 		};
+		const overlayBypassSpansForRow = (y) => {
+			const current = overlayVisibleSpans.get(y) ?? [];
+			const previous = prevOverlayVisibleSpans.get(y) ?? [];
+			return current.length || previous.length ? mergeSpans([...current, ...previous]) : [];
+		};
+		const subtractSpans = (spans, bypass) => {
+			if (!bypass.length) return [...spans];
+			const result = [];
+			for (const span of spans) {
+				let cursor = span.start;
+				for (const cut of bypass) {
+					if (cut.end <= cursor) continue;
+					if (cut.start >= span.end) break;
+					if (cursor < cut.start) result.push({
+						start: cursor,
+						end: Math.min(cut.start, span.end)
+					});
+					cursor = Math.max(cursor, cut.end);
+					if (cursor >= span.end) break;
+				}
+				if (cursor < span.end) result.push({
+					start: cursor,
+					end: span.end
+				});
+			}
+			return result;
+		};
+		const preserveFingerprintSpans = (y, spans) => {
+			if (!fpPrevValid || y < 0 || y >= fpRows || currentFP.length !== prevFP.length) return;
+			const base = y * fpCols;
+			for (const span of spans) {
+				const start = Math.max(0, Math.min(fpCols, span.start));
+				const end = Math.max(start, Math.min(fpCols, span.end));
+				for (let x = start; x < end; x++) {
+					currentFP[base + x] = prevFP[base + x];
+					currentHrefIds[base + x] = prevHrefIds[base + x];
+					currentTextIds[base + x] = prevTextIds[base + x];
+				}
+			}
+		};
+		const renderRowPreservingTerminalGraphics = (y, row) => {
+			const spans = terminalGraphicTextPreserveSpans.get(y);
+			if (!(spans === null || spans === void 0 ? void 0 : spans.length)) {
+				renderRow(y, row);
+				return;
+			}
+			const effectiveSpans = subtractSpans(spans, overlayBypassSpansForRow(y));
+			if (!effectiveSpans.length) {
+				renderRow(y, row);
+				return;
+			}
+			let cursor = 0;
+			for (const span of effectiveSpans) {
+				if (cursor < span.start) renderRow(y, row, cursor, span.start, false);
+				cursor = Math.max(cursor, span.end);
+			}
+			if (cursor < size.cols) renderRow(y, row, cursor, size.cols, false);
+			preserveFingerprintSpans(y, effectiveSpans);
+		};
 		const lastRenderableColumnInCurrentRow = (rowY, cols, blankFingerprint) => {
 			if (!fpCols || rowY < 0 || rowY >= fpRows) return -1;
 			const base = rowY * fpCols;
@@ -9732,16 +11903,15 @@ function createStdoutRenderer(terminal, options) {
 			} 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);
 		const overlayRowSet = overlayRows.length ? new Set(overlayRows) : null;
 		const overlayPartialRows = Array.from(new Set([...overlayCoverage.partialRows, ...prevOverlayPartialRows])).sort((a, b) => a - b);
 		const overlayPartialRowSet = overlayPartialRows.length ? new Set(overlayPartialRows) : null;
-		const overlayTouchedRowSet = (() => {
+		overlayTouchedRowSet = (() => {
 			if (!overlayRowSet && !overlayPartialRowSet) return null;
 			return new Set([...overlayRowSet ? Array.from(overlayRowSet) : [], ...overlayPartialRowSet ? Array.from(overlayPartialRowSet) : []]);
 		})();
-		let explicitScrollOperations = normalizedScrollOperations;
+		let explicitScrollOperations = terminalGraphicsBlockScrollRegions ? null : normalizedScrollOperations;
 		let hiddenExplicitDirtyRows = null;
 		let allowInferredScrollRegions = true;
 		if (explicitScrollOperations && overlayRows.length) {
@@ -9756,6 +11926,7 @@ function createStdoutRenderer(terminal, options) {
 				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;
+				forceDirtyRowsRepaintForFrame = 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");
@@ -9770,10 +11941,18 @@ function createStdoutRenderer(terminal, options) {
 				expandedRows.add(y);
 			}
 		};
+		if (terminalGraphicsBlockScrollRegions && normalizedScrollOperations && rowsToRender) {
+			includeRowsForPendingScrollOperations(normalizedScrollOperations);
+			rowsToRender = Array.from(expandedRows).sort((a, b) => a - b);
+			dirtySorted = true;
+			forceDirtyRowsRepaintForFrame = true;
+			if (isDebugEnabled()) getDebugLog().render(" Scroll regions disabled for frame with active/pending terminal graphics");
+		}
 		if (explicitScrollOperations && rowsToRender && (!enableScrollRegions || !fpPrevValid)) {
 			includeRowsForPendingScrollOperations(explicitScrollOperations);
 			rowsToRender = Array.from(expandedRows).sort((a, b) => a - b);
 			dirtySorted = true;
+			forceDirtyRowsRepaintForFrame = 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");
@@ -9781,7 +11960,7 @@ function createStdoutRenderer(terminal, options) {
 		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 && !forceDirtyRowsRepaint && allowInferredScrollRegions;
+		const useScrollRegions = !terminalGraphicsBlockScrollRegions && enableScrollRegions && fpPrevValid && scrollRowsCandidate && scrollRowsCandidate.length >= 3 && !forceDirtyRowsRepaint && allowInferredScrollRegions;
 		let scrollHandled = false;
 		if (enableScrollRegions && explicitScrollOperations && scrollRowsCandidate && fpPrevValid) {
 			if (currentFP.length === prevFP.length) {
@@ -9856,9 +12035,9 @@ function createStdoutRenderer(terminal, options) {
 			for (const y of explicitDirtyRows) {
 				const row = terminal.getRow(y);
 				const overlayRow = overlayTouchedRowSet === null || overlayTouchedRowSet === void 0 ? void 0 : overlayTouchedRowSet.has(y);
-				if (forceDirtyRowsRepaint || !shouldUseDirtySpans() || overlayRow) {
+				if (forceTerminalGraphicsRowRepaint(y) || !shouldUseDirtySpans() || overlayRow) {
 					fingerprintRow(row, y, size.cols);
-					renderRow(y, row);
+					renderRowPreservingTerminalGraphics(y, row);
 					paintedExplicitRows.push(y);
 					continue;
 				}
@@ -9935,12 +12114,12 @@ function createStdoutRenderer(terminal, options) {
 				for (let y = shift.newRowStart; y < shift.newRowEnd; y++) {
 					const row = terminal.getRow(y);
 					fingerprintRow(row, y, size.cols);
-					renderRow(y, row);
+					renderRowPreservingTerminalGraphics(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);
-					if (shouldUseDirtySpans()) {
+					if (!forceTerminalGraphicsRowRepaint(y) && shouldUseDirtySpans()) {
 						const spans = resolveChangedSpansAgainstReference(row, y, size.cols, currentFP, currentHrefIds, currentTextIds);
 						if (!spans.length) {
 							fingerprintRow(row, y, size.cols);
@@ -9952,7 +12131,7 @@ function createStdoutRenderer(terminal, options) {
 						continue;
 					}
 					fingerprintRow(row, y, size.cols);
-					renderRow(y, row);
+					renderRowPreservingTerminalGraphics(y, row);
 				}
 				for (let y = shift.newRowStart; y < shift.newRowEnd; y++) fingerprintRow(terminal.getRow(y), y, size.cols);
 				const renderedRows = new Set();
@@ -9972,7 +12151,7 @@ function createStdoutRenderer(terminal, options) {
 			for (let y = 0; y < size.rows; y++) {
 				const row = terminal.getRow(y);
 				fingerprintRow(row, y, size.cols);
-				renderRow(y, row);
+				renderRowPreservingTerminalGraphics(y, row);
 			}
 		} else {
 			const overlayDirtyRows = overlayTouchedRowSet ? rowsToRender.filter((y) => overlayTouchedRowSet.has(y)) : [];
@@ -9980,8 +12159,8 @@ function createStdoutRenderer(terminal, options) {
 			for (const y of rowsToRender) {
 				const row = terminal.getRow(y);
 				fingerprintRow(row, y, size.cols);
-				if (forceDirtyRowsRepaint || !shouldUseDirtySpans()) {
-					renderRow(y, row);
+				if (forceTerminalGraphicsRowRepaint(y) || !shouldUseDirtySpans()) {
+					renderRowPreservingTerminalGraphics(y, row);
 					continue;
 				}
 				const spans = resolveChangedSpans(row, y, size.cols, (dirtyRowSnapshots === null || dirtyRowSnapshots === void 0 ? void 0 : dirtyRowSnapshots.get(y)) ?? null);
@@ -9990,7 +12169,7 @@ function createStdoutRenderer(terminal, options) {
 				renderDirtySpans(y, row, spans, rewriteTail);
 			}
 		}
-		if (!rowsToRender && lastRenderedRows > size.rows) {
+		if (!rowsToRender && lastRenderedRows > size.rows && !rowsOnlyResizeBaseline) {
 			const extraRows = lastRenderedRows - size.rows;
 			if (activeStyleKey !== bgKey) {
 				frameParts.push(SGR_RESET, bgSeq);
@@ -10001,7 +12180,8 @@ function createStdoutRenderer(terminal, options) {
 				frameParts.push(rowClearToEol[size.rows + i]);
 			}
 		}
-		const nextLastRenderedRows = !rowsToRender ? size.rows : lastRenderedRows;
+		const nextLastRenderedRows = !rowsToRender || rowsToRender.length === 0 ? size.rows : lastRenderedRows;
+		const graphicsOnlyFrame = Boolean(rowsToRender && rowsToRender.length === 0) && !scrollHandled && (graphicsClearsToRender.length > 0 || graphicsToRender.length > 0);
 		const commitRenderBaseline = () => {
 			lastRenderedRows = nextLastRenderedRows;
 			const tmpFP = prevFP;
@@ -10013,10 +12193,258 @@ function createStdoutRenderer(terminal, options) {
 			const tmpTextIds = prevTextIds;
 			prevTextIds = currentTextIds;
 			currentTextIds = tmpTextIds;
-			fpPrevValid = !hrefIndexResetRequiresBaseline && !fingerprintInternResetRequiresBaseline;
+			fpPrevValid = graphicsOnlyFrame ? fpPrevValid : !hrefIndexResetRequiresBaseline && !fingerprintInternResetRequiresBaseline;
 			prevOverlayBlockedRows = overlayCoverage.blockedRows;
 			prevOverlayPartialRows = overlayCoverage.partialRows;
+			prevOverlayVisibleSpans = overlayVisibleSpans;
+		};
+		if (graphicsOnlyFrame && fpPrevValid && currentFP.length === prevFP.length) {
+			currentFP.set(prevFP);
+			currentHrefIds.set(prevHrefIds);
+			currentTextIds.set(prevTextIds);
+		}
+		let renderedRowsLookup;
+		const rowWasPaintedByTextRenderer = (y) => {
+			if (scrollHandled) return true;
+			if (!rowsToRender) return true;
+			renderedRowsLookup ??= new Set(rowsToRender);
+			return renderedRowsLookup.has(y);
 		};
+		const clearGraphicRectForRowsNotPainted = (rect) => {
+			if (scrollHandled) return "";
+			const erase = `\u001B[${Math.max(0, rect.w)}X`;
+			const clearStyle = bgSeq;
+			let out$1 = "";
+			for (let row = 0; row < rect.h; row++) {
+				const y = rect.y + row;
+				const spans = terminalGraphicTextPreserveSpans.get(y);
+				const preservedGraphicSpan = !(overlayTouchedRowSet === null || overlayTouchedRowSet === void 0 ? void 0 : overlayTouchedRowSet.has(y)) && Boolean(spans === null || spans === void 0 ? void 0 : spans.some((span) => span.start < rect.x + rect.w && span.end > rect.x));
+				if ((!rowsToRender || rowWasPaintedByTextRenderer(y)) && !preservedGraphicSpan) continue;
+				out$1 += `\u001B[${y + 1};${rect.x + 1}H${clearStyle}${erase}${SGR_RESET}`;
+			}
+			return out$1;
+		};
+		const clearGraphicRowBackgroundForRowsNotPainted = (rect) => {
+			if (scrollHandled) return "";
+			const clearStyle = bgSeq;
+			let out$1 = "";
+			const leftW = Math.max(0, Math.min(size.cols, rect.x));
+			const rightX = Math.max(0, Math.min(size.cols, rect.x + rect.w));
+			const rightW = Math.max(0, size.cols - rightX);
+			if (leftW <= 0 && rightW <= 0) return "";
+			for (let row = 0; row < rect.h; row++) {
+				const y = rect.y + row;
+				if (!rowsToRender || rowWasPaintedByTextRenderer(y)) continue;
+				if (leftW > 0) out$1 += `\u001B[${y + 1};1H${clearStyle}\u001B[${leftW}X${SGR_RESET}`;
+				if (rightW > 0) out$1 += `\u001B[${y + 1};${rightX + 1}H${clearStyle}\u001B[${rightW}X${SGR_RESET}`;
+			}
+			return out$1;
+		};
+		let commitTerminalGraphicsState = null;
+		let restoreTerminalGraphicsAfterWriteFailure = null;
+		let terminalGraphicsMetrics = null;
+		const mergeGraphicsQueuedDuringPaint = () => {
+			const seenEntries = new Set(graphicsEntriesToRender.map(([key]) => key));
+			let changed = false;
+			for (const entry of pendingGraphics.entries()) {
+				if (seenEntries.has(entry[0])) continue;
+				graphicsEntriesToRender.push(entry);
+				changed = true;
+			}
+			for (const id of pendingGraphicClears) {
+				if (pendingGraphicClearsToRender.has(id)) continue;
+				pendingGraphicClearsToRender.add(id);
+				graphicsClearsToRender.push(id);
+			}
+			if (!changed) return;
+			graphicsEntriesToRender = graphicsEntriesToRender.sort(([, a], [, b]) => {
+				const opA = a.op === "clear" ? 0 : 1;
+				const opB = b.op === "clear" ? 0 : 1;
+				return opA - opB || a.order - b.order;
+			});
+			graphicsToRender = graphicsEntriesToRender.map(([, payload]) => payload);
+		};
+		mergeGraphicsQueuedDuringPaint();
+		if (graphicsClearsToRender.length > 0 || graphicsToRender.length > 0) {
+			const nextActiveGraphics = new Map(activeGraphics);
+			const nextActiveGraphicSignatures = new Map(activeGraphicSignatures);
+			const nextPendingGraphicSignatures = new Map(pendingGraphicSignatures);
+			let terminalGraphicsDraws = 0;
+			let terminalGraphicsClears = 0;
+			let terminalGraphicsBytes = 0;
+			const countGraphicsBytes = (value) => {
+				terminalGraphicsBytes += Buffer.byteLength(value, "utf8");
+				return value;
+			};
+			const appendTerminalGraphicSequenceAt = (sequence, rect, fallbackCell, skipWithoutRect = false) => {
+				if (!rect && skipWithoutRect) return false;
+				const cell = rect ? {
+					x: rect.x,
+					y: rect.y
+				} : clampCellToViewport(fallbackCell, size);
+				frameParts.push(countGraphicsBytes(`\u001B[${cell.y + 1};${cell.x + 1}H`), countGraphicsBytes(maybeWrapTerminalGraphic(sequence)), countGraphicsBytes(SGR_RESET));
+				return true;
+			};
+			const appendActiveGraphicProtocolClear = (active, rect) => {
+				if (!active.clearSequence) return false;
+				return appendTerminalGraphicSequenceAt(active.clearSequence, rect, {
+					cellX: active.x,
+					cellY: active.y
+				}, clearSequenceNeedsVisibleCell(active.clearSequence, active.protocol));
+			};
+			hasFrameOutput = true;
+			if (enableOsc8Links && activeStyle.href) frameParts.push(OSC8_CLOSE);
+			if (allowGraphicsOnlyWithoutBaseline) frameParts.push(CURSOR_SAVE);
+			activeStyle = {
+				fg: null,
+				bg: defaultBg,
+				bold: false,
+				dim: false,
+				italic: false,
+				underline: false,
+				inverse: false,
+				href: null
+			};
+			activeStyleKey = null;
+			frameParts.push(countGraphicsBytes(SGR_RESET));
+			for (const id of graphicsClearsToRender) {
+				const active = nextActiveGraphics.get(id);
+				if (!active) continue;
+				const visibleRect = clipGraphicRectToViewport(active, size);
+				if (isDebugEnabled()) getDebugLog().render(`terminal graphic render active clear: id=${id}, x=${active.x}, y=${active.y}, w=${active.w}, h=${active.h}, visible=${visibleRect ? `${visibleRect.x},${visibleRect.y},${visibleRect.w},${visibleRect.h}` : "none"}`);
+				let wroteClear = false;
+				if (visibleRect) {
+					const clearRect$1 = clearGraphicRectForRowsNotPainted(visibleRect);
+					if (clearRect$1) {
+						frameParts.push(countGraphicsBytes(clearRect$1));
+						wroteClear = true;
+					}
+				}
+				wroteClear = appendActiveGraphicProtocolClear(active, visibleRect) || wroteClear;
+				if (wroteClear) terminalGraphicsClears++;
+				retainedGraphics.delete(id);
+				terminalResizeDirtyGraphics.delete(id);
+				nextActiveGraphics.delete(id);
+				nextActiveGraphicSignatures.delete(id);
+				nextPendingGraphicSignatures.delete(id);
+			}
+			for (const payload of graphicsToRender) {
+				if (payload.op === "clear") {
+					const active = nextActiveGraphics.get(payload.id);
+					const rect$1 = clipGraphicRectToViewport({
+						x: (active === null || active === void 0 ? void 0 : active.x) ?? payload.x,
+						y: (active === null || active === void 0 ? void 0 : active.y) ?? payload.y,
+						w: (active === null || active === void 0 ? void 0 : active.w) ?? payload.w ?? 1,
+						h: (active === null || active === void 0 ? void 0 : active.h) ?? payload.h ?? 1
+					}, size);
+					if (isDebugEnabled()) getDebugLog().render(`terminal graphic render payload clear: id=${payload.id}, x=${(active === null || active === void 0 ? void 0 : active.x) ?? payload.x}, y=${(active === null || active === void 0 ? void 0 : active.y) ?? payload.y}, w=${(active === null || active === void 0 ? void 0 : active.w) ?? payload.w ?? 1}, h=${(active === null || active === void 0 ? void 0 : active.h) ?? payload.h ?? 1}, visible=${rect$1 ? `${rect$1.x},${rect$1.y},${rect$1.w},${rect$1.h}` : "none"}`);
+					const clearRect$2 = rect$1 ? clearGraphicRectForRowsNotPainted(rect$1) : "";
+					let wroteClear = false;
+					if (clearRect$2) {
+						frameParts.push(countGraphicsBytes(clearRect$2));
+						wroteClear = true;
+					}
+					wroteClear = appendTerminalGraphicSequenceAt(payload.sequence, rect$1, {
+						cellX: (active === null || active === void 0 ? void 0 : active.x) ?? payload.x,
+						cellY: (active === null || active === void 0 ? void 0 : active.y) ?? payload.y
+					}, clearSequenceNeedsVisibleCell(payload.sequence, payload.protocol)) || wroteClear;
+					if (wroteClear) terminalGraphicsClears++;
+					if (active && payload.retainOnClear) retainTerminalGraphic(payload.id, active, nextActiveGraphicSignatures.get(payload.id));
+					else retainedGraphics.delete(payload.id);
+					terminalResizeDirtyGraphics.delete(payload.id);
+					nextActiveGraphics.delete(payload.id);
+					nextActiveGraphicSignatures.delete(payload.id);
+					nextPendingGraphicSignatures.delete(payload.id);
+					continue;
+				}
+				const previous = nextActiveGraphics.get(payload.id);
+				const rect = anchoredGraphicRectInViewport({
+					x: payload.x,
+					y: payload.y,
+					w: payload.w ?? 1,
+					h: payload.h ?? 1
+				}, size);
+				if (!rect) {
+					if (previous) {
+						const visiblePrevious = clipGraphicRectToViewport(previous, size);
+						let wroteClear = false;
+						if (visiblePrevious) {
+							const clearPrevious = clearGraphicRectForRowsNotPainted(visiblePrevious);
+							if (clearPrevious) {
+								frameParts.push(countGraphicsBytes(clearPrevious));
+								wroteClear = true;
+							}
+						}
+						wroteClear = appendActiveGraphicProtocolClear(previous, visiblePrevious) || wroteClear;
+						if (wroteClear) terminalGraphicsClears++;
+						retainTerminalGraphic(payload.id, previous, nextActiveGraphicSignatures.get(payload.id), { autoRedrawOnResize: true });
+						nextActiveGraphics.delete(payload.id);
+						nextActiveGraphicSignatures.delete(payload.id);
+					}
+					terminalResizeDirtyGraphics.delete(payload.id);
+					nextPendingGraphicSignatures.delete(payload.id);
+					continue;
+				}
+				const previousSignature = previous ? nextActiveGraphicSignatures.get(payload.id) : void 0;
+				const nextSignature = nextPendingGraphicSignatures.get(payload.id) ?? terminalGraphicsPayloadSignature(payload);
+				const canReplacePlacement = previous != null && payload.resizeRedraw && canReplaceKittyPlacementWithoutClear(previous, payload);
+				const resizeRedrawNeedsClear = previous && (payload.resizeRedraw || payload.terminalResizeRedraw) && Boolean(previous.clearSequence) && !canReplacePlacement;
+				if (previous && (!canReplacePlacement && (previousSignature !== nextSignature || !sameGraphicRect(previous, rect)) || resizeRedrawNeedsClear)) {
+					const visiblePrevious = clipGraphicRectToViewport(previous, size);
+					let wroteClear = false;
+					if (visiblePrevious) {
+						const clearPrevious = clearGraphicRectForRowsNotPainted(visiblePrevious);
+						if (clearPrevious) {
+							frameParts.push(countGraphicsBytes(clearPrevious));
+							wroteClear = true;
+						}
+					}
+					wroteClear = appendActiveGraphicProtocolClear(previous, visiblePrevious) || wroteClear;
+					if (wroteClear) terminalGraphicsClears++;
+				}
+				const visibleRect = clipGraphicRectToViewport(rect, size);
+				if (isDebugEnabled()) getDebugLog().render(`terminal graphic render draw: id=${payload.id}, x=${rect.x}, y=${rect.y}, w=${rect.w}, h=${rect.h}, visible=${visibleRect ? `${visibleRect.x},${visibleRect.y},${visibleRect.w},${visibleRect.h}` : "none"}, resizeRedraw=${payload.resizeRedraw || payload.terminalResizeRedraw ? "true" : "false"}, previous=${previous ? `${previous.x},${previous.y},${previous.w},${previous.h}` : "none"}`);
+				const clearRect$1 = visibleRect ? clearGraphicRectForRowsNotPainted(visibleRect) : "";
+				const clearRowBackground = visibleRect ? clearGraphicRowBackgroundForRowsNotPainted(visibleRect) : "";
+				const cursor = `\u001B[${rect.y + 1};${rect.x + 1}H`;
+				const sequencePayload = (canReplacePlacement || payload.terminalResizeRedraw) && payload.resizeSequence ? payload.resizeSequence : payload.sequence;
+				const sequence = maybeWrapTerminalGraphic(sequencePayload);
+				frameParts.push(countGraphicsBytes(cursor), countGraphicsBytes(sequence), countGraphicsBytes(SGR_RESET), clearRowBackground ? countGraphicsBytes(clearRowBackground) : "", clearRect$1 ? countGraphicsBytes(clearRect$1) : "");
+				terminalGraphicsDraws++;
+				nextActiveGraphics.set(payload.id, {
+					...rect,
+					protocol: payload.protocol,
+					sequence: payload.sequence,
+					resizeSequence: payload.resizeSequence ?? (previous === null || previous === void 0 ? void 0 : previous.resizeSequence),
+					clearSequence: payload.clearSequence
+				});
+				nextActiveGraphicSignatures.set(payload.id, nextSignature);
+				nextPendingGraphicSignatures.delete(payload.id);
+				terminalResizeDirtyGraphics.delete(payload.id);
+			}
+			if (allowGraphicsOnlyWithoutBaseline) frameParts.push(CURSOR_RESTORE);
+			restoreTerminalGraphicsAfterWriteFailure = () => {
+				for (const id of graphicsClearsToRender) pendingGraphicClears.add(id);
+				for (const [key, payload] of graphicsEntriesToRender) pendingGraphics.set(key, payload);
+			};
+			commitTerminalGraphicsState = () => {
+				for (const id of pendingGraphicClearsToRender) pendingGraphicClears.delete(id);
+				for (const [key, payload] of graphicsEntriesToRender) if (pendingGraphics.get(key) === payload) pendingGraphics.delete(key);
+				activeGraphics.clear();
+				for (const [id, active] of nextActiveGraphics) activeGraphics.set(id, active);
+				activeGraphicSignatures.clear();
+				for (const [id, signature] of nextActiveGraphicSignatures) activeGraphicSignatures.set(id, signature);
+				pendingGraphicSignatures.clear();
+				for (const [id, signature] of nextPendingGraphicSignatures) pendingGraphicSignatures.set(id, signature);
+			};
+			terminalGraphicsMetrics = {
+				draws: terminalGraphicsDraws,
+				clears: terminalGraphicsClears,
+				bytes: terminalGraphicsBytes,
+				active: nextActiveGraphics.size
+			};
+			if (isDebugEnabled()) getDebugLog().render(`terminal graphics frame: draws=${terminalGraphicsDraws}, clears=${terminalGraphicsClears}, bytes=${terminalGraphicsBytes}, activeNext=${nextActiveGraphics.size}`);
+		}
 		let emittedCursorPos = null;
 		if (getImeAnchor) {
 			const anchor = getImeAnchor();
@@ -10041,8 +12469,9 @@ function createStdoutRenderer(terminal, options) {
 		}
 		if (enableOsc8Links && activeStyle.href) frameParts.push(OSC8_CLOSE);
 		frameParts.push(SGR_RESET);
-		frameParts.push("\x1B[?7h");
-		frameParts.push(!isGhostty && useSyncOutput ? SYNC_END : "");
+		if (hideCursor && !getImeAnchor) frameParts.push(CURSOR_HOME);
+		frameParts.push(allowGraphicsOnlyWithoutBaseline || keepLineWrapDisabled ? "" : "\x1B[?7h");
+		frameParts.push(useFrameSyncOutput ? SYNC_END : "");
 		const frame = frameParts.join("");
 		const frameBytes = Buffer.byteLength(frame, "utf8");
 		if (profiler) profiler.recordRender({
@@ -10103,10 +12532,11 @@ function createStdoutRenderer(terminal, options) {
 			const resetCount = countResets(frame);
 			const buildTime = (performance.now() - renderStart).toFixed(2);
 			getDebugLog().render(` Frame built: ${frameSize} bytes, ${cursorSeqCount} cursor sequences, ${resetCount} resets, ${buildTime}ms`);
-			getDebugLog().render(` Terminal: ${isGhostty ? "GHOSTTY" : "other"}, useSyncOutput: ${useSyncOutput}`);
+			getDebugLog().render(` Terminal: ${isGhostty ? "GHOSTTY" : "other"}, useSyncOutput: ${useSyncOutput}, useFrameSyncOutput: ${useFrameSyncOutput}`);
 		}
 		const writeStart = performance.now();
 		const resolveWriteMode = (frameSizeBytes) => {
+			if (frameHasTerminalGraphics && frameSizeBytes <= syncMaxBytes) return canUseSyncStdout ? "sync" : "stream";
 			if (isGhostty) return "chunked";
 			const preferChunked = frameSizeBytes >= chunkThresholdBytes || writeEmaMs >= 24;
 			if (preferChunked) return "chunked";
@@ -10136,12 +12566,15 @@ function createStdoutRenderer(terminal, options) {
 				getDebugLog().render(` Write completed in ${writeTime}ms`);
 			}
 		} catch (writeError) {
+			restoreTerminalGraphicsAfterWriteFailure === null || restoreTerminalGraphicsAfterWriteFailure === void 0 || restoreTerminalGraphicsAfterWriteFailure();
 			if (isDebugEnabled()) getDebugLog().error(`Write ERROR:`, writeError);
 			try {
-				out.write(`\u001B[?7h${!isGhostty && useSyncOutput ? SYNC_END : ""}`);
+				out.write(`\u001B[?7h${useFrameSyncOutput ? SYNC_END : ""}`);
 			} catch {}
 			throw writeError;
 		}
+		commitTerminalGraphicsState === null || commitTerminalGraphicsState === void 0 || commitTerminalGraphicsState();
+		if (terminalGraphicsMetrics) recordStdoutTerminalGraphics(terminalGraphicsMetrics);
 		commitRenderBaseline();
 		{
 			const writeMs = performance.now() - writeStart;
@@ -10149,6 +12582,9 @@ function createStdoutRenderer(terminal, options) {
 			if (emittedCursorPos) {
 				lastCursorX = emittedCursorPos.x;
 				lastCursorY = emittedCursorPos.y;
+			} else if (hideCursor && !getImeAnchor) {
+				lastCursorX = 0;
+				lastCursorY = 0;
 			} else {
 				lastCursorX = null;
 				lastCursorY = null;
@@ -10315,6 +12751,7 @@ function createStdoutRenderer(terminal, options) {
 	*/
 	function render(dirtyRows, sync, scrollOperations) {
 		if (disposed) return;
+		if (dirtyRows == null || sync) deferGraphicsFlushUntilResizeCommit = false;
 		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 == null) {
 			accumulatedAllRows = true;
@@ -10326,7 +12763,7 @@ function createStdoutRenderer(terminal, options) {
 			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) {
+			else if (!accumulatedAllRows && accumulatedDirtyCount === 0 && !getImeAnchor && !hasPendingTerminalGraphics()) {
 				cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutQueued(0);
 				return;
 			}
@@ -10345,8 +12782,8 @@ function createStdoutRenderer(terminal, options) {
 				}
 			}
 		}
-		const now$2 = Date.now();
-		const elapsed = now$2 - lastFrameTime;
+		const now$3 = Date.now();
+		const elapsed = now$3 - lastFrameTime;
 		const queuedDelayMs = Math.max(0, MIN_FRAME_MS - elapsed);
 		if (pendingRender && !sync) {
 			cliLatency === null || cliLatency === void 0 || cliLatency.recordStdoutQueued(queuedDelayMs);
@@ -10436,13 +12873,94 @@ function createStdoutRenderer(terminal, options) {
 		} catch {}
 	}
 	installFingerprintFn();
+	let suppressNextResizeCommitRender = false;
+	function consumeResizeDirtyState() {
+		suppressNextResizeCommitRender = true;
+		try {
+			terminal.commit({ sync: true });
+		} finally {
+			suppressNextResizeCommitRender = false;
+		}
+	}
+	function clearRowsOnlyResizeRepaintTimer() {
+		if (!rowsOnlyResizeRepaintTimer) return;
+		clearTimeout(rowsOnlyResizeRepaintTimer);
+		rowsOnlyResizeRepaintTimer = null;
+	}
+	function repaintRowsAfterRowsOnlyResize() {
+		if (disposed) return;
+		const { rows } = terminal.size();
+		if (rows <= 0) return;
+		if (isDebugEnabled()) getDebugLog().render(`rows-only resize repaint: rows=${rows}`);
+		preserveNextRowsOnlyResizeBaseline = true;
+		const dirtyRows = Array.from({ length: rows }, (_, y) => y);
+		accumulatedDirtyRowsRequireRepaint = true;
+		deferGraphicsFlushUntilResizeCommit = false;
+		allowNextGraphicsOnlyRenderWithoutBaseline = false;
+		render(dirtyRows, true);
+	}
+	function scheduleRowsOnlyResizeRepaint() {
+		clearRowsOnlyResizeRepaintTimer();
+		if (isDebugEnabled()) getDebugLog().render(`rows-only resize repaint scheduled: delay=${ROWS_ONLY_RESIZE_REPAINT_DELAY_MS}ms`);
+		rowsOnlyResizeRepaintTimer = setTimeout(() => {
+			rowsOnlyResizeRepaintTimer = null;
+			repaintRowsAfterRowsOnlyResize();
+		}, ROWS_ONLY_RESIZE_REPAINT_DELAY_MS);
+	}
 	if (altScreen && outputIsTTY) out.write("\x1B[?1049h");
+	if (keepLineWrapDisabled) out.write("\x1B[?7l");
 	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 }) => {
+		if (suppressNextResizeCommitRender) return;
+		const deferRowsOnlyResizeCommit = rowsOnlyResizeRepaintTimer && (dirtyRows == null || dirtyRows.length >= terminal.size().rows);
+		if (deferRowsOnlyResizeCommit) {
+			if (isDebugEnabled()) getDebugLog().render(`rows-only resize commit deferred: dirtyRows=${(dirtyRows === null || dirtyRows === void 0 ? void 0 : dirtyRows.length) ?? "null"}${sync ? " (sync)" : ""}`);
+			scheduleRowsOnlyResizeRepaint();
+			return;
+		}
 		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);
 	});
+	let terminalResizeCols = terminal.size().cols;
+	let terminalResizeRows = terminal.size().rows;
+	const offTerminalResize = terminal.on("resize", ({ cols, rows }) => {
+		const colsChanged = cols !== terminalResizeCols;
+		const rowsChanged = rows !== terminalResizeRows;
+		const rowsIncreased = rows > terminalResizeRows;
+		terminalResizeCols = cols;
+		terminalResizeRows = rows;
+		if (!colsChanged && !rowsChanged) return;
+		if (pendingRender) {
+			pendingRender = false;
+			if (renderTimer) {
+				clearTimeout(renderTimer);
+				renderTimer = null;
+			}
+			if (isDebugEnabled()) getDebugLog().render("pending stdout render canceled until resize commit");
+		}
+		queueTerminalGraphicsForResizeRedraw({
+			cols,
+			rows
+		});
+		if (!colsChanged) {
+			consumeResizeDirtyState();
+			preserveNextRowsOnlyResizeBaseline = true;
+			if (rowsIncreased) {
+				clearRowsOnlyResizeRepaintTimer();
+				repaintRowsAfterRowsOnlyResize();
+				return;
+			}
+			scheduleRowsOnlyResizeRepaint();
+			if (hasPendingTerminalGraphics()) {
+				deferGraphicsFlushUntilResizeCommit = false;
+				allowNextGraphicsOnlyRenderWithoutBaseline = true;
+				render([], true);
+			}
+			return;
+		}
+		clearRowsOnlyResizeRepaintTimer();
+	});
 	const resizeSource = (options === null || options === void 0 ? void 0 : options.output) ?? process.stdout;
 	const canTrackResize = Boolean(trackResize && outputIsTTY && typeof (resizeSource === null || resizeSource === void 0 ? void 0 : resizeSource.on) === "function");
 	const onResize = () => {
@@ -10450,9 +12968,13 @@ function createStdoutRenderer(terminal, options) {
 		const rows = Number(resizeSource === null || resizeSource === void 0 ? void 0 : resizeSource.rows);
 		if (!Number.isFinite(cols) || !Number.isFinite(rows)) return;
 		const size = terminal.size();
+		if (isDebugEnabled()) getDebugLog().render(`stdout resize event: output=${cols}x${rows}, terminal=${size.cols}x${size.rows}, trackResize=${trackResize ? "true" : "false"}`);
 		if (cols === size.cols && rows === size.rows) return;
+		const colsChanged = cols !== size.cols;
+		const rowsChanged = rows !== size.rows;
 		terminal.resize(cols, rows);
-		render();
+		consumeResizeDirtyState();
+		if (isDebugEnabled()) getDebugLog().render(`stdout resize consumed: target=${cols}x${rows}, colsChanged=${colsChanged ? "true" : "false"}, rowsChanged=${rowsChanged ? "true" : "false"}`);
 	};
 	if (canTrackResize) try {
 		resizeSource.on("resize", onResize);
@@ -10482,17 +13004,72 @@ function createStdoutRenderer(terminal, options) {
 	function dispose() {
 		if (disposed) return;
 		disposed = true;
+		let disposeError = null;
 		if (renderTimer) {
 			clearTimeout(renderTimer);
 			renderTimer = null;
 		}
+		if (terminalGraphicsFlushTimer) {
+			clearTimeout(terminalGraphicsFlushTimer);
+			terminalGraphicsFlushTimer = null;
+		}
+		clearRowsOnlyResizeRepaintTimer();
 		accumulatedAllRows = false;
 		accumulatedDirtyBits = null;
 		accumulatedDirtyCount = 0;
 		accumulatedDirtyMin = Number.POSITIVE_INFINITY;
 		accumulatedDirtyMax = -1;
 		accumulatedDirtyRowsRequireRepaint = false;
+		pendingGraphics.clear();
+		pendingGraphicClears.clear();
+		pendingGraphicSignatures.clear();
+		retainedGraphics.clear();
+		terminalResizeDirtyGraphics.clear();
+		try {
+			if (activeGraphics.size > 0) {
+				const size = terminal.size();
+				const clearParts = [];
+				let terminalGraphicsClears = 0;
+				for (const active of activeGraphics.values()) {
+					const visibleRect = clipGraphicRectToViewport(active, size);
+					let wroteClear = false;
+					if (visibleRect) {
+						clearParts.push(clearGraphicRect(visibleRect));
+						wroteClear = true;
+					}
+					if (active.clearSequence && (visibleRect || !clearSequenceNeedsVisibleCell(active.clearSequence, active.protocol))) {
+						const cell = visibleRect ? {
+							x: visibleRect.x,
+							y: visibleRect.y
+						} : clampCellToViewport({
+							cellX: active.x,
+							cellY: active.y
+						}, size);
+						clearParts.push(`\u001B[${cell.y + 1};${cell.x + 1}H`, maybeWrapTerminalGraphic(active.clearSequence));
+						wroteClear = true;
+					}
+					if (wroteClear) terminalGraphicsClears++;
+				}
+				activeGraphics.clear();
+				activeGraphicSignatures.clear();
+				if (clearParts.length > 0) {
+					const frame = `${SGR_RESET}${clearParts.join("")}${SGR_RESET}`;
+					out.write(frame);
+					recordStdoutTerminalGraphics({
+						clears: terminalGraphicsClears,
+						bytes: Buffer.byteLength(frame, "utf8"),
+						active: 0
+					});
+				} else recordStdoutTerminalGraphics({ active: 0 });
+			}
+		} catch {
+			activeGraphics.clear();
+			activeGraphicSignatures.clear();
+			recordStdoutTerminalGraphics({ active: 0 });
+		}
+		unregisterGraphicsOutput();
 		off();
+		offTerminalResize();
 		releaseFingerprintFn();
 		if (canTrackResize && typeof (resizeSource === null || resizeSource === void 0 ? void 0 : resizeSource.off) === "function") try {
 			resizeSource.off("resize", onResize);
@@ -10500,9 +13077,15 @@ function createStdoutRenderer(terminal, options) {
 		else if (canTrackResize && typeof (resizeSource === null || resizeSource === void 0 ? void 0 : resizeSource.removeListener) === "function") try {
 			resizeSource.removeListener("resize", onResize);
 		} catch {}
-		if (hideCursor) out.write("\x1B[?25h");
-		if (altScreen && outputIsTTY) out.write("\x1B[?1049l");
+		try {
+			if (keepLineWrapDisabled) out.write("\x1B[?7h");
+			if (hideCursor) out.write("\x1B[?25h");
+			if (altScreen && outputIsTTY) out.write("\x1B[?1049l");
+		} catch (err) {
+			if (disposeError == null) disposeError = err;
+		}
 		profiler === null || profiler === void 0 || profiler.dispose();
+		if (disposeError) throw disposeError;
 	}
 	const updateTheme = (next) => {
 		if (disposed) return;
@@ -10517,10 +13100,12 @@ function createStdoutRenderer(terminal, options) {
 		fpPrevValid = false;
 		prevOverlayBlockedRows = [];
 		prevOverlayPartialRows = [];
+		prevOverlayVisibleSpans = new Map();
 		render();
 	};
 	return {
 		capabilities: STDOUT_RENDERER_CAPABILITIES,
+		graphicsCapabilities,
 		render,
 		dispose,
 		setCursor,
@@ -10554,4 +13139,4 @@ function createNodeMentionPathProvider() {
 }
 
 //#endregion
-export { HEADLESS_RENDERER_CAPABILITIES, STDOUT_RENDERER_CAPABILITIES, createCliEventManager, createDefaultTInputHostAdapter, createNodeMentionPathProvider, createNodePathPickerProvider, createOsc52ClipboardProvider, createStdinDriver, createStdoutRenderer, createTInputHostPlugin, createTerminalApp, defaultTInputHostPlugin, getCliLatencyProfiler, getStdoutRendererMetrics, installNodeFileWriters, installTerminalCleanup, readEventLog, resetNodeFileWriters, resolveUserPath, sanitizeTerminalHref, suggestPaths, writeEventLog, writeSnapshot };
+export { HEADLESS_RENDERER_CAPABILITIES, STDOUT_RENDERER_CAPABILITIES, createCliEventManager, createDefaultTInputHostAdapter, createIterm2InlineImageSequence, createKittyDeleteGraphicsSequence, createKittyGraphicsSequence, createNodeMentionPathProvider, createNodePathPickerProvider, createOsc52ClipboardProvider, createStdinDriver, createStdoutRenderer, createTInputHostPlugin, createTerminalApp, createTerminalGraphicRenderQueue, defaultTInputHostPlugin, detectTerminalGraphicsCapabilities, getCliLatencyProfiler, getStdoutRendererMetrics, installNodeFileWriters, installTerminalCleanup, readEventLog, resetNodeFileWriters, resolveUserPath, sanitizeTerminalHref, suggestPaths, writeEventLog, writeSnapshot };