From 6ca128eec8eeb14bfddde298180f2a39f92bde33 Mon Sep 17 00:00:00 2001
From: Pyseph <45090858+Pyseph@users.noreply.github.com>
Date: Wed, 4 Nov 2026 16:48:53 +0100
Subject: [PATCH] perf(mobile): convert only the changed block of a streaming
 assistant message

A streamed reply re-ran the whole Markdown-to-native conversion on every update. While a message is streaming, split its text at blank lines that close every open block, keep the previous update's converted blocks, and convert only the blocks that changed. Finished text, every other consumer and text with syntax that ties blocks together keep the whole-text conversion.
---
 .../src/features/threads/ThreadFeed.tsx       |   5 +
 apps/mobile/src/lib/markdownDocument.ts       |  43 ++-
 .../src/lib/markdownStreamBlocks.test.ts      | 306 ++++++++++++++++++
 apps/mobile/src/lib/markdownStreamBlocks.ts   | 234 ++++++++++++++
 .../src/native/EnrichedMarkdownText.tsx       |  40 ++-
 .../native/SelectableMarkdownText.types.ts    |   2 +
 6 files changed, 597 insertions(+), 33 deletions(-)
 create mode 100644 apps/mobile/src/lib/markdownStreamBlocks.test.ts
 create mode 100644 apps/mobile/src/lib/markdownStreamBlocks.ts

