diff --git a/apps/mobile/src/features/threads/ThreadFeed.tsx b/apps/mobile/src/features/threads/ThreadFeed.tsx
index e3e9e97e78510..174a7206dd985 100644
--- a/apps/mobile/src/features/threads/ThreadFeed.tsx
+++ b/apps/mobile/src/features/threads/ThreadFeed.tsx
@@ -1147,6 +1147,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 models = useModelMentions(props.environmentId, props.markdown);
   const liveMarkdown = useLiveThreadLinkLabels(props.markdown, props.environmentId);
@@ -1166,6 +1167,7 @@ const AssistantMarkdownContent = memo(function AssistantMarkdownContent(props: {
       renderImage={props.renderImage}
       skills={props.skills}
       models={models}
+      streaming={props.streaming}
     />
   );
 });
@@ -1179,6 +1181,7 @@ function AssistantMarkdownBlocks(props: {
   readonly renderImage: MarkdownImageRenderer;
   readonly skills?: ReadonlyArray<SelectableMarkdownSkill> | undefined;
   readonly models: ReturnType<typeof useModelMentions>;
+  readonly streaming?: boolean | undefined;
 }) {
   const blocks = useMemo(
     () =>
@@ -1222,6 +1225,7 @@ function AssistantMarkdownBlocks(props: {
           textStyle={props.markdownStyles.nativeTextStyle}
           {...props.linkHandlers}
           renderImage={props.renderImage}
+          streaming={props.streaming}
         />
       );
     });
@@ -2232,6 +2236,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 23f6d5352c679..1810f6fa31f7f 100644
--- a/apps/mobile/src/lib/markdownDocument.ts
+++ b/apps/mobile/src/lib/markdownDocument.ts
@@ -285,25 +285,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[] = [];
@@ -439,7 +449,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 16bab62f09372..69d9122a92f09 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 ReactElement, type ReactNode } from "react";
 import { Platform, Share, StyleSheet, useWindowDimensions, View } from "react-native";
 import {
@@ -30,7 +29,6 @@ import { useRetryingImageSource } from "./useRetryingImageSource";
 import * as Dialog from "../components/ui/Dialog";
 import { copyTextWithHaptic } from "../lib/copyTextWithHaptic";
 import {
-  ENRICHED_INLINE_FILE_LINK_REGEX,
   enrichedTextLinkRegex,
   enrichedModelDetails,
   enrichedModelReference,
@@ -198,20 +196,20 @@ function codeBlockElement(
 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 63f8429c386fd..a1b155a8adc00 100644
--- a/apps/mobile/src/native/SelectableMarkdownText.types.ts
+++ b/apps/mobile/src/native/SelectableMarkdownText.types.ts
@@ -76,6 +76,8 @@ export interface SelectableMarkdownTextProps {
   readonly skills?: ReadonlyArray<SelectableMarkdownSkill>;
   readonly models?: ReadonlyArray<SelectableMarkdownModel>;
   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;