mixdog 0.9.64 → 0.9.66

package/src/tui/markdown/stream-fence.mjs

@@ -55,6 +55,8 @@ export function trimPartialClosingFences(tokens) {
  */
 const OPEN_FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
 const CLOSE_FENCE_RE = /^ {0,3}([`~]+)[ \t]*$/;
+const OPEN_FENCE_SCAN_LRU_MAX = 32;
+const openFenceScanByStreamKey = new Map();
 
 function isClosingFence(line, char, openLen) {
   const m = CLOSE_FENCE_RE.exec(line);
@@ -66,12 +68,14 @@ function isClosingFence(line, char, openLen) {
   return run.startsWith(char.repeat(openLen));
 }
 
-export function findOpenFenceStart(text) {
-  const value = String(text ?? '');
-  let open = null;
-  let start = 0;
-  for (let i = 0; i <= value.length; i++) {
+function scanOpenFence(value, startAt = 0, initialOpen = null) {
+  let open = initialOpen;
+  let start = startAt;
+  const checkpointIndex = value.lastIndexOf('\n') + 1;
+  let openBeforeCheckpoint = start === checkpointIndex ? open : null;
+  for (let i = startAt; i <= value.length; i++) {
     if (i !== value.length && value[i] !== '\n') continue;
+    if (start === checkpointIndex) openBeforeCheckpoint = open;
     const line = value.slice(start, i);
     if (!open) {
       const m = OPEN_FENCE_RE.exec(line);
@@ -88,7 +92,40 @@ export function findOpenFenceStart(text) {
     }
     start = i + 1;
   }
+  return { open, checkpointIndex, openBeforeCheckpoint };
+}
+
+function touchOpenFenceScan(key, entry) {
+  if (openFenceScanByStreamKey.has(key)) openFenceScanByStreamKey.delete(key);
+  openFenceScanByStreamKey.set(key, entry);
+  while (openFenceScanByStreamKey.size > OPEN_FENCE_SCAN_LRU_MAX) {
+    const oldest = openFenceScanByStreamKey.keys().next().value;
+    if (oldest === undefined) break;
+    openFenceScanByStreamKey.delete(oldest);
+  }
+}
+
+export function resetOpenFenceScan(streamKey) {
+  if (streamKey == null || streamKey === '') return;
+  openFenceScanByStreamKey.delete(String(streamKey));
+}
+
+export function resetAllOpenFenceScans() {
+  openFenceScanByStreamKey.clear();
+}
+
+export function findOpenFenceStart(text, streamKey = null) {
+  const value = String(text ?? '');
+  const key = streamKey == null || streamKey === '' ? null : String(streamKey);
+  const cached = key ? openFenceScanByStreamKey.get(key) : null;
+  if (cached?.text === value) return cached.result;
+  const scanned = cached && value.startsWith(cached.text)
+    ? scanOpenFence(value, cached.checkpointIndex, cached.openBeforeCheckpoint)
+    : scanOpenFence(value);
   // Only fast-path unambiguously top-level (column-0) fences.
-  if (!open || open.indent !== 0) return null;
-  return { index: open.index, lang: open.lang };
+  const result = !scanned.open || scanned.open.indent !== 0
+    ? null
+    : { index: scanned.open.index, lang: scanned.open.lang };
+  if (key) touchOpenFenceScan(key, { text: value, ...scanned, result });
+  return result;
 }

package/src/tui/markdown/streaming-markdown.mjs

@@ -4,10 +4,17 @@
  */
 import { marked } from 'marked';
 import { configureMarked, hasMarkdownSyntax } from './render-ansi.mjs';
-import { trimPartialClosingFences, findOpenFenceStart } from './stream-fence.mjs';
+import {
+  trimPartialClosingFences,
+  findOpenFenceStart,
+  resetAllOpenFenceScans,
+  resetOpenFenceScan,
+} from './stream-fence.mjs';
 import { displayWidth } from '../display-width.mjs';
 
 const stablePrefixByStreamKey = new Map();
+const markdownSyntaxByStreamKey = new Map();
+const plainWindowSyntaxByStreamKey = new Map();
 // Reuse the current normalized-text split across measure → render → harvest.
 const resolvedPartsByStreamKey = new Map();
 const STABLE_PREFIX_LRU_MAX = 32;
@@ -17,48 +24,92 @@ export function streamingLayoutText(text) {
   return String(text ?? '').replace(/^\n+|\n+$/g, '');
 }
 
-export function windowPlainStreamingText(text, columns, maxRows) {
+export function windowPlainStreamingText(text, columns, maxRows, streamKey = null) {
   const value = streamingLayoutText(text);
   const rowBudget = Math.max(0, Math.floor(Number(maxRows) || 0));
-  if (!value || rowBudget <= 0 || hasMarkdownSyntax(value)) return value;
-  const lines = value.split('\n');
+  const key = streamKey == null || streamKey === '' ? null : String(streamKey);
+  if (!value || rowBudget <= 0 || cachedStreamingHasMarkdownSyntax(
+    plainWindowSyntaxByStreamKey,
+    value,
+    key,
+  )) return value;
   const width = Math.max(1, Math.floor(Number(columns) || 80));
   let rows = 0;
-  let start = lines.length;
-  while (start > 0) {
-    const line = lines[start - 1];
+  let end = value.length;
+  let start = end;
+  while (end >= 0) {
+    const newline = value.lastIndexOf('\n', end - 1);
+    const lineStart = newline + 1;
+    const line = value.slice(lineStart, end);
     const lineRows = Math.max(1, Math.ceil(displayWidth(line) / width));
     if (rows > 0 && rows + lineRows > rowBudget) break;
     rows += lineRows;
-    start -= 1;
-    if (rows >= rowBudget) break;
+    start = lineStart;
+    if (rows >= rowBudget || newline < 0) break;
+    end = newline;
   }
-  return start > 0 ? lines.slice(start).join('\n') : value;
+  return start > 0 ? value.slice(start) : value;
 }
 
 function isWhitespaceOnlyText(text) {
   return !String(text ?? '').trim();
 }
 
-function touchStablePrefixKey(key, value) {
+function touchLruKey(cache, key, value) {
   if (!key) return;
-  if (stablePrefixByStreamKey.has(key)) stablePrefixByStreamKey.delete(key);
-  stablePrefixByStreamKey.set(key, value);
-  while (stablePrefixByStreamKey.size > STABLE_PREFIX_LRU_MAX) {
-    const oldest = stablePrefixByStreamKey.keys().next().value;
+  if (cache.has(key)) cache.delete(key);
+  cache.set(key, value);
+  while (cache.size > STABLE_PREFIX_LRU_MAX) {
+    const oldest = cache.keys().next().value;
     if (oldest === undefined) break;
-    stablePrefixByStreamKey.delete(oldest);
+    cache.delete(oldest);
   }
 }
 
+function touchStablePrefixKey(key, value) {
+  touchLruKey(stablePrefixByStreamKey, key, value);
+}
+
 function getStablePrefixKey(key) {
-  if (!key || !stablePrefixByStreamKey.has(key)) return '';
+  if (!key || !stablePrefixByStreamKey.has(key)) return { text: '', chunks: [] };
   const value = stablePrefixByStreamKey.get(key);
-  stablePrefixByStreamKey.delete(key);
-  stablePrefixByStreamKey.set(key, value);
+  touchStablePrefixKey(key, value);
   return value;
 }
 
+function stableStateForText(text, previous) {
+  if (!text) return { text: '', chunks: [] };
+  if (text.startsWith(previous.text)) {
+    const appended = text.substring(previous.text.length);
+    return appended
+      ? { text, chunks: [...previous.chunks, appended] }
+      : previous;
+  }
+  return { text, chunks: [text] };
+}
+
+function cachedStreamingHasMarkdownSyntax(cache, text, key) {
+  if (!key) return hasMarkdownSyntax(text);
+  const previous = cache.get(key);
+  let value;
+  if (previous && text.startsWith(previous.text)) {
+    if (previous.value) {
+      value = true;
+    } else {
+      const lineStart = previous.text.lastIndexOf('\n') + 1;
+      value = hasMarkdownSyntax(text.substring(Math.max(0, lineStart - 1)));
+    }
+  } else {
+    value = hasMarkdownSyntax(text);
+  }
+  touchLruKey(cache, key, { text, value });
+  return value;
+}
+
+function streamingHasMarkdownSyntax(text, key) {
+  return cachedStreamingHasMarkdownSyntax(markdownSyntaxByStreamKey, text, key);
+}
+
 function getResolvedPartsKey(key, text) {
   if (!key) return null;
   const entry = resolvedPartsByStreamKey.get(key);
@@ -136,12 +187,18 @@ export function resetStreamingMarkdownStablePrefix(streamKey) {
   if (streamKey == null || streamKey === '') return;
   const key = String(streamKey);
   stablePrefixByStreamKey.delete(key);
+  markdownSyntaxByStreamKey.delete(key);
+  plainWindowSyntaxByStreamKey.delete(key);
   resolvedPartsByStreamKey.delete(key);
+  resetOpenFenceScan(key);
 }
 
 export function resetAllStreamingMarkdownStablePrefixes() {
   stablePrefixByStreamKey.clear();
+  markdownSyntaxByStreamKey.clear();
+  plainWindowSyntaxByStreamKey.clear();
   resolvedPartsByStreamKey.clear();
+  resetAllOpenFenceScans();
 }
 
 export function resolveStreamingMarkdownParts(text, streamKey) {
@@ -155,42 +212,47 @@ export function resolveStreamingMarkdownParts(text, streamKey) {
     return cacheResolvedPartsKey(key, t, {
       plain: true,
       stablePrefix: '',
+      stableChunks: [],
       unstableSuffix: '',
       unstableForRender: '',
     });
   }
 
-  if (!hasMarkdownSyntax(t)) {
+  if (!streamingHasMarkdownSyntax(t, key)) {
     if (key) stablePrefixByStreamKey.delete(key);
     return cacheResolvedPartsKey(key, t, {
       plain: true,
       stablePrefix: '',
+      stableChunks: [],
       unstableSuffix: t,
       unstableForRender: t,
     });
   }
 
-  let stablePrefix = key ? getStablePrefixKey(key) : '';
-  if (!t.startsWith(stablePrefix)) {
-    stablePrefix = '';
+  let stableState = key ? getStablePrefixKey(key) : { text: '', chunks: [] };
+  if (!t.startsWith(stableState.text)) {
+    stableState = { text: '', chunks: [] };
   }
+  let stablePrefix = stableState.text;
 
   // Open-fence fast path: never run marked.lexer on a growing unclosed code
   // block (its closing-fence regex never matches and backtracks over the whole
   // body every delta — the ~56ms/frame cost). Split cheaply at the fence line:
   // everything before it is settled markdown (lexed + cached once by the stable
   // <Markdown>), the open block is rendered flat until the closing fence lands.
-  const open = findOpenFenceStart(t);
+  const open = findOpenFenceStart(t, key);
   if (open) {
     let openPrefix = t.substring(0, open.index);
     if (isWhitespaceOnlyText(openPrefix)) openPrefix = '';
-    if (key && openPrefix) touchStablePrefixKey(key, openPrefix);
+    stableState = stableStateForText(openPrefix, stableState);
+    if (key && openPrefix) touchStablePrefixKey(key, stableState);
     else if (key) stablePrefixByStreamKey.delete(key);
     const unstableSuffix = t.substring(openPrefix.length);
     return cacheResolvedPartsKey(key, t, {
       plain: false,
       openFence: true,
       stablePrefix: openPrefix,
+      stableChunks: stableState.chunks,
       unstableSuffix,
       unstableForRender: unstableSuffix,
     });
@@ -214,20 +276,26 @@ export function resolveStreamingMarkdownParts(text, streamKey) {
     if (advance > 0) {
       stablePrefix = t.substring(0, boundary + advance);
       if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = '';
-      if (key && stablePrefix) touchStablePrefixKey(key, stablePrefix);
+      stableState = stableStateForText(stablePrefix, stableState);
+      if (key && stablePrefix) touchStablePrefixKey(key, stableState);
       else if (key && !stablePrefix) stablePrefixByStreamKey.delete(key);
     }
   } catch {
     stablePrefix = '';
+    stableState = { text: '', chunks: [] };
     if (key) stablePrefixByStreamKey.delete(key);
   }
 
-  if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = '';
+  if (isWhitespaceOnlyText(stablePrefix)) {
+    stablePrefix = '';
+    stableState = { text: '', chunks: [] };
+  }
 
   const unstableSuffix = t.substring(stablePrefix.length);
   return cacheResolvedPartsKey(key, t, {
     plain: false,
     stablePrefix,
+    stableChunks: stableState.chunks,
     unstableSuffix,
     unstableForRender: balanceStreamingMarkdown(unstableSuffix),
   });

package/src/ui/stream-finalize.mjs

@@ -0,0 +1,45 @@
+import { visibleWidth } from './ansi.mjs';
+
+/**
+ * Build a conservative in-place final-format patch for a streamed terminal
+ * block. Logical rows must map 1:1 to physical rows; wrapped or structurally
+ * changed output returns null so the caller can use the full-redraw fallback.
+ */
+export function buildStreamFinalPatch(rawText, renderedText, { columns = 80 } = {}) {
+  const raw = String(rawText ?? '');
+  const rendered = String(renderedText ?? '');
+  if (raw.includes('\r') || rendered.includes('\r')) return null;
+  const rawLines = raw.split('\n');
+  const renderedLines = rendered.split('\n');
+  if (rawLines.length !== renderedLines.length) return null;
+
+  const width = Math.max(1, Math.floor(Number(columns) || 80));
+  for (let index = 0; index < rawLines.length; index += 1) {
+    if (visibleWidth(rawLines[index]) >= width || visibleWidth(renderedLines[index]) >= width) {
+      return null;
+    }
+  }
+
+  const changedRows = [];
+  for (let index = 0; index < rawLines.length; index += 1) {
+    if (rawLines[index] !== renderedLines[index]) changedRows.push(index);
+  }
+  if (changedRows.length === 0) {
+    return { output: '', changedRows: 0, totalRows: rawLines.length };
+  }
+
+  let output = '\r';
+  for (let index = rawLines.length - 1; index >= 0; index -= 1) {
+    if (rawLines[index] !== renderedLines[index]) {
+      output += `\x1b[2K${renderedLines[index]}`;
+    }
+    if (index > 0) output += '\r\x1b[1A';
+  }
+  if (rawLines.length > 1) {
+    output += `\r\x1b[${rawLines.length - 1}B`;
+    const lastWidth = visibleWidth(renderedLines.at(-1) || '');
+    if (lastWidth > 0) output += `\x1b[${lastWidth}C`;
+  }
+
+  return { output, changedRows: changedRows.length, totalRows: rawLines.length };
+}