diff --git a/apps/mobile/src/features/threads/ThreadFeed.tsx b/apps/mobile/src/features/threads/ThreadFeed.tsx
index 1abfb6061a6bb..adc6fbb80bc86 100644
--- a/apps/mobile/src/features/threads/ThreadFeed.tsx
+++ b/apps/mobile/src/features/threads/ThreadFeed.tsx
@@ -1191,6 +1191,7 @@ const AssistantMarkdownContent = memo(function AssistantMarkdownContent(props: {
   readonly onUseArtifactTemplate?: ((template: CodexArtifactTemplate) => void) | undefined;
   readonly renderImage: MarkdownImageRenderer;
   readonly skills?: ReadonlyArray<SelectableMarkdownSkill> | undefined;
+  readonly streaming?: boolean | undefined;
 }) {
   const liveMarkdown = useLiveThreadLinkLabels(props.markdown, props.environmentId);
   const threadIcons = useThreadChipIcons(props.environmentId, liveMarkdown);
@@ -1208,6 +1209,7 @@ const AssistantMarkdownContent = memo(function AssistantMarkdownContent(props: {
       onUseArtifactTemplate={props.onUseArtifactTemplate}
       renderImage={props.renderImage}
       skills={props.skills}
+      streaming={props.streaming}
     />
   );
 });
@@ -1220,6 +1222,7 @@ function AssistantMarkdownBlocks(props: {
   readonly onUseArtifactTemplate?: ((template: CodexArtifactTemplate) => void) | undefined;
   readonly renderImage: MarkdownImageRenderer;
   readonly skills?: ReadonlyArray<SelectableMarkdownSkill> | undefined;
+  readonly streaming?: boolean | undefined;
 }) {
   const blocks = useMemo(
     () =>
@@ -1262,6 +1265,7 @@ function AssistantMarkdownBlocks(props: {
           textStyle={props.markdownStyles.nativeTextStyle}
           {...props.linkHandlers}
           renderImage={props.renderImage}
+          streaming={props.streaming}
         />
       );
     });
@@ -2266,6 +2270,7 @@ function renderFeedEntry(
               onUseArtifactTemplate={props.onUseArtifactTemplate}
               renderImage={props.renderMarkdownImage}
               skills={props.skills}
+              streaming={message.streaming}
             />
           </MarkdownImageAvailableWidthContext>
         ) : null}
diff --git a/apps/mobile/src/lib/markdownDocument.ts b/apps/mobile/src/lib/markdownDocument.ts
index 6e5bc86cf771d..0274b3454d90b 100644
--- a/apps/mobile/src/lib/markdownDocument.ts
+++ b/apps/mobile/src/lib/markdownDocument.ts
@@ -287,25 +287,35 @@ export function markdownWithHtml(markdown: string): string {
 // Start only at the beginning of a backtick run to avoid retrying every suffix.
 const INLINE_CODE_SPAN = /(?<!`)`+([^`\r\n]+)`+/g;
 
-export function markdownWithInlineFileLinks(markdown: string, fileLink: RegExp): string {
-  return transformNativeMarkdown(markdown, fileLink, false);
+/**
+ * File links are rewritten only when some inline-code span of the document looks like a path.
+ * That is a decision about the whole document, so a caller converting it in pieces passes it on.
+ */
+export function markdownMayLinkFiles(markdown: string, fileLink: RegExp): boolean {
+  for (const [, code] of markdown.matchAll(INLINE_CODE_SPAN)) {
+    if (fileLink.test(code!.trim())) return true;
+  }
+  return false;
+}
+
+export function markdownWithInlineFileLinks(
+  markdown: string,
+  fileLink: RegExp,
+  linkFiles?: boolean,
+): string {
+  return transformNativeMarkdown(markdown, fileLink, false, linkFiles);
 }
 
 function transformNativeMarkdown(
   markdown: string,
   fileLink: RegExp | undefined,
   tableBreaks: boolean,
+  linkFilesOverride?: boolean,
 ): string {
   const breakTables = tableBreaks && mayHaveTableUnderText(markdown);
-  let linkFiles = false;
-  if (fileLink) {
-    for (const [, code] of markdown.matchAll(INLINE_CODE_SPAN)) {
-      if (fileLink.test(code!.trim())) {
-        linkFiles = true;
-        break;
-      }
-    }
-  }
+  const linkFiles = fileLink
+    ? (linkFilesOverride ?? markdownMayLinkFiles(markdown, fileLink))
+    : false;
   if (!linkFiles && !breakTables) return markdown;
   const edits: MarkdownEdit[] = [];
   const fileEdits: MarkdownEdit[] = [];
@@ -441,7 +451,16 @@ export function parseMarkdownDocument(markdown: string): Root {
 }
 
 export function markdownForNativeRendering(markdown: string, fileLink: RegExp): string {
-  return transformNativeMarkdown(markdownForNativeParsing(markdown), fileLink, true);
+  return markdownRenderParsed(markdownForNativeParsing(markdown), fileLink);
+}
+
+/** What `markdownForNativeRendering` does after `markdownForNativeParsing`. */
+export function markdownRenderParsed(
+  parsed: string,
+  fileLink: RegExp,
+  linkFiles?: boolean,
+): string {
+  return transformNativeMarkdown(parsed, fileLink, true, linkFiles);
 }
 
 /** Native media slots only cover standalone images; nested file embeds must become links. */
diff --git a/apps/mobile/src/lib/markdownStreamBlocks.test.ts b/apps/mobile/src/lib/markdownStreamBlocks.test.ts
new file mode 100644
index 0000000000000..bdc0f94661420
--- /dev/null
+++ b/apps/mobile/src/lib/markdownStreamBlocks.test.ts
@@ -0,0 +1,306 @@
+import { describe, expect, it } from "vite-plus/test";
+import { ENRICHED_INLINE_FILE_LINK_REGEX } from "./enrichedLinkPresentation";
+import {
+  markdownForNativeParsing,
+  markdownForNativeRendering,
+  markdownWithFileEmbeds,
+  markdownWithInlineFileLinks,
+  markdownWithTableBreaks,
+} from "./markdownDocument";
+import {
+  convertNativeMarkdown,
+  convertStreamingMarkdown,
+  createNativeMarkdownBlockCache,
+  nativeMarkdownPipeline,
+  splitMarkdownStreamBlocks,
+  type NativeMarkdownPipeline,
+  type NativeMarkdownRender,
+} from "./markdownStreamBlocks";
+
+const label = (href: string, standalone: boolean) =>
+  /\.png$/.test(href) ? `${standalone ? "S" : "N"}:${href}` : null;
+const owners = [
+  { name: "plain", owner: undefined },
+  { name: "embed", owner: label },
+] as const;
+
+const sameRender = (a: NativeMarkdownRender, b: NativeMarkdownRender) =>
+  a.markdown === b.markdown && [...a.fileHrefs].toString() === [...b.fileHrefs].toString();
+
+/** What the component does while a reply streams. */
+function stream(
+  text: string,
+  owner: typeof label | undefined,
+  cache = createNativeMarkdownBlockCache(),
+  pipeline: NativeMarkdownPipeline = nativeMarkdownPipeline(owner),
+): NativeMarkdownRender | null {
+  return convertStreamingMarkdown(text, owner, cache, true, pipeline, 0);
+}
+
+// Every prefix of `text`, through one cache, must convert like the whole text (or be refused).
+function expectPrefixesMatch(name: string, text: string) {
+  for (const { owner } of owners) {
+    const cache = createNativeMarkdownBlockCache();
+    for (let end = 0; end <= text.length; end += 1) {
+      const prefix = text.slice(0, end);
+      const streamed = stream(prefix, owner, cache);
+      if (streamed === null) continue;
+      const expected = convertNativeMarkdown(prefix, owner);
+      expect(streamed.markdown, `${name}@${end}`).toBe(expected.markdown);
+      expect([...streamed.fileHrefs], `${name}@${end}`).toEqual([...expected.fileHrefs]);
+    }
+  }
+}
+
+const fence =
+  "```ts\nexport function f(x: Array<string>) {\n  return `a/b.ts`;\n\n  // blank\n}\n```";
+const samples: Record<string, string> = {
+  prose: "Intro with `src/a.ts:12` and Array<string>.\n\nSecond paragraph.\n\nThird.",
+  fences: `Before\n\n${fence}\n\nAfter \`src/b.ts\`\n\n\`\`\`\nunclosed <div>\n\nstill code`,
+  list: "- one `src/a.ts`\n- two\n\n- loose\n\n  continued\n\n  ```sh\n  echo <x>\n\n  more\n  ```\n- last\n\nend",
+  quote: "> quoted `x/y.ts`\n>\n> more\n\n> next quote\n\ntail",
+  tables: "Text\n| a | b |\n| - | - |\n| `src/a\\|b.ts` | 2 |\n\nmid\n\n| c |\n| - |\n| d |",
+  html: 'Use <b>bold</b> and <a href="https://e.com">link</a><br>x\n\nArray<string> and 1 < 2\n\nend',
+  images: "![a](pic.png) and ![b](https://e.com/z.jpg)\n\n![c](d.png)\n\ntext",
+  windows:
+    String.raw`[w](C:\work\.t3\f.md)` + "\n\nplain `src/q.ts`\n\n" + String.raw`[v](<C:\a b\c.md>)`,
+  setext: "Title\n===\n\nbody\n\n---\n\nmore",
+  indented: "para\n\n    code <b>\n\n    more\n\nafter",
+};
+
+// Each of these made a block-by-block conversion differ from the whole-text one in an earlier
+// design, so they are kept as named cases.
+const pitfalls: Record<string, string> = {
+  tripleBacktickProse:
+    "To open a fence, type ``` on its own line; see `src/a.ts` for details.\n\nAlso check `src/b.ts`.\n\nDone.",
+  literalBacktick:
+    "Escape a backtick with `` ` `` as in `src/a.ts`.\n\nSee also `src/b.ts`.\n\nDone.",
+  wrappedCodeSpan: "Run `vp test\nrun` on `src/a.ts`.\n\nSee also `src/b.ts`.\n\nDone.",
+  brOpensFence: "text<br>```ts\nconst a = 1;\n\nnext `src/a.ts`\n\nlast",
+  pOpensFence: "x <p>```\n\nfoo `src/a.ts`\n\nlast",
+  removedTagJoinsBackticks: "``<script>``` \n\n`src/z.ts`\n\nlast",
+  fakeFenceInfo: "```a`b\nnot a fence `src/q.ts` text\n\nnext",
+  linkRewriteOpensFence: "```ts`src/a.ts`\n\n![z](z.png)\n\nlast",
+  quoteDefinition: "> [ref]: https://u.com\n\nSee [`src/a.ts`][ref] here\n\nlast",
+  listDefinition: "- [ref]: https://u.com\n\nSee [`src/a.ts`][ref] here\n\nlast",
+  multiLineDefinition: "See [`src/a.ts`][foo bar] here\n\n[foo\nbar]: https://u.com\n\nlast",
+  imageDefinition: "![r][im]\n\n> [im]: x.png\n\nlast",
+  htmlDefinition: "A [`src/a.ts`][ref]\n\ny <p>[ref]: https://u.com\n\nz",
+  footnote: "Note[^1]\n\nmore\n\n[^1]: the note",
+  definition: "See [x][ref] and [`a/b.ts`][ref]\n\nmore\n\n[ref]: https://example.com",
+  htmlBlock: "<details>\n<summary>S</summary>\n\nBody `src/z.ts`\n\n</details>\n\nafter",
+  htmlBlockInList: "- <![CDATA[\n\t\n`C:\\x\\y.ts`<br/>",
+  nbspCloser: "```\ncode\n```\u00a0\n\nafter `src/a.ts`\n\nmore",
+  nbspBlank: 'see <a href="https://e.com">foo\n\u00a0\nbar</a> end\n\nnext',
+  bomAtStart: "\ufeff```\ncode\n\nafter `src/a.ts`\n\nlast",
+  bomLater: "a\n\n\ufeff`a/b.ts:3`\n\nlast",
+  crlf: "a\r\n\r\nb `src/a.ts`\r\n\r\nc",
+};
+
+describe("convertNativeMarkdown", () => {
+  // The conversion the feed ran before the streaming path existed, written out from its passes.
+  it("is the whole-text pipeline: parse, file links, file embeds, table breaks", () => {
+    for (const sample of [...Object.values(samples), ...Object.values(pitfalls)]) {
+      expect(convertNativeMarkdown(sample, undefined).markdown).toBe(
+        markdownForNativeRendering(sample, ENRICHED_INLINE_FILE_LINK_REGEX),
+      );
+      const content = markdownWithInlineFileLinks(
+        markdownForNativeParsing(sample),
+        ENRICHED_INLINE_FILE_LINK_REGEX,
+      );
+      const files = markdownWithFileEmbeds(content, label);
+      const expected = markdownWithTableBreaks(files.markdown);
+      const actual = convertNativeMarkdown(sample, label);
+      expect(actual.markdown).toBe(expected);
+      expect([...actual.fileHrefs]).toEqual([...files.fileHrefs]);
+    }
+  });
+});
+
+describe("convertStreamingMarkdown", () => {
+  it("converts every prefix of a stream like the whole text, reusing one cache", () => {
+    for (const [name, sample] of Object.entries({ ...samples, ...pitfalls }))
+      expectPrefixesMatch(name, sample);
+  });
+
+  it("converts a file link in a block that has no path of its own like the whole text does", () => {
+    // The whole text links files because one span looks like a path; every block must follow.
+    for (const name of ["tripleBacktickProse", "literalBacktick", "wrappedCodeSpan"] as const) {
+      const text = pitfalls[name]!;
+      const streamed = stream(text, label);
+      expect(streamed, name).not.toBeNull();
+      expect(streamed!.markdown, name).toBe(convertNativeMarkdown(text, label).markdown);
+    }
+  });
+
+  it("refuses text whose blocks can depend on each other", () => {
+    for (const name of [
+      "quoteDefinition",
+      "listDefinition",
+      "multiLineDefinition",
+      "imageDefinition",
+      "htmlDefinition",
+      "footnote",
+      "definition",
+      "htmlBlock",
+      "htmlBlockInList",
+      "bomAtStart",
+      "bomLater",
+      "crlf",
+      "linkRewriteOpensFence",
+      "fakeFenceInfo",
+    ] as const)
+      expect(splitMarkdownStreamBlocks(pitfalls[name]!), name).toBeNull();
+    for (const name of ["brOpensFence", "pOpensFence", "removedTagJoinsBackticks"] as const)
+      expect(stream(pitfalls[name]!, label), name).toBeNull();
+  });
+
+  it("treats only spaces and tabs as blank", () => {
+    expect(splitMarkdownStreamBlocks("a\n\u00a0\nb\n\nc")).toEqual(["a\n\u00a0\nb\n\n", "c"]);
+  });
+
+  it("never splits text that is not streaming", () => {
+    const cache = createNativeMarkdownBlockCache();
+    const text = "First\n\nSecond\n\nThird";
+    expect(stream(text, label, cache)).not.toBeNull();
+    expect(
+      convertStreamingMarkdown(text, label, cache, false, nativeMarkdownPipeline(label), 0),
+    ).toBeNull();
+    expect(cache.blocks.size).toBe(0);
+  });
+
+  it("leaves short text to the whole-text conversion", () => {
+    const text = "a\n\nb";
+    expect(
+      convertStreamingMarkdown(
+        text,
+        label,
+        createNativeMarkdownBlockCache(),
+        true,
+        nativeMarkdownPipeline(label),
+      ),
+    ).toBeNull();
+  });
+
+  it("converts only blocks that changed", () => {
+    const parsed: string[] = [];
+    const base = nativeMarkdownPipeline(label);
+    const counting: NativeMarkdownPipeline = {
+      ...base,
+      parse: (block) => {
+        parsed.push(block);
+        return base.parse(block);
+      },
+    };
+    const cache = createNativeMarkdownBlockCache();
+    const text = "First `src/a.ts`\n\nSecond block\n\nThird";
+    stream(text, label, cache, counting);
+    expect(parsed).toHaveLength(3);
+    parsed.length = 0;
+    const next = stream(`${text} grows`, label, cache, counting)!;
+    expect(parsed).toEqual(["Third grows"]);
+    expect(sameRender(next, convertNativeMarkdown(`${text} grows`, label))).toBe(true);
+  });
+
+  it("drops cached blocks when the owner changes", () => {
+    const cache = createNativeMarkdownBlockCache();
+    const text = "One `src/a.ts`\n\nTwo";
+    const first = stream(text, label, cache)!;
+    const other = (href: string, standalone: boolean) => `X${label(href, standalone) ?? ""}`;
+    const second = stream(text, other as typeof label, cache)!;
+    expect(sameRender(first, convertNativeMarkdown(text, label))).toBe(true);
+    expect(sameRender(second, convertNativeMarkdown(text, other as typeof label))).toBe(true);
+  });
+
+  it("re-renders every block when the first file path shows up late", () => {
+    const cache = createNativeMarkdownBlockCache();
+    const early = "Escape a backtick with `` ` `` as in `src/a.ts`.\n\nMore.\n\nAnd more.";
+    const late = `${early}\n\nSee \`src/b.ts\`.`;
+    const before = stream(early, label, cache)!;
+    expect(before.markdown).toBe(convertNativeMarkdown(early, label).markdown);
+    expect(before.markdown).not.toContain("[src/a.ts]");
+    const after = stream(late, label, cache)!;
+    expect(after.markdown).toBe(convertNativeMarkdown(late, label).markdown);
+    expect(after.markdown).toContain("[src/a.ts](<src/a.ts>)");
+  });
+});
+
+// A small seeded fuzz: sub-line tokens joined into documents, compared cold and at every prefix.
+describe("differential against whole-text conversion", () => {
+  const tokens = [
+    "\n",
+    "\n\n",
+    "\n\n",
+    "\n \n",
+    "```",
+    "```ts",
+    "~~~",
+    "    ",
+    "- ",
+    "1. ",
+    "> ",
+    "`src/a.ts`",
+    "`x`",
+    "``",
+    "`",
+    "[`src/a.ts`][r]",
+    "![x](p.png)",
+    "[r]: p.png",
+    "arr[i]: v",
+    "<br>",
+    "<p>",
+    "<div>",
+    "<!-- c -->",
+    '<img src="q.png">',
+    '<a href="https://e.com">',
+    "</a>",
+    "|a|b|",
+    "|-|-|",
+    "| `src/a\\|b.ts` | c |",
+    "---",
+    "# ",
+    "x",
+    "word ",
+    " ",
+    "**",
+    "\u00a0",
+    "[^1]",
+    String.raw`[w](C:\work\f.md)`,
+    "`C:\\x\\y.ts`",
+    "\\`",
+  ];
+  it("matches on generated documents, whole and at every prefix", () => {
+    let seed = 7;
+    const random = () => (seed = (seed * 1664525 + 1013904223) >>> 0) / 2 ** 32;
+    for (let count = 0; count < 250; count += 1) {
+      const parts = Array.from(
+        { length: 3 + Math.floor(random() * 10) },
+        () => tokens[Math.floor(random() * tokens.length)]!,
+      );
+      parts.push("\n\n", "`src/z.ts`");
+      expectPrefixesMatch(`doc${count}`, parts.join(""));
+    }
+  });
+});
+
+describe("splitMarkdownStreamBlocks", () => {
+  it("splits at blank lines that close every open block and joins back exactly", () => {
+    for (const sample of Object.values(samples)) {
+      const blocks = splitMarkdownStreamBlocks(sample);
+      expect(blocks?.join("")).toBe(sample);
+    }
+    expect(splitMarkdownStreamBlocks(samples.prose!)).toHaveLength(3);
+    expect(splitMarkdownStreamBlocks(samples.list!)?.[0]).toContain("- last");
+  });
+
+  it("keeps a fenced code block, blank lines and all, in one piece", () => {
+    const blocks = splitMarkdownStreamBlocks(`Before\n\n${fence}\n\nAfter`);
+    expect(blocks).toEqual(["Before\n\n", `${fence}\n\n`, "After"]);
+  });
+
+  it("does not look inside a fenced code block for syntax that ties blocks together", () => {
+    expect(
+      splitMarkdownStreamBlocks("```ts\ntype T = { [k: string]: number };\n<View />\n```\n\nafter"),
+    ).toHaveLength(2);
+  });
+});
diff --git a/apps/mobile/src/lib/markdownStreamBlocks.ts b/apps/mobile/src/lib/markdownStreamBlocks.ts
new file mode 100644
index 0000000000000..d1b49a3a70ffb
--- /dev/null
+++ b/apps/mobile/src/lib/markdownStreamBlocks.ts
@@ -0,0 +1,234 @@
+import { ENRICHED_INLINE_FILE_LINK_REGEX } from "./enrichedLinkPresentation";
+import {
+  markdownForNativeParsing,
+  markdownForNativeRendering,
+  markdownMayLinkFiles,
+  markdownRenderParsed,
+  markdownWithFileEmbeds,
+  markdownWithInlineFileLinks,
+  markdownWithTableBreaks,
+} from "./markdownDocument";
+
+export interface NativeMarkdownRender {
+  readonly markdown: string;
+  readonly fileHrefs: ReadonlySet<string>;
+}
+
+type FileEmbedLabel = (href: string, standalone: boolean) => string | null;
+
+/** The conversion every Markdown view applies to its whole text before the native view draws it. */
+export function convertNativeMarkdown(
+  markdown: string,
+  fileEmbedLabel: FileEmbedLabel | undefined,
+): NativeMarkdownRender {
+  if (!fileEmbedLabel) {
+    return {
+      markdown: markdownForNativeRendering(markdown, ENRICHED_INLINE_FILE_LINK_REGEX),
+      fileHrefs: new Set<string>(),
+    };
+  }
+  const content = markdownWithInlineFileLinks(
+    markdownForNativeParsing(markdown),
+    ENRICHED_INLINE_FILE_LINK_REGEX,
+  );
+  const files = markdownWithFileEmbeds(content, fileEmbedLabel);
+  return { ...files, markdown: markdownWithTableBreaks(files.markdown) };
+}
+
+/**
+ * `convertNativeMarkdown` cut in two at the one decision it takes for the whole document
+ * (whether file links are rewritten), so a piece of the text can be converted on its own.
+ */
+export interface NativeMarkdownPipeline {
+  /** The passes that come before the file-link decision. */
+  parse(block: string): string;
+  /** Whether the parsed block holds an inline-code span that may become a file link. */
+  mayLinkFiles(parsed: string): boolean;
+  /** The remaining passes, given the decision for the whole document. */
+  render(parsed: string, linkFiles: boolean): NativeMarkdownRender;
+}
+
+export function nativeMarkdownPipeline(
+  fileEmbedLabel: FileEmbedLabel | undefined,
+): NativeMarkdownPipeline {
+  return {
+    parse: markdownForNativeParsing,
+    mayLinkFiles: (parsed) => markdownMayLinkFiles(parsed, ENRICHED_INLINE_FILE_LINK_REGEX),
+    render: (parsed, linkFiles) => {
+      if (!fileEmbedLabel) {
+        return {
+          markdown: markdownRenderParsed(parsed, ENRICHED_INLINE_FILE_LINK_REGEX, linkFiles),
+          fileHrefs: new Set<string>(),
+        };
+      }
+      const content = markdownWithInlineFileLinks(
+        parsed,
+        ENRICHED_INLINE_FILE_LINK_REGEX,
+        linkFiles,
+      );
+      const files = markdownWithFileEmbeds(content, fileEmbedLabel);
+      return { ...files, markdown: markdownWithTableBreaks(files.markdown) };
+    },
+  };
+}
+
+// Ties blocks together: a reference definition (`]:`, even in a quote or list or over several
+// lines) that any block may use, or an HTML block that runs past a blank line.
+const UNSAFE_LINE = /\]:|^[ \t>]*(?:(?:[-*+]|\d{1,9}[.)])[ \t]+[ \t>]*)*<[A-Za-z!?/]/;
+// The parser drops a byte-order mark, which would shift every offset after it.
+const BYTE_ORDER_MARK = String.fromCharCode(0xfeff);
+// CommonMark blank lines hold only spaces and tabs; `trim()` would also accept NBSP and friends.
+const BLANK_LINE = /^[ \t]*$/;
+const FENCE_PATTERN = /^ {0,3}(`{3,}|~{3,})/;
+const FENCE_CLOSER = /^ {0,3}(`{3,}|~{3,})[ \t]*$/;
+// After a blank line these still continue the previous block: a list item or indented content.
+const CONTINUATION_PATTERN = /^(?:[ \t]|(?:[-*+]|\d{1,9}[.)])(?:[ \t]|$))/;
+
+/** Shorter text converts in a few milliseconds, so it keeps the plain whole-text conversion. */
+export const NATIVE_MARKDOWN_BLOCK_MIN_LENGTH = 2048;
+
+function fenceOpener(line: string): string | undefined {
+  const opener = FENCE_PATTERN.exec(line)?.[1];
+  // A backtick fence cannot have a backtick in its info string, so that line is inline code.
+  if (opener && opener[0] === "`" && line.indexOf("`", line.indexOf(opener) + opener.length) !== -1)
+    return undefined;
+  return opener;
+}
+
+/**
+ * Cuts Markdown at blank lines that close every open block, so each piece converts the way it
+ * does inside the whole text. Returns null when the text has syntax that can tie blocks together.
+ */
+export function splitMarkdownStreamBlocks(text: string): string[] | null {
+  if (text.includes("\r") || text.includes(BYTE_ORDER_MARK) || text.includes("\0")) return null;
+  const blocks: string[] = [];
+  let blockStart = 0;
+  let lineStart = 0;
+  let fence: string | null = null;
+  let fenceIndent = 0;
+  let afterBlankLine = false;
+  for (const line of text.split("\n")) {
+    const opener = fenceOpener(line);
+    // Backticks in the info string make this inline code, but rewriting that code into a file
+    // link removes them and turns the line into a fence for the passes that follow.
+    if (fence === null && !opener && FENCE_PATTERN.test(line)) return null;
+    // An indented fence may belong to a list item, so only a top-level fence hides its lines.
+    if ((fence === null || fenceIndent > 0) && UNSAFE_LINE.test(line)) return null;
+    if (fence !== null) {
+      // A line left of an indented fence may end the list item holding it, which isn't tracked.
+      if (/\S/.test(line.slice(0, fenceIndent))) return null;
+      if (
+        opener &&
+        opener[0] === fence[0] &&
+        opener.length >= fence.length &&
+        FENCE_CLOSER.test(line)
+      ) {
+        fence = null;
+      }
+    } else if (BLANK_LINE.test(line)) {
+      afterBlankLine = true;
+    } else {
+      if (afterBlankLine && lineStart > blockStart && !CONTINUATION_PATTERN.test(line)) {
+        blocks.push(text.slice(blockStart, lineStart));
+        blockStart = lineStart;
+      }
+      afterBlankLine = false;
+      fence = opener ?? null;
+      if (opener) fenceIndent = line.indexOf(opener);
+    }
+    lineStart += line.length + 1;
+  }
+  blocks.push(text.slice(blockStart));
+  return blocks;
+}
+
+function splitsAsParsed(parsed: readonly string[]): boolean {
+  const resplit = splitMarkdownStreamBlocks(parsed.join(""));
+  return (
+    resplit !== null &&
+    resplit.length === parsed.length &&
+    resplit.every((block, index) => block === parsed[index])
+  );
+}
+
+interface BlockEntry {
+  readonly parsed: string;
+  readonly mayLinkFiles: boolean;
+  // Indexed by the file-link decision for the whole document.
+  readonly renders: [NativeMarkdownRender | undefined, NativeMarkdownRender | undefined];
+}
+
+/** Converted blocks of the previous update, valid for one `owner` (the file-embed callback). */
+export interface NativeMarkdownBlockCache {
+  owner: unknown;
+  blocks: Map<string, BlockEntry>;
+}
+
+export function createNativeMarkdownBlockCache(): NativeMarkdownBlockCache {
+  return { owner: undefined, blocks: new Map() };
+}
+
+/**
+ * Converts text that is still streaming one block at a time and reuses every block that did not
+ * change since the previous call, so an update converts only its last block. Returns null when
+ * the caller must convert the whole text: the text is not streaming, is short, or has syntax that
+ * can tie blocks together. Finished text therefore always gets the whole-text conversion.
+ */
+export function convertStreamingMarkdown(
+  markdown: string,
+  owner: unknown,
+  cache: NativeMarkdownBlockCache,
+  streaming: boolean,
+  pipeline: NativeMarkdownPipeline,
+  minLength: number = NATIVE_MARKDOWN_BLOCK_MIN_LENGTH,
+): NativeMarkdownRender | null {
+  const blocks =
+    streaming && markdown.length >= minLength ? splitMarkdownStreamBlocks(markdown) : null;
+  if (!blocks || blocks.length < 2) {
+    cache.blocks = new Map();
+    return null;
+  }
+  if (cache.owner !== owner) {
+    cache.owner = owner;
+    cache.blocks = new Map();
+  }
+  const previous = cache.blocks;
+  const next = new Map<string, BlockEntry>();
+  let linkFiles = false;
+  let rewritten = false;
+  for (const block of blocks) {
+    let entry = next.get(block) ?? previous.get(block);
+    if (!entry) {
+      const parsed = pipeline.parse(block);
+      entry = {
+        parsed,
+        mayLinkFiles: pipeline.mayLinkFiles(parsed),
+        renders: [undefined, undefined],
+      };
+    }
+    next.set(block, entry);
+    rewritten ||= entry.parsed !== block;
+    // The whole text links files when any of its spans looks like a path, so all blocks must.
+    linkFiles ||= entry.mayLinkFiles;
+  }
+  // Rewriting HTML can join or break lines (`<br>`, `<p>`, a removed tag between two backticks),
+  // which can open a fence or end a block. The later passes parse the rewritten text, so it has
+  // to split at the same places.
+  if (rewritten && !splitsAsParsed(blocks.map((block) => next.get(block)!.parsed))) {
+    cache.blocks = next;
+    return null;
+  }
+  const parts: string[] = [];
+  let fileHrefs: Set<string> | undefined;
+  for (const block of blocks) {
+    const entry = next.get(block)!;
+    const result = (entry.renders[+linkFiles] ??= pipeline.render(entry.parsed, linkFiles));
+    parts.push(result.markdown);
+    if (result.fileHrefs.size > 0) {
+      fileHrefs ??= new Set();
+      for (const href of result.fileHrefs) fileHrefs.add(href);
+    }
+  }
+  cache.blocks = next;
+  return { markdown: parts.join(""), fileHrefs: fileHrefs ?? new Set() };
+}
diff --git a/apps/mobile/src/native/EnrichedMarkdownText.tsx b/apps/mobile/src/native/EnrichedMarkdownText.tsx
index 6fa8c229a9539..46c37df0ceae0 100644
--- a/apps/mobile/src/native/EnrichedMarkdownText.tsx
+++ b/apps/mobile/src/native/EnrichedMarkdownText.tsx
@@ -5,12 +5,11 @@ import {
   formatComposerContextReference,
 } from "@t3tools/shared/composerContextReferences";
 import {
-  markdownForNativeRendering,
-  markdownWithFileEmbeds,
-  markdownForNativeParsing,
-  markdownWithInlineFileLinks,
-  markdownWithTableBreaks,
-} from "../lib/markdownDocument";
+  convertNativeMarkdown,
+  convertStreamingMarkdown,
+  createNativeMarkdownBlockCache,
+  nativeMarkdownPipeline,
+} from "../lib/markdownStreamBlocks";
 import { isValidElement, useMemo, useState, type ReactNode } from "react";
 import { Platform, Share, StyleSheet, useWindowDimensions, View } from "react-native";
 import {
@@ -27,7 +26,6 @@ import { useEnrichedLinkVariants } from "./useEnrichedLinkVariants";
 import { useRetryingImageSource } from "./useRetryingImageSource";
 import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
 import {
-  ENRICHED_INLINE_FILE_LINK_REGEX,
   enrichedSkillLinkRegex,
   enrichedLinkVariantPattern,
 } from "../lib/enrichedLinkPresentation";
@@ -164,20 +162,20 @@ function enrichedStyle(
 export function MobileEnrichedMarkdownText(props: SelectableMarkdownTextProps) {
   const { renderImage, resolveImageSource, fileEmbedLabel } = props;
   const { themeAppearance, mathRenderingEnabled } = useAppearancePreferences();
-  const { markdown, fileHrefs } = useMemo(() => {
-    if (!fileEmbedLabel) {
-      return {
-        markdown: markdownForNativeRendering(props.markdown, ENRICHED_INLINE_FILE_LINK_REGEX),
-        fileHrefs: new Set<string>(),
-      };
-    }
-    const content = markdownWithInlineFileLinks(
-      markdownForNativeParsing(props.markdown),
-      ENRICHED_INLINE_FILE_LINK_REGEX,
-    );
-    const files = markdownWithFileEmbeds(content, fileEmbedLabel);
-    return { ...files, markdown: markdownWithTableBreaks(files.markdown) };
-  }, [props.markdown, fileEmbedLabel]);
+  // A streaming reply grows at its end, so its earlier blocks keep their conversion.
+  const [blockCache] = useState(createNativeMarkdownBlockCache);
+  const streaming = props.streaming === true;
+  const { markdown, fileHrefs } = useMemo(
+    () =>
+      convertStreamingMarkdown(
+        props.markdown,
+        fileEmbedLabel,
+        blockCache,
+        streaming,
+        nativeMarkdownPipeline(fileEmbedLabel),
+      ) ?? convertNativeMarkdown(props.markdown, fileEmbedLabel),
+    [props.markdown, fileEmbedLabel, streaming, blockCache],
+  );
   const [parsedLinkUrls, setParsedLinkUrls] = useState<ReadonlyArray<string>>([]);
   const onLinksChange = (links: MarkdownLinkOccurrence[]) => {
     const urls = [...new Set(links.map((link) => link.url))];
diff --git a/apps/mobile/src/native/SelectableMarkdownText.types.ts b/apps/mobile/src/native/SelectableMarkdownText.types.ts
index 686007015268b..308cd34e16698 100644
--- a/apps/mobile/src/native/SelectableMarkdownText.types.ts
+++ b/apps/mobile/src/native/SelectableMarkdownText.types.ts
@@ -67,6 +67,8 @@ export interface SelectableMarkdownTextProps {
   readonly textStyle: NativeMarkdownTextStyle;
   readonly skills?: ReadonlyArray<SelectableMarkdownSkill>;
   readonly preserveSoftBreaks?: boolean;
+  /** The text is still arriving, so it may convert block by block. Finished text converts whole. */
+  readonly streaming?: boolean | undefined;
   readonly onLinkPress?: (href: string) => void;
   readonly fileContextMenu?: (href: string) => MarkdownFileContextMenu | undefined;
   readonly onFileContextMenuAction?: (href: string, actionId: string) => void;