@simon_he/vue-tui 1.0.0 → 1.0.2

package/dist/cli.cjs

@@ -3674,7 +3674,7 @@ function clamp(n, min, max) {
 function setFingerprintFn(buffer, fn) {
   buffer.fingerprintFn = fn;
   const len = buffer.rows * buffer.cols;
-  if (!len) {
+  if (!fn || !len) {
     buffer.soaFingerprints = null;
     return;
   }
@@ -3692,7 +3692,12 @@ function setFingerprintFn(buffer, fn) {
 function getRowFingerprints(buffer, y) {
   if (!buffer.soaFingerprints)
     return null;
-  const physY = physicalRowIndex(buffer, y);
+  if (buffer.rows <= 0 || buffer.cols <= 0)
+    return null;
+  const yy = Math.floor(y);
+  if (!Number.isFinite(yy) || yy < 0 || yy >= buffer.rows)
+    return null;
+  const physY = physicalRowIndex(buffer, yy);
   const base = physY * buffer.cols;
   return buffer.soaFingerprints.subarray(base, base + buffer.cols);
 }
@@ -4988,11 +4993,17 @@ function createTerminal(opts) {
       },
       setFingerprintFn(fn) {
         assertNotDisposed();
-        base.setFingerprintFn(fn);
+        const state = getPlaneState(plane);
+        setFingerprintFn(state.buffer, fn);
       },
       getRowFingerprints(y) {
         assertNotDisposed();
-        return base.getRowFingerprints(y);
+        const yy = Math.floor(y);
+        const state = getPlaneState(plane);
+        if (!Number.isFinite(yy) || yy < 0 || yy >= state.buffer.rows) {
+          throw new RangeError("Row out of bounds");
+        }
+        return getRowFingerprints(state.buffer, yy);
       }
     };
     planeTerminals.set(plane, api);
@@ -5187,7 +5198,11 @@ function createTerminal(opts) {
     },
     getRowFingerprints(y) {
       assertNotDisposed();
-      return getRowFingerprints(compositeBuffer, y);
+      const yy = Math.floor(y);
+      if (!Number.isFinite(yy) || yy < 0 || yy >= compositeBuffer.rows) {
+        throw new RangeError("Row out of bounds");
+      }
+      return getRowFingerprints(compositeBuffer, yy);
     }
   };
   base[TERMINAL_PLANE_INTERNALS] = {
@@ -9327,6 +9342,7 @@ var SYNC_START = "\x1B[?2026h";
 var SYNC_END = "\x1B[?2026l";
 var OSC8_OPEN = (href) => `\x1B]8;;${href}\x07`;
 var OSC8_CLOSE = "\x1B]8;;\x07";
+var stdoutFingerprintOwners = /* @__PURE__ */ new WeakMap();
 function createStdoutRenderer(terminal, options) {
   var _a, _b;
   const env = ((_a = import_node_process6.default) == null ? void 0 : _a.env) ?? {};
@@ -9336,9 +9352,17 @@ function createStdoutRenderer(terminal, options) {
   if (!output)
     throw new Error("createStdoutRenderer requires a Node stdout-like output");
   const out = output;
+  const outputFd = Number(out.fd);
+  const canUseSyncStdout = (options == null ? void 0 : options.output) == null && Number.isInteger(outputFd) && outputFd === 1;
+  const fingerprintOwner = Symbol("stdout-renderer");
+  let ownsFingerprintFn = false;
+  const fingerprintTerminal = terminal;
+  const canInstallTerminalFingerprintFn = () => typeof fingerprintTerminal.setFingerprintFn === "function" && typeof fingerprintTerminal.getRowFingerprints === "function";
+  const outputIsTTY = Boolean(out.isTTY);
+  const outputAllowsOsc8Links = out.isTTY !== false;
   const clear = (options == null ? void 0 : options.clear) ?? true;
   const hideCursor = (options == null ? void 0 : options.hideCursor) ?? true;
-  const altScreen = (options == null ? void 0 : options.altScreen) ?? Boolean(out.isTTY);
+  const altScreen = (options == null ? void 0 : options.altScreen) ?? outputIsTTY;
   let defaultBg = (options == null ? void 0 : options.defaultBg) == null || (options == null ? void 0 : options.defaultBg) === "transparent" ? void 0 : (options == null ? void 0 : options.defaultBg) ?? "black";
   let palette = (options == null ? void 0 : options.palette) ?? null;
   const trackResize = (options == null ? void 0 : options.trackResize) ?? true;
@@ -9353,11 +9377,11 @@ function createStdoutRenderer(terminal, options) {
   function resolveUseSyncOutput() {
     if ((options == null ? void 0 : options.useSyncOutput) != null)
       return options.useSyncOutput;
-    const term = String(env.TERM ?? "").toLowerCase();
+    const term2 = String(env.TERM ?? "").toLowerCase();
     const termProgram2 = String(env.TERM_PROGRAM ?? "").toLowerCase();
     const termProgramVersion = env.TERM_PROGRAM_VERSION;
     const isGhostty2 = "GHOSTTY_RESOURCES_DIR" in env;
-    const isProblematicTerminal = isGhostty2 || termProgram2.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;
     }
@@ -9386,10 +9410,134 @@ function createStdoutRenderer(terminal, options) {
   const chunkThresholdBytes = 64 * 1024;
   const syncMaxBytes = 128 * 1024;
   const dirtyFullThreshold = 0.6;
+  const DIRTY_SPAN_MERGE_GAP_CELLS = 2;
+  const DIRTY_SPAN_MAX_PER_ROW = 12;
+  const DIRTY_SPAN_FULL_ROW_THRESHOLD = 0.7;
+  const EST_STYLE_SWITCH_BYTES = 8;
+  const EST_CLEAR_TO_EOL_BYTES = 3;
   const disableCursorPos = false;
   const termProgram = String(env.TERM_PROGRAM ?? "").trim().toLowerCase();
+  const term = String(env.TERM ?? "").trim().toLowerCase();
+  const isKitty = "KITTY_WINDOW_ID" in env || termProgram.includes("kitty") || term.includes("kitty");
+  const isAlacritty = "ALACRITTY_WINDOW_ID" in env || "ALACRITTY_LOG" in env || termProgram.includes("alacritty") || term.includes("alacritty");
+  const isWezTerm = "WEZTERM_PANE" in env || "WEZTERM_EXECUTABLE" in env || termProgram.includes("wezterm");
   const isVscodeTerminal = termProgram === "vscode" || "VSCODE_PID" in env || "VSCODE_IPC_HOOK_CLI" in env;
-  const enableOsc8Links = out.isTTY !== false && !isVscodeTerminal;
+  const useConservativeDirtyRows = Boolean(
+    outputIsTTY && (isGhostty || isKitty || isAlacritty || isWezTerm)
+  );
+  const normalizeDirtyRowPatchMode = (value) => {
+    const normalized = typeof value === "string" ? value.trim().toLowerCase() : value;
+    return normalized === "auto" || normalized === "row" || normalized === "span" ? normalized : null;
+  };
+  const normalizeColumnDiffMode = (value) => {
+    if (value === true)
+      return "span";
+    if (value === false)
+      return "row";
+    if (typeof value === "string" && value.trim().toLowerCase() === "auto")
+      return "auto";
+    return null;
+  };
+  const firstValidDirtyRowPatchMode = (...values) => {
+    for (const value of values) {
+      const mode = normalizeDirtyRowPatchMode(value);
+      if (mode)
+        return mode;
+    }
+    return null;
+  };
+  function resolveDirtyRowPatchMode() {
+    const explicitMode = options == null ? void 0 : options.dirtyRowPatchMode;
+    if (explicitMode != null) {
+      const optionMode = normalizeDirtyRowPatchMode(explicitMode);
+      if (!optionMode) {
+        throw new Error(
+          `Invalid dirtyRowPatchMode=${JSON.stringify(
+            explicitMode
+          )}; expected "auto", "row", or "span".`
+        );
+      }
+      return optionMode;
+    }
+    const legacy = options == null ? void 0 : options.columnDiff;
+    if (legacy !== void 0) {
+      const legacyMode = normalizeColumnDiffMode(legacy);
+      if (!legacyMode) {
+        throw new Error(
+          `Invalid columnDiff=${JSON.stringify(legacy)}; expected boolean or "auto".`
+        );
+      }
+      return legacyMode;
+    }
+    const envMode = firstValidDirtyRowPatchMode(
+      env.VUE_TUI_DIRTY_ROW_PATCH_MODE,
+      env.DIMCODE_TUI_DIRTY_ROW_RENDER_MODE,
+      env.DIMCODE_TUI_DIRTY_ROW_PATCH_MODE
+    );
+    if (envMode)
+      return envMode;
+    return "auto";
+  }
+  const dirtyRowPatchMode = resolveDirtyRowPatchMode();
+  const dirtySpanConservativeMaxCells = (() => {
+    if ((options == null ? void 0 : options.dirtySpanConservativeMaxCells) !== void 0) {
+      const raw2 = options.dirtySpanConservativeMaxCells;
+      const value2 = typeof raw2 === "number" ? raw2 : Number(raw2);
+      if (!Number.isFinite(value2) || value2 <= 0) {
+        throw new Error(
+          `Invalid dirtySpanConservativeMaxCells=${JSON.stringify(
+            raw2
+          )}; expected a positive finite number.`
+        );
+      }
+      return Math.floor(value2);
+    }
+    const raw = firstNonEmptyEnv(
+      env,
+      "VUE_TUI_DIRTY_SPAN_MAX_CELLS",
+      "DIMCODE_TUI_DIRTY_SPAN_MAX_CELLS"
+    );
+    const value = Number(raw);
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : 32;
+  })();
+  function resolveInternalColumnDiffMode() {
+    const value = options == null ? void 0 : options.__columnDiffMode;
+    if (value == null)
+      return "auto";
+    if (value === "auto" || value === "single-span" || value === "multi-span" || value === "full-row") {
+      return value;
+    }
+    throw new Error(
+      `Invalid __columnDiffMode=${JSON.stringify(
+        value
+      )}; expected "auto", "single-span", "multi-span", or "full-row".`
+    );
+  }
+  const columnDiffMode = resolveInternalColumnDiffMode();
+  function resolveEffectiveDirtyRowPatchMode() {
+    switch (columnDiffMode) {
+      case "full-row":
+        return "row";
+      case "single-span":
+        return "single-span";
+      case "multi-span":
+        return "multi-span";
+      case "auto":
+        break;
+    }
+    switch (dirtyRowPatchMode) {
+      case "row":
+        return "row";
+      case "span":
+      case "auto":
+        return "multi-span";
+    }
+  }
+  const effectiveDirtyRowPatchMode = resolveEffectiveDirtyRowPatchMode();
+  const shouldUseDirtySpans = () => effectiveDirtyRowPatchMode !== "row";
+  const shouldUseMultiDirtySpans = () => effectiveDirtyRowPatchMode === "multi-span";
+  const enableOsc8Links = outputAllowsOsc8Links && !isVscodeTerminal;
+  const renderedHref = (value) => enableOsc8Links ? normalizeHref(value) : null;
   let disposed = false;
   let lastFrameTime = 0;
   let pendingRender = false;
@@ -9402,8 +9550,9 @@ function createStdoutRenderer(terminal, options) {
   let accumulatedDirtyCount = 0;
   let accumulatedDirtyMin = Number.POSITIVE_INFINITY;
   let accumulatedDirtyMax = -1;
+  let accumulatedDirtyRowsRequireRepaint = false;
   let accumulatedScrollOperations = null;
-  const MIN_FRAME_MS = !out.isTTY ? 0 : 16;
+  const MIN_FRAME_MS = outputIsTTY ? 16 : 0;
   function clampCellToViewport(cell, size) {
     const maxX = Math.max(0, Math.floor(size.cols) - 1);
     const maxY = Math.max(0, Math.floor(size.rows) - 1);
@@ -9421,60 +9570,74 @@ function createStdoutRenderer(terminal, options) {
     const env2 = ((_a2 = import_node_process6.default) == null ? void 0 : _a2.env) ?? {};
     return detectTerminalColorCapability({
       env: env2,
-      isTTY: Boolean(out.isTTY),
+      isTTY: outputIsTTY,
       platform: String(((_b2 = import_node_process6.default) == null ? void 0 : _b2.platform) ?? "")
     }).mode;
   }
   const colorMode = resolveColorMode();
   const enableDim = colorMode === "truecolor";
-  const COLOR_INDEX = {
-    black: 1,
-    red: 2,
-    green: 3,
-    yellow: 4,
-    blue: 5,
-    magenta: 6,
-    cyan: 7,
-    white: 8,
-    blackBright: 9,
-    redBright: 10,
-    greenBright: 11,
-    yellowBright: 12,
-    blueBright: 13,
-    magentaBright: 14,
-    cyanBright: 15,
-    whiteBright: 16
-  };
-  const BUILTIN_COLOR_INDEX = { ...COLOR_INDEX };
-  let nextColorIdx = 17;
-  const MAX_COLOR_INDEX = 255;
-  function colorIndex(color) {
-    if (!color)
-      return 0;
-    let idx = COLOR_INDEX[color];
-    if (idx !== void 0)
-      return idx;
-    if (nextColorIdx > MAX_COLOR_INDEX)
-      return MAX_COLOR_INDEX;
-    idx = nextColorIdx++;
-    COLOR_INDEX[color] = idx;
-    return idx;
-  }
   let styleKeyCache = /* @__PURE__ */ new WeakMap();
+  const styleKeyIndex = /* @__PURE__ */ new Map();
+  let nextStyleKey = 1;
+  const MAX_STYLE_KEYS = 131072;
+  const MAX_UINT32_INTERN_ID = 4294967295;
+  const STYLE_KEY_SEP = "";
   const normalizedHrefCache = /* @__PURE__ */ new Map();
   const MAX_HREF_CACHE = 2048;
-  const HREF_STYLE_FLAG = 1 << 21;
+  let fingerprintInternResetRequiresBaseline = false;
+  let fingerprintBaselineGeneration = 0;
+  let activeRenderBaselineGeneration = 0;
+  let terminalFingerprintFnDirty = false;
+  let fingerprintInstallBlockedByExternalProvider = false;
+  function invalidateFingerprintBaseline() {
+    fpPrevValid = false;
+    fingerprintInternResetRequiresBaseline = true;
+    fingerprintBaselineGeneration++;
+  }
+  const activeRenderBaselineChanged = () => activeRenderBaselineGeneration !== fingerprintBaselineGeneration;
+  function resetStyleKeyIndex(resetIds = false) {
+    styleKeyCache = /* @__PURE__ */ new WeakMap();
+    styleKeyIndex.clear();
+    if (resetIds)
+      nextStyleKey = 1;
+    terminalFingerprintFnDirty = true;
+    invalidateFingerprintBaseline();
+  }
+  function internStyleKey(signature) {
+    const cached = styleKeyIndex.get(signature);
+    if (cached !== void 0)
+      return cached;
+    if (styleKeyIndex.size >= MAX_STYLE_KEYS) {
+      resetStyleKeyIndex();
+    }
+    if (nextStyleKey >= MAX_UINT32_INTERN_ID)
+      resetStyleKeyIndex(true);
+    const key = nextStyleKey++;
+    styleKeyIndex.set(signature, key);
+    return key;
+  }
+  function styleSignature(style) {
+    return [
+      style.fg ?? "",
+      style.bg ?? defaultBg ?? "",
+      style.bold ? "1" : "0",
+      enableDim && style.dim ? "1" : "0",
+      style.italic ? "1" : "0",
+      style.underline ? "1" : "0",
+      style.inverse ? "1" : "0",
+      renderedHref(style.href) ? "1" : "0"
+    ].join(STYLE_KEY_SEP);
+  }
   function styleKey(style) {
     const cached = styleKeyCache.get(style);
     if (cached !== void 0)
       return cached;
-    const href = normalizeHref(style.href);
-    const key = colorIndex(style.fg) | colorIndex(style.bg ?? defaultBg) << 8 | (style.bold ? 1 << 16 : 0) | (enableDim && style.dim ? 1 << 17 : 0) | (style.italic ? 1 << 18 : 0) | (style.underline ? 1 << 19 : 0) | (style.inverse ? 1 << 20 : 0) | (href ? HREF_STYLE_FLAG : 0);
+    const key = internStyleKey(styleSignature(style));
     styleKeyCache.set(style, key);
     return key;
   }
   function styleKeyFromParts(style) {
-    return colorIndex(style.fg) | colorIndex(style.bg ?? defaultBg) << 8 | (style.bold ? 1 << 16 : 0) | (enableDim && style.dim ? 1 << 17 : 0) | (style.italic ? 1 << 18 : 0) | (style.underline ? 1 << 19 : 0) | (style.inverse ? 1 << 20 : 0) | (normalizeHref(style.href) ? HREF_STYLE_FLAG : 0);
+    return internStyleKey(styleSignature(style));
   }
   function normalizeHref(value) {
     if (typeof value !== "string")
@@ -9577,17 +9740,26 @@ function createStdoutRenderer(terminal, options) {
   let prevFP = new Uint32Array(0);
   let currentHrefIds = new Uint32Array(0);
   let prevHrefIds = new Uint32Array(0);
+  let currentTextIds = new Uint32Array(0);
+  let prevTextIds = new Uint32Array(0);
   let fpPrevValid = false;
+  let nextCellTextId = 1;
+  let blankTextId = 0;
+  let emptyTextId = 0;
+  let continuationTextId = 0;
+  const cellTextIdCache = /* @__PURE__ */ new Map();
+  const MAX_CELL_TEXT_IDS = 131072;
   let prevOverlayBlockedRows = [];
   let prevOverlayPartialRows = [];
   const hrefIndex = /* @__PURE__ */ new Map();
   let nextHrefId = 1;
   const MAX_HREF_IDS = 8192;
   let hrefIndexResetRequiresBaseline = false;
-  function resetHrefIndex() {
+  function resetHrefIndex(resetIds = false) {
     hrefIndex.clear();
-    nextHrefId = 1;
-    fpPrevValid = false;
+    if (resetIds)
+      nextHrefId = 1;
+    invalidateFingerprintBaseline();
     hrefIndexResetRequiresBaseline = true;
   }
   function ensureFingerprints(cols, rows) {
@@ -9600,52 +9772,457 @@ function createStdoutRenderer(terminal, options) {
     prevFP = new Uint32Array(len);
     currentHrefIds = new Uint32Array(len);
     prevHrefIds = new Uint32Array(len);
+    currentTextIds = new Uint32Array(len);
+    prevTextIds = new Uint32Array(len);
     fpPrevValid = false;
     prevOverlayBlockedRows = [];
     prevOverlayPartialRows = [];
   }
-  function charHash10(ch) {
-    if (ch.length <= 1)
-      return (ch.charCodeAt(0) || 0) & 1023;
-    let h2 = 33052;
-    for (let i = 0; i < ch.length; i++) {
-      h2 ^= ch.charCodeAt(i);
-      h2 = h2 * 257 & 65535;
+  function cellFingerprintFromStyleKey(_ch, key) {
+    return key >>> 0;
+  }
+  function cellFingerprint(_ch, style) {
+    return styleKey(style) >>> 0;
+  }
+  function allocateCellTextId(text) {
+    const id = nextCellTextId++;
+    cellTextIdCache.set(text, id);
+    return id;
+  }
+  function resetCellTextIdCache(resetIds = false) {
+    cellTextIdCache.clear();
+    if (resetIds)
+      nextCellTextId = 1;
+    blankTextId = allocateCellTextId(" ");
+    emptyTextId = allocateCellTextId("");
+    continuationTextId = nextCellTextId++;
+    invalidateFingerprintBaseline();
+  }
+  function cellIdentityTextId(cell) {
+    if (cell.continuation)
+      return continuationTextId;
+    if (cell.ch === "")
+      return emptyTextId;
+    return cellTextId(cell.ch);
+  }
+  function cellTextId(text) {
+    let cached = cellTextIdCache.get(text);
+    if (cached !== void 0)
+      return cached;
+    const mustResetTextIds = nextCellTextId >= MAX_UINT32_INTERN_ID - 2;
+    if (cellTextIdCache.size >= MAX_CELL_TEXT_IDS || mustResetTextIds) {
+      resetCellTextIdCache(mustResetTextIds);
+      cached = cellTextIdCache.get(text);
+      if (cached !== void 0)
+        return cached;
     }
-    return h2 & 1023;
+    return allocateCellTextId(text);
   }
+  resetCellTextIdCache(true);
   function hrefId(href) {
     if (!href)
       return 0;
     const cached = hrefIndex.get(href);
     if (cached != null)
       return cached;
-    if (hrefIndex.size >= MAX_HREF_IDS || nextHrefId >= 4294967295) {
-      resetHrefIndex();
+    const mustResetHrefIds = nextHrefId >= MAX_UINT32_INTERN_ID;
+    if (hrefIndex.size >= MAX_HREF_IDS || mustResetHrefIds) {
+      resetHrefIndex(mustResetHrefIds);
     }
     const id = nextHrefId++;
     hrefIndex.set(href, id);
     return id;
   }
-  function cellFingerprint(ch, style) {
-    return styleKey(style) << 10 | charHash10(ch);
+  const BLANK_STYLE = Object.freeze({});
+  const BLANK_CELL = Object.freeze({
+    ch: " ",
+    width: 1,
+    style: BLANK_STYLE
+  });
+  const cellAt = (row, x) => row[x] ?? BLANK_CELL;
+  function rowFingerprintsForThisRenderer(y) {
+    var _a2;
+    if (terminalFingerprintFnDirty)
+      return null;
+    if (!ownsFingerprintFn || stdoutFingerprintOwners.get(terminal) !== fingerprintOwner)
+      return null;
+    return ((_a2 = fingerprintTerminal.getRowFingerprints) == null ? void 0 : _a2.call(fingerprintTerminal, y)) ?? null;
+  }
+  function hasActiveExternalFingerprintProvider() {
+    if (!canInstallTerminalFingerprintFn())
+      return false;
+    if (stdoutFingerprintOwners.has(terminal))
+      return false;
+    try {
+      const rows = terminal.size().rows;
+      if (rows <= 0)
+        return false;
+      return fingerprintTerminal.getRowFingerprints(0) != null;
+    } catch {
+      return false;
+    }
+  }
+  function shouldAttemptFingerprintInstall() {
+    return !fingerprintInstallBlockedByExternalProvider || !hasActiveExternalFingerprintProvider();
   }
   function fingerprintRow(row, y, cols) {
-    const rowFP = terminal.getRowFingerprints(y);
+    const rowFP = rowFingerprintsForThisRenderer(y);
     const base = y * fpCols;
-    if (rowFP && rowFP.length >= cols) {
+    if (rowFP && rowFP.length >= cols && row.length >= cols) {
       currentFP.set(rowFP.subarray(0, cols), base);
     } else {
       for (let x = 0; x < cols; x++) {
-        const cell = row[x];
+        const cell = cellAt(row, x);
         currentFP[base + x] = cellFingerprint(cell.ch, cell.style);
       }
     }
     for (let x = 0; x < cols; x++) {
-      const cell = row[x];
-      currentHrefIds[base + x] = hrefId(normalizeHref(cell.style.href));
+      const cell = cellAt(row, x);
+      currentHrefIds[base + x] = hrefId(renderedHref(cell.style.href));
+      currentTextIds[base + x] = cellIdentityTextId(cell);
+    }
+  }
+  function snapshotRowFingerprints(row, y, cols) {
+    const fp = new Uint32Array(cols);
+    const hrefIds = new Uint32Array(cols);
+    const textIds = new Uint32Array(cols);
+    const rowFP = rowFingerprintsForThisRenderer(y);
+    if (rowFP && rowFP.length >= cols && row.length >= cols) {
+      fp.set(rowFP.subarray(0, cols));
+    } else {
+      for (let x = 0; x < cols; x++) {
+        const cell = cellAt(row, x);
+        fp[x] = cellFingerprint(cell.ch, cell.style);
+      }
     }
+    for (let x = 0; x < cols; x++) {
+      const cell = cellAt(row, x);
+      hrefIds[x] = hrefId(renderedHref(cell.style.href));
+      textIds[x] = cellIdentityTextId(cell);
+    }
+    return { fp, hrefIds, textIds };
   }
+  const currentCellMatchesPrevious = (base, x) => {
+    return currentFP[base + x] === prevFP[base + x] && currentTextIds[base + x] === prevTextIds[base + x] && currentHrefIds[base + x] === prevHrefIds[base + x];
+  };
+  const cellMatchesPreviousAt = (currentBase, previousBase, x) => {
+    return currentFP[currentBase + x] === prevFP[previousBase + x] && currentTextIds[currentBase + x] === prevTextIds[previousBase + x] && currentHrefIds[currentBase + x] === prevHrefIds[previousBase + x];
+  };
+  const referenceCellMatchesCurrent = (row, rowFP, base, x, cols, referenceFP, referenceHrefIds, referenceTextIds) => {
+    const cell = cellAt(row, x);
+    const fingerprint = rowFP && rowFP.length >= cols && row.length >= cols ? rowFP[x] : cellFingerprint(cell.ch, cell.style);
+    return fingerprint === referenceFP[base + x] && cellIdentityTextId(cell) === referenceTextIds[base + x] && hrefId(renderedHref(cell.style.href)) === referenceHrefIds[base + x];
+  };
+  const fullRowDirtySpan = (cols) => {
+    return cols > 0 ? [{ startX: 0, endXExclusive: cols }] : [];
+  };
+  const dirtySpanWidth = (span) => Math.max(0, span.endXExclusive - span.startX);
+  const dirtySpanCoverage = (spans) => {
+    let total = 0;
+    for (const span of spans)
+      total += dirtySpanWidth(span);
+    return total;
+  };
+  const estimatedCursorMoveBytes = (y, x) => {
+    return 3 + String(y + 1).length + 1 + String(x + 1).length + 1;
+  };
+  const estimatedRenderableTextBytes = (row, startX, endXExclusive, cols) => {
+    const start = Math.max(0, Math.min(cols, Math.floor(startX)));
+    const end = Math.max(start, Math.min(cols, Math.floor(endXExclusive)));
+    let bytes = 0;
+    for (let x = start; x < end; x++) {
+      const cell = cellAt(row, x);
+      if (cell.continuation)
+        continue;
+      bytes += import_node_buffer3.Buffer.byteLength(cell.ch || " ", "utf8");
+    }
+    return bytes;
+  };
+  const estimatedSpanPatchBytes = (row, spans, y, cols, clearToEol) => {
+    let bytes = 0;
+    for (const span of spans) {
+      bytes += estimatedCursorMoveBytes(y, span.startX);
+      bytes += estimatedRenderableTextBytes(row, span.startX, span.endXExclusive, cols);
+      bytes += EST_STYLE_SWITCH_BYTES;
+    }
+    if (clearToEol)
+      bytes += EST_CLEAR_TO_EOL_BYTES;
+    return bytes;
+  };
+  const estimatedContiguousPatchBytes = (row, spans, y, cols, clearToEol) => {
+    if (!spans.length)
+      return 0;
+    const first = spans[0];
+    const last = spans[spans.length - 1];
+    return estimatedCursorMoveBytes(y, first.startX) + estimatedRenderableTextBytes(row, first.startX, last.endXExclusive, cols) + EST_STYLE_SWITCH_BYTES + (clearToEol ? EST_CLEAR_TO_EOL_BYTES : 0);
+  };
+  const estimatedFullRowPatchBytes = (row, y, cols, clearToEol) => {
+    return estimatedCursorMoveBytes(y, 0) + EST_STYLE_SWITCH_BYTES + estimatedRenderableTextBytes(row, 0, cols, cols) + (clearToEol ? EST_CLEAR_TO_EOL_BYTES : 0);
+  };
+  const resolveDirtySpanRenderMode = (row, spans, y, cols, clearToEol) => {
+    if (spans.length <= 0)
+      return "spans";
+    const forceSpanPatch = dirtyRowPatchMode === "span" || columnDiffMode === "single-span" || columnDiffMode === "multi-span";
+    const coverage = dirtySpanCoverage(spans);
+    const fullRowCoverageLimit = Math.max(1, Math.floor(cols * DIRTY_SPAN_FULL_ROW_THRESHOLD));
+    if (!forceSpanPatch && dirtyRowPatchMode === "auto" && useConservativeDirtyRows && coverage > dirtySpanConservativeMaxCells) {
+      return "row";
+    }
+    if (!forceSpanPatch && coverage >= fullRowCoverageLimit) {
+      return "row";
+    }
+    const fullRowCost = estimatedFullRowPatchBytes(row, y, cols, clearToEol);
+    if (spans.length === 1) {
+      const spanCost = estimatedSpanPatchBytes(row, spans, y, cols, clearToEol);
+      return forceSpanPatch || spanCost < fullRowCost ? "spans" : "row";
+    }
+    const multiCost = estimatedSpanPatchBytes(row, spans, y, cols, clearToEol);
+    const first = spans[0];
+    const last = spans[spans.length - 1];
+    const contiguousWidth = Math.max(0, last.endXExclusive - first.startX);
+    const canUseContiguous = forceSpanPatch || contiguousWidth < fullRowCoverageLimit;
+    const contiguousCost = canUseContiguous ? estimatedContiguousPatchBytes(row, spans, y, cols, clearToEol) : Number.POSITIVE_INFINITY;
+    const tooManySpans = !forceSpanPatch && spans.length > DIRTY_SPAN_MAX_PER_ROW;
+    const effectiveMultiCost = tooManySpans ? Number.POSITIVE_INFINITY : multiCost;
+    if (forceSpanPatch) {
+      return contiguousCost < multiCost ? "contiguous" : "spans";
+    }
+    if (contiguousCost < effectiveMultiCost && contiguousCost < fullRowCost) {
+      return "contiguous";
+    }
+    if (!tooManySpans && multiCost < fullRowCost) {
+      return "spans";
+    }
+    return "row";
+  };
+  const expandSpanStart = (row, startX, cols) => {
+    var _a2;
+    let x = Math.max(0, Math.min(cols, Math.floor(startX)));
+    while (x > 0 && ((_a2 = row[x]) == null ? void 0 : _a2.continuation))
+      x--;
+    const prev = row[x - 1];
+    if (prev && prev.width === 2 && !prev.continuation)
+      x--;
+    return Math.max(0, x);
+  };
+  const expandSpanEnd = (row, endXExclusive, cols) => {
+    var _a2;
+    let x = Math.max(0, Math.min(cols, Math.floor(endXExclusive)));
+    const last = row[x - 1];
+    if (last && last.width === 2 && !last.continuation)
+      x++;
+    while (x < cols && ((_a2 = row[x]) == null ? void 0 : _a2.continuation))
+      x++;
+    return Math.min(cols, x);
+  };
+  const previousCellLooksLikeWideContinuation = (referenceTextIds, base, x) => {
+    if (x <= 0 || x >= fpCols)
+      return false;
+    return referenceTextIds[base + x] === continuationTextId;
+  };
+  const expandSpanForReferenceWideGlyphs = (span, referenceTextIds, base, cols) => {
+    let startX = span.startX;
+    let endXExclusive = span.endXExclusive;
+    const limit = Math.max(0, Math.min(cols, fpCols));
+    if (startX > 0) {
+      if (previousCellLooksLikeWideContinuation(referenceTextIds, base, startX)) {
+        startX--;
+      } else if (previousCellLooksLikeWideContinuation(referenceTextIds, base, startX - 1)) {
+        startX = Math.max(0, startX - 2);
+      }
+    }
+    while (endXExclusive < limit) {
+      if (!previousCellLooksLikeWideContinuation(referenceTextIds, base, endXExclusive)) {
+        break;
+      }
+      endXExclusive++;
+    }
+    return { startX, endXExclusive };
+  };
+  const widenSpanToCurrentGlyphBoundaries = (row, span, cols) => {
+    return {
+      startX: expandSpanStart(row, span.startX, cols),
+      endXExclusive: expandSpanEnd(row, span.endXExclusive, cols)
+    };
+  };
+  const expandSpansForReferenceWideGlyphs = (spans, row, y, cols, referenceTextIds) => {
+    if (!spans.length || !fpCols || y < 0 || y >= fpRows)
+      return spans;
+    const base = y * fpCols;
+    const expanded = [];
+    for (const span of spans) {
+      const next = widenSpanToCurrentGlyphBoundaries(
+        row,
+        expandSpanForReferenceWideGlyphs(span, referenceTextIds, base, cols),
+        cols
+      );
+      const prev = expanded[expanded.length - 1];
+      if (prev && next.startX <= prev.endXExclusive + DIRTY_SPAN_MERGE_GAP_CELLS) {
+        expanded[expanded.length - 1] = {
+          startX: prev.startX,
+          endXExclusive: Math.max(prev.endXExclusive, next.endXExclusive)
+        };
+        continue;
+      }
+      expanded.push(next);
+    }
+    return expanded;
+  };
+  const pushDirtySpan = (spans, row, startX, endXExclusive, cols) => {
+    let expandedStart = Math.max(0, Math.min(cols, startX));
+    let expandedEnd = Math.max(expandedStart, Math.min(cols, endXExclusive));
+    if (expandedEnd <= expandedStart)
+      return;
+    expandedStart = expandSpanStart(row, expandedStart, cols);
+    expandedEnd = expandSpanEnd(row, expandedEnd, cols);
+    expandedStart = Math.max(0, Math.min(cols, expandedStart));
+    expandedEnd = Math.max(expandedStart, Math.min(cols, expandedEnd));
+    if (expandedEnd <= expandedStart)
+      return;
+    const prev = spans[spans.length - 1];
+    if (prev && expandedStart <= prev.endXExclusive + DIRTY_SPAN_MERGE_GAP_CELLS) {
+      spans[spans.length - 1] = {
+        startX: prev.startX,
+        endXExclusive: Math.max(prev.endXExclusive, expandedEnd)
+      };
+      return;
+    }
+    spans.push({
+      startX: expandedStart,
+      endXExclusive: expandedEnd
+    });
+  };
+  const collectChangedSpans = (row, cols, changedAt) => {
+    const limit = Math.max(0, cols);
+    if (limit <= 0)
+      return [];
+    const spans = [];
+    let startX = -1;
+    for (let x = 0; x < limit; x++) {
+      if (changedAt(x)) {
+        if (startX < 0)
+          startX = x;
+        continue;
+      }
+      if (startX >= 0) {
+        pushDirtySpan(spans, row, startX, x, cols);
+        startX = -1;
+      }
+    }
+    if (startX >= 0) {
+      pushDirtySpan(spans, row, startX, limit, cols);
+    }
+    return spans;
+  };
+  const resolveChangedSpans = (row, y, cols, nextSnapshot) => {
+    if (!fpCols || cols !== fpCols || y >= fpRows || !fpPrevValid) {
+      return fullRowDirtySpan(cols);
+    }
+    const base = y * fpCols;
+    let spans;
+    if (!nextSnapshot) {
+      spans = expandSpansForReferenceWideGlyphs(
+        collectChangedSpans(row, cols, (x) => !currentCellMatchesPrevious(base, x)),
+        row,
+        y,
+        cols,
+        prevTextIds
+      );
+    } else {
+      spans = expandSpansForReferenceWideGlyphs(
+        collectChangedSpans(row, cols, (x) => {
+          return nextSnapshot.fp[x] !== prevFP[base + x] || nextSnapshot.textIds[x] !== prevTextIds[base + x] || nextSnapshot.hrefIds[x] !== prevHrefIds[base + x];
+        }),
+        row,
+        y,
+        cols,
+        prevTextIds
+      );
+    }
+    return activeRenderBaselineChanged() ? fullRowDirtySpan(cols) : spans;
+  };
+  const resolveChangedSpansAgainstFill = (row, y, cols, fillFingerprint, fillTextId = blankTextId, fillHrefId = 0) => {
+    if (!fpCols || cols !== fpCols || y >= fpRows) {
+      return fullRowDirtySpan(cols);
+    }
+    const base = y * fpCols;
+    const spans = collectChangedSpans(row, cols, (x) => {
+      return currentFP[base + x] !== fillFingerprint || currentTextIds[base + x] !== fillTextId || currentHrefIds[base + x] !== fillHrefId;
+    });
+    return activeRenderBaselineChanged() ? fullRowDirtySpan(cols) : spans;
+  };
+  const resolveChangedSpansAgainstReference = (row, y, cols, referenceFP, referenceHrefIds, referenceTextIds) => {
+    if (!fpCols || cols !== fpCols || y >= fpRows) {
+      return fullRowDirtySpan(cols);
+    }
+    const rowFP = rowFingerprintsForThisRenderer(y);
+    const base = y * fpCols;
+    const spans = expandSpansForReferenceWideGlyphs(
+      collectChangedSpans(row, cols, (x) => {
+        return !referenceCellMatchesCurrent(
+          row,
+          rowFP,
+          base,
+          x,
+          cols,
+          referenceFP,
+          referenceHrefIds,
+          referenceTextIds
+        );
+      }),
+      row,
+      y,
+      cols,
+      referenceTextIds
+    );
+    return activeRenderBaselineChanged() ? fullRowDirtySpan(cols) : spans;
+  };
+  const isEolClearEquivalentBlankCell = (cell, defaultBlankStyleKey) => {
+    if (!cell)
+      return true;
+    if (cell.continuation)
+      return false;
+    const ch = cell.ch || " ";
+    if (ch !== " ")
+      return false;
+    if (cell.width !== 1)
+      return false;
+    if (renderedHref(cell.style.href))
+      return false;
+    return styleKey(cell.style) === defaultBlankStyleKey;
+  };
+  const lastExplicitPaintColumnInRow = (row, cols, defaultBlankStyleKey) => {
+    const limit = Math.max(0, cols);
+    for (let x = limit - 1; x >= 0; x--) {
+      const cell = cellAt(row, x);
+      if (!isEolClearEquivalentBlankCell(cell, defaultBlankStyleKey)) {
+        if (cell && !cell.continuation && cell.width === 2 && x + 1 < limit) {
+          return x + 1;
+        }
+        return x;
+      }
+    }
+    return -1;
+  };
+  const shouldRewriteRowTail = (row, y, cols, referenceFP, referenceHrefIds, referenceTextIds, defaultBlankStyleKey = styleKeyFromParts({ bg: defaultBg })) => {
+    if (!fpCols || y >= fpRows)
+      return true;
+    const currentTailStart = Math.max(
+      0,
+      Math.min(cols, lastExplicitPaintColumnInRow(row, cols, defaultBlankStyleKey) + 1)
+    );
+    if (currentTailStart >= cols)
+      return false;
+    const blankFP = cellFingerprintFromStyleKey(" ", defaultBlankStyleKey);
+    const base = y * fpCols;
+    const limit = Math.min(cols, fpCols);
+    for (let x = currentTailStart; x < limit; x++) {
+      if (referenceFP[base + x] !== blankFP || referenceTextIds[base + x] !== blankTextId || referenceHrefIds[base + x] !== 0) {
+        return true;
+      }
+    }
+    return false;
+  };
   const rowCursorToCol1 = [];
   const rowClearToEol = [];
   const rowTextPartsScratch = [];
@@ -9721,15 +10298,16 @@ function createStdoutRenderer(terminal, options) {
       rowClearToEol[y] = `\x1B[${y + 1};1H\x1B[K`;
     }
   };
-  const rowHasNonDefaultBlankCell = (source, y, cols) => {
+  const rowHasNonDefaultBlankCell = (sourceFP, sourceTextIds, sourceHrefIds, y, cols) => {
     if (!fpCols || y < 0 || y >= fpRows)
       return false;
-    const blankFP = styleKeyFromParts({ bg: defaultBg }) << 10 | charHash10(" ");
+    const blankFP = cellFingerprintFromStyleKey(" ", styleKeyFromParts({ bg: defaultBg }));
     const base = y * fpCols;
     const limit = Math.min(cols, fpCols);
     for (let x = 0; x < limit; x++) {
-      if (source[base + x] !== blankFP)
+      if (sourceFP[base + x] !== blankFP || sourceTextIds[base + x] !== blankTextId || sourceHrefIds[base + x] !== 0) {
         return true;
+      }
     }
     return false;
   };
@@ -9754,7 +10332,7 @@ function createStdoutRenderer(terminal, options) {
       return false;
     if (isGhostty || isVscodeTerminal)
       return false;
-    return out.isTTY !== false;
+    return outputIsTTY;
   })();
   function prepareExplicitScrollOperations(operations, blockedRows) {
     if (!operations.length || !(blockedRows == null ? void 0 : blockedRows.size)) {
@@ -9880,7 +10458,7 @@ function createStdoutRenderer(terminal, options) {
         const srcY = y + delta;
         if (srcY < band.start || srcY >= band.end)
           continue;
-        const informative = rowHasNonDefaultBlankCell(currentFP, y, cols) || rowHasNonDefaultBlankCell(prevFP, srcY, cols);
+        const informative = rowHasNonDefaultBlankCell(currentFP, currentTextIds, currentHrefIds, y, cols) || rowHasNonDefaultBlankCell(prevFP, prevTextIds, prevHrefIds, srcY, cols);
         if (!informative)
           continue;
         checked++;
@@ -9888,7 +10466,7 @@ function createStdoutRenderer(terminal, options) {
         const prevBase = srcY * fpCols;
         let rowMatch = true;
         for (let x = 0; x < cols; x++) {
-          if (currentFP[curBase + x] !== prevFP[prevBase + x] || currentHrefIds[curBase + x] !== prevHrefIds[prevBase + x]) {
+          if (!cellMatchesPreviousAt(curBase, prevBase, x)) {
             rowMatch = false;
             break;
           }
@@ -9919,7 +10497,7 @@ function createStdoutRenderer(terminal, options) {
           const prevBase = srcY * fpCols;
           let rowMatch = true;
           for (let x = 0; x < cols; x++) {
-            if (currentFP[curBase + x] !== prevFP[prevBase + x] || currentHrefIds[curBase + x] !== prevHrefIds[prevBase + x]) {
+            if (!cellMatchesPreviousAt(curBase, prevBase, x)) {
               rowMatch = false;
               break;
             }
@@ -9939,43 +10517,96 @@ function createStdoutRenderer(terminal, options) {
     }
     return null;
   }
-  function writeChunked(data) {
-    if (!isGhostty) {
-      if (data.length <= chunkSize) {
-        out.write(data);
-        return;
+  const isHighSurrogate = (code) => code >= 55296 && code <= 56319;
+  const isLowSurrogate = (code) => code >= 56320 && code <= 57343;
+  const codePointEnd = (data, index) => {
+    const code = data.charCodeAt(index);
+    if (isHighSurrogate(code) && index + 1 < data.length) {
+      const next = data.charCodeAt(index + 1);
+      if (isLowSurrogate(next))
+        return index + 2;
+    }
+    return index + 1;
+  };
+  const codePointBefore = (data, index) => {
+    if (index <= 0)
+      return null;
+    const prev = data.charCodeAt(index - 1);
+    if (isLowSurrogate(prev) && index - 2 >= 0) {
+      const high = data.charCodeAt(index - 2);
+      if (isHighSurrogate(high))
+        return data.codePointAt(index - 2) ?? null;
+    }
+    return data.codePointAt(index - 1) ?? null;
+  };
+  const isGraphemeContinuationCodePoint = (codePoint) => codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071 || codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999 || codePoint >= 127995 && codePoint <= 127999 || codePoint >= 917536 && codePoint <= 917631;
+  const shouldAttachToPreviousGrapheme = (data, index) => {
+    const codePoint = data.codePointAt(index);
+    if (codePoint == null)
+      return false;
+    if (codePoint === 8205)
+      return true;
+    if (codePointBefore(data, index) === 8205)
+      return true;
+    return isGraphemeContinuationCodePoint(codePoint);
+  };
+  const safeChunkEnd = (data, start, maxBytes) => {
+    let end = start;
+    let bytes = 0;
+    const limit = Math.max(1, Math.floor(maxBytes));
+    while (end < data.length) {
+      const next = codePointEnd(data, end);
+      const partBytes = import_node_buffer3.Buffer.byteLength(data.slice(end, next), "utf8");
+      if (end > start && bytes + partBytes > limit && !shouldAttachToPreviousGrapheme(data, end)) {
+        break;
+      }
+      bytes += partBytes;
+      end = next;
+      while (end < data.length && shouldAttachToPreviousGrapheme(data, end)) {
+        const attachedEnd = codePointEnd(data, end);
+        bytes += import_node_buffer3.Buffer.byteLength(data.slice(end, attachedEnd), "utf8");
+        end = attachedEnd;
       }
-      for (let i = 0; i < data.length; i += chunkSize) {
-        const chunk = data.slice(i, i + chunkSize);
-        out.write(chunk);
+      if (bytes >= limit && (end >= data.length || !shouldAttachToPreviousGrapheme(data, end))) {
+        break;
       }
+    }
+    return end > start ? end : codePointEnd(data, start);
+  };
+  function writeChunked(data) {
+    if (import_node_buffer3.Buffer.byteLength(data, "utf8") <= chunkSize) {
+      out.write(data);
       return;
     }
     if (isDebugEnabled()) {
-      getDebugLog().render(`writeChunked: sync chunked write of ${data.length} bytes`);
+      getDebugLog().render(
+        `writeChunked: sync chunked write of ${import_node_buffer3.Buffer.byteLength(data, "utf8")} bytes`
+      );
     }
     try {
-      if (data.length <= chunkSize) {
-        out.write(data);
-      } else {
-        for (let i = 0; i < data.length; i += chunkSize) {
-          const chunk = data.slice(i, i + chunkSize);
-          out.write(chunk);
-        }
+      for (let start = 0; start < data.length; ) {
+        const end = safeChunkEnd(data, start, chunkSize);
+        out.write(data.slice(start, end));
+        start = end;
       }
       if (isDebugEnabled())
         getDebugLog().render(`writeChunked: chunked write completed`);
     } catch (e) {
       if (isDebugEnabled())
         getDebugLog().error(`writeChunked: write error`, e);
+      throw e;
     }
   }
-  function doRender(dirtyRows, scrollOperations) {
+  function doRender(dirtyRows, scrollOperations, forceDirtyRowsRepaint = false) {
     if (isDebugEnabled()) {
       getDebugLog().render(`doRender() START: dirtyRows=${(dirtyRows == null ? void 0 : dirtyRows.length) ?? "null"}`);
     }
     if (disposed)
       return;
+    const currentFingerprintOwner = stdoutFingerprintOwners.get(terminal);
+    if ((!ownsFingerprintFn || terminalFingerprintFnDirty) && (!currentFingerprintOwner || currentFingerprintOwner === fingerprintOwner) && canInstallTerminalFingerprintFn() && shouldAttemptFingerprintInstall()) {
+      installFingerprintFn(terminalFingerprintFnDirty);
+    }
     cliLatency == null ? void 0 : cliLatency.recordStdoutRenderStart();
     pendingRender = false;
     accumulatedAllRows = false;
@@ -9983,6 +10614,7 @@ function createStdoutRenderer(terminal, options) {
     accumulatedDirtyCount = 0;
     accumulatedDirtyMin = Number.POSITIVE_INFINITY;
     accumulatedDirtyMax = -1;
+    accumulatedDirtyRowsRequireRepaint = false;
     accumulatedScrollOperations = null;
     lastFrameTime = Date.now();
     const renderStart = performance.now();
@@ -9992,11 +10624,15 @@ function createStdoutRenderer(terminal, options) {
     const bgSeq = openBg(defaultBg);
     const bgOnlyStyle = { bg: defaultBg };
     const bgKey = styleKeyFromParts({ bg: defaultBg });
-    const blankFP = bgKey << 10 | charHash10(" ");
+    const blankFP = cellFingerprintFromStyleKey(" ", bgKey);
     let dirtySorted = true;
-    const forceFullRender = hrefIndexResetRequiresBaseline;
-    if (forceFullRender)
+    const forceFullRender = hrefIndexResetRequiresBaseline || fingerprintInternResetRequiresBaseline;
+    if (forceFullRender) {
       hrefIndexResetRequiresBaseline = false;
+      fingerprintInternResetRequiresBaseline = false;
+      fpPrevValid = false;
+    }
+    activeRenderBaselineGeneration = fingerprintBaselineGeneration;
     const normalizedScrollOperations = (() => {
       if (!(scrollOperations == null ? void 0 : scrollOperations.length))
         return null;
@@ -10014,10 +10650,12 @@ function createStdoutRenderer(terminal, options) {
       return outOps;
     })();
     let rowsToRender = (() => {
-      if (forceFullRender)
+      if (forceFullRender || !fpPrevValid)
         return null;
-      if (!dirtyRows || dirtyRows.length === 0)
+      if (!dirtyRows)
         return null;
+      if (dirtyRows.length === 0)
+        return [];
       const outRows = [];
       outRows.length = dirtyRows.length;
       let outLen = 0;
@@ -10025,7 +10663,7 @@ function createStdoutRenderer(terminal, options) {
       let prev = -1;
       for (let i = 0; i < dirtyRows.length; i++) {
         const y = Math.floor(dirtyRows[i] ?? -1);
-        if (y < 0 || y >= size.rows)
+        if (!Number.isFinite(y) || y < 0 || y >= size.rows)
           continue;
         if (y <= prev)
           sorted = false;
@@ -10034,15 +10672,32 @@ function createStdoutRenderer(terminal, options) {
       }
       outRows.length = outLen;
       if (!outRows.length)
-        return null;
+        return [];
       dirtySorted = sorted;
       if (!sorted)
         outRows.sort((a, b) => a - b);
       return outRows;
     })();
+    if ((rowsToRender == null ? void 0 : rowsToRender.length) === 0 && !normalizedScrollOperations && !getImeAnchor) {
+      if (isDebugEnabled())
+        getDebugLog().render(" No valid dirty rows; frame skipped");
+      cliLatency == null ? void 0 : cliLatency.recordStdoutNoOutput();
+      return;
+    }
+    const dirtyRowSnapshots = fpPrevValid && rowsToRender ? /* @__PURE__ */ new Map() : null;
+    const snapshotDirtyRowFingerprints = () => {
+      if (!dirtyRowSnapshots || !rowsToRender)
+        return;
+      for (const y of rowsToRender) {
+        const row = terminal.getRow(y);
+        dirtyRowSnapshots.set(y, snapshotRowFingerprints(row, y, size.cols));
+      }
+    };
+    snapshotDirtyRowFingerprints();
     if (fpPrevValid && rowsToRender) {
       currentFP.set(prevFP);
       currentHrefIds.set(prevHrefIds);
+      currentTextIds.set(prevTextIds);
     }
     const frameParts = [];
     frameParts.push(!isGhostty && useSyncOutput ? SYNC_START : "");
@@ -10062,6 +10717,15 @@ function createStdoutRenderer(terminal, options) {
       inverse: false,
       href: null
     };
+    const closeActiveHrefBeforeCursorMove = () => {
+      if (!enableOsc8Links || !activeStyle.href)
+        return;
+      frameParts.push(OSC8_CLOSE);
+      activeStyle = {
+        ...activeStyle,
+        href: null
+      };
+    };
     const normalizeStyle2 = (style) => {
       return {
         fg: style.fg ?? null,
@@ -10071,7 +10735,7 @@ function createStdoutRenderer(terminal, options) {
         italic: Boolean(style.italic),
         underline: Boolean(style.underline),
         inverse: Boolean(style.inverse),
-        href: normalizeHref(style.href)
+        href: renderedHref(style.href)
       };
     };
     const emitStyle = (nextStyle, nextKey) => {
@@ -10108,15 +10772,23 @@ function createStdoutRenderer(terminal, options) {
       activeStyleKey = nextKey;
       activeStyle = next;
     };
-    const shouldEmitStyle = (style, key) => activeStyleKey !== key || activeStyle.href !== normalizeHref(style.href);
-    const renderRow = (y, row, startX = 0, endXExclusive = row.length, clearToEol = true) => {
-      const spanStart = Math.max(0, Math.min(row.length, Math.floor(startX)));
-      const spanEnd = Math.max(spanStart, Math.min(row.length, Math.floor(endXExclusive)));
-      if (spanStart >= spanEnd && !clearToEol) {
+    const shouldEmitStyle = (style, key) => activeStyleKey !== key || activeStyle.href !== renderedHref(style.href);
+    const renderRow = (y, row, startX = 0, endXExclusive = size.cols, clearToEol = true) => {
+      const spanStart = Math.max(0, Math.min(size.cols, Math.floor(startX)));
+      const spanEnd = Math.max(spanStart, Math.min(size.cols, Math.floor(endXExclusive)));
+      const shouldClearToEol = clearToEol && spanEnd < size.cols;
+      if (spanStart >= spanEnd && !shouldClearToEol) {
         return;
       }
       hasFrameOutput = true;
+      const pushCursorFixAfterCell = (parts, cellX, cell) => {
+        const afterX = cellX + (cell.width ?? 1);
+        if (afterX >= size.cols)
+          return;
+        parts.push(`\x1B[${y + 1};${afterX + 1}H`);
+      };
       if (!disableCursorPos) {
+        closeActiveHrefBeforeCursorMove();
         if (spanStart === 0 && lastRenderWasFullRow && y === lastRenderedY + 1) {
           frameParts.push("\r\n");
         } else {
@@ -10130,7 +10802,7 @@ function createStdoutRenderer(terminal, options) {
       const currentTextParts = rowTextPartsScratch;
       currentTextParts.length = 0;
       for (let x = spanStart; x < spanEnd; x++) {
-        const cell = row[x];
+        const cell = cellAt(row, x);
         if (cell.continuation)
           continue;
         const ch = cell.ch || " ";
@@ -10141,14 +10813,14 @@ function createStdoutRenderer(terminal, options) {
           currentStyle = nextStyle;
           currentTextParts.push(ch);
           if (needsCursorFix(cell, ch)) {
-            currentTextParts.push(`\x1B[${y + 1};${x + 1 + (cell.width ?? 1)}H`);
+            pushCursorFixAfterCell(currentTextParts, x, cell);
           }
           continue;
         }
-        if (key === currentKey && normalizeHref(nextStyle.href) === normalizeHref(currentStyle == null ? void 0 : currentStyle.href)) {
+        if (key === currentKey && renderedHref(nextStyle.href) === renderedHref(currentStyle == null ? void 0 : currentStyle.href)) {
           currentTextParts.push(ch);
           if (needsCursorFix(cell, ch)) {
-            currentTextParts.push(`\x1B[${y + 1};${x + 1 + (cell.width ?? 1)}H`);
+            pushCursorFixAfterCell(currentTextParts, x, cell);
           }
           continue;
         }
@@ -10161,7 +10833,7 @@ function createStdoutRenderer(terminal, options) {
         currentTextParts.length = 0;
         currentTextParts.push(ch);
         if (needsCursorFix(cell, ch))
-          currentTextParts.push(`\x1B[${y + 1};${x + 1 + (cell.width ?? 1)}H`);
+          pushCursorFixAfterCell(currentTextParts, x, cell);
       }
       if (currentKey != null) {
         if (shouldEmitStyle(currentStyle, currentKey)) {
@@ -10169,14 +10841,103 @@ function createStdoutRenderer(terminal, options) {
         }
         frameParts.push(currentTextParts.join(""));
       }
-      if (clearToEol) {
+      if (shouldClearToEol) {
         if (activeStyleKey !== bgKey) {
           emitStyle(bgOnlyStyle, bgKey);
         }
         frameParts.push("\x1B[K");
       }
       lastRenderedY = y;
-      lastRenderWasFullRow = spanStart === 0 && clearToEol;
+      lastRenderWasFullRow = spanStart === 0 && (spanEnd >= size.cols || shouldClearToEol);
+    };
+    const lastRenderableColumnInCurrentRow = (rowY, cols, blankFingerprint) => {
+      if (!fpCols || rowY < 0 || rowY >= fpRows)
+        return -1;
+      const base = rowY * fpCols;
+      const limit = Math.min(cols, fpCols);
+      for (let x = limit - 1; x >= 0; x--) {
+        if (currentFP[base + x] !== blankFingerprint || currentTextIds[base + x] !== blankTextId || currentHrefIds[base + x] !== 0) {
+          return x;
+        }
+      }
+      return -1;
+    };
+    const resolveTailClearStartX = (rowY, cols, shouldRewriteTail, blankFingerprint) => {
+      if (!shouldRewriteTail)
+        return null;
+      const lastRenderableX = lastRenderableColumnInCurrentRow(rowY, cols, blankFingerprint);
+      const clearStartX = Math.max(0, Math.min(cols, lastRenderableX + 1));
+      return clearStartX < cols ? clearStartX : null;
+    };
+    const renderDirtySpans = (rowY, row, rawSpans, rewriteTail) => {
+      if (!rawSpans.length && !rewriteTail)
+        return;
+      const rowCols = size.cols;
+      const clearStartX = resolveTailClearStartX(rowY, rowCols, rewriteTail, blankFP);
+      const paintTailInsteadOfEscK = clearStartX != null && dirtyRowPatchMode === "auto" && useConservativeDirtyRows;
+      const spansToPaint = [];
+      for (const span of rawSpans) {
+        const startX = Math.max(0, Math.min(rowCols, span.startX));
+        const endXExclusive = Math.max(startX, Math.min(rowCols, span.endXExclusive));
+        if (endXExclusive <= startX)
+          continue;
+        if (clearStartX != null && !paintTailInsteadOfEscK) {
+          if (startX >= clearStartX)
+            continue;
+          const clippedEnd = Math.min(endXExclusive, clearStartX);
+          if (clippedEnd > startX) {
+            spansToPaint.push({
+              startX,
+              endXExclusive: clippedEnd
+            });
+          }
+          continue;
+        }
+        spansToPaint.push({
+          startX,
+          endXExclusive
+        });
+      }
+      if (paintTailInsteadOfEscK && clearStartX != null && clearStartX < rowCols) {
+        const prev = spansToPaint[spansToPaint.length - 1];
+        if (prev && clearStartX <= prev.endXExclusive + DIRTY_SPAN_MERGE_GAP_CELLS) {
+          spansToPaint[spansToPaint.length - 1] = {
+            startX: prev.startX,
+            endXExclusive: rowCols
+          };
+        } else {
+          spansToPaint.push({
+            startX: clearStartX,
+            endXExclusive: rowCols
+          });
+        }
+      }
+      const clearToEolForCost = clearStartX != null && clearStartX < rowCols && !paintTailInsteadOfEscK;
+      const renderMode = !shouldUseMultiDirtySpans() && spansToPaint.length > 0 ? "contiguous" : resolveDirtySpanRenderMode(row, spansToPaint, rowY, rowCols, clearToEolForCost);
+      if (renderMode === "row") {
+        if (clearStartX != null && !paintTailInsteadOfEscK) {
+          renderRow(rowY, row, 0, clearStartX, true);
+        } else {
+          renderRow(rowY, row, 0, rowCols, false);
+        }
+        return;
+      } else if (renderMode === "contiguous") {
+        const first = spansToPaint[0];
+        const last = spansToPaint[spansToPaint.length - 1];
+        if (first && last) {
+          const rewriteEnd = clearStartX == null || paintTailInsteadOfEscK ? last.endXExclusive : Math.min(last.endXExclusive, clearStartX);
+          if (rewriteEnd > first.startX) {
+            renderRow(rowY, row, first.startX, rewriteEnd, false);
+          }
+        }
+      } else {
+        for (const span of spansToPaint) {
+          renderRow(rowY, row, span.startX, span.endXExclusive, false);
+        }
+      }
+      if (clearStartX != null && !paintTailInsteadOfEscK) {
+        renderRow(rowY, row, clearStartX, clearStartX, true);
+      }
     };
     const overlayCoverage = overlayPlaneCoverageRows(size.rows);
     const overlayRows = Array.from(
@@ -10213,12 +10974,12 @@ function createStdoutRenderer(terminal, options) {
         }
       } else {
         allowInferredScrollRegions = false;
-        const expandedRows = new Set(rowsToRender ?? []);
+        const expandedRows2 = new Set(rowsToRender ?? []);
         for (const op of explicitScrollOperations) {
           for (let y = op.startY; y < op.endY; y++)
-            expandedRows.add(y);
+            expandedRows2.add(y);
         }
-        rowsToRender = Array.from(expandedRows).sort((a, b) => a - b);
+        rowsToRender = Array.from(expandedRows2).sort((a, b) => a - b);
         dirtySorted = true;
         explicitScrollOperations = null;
         hiddenExplicitDirtyRows = null;
@@ -10230,15 +10991,20 @@ function createStdoutRenderer(terminal, options) {
       }
     }
     const scrollRowsCandidate = rowsToRender;
-    if (explicitScrollOperations && rowsToRender && (!enableScrollRegions || !fpPrevValid)) {
-      const expandedRows = new Set(rowsToRender);
-      for (const op of explicitScrollOperations) {
+    const expandedRows = new Set(rowsToRender ?? []);
+    const includeRowsForPendingScrollOperations = (operations) => {
+      if (!(operations == null ? void 0 : operations.length))
+        return;
+      for (const op of operations) {
         for (let y = op.startY; y < op.endY; y++) {
           if (hiddenExplicitDirtyRows == null ? void 0 : hiddenExplicitDirtyRows.has(y))
             continue;
           expandedRows.add(y);
         }
       }
+    };
+    if (explicitScrollOperations && rowsToRender && (!enableScrollRegions || !fpPrevValid)) {
+      includeRowsForPendingScrollOperations(explicitScrollOperations);
       rowsToRender = Array.from(expandedRows).sort((a, b) => a - b);
       dirtySorted = true;
       explicitScrollOperations = null;
@@ -10250,18 +11016,19 @@ function createStdoutRenderer(terminal, options) {
       }
     }
     const denseDirtyRows = Boolean(
-      rowsToRender && rowsToRender.length >= size.rows * dirtyFullThreshold
+      rowsToRender && size.rows > 1 && rowsToRender.length >= size.rows * dirtyFullThreshold
     );
     if (denseDirtyRows) {
       rowsToRender = null;
     }
     let profiledRowCount = rowsToRender ? rowsToRender.length : size.rows;
-    const useScrollRegions = enableScrollRegions && fpPrevValid && scrollRowsCandidate && scrollRowsCandidate.length >= 3 && allowInferredScrollRegions;
+    const useScrollRegions = enableScrollRegions && fpPrevValid && scrollRowsCandidate && scrollRowsCandidate.length >= 3 && !forceDirtyRowsRepaint && allowInferredScrollRegions;
     let scrollHandled = false;
     if (enableScrollRegions && explicitScrollOperations && scrollRowsCandidate && fpPrevValid) {
       if (currentFP.length === prevFP.length) {
         currentFP.set(prevFP);
         currentHrefIds.set(prevHrefIds);
+        currentTextIds.set(prevTextIds);
       }
       const explicitRowsToRender = /* @__PURE__ */ new Set();
       for (const y of scrollRowsCandidate) {
@@ -10286,6 +11053,7 @@ function createStdoutRenderer(terminal, options) {
             for (let x = 0; x < size.cols; x++) {
               currentFP[dstBase + x] = prevFP[srcBase + x];
               currentHrefIds[dstBase + x] = prevHrefIds[srcBase + x];
+              currentTextIds[dstBase + x] = prevTextIds[srcBase + x];
             }
           }
           for (let y = op.endY - op.delta; y < op.endY; y++) {
@@ -10294,6 +11062,7 @@ function createStdoutRenderer(terminal, options) {
             for (let x = 0; x < size.cols; x++) {
               currentFP[base + x] = blankFP;
               currentHrefIds[base + x] = 0;
+              currentTextIds[base + x] = blankTextId;
             }
           }
         } else {
@@ -10306,6 +11075,7 @@ function createStdoutRenderer(terminal, options) {
             for (let x = 0; x < size.cols; x++) {
               currentFP[dstBase + x] = prevFP[srcBase + x];
               currentHrefIds[dstBase + x] = prevHrefIds[srcBase + x];
+              currentTextIds[dstBase + x] = prevTextIds[srcBase + x];
             }
           }
           for (let y = op.startY; y < op.startY + absDelta; y++) {
@@ -10314,6 +11084,7 @@ function createStdoutRenderer(terminal, options) {
             for (let x = 0; x < size.cols; x++) {
               currentFP[base + x] = blankFP;
               currentHrefIds[base + x] = 0;
+              currentTextIds[base + x] = blankTextId;
             }
           }
         }
@@ -10322,10 +11093,44 @@ function createStdoutRenderer(terminal, options) {
       const explicitDirtyRows = Array.from(explicitRowsToRender).sort((a, b) => a - b);
       const overlayDirtyRows = overlayTouchedRowSet ? explicitDirtyRows.filter((y) => overlayTouchedRowSet.has(y)) : [];
       const paintedExplicitRows = [];
+      const insertedRows = /* @__PURE__ */ new Set();
+      for (const op of explicitScrollOperations) {
+        const absDelta = Math.abs(op.delta);
+        if (op.delta > 0) {
+          for (let y = op.endY - absDelta; y < op.endY; y++)
+            insertedRows.add(y);
+        } else {
+          for (let y = op.startY; y < op.startY + absDelta; y++)
+            insertedRows.add(y);
+        }
+      }
       for (const y of explicitDirtyRows) {
         const row = terminal.getRow(y);
-        fingerprintRow(row, y, size.cols);
-        renderRow(y, row);
+        const overlayRow = overlayTouchedRowSet == null ? void 0 : overlayTouchedRowSet.has(y);
+        if (forceDirtyRowsRepaint || !shouldUseDirtySpans() || overlayRow) {
+          fingerprintRow(row, y, size.cols);
+          renderRow(y, row);
+          paintedExplicitRows.push(y);
+          continue;
+        }
+        const insertedRow = insertedRows.has(y);
+        if (insertedRow)
+          fingerprintRow(row, y, size.cols);
+        const spans = insertedRow ? resolveChangedSpansAgainstFill(row, y, size.cols, blankFP, blankTextId, 0) : resolveChangedSpansAgainstReference(
+          row,
+          y,
+          size.cols,
+          currentFP,
+          currentHrefIds,
+          currentTextIds
+        );
+        if (!spans.length) {
+          continue;
+        }
+        const rewriteTail = !insertedRow && shouldRewriteRowTail(row, y, size.cols, currentFP, currentHrefIds, currentTextIds, bgKey);
+        if (!insertedRow)
+          fingerprintRow(row, y, size.cols);
+        renderDirtySpans(y, row, spans, rewriteTail);
         paintedExplicitRows.push(y);
       }
       if (isDebugEnabled() && overlayDirtyRows.length) {
@@ -10342,6 +11147,7 @@ function createStdoutRenderer(terminal, options) {
         if (currentFP.length === prevFP.length) {
           currentFP.set(prevFP);
           currentHrefIds.set(prevHrefIds);
+          currentTextIds.set(prevTextIds);
         }
         hasFrameOutput = true;
         if (isDebugEnabled()) {
@@ -10365,6 +11171,7 @@ function createStdoutRenderer(terminal, options) {
             for (let x = 0; x < size.cols; x++) {
               currentFP[dstBase + x] = prevFP[srcBase + x];
               currentHrefIds[dstBase + x] = prevHrefIds[srcBase + x];
+              currentTextIds[dstBase + x] = prevTextIds[srcBase + x];
             }
           }
           for (let y = shift.regionEnd - shift.delta; y < shift.regionEnd; y++) {
@@ -10372,6 +11179,7 @@ function createStdoutRenderer(terminal, options) {
             for (let x = 0; x < size.cols; x++) {
               currentFP[base + x] = blankFP;
               currentHrefIds[base + x] = 0;
+              currentTextIds[base + x] = blankTextId;
             }
           }
         } else {
@@ -10382,6 +11190,7 @@ function createStdoutRenderer(terminal, options) {
             for (let x = 0; x < size.cols; x++) {
               currentFP[dstBase + x] = prevFP[srcBase + x];
               currentHrefIds[dstBase + x] = prevHrefIds[srcBase + x];
+              currentTextIds[dstBase + x] = prevTextIds[srcBase + x];
             }
           }
           for (let y = shift.regionStart; y < shift.regionStart + absDelta; y++) {
@@ -10389,6 +11198,7 @@ function createStdoutRenderer(terminal, options) {
             for (let x = 0; x < size.cols; x++) {
               currentFP[base + x] = blankFP;
               currentHrefIds[base + x] = 0;
+              currentTextIds[base + x] = blankTextId;
             }
           }
         }
@@ -10402,6 +11212,32 @@ function createStdoutRenderer(terminal, options) {
         ) : shift.extraDirtyRows;
         for (const y of extraDirtyRows) {
           const row = terminal.getRow(y);
+          if (shouldUseDirtySpans()) {
+            const spans = resolveChangedSpansAgainstReference(
+              row,
+              y,
+              size.cols,
+              currentFP,
+              currentHrefIds,
+              currentTextIds
+            );
+            if (!spans.length) {
+              fingerprintRow(row, y, size.cols);
+              continue;
+            }
+            const rewriteTail = shouldRewriteRowTail(
+              row,
+              y,
+              size.cols,
+              currentFP,
+              currentHrefIds,
+              currentTextIds,
+              bgKey
+            );
+            fingerprintRow(row, y, size.cols);
+            renderDirtySpans(y, row, spans, rewriteTail);
+            continue;
+          }
           fingerprintRow(row, y, size.cols);
           renderRow(y, row);
         }
@@ -10439,13 +11275,30 @@ function createStdoutRenderer(terminal, options) {
       const overlayDirtyRows = overlayTouchedRowSet ? rowsToRender.filter((y) => overlayTouchedRowSet.has(y)) : [];
       if (isDebugEnabled()) {
         getDebugLog().render(
-          ` Partial render: ${rowsToRender.length} dirty rows: [${rowsToRender.join(", ")}]${overlayDirtyRows.length ? ` (overlay-full-row: [${overlayDirtyRows.join(", ")}])` : ""}`
+          ` Partial render: ${rowsToRender.length} dirty rows: [${rowsToRender.join(",")}]${overlayDirtyRows.length ? ` (overlay-full-row: [${overlayDirtyRows.join(", ")}])` : ""}`
         );
       }
       for (const y of rowsToRender) {
         const row = terminal.getRow(y);
         fingerprintRow(row, y, size.cols);
-        renderRow(y, row);
+        if (forceDirtyRowsRepaint || !shouldUseDirtySpans()) {
+          renderRow(y, row);
+          continue;
+        }
+        const spans = resolveChangedSpans(row, y, size.cols, (dirtyRowSnapshots == null ? void 0 : dirtyRowSnapshots.get(y)) ?? null);
+        if (!spans.length) {
+          continue;
+        }
+        const rewriteTail = shouldRewriteRowTail(
+          row,
+          y,
+          size.cols,
+          prevFP,
+          prevHrefIds,
+          prevTextIds,
+          bgKey
+        );
+        renderDirtySpans(y, row, spans, rewriteTail);
       }
     }
     if (!rowsToRender && lastRenderedRows > size.rows) {
@@ -10459,17 +11312,22 @@ function createStdoutRenderer(terminal, options) {
         frameParts.push(rowClearToEol[size.rows + i]);
       }
     }
-    if (!rowsToRender)
-      lastRenderedRows = size.rows;
-    const tmpFP = prevFP;
-    prevFP = currentFP;
-    currentFP = tmpFP;
-    const tmpHrefIds = prevHrefIds;
-    prevHrefIds = currentHrefIds;
-    currentHrefIds = tmpHrefIds;
-    fpPrevValid = !hrefIndexResetRequiresBaseline;
-    prevOverlayBlockedRows = overlayCoverage.blockedRows;
-    prevOverlayPartialRows = overlayCoverage.partialRows;
+    const nextLastRenderedRows = !rowsToRender ? size.rows : lastRenderedRows;
+    const commitRenderBaseline = () => {
+      lastRenderedRows = nextLastRenderedRows;
+      const tmpFP = prevFP;
+      prevFP = currentFP;
+      currentFP = tmpFP;
+      const tmpHrefIds = prevHrefIds;
+      prevHrefIds = currentHrefIds;
+      currentHrefIds = tmpHrefIds;
+      const tmpTextIds = prevTextIds;
+      prevTextIds = currentTextIds;
+      currentTextIds = tmpTextIds;
+      fpPrevValid = !hrefIndexResetRequiresBaseline && !fingerprintInternResetRequiresBaseline;
+      prevOverlayBlockedRows = overlayCoverage.blockedRows;
+      prevOverlayPartialRows = overlayCoverage.partialRows;
+    };
     let emittedCursorPos = null;
     if (getImeAnchor) {
       const anchor = getImeAnchor();
@@ -10478,11 +11336,13 @@ function createStdoutRenderer(terminal, options) {
         if (hasFrameOutput || x !== lastCursorX || y !== lastCursorY) {
           hasFrameOutput = true;
           emittedCursorPos = { x, y };
+          closeActiveHrefBeforeCursorMove();
           frameParts.push(`\x1B[${y + 1};${x + 1}H`);
         }
       }
     }
     if (!hasFrameOutput) {
+      commitRenderBaseline();
       if (isDebugEnabled())
         getDebugLog().render(" No-op frame skipped");
       cliLatency == null ? void 0 : cliLatency.recordStdoutNoOutput();
@@ -10494,6 +11354,7 @@ function createStdoutRenderer(terminal, options) {
     frameParts.push("\x1B[?7h");
     frameParts.push(!isGhostty && useSyncOutput ? SYNC_END : "");
     const frame = frameParts.join("");
+    const frameBytes = import_node_buffer3.Buffer.byteLength(frame, "utf8");
     if (profiler) {
       profiler.recordRender({
         durationMs: profiler.now() - renderStart,
@@ -10553,7 +11414,7 @@ function createStdoutRenderer(terminal, options) {
         }
         return count;
       };
-      const frameSize = frame.length;
+      const frameSize = frameBytes;
       const cursorSeqCount = countCursorMoves(frame);
       const resetCount = countResets(frame);
       const buildTime = (performance.now() - renderStart).toFixed(2);
@@ -10568,15 +11429,14 @@ function createStdoutRenderer(terminal, options) {
     const resolveWriteMode = (frameSizeBytes) => {
       if (isGhostty)
         return "chunked";
-      const canWriteSync = out.fd === 1;
       const preferChunked = frameSizeBytes >= chunkThresholdBytes || writeEmaMs >= 24;
       if (preferChunked)
         return "chunked";
-      if (canWriteSync && frameSizeBytes <= syncMaxBytes)
+      if (canUseSyncStdout && frameSizeBytes <= syncMaxBytes)
         return "sync";
       return "stream";
     };
-    const writeMode = resolveWriteMode(frame.length);
+    const writeMode = resolveWriteMode(frameBytes);
     if (isDebugEnabled())
       getDebugLog().render(`Before write()`);
     try {
@@ -10587,11 +11447,11 @@ function createStdoutRenderer(terminal, options) {
           );
         }
         writeChunked(frame);
-      } else if (writeMode === "sync" && out.fd === 1) {
+      } else if (writeMode === "sync" && canUseSyncStdout) {
         if (isDebugEnabled())
           getDebugLog().render(` Using writeSync`);
         try {
-          writeFdSync(1, frame);
+          writeFdSync(outputFd, frame);
         } catch {
           if (isDebugEnabled()) {
             getDebugLog().render(` writeSync failed, falling back to stream write`);
@@ -10610,14 +11470,13 @@ function createStdoutRenderer(terminal, options) {
     } catch (writeError) {
       if (isDebugEnabled())
         getDebugLog().error(`Write ERROR:`, writeError);
-      if (!isGhostty && useSyncOutput) {
-        try {
-          out.write(`\x1B[?7h${SYNC_END}`);
-        } catch {
-        }
+      try {
+        out.write(`\x1B[?7h${!isGhostty && useSyncOutput ? SYNC_END : ""}`);
+      } catch {
       }
       throw writeError;
     }
+    commitRenderBaseline();
     {
       const writeMs = performance.now() - writeStart;
       writeEmaMs = writeEmaMs === 0 ? writeMs : writeEmaMs * 0.85 + writeMs * 0.15;
@@ -10630,7 +11489,7 @@ function createStdoutRenderer(terminal, options) {
       }
       recordStdoutFrame({
         at: Date.now(),
-        bytes: frame.length,
+        bytes: frameBytes,
         writeMs,
         writeEmaMs,
         writeMode: writeMode === "sync" ? "sync" : writeMode === "chunked" ? "chunked" : "stream"
@@ -10638,13 +11497,13 @@ function createStdoutRenderer(terminal, options) {
       if (profiler) {
         profiler.recordWrite({
           durationMs: writeMs,
-          bytes: frame.length,
+          bytes: frameBytes,
           mode: writeMode === "sync" ? "sync" : writeMode === "chunked" ? "chunked" : "stream"
         });
       }
       cliLatency == null ? void 0 : cliLatency.recordStdoutWrite({
         durationMs: writeMs,
-        bytes: frame.length,
+        bytes: frameBytes,
         mode: writeMode === "sync" ? "sync" : writeMode === "chunked" ? "chunked" : "stream"
       });
     }
@@ -10769,6 +11628,7 @@ function createStdoutRenderer(terminal, options) {
   }
   function markScrollOperationDirty(op, rowCount) {
     markAccumulatedDirtyRange(op.startY, op.endY, rowCount);
+    accumulatedDirtyRowsRequireRepaint = true;
   }
   function mergeScrollOperations(next) {
     if (!(next == null ? void 0 : next.length) || accumulatedAllRows)
@@ -10819,20 +11679,28 @@ function createStdoutRenderer(terminal, options) {
         `render() called: dirtyRows=${(dirtyRows == null ? void 0 : dirtyRows.length) ?? "null"}, pending=${pendingRender}, elapsed=${Date.now() - lastFrameTime}ms`
       );
     }
-    if (!dirtyRows || dirtyRows.length === 0) {
+    if (dirtyRows == null) {
       accumulatedAllRows = true;
       accumulatedDirtyBits = null;
       accumulatedDirtyCount = 0;
       accumulatedDirtyMin = Number.POSITIVE_INFINITY;
       accumulatedDirtyMax = -1;
+      accumulatedDirtyRowsRequireRepaint = false;
       accumulatedScrollOperations = null;
+    } else if (dirtyRows.length === 0) {
+      if (scrollOperations == null ? void 0 : scrollOperations.length) {
+        mergeScrollOperations(scrollOperations);
+      } else if (!accumulatedAllRows && accumulatedDirtyCount === 0 && !getImeAnchor) {
+        cliLatency == null ? void 0 : cliLatency.recordStdoutQueued(0);
+        return;
+      }
     } else if (!accumulatedAllRows) {
       const rowCount = terminal.size().rows;
       mergeScrollOperations(scrollOperations);
       const bits = ensureAccumulatedDirtyBits(rowCount);
       for (let i = 0; i < dirtyRows.length; i++) {
         const y = Math.floor(dirtyRows[i] ?? -1);
-        if (y < 0 || y >= rowCount)
+        if (!Number.isFinite(y) || y < 0 || y >= rowCount)
           continue;
         if (!bits[y]) {
           bits[y] = 1;
@@ -10861,15 +11729,17 @@ function createStdoutRenderer(terminal, options) {
       }
       const rows = buildAccumulatedRows(dirtyRows);
       const pendingScrolls = buildAccumulatedScrollOperations();
+      const forceDirtyRowsRepaint = accumulatedDirtyRowsRequireRepaint;
       cliLatency == null ? void 0 : cliLatency.recordStdoutQueued(0);
-      doRender(rows, pendingScrolls);
+      doRender(rows, pendingScrolls, forceDirtyRowsRepaint);
       return;
     }
     if (elapsed >= MIN_FRAME_MS) {
       const rows = buildAccumulatedRows(dirtyRows);
       const pendingScrolls = buildAccumulatedScrollOperations();
+      const forceDirtyRowsRepaint = accumulatedDirtyRowsRequireRepaint;
       cliLatency == null ? void 0 : cliLatency.recordStdoutQueued(0);
-      doRender(rows, pendingScrolls);
+      doRender(rows, pendingScrolls, forceDirtyRowsRepaint);
     } else {
       pendingRender = true;
       if (renderTimer)
@@ -10879,19 +11749,67 @@ function createStdoutRenderer(terminal, options) {
         if (!disposed) {
           const rows = buildAccumulatedRows(dirtyRows);
           const pendingScrolls = buildAccumulatedScrollOperations();
-          doRender(rows, pendingScrolls);
+          const forceDirtyRowsRepaint = accumulatedDirtyRowsRequireRepaint;
+          doRender(rows, pendingScrolls, forceDirtyRowsRepaint);
         }
       }, queuedDelayMs);
       cliLatency == null ? void 0 : cliLatency.recordStdoutQueued(queuedDelayMs);
     }
   }
-  function installFingerprintFn() {
-    terminal.setFingerprintFn((ch, style) => {
+  function installFingerprintFn(force = false) {
+    if (!canInstallTerminalFingerprintFn()) {
+      if (ownsFingerprintFn && stdoutFingerprintOwners.get(terminal) === fingerprintOwner) {
+        stdoutFingerprintOwners.delete(terminal);
+        invalidateFingerprintBaseline();
+      }
+      ownsFingerprintFn = false;
+      terminalFingerprintFnDirty = true;
+      fingerprintInstallBlockedByExternalProvider = false;
+      return;
+    }
+    const currentOwner = stdoutFingerprintOwners.get(terminal);
+    if (!currentOwner && !ownsFingerprintFn && hasActiveExternalFingerprintProvider()) {
+      fingerprintInstallBlockedByExternalProvider = true;
+      ownsFingerprintFn = false;
+      terminalFingerprintFnDirty = false;
+      invalidateFingerprintBaseline();
+      return;
+    }
+    fingerprintInstallBlockedByExternalProvider = false;
+    if (currentOwner && currentOwner !== fingerprintOwner) {
+      if (ownsFingerprintFn)
+        invalidateFingerprintBaseline();
+      ownsFingerprintFn = false;
+      return;
+    }
+    if (ownsFingerprintFn && currentOwner === fingerprintOwner && !force && !terminalFingerprintFnDirty) {
+      return;
+    }
+    stdoutFingerprintOwners.set(terminal, fingerprintOwner);
+    ownsFingerprintFn = true;
+    fingerprintTerminal.setFingerprintFn((ch, style) => {
       return cellFingerprint(ch, style);
     });
+    terminalFingerprintFnDirty = false;
+    invalidateFingerprintBaseline();
+  }
+  function releaseFingerprintFn() {
+    var _a2;
+    if (!ownsFingerprintFn)
+      return;
+    if (stdoutFingerprintOwners.get(terminal) !== fingerprintOwner) {
+      ownsFingerprintFn = false;
+      return;
+    }
+    stdoutFingerprintOwners.delete(terminal);
+    ownsFingerprintFn = false;
+    try {
+      (_a2 = fingerprintTerminal.setFingerprintFn) == null ? void 0 : _a2.call(fingerprintTerminal, null);
+    } catch {
+    }
   }
   installFingerprintFn();
-  if (altScreen && out.isTTY)
+  if (altScreen && outputIsTTY)
     out.write("\x1B[?1049h");
   if (hideCursor)
     out.write("\x1B[?25l");
@@ -10908,7 +11826,7 @@ function createStdoutRenderer(terminal, options) {
   });
   const resizeSource = (options == null ? void 0 : options.output) ?? import_node_process6.default.stdout;
   const canTrackResize = Boolean(
-    trackResize && out.isTTY && typeof (resizeSource == null ? void 0 : resizeSource.on) === "function"
+    trackResize && outputIsTTY && typeof (resizeSource == null ? void 0 : resizeSource.on) === "function"
   );
   const onResize = () => {
     const cols = Number(resizeSource == null ? void 0 : resizeSource.columns);
@@ -10959,7 +11877,9 @@ function createStdoutRenderer(terminal, options) {
     accumulatedDirtyCount = 0;
     accumulatedDirtyMin = Number.POSITIVE_INFINITY;
     accumulatedDirtyMax = -1;
+    accumulatedDirtyRowsRequireRepaint = false;
     off();
+    releaseFingerprintFn();
     if (canTrackResize && typeof (resizeSource == null ? void 0 : resizeSource.off) === "function") {
       try {
         resizeSource.off("resize", onResize);
@@ -10973,7 +11893,7 @@ function createStdoutRenderer(terminal, options) {
     }
     if (hideCursor)
       out.write("\x1B[?25h");
-    if (altScreen && out.isTTY)
+    if (altScreen && outputIsTTY)
       out.write("\x1B[?1049l");
     profiler == null ? void 0 : profiler.dispose();
   }
@@ -10987,13 +11907,8 @@ function createStdoutRenderer(terminal, options) {
     }
     if ("palette" in next)
       palette = next.palette ?? null;
-    styleKeyCache = /* @__PURE__ */ new WeakMap();
-    for (const key of Object.keys(COLOR_INDEX)) {
-      if (!(key in BUILTIN_COLOR_INDEX))
-        delete COLOR_INDEX[key];
-    }
-    nextColorIdx = 17;
-    installFingerprintFn();
+    resetStyleKeyIndex();
+    installFingerprintFn(true);
     fpRows = 0;
     fpPrevValid = false;
     prevOverlayBlockedRows = [];