fix(tui): arm a fence that replaces a prose block

A same-count block swap can introduce a new code node. Follow child
identity so that fence still gets link callbacks, and skip the walk
only when those nodes are unchanged.

Author: TheGreatAxios

src/tui/code-links.ts

@@ -406,28 +406,37 @@ export function armMarkdownLinks(
   };
 }
 
-const armedChildCounts = new WeakMap<Renderable, number>();
+const armedChildIdentity = new WeakMap<Renderable, readonly Renderable[]>();
 let codeLinkWalkCount = 0;
 
-/** Subtree walks `armCodeLinks` actually performed. Equal child counts do not count. */
+/** 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.
- * A retext whose child count did not grow has no new code block to arm.
+ * OpenTUI can swap the only block for a new CodeRenderable without growing
+ * the child count, so the walk follows child identity, not the count.
  */
 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;
-  }
+  const children = node.getChildren();
+  const previous = armedChildIdentity.get(node);
+  if (previous !== undefined && sameChildIdentity(previous, children)) return;
   codeLinkWalkCount += 1;
   const walk = (current: Renderable): void => {
     if (current instanceof CodeRenderable) {
@@ -441,5 +450,5 @@ export function armCodeLinks(node: Renderable): void {
     for (const child of current.getChildren()) walk(child);
   };
   walk(node);
-  armedChildCounts.set(node, count);
+  armedChildIdentity.set(node, children);
 }

src/tui/stream-retext-work.test.ts

@@ -3,6 +3,7 @@
  * copy the transcript child list to find the open row.
  */
 import { describe, expect, test } from "bun:test";
+import { CodeRenderable, type BaseRenderable } from "@opentui/core";
 import { withTestRenderer } from "./harness";
 import { codeLinkArmWalks } from "./code-links";
 import { appendStreamRow, replaceStreamRowAt } from "./shell/chrome";
@@ -17,6 +18,16 @@ const SHELL_OPTS = {
 
 const SETTLED = "### Title\n\n```bash\necho hi\n```\n\ntail";
 
+function codeNodes(node: BaseRenderable): CodeRenderable[] {
+  const found: CodeRenderable[] = [];
+  const walk = (current: BaseRenderable): void => {
+    if (current instanceof CodeRenderable) found.push(current);
+    for (const child of current.getChildren()) walk(child);
+  };
+  walk(node);
+  return found;
+}
+
 describe("streaming retext work", () => {
   test("an in-place retext does not call getChildren to find the row", async () => {
     await withTestRenderer(
@@ -102,4 +113,38 @@ describe("streaming retext work", () => {
       { width: 80, height: 24 },
     );
   });
+
+  test("prose rewritten as one fenced URL block arms that code node", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, SHELL_OPTS);
+        try {
+          appendStreamRow(shell, {
+            role: "assistant",
+            streaming: true,
+            text: "hello",
+          });
+          await h.renderOnce();
+          const before = codeLinkArmWalks();
+          replaceStreamRowAt(shell, 0, {
+            role: "assistant",
+            streaming: true,
+            text: "```js\nhttps://example.com\n```",
+          });
+          const row = transcriptRowChildren(shell)[0];
+          if (row === undefined) throw new Error("row missing");
+          const codes = codeNodes(row);
+          expect(codes).toHaveLength(1);
+          const code = codes[0];
+          if (code === undefined) throw new Error("code node missing");
+          expect(code.onChunks).toBeDefined();
+          expect(code.onHighlight).toBeDefined();
+          expect(codeLinkArmWalks()).toBeGreaterThan(before);
+        } finally {
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
 });