react-native-nitro-markdown 0.7.0 → 0.7.2

package/lib/typescript/module/use-markdown-stream.d.ts

@@ -1,6 +1,6 @@
 import { createMarkdownSession } from "./MarkdownSession";
 export type MarkdownSession = ReturnType<typeof createMarkdownSession>;
-export declare function useMarkdownSession(): {
+export declare function useMarkdownSession(initialText?: string): {
     getSession: () => import("./specs/MarkdownSession.nitro").MarkdownSession;
     isStreaming: boolean;
     setIsStreaming: import("react").Dispatch<import("react").SetStateAction<boolean>>;
@@ -10,6 +10,9 @@ export declare function useMarkdownSession(): {
     reset: (text: string) => void;
     replace: (from: number, to: number, text: string) => number;
 };
+export type MarkdownSessionController = ReturnType<typeof useMarkdownSession>;
+export declare function isMarkdownSessionController(value: MarkdownSession | MarkdownSessionController): value is MarkdownSessionController;
+export declare function resolveMarkdownSession(session: MarkdownSession | MarkdownSessionController): MarkdownSession;
 export declare function useStream(timestamps?: Record<number, number>): {
     isPlaying: boolean;
     setIsPlaying: import("react").Dispatch<import("react").SetStateAction<boolean>>;

package/lib/typescript/module/use-markdown-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-markdown-stream.d.ts","sourceRoot":"","sources":["../../../src/use-markdown-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAO1D,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEvE,wBAAgB,kBAAkB;;;;;;6BAiCY,MAAM;kBAMjB,MAAM;oBAIJ,MAAM,MAAM,MAAM,QAAQ,MAAM;EAcpE;AAED,wBAAgB,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;0BAgBzC,MAAM;;;;;;6BA1CoB,MAAM;kBAMjB,MAAM;oBAIJ,MAAM,MAAM,MAAM,QAAQ,MAAM;EAqDpE"}
+{"version":3,"file":"use-markdown-stream.d.ts","sourceRoot":"","sources":["../../../src/use-markdown-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAO1D,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEvE,wBAAgB,kBAAkB,CAAC,WAAW,CAAC,EAAE,MAAM;;;;;;6BAuCT,MAAM;kBAMjB,MAAM;oBAIJ,MAAM,MAAM,MAAM,QAAQ,MAAM;EA0BpE;AAED,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9E,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,eAAe,GAAG,yBAAyB,GACjD,KAAK,IAAI,yBAAyB,CAEpC;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,eAAe,GAAG,yBAAyB,GACnD,eAAe,CAMjB;AAED,wBAAgB,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;0BAgBzC,MAAM;;;;;;6BAxEoB,MAAM;kBAMjB,MAAM;oBAIJ,MAAM,MAAM,MAAM,QAAQ,MAAM;EAmFpE"}

package/lib/typescript/module/utils/incremental-ast.d.ts

@@ -1,5 +1,6 @@
 import { type MarkdownNode } from "../headless";
 import type { ParserOptions } from "../Markdown.nitro";
+export declare const reuseStableAstNodes: (previousNode: MarkdownNode, nextNode: MarkdownNode) => MarkdownNode;
 export type IncrementalAstInput = {
     allowIncremental?: boolean;
     nextText: string;

package/lib/typescript/module/utils/incremental-ast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"incremental-ast.d.ts","sourceRoot":"","sources":["../../../../src/utils/incremental-ast.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAqJvD,MAAM,MAAM,mBAAmB,GAAG;IAChC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,WAAW,EAAE,YAAY,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,qEAM9B,mBAAmB,KAAG,YAgDxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,MAAM,MAAM,EACZ,UAAU,aAAa,KACtB,YAEF,CAAC"}
+{"version":3,"file":"incremental-ast.d.ts","sourceRoot":"","sources":["../../../../src/utils/incremental-ast.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AA2KvD,eAAO,MAAM,mBAAmB,GAC9B,cAAc,YAAY,EAC1B,UAAU,YAAY,KACrB,YA0CF,CAAC;AAUF,MAAM,MAAM,mBAAmB,GAAG;IAChC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,WAAW,EAAE,YAAY,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,qEAM9B,mBAAmB,KAAG,YAgDxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,MAAM,MAAM,EACZ,UAAU,aAAa,KACtB,YAEF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-markdown",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "High-performance Markdown parser for React Native using Nitro Modules and md4c",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -57,6 +57,7 @@
     "clean": "rimraf lib nitrogen/generated",
     "codegen": "nitrogen --logLevel=\"debug\"",
     "lint": "bunx eslint src --max-warnings=0 --ignore-pattern 'src/**/__tests__/**' --ignore-pattern 'src/**/*.nitro.ts'",
+    "lint:fix": "bunx eslint src --fix --ignore-pattern 'src/**/__tests__/**' --ignore-pattern 'src/**/*.nitro.ts'",
     "typecheck": "tsc --noEmit",
     "test": "jest",
     "test:coverage": "jest --coverage",

package/src/MarkdownContext.ts

@@ -123,6 +123,8 @@ export type CustomRenderers = Partial<{
   >;
 }>;
 
+export type MarkdownRenderers = CustomRenderers;
+
 export type TableOptions = {
   minColumnWidth?: number;
   measurementStabilizeMs?: number;

package/src/MarkdownSession.ts

@@ -3,6 +3,13 @@ import type { MarkdownSession as MarkdownSessionSpec } from "./specs/MarkdownSes
 
 export type MarkdownSession = MarkdownSessionSpec;
 
-export function createMarkdownSession(): MarkdownSession {
-  return NitroModules.createHybridObject<MarkdownSession>("MarkdownSession");
+export function createMarkdownSession(initialText?: string): MarkdownSession {
+  const session =
+    NitroModules.createHybridObject<MarkdownSession>("MarkdownSession");
+
+  if (initialText !== undefined) {
+    session.reset(initialText);
+  }
+
+  return session;
 }

package/src/index.ts

@@ -48,6 +48,7 @@ export type {
   LinkPressHandler,
   MarkdownContextValue,
   CustomRendererPropsByNode,
+  MarkdownRenderers,
   TableOptions,
 } from "./MarkdownContext";
 
@@ -77,6 +78,7 @@ export { MathInline, MathBlock } from "./renderers/math";
 export { createMarkdownSession } from "./MarkdownSession";
 export type { MarkdownSession } from "./MarkdownSession";
 export { useMarkdownSession, useStream } from "./use-markdown-stream";
+export type { MarkdownSessionController } from "./use-markdown-stream";
 
 export type {
   HighlightedToken,

package/src/markdown-stream.tsx

@@ -3,12 +3,18 @@ import {
   useEffect,
   useRef,
   useCallback,
+  useMemo,
   startTransition,
   type FC,
 } from "react";
 import type { MarkdownNode } from "./headless";
+import type { ParserOptions } from "./Markdown.nitro";
 import { Markdown, type MarkdownProps } from "./markdown";
 import type { MarkdownSession } from "./specs/MarkdownSession.nitro";
+import {
+  resolveMarkdownSession,
+  type MarkdownSessionController,
+} from "./use-markdown-stream";
 import { getNextStreamAst, parseMarkdownAst } from "./utils/incremental-ast";
 
 const normalizeOffset = (value: number): number | null => {
@@ -17,6 +23,22 @@ const normalizeOffset = (value: number): number | null => {
   return Math.floor(value);
 };
 
+const normalizeParserOptions = (
+  options?: ParserOptions,
+): ParserOptions | undefined => {
+  if (!options) return undefined;
+
+  const gfm = options.gfm;
+  const math = options.math;
+  const html = options.html;
+
+  if (gfm === undefined && math === undefined && html === undefined) {
+    return undefined;
+  }
+
+  return { gfm, math, html };
+};
+
 const resolveStreamText = ({
   forceFullSync,
   pendingFrom,
@@ -71,7 +93,7 @@ export type MarkdownStreamProps = {
   /**
    * The active MarkdownSession to stream content from.
    */
-  session: MarkdownSession;
+  session: MarkdownSession | MarkdownSessionController;
   /**
    * Throttle UI updates when updateStrategy is "interval".
    * Ignored when updateStrategy is "raf".
@@ -110,15 +132,28 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
   plugins,
   ...props
 }) => {
+  const activeSession = resolveMarkdownSession(session);
+  const parserOptionGfm = options?.gfm;
+  const parserOptionMath = options?.math;
+  const parserOptionHtml = options?.html;
+  const parserOptions = useMemo(
+    () =>
+      normalizeParserOptions({
+        gfm: parserOptionGfm,
+        math: parserOptionMath,
+        html: parserOptionHtml,
+      }),
+    [parserOptionGfm, parserOptionMath, parserOptionHtml],
+  );
   const parseText = useCallback(
-    (text: string): MarkdownNode => parseMarkdownAst(text, options),
-    [options],
+    (text: string): MarkdownNode => parseMarkdownAst(text, parserOptions),
+    [parserOptions],
   );
   const createEmptyAst = (): MarkdownNode => ({
     type: "document",
     children: [],
   });
-  const initialText = session.getAllText();
+  const initialText = activeSession.getAllText();
   const hasBeforeParsePlugins =
     plugins?.some((plugin) => typeof plugin.beforeParse === "function") ??
     false;
@@ -148,7 +183,7 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
   }, []);
 
   useEffect(() => {
-    const initialText = session.getAllText();
+    const initialText = activeSession.getAllText();
     const initialState = {
       text: initialText,
       ast: hasBeforeParsePlugins ? createEmptyAst() : parseText(initialText),
@@ -159,7 +194,7 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
     forceFullSyncRef.current = false;
     renderStateRef.current = initialState;
     setRenderState(initialState);
-  }, [hasBeforeParsePlugins, parseText, session]);
+  }, [activeSession, hasBeforeParsePlugins, parseText]);
 
   useEffect(() => {
     const flushUpdate = () => {
@@ -179,13 +214,19 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
       pendingToRef.current = null;
       forceFullSyncRef.current = false;
 
-      const latest = resolveStreamText({
-        forceFullSync,
-        pendingFrom,
-        pendingTo,
-        previousText: previousState.text,
-        session,
-      });
+      let latest: string;
+      try {
+        latest = resolveStreamText({
+          forceFullSync,
+          pendingFrom,
+          pendingTo,
+          previousText: previousState.text,
+          session: activeSession,
+        });
+      } catch (error) {
+        warnStreamError("[NitroMarkdown] Failed to read stream session:", error);
+        return;
+      }
       if (latest === previousState.text) return;
 
       const nextAst = hasBeforeParsePlugins
@@ -193,7 +234,7 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
         : getNextStreamAst({
             allowIncremental,
             nextText: latest,
-            options,
+            options: parserOptions,
             previousAst: previousState.ast,
             previousText: previousState.text,
           });
@@ -230,7 +271,9 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
     let unsubscribe: (() => void) | null = null;
 
     try {
-      unsubscribe = session.addListener((from, to) => {
+      unsubscribe = activeSession.addListener((from, to) => {
+        if (!mountedRef.current) return;
+
         const nextFrom = normalizeOffset(from);
         const nextTo = normalizeOffset(to);
 
@@ -254,6 +297,10 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
     }
 
     return () => {
+      pendingUpdateRef.current = false;
+      pendingFromRef.current = null;
+      pendingToRef.current = null;
+      forceFullSyncRef.current = false;
       try {
         unsubscribe?.();
       } catch (error) {
@@ -274,9 +321,8 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
   }, [
     allowIncremental,
     hasBeforeParsePlugins,
-    options,
-    plugins,
-    session,
+    parserOptions,
+    activeSession,
     updateIntervalMs,
     updateStrategy,
     useTransitionUpdates,

package/src/markdown.tsx

@@ -483,8 +483,14 @@ export const Markdown: FC<MarkdownProps> = ({
         math: parserOptionMath,
         html: parserOptionHtml,
       });
+      const shouldCloneSourceAst =
+        sourceAst &&
+        (Boolean(astTransform) ||
+          sortedPlugins?.some((plugin) => plugin.afterParse) === true);
       let parsedAst = sourceAst
-        ? cloneMarkdownNode(sourceAst)
+        ? shouldCloneSourceAst
+          ? cloneMarkdownNode(sourceAst)
+          : sourceAst
         : parseCache
           ? getCachedParsedAst(markdownToParse, parserOptions)
           : parseWithNativeParser(markdownToParse, parserOptions);

package/src/renderers/image.tsx

@@ -2,6 +2,7 @@ import {
   useState,
   useEffect,
   useMemo,
+  useRef,
   type ReactNode,
   type FC,
   type ComponentType,
@@ -47,6 +48,7 @@ export const Image: FC<ImageProps> = ({ url, title, alt, Renderer, style }) => {
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState(false);
   const [aspectRatio, setAspectRatio] = useState<number | undefined>(undefined);
+  const mountedRef = useRef(true);
   const { theme, imageOptions } = useMarkdownContext();
   const allowedImageHref = useMemo(
     () => getAllowedImageHref(url, imageOptions),
@@ -115,6 +117,13 @@ export const Image: FC<ImageProps> = ({ url, title, alt, Renderer, style }) => {
     [theme, aspectRatio],
   );
 
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+
   useEffect(() => {
     let isMounted = true;
     setLoading(true);
@@ -236,9 +245,11 @@ export const Image: FC<ImageProps> = ({ url, title, alt, Renderer, style }) => {
         accessibilityRole={accessibilityLabel ? "image" : undefined}
         accessibilityLabel={accessibilityLabel}
         onLoad={() => {
+          if (!mountedRef.current) return;
           setLoading(false);
         }}
         onError={() => {
+          if (!mountedRef.current) return;
           setLoading(false);
           setError(true);
         }}

package/src/renderers/math.tsx

@@ -247,6 +247,14 @@ export const MathInline: FC<MathInlineProps> = ({ content, style }) => {
   const { theme } = useMarkdownContext();
   const styles = getCachedStyles(mathStylesCache, theme, createMathStyles);
   const [hasRenderError, setHasRenderError] = useState(false);
+  const mountedRef = useRef(true);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
 
   if (!content) return null;
 
@@ -260,6 +268,7 @@ export const MathInline: FC<MathInlineProps> = ({ content, style }) => {
           color={theme.colors.text}
           style={styles.ratexInline}
           onError={() => {
+            if (!mountedRef.current) return;
             setHasRenderError(true);
           }}
         />
@@ -283,6 +292,14 @@ export const MathBlock: FC<MathBlockProps> = ({ content, style }) => {
   const { theme } = useMarkdownContext();
   const styles = getCachedStyles(mathStylesCache, theme, createMathStyles);
   const [hasRenderError, setHasRenderError] = useState(false);
+  const mountedRef = useRef(true);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
 
   if (!content) return null;
 
@@ -300,6 +317,7 @@ export const MathBlock: FC<MathBlockProps> = ({ content, style }) => {
             color={theme.colors.text}
             style={styles.ratexBlock}
             onError={() => {
+              if (!mountedRef.current) return;
               setHasRenderError(true);
             }}
           />

package/src/use-markdown-stream.ts

@@ -1,4 +1,4 @@
-import { useRef, useCallback, useState, useEffect } from "react";
+import { useRef, useCallback, useState, useEffect, useMemo } from "react";
 import { createMarkdownSession } from "./MarkdownSession";
 import {
   createTimestampTimeline,
@@ -8,10 +8,11 @@ import {
 
 export type MarkdownSession = ReturnType<typeof createMarkdownSession>;
 
-export function useMarkdownSession() {
+export function useMarkdownSession(initialText?: string) {
   const sessionRef = useRef<MarkdownSession | null>(null);
+  const initialTextRef = useRef(initialText);
   if (sessionRef.current === null) {
-    sessionRef.current = createMarkdownSession();
+    sessionRef.current = createMarkdownSession(initialText);
   }
 
   const [isStreaming, setIsStreaming] = useState(false);
@@ -20,17 +21,22 @@ export function useMarkdownSession() {
     const session = sessionRef.current!;
     return () => {
       try {
-        session.clear();
+        session.dispose();
       } finally {
-        try {
-          session.dispose();
-        } finally {
-          sessionRef.current = null;
-        }
+        sessionRef.current = null;
       }
     };
   }, []);
 
+  useEffect(() => {
+    if (initialText === undefined || initialTextRef.current === initialText) {
+      return;
+    }
+
+    initialTextRef.current = initialText;
+    sessionRef.current!.reset(initialText);
+  }, [initialText]);
+
   const stop = useCallback(() => {
     setIsStreaming(false);
   }, []);
@@ -55,16 +61,46 @@ export function useMarkdownSession() {
     return sessionRef.current!.replace(from, to, text);
   }, []);
 
-  return {
-    getSession,
-    isStreaming,
-    setIsStreaming,
-    stop,
-    clear,
-    setHighlight,
-    reset,
-    replace,
-  };
+  return useMemo(
+    () => ({
+      getSession,
+      isStreaming,
+      setIsStreaming,
+      stop,
+      clear,
+      setHighlight,
+      reset,
+      replace,
+    }),
+    [
+      clear,
+      getSession,
+      isStreaming,
+      replace,
+      reset,
+      setHighlight,
+      setIsStreaming,
+      stop,
+    ],
+  );
+}
+
+export type MarkdownSessionController = ReturnType<typeof useMarkdownSession>;
+
+export function isMarkdownSessionController(
+  value: MarkdownSession | MarkdownSessionController,
+): value is MarkdownSessionController {
+  return typeof Reflect.get(value, "getSession") === "function";
+}
+
+export function resolveMarkdownSession(
+  session: MarkdownSession | MarkdownSessionController,
+): MarkdownSession {
+  if (isMarkdownSessionController(session)) {
+    return session.getSession();
+  }
+
+  return session;
 }
 
 export function useStream(timestamps?: Record<number, number>) {

package/src/utils/incremental-ast.ts

@@ -152,6 +152,83 @@ const endsAtBlockBoundary = (text: string): boolean => {
   return text.endsWith("\n") || text.endsWith("\r");
 };
 
+const nodesHaveMatchingMetadata = (
+  previousNode: MarkdownNode,
+  nextNode: MarkdownNode,
+): boolean => {
+  return (
+    previousNode.type === nextNode.type &&
+    previousNode.content === nextNode.content &&
+    previousNode.level === nextNode.level &&
+    previousNode.href === nextNode.href &&
+    previousNode.title === nextNode.title &&
+    previousNode.alt === nextNode.alt &&
+    previousNode.language === nextNode.language &&
+    previousNode.ordered === nextNode.ordered &&
+    previousNode.start === nextNode.start &&
+    previousNode.checked === nextNode.checked &&
+    previousNode.isHeader === nextNode.isHeader &&
+    previousNode.align === nextNode.align &&
+    previousNode.beg === nextNode.beg &&
+    previousNode.end === nextNode.end
+  );
+};
+
+export const reuseStableAstNodes = (
+  previousNode: MarkdownNode,
+  nextNode: MarkdownNode,
+): MarkdownNode => {
+  if (previousNode.type !== nextNode.type) {
+    return nextNode;
+  }
+
+  const hasMatchingMetadata = nodesHaveMatchingMetadata(previousNode, nextNode);
+  const previousChildren = previousNode.children;
+  const nextChildren = nextNode.children;
+
+  if (!previousChildren || !nextChildren) {
+    return hasMatchingMetadata && previousChildren === nextChildren
+      ? previousNode
+      : nextNode;
+  }
+
+  if (previousChildren.length !== nextChildren.length) {
+    return {
+      ...nextNode,
+      children: nextChildren.map((nextChild, index) => {
+        const previousChild = previousChildren[index];
+        return previousChild
+          ? reuseStableAstNodes(previousChild, nextChild)
+          : nextChild;
+      }),
+    };
+  }
+
+  let hasChildChange = false;
+  const children = nextChildren.map((nextChild, index) => {
+    const child = reuseStableAstNodes(previousChildren[index], nextChild);
+    hasChildChange ||= child !== previousChildren[index];
+    return child;
+  });
+
+  if (hasMatchingMetadata && !hasChildChange) {
+    return previousNode;
+  }
+
+  return {
+    ...nextNode,
+    children,
+  };
+};
+
+const parseAstWithStableNodes = (
+  previousAst: MarkdownNode,
+  text: string,
+  options?: ParserOptions,
+): MarkdownNode => {
+  return reuseStableAstNodes(previousAst, parseAst(text, options));
+};
+
 export type IncrementalAstInput = {
   allowIncremental?: boolean;
   nextText: string;
@@ -168,7 +245,7 @@ export const getNextStreamAst = ({
   previousText,
 }: IncrementalAstInput): MarkdownNode => {
   if (!allowIncremental || !nextText.startsWith(previousText)) {
-    return parseAst(nextText, options);
+    return parseAstWithStableNodes(previousAst, nextText, options);
   }
 
   const appendedChunk = nextText.slice(previousText.length);
@@ -194,7 +271,7 @@ export const getNextStreamAst = ({
 
   if (!PLAIN_TEXT_APPEND_PATTERN.test(appendedChunk)) {
     if (endsAtBlockBoundary(previousText)) {
-      return parseAst(nextText, options);
+      return parseAstWithStableNodes(previousAst, nextText, options);
     }
 
     const textAppendedAst = appendPlainTextToAst(
@@ -208,12 +285,12 @@ export const getNextStreamAst = ({
   }
 
   if (insideFencedCodeBlock) {
-    return parseAst(nextText, options);
+    return parseAstWithStableNodes(previousAst, nextText, options);
   }
 
   // Correctness-first fallback: full reparse for all non-trivial appends.
   // Incremental append is only used for plain text chunks at the true trailing leaf.
-  return parseAst(nextText, options);
+  return parseAstWithStableNodes(previousAst, nextText, options);
 };
 
 export const parseMarkdownAst = (