@xuhaojun/githunk 0.1.0 → 0.1.1

package/dist/githunk.js

@@ -4408,6 +4408,13 @@ function syncVerticalScrollbar(bar, text, viewportHeight) {
   bar.viewportSize = scrollbarViewportOverrides.get(bar) ?? Math.max(0, Math.floor(text.height));
   bar.scrollPosition = text.scrollY;
 }
+function clearScrollbarViewportOverride(text) {
+  const bar = scrollbars.get(text);
+  if (bar === undefined)
+    return;
+  scrollbarViewportOverrides.delete(bar);
+  syncVerticalScrollbar(bar, text);
+}
 function createPane(renderer, id, title, content, selectable = false, options = {}) {
   const tabsConfig = options.tabs;
   const BoxClass = tabsConfig === undefined ? BoxRenderable2 : PaneTabsBoxRenderable;
@@ -4892,36 +4899,62 @@ function computeColumnLayout(rows, width) {
   const widths = indexes.map((j) => j === flexIndex ? flexWidth : rawWidths[j]);
   return { indexes, widths };
 }
-function renderColumns(row, layout) {
-  const chunks = [];
+function layoutListRowSegments(row, layout) {
+  const segments = [];
   for (let i = 0;i < layout.indexes.length; i++) {
     const column = row.columns[layout.indexes[i]];
     const cellWidth = layout.widths[i];
     const isLast = i === layout.indexes.length - 1;
     if (i > 0)
-      chunks.push(plainChunk2(" "));
+      segments.push({ text: " " });
     const text = column?.text ?? "";
     const truncated = truncateToWidth(text, cellWidth);
     if (truncated.length > 0) {
-      if (column?.segments !== undefined && truncated === text) {
+      if (column?.segments !== undefined) {
+        let remaining = [...truncated].length;
         for (const segment of column.segments) {
+          if (remaining <= 0)
+            break;
           if (segment.text.length === 0)
             continue;
-          chunks.push(styleToChunk(segment.text, column.style, segment.color));
+          const chars = [...segment.text];
+          if (chars.length <= remaining) {
+            segments.push({
+              text: segment.text,
+              ...column.style === undefined ? {} : { style: column.style },
+              ...segment.color === undefined ? {} : { color: segment.color }
+            });
+            remaining -= chars.length;
+          } else {
+            segments.push({
+              text: chars.slice(0, remaining).join(""),
+              ...column.style === undefined ? {} : { style: column.style },
+              ...segment.color === undefined ? {} : { color: segment.color }
+            });
+            remaining = 0;
+            break;
+          }
         }
       } else {
-        chunks.push(styleToChunk(truncated, column?.style, column?.color));
+        segments.push({
+          text: truncated,
+          ...column?.style === undefined ? {} : { style: column.style },
+          ...column?.color === undefined ? {} : { color: column.color }
+        });
       }
     }
     if (!isLast) {
       const pad = cellWidth - visualLength(truncated);
       if (pad > 0)
-        chunks.push(plainChunk2(" ".repeat(pad)));
+        segments.push({ text: " ".repeat(pad) });
     }
   }
-  while (chunks.length > 0 && chunks[chunks.length - 1].text.trim().length === 0)
-    chunks.pop();
-  return chunks;
+  while (segments.length > 0 && segments[segments.length - 1].text.trim().length === 0)
+    segments.pop();
+  return segments;
+}
+function renderColumns(row, layout) {
+  return layoutListRowSegments(row, layout).map((segment) => styleToChunk(segment.text, segment.style, segment.color));
 }
 function highlightChunk(chunk, selectedBg) {
   const current = chunk.fg;
@@ -5017,6 +5050,393 @@ function renderListRows(state, focused, width, hoveredId) {
   return new StyledText2(allChunks);
 }
 
+// src/ui/panes/list-text.ts
+import { parseColor } from "@opentui/core";
+
+// src/domain/diff/cell-width.ts
+var WIDE_RANGES = [
+  [4352, 4447],
+  [11904, 42191],
+  [44032, 55203],
+  [63744, 64255],
+  [65072, 65135],
+  [65280, 65376],
+  [65504, 65510],
+  [127744, 129535],
+  [129648, 129791],
+  [131072, 262141]
+];
+function isWide(grapheme) {
+  const code = grapheme.codePointAt(0);
+  if (code === undefined)
+    return false;
+  for (const [low, high] of WIDE_RANGES) {
+    if (code >= low && code <= high)
+      return true;
+  }
+  return false;
+}
+function cellWidth(value) {
+  let ascii = true;
+  for (let index = 0;index < value.length; index++) {
+    if (value.charCodeAt(index) > 127) {
+      ascii = false;
+      break;
+    }
+  }
+  if (ascii)
+    return value.length;
+  let width = 0;
+  for (const codePoint of value)
+    width += isWide(codePoint) ? 2 : 1;
+  return width;
+}
+
+// src/ui/panes/pane-text.ts
+function internalsOf(text) {
+  const candidate = text;
+  const buffer = candidate.textBuffer;
+  const style = candidate._textBufferSyntaxStyle;
+  if (buffer === undefined || style === undefined)
+    return;
+  if (typeof buffer.setText !== "function" || typeof buffer.addHighlight !== "function" || typeof buffer.clearAllHighlights !== "function")
+    return;
+  if (typeof buffer.clearLineHighlights !== "function")
+    return;
+  if (typeof style.registerStyle !== "function" || typeof candidate.updateTextInfo !== "function")
+    return;
+  return candidate;
+}
+function paneTextBuffer(text) {
+  const internals = internalsOf(text);
+  if (internals === undefined)
+    return;
+  internals._hasManualStyledText = true;
+  return {
+    setText(value) {
+      internals.textBuffer.setText(value);
+      internals.updateTextInfo();
+    },
+    addHighlight(row, highlight) {
+      internals.textBuffer.addHighlight(row, highlight);
+    },
+    clearRow(row) {
+      internals.textBuffer.clearLineHighlights(row);
+    },
+    clearAllHighlights() {
+      internals.textBuffer.clearAllHighlights();
+    },
+    registerStyle(name, definition) {
+      return internals._textBufferSyntaxStyle.registerStyle(name, definition);
+    },
+    refresh() {
+      internals.updateTextInfo();
+    }
+  };
+}
+function onPaneLifecyclePass(text, callback) {
+  const host = text;
+  const previous = host.onLifecyclePass;
+  host.onLifecyclePass = () => {
+    previous?.call(text);
+    callback();
+  };
+}
+
+// src/ui/panes/viewport-highlights.ts
+var MARGIN_LINES = 32;
+var LINE_END_COLS = 1e6;
+function createViewportHighlights(text, spec) {
+  const { buffer, paintLine, scrollY: logicalScrollY } = spec;
+  let content;
+  let installed = "";
+  let active = false;
+  let rowSources;
+  let rowSourcesWidth = -1;
+  let appliedScrollY = -1;
+  let appliedHeight = -1;
+  let painted;
+  const paint = (force) => {
+    if (!active)
+      return;
+    const height = Math.max(1, Math.floor(text.height));
+    const scrollY = Math.max(0, Math.floor(logicalScrollY?.(content) ?? text.scrollY));
+    const width = Math.max(1, Math.floor(text.width));
+    if (!force && painted !== undefined && appliedScrollY === scrollY && appliedHeight === height && rowSourcesWidth === width)
+      return;
+    if (rowSources === undefined || rowSourcesWidth !== width) {
+      rowSources = text.lineInfo.lineSources;
+      rowSourcesWidth = width;
+    }
+    const sources = rowSources;
+    const lastRow = Math.max(0, Math.min(scrollY + height - 1, sources.length - 1));
+    const firstLine = sources[Math.min(scrollY, lastRow)] ?? scrollY;
+    const lastLine = sources[lastRow] ?? lastRow;
+    const from = Math.max(0, firstLine - MARGIN_LINES);
+    const to = lastLine + MARGIN_LINES;
+    const previous = painted;
+    if (force || previous === undefined || previous.to < from || previous.from > to) {
+      buffer.clearAllHighlights();
+      for (let line = from;line <= to; line++)
+        paintLine(line, content);
+    } else {
+      for (let line = previous.from;line < from; line++)
+        buffer.clearRow(line);
+      for (let line = to + 1;line <= previous.to; line++)
+        buffer.clearRow(line);
+      for (let line = from;line < previous.from; line++)
+        paintLine(line, content);
+      for (let line = previous.to + 1;line <= to; line++)
+        paintLine(line, content);
+    }
+    painted = { from, to };
+    appliedScrollY = scrollY;
+    appliedHeight = height;
+  };
+  onPaneLifecyclePass(text, () => paint(false));
+  return {
+    install(full, next) {
+      content = next;
+      active = true;
+      const changed = installed !== full;
+      if (changed) {
+        installed = full;
+        buffer.setText(full);
+        rowSources = undefined;
+        painted = undefined;
+      }
+      paint(changed);
+    },
+    repaint() {
+      paint(true);
+    },
+    release() {
+      if (!active)
+        return;
+      buffer.clearAllHighlights();
+      active = false;
+      installed = "";
+      rowSources = undefined;
+      rowSourcesWidth = -1;
+      appliedScrollY = -1;
+      appliedHeight = -1;
+      painted = undefined;
+    }
+  };
+}
+
+// src/ui/panes/list-text.ts
+var painters = new WeakMap;
+function resolveSegment(text, style, color) {
+  let fg3;
+  let dim2;
+  if (color !== undefined) {
+    fg3 = parseColor(color);
+  } else {
+    switch (style) {
+      case "dim":
+        dim2 = true;
+        break;
+      case "cyan":
+        fg3 = ANSI_CYAN;
+        break;
+      case "green":
+        fg3 = ANSI_GREEN;
+        break;
+      case "yellow":
+        fg3 = ANSI_YELLOW;
+        break;
+      case "magenta":
+        fg3 = ANSI_MAGENTA;
+        break;
+      case "default":
+      case undefined:
+        break;
+    }
+  }
+  return {
+    text,
+    ...fg3 === undefined ? {} : { fg: fg3 },
+    ...dim2 === undefined ? {} : { dim: dim2 }
+  };
+}
+function styleKey(fg3, bold3, dim2, bg2) {
+  const fgKey = fg3 === undefined ? "" : fg3.toInts().join(",");
+  const bgKey = bg2 === undefined ? "" : bg2.toInts().join(",");
+  return `${fgKey}|${bold3 ? 1 : 0}|${dim2 ? 1 : 0}|${bgKey}`;
+}
+function styleIdFor(record, fg3, bold3, dim2, bg2) {
+  const key = styleKey(fg3, bold3, dim2, bg2);
+  const cached = record.styleIds.get(key);
+  if (cached !== undefined)
+    return cached;
+  const id = record.buffer.registerStyle(`githunk.list.${record.styleIds.size}`, {
+    ...fg3 === undefined ? {} : { fg: fg3 },
+    ...bg2 === undefined ? {} : { bg: bg2 },
+    ...bold3 ? { bold: bold3 } : {},
+    ...dim2 ? { dim: dim2 } : {}
+  });
+  record.styleIds.set(key, id);
+  return id;
+}
+function rowVisual(state, focused, hoveredId, rowIndexById, range, displayRow) {
+  if (displayRow.kind !== "item")
+    return 0;
+  if (focused && displayRow.id === state.selectedId)
+    return 1;
+  if (range !== undefined) {
+    const index = rowIndexById.get(displayRow.id);
+    if (index !== undefined && index >= range.startIndex && index <= range.endIndex)
+      return 2;
+  }
+  if (displayRow.id === hoveredId)
+    return 3;
+  return 0;
+}
+function layoutFor(state, safeWidth) {
+  const displayRows = state.displayRows;
+  const rowMap = new Map(state.rows.map((row) => [row.id, row]));
+  const visibleRows = displayRows.flatMap((dr) => {
+    if (dr.kind !== "item")
+      return [];
+    const row = rowMap.get(dr.id);
+    return row === undefined ? [] : [row];
+  });
+  const layout = computeColumnLayout(visibleRows, safeWidth);
+  const rowTexts = [];
+  const rowSegments = [];
+  for (const dr of displayRows) {
+    if (dr.kind !== "item") {
+      const truncated = [...dr.text].slice(0, safeWidth).join("");
+      rowTexts.push(truncated);
+      rowSegments.push(truncated.length === 0 ? [] : [{ text: truncated }]);
+      continue;
+    }
+    const row = rowMap.get(dr.id);
+    const laidOut = row === undefined ? [] : layoutListRowSegments(row, layout).map((segment) => resolveSegment(segment.text, segment.style, segment.color));
+    const joined = laidOut.map((segment) => segment.text).join("");
+    const pad = Math.max(0, safeWidth - cellWidth(joined));
+    rowTexts.push(pad === 0 ? joined : `${joined}${" ".repeat(pad)}`);
+    rowSegments.push(laidOut);
+  }
+  return { rows: state.rows, width: safeWidth, rowTexts, rowSegments, joined: rowTexts.join(`
+`) };
+}
+function visualsFor(state, focused, hoveredId) {
+  const rowIndexById = new Map(state.rows.map((row, index) => [row.id, index]));
+  const rangeActive = focused && isListRangeActive(state);
+  const range = rangeActive ? getListSelectionRange(state) : undefined;
+  return state.displayRows.map((dr) => rowVisual(state, focused, hoveredId, rowIndexById, range, dr));
+}
+function paintRow(record, line) {
+  const snap = record.ref.snap;
+  if (snap === undefined)
+    return;
+  const segments = snap.rowSegments[line];
+  const visual = snap.visuals[line];
+  if (segments === undefined || visual === undefined)
+    return;
+  const { buffer } = record;
+  buffer.clearRow(line);
+  const bg2 = visual === 1 || visual === 2 ? SELECTED_LINE_BG : visual === 3 ? HOVER_LINE_BG : undefined;
+  let column = 0;
+  for (const segment of segments) {
+    const cells = cellWidth(segment.text);
+    if (cells > 0) {
+      if (visual === 1) {
+        buffer.addHighlight(line, {
+          start: column,
+          end: column + cells,
+          styleId: styleIdFor(record, segment.fg === undefined ? undefined : brightenAnsiForeground(segment.fg), true, segment.dim === true, bg2)
+        });
+      } else if (bg2 !== undefined) {
+        buffer.addHighlight(line, {
+          start: column,
+          end: column + cells,
+          styleId: styleIdFor(record, segment.fg, false, segment.dim === true, bg2)
+        });
+      } else if (segment.fg !== undefined || segment.dim === true) {
+        buffer.addHighlight(line, {
+          start: column,
+          end: column + cells,
+          styleId: styleIdFor(record, segment.fg, false, segment.dim === true, undefined)
+        });
+      }
+    }
+    column += cells;
+  }
+  if (bg2 !== undefined) {
+    buffer.addHighlight(line, { start: column, end: LINE_END_COLS, styleId: styleIdFor(record, undefined, false, false, bg2) });
+  }
+}
+function ensurePainter(text, buffer) {
+  const existing = painters.get(text);
+  if (existing !== undefined)
+    return existing;
+  const ref = { snap: undefined };
+  const record = {
+    buffer,
+    viewport: undefined,
+    ref,
+    styleIds: new Map,
+    cache: undefined,
+    joined: "",
+    visuals: []
+  };
+  record.viewport = createViewportHighlights(text, {
+    buffer,
+    paintLine: (line) => paintRow(record, line)
+  });
+  painters.set(text, record);
+  return record;
+}
+function installListText(text, content) {
+  const buffer = paneTextBuffer(text);
+  if (buffer === undefined) {
+    text.content = renderListRows(content.state, content.focused, content.width, content.hoveredId);
+    return;
+  }
+  const record = ensurePainter(text, buffer);
+  const safeWidth = Math.max(0, Math.floor(content.width));
+  const previousCache = record.cache;
+  const cache = previousCache !== undefined && previousCache.rows === content.state.rows && previousCache.width === safeWidth ? previousCache : layoutFor(content.state, safeWidth);
+  record.cache = cache;
+  const visuals = visualsFor(content.state, content.focused, content.hoveredId);
+  record.ref.snap = { rowSegments: cache.rowSegments, visuals };
+  if (cache.joined !== record.joined) {
+    record.joined = cache.joined;
+    record.visuals = visuals;
+    record.viewport.install(cache.joined, record.ref);
+    return;
+  }
+  if (cache !== previousCache) {
+    record.visuals = visuals;
+    record.viewport.repaint();
+    record.buffer.refresh();
+    return;
+  }
+  const previous = record.visuals;
+  record.visuals = visuals;
+  let repainted = false;
+  const lines = Math.max(previous.length, visuals.length);
+  for (let line = 0;line < lines; line++) {
+    if (previous[line] !== visuals[line]) {
+      paintRow(record, line);
+      repainted = true;
+    }
+  }
+  if (repainted)
+    record.buffer.refresh();
+}
+function releaseListText(text) {
+  const record = painters.get(text);
+  if (record === undefined)
+    return;
+  record.viewport.release();
+  record.buffer.refresh();
+  painters.delete(text);
+}
+
 // src/ui/panes/branches-pane.ts
 function localBranchRows(model, filter = "", options = {}) {
   const listing = model.branches;
@@ -5067,8 +5487,7 @@ function createBranchesPane(renderer, model) {
   const rows = localBranchRows(model);
   const displayRows = rows.length === 0 ? [{ kind: "message", text: "No branches" }] : undefined;
   const state = createListState(rows, displayRows);
-  const content = renderListRows(state, false, 80);
-  pane.update(content);
+  installListText(pane.text, { state, width: 80, focused: false });
   pane.syncScrollbar();
   return pane;
 }
@@ -5389,47 +5808,6 @@ function commitGraphRows(commits, getColor) {
 
 // src/ui/author-style.ts
 import { createHash as createHash2 } from "node:crypto";
-
-// src/ui/cell-width.ts
-var WIDE_RANGES = [
-  [4352, 4447],
-  [11904, 42191],
-  [44032, 55203],
-  [63744, 64255],
-  [65072, 65135],
-  [65280, 65376],
-  [65504, 65510],
-  [127744, 129535],
-  [129648, 129791],
-  [131072, 262141]
-];
-function isWide(grapheme) {
-  const code = grapheme.codePointAt(0);
-  if (code === undefined)
-    return false;
-  for (const [low, high] of WIDE_RANGES) {
-    if (code >= low && code <= high)
-      return true;
-  }
-  return false;
-}
-function cellWidth(value) {
-  let ascii = true;
-  for (let index = 0;index < value.length; index++) {
-    if (value.charCodeAt(index) > 127) {
-      ascii = false;
-      break;
-    }
-  }
-  if (ascii)
-    return value.length;
-  let width = 0;
-  for (const codePoint of value)
-    width += isWide(codePoint) ? 2 : 1;
-  return width;
-}
-
-// src/ui/author-style.ts
 var initialsCache = new Map;
 var colorCache = new Map;
 function randInt(bytes, max) {
@@ -5559,20 +5937,22 @@ function buildCommitRows(commits, now, filter = "") {
     const shortHash2 = commit.oid.length >= 8 ? commit.oid.slice(0, 8) : commit.shortOid;
     const initials = authorInitials(commit.authorName).padEnd(AUTHOR_COLUMN_WIDTH, " ");
     const relative = formatRelativeTime(commit.authoredAt, now);
+    const graphText = graph?.text ?? "";
+    const graphSegments = graph?.segments ?? [];
+    const subjectSegments = commit.subject.length === 0 ? [] : [{ text: commit.subject }];
     return {
       id: commit.oid,
       columns: [
         { text: shortHash2, priority: 1, color: commitHashColor(commit.status) },
-        { text: initials, priority: 3, color: authorColor(commit.authorName) },
-        { text: graph?.text ?? "", priority: 0, segments: graph?.segments ?? [] },
-        { text: commit.subject, priority: 2, flex: true },
-        { text: relative, priority: 4, style: "dim" }
+        { text: initials, priority: 2, color: authorColor(commit.authorName) },
+        { text: `${graphText}${commit.subject}`, priority: 2, flex: true, segments: [...graphSegments, ...subjectSegments] },
+        { text: relative, priority: 0, style: "dim" }
       ]
     };
   });
   if (filter.length === 0)
     return rows;
-  return [...filterItems(filter, rows, (row) => `${row.columns[0]?.text ?? ""} ${row.columns[3]?.text ?? row.id}`)];
+  return [...filterItems(filter, rows, (row) => `${row.columns[0]?.text ?? ""} ${row.columns[2]?.text ?? row.id}`)];
 }
 function createCommitsPane(renderer, model) {
   const pane = createPane(renderer, "commits", "", "No commit selected", false, {
@@ -5586,6 +5966,7 @@ function updateCommitsPane(pane, model) {
   if (commits.length === 0) {
     const empty = createListState([]);
     paneStates.set(pane, empty);
+    releaseListText(pane.text);
     pane.update(model.loading ? "Loading…" : "No commits");
     return;
   }
@@ -5599,8 +5980,7 @@ function updateCommitsPane(pane, model) {
       state = withPrev;
   }
   paneStates.set(pane, state);
-  const content = renderListRows(state, false, 80);
-  pane.update(content);
+  installListText(pane.text, { state, width: 80, focused: false });
   pane.box.bottomTitle = undefined;
 }
 
@@ -5736,183 +6116,56 @@ function parseAnsi(input) {
   let runStart = 0;
   let runStyle = { ...DEFAULT_STYLE };
   const closeRun = () => {
-    if (column > runStart && styled(runStyle)) {
-      spans.push({
-        row,
-        start: runStart,
-        end: column,
-        ...runStyle.fg === undefined ? {} : { fg: runStyle.fg },
-        ...runStyle.bold ? { bold: true } : {},
-        ...runStyle.dim ? { dim: true } : {}
-      });
-    }
-    runStart = column;
-  };
-  for (let index = 0;index < input.length; ) {
-    const char = input[index];
-    if (char === "\x1B") {
-      const length = escapeLength(input, index);
-      if (input[index + 1] === "[" && input[index + length - 1] === "m") {
-        const next = applySgr(style, parseParams(input.slice(index + 2, index + length - 1)));
-        if (!sameStyle(next, runStyle)) {
-          closeRun();
-          runStyle = next;
-        }
-        style = next;
-      }
-      index += length;
-      continue;
-    }
-    if (char === `
-`) {
-      closeRun();
-      out.push(char);
-      row++;
-      column = 0;
-      runStart = 0;
-      index += 1;
-      continue;
-    }
-    const codePoint = input.codePointAt(index);
-    const size = codePoint > 65535 ? 2 : 1;
-    out.push(input.slice(index, index + size));
-    column += 1;
-    index += size;
-  }
-  closeRun();
-  return { text: out.join(""), spans };
-}
-
-// src/ui/panes/command-log-pane.ts
-import { BoxRenderable as BoxRenderable3, TextRenderable as TextRenderable2 } from "@opentui/core";
-
-// src/ui/panes/pane-text.ts
-function internalsOf(text) {
-  const candidate = text;
-  const buffer = candidate.textBuffer;
-  const style = candidate._textBufferSyntaxStyle;
-  if (buffer === undefined || style === undefined)
-    return;
-  if (typeof buffer.setText !== "function" || typeof buffer.addHighlight !== "function" || typeof buffer.clearAllHighlights !== "function")
-    return;
-  if (typeof buffer.clearLineHighlights !== "function")
-    return;
-  if (typeof style.registerStyle !== "function" || typeof candidate.updateTextInfo !== "function")
-    return;
-  return candidate;
-}
-function paneTextBuffer(text) {
-  const internals = internalsOf(text);
-  if (internals === undefined)
-    return;
-  internals._hasManualStyledText = true;
-  return {
-    setText(value) {
-      internals.textBuffer.setText(value);
-      internals.updateTextInfo();
-    },
-    addHighlight(row, highlight) {
-      internals.textBuffer.addHighlight(row, highlight);
-    },
-    clearRow(row) {
-      internals.textBuffer.clearLineHighlights(row);
-    },
-    clearAllHighlights() {
-      internals.textBuffer.clearAllHighlights();
-    },
-    registerStyle(name, definition) {
-      return internals._textBufferSyntaxStyle.registerStyle(name, definition);
-    }
-  };
-}
-function onPaneLifecyclePass(text, callback) {
-  const host = text;
-  const previous = host.onLifecyclePass;
-  host.onLifecyclePass = () => {
-    previous?.call(text);
-    callback();
-  };
-}
-
-// src/ui/panes/viewport-highlights.ts
-var MARGIN_LINES = 32;
-var LINE_END_COLS = 1e6;
-function createViewportHighlights(text, spec) {
-  const { buffer, paintLine } = spec;
-  let content;
-  let installed = "";
-  let active = false;
-  let rowSources;
-  let rowSourcesWidth = -1;
-  let appliedScrollY = -1;
-  let appliedHeight = -1;
-  let painted;
-  const paint = (force) => {
-    if (!active)
-      return;
-    const height = Math.max(1, Math.floor(text.height));
-    const scrollY = Math.max(0, Math.floor(text.scrollY));
-    const width = Math.max(1, Math.floor(text.width));
-    if (!force && painted !== undefined && appliedScrollY === scrollY && appliedHeight === height && rowSourcesWidth === width)
-      return;
-    if (rowSources === undefined || rowSourcesWidth !== width) {
-      rowSources = text.lineInfo.lineSources;
-      rowSourcesWidth = width;
-    }
-    const sources = rowSources;
-    const lastRow = Math.max(0, Math.min(scrollY + height - 1, sources.length - 1));
-    const firstLine = sources[Math.min(scrollY, lastRow)] ?? scrollY;
-    const lastLine = sources[lastRow] ?? lastRow;
-    const from = Math.max(0, firstLine - MARGIN_LINES);
-    const to = lastLine + MARGIN_LINES;
-    const previous = painted;
-    if (previous === undefined || previous.to < from || previous.from > to) {
-      buffer.clearAllHighlights();
-      for (let line = from;line <= to; line++)
-        paintLine(line, content);
-    } else {
-      for (let line = previous.from;line < from; line++)
-        buffer.clearRow(line);
-      for (let line = to + 1;line <= previous.to; line++)
-        buffer.clearRow(line);
-      for (let line = from;line < previous.from; line++)
-        paintLine(line, content);
-      for (let line = previous.to + 1;line <= to; line++)
-        paintLine(line, content);
-    }
-    painted = { from, to };
-    appliedScrollY = scrollY;
-    appliedHeight = height;
-  };
-  onPaneLifecyclePass(text, () => paint(false));
-  return {
-    install(full, next) {
-      content = next;
-      active = true;
-      const changed = installed !== full;
-      if (changed) {
-        installed = full;
-        buffer.setText(full);
-        rowSources = undefined;
-        painted = undefined;
-      }
-      paint(changed);
-    },
-    release() {
-      if (!active)
-        return;
-      buffer.clearAllHighlights();
-      active = false;
-      installed = "";
-      rowSources = undefined;
-      rowSourcesWidth = -1;
-      appliedScrollY = -1;
-      appliedHeight = -1;
-      painted = undefined;
+    if (column > runStart && styled(runStyle)) {
+      spans.push({
+        row,
+        start: runStart,
+        end: column,
+        ...runStyle.fg === undefined ? {} : { fg: runStyle.fg },
+        ...runStyle.bold ? { bold: true } : {},
+        ...runStyle.dim ? { dim: true } : {}
+      });
     }
+    runStart = column;
   };
+  for (let index = 0;index < input.length; ) {
+    const char = input[index];
+    if (char === "\x1B") {
+      const length = escapeLength(input, index);
+      if (input[index + 1] === "[" && input[index + length - 1] === "m") {
+        const next = applySgr(style, parseParams(input.slice(index + 2, index + length - 1)));
+        if (!sameStyle(next, runStyle)) {
+          closeRun();
+          runStyle = next;
+        }
+        style = next;
+      }
+      index += length;
+      continue;
+    }
+    if (char === `
+`) {
+      closeRun();
+      out.push(char);
+      row++;
+      column = 0;
+      runStart = 0;
+      index += 1;
+      continue;
+    }
+    const codePoint = input.codePointAt(index);
+    const size = codePoint > 65535 ? 2 : 1;
+    out.push(input.slice(index, index + size));
+    column += 1;
+    index += size;
+  }
+  closeRun();
+  return { text: out.join(""), spans };
 }
 
+// src/ui/panes/command-log-pane.ts
+import { BoxRenderable as BoxRenderable3, TextRenderable as TextRenderable2 } from "@opentui/core";
+
 // src/ui/panes/command-log-text.ts
 var STYLE_DEFINITIONS = {
   action: { fg: ANSI_YELLOW },
@@ -5947,7 +6200,7 @@ function registerStyles(buffer) {
   }
   return ids;
 }
-var painters = new WeakMap;
+var painters2 = new WeakMap;
 function installCommandLogText(text, lines) {
   const full = lines.map((line) => line.spans.map((span) => span.text).join("")).join(`
 `);
@@ -5956,7 +6209,7 @@ function installCommandLogText(text, lines) {
     text.content = full;
     return;
   }
-  let painter = painters.get(text);
+  let painter = painters2.get(text);
   if (painter === undefined) {
     const styleIds = registerStyles(buffer);
     painter = createViewportHighlights(text, {
@@ -5970,7 +6223,7 @@ function installCommandLogText(text, lines) {
         }
       }
     });
-    painters.set(text, painter);
+    painters2.set(text, painter);
   }
   painter.install(full, lines);
 }
@@ -6452,7 +6705,7 @@ function createFilesPane(renderer, model) {
   const initialRows = filesTreeRows(createFilesTreeState(model), model);
   const displayRows = initialRows.length === 0 ? [{ kind: "message", text: NO_CHANGED_FILES }] : undefined;
   const state = createListState(initialRows, displayRows);
-  pane.update(renderListRows(state, false, 80));
+  installListText(pane.text, { state, width: 80, focused: false });
   return pane;
 }
 function anyStagedChanges(model) {
@@ -6737,14 +6990,14 @@ function changedIndexesInDiffLineRange(document, state) {
 
 // src/ui/panes/ansi-text.ts
 import { StyledText as StyledText3, bold as boldChunk, dim as dimChunk, fg as fgChunk } from "@opentui/core";
-var painters2 = new WeakMap;
-function styleKey(span) {
+var painters3 = new WeakMap;
+function styleKey2(span) {
   const color = span.fg;
   const colorKey = color === undefined ? "-" : `${color.intent}:${color.slot}:${color.toInts().join(",")}`;
   return `${colorKey}|${span.bold === true ? "b" : "-"}${span.dim === true ? "d" : "-"}`;
 }
-function styleIdFor(buffer, styleIds, span) {
-  const key = styleKey(span);
+function styleIdFor2(buffer, styleIds, span) {
+  const key = styleKey2(span);
   const existing = styleIds.get(key);
   if (existing !== undefined)
     return existing;
@@ -6826,7 +7079,7 @@ function installAnsiText(text, content) {
   }
   const { text: full, firstBodyRow } = joined(content);
   const spansByRow = groupByRow(content.spans, firstBodyRow);
-  let painter = painters2.get(text);
+  let painter = painters3.get(text);
   if (painter === undefined) {
     const styleIds = new Map;
     painter = {
@@ -6838,17 +7091,17 @@ function installAnsiText(text, content) {
           if (spans === undefined)
             return;
           for (const span of spans) {
-            buffer.addHighlight(row, { start: span.start, end: span.end, styleId: styleIdFor(buffer, styleIds, span) });
+            buffer.addHighlight(row, { start: span.start, end: span.end, styleId: styleIdFor2(buffer, styleIds, span) });
           }
         }
       })
     };
-    painters2.set(text, painter);
+    painters3.set(text, painter);
   }
   painter.highlights.install(full, spansByRow);
 }
 function releaseAnsiText(text) {
-  painters2.get(text)?.highlights.release();
+  painters3.get(text)?.highlights.release();
 }
 
 // src/ui/panes/diff-text.ts
@@ -6937,7 +7190,7 @@ function statSpansForRow(value, spans) {
 function preambleSpansForRow(value, spans) {
   return spans === undefined ? [plainChunk3(value)] : statSpansForRow(value, spans);
 }
-var painters3 = new WeakMap;
+var painters4 = new WeakMap;
 function registerStyles2(buffer) {
   const ids = {};
   for (const [name, definition] of Object.entries(STYLE_DEFINITIONS2)) {
@@ -6975,7 +7228,7 @@ function styledChunk(style, value) {
 }
 function paintAsChunks2(text, content) {
   const { text: full, firstDiffRow } = joined2(content);
-  const preambleSpans = statSpansForPreamble(content.preamble);
+  const preambleSpans = content.preambleSpans ?? statSpansForPreamble(content.preamble);
   const rows = full.split(`
 `);
   const chunks = [];
@@ -7008,13 +7261,15 @@ function installDiffText(text, content) {
   const paint = {
     displayLines: content.displayLines,
     firstDiffRow,
-    preambleSpans: statSpansForPreamble(content.preamble)
+    preambleSpans: content.preambleSpans ?? statSpansForPreamble(content.preamble),
+    ...content.highlightScrollY === undefined ? {} : { highlightScrollY: content.highlightScrollY }
   };
-  let painter = painters3.get(text);
+  let painter = painters4.get(text);
   if (painter === undefined) {
     const styleIds = registerStyles2(buffer);
     painter = createViewportHighlights(text, {
       buffer,
+      scrollY: (current) => current.highlightScrollY?.() ?? text.scrollY,
       paintLine: (row, current) => {
         const preambleSpans = current.preambleSpans.get(row);
         if (preambleSpans !== undefined) {
@@ -7031,12 +7286,508 @@ function installDiffText(text, content) {
           buffer.addHighlight(row, { start: display.gutterCols, end: LINE_END_COLS, styleId: styleIds[display.style] });
       }
     });
-    painters3.set(text, painter);
+    painters4.set(text, painter);
   }
   painter.install(full, paint);
 }
 function releaseDiffText(text) {
-  painters3.get(text)?.release();
+  painters4.get(text)?.release();
+}
+
+// src/domain/diff/virtual.ts
+var VIRTUAL_DIFF_LINE_THRESHOLD = 1e4;
+function isSourceLine(line) {
+  return line.kind === "context" || line.kind === "addition" || line.kind === "deletion";
+}
+function styleFor2(line) {
+  if (line.kind === "addition")
+    return "addition";
+  if (line.kind === "deletion")
+    return "deletion";
+  if (line.kind === "hunk-header")
+    return "hunk-header";
+  if (line.kind === "metadata" || line.kind === "no-newline")
+    return "metadata";
+  return "plain";
+}
+function lineNumberWidth2(document) {
+  let largest = 1;
+  for (const line of document.lines) {
+    largest = Math.max(largest, line.oldLine ?? 0, line.newLine ?? 0);
+  }
+  return String(largest).length;
+}
+function linePrefix(line, width) {
+  if (!isSourceLine(line))
+    return "";
+  const old = line.oldLine === undefined ? "" : String(line.oldLine);
+  const next = line.newLine === undefined ? "" : String(line.newLine);
+  return `${old.padStart(width, " ")} ${next.padStart(width, " ")} `;
+}
+function withoutLineEnding2(raw) {
+  if (raw.endsWith(`\r
+`))
+    return raw.slice(0, -2);
+  if (raw.endsWith(`
+`) || raw.endsWith("\r"))
+    return raw.slice(0, -1);
+  return raw;
+}
+function normalizePreamble(preamble) {
+  if (preamble.length === 0)
+    return { text: "", rows: [], starts: [], ends: [] };
+  const text = preamble.endsWith(`
+`) ? preamble : `${preamble}
+`;
+  const rows = text.slice(0, -1).split(`
+`).map(withoutLineEnding2);
+  const starts = [];
+  const ends = [];
+  let start = 0;
+  for (let row = 0;row < rows.length; row += 1) {
+    const newline = text.indexOf(`
+`, start);
+    starts.push(start);
+    ends.push(newline < 0 ? text.length : newline + 1);
+    start = newline < 0 ? text.length : newline + 1;
+  }
+  return { text, rows, starts, ends };
+}
+function boundedIndex(value, length) {
+  if (!Number.isFinite(value))
+    return value < 0 ? 0 : length;
+  return Math.min(length, Math.max(0, Math.floor(value)));
+}
+function createVirtualDiffLayout(document, preamble) {
+  const normalized = normalizePreamble(preamble);
+  const width = lineNumberWidth2(document);
+  const prefixes = document.lines.map((line) => linePrefix(line, width));
+  const displayStarts = new Array(document.lines.length);
+  let displayLength = normalized.text.length;
+  let contentWidth = 0;
+  for (const row of normalized.rows)
+    contentWidth = Math.max(contentWidth, cellWidth(row));
+  for (let index = 0;index < document.lines.length; index += 1) {
+    const line = document.lines[index];
+    const prefix = prefixes[index];
+    const text = `${prefix}${withoutLineEnding2(line.raw)}`;
+    displayStarts[index] = displayLength;
+    displayLength += prefix.length + line.raw.length;
+    contentWidth = Math.max(contentWidth, cellWidth(text));
+  }
+  const totalRows = normalized.rows.length + document.lines.length;
+  const bodyRow = (lineIndex) => {
+    const line = document.lines[lineIndex];
+    const prefix = prefixes[lineIndex];
+    return {
+      text: `${prefix}${withoutLineEnding2(line.raw)}`,
+      gutterCols: prefix.length,
+      style: styleFor2(line),
+      lineIndex,
+      rawStartUtf16: line.startUtf16,
+      rawEndUtf16: line.endUtf16,
+      displayStartUtf16: displayStarts[lineIndex],
+      displayEndUtf16: displayStarts[lineIndex] + prefix.length + line.raw.length
+    };
+  };
+  const rowAt = (row) => {
+    if (!Number.isSafeInteger(row) || row < 0 || row >= totalRows)
+      return;
+    if (row < normalized.rows.length) {
+      const text = normalized.rows[row];
+      return {
+        text,
+        gutterCols: 0,
+        style: "plain",
+        displayStartUtf16: normalized.starts[row],
+        displayEndUtf16: normalized.ends[row]
+      };
+    }
+    return bodyRow(row - normalized.rows.length);
+  };
+  const window = (scrollTop, viewportHeight, overscan) => {
+    const viewport = Math.max(0, Math.floor(Number.isFinite(viewportHeight) ? viewportHeight : 0));
+    if (totalRows === 0 || viewport === 0)
+      return [0, -1];
+    const margin = Math.max(0, Math.floor(Number.isFinite(overscan) ? overscan : 0));
+    const maxScroll = Math.max(0, totalRows - viewport);
+    const top = Math.min(maxScroll, Math.max(0, Math.floor(Number.isFinite(scrollTop) ? scrollTop : 0)));
+    return [Math.max(0, top - margin), Math.min(totalRows - 1, top + viewport - 1 + margin)];
+  };
+  const displayOffsetsForLines = (startIndex, endIndex) => {
+    let start = boundedIndex(startIndex, document.lines.length);
+    let end = boundedIndex(endIndex, document.lines.length);
+    if (end < start)
+      [start, end] = [end, start];
+    const rawStartUtf16 = start < document.lines.length ? document.lines[start].startUtf16 : document.text.length;
+    const rawEndUtf16 = end < document.lines.length ? document.lines[end].startUtf16 : document.text.length;
+    const displayStartUtf16 = start < document.lines.length ? displayStarts[start] : displayLength;
+    const displayEndUtf16 = end < document.lines.length ? displayStarts[end] : displayLength;
+    return { rawStartUtf16, rawEndUtf16, displayStartUtf16, displayEndUtf16 };
+  };
+  const rawOffsetAt = (row, column) => {
+    const value = rowAt(row);
+    if (value?.lineIndex === undefined || value.rawStartUtf16 === undefined || value.rawEndUtf16 === undefined)
+      return;
+    const line = document.lines[value.lineIndex];
+    const target = Math.max(0, Math.floor(Number.isFinite(column) ? column : 0));
+    if (target <= value.gutterCols)
+      return line.startUtf16;
+    const body = withoutLineEnding2(line.raw);
+    const bodyColumn = target - value.gutterCols;
+    let cells = 0;
+    let utf16 = 0;
+    for (const codePoint of body) {
+      const widthInCells = cellWidth(codePoint);
+      if (bodyColumn <= cells)
+        return line.startUtf16 + utf16;
+      utf16 += codePoint.length;
+      cells += widthInCells;
+      if (bodyColumn <= cells)
+        return line.startUtf16 + utf16;
+    }
+    return line.endUtf16;
+  };
+  return { preambleRows: normalized.rows.length, totalRows, contentWidth, rowAt, window, displayOffsetsForLines, rawOffsetAt };
+}
+
+// src/ui/panes/virtual-main-pane.ts
+var ACCESSORS = ["scrollY", "scrollHeight", "maxScrollY", "scrollX", "scrollWidth", "maxScrollX"];
+var virtualPanes = new WeakMap;
+var VIRTUAL_MAIN_OVERSCAN_MIN = 10;
+function prototypeDescriptor(text, name) {
+  let prototype = Object.getPrototypeOf(text);
+  while (prototype !== null) {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+    if (descriptor !== undefined)
+      return descriptor;
+    prototype = Object.getPrototypeOf(prototype);
+  }
+  return;
+}
+function isFiniteNonNegative(value) {
+  return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function documentSelection(document, startUtf16, endUtf16) {
+  const line = document.lines.find((entry) => startUtf16 >= entry.startUtf16 && startUtf16 <= entry.endUtf16) ?? document.lines[0];
+  return {
+    valid: true,
+    startUtf16,
+    endUtf16,
+    ...line === undefined ? {} : {
+      fileIndex: line.fileIndex,
+      ...line.hunkIndex === undefined ? {} : { hunkIndex: line.hunkIndex }
+    },
+    active: true
+  };
+}
+function dimensions(text) {
+  return {
+    height: Math.max(1, Math.floor(isFiniteNonNegative(text.height))),
+    width: Math.max(0, Math.floor(isFiniteNonNegative(text.width)))
+  };
+}
+function padDisplayRow(value, width) {
+  return `${value}${" ".repeat(Math.max(0, width - cellWidth(value)))}`;
+}
+function withoutLineEnding3(raw) {
+  if (raw.endsWith(`\r
+`))
+    return raw.slice(0, -2);
+  if (raw.endsWith(`
+`) || raw.endsWith("\r"))
+    return raw.slice(0, -1);
+  return raw;
+}
+function rawDisplayCells(raw, relativeUtf16, includeLineEnding) {
+  const body = withoutLineEnding3(raw);
+  const prefixLength = Math.min(body.length, Math.max(0, Math.floor(relativeUtf16)));
+  const cells = cellWidth(body.slice(0, prefixLength));
+  return cells + (includeLineEnding && prefixLength >= body.length && body.length < raw.length ? 1 : 0);
+}
+function installAccessors(pane, state, rerender) {
+  const text = pane.text;
+  for (const name of ACCESSORS) {
+    const descriptor = state.originalDescriptors.get(name);
+    if (descriptor === undefined)
+      continue;
+    const nextDescriptor = {
+      configurable: true,
+      enumerable: descriptor.enumerable ?? false,
+      get: () => {
+        if (!state.active)
+          return descriptor.get?.call(text);
+        const layout = state.layout;
+        if (name === "scrollY")
+          return state.scrollY;
+        if (name === "scrollX")
+          return state.scrollX;
+        if (name === "scrollHeight")
+          return layout?.totalRows ?? descriptor.get?.call(text) ?? 0;
+        if (name === "scrollWidth")
+          return layout?.contentWidth ?? descriptor.get?.call(text) ?? 0;
+        const viewport = name === "maxScrollY" ? state.viewportHeight : state.viewportWidth;
+        const size = name === "maxScrollY" ? layout?.totalRows ?? 0 : layout?.contentWidth ?? 0;
+        return Math.max(0, size - viewport);
+      },
+      ...name === "scrollY" || name === "scrollX" ? {
+        set: (value) => {
+          if (!state.active) {
+            descriptor.set?.call(text, value);
+            return;
+          }
+          const numeric = typeof value === "number" ? value : Number(value);
+          if (name === "scrollY") {
+            const max = Math.max(0, (state.layout?.totalRows ?? 0) - state.viewportHeight);
+            const next = Math.min(max, Math.floor(isFiniteNonNegative(numeric)));
+            if (state.scrollY === next)
+              return;
+            state.scrollY = next;
+            rerender();
+          } else {
+            const max = Math.max(0, (state.layout?.contentWidth ?? 0) - state.viewportWidth);
+            const next = Math.min(max, Math.floor(isFiniteNonNegative(numeric)));
+            state.scrollX = next;
+            descriptor.set?.call(text, next);
+            pane.text.requestRender();
+          }
+        }
+      } : {}
+    };
+    Object.defineProperty(text, name, nextDescriptor);
+  }
+}
+function createAdapter(pane) {
+  const text = pane.text;
+  const originalOwnDescriptors = new Map(ACCESSORS.map((name) => [name, Object.getOwnPropertyDescriptor(text, name)]));
+  const originalDescriptors = new Map(ACCESSORS.map((name) => [name, Object.getOwnPropertyDescriptor(text, name) ?? prototypeDescriptor(text, name)]));
+  const state = {
+    active: false,
+    document: undefined,
+    layout: undefined,
+    preamble: "",
+    scrollY: 0,
+    scrollX: 0,
+    viewportHeight: Math.max(1, Math.floor(text.height)),
+    viewportWidth: Math.max(0, Math.floor(text.width)),
+    rawSelection: undefined,
+    renderedWindow: undefined,
+    preambleSpans: new Map,
+    originalDescriptors,
+    originalOwnDescriptors
+  };
+  const restoreAccessors = () => {
+    const target = text;
+    for (const name of ACCESSORS) {
+      delete target[name];
+      const own = state.originalOwnDescriptors.get(name);
+      if (own !== undefined)
+        Object.defineProperty(target, name, own);
+    }
+  };
+  const visibleSelection = () => {
+    const selection = state.rawSelection;
+    const layout = state.layout;
+    const window = state.renderedWindow;
+    if (selection === undefined || layout === undefined || window === undefined)
+      return;
+    let start;
+    let end;
+    let localOffset = 0;
+    for (let row = window[0];row <= window[1]; row += 1) {
+      const current = layout.rowAt(row);
+      if (current === undefined)
+        continue;
+      const rowStart = localOffset;
+      localOffset += layout.contentWidth + (row < window[1] ? 1 : 0);
+      if (current.lineIndex === undefined || current.rawStartUtf16 === undefined || current.rawEndUtf16 === undefined)
+        continue;
+      const line = state.document?.lines[current.lineIndex];
+      if (line === undefined)
+        continue;
+      const overlapStart = Math.max(selection.startUtf16, current.rawStartUtf16);
+      const overlapEnd = Math.min(selection.endUtf16, current.rawEndUtf16);
+      if (overlapStart >= overlapEnd)
+        continue;
+      const displayStart = rowStart + (overlapStart === current.rawStartUtf16 ? 0 : current.gutterCols + rawDisplayCells(line.raw, overlapStart - current.rawStartUtf16, false));
+      const displayEnd = rowStart + current.gutterCols + rawDisplayCells(line.raw, overlapEnd - current.rawStartUtf16, overlapEnd > current.rawStartUtf16 + withoutLineEnding3(line.raw).length);
+      start = start === undefined ? displayStart : Math.min(start, displayStart);
+      end = end === undefined ? displayEnd : Math.max(end, displayEnd);
+    }
+    return start === undefined || end === undefined ? undefined : { start, end };
+  };
+  const paintSelection = () => {
+    const selected = visibleSelection();
+    const surface = text;
+    if (selected === undefined)
+      surface.resetSelection?.();
+    else
+      surface.setSelection?.(selected.start, selected.end);
+  };
+  const renderWindow = () => {
+    if (!state.active || state.layout === undefined)
+      return;
+    const current = dimensions(text);
+    state.viewportHeight = current.height;
+    state.viewportWidth = current.width;
+    const max = Math.max(0, state.layout.totalRows - state.viewportHeight);
+    if (state.scrollY > max)
+      state.scrollY = max;
+    const maxX = Math.max(0, state.layout.contentWidth - state.viewportWidth);
+    if (state.scrollX > maxX)
+      state.scrollX = maxX;
+    const overscan = Math.max(VIRTUAL_MAIN_OVERSCAN_MIN, state.viewportHeight);
+    const window = state.layout.window(state.scrollY, state.viewportHeight, overscan);
+    const localScrollY = state.scrollY - window[0];
+    state.renderedWindow = window;
+    const rows = [];
+    const displays = [];
+    const preambleRows = [];
+    const preambleSpans = new Map;
+    const first = window[0];
+    const last = window[1];
+    if (last >= first && first < state.layout.preambleRows) {
+      const preambleLast = Math.min(last, state.layout.preambleRows - 1);
+      for (let row = first;row <= preambleLast; row += 1) {
+        const value = state.layout.rowAt(row);
+        if (value !== undefined)
+          preambleRows.push(padDisplayRow(value.text, state.layout.contentWidth));
+        const spans = state.preambleSpans.get(row);
+        if (spans !== undefined)
+          preambleSpans.set(row - first, spans);
+      }
+    }
+    const bodyFirst = Math.max(first, state.layout.preambleRows);
+    for (let row = bodyFirst;row <= last; row += 1) {
+      const value = state.layout.rowAt(row);
+      if (value === undefined || value.lineIndex === undefined)
+        continue;
+      rows.push(padDisplayRow(value.text, state.layout.contentWidth));
+      displays.push({ gutterCols: value.gutterCols, style: value.style });
+    }
+    const preamble = preambleRows.length === 0 ? "" : `${preambleRows.join(`
+`)}
+`;
+    installDiffText(text, { preamble, body: rows.join(`
+`), displayLines: displays, highlightScrollY: () => localScrollY, preambleSpans });
+    const originalScrollY = state.originalDescriptors.get("scrollY")?.set;
+    originalScrollY?.call(text, localScrollY);
+    const originalScrollX = state.originalDescriptors.get("scrollX")?.set;
+    originalScrollX?.call(text, state.scrollX);
+    paintSelection();
+    pane.syncScrollbar(state.viewportHeight);
+    text.requestRender?.();
+  };
+  const rerender = () => renderWindow();
+  const adapter = {
+    install(document, preamble) {
+      if (!state.active) {
+        state.scrollY = isFiniteNonNegative(Number(text.scrollY));
+        state.scrollX = isFiniteNonNegative(Number(text.scrollX));
+      }
+      state.active = true;
+      state.document = document;
+      state.layout = createVirtualDiffLayout(document, preamble);
+      state.preamble = preamble;
+      state.preambleSpans = statSpansForPreamble(preamble);
+      const current = dimensions(text);
+      state.viewportHeight = current.height;
+      state.viewportWidth = current.width;
+      installAccessors(pane, state, rerender);
+      text.wrapMode = "none";
+      renderWindow();
+    },
+    deactivate() {
+      if (!state.active)
+        return;
+      const originalY = state.originalDescriptors.get("scrollY")?.set;
+      const originalX = state.originalDescriptors.get("scrollX")?.set;
+      originalY?.call(text, state.scrollY);
+      originalX?.call(text, state.scrollX);
+      state.active = false;
+      state.document = undefined;
+      state.layout = undefined;
+      state.rawSelection = undefined;
+      state.renderedWindow = undefined;
+      releaseDiffText(text);
+      state.preambleSpans = new Map;
+      restoreAccessors();
+      clearScrollbarViewportOverride(text);
+      text.wrapMode = "char";
+    },
+    isActive: () => state.active,
+    layout: () => state.layout,
+    lineOffsets: (startIndex, endIndex) => state.layout?.displayOffsetsForLines(startIndex, endIndex),
+    visualRowRange: (startIndex, endIndex) => {
+      if (state.layout === undefined)
+        return;
+      const start = state.layout.preambleRows + Math.max(0, startIndex);
+      const end = state.layout.preambleRows + Math.max(startIndex, endIndex);
+      return { startRow: start, endRow: end };
+    },
+    setLineSelection(startUtf16, endUtf16) {
+      if (!state.active || state.document === undefined)
+        return;
+      state.rawSelection = documentSelection(state.document, startUtf16, endUtf16);
+      paintSelection();
+    },
+    setPointerSelection(startRow, startColumn, endRow, endColumn) {
+      if (!state.active || state.layout === undefined || state.document === undefined)
+        return;
+      const start = state.layout.rawOffsetAt(Math.max(0, Math.floor(state.scrollY + startRow)), Math.max(0, Math.floor(state.scrollX + startColumn)));
+      const end = state.layout.rawOffsetAt(Math.max(0, Math.floor(state.scrollY + endRow)), Math.max(0, Math.floor(state.scrollX + endColumn)));
+      if (start === undefined || end === undefined) {
+        state.rawSelection = undefined;
+        paintSelection();
+        return;
+      }
+      const selection = documentSelection(state.document, Math.min(start, end), Math.max(start, end));
+      state.rawSelection = selection;
+      paintSelection();
+      return selection;
+    },
+    selection: () => state.rawSelection,
+    resetSelection() {
+      state.rawSelection = undefined;
+      text.resetSelection?.();
+    },
+    clampScroll() {
+      if (!state.active || state.layout === undefined) {
+        const originalY = state.originalDescriptors.get("scrollY")?.set;
+        const originalX = state.originalDescriptors.get("scrollX")?.set;
+        originalY?.call(text, text.scrollY);
+        originalX?.call(text, text.scrollX);
+        return;
+      }
+      const maxY = Math.max(0, state.layout.totalRows - state.viewportHeight);
+      const maxX = Math.max(0, state.layout.contentWidth - state.viewportWidth);
+      state.scrollY = Math.min(maxY, Math.max(0, state.scrollY));
+      state.scrollX = Math.min(maxX, Math.max(0, state.scrollX));
+      renderWindow();
+    }
+  };
+  onPaneLifecyclePass(text, () => {
+    if (!state.active || state.layout === undefined)
+      return;
+    const current = dimensions(text);
+    if (current.height !== state.viewportHeight || current.width !== state.viewportWidth)
+      renderWindow();
+  });
+  return adapter;
+}
+function createVirtualMainPane(pane) {
+  const existing = virtualPanes.get(pane);
+  if (existing !== undefined)
+    return existing;
+  const adapter = createAdapter(pane);
+  virtualPanes.set(pane, adapter);
+  return adapter;
+}
+function virtualMainPaneFor(pane) {
+  return virtualPanes.get(pane);
+}
+function isVirtualDiffDocument(document) {
+  return document.lines.length > VIRTUAL_DIFF_LINE_THRESHOLD;
 }
 
 // src/ui/panes/main-pane.ts
@@ -7071,6 +7822,7 @@ function createMainPane(renderer, _model) {
   const pane = createPane(renderer, "main", "0 Main", "", true);
   pane.text.selectionBg = SELECTED_LINE_BG;
   ensureMainTextSelectionSurface(pane);
+  createVirtualMainPane(pane);
   pane.box.title = "0 Main";
   paneTitles.set(pane, "0 Main");
   return pane;
@@ -7119,6 +7871,9 @@ function mainDiffVisualRowRange(pane, startIndex, endIndex) {
   const document = documents.get(pane);
   if (document === undefined)
     return;
+  const virtual = virtualMainPaneFor(pane);
+  if (virtual?.isActive())
+    return virtual.visualRowRange(startIndex, endIndex);
   const content = installedContents.get(pane);
   const preambleRows = (normalizedPreamble(content?.preamble ?? "").match(/\n/g) ?? []).length;
   const firstSource = preambleRows + Math.max(0, startIndex);
@@ -7143,7 +7898,16 @@ function getMainDiffLineSelection(pane) {
   if (document === undefined || state === undefined || state.rangeMode === "none")
     return;
   const range = diffLineSelectionRange(state);
-  const offsets = mainDiffLineOffsets(document, range.startIndex, range.endIndex, installedContents.get(pane)?.preamble ?? "");
+  const virtual = virtualMainPaneFor(pane);
+  const offsets = virtual?.isActive() ? (() => {
+    const value = virtual.lineOffsets(range.startIndex, range.endIndex + 1);
+    return value === undefined ? undefined : {
+      startUtf16: value.rawStartUtf16,
+      endUtf16: value.rawEndUtf16,
+      displayStartUtf16: value.displayStartUtf16,
+      displayEndUtf16: value.displayEndUtf16
+    };
+  })() : mainDiffLineOffsets(document, range.startIndex, range.endIndex, installedContents.get(pane)?.preamble ?? "");
   if (offsets === undefined)
     return;
   return {
@@ -7154,16 +7918,42 @@ function getMainDiffLineSelection(pane) {
   };
 }
 function applyMainDiffLineVisualSelection(pane, resetWhenInactive = true) {
-  const text = pane.text;
+  const virtual = virtualMainPaneFor(pane);
   const selection = getMainDiffLineSelection(pane);
-  if (selection !== undefined) {
+  if (virtual?.isActive()) {
+    if (selection !== undefined)
+      virtual.setLineSelection(selection.startUtf16, selection.endUtf16);
+    else if (resetWhenInactive)
+      virtual.resetSelection();
+    return;
+  }
+  const text = pane.text;
+  if (selection !== undefined)
     text.setSelection?.(selection.displayStartUtf16, selection.displayEndUtf16);
-  } else if (resetWhenInactive) {
+  else if (resetWhenInactive)
     text.resetSelection?.();
-  }
+}
+function getMainPointerSelection(pane) {
+  return virtualMainPaneFor(pane)?.selection();
 }
 function setMainDiffLineRangeState(pane, state) {
   lineRanges.set(pane, state);
+  const virtual = virtualMainPaneFor(pane);
+  if (state.rangeMode === "none") {
+    if (virtual?.isActive())
+      virtual.resetSelection();
+    else
+      applyMainDiffLineVisualSelection(pane);
+    return;
+  }
+  const document = documents.get(pane);
+  const range = diffLineSelectionRange(state);
+  const start = document?.lines[range.startIndex];
+  const end = document?.lines[range.endIndex];
+  if (virtual?.isActive() && start !== undefined && end !== undefined) {
+    virtual.setLineSelection(start.startUtf16, end.endUtf16);
+    return;
+  }
   applyMainDiffLineVisualSelection(pane);
 }
 function getMainDocument(pane) {
@@ -7243,11 +8033,17 @@ function buildPlainContent(content) {
   return "No content";
 }
 function clampMainScroll(pane) {
+  const virtual = virtualMainPaneFor(pane);
+  if (virtual?.isActive()) {
+    virtual.clampScroll();
+    return;
+  }
   pane.text.scrollY = Math.max(0, Math.min(pane.text.maxScrollY, pane.text.scrollY));
   pane.text.scrollX = Math.max(0, Math.min(pane.text.maxScrollX, pane.text.scrollX));
   pane.syncScrollbar();
 }
 function updatePlain(pane, value) {
+  virtualMainPaneFor(pane)?.deactivate();
   releaseDiffText(pane.text);
   releaseAnsiText(pane.text);
   pane.update(value);
@@ -7255,20 +8051,25 @@ function updatePlain(pane, value) {
 function installMainContent(pane, content, tooSmall) {
   const previousContent = installedContents.get(pane);
   const previousText = renderedTexts.get(pane);
-  const nextText = renderedTextFor(content);
+  const virtualDocument = content.document !== undefined && isVirtualDiffDocument(content.document);
+  const nextText = virtualDocument ? undefined : renderedTextFor(content);
   const previousIdentity = previousContent === undefined ? undefined : `${previousContent.source}:${previousContent.stableId}`;
   const nextIdentity = `${content.source}:${content.stableId}`;
   const sameIdentity = previousIdentity !== undefined && previousIdentity === nextIdentity;
-  const identicalText = previousText !== undefined && previousText === nextText;
+  const identicalText = virtualDocument ? previousContent?.document?.text === content.document?.text && previousContent?.preamble === content.preamble : previousText !== undefined && previousText === nextText;
   const previousWasDocument = documents.has(pane);
   const replacingDocument = previousWasDocument && content.document === undefined;
   const enteringDocument = !previousWasDocument && content.document !== undefined;
   const leavingAnsi = previousContent?.ansi !== undefined && content.ansi === undefined;
   installedContents.set(pane, content);
-  renderedTexts.set(pane, nextText);
+  if (nextText === undefined)
+    renderedTexts.delete(pane);
+  else
+    renderedTexts.set(pane, nextText);
   paneTitles.set(pane, `0 Main — ${content.label}`);
   const previousRange = lineRanges.get(pane);
   const clearSelection = () => {
+    virtualMainPaneFor(pane)?.resetSelection();
     const view = pane.text;
     if (view !== null && typeof view === "object" && "resetSelection" in view) {
       const reset = view.resetSelection;
@@ -7339,6 +8140,16 @@ function installMainContent(pane, content, tooSmall) {
     } else {
       cursorTargets.delete(pane);
     }
+    const virtual = virtualMainPaneFor(pane);
+    if (virtualDocument && virtual !== undefined) {
+      releaseAnsiText(pane.text);
+      virtual.install(doc, content.preamble ?? "");
+      renderedTexts.delete(pane);
+      if (previousRange?.rangeMode !== "none")
+        applyMainDiffLineVisualSelection(pane);
+      return;
+    }
+    virtual?.deactivate();
     pane.text.wrapMode = "char";
     releaseAnsiText(pane.text);
     if (enteringDocument || !sameIdentity || !identicalText) {
@@ -7353,6 +8164,7 @@ function installMainContent(pane, content, tooSmall) {
     return;
   }
   if (content.ansi !== undefined) {
+    virtualMainPaneFor(pane)?.deactivate();
     documents.delete(pane);
     if (replacingDocument || !sameIdentity || !identicalText)
       clearSelection();
@@ -7364,6 +8176,7 @@ function installMainContent(pane, content, tooSmall) {
     pane.syncScrollbar();
     return;
   }
+  virtualMainPaneFor(pane)?.deactivate();
   documents.delete(pane);
   if (replacingDocument || leavingAnsi || !sameIdentity || !identicalText)
     clearSelection();
@@ -7415,8 +8228,7 @@ function createStashPane(renderer, model) {
   const rows = stashRows(model);
   const displayRows = stashDisplayRows(model, rows);
   const state = createListState(rows, displayRows);
-  const content = renderListRows(state, false, 80);
-  pane.update(content);
+  installListText(pane.text, { state, width: 80, focused: false });
   return pane;
 }
 function selectedStashEntryFromState(state, model) {
@@ -9336,6 +10148,7 @@ class RootView {
   lastSplitterPress;
   activeSplitterDrag;
   gestureOwner;
+  mainPointerAnchor;
   pendingClick;
   hoveredListRow;
   model;
@@ -9624,6 +10437,10 @@ class RootView {
       this.syncPreviewForFocus(focus);
     };
     this.handleResize = () => {
+      if (this.gestureOwner?.kind === "main-selection") {
+        virtualMainPaneFor(this.panes.main)?.resetSelection();
+        this.cancelGesture();
+      }
       this.recomputeLayout();
     };
     this.handleKey = (key) => {
@@ -9672,6 +10489,10 @@ class RootView {
     this.applyLayout();
   }
   update(model, options = {}) {
+    if (this.gestureOwner?.kind === "main-selection") {
+      virtualMainPaneFor(this.panes.main)?.resetSelection();
+      this.cancelGesture();
+    }
     this.branchActionGeneration += 1;
     this.invalidateBranchCommitsRequest();
     if (!options.preserveRemoteCheckout) {
@@ -9902,7 +10723,11 @@ class RootView {
     };
   }
   cancelGesture() {
+    if (this.gestureOwner?.kind === "main-selection") {
+      virtualMainPaneFor(this.panes.main)?.resetSelection();
+    }
     this.gestureOwner = undefined;
+    this.mainPointerAnchor = undefined;
     this.activeSplitterDrag = undefined;
   }
   get activeBranchesTab() {
@@ -10201,14 +11026,15 @@ class RootView {
     const focused = this.focusManager.active === "branches";
     const activeView = this.activeListView("branches");
     if (activeView === undefined) {
+      releaseListText(pane.text);
       pane.update("");
       return;
     }
     const { state } = activeView;
     const win = this.geometry.windows.branches;
     const width = sidePaneListWidth(win, state);
-    const content = renderListRows(state, focused, width, this.hoveredIdFor(activeView));
-    pane.update(content);
+    const hoveredId = this.hoveredIdFor(activeView);
+    installListText(pane.text, { state, width, focused, ...hoveredId === undefined ? {} : { hoveredId } });
     pane.syncScrollbar(sidePaneViewportHeight(win));
   }
   get filesTitleStyled() {
@@ -10268,13 +11094,15 @@ class RootView {
     pane.setTabs?.({ tabs: tabsInput.tabs, activeIndex: tabsInput.activeIndex, focused: tabsInput.focused });
     const activeView = this.activeListView("files");
     if (activeView === undefined) {
+      releaseListText(pane.text);
       pane.update("");
       return;
     }
     const { state } = activeView;
     const win = this.geometry.windows.files;
     const width = sidePaneListWidth(win, state);
-    pane.update(renderListRows(state, tabsInput.focused, width, this.hoveredIdFor(activeView)));
+    const hoveredId = this.hoveredIdFor(activeView);
+    installListText(pane.text, { state, width, focused: tabsInput.focused, ...hoveredId === undefined ? {} : { hoveredId } });
     pane.syncScrollbar(sidePaneViewportHeight(win));
   }
   refreshStashState(model) {
@@ -10288,6 +11116,7 @@ class RootView {
     const pane = this.panes.stash;
     const activeView = this.activeListView("stash");
     if (activeView === undefined) {
+      releaseListText(pane.text);
       pane.update("");
       return;
     }
@@ -10295,8 +11124,8 @@ class RootView {
     const focused = this.focusManager.active === "stash";
     const win = this.geometry.windows.stash;
     const width = sidePaneListWidth(win, state);
-    const content = renderListRows(state, focused, width, this.hoveredIdFor(activeView));
-    pane.update(content);
+    const hoveredId = this.hoveredIdFor(activeView);
+    installListText(pane.text, { state, width, focused, ...hoveredId === undefined ? {} : { hoveredId } });
     pane.syncScrollbar(sidePaneViewportHeight(win));
   }
   renderSidePanes() {
@@ -10945,8 +11774,8 @@ class RootView {
   }
   focusedPageStep() {
     const focus = this.focusManager.active;
-    const dimensions = focus === "command-log" ? this.geometry.windows.log : this.geometry.windows[focus] ?? this.geometry.windows.main;
-    return Math.max(1, heightOf(dimensions) - 2);
+    const dimensions2 = focus === "command-log" ? this.geometry.windows.log : this.geometry.windows[focus] ?? this.geometry.windows.main;
+    return Math.max(1, heightOf(dimensions2) - 2);
   }
   actionPage(direction) {
     if (this.focusManager.active === "main") {
@@ -12352,7 +13181,7 @@ class RootView {
       let next = -1;
       for (let i = current + 1;i < view.rows.length; i++) {
         const row = view.rows[i];
-        const text = `${row.columns[0]?.text ?? ""} ${row.columns[3]?.text ?? ""}`.toLowerCase();
+        const text = `${row.columns[0]?.text ?? ""} ${row.columns[2]?.text ?? ""}`.toLowerCase();
         if (text.includes(normalizedQuery)) {
           next = i;
           break;
@@ -12361,7 +13190,7 @@ class RootView {
       if (next === -1) {
         for (let i = 0;i <= current; i++) {
           const row = view.rows[i];
-          const text = `${row.columns[0]?.text ?? ""} ${row.columns[3]?.text ?? ""}`.toLowerCase();
+          const text = `${row.columns[0]?.text ?? ""} ${row.columns[2]?.text ?? ""}`.toLowerCase();
           if (text.includes(normalizedQuery)) {
             next = i;
             break;
@@ -12387,11 +13216,44 @@ class RootView {
       const query = this.getFilterForKey(this.filterKey("main"));
       if (query.length === 0)
         return;
-      const text = getMainRenderedText(this.panes.main) ?? getMainDocument(this.panes.main)?.text ?? "";
+      const document = getMainDocument(this.panes.main);
+      const virtual = virtualMainPaneFor(this.panes.main);
+      const normalizedQuery = query.toLowerCase();
+      if (document !== undefined && virtual?.isActive()) {
+        const layout = virtual.layout();
+        const preambleRows = layout?.preambleRows ?? 0;
+        const totalRows = layout?.totalRows ?? preambleRows + document.lines.length;
+        const currentLine2 = this.panes.main.text.scrollY - preambleRows;
+        let nextLine2 = -1;
+        const firstCandidate = Math.max(0, currentLine2 + 1);
+        for (let i = firstCandidate;i < document.lines.length; i += 1) {
+          if (document.lines[i].raw.toLowerCase().includes(normalizedQuery)) {
+            nextLine2 = i;
+            break;
+          }
+        }
+        if (nextLine2 === -1) {
+          for (let i = 0;i <= currentLine2 && i < document.lines.length; i += 1) {
+            if (document.lines[i].raw.toLowerCase().includes(normalizedQuery)) {
+              nextLine2 = i;
+              break;
+            }
+          }
+        }
+        if (nextLine2 !== -1) {
+          this.clearNonStickyMainRange();
+          const targetRow = preambleRows + nextLine2;
+          this.panes.main.text.scrollY = Math.max(0, targetRow - 2);
+          this.panes.main.syncScrollbar();
+          this.panes.main.box.bottomTitle = `Search: ${query} (${targetRow + 1}/${totalRows})`;
+          this.root.requestRender();
+        }
+        return;
+      }
+      const text = getMainRenderedText(this.panes.main) ?? document?.text ?? "";
       if (text.length === 0)
         return;
       const normalizedText = text.toLowerCase();
-      const normalizedQuery = query.toLowerCase();
       const currentY = this.panes.main.text.scrollY;
       const lines = text.split(`
 `);
@@ -12415,6 +13277,7 @@ class RootView {
         this.clearNonStickyMainRange();
         const targetY = Math.max(0, nextLine - 2);
         this.panes.main.text.scrollY = targetY;
+        this.panes.main.syncScrollbar();
         this.panes.main.box.bottomTitle = `Search: ${query} (${nextLine + 1}/${lines.length})`;
         this.root.requestRender();
       }
@@ -12435,7 +13298,7 @@ class RootView {
       let prev = -1;
       for (let i = current - 1;i >= 0; i--) {
         const row = view.rows[i];
-        const text = `${row.columns[0]?.text ?? ""} ${row.columns[3]?.text ?? ""}`.toLowerCase();
+        const text = `${row.columns[0]?.text ?? ""} ${row.columns[2]?.text ?? ""}`.toLowerCase();
         if (text.includes(normalizedQuery)) {
           prev = i;
           break;
@@ -12444,7 +13307,7 @@ class RootView {
       if (prev === -1) {
         for (let i = view.rows.length - 1;i >= current; i--) {
           const row = view.rows[i];
-          const text = `${row.columns[0]?.text ?? ""} ${row.columns[3]?.text ?? ""}`.toLowerCase();
+          const text = `${row.columns[0]?.text ?? ""} ${row.columns[2]?.text ?? ""}`.toLowerCase();
           if (text.includes(normalizedQuery)) {
             prev = i;
             break;
@@ -12470,13 +13333,45 @@ class RootView {
       const query = this.getFilterForKey(this.filterKey("main"));
       if (query.length === 0)
         return;
-      const text = getMainRenderedText(this.panes.main) ?? getMainDocument(this.panes.main)?.text ?? "";
+      const document = getMainDocument(this.panes.main);
+      const virtual = virtualMainPaneFor(this.panes.main);
+      const normalizedQuery = query.toLowerCase();
+      if (document !== undefined && virtual?.isActive()) {
+        const layout = virtual.layout();
+        const preambleRows = layout?.preambleRows ?? 0;
+        const totalRows = layout?.totalRows ?? preambleRows + document.lines.length;
+        const currentLine = this.panes.main.text.scrollY - preambleRows;
+        let previousLine = -1;
+        for (let i = Math.min(document.lines.length - 1, currentLine - 1);i >= 0; i -= 1) {
+          if (document.lines[i].raw.toLowerCase().includes(normalizedQuery)) {
+            previousLine = i;
+            break;
+          }
+        }
+        if (previousLine === -1) {
+          for (let i = document.lines.length - 1;i >= currentLine && i >= 0; i -= 1) {
+            if (document.lines[i].raw.toLowerCase().includes(normalizedQuery)) {
+              previousLine = i;
+              break;
+            }
+          }
+        }
+        if (previousLine !== -1) {
+          this.clearNonStickyMainRange();
+          const targetRow = preambleRows + previousLine;
+          this.panes.main.text.scrollY = Math.max(0, targetRow - 2);
+          this.panes.main.syncScrollbar();
+          this.panes.main.box.bottomTitle = `Search: ${query} (${targetRow + 1}/${totalRows})`;
+          this.root.requestRender();
+        }
+        return;
+      }
+      const text = getMainRenderedText(this.panes.main) ?? document?.text ?? "";
       if (text.length === 0)
         return;
       const lines = text.split(`
 `);
       const currentY = this.panes.main.text.scrollY;
-      const normalizedQuery = query.toLowerCase();
       let prevLine = -1;
       for (let i = currentY - 1;i >= 0; i--) {
         if (lines[i].toLowerCase().includes(normalizedQuery)) {
@@ -12496,6 +13391,7 @@ class RootView {
         this.clearNonStickyMainRange();
         const targetY = Math.max(0, prevLine - 2);
         this.panes.main.text.scrollY = targetY;
+        this.panes.main.syncScrollbar();
         this.panes.main.box.bottomTitle = `Search: ${query} (${prevLine + 1}/${lines.length})`;
         this.root.requestRender();
       }
@@ -12530,6 +13426,13 @@ class RootView {
     return [...paths];
   }
   mainActionTarget(document) {
+    const pointer = getMainPointerSelection(this.panes.main);
+    if (pointer?.fileIndex !== undefined && pointer.valid && pointer.endUtf16 > pointer.startUtf16) {
+      return {
+        fileIndex: pointer.fileIndex,
+        ...pointer.hunkIndex === undefined ? {} : { hunkIndex: pointer.hunkIndex }
+      };
+    }
     const selected = getMainDiffLineSelection(this.panes.main);
     const firstIndex = selected?.indexes[0];
     const line = firstIndex === undefined ? undefined : document.lines[firstIndex];
@@ -12541,10 +13444,43 @@ class RootView {
     }
     return getMainCursorTarget(this.panes.main);
   }
+  mainPointerCoordinates(event) {
+    const geometry = this.paneTextGeometry("main");
+    if (geometry === undefined)
+      return;
+    const row = event.y - geometry.screenY;
+    const column = event.x - geometry.screenX;
+    if (!Number.isSafeInteger(row) || !Number.isSafeInteger(column) || row < 0 || row >= geometry.height || column < 0 || column >= geometry.width)
+      return;
+    return { row, column };
+  }
+  updateVirtualMainPointer(event) {
+    const virtual = virtualMainPaneFor(this.panes.main);
+    if (!virtual?.isActive())
+      return;
+    const anchor = this.mainPointerAnchor;
+    if (anchor === undefined) {
+      virtual.resetSelection();
+      return;
+    }
+    const point = this.mainPointerCoordinates(event);
+    if (point === undefined) {
+      virtual.resetSelection();
+      return;
+    }
+    virtual.setPointerSelection(anchor.row, anchor.column, point.row, point.column);
+  }
   mainChangeSelection() {
     const document = getMainDocument(this.panes.main);
     if (!document)
       return;
+    const pointerSelection = getMainPointerSelection(this.panes.main);
+    if (pointerSelection?.valid && pointerSelection.endUtf16 > pointerSelection.startUtf16) {
+      return {
+        document,
+        indexes: changeLineIndexes(document, pointerSelection.startUtf16, pointerSelection.endUtf16)
+      };
+    }
     const keyboardSelection = getMainDiffLineSelection(this.panes.main);
     if (keyboardSelection !== undefined) {
       return {
@@ -12939,7 +13875,7 @@ class RootView {
     let commitsState = setListRows(panel.views.commits, rows, displayRows);
     if (commitsSearch.length > 0 && rows.length > 0) {
       const normalized = commitsSearch.toLowerCase();
-      const matchIndex = rows.findIndex((row) => (row.columns[3]?.text ?? "").toLowerCase().includes(normalized) || (row.columns[0]?.text ?? "").toLowerCase().includes(normalized));
+      const matchIndex = rows.findIndex((row) => (row.columns[2]?.text ?? "").toLowerCase().includes(normalized) || (row.columns[0]?.text ?? "").toLowerCase().includes(normalized));
       if (matchIndex >= 0) {
         const matchId = rows[matchIndex].id;
         commitsState = selectListRow(commitsState, matchId);
@@ -12970,14 +13906,15 @@ class RootView {
     }
     const activeView = this.activeListView("commits");
     if (activeView === undefined) {
+      releaseListText(pane.text);
       pane.update("");
       return;
     }
     const { state } = activeView;
     const width = sidePaneListWidth(this.geometry.windows.commits, state);
     const focused = this.focusManager.active === "commits";
-    const content = renderListRows(state, focused, width, this.hoveredIdFor(activeView));
-    pane.update(content);
+    const hoveredId = this.hoveredIdFor(activeView);
+    installListText(pane.text, { state, width, focused, ...hoveredId === undefined ? {} : { hoveredId } });
     pane.syncScrollbar(sidePaneViewportHeight(this.geometry.windows.commits));
   }
   installInitialMainContent(model) {
@@ -13209,16 +14146,19 @@ class RootView {
       this.root.requestRender();
       return;
     }
+    const rawPointerSelection = getMainPointerSelection(pane);
+    const pointerSelection = rawPointerSelection !== undefined && rawPointerSelection.valid && rawPointerSelection.endUtf16 > rawPointerSelection.startUtf16 ? rawPointerSelection : undefined;
     const keyboardSelection = getMainDiffLineSelection(pane);
     const nativeRange = pane.text.getSelection();
-    let selection = mode === "hunk" || mode === "file" || keyboardSelection === undefined ? undefined : {
+    let selection = mode === "hunk" || mode === "file" ? undefined : pointerSelection ?? (keyboardSelection === undefined ? undefined : {
       valid: true,
       startUtf16: keyboardSelection.startUtf16,
       endUtf16: keyboardSelection.endUtf16,
       active: true
-    };
-    if (selection === undefined && keyboardSelection === undefined && nativeRange)
+    });
+    if (selection === undefined && pointerSelection === undefined && keyboardSelection === undefined && nativeRange) {
       selection = selectionFromRenderable(document, nativeRange, pane.text.getSelectedText());
+    }
     if (!selection && (mode === "hunk" || mode === "file")) {
       const target = getMainCursorTarget(pane);
       if (target) {
@@ -13538,6 +14478,9 @@ class RootView {
         bar.onMouseDown = undefined;
         bar.onMouseDrag = undefined;
         bar.onMouseUp = undefined;
+        bar.slider.onMouseDown = undefined;
+        bar.slider.onMouseDrag = undefined;
+        bar.slider.onMouseUp = undefined;
       }
     }
     this.renderer.off("resize", this.handleResize);
@@ -13564,20 +14507,33 @@ class RootView {
       const bar = paneScrollbar(typedPane.text);
       if (!bar)
         continue;
-      bar.onMouseDown = (event) => {
+      const beginScrollbarGesture = (event) => {
+        this.updateHoveredListRow(event.x, event.y);
         this.pendingClick = undefined;
         this.lastSplitterPress = undefined;
         this.gestureOwner = { kind: "scrollbar", paneId: typedPane.id };
+        this.scrollPaneByScrollbarPosition(typedPane.id, event.y);
         event.stopPropagation();
       };
-      bar.onMouseDrag = (event) => {
-        if (this.gestureOwner?.kind === "scrollbar" && this.gestureOwner.paneId === typedPane.id)
+      const continueScrollbarGesture = (event) => {
+        if (this.gestureOwner?.kind === "scrollbar" && this.gestureOwner.paneId === typedPane.id) {
+          this.scrollPaneByScrollbarPosition(typedPane.id, event.y);
           event.stopPropagation();
+        }
       };
-      bar.onMouseUp = (event) => {
-        if (this.gestureOwner?.kind === "scrollbar" && this.gestureOwner.paneId === typedPane.id)
+      const endScrollbarGesture = (event) => {
+        if (this.gestureOwner?.kind === "scrollbar" && this.gestureOwner.paneId === typedPane.id) {
+          this.scrollPaneByScrollbarPosition(typedPane.id, event.y);
+          this.gestureOwner = undefined;
           event.stopPropagation();
+        }
       };
+      bar.onMouseDown = beginScrollbarGesture;
+      bar.onMouseDrag = continueScrollbarGesture;
+      bar.onMouseUp = endScrollbarGesture;
+      bar.slider.onMouseDown = beginScrollbarGesture;
+      bar.slider.onMouseDrag = continueScrollbarGesture;
+      bar.slider.onMouseUp = endScrollbarGesture;
     }
     this.root.onMouse = (event) => {
       if (this.isBranchReviewActive?.())
@@ -13686,14 +14642,22 @@ class RootView {
           return;
         }
         if (owner.kind === "main-selection") {
+          const virtual = virtualMainPaneFor(this.panes.main);
           if (event.type === "drag") {
             this.pendingClick = undefined;
             this.lastSplitterPress = undefined;
+            if (virtual?.isActive())
+              this.updateVirtualMainPointer(event);
+            event.preventDefault();
             event.stopPropagation();
             return;
           }
-          if (event.type === "up") {
+          if (event.type === "up" || event.type === "cancel") {
+            if (virtual?.isActive() && event.type === "up")
+              this.updateVirtualMainPointer(event);
             this.gestureOwner = undefined;
+            this.mainPointerAnchor = undefined;
+            event.preventDefault();
             event.stopPropagation();
             return;
           }
@@ -13824,10 +14788,22 @@ class RootView {
         if (paneId === "main") {
           this.pendingClick = undefined;
           this.lastSplitterPress = undefined;
-          this.gestureOwner = { kind: "main-selection" };
           if (this.focusManager.active !== "main")
             this.focusManager.focus("main");
+          const virtual = virtualMainPaneFor(this.panes.main);
+          const canSelect = event.button === 0 && !event.modifiers.ctrl;
+          const point = virtual?.isActive() && canSelect ? this.mainPointerCoordinates(event) : undefined;
+          this.mainPointerAnchor = point;
+          if (virtual?.isActive()) {
+            if (point === undefined)
+              virtual.resetSelection();
+            else
+              virtual.setPointerSelection(point.row, point.column, point.row, point.column);
+          }
+          this.gestureOwner = { kind: "main-selection" };
           this.clearTransientMenus();
+          if (virtual?.isActive() && canSelect)
+            event.preventDefault();
           event.stopPropagation();
           return;
         }
@@ -14096,16 +15072,16 @@ class RootView {
     this.syncPaneBorders();
     const windows = this.geometry.windows;
     const place = (renderable, name) => {
-      const dimensions = windows[name];
-      if (dimensions === undefined) {
+      const dimensions2 = windows[name];
+      if (dimensions2 === undefined) {
         renderable.visible = false;
         return;
       }
-      renderable.left = dimensions.x0;
-      renderable.top = dimensions.y0;
-      renderable.width = Math.max(1, widthOf(dimensions));
-      renderable.height = Math.max(1, heightOf(dimensions));
-      renderable.visible = widthOf(dimensions) > 0 && heightOf(dimensions) > 0;
+      renderable.left = dimensions2.x0;
+      renderable.top = dimensions2.y0;
+      renderable.width = Math.max(1, widthOf(dimensions2));
+      renderable.height = Math.max(1, heightOf(dimensions2));
+      renderable.visible = widthOf(dimensions2) > 0 && heightOf(dimensions2) > 0;
     };
     for (const name of SIDE_WINDOWS)
       place(this.panes[name].box, name);
@@ -14705,7 +15681,7 @@ function isWorkerAvailable() {
 }
 
 // src/ui/review-workspace/ReviewWorkspaceApp.tsx
-import { StyledText as StyledText8, parseColor as parseColor2 } from "@opentui/core";
+import { StyledText as StyledText8, parseColor as parseColor3 } from "@opentui/core";
 import { useKeyboard, useTerminalDimensions } from "@opentui/react";
 import { useCallback, useEffect as useEffect3, useLayoutEffect as useLayoutEffect2, useMemo as useMemo4, useRef as useRef2, useState as useState3, useSyncExternalStore } from "react";
 
@@ -15731,7 +16707,7 @@ function buildHunkStackRows(file, state, highlight, options) {
   return rows;
 }
 // src/ui/review-workspace/components/ReviewDiffRow.tsx
-import { StyledText as StyledText7, parseColor } from "@opentui/core";
+import { StyledText as StyledText7, parseColor as parseColor2 } from "@opentui/core";
 
 // src/ui/review-workspace/hunk-code-columns.ts
 var HUNK_DIFF_RAIL_WIDTH = 1;
@@ -15804,7 +16780,7 @@ function color(value) {
   const cached = colorCache2.get(value);
   if (cached)
     return cached;
-  const parsed = parseColor(value);
+  const parsed = parseColor2(value);
   colorCache2.set(value, parsed);
   return parsed;
 }
@@ -17916,7 +18892,7 @@ var colorCache3 = new Map;
 function textChunk(text, style) {
   let fg5 = colorCache3.get(COLORS2[style]);
   if (!fg5) {
-    fg5 = parseColor2(COLORS2[style]);
+    fg5 = parseColor3(COLORS2[style]);
     colorCache3.set(COLORS2[style], fg5);
   }
   return { __isChunk: true, text, fg: fg5 };
@@ -18154,14 +19130,14 @@ function ReviewWorkspaceApp({ session }) {
   const finishSummaryRef = useRef2(null);
   const finishSubmitRef = useRef2(false);
   const expandedSourceRef = useRef2(new Map);
-  const dimensions = { width: Math.max(1, terminal.width), height: Math.max(1, terminal.height) };
-  const maxSidebarWidth = Math.max(REVIEW_SIDEBAR_MIN_WIDTH, dimensions.width - REVIEW_RESIZE_BAR_WIDTH - REVIEW_DIFF_BORDER_WIDTH - REVIEW_DIFF_MIN_CONTENT_WIDTH);
-  const sidebarWidth = dimensions.width >= REVIEW_SIDEBAR_VISIBILITY_WIDTH ? Math.min(Math.max(sidebarWidthPreference, REVIEW_SIDEBAR_MIN_WIDTH), maxSidebarWidth) : 0;
-  const diffWidth = Math.max(1, dimensions.width - sidebarWidth - (sidebarWidth > 0 ? REVIEW_RESIZE_BAR_WIDTH : 0) - REVIEW_DIFF_BORDER_WIDTH);
+  const dimensions2 = { width: Math.max(1, terminal.width), height: Math.max(1, terminal.height) };
+  const maxSidebarWidth = Math.max(REVIEW_SIDEBAR_MIN_WIDTH, dimensions2.width - REVIEW_RESIZE_BAR_WIDTH - REVIEW_DIFF_BORDER_WIDTH - REVIEW_DIFF_MIN_CONTENT_WIDTH);
+  const sidebarWidth = dimensions2.width >= REVIEW_SIDEBAR_VISIBILITY_WIDTH ? Math.min(Math.max(sidebarWidthPreference, REVIEW_SIDEBAR_MIN_WIDTH), maxSidebarWidth) : 0;
+  const diffWidth = Math.max(1, dimensions2.width - sidebarWidth - (sidebarWidth > 0 ? REVIEW_RESIZE_BAR_WIDTH : 0) - REVIEW_DIFF_BORDER_WIDTH);
   const layout = layoutMode === "auto" ? diffWidth >= 64 ? "split" : "stack" : layoutMode;
   const composerHeight = state?.draft ? canShowReplacementDraft(state) ? 9 : 6 : 0;
-  const diffHeight = Math.max(1, dimensions.height - 4 - composerHeight - 2);
-  const resizeBarHeight = Math.max(1, dimensions.height - 4 - composerHeight);
+  const diffHeight = Math.max(1, dimensions2.height - 4 - composerHeight - 2);
+  const resizeBarHeight = Math.max(1, dimensions2.height - 4 - composerHeight);
   const sidebarFocused = focus === "sidebar" || focus === "filter";
   const diffFocused = focus === "stream";
   const files = useMemo4(() => state ? toHunkReviewFiles(visibleReviewFiles(state)) : [], [state?.document, state?.feedback, state?.filter, state?.viewed]);
@@ -18953,7 +19929,7 @@ function ReviewWorkspaceApp({ session }) {
         id: "react-review-header",
         style: { width: "100%", height: 3, flexShrink: 0 },
         children: /* @__PURE__ */ jsx4("text", {
-          content: headerText(state, dimensions.width, controller.error),
+          content: headerText(state, dimensions2.width, controller.error),
           wrapMode: "none",
           truncate: true
         })
@@ -19180,7 +20156,7 @@ function ReviewWorkspaceApp({ session }) {
       }),
       orphanedFeedback.length > 0 ? /* @__PURE__ */ jsx4("box", {
         id: "review-orphaned-feedback",
-        style: { position: "absolute", left: 1, bottom: 1, width: Math.max(20, dimensions.width - 2), height: Math.min(4, orphanedFeedback.length), zIndex: 50, border: true, flexDirection: "column", backgroundColor: "#202020" },
+        style: { position: "absolute", left: 1, bottom: 1, width: Math.max(20, dimensions2.width - 2), height: Math.min(4, orphanedFeedback.length), zIndex: 50, border: true, flexDirection: "column", backgroundColor: "#202020" },
         children: orphanedFeedback.slice(0, 4).map((feedback) => /* @__PURE__ */ jsxs4("box", {
           style: { width: "100%", height: 1, flexDirection: "row" },
           onMouseUp: () => {
@@ -19225,7 +20201,7 @@ function ReviewWorkspaceApp({ session }) {
       }) : null,
       feedbackMessage ? /* @__PURE__ */ jsx4("box", {
         id: "review-feedback-message",
-        style: { position: "absolute", left: 1, bottom: orphanedFeedback.length > 0 ? Math.min(5, orphanedFeedback.length + 1) : 1, width: Math.max(20, dimensions.width - 2), height: 1, zIndex: 55, backgroundColor: "#202020" },
+        style: { position: "absolute", left: 1, bottom: orphanedFeedback.length > 0 ? Math.min(5, orphanedFeedback.length + 1) : 1, width: Math.max(20, dimensions2.width - 2), height: 1, zIndex: 55, backgroundColor: "#202020" },
         children: /* @__PURE__ */ jsx4("text", {
           content: feedbackMessage,
           wrapMode: "none",
@@ -19445,7 +20421,7 @@ function ReviewWorkspaceApp({ session }) {
       }) : null,
       helpOpen ? /* @__PURE__ */ jsx4("box", {
         id: "review-help-dialog",
-        style: { position: "absolute", left: Math.max(1, Math.floor(dimensions.width / 10)), top: 2, width: Math.max(50, Math.floor(dimensions.width * 4 / 5)), height: Math.min(26, Math.max(14, dimensions.height - 4)), zIndex: 70, border: true, flexDirection: "column", backgroundColor: "#202020" },
+        style: { position: "absolute", left: Math.max(1, Math.floor(dimensions2.width / 10)), top: 2, width: Math.max(50, Math.floor(dimensions2.width * 4 / 5)), height: Math.min(26, Math.max(14, dimensions2.height - 4)), zIndex: 70, border: true, flexDirection: "column", backgroundColor: "#202020" },
         children: /* @__PURE__ */ jsx4("text", {
           content: `Review commands
 ${reviewHelp(focus, state)}
@@ -19456,7 +20432,7 @@ Esc close this help`,
       }) : null,
       finishDialog.isOpen() ? /* @__PURE__ */ jsxs4("box", {
         id: "review-finish-dialog",
-        style: { position: "absolute", left: Math.max(1, Math.floor(dimensions.width / 8)), top: 3, width: Math.max(40, Math.floor(dimensions.width * 3 / 4)), height: 10, zIndex: 60, border: true, flexDirection: "column", backgroundColor: "#202020" },
+        style: { position: "absolute", left: Math.max(1, Math.floor(dimensions2.width / 8)), top: 3, width: Math.max(40, Math.floor(dimensions2.width * 3 / 4)), height: 10, zIndex: 60, border: true, flexDirection: "column", backgroundColor: "#202020" },
         children: [
           /* @__PURE__ */ jsx4("text", {
             content: `Finish review — ${finishDialog.getDecision()}`,