@simon_he/vue-tui 0.0.5 → 0.0.6

package/dist/index.cjs

@@ -2662,12 +2662,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 +2781,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 +2815,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 +2887,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 +2934,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 +3034,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 +3238,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 +3307,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 +3324,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 +3463,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 +3662,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 +3866,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 +3948,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 +3965,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 +3991,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 +4062,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,13 +4084,34 @@ 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;
 }
 
 // src/create-terminal-app.ts
-var import_node_process8 = __toESM(require("process"), 1);
+var import_node_process7 = __toESM(require("process"), 1);
 var import_vue4 = require("vue");
 
 // src/cli/headless-renderer.ts
@@ -6028,9 +6444,6 @@ 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);
@@ -6615,6 +7028,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 +7082,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 +7156,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 +7289,8 @@ function createRenderManager(terminal) {
   return {
     rootStack,
     createStack,
+    invalidatePlane,
+    scrollPlane,
     register,
     update,
     unregister,
@@ -6935,9 +7379,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 env = ((_a2 = import_node_process7.default) == null ? void 0 : _a2.env) ?? {};
   const isGhostty = "GHOSTTY_RESOURCES_DIR" in env;
   const throttleMs = (() => {
     const raw = env.DIMCODE_TUI_THROTTLE_MS;
@@ -6948,7 +7393,7 @@ function createTerminalApp(options) {
   })();
   const frameThrottleMs = (() => {
     var _a3, _b2;
-    if (!((_b2 = (_a3 = import_node_process8.default) == null ? void 0 : _a3.stdout) == null ? void 0 : _b2.isTTY))
+    if (!((_b2 = (_a3 = import_node_process7.default) == null ? void 0 : _a3.stdout) == null ? void 0 : _b2.isTTY))
       return 0;
     return isGhostty ? 24 : 16;
   })();
@@ -6974,17 +7419,21 @@ function createTerminalApp(options) {
     pendingInvalidatePlanes.clear();
     return activePlanes;
   }
-  function flush() {
+  function flush(sync) {
     if (disposed)
       return;
     scheduled = false;
     flushing = true;
     const activePlanes = takeActivePlanes();
     render.render({ activePlanes });
-    terminal.commit({ planes: activePlanes });
+    terminal.commit({ planes: activePlanes, sync });
     flushing = false;
     lastFlushAtMs = Date.now();
     scheduledAtMs = 0;
+    if (pendingInvalidateAfterFlush) {
+      pendingInvalidateAfterFlush = false;
+      flush(true);
+    }
   }
   function clearScheduledTimer() {
     if (!timer)
@@ -7006,9 +7455,9 @@ function createTerminalApp(options) {
     }
     clearScheduledTimer();
     scheduledAtMs = nowMs;
-    if (typeof import_node_process8.default.nextTick === "function") {
+    if (typeof import_node_process7.default.nextTick === "function") {
       ;
-      import_node_process8.default.nextTick(() => {
+      import_node_process7.default.nextTick(() => {
         flush();
       });
     } else if (typeof globalThis.setImmediate === "function") {
@@ -7029,16 +7478,23 @@ function createTerminalApp(options) {
       return;
     clearScheduledTimer();
     scheduled = false;
-    flush();
+    flush(true);
   }
   function invalidate(options2) {
     if (disposed)
       return;
-    if (flushing)
+    if (flushing) {
+      queueInvalidatePlane(options2 == null ? void 0 : options2.plane);
+      pendingInvalidateAfterFlush = true;
       return;
+    }
     const priority = (options2 == null ? void 0 : options2.priority) ?? "normal";
     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 +7637,7 @@ function createTerminalApp(options) {
       if (disposed)
         return;
       disposed = true;
+      clearScheduledTimer();
       if (mounted)
         app.unmount();
       offResize == null ? void 0 : offResize();
@@ -7238,7 +7695,7 @@ function recordStdoutFrame(info) {
 
 // src/renderer/cli/stdout-renderer.ts
 var import_node_buffer2 = require("buffer");
-var import_node_process9 = __toESM(require("process"), 1);
+var import_node_process8 = __toESM(require("process"), 1);
 var debugLog = null;
 function getDebugLog() {
   if (!debugLog) {
@@ -7276,7 +7733,7 @@ function parseWriteMode(raw) {
 }
 function createStdoutRenderer(terminal, options) {
   var _a2, _b2, _c, _d;
-  const output = (options == null ? void 0 : options.output) ?? import_node_process9.default.stdout;
+  const output = (options == null ? void 0 : options.output) ?? import_node_process8.default.stdout;
   if (!output)
     throw new Error("createStdoutRenderer requires a Node stdout-like output");
   const out = output;
@@ -7292,7 +7749,7 @@ function createStdoutRenderer(terminal, options) {
     var _a3;
     if ((options == null ? void 0 : options.useSyncOutput) != null)
       return options.useSyncOutput;
-    const env2 = ((_a3 = import_node_process9.default) == null ? void 0 : _a3.env) ?? {};
+    const env2 = ((_a3 = import_node_process8.default) == null ? void 0 : _a3.env) ?? {};
     const envValue = env2.DIMCODE_SYNC_OUTPUT;
     if (envValue != null) {
       const v = String(envValue).trim().toLowerCase();
@@ -7325,8 +7782,8 @@ function createStdoutRenderer(terminal, options) {
     return 0;
   }
   const useSyncOutput = resolveUseSyncOutput();
-  const isGhostty = "GHOSTTY_RESOURCES_DIR" in (((_a2 = import_node_process9.default) == null ? void 0 : _a2.env) ?? {});
-  const env = ((_b2 = import_node_process9.default) == null ? void 0 : _b2.env) ?? {};
+  const isGhostty = "GHOSTTY_RESOURCES_DIR" in (((_a2 = import_node_process8.default) == null ? void 0 : _a2.env) ?? {});
+  const env = ((_b2 = import_node_process8.default) == null ? void 0 : _b2.env) ?? {};
   const forcedWriteMode = parseWriteMode(
     env.DIMCODE_TUI_WRITE_MODE ?? env.VUE_TUI_WRITE_MODE
   );
@@ -7353,14 +7810,14 @@ function createStdoutRenderer(terminal, options) {
       return Math.min(1, Math.max(0.05, n));
     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 disableCursorPos = isGhostty && ((_d = (_c = import_node_process8.default) == null ? void 0 : _c.env) == null ? void 0 : _d.DIMCODE_DISABLE_CURSOR_POS) === "1";
+  const isVscodeTerminal = String(env.TERM_PROGRAM ?? "").trim().toLowerCase() === "vscode" || "VSCODE_PID" in env || "VSCODE_IPC_HOOK_CLI" in env;
   const enableOsc8Links = (() => {
     if (!out.isTTY)
       return false;
     const raw = String(env.DIMCODE_TUI_LINKS ?? "").trim().toLowerCase();
     if (!raw) {
-      return !(String(env.TERM_PROGRAM ?? "").trim().toLowerCase() === "vscode" || "VSCODE_PID" in env || "VSCODE_IPC_HOOK_CLI" in env);
+      return !isVscodeTerminal;
     }
     return !(raw === "0" || raw === "false" || raw === "no");
   })();
@@ -7369,11 +7826,15 @@ function createStdoutRenderer(terminal, options) {
   let pendingRender = false;
   let renderTimer = null;
   let writeEmaMs = 0;
+  let lastCursorX = null;
+  let lastCursorY = null;
   let accumulatedAllRows = false;
   let accumulatedDirtyBits = null;
   let accumulatedDirtyCount = 0;
   let accumulatedDirtyMin = Number.POSITIVE_INFINITY;
   let accumulatedDirtyMax = -1;
+  let accumulatedScrollOperations = null;
+  let accumulatedSkipUnchangedDirtyRows = true;
   const MIN_FRAME_MS = !out.isTTY ? 0 : isGhostty ? 24 : 16;
   function clampCellToViewport(cell, size) {
     const maxX = Math.max(0, Math.floor(size.cols) - 1);
@@ -7389,26 +7850,44 @@ function createStdoutRenderer(terminal, options) {
     const opt = (options == null ? void 0 : options.colorMode) ?? "auto";
     if (opt !== "auto")
       return opt;
-    const env2 = ((_a3 = import_node_process9.default) == null ? void 0 : _a3.env) ?? {};
+    const env2 = ((_a3 = import_node_process8.default) == null ? void 0 : _a3.env) ?? {};
     return detectTerminalColorCapability({
       env: env2,
       isTTY: Boolean(out.isTTY),
-      platform: String(((_b3 = import_node_process9.default) == null ? void 0 : _b3.platform) ?? "")
+      platform: String(((_b3 = import_node_process8.default) == null ? void 0 : _b3.platform) ?? "")
     }).mode;
   }
   const colorMode = resolveColorMode();
   const enableDim = colorMode === "truecolor";
+  const COLOR_INDEX = {
+    black: 1,
+    red: 2,
+    green: 3,
+    yellow: 4,
+    blue: 5,
+    magenta: 6,
+    cyan: 7,
+    white: 8,
+    blackBright: 9,
+    redBright: 10,
+    greenBright: 11,
+    yellowBright: 12,
+    blueBright: 13,
+    magentaBright: 14,
+    cyanBright: 15,
+    whiteBright: 16
+  };
   let 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 +7934,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 +7993,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 +8012,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 < row.length; x++) {
-      if (row[x] === prevRow[x])
+    for (let x = 0; x < cols; x++) {
+      if (currentFP[base + x] === fillFingerprint)
         continue;
       if (startX === -1)
         startX = x;
       endXExclusive = x + 1;
     }
-    if (startX === -1 || endXExclusive === -1)
+    if (startX === -1)
       return null;
-    const expandedStart = Math.min(
-      expandSpanStart(row, startX),
-      expandSpanStart(prevRow, startX)
-    );
-    const expandedEnd = Math.max(
-      expandSpanEnd(row, endXExclusive),
-      expandSpanEnd(prevRow, endXExclusive)
-    );
+    const expandedStart = expandSpanStart(row, startX);
+    const expandedEnd = expandSpanEnd(row, endXExclusive);
     return expandedEnd > expandedStart ? { startX: expandedStart, endXExclusive: expandedEnd } : null;
   };
-  function overlayPlaneHasVisibleContent() {
-    const lines = overlayTerminal.snapshot().lines;
-    for (const line of lines) {
-      for (let i = 0; i < line.length; i++) {
-        if (line.charCodeAt(i) !== 32)
-          return true;
-      }
+  const resolveChangedSpanAgainstReference = (row, y, cols) => {
+    if (!fpCols || y >= fpRows)
+      return row.length ? { startX: 0, endXExclusive: row.length } : null;
+    const rowFP = terminal.getRowFingerprints(y);
+    const base = y * fpCols;
+    let startX = -1;
+    let endXExclusive = -1;
+    for (let x = 0; x < cols; x++) {
+      const fingerprint = rowFP && rowFP.length >= cols ? rowFP[x] : 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 (prev + 1 - bandStart > bestEnd - bestStart) {
+        bestStart = bandStart;
+        bestEnd = prev + 1;
+      }
+      bandStart = y;
+      prev = y;
+    }
+    if (bandStart !== -1 && prev + 1 - bandStart > bestEnd - bestStart) {
+      bestStart = bandStart;
+      bestEnd = prev + 1;
+    }
+    if (bestStart === -1)
+      return null;
+    const outsideRows = [];
+    for (const y of rows) {
+      if ((blocked == null ? void 0 : blocked.has(y)) || y < bestStart || y >= bestEnd) {
+        outsideRows.push(y);
+      }
+    }
+    return { start: bestStart, end: bestEnd, outsideRows };
+  }
+  function detectScrollShift(cols, dirtyRows, blockedRows) {
+    if (!fpPrevValid || !fpCols || cols !== fpCols)
+      return null;
+    const band = largestDirtyBand(dirtyRows, blockedRows);
+    if (!band || band.end - band.start < 3)
+      return null;
+    const maxDelta = Math.min(
+      12,
+      Math.max(5, band.end - band.start - 1)
+    );
+    for (let delta = -maxDelta; delta <= maxDelta; delta++) {
+      if (delta === 0)
+        continue;
+      let matches = 0;
+      let checked = 0;
+      let mismatches = 0;
+      for (let y = band.start; y < band.end; y++) {
+        const srcY = y + delta;
+        if (srcY < band.start || srcY >= band.end)
+          continue;
+        const informative = rowHasNonDefaultBlankCell(currentFP, y, cols) || rowHasNonDefaultBlankCell(prevFP, srcY, cols);
+        if (!informative)
+          continue;
+        checked++;
+        const curBase = y * fpCols;
+        const prevBase = srcY * fpCols;
+        let rowMatch = true;
+        for (let x = 0; x < cols; x++) {
+          if (currentFP[curBase + x] !== prevFP[prevBase + x]) {
+            rowMatch = false;
+            break;
+          }
+        }
+        if (rowMatch) {
+          matches++;
+        } else {
+          mismatches++;
+        }
+      }
+      if (checked > 0 && matches >= 3 && mismatches <= Math.ceil(checked * 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 null;
   }
   function writeChunked(data) {
     if (!isGhostty) {
@@ -7569,7 +8336,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"}`
@@ -7583,15 +8350,56 @@ function createStdoutRenderer(terminal, options) {
     accumulatedDirtyCount = 0;
     accumulatedDirtyMin = Number.POSITIVE_INFINITY;
     accumulatedDirtyMax = -1;
+    accumulatedScrollOperations = null;
+    accumulatedSkipUnchangedDirtyRows = true;
     lastFrameTime = Date.now();
     const renderStart = performance.now();
     const size = terminal.size();
     ensureRowEscapes(Math.max(size.rows, lastRenderedRows));
-    ensureRenderedRowCache(size.rows);
+    ensureFingerprints(size.cols, size.rows);
     const bgSeq = openBg(defaultBg);
     const bgOnlyStyle = { bg: defaultBg };
     const bgKey = styleKeyFromParts({ bg: defaultBg });
+    const blankFP = bgKey << 16 | charHash16(" ");
+    const cellFingerprint = (cell) => 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 +8425,13 @@ function createStdoutRenderer(terminal, options) {
         outRows.sort((a, b) => a - b);
       return outRows;
     })();
-    if (rowsToRender && rowsToRender.length >= size.rows * dirtyFullThreshold) {
-      rowsToRender = null;
-    }
     const frameParts = [];
     frameParts.push(!isGhostty && useSyncOutput ? SYNC_START : "");
     frameParts.push("\x1B[?7l");
     frameParts.push(SGR_RESET, bgSeq);
+    let lastRenderedY = -1;
+    let lastRenderWasFullRow = false;
+    let hasFrameOutput = false;
     let activeStyleKey = null;
     let activeStyle = {
       fg: null,
@@ -7688,13 +8496,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 +8530,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 +8562,334 @@ 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;
+    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 = overlayRowSet ? explicitDirtyRows.filter((y) => overlayRowSet.has(y)) : [];
+      const paintedExplicitRows = [];
+      for (const y of explicitDirtyRows) {
+        const row = terminal.getRow(y);
+        const overlayRow = overlayRowSet == null ? void 0 : overlayRowSet.has(y);
+        if (overlayRow) {
+          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 = overlayRowSet == null ? void 0 : overlayRowSet.has(y);
+          if (overlayRow) {
+            renderRow2(y, row);
+            fingerprintRow(row, y, size.cols);
+            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 = overlayRowSet ? rowsToRender.filter((y) => overlayRowSet.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 = overlayRowSet == null ? void 0 : overlayRowSet.has(y);
+        if (overlayRow) {
           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 +8900,35 @@ 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");
+      return;
+    }
     if (enableOsc8Links && activeStyle.href)
       frameParts.push(OSC8_CLOSE);
     frameParts.push(SGR_RESET);
@@ -7816,9 +8938,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 +9066,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,
@@ -7965,7 +9094,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 +9102,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 +9150,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 +9203,31 @@ function createStdoutRenderer(terminal, options) {
             accumulatedDirtyMax = y;
         }
       }
+      mergeScrollOperations(scrollOperations);
+      accumulatedSkipUnchangedDirtyRows && (accumulatedSkipUnchangedDirtyRows = skipUnchangedDirtyRows);
     }
-    if (pendingRender)
+    if (pendingRender && !sync) {
       return;
+    }
     const now3 = Date.now();
     const elapsed = now3 - lastFrameTime;
+    if (sync) {
+      if (pendingRender) {
+        pendingRender = false;
+        if (renderTimer) {
+          clearTimeout(renderTimer);
+          renderTimer = null;
+        }
+      }
+      const rows = buildAccumulatedRows();
+      const pendingScrolls = buildAccumulatedScrollOperations();
+      doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
+      return;
+    }
     if (elapsed >= MIN_FRAME_MS) {
       const rows = buildAccumulatedRows();
-      doRender(rows);
+      const pendingScrolls = buildAccumulatedScrollOperations();
+      doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
     } else {
       pendingRender = true;
       if (renderTimer)
@@ -8041,11 +9236,15 @@ function createStdoutRenderer(terminal, options) {
         renderTimer = null;
         if (!disposed) {
           const rows = buildAccumulatedRows();
-          doRender(rows);
+          const pendingScrolls = buildAccumulatedScrollOperations();
+          doRender(rows, pendingScrolls, accumulatedSkipUnchangedDirtyRows);
         }
       }, MIN_FRAME_MS - elapsed);
     }
   }
+  terminal.setFingerprintFn((ch, style) => {
+    return styleKey2(style) << 16 | charHash16(ch);
+  });
   if (altScreen && out.isTTY)
     out.write("\x1B[?1049h");
   if (hideCursor)
@@ -8053,15 +9252,15 @@ 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 resizeSource = (options == null ? void 0 : options.output) ?? import_node_process8.default.stdout;
   const canTrackResize = Boolean(
     trackResize && out.isTTY && typeof (resizeSource == null ? void 0 : resizeSource.on) === "function"
   );
@@ -8093,6 +9292,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 +9338,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 };
@@ -8439,10 +9643,10 @@ function createDomRenderer(terminal, container) {
 }
 
 // src/runtime/index.ts
-var import_node_process10 = __toESM(require("process"), 1);
+var import_node_process9 = __toESM(require("process"), 1);
 function isNodeLike2() {
   var _a2, _b2;
-  return typeof ((_b2 = (_a2 = import_node_process10.default) == null ? void 0 : _a2.versions) == null ? void 0 : _b2.node) === "string";
+  return typeof ((_b2 = (_a2 = import_node_process9.default) == null ? void 0 : _a2.versions) == null ? void 0 : _b2.node) === "string";
 }
 function detectEnv() {
   const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
@@ -8602,23 +9806,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 +9846,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 +9864,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 };
@@ -9910,6 +11133,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 +11182,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")
@@ -10176,6 +11420,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 +11465,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 +11501,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 +13658,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 +13690,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 +13704,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 +13727,9 @@ var TerminalProvider = (0, import_vue19.defineComponent)({
         raf = 0;
       }
       clearTimer();
-      flush();
+      holdNormalInvalidates = true;
+      scheduleNormalInvalidateRelease();
+      flush(true);
     }
     function invalidate(options) {
       if (unmounting)
@@ -12443,6 +13741,10 @@ var TerminalProvider = (0, import_vue19.defineComponent)({
         flushNow();
         return;
       }
+      if (holdNormalInvalidates) {
+        pendingInvalidate = true;
+        return;
+      }
       if (priority === "low") {
         if (timer || raf)
           return;
@@ -13022,6 +14324,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 +15328,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 +15365,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 +15499,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 +15617,7 @@ var TInput = (0, import_vue21.defineComponent)({
       emitMentions(nextMentions);
       ensureCursorVisible();
       syncImeAnchorNow();
-      scheduler.invalidate();
+      scheduler.flushNow();
     }
     function removePendingPasteImage(placeholderPath) {
       const current = getCurrentMentions();
@@ -15124,10 +16435,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 +16703,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 +16731,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,19 +17301,27 @@ 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;
@@ -16019,7 +17342,7 @@ function createWheelScrollState() {
     lastEdgeAt: 0
   };
 }
-function applyWheelScroll(state, deltaY, scrollTop, maxTop, now3 = Date.now()) {
+function applyWheelScroll(state, deltaY, scrollTop, maxTop, now3 = Date.now(), deltaMode = "auto") {
   if (!Number.isFinite(deltaY) || deltaY === 0 || maxTop <= 0) {
     if (maxTop <= 0) {
       state.accumulator = 0;
@@ -16029,12 +17352,12 @@ function applyWheelScroll(state, deltaY, scrollTop, maxTop, now3 = Date.now()) {
     return { nextTop: scrollTop, dir: 0, lines: 0 };
   }
   const dt = state.lastAt ? now3 - state.lastAt : Infinity;
-  const lineUnits = isLineUnitDelta(deltaY);
+  const lineUnits = isLineUnitDelta(deltaY, deltaMode);
   if (lineUnits && dt !== Infinity && dt >= 0 && dt < MIN_TICK_INTERVAL_MS)
     return { nextTop: scrollTop, dir: 0, lines: 0 };
   const accel = lineUnits ? 1 : state.lastAt ? accelFactor(now3, state.lastAt) : 1;
   state.lastAt = now3;
-  state.accumulator += normalizeDelta(deltaY) * accel;
+  state.accumulator += normalizeDelta(deltaY, deltaMode) * accel;
   const lines = Math.trunc(state.accumulator);
   if (lines === 0)
     return { nextTop: scrollTop, dir: 0, lines: 0 };
@@ -16071,6 +17394,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 +17584,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 +17594,9 @@ var TList = (0, import_vue24.defineComponent)({
             wheelState,
             delta,
             scrollTop.value,
-            maxTop
+            maxTop,
+            Date.now(),
+            mode
           );
           if (!dir || nextTop === scrollTop.value)
             return;
@@ -16552,6 +17890,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 +18267,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 +18277,9 @@ var TPathPicker = (0, import_vue26.defineComponent)({
             wheelState,
             delta,
             scrollTop.value,
-            maxTop
+            maxTop,
+            Date.now(),
+            mode
           );
           if (!dir || nextTop === scrollTop.value)
             return;