mixdog 0.9.53 → 0.9.55

package/src/tui/input-editing.mjs

@@ -228,19 +228,39 @@ export function offsetAtCell(text, row, col, width) {
 
 function boundaryPositions(text, width) {
   const value = String(text || '');
-  const offsets = [0];
-  for (const unit of graphemeUnits(value)) offsets.push(unit.end);
-
-  const seen = new Set();
-  const positions = offsets
-    .filter((offset) => {
-      if (seen.has(offset)) return false;
-      seen.add(offset);
-      return true;
-    })
-    // Decide the flush-boundary advance from the FULL text so a soft-wrap
-    // offset reports {row N+1, col 0} (matching ink) instead of {row N, col w}.
-    .map((offset) => ({ offset, ...caretPosition(value, offset, width) }));
+  const w = safeWidth(width);
+  const units = graphemeUnits(value);
+  const positions = [{ offset: 0, row: 0, col: 0 }];
+  let row = 0;
+  let col = 0;
+
+  // Build every grapheme-boundary position in one pass. This is the same state
+  // transition as caretPosition(), but avoids re-segmenting and re-scanning the
+  // entire prefix for every candidate during mouse hit-testing.
+  for (let i = 0; i < units.length; i += 1) {
+    const { end, segment } = units[i];
+    if (segment === '\n') {
+      row += 1;
+      col = 0;
+    } else {
+      const segmentWidth = displayWidth(segment);
+      if (segmentWidth > 0) {
+        if (col > 0 && col + segmentWidth > w) {
+          row += 1;
+          col = 0;
+        }
+        col += segmentWidth;
+        // Decide the flush-boundary advance from the FULL text so a soft-wrap
+        // offset reports {row N+1, col 0} (matching ink), exactly as
+        // caretPosition(value, end, w) does when more content follows.
+        if (col === w && i < units.length - 1) {
+          row += 1;
+          col = 0;
+        }
+      }
+    }
+    positions.push({ offset: end, row, col });
+  }
   return positions;
 }
 

package/src/tui/markdown/measure-rendered-rows.mjs

@@ -7,6 +7,23 @@ import { assistantBodyWidth, measureMarkdownTableRows } from './table-layout.mjs
 import { renderTokenAnsiSegments } from './render-ansi.mjs';
 import { resolveStreamingMarkdownParts } from './streaming-markdown.mjs';
 
+// One latest measurement per live stream. The small LRU bound mirrors the
+// streaming-markdown split caches: completed/abandoned stream ids cannot make
+// this module retain an unbounded response history.
+const streamingRowsByKey = new Map();
+const STREAMING_ROWS_LRU_MAX = 32;
+
+function cacheStreamingRows(key, entry) {
+  if (!key) return;
+  if (streamingRowsByKey.has(key)) streamingRowsByKey.delete(key);
+  streamingRowsByKey.set(key, entry);
+  while (streamingRowsByKey.size > STREAMING_ROWS_LRU_MAX) {
+    const oldest = streamingRowsByKey.keys().next().value;
+    if (oldest === undefined) break;
+    streamingRowsByKey.delete(oldest);
+  }
+}
+
 function wrappedLineRows(line, width) {
   const text = String(line);
   const full = displayWidth(text);
@@ -62,17 +79,104 @@ export function measureMarkdownRenderedRows(text, columns, { trimPartialFences =
   return Math.max(1, rows);
 }
 
-export function measureStreamingMarkdownRenderedRows(text, columns, streamKey) {
+function measureStreamingPartsUncached(parts, columns) {
+  if (parts.plain) {
+    return estimateWrappedRowsFallback(parts.unstableForRender, columns, 3);
+  }
+  let rows = 0;
+  let childCount = 0;
+  if (parts.stablePrefix) {
+    rows += measureMarkdownRenderedRows(parts.stablePrefix, columns, { trimPartialFences: false });
+    childCount += 1;
+  }
+  if (parts.unstableSuffix) {
+    rows += measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
+    childCount += 1;
+  }
+  if (childCount === 2) rows += 1;
+  return childCount === 0 ? 1 : Math.max(1, rows);
+}
+
+// Test/reference path: resolve the same renderer split, but deliberately bypass
+// streamingRowsByKey and remeasure every rendered child from scratch.
+export function measureStreamingMarkdownRenderedRowsUncached(text, columns, streamKey) {
   const value = String(text ?? '');
   if (!value) return 1;
+  return measureStreamingPartsUncached(resolveStreamingMarkdownParts(value, streamKey), columns);
+}
+
+export function measureStreamingMarkdownRenderedRows(text, columns, streamKey) {
+  const value = String(text ?? '');
+  const key = streamKey == null || streamKey === '' ? null : String(streamKey);
+  const cached = key ? streamingRowsByKey.get(key) : null;
+  // Check the exact render inputs before even resolving markdown parts. App
+  // renders caused by typing or overlays therefore do no wrapping/token work
+  // when the live tail itself did not change.
+  if (cached && cached.text === value && cached.columns === columns) {
+    cacheStreamingRows(key, cached);
+    return cached.rows;
+  }
+  if (!value) {
+    cacheStreamingRows(key, {
+      text: value,
+      columns,
+      mode: 'empty',
+      rows: 1,
+    });
+    return 1;
+  }
   const parts = resolveStreamingMarkdownParts(value, streamKey);
   if (parts.plain) {
-    return estimateWrappedRowsFallback(parts.unstableForRender, columns, 3);
+    const plain = parts.unstableForRender;
+    const width = Math.max(8, Number(columns || 80) - 3);
+    const lastBreak = plain.lastIndexOf('\n');
+    const stablePrefix = lastBreak >= 0 ? plain.substring(0, lastBreak + 1) : '';
+    let stableRows = 0;
+    if (cached
+      && cached.mode === 'plain'
+      && cached.columns === columns
+      && stablePrefix.startsWith(cached.stablePrefix)) {
+      // Lines preceding the currently-growing final line wrap independently.
+      // Measure only complete lines added since the previous split.
+      const addedComplete = plain.substring(cached.stablePrefix.length, Math.max(cached.stablePrefix.length, lastBreak));
+      stableRows = cached.stableRows;
+      if (addedComplete) {
+        stableRows += addedComplete
+          .split('\n')
+          .reduce((sum, line) => sum + wrappedLineRows(line, width), 0);
+      }
+    } else if (lastBreak >= 0) {
+      stableRows = plain
+        .substring(0, lastBreak)
+        .split('\n')
+        .reduce((sum, line) => sum + wrappedLineRows(line, width), 0);
+    }
+    const finalLine = lastBreak >= 0 ? plain.substring(lastBreak + 1) : plain;
+    const rows = Math.max(1, stableRows + wrappedLineRows(finalLine, width));
+    cacheStreamingRows(key, {
+      text: value,
+      columns,
+      mode: 'plain',
+      stablePrefix,
+      stableRows,
+      rows,
+    });
+    return rows;
   }
   let rows = 0;
   let childCount = 0;
+  let stableRows = 0;
   if (parts.stablePrefix) {
-    rows += measureMarkdownRenderedRows(parts.stablePrefix, columns, { trimPartialFences: false });
+    // The renderer mounts stablePrefix and unstableSuffix as separate Markdown
+    // children. An unchanged stable child is therefore safe to reuse exactly;
+    // only the independently-rendered live suffix needs measuring on append.
+    stableRows = cached
+      && cached.mode === 'markdown'
+      && cached.columns === columns
+      && cached.stablePrefix === parts.stablePrefix
+      ? cached.stableRows
+      : measureMarkdownRenderedRows(parts.stablePrefix, columns, { trimPartialFences: false });
+    rows += stableRows;
     childCount += 1;
   }
   if (parts.unstableSuffix) {
@@ -80,6 +184,14 @@ export function measureStreamingMarkdownRenderedRows(text, columns, streamKey) {
     childCount += 1;
   }
   if (childCount === 2) rows += 1;
-  if (childCount === 0) return 1;
-  return Math.max(1, rows);
+  const measuredRows = childCount === 0 ? 1 : Math.max(1, rows);
+  cacheStreamingRows(key, {
+    text: value,
+    columns,
+    mode: 'markdown',
+    stablePrefix: parts.stablePrefix,
+    stableRows,
+    rows: measuredRows,
+  });
+  return measuredRows;
 }

package/vendor/ink/build/ink.js

@@ -403,7 +403,7 @@ export default class Ink {
     // [mixdog fork] Update the mouse drag-selection rectangle and repaint so the
     // inverse highlight tracks the drag. Called by the App's mouse handler.
     // A no-op-equal update is skipped to avoid redundant frames during motion.
-    setSelection = (rect, options = {}) => {
+    setSelection = (rect) => {
         const a = this.selectionRect;
         const same = a === rect ||
             (a && rect &&
@@ -417,21 +417,10 @@ export default class Ink {
                 a.captureText === rect.captureText &&
                 a.selectionForeground === rect.selectionForeground &&
                 a.selectionBackground === rect.selectionBackground);
-        if (same) {
-            if (!options.immediate) {
-                return;
-            }
-        }
-        else {
-            this.selectionRect = rect ?? null;
-        }
+        if (same)
+            return;
+        this.selectionRect = rect ?? null;
         if (!this.isUnmounted) {
-            if (options.immediate) {
-                this.selectionRepaintEpoch++;
-                this.selectionRepaintFlushPending = false;
-                this.rootNode.onImmediateRender();
-                return;
-            }
             this.scheduleSelectionRepaint();
         }
     };
@@ -456,7 +445,10 @@ export default class Ink {
             if (this.hasPendingThrottledRender) {
                 return;
             }
-            this.rootNode.onImmediateRender();
+            // Selection motion must share Ink's normal maxFps throttle; the old
+            // unthrottled callback regenerated a whole frame for every accepted
+            // drag update even though selection updates are coalesced.
+            this.rootNode.onRender();
         });
     };
     // [mixdog fork] Given a 0-based cell (x, y), return the inclusive rect of the