@simon_he/vue-tui 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -361,7 +361,7 @@ __export(path_suggest_exports, {
 });
 function isNodeLike() {
   var _a2;
-  const proc = import_node_process3.default;
+  const proc = import_node_process4.default;
   return typeof ((_a2 = proc == null ? void 0 : proc.versions) == null ? void 0 : _a2.node) === "string";
 }
 function loadGitignoreRulesAsync(workspaceAbs) {
@@ -559,16 +559,16 @@ async function suggestPaths2(options) {
 }
 function resolveUserPath2(workspaceAbs, input) {
   var _a2;
-  const env = ((_a2 = import_node_process3.default) == null ? void 0 : _a2.env) ?? {};
+  const env = ((_a2 = import_node_process4.default) == null ? void 0 : _a2.env) ?? {};
   return resolveUserPath(workspaceAbs, input, {
     homeDir: String(env.HOME || env.USERPROFILE || "")
   });
 }
-var import_node_process3, DEFAULT_IGNORED_SEGMENTS, EMPTY_GITIGNORE_RULES, gitignoreRulesCache, gitignoreRulesLoading;
+var import_node_process4, DEFAULT_IGNORED_SEGMENTS, EMPTY_GITIGNORE_RULES, gitignoreRulesCache, gitignoreRulesLoading;
 var init_path_suggest = __esm({
   "src/cli/path-suggest.ts"() {
     "use strict";
-    import_node_process3 = __toESM(require("process"), 1);
+    import_node_process4 = __toESM(require("process"), 1);
     init_path();
     init_path_suggest_core();
     init_path_suggest_core();
@@ -638,6 +638,7 @@ __export(src_exports, {
   defaultTInputHostPlugin: () => defaultTInputHostPlugin,
   detectTerminalColorCapability: () => detectTerminalColorCapability,
   formatInlineCellLine: () => formatInlineCellLine,
+  getCliLatencyProfiler: () => getCliLatencyProfiler,
   getStdoutRendererMetrics: () => getStdoutRendererMetrics,
   lintJsonText: () => lintJsonText,
   normalizeNewlines: () => normalizeNewlines,
@@ -1017,7 +1018,359 @@ function ansiColors(level) {
 }
 
 // src/cli/input.ts
-var import_node_process2 = __toESM(require("process"), 1);
+var import_node_process3 = __toESM(require("process"), 1);
+
+// src/observability/cli-latency.ts
+var import_node_fs = require("fs");
+var import_node_process = __toESM(require("process"), 1);
+var EVENT_OP_ID = Symbol("dimcode.cliLatencyOpId");
+var DEFAULT_LOG_PATH = "/tmp/dimcode-cli-latency.jsonl";
+var INVALIDATE_ASSOCIATION_WINDOW_MS = 32;
+var MAX_OP_AGE_MS = 5e3;
+var nextOpId = 1;
+var singleton;
+function now() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function diffMs(end, start) {
+  if (end == null || start == null)
+    return null;
+  return Math.max(0, end - start);
+}
+function parseEnabled(value) {
+  const raw = String(value ?? "").trim().toLowerCase();
+  return raw === "1" || raw === "true" || raw === "yes";
+}
+function isTrackedEventType(type) {
+  return type === "keydown" || type === "beforeinput" || type === "input" || type === "paste";
+}
+function defineOpId(target, id) {
+  try {
+    Object.defineProperty(target, EVENT_OP_ID, {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: id
+    });
+  } catch {
+  }
+}
+function readOpId(target) {
+  const value = target == null ? void 0 : target[EVENT_OP_ID];
+  return typeof value === "number" ? value : null;
+}
+function createDisabledProfiler() {
+  return null;
+}
+function createProfiler() {
+  var _a2, _b2, _c;
+  const env = ((_a2 = import_node_process.default) == null ? void 0 : _a2.env) ?? {};
+  if (!parseEnabled(env.DIMCODE_PROFILE_INPUT_LATENCY))
+    return createDisabledProfiler();
+  const logPath = String(
+    env.DIMCODE_PROFILE_INPUT_LATENCY_LOG_PATH ?? DEFAULT_LOG_PATH
+  ).trim() || DEFAULT_LOG_PATH;
+  const ops = /* @__PURE__ */ new Map();
+  const pendingCommitIds = /* @__PURE__ */ new Set();
+  const pendingWriteIds = /* @__PURE__ */ new Set();
+  let currentDispatchOpId = null;
+  let lastDispatchOpId = null;
+  let lastDispatchEndedAt = null;
+  let currentFlushIds = [];
+  let lastRawInputAt = null;
+  const emit = (record) => {
+    try {
+      (0, import_node_fs.appendFileSync)(logPath, `${JSON.stringify(record)}
+`);
+    } catch {
+    }
+  };
+  const cleanupOp = (id) => {
+    ops.delete(id);
+    pendingCommitIds.delete(id);
+    pendingWriteIds.delete(id);
+    if (currentDispatchOpId === id)
+      currentDispatchOpId = null;
+    if (lastDispatchOpId === id) {
+      lastDispatchOpId = null;
+      lastDispatchEndedAt = null;
+    }
+    if (currentFlushIds.includes(id))
+      currentFlushIds = currentFlushIds.filter((value) => value !== id);
+  };
+  const flushOp = (op, outcome) => {
+    const totalStart = op.rawInputAt ?? op.stdinDispatchAt ?? op.dispatchStartAt;
+    emit({
+      ts: op.createdAtIso,
+      id: op.id,
+      event: {
+        type: op.eventType,
+        key: op.key,
+        code: op.code,
+        defaultPrevented: op.defaultPrevented,
+        parser: op.parser
+      },
+      operation: op.operation,
+      stages: {
+        rawInputAt: op.rawInputAt,
+        stdinDispatchAt: op.stdinDispatchAt,
+        dispatchStartAt: op.dispatchStartAt,
+        dispatchEndAt: op.dispatchEndAt,
+        invalidateAt: op.invalidateAt,
+        flushStartAt: op.flushStartAt,
+        flushEndAt: op.flushEndAt,
+        commitAt: op.commitAt,
+        stdoutRenderStartAt: op.stdoutRenderStartAt,
+        writeStartAt: op.writeStartAt,
+        writeEndAt: op.writeEndAt
+      },
+      timingsMs: {
+        inputParseWait: diffMs(op.stdinDispatchAt, op.rawInputAt),
+        eventDispatch: diffMs(op.dispatchEndAt, op.dispatchStartAt),
+        dispatchToInvalidate: diffMs(op.invalidateAt, op.dispatchEndAt),
+        dispatchToFlush: diffMs(op.flushStartAt, op.dispatchEndAt),
+        flushToCommitDone: diffMs(op.flushEndAt, op.flushStartAt),
+        commitToRender: diffMs(op.stdoutRenderStartAt, op.commitAt),
+        renderToWriteStart: diffMs(op.writeStartAt, op.stdoutRenderStartAt),
+        write: op.writeDurationMs,
+        totalToWrite: diffMs(op.writeEndAt, totalStart)
+      },
+      scheduler: {
+        invalidatePriority: op.invalidatePriority,
+        invalidatePlane: op.invalidatePlane,
+        commitSync: op.commitSync,
+        commitPlaneCount: op.commitPlaneCount,
+        commitDirtyRows: op.commitDirtyRows,
+        stdoutQueuedDelayMs: op.stdoutQueuedDelayMs,
+        writeMode: op.writeMode,
+        writeBytes: op.writeBytes
+      },
+      outcome
+    });
+    cleanupOp(op.id);
+  };
+  const expireOldOps = () => {
+    const currentTime = now();
+    for (const op of ops.values()) {
+      if (currentTime - op.createdAt < MAX_OP_AGE_MS)
+        continue;
+      flushOp(op, op.writeEndAt != null ? "completed" : "timeout");
+    }
+  };
+  const flushPendingOps = (outcome) => {
+    for (const op of Array.from(ops.values()))
+      flushOp(op, op.writeEndAt != null ? "completed" : outcome);
+  };
+  const ensureOp = (event) => {
+    const type = String((event == null ? void 0 : event.type) ?? "");
+    if (!isTrackedEventType(type))
+      return null;
+    const existingId = readOpId(event);
+    if (existingId != null) {
+      return ops.get(existingId) ?? null;
+    }
+    const id = nextOpId++;
+    const op = {
+      id,
+      createdAt: now(),
+      createdAtIso: (/* @__PURE__ */ new Date()).toISOString(),
+      eventType: type,
+      key: String((event == null ? void 0 : event.key) ?? ""),
+      code: String((event == null ? void 0 : event.code) ?? ""),
+      operation: null,
+      rawInputAt: null,
+      stdinDispatchAt: null,
+      dispatchStartAt: null,
+      dispatchEndAt: null,
+      invalidateAt: null,
+      invalidatePriority: null,
+      invalidatePlane: null,
+      flushStartAt: null,
+      flushEndAt: null,
+      commitAt: null,
+      commitSync: null,
+      commitPlaneCount: null,
+      commitDirtyRows: null,
+      stdoutQueuedDelayMs: null,
+      stdoutRenderStartAt: null,
+      writeStartAt: null,
+      writeEndAt: null,
+      writeDurationMs: null,
+      writeMode: null,
+      writeBytes: null,
+      defaultPrevented: null,
+      parser: null
+    };
+    ops.set(id, op);
+    defineOpId(event, id);
+    expireOldOps();
+    return op;
+  };
+  const forIds = (ids, fn) => {
+    for (const id of ids) {
+      const op = ops.get(id);
+      if (!op)
+        continue;
+      fn(op);
+    }
+  };
+  const resolveActiveOp = () => {
+    if (currentDispatchOpId != null)
+      return ops.get(currentDispatchOpId) ?? null;
+    if (lastDispatchOpId != null && lastDispatchEndedAt != null && now() - lastDispatchEndedAt <= INVALIDATE_ASSOCIATION_WINDOW_MS) {
+      return ops.get(lastDispatchOpId) ?? null;
+    }
+    return null;
+  };
+  (_c = (_b2 = import_node_process.default) == null ? void 0 : _b2.once) == null ? void 0 : _c.call(_b2, "exit", () => {
+    flushPendingOps("process-exit");
+  });
+  return {
+    enabled: true,
+    recordRawInput(_info) {
+      lastRawInputAt = now();
+      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();
+      if (!op.parser && (info == null ? 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();
+    },
+    recordEventDispatchEnd(event, info) {
+      const op = ensureOp(event);
+      if (!op)
+        return;
+      op.defaultPrevented = Boolean(info.defaultPrevented);
+      if (op.dispatchEndAt == null)
+        op.dispatchEndAt = now();
+      currentDispatchOpId = currentDispatchOpId === op.id ? null : currentDispatchOpId;
+      lastDispatchOpId = op.id;
+      lastDispatchEndedAt = op.dispatchEndAt;
+    },
+    recordSchedulerInvalidate(info) {
+      const op = resolveActiveOp();
+      if (!op)
+        return;
+      if (op.invalidateAt == null)
+        op.invalidateAt = now();
+      if (!op.invalidatePriority && (info == null ? void 0 : info.priority))
+        op.invalidatePriority = String(info.priority);
+      if (!op.invalidatePlane && (info == null ? void 0 : info.plane))
+        op.invalidatePlane = String(info.plane);
+      pendingCommitIds.add(op.id);
+    },
+    recordFlushStart(info) {
+      currentFlushIds = Array.from(pendingCommitIds);
+      if (!currentFlushIds.length)
+        return;
+      const flushTime = now();
+      forIds(currentFlushIds, (op) => {
+        if (op.flushStartAt == null)
+          op.flushStartAt = flushTime;
+        if (op.commitSync == null && (info == null ? void 0 : info.sync) != null)
+          op.commitSync = Boolean(info.sync);
+        if (op.commitPlaneCount == null && Array.isArray(info == null ? void 0 : info.activePlanes)) {
+          op.commitPlaneCount = info.activePlanes.length;
+        }
+      });
+    },
+    recordFlushEnd() {
+      if (!currentFlushIds.length)
+        return;
+      const flushTime = now();
+      forIds(currentFlushIds, (op) => {
+        if (op.flushEndAt == null)
+          op.flushEndAt = flushTime;
+      });
+      currentFlushIds = [];
+    },
+    recordCommit(info) {
+      if (!pendingCommitIds.size)
+        return;
+      const commitTime = now();
+      const ids = Array.from(pendingCommitIds);
+      pendingCommitIds.clear();
+      forIds(ids, (op) => {
+        if (op.flushEndAt == null && op.flushStartAt != null)
+          op.flushEndAt = commitTime;
+        if (op.commitAt == null)
+          op.commitAt = commitTime;
+        op.commitSync = (info == null ? void 0 : info.sync) == null ? op.commitSync : Boolean(info.sync);
+        op.commitPlaneCount = Array.isArray(info == null ? void 0 : info.planes) ? info.planes.length : op.commitPlaneCount;
+        op.commitDirtyRows = Array.isArray(info == null ? void 0 : info.dirtyRows) ? info.dirtyRows.length : (info == null ? void 0 : info.dirtyRows) === null ? null : op.commitDirtyRows;
+        pendingWriteIds.add(op.id);
+      });
+    },
+    recordStdoutQueued(delayMs) {
+      if (!pendingWriteIds.size)
+        return;
+      forIds(pendingWriteIds, (op) => {
+        if (op.stdoutQueuedDelayMs == null)
+          op.stdoutQueuedDelayMs = Math.max(0, delayMs);
+      });
+    },
+    recordStdoutRenderStart() {
+      if (!pendingWriteIds.size)
+        return;
+      const renderTime = now();
+      forIds(pendingWriteIds, (op) => {
+        if (op.stdoutRenderStartAt == null)
+          op.stdoutRenderStartAt = renderTime;
+      });
+    },
+    recordStdoutNoOutput() {
+      if (!pendingWriteIds.size)
+        return;
+      const ids = Array.from(pendingWriteIds);
+      pendingWriteIds.clear();
+      forIds(ids, (op) => flushOp(op, "no-output"));
+    },
+    recordStdoutWrite(info) {
+      if (!pendingWriteIds.size)
+        return;
+      const writeEndTime = now();
+      const ids = Array.from(pendingWriteIds);
+      pendingWriteIds.clear();
+      forIds(ids, (op) => {
+        op.writeEndAt = writeEndTime;
+        op.writeDurationMs = Math.max(0, info.durationMs);
+        op.writeStartAt = writeEndTime - op.writeDurationMs;
+        op.writeMode = String(info.mode ?? "");
+        op.writeBytes = Math.max(0, Math.floor(info.bytes));
+        flushOp(op, "completed");
+      });
+    },
+    markOperation(operation) {
+      const nextOperation = String(operation ?? "").trim();
+      if (!nextOperation)
+        return;
+      const op = resolveActiveOp();
+      if (!op)
+        return;
+      op.operation = nextOperation;
+    }
+  };
+}
+function getCliLatencyProfiler() {
+  if (singleton !== void 0)
+    return singleton;
+  singleton = createProfiler();
+  return singleton;
+}
 
 // src/utils/newlines.ts
 function normalizeNewlines(text) {
@@ -1474,13 +1827,13 @@ function parseLegacySequence(sequence) {
 }
 
 // src/cli/parse-mouse.ts
-var import_node_fs = require("fs");
-var import_node_process = __toESM(require("process"), 1);
+var import_node_fs2 = require("fs");
+var import_node_process2 = __toESM(require("process"), 1);
 function parseMouseSgr(sequence) {
   var _a2;
   if (!sequence.startsWith("\x1B[<"))
     return { handled: false, event: null };
-  const env = ((_a2 = import_node_process.default) == null ? void 0 : _a2.env) ?? {};
+  const env = ((_a2 = import_node_process2.default) == null ? void 0 : _a2.env) ?? {};
   const invertWheel = String(env.DIMCODE_WHEEL_INVERT ?? env.VUE_TUI_WHEEL_INVERT ?? "") === "1";
   const mouseDebugEnabled = String(env.DIMCODE_MOUSE_DEBUG ?? env.VUE_TUI_MOUSE_DEBUG ?? "") === "1";
   const mouseDebugPath = String(
@@ -1490,7 +1843,7 @@ function parseMouseSgr(sequence) {
     if (!mouseDebugEnabled)
       return;
     try {
-      (0, import_node_fs.appendFileSync)(mouseDebugPath, `${msg}
+      (0, import_node_fs2.appendFileSync)(mouseDebugPath, `${msg}
 `);
     } catch {
     }
@@ -1619,6 +1972,7 @@ var import_node_events = require("events");
 var ESC3 = "\x1B";
 var BRACKETED_PASTE_START = "\x1B[200~";
 var BRACKETED_PASTE_END = "\x1B[201~";
+var ESC_CONTINUATION_RESCUE_WINDOW_MS = 64;
 function looksLikeQuotedPathPaste(value) {
   if (!value)
     return false;
@@ -1741,11 +2095,19 @@ function extractCompleteSequences(buffer) {
   }
   return { sequences, remainder: "" };
 }
+function looksLikeSplitEscapeContinuation(value) {
+  const first = value[0];
+  if (first !== "[" && first !== "]" && first !== "P" && first !== "_" && first !== "O") {
+    return false;
+  }
+  return isCompleteSequence(`${ESC3}${value}`) !== "not-escape";
+}
 var StdinBuffer = class extends import_node_events.EventEmitter {
   buffer = "";
   timeout = null;
   timeoutMs;
   escTimeoutMs;
+  pendingEscContinuationAt = null;
   pasteMode = false;
   pasteBuffer = "";
   constructor(options = {}) {
@@ -1769,6 +2131,12 @@ var StdinBuffer = class extends import_node_events.EventEmitter {
     } 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 = `${ESC3}${str}`;
+    }
     if (str.length === 0 && this.buffer.length === 0) {
       this.emit("data", "");
       return;
@@ -1830,7 +2198,10 @@ var StdinBuffer = class extends import_node_events.EventEmitter {
     if (this.buffer.length > 0) {
       const timeoutMs = this.buffer === ESC3 ? this.escTimeoutMs : this.timeoutMs;
       this.timeout = setTimeout(() => {
+        const rescuableLoneEsc = this.buffer === ESC3;
         const flushed = this.flush();
+        if (rescuableLoneEsc && flushed.length === 1 && flushed[0] === ESC3)
+          this.pendingEscContinuationAt = Date.now();
         for (const sequence of flushed)
           this.emit("data", sequence);
       }, timeoutMs);
@@ -1853,6 +2224,7 @@ var StdinBuffer = class extends import_node_events.EventEmitter {
       this.timeout = null;
     }
     this.buffer = "";
+    this.pendingEscContinuationAt = null;
     this.pasteMode = false;
     this.pasteBuffer = "";
   }
@@ -1865,6 +2237,10 @@ var StdinBuffer = class extends import_node_events.EventEmitter {
 };
 
 // src/cli/input.ts
+var KITTY_KEYBOARD_PROTOCOL_ENABLE = "\x1B[>1u";
+var KITTY_KEYBOARD_PROTOCOL_DISABLE = "\x1B[<u";
+var XTERM_MODIFY_OTHER_KEYS_ENABLE = "\x1B[>4;2m";
+var XTERM_MODIFY_OTHER_KEYS_DISABLE = "\x1B[>4n";
 function isPrintable(ch) {
   if (ch.length === 0)
     return false;
@@ -1888,13 +2264,64 @@ function ctrlKeyFromChar(ch) {
     return String.fromCharCode(code + 96);
   return null;
 }
+function isUnhandledCtrlC(event) {
+  return event.type === "keydown" && (event.key === "c" || event.key === "C") && event.ctrlKey === true && event.metaKey !== true && event.altKey !== true && event.shiftKey !== true;
+}
+function parseKeyboardProtocol(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (normalized === "auto" || normalized === "kitty" || normalized === "xterm" || normalized === "off") {
+    return normalized;
+  }
+  return null;
+}
+function detectKeyboardProtocol(env) {
+  const termProgram = String(env.TERM_PROGRAM ?? "").trim().toLowerCase();
+  const term = String(env.TERM ?? "").trim().toLowerCase();
+  const hasKittyProtocolTerminal = "GHOSTTY_RESOURCES_DIR" in env || "WEZTERM_PANE" in env || "KITTY_WINDOW_ID" in env || "KITTY_INSTALLATION_DIR" in env || "ALACRITTY_WINDOW_ID" in env || "ALACRITTY_LOG" in env || termProgram.includes("ghostty") || termProgram.includes("wezterm") || termProgram.includes("kitty") || termProgram.includes("alacritty");
+  if (hasKittyProtocolTerminal)
+    return "kitty";
+  const isScreenLike = "TMUX" in env || term.includes("screen") || term.includes("tmux");
+  const hasXtermKeyboardTerminal = termProgram.includes("iterm") || termProgram.includes("apple_terminal") || termProgram.includes("vscode") || term.includes("xterm") && !isScreenLike;
+  return hasXtermKeyboardTerminal ? "xterm" : "off";
+}
+function resolveKeyboardProtocol(options) {
+  var _a2;
+  const configured = parseKeyboardProtocol(options.keyboardProtocol) ?? "auto";
+  if (configured !== "auto")
+    return configured;
+  const envOverride = parseKeyboardProtocol((_a2 = options.env) == null ? void 0 : _a2.DIMCODE_KEYBOARD_PROTOCOL);
+  if (envOverride && envOverride !== "auto")
+    return envOverride;
+  return detectKeyboardProtocol(options.env ?? {});
+}
+function getKeyboardProtocolSequences(protocol) {
+  if (protocol === "kitty") {
+    return {
+      enable: KITTY_KEYBOARD_PROTOCOL_ENABLE,
+      disable: KITTY_KEYBOARD_PROTOCOL_DISABLE
+    };
+  }
+  if (protocol === "xterm") {
+    return {
+      enable: XTERM_MODIFY_OTHER_KEYS_ENABLE,
+      disable: XTERM_MODIFY_OTHER_KEYS_DISABLE
+    };
+  }
+  return null;
+}
 function createStdinDriver(options) {
-  const stdin = options.stdin ?? import_node_process2.default.stdin;
-  const stdout = options.stdout ?? import_node_process2.default.stdout;
+  const stdin = options.stdin ?? import_node_process3.default.stdin;
+  const stdout = options.stdout ?? import_node_process3.default.stdout;
   if (!stdin || !stdout)
     throw new Error("createStdinDriver requires Node process.stdin/stdout");
+  const env = options.env ?? import_node_process3.default.env ?? {};
   const enableMouse = options.enableMouse ?? true;
   const enableMouseMotion = options.enableMouseMotion ?? false;
+  const keyboardProtocol = resolveKeyboardProtocol({
+    keyboardProtocol: options.keyboardProtocol,
+    env
+  });
+  const keyboardProtocolSequences = getKeyboardProtocolSequences(keyboardProtocol);
   let disposed = false;
   let swallowNextLF = false;
   let lastMouseDown = null;
@@ -1903,61 +2330,69 @@ function createStdinDriver(options) {
     timeout: 50,
     // When mouse tracking is enabled, CSI mouse reports are frequent and we really want to avoid
     // leaking "[<...;...;...M" into focused inputs if the leading ESC gets chunk-split.
-    // Keep this low to reduce perceived latency for plain Esc while still covering split CSI.
-    escTimeout: enableMouse ? 80 : 20
+    // Keep this well below one frame so plain Esc remains responsive while the
+    // stdin buffer rescue path still covers delayed CSI continuations.
+    escTimeout: enableMouse ? 8 : 6
   });
-  const handlePlainChar = (ch) => {
+  const latency = getCliLatencyProfiler();
+  const dispatchEvent = (event, parser) => {
     var _a2;
+    latency == null ? void 0 : latency.recordStdinDispatch(event, { parser });
+    const prevented = Boolean(options.dispatch(event));
+    if (isUnhandledCtrlC(event) && !prevented)
+      (_a2 = options.onExit) == null ? void 0 : _a2.call(options);
+    return prevented;
+  };
+  const handlePlainChar = (ch) => {
     if (swallowNextLF) {
       swallowNextLF = false;
       if (ch === "\n")
         return;
     }
     if (ch === "") {
-      const prevented = Boolean(
-        options.dispatch(keyEvent("c", "", { ctrlKey: true }))
-      );
-      if (!prevented)
-        (_a2 = options.onExit) == null ? void 0 : _a2.call(options);
+      dispatchEvent(keyEvent("c", "", { ctrlKey: true }), "plain");
       return;
     }
     if (ch === "\r") {
       swallowNextLF = true;
-      options.dispatch(keyEvent("Enter", "Enter"));
+      dispatchEvent(keyEvent("Enter", "Enter"), "plain");
       return;
     }
     if (ch === "\n") {
-      options.dispatch({
-        type: "input",
-        data: "\n",
-        inputType: "insertLineBreak",
-        text: "\n"
-      });
+      dispatchEvent(
+        {
+          type: "input",
+          data: "\n",
+          inputType: "insertLineBreak",
+          text: "\n"
+        },
+        "plain"
+      );
       return;
     }
     const ctrlKey = ctrlKeyFromChar(ch);
     if (ctrlKey) {
       if (ctrlKey === "i") {
-        options.dispatch(keyEvent("Tab", "Tab"));
+        dispatchEvent(keyEvent("Tab", "Tab"), "plain");
         return;
       }
       if (ctrlKey === "h") {
-        options.dispatch(keyEvent("Backspace", "Backspace"));
+        dispatchEvent(keyEvent("Backspace", "Backspace"), "plain");
         return;
       }
-      options.dispatch(keyEvent(ctrlKey, "", { ctrlKey: true }));
+      dispatchEvent(keyEvent(ctrlKey, "", { ctrlKey: true }), "plain");
       return;
     }
     if (ch === "\x7F") {
-      options.dispatch(keyEvent("Backspace", "Backspace"));
+      dispatchEvent(keyEvent("Backspace", "Backspace"), "plain");
       return;
     }
     if (ch === "	") {
-      options.dispatch(keyEvent("Tab", "Tab"));
+      dispatchEvent(keyEvent("Tab", "Tab"), "plain");
       return;
     }
     if (isPrintable(ch))
-      options.dispatch(keyEvent(ch));
+      dispatchEvent(keyEvent(ch), "plain");
   };
   const handleMouseEvent = (event) => {
     const ev = event;
@@ -2039,22 +2474,22 @@ function createStdinDriver(options) {
     const kitty = parseKittySequence(sequence);
     if (kitty.handled) {
       if (kitty.event)
-        options.dispatch(kitty.event);
+        dispatchEvent(kitty.event, "kitty");
       return;
     }
     const legacy = parseLegacySequence(sequence);
     if (legacy.handled) {
       if (legacy.event)
-        options.dispatch(legacy.event);
+        dispatchEvent(legacy.event, "legacy");
       return;
     }
     if (sequence.startsWith("\x1B")) {
       if (sequence.length === 2 && isPrintable(sequence[1])) {
-        options.dispatch(keyEvent(sequence[1], "", { altKey: true }));
+        dispatchEvent(keyEvent(sequence[1], "", { altKey: true }), "alt");
         return;
       }
       if (sequence === "\x1B") {
-        options.dispatch(keyEvent("Escape", "Escape"));
+        dispatchEvent(keyEvent("Escape", "Escape"), "escape");
         return;
       }
       return;
@@ -2066,7 +2501,7 @@ function createStdinDriver(options) {
   stdinBuffer.on("paste", (data) => {
     const pastedText = normalizeNewlines(data);
     if (pastedText)
-      options.dispatch({ type: "paste", text: pastedText });
+      dispatchEvent({ type: "paste", text: pastedText }, "paste");
   });
   const decodeBytes = (bytes) => {
     if (bytes.length === 1 && bytes[0] > 127) {
@@ -2081,6 +2516,7 @@ function createStdinDriver(options) {
   const onData = (chunk) => {
     if (disposed)
       return;
+    latency == null ? void 0 : latency.recordRawInput();
     if (typeof chunk === "string") {
       stdinBuffer.process(chunk);
       return;
@@ -2111,6 +2547,8 @@ function createStdinDriver(options) {
   if (stdout.isTTY) {
     stdout.write("\x1B[?2004h");
     stdout.write("\x1B[?1004h");
+    if (keyboardProtocolSequences)
+      stdout.write(keyboardProtocolSequences.enable);
     if (enableMouse) {
       stdout.write("\x1B[?1007h");
       if (enableMouseMotion)
@@ -2140,6 +2578,8 @@ function createStdinDriver(options) {
     if (stdout.isTTY) {
       stdout.write("\x1B[?2004l");
       stdout.write("\x1B[?1004l");
+      if (keyboardProtocolSequences)
+        stdout.write(keyboardProtocolSequences.disable);
       if (enableMouse) {
         stdout.write("\x1B[?1007l");
         if (enableMouseMotion)
@@ -2662,12 +3102,53 @@ function createGridBuffer(cols, rows) {
     cursorStyle: DEFAULT_STYLE,
     scrollback: [],
     scrollbackLimit: 1e3,
-    rowPool: []
+    rowPool: [],
+    soaFingerprints: null,
+    fingerprintFn: null
   };
 }
 function clamp(n, min, max) {
   return Math.max(min, Math.min(max, n));
 }
+function setFingerprintFn(buffer, fn) {
+  buffer.fingerprintFn = fn;
+  const len = buffer.rows * buffer.cols;
+  if (!len) {
+    buffer.soaFingerprints = null;
+    return;
+  }
+  buffer.soaFingerprints = new Uint32Array(len);
+  for (let y = 0; y < buffer.rows; y++) {
+    const row = getBufferRow(buffer, y);
+    const physY = physicalRowIndex(buffer, y);
+    const base = physY * buffer.cols;
+    for (let x = 0; x < buffer.cols; x++) {
+      const cell = row[x];
+      buffer.soaFingerprints[base + x] = fn(cell.ch, cell.style);
+    }
+  }
+}
+function getRowFingerprints(buffer, y) {
+  if (!buffer.soaFingerprints)
+    return null;
+  const physY = physicalRowIndex(buffer, y);
+  const base = physY * buffer.cols;
+  return buffer.soaFingerprints.subarray(base, base + buffer.cols);
+}
+function updateCellFingerprint(buffer, physY, x, ch, style) {
+  if (!buffer.soaFingerprints || !buffer.fingerprintFn)
+    return;
+  buffer.soaFingerprints[physY * buffer.cols + x] = buffer.fingerprintFn(ch, style);
+}
+function updateRangeFingerprint(buffer, physY, x0, x1, ch, style) {
+  if (!buffer.soaFingerprints || !buffer.fingerprintFn)
+    return;
+  const fp = buffer.fingerprintFn(ch, style);
+  const base = physY * buffer.cols;
+  for (let x = x0; x < x1; x++) {
+    buffer.soaFingerprints[base + x] = fp;
+  }
+}
 function physicalRowIndex(buffer, y) {
   return (buffer.gridStart + y) % buffer.rows;
 }
@@ -2740,9 +3221,17 @@ function putCell(buffer, x, y, ch, style) {
     markDirty(buffer, y);
     return;
   }
-  row[x] = createCell(ch, style);
+  const cell = createCell(ch, style);
+  row[x] = cell;
   if (width === 2 && x + 1 < buffer.cols)
     row[x + 1] = createContinuationCell(style);
+  if (buffer.soaFingerprints) {
+    const physY = physicalRowIndex(buffer, y);
+    updateCellFingerprint(buffer, physY, x, cell.ch, cell.style);
+    if (width === 2 && x + 1 < buffer.cols) {
+      updateCellFingerprint(buffer, physY, x + 1, "", cell.style);
+    }
+  }
   markDirty(buffer, y);
 }
 function fillRect(buffer, x, y, w, h18, ch = " ", style) {
@@ -2766,6 +3255,10 @@ function fillRect(buffer, x, y, w, h18, ch = " ", style) {
       row.fill(fillCell, x0, x1);
       if (x1 < buffer.cols && ((_b2 = row[x1]) == null ? void 0 : _b2.continuation))
         row[x1] = blank;
+      if (buffer.soaFingerprints) {
+        const physY = physicalRowIndex(buffer, yy);
+        updateRangeFingerprint(buffer, physY, x0, x1, fillCell.ch, fillCell.style);
+      }
       markDirty(buffer, yy);
     }
     return;
@@ -2834,6 +3327,19 @@ function blankRow(buffer) {
     pooled[x] = blank;
   return pooled;
 }
+function recomputeFingerprintsForRows(buffer, startY, endY) {
+  if (!buffer.soaFingerprints || !buffer.fingerprintFn)
+    return;
+  for (let y = startY; y < endY; y++) {
+    const row = getBufferRow(buffer, y);
+    const physY = physicalRowIndex(buffer, y);
+    const base = physY * buffer.cols;
+    for (let x = 0; x < buffer.cols; x++) {
+      const cell = row[x];
+      buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
+    }
+  }
+}
 function scrollBuffer(buffer, lines) {
   const n = Math.trunc(lines);
   if (n === 0 || buffer.rows === 0)
@@ -2868,6 +3374,70 @@ function scrollBuffer(buffer, lines) {
   markAllDirty(buffer);
   buffer.cursorY = clamp(buffer.cursorY - n, 0, Math.max(0, buffer.rows - 1));
 }
+function scrollBufferRegion(buffer, startY, endY, lines) {
+  const n = Math.trunc(lines);
+  if (n === 0 || buffer.rows === 0)
+    return [];
+  const start = clamp(Math.floor(startY), 0, buffer.rows);
+  const end = clamp(Math.floor(endY), 0, buffer.rows);
+  const height = end - start;
+  if (height <= 0)
+    return [];
+  const absDelta = Math.abs(n);
+  const insertedRows = [];
+  const replaceRegionWithBlankRows = () => {
+    for (let y = start; y < end; y++) {
+      const physY = physicalRowIndex(buffer, y);
+      buffer.rowPool.push(buffer.grid[physY]);
+      buffer.grid[physY] = blankRow(buffer);
+      markDirty(buffer, y);
+      insertedRows.push(y);
+    }
+  };
+  if (absDelta >= height) {
+    replaceRegionWithBlankRows();
+    recomputeFingerprintsForRows(buffer, start, end);
+    if (buffer.cursorY >= start && buffer.cursorY < end)
+      buffer.cursorY = clamp(buffer.cursorY - n, start, Math.max(start, end - 1));
+    return insertedRows;
+  }
+  const regionRows = [];
+  for (let y = start; y < end; y++)
+    regionRows.push(getBufferRow(buffer, y));
+  const nextRows = Array.from({ length: height }, () => []);
+  if (n > 0) {
+    const movedCount = height - n;
+    for (let i = 0; i < movedCount; i++)
+      nextRows[i] = regionRows[i + n];
+    for (let i = 0; i < n; i++) {
+      buffer.rowPool.push(regionRows[i]);
+      const y = end - n + i;
+      nextRows[movedCount + i] = blankRow(buffer);
+      markDirty(buffer, y);
+      insertedRows.push(y);
+    }
+  } else {
+    const insertedCount = -n;
+    const movedCount = height - insertedCount;
+    for (let i = 0; i < insertedCount; i++) {
+      buffer.rowPool.push(regionRows[height - insertedCount + i]);
+      const y = start + i;
+      nextRows[i] = blankRow(buffer);
+      markDirty(buffer, y);
+      insertedRows.push(y);
+    }
+    for (let i = 0; i < movedCount; i++)
+      nextRows[insertedCount + i] = regionRows[i];
+  }
+  for (let i = 0; i < height; i++) {
+    const physY = physicalRowIndex(buffer, start + i);
+    buffer.grid[physY] = nextRows[i];
+  }
+  recomputeFingerprintsForRows(buffer, start, end);
+  if (buffer.cursorY >= start && buffer.cursorY < end)
+    buffer.cursorY = clamp(buffer.cursorY - n, start, Math.max(start, end - 1));
+  return insertedRows;
+}
 function resizeBuffer(buffer, cols, rows) {
   var _a2;
   const nextCols = Math.max(0, Math.floor(cols));
@@ -2904,6 +3474,22 @@ function resizeBuffer(buffer, cols, rows) {
   buffer.dirtyAll = nextRows > 0;
   buffer.cursorX = clamp(buffer.cursorX, 0, Math.max(0, nextCols));
   buffer.cursorY = clamp(buffer.cursorY, 0, Math.max(0, nextRows - 1));
+  if (buffer.fingerprintFn) {
+    const len = nextRows * nextCols;
+    if (len > 0) {
+      buffer.soaFingerprints = new Uint32Array(len);
+      for (let y = 0; y < nextRows; y++) {
+        const row = nextGrid[y];
+        const base = y * nextCols;
+        for (let x = 0; x < nextCols; x++) {
+          const cell = row[x];
+          buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
+        }
+      }
+    } else {
+      buffer.soaFingerprints = null;
+    }
+  }
 }
 function snapshotText(buffer) {
   const out = [];
@@ -3092,6 +3678,40 @@ function scrollPlaneCoverage(state, lines) {
   for (let i = 0; i < -n; i++)
     state.coverage.unshift(new Uint8Array(cols));
 }
+function scrollPlaneCoverageRegion(state, startY, endY, lines) {
+  const n = Math.trunc(lines);
+  if (n === 0 || state.coverage.length === 0)
+    return;
+  const start = Math.max(0, Math.min(state.coverage.length, Math.floor(startY)));
+  const end = Math.max(0, Math.min(state.coverage.length, Math.floor(endY)));
+  const height = end - start;
+  if (height <= 0)
+    return;
+  const cols = state.buffer.cols;
+  if (Math.abs(n) >= height) {
+    for (let y = start; y < end; y++)
+      state.coverage[y] = new Uint8Array(cols);
+    return;
+  }
+  const region = state.coverage.slice(start, end);
+  const next = Array.from({ length: height }, () => new Uint8Array(0));
+  if (n > 0) {
+    const movedCount = height - n;
+    for (let i = 0; i < movedCount; i++)
+      next[i] = region[i + n];
+    for (let i = 0; i < n; i++)
+      next[movedCount + i] = new Uint8Array(cols);
+  } else {
+    const insertedCount = -n;
+    const movedCount = height - insertedCount;
+    for (let i = 0; i < insertedCount; i++)
+      next[i] = new Uint8Array(cols);
+    for (let i = 0; i < movedCount; i++)
+      next[insertedCount + i] = region[i];
+  }
+  for (let i = 0; i < height; i++)
+    state.coverage[start + i] = next[i];
+}
 function resizePlaneState(state, cols, rows) {
   resizeBuffer(state.buffer, cols, rows);
   state.coverage = resizeCoverage(state.coverage, state.buffer.cols, state.buffer.rows);
@@ -3127,6 +3747,14 @@ function resetPlaneRowsForRender(terminal, plane, dirtyRows) {
   const internals = terminal[TERMINAL_PLANE_INTERNALS];
   internals == null ? void 0 : internals.resetRowsForRender(plane, dirtyRows);
 }
+function getPlaneRowCoverageKind(terminal, plane, y) {
+  const internals = terminal[TERMINAL_PLANE_INTERNALS];
+  return (internals == null ? void 0 : internals.getRowCoverageKind(plane, y)) ?? 0;
+}
+function scrollPlaneRows(terminal, plane, startY, endY, lines) {
+  const internals = terminal[TERMINAL_PLANE_INTERNALS];
+  internals == null ? void 0 : internals.scrollRows(plane, startY, endY, lines);
+}
 function createTerminal(opts) {
   const emitter = new Emitter();
   const compositeBuffer = createGridBuffer(opts.cols, opts.rows);
@@ -3136,6 +3764,7 @@ function createTerminal(opts) {
   let pendingCommit = false;
   let pendingCommitAllPlanes = false;
   let pendingCommitPlanes = null;
+  const pendingPlaneScrollOps = /* @__PURE__ */ new Map();
   const planeTerminals = /* @__PURE__ */ new Map();
   let base;
   compositeBuffer.cursorVisible = false;
@@ -3274,8 +3903,171 @@ function createTerminal(opts) {
     scrollBuffer(state.buffer, lines);
     scrollPlaneCoverage(state, lines);
   }
+  function normalizeScrollOperation(startY, endY, delta, totalRows) {
+    const start = Math.max(0, Math.min(totalRows, Math.floor(startY)));
+    const end = Math.max(0, Math.min(totalRows, Math.floor(endY)));
+    const height = end - start;
+    const lines = Math.trunc(delta);
+    if (height <= 0 || lines === 0 || Math.abs(lines) >= height)
+      return null;
+    return { startY: start, endY: end, delta: lines };
+  }
+  function recordPendingScrollOp(plane, op) {
+    const prev = pendingPlaneScrollOps.get(plane);
+    if (prev && prev.startY === op.startY && prev.endY === op.endY) {
+      const nextDelta = prev.delta + op.delta;
+      if (nextDelta === 0) {
+        pendingPlaneScrollOps.delete(plane);
+        return;
+      }
+      const next = normalizeScrollOperation(
+        op.startY,
+        op.endY,
+        nextDelta,
+        compositeBuffer.rows
+      );
+      if (!next) {
+        pendingPlaneScrollOps.delete(plane);
+        return;
+      }
+      pendingPlaneScrollOps.set(plane, next);
+      return;
+    }
+    pendingPlaneScrollOps.set(plane, op);
+  }
+  function takePendingScrollOps(planes) {
+    const planesToTake = (planes == null ? void 0 : planes.length) ? planes : TERMINAL_RENDER_PLANES;
+    const out = [];
+    for (const plane of planesToTake) {
+      const op = pendingPlaneScrollOps.get(plane);
+      if (!op)
+        continue;
+      pendingPlaneScrollOps.delete(plane);
+      out.push({ plane, ...op });
+    }
+    return out.length ? out : null;
+  }
+  function higherPlanesFor(plane) {
+    const planeIndex = TERMINAL_RENDER_PLANES.indexOf(plane);
+    if (planeIndex < 0)
+      return [];
+    return TERMINAL_RENDER_PLANES.slice(planeIndex + 1);
+  }
+  function higherPlaneCoverageKind(plane, y) {
+    var _a2;
+    const higherPlanes = higherPlanesFor(plane);
+    if (!higherPlanes.length || y < 0 || y >= compositeBuffer.rows)
+      return 0;
+    let covered = 0;
+    for (let x = 0; x < compositeBuffer.cols; x++) {
+      let cellCovered = false;
+      for (const higherPlane of higherPlanes) {
+        const state = planeStates.get(higherPlane);
+        if ((_a2 = state == null ? void 0 : state.coverage[y]) == null ? void 0 : _a2[x]) {
+          cellCovered = true;
+          break;
+        }
+      }
+      if (cellCovered)
+        covered++;
+    }
+    if (covered === 0)
+      return 0;
+    if (covered >= compositeBuffer.cols)
+      return 2;
+    return 1;
+  }
+  function prepareCompositeScrollOps(pendingOps) {
+    if (!(pendingOps == null ? void 0 : pendingOps.length)) {
+      return {
+        scrollOperations: null,
+        extraDirtyRows: []
+      };
+    }
+    const scrollOperations = [];
+    const extraDirtyRows = /* @__PURE__ */ new Set();
+    for (const pending of pendingOps) {
+      const blockedRows = /* @__PURE__ */ new Set();
+      const partiallyBlockedRows = /* @__PURE__ */ new Set();
+      for (let y = pending.startY; y < pending.endY; y++) {
+        const coverageKind = higherPlaneCoverageKind(pending.plane, y);
+        if (coverageKind === 0)
+          continue;
+        blockedRows.add(y);
+        if (coverageKind === 1)
+          partiallyBlockedRows.add(y);
+      }
+      if (!blockedRows.size) {
+        scrollOperations.push({
+          startY: pending.startY,
+          endY: pending.endY,
+          delta: pending.delta
+        });
+        continue;
+      }
+      const absDelta = Math.abs(pending.delta);
+      for (let y = pending.startY; y < pending.endY; y++) {
+        if (partiallyBlockedRows.has(y))
+          extraDirtyRows.add(y);
+      }
+      let bandStart = -1;
+      const flushBand = (bandEnd) => {
+        if (bandStart < 0 || bandEnd <= bandStart)
+          return;
+        const bandHeight = bandEnd - bandStart;
+        if (absDelta >= bandHeight) {
+          for (let y = bandStart; y < bandEnd; y++)
+            extraDirtyRows.add(y);
+          bandStart = -1;
+          return;
+        }
+        scrollOperations.push({
+          startY: bandStart,
+          endY: bandEnd,
+          delta: pending.delta
+        });
+        if (pending.delta > 0) {
+          for (let y = bandEnd - absDelta; y < bandEnd; y++)
+            extraDirtyRows.add(y);
+        } else {
+          for (let y = bandStart; y < bandStart + absDelta; y++)
+            extraDirtyRows.add(y);
+        }
+        bandStart = -1;
+      };
+      for (let y = pending.startY; y < pending.endY; y++) {
+        if (blockedRows.has(y)) {
+          flushBand(y);
+          continue;
+        }
+        if (bandStart < 0)
+          bandStart = y;
+      }
+      flushBand(pending.endY);
+    }
+    return {
+      scrollOperations: scrollOperations.length ? scrollOperations : null,
+      extraDirtyRows: Array.from(extraDirtyRows).sort((a, b) => a - b)
+    };
+  }
+  function scrollRowsForPlane(plane, startY, endY, lines) {
+    const state = getPlaneState(plane);
+    const op = normalizeScrollOperation(
+      startY,
+      endY,
+      lines,
+      state.buffer.rows
+    );
+    if (!op)
+      return;
+    scrollBufferRegion(state.buffer, op.startY, op.endY, op.delta);
+    scrollPlaneCoverageRegion(state, op.startY, op.endY, op.delta);
+    recordPendingScrollOp(plane, op);
+  }
   function composeRows(rows) {
     const blank = createBlankCell();
+    const fpFn = compositeBuffer.fingerprintFn;
+    const fpArr = compositeBuffer.soaFingerprints;
     const rowList = rows ?? Array.from({ length: compositeBuffer.rows }, (_, index) => index);
     for (const y of rowList) {
       if (y < 0 || y >= compositeBuffer.rows)
@@ -3310,6 +4102,14 @@ function createTerminal(opts) {
           }
         }
       }
+      if (fpFn && fpArr) {
+        const physY = (compositeBuffer.gridStart + y) % compositeBuffer.rows;
+        const base2 = physY * cols;
+        for (let x = 0; x < cols; x++) {
+          const cell = dst[x];
+          fpArr[base2 + x] = fpFn(cell.ch, cell.style);
+        }
+      }
       markDirty(compositeBuffer, y);
     }
   }
@@ -3506,6 +4306,14 @@ function createTerminal(opts) {
         return all.slice(
           Math.max(0, all.length - Math.max(0, Math.floor(count)))
         );
+      },
+      setFingerprintFn(fn) {
+        assertNotDisposed();
+        base.setFingerprintFn(fn);
+      },
+      getRowFingerprints(y) {
+        assertNotDisposed();
+        return base.getRowFingerprints(y);
       }
     };
     planeTerminals.set(plane, api);
@@ -3580,6 +4388,9 @@ function createTerminal(opts) {
         return pendingDirtyRowsForPlanes((meta == null ? void 0 : meta.planes) ?? null);
       }
       const planesToCompose = ((_b2 = meta == null ? void 0 : meta.planes) == null ? void 0 : _b2.length) ? meta.planes : TERMINAL_RENDER_PLANES;
+      const pendingScrollOps = takePendingScrollOps(planesToCompose);
+      const preparedScroll = prepareCompositeScrollOps(pendingScrollOps);
+      const scrollOperations = preparedScroll.scrollOperations;
       let composeAllRows = false;
       const dirtyRows = /* @__PURE__ */ new Set();
       for (const plane of planesToCompose) {
@@ -3594,12 +4405,23 @@ function createTerminal(opts) {
         for (const y of rows)
           dirtyRows.add(y);
       }
+      for (const y of preparedScroll.extraDirtyRows)
+        dirtyRows.add(y);
       const normalizedDirtyRows = composeAllRows ? null : Array.from(dirtyRows).sort((a, b) => a - b);
+      if (scrollOperations) {
+        for (const op of scrollOperations)
+          scrollBufferRegion(compositeBuffer, op.startY, op.endY, op.delta);
+      }
       if (normalizedDirtyRows !== null && normalizedDirtyRows.length === 0) {
         const pendingCompositeRows = collectAndClearDirtyRows(compositeBuffer);
         if (pendingCompositeRows !== null && pendingCompositeRows.length === 0)
           return pendingCompositeRows;
-        emitter.emit("commit", { dirtyRows: pendingCompositeRows, planes: (meta == null ? void 0 : meta.planes) ?? null });
+        emitter.emit("commit", {
+          dirtyRows: pendingCompositeRows,
+          planes: (meta == null ? void 0 : meta.planes) ?? null,
+          sync: meta == null ? void 0 : meta.sync,
+          scrollOperations
+        });
         return pendingCompositeRows;
       }
       composeRows(normalizedDirtyRows);
@@ -3609,7 +4431,12 @@ function createTerminal(opts) {
       const committedRows = collectAndClearDirtyRows(compositeBuffer);
       if (committedRows !== null && committedRows.length === 0)
         return committedRows;
-      emitter.emit("commit", { dirtyRows: committedRows, planes: (meta == null ? void 0 : meta.planes) ?? null });
+      emitter.emit("commit", {
+        dirtyRows: committedRows,
+        planes: (meta == null ? void 0 : meta.planes) ?? null,
+        sync: meta == null ? void 0 : meta.sync,
+        scrollOperations
+      });
       return committedRows;
     },
     on(event, cb) {
@@ -3675,6 +4502,14 @@ function createTerminal(opts) {
       return all.slice(
         Math.max(0, all.length - Math.max(0, Math.floor(count)))
       );
+    },
+    setFingerprintFn(fn) {
+      assertNotDisposed();
+      setFingerprintFn(compositeBuffer, fn);
+    },
+    getRowFingerprints(y) {
+      assertNotDisposed();
+      return getRowFingerprints(compositeBuffer, y);
     }
   };
   base[TERMINAL_PLANE_INTERNALS] = {
@@ -3689,6 +4524,27 @@ function createTerminal(opts) {
       }
       for (const y of rows)
         clearPlaneCoverageRow(state, y);
+    },
+    getRowCoverageKind(plane, y) {
+      const state = getPlaneState(plane);
+      if (y < 0 || y >= state.coverage.length)
+        return 0;
+      const row = state.coverage[y];
+      if (!(row == null ? void 0 : row.length))
+        return 0;
+      let covered = 0;
+      for (let x = 0; x < row.length; x++) {
+        if (row[x])
+          covered++;
+      }
+      if (covered === 0)
+        return 0;
+      if (covered >= row.length)
+        return 2;
+      return 1;
+    },
+    scrollRows(plane, startY, endY, lines) {
+      scrollRowsForPlane(plane, startY, endY, lines);
     }
   };
   return base;
@@ -3797,8 +4653,8 @@ function createHeadlessRoot() {
 }
 
 // src/events/manager/cli-event-manager.ts
-var import_node_fs2 = require("fs");
-var import_node_process4 = __toESM(require("process"), 1);
+var import_node_fs3 = require("fs");
+var import_node_process5 = __toESM(require("process"), 1);
 function contains(rect, x, y) {
   return x >= rect.x && y >= rect.y && x < rect.x + rect.w && y < rect.y + rect.h;
 }
@@ -3811,7 +4667,7 @@ function area(rect) {
 function isVisible(node) {
   return node.visible !== false;
 }
-function now() {
+function now2() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
 function rectRowRange(rect) {
@@ -3833,6 +4689,7 @@ function createCliEventManager(options) {
   let hoverPath = [];
   const record = options == null ? void 0 : options.record;
   const onFocusChange = options == null ? void 0 : options.onFocusChange;
+  const latency = getCliLatencyProfiler();
   const MODAL_FOCUS_Z_THRESHOLD = 100;
   const MODAL_ROOT_MIN_AREA = 40;
   function focusLockTarget() {
@@ -4014,7 +4871,7 @@ function createCliEventManager(options) {
       bubbles: true,
       cancelable: true,
       defaultPrevented: false,
-      timeStamp: now(),
+      timeStamp: now2(),
       __stopped: false,
       stopPropagation() {
         this.__stopped = true;
@@ -4038,10 +4895,10 @@ function createCliEventManager(options) {
         handler(event);
       } catch (err) {
         try {
-          const env = (_a2 = import_node_process4.default) == null ? void 0 : _a2.env;
+          const env = (_a2 = import_node_process5.default) == null ? void 0 : _a2.env;
           if ((env == null ? void 0 : env.DIMCODE_DEBUG) === "1") {
             const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[1].slice(0, -1);
-            (0, import_node_fs2.appendFileSync)(
+            (0, import_node_fs3.appendFileSync)(
               "/tmp/goatchain-debug.log",
               `[${timestamp}] [EVENT-MGR] ERROR in handler ${node.id}.${handlerKey}: ${err}
 `
@@ -4275,57 +5132,67 @@ function createCliEventManager(options) {
     },
     dispatch(event) {
       record == null ? void 0 : record(event);
-      if (event.type === "keydown" || event.type === "keyup") {
-        return dispatchToFocused(event.type, event);
-      }
-      if (event.type === "pointerdown" || event.type === "pointermove" || event.type === "pointerup" || event.type === "click" || event.type === "dblclick" || event.type === "contextmenu" || event.type === "wheel") {
-        if (event.type === "pointerdown") {
-          const list = candidatesAt(event.cellX, event.cellY);
-          const target = pickTarget(list);
-          if (target == null ? void 0 : target.focusable)
-            setFocus(target.id);
-          capturedId = (target == null ? void 0 : target.id) ?? null;
-          updateHover(target, event);
-          dispatchPointerEvent("pointerdown", event, target);
-          return false;
-        }
-        if (event.type === "pointermove" && capturedId) {
-          const target = nodes.get(capturedId) ?? null;
-          if (!target)
-            return false;
-          updateHover(target, event);
-          const path = ancestorsForTarget(target);
-          const ev = buildPointerEvent("pointermove", path, event);
-          dispatchWithPhases("pointermove", path, target, ev);
-          return ev.defaultPrevented;
-        }
-        if (event.type === "pointermove") {
-          const list = candidatesAt(event.cellX, event.cellY);
-          const target = pickTarget(list);
-          updateHover(target, event);
-          dispatchPointerEvent("pointermove", event, target);
-          return false;
+      latency == null ? void 0 : latency.recordEventDispatchStart(event);
+      let prevented = false;
+      try {
+        if (event.type === "keydown" || event.type === "keyup") {
+          prevented = dispatchToFocused(event.type, event);
+          return prevented;
         }
-        if (event.type === "pointerup" && capturedId) {
-          const target = nodes.get(capturedId) ?? null;
-          const path = target ? ancestorsForTarget(target) : [];
-          const ev = buildPointerEvent("pointerup", path, event);
-          dispatchWithPhases("pointerup", path, target, ev);
-          capturedId = null;
-          return ev.defaultPrevented;
+        if (event.type === "pointerdown" || event.type === "pointermove" || event.type === "pointerup" || event.type === "click" || event.type === "dblclick" || event.type === "contextmenu" || event.type === "wheel") {
+          if (event.type === "pointerdown") {
+            const list = candidatesAt(event.cellX, event.cellY);
+            const target = pickTarget(list);
+            if (target == null ? void 0 : target.focusable)
+              setFocus(target.id);
+            capturedId = (target == null ? void 0 : target.id) ?? null;
+            updateHover(target, event);
+            dispatchPointerEvent("pointerdown", event, target);
+            return prevented;
+          }
+          if (event.type === "pointermove" && capturedId) {
+            const target = nodes.get(capturedId) ?? null;
+            if (!target)
+              return prevented;
+            updateHover(target, event);
+            const path = ancestorsForTarget(target);
+            const ev = buildPointerEvent("pointermove", path, event);
+            dispatchWithPhases("pointermove", path, target, ev);
+            prevented = ev.defaultPrevented;
+            return prevented;
+          }
+          if (event.type === "pointermove") {
+            const list = candidatesAt(event.cellX, event.cellY);
+            const target = pickTarget(list);
+            updateHover(target, event);
+            dispatchPointerEvent("pointermove", event, target);
+            return prevented;
+          }
+          if (event.type === "pointerup" && capturedId) {
+            const target = nodes.get(capturedId) ?? null;
+            const path = target ? ancestorsForTarget(target) : [];
+            const ev = buildPointerEvent("pointerup", path, event);
+            dispatchWithPhases("pointerup", path, target, ev);
+            capturedId = null;
+            prevented = ev.defaultPrevented;
+            return prevented;
+          }
+          if (event.type === "pointerup") {
+            dispatchPointerEvent("pointerup", event);
+            capturedId = null;
+            return prevented;
+          }
+          dispatchPointerEvent(event.type, event);
+          return prevented;
         }
-        if (event.type === "pointerup") {
-          dispatchPointerEvent("pointerup", event);
-          capturedId = null;
-          return false;
+        if (event.type === "beforeinput" || event.type === "input" || event.type === "compositionstart" || event.type === "compositionupdate" || event.type === "compositionend" || event.type === "paste") {
+          prevented = dispatchToFocusedText(event.type, event);
+          return prevented;
         }
-        dispatchPointerEvent(event.type, event);
-        return false;
-      }
-      if (event.type === "beforeinput" || event.type === "input" || event.type === "compositionstart" || event.type === "compositionupdate" || event.type === "compositionend" || event.type === "paste") {
-        return dispatchToFocusedText(event.type, event);
+        return prevented;
+      } finally {
+        latency == null ? void 0 : latency.recordEventDispatchEnd(event, { defaultPrevented: prevented });
       }
-      return false;
     },
     debugNodes() {
       return Array.from(nodes.values()).map((n) => ({
@@ -4360,7 +5227,7 @@ function containsRect2(outer, inner) {
 function area2(rect) {
   return Math.max(0, rect.w) * Math.max(0, rect.h);
 }
-function now2() {
+function now3() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
 function rectRowRange2(rect) {
@@ -4383,9 +5250,9 @@ function createEventManager(container, metrics2, options) {
   let hoverPath = [];
   let lastPointerMoveEvent = null;
   const rawRecord = options == null ? void 0 : options.record;
-  const recordStart = now2();
+  const recordStart = now3();
   const record = rawRecord ? (event) => {
-    rawRecord({ ...event, time: now2() - recordStart });
+    rawRecord({ ...event, time: now3() - recordStart });
   } : void 0;
   const onFocusChange = options == null ? void 0 : options.onFocusChange;
   const textInputTarget = (options == null ? void 0 : options.textInputTarget) ?? null;
@@ -4609,7 +5476,7 @@ function createEventManager(container, metrics2, options) {
       bubbles: true,
       cancelable: true,
       defaultPrevented: false,
-      timeStamp: now2(),
+      timeStamp: now3(),
       __stopped: false,
       stopPropagation() {
         this.__stopped = true;
@@ -5479,15 +6346,15 @@ function createTraceStore(opts) {
 }
 
 // src/observability/tui-profiler.ts
-var import_node_fs3 = require("fs");
-var import_node_process5 = __toESM(require("process"), 1);
+var import_node_fs4 = require("fs");
+var import_node_process6 = __toESM(require("process"), 1);
 function defaultNow() {
   const p = globalThis.performance;
   if (p && typeof p.now === "function")
     return p.now();
   return Date.now();
 }
-function parseEnabled(v) {
+function parseEnabled2(v) {
   return String(v ?? "").trim() === "1";
 }
 function parseLogFormat(v) {
@@ -5512,8 +6379,8 @@ function formatClockTime(ms) {
 }
 function createTuiProfiler(name) {
   var _a2, _b2;
-  const env = (_a2 = import_node_process5.default) == null ? void 0 : _a2.env;
-  if (!parseEnabled(env == null ? void 0 : env.DIMCODE_PROFILE_TUI))
+  const env = (_a2 = import_node_process6.default) == null ? void 0 : _a2.env;
+  if (!parseEnabled2(env == null ? void 0 : env.DIMCODE_PROFILE_TUI))
     return null;
   const format = parseLogFormat(env == null ? void 0 : env.DIMCODE_PROFILE_TUI_FORMAT);
   const logDest = parseLogDest(env == null ? void 0 : env.DIMCODE_PROFILE_TUI_LOG_DEST);
@@ -5536,8 +6403,8 @@ function createTuiProfiler(name) {
   const invalidatePlaneCounts = /* @__PURE__ */ new Map();
   const renderPlaneCounts = /* @__PURE__ */ new Map();
   const logEveryMs = Number((env == null ? void 0 : env.DIMCODE_PROFILE_TUI_LOG_EVERY_MS) ?? 1e3);
-  const now3 = defaultNow;
-  let lastLogAt = now3();
+  const now4 = defaultNow;
+  let lastLogAt = now4();
   function incrementPlaneCount(target, key) {
     const normalized = String(key ?? "all").trim() || "all";
     target.set(normalized, (target.get(normalized) ?? 0) + 1);
@@ -5546,7 +6413,7 @@ function createTuiProfiler(name) {
     const dest = logDest;
     if ((dest === "file" || dest === "both") && logPath) {
       try {
-        (0, import_node_fs3.appendFileSync)(logPath, `${line}
+        (0, import_node_fs4.appendFileSync)(logPath, `${line}
 `);
       } catch {
       }
@@ -5556,7 +6423,7 @@ function createTuiProfiler(name) {
     }
   }
   function flushLog() {
-    const at = now3();
+    const at = now4();
     const elapsed = at - lastLogAt;
     if (elapsed <= 0)
       return;
@@ -5638,7 +6505,7 @@ function createTuiProfiler(name) {
   );
   (_b2 = timer.unref) == null ? void 0 : _b2.call(timer);
   return {
-    now: now3,
+    now: now4,
     recordInvalidate(info) {
       invalidates++;
       incrementPlaneCount(invalidatePlaneCounts, (info == null ? void 0 : info.plane) ?? "all");
@@ -6028,19 +6895,16 @@ var RenderStackKey = Symbol(
   "RenderStack"
 );
 
-// src/vue/render/render-manager.ts
-var import_node_process7 = __toESM(require("process"), 1);
-
 // src/core/debug-logger.ts
-var import_node_fs4 = require("fs");
-var import_node_process6 = __toESM(require("process"), 1);
+var import_node_fs5 = require("fs");
+var import_node_process7 = __toESM(require("process"), 1);
 var LOG_FILE = "/tmp/goatchain-debug.log";
 var enabled = false;
 function createDebugLogger(enable = false) {
   enabled = enable;
   if (enabled) {
     try {
-      (0, import_node_fs4.writeFileSync)(
+      (0, import_node_fs5.writeFileSync)(
         LOG_FILE,
         `=== GoatChain Debug Log Started at ${(/* @__PURE__ */ new Date()).toISOString()} ===
 
@@ -6073,13 +6937,13 @@ function write(data) {
   if (!enabled)
     return;
   try {
-    (0, import_node_fs4.appendFileSync)(LOG_FILE, data);
+    (0, import_node_fs5.appendFileSync)(LOG_FILE, data);
   } catch {
   }
 }
 function isDebugEnabled() {
   var _a2;
-  const env = (_a2 = import_node_process6.default) == null ? void 0 : _a2.env;
+  const env = (_a2 = import_node_process7.default) == null ? void 0 : _a2.env;
   return (env == null ? void 0 : env.DIMCODE_DEBUG) === "1" || (env == null ? void 0 : env.DEBUG) === "1";
 }
 
@@ -6615,6 +7479,30 @@ function createRenderManager(terminal) {
       }
     }
   }
+  function markRows(plane, rows) {
+    if (!rows.length)
+      return;
+    const state = getDirtyState(plane);
+    for (let i = 0; i < rows.length; i++) {
+      const y = Math.floor(rows[i] ?? -1);
+      if (y < 0 || y >= terminalRows)
+        continue;
+      if (state.dirtyRowBits[y] === 0) {
+        state.dirtyRowBits[y] = 1;
+        state.dirtyRowCount++;
+        if (y < state.dirtyMinY)
+          state.dirtyMinY = y;
+        if (y > state.dirtyMaxY)
+          state.dirtyMaxY = y;
+      }
+    }
+  }
+  function scrollPlane(plane, startY, endY, delta) {
+    scrollPlaneRows(terminal, plane, startY, endY, delta);
+  }
+  function invalidatePlane(plane) {
+    getDirtyState(plane).allRowsDirty = true;
+  }
   function register(node) {
     const id = `r${nextNodeId++}`;
     const rect = node.rect ?? null;
@@ -6645,8 +7533,14 @@ function createRenderManager(terminal) {
     const nextPlane = next.plane ?? prev.plane;
     const nextRect = next.rect ?? prev.rect;
     const { y0, y1 } = rectToYBounds(nextRect);
-    markRect(prev.plane, prev.rect);
-    markRect(nextPlane, nextRect);
+    const dirtyRowsHint = next.dirtyRowsHint;
+    const canUseDirtyRowsHint = nextPlane === prev.plane && dirtyRowsHint != null && dirtyRowsHint.length > 0;
+    if (canUseDirtyRowsHint) {
+      markRows(nextPlane, dirtyRowsHint);
+    } else {
+      markRect(prev.plane, prev.rect);
+      markRect(nextPlane, nextRect);
+    }
     const full = Object.freeze({
       ...prev,
       stack: next.stack ?? prev.stack,
@@ -6713,11 +7607,10 @@ function createRenderManager(terminal) {
     return false;
   }
   function render(options) {
-    var _a2;
     const renderStart = profiler == null ? void 0 : profiler.now();
     const activePlanes = (options == null ? void 0 : options.activePlanes) ?? null;
     const requestedPlanes = activePlanes ?? TERMINAL_RENDER_PLANES;
-    const env = (_a2 = import_node_process7.default) == null ? void 0 : _a2.env;
+    const env = process == null ? void 0 : process.env;
     if ((env == null ? void 0 : env.DIMCODE_DEBUG) === "1")
       renderMgrDebugLog.render("[RENDER-MANAGER] render() called");
     if (!hasPendingDirtyWork(requestedPlanes)) {
@@ -6847,6 +7740,8 @@ function createRenderManager(terminal) {
   return {
     rootStack,
     createStack,
+    invalidatePlane,
+    scrollPlane,
     register,
     update,
     unregister,
@@ -6903,6 +7798,7 @@ function createTerminalApp(options) {
   const trace = createTraceStore({
     enabled: Boolean(globalThis.__VT_DEBUG_TRACE__)
   });
+  const latency = getCliLatencyProfiler();
   const profiler = createTuiProfiler("cli-scheduler");
   const events = createCliEventManager({
     record: (event) => {
@@ -6917,7 +7813,8 @@ function createTerminalApp(options) {
     }
   });
   const render = createRenderManager(terminal);
-  const offCommit = terminal.on("commit", ({ dirtyRows, planes }) => {
+  const offCommit = terminal.on("commit", ({ dirtyRows, planes, sync }) => {
+    latency == null ? void 0 : latency.recordCommit({ dirtyRows, planes, sync });
     if (!trace.enabled.value)
       return;
     trace.push({
@@ -6935,10 +7832,10 @@ function createTerminalApp(options) {
   let lastFlushAtMs = 0;
   let scheduledAtMs = 0;
   let timer = null;
+  let pendingInvalidateAfterFlush = false;
   let pendingInvalidateAllPlanes = false;
   const pendingInvalidatePlanes = /* @__PURE__ */ new Set();
   const env = ((_a2 = import_node_process8.default) == null ? void 0 : _a2.env) ?? {};
-  const isGhostty = "GHOSTTY_RESOURCES_DIR" in env;
   const throttleMs = (() => {
     const raw = env.DIMCODE_TUI_THROTTLE_MS;
     if (!raw)
@@ -6950,7 +7847,7 @@ function createTerminalApp(options) {
     var _a3, _b2;
     if (!((_b2 = (_a3 = import_node_process8.default) == null ? void 0 : _a3.stdout) == null ? void 0 : _b2.isTTY))
       return 0;
-    return isGhostty ? 24 : 16;
+    return 16;
   })();
   function queueInvalidatePlane(plane) {
     if (!plane) {
@@ -6974,17 +7871,26 @@ function createTerminalApp(options) {
     pendingInvalidatePlanes.clear();
     return activePlanes;
   }
-  function flush() {
+  function flush(sync) {
     if (disposed)
       return;
     scheduled = false;
     flushing = true;
     const activePlanes = takeActivePlanes();
-    render.render({ activePlanes });
-    terminal.commit({ planes: activePlanes });
-    flushing = false;
-    lastFlushAtMs = Date.now();
-    scheduledAtMs = 0;
+    latency == null ? void 0 : latency.recordFlushStart({ sync, activePlanes });
+    try {
+      render.render({ activePlanes });
+      terminal.commit({ planes: activePlanes, sync });
+    } finally {
+      latency == null ? void 0 : latency.recordFlushEnd();
+      flushing = false;
+      lastFlushAtMs = Date.now();
+      scheduledAtMs = 0;
+    }
+    if (pendingInvalidateAfterFlush) {
+      pendingInvalidateAfterFlush = false;
+      flush(true);
+    }
   }
   function clearScheduledTimer() {
     if (!timer)
@@ -7029,16 +7935,27 @@ function createTerminalApp(options) {
       return;
     clearScheduledTimer();
     scheduled = false;
-    flush();
+    flush(true);
   }
   function invalidate(options2) {
     if (disposed)
       return;
-    if (flushing)
-      return;
     const priority = (options2 == null ? void 0 : options2.priority) ?? "normal";
+    latency == null ? void 0 : latency.recordSchedulerInvalidate({
+      priority,
+      plane: (options2 == null ? void 0 : options2.plane) ?? null
+    });
+    if (flushing) {
+      queueInvalidatePlane(options2 == null ? void 0 : options2.plane);
+      pendingInvalidateAfterFlush = true;
+      return;
+    }
     queueInvalidatePlane(options2 == null ? void 0 : options2.plane);
     profiler == null ? void 0 : profiler.recordInvalidate({ plane: (options2 == null ? void 0 : options2.plane) ?? null });
+    if (priority === "high") {
+      flushNow();
+      return;
+    }
     const nowMs = Date.now();
     const throttleDelayMs = throttleMs > 0 ? Math.max(0, lastFlushAtMs + throttleMs - nowMs) : 0;
     const laneDelayMs = priority === "low" ? Math.max(throttleDelayMs, frameThrottleMs || 16) : priority === "normal" ? Math.max(throttleDelayMs, frameThrottleMs) : 0;
@@ -7181,6 +8098,7 @@ function createTerminalApp(options) {
       if (disposed)
         return;
       disposed = true;
+      clearScheduledTimer();
       if (mounted)
         app.unmount();
       offResize == null ? void 0 : offResize();
@@ -7287,6 +8205,7 @@ function createStdoutRenderer(terminal, options) {
   let palette = options == null ? void 0 : options.palette;
   const trackResize = (options == null ? void 0 : options.trackResize) ?? true;
   const getImeAnchor = options == null ? void 0 : options.getImeAnchor;
+  const cliLatency = getCliLatencyProfiler();
   const profiler = createTuiProfiler("stdout-renderer");
   function resolveUseSyncOutput() {
     var _a3;
@@ -7298,15 +8217,15 @@ function createStdoutRenderer(terminal, options) {
       const v = String(envValue).trim().toLowerCase();
       return v === "1" || v === "true" || v === "yes";
     }
-    const term = String(env2.TERM ?? "").toLowerCase();
-    const termProgram = String(env2.TERM_PROGRAM ?? "").toLowerCase();
+    const term2 = String(env2.TERM ?? "").toLowerCase();
+    const termProgram2 = String(env2.TERM_PROGRAM ?? "").toLowerCase();
     const termProgramVersion = env2.TERM_PROGRAM_VERSION;
     const isGhostty2 = "GHOSTTY_RESOURCES_DIR" in env2;
-    const isProblematicTerminal = isGhostty2 || termProgram.includes("apple_terminal") || term.includes("screen") && !term.includes("tmux");
+    const isProblematicTerminal = isGhostty2 || termProgram2.includes("apple_terminal") || term2.includes("screen") && !term2.includes("tmux");
     if (isProblematicTerminal) {
       return false;
     }
-    const isGoodTerminal = termProgram.includes("iterm") && termProgramVersion && compareVersion(String(termProgramVersion), "3.5.0") >= 0;
+    const isGoodTerminal = termProgram2.includes("iterm") && termProgramVersion && compareVersion(String(termProgramVersion), "3.5.0") >= 0;
     if (isGoodTerminal) {
       return true;
     }
@@ -7354,13 +8273,16 @@ function createStdoutRenderer(terminal, options) {
     return 0.6;
   })();
   const disableCursorPos = isGhostty && ((_d = (_c = import_node_process9.default) == null ? void 0 : _c.env) == null ? void 0 : _d.DIMCODE_DISABLE_CURSOR_POS) === "1";
-  const overlayTerminal = getPlaneTerminal(terminal, "overlay");
+  const termProgram = String(env.TERM_PROGRAM ?? "").trim().toLowerCase();
+  const term = String(env.TERM ?? "").trim().toLowerCase();
+  const isVscodeTerminal = termProgram === "vscode" || "VSCODE_PID" in env || "VSCODE_IPC_HOOK_CLI" in env;
+  const useConservativeDirtyRowRendering = out.isTTY !== false && !isVscodeTerminal && (isGhostty || "KITTY_WINDOW_ID" in env || "ALACRITTY_WINDOW_ID" in env || "ALACRITTY_LOG" in env || "WEZTERM_PANE" in env || "WEZTERM_EXECUTABLE" in env || termProgram.includes("kitty") || termProgram.includes("alacritty") || termProgram.includes("wezterm") || term.includes("kitty") || term.includes("alacritty"));
   const enableOsc8Links = (() => {
     if (!out.isTTY)
       return false;
     const raw = String(env.DIMCODE_TUI_LINKS ?? "").trim().toLowerCase();
     if (!raw) {
-      return !(String(env.TERM_PROGRAM ?? "").trim().toLowerCase() === "vscode" || "VSCODE_PID" in env || "VSCODE_IPC_HOOK_CLI" in env);
+      return !isVscodeTerminal;
     }
     return !(raw === "0" || raw === "false" || raw === "no");
   })();
@@ -7369,12 +8291,16 @@ function createStdoutRenderer(terminal, options) {
   let pendingRender = false;
   let renderTimer = null;
   let writeEmaMs = 0;
+  let lastCursorX = null;
+  let lastCursorY = null;
   let accumulatedAllRows = false;
   let accumulatedDirtyBits = null;
   let accumulatedDirtyCount = 0;
   let accumulatedDirtyMin = Number.POSITIVE_INFINITY;
   let accumulatedDirtyMax = -1;
-  const MIN_FRAME_MS = !out.isTTY ? 0 : isGhostty ? 24 : 16;
+  let accumulatedScrollOperations = null;
+  let accumulatedSkipUnchangedDirtyRows = true;
+  const MIN_FRAME_MS = !out.isTTY ? 0 : 16;
   function clampCellToViewport(cell, size) {
     const maxX = Math.max(0, Math.floor(size.cols) - 1);
     const maxY = Math.max(0, Math.floor(size.rows) - 1);
@@ -7398,17 +8324,35 @@ function createStdoutRenderer(terminal, options) {
   }
   const colorMode = resolveColorMode();
   const enableDim = colorMode === "truecolor";
+  const COLOR_INDEX = {
+    black: 1,
+    red: 2,
+    green: 3,
+    yellow: 4,
+    blue: 5,
+    magenta: 6,
+    cyan: 7,
+    white: 8,
+    blackBright: 9,
+    redBright: 10,
+    greenBright: 11,
+    yellowBright: 12,
+    blueBright: 13,
+    magentaBright: 14,
+    cyanBright: 15,
+    whiteBright: 16
+  };
   let styleKeyCache2 = /* @__PURE__ */ new WeakMap();
   function styleKey2(style) {
     const cached = styleKeyCache2.get(style);
-    if (cached)
+    if (cached !== void 0)
       return cached;
-    const key = `${style.fg ?? ""}|${style.bg ?? defaultBg}|${style.bold ? 1 : 0}|${enableDim && style.dim ? 1 : 0}|${style.italic ? 1 : 0}|${style.underline ? 1 : 0}|${style.inverse ? 1 : 0}|${style.href ?? ""}`;
+    const key = (COLOR_INDEX[style.fg] ?? 0) | (COLOR_INDEX[style.bg ?? defaultBg] ?? 0) << 5 | (style.bold ? 1 << 10 : 0) | (enableDim && style.dim ? 1 << 11 : 0) | (style.italic ? 1 << 12 : 0) | (style.underline ? 1 << 13 : 0) | (style.inverse ? 1 << 14 : 0) | (style.href ? 1 << 15 : 0);
     styleKeyCache2.set(style, key);
     return key;
   }
   function styleKeyFromParts(style) {
-    return `${style.fg ?? ""}|${style.bg ?? defaultBg}|${style.bold ? 1 : 0}|${enableDim && style.dim ? 1 : 0}|${style.italic ? 1 : 0}|${style.underline ? 1 : 0}|${style.inverse ? 1 : 0}|${style.href ?? ""}`;
+    return (COLOR_INDEX[style.fg] ?? 0) | (COLOR_INDEX[style.bg ?? defaultBg] ?? 0) << 5 | (style.bold ? 1 << 10 : 0) | (enableDim && style.dim ? 1 << 11 : 0) | (style.italic ? 1 << 12 : 0) | (style.underline ? 1 << 13 : 0) | (style.inverse ? 1 << 14 : 0) | (style.href ? 1 << 15 : 0);
   }
   function openColor(fg) {
     if (!fg)
@@ -7455,7 +8399,47 @@ function createStdoutRenderer(terminal, options) {
     return result;
   }
   let lastRenderedRows = 0;
-  let renderedRowCache = [];
+  let fpCols = 0;
+  let fpRows = 0;
+  let currentFP = new Uint32Array(0);
+  let prevFP = new Uint32Array(0);
+  let fpPrevValid = false;
+  let prevOverlayBlockedRows = [];
+  let prevOverlayPartialRows = [];
+  function ensureFingerprints(cols, rows) {
+    if (cols === fpCols && rows === fpRows)
+      return;
+    fpCols = cols;
+    fpRows = rows;
+    const len = cols * rows;
+    currentFP = new Uint32Array(len);
+    prevFP = new Uint32Array(len);
+    fpPrevValid = false;
+    prevOverlayBlockedRows = [];
+    prevOverlayPartialRows = [];
+  }
+  function charHash16(ch) {
+    if (ch.length <= 1)
+      return ch.charCodeAt(0) || 0;
+    let h18 = 33052;
+    for (let i = 0; i < ch.length; i++) {
+      h18 ^= ch.charCodeAt(i);
+      h18 = h18 * 257 & 65535;
+    }
+    return h18;
+  }
+  function fingerprintRow(row, y, cols) {
+    const rowFP = terminal.getRowFingerprints(y);
+    if (rowFP && rowFP.length >= cols) {
+      currentFP.set(rowFP.subarray(0, cols), y * fpCols);
+      return;
+    }
+    const base = y * fpCols;
+    for (let x = 0; x < cols; x++) {
+      const cell = row[x];
+      currentFP[base + x] = styleKey2(cell.style) << 16 | charHash16(cell.ch);
+    }
+  }
   const rowCursorToCol1 = [];
   const rowClearToEol = [];
   const rowTextPartsScratch = [];
@@ -7474,14 +8458,6 @@ function createStdoutRenderer(terminal, options) {
       rowClearToEol[y] = `\x1B[${y + 1};1H\x1B[K`;
     }
   };
-  const ensureRenderedRowCache = (rows) => {
-    if (renderedRowCache.length > rows) {
-      renderedRowCache.length = rows;
-      return;
-    }
-    while (renderedRowCache.length < rows)
-      renderedRowCache.push([]);
-  };
   const expandSpanStart = (row, startX) => {
     var _a3;
     let x = Math.max(0, Math.min(row.length, startX));
@@ -7501,40 +8477,296 @@ function createStdoutRenderer(terminal, options) {
     }
     return x;
   };
-  const resolveChangedSpan = (row, prevRow) => {
-    if (!prevRow || prevRow.length !== row.length) {
+  const resolveChangedSpan = (row, y, cols) => {
+    if (!fpCols || y >= fpRows || !fpPrevValid)
+      return row.length ? { startX: 0, endXExclusive: row.length } : null;
+    const base = y * fpCols;
+    let startX = -1;
+    let endXExclusive = -1;
+    for (let x = 0; x < cols; x++) {
+      if (currentFP[base + x] === prevFP[base + x])
+        continue;
+      if (startX === -1)
+        startX = x;
+      endXExclusive = x + 1;
+    }
+    if (startX === -1)
+      return null;
+    const expandedStart = expandSpanStart(row, startX);
+    const expandedEnd = expandSpanEnd(row, endXExclusive);
+    return expandedEnd > expandedStart ? { startX: expandedStart, endXExclusive: expandedEnd } : null;
+  };
+  const resolveChangedSpanAgainstFill = (row, y, cols, fillFingerprint) => {
+    if (!fpCols || y >= fpRows)
       return row.length ? { startX: 0, endXExclusive: row.length } : null;
+    const base = y * fpCols;
+    let startX = -1;
+    let endXExclusive = -1;
+    for (let x = 0; x < cols; x++) {
+      if (currentFP[base + x] === fillFingerprint)
+        continue;
+      if (startX === -1)
+        startX = x;
+      endXExclusive = x + 1;
     }
+    if (startX === -1)
+      return null;
+    const expandedStart = expandSpanStart(row, startX);
+    const expandedEnd = expandSpanEnd(row, endXExclusive);
+    return expandedEnd > expandedStart ? { startX: expandedStart, endXExclusive: expandedEnd } : null;
+  };
+  const resolveChangedSpanAgainstReference = (row, y, cols) => {
+    if (!fpCols || y >= fpRows)
+      return row.length ? { startX: 0, endXExclusive: row.length } : null;
+    const rowFP = terminal.getRowFingerprints(y);
+    const base = y * fpCols;
     let startX = -1;
     let endXExclusive = -1;
-    for (let x = 0; x < row.length; x++) {
-      if (row[x] === prevRow[x])
+    for (let x = 0; x < cols; x++) {
+      const fingerprint = rowFP && rowFP.length >= cols ? rowFP[x] : styleKey2(row[x].style) << 16 | charHash16(row[x].ch);
+      if (fingerprint === currentFP[base + x])
+        continue;
+      if (startX === -1)
+        startX = x;
+      endXExclusive = x + 1;
+    }
+    if (startX === -1)
+      return null;
+    const expandedStart = expandSpanStart(row, startX);
+    const expandedEnd = expandSpanEnd(row, endXExclusive);
+    return expandedEnd > expandedStart ? { startX: expandedStart, endXExclusive: expandedEnd } : null;
+  };
+  const rowMatchesPreviousFrame = (y, cols) => {
+    if (!fpCols || y < 0 || y >= fpRows || !fpPrevValid)
+      return false;
+    const rowFP = terminal.getRowFingerprints(y);
+    const row = rowFP && rowFP.length >= cols ? null : terminal.getRow(y);
+    const base = y * fpCols;
+    for (let x = 0; x < cols; x++) {
+      const fingerprint = rowFP && rowFP.length >= cols ? rowFP[x] : styleKey2(row[x].style) << 16 | charHash16(row[x].ch);
+      if (fingerprint !== prevFP[base + x])
+        return false;
+    }
+    return true;
+  };
+  const rowHasNonDefaultBlankCell = (source, y, cols) => {
+    if (!fpCols || y < 0 || y >= fpRows)
+      return false;
+    const blankFP = styleKeyFromParts({ bg: defaultBg }) << 16 | charHash16(" ");
+    const base = y * fpCols;
+    const limit = Math.min(cols, fpCols);
+    for (let x = 0; x < limit; x++) {
+      if (source[base + x] !== blankFP)
+        return true;
+    }
+    return false;
+  };
+  function overlayPlaneCoverageRows(totalRows) {
+    const blockedRows = [];
+    const partialRows = [];
+    for (let y = 0; y < totalRows; y++) {
+      const kind = getPlaneRowCoverageKind(terminal, "overlay", y);
+      if (!kind)
+        continue;
+      blockedRows.push(y);
+      if (kind === 1)
+        partialRows.push(y);
+    }
+    return { blockedRows, partialRows };
+  }
+  const enableScrollRegions = (() => {
+    const raw = String(env.DIMCODE_TUI_SCROLL_REGIONS ?? "").trim();
+    if (raw === "0" || raw === "false")
+      return false;
+    if (isGhostty || isVscodeTerminal)
+      return false;
+    return out.isTTY !== false;
+  })();
+  function prepareExplicitScrollOperations(operations, blockedRows) {
+    if (!operations.length || !(blockedRows == null ? void 0 : blockedRows.size)) {
+      return {
+        operations,
+        hiddenRows: /* @__PURE__ */ new Set(),
+        trimmed: false,
+        blockedInterior: false
+      };
+    }
+    const hiddenRows = /* @__PURE__ */ new Set();
+    const prepared = [];
+    let trimmed = false;
+    for (const op of operations) {
+      let startY = op.startY;
+      let endY = op.endY;
+      while (startY < endY && blockedRows.has(startY)) {
+        hiddenRows.add(startY);
+        startY++;
+        trimmed = true;
+      }
+      while (endY > startY && blockedRows.has(endY - 1)) {
+        hiddenRows.add(endY - 1);
+        endY--;
+        trimmed = true;
+      }
+      for (let y = startY; y < endY; y++) {
+        if (!blockedRows.has(y))
+          continue;
+        return {
+          operations: null,
+          hiddenRows,
+          trimmed,
+          blockedInterior: true
+        };
+      }
+      if (endY <= startY || Math.abs(op.delta) >= endY - startY) {
+        return {
+          operations: null,
+          hiddenRows,
+          trimmed,
+          blockedInterior: false
+        };
+      }
+      prepared.push(
+        startY === op.startY && endY === op.endY ? op : { startY, endY, delta: op.delta }
+      );
+    }
+    return {
+      operations: prepared,
+      hiddenRows,
+      trimmed,
+      blockedInterior: false
+    };
+  }
+  function largestDirtyBand(rows, blockedRows) {
+    if (rows.length === 0)
+      return null;
+    const blocked = (blockedRows == null ? void 0 : blockedRows.length) ? new Set(blockedRows) : null;
+    let bestStart = -1;
+    let bestEnd = -1;
+    let bandStart = -1;
+    let prev = -1;
+    for (let i = 0; i < rows.length; i++) {
+      const y = rows[i];
+      if (blocked == null ? void 0 : blocked.has(y)) {
+        if (bandStart !== -1 && prev + 1 - bandStart > bestEnd - bestStart) {
+          bestStart = bandStart;
+          bestEnd = prev + 1;
+        }
+        bandStart = -1;
+        prev = -1;
+        continue;
+      }
+      if (bandStart === -1) {
+        bandStart = y;
+        prev = y;
+        if (bestStart === -1) {
+          bestStart = y;
+          bestEnd = y + 1;
+        }
+        continue;
+      }
+      if (y === prev + 1) {
+        prev = y;
         continue;
-      if (startX === -1)
-        startX = x;
-      endXExclusive = x + 1;
+      }
+      if (prev + 1 - bandStart > bestEnd - bestStart) {
+        bestStart = bandStart;
+        bestEnd = prev + 1;
+      }
+      bandStart = y;
+      prev = y;
+    }
+    if (bandStart !== -1 && prev + 1 - bandStart > bestEnd - bestStart) {
+      bestStart = bandStart;
+      bestEnd = prev + 1;
     }
-    if (startX === -1 || endXExclusive === -1)
+    if (bestStart === -1)
       return null;
-    const expandedStart = Math.min(
-      expandSpanStart(row, startX),
-      expandSpanStart(prevRow, startX)
-    );
-    const expandedEnd = Math.max(
-      expandSpanEnd(row, endXExclusive),
-      expandSpanEnd(prevRow, endXExclusive)
+    const outsideRows = [];
+    for (const y of rows) {
+      if ((blocked == null ? void 0 : blocked.has(y)) || y < bestStart || y >= bestEnd) {
+        outsideRows.push(y);
+      }
+    }
+    return { start: bestStart, end: bestEnd, outsideRows };
+  }
+  function detectScrollShift(cols, dirtyRows, blockedRows) {
+    if (!fpPrevValid || !fpCols || cols !== fpCols)
+      return null;
+    const band = largestDirtyBand(dirtyRows, blockedRows);
+    if (!band || band.end - band.start < 3)
+      return null;
+    const maxDelta = Math.min(
+      12,
+      Math.max(5, band.end - band.start - 1)
     );
-    return expandedEnd > expandedStart ? { startX: expandedStart, endXExclusive: expandedEnd } : null;
-  };
-  function overlayPlaneHasVisibleContent() {
-    const lines = overlayTerminal.snapshot().lines;
-    for (const line of lines) {
-      for (let i = 0; i < line.length; i++) {
-        if (line.charCodeAt(i) !== 32)
-          return true;
+    for (let delta = -maxDelta; delta <= maxDelta; delta++) {
+      if (delta === 0)
+        continue;
+      let matches = 0;
+      let checked = 0;
+      let mismatches = 0;
+      for (let y = band.start; y < band.end; y++) {
+        const srcY = y + delta;
+        if (srcY < band.start || srcY >= band.end)
+          continue;
+        const informative = rowHasNonDefaultBlankCell(currentFP, y, cols) || rowHasNonDefaultBlankCell(prevFP, srcY, cols);
+        if (!informative)
+          continue;
+        checked++;
+        const curBase = y * fpCols;
+        const prevBase = srcY * fpCols;
+        let rowMatch = true;
+        for (let x = 0; x < cols; x++) {
+          if (currentFP[curBase + x] !== prevFP[prevBase + x]) {
+            rowMatch = false;
+            break;
+          }
+        }
+        if (rowMatch) {
+          matches++;
+        } else {
+          mismatches++;
+        }
+      }
+      if (checked > 0 && matches >= 3 && mismatches <= Math.ceil(checked * 0.2)) {
+        const absDelta = Math.abs(delta);
+        let newRowStart;
+        let newRowEnd;
+        if (delta > 0) {
+          newRowStart = Math.max(band.start, band.end - absDelta);
+          newRowEnd = band.end;
+        } else {
+          newRowStart = band.start;
+          newRowEnd = Math.min(band.end, band.start + absDelta);
+        }
+        const extraDirty = [...band.outsideRows];
+        for (let y = band.start; y < band.end; y++) {
+          const srcY = y + delta;
+          if (srcY < band.start || srcY >= band.end)
+            continue;
+          const curBase = y * fpCols;
+          const prevBase = srcY * fpCols;
+          let rowMatch = true;
+          for (let x = 0; x < cols; x++) {
+            if (currentFP[curBase + x] !== prevFP[prevBase + x]) {
+              rowMatch = false;
+              break;
+            }
+          }
+          if (!rowMatch)
+            extraDirty.push(y);
+        }
+        return {
+          regionStart: band.start,
+          regionEnd: band.end,
+          delta,
+          newRowStart,
+          newRowEnd,
+          extraDirtyRows: extraDirty
+        };
       }
     }
-    return false;
+    return null;
   }
   function writeChunked(data) {
     if (!isGhostty) {
@@ -7569,7 +8801,7 @@ function createStdoutRenderer(terminal, options) {
         getDebugLog().error(`writeChunked: write error`, e);
     }
   }
-  function doRender(dirtyRows) {
+  function doRender(dirtyRows, scrollOperations, skipUnchangedDirtyRows = false) {
     if (isDebugEnabled()) {
       getDebugLog().render(
         `doRender() START: dirtyRows=${(dirtyRows == null ? void 0 : dirtyRows.length) ?? "null"}`
@@ -7577,21 +8809,63 @@ function createStdoutRenderer(terminal, options) {
     }
     if (disposed)
       return;
+    cliLatency == null ? void 0 : cliLatency.recordStdoutRenderStart();
     pendingRender = false;
     accumulatedAllRows = false;
     accumulatedDirtyBits = null;
     accumulatedDirtyCount = 0;
     accumulatedDirtyMin = Number.POSITIVE_INFINITY;
     accumulatedDirtyMax = -1;
+    accumulatedScrollOperations = null;
+    accumulatedSkipUnchangedDirtyRows = true;
     lastFrameTime = Date.now();
     const renderStart = performance.now();
     const size = terminal.size();
     ensureRowEscapes(Math.max(size.rows, lastRenderedRows));
-    ensureRenderedRowCache(size.rows);
+    ensureFingerprints(size.cols, size.rows);
     const bgSeq = openBg(defaultBg);
     const bgOnlyStyle = { bg: defaultBg };
     const bgKey = styleKeyFromParts({ bg: defaultBg });
+    const blankFP = bgKey << 16 | charHash16(" ");
+    const cellFingerprint = (cell) => styleKey2(cell.style) << 16 | charHash16(cell.ch);
+    const lastOccupiedColumnInRow = (row, cols) => {
+      const limit = Math.min(row.length, cols);
+      for (let x = limit - 1; x >= 0; x--) {
+        if (cellFingerprint(row[x]) !== blankFP)
+          return x;
+      }
+      return -1;
+    };
+    const lastOccupiedColumnInReference = (source, y, cols) => {
+      if (!fpCols || y < 0 || y >= fpRows)
+        return -1;
+      const limit = Math.min(fpCols, cols);
+      const base = y * fpCols;
+      for (let x = limit - 1; x >= 0; x--) {
+        if (source[base + x] !== blankFP)
+          return x;
+      }
+      return -1;
+    };
+    const shouldRewriteRowTail = (row, y, cols, reference) => lastOccupiedColumnInRow(row, cols) < lastOccupiedColumnInReference(reference, y, cols);
     let dirtySorted = true;
+    const normalizedScrollOperations = (() => {
+      if (!(scrollOperations == null ? void 0 : scrollOperations.length))
+        return null;
+      const outOps = [];
+      for (const op of scrollOperations) {
+        const startY = Math.max(0, Math.min(size.rows, Math.floor(op.startY)));
+        const endY = Math.max(0, Math.min(size.rows, Math.floor(op.endY)));
+        const delta = Math.trunc(op.delta);
+        if (endY <= startY || delta === 0 || Math.abs(delta) >= endY - startY)
+          continue;
+        outOps.push({ startY, endY, delta });
+      }
+      if (!outOps.length)
+        return null;
+      outOps.sort((a, b) => a.startY - b.startY);
+      return outOps;
+    })();
     let rowsToRender = (() => {
       if (!dirtyRows || dirtyRows.length === 0)
         return null;
@@ -7617,13 +8891,16 @@ function createStdoutRenderer(terminal, options) {
         outRows.sort((a, b) => a - b);
       return outRows;
     })();
-    if (rowsToRender && rowsToRender.length >= size.rows * dirtyFullThreshold) {
-      rowsToRender = null;
+    if (fpPrevValid && rowsToRender) {
+      currentFP.set(prevFP);
     }
     const frameParts = [];
     frameParts.push(!isGhostty && useSyncOutput ? SYNC_START : "");
     frameParts.push("\x1B[?7l");
     frameParts.push(SGR_RESET, bgSeq);
+    let lastRenderedY = -1;
+    let lastRenderWasFullRow = false;
+    let hasFrameOutput = false;
     let activeStyleKey = null;
     let activeStyle = {
       fg: null,
@@ -7688,13 +8965,17 @@ function createStdoutRenderer(terminal, options) {
         Math.min(row.length, Math.floor(endXExclusive))
       );
       if (spanStart >= spanEnd && !clearToEol) {
-        renderedRowCache[y] = row.slice();
         return;
       }
+      hasFrameOutput = true;
       if (!disableCursorPos) {
-        frameParts.push(
-          spanStart === 0 ? rowCursorToCol1[y] : `\x1B[${y + 1};${spanStart + 1}H`
-        );
+        if (spanStart === 0 && lastRenderWasFullRow && y === lastRenderedY + 1) {
+          frameParts.push("\r\n");
+        } else {
+          frameParts.push(
+            spanStart === 0 ? rowCursorToCol1[y] : `\x1B[${y + 1};${spanStart + 1}H`
+          );
+        }
       }
       let currentKey = null;
       let currentStyle = null;
@@ -7718,7 +8999,7 @@ function createStdoutRenderer(terminal, options) {
           }
           continue;
         }
-        if (key === currentKey) {
+        if (key === currentKey && !(key & 32768 && nextStyle.href !== (currentStyle == null ? void 0 : currentStyle.href))) {
           currentTextParts.push(ch);
           if (needsWideCursorFix(cell, ch)) {
             currentTextParts.push(
@@ -7750,39 +9031,342 @@ function createStdoutRenderer(terminal, options) {
         }
         frameParts.push("\x1B[K");
       }
-      renderedRowCache[y] = row.slice();
+      lastRenderedY = y;
+      lastRenderWasFullRow = spanStart === 0 && clearToEol;
     };
-    if (!rowsToRender) {
+    const overlayCoverage = overlayPlaneCoverageRows(size.rows);
+    const overlayRows = Array.from(
+      /* @__PURE__ */ new Set([
+        ...overlayCoverage.blockedRows,
+        ...prevOverlayBlockedRows
+      ])
+    ).sort((a, b) => a - b);
+    const overlayRowSet = overlayRows.length ? new Set(overlayRows) : null;
+    const overlayPartialRows = Array.from(
+      /* @__PURE__ */ new Set([
+        ...overlayCoverage.partialRows,
+        ...prevOverlayPartialRows
+      ])
+    ).sort((a, b) => a - b);
+    const overlayPartialRowSet = overlayPartialRows.length ? new Set(overlayPartialRows) : null;
+    const overlayTouchedRowSet = (() => {
+      if (!overlayRowSet && !overlayPartialRowSet)
+        return null;
+      return /* @__PURE__ */ new Set([
+        ...overlayRowSet ? Array.from(overlayRowSet) : [],
+        ...overlayPartialRowSet ? Array.from(overlayPartialRowSet) : []
+      ]);
+    })();
+    let explicitScrollOperations = normalizedScrollOperations;
+    let hiddenExplicitDirtyRows = null;
+    let allowInferredScrollRegions = true;
+    if (explicitScrollOperations && overlayRows.length) {
+      const preparedExplicit = prepareExplicitScrollOperations(
+        explicitScrollOperations,
+        overlayRowSet
+      );
+      hiddenExplicitDirtyRows = preparedExplicit.hiddenRows.size ? preparedExplicit.hiddenRows : null;
+      if (preparedExplicit.operations) {
+        explicitScrollOperations = preparedExplicit.operations;
+        if (preparedExplicit.trimmed && isDebugEnabled()) {
+          getDebugLog().render(
+            ` Explicit scroll ops clipped around overlay rows: ${normalizedScrollOperations.map((op, index) => `${op.startY}-${op.endY - 1}:${op.delta}->${explicitScrollOperations[index].startY}-${explicitScrollOperations[index].endY - 1}:${explicitScrollOperations[index].delta}`).join(", ")}`
+          );
+        }
+      } else {
+        allowInferredScrollRegions = false;
+        const expandedRows = new Set(rowsToRender ?? []);
+        for (const op of explicitScrollOperations) {
+          for (let y = op.startY; y < op.endY; y++)
+            expandedRows.add(y);
+        }
+        rowsToRender = Array.from(expandedRows).sort((a, b) => a - b);
+        dirtySorted = true;
+        explicitScrollOperations = null;
+        hiddenExplicitDirtyRows = null;
+        if (isDebugEnabled()) {
+          getDebugLog().render(
+            preparedExplicit.blockedInterior ? " Explicit scroll ops split by interior overlay rows; falling back to region repaint" : " Explicit scroll ops could not be clipped safely; falling back to region repaint"
+          );
+        }
+      }
+    }
+    const scrollRowsCandidate = rowsToRender;
+    if (explicitScrollOperations && rowsToRender && (!enableScrollRegions || !fpPrevValid)) {
+      const expandedRows = new Set(rowsToRender);
+      for (const op of explicitScrollOperations) {
+        for (let y = op.startY; y < op.endY; y++) {
+          if (hiddenExplicitDirtyRows == null ? void 0 : hiddenExplicitDirtyRows.has(y))
+            continue;
+          expandedRows.add(y);
+        }
+      }
+      rowsToRender = Array.from(expandedRows).sort((a, b) => a - b);
+      dirtySorted = true;
+      explicitScrollOperations = null;
+      hiddenExplicitDirtyRows = null;
+      if (isDebugEnabled()) {
+        getDebugLog().render(
+          enableScrollRegions ? " Explicit scroll ops fell back to region repaint because previous fingerprints are unavailable" : " Explicit scroll ops fell back to region repaint because scroll regions are disabled"
+        );
+      }
+    }
+    const denseDirtyRows = Boolean(
+      rowsToRender && rowsToRender.length >= size.rows * dirtyFullThreshold
+    );
+    if (denseDirtyRows) {
+      rowsToRender = null;
+    }
+    let profiledRowCount = rowsToRender ? rowsToRender.length : size.rows;
+    const useScrollRegions = enableScrollRegions && fpPrevValid && scrollRowsCandidate && scrollRowsCandidate.length >= 3 && allowInferredScrollRegions;
+    let scrollHandled = false;
+    if (enableScrollRegions && explicitScrollOperations && scrollRowsCandidate && fpPrevValid) {
+      if (currentFP.length === prevFP.length)
+        currentFP.set(prevFP);
+      const insertedRows = /* @__PURE__ */ new Set();
+      const explicitRowsToRender = /* @__PURE__ */ new Set();
+      for (const y of scrollRowsCandidate) {
+        if (hiddenExplicitDirtyRows == null ? void 0 : hiddenExplicitDirtyRows.has(y))
+          continue;
+        explicitRowsToRender.add(y);
+      }
+      if (isDebugEnabled()) {
+        getDebugLog().render(
+          ` Explicit scroll ops: ${explicitScrollOperations.map((op) => `${op.startY}-${op.endY - 1}:${op.delta}`).join(", ")}`
+        );
+      }
+      for (const op of explicitScrollOperations) {
+        hasFrameOutput = true;
+        frameParts.push(`\x1B[${op.startY + 1};${op.endY}r`);
+        if (op.delta > 0) {
+          frameParts.push(`\x1B[${op.endY};1H`);
+          frameParts.push(`\x1B[${op.delta}S`);
+          for (let y = op.startY; y < op.endY - op.delta; y++) {
+            const dstBase = y * fpCols;
+            const srcBase = (y + op.delta) * fpCols;
+            for (let x = 0; x < size.cols; x++)
+              currentFP[dstBase + x] = prevFP[srcBase + x];
+          }
+          for (let y = op.endY - op.delta; y < op.endY; y++) {
+            const base = y * fpCols;
+            insertedRows.add(y);
+            explicitRowsToRender.add(y);
+            for (let x = 0; x < size.cols; x++)
+              currentFP[base + x] = blankFP;
+          }
+        } else {
+          const absDelta = -op.delta;
+          frameParts.push(`\x1B[${op.startY + 1};1H`);
+          frameParts.push(`\x1B[${absDelta}T`);
+          for (let y = op.endY - 1; y >= op.startY + absDelta; y--) {
+            const dstBase = y * fpCols;
+            const srcBase = (y - absDelta) * fpCols;
+            for (let x = 0; x < size.cols; x++)
+              currentFP[dstBase + x] = prevFP[srcBase + x];
+          }
+          for (let y = op.startY; y < op.startY + absDelta; y++) {
+            const base = y * fpCols;
+            insertedRows.add(y);
+            explicitRowsToRender.add(y);
+            for (let x = 0; x < size.cols; x++)
+              currentFP[base + x] = blankFP;
+          }
+        }
+        frameParts.push("\x1B[r");
+      }
+      const explicitDirtyRows = Array.from(explicitRowsToRender).sort(
+        (a, b) => a - b
+      );
+      const overlayDirtyRows = overlayTouchedRowSet ? explicitDirtyRows.filter((y) => overlayTouchedRowSet.has(y)) : [];
+      const paintedExplicitRows = [];
+      for (const y of explicitDirtyRows) {
+        const row = terminal.getRow(y);
+        const overlayRow = overlayTouchedRowSet == null ? void 0 : overlayTouchedRowSet.has(y);
+        if (overlayRow || useConservativeDirtyRowRendering) {
+          fingerprintRow(row, y, size.cols);
+          renderRow2(y, row);
+          paintedExplicitRows.push(y);
+          continue;
+        }
+        const span = (() => {
+          if (insertedRows.has(y)) {
+            fingerprintRow(row, y, size.cols);
+            return resolveChangedSpanAgainstFill(row, y, size.cols, blankFP);
+          }
+          return resolveChangedSpanAgainstReference(row, y, size.cols);
+        })();
+        if (!span) {
+          if (!skipUnchangedDirtyRows)
+            fingerprintRow(row, y, size.cols);
+          if (!skipUnchangedDirtyRows) {
+            renderRow2(y, row);
+            paintedExplicitRows.push(y);
+          }
+          continue;
+        }
+        const rewriteTail = !insertedRows.has(y) && shouldRewriteRowTail(row, y, size.cols, currentFP);
+        fingerprintRow(row, y, size.cols);
+        renderRow2(
+          y,
+          row,
+          span.startX,
+          rewriteTail ? row.length : span.endXExclusive,
+          rewriteTail || span.endXExclusive >= row.length
+        );
+        paintedExplicitRows.push(y);
+      }
+      if (isDebugEnabled() && overlayDirtyRows.length) {
+        getDebugLog().render(
+          ` Explicit scroll ops overlay rows: [${overlayDirtyRows.join(", ")}]`
+        );
+      }
+      profiledRowCount = explicitDirtyRows.length;
+      scrollHandled = true;
+    } else if (useScrollRegions && scrollRowsCandidate) {
+      for (let y = 0; y < size.rows; y++) {
+        fingerprintRow(terminal.getRow(y), y, size.cols);
+      }
+      const shift = detectScrollShift(
+        size.cols,
+        scrollRowsCandidate,
+        overlayRows
+      );
+      if (shift) {
+        if (currentFP.length === prevFP.length)
+          currentFP.set(prevFP);
+        hasFrameOutput = true;
+        if (isDebugEnabled()) {
+          getDebugLog().render(
+            ` Scroll region: delta=${shift.delta}, region=${shift.regionStart}-${shift.regionEnd - 1}, new rows=${shift.newRowStart}-${shift.newRowEnd - 1}`
+          );
+        }
+        frameParts.push(`\x1B[${shift.regionStart + 1};${shift.regionEnd}r`);
+        if (shift.delta > 0) {
+          frameParts.push(`\x1B[${shift.regionEnd};1H`);
+          frameParts.push(`\x1B[${shift.delta}S`);
+        } else {
+          frameParts.push(`\x1B[${shift.regionStart + 1};1H`);
+          frameParts.push(`\x1B[${-shift.delta}T`);
+        }
+        frameParts.push("\x1B[r");
+        if (shift.delta > 0) {
+          for (let y = shift.regionStart; y < shift.regionEnd - shift.delta; y++) {
+            const dstBase = y * fpCols;
+            const srcBase = (y + shift.delta) * fpCols;
+            for (let x = 0; x < size.cols; x++)
+              currentFP[dstBase + x] = prevFP[srcBase + x];
+          }
+          for (let y = shift.regionEnd - shift.delta; y < shift.regionEnd; y++) {
+            const base = y * fpCols;
+            for (let x = 0; x < size.cols; x++)
+              currentFP[base + x] = blankFP;
+          }
+        } else {
+          const absDelta = -shift.delta;
+          for (let y = shift.regionEnd - 1; y >= shift.regionStart + absDelta; y--) {
+            const dstBase = y * fpCols;
+            const srcBase = (y - absDelta) * fpCols;
+            for (let x = 0; x < size.cols; x++)
+              currentFP[dstBase + x] = prevFP[srcBase + x];
+          }
+          for (let y = shift.regionStart; y < shift.regionStart + absDelta; y++) {
+            const base = y * fpCols;
+            for (let x = 0; x < size.cols; x++)
+              currentFP[base + x] = blankFP;
+          }
+        }
+        for (let y = shift.newRowStart; y < shift.newRowEnd; y++) {
+          const row = terminal.getRow(y);
+          fingerprintRow(row, y, size.cols);
+          renderRow2(y, row);
+        }
+        const extraDirtyRows = overlayRowSet ? shift.extraDirtyRows.filter(
+          (y) => !overlayRowSet.has(y) || Boolean(overlayPartialRowSet == null ? void 0 : overlayPartialRowSet.has(y))
+        ) : shift.extraDirtyRows;
+        for (const y of extraDirtyRows) {
+          const row = terminal.getRow(y);
+          const overlayRow = overlayTouchedRowSet == null ? void 0 : overlayTouchedRowSet.has(y);
+          if (overlayRow || useConservativeDirtyRowRendering) {
+            fingerprintRow(row, y, size.cols);
+            renderRow2(y, row);
+            continue;
+          }
+          const span = resolveChangedSpanAgainstReference(row, y, size.cols);
+          if (!span) {
+            if (!skipUnchangedDirtyRows) {
+              fingerprintRow(row, y, size.cols);
+              renderRow2(y, row);
+            }
+            continue;
+          }
+          const rewriteTail = shouldRewriteRowTail(row, y, size.cols, currentFP);
+          renderRow2(
+            y,
+            row,
+            span.startX,
+            rewriteTail ? row.length : span.endXExclusive,
+            rewriteTail || span.endXExclusive >= row.length
+          );
+          fingerprintRow(row, y, size.cols);
+        }
+        for (let y = shift.newRowStart; y < shift.newRowEnd; y++) {
+          fingerprintRow(terminal.getRow(y), y, size.cols);
+        }
+        const renderedRows = /* @__PURE__ */ new Set();
+        for (let y = shift.newRowStart; y < shift.newRowEnd; y++)
+          renderedRows.add(y);
+        for (const y of extraDirtyRows)
+          renderedRows.add(y);
+        profiledRowCount = renderedRows.size;
+        scrollHandled = true;
+      }
+    }
+    if (!scrollHandled && denseDirtyRows && scrollRowsCandidate && useScrollRegions) {
+      rowsToRender = scrollRowsCandidate;
+      profiledRowCount = rowsToRender.length;
+      if (isDebugEnabled()) {
+        getDebugLog().render(
+          ` Dense dirty rows fell back to partial render: ${rowsToRender.length} rows`
+        );
+      }
+    }
+    if (scrollHandled) {
+    } else if (!rowsToRender) {
       if (isDebugEnabled())
         getDebugLog().render(` Full render: ${size.rows} rows`);
       for (let y = 0; y < size.rows; y++) {
         const row = terminal.getRow(y);
+        fingerprintRow(row, y, size.cols);
         renderRow2(y, row);
       }
     } else {
-      const repaintFullDirtyRows = overlayPlaneHasVisibleContent();
+      const overlayDirtyRows = overlayTouchedRowSet ? rowsToRender.filter((y) => overlayTouchedRowSet.has(y)) : [];
       if (isDebugEnabled()) {
         getDebugLog().render(
-          ` Partial render: ${rowsToRender.length} dirty rows: [${rowsToRender.join(", ")}]${repaintFullDirtyRows ? " (overlay-full-row)" : ""}`
+          ` Partial render: ${rowsToRender.length} dirty rows: [${rowsToRender.join(", ")}]${overlayDirtyRows.length ? ` (overlay-full-row: [${overlayDirtyRows.join(", ")}])` : ""}`
         );
       }
       for (const y of rowsToRender) {
         const row = terminal.getRow(y);
-        if (repaintFullDirtyRows) {
+        fingerprintRow(row, y, size.cols);
+        const overlayRow = overlayTouchedRowSet == null ? void 0 : overlayTouchedRowSet.has(y);
+        if (overlayRow || useConservativeDirtyRowRendering) {
           renderRow2(y, row);
           continue;
         }
-        const span = resolveChangedSpan(row, renderedRowCache[y]);
+        const span = resolveChangedSpan(row, y, size.cols);
         if (!span) {
-          renderRow2(y, row);
+          if (!skipUnchangedDirtyRows)
+            renderRow2(y, row);
           continue;
         }
+        const rewriteTail = shouldRewriteRowTail(row, y, size.cols, prevFP);
         renderRow2(
           y,
           row,
           span.startX,
-          span.endXExclusive,
-          span.endXExclusive >= row.length
+          rewriteTail ? row.length : span.endXExclusive,
+          rewriteTail || span.endXExclusive >= row.length
         );
       }
     }
@@ -7793,20 +9377,36 @@ function createStdoutRenderer(terminal, options) {
         activeStyleKey = bgKey;
       }
       for (let i = 0; i < extraRows; i++) {
+        hasFrameOutput = true;
         frameParts.push(rowClearToEol[size.rows + i]);
       }
     }
     if (!rowsToRender)
       lastRenderedRows = size.rows;
-    if (!rowsToRender || renderedRowCache.length !== size.rows)
-      renderedRowCache.length = size.rows;
+    const tmpFP = prevFP;
+    prevFP = currentFP;
+    currentFP = tmpFP;
+    fpPrevValid = true;
+    prevOverlayBlockedRows = overlayCoverage.blockedRows;
+    prevOverlayPartialRows = overlayCoverage.partialRows;
+    let emittedCursorPos = null;
     if (getImeAnchor) {
       const anchor = getImeAnchor();
       if (anchor) {
         const { x, y } = clampCellToViewport(anchor, size);
-        frameParts.push(`\x1B[${y + 1};${x + 1}H`);
+        if (hasFrameOutput || x !== lastCursorX || y !== lastCursorY) {
+          hasFrameOutput = true;
+          emittedCursorPos = { x, y };
+          frameParts.push(`\x1B[${y + 1};${x + 1}H`);
+        }
       }
     }
+    if (!hasFrameOutput) {
+      if (isDebugEnabled())
+        getDebugLog().render(" No-op frame skipped");
+      cliLatency == null ? void 0 : cliLatency.recordStdoutNoOutput();
+      return;
+    }
     if (enableOsc8Links && activeStyle.href)
       frameParts.push(OSC8_CLOSE);
     frameParts.push(SGR_RESET);
@@ -7816,9 +9416,9 @@ function createStdoutRenderer(terminal, options) {
     if (profiler) {
       profiler.recordRender({
         durationMs: profiler.now() - renderStart,
-        rows: rowsToRender ? rowsToRender.length : size.rows,
+        rows: profiledRowCount,
         nodes: 0,
-        fullRepaint: !rowsToRender,
+        fullRepaint: !rowsToRender && !scrollHandled,
         sorted: dirtySorted
       });
     }
@@ -7944,6 +9544,13 @@ function createStdoutRenderer(terminal, options) {
     {
       const writeMs = performance.now() - writeStart;
       writeEmaMs = writeEmaMs === 0 ? writeMs : writeEmaMs * 0.85 + writeMs * 0.15;
+      if (emittedCursorPos) {
+        lastCursorX = emittedCursorPos.x;
+        lastCursorY = emittedCursorPos.y;
+      } else {
+        lastCursorX = null;
+        lastCursorY = null;
+      }
       recordStdoutFrame({
         at: Date.now(),
         bytes: frame.length,
@@ -7958,6 +9565,11 @@ function createStdoutRenderer(terminal, options) {
           mode: writeMode === "sync" ? "sync" : writeMode === "chunked" ? "chunked" : "stream"
         });
       }
+      cliLatency == null ? void 0 : cliLatency.recordStdoutWrite({
+        durationMs: writeMs,
+        bytes: frame.length,
+        mode: writeMode === "sync" ? "sync" : writeMode === "chunked" ? "chunked" : "stream"
+      });
     }
     if (isDebugEnabled()) {
       const totalTime = (performance.now() - renderStart).toFixed(2);
@@ -7965,7 +9577,7 @@ function createStdoutRenderer(terminal, options) {
       getDebugLog().render(`doRender() END`);
     }
   }
-  function render(dirtyRows) {
+  function render(dirtyRows, sync, scrollOperations, skipUnchangedDirtyRows = false) {
     if (disposed)
       return;
     if (isDebugEnabled()) {
@@ -7973,6 +9585,24 @@ function createStdoutRenderer(terminal, options) {
         `render() called: dirtyRows=${(dirtyRows == null ? void 0 : dirtyRows.length) ?? "null"}, pending=${pendingRender}, elapsed=${Date.now() - lastFrameTime}ms`
       );
     }
+    const isSmallSyncPatch = Boolean(
+      sync && (dirtyRows == null ? void 0 : dirtyRows.length) && dirtyRows.length <= 12 && !(scrollOperations == null ? void 0 : scrollOperations.length)
+    );
+    if (isSmallSyncPatch)
+      skipUnchangedDirtyRows = false;
+    if ((dirtyRows == null ? void 0 : dirtyRows.length) && skipUnchangedDirtyRows && fpPrevValid && !(scrollOperations == null ? void 0 : scrollOperations.length) && dirtyRows.length < terminal.size().rows) {
+      const cols = terminal.size().cols;
+      const nextDirtyRows = dirtyRows.filter((y) => !rowMatchesPreviousFrame(y, cols));
+      if (nextDirtyRows.length === 0) {
+        if (isDebugEnabled()) {
+          getDebugLog().render(
+            `Skipped unchanged dirty commit: ${dirtyRows.length} rows`
+          );
+        }
+        return;
+      }
+      dirtyRows = nextDirtyRows;
+    }
     const ensureDirtyBits = (rowCount) => {
       if (!accumulatedDirtyBits || accumulatedDirtyBits.length !== rowCount) {
         accumulatedDirtyBits = new Uint8Array(rowCount);
@@ -8003,12 +9633,43 @@ function createStdoutRenderer(terminal, options) {
       out2.length = outLen;
       return outLen ? out2 : null;
     };
+    const buildAccumulatedScrollOperations = () => {
+      return (accumulatedScrollOperations == null ? void 0 : accumulatedScrollOperations.length) ? accumulatedScrollOperations : null;
+    };
+    const mergeScrollOperations = (next) => {
+      if (!(next == null ? void 0 : next.length) || accumulatedAllRows)
+        return;
+      const merged = accumulatedScrollOperations ? accumulatedScrollOperations.slice() : [];
+      for (const op of next) {
+        const startY = Math.floor(op.startY);
+        const endY = Math.floor(op.endY);
+        const delta = Math.trunc(op.delta);
+        if (endY <= startY || delta === 0)
+          continue;
+        const existingIndex = merged.findIndex(
+          (existing) => existing.startY === startY && existing.endY === endY
+        );
+        if (existingIndex >= 0) {
+          const existing = merged[existingIndex];
+          const nextDelta = existing.delta + delta;
+          if (nextDelta === 0)
+            merged.splice(existingIndex, 1);
+          else
+            merged[existingIndex] = { startY, endY, delta: nextDelta };
+        } else {
+          merged.push({ startY, endY, delta });
+        }
+      }
+      accumulatedScrollOperations = merged.length ? merged : null;
+    };
     if (!dirtyRows || dirtyRows.length === 0) {
       accumulatedAllRows = true;
       accumulatedDirtyBits = null;
       accumulatedDirtyCount = 0;
       accumulatedDirtyMin = Number.POSITIVE_INFINITY;
       accumulatedDirtyMax = -1;
+      accumulatedScrollOperations = null;
+      accumulatedSkipUnchangedDirtyRows = false;
     } else if (!accumulatedAllRows) {
       const rowCount = terminal.size().rows;
       const bits = ensureDirtyBits(rowCount);
@@ -8025,14 +9686,35 @@ function createStdoutRenderer(terminal, options) {
             accumulatedDirtyMax = y;
         }
       }
+      mergeScrollOperations(scrollOperations);
+      accumulatedSkipUnchangedDirtyRows && (accumulatedSkipUnchangedDirtyRows = skipUnchangedDirtyRows);
+    }
+    const now4 = Date.now();
+    const elapsed = now4 - lastFrameTime;
+    const queuedDelayMs = Math.max(0, MIN_FRAME_MS - elapsed);
+    if (pendingRender && !sync) {
+      cliLatency == null ? void 0 : cliLatency.recordStdoutQueued(queuedDelayMs);
+      return;
     }
-    if (pendingRender)
+    if (sync) {
+      if (pendingRender) {
+        pendingRender = false;
+        if (renderTimer) {
+          clearTimeout(renderTimer);
+          renderTimer = null;
+        }
+      }
+      const rows = buildAccumulatedRows();
+      const pendingScrolls = buildAccumulatedScrollOperations();
+      cliLatency == null ? void 0 : cliLatency.recordStdoutQueued(0);
+      doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
       return;
-    const now3 = Date.now();
-    const elapsed = now3 - lastFrameTime;
+    }
     if (elapsed >= MIN_FRAME_MS) {
       const rows = buildAccumulatedRows();
-      doRender(rows);
+      const pendingScrolls = buildAccumulatedScrollOperations();
+      cliLatency == null ? void 0 : cliLatency.recordStdoutQueued(0);
+      doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
     } else {
       pendingRender = true;
       if (renderTimer)
@@ -8041,11 +9723,16 @@ function createStdoutRenderer(terminal, options) {
         renderTimer = null;
         if (!disposed) {
           const rows = buildAccumulatedRows();
-          doRender(rows);
+          const pendingScrolls = buildAccumulatedScrollOperations();
+          doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
         }
-      }, MIN_FRAME_MS - elapsed);
+      }, queuedDelayMs);
+      cliLatency == null ? void 0 : cliLatency.recordStdoutQueued(queuedDelayMs);
     }
   }
+  terminal.setFingerprintFn((ch, style) => {
+    return styleKey2(style) << 16 | charHash16(ch);
+  });
   if (altScreen && out.isTTY)
     out.write("\x1B[?1049h");
   if (hideCursor)
@@ -8053,13 +9740,13 @@ function createStdoutRenderer(terminal, options) {
   if (clear) {
     out.write(`${SGR_RESET}${openBg(defaultBg)}\x1B[2J\x1B[H${SGR_RESET}`);
   }
-  const off = terminal.on("commit", ({ dirtyRows }) => {
+  const off = terminal.on("commit", ({ dirtyRows, scrollOperations, sync }) => {
     if (isDebugEnabled()) {
       getDebugLog().render(
-        `Commit event: dirtyRows=${(dirtyRows == null ? void 0 : dirtyRows.length) ?? "null"}, rows=${(dirtyRows == null ? void 0 : dirtyRows.join(",")) ?? "all"}`
+        `Commit event: dirtyRows=${(dirtyRows == null ? void 0 : dirtyRows.length) ?? "null"}, rows=${(dirtyRows == null ? void 0 : dirtyRows.join(",")) ?? "all"}${(scrollOperations == null ? void 0 : scrollOperations.length) ? `, scrollOps=${scrollOperations.map((op) => `${op.startY}-${op.endY - 1}:${op.delta}`).join("|")}` : ""}${sync ? " (sync)" : ""}`
       );
     }
-    render(dirtyRows);
+    render(dirtyRows, sync, scrollOperations, true);
   });
   const resizeSource = (options == null ? void 0 : options.output) ?? import_node_process9.default.stdout;
   const canTrackResize = Boolean(
@@ -8093,6 +9780,8 @@ function createStdoutRenderer(terminal, options) {
       { cols: size.cols, rows: size.rows }
     );
     out.write(`\x1B[${cy + 1};${cx + 1}H`);
+    lastCursorX = cx;
+    lastCursorY = cy;
   }
   function showCursor(visible) {
     if (disposed)
@@ -8137,7 +9826,10 @@ function createStdoutRenderer(terminal, options) {
     if ("palette" in next)
       palette = next.palette;
     styleKeyCache2 = /* @__PURE__ */ new WeakMap();
-    renderedRowCache = [];
+    fpRows = 0;
+    fpPrevValid = false;
+    prevOverlayBlockedRows = [];
+    prevOverlayPartialRows = [];
     render();
   };
   return { render, dispose, setCursor, showCursor, updateTheme };
@@ -8324,6 +10016,12 @@ var rowCache = /* @__PURE__ */ new WeakMap();
 function segmentsToKey(segments) {
   return segments.map((s) => `${s.key}:${s.text}:${s.cols}:${s.wide}`).join("|");
 }
+function isPlainStyle(style) {
+  return !style.fg && !style.bg && !style.bold && !style.dim && !style.italic && !style.underline && !style.inverse && !style.href;
+}
+function isTransparentBlankRow(segments) {
+  return segments.length === 1 && isPlainStyle(segments[0].style) && segments[0].text.trim().length === 0;
+}
 function renderRow(terminal, metrics2, wideScaleX, y, lineEl) {
   const segments = computeRowSegments(terminal, y);
   const newKey = segmentsToKey(segments);
@@ -8331,6 +10029,10 @@ function renderRow(terminal, metrics2, wideScaleX, y, lineEl) {
   if (cachedKey === newKey)
     return;
   rowCache.set(lineEl, newKey);
+  if (isTransparentBlankRow(segments)) {
+    lineEl.replaceChildren();
+    return;
+  }
   const fragment = document.createDocumentFragment();
   for (const seg of segments) {
     const span = document.createElement("span");
@@ -8353,6 +10055,7 @@ function createDomRenderer(terminal, container) {
   container.style.whiteSpace = "pre";
   container.style.display = "inline-block";
   container.style.overflow = "hidden";
+  container.style.position = "relative";
   container.style.userSelect = "text";
   container.style.outline = "none";
   container.style.contain = "layout style";
@@ -8360,21 +10063,105 @@ function createDomRenderer(terminal, container) {
   installAnsiPaletteCssVars(container);
   let metrics2 = measureCell(container);
   let wideScaleX = 1;
-  let lineEls = [];
+  const planeLayers = /* @__PURE__ */ new Map();
   let raf = 0;
-  const pending = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
   let disposed = false;
+  function applyPlaneOffset(plane, offsetPx) {
+    const layer = planeLayers.get(plane);
+    if (!layer)
+      return;
+    const next = Number.isFinite(offsetPx) ? offsetPx : 0;
+    if (layer.offsetPx === next)
+      return;
+    layer.offsetPx = next;
+    layer.contentEl.style.transform = next ? `translateY(${next}px)` : "translateY(0px)";
+  }
+  function applyPlaneViewport(plane, viewport) {
+    const layer = planeLayers.get(plane);
+    if (!layer)
+      return;
+    const totalHeight = terminal.size().rows * metrics2.cellHeight;
+    if (!viewport) {
+      layer.viewportTopPx = 0;
+      layer.viewportHeightPx = null;
+      layer.el.style.clipPath = "none";
+      return;
+    }
+    const topPx = Math.max(
+      0,
+      Math.min(totalHeight, Math.floor(viewport.topPx))
+    );
+    const heightPx = Math.max(
+      0,
+      Math.min(totalHeight - topPx, Math.floor(viewport.heightPx))
+    );
+    layer.viewportTopPx = topPx;
+    layer.viewportHeightPx = heightPx;
+    if (topPx === 0 && heightPx >= totalHeight) {
+      layer.el.style.clipPath = "none";
+      return;
+    }
+    const bottomPx = Math.max(0, totalHeight - topPx - heightPx);
+    layer.el.style.clipPath = `inset(${topPx}px 0px ${bottomPx}px 0px)`;
+  }
   function rebuildLines() {
     const { rows, cols } = terminal.size();
     container.style.width = `${cols * metrics2.cellWidth}px`;
     container.style.height = `${rows * metrics2.cellHeight}px`;
     const fragment = document.createDocumentFragment();
-    lineEls = Array.from({ length: rows }, () => {
-      const line = document.createElement("div");
-      line.style.cssText = `height:${metrics2.cellHeight}px;width:${cols * metrics2.cellWidth}px;overflow:hidden;contain:layout style`;
-      fragment.appendChild(line);
-      return line;
-    });
+    for (let i = 0; i < TERMINAL_RENDER_PLANES.length; i++) {
+      const plane = TERMINAL_RENDER_PLANES[i];
+      const planeTerminal = getPlaneTerminal(terminal, plane);
+      let layer = planeLayers.get(plane);
+      if (!layer) {
+        const el = document.createElement("div");
+        const contentEl = document.createElement("div");
+        el.dataset.vtPlane = plane;
+        el.style.pointerEvents = "none";
+        contentEl.style.position = "absolute";
+        contentEl.style.left = "0";
+        contentEl.style.top = "0";
+        layer = {
+          el,
+          contentEl,
+          lines: [],
+          offsetPx: 0,
+          terminal: planeTerminal,
+          viewportTopPx: 0,
+          viewportHeightPx: null
+        };
+        planeLayers.set(plane, layer);
+      }
+      layer.terminal = planeTerminal;
+      layer.el.style.position = "absolute";
+      layer.el.style.left = "0";
+      layer.el.style.top = "0";
+      layer.el.style.width = `${cols * metrics2.cellWidth}px`;
+      layer.el.style.height = `${rows * metrics2.cellHeight}px`;
+      layer.el.style.overflow = "hidden";
+      layer.el.style.zIndex = String(i);
+      layer.contentEl.style.width = `${cols * metrics2.cellWidth}px`;
+      layer.contentEl.style.height = `${rows * metrics2.cellHeight}px`;
+      applyPlaneOffset(plane, layer.offsetPx);
+      applyPlaneViewport(
+        plane,
+        layer.viewportHeightPx == null ? null : {
+          topPx: layer.viewportTopPx,
+          heightPx: layer.viewportHeightPx
+        }
+      );
+      const lineFragment = document.createDocumentFragment();
+      layer.lines = Array.from({ length: rows }, () => {
+        const line = document.createElement("div");
+        line.style.cssText = `height:${metrics2.cellHeight}px;width:${cols * metrics2.cellWidth}px;overflow:hidden;contain:layout style`;
+        lineFragment.appendChild(line);
+        return line;
+      });
+      layer.contentEl.replaceChildren(lineFragment);
+      layer.el.replaceChildren(layer.contentEl);
+      fragment.appendChild(layer.el);
+    }
     container.replaceChildren(fragment);
   }
   function refresh() {
@@ -8383,28 +10170,54 @@ function createDomRenderer(terminal, container) {
     wideScaleX = wideW > 0 ? Math.max(1, Math.min(2, metrics2.cellWidth * 2 / wideW)) : 1;
     rebuildLines();
     const size = terminal.size();
-    for (let y = 0; y < size.rows; y++)
-      renderRow(terminal, metrics2, wideScaleX, y, lineEls[y]);
+    for (const plane of TERMINAL_RENDER_PLANES) {
+      const layer = planeLayers.get(plane);
+      if (!layer)
+        continue;
+      for (let y = 0; y < size.rows; y++)
+        renderRow(layer.terminal, metrics2, wideScaleX, y, layer.lines[y]);
+    }
   }
   function flushPending() {
     raf = 0;
     if (disposed)
       return;
-    for (const y of pending) {
-      const line = lineEls[y];
-      if (line)
-        renderRow(terminal, metrics2, wideScaleX, y, line);
+    for (const plane of TERMINAL_RENDER_PLANES) {
+      const layer = planeLayers.get(plane);
+      const rows = pending.get(plane);
+      if (!layer || !(rows == null ? void 0 : rows.size))
+        continue;
+      for (const y of rows) {
+        const line = layer.lines[y];
+        if (line)
+          renderRow(layer.terminal, metrics2, wideScaleX, y, line);
+      }
+      rows.clear();
     }
-    pending.clear();
   }
-  const offCommit = terminal.on("commit", ({ dirtyRows }) => {
+  const offCommit = terminal.on("commit", ({ dirtyRows, planes }) => {
+    const activePlanes = (planes == null ? void 0 : planes.length) ? planes : TERMINAL_RENDER_PLANES;
     if (dirtyRows === null) {
       const size = terminal.size();
-      for (let y = 0; y < size.rows; y++)
-        pending.add(y);
+      for (const plane of activePlanes) {
+        let rows = pending.get(plane);
+        if (!rows) {
+          rows = /* @__PURE__ */ new Set();
+          pending.set(plane, rows);
+        }
+        for (let y = 0; y < size.rows; y++)
+          rows.add(y);
+      }
     } else {
-      for (const y of dirtyRows)
-        pending.add(y);
+      for (const plane of activePlanes) {
+        let rows = pending.get(plane);
+        if (!rows) {
+          rows = /* @__PURE__ */ new Set();
+          pending.set(plane, rows);
+        }
+        for (const y of dirtyRows)
+          rows.add(y);
+      }
     }
     if (!raf) {
       raf = -1;
@@ -8433,7 +10246,14 @@ function createDomRenderer(terminal, container) {
       if (raf > 0)
         cancelAnimationFrame(raf);
       pending.clear();
+      planeLayers.clear();
       container.replaceChildren();
+    },
+    setPlaneOffset(plane, offsetPx) {
+      applyPlaneOffset(plane, offsetPx);
+    },
+    setPlaneViewport(plane, viewport) {
+      applyPlaneViewport(plane, viewport);
     }
   };
 }
@@ -8602,23 +10422,39 @@ function useTerminal() {
 
 // src/vue/composables/use-render-node.ts
 var pendingInvalidateByScheduler = /* @__PURE__ */ new WeakMap();
-function requestBatchedInvalidate(scheduler, plane) {
+function mergePriority(prev, next) {
+  if (prev === "high" || next === "high")
+    return "high";
+  if (prev === "normal" || next === "normal")
+    return "normal";
+  return "low";
+}
+function requestBatchedInvalidate(scheduler, plane, priority) {
   let state = pendingInvalidateByScheduler.get(scheduler);
   if (!state) {
-    state = { queued: false, plane: null };
+    state = { queued: false, plane: null, priority: "low" };
     pendingInvalidateByScheduler.set(scheduler, state);
   }
   if (state.queued) {
     state.plane = state.plane == null || state.plane === plane ? plane : null;
+    state.priority = mergePriority(state.priority, priority);
     return;
   }
   state.plane = plane;
+  state.priority = priority;
   state.queued = true;
   queueMicrotask(() => {
     state.queued = false;
     const queuedPlane = state.plane;
+    const queuedPriority = state.priority;
     state.plane = null;
-    scheduler.invalidate(queuedPlane ? { plane: queuedPlane } : void 0);
+    state.priority = "low";
+    scheduler.invalidate(
+      queuedPlane || queuedPriority !== "normal" ? {
+        plane: queuedPlane ?? void 0,
+        priority: queuedPriority
+      } : void 0
+    );
   });
 }
 function useRenderNode(getOptions) {
@@ -8626,11 +10462,13 @@ function useRenderNode(getOptions) {
   const parentStack = useRenderStack();
   const plane = (0, import_vue7.inject)(RenderPlaneContextKey, (0, import_vue7.ref)("default"));
   const id = (0, import_vue7.ref)(null);
+  const lastPlane = (0, import_vue7.ref)(plane.value);
   const options = (0, import_vue7.computed)(() => getOptions());
   const stop = (0, import_vue7.watchEffect)(() => {
     const opt = options.value;
     void opt.deps;
     const stack = opt.stack ?? parentStack.value;
+    lastPlane.value = plane.value;
     if (!stack)
       return;
     if (!id.value) {
@@ -8642,23 +10480,24 @@ function useRenderNode(getOptions) {
         paint: opt.paint
       });
       id.value = node.id;
-      requestBatchedInvalidate(scheduler, plane.value);
+      requestBatchedInvalidate(scheduler, plane.value, opt.priority ?? "normal");
       return;
     }
     render.update(id.value, {
       stack,
       zIndex: opt.zIndex ?? 0,
       rect: opt.rect ?? null,
+      dirtyRowsHint: opt.dirtyRowsHint,
       plane: plane.value,
       paint: opt.paint
     });
-    requestBatchedInvalidate(scheduler, plane.value);
+    requestBatchedInvalidate(scheduler, plane.value, opt.priority ?? "normal");
   });
   (0, import_vue7.onBeforeUnmount)(() => {
     stop();
     if (id.value) {
       render.unregister(id.value);
-      requestBatchedInvalidate(scheduler, plane.value);
+      requestBatchedInvalidate(scheduler, lastPlane.value, "normal");
     }
   });
   return { id };
@@ -9902,6 +11741,7 @@ function mentionIndexAt2(value, mentionToken, index) {
   return countMentionTokens2(value, mentionToken, index);
 }
 function createPromptMentionPlugin(options = {}) {
+  const latency = getCliLatencyProfiler();
   return {
     name: "promptMention",
     install: (ctx) => {
@@ -9910,6 +11750,8 @@ function createPromptMentionPlugin(options = {}) {
         ctx.render.rootStack,
         1e4
       );
+      let lastTopClampedRect = null;
+      let lastPromptRect = null;
       const derivedStyleCache = /* @__PURE__ */ new WeakMap();
       const reactiveProps = (0, import_vue10.reactive)({
         promptSuggestions: getProps().promptSuggestions,
@@ -9957,6 +11799,25 @@ function createPromptMentionPlugin(options = {}) {
         multilineToken: "\uFFFC",
         mentionToken: ctx.mentionToken
       });
+      (0, import_vue10.watch)(
+        () => {
+          if (!ctx.visible.value || !promptMention.promptVisible.value)
+            return null;
+          const rect = promptMention.promptRect.value;
+          return [
+            Math.floor(rect.x),
+            Math.floor(rect.y),
+            Math.floor(rect.w),
+            Math.floor(rect.h)
+          ].join(":");
+        },
+        (nextRectKey, prevRectKey) => {
+          if (!prevRectKey || nextRectKey === prevRectKey)
+            return;
+          ctx.render.invalidatePlane("default");
+          ctx.scheduler.invalidate({ priority: "high" });
+        }
+      );
       ctx.registerChipStyleProvider({
         getStyle: (baseStyle, chip) => {
           if (chip.kind !== "mention")
@@ -10043,6 +11904,12 @@ function createPromptMentionPlugin(options = {}) {
             query: ctx0.query
           });
           if (handled !== false) {
+            const value = ctx.getValue();
+            const before2 = value.slice(0, ctx0.tokenStart);
+            const after2 = value.slice(ctx0.tokenEnd);
+            const nextValue2 = `${before2}${after2}`;
+            ctx.pushUndoSnapshot(nextValue2);
+            ctx.applyEdit(nextValue2, ctx0.tokenStart);
             promptMention.promptSuppressedKey.value = ctx0.key;
             ctx.scheduler.invalidate();
             return;
@@ -10086,8 +11953,17 @@ function createPromptMentionPlugin(options = {}) {
         var _a2, _b2, _c, _d;
         if (!promptMention.promptVisible.value)
           return false;
+        const markPromptOperation = (suffix) => {
+          const ctx0 = promptMention.activeContext.value;
+          const mentionTrigger = getProps().mentionTrigger || "@";
+          const skillTrigger = getProps().skillTrigger || "";
+          const tokenText = String((ctx0 == null ? void 0 : ctx0.tokenText) ?? "");
+          const scope = tokenText.startsWith(mentionTrigger) ? "prompt.mention" : skillTrigger && tokenText.startsWith(skillTrigger) ? "prompt.skill" : "prompt.command";
+          latency == null ? void 0 : latency.markOperation(`${scope}.${suffix}`);
+        };
         const len = promptMention.promptMatches.value.length;
         if (e.key === "ArrowDown") {
+          markPromptOperation("navigate.next");
           e.preventDefault();
           if (len <= 0) {
             promptMention.promptActive.value = 0;
@@ -10104,6 +11980,7 @@ function createPromptMentionPlugin(options = {}) {
           return true;
         }
         if (e.key === "ArrowUp") {
+          markPromptOperation("navigate.prev");
           e.preventDefault();
           if (len <= 0) {
             promptMention.promptActive.value = 0;
@@ -10139,11 +12016,13 @@ function createPromptMentionPlugin(options = {}) {
             const candidate = String(((_c = match == null ? void 0 : match.item) == null ? void 0 : _c.value) ?? "");
             if (!typed || !candidate.startsWith(typed))
               return false;
+            markPromptOperation("accept");
             e.preventDefault();
             acceptPrompt(promptMention.promptActive.value);
             return true;
           }
           if (e.key === "Tab" && (isMention || isSkill)) {
+            markPromptOperation("accept");
             e.preventDefault();
             if (len === 0)
               return true;
@@ -10160,11 +12039,13 @@ function createPromptMentionPlugin(options = {}) {
           }
           if (len === 0)
             return false;
+          markPromptOperation("accept");
           e.preventDefault();
           acceptPrompt(promptMention.promptActive.value);
           return true;
         }
         if (e.key === "Escape") {
+          markPromptOperation("dismiss");
           e.preventDefault();
           promptMention.promptSuppressedKey.value = ((_d = promptMention.activeContext.value) == null ? void 0 : _d.key) ?? null;
           ctx.scheduler.invalidate();
@@ -10176,6 +12057,28 @@ function createPromptMentionPlugin(options = {}) {
       useRenderNode(() => ({
         zIndex: getProps().zIndex + 5,
         stack: promptOverlayStack,
+        dirtyRowsHint: (() => {
+          const currentRect = ctx.visible.value && promptMention.promptVisible.value ? {
+            y: Math.floor(promptMention.promptRect.value.y),
+            h: Math.max(0, Math.floor(promptMention.promptRect.value.h))
+          } : null;
+          const rects = [lastPromptRect, currentRect].filter(Boolean);
+          if (!rects.length)
+            return void 0;
+          const maxRows = ctx.terminal.size().rows;
+          const start = Math.max(
+            0,
+            Math.min(...rects.map((rect) => rect.y)) - 1
+          );
+          const end = Math.min(
+            maxRows,
+            Math.max(...rects.map((rect) => rect.y + rect.h)) + 1
+          );
+          if (end <= start)
+            return void 0;
+          return Array.from({ length: end - start }, (_, index) => start + index);
+        })(),
+        priority: "high",
         rect: ctx.visible.value && promptMention.promptVisible.value ? promptMention.promptRect.value : { x: 0, y: 0, w: 0, h: 0 },
         deps: [
           ctx.visible.value,
@@ -10199,6 +12102,10 @@ function createPromptMentionPlugin(options = {}) {
           const r = promptMention.promptRect.value;
           if (r.w < 3 || r.h < 3)
             return;
+          lastPromptRect = {
+            y: Math.floor(r.y),
+            h: Math.max(0, Math.floor(r.h))
+          };
           const base = getProps().style ?? ctx.defaultStyle.value;
           const selectedOverride = { bg: "blue" };
           const styleKey2 = base && typeof base === "object" ? base : null;
@@ -10231,6 +12138,18 @@ function createPromptMentionPlugin(options = {}) {
           const contentW = Math.max(0, innerW - sidePad * 2);
           const contentX = x0 + 1 + sidePad;
           const borderStyle = derived.borderStyle;
+          if (lastTopClampedRect && y0 > 0) {
+            ctx.terminal.write(spaces(lastTopClampedRect.w), {
+              x: lastTopClampedRect.x,
+              y: 0,
+              style: getProps().style ?? ctx.defaultStyle.value
+            });
+            lastTopClampedRect = null;
+          }
+          if (y0 === 0)
+            lastTopClampedRect = { x: x0, w };
+          else
+            lastTopClampedRect = null;
           ctx.terminal.write(`\u250C${repeatChar("\u2500", innerW)}\u2510`, {
             x: x0,
             y: y0,
@@ -12376,6 +14295,8 @@ var TerminalProvider = (0, import_vue19.defineComponent)({
     let rafToken = 0;
     let pendingInvalidate = false;
     let timer = null;
+    let holdNormalInvalidates = false;
+    let holdReleaseToken = 0;
     let pendingInvalidateAllPlanes = false;
     const pendingInvalidatePlanes = /* @__PURE__ */ new Set();
     let imeComposing = false;
@@ -12406,12 +14327,12 @@ var TerminalProvider = (0, import_vue19.defineComponent)({
       pendingInvalidatePlanes.clear();
       return activePlanes;
     }
-    function flush() {
+    function flush(sync = false) {
       if (unmounting)
         return;
       const activePlanes = takeActivePlanes();
       render.render({ activePlanes });
-      terminal.commit({ planes: activePlanes });
+      terminal.commit({ planes: activePlanes, sync });
       updateImePositionAfterFlush == null ? void 0 : updateImePositionAfterFlush();
     }
     function clearTimer() {
@@ -12420,6 +14341,18 @@ var TerminalProvider = (0, import_vue19.defineComponent)({
       clearTimeout(timer);
       timer = null;
     }
+    function scheduleNormalInvalidateRelease() {
+      const token = ++holdReleaseToken;
+      void (0, import_vue19.nextTick)(() => {
+        if (token !== holdReleaseToken)
+          return;
+        holdNormalInvalidates = false;
+        if (unmounting || !pendingInvalidate)
+          return;
+        pendingInvalidate = false;
+        invalidate({ priority: "normal" });
+      });
+    }
     function flushNow() {
       if (unmounting)
         return;
@@ -12431,7 +14364,9 @@ var TerminalProvider = (0, import_vue19.defineComponent)({
         raf = 0;
       }
       clearTimer();
-      flush();
+      holdNormalInvalidates = true;
+      scheduleNormalInvalidateRelease();
+      flush(true);
     }
     function invalidate(options) {
       if (unmounting)
@@ -12443,6 +14378,10 @@ var TerminalProvider = (0, import_vue19.defineComponent)({
         flushNow();
         return;
       }
+      if (holdNormalInvalidates) {
+        pendingInvalidate = true;
+        return;
+      }
       if (priority === "low") {
         if (timer || raf)
           return;
@@ -13022,6 +14961,8 @@ var TerminalProvider = (0, import_vue19.defineComponent)({
     (0, import_vue19.onBeforeUnmount)(() => {
       unmounting = true;
       offCommit == null ? void 0 : offCommit();
+      clearTimer();
+      holdReleaseToken++;
       if (raf > 0)
         cancelAnimationFrame(raf);
       raf = 0;
@@ -14024,7 +15965,10 @@ var TInput = (0, import_vue21.defineComponent)({
       emit("input", nextValue);
       if (commit)
         emit("change", nextValue);
-      scheduler.invalidate();
+      scheduler.flushNow();
+      void (0, import_vue21.nextTick)(() => {
+        scheduler.flushNow();
+      });
     }
     function applyMove(nextCursor, extend) {
       const prev = cursor.value;
@@ -14058,7 +16002,7 @@ var TInput = (0, import_vue21.defineComponent)({
       }
       ensureCursorVisible();
       syncImeAnchorNow();
-      scheduler.invalidate();
+      scheduler.flushNow();
     }
     (0, import_vue21.watch)(
       [() => absRect.value.w, () => absRect.value.h, () => wrapMode.value],
@@ -14192,7 +16136,11 @@ var TInput = (0, import_vue21.defineComponent)({
           terminal,
           scheduler,
           defaultStyle,
-          render,
+          render: {
+            rootStack: render.rootStack,
+            createStack: render.createStack,
+            invalidatePlane: render.invalidatePlane
+          },
           visible,
           rawAbsRect,
           eventZ,
@@ -14306,7 +16254,7 @@ var TInput = (0, import_vue21.defineComponent)({
       emitMentions(nextMentions);
       ensureCursorVisible();
       syncImeAnchorNow();
-      scheduler.invalidate();
+      scheduler.flushNow();
     }
     function removePendingPasteImage(placeholderPath) {
       const current = getCurrentMentions();
@@ -15124,10 +17072,12 @@ var TInput = (0, import_vue21.defineComponent)({
           clearAll();
           return;
         }
-        focused.value = false;
-        anchor.value = null;
-        emit("blur");
-        scheduler.invalidate();
+        const manager = events.value;
+        if (manager && manager.getFocused()) {
+          manager.focus(null);
+          return;
+        }
+        applyBlur();
         return;
       }
       if (isPrintableKey(e)) {
@@ -15390,6 +17340,7 @@ var TInput = (0, import_vue21.defineComponent)({
       var _a2;
       return {
         zIndex: props.zIndex,
+        priority: pendingValue.value != null ? "high" : "normal",
         rect: visible.value ? absRect.value : { x: 0, y: 0, w: 0, h: 0 },
         deps: [
           visible.value,
@@ -15417,6 +17368,7 @@ var TInput = (0, import_vue21.defineComponent)({
           blinkOn.value,
           defaultStyle.value,
           ((_a2 = chipStyleProvider.value) == null ? void 0 : _a2.version.value) ?? 0,
+          pendingValue.value,
           props.skillHighlightStyle,
           props.skillTrigger
         ],
@@ -15986,26 +17938,34 @@ var import_vue24 = require("vue");
 
 // src/vue/utils/wheel-scroll.ts
 var LINE_UNIT_THRESHOLD = 3;
-var PIXELS_PER_LINE = 100;
+var PIXELS_PER_LINE = 0.75;
 var ACCEL_WINDOW_MS = 120;
-var MAX_ACCEL = 2.5;
+var MAX_ACCEL = 26;
 var EDGE_BOUNCE_MS = 120;
 var MIN_TICK_INTERVAL_MS = 6;
 function clamp5(n, min, max) {
   return Math.max(min, Math.min(max, n));
 }
-function isLineUnitDelta(deltaY) {
+function isLineUnitDelta(deltaY, mode = "auto") {
+  if (mode === "line")
+    return true;
+  if (mode === "pixel")
+    return false;
   const abs = Math.abs(deltaY);
   return abs > 0 && abs <= LINE_UNIT_THRESHOLD && Number.isInteger(deltaY);
 }
-function normalizeDelta(deltaY) {
+function normalizeDelta(deltaY, mode = "auto") {
+  if (mode === "line")
+    return deltaY;
+  if (mode === "pixel")
+    return deltaY / PIXELS_PER_LINE;
   const abs = Math.abs(deltaY);
   if (abs <= LINE_UNIT_THRESHOLD && Number.isInteger(deltaY))
     return deltaY;
   return deltaY / PIXELS_PER_LINE;
 }
-function accelFactor(now3, lastAt) {
-  const dt = now3 - lastAt;
+function accelFactor(now4, lastAt) {
+  const dt = now4 - lastAt;
   if (!Number.isFinite(dt) || dt <= 0 || dt > ACCEL_WINDOW_MS)
     return 1;
   const t = 1 - dt / ACCEL_WINDOW_MS;
@@ -16016,25 +17976,30 @@ function createWheelScrollState() {
     accumulator: 0,
     lastAt: 0,
     lastEdgeDir: 0,
-    lastEdgeAt: 0
+    lastEdgeAt: 0,
+    lastLineUnitDir: 0
   };
 }
-function applyWheelScroll(state, deltaY, scrollTop, maxTop, now3 = Date.now()) {
+function applyWheelScroll(state, deltaY, scrollTop, maxTop, now4 = Date.now(), deltaMode = "auto", options = {}) {
   if (!Number.isFinite(deltaY) || deltaY === 0 || maxTop <= 0) {
     if (maxTop <= 0) {
       state.accumulator = 0;
       state.lastEdgeDir = 0;
       state.lastEdgeAt = 0;
+      state.lastLineUnitDir = 0;
     }
     return { nextTop: scrollTop, dir: 0, lines: 0 };
   }
-  const dt = state.lastAt ? now3 - state.lastAt : Infinity;
-  const lineUnits = isLineUnitDelta(deltaY);
-  if (lineUnits && dt !== Infinity && dt >= 0 && dt < MIN_TICK_INTERVAL_MS)
+  const dt = state.lastAt ? now4 - state.lastAt : Infinity;
+  const lineUnits = isLineUnitDelta(deltaY, deltaMode);
+  const inputDir = Math.sign(normalizeDelta(deltaY, deltaMode));
+  if (lineUnits && dt !== Infinity && dt >= 0 && dt < MIN_TICK_INTERVAL_MS && inputDir === state.lastLineUnitDir) {
     return { nextTop: scrollTop, dir: 0, lines: 0 };
-  const accel = lineUnits ? 1 : state.lastAt ? accelFactor(now3, state.lastAt) : 1;
-  state.lastAt = now3;
-  state.accumulator += normalizeDelta(deltaY) * accel;
+  }
+  state.lastLineUnitDir = lineUnits ? inputDir : 0;
+  const accel = lineUnits ? 1 : options.disableAcceleration ? 1 : state.lastAt ? accelFactor(now4, state.lastAt) : 1;
+  state.lastAt = now4;
+  state.accumulator += normalizeDelta(deltaY, deltaMode) * accel;
   const lines = Math.trunc(state.accumulator);
   if (lines === 0)
     return { nextTop: scrollTop, dir: 0, lines: 0 };
@@ -16044,11 +18009,11 @@ function applyWheelScroll(state, deltaY, scrollTop, maxTop, now3 = Date.now()) {
   const atBottom = scrollTop >= maxTop;
   if (dir < 0 && atTop || dir > 0 && atBottom) {
     state.lastEdgeDir = dir;
-    state.lastEdgeAt = now3;
+    state.lastEdgeAt = now4;
     state.accumulator = 0;
     return { nextTop: scrollTop, dir: 0, lines: 0 };
   }
-  if (state.lastEdgeDir !== 0 && now3 - state.lastEdgeAt < EDGE_BOUNCE_MS && dir === -state.lastEdgeDir && (atTop || atBottom)) {
+  if (state.lastEdgeDir !== 0 && now4 - state.lastEdgeAt < EDGE_BOUNCE_MS && dir === -state.lastEdgeDir && (atTop || atBottom)) {
     return { nextTop: scrollTop, dir: 0, lines: 0 };
   }
   const unclamped = scrollTop + lines;
@@ -16071,6 +18036,18 @@ function applyWheelScroll(state, deltaY, scrollTop, maxTop, now3 = Date.now()) {
 function clamp6(n, min, max) {
   return Math.max(min, Math.min(max, n));
 }
+function getWheelScrollInput(e) {
+  const deltaY = Number(e.deltaY ?? 0);
+  const deltaMode = typeof e.deltaMode === "number" ? e.deltaMode : void 0;
+  if (Number.isInteger(deltaY) && deltaY !== 0 && Math.abs(deltaY) >= 100 && Math.abs(deltaY) % 100 === 0 && (deltaMode == null || deltaMode === 0)) {
+    return { deltaY: deltaY / 100, mode: "line" };
+  }
+  if (deltaMode === 1)
+    return { deltaY, mode: "line" };
+  if (deltaMode === 0)
+    return { deltaY, mode: "pixel" };
+  return { deltaY, mode: "auto" };
+}
 var TList = (0, import_vue24.defineComponent)({
   name: "TList",
   props: {
@@ -16249,7 +18226,8 @@ var TList = (0, import_vue24.defineComponent)({
             commit(idx);
         },
         wheel: (e) => {
-          const delta = e.deltaY ?? 0;
+          const { deltaY, mode } = getWheelScrollInput(e);
+          const delta = deltaY;
           if (!delta)
             return;
           const h18 = Math.max(0, props.h);
@@ -16258,7 +18236,9 @@ var TList = (0, import_vue24.defineComponent)({
             wheelState,
             delta,
             scrollTop.value,
-            maxTop
+            maxTop,
+            Date.now(),
+            mode
           );
           if (!dir || nextTop === scrollTop.value)
             return;
@@ -16552,6 +18532,18 @@ init_path();
 function clamp7(n, min, max) {
   return Math.max(min, Math.min(max, n));
 }
+function getWheelScrollInput2(e) {
+  const deltaY = Number(e.deltaY ?? 0);
+  const deltaMode = typeof e.deltaMode === "number" ? e.deltaMode : void 0;
+  if (Number.isInteger(deltaY) && deltaY !== 0 && Math.abs(deltaY) >= 100 && Math.abs(deltaY) % 100 === 0 && (deltaMode == null || deltaMode === 0)) {
+    return { deltaY: deltaY / 100, mode: "line" };
+  }
+  if (deltaMode === 1)
+    return { deltaY, mode: "line" };
+  if (deltaMode === 0)
+    return { deltaY, mode: "pixel" };
+  return { deltaY, mode: "auto" };
+}
 function isCtrlLike(e) {
   return Boolean(e.ctrlKey || e.metaKey);
 }
@@ -16917,7 +18909,8 @@ var TPathPicker = (0, import_vue26.defineComponent)({
           await trySelect(s.absPath);
         },
         wheel: (e) => {
-          const delta = e.deltaY ?? 0;
+          const { deltaY, mode } = getWheelScrollInput2(e);
+          const delta = deltaY;
           if (!delta)
             return;
           const h18 = Math.max(0, listH.value);
@@ -16926,7 +18919,9 @@ var TPathPicker = (0, import_vue26.defineComponent)({
             wheelState,
             delta,
             scrollTop.value,
-            maxTop
+            maxTop,
+            Date.now(),
+            mode
           );
           if (!dir || nextTop === scrollTop.value)
             return;
@@ -18073,6 +20068,7 @@ var TRouterView = (0, import_vue32.defineComponent)({
   defaultTInputHostPlugin,
   detectTerminalColorCapability,
   formatInlineCellLine,
+  getCliLatencyProfiler,
   getStdoutRendererMetrics,
   lintJsonText,
   normalizeNewlines,