@simon_he/vue-tui 1.0.0 → 1.0.1

package/dist/agent.cjs

@@ -6169,6 +6169,49 @@ var TSelect = (0, import_vue12.defineComponent)({
     const typeaheadQuery = (0, import_vue12.ref)("");
     const query = (0, import_vue12.computed)(() => props.query ?? innerQuery.value);
     const options = (0, import_vue12.computed)(() => providerOptions.value ?? props.options);
+    function getOptionLabel(opt) {
+      return isOptionObject(opt) ? opt.label : opt;
+    }
+    function getOptionKind(opt) {
+      return isOptionObject(opt) ? opt.kind : void 0;
+    }
+    function getOptionValue(opt, index) {
+      if (props.valueMode === "index")
+        return index;
+      if (props.valueMode === "option")
+        return opt;
+      return isOptionObject(opt) && "value" in opt ? opt.value : getOptionLabel(opt);
+    }
+    const optionValueIndex = (0, import_vue12.computed)(() => {
+      if (props.valueMode === "index")
+        return null;
+      const indexed = /* @__PURE__ */ new Map();
+      const opts = options.value;
+      for (let index = 0; index < opts.length; index++) {
+        const value = getOptionValue(opts[index], index);
+        if (typeof value === "number" && value === 0)
+          continue;
+        if (!indexed.has(value))
+          indexed.set(value, index);
+      }
+      return indexed;
+    });
+    function valuesEqual(a, b) {
+      return Object.is(a, b);
+    }
+    function modelIndex(value, useValueIndex = props.multiple) {
+      if (props.valueMode === "index")
+        return normalizeModelIndex(value);
+      if (useValueIndex) {
+        const indexed = optionValueIndex.value;
+        const cached = indexed?.get(value);
+        if (cached != null)
+          return cached;
+      }
+      return options.value.findIndex(
+        (opt, optIndex) => valuesEqual(getOptionValue(opt, optIndex), value)
+      );
+    }
     const initialActive = (() => {
       const max = Math.max(0, options.value.length - 1);
       if (!props.multiple) {
@@ -6226,29 +6269,6 @@ var TSelect = (0, import_vue12.defineComponent)({
       }
       innerActive.value = clamp5(active.value, 0, max);
     });
-    function getOptionLabel(opt) {
-      return isOptionObject(opt) ? opt.label : opt;
-    }
-    function getOptionKind(opt) {
-      return isOptionObject(opt) ? opt.kind : void 0;
-    }
-    function getOptionValue(opt, index) {
-      if (props.valueMode === "index")
-        return index;
-      if (props.valueMode === "option")
-        return opt;
-      return isOptionObject(opt) && "value" in opt ? opt.value : getOptionLabel(opt);
-    }
-    function valuesEqual(a, b) {
-      return Object.is(a, b);
-    }
-    function modelIndex(value) {
-      if (props.valueMode === "index")
-        return normalizeModelIndex(value);
-      return options.value.findIndex(
-        (opt, optIndex) => valuesEqual(getOptionValue(opt, optIndex), value)
-      );
-    }
     function isOptionInteractive(opt) {
       if (!opt)
         return false;
@@ -7596,22 +7616,40 @@ function normalizeVisibleLimit2(value) {
 function isCommandPaletteRowSelectable(item) {
   return Boolean(item && item.kind !== "separator" && item.kind !== "group" && !item.disabled);
 }
-function substringMatcher(item, query) {
-  const q = query.trim().toLowerCase();
-  if (!q)
-    return { score: 0 };
-  const labelRanges = computeCommandPaletteMatchRanges(item.label, q);
-  const detailRanges = item.detail ? computeCommandPaletteMatchRanges(item.detail, q) : [];
-  const keywordMatch = (item.keywords ?? []).some(
-    (keyword) => String(keyword ?? "").toLowerCase().includes(q)
-  );
-  if (!labelRanges.length && !detailRanges.length && !keywordMatch)
-    return null;
-  return {
-    score: labelRanges.length ? 100 : detailRanges.length ? 50 : 10,
-    labelRanges,
-    detailRanges
-  };
+function defaultSubstringEntries(sourceItems, query) {
+  const q = query.trim();
+  if (!q) {
+    return sourceItems.map((item, sourceIndex) => ({
+      item,
+      sourceIndex,
+      match: { score: 0 }
+    }));
+  }
+  const needle = q.toLowerCase();
+  const labelMatches = [];
+  const detailMatches = [];
+  const keywordMatches = [];
+  for (let sourceIndex = 0; sourceIndex < sourceItems.length; sourceIndex++) {
+    const item = sourceItems[sourceIndex];
+    if (item.kind === "separator" || item.kind === "group")
+      continue;
+    const label = String(item.label ?? "");
+    const detail = item.detail == null ? "" : String(item.detail);
+    if (label.toLowerCase().includes(needle)) {
+      labelMatches.push({ item, sourceIndex, match: { score: 100 } });
+      continue;
+    }
+    if (detail.toLowerCase().includes(needle)) {
+      detailMatches.push({ item, sourceIndex, match: { score: 50 } });
+      continue;
+    }
+    if ((item.keywords ?? []).some(
+      (keyword) => String(keyword ?? "").toLowerCase().includes(needle)
+    )) {
+      keywordMatches.push({ item, sourceIndex, match: { score: 10 } });
+    }
+  }
+  return labelMatches.concat(detailMatches, keywordMatches);
 }
 function fuzzyMatcher(item, query) {
   const q = query.trim().toLowerCase();
@@ -7779,14 +7817,22 @@ var TCommandPalette = (0, import_vue16.defineComponent)({
     const filteredEntries = (0, import_vue16.computed)(() => {
       const q = query.value.trim();
       const sourceItems = props.itemsProvider ? providerItems.value ?? [] : props.items;
-      const matcher = props.matcher ?? (props.filterStrategy === "fuzzy" ? fuzzyMatcher : substringMatcher);
-      const entries = sourceItems.flatMap((item, sourceIndex) => {
+      if (!props.matcher && props.filterStrategy === "substring") {
+        return defaultSubstringEntries(sourceItems, q);
+      }
+      const matcher = props.matcher ?? fuzzyMatcher;
+      const entries = [];
+      for (let sourceIndex = 0; sourceIndex < sourceItems.length; sourceIndex++) {
+        const item = sourceItems[sourceIndex];
         if (item.kind === "separator" || item.kind === "group") {
-          return q ? [] : [{ item, sourceIndex, match: { score: 0 } }];
+          if (!q)
+            entries.push({ item, sourceIndex, match: { score: 0 } });
+          continue;
         }
         const match2 = matcher(item, q);
-        return match2 ? [{ item, sourceIndex, match: match2 }] : [];
-      });
+        if (match2)
+          entries.push({ item, sourceIndex, match: match2 });
+      }
       entries.sort((a, b) => b.match.score - a.match.score || a.sourceIndex - b.sourceIndex);
       return entries;
     });
@@ -9879,6 +9925,13 @@ function normalizeInt(value) {
   const n = Math.floor(Number(value));
   return Number.isFinite(n) ? n : 0;
 }
+function normalizeChangedRange(range, count) {
+  if (!range)
+    return null;
+  const start = clamp8(normalizeInt(range.start), 0, count);
+  const end = clamp8(normalizeInt(range.end), start, count);
+  return { start, end };
+}
 function getWheelScrollInput2(e) {
   const deltaY = Number(e.deltaY ?? 0);
   const deltaMode = typeof e.deltaMode === "number" ? e.deltaMode : void 0;
@@ -9903,6 +9956,10 @@ var TVirtualRows = (0, import_vue20.defineComponent)({
     zIndex: { type: Number, default: 0 },
     itemCount: { type: Number, required: true },
     itemVersion: { type: Number, required: true },
+    itemChangedRange: {
+      type: Function,
+      default: void 0
+    },
     getItem: { type: Function, required: true },
     paintItem: {
       type: Function,
@@ -10102,6 +10159,23 @@ var TVirtualRows = (0, import_vue20.defineComponent)({
     function invalidateSelf(priority = "normal") {
       scheduler.invalidate({ priority, plane: plane.value, reason: "scroll" });
     }
+    function markScrollDamage(prevTop, nextTop, strategy = "auto") {
+      const r = normalizedRect();
+      const h24 = r.h;
+      const delta = nextTop - prevTop;
+      if (h24 <= 0 || !delta)
+        return;
+      const size = terminal.size();
+      const ownsFullRows = Math.floor(r.x) === 0 && Math.floor(r.w) >= size.cols;
+      const withinTerminalRows = r.y >= 0 && r.y + h24 <= size.rows;
+      const canUseScrollPlane = strategy === "auto" && props.rowScrollMode === "unsafe-full-row" && rendererCapabilities.value.scrollOperations && ownsFullRows && withinTerminalRows && !isClipped() && Math.abs(delta) < h24 && !dirtyRowsHint?.length;
+      if (canUseScrollPlane) {
+        render.unsafeScrollPlaneRows(plane.value, r.y, r.y + h24, delta);
+        markRowsDirty(exposedRowsForDelta2(r.y, h24, delta));
+      } else {
+        markViewportDirty();
+      }
+    }
     function applyScrollTop(nextTop, options) {
       const r = normalizedRect();
       const h24 = r.h;
@@ -10122,16 +10196,7 @@ var TVirtualRows = (0, import_vue20.defineComponent)({
       setCurrentScrollTop(clampedTop);
       if (options?.emitUpdate !== false)
         emit("update:scrollTop", clampedTop);
-      const size = terminal.size();
-      const ownsFullRows = Math.floor(r.x) === 0 && Math.floor(r.w) >= size.cols;
-      const withinTerminalRows = r.y >= 0 && r.y + h24 <= size.rows;
-      const canUseScrollPlane = (options?.strategy ?? "auto") === "auto" && props.rowScrollMode === "unsafe-full-row" && rendererCapabilities.value.scrollOperations && ownsFullRows && withinTerminalRows && !isClipped() && Math.abs(delta) < h24 && !dirtyRowsHint?.length;
-      if (canUseScrollPlane) {
-        render.unsafeScrollPlaneRows(plane.value, r.y, r.y + h24, delta);
-        markRowsDirty(exposedRowsForDelta2(r.y, h24, delta));
-      } else {
-        markViewportDirty();
-      }
+      markScrollDamage(prevTop, clampedTop, options?.strategy);
       if (options?.emitScroll)
         emitScroll(clampedTop);
       return true;
@@ -10198,8 +10263,11 @@ var TVirtualRows = (0, import_vue20.defineComponent)({
       invalidateSelf("normal");
     }
     function invalidateRange(start, end) {
+      markItemRangeDirty(start, end);
+    }
+    function markItemRangeDirty(start, end) {
       if (!hasPaintableViewport())
-        return;
+        return false;
       const r = normalizedRect();
       const { y: clipY } = clipOffsets();
       const top = currentScrollTop() + clipY;
@@ -10212,9 +10280,10 @@ var TVirtualRows = (0, import_vue20.defineComponent)({
           rows.push(y);
       }
       if (!rows.length)
-        return;
+        return true;
       markRowsDirty(rows);
       invalidateSelf("normal");
+      return true;
     }
     function invalidateIndex(index) {
       const n = normalizeInt(index);
@@ -10454,8 +10523,9 @@ var TVirtualRows = (0, import_vue20.defineComponent)({
           return;
         }
         cancelWheelScrollFrame();
+        const prevTop = controlledScrollTop.value;
         controlledScrollTop.value = nextTop;
-        markViewportDirty();
+        markScrollDamage(prevTop, nextTop);
         selection.refresh(pendingSelectionScrollFocusRemap ? { remapFocus: true } : void 0);
         pendingSelectionScrollFocusRemap = false;
         invalidateSelf("high");
@@ -10479,7 +10549,7 @@ var TVirtualRows = (0, import_vue20.defineComponent)({
         () => absRect.value.w,
         () => absRect.value.h
       ],
-      () => {
+      (next, prev) => {
         resetWheelScrollState(wheelState);
         const nextTop = clampScrollTop(currentScrollTop());
         if (isScrollControlled()) {
@@ -10490,6 +10560,16 @@ var TVirtualRows = (0, import_vue20.defineComponent)({
         } else {
           setCurrentScrollTop(nextTop);
         }
+        const onlyItemVersionChanged = Boolean(
+          prev && next[0] === prev[0] && next[1] !== prev[1] && next[2] === prev[2] && next[3] === prev[3] && next[4] === prev[4] && next[5] === prev[5] && next[6] === prev[6] && next[7] === prev[7] && next[8] === prev[8] && next[9] === prev[9]
+        );
+        if (onlyItemVersionChanged) {
+          const changedRange = normalizeChangedRange(props.itemChangedRange?.(), itemCount.value);
+          if (changedRange) {
+            markItemRangeDirty(changedRange.start, changedRange.end);
+            return;
+          }
+        }
         markViewportDirty();
         invalidateSelf("normal");
       },
@@ -10517,7 +10597,6 @@ var TVirtualRows = (0, import_vue20.defineComponent)({
         absRect.value,
         fullRect.value,
         itemCount.value,
-        props.itemVersion,
         props.getItem,
         props.paintItem,
         props.selectionSpanText,
@@ -10606,8 +10685,11 @@ var EMPTY_LAYOUT = Object.freeze({
   visualRows: Object.freeze([]),
   rowStarts: /* @__PURE__ */ new Map(),
   rowEnds: /* @__PURE__ */ new Map(),
-  regions: Object.freeze([])
+  regions: Object.freeze([]),
+  fixedRows: false,
+  rowCount: 0
 });
+var MAX_KEYED_ROW_LAYOUT_CACHE_ENTRIES = 2048;
 function clamp9(n, min, max) {
   return Math.max(min, Math.min(max, n));
 }
@@ -10615,6 +10697,13 @@ function normalizeInt2(value) {
   const n = Math.floor(Number(value));
   return Number.isFinite(n) ? n : 0;
 }
+function normalizedChangedRange(range, count) {
+  if (!range)
+    return null;
+  const start = clamp9(normalizeInt2(range.start), 0, count);
+  const end = clamp9(normalizeInt2(range.end), start, count);
+  return { start, end };
+}
 function sourceSegmentsForRegion(row) {
   if (row.kind === "message")
     return row.segments;
@@ -10651,8 +10740,27 @@ function rowHasRegionId(row, rowKey, id) {
   }
   return false;
 }
-function sameCachedLayout(entry, next) {
-  return Boolean(entry) && (next.usesSourceRowVersion || entry.version === next.version) && entry.rowVersion === next.rowVersion && entry.usesSourceRowVersion === next.usesSourceRowVersion && (next.usesSourceRowVersion || entry.row === next.row) && entry.rowIndex === next.rowIndex && entry.rowKey === next.rowKey && entry.width === next.width && entry.wrap === next.wrap && entry.baseStyle === next.baseStyle && entry.hoverStyle === next.hoverStyle && entry.focusStyle === next.focusStyle && entry.hoverRegionId === next.hoverRegionId && entry.focusedRegionId === next.focusedRegionId;
+function cachedLayoutHasRegionId(entry, id) {
+  if (!entry || !id)
+    return false;
+  for (const visualRow of entry.visualRows) {
+    if (visualRow.hitRegions.some((region) => region.id === id))
+      return true;
+  }
+  return false;
+}
+function rowLayoutIdentityKey(rowKey, rowVersion) {
+  return JSON.stringify([rowKey, rowVersion]);
+}
+function reindexVisualRows(rows, rowIndex) {
+  return rows.map((visualRow) => ({
+    ...visualRow,
+    rowIndex,
+    hitRegions: visualRow.hitRegions.map((region) => ({ ...region, rowIndex }))
+  }));
+}
+function sameCachedLayout(entry, next, matchRowIndex = true) {
+  return Boolean(entry) && (next.usesSourceRowVersion || entry.version === next.version) && entry.rowVersion === next.rowVersion && entry.usesSourceRowVersion === next.usesSourceRowVersion && (next.usesSourceRowVersion || entry.row === next.row) && (!matchRowIndex || entry.rowIndex === next.rowIndex) && entry.rowKey === next.rowKey && entry.width === next.width && entry.wrap === next.wrap && entry.baseStyle === next.baseStyle && entry.hoverStyle === next.hoverStyle && entry.focusStyle === next.focusStyle && entry.hoverRegionId === next.hoverRegionId && entry.focusedRegionId === next.focusedRegionId;
 }
 var TTranscriptView = (0, import_vue21.defineComponent)({
   name: "TTranscriptView",
@@ -10702,6 +10810,10 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
     const hoveredRegion = (0, import_vue21.ref)(null);
     const focusedRegion = (0, import_vue21.ref)(null);
     const rowLayoutCache = /* @__PURE__ */ new Map();
+    const keyedRowLayoutCache = /* @__PURE__ */ new Map();
+    let previousWrappedLayout = null;
+    let previousWrappedDeps = null;
+    let canUseWrappedChangedRangeRepaint = false;
     let warnedLargeFlattenedRows = false;
     function isScrollControlled() {
       return Object.prototype.hasOwnProperty.call(instance?.vnode.props ?? {}, "scrollTop");
@@ -10709,14 +10821,181 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
     function currentScrollTop() {
       return normalizeInt2(isScrollControlled() ? props.scrollTop : innerScrollTop.value);
     }
+    function currentScrollTopForRowCount(count) {
+      const viewportRows = Math.max(0, normalizeInt2(props.h));
+      const maxTop = Math.max(0, count - viewportRows);
+      return clamp9(currentScrollTop(), 0, maxTop);
+    }
+    function rememberKeyedRowLayout(entry) {
+      if (!entry.usesSourceRowVersion)
+        return;
+      keyedRowLayoutCache.set(rowLayoutIdentityKey(entry.rowKey, entry.rowVersion), entry);
+      if (keyedRowLayoutCache.size <= MAX_KEYED_ROW_LAYOUT_CACHE_ENTRIES)
+        return;
+      const first = keyedRowLayoutCache.keys().next().value;
+      if (first != null)
+        keyedRowLayoutCache.delete(first);
+    }
+    function layoutSourceRow(rowIndex, options) {
+      const sourceRowVersion = props.source.getRowVersion?.(rowIndex);
+      let cached = rowLayoutCache.get(rowIndex);
+      const usesSourceRowVersion = sourceRowVersion != null;
+      let row = cached?.row;
+      let rowKey = cached?.rowKey;
+      let canUseCachedRow = false;
+      if (usesSourceRowVersion && cached?.usesSourceRowVersion && cached.rowVersion === sourceRowVersion) {
+        if (props.source.getRowKey) {
+          rowKey = props.source.getRowKey(rowIndex);
+          canUseCachedRow = rowKey === cached.rowKey;
+        } else {
+          rowKey = cached.rowKey;
+          canUseCachedRow = true;
+        }
+      }
+      if (!canUseCachedRow && usesSourceRowVersion && props.source.getRowKey) {
+        rowKey = props.source.getRowKey(rowIndex);
+        cached = keyedRowLayoutCache.get(rowLayoutIdentityKey(rowKey, sourceRowVersion));
+        if (cached) {
+          row = cached.row;
+          canUseCachedRow = true;
+        }
+      }
+      if (!canUseCachedRow || row == null || rowKey == null) {
+        row = props.source.getRow(rowIndex);
+        rowKey = props.source.getRowKey?.(rowIndex) ?? row.key;
+        canUseCachedRow = false;
+      }
+      const nextHoverRegionId = canUseCachedRow ? cachedLayoutHasRegionId(cached, options.hoverRegionId) ? options.hoverRegionId : null : rowHasRegionId(row, rowKey, options.hoverRegionId) ? options.hoverRegionId : null;
+      const nextFocusedRegionId = canUseCachedRow ? cachedLayoutHasRegionId(cached, options.focusedRegionId) ? options.focusedRegionId : null : rowHasRegionId(row, rowKey, options.focusedRegionId) ? options.focusedRegionId : null;
+      const cacheKey = {
+        version: props.version,
+        rowVersion: sourceRowVersion ?? props.version,
+        usesSourceRowVersion,
+        row,
+        rowIndex,
+        rowKey,
+        width: options.width,
+        wrap: props.wrap,
+        baseStyle: options.baseStyle,
+        hoverStyle: props.hoverStyle,
+        focusStyle: props.focusStyle,
+        hoverRegionId: nextHoverRegionId,
+        focusedRegionId: nextFocusedRegionId
+      };
+      const cacheMatches = sameCachedLayout(cached, cacheKey);
+      const reindexableCacheMatches = !cacheMatches && canUseCachedRow && sameCachedLayout(cached, cacheKey, false);
+      const rows = cacheMatches ? cached.visualRows : reindexableCacheMatches ? reindexVisualRows(cached.visualRows, rowIndex) : layoutTranscriptRow({
+        row,
+        rowIndex,
+        rowKey,
+        width: options.width,
+        baseStyle: options.baseStyle,
+        hoverRegionId: nextHoverRegionId,
+        focusedRegionId: nextFocusedRegionId,
+        hoverStyle: props.hoverStyle,
+        focusStyle: props.focusStyle,
+        wrap: props.wrap
+      });
+      if (rows !== cached?.visualRows) {
+        const entry = { ...cacheKey, visualRows: rows };
+        rowLayoutCache.set(rowIndex, entry);
+        rememberKeyedRowLayout(entry);
+      }
+      return { rows, cacheHit: cacheMatches || reindexableCacheMatches };
+    }
+    function pruneRowLayoutCache(count) {
+      for (const rowIndex of rowLayoutCache.keys()) {
+        if (rowIndex >= count)
+          rowLayoutCache.delete(rowIndex);
+      }
+    }
+    function sameWrappedDeps(a, b) {
+      return Boolean(a) && a.width === b.width && a.baseStyle === b.baseStyle && a.hoverStyle === b.hoverStyle && a.focusStyle === b.focusStyle && a.hoverRegionId === b.hoverRegionId && a.focusedRegionId === b.focusedRegionId;
+    }
+    function visibleRegionsForVisualRows(visualRows) {
+      const top = clamp9(currentScrollTop(), 0, visualRows.length);
+      const bottom = Math.min(visualRows.length, top + Math.max(0, normalizeInt2(props.h)));
+      const regions = [];
+      for (let index = top; index < bottom; index++) {
+        regions.push(...visualRows[index]?.hitRegions ?? []);
+      }
+      return regions;
+    }
+    function tryUpdateWrappedLayoutFromChangedRange(count, changedRange, deps) {
+      const previous = previousWrappedLayout;
+      if (!previous || previous.fixedRows || previous.rowCount !== count)
+        return null;
+      if (!changedRange || !sameWrappedDeps(previousWrappedDeps, deps))
+        return null;
+      const changedCount = changedRange.end - changedRange.start;
+      if (changedCount <= 0) {
+        canUseWrappedChangedRangeRepaint = true;
+        return {
+          state: { ...previous, regions: visibleRegionsForVisualRows(previous.visualRows) },
+          cacheHit: count,
+          cacheMiss: 0
+        };
+      }
+      const oldVisualStart = previous.rowStarts.get(changedRange.start);
+      const oldVisualEnd = previous.rowEnds.get(changedRange.end - 1);
+      if (oldVisualStart == null || oldVisualEnd == null)
+        return null;
+      const nextRows = [];
+      const changedRowHeights = [];
+      let cacheHit = count - changedCount;
+      let cacheMiss = 0;
+      for (let rowIndex = changedRange.start; rowIndex < changedRange.end; rowIndex++) {
+        const result = layoutSourceRow(rowIndex, {
+          width: deps.width,
+          baseStyle: deps.baseStyle,
+          hoverRegionId: deps.hoverRegionId,
+          focusedRegionId: deps.focusedRegionId
+        });
+        if (result.cacheHit)
+          cacheHit++;
+        else
+          cacheMiss++;
+        changedRowHeights.push(result.rows.length);
+        nextRows.push(...result.rows);
+      }
+      if (nextRows.length !== oldVisualEnd - oldVisualStart)
+        return null;
+      canUseWrappedChangedRangeRepaint = true;
+      const visualRows = previous.visualRows;
+      for (let index = 0; index < nextRows.length; index++) {
+        visualRows[oldVisualStart + index] = nextRows[index];
+      }
+      const rowStarts = previous.rowStarts;
+      const rowEnds = previous.rowEnds;
+      let visualCursor = oldVisualStart;
+      for (let rowIndex = changedRange.start, offset = 0; rowIndex < changedRange.end; rowIndex++, offset++) {
+        rowStarts.set(rowIndex, visualCursor);
+        visualCursor += changedRowHeights[offset] ?? 0;
+        rowEnds.set(rowIndex, visualCursor);
+      }
+      const state = {
+        visualRows,
+        rowStarts,
+        rowEnds,
+        regions: visibleRegionsForVisualRows(visualRows),
+        fixedRows: false,
+        rowCount: count
+      };
+      previousWrappedLayout = state;
+      return { state, cacheHit, cacheMiss };
+    }
     const layoutState = (0, import_vue21.computed)(() => {
       void props.version;
+      canUseWrappedChangedRangeRepaint = false;
       const perfEnabled = observability.framePerf.enabled.value;
       const perfStartedAt = perfEnabled ? framePerfNow() : 0;
       const width = Math.max(1, Math.floor(props.w));
       const count = Math.max(0, normalizeInt2(props.source.rowCount()));
       if (!count) {
         rowLayoutCache.clear();
+        keyedRowLayoutCache.clear();
+        previousWrappedLayout = null;
+        previousWrappedDeps = null;
         if (perfEnabled) {
           observability.framePerf.recordComponent({
             name: "TTranscriptView",
@@ -10733,7 +11012,10 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
         }
         return EMPTY_LAYOUT;
       }
+      const fixedRows = props.wrap === false;
       const visualRows = [];
+      if (fixedRows)
+        visualRows.length = count;
       const rowStarts = /* @__PURE__ */ new Map();
       const rowEnds = /* @__PURE__ */ new Map();
       const regions = [];
@@ -10742,59 +11024,81 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
       const focusedRegionId = focusedRegion.value?.id ?? null;
       let cacheHit = 0;
       let cacheMiss = 0;
-      for (let rowIndex = 0; rowIndex < count; rowIndex++) {
-        const row = props.source.getRow(rowIndex);
-        const rowKey = props.source.getRowKey?.(rowIndex) ?? row.key;
-        const sourceRowVersion = props.source.getRowVersion?.(rowIndex);
-        const localHoverRegionId = rowHasRegionId(row, rowKey, hoverRegionId) ? hoverRegionId : null;
-        const localFocusedRegionId = rowHasRegionId(row, rowKey, focusedRegionId) ? focusedRegionId : null;
-        const cacheKey = {
-          version: props.version,
-          rowVersion: sourceRowVersion ?? props.version,
-          usesSourceRowVersion: sourceRowVersion != null,
-          row,
-          rowIndex,
-          rowKey,
-          width,
-          wrap: props.wrap,
-          baseStyle,
-          hoverStyle: props.hoverStyle,
-          focusStyle: props.focusStyle,
-          hoverRegionId: localHoverRegionId,
-          focusedRegionId: localFocusedRegionId
-        };
-        rowStarts.set(rowIndex, visualRows.length);
-        const cached = rowLayoutCache.get(rowIndex);
-        const cacheMatches = sameCachedLayout(cached, cacheKey);
-        if (cacheMatches)
-          cacheHit++;
-        else
-          cacheMiss++;
-        const rows = cacheMatches ? cached.visualRows : layoutTranscriptRow({
-          row,
-          rowIndex,
-          rowKey,
-          width,
-          baseStyle,
-          hoverRegionId: localHoverRegionId,
-          focusedRegionId: localFocusedRegionId,
-          hoverStyle: props.hoverStyle,
-          focusStyle: props.focusStyle,
-          wrap: props.wrap
-        });
-        if (rows !== cached?.visualRows)
-          rowLayoutCache.set(rowIndex, { ...cacheKey, visualRows: rows });
-        for (const visualRow of rows) {
-          visualRows.push(visualRow);
-          regions.push(...visualRow.hitRegions);
+      const sourceChangedRange = normalizedChangedRange(props.source.getChangedRange?.(), count);
+      const wrappedDeps = {
+        width,
+        baseStyle,
+        hoverStyle: props.hoverStyle,
+        focusStyle: props.focusStyle,
+        hoverRegionId,
+        focusedRegionId
+      };
+      if (fixedRows) {
+        previousWrappedLayout = null;
+        previousWrappedDeps = null;
+        const top = currentScrollTopForRowCount(count);
+        const bottom = Math.min(count, top + Math.max(0, normalizeInt2(props.h)));
+        for (let rowIndex = top; rowIndex < bottom; rowIndex++) {
+          rowStarts.set(rowIndex, rowIndex);
+          rowEnds.set(rowIndex, rowIndex + 1);
+          const result = layoutSourceRow(rowIndex, {
+            width,
+            baseStyle,
+            hoverRegionId,
+            focusedRegionId
+          });
+          if (result.cacheHit)
+            cacheHit++;
+          else
+            cacheMiss++;
+          const row = result.rows[0];
+          visualRows[rowIndex] = row;
+          regions.push(...row.hitRegions);
+        }
+      } else {
+        const incremental = tryUpdateWrappedLayoutFromChangedRange(
+          count,
+          sourceChangedRange,
+          wrappedDeps
+        );
+        if (incremental) {
+          if (perfEnabled) {
+            observability.framePerf.recordComponent({
+              name: "TTranscriptView",
+              id: instance?.uid == null ? void 0 : String(instance.uid),
+              phase: "layout",
+              durationMs: framePerfNow() - perfStartedAt,
+              itemCount: count,
+              renderedCount: incremental.state.visualRows.length,
+              cacheHit: incremental.cacheHit,
+              cacheMiss: incremental.cacheMiss,
+              width,
+              version: props.version
+            });
+          }
+          return incremental.state;
+        }
+        for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+          rowStarts.set(rowIndex, visualRows.length);
+          const result = layoutSourceRow(rowIndex, {
+            width,
+            baseStyle,
+            hoverRegionId,
+            focusedRegionId
+          });
+          if (result.cacheHit)
+            cacheHit++;
+          else
+            cacheMiss++;
+          for (const visualRow of result.rows) {
+            visualRows.push(visualRow);
+            regions.push(...visualRow.hitRegions);
+          }
+          rowEnds.set(rowIndex, visualRows.length);
         }
-        rowEnds.set(rowIndex, visualRows.length);
-      }
-      for (const rowIndex of rowLayoutCache.keys()) {
-        if (rowIndex >= count)
-          rowLayoutCache.delete(rowIndex);
       }
-      if (!warnedLargeFlattenedRows && globalThis.__VT_DEBUG_PERF__ && visualRows.length > 5e3) {
+      pruneRowLayoutCache(count);
+      if (!warnedLargeFlattenedRows && !fixedRows && globalThis.__VT_DEBUG_PERF__ && visualRows.length > 5e3) {
         warnedLargeFlattenedRows = true;
         console.warn(
           "[vue-tui] TTranscriptView flattens all transcript rows; use TLogView or windowed source for large retained output."
@@ -10807,14 +11111,22 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
           phase: "layout",
           durationMs: framePerfNow() - perfStartedAt,
           itemCount: count,
-          renderedCount: visualRows.length,
+          renderedCount: fixedRows ? cacheHit + cacheMiss : visualRows.length,
           cacheHit,
           cacheMiss,
           width,
           version: props.version
         });
       }
-      return { visualRows, rowStarts, rowEnds, regions };
+      const state = { visualRows, rowStarts, rowEnds, regions, fixedRows, rowCount: count };
+      if (fixedRows) {
+        previousWrappedLayout = null;
+        previousWrappedDeps = null;
+      } else {
+        previousWrappedLayout = state;
+        previousWrappedDeps = wrappedDeps;
+      }
+      return state;
     });
     const maxScrollTop = (0, import_vue21.computed)(
       () => Math.max(0, layoutState.value.visualRows.length - Math.max(0, normalizeInt2(props.h)))
@@ -10863,8 +11175,11 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
         return [];
       const rows = layoutState.value.visualRows;
       const indexes = [];
-      for (let i = 0; i < rows.length; i++) {
-        if (rows[i].hitRegions.some((candidate) => candidate.id === region.id))
+      const top = layoutState.value.fixedRows ? clamp9(currentScrollTop(), 0, rows.length) : 0;
+      const bottom = layoutState.value.fixedRows ? Math.min(rows.length, top + Math.max(0, normalizeInt2(props.h))) : rows.length;
+      for (let i = top; i < bottom; i++) {
+        const row = getVisualRow(i);
+        if (row?.hitRegions.some((candidate) => candidate.id === region.id))
           indexes.push(i);
       }
       return indexes;
@@ -10897,7 +11212,7 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
       const seen = /* @__PURE__ */ new Set();
       const regions = [];
       for (let i = top; i < bottom; i++) {
-        for (const region of rows[i]?.hitRegions ?? []) {
+        for (const region of getVisualRow(i)?.hitRegions ?? []) {
           if (seen.has(region.id))
             continue;
           seen.add(region.id);
@@ -10911,7 +11226,7 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
       const top = clamp9(currentScrollTop(), 0, rows.length);
       const bottom = Math.min(rows.length, top + Math.max(0, normalizeInt2(props.h)));
       for (let i = top; i < bottom; i++) {
-        if (rows[i]?.hitRegions.some((region) => region.id === id))
+        if (getVisualRow(i)?.hitRegions.some((region) => region.id === id))
           return true;
       }
       return false;
@@ -10978,8 +11293,8 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
     }
     function scrollToRow(index, options) {
       const rowIndex = clamp9(normalizeInt2(index), 0, Math.max(0, props.source.rowCount() - 1));
-      const visualIndex = layoutState.value.rowStarts.get(rowIndex) ?? 0;
-      const rowEnd = layoutState.value.rowEnds.get(rowIndex) ?? visualIndex + 1;
+      const visualIndex = layoutState.value.fixedRows ? rowIndex : layoutState.value.rowStarts.get(rowIndex) ?? 0;
+      const rowEnd = layoutState.value.fixedRows ? rowIndex + 1 : layoutState.value.rowEnds.get(rowIndex) ?? visualIndex + 1;
       const viewportRows = Math.max(1, normalizeInt2(props.h));
       const rowHeight = Math.max(1, rowEnd - visualIndex);
       let top = visualIndex;
@@ -10992,8 +11307,8 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
       setScrollTop(top);
     }
     function invalidateRow(index) {
-      const start = layoutState.value.rowStarts.get(index);
-      const end = layoutState.value.rowEnds.get(index);
+      const start = layoutState.value.fixedRows ? index : layoutState.value.rowStarts.get(index);
+      const end = layoutState.value.fixedRows ? index + 1 : layoutState.value.rowEnds.get(index);
       if (start == null || end == null)
         return;
       rowsRef.value?.invalidateRange(start, end);
@@ -11001,12 +11316,27 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
     function invalidateRange(start, end) {
       const first = clamp9(normalizeInt2(start), 0, props.source.rowCount());
       const last = clamp9(normalizeInt2(end), first, props.source.rowCount());
-      const visualStart = layoutState.value.rowStarts.get(first);
-      const visualEnd = layoutState.value.rowEnds.get(last - 1);
+      const visualStart = layoutState.value.fixedRows ? first : layoutState.value.rowStarts.get(first);
+      const visualEnd = layoutState.value.fixedRows ? last : layoutState.value.rowEnds.get(last - 1);
       if (visualStart == null || visualEnd == null)
         return;
       rowsRef.value?.invalidateRange(visualStart, visualEnd);
     }
+    function virtualRowsChangedRange() {
+      const state = layoutState.value;
+      const changedRange = normalizedChangedRange(props.source.getChangedRange?.(), state.rowCount);
+      if (!changedRange)
+        return null;
+      if (state.fixedRows || changedRange.end <= changedRange.start)
+        return changedRange;
+      if (!canUseWrappedChangedRangeRepaint)
+        return null;
+      const visualStart = state.rowStarts.get(changedRange.start);
+      const visualEnd = state.rowEnds.get(changedRange.end - 1);
+      if (visualStart == null || visualEnd == null)
+        return null;
+      return { start: visualStart, end: visualEnd };
+    }
     expose({
       scrollToBottom,
       scrollToTop,
@@ -11110,7 +11440,22 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
       return text2;
     }
     function getVisualRow(index) {
-      return layoutState.value.visualRows[index];
+      const state = layoutState.value;
+      const cached = state.visualRows[index];
+      if (cached || !state.fixedRows)
+        return cached;
+      if (index < 0 || index >= state.visualRows.length)
+        return void 0;
+      const result = layoutSourceRow(index, {
+        width: Math.max(1, Math.floor(props.w)),
+        baseStyle: props.style ?? defaultStyle.value,
+        hoverRegionId: hoveredRegion.value?.id ?? null,
+        focusedRegionId: focusedRegion.value?.id ?? null
+      });
+      const row = result.rows[0];
+      if (row)
+        state.visualRows[index] = row;
+      return row;
     }
     function selectionTextForVisualRow(visualRow) {
       if (!visualRow)
@@ -11138,6 +11483,7 @@ var TTranscriptView = (0, import_vue21.defineComponent)({
       zIndex: props.zIndex,
       itemCount: layoutState.value.visualRows.length,
       itemVersion: props.version,
+      itemChangedRange: virtualRowsChangedRange,
       getItem: getVisualRow,
       paintItem: paintVisualRow,
       renderItemNodes: renderVisualRowNodes,
@@ -11786,6 +12132,20 @@ function wrapStyledSegmentsByCells(segments, width) {
     rowCells += cells;
   };
   for (const seg of segments) {
+    const cells = textCellWidth(seg.text);
+    if (cells === seg.text.length) {
+      for (let i = 0; i < seg.text.length; ) {
+        if (rowCells >= width)
+          openRow();
+        const take = Math.min(width - rowCells, seg.text.length - i);
+        if (take <= 0)
+          break;
+        row.push({ text: seg.text.slice(i, i + take), cells: take, style: seg.style });
+        rowCells += take;
+        i += take;
+      }
+      continue;
+    }
     forEachTextCellSegment(seg.text, (piece) => {
       if (!piece.text || piece.cells <= 0)
         return;
@@ -11794,6 +12154,116 @@ function wrapStyledSegmentsByCells(segments, width) {
   }
   return rows;
 }
+function countWrappedTextRows(text2, width) {
+  width = Math.max(1, Math.floor(width));
+  if (!text2)
+    return 1;
+  const cells = textCellWidth(text2);
+  if (cells <= 0)
+    return 1;
+  if (cells === text2.length)
+    return Math.max(1, Math.ceil(cells / width));
+  let rows = 1;
+  let rowCells = 0;
+  forEachTextCellSegment(text2, (piece) => {
+    if (!piece.text || piece.cells <= 0)
+      return;
+    const pieceCells = piece.cells;
+    if (rowCells > 0 && rowCells + pieceCells > width) {
+      rows++;
+      rowCells = 0;
+    }
+    if (pieceCells > width) {
+      let remaining = pieceCells;
+      while (remaining > 0) {
+        if (rowCells >= width) {
+          rows++;
+          rowCells = 0;
+        }
+        const take = Math.min(width - rowCells, remaining);
+        rowCells += take;
+        remaining -= take;
+      }
+      return;
+    }
+    if (rowCells >= width) {
+      rows++;
+      rowCells = 0;
+    }
+    rowCells += pieceCells;
+  });
+  return rows;
+}
+function countWrappedPlainTextRows(text2, width) {
+  width = Math.max(1, Math.floor(width));
+  if (!text2)
+    return 1;
+  let rows = 0;
+  let rowCells = 0;
+  let sawText = false;
+  forEachTextCellSegment(text2, (piece) => {
+    if (!piece.text || piece.cells <= 0)
+      return;
+    sawText = true;
+    const cells = piece.cells;
+    if (rowCells > 0 && rowCells + cells > width) {
+      rows++;
+      rowCells = 0;
+    }
+    rowCells += cells;
+    if (rowCells >= width) {
+      rows++;
+      rowCells = 0;
+    }
+  });
+  return Math.max(1, rows + (rowCells > 0 || !sawText ? 1 : 0));
+}
+function countAsciiAnsiTextCells(text2) {
+  let cells = 0;
+  for (let i = 0; i < text2.length; i++) {
+    const code2 = text2.charCodeAt(i);
+    if (code2 > 127)
+      return null;
+    if (code2 === 27) {
+      const next = text2[i + 1];
+      if (next === "[") {
+        let j = i + 2;
+        while (j < text2.length) {
+          const c = text2.charCodeAt(j);
+          if (c >= 64 && c <= 126)
+            break;
+          j++;
+        }
+        if (j >= text2.length)
+          return null;
+        i = j;
+        continue;
+      }
+      if (next === "]") {
+        let j = i + 2;
+        while (j < text2.length) {
+          const c = text2.charCodeAt(j);
+          if (c === 7)
+            break;
+          if (c === 27 && text2[j + 1] === "\\") {
+            j++;
+            break;
+          }
+          j++;
+        }
+        if (j >= text2.length)
+          return null;
+        i = j;
+        continue;
+      }
+      return null;
+    }
+    if (code2 <= 31 || code2 === 127)
+      return null;
+    cells++;
+  }
+  return cells;
+}
 var TLogView = (0, import_vue22.defineComponent)({
   name: "TLogView",
   props: {
@@ -11932,6 +12402,7 @@ var TLogView = (0, import_vue22.defineComponent)({
     const renderLineCache = /* @__PURE__ */ new Map();
     const wrapLineCache = /* @__PURE__ */ new Map();
     const ansiLineCache = /* @__PURE__ */ new Map();
+    const ansiTextCache = /* @__PURE__ */ new Map();
     const ansiWrapCache = /* @__PURE__ */ new Map();
     const ansiRowCache = /* @__PURE__ */ new Map();
     const linkifyLineCache = /* @__PURE__ */ new Map();
@@ -12053,6 +12524,9 @@ var TLogView = (0, import_vue22.defineComponent)({
     function ansiLineCacheKey(key, baseStyleKey, linkKey) {
       return JSON.stringify(["ansi-line", key, baseStyleKey, linksEnabled() ? 1 : 0, linkKey]);
     }
+    function ansiTextCacheKey(key) {
+      return JSON.stringify(["ansi-text", key]);
+    }
     function linkifyLineCacheKey(key, baseStyleKey, linkKey, optionsKey) {
       return JSON.stringify(["linkify-line", key, baseStyleKey, linkKey, optionsKey]);
     }
@@ -12115,6 +12589,15 @@ var TLogView = (0, import_vue22.defineComponent)({
         ansiLineCache.delete(entry.key);
       }
     }
+    function trimAnsiTextCache() {
+      const max = DEFAULT_LOG_RENDER_CACHE_SIZE;
+      if (ansiTextCache.size <= max)
+        return;
+      const entries = Array.from(ansiTextCache.values()).sort((a, b) => a.touchedAt - b.touchedAt);
+      for (const entry of entries.slice(0, ansiTextCache.size - max)) {
+        ansiTextCache.delete(entry.key);
+      }
+    }
     function trimAnsiWrapCache() {
       const max = DEFAULT_LOG_WRAP_CACHE_SIZE;
       if (ansiWrapCache.size <= max)
@@ -12170,6 +12653,7 @@ var TLogView = (0, import_vue22.defineComponent)({
       renderLineCache.clear();
       wrapLineCache.clear();
       ansiLineCache.clear();
+      ansiTextCache.clear();
       ansiWrapCache.clear();
       ansiRowCache.clear();
       linkifyLineCache.clear();
@@ -12255,6 +12739,24 @@ var TLogView = (0, import_vue22.defineComponent)({
       });
       return segments;
     }
+    function ansiPlainTextForLine(index, count) {
+      if (index < 0 || index >= count)
+        return "";
+      const rawKey = lineKey(index);
+      const key = ansiTextCacheKey(rawKey);
+      const cached = ansiTextCache.get(key);
+      if (cached) {
+        cached.touchedAt = ++cacheClock;
+        return cached.value;
+      }
+      const text2 = sanitizeAnsiInlineText(props.source.getLine(index));
+      ansiTextCache.set(key, {
+        key,
+        value: text2,
+        touchedAt: ++cacheClock
+      });
+      return text2;
+    }
     function ansiWrappedRowsForLine(index, count, width, baseStyle, baseStyleKey, linkKey = linkStyleCacheKey()) {
       if (index < 0 || index >= count)
         return [[]];
@@ -12650,10 +13152,9 @@ var TLogView = (0, import_vue22.defineComponent)({
       lineMatches.push(matchIndex);
       invalidateSearchMarkers();
     }
-    function searchableTextForLine(index, count, baseStyle, baseStyleKey) {
-      if (props.ansi) {
-        return ansiSegmentsForLine(index, count, baseStyle, baseStyleKey).map((seg) => seg.text).join("");
-      }
+    function searchableTextForLine(index, count) {
+      if (props.ansi)
+        return ansiPlainTextForLine(index, count);
       return sanitizeInlineText(props.source.getLine(index));
     }
     function normalizeSearchResultPreviewWidth(value) {
@@ -12668,8 +13169,8 @@ var TLogView = (0, import_vue22.defineComponent)({
         return DEFAULT_SEARCH_RESULTS_CONTEXT_CELLS;
       return Math.max(0, n);
     }
-    function previewForMatch(match2, count, baseStyle, baseStyleKey, options) {
-      const text2 = searchableTextForLine(match2.index, count, baseStyle, baseStyleKey);
+    function previewForMatch(match2, count, options) {
+      const text2 = searchableTextForLine(match2.index, count);
       const totalCells = textCellWidth(text2);
       const matchCells = Math.max(1, match2.endCell - match2.startCell);
       const previewWidth = Math.max(options.previewWidth, matchCells);
@@ -12704,7 +13205,7 @@ var TLogView = (0, import_vue22.defineComponent)({
         matchEndCell
       };
     }
-    function cachedLineSearchMatches(index, count, search, baseStyle, baseStyleKey) {
+    function cachedLineSearchMatches(index, count, search) {
       const rawKey = lineKey(index);
       const key = searchLineCacheKey(rawKey, search.key);
       const cached = searchLineCache.get(key);
@@ -12712,9 +13213,7 @@ var TLogView = (0, import_vue22.defineComponent)({
         cached.touchedAt = ++cacheClock;
         return cached.matches;
       }
-      const matches = search.findLineMatches(
-        searchableTextForLine(index, count, baseStyle, baseStyleKey)
-      );
+      const matches = search.findLineMatches(searchableTextForLine(index, count));
       searchLineCache.set(key, {
         key,
         matches,
@@ -12722,10 +13221,10 @@ var TLogView = (0, import_vue22.defineComponent)({
       });
       return matches;
     }
-    function scanSearchLine(index, count, search, baseStyle, baseStyleKey, maxMatches, absoluteBase) {
+    function scanSearchLine(index, count, search, maxMatches, absoluteBase) {
       if (searchMatches.length >= maxMatches)
         return;
-      const lineMatches = cachedLineSearchMatches(index, count, search, baseStyle, baseStyleKey);
+      const lineMatches = cachedLineSearchMatches(index, count, search);
       for (const match2 of lineMatches) {
         if (searchMatches.length >= maxMatches)
           return;
@@ -12755,19 +13254,9 @@ var TLogView = (0, import_vue22.defineComponent)({
       const count = lineCount();
       const maxMatches = maxSearchMatches();
       const absoluteBase = firstLineIndex();
-      const base = props.style ?? defaultStyle.value;
-      const baseStyleKey = styleCacheKey(base);
       let scanned = 0;
       while (searchCursor < count && searchMatches.length < maxMatches && (scanned === 0 || ctx.now() - started < budget)) {
-        scanSearchLine(
-          searchCursor,
-          count,
-          compiledSearch,
-          base,
-          baseStyleKey,
-          maxMatches,
-          absoluteBase
-        );
+        scanSearchLine(searchCursor, count, compiledSearch, maxMatches, absoluteBase);
         searchCursor++;
         scanned++;
       }
@@ -12788,6 +13277,7 @@ var TLogView = (0, import_vue22.defineComponent)({
       emitSearchMarkers(true);
       markViewportDirty();
       ctx.invalidate({ priority: "low", plane: plane.value, reason: "data" });
+      trimAnsiTextCache();
       trimSearchLineCache();
     }
     function requestSearchScan() {
@@ -13059,22 +13549,39 @@ var TLogView = (0, import_vue22.defineComponent)({
       if (count > visualIndexLineCount)
         appendEstimatedVisualLines(visualIndexLineCount, count);
     }
-    function measureVisualLine(index) {
+    function measureVisualLine(index, options) {
       ensureVisualIndex();
       if (index < 0 || index >= visualIndexLineCount)
         return 0;
       const key = lineKey(index);
       if (visualKeys[index] === key)
         return 0;
-      const base = props.style ?? defaultStyle.value;
-      const rows = props.ansi ? ansiWrappedRowsForLine(
-        index,
-        visualIndexLineCount,
-        visualIndexWidth,
-        base,
-        styleCacheKey(base)
-      ) : wrappedRowsForLine(index, visualIndexLineCount, visualIndexWidth);
-      const nextCount = Math.max(1, rows.length);
+      let nextCount;
+      if (options?.countOnly === true) {
+        if (props.ansi) {
+          const raw = props.source.getLine(index);
+          const asciiCells = countAsciiAnsiTextCells(raw);
+          nextCount = asciiCells == null ? countWrappedTextRows(
+            ansiPlainTextForLine(index, visualIndexLineCount),
+            visualIndexWidth
+          ) : Math.max(1, Math.ceil(asciiCells / visualIndexWidth));
+        } else {
+          nextCount = countWrappedPlainTextRows(
+            sanitizeInlineText(props.source.getLine(index)),
+            visualIndexWidth
+          );
+        }
+      } else {
+        const base = props.style ?? defaultStyle.value;
+        const rows = props.ansi ? ansiWrappedRowsForLine(
+          index,
+          visualIndexLineCount,
+          visualIndexWidth,
+          base,
+          styleCacheKey(base)
+        ) : wrappedRowsForLine(index, visualIndexLineCount, visualIndexWidth);
+        nextCount = Math.max(1, rows.length);
+      }
       const prevCount = visualCounts[index] ?? 1;
       if (nextCount !== prevCount) {
         visualCounts[index] = nextCount;
@@ -13120,6 +13627,7 @@ var TLogView = (0, import_vue22.defineComponent)({
       if (visualMeasureCursor >= target) {
         syncVisualIndexStatus();
         emitVisualIndex();
+        trimAnsiTextCache();
         return;
       }
       const started = ctx.now();
@@ -13131,7 +13639,7 @@ var TLogView = (0, import_vue22.defineComponent)({
         const effectiveTop = currentScrollTop() + topAdjustment;
         const start = visualStartForLine(index);
         const prevCount = visualCounts[index] ?? 1;
-        const delta = measureVisualLine(index);
+        const delta = measureVisualLine(index, { countOnly: true });
         if (delta !== 0 && effectiveTop >= start + prevCount)
           topAdjustment += delta;
         visualMeasureCursor++;
@@ -13167,6 +13675,7 @@ var TLogView = (0, import_vue22.defineComponent)({
       }
       syncVisualIndexStatus();
       emitVisualIndex();
+      trimAnsiTextCache();
     }
     function requestVisualIndexMeasurement(restartFrom = measuredLineCount) {
       if (!props.wrap) {
@@ -13180,6 +13689,7 @@ var TLogView = (0, import_vue22.defineComponent)({
       if (measuredLineCount >= target) {
         syncVisualIndexStatus();
         emitVisualIndex();
+        trimAnsiTextCache();
         return;
       }
       const generation = ++visualMeasureGeneration;
@@ -13772,7 +14282,7 @@ var TLogView = (0, import_vue22.defineComponent)({
           emitScroll(clampedTop);
         return true;
       }
-      const scrollPlan = !props.wrap ? prepareUnsafeFullRowScroll({
+      const scrollPlan = prepareUnsafeFullRowScroll({
         render,
         plane: plane.value,
         rect: r,
@@ -13783,7 +14293,7 @@ var TLogView = (0, import_vue22.defineComponent)({
         isClipped: isClipped(),
         hasPendingDirtyRows: Boolean(dirtyRowsHint?.length),
         strategy
-      }) : null;
+      });
       if (scrollPlan) {
         const rows = options?.extraDirtyRows?.length ? [...scrollPlan.exposedRows, ...options.extraDirtyRows] : scrollPlan.exposedRows;
         if (markRowsDirty(rows)) {
@@ -14348,14 +14858,12 @@ var TLogView = (0, import_vue22.defineComponent)({
         }));
       }
       const count = lineCount();
-      const base = props.style ?? defaultStyle.value;
-      const baseStyleKey = styleCacheKey(base);
       const previewWidth = normalizeSearchResultPreviewWidth(options?.previewWidth);
       const contextCells = normalizeSearchResultContextCells(options?.contextCells);
       return searchMatches.slice(offset, offset + limit).map((match2, index) => ({
         matchIndex: offset + index,
         match: copySearchMatch(match2),
-        preview: previewForMatch(match2, count, base, baseStyleKey, {
+        preview: previewForMatch(match2, count, {
           previewWidth,
           contextCells
         })