Merge pull request #1540 from corbitsdev/cl-10819-streaming-retext-on-main

perf(tui): stop rejoining streaming markdown on every retext

Author: TheGreatAxios

src/tui/code-links.ts

@@ -406,13 +406,46 @@ export function armMarkdownLinks(
   };
 }
 
+const armedChildIdentity = new WeakMap<Renderable, readonly Renderable[]>();
+let codeLinkWalkCount = 0;
+
+/** Subtree walks `armCodeLinks` actually performed. Same child nodes do not count. */
+export function codeLinkArmWalks(): number {
+  return codeLinkWalkCount;
+}
+
+function sameChildIdentity(
+  previous: readonly Renderable[],
+  next: readonly Renderable[],
+): boolean {
+  if (previous.length !== next.length) return false;
+  for (let i = 0; i < previous.length; i += 1) {
+    if (previous[i] !== next[i]) return false;
+  }
+  return true;
+}
+
 /**
  * Fenced code is a Code renderable without markdown's link callbacks.
  * `onHighlight` keeps the tree-sitter groups; `onChunks` is `detectLinks`,
  * so a bare URL becomes an OSC-8 span and survives native wrap. Markdown
  * prose already sets both — do not replace those, or conceal regresses.
+ * OpenTUI can swap the only block for a new CodeRenderable without growing
+ * the child count, so the walk follows child identity, not the count. A
+ * list box can also stay the same object while a fence is inserted under
+ * it; that new code node still needs the walk.
  */
 export function armCodeLinks(node: Renderable): void {
+  const children = node.getChildren();
+  const previous = armedChildIdentity.get(node);
+  if (
+    previous !== undefined &&
+    sameChildIdentity(previous, children) &&
+    !hasUnarmedCode(node)
+  ) {
+    return;
+  }
+  codeLinkWalkCount += 1;
   const walk = (current: Renderable): void => {
     if (current instanceof CodeRenderable) {
       if (current.onHighlight === undefined) {
@@ -425,4 +458,19 @@ export function armCodeLinks(node: Renderable): void {
     for (const child of current.getChildren()) walk(child);
   };
   walk(node);
+  armedChildIdentity.set(node, children);
+}
+
+/** True when a code node under `node` was created without link callbacks. */
+function hasUnarmedCode(node: Renderable): boolean {
+  if (
+    node instanceof CodeRenderable &&
+    (node.onHighlight === undefined || node.onChunks === undefined)
+  ) {
+    return true;
+  }
+  for (const child of node.getChildren()) {
+    if (hasUnarmedCode(child)) return true;
+  }
+  return false;
 }

src/tui/markdown-parser.test.ts

@@ -1,12 +1,16 @@
 import { describe, expect, test } from "bun:test";
 import {
+  clearMarkdownParseInputCache,
   nextStreamMarkdownState,
   parseMarkdown,
+  settledBlockFullSplits,
   splitAtSettledBlock,
   splitAtSettledHeading,
   withholdIncompleteHeading,
   type StyledSegment,
 } from "./markdown-parser.js";
+import { setTheme } from "./theme.js";
+import "./stream.js";
 
 function firstLine(text: string): StyledSegment[] {
   return parseMarkdown(text)[0] ?? [];
@@ -579,6 +583,78 @@ describe("splitAtSettledBlock", () => {
       expect(splitAtSettledBlock(text)).toEqual(splitAtSettledHeading(text));
     }
   });
+
+  test("an unchanged body does not split or join again", () => {
+    clearMarkdownParseInputCache();
+    const text = "### Title\n\n```bash\necho hi\n```\n\ntail";
+    const before = settledBlockFullSplits();
+    const first = splitAtSettledBlock(text, 40);
+    const second = splitAtSettledBlock(text, 40);
+    expect(second).toBe(first);
+    expect(second?.frozen).toBe(first?.frozen);
+    expect(settledBlockFullSplits() - before).toBe(1);
+  });
+
+  test("an append keeps the frozen string and skips another full-body join", () => {
+    clearMarkdownParseInputCache();
+    const base = "### Title\n\n```bash\necho hi\n```\n\ntail";
+    const first = splitAtSettledBlock(base, 40);
+    const before = settledBlockFullSplits();
+    const next = splitAtSettledBlock(`${base} more`, 40);
+    expect(next?.frozen).toBe(first?.frozen);
+    expect(next?.live).toBe("tail more");
+    expect(next?.gapRows).toBe(1);
+    expect(settledBlockFullSplits() - before).toBe(0);
+  });
+
+  test("appended chunks match a full split at every prefix", () => {
+    clearMarkdownParseInputCache();
+    const chunks = [
+      "### Title",
+      "\n\n",
+      "hello",
+      " world",
+      "\n\n```bash\n",
+      "echo hi\n",
+      "```\n\n",
+      "tail",
+      " more",
+      "\n\n| a | b |\n|---|---|\n| 1 | 2 |\n\n",
+      "after",
+      "\n\n## Next\n\n",
+      "done",
+    ];
+    let body = "";
+    chunks.forEach((chunk, index) => {
+      body += chunk;
+      const fast = splitAtSettledBlock(body, 48);
+      // A fresh width has no append chain, so this walk is the full split.
+      const full = splitAtSettledBlock(body, -(index + 1));
+      expect(fast).toEqual(full);
+    });
+    clearMarkdownParseInputCache();
+    const rewritten = "### Title\n\nrewritten tail";
+    expect(splitAtSettledBlock(rewritten, 48)).toEqual(
+      splitAtSettledBlock(rewritten, -2),
+    );
+  });
+
+  test("a theme change drops the parse-input cache", () => {
+    const text = "### T\n\nhello";
+    try {
+      setTheme("corbits-dark");
+      clearMarkdownParseInputCache();
+      splitAtSettledBlock(text, 12);
+      const before = settledBlockFullSplits();
+      splitAtSettledBlock(text, 12);
+      expect(settledBlockFullSplits() - before).toBe(0);
+      setTheme("corbits-light");
+      splitAtSettledBlock(text, 12);
+      expect(settledBlockFullSplits() - before).toBe(1);
+    } finally {
+      setTheme("corbits-dark");
+    }
+  });
 });
 
 describe("nextStreamMarkdownState", () => {

src/tui/markdown-parser.ts

@@ -1,4 +1,5 @@
 import { highlightCode } from "./syntax-highlight.js";
+import { onThemeChange } from "./theme.js";
 import { wrapRanges, stringWidth } from "./view/height.js";
 
 export interface StyledSegment {
@@ -742,8 +743,106 @@ export function splitAtSettledHeading(text: string): MarkdownSplit | null {
  * heading checks stay in that order so a settled block can freeze while the
  * tail is still streaming. An unclosed fence consumes to the end; blank lines
  * before the tail collapse to one.
+ *
+ * Repeat calls keep the previous frozen string object. An unchanged body
+ * returns the cached split; an append reuses that frozen reference and only
+ * rebuilds the live tail. The cache stores those parse inputs (text, width),
+ * not painted nodes, and drops them when the theme changes.
  */
-export function splitAtSettledBlock(withheld: string): MarkdownSplit | null {
+const PARSE_INPUT_CACHE_LIMIT = 32;
+
+interface SettledSplitEntry {
+  input: string;
+  width: number;
+  split: MarkdownSplit | null;
+  restStart: number;
+}
+
+const parseInputCache: SettledSplitEntry[] = [];
+let settledBlockFullSplitCount = 0;
+
+/** Full-body split walks since process start. Appends and cache hits do not count. */
+export function settledBlockFullSplits(): number {
+  return settledBlockFullSplitCount;
+}
+
+/** Drop cached parse inputs. Theme changes call this; the strings are not styled. */
+export function clearMarkdownParseInputCache(): void {
+  parseInputCache.length = 0;
+}
+
+onThemeChange(() => {
+  clearMarkdownParseInputCache();
+});
+
+function rememberSplit(
+  entry: SettledSplitEntry,
+  drop?: SettledSplitEntry,
+): void {
+  if (drop !== undefined) {
+    const index = parseInputCache.indexOf(drop);
+    if (index >= 0) parseInputCache.splice(index, 1);
+  }
+  parseInputCache.push(entry);
+  if (parseInputCache.length > PARSE_INPUT_CACHE_LIMIT) parseInputCache.shift();
+}
+
+function findCachedSplit(
+  text: string,
+  width: number,
+): SettledSplitEntry | undefined {
+  for (let i = parseInputCache.length - 1; i >= 0; i--) {
+    const entry = parseInputCache[i];
+    if (entry === undefined || entry.width !== width || entry.input !== text) {
+      continue;
+    }
+    if (i !== parseInputCache.length - 1) {
+      parseInputCache.splice(i, 1);
+      parseInputCache.push(entry);
+    }
+    return entry;
+  }
+  return undefined;
+}
+
+function findAppendBase(
+  text: string,
+  width: number,
+): SettledSplitEntry | undefined {
+  for (let i = parseInputCache.length - 1; i >= 0; i--) {
+    const entry = parseInputCache[i];
+    if (entry === undefined || entry.width !== width || entry.split === null) {
+      continue;
+    }
+    if (text.length <= entry.input.length || !text.startsWith(entry.input)) {
+      continue;
+    }
+    return entry;
+  }
+  return undefined;
+}
+
+function restStartFor(withheld: string, split: MarkdownSplit | null): number {
+  if (split === null || !withheld.startsWith(split.frozen)) return 0;
+  const end = split.frozen.length;
+  return end < withheld.length && withheld[end] === "\n" ? end + 1 : end;
+}
+
+function firstContentOffset(text: string): number {
+  let start = 0;
+  for (let i = 0; i <= text.length; i++) {
+    if (i !== text.length && text[i] !== "\n") continue;
+    if (text.slice(start, i).trim().length > 0) return start;
+    start = i + 1;
+  }
+  return text.length;
+}
+
+function computeSettledSplit(
+  withheld: string,
+  account: boolean,
+): { split: MarkdownSplit | null; restStart: number } {
+  if (account) settledBlockFullSplitCount += 1;
   const lines = withheld.split("\n");
   const boundaries = new Set<number>();
   let i = 0;
@@ -803,13 +902,78 @@ export function splitAtSettledBlock(withheld: string): MarkdownSplit | null {
     const rest = lines.slice(boundary + 1);
     const firstContent = rest.findIndex((entry) => entry.trim().length > 0);
     if (firstContent === -1) continue;
-    return settledSplit(
+    const split = settledSplit(
       lines.slice(0, boundary + 1).join("\n"),
       rest,
       firstContent,
     );
+    return { split, restStart: restStartFor(withheld, split) };
+  }
+  return { split: null, restStart: 0 };
+}
+
+function tryExtendSplit(
+  prev: SettledSplitEntry,
+  withheld: string,
+  width: number,
+): SettledSplitEntry | undefined {
+  const split = prev.split;
+  if (split === null || !withheld.startsWith(split.frozen)) return undefined;
+  const candidateLive = split.live + withheld.slice(prev.input.length);
+  const moved = computeSettledSplit(candidateLive, false);
+  if (moved.split === null) {
+    return {
+      input: withheld,
+      width,
+      split: {
+        frozen: split.frozen,
+        live: candidateLive,
+        gapRows: split.gapRows,
+      },
+      restStart: prev.restStart,
+    };
+  }
+  const tail = withheld.slice(prev.restStart);
+  const at = firstContentOffset(tail);
+  const marker = moved.split.frozen;
+  if (!tail.startsWith(marker, at)) return undefined;
+  const frozenEnd = prev.restStart + at + marker.length;
+  const frozen = withheld.slice(0, frozenEnd);
+  const next: MarkdownSplit = {
+    frozen,
+    live: moved.split.live,
+    gapRows: moved.split.gapRows,
+  };
+  return {
+    input: withheld,
+    width,
+    split: next,
+    restStart: restStartFor(withheld, next),
+  };
+}
+
+export function splitAtSettledBlock(
+  withheld: string,
+  width = 0,
+): MarkdownSplit | null {
+  const cached = findCachedSplit(withheld, width);
+  if (cached) return cached.split;
+  const base = findAppendBase(withheld, width);
+  if (base) {
+    const extended = tryExtendSplit(base, withheld, width);
+    if (extended) {
+      rememberSplit(extended, base);
+      return extended.split;
+    }
   }
-  return null;
+  const computed = computeSettledSplit(withheld, true);
+  rememberSplit({
+    input: withheld,
+    width,
+    split: computed.split,
+    restStart: computed.restStart,
+  });
+  return computed.split;
 }
 
 /** Paint state for one streaming markdown row across repaints. */
@@ -833,6 +997,8 @@ export function nextStreamMarkdownState(
 ): { state: StreamMarkdownSnapshot; paintFrozen: boolean } {
   const state: StreamMarkdownSnapshot = { content, frozen, width, streaming };
   if (prev === null) return { state, paintFrozen: true };
+  // Frozen text is the cached string object, so an unchanged boundary does
+  // not compare a freshly joined copy of the prefix.
   const paintFrozen =
     prev.frozen !== frozen ||
     prev.width !== width ||

src/tui/shell/chrome.ts

@@ -139,6 +139,8 @@ import {
   labelBefore,
   noteAgentVoice,
   retextStreamRow,
+  transcriptLaidOutRow,
+  transcriptLaidOutRowCount,
   transcriptMarker,
   transcriptRowChildren,
   transcriptRowLayout,
@@ -1353,16 +1355,17 @@ export function replaceStreamRowAt(
   if (local < 0 || local >= shell.streamLog.length) return;
   shell.streamLog[local] = row;
 
-  const children = transcriptRowChildren(shell);
-  // A raw appendTranscript line breaks the 1:1 node↔row mapping; fall back to
-  // a full repaint, which derives every node from the log.
-  if (children.length !== shell.streamLog.length) {
+  // Index the content list directly. `getChildren()` copies every row to
+  // find this one, and an in-place retext never needs that copy. A raw
+  // appendTranscript line breaks the 1:1 node-row mapping; fall back to a
+  // full repaint, which derives every node from the log.
+  if (transcriptLaidOutRowCount(shell) !== shell.streamLog.length) {
     repaintTranscriptWindow(shell);
     paintChrome(shell);
     return;
   }
 
-  const stale = children[local];
+  const stale = transcriptLaidOutRow(shell, local);
   if (stale && retextStreamRow(shell, stale, row, labelBefore(shell, local))) {
     paintChrome(shell);
     return;