mixdog 0.9.65 → 0.9.66

package/src/tui/engine/frame-batched-store.mjs

@@ -12,6 +12,8 @@ export function createFrameBatchedStorePublisher({
   setTimer = setTimeout,
   clearTimer = clearTimeout,
   enqueueMicrotask = queueMicrotask,
+  scheduleFrame = (callback, delay) => setTimer(callback, delay),
+  cancelFrame = (handle) => clearTimer(handle),
 }) {
   let timer = null;
   let emitPending = false;
@@ -20,7 +22,7 @@ export function createFrameBatchedStorePublisher({
 
   const flush = () => {
     if (timer !== null) {
-      clearTimer(timer);
+      cancelFrame(timer);
       timer = null;
     }
     immediatePending = false;
@@ -43,7 +45,7 @@ export function createFrameBatchedStorePublisher({
   const emit = () => {
     emitPending = true;
     if (timer !== null || isDisposed()) return;
-    timer = setTimer(flush, frameMs);
+    timer = scheduleFrame(flush, frameMs);
     timer?.unref?.();
   };
 
@@ -64,7 +66,7 @@ export function createFrameBatchedStorePublisher({
     // Disposal is itself an immediate boundary: publish the final pending
     // snapshot once, while subscribers are still present, then disarm.
     if (emitPending && !isDisposed()) flush();
-    else if (timer !== null) clearTimer(timer);
+    else if (timer !== null) cancelFrame(timer);
     timer = null;
     emitPending = false;
     structureChangePending = false;

package/src/tui/engine/render-timing.mjs

@@ -20,11 +20,38 @@
 const RENDER_ACK_FALLBACK_MS = 32;
 const RENDER_ACK_HANG_GUARD_MS = 250;
 const RENDER_SETTLE_IDLE_MS = 64;
+export const TUI_RENDER_FPS = 60;
+// Ink uses Math.ceil(1000 / maxFps); share that exact cadence with the store.
+export const TUI_FRAME_MS = Math.ceil(1000 / TUI_RENDER_FPS);
 
 // Back-compat alias: previously the fixed wait duration, now the fallback only.
 
 let pendingRenderAcks = [];
 let renderAckSeq = 0;
+let lastRenderFrameAt = 0;
+
+export const renderFrameDelay = (
+  lastFrameAt,
+  currentTime,
+  frameMs = TUI_FRAME_MS,
+) => {
+  if (!(lastFrameAt > 0)) return frameMs;
+  return Math.max(0, frameMs - Math.max(0, currentTime - lastFrameAt));
+};
+
+export const scheduleRenderAlignedStoreFlush = (
+  callback,
+  frameMs = TUI_FRAME_MS,
+) => {
+  const timer = setTimeout(
+    callback,
+    renderFrameDelay(lastRenderFrameAt, performance.now(), frameMs),
+  );
+  timer.unref?.();
+  return timer;
+};
+
+export const cancelRenderAlignedStoreFlush = (timer) => clearTimeout(timer);
 
 /**
  * Called by the Ink onRender hook once per painted frame. The sequence is
@@ -38,6 +65,7 @@ export const scheduleRenderFrameAck = () => {
 };
 
 const notifyRenderFrame = (seq = ++renderAckSeq) => {
+  lastRenderFrameAt = performance.now();
   if (pendingRenderAcks.length === 0) return;
   const acks = pendingRenderAcks;
   pendingRenderAcks = [];

package/src/tui/engine/session-api-ext.mjs

@@ -745,6 +745,13 @@ export function createEngineApiB(bag) {
     listSessions: (options) => {
       return runtime.listSessions(options);
     },
+    // Desktop sidebar watcher hook: EngineHost fs.watches this directory so
+    // heartbeat sidecar create/delete pushes instant working/dot updates.
+    // Without it the watcher silently no-ops and the sidebar falls back to
+    // the 60s safety poll (user: spinner kept spinning after the turn ended).
+    sessionStoreDir: () => {
+      try { return runtime.sessionStoreDir?.() || null; } catch { return null; }
+    },
     deleteSession: async (id) => {
       if (getState().commandBusy) return false;
       const deletingCurrent = String(runtime.session?.id || getState().sessionId || '') === String(id || '');

package/src/tui/engine/tui-steering-persist.mjs

@@ -8,6 +8,11 @@ import { promptContentText } from './queue-helpers.mjs';
 
 const PENDING_MESSAGES_FILE = 'session-pending-messages.json';
 const PENDING_MESSAGES_MODE = 0o600;
+// Restore window for persisted busy-input steering rows. Rows older than this
+// are leftovers of a session that ended long ago — restoring them into a fresh
+// TUI boot reads as a surprise self-injection (user report), so they are
+// discarded at drain time instead.
+const STALE_STEERING_RESTORE_TTL_MS = 30 * 60 * 1000;
 
 // Serialize this UI process's own steering writes so append→drop→drain keep
 // their issue order even though each now waits on the lock asynchronously.
@@ -44,7 +49,9 @@ function normalizeTuiSteeringQueueEntry(entry) {
   if (typeof entry.text === 'string' && entry.text.trim()) {
     const text = entry.text.trim();
     const id = typeof entry.id === 'string' && entry.id.trim() ? entry.id.trim() : null;
-    return id ? { id, text } : text;
+    if (!id) return text;
+    const at = Number(entry.at);
+    return Number.isFinite(at) && at > 0 ? { id, text, at } : { id, text };
   }
   return null;
 }
@@ -116,7 +123,7 @@ export function appendTuiSteeringPersist(leadSessionId, entry) {
   const key = tuiSteeringSessionKey(leadSessionId);
   if (!key) return Promise.resolve();
   if (!entry.steeringPersistId) entry.steeringPersistId = newSteeringPersistId();
-  const record = { id: entry.steeringPersistId, text };
+  const record = { id: entry.steeringPersistId, text, at: Date.now() };
   return _serialize(async () => {
     try {
       await updateJsonAtomic(pendingMessagesPath(), (raw) => {
@@ -187,12 +194,23 @@ export function drainTuiSteeringPersist(leadSessionId) {
   if (!key) return Promise.resolve([]);
   return _serialize(async () => {
     let drained = [];
+    let droppedStale = 0;
     try {
       await updateJsonAtomic(pendingMessagesPath(), (raw) => {
         const next = normalizePendingStore(raw);
         const q = Array.isArray(next.sessions[key]) ? next.sessions[key] : [];
-        drained = q.map(drainedRowToRestore).filter(Boolean);
-        if (drained.length === 0) return undefined;
+        // Per-row timestamps age precisely; legacy rows without one age from
+        // the session key's last touch time.
+        const now = Date.now();
+        const touchedAt = Number(next.sessionTouchedAt?.[key]) || 0;
+        const fresh = q.filter((row) => {
+          const at = Number(row?.at) || touchedAt;
+          const stale = at > 0 && (now - at) > STALE_STEERING_RESTORE_TTL_MS;
+          if (stale) droppedStale += 1;
+          return !stale;
+        });
+        drained = fresh.map(drainedRowToRestore).filter(Boolean);
+        if (drained.length === 0 && droppedStale === 0) return undefined;
         delete next.sessions[key];
         if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
         next.updatedAt = Date.now();
@@ -201,6 +219,9 @@ export function drainTuiSteeringPersist(leadSessionId) {
     } catch (err) {
       try { process.stderr.write(`[tui] steering-queue drain failed sessionId=${leadSessionId}: ${err?.message || err}\n`); } catch {}
     }
+    if (droppedStale > 0) {
+      try { process.stderr.write(`[tui] dropped ${droppedStale} stale steering row(s) sessionId=${leadSessionId}\n`); } catch {}
+    }
     return drained;
   });
 }

package/src/tui/engine.mjs

@@ -77,7 +77,12 @@ import {
 import {
   resolveTuiRuntimeNotificationDelivery,
 } from './engine/notification-plan.mjs';
-import { yieldToRenderer } from './engine/render-timing.mjs';
+import {
+  TUI_FRAME_MS,
+  cancelRenderAlignedStoreFlush,
+  scheduleRenderAlignedStoreFlush,
+  yieldToRenderer,
+} from './engine/render-timing.mjs';
 import {
   aggregateRawResult,
   aggregateBucketForCategory,
@@ -273,6 +278,9 @@ export async function createEngineSession({
     },
     listeners,
     isDisposed: () => flags.disposed,
+    frameMs: TUI_FRAME_MS,
+    scheduleFrame: scheduleRenderAlignedStoreFlush,
+    cancelFrame: cancelRenderAlignedStoreFlush,
   });
   const emit = publisher.emit;
   const flushEmit = publisher.flush;

package/src/tui/index.jsx

@@ -14,7 +14,7 @@ import { format } from 'node:util';
 import { App } from './App.jsx';
 import { cancelPendingMouseTrackingRestores } from './app/use-mouse-input.mjs';
 import { createEngineSession } from './engine.mjs';
-import { scheduleRenderFrameAck } from './engine/render-timing.mjs';
+import { scheduleRenderFrameAck, TUI_RENDER_FPS } from './engine/render-timing.mjs';
 import { installProcessSignalCleanup } from '../runtime/shared/process-shutdown.mjs';
 import { finishProcessLifecycle } from '../runtime/shared/process-lifecycle.mjs';
 import { rgbSgr } from '../ui/ansi.mjs';
@@ -481,6 +481,12 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
 
   process.on('exit', restoreTerminal);
 
+  // Engine startup is independent from palette selection. Start it now and
+  // overlap its runtime import/config work with the theme read, while still
+  // awaiting the theme before the first React frame.
+  const storeOutcomePromise = createEngineSession({ provider, model, toolMode, remote })
+    .then((store) => ({ store, error: null }), (error) => ({ store: null, error }));
+
   // Apply the persisted UI theme (ui.theme in mixdog-config.json) before the
   // first React frame so the whole tree paints in the chosen palette. Unknown
   // or missing values leave the default Mixdog dark palette in place; a failed
@@ -496,7 +502,9 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
 
   let store;
   try {
-    store = await createEngineSession({ provider, model, toolMode, remote });
+    const outcome = await storeOutcomePromise;
+    if (outcome.error) throw outcome.error;
+    store = outcome.store;
     bootProfile('store:ready', { ms: (performance.now() - startedAt).toFixed(1) });
   } catch (error) {
     splash.stop();
@@ -590,7 +598,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     // its clear-frame → write → relative re-render dance, which scrolls the
     // alt screen one line per stray console line (the streaming newline
     // bounce). See installTuiConsoleGuard.
-    const instance = render(<App store={store} forceOnboarding={forceOnboarding === true} />, { exitOnCtrlC: false, maxFps: 60, incrementalRendering: true, patchConsole: false, onRender: makeRenderProfiler() });
+    const instance = render(<App store={store} forceOnboarding={forceOnboarding === true} />, { exitOnCtrlC: false, maxFps: TUI_RENDER_FPS, incrementalRendering: true, patchConsole: false, onRender: makeRenderProfiler() });
     bootProfile('render:mounted', { ms: (performance.now() - startedAt).toFixed(1) });
     const { waitUntilExit } = instance;
     // [mixdog fork] Hand the ink renderer's drag-selection setter to the store so

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

@@ -85,15 +85,19 @@ function measureStreamingPartsUncached(parts, columns) {
   }
   let rows = 0;
   let childCount = 0;
-  if (parts.stablePrefix) {
-    rows += measureMarkdownRenderedRows(parts.stablePrefix, columns, { trimPartialFences: false });
+  const stableChunks = parts.stableChunks?.length
+    ? parts.stableChunks
+    : parts.stablePrefix ? [parts.stablePrefix] : [];
+  for (const chunk of stableChunks) {
+    if (childCount > 0) rows += 1;
+    rows += measureMarkdownRenderedRows(chunk, columns, { trimPartialFences: false });
     childCount += 1;
   }
   if (parts.unstableSuffix) {
+    if (childCount > 0) rows += 1;
     rows += measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
     childCount += 1;
   }
-  if (childCount === 2) rows += 1;
   return childCount === 0 ? 1 : Math.max(1, rows);
 }
 
@@ -166,30 +170,38 @@ export function measureStreamingMarkdownRenderedRows(text, columns, streamKey) {
   let rows = 0;
   let childCount = 0;
   let stableRows = 0;
-  if (parts.stablePrefix) {
-    // 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;
+  const stableChunks = parts.stableChunks?.length
+    ? parts.stableChunks
+    : parts.stablePrefix ? [parts.stablePrefix] : [];
+  const reusableChunks = cached
+    && cached.mode === 'markdown'
+    && cached.columns === columns
+    && Array.isArray(cached.stableChunks)
+    && cached.stableChunks.length <= stableChunks.length
+    && cached.stableChunks.every((chunk, index) => chunk === stableChunks[index]);
+  let measuredStableChunks = 0;
+  if (reusableChunks) {
+    stableRows = cached.stableRows;
+    measuredStableChunks = cached.stableChunks.length;
+  }
+  for (let index = measuredStableChunks; index < stableChunks.length; index += 1) {
+    if (index > 0) stableRows += 1;
+    stableRows += measureMarkdownRenderedRows(stableChunks[index], columns, { trimPartialFences: false });
   }
+  rows += stableRows;
+  childCount = stableChunks.length;
   if (parts.unstableSuffix) {
+    if (childCount > 0) rows += 1;
     rows += measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
     childCount += 1;
   }
-  if (childCount === 2) rows += 1;
   const measuredRows = childCount === 0 ? 1 : Math.max(1, rows);
   cacheStreamingRows(key, {
     text: value,
     columns,
     mode: 'markdown',
     stablePrefix: parts.stablePrefix,
+    stableChunks: stableChunks.slice(),
     stableRows,
     rows: measuredRows,
   });

package/src/tui/markdown/render-ansi.mjs

@@ -16,9 +16,14 @@
 import { marked } from 'marked';
 import { formatToken } from './format-token.mjs';
 import { trimPartialClosingFences, findOpenFenceStart } from './stream-fence.mjs';
+import { getThemeVersion } from '../theme.mjs';
 
 const TOKEN_CACHE_MAX = 500;
 const tokenCache = new Map();
+const renderedSegmentCache = [];
+const RENDERED_SEGMENT_CACHE_MAX = 12;
+const RENDERED_SEGMENT_CACHE_MAX_CHARS = 256 * 1024;
+let renderedSegmentCacheChars = 0;
 const MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|^\d+\. |\n\d+\. /;
 
 let _configured = false;
@@ -99,8 +104,24 @@ function lexMarkdown(content, { trimPartialFences = false } = {}) {
  * Blank-edge-only ansi segments are dropped (mirrors the component's pushAnsi).
  */
 export function renderTokenAnsiSegments(content, opts = {}) {
-  const tokens = lexMarkdown(content, opts);
+  const text = String(content ?? '');
   const width = Number(opts.width) || 0;
+  const trimPartialFences = opts.trimPartialFences === true;
+  const themeVersion = getThemeVersion();
+  for (let index = renderedSegmentCache.length - 1; index >= 0; index -= 1) {
+    const entry = renderedSegmentCache[index];
+    if (
+      entry.text === text
+      && entry.width === width
+      && entry.trimPartialFences === trimPartialFences
+      && entry.themeVersion === themeVersion
+    ) {
+      renderedSegmentCache.splice(index, 1);
+      renderedSegmentCache.push(entry);
+      return entry.segments;
+    }
+  }
+  const tokens = lexMarkdown(text, opts);
   const segments = [];
   for (const token of tokens) {
     if (token.type === 'table') {
@@ -113,5 +134,17 @@ export function renderTokenAnsiSegments(content, opts = {}) {
       segments.push({ type: 'ansi', ansi, token });
     }
   }
+  if (text.length <= RENDERED_SEGMENT_CACHE_MAX_CHARS) {
+    const entry = { text, width, trimPartialFences, themeVersion, segments };
+    renderedSegmentCache.push(entry);
+    renderedSegmentCacheChars += text.length;
+    while (
+      renderedSegmentCache.length > RENDERED_SEGMENT_CACHE_MAX
+      || renderedSegmentCacheChars > RENDERED_SEGMENT_CACHE_MAX_CHARS
+    ) {
+      const removed = renderedSegmentCache.shift();
+      renderedSegmentCacheChars -= removed?.text.length || 0;
+    }
+  }
   return segments;
 }

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),
   });