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

Frame retext was rebuilding the frozen prefix, walking every code
block, and copying the transcript child list even when the row only
grew at the tail.

Author: TheGreatAxios

src/tui/code-links.ts

@@ -406,13 +406,29 @@ export function armMarkdownLinks(
   };
 }
 
+const armedChildCounts = new WeakMap<Renderable, number>();
+let codeLinkWalkCount = 0;
+
+/** Subtree walks `armCodeLinks` actually performed. Equal child counts do not count. */
+export function codeLinkArmWalks(): number {
+  return codeLinkWalkCount;
+}
+
 /**
  * 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.
+ * A retext whose child count did not grow has no new code block to arm.
  */
 export function armCodeLinks(node: Renderable): void {
+  const count = node.getChildrenCount();
+  const previous = armedChildCounts.get(node);
+  if (previous !== undefined && count <= previous) {
+    if (count < previous) armedChildCounts.set(node, count);
+    return;
+  }
+  codeLinkWalkCount += 1;
   const walk = (current: Renderable): void => {
     if (current instanceof CodeRenderable) {
       if (current.onHighlight === undefined) {
@@ -425,4 +441,5 @@ export function armCodeLinks(node: Renderable): void {
     for (const child of current.getChildren()) walk(child);
   };
   walk(node);
+  armedChildCounts.set(node, count);
 }

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;