@stream-mdx/react 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -46,11 +46,11 @@ function assignMdxChildKey(child, index) {
   if (Array.isArray(child)) {
     return child.map((entry, subIndex) => assignMdxChildKey(entry, `${index}-${subIndex}`));
   }
-  if (import_react2.default.isValidElement(child)) {
+  if (import_react3.default.isValidElement(child)) {
     if (child.key !== null && child.key !== void 0) {
       return child;
     }
-    return import_react2.default.cloneElement(child, { key: index });
+    return import_react3.default.cloneElement(child, { key: index });
   }
   return child;
 }
@@ -79,14 +79,14 @@ function registerInlineMdxModule(compiled) {
     dependencies: compiled.dependencies ?? []
   });
 }
-var import_react2, ReactJsxRuntime, withClassName, MDXClient, MDXComponentFactory, globalMDXClient, globalComponentFactory;
+var import_react3, ReactJsxRuntime, withClassName, MDXClient, MDXComponentFactory, globalMDXClient, globalComponentFactory;
 var init_mdx_client = __esm({
   "src/mdx-client.ts"() {
     "use strict";
-    import_react2 = __toESM(require("react"), 1);
+    import_react3 = __toESM(require("react"), 1);
     ReactJsxRuntime = __toESM(require("react/jsx-runtime"), 1);
     withClassName = (tag, className) => {
-      return (props) => import_react2.default.createElement(tag, { className, ...props });
+      return (props) => import_react3.default.createElement(tag, { className, ...props });
     };
     MDXClient = class {
       constructor(compileEndpoint = "/api/mdx-compile-v2") {
@@ -103,7 +103,7 @@ var init_mdx_client = __esm({
         if (block.type !== "mdx") {
           throw new Error("Block is not MDX type");
         }
-        const cacheKey = block.id;
+        const cacheKey = `${block.id}\0${block.payload.raw ?? ""}`;
         const cachedPromise = this.cache.get(cacheKey);
         if (cachedPromise) {
           return cachedPromise;
@@ -261,14 +261,14 @@ var init_mdx_client = __esm({
             const registryComponents = this.getComponents();
             const incomingComponents = props?.components;
             const mergedComponents = incomingComponents ? { ...registryComponents, ...incomingComponents } : registryComponents;
-            return import_react2.default.createElement(MDXComponent, {
+            return import_react3.default.createElement(MDXComponent, {
               ...props,
               components: mergedComponents
             });
           };
         } catch (error) {
           console.error("Failed to evaluate MDX:", error);
-          return () => import_react2.default.createElement(
+          return () => import_react3.default.createElement(
             "div",
             {
               className: "mdx-error"
@@ -288,7 +288,7 @@ var init_mdx_client = __esm({
           if (Array.isArray(finalProps.children)) {
             finalProps.children = finalProps.children.map((child, index) => assignMdxChildKey(child, index));
           }
-          return import_react2.default.createElement(type, finalProps);
+          return import_react3.default.createElement(type, finalProps);
         };
         const runtimeJsx = typeof runtime.jsx === "function" ? runtime.jsx.bind(runtime) : createElementWithChildren;
         const runtimeJsxs = typeof runtime.jsxs === "function" ? runtime.jsxs.bind(runtime) : createElementWithChildren;
@@ -297,20 +297,20 @@ var init_mdx_client = __esm({
           jsx: runtimeJsx,
           jsxs: runtimeJsxs,
           jsxDEV: runtimeJsxDEV,
-          Fragment: runtime.Fragment ?? import_react2.default.Fragment
+          Fragment: runtime.Fragment ?? import_react3.default.Fragment
         };
         return {
           __mdx_runtime: jsxRuntime,
-          React: import_react2.default,
-          Fragment: import_react2.default.Fragment,
-          useState: import_react2.default.useState,
-          useEffect: import_react2.default.useEffect,
-          useMemo: import_react2.default.useMemo,
-          useCallback: import_react2.default.useCallback,
-          useRef: import_react2.default.useRef,
-          useContext: import_react2.default.useContext,
-          useReducer: import_react2.default.useReducer,
-          useLayoutEffect: import_react2.default.useLayoutEffect,
+          React: import_react3.default,
+          Fragment: import_react3.default.Fragment,
+          useState: import_react3.default.useState,
+          useEffect: import_react3.default.useEffect,
+          useMemo: import_react3.default.useMemo,
+          useCallback: import_react3.default.useCallback,
+          useRef: import_react3.default.useRef,
+          useContext: import_react3.default.useContext,
+          useReducer: import_react3.default.useReducer,
+          useLayoutEffect: import_react3.default.useLayoutEffect,
           console: {
             log: console.log,
             warn: console.warn,
@@ -376,13 +376,13 @@ var init_mdx_client = __esm({
           ol: withClassName("ol", "mdx-ol"),
           li: withClassName("li", "mdx-li"),
           blockquote: withClassName("blockquote", "mdx-blockquote"),
-          a: (props) => import_react2.default.createElement("a", {
+          a: (props) => import_react3.default.createElement("a", {
             className: "mdx-link",
             target: props.href?.startsWith("http") ? "_blank" : void 0,
             rel: props.href?.startsWith("http") ? "noopener noreferrer" : void 0,
             ...props
           }),
-          img: (props) => import_react2.default.createElement("img", { className: "mdx-img", ...props }),
+          img: (props) => import_react3.default.createElement("img", { className: "mdx-img", ...props }),
           table: withClassName("table", "mdx-table"),
           thead: withClassName("thead", "mdx-thead"),
           tbody: withClassName("tbody", "mdx-tbody"),
@@ -409,6 +409,7 @@ var init_mdx_client = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BottomStickScrollArea: () => BottomStickScrollArea,
   ComponentRegistry: () => ComponentRegistry,
   DEFAULT_COALESCE_CONFIG: () => import_core3.DEFAULT_COALESCE_CONFIG,
   DEFAULT_VIRTUALIZED_CODE_CONFIG: () => DEFAULT_VIRTUALIZED_CODE_CONFIG,
@@ -434,6 +435,7 @@ __export(index_exports, {
   defaultInlineComponents: () => defaultInlineComponents,
   getMDXClient: () => getMDXClient,
   getMDXComponentFactory: () => getMDXComponentFactory,
+  getPatchKind: () => import_patch_batching.getPatchKind,
   isHeavyPatch: () => import_patch_batching.isHeavyPatch,
   isListPatchDebugEnabled: () => isListPatchDebugEnabled,
   mapHtmlToReact: () => mapHtmlToReact,
@@ -454,6 +456,321 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/components/bottom-stick-scroll-area.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var EPS_BOTTOM_PX = 2;
+var EPS_OVERFLOW_PX = 1;
+var DETACH_SCROLL_DELTA_PX = 1;
+var RETURN_MIN_MS = 180;
+var RETURN_MAX_MS = 520;
+var RETURN_PX_PER_MS = 2.2;
+var RETURN_SETTLE_FRAMES = 2;
+function clamp01(value) {
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function easeOutCubic(value) {
+  return 1 - (1 - value) ** 3;
+}
+function joinClasses(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+function measure(viewport) {
+  const scrollTop = viewport.scrollTop;
+  const scrollHeight = viewport.scrollHeight;
+  const clientHeight = viewport.clientHeight;
+  const maxScrollTop = Math.max(0, scrollHeight - clientHeight);
+  const distanceToBottom = Math.max(0, maxScrollTop - scrollTop);
+  const isOverflowing = scrollHeight > clientHeight + EPS_OVERFLOW_PX;
+  return { scrollTop, scrollHeight, clientHeight, maxScrollTop, distanceToBottom, isOverflowing };
+}
+function DefaultJumpButton({ canJump, jumpToBottom }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "button",
+    {
+      type: "button",
+      onClick: jumpToBottom,
+      "aria-label": "Scroll to bottom",
+      style: {
+        pointerEvents: canJump ? "auto" : "none",
+        borderRadius: 9999,
+        border: "1px solid color-mix(in srgb, currentColor 20%, transparent)",
+        width: 40,
+        height: 40,
+        display: "grid",
+        placeItems: "center",
+        boxShadow: "0 8px 20px rgba(0,0,0,0.18)",
+        background: "color-mix(in srgb, var(--background, #fff) 92%, transparent)",
+        color: "var(--foreground, #111)",
+        cursor: canJump ? "pointer" : "default"
+      },
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "aria-hidden": true, children: "\u2193" })
+    }
+  );
+}
+function BottomStickScrollArea({
+  children,
+  className,
+  viewportClassName,
+  contentClassName,
+  showJumpToBottom = true,
+  onDebugStateChange,
+  onModeChange,
+  debugDomAttributes = false,
+  renderJumpToBottom,
+  jumpContainerClassName
+}) {
+  const viewportRef = (0, import_react.useRef)(null);
+  const contentRef = (0, import_react.useRef)(null);
+  const modeRef = (0, import_react.useRef)("STICKY_INSTANT");
+  const [mode, setMode] = (0, import_react.useState)("STICKY_INSTANT");
+  const [isOverflowing, setIsOverflowing] = (0, import_react.useState)(false);
+  const [distanceToBottom, setDistanceToBottom] = (0, import_react.useState)(0);
+  const prevScrollTopRef = (0, import_react.useRef)(0);
+  const lastProgrammaticWriteRef = (0, import_react.useRef)(null);
+  const programmaticWriteCountRef = (0, import_react.useRef)(0);
+  const pendingStickRafRef = (0, import_react.useRef)(null);
+  const stickRequestedRef = (0, import_react.useRef)(false);
+  const returnRafRef = (0, import_react.useRef)(null);
+  const returnAnimRef = (0, import_react.useRef)(null);
+  const setModeBoth = (0, import_react.useCallback)(
+    (next) => {
+      modeRef.current = next;
+      setMode(next);
+      onModeChange?.(next);
+    },
+    [onModeChange]
+  );
+  const updateDebug = (0, import_react.useCallback)(() => {
+    const viewport = viewportRef.current;
+    if (!viewport) return;
+    const m = measure(viewport);
+    if (debugDomAttributes) {
+      viewport.dataset.stickyMode = modeRef.current;
+      viewport.dataset.distanceToBottom = String(m.distanceToBottom);
+      viewport.dataset.isOverflowing = m.isOverflowing ? "1" : "0";
+      viewport.dataset.programmaticWrites = String(programmaticWriteCountRef.current);
+    }
+    onDebugStateChange?.({
+      mode: modeRef.current,
+      isOverflowing: m.isOverflowing,
+      distanceToBottom: m.distanceToBottom,
+      scrollTop: m.scrollTop,
+      maxScrollTop: m.maxScrollTop,
+      scrollHeight: m.scrollHeight,
+      clientHeight: m.clientHeight,
+      programmaticWrites: programmaticWriteCountRef.current
+    });
+    setDistanceToBottom(
+      (previous) => Math.abs(previous - m.distanceToBottom) <= 0.1 ? previous : m.distanceToBottom
+    );
+  }, [debugDomAttributes, onDebugStateChange]);
+  const writeScrollTop = (0, import_react.useCallback)((nextTop) => {
+    const viewport = viewportRef.current;
+    if (!viewport) return;
+    viewport.scrollTop = nextTop;
+    programmaticWriteCountRef.current += 1;
+    lastProgrammaticWriteRef.current = { at: performance.now(), top: nextTop };
+  }, []);
+  const cancelPendingStick = (0, import_react.useCallback)(() => {
+    if (pendingStickRafRef.current !== null) {
+      cancelAnimationFrame(pendingStickRafRef.current);
+      pendingStickRafRef.current = null;
+    }
+    stickRequestedRef.current = false;
+  }, []);
+  const cancelReturn = (0, import_react.useCallback)(() => {
+    if (returnRafRef.current !== null) {
+      cancelAnimationFrame(returnRafRef.current);
+      returnRafRef.current = null;
+    }
+    returnAnimRef.current = null;
+  }, []);
+  const stickToBottomInstant = (0, import_react.useCallback)(() => {
+    const viewport = viewportRef.current;
+    if (!viewport) return;
+    stickRequestedRef.current = true;
+    if (pendingStickRafRef.current !== null) return;
+    pendingStickRafRef.current = requestAnimationFrame(() => {
+      pendingStickRafRef.current = null;
+      if (!stickRequestedRef.current) return;
+      stickRequestedRef.current = false;
+      if (modeRef.current !== "STICKY_INSTANT") return;
+      const m = measure(viewport);
+      writeScrollTop(m.maxScrollTop);
+      updateDebug();
+    });
+  }, [updateDebug, writeScrollTop]);
+  const startReturnToBottomSmooth = (0, import_react.useCallback)(() => {
+    const viewport = viewportRef.current;
+    if (!viewport) return;
+    cancelPendingStick();
+    cancelReturn();
+    const initial = measure(viewport);
+    if (initial.distanceToBottom <= EPS_BOTTOM_PX) {
+      setModeBoth("STICKY_INSTANT");
+      stickToBottomInstant();
+      updateDebug();
+      return;
+    }
+    const durationMs = Math.max(
+      RETURN_MIN_MS,
+      Math.min(RETURN_MAX_MS, initial.distanceToBottom / RETURN_PX_PER_MS)
+    );
+    returnAnimRef.current = {
+      startTime: performance.now(),
+      startTop: initial.scrollTop,
+      durationMs,
+      settleFrames: 0
+    };
+    setModeBoth("RETURNING_SMOOTH");
+    const tick = (now2) => {
+      const viewportCurrent = viewportRef.current;
+      const anim = returnAnimRef.current;
+      if (!viewportCurrent || !anim || modeRef.current !== "RETURNING_SMOOTH") {
+        cancelReturn();
+        return;
+      }
+      const before = measure(viewportCurrent);
+      const progress = clamp01((now2 - anim.startTime) / anim.durationMs);
+      const eased = easeOutCubic(progress);
+      const targetBottom = before.maxScrollTop;
+      let nextTop = anim.startTop + (targetBottom - anim.startTop) * eased;
+      if (nextTop < before.scrollTop) {
+        nextTop = before.scrollTop;
+      }
+      writeScrollTop(nextTop);
+      const after = measure(viewportCurrent);
+      if (after.distanceToBottom <= EPS_BOTTOM_PX) {
+        anim.settleFrames += 1;
+      } else {
+        anim.settleFrames = 0;
+      }
+      const doneByTime = progress >= 1;
+      const doneBySettle = anim.settleFrames >= RETURN_SETTLE_FRAMES && progress >= 0.6;
+      if (doneByTime && doneBySettle) {
+        cancelReturn();
+        setModeBoth("STICKY_INSTANT");
+        stickToBottomInstant();
+        updateDebug();
+        return;
+      }
+      updateDebug();
+      returnRafRef.current = requestAnimationFrame(tick);
+    };
+    returnRafRef.current = requestAnimationFrame(tick);
+  }, [cancelPendingStick, cancelReturn, setModeBoth, stickToBottomInstant, updateDebug, writeScrollTop]);
+  const onViewportScroll = (0, import_react.useCallback)(
+    (event) => {
+      const viewport = event.currentTarget;
+      const m = measure(viewport);
+      setIsOverflowing((previous) => previous === m.isOverflowing ? previous : m.isOverflowing);
+      const previousTop = prevScrollTopRef.current;
+      const delta = m.scrollTop - previousTop;
+      const lastWrite = lastProgrammaticWriteRef.current;
+      const wroteRecently = lastWrite !== null && performance.now() - lastWrite.at < 60;
+      const isLikelyOwnWrite = wroteRecently && lastWrite !== null && Math.abs(m.scrollTop - lastWrite.top) <= 2;
+      if (modeRef.current === "RETURNING_SMOOTH") {
+        if (!isLikelyOwnWrite && delta < -DETACH_SCROLL_DELTA_PX) {
+          cancelReturn();
+          setModeBoth("DETACHED");
+        }
+      } else if (modeRef.current === "STICKY_INSTANT") {
+        if (!isLikelyOwnWrite && delta < -DETACH_SCROLL_DELTA_PX && m.isOverflowing) {
+          cancelPendingStick();
+          setModeBoth("DETACHED");
+        }
+      } else if (modeRef.current === "DETACHED") {
+        if (m.distanceToBottom <= EPS_BOTTOM_PX) {
+          setModeBoth("STICKY_INSTANT");
+          stickToBottomInstant();
+        }
+      }
+      prevScrollTopRef.current = m.scrollTop;
+      updateDebug();
+    },
+    [cancelPendingStick, cancelReturn, setModeBoth, stickToBottomInstant, updateDebug]
+  );
+  (0, import_react.useEffect)(() => {
+    const viewport = viewportRef.current;
+    const content = contentRef.current;
+    if (!viewport || !content) return;
+    const observer = new ResizeObserver(() => {
+      const m = measure(viewport);
+      setIsOverflowing((previous) => previous === m.isOverflowing ? previous : m.isOverflowing);
+      if (modeRef.current === "STICKY_INSTANT") {
+        stickToBottomInstant();
+      }
+      updateDebug();
+    });
+    observer.observe(content);
+    observer.observe(viewport);
+    return () => observer.disconnect();
+  }, [stickToBottomInstant, updateDebug]);
+  (0, import_react.useLayoutEffect)(() => {
+    const viewport = viewportRef.current;
+    if (!viewport) return;
+    setModeBoth("STICKY_INSTANT");
+    const initial = measure(viewport);
+    writeScrollTop(initial.maxScrollTop);
+    prevScrollTopRef.current = viewport.scrollTop;
+    setIsOverflowing(initial.isOverflowing);
+    setDistanceToBottom(initial.distanceToBottom);
+    updateDebug();
+  }, [setModeBoth, updateDebug, writeScrollTop]);
+  (0, import_react.useEffect)(() => {
+    return () => {
+      cancelPendingStick();
+      cancelReturn();
+    };
+  }, [cancelPendingStick, cancelReturn]);
+  const canJump = isOverflowing && mode === "DETACHED";
+  const jumpButton = renderJumpToBottom?.({
+    mode,
+    canJump,
+    isOverflowing,
+    distanceToBottom,
+    jumpToBottom: startReturnToBottomSmooth
+  }) ?? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DefaultJumpButton, { canJump, jumpToBottom: startReturnToBottomSmooth });
+  const jumpContainerClassNameBase = "pointer-events-none absolute z-20";
+  const jumpContainerStyle = {
+    position: "absolute",
+    zIndex: 20,
+    left: 0,
+    right: 0,
+    bottom: 12,
+    display: "flex",
+    justifyContent: "center",
+    opacity: canJump ? 1 : 0,
+    transform: canJump ? "translateY(0px)" : "translateY(4px)",
+    transition: "opacity 150ms ease, transform 150ms ease",
+    pointerEvents: "none"
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: joinClasses("relative h-full w-full overflow-hidden", className), children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "div",
+      {
+        ref: viewportRef,
+        className: joinClasses("h-full w-full overflow-auto", viewportClassName),
+        onScroll: onViewportScroll,
+        "data-testid": "sticky-scroll-viewport",
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: contentRef, className: joinClasses("flex min-h-full w-full flex-col", contentClassName), children })
+      }
+    ),
+    showJumpToBottom ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "div",
+      {
+        className: joinClasses(jumpContainerClassNameBase, jumpContainerClassName),
+        style: jumpContainerStyle,
+        "aria-hidden": !canJump,
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: canJump ? "pointer-events-auto" : "pointer-events-none", children: jumpButton })
+      }
+    ) : null
+  ] });
+}
+
 // src/components/index.ts
 var import_core = require("@stream-mdx/core");
 
@@ -630,7 +947,7 @@ function percentile(values, ratio) {
 }
 
 // src/mdx-hydration-context.ts
-var import_react = __toESM(require("react"), 1);
+var import_react2 = __toESM(require("react"), 1);
 var MdxHydrationController = class {
   constructor(options) {
     this.active = 0;
@@ -668,7 +985,7 @@ var MdxHydrationController = class {
     next();
   }
 };
-var MdxHydrationContext = import_react.default.createContext({ controller: null });
+var MdxHydrationContext = import_react2.default.createContext({ controller: null });
 function createMdxHydrationController(options) {
   if (!options || options.strategy === "immediate") {
     return null;
@@ -689,11 +1006,11 @@ function prefetchMdxRuntime() {
 }
 
 // src/renderer/use-deferred-render.ts
-var import_react3 = require("react");
+var import_react4 = require("react");
 function useDeferredRender(ref, options) {
   const enabled = options?.enabled ?? true;
-  const [shouldRender, setShouldRender] = (0, import_react3.useState)(!enabled);
-  (0, import_react3.useEffect)(() => {
+  const [shouldRender, setShouldRender] = (0, import_react4.useState)(!enabled);
+  (0, import_react4.useEffect)(() => {
     if (!enabled) {
       setShouldRender(true);
       return;
@@ -746,10 +1063,10 @@ function useDeferredRender(ref, options) {
 
 // src/components/index.ts
 var import_core2 = require("@stream-mdx/core");
-var import_react5 = __toESM(require("react"), 1);
+var import_react6 = __toESM(require("react"), 1);
 
 // src/utils/inline-html.ts
-var import_react4 = __toESM(require("react"), 1);
+var import_react5 = __toESM(require("react"), 1);
 var BACKTICK_CONTENT = /^`([\s\S]+)`$/;
 var DEFAULT_INLINE_HTML_RENDERERS = {
   kbd: (descriptor, ctx) => {
@@ -761,7 +1078,7 @@ var DEFAULT_INLINE_HTML_RENDERERS = {
       if (ctx.key !== void 0 && ctx.key !== null) {
         props.key = ctx.key;
       }
-      return import_react4.default.createElement("kbd", props, import_react4.default.createElement("code", { className: "inline-code" }, codeText));
+      return import_react5.default.createElement("kbd", props, import_react5.default.createElement("code", { className: "inline-code" }, codeText));
     }
     return ctx.defaultRender();
   }
@@ -779,9 +1096,9 @@ function renderInlineHtmlSegment(raw, sanitized, options = {}) {
         return null;
       }
       if (options.key !== void 0 && options.key !== null) {
-        return import_react4.default.createElement(import_react4.default.Fragment, { key: options.key }, descriptor.text);
+        return import_react5.default.createElement(import_react5.default.Fragment, { key: options.key }, descriptor.text);
       }
-      return import_react4.default.createElement(import_react4.default.Fragment, {}, descriptor.text);
+      return import_react5.default.createElement(import_react5.default.Fragment, {}, descriptor.text);
     }
     if (isInlineTag) {
       const parsedElement = renderSanitizedHtmlTree(descriptor.sanitized, options.key);
@@ -796,15 +1113,15 @@ function renderInlineHtmlSegment(raw, sanitized, options = {}) {
     if (options.key !== void 0 && options.key !== null) {
       props.key = options.key;
     }
-    return import_react4.default.createElement("span", props);
+    return import_react5.default.createElement("span", props);
   };
   const allRenderers = options.renderers ? { ...DEFAULT_INLINE_HTML_RENDERERS, ...options.renderers } : DEFAULT_INLINE_HTML_RENDERERS;
   const renderer = allRenderers[descriptor.tagName];
   if (renderer) {
     const rendered = renderer(descriptor, { key: options.key, defaultRender });
     if (rendered) {
-      if (options.key !== void 0 && options.key !== null && import_react4.default.isValidElement(rendered) && rendered.key === null) {
-        return import_react4.default.cloneElement(rendered, { key: options.key });
+      if (options.key !== void 0 && options.key !== null && import_react5.default.isValidElement(rendered) && rendered.key === null) {
+        return import_react5.default.cloneElement(rendered, { key: options.key });
       }
       return rendered;
     }
@@ -916,21 +1233,21 @@ function renderSanitizedHtmlTree(html, key) {
     }
     if (children.length === 1) {
       const [child] = children;
-      if (import_react4.default.isValidElement(child)) {
+      if (import_react5.default.isValidElement(child)) {
         if (key !== void 0 && key !== null) {
-          return import_react4.default.cloneElement(child, { key });
+          return import_react5.default.cloneElement(child, { key });
         }
         return child;
       }
       if (typeof child === "string" || typeof child === "number") {
         if (key !== void 0 && key !== null) {
-          return import_react4.default.createElement(import_react4.default.Fragment, { key }, child);
+          return import_react5.default.createElement(import_react5.default.Fragment, { key }, child);
         }
-        return import_react4.default.createElement(import_react4.default.Fragment, {}, child);
+        return import_react5.default.createElement(import_react5.default.Fragment, {}, child);
       }
-      return import_react4.default.createElement(import_react4.default.Fragment, { key }, child);
+      return import_react5.default.createElement(import_react5.default.Fragment, { key }, child);
     }
-    return import_react4.default.createElement(import_react4.default.Fragment, { key }, ...children);
+    return import_react5.default.createElement(import_react5.default.Fragment, { key }, ...children);
   } catch {
     return null;
   }
@@ -955,9 +1272,9 @@ function convertDomNode(node, key) {
     }
   });
   if (children.length === 0) {
-    return import_react4.default.createElement(tagName, props);
+    return import_react5.default.createElement(tagName, props);
   }
-  return import_react4.default.createElement(tagName, props, ...children);
+  return import_react5.default.createElement(tagName, props, ...children);
 }
 function getElementAttributes(element) {
   const attrs = {};
@@ -1018,12 +1335,12 @@ var INLINE_ELEMENTS = /* @__PURE__ */ new Set([
 ]);
 
 // src/components/link-safety-modal.tsx
-var import_jsx_runtime = require("react/jsx-runtime");
+var import_jsx_runtime2 = require("react/jsx-runtime");
 var DefaultLinkSafetyModal = ({ url, isOpen, isChecking, onClose, onConfirm, onCopy }) => {
   if (!isOpen) {
     return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
     "div",
     {
       className: "stream-mdx-link-modal-backdrop",
@@ -1041,7 +1358,7 @@ var DefaultLinkSafetyModal = ({ url, isOpen, isChecking, onClose, onConfirm, onC
         padding: "24px"
       },
       onClick: onClose,
-      children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+      children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
         "div",
         {
           className: "stream-mdx-link-modal",
@@ -1056,12 +1373,12 @@ var DefaultLinkSafetyModal = ({ url, isOpen, isChecking, onClose, onConfirm, onC
           },
           onClick: (event) => event.stopPropagation(),
           children: [
-            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { fontWeight: 600, marginBottom: 8 }, children: "Open external link?" }),
-            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { fontSize: 13, opacity: 0.8, wordBreak: "break-all", marginBottom: 16 }, children: url }),
-            /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { display: "flex", gap: 8, justifyContent: "flex-end" }, children: [
-              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", onClick: onCopy, disabled: isChecking, style: buttonStyle, children: "Copy link" }),
-              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", onClick: onConfirm, disabled: isChecking, style: primaryButtonStyle, children: "Open link" }),
-              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", onClick: onClose, style: buttonStyle, children: "Cancel" })
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { fontWeight: 600, marginBottom: 8 }, children: "Open external link?" }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { fontSize: 13, opacity: 0.8, wordBreak: "break-all", marginBottom: 16 }, children: url }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { display: "flex", gap: 8, justifyContent: "flex-end" }, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { type: "button", onClick: onCopy, disabled: isChecking, style: buttonStyle, children: "Copy link" }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { type: "button", onClick: onConfirm, disabled: isChecking, style: primaryButtonStyle, children: "Open link" }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { type: "button", onClick: onClose, style: buttonStyle, children: "Cancel" })
             ] })
           ]
         }
@@ -1085,7 +1402,7 @@ var primaryButtonStyle = {
 };
 
 // src/components/index.ts
-var MdxRuntimeBoundary = class extends import_react5.default.Component {
+var MdxRuntimeBoundary = class extends import_react6.default.Component {
   constructor() {
     super(...arguments);
     this.state = { hasError: false };
@@ -1115,31 +1432,31 @@ function renderInlineNodes(nodes, components) {
       case "text": {
         const textComponent = components.text;
         if (textComponent && textComponent !== defaultInlineComponents.text) {
-          return import_react5.default.createElement(textComponent, { key, text: node.text });
+          return import_react6.default.createElement(textComponent, { key, text: node.text });
         }
-        return import_react5.default.createElement(import_react5.default.Fragment, { key, children: node.text });
+        return import_react6.default.createElement(import_react6.default.Fragment, { key, children: node.text });
       }
       case "strong":
-        return import_react5.default.createElement(components.strong, {
+        return import_react6.default.createElement(components.strong, {
           key,
           children: renderInlineNodes(node.children, components)
         });
       case "em":
-        return import_react5.default.createElement(components.em, {
+        return import_react6.default.createElement(components.em, {
           key,
           children: renderInlineNodes(node.children, components)
         });
       case "strike": {
-        const StrikeComponent = components.strike ?? ((props) => import_react5.default.createElement("del", {}, props.children));
-        return import_react5.default.createElement(StrikeComponent, {
+        const StrikeComponent = components.strike ?? ((props) => import_react6.default.createElement("del", {}, props.children));
+        return import_react6.default.createElement(StrikeComponent, {
           key,
           children: renderInlineNodes(node.children, components)
         });
       }
       case "code":
-        return import_react5.default.createElement(components.code, { key, text: node.text });
+        return import_react6.default.createElement(components.code, { key, text: node.text });
       case "link":
-        return import_react5.default.createElement(
+        return import_react6.default.createElement(
           components.link,
           {
             key,
@@ -1149,18 +1466,18 @@ function renderInlineNodes(nodes, components) {
           }
         );
       case "image":
-        return import_react5.default.createElement(components.image, {
+        return import_react6.default.createElement(components.image, {
           key,
           src: node.src,
           alt: node.alt,
           title: node.title
         });
       case "br":
-        return import_react5.default.createElement(import_react5.default.Fragment, { key }, import_react5.default.createElement(components.br, {}));
+        return import_react6.default.createElement(import_react6.default.Fragment, { key }, import_react6.default.createElement(components.br, {}));
       default: {
         const component = components[node.kind];
         if (component) {
-          return import_react5.default.createElement(component, { key, ...node });
+          return import_react6.default.createElement(component, { key, ...node });
         }
         return null;
       }
@@ -1168,18 +1485,18 @@ function renderInlineNodes(nodes, components) {
   });
 }
 var defaultInlineComponents = {
-  text: ({ text }) => import_react5.default.createElement(import_react5.default.Fragment, {}, text),
-  strong: ({ children }) => import_react5.default.createElement("strong", {}, children),
-  em: ({ children }) => import_react5.default.createElement("em", {}, children),
-  strike: ({ children }) => import_react5.default.createElement("del", {}, children),
-  code: ({ text }) => import_react5.default.createElement(
+  text: ({ text }) => import_react6.default.createElement(import_react6.default.Fragment, {}, text),
+  strong: ({ children }) => import_react6.default.createElement("strong", {}, children),
+  em: ({ children }) => import_react6.default.createElement("em", {}, children),
+  strike: ({ children }) => import_react6.default.createElement("del", {}, children),
+  code: ({ text }) => import_react6.default.createElement(
     "code",
     {
       className: "inline-code"
     },
     text
   ),
-  link: ({ href, title, children }) => import_react5.default.createElement(
+  link: ({ href, title, children }) => import_react6.default.createElement(
     "a",
     {
       href,
@@ -1190,15 +1507,15 @@ var defaultInlineComponents = {
     },
     children
   ),
-  image: ({ src, alt, title }) => import_react5.default.createElement("img", {
+  image: ({ src, alt, title }) => import_react6.default.createElement("img", {
     src,
     alt,
     title,
     className: "markdown-image"
   }),
-  br: () => import_react5.default.createElement("br"),
+  br: () => import_react6.default.createElement("br"),
   // Custom extensible components
-  mention: ({ handle }) => import_react5.default.createElement(
+  mention: ({ handle }) => import_react6.default.createElement(
     "span",
     {
       className: "mention",
@@ -1206,7 +1523,7 @@ var defaultInlineComponents = {
     },
     `@${handle}`
   ),
-  citation: ({ id }) => import_react5.default.createElement(
+  citation: ({ id }) => import_react6.default.createElement(
     "span",
     {
       className: "citation",
@@ -1214,7 +1531,7 @@ var defaultInlineComponents = {
     },
     `[${id}]`
   ),
-  "math-inline": ({ tex }) => import_react5.default.createElement(
+  "math-inline": ({ tex }) => import_react6.default.createElement(
     "span",
     {
       className: "math-inline",
@@ -1222,27 +1539,31 @@ var defaultInlineComponents = {
     },
     `$${tex}$`
   ),
-  "math-display": ({ tex }) => import_react5.default.createElement(
+  "math-display": ({ tex }) => import_react6.default.createElement(
     "div",
     {
       className: "math-display markdown-math-display",
       "data-tex": tex,
       style: { overflowX: "auto" }
     },
-    import_react5.default.createElement("span", { className: "math-display-content" }, `$$${tex}$$`)
+    import_react6.default.createElement("span", { className: "math-display-content" }, `$$${tex}$$`)
   ),
   // Footnote inline reference (superscript anchor)
   "footnote-ref": ({ label, number }) => {
     const n = number ?? "?";
     const href = number ? `#fn:${n}` : void 0;
     const id = number ? `fnref:${n}` : void 0;
-    return import_react5.default.createElement("sup", { className: "footnote-ref" }, import_react5.default.createElement("a", { href, id, "data-label": label }, String(n)));
+    return import_react6.default.createElement(
+      "sup",
+      { className: "footnote-ref" },
+      import_react6.default.createElement("a", { href, id, "data-label": label, style: { color: "var(--foreground)", textDecoration: "underline" } }, String(n))
+    );
   }
 };
 var defaultBlockComponents = {
   paragraph: ({ inlines, raw, meta, children }) => {
     if (children !== void 0) {
-      return import_react5.default.createElement(
+      return import_react6.default.createElement(
         "p",
         {
           className: "markdown-paragraph"
@@ -1256,7 +1577,7 @@ var defaultBlockComponents = {
       if (structured.length === 1) {
         return structured[0];
       }
-      return import_react5.default.createElement(import_react5.default.Fragment, {}, ...structured);
+      return import_react6.default.createElement(import_react6.default.Fragment, {}, ...structured);
     }
     const filteredInlines = inlines && raw && inlines.length > 0 ? inlines.filter((node) => !(node.kind === "text" && node.text === raw)) : inlines ?? [];
     const effectiveInlines = filteredInlines.length > 0 ? filteredInlines : raw ? [
@@ -1265,7 +1586,7 @@ var defaultBlockComponents = {
         text: raw
       }
     ] : [];
-    return import_react5.default.createElement(
+    return import_react6.default.createElement(
       "p",
       {
         className: "markdown-paragraph"
@@ -1278,7 +1599,7 @@ var defaultBlockComponents = {
     const onlyPlainText = Array.isArray(inlines) && inlines.length > 0 && inlines.every((node) => node.kind === "text");
     const children = onlyPlainText ? inlines.map((node) => node.kind === "text" ? node.text : "").join("") : renderInlineNodes(inlines, defaultInlineComponents);
     const headingId = typeof meta?.headingId === "string" && meta.headingId.length > 0 ? meta.headingId : void 0;
-    return import_react5.default.createElement(
+    return import_react6.default.createElement(
       tag,
       {
         className: `markdown-heading markdown-h${level}`,
@@ -1291,7 +1612,7 @@ var defaultBlockComponents = {
   code: ({ html, meta, lines, lang, preAttrs, codeAttrs }) => {
     const language = typeof lang === "string" ? lang : typeof meta?.lang === "string" ? String(meta.lang) : "text";
     if (html) {
-      return import_react5.default.createElement("div", {
+      return import_react6.default.createElement("div", {
         className: `markdown-code-block language-${language || "text"}`,
         /* biome-ignore lint/security/noDangerouslySetInnerHtml: highlighted HTML is generated by our sanitizer */
         dangerouslySetInnerHTML: { __html: html }
@@ -1301,20 +1622,20 @@ var defaultBlockComponents = {
     if (lines && lines.length > 0) {
       const preAttributes = attrsToProps(preAttrs);
       const codeAttributes = attrsToProps(codeAttrs);
-      return import_react5.default.createElement(
+      return import_react6.default.createElement(
         "pre",
         {
           ...preAttributes,
           className: preAttributes.className ? `${preAttributes.className} markdown-code-block language-${language || "text"}` : `markdown-code-block language-${language || "text"}`
         },
-        import_react5.default.createElement(
+        import_react6.default.createElement(
           "code",
           {
             ...codeAttributes,
             className: codeAttributes.className ? `${codeAttributes.className} language-${language || "text"}` : `language-${language || "text"}`
           },
           lines.map(
-            (line) => import_react5.default.createElement("span", {
+            (line) => import_react6.default.createElement("span", {
               key: line.id,
               className: "line",
               /* biome-ignore lint/security/noDangerouslySetInnerHtml: line HTML is sanitized server-side */
@@ -1324,19 +1645,19 @@ var defaultBlockComponents = {
         )
       );
     }
-    return import_react5.default.createElement("pre", {
+    return import_react6.default.createElement("pre", {
       className: `markdown-code-block language-${language || "text"}`,
       children: code
     });
   },
-  blockquote: ({ inlines, renderedContent }) => import_react5.default.createElement(
+  blockquote: ({ inlines, renderedContent }) => import_react6.default.createElement(
     "blockquote",
     {
       className: "markdown-blockquote"
     },
     renderedContent ?? renderInlineNodes(inlines, defaultInlineComponents)
   ),
-  hr: (props) => import_react5.default.createElement("hr", props),
+  hr: (props) => import_react6.default.createElement("hr", props),
   list: ({ ordered, items }) => {
     if (items.length === 0) {
       return null;
@@ -1346,7 +1667,7 @@ var defaultBlockComponents = {
       ["--list-indent"]: `calc(2.5rem + ${String(items.length).length}ch)`
     } : void 0;
     const listItems = items.map(
-      (item, index) => import_react5.default.createElement(
+      (item, index) => import_react6.default.createElement(
         "li",
         {
           key: index,
@@ -1357,7 +1678,7 @@ var defaultBlockComponents = {
         renderInlineNodes(item, defaultInlineComponents)
       )
     );
-    return import_react5.default.createElement(
+    return import_react6.default.createElement(
       tag,
       {
         className: `markdown-list ${ordered ? "ordered" : "unordered"}`,
@@ -1371,23 +1692,23 @@ var defaultBlockComponents = {
     const htmlString = typeof window === "undefined" ? raw : (0, import_core.sanitizeHTML)(raw);
     if (typeof window !== "undefined" && elements) {
       const content = mapHtmlToReact(htmlString, elements);
-      return import_react5.default.createElement("div", { className: "markdown-html" }, content);
+      return import_react6.default.createElement("div", { className: "markdown-html" }, content);
     }
-    return import_react5.default.createElement("div", {
+    return import_react6.default.createElement("div", {
       className: "markdown-html",
       /* biome-ignore lint/security/noDangerouslySetInnerHtml: htmlString is sanitized before injection */
       dangerouslySetInnerHTML: { __html: htmlString }
     });
   },
-  mdx: ({ compiledRef, compiledModule, status, errorMessage, raw }) => {
-    const [Comp, setComp] = import_react5.default.useState(null);
-    const [internalError, setInternalError] = import_react5.default.useState(null);
-    const [renderError, setRenderError] = import_react5.default.useState(null);
-    const [retryKey, setRetryKey] = import_react5.default.useState(0);
-    const hydrationContext = import_react5.default.useContext(MdxHydrationContext);
+  mdx: ({ compiledRef, compiledModule, status, errorMessage }) => {
+    const [Comp, setComp] = import_react6.default.useState(null);
+    const [internalError, setInternalError] = import_react6.default.useState(null);
+    const [renderError, setRenderError] = import_react6.default.useState(null);
+    const [retryKey, setRetryKey] = import_react6.default.useState(0);
+    const hydrationContext = import_react6.default.useContext(MdxHydrationContext);
     const hydrationController = hydrationContext?.controller ?? null;
     const hydrationOptions = hydrationContext?.options;
-    const containerRef = import_react5.default.useRef(null);
+    const containerRef = import_react6.default.useRef(null);
     const deferHydration = hydrationOptions?.strategy === "visible";
     const shouldHydrate = useDeferredRender(
       containerRef,
@@ -1399,13 +1720,13 @@ var defaultBlockComponents = {
       } : { enabled: false }
     );
     const resolvedId = compiledModule?.id ?? (compiledRef?.id && compiledRef.id !== "pending" ? compiledRef.id : void 0);
-    const handleRetry = import_react5.default.useCallback(() => {
+    const handleRetry = import_react6.default.useCallback(() => {
       setInternalError(null);
       setRenderError(null);
       setComp(null);
       setRetryKey((prev) => prev + 1);
     }, []);
-    const handleRuntimeError = import_react5.default.useCallback(
+    const handleRuntimeError = import_react6.default.useCallback(
       (error) => {
         const message2 = error instanceof Error ? error.message : String(error);
         setRenderError(message2);
@@ -1416,7 +1737,7 @@ var defaultBlockComponents = {
     const effectiveStatus = status ? status : resolvedId ? "compiled" : "pending";
     const failureMessage = errorMessage ?? internalError ?? renderError ?? null;
     const moduleDependencies = compiledModule?.dependencies;
-    import_react5.default.useEffect(() => {
+    import_react6.default.useEffect(() => {
       if (!shouldHydrate) {
         return;
       }
@@ -1480,9 +1801,8 @@ var defaultBlockComponents = {
     const waitingForVisibility = deferHydration && !shouldHydrate && Boolean(resolvedId);
     const pendingLabel = waitingForVisibility ? "MDX ready (hydrate on view)\u2026" : compileMode === "worker" ? "Compiling MDX (client)\u2026" : "Compiling MDX (server)\u2026";
     const message = failureMessage ?? (compileMode === "worker" ? "MDX compilation failed in client mode. Try switching back to server rendering or restarting the stream." : "MDX compilation failed. Try restarting the stream.");
-    const rawFallback = typeof raw === "string" && raw.trim().length > 0 ? import_react5.default.createElement("pre", { className: "markdown-mdx-fallback" }, raw) : null;
     const allowRetry = Boolean(internalError || renderError);
-    const retryButton = allowRetry ? import_react5.default.createElement(
+    const retryButton = allowRetry ? import_react6.default.createElement(
       "button",
       {
         type: "button",
@@ -1491,13 +1811,14 @@ var defaultBlockComponents = {
       },
       "Retry hydration"
     ) : null;
-    const errorPanel = import_react5.default.createElement(
-      "div",
-      { className: "markdown-mdx-error" },
-      import_react5.default.createElement(import_react5.default.Fragment, null, import_react5.default.createElement("strong", null, "MDX failed"), import_react5.default.createElement("div", null, message))
+    const errorPanel = import_react6.default.createElement(
+      import_react6.default.Fragment,
+      null,
+      import_react6.default.createElement("strong", null, "MDX failed"),
+      import_react6.default.createElement("div", null, message)
     );
     if (Comp && !failureMessage) {
-      return import_react5.default.createElement(
+      return import_react6.default.createElement(
         "div",
         {
           className: "markdown-mdx",
@@ -1506,30 +1827,29 @@ var defaultBlockComponents = {
           "data-mdx-status": failureMessage ? "error" : "compiled",
           "data-mdx-mode": compileMode
         },
-        import_react5.default.createElement(
+        import_react6.default.createElement(
           MdxRuntimeBoundary,
           { resetKey: retryKey, onError: handleRuntimeError },
-          import_react5.default.createElement(Comp, {})
+          import_react6.default.createElement(Comp, {})
         )
       );
     }
     if (failureMessage) {
-      return import_react5.default.createElement(
+      return import_react6.default.createElement(
         "div",
         {
-          className: "markdown-mdx",
+          className: "markdown-mdx error",
           ref: containerRef,
           "data-mdx-ref": pendingId,
           "data-mdx-status": "error",
           "data-mdx-mode": compileMode
         },
         errorPanel,
-        rawFallback,
         retryButton
       );
     }
     if (!Comp) {
-      return import_react5.default.createElement(
+      return import_react6.default.createElement(
         "div",
         {
           className: "markdown-mdx",
@@ -1544,28 +1864,37 @@ var defaultBlockComponents = {
   },
   // Footnotes block rendered at page end
   footnotes: ({ items }) => {
-    if (!items || items.length === 0) return import_react5.default.createElement(import_react5.default.Fragment, null);
+    if (!items || items.length === 0) return import_react6.default.createElement(import_react6.default.Fragment, null);
     const listItems = items.map(
-      (item) => import_react5.default.createElement(
+      (item) => import_react6.default.createElement(
         "li",
         { key: item.number, id: `fn:${item.number}` },
         renderInlineNodes(item.inlines, defaultInlineComponents),
         " ",
-        import_react5.default.createElement("a", { href: `#fnref:${item.number}`, className: "footnote-backref", "aria-label": "Back to content" }, "\u21A9")
+        import_react6.default.createElement(
+          "a",
+          {
+            href: `#fnref:${item.number}`,
+            className: "footnote-backref",
+            "aria-label": "Back to content",
+            style: { color: "var(--foreground)", textDecoration: "underline" }
+          },
+          "\u21A9"
+        )
       )
     );
-    return import_react5.default.createElement("section", { className: "footnotes" }, import_react5.default.createElement("hr", {}), import_react5.default.createElement("ol", {}, listItems));
+    return import_react6.default.createElement("section", { className: "footnotes" }, import_react6.default.createElement("hr", {}), import_react6.default.createElement("ol", {}, listItems));
   },
   // Footnote definition placeholders (render nothing)
-  "footnote-def": () => import_react5.default.createElement(import_react5.default.Fragment, null),
+  "footnote-def": () => import_react6.default.createElement(import_react6.default.Fragment, null),
   // Callouts block
   callout: ({ kind, inlines = [] }) => {
     const tone = (kind || "NOTE").toUpperCase();
     const title = tone.charAt(0) + tone.slice(1).toLowerCase();
-    return import_react5.default.createElement(
+    return import_react6.default.createElement(
       "div",
       { className: `markdown-callout markdown-callout-${tone.toLowerCase()} border rounded p-3 my-3` },
-      import_react5.default.createElement("div", { className: "font-semibold mb-1" }, title),
+      import_react6.default.createElement("div", { className: "font-semibold mb-1" }, title),
       inlines.length > 0 ? renderInlineNodes(inlines, defaultInlineComponents) : null
     );
   },
@@ -1580,7 +1909,7 @@ var defaultBlockComponents = {
     const renderCells = (cells, tag, rowIdx) => cells.map((cell, i) => {
       const columnAlign = align?.[i] ?? void 0;
       const cellStyle = columnAlign ? { textAlign: columnAlign } : void 0;
-      return import_react5.default.createElement(
+      return import_react6.default.createElement(
         tag === "th" ? El.Th : El.Td,
         {
           key: `${rowIdx}-${i}`,
@@ -1591,14 +1920,14 @@ var defaultBlockComponents = {
         renderInlineNodes(cell, defaultInlineComponents)
       );
     });
-    return import_react5.default.createElement(
+    return import_react6.default.createElement(
       El.Table,
       { className: "markdown-table" },
-      header && header.length > 0 ? import_react5.default.createElement(El.Thead, {}, import_react5.default.createElement(El.Tr, {}, renderCells(header, "th", -1))) : null,
-      import_react5.default.createElement(
+      header && header.length > 0 ? import_react6.default.createElement(El.Thead, {}, import_react6.default.createElement(El.Tr, {}, renderCells(header, "th", -1))) : null,
+      import_react6.default.createElement(
         El.Tbody,
         {},
-        rows.map((row, r) => import_react5.default.createElement(El.Tr, { key: r }, renderCells(row, "td", r)))
+        rows.map((row, r) => import_react6.default.createElement(El.Tr, { key: r }, renderCells(row, "td", r)))
       )
     );
   }
@@ -1667,7 +1996,7 @@ var ComponentRegistry = class {
   renderBlock(block) {
     const Component = this.getBlockComponent(block.type);
     const props = this.getBlockProps(block);
-    return import_react5.default.createElement(Component, {
+    return import_react6.default.createElement(Component, {
       key: block.id,
       ...props
     });
@@ -1796,42 +2125,42 @@ var ComponentRegistry = class {
 function getDefaultHtmlElements() {
   return {
     // Text semantics
-    p: (props) => import_react5.default.createElement("p", props),
-    strong: (props) => import_react5.default.createElement("strong", props),
-    em: (props) => import_react5.default.createElement("em", props),
-    code: (props) => import_react5.default.createElement("code", props),
-    pre: (props) => import_react5.default.createElement("pre", props),
-    span: (props) => import_react5.default.createElement("span", props),
-    br: (props) => import_react5.default.createElement("br", props),
-    hr: (props) => import_react5.default.createElement("hr", props),
+    p: (props) => import_react6.default.createElement("p", props),
+    strong: (props) => import_react6.default.createElement("strong", props),
+    em: (props) => import_react6.default.createElement("em", props),
+    code: (props) => import_react6.default.createElement("code", props),
+    pre: (props) => import_react6.default.createElement("pre", props),
+    span: (props) => import_react6.default.createElement("span", props),
+    br: (props) => import_react6.default.createElement("br", props),
+    hr: (props) => import_react6.default.createElement("hr", props),
     // Lists
-    ul: (props) => import_react5.default.createElement("ul", props),
-    ol: (props) => import_react5.default.createElement("ol", props),
-    li: (props) => import_react5.default.createElement("li", props),
+    ul: (props) => import_react6.default.createElement("ul", props),
+    ol: (props) => import_react6.default.createElement("ol", props),
+    li: (props) => import_react6.default.createElement("li", props),
     // Links & media
-    a: (props) => import_react5.default.createElement("a", props),
-    img: (props) => import_react5.default.createElement("img", props),
+    a: (props) => import_react6.default.createElement("a", props),
+    img: (props) => import_react6.default.createElement("img", props),
     // Blockquotes
-    blockquote: (props) => import_react5.default.createElement("blockquote", props),
+    blockquote: (props) => import_react6.default.createElement("blockquote", props),
     // Tables
-    table: (props) => import_react5.default.createElement("table", props),
-    thead: (props) => import_react5.default.createElement("thead", props),
-    tbody: (props) => import_react5.default.createElement("tbody", props),
-    tr: (props) => import_react5.default.createElement("tr", props),
-    th: (props) => import_react5.default.createElement("th", props),
-    td: (props) => import_react5.default.createElement("td", props),
+    table: (props) => import_react6.default.createElement("table", props),
+    thead: (props) => import_react6.default.createElement("thead", props),
+    tbody: (props) => import_react6.default.createElement("tbody", props),
+    tr: (props) => import_react6.default.createElement("tr", props),
+    th: (props) => import_react6.default.createElement("th", props),
+    td: (props) => import_react6.default.createElement("td", props),
     // Generic
-    div: (props) => import_react5.default.createElement("div", props)
+    div: (props) => import_react6.default.createElement("div", props)
   };
 }
 function getDefaultTableElements(overrides) {
   const base = {
-    Table: (props) => import_react5.default.createElement("table", props),
-    Thead: (props) => import_react5.default.createElement("thead", props),
-    Tbody: (props) => import_react5.default.createElement("tbody", props),
-    Tr: (props) => import_react5.default.createElement("tr", props),
-    Th: (props) => import_react5.default.createElement("th", props),
-    Td: (props) => import_react5.default.createElement("td", props)
+    Table: (props) => import_react6.default.createElement("table", props),
+    Thead: (props) => import_react6.default.createElement("thead", props),
+    Tbody: (props) => import_react6.default.createElement("tbody", props),
+    Tr: (props) => import_react6.default.createElement("tr", props),
+    Th: (props) => import_react6.default.createElement("th", props),
+    Td: (props) => import_react6.default.createElement("td", props)
   };
   return { ...base, ...overrides || {} };
 }
@@ -1845,12 +2174,12 @@ function mapHtmlToReact(html, elements) {
       children.push(element);
     }
   });
-  return import_react5.default.createElement(import_react5.default.Fragment, {}, ...children);
+  return import_react6.default.createElement(import_react6.default.Fragment, {}, ...children);
 }
 function toReact(node, elements, key) {
   if (node.nodeType === Node.TEXT_NODE) {
     const text = node.textContent ?? "";
-    return import_react5.default.createElement(import_react5.default.Fragment, { key }, text);
+    return import_react6.default.createElement(import_react6.default.Fragment, { key }, text);
   }
   if (node.nodeType !== Node.ELEMENT_NODE) {
     return null;
@@ -1872,9 +2201,9 @@ function toReact(node, elements, key) {
   const component = elements[tag];
   const elementChildren = children.length > 0 ? children : void 0;
   if (component) {
-    return import_react5.default.createElement(component, { ...props, key }, elementChildren);
+    return import_react6.default.createElement(component, { ...props, key }, elementChildren);
   }
-  return import_react5.default.createElement(tag, { ...props, key }, elementChildren);
+  return import_react6.default.createElement(tag, { ...props, key }, elementChildren);
 }
 function attrsToProps(attrs) {
   if (!attrs) return {};
@@ -1919,12 +2248,12 @@ function renderParagraphMixedSegments(segments, inlineComponents, inlineHtmlRend
     nodes.forEach((node, idx) => {
       if (node === null || node === void 0) return;
       const key = `${baseKey}-${idx}`;
-      if (import_react5.default.isValidElement(node)) {
-        target.push(node.key === key ? node : import_react5.default.cloneElement(node, { key }));
+      if (import_react6.default.isValidElement(node)) {
+        target.push(node.key === key ? node : import_react6.default.cloneElement(node, { key }));
       } else if (typeof node === "string" || typeof node === "number") {
-        target.push(import_react5.default.createElement(import_react5.default.Fragment, { key }, node));
+        target.push(import_react6.default.createElement(import_react6.default.Fragment, { key }, node));
       } else {
-        target.push(import_react5.default.createElement(import_react5.default.Fragment, { key }, node));
+        target.push(import_react6.default.createElement(import_react6.default.Fragment, { key }, node));
       }
     });
   };
@@ -1940,7 +2269,7 @@ function renderParagraphMixedSegments(segments, inlineComponents, inlineHtmlRend
     }
     const key = `paragraph-inline-group-${inlineGroupIndex++}`;
     result.push(
-      import_react5.default.createElement(
+      import_react6.default.createElement(
         "p",
         {
           key,
@@ -1958,7 +2287,7 @@ function renderParagraphMixedSegments(segments, inlineComponents, inlineHtmlRend
         const inlineNodes = Array.isArray(segment.inline) ? segment.inline : [];
         if (inlineNodes.length === 0) {
           if (segment.value) {
-            inlineBuffer.push(import_react5.default.createElement(import_react5.default.Fragment, { key }, segment.value));
+            inlineBuffer.push(import_react6.default.createElement(import_react6.default.Fragment, { key }, segment.value));
           }
           break;
         }
@@ -1986,14 +2315,14 @@ function renderParagraphMixedSegments(segments, inlineComponents, inlineHtmlRend
         const status = segment.status ?? "pending";
         let element;
         if (status === "compiled") {
-          element = import_react5.default.createElement("span", { className: "markdown-mdx-inline", "data-mdx-status": "compiled" });
+          element = import_react6.default.createElement("span", { className: "markdown-mdx-inline", "data-mdx-status": "compiled" });
         } else if (status === "error") {
           const message = segment.value || "MDX error";
-          element = import_react5.default.createElement("span", { className: "markdown-mdx-inline text-destructive", "data-mdx-status": "error" }, message);
+          element = import_react6.default.createElement("span", { className: "markdown-mdx-inline text-destructive", "data-mdx-status": "error" }, message);
         } else {
-          element = import_react5.default.createElement("span", { className: "markdown-mdx-inline", "data-mdx-status": status }, segment.value);
+          element = import_react6.default.createElement("span", { className: "markdown-mdx-inline", "data-mdx-status": status }, segment.value);
         }
-        inlineBuffer.push(import_react5.default.createElement(import_react5.default.Fragment, { key }, element));
+        inlineBuffer.push(import_react6.default.createElement(import_react6.default.Fragment, { key }, element));
         break;
       }
       case "html": {
@@ -2009,7 +2338,7 @@ function renderParagraphMixedSegments(segments, inlineComponents, inlineHtmlRend
             result.push(element);
           } else if (html) {
             result.push(
-              import_react5.default.createElement("div", {
+              import_react6.default.createElement("div", {
                 key,
                 className: "markdown-inline-html-block",
                 dangerouslySetInnerHTML: { __html: html }
@@ -2028,7 +2357,7 @@ function renderParagraphMixedSegments(segments, inlineComponents, inlineHtmlRend
   flushInline();
   if (result.length === 0) {
     return [
-      import_react5.default.createElement(
+      import_react6.default.createElement(
         "p",
         {
           key: "paragraph-inline-group-0",
@@ -2090,20 +2419,21 @@ var BLOCK_LEVEL_TAGS = /* @__PURE__ */ new Set([
 init_mdx_client();
 
 // src/mdx-coordinator.ts
-var import_react6 = require("react");
+var import_react7 = require("react");
 init_mdx_client();
 function useMdxCoordinator(blocks, compileEndpoint, options) {
-  const mdxClientRef = (0, import_react6.useRef)(getMDXClient(compileEndpoint));
+  const mdxClientRef = (0, import_react7.useRef)(getMDXClient(compileEndpoint));
   const mode = options?.mode ?? "server";
-  const [compiledMap, setCompiledMap] = (0, import_react6.useState)(/* @__PURE__ */ new Map());
-  const blockSignatureRef = (0, import_react6.useRef)(/* @__PURE__ */ new Map());
-  const applyCompiledRef = (0, import_react6.useCallback)(
+  const [compiledMap, setCompiledMap] = (0, import_react7.useState)(/* @__PURE__ */ new Map());
+  const blockSignatureRef = (0, import_react7.useRef)(/* @__PURE__ */ new Map());
+  const failedSignatureRef = (0, import_react7.useRef)(/* @__PURE__ */ new Map());
+  const applyCompiledRef = (0, import_react7.useCallback)(
     (block, compiledId) => {
       if (mode === "worker") {
         return;
       }
       if (options?.workerClient) {
-        options.workerClient.setMdxCompiled(block.id, compiledId);
+        options.workerClient.setMdxCompiled(block.id, compiledId, block.payload.raw ?? "");
         return;
       }
       const store = options?.store;
@@ -2114,6 +2444,9 @@ function useMdxCoordinator(blocks, compileEndpoint, options) {
       const index = currentBlocks.findIndex((candidate) => candidate.id === block.id);
       if (index === -1) return;
       const current = currentBlocks[index];
+      if ((current.payload.raw ?? "") !== (block.payload.raw ?? "")) {
+        return;
+      }
       if (current.payload.compiledMdxRef?.id === compiledId) {
         return;
       }
@@ -2139,11 +2472,17 @@ function useMdxCoordinator(blocks, compileEndpoint, options) {
     },
     [options?.workerClient, options?.store, mode]
   );
-  (0, import_react6.useEffect)(() => {
+  (0, import_react7.useEffect)(() => {
     if (mode === "worker") {
       return;
     }
-    const targets = blocks.filter((b) => b.type === "mdx" && b.isFinalized && !b.payload.compiledMdxRef && !compiledMap.has(b.id));
+    const targets = blocks.filter((b) => {
+      if (b.type !== "mdx" || !b.isFinalized || b.payload.compiledMdxRef || compiledMap.has(b.id)) {
+        return false;
+      }
+      const raw = b.payload.raw ?? "";
+      return failedSignatureRef.current.get(b.id) !== raw;
+    });
     if (targets.length === 0) return;
     let cancelled = false;
     (async () => {
@@ -2162,22 +2501,29 @@ function useMdxCoordinator(blocks, compileEndpoint, options) {
             next.set(block.id, compiled.id);
             return next;
           });
+          failedSignatureRef.current.delete(block.id);
           applyCompiledRef(block, compiled.id);
         } catch (e) {
           console.warn("MDX compile failed for block", block.id, e);
+          failedSignatureRef.current.set(block.id, block.payload.raw ?? "");
           if (options?.workerClient) {
-            options.workerClient.setMdxError(block.id, e instanceof Error ? e.message : String(e));
+            options.workerClient.setMdxError(block.id, e instanceof Error ? e.message : String(e), block.payload.raw ?? "");
           } else if (options?.store) {
+            const currentBlocks = options.store.getBlocks();
+            const current = currentBlocks.find((candidate) => candidate.id === block.id);
+            if (!current || (current.payload.raw ?? "") !== (block.payload.raw ?? "")) {
+              continue;
+            }
             options.store.applyPatches([
               {
                 op: "setProps",
                 at: { blockId: block.id, nodeId: block.id },
                 props: {
                   block: {
-                    ...block,
+                    ...current,
                     payload: {
-                      ...block.payload,
-                      meta: { ...block.payload.meta ?? {}, mdxStatus: "error", mdxError: e instanceof Error ? e.message : String(e) }
+                      ...current.payload,
+                      meta: { ...current.payload.meta ?? {}, mdxStatus: "error", mdxError: e instanceof Error ? e.message : String(e) }
                     }
                   }
                 }
@@ -2191,7 +2537,7 @@ function useMdxCoordinator(blocks, compileEndpoint, options) {
       cancelled = true;
     };
   }, [blocks, compiledMap, applyCompiledRef, options?.workerClient, options?.store, mode]);
-  (0, import_react6.useEffect)(() => {
+  (0, import_react7.useEffect)(() => {
     if (mode === "worker") {
       return;
     }
@@ -2210,6 +2556,7 @@ function useMdxCoordinator(blocks, compileEndpoint, options) {
         const currentSignature = candidate.payload.raw ?? "";
         if (previousSignature !== void 0 && previousSignature !== currentSignature) {
           next.delete(blockId);
+          failedSignatureRef.current.delete(blockId);
           mutated = true;
         }
       }
@@ -2219,11 +2566,14 @@ function useMdxCoordinator(blocks, compileEndpoint, options) {
     for (const block of blocks) {
       if (block.type === "mdx") {
         signatureMap.set(block.id, block.payload.raw ?? "");
+        if (!block.isFinalized || block.payload.compiledMdxRef) {
+          failedSignatureRef.current.delete(block.id);
+        }
       }
     }
     blockSignatureRef.current = signatureMap;
   }, [blocks, mode]);
-  const derivedBlocks = (0, import_react6.useMemo)(() => {
+  const derivedBlocks = (0, import_react7.useMemo)(() => {
     if (mode === "worker") {
       return blocks;
     }
@@ -2406,7 +2756,7 @@ async function prefetchMdxBundle(request) {
 }
 
 // src/math/display-wrapper.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
+var import_jsx_runtime3 = require("react/jsx-runtime");
 var BASE_CLASS = "katex-block-wrapper my-2";
 var SCROLL_ROOT_CLASS = "katex-scroll relative overflow-x-hidden w-full max-w-full";
 var VIEWPORT_CLASS = "katex-scroll-viewport h-full w-full rounded-[inherit]";
@@ -2421,27 +2771,30 @@ function combineClassNames(base, extra) {
 }
 function DisplayMathWrapper({ children, className = "" }) {
   const wrapperClass = combineClassNames(BASE_CLASS, className);
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: wrapperClass, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { dir: "ltr", className: SCROLL_ROOT_CLASS, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: VIEWPORT_CLASS, style: VIEWPORT_STYLE, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: SHIM_STYLE, children }) }) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: wrapperClass, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { dir: "ltr", className: SCROLL_ROOT_CLASS, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: VIEWPORT_CLASS, style: VIEWPORT_STYLE, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: SHIM_STYLE, children }) }) }) });
 }
 function renderDisplayMathWithHtml(html, className) {
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(DisplayMathWrapper, { className, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "katex-block", dangerouslySetInnerHTML: { __html: html } }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(DisplayMathWrapper, { className, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "katex-block", dangerouslySetInnerHTML: { __html: html } }) });
 }
 
 // src/renderer.tsx
-var import_react13 = __toESM(require("react"), 1);
+var import_react14 = __toESM(require("react"), 1);
 var import_worker = require("@stream-mdx/worker");
 init_mdx_client();
 
 // src/renderer/code-highlight-context.tsx
-var import_react7 = __toESM(require("react"), 1);
-var CodeHighlightRequestContext = import_react7.default.createContext(null);
+var import_react8 = __toESM(require("react"), 1);
+var CodeHighlightRequestContext = import_react8.default.createContext(null);
 function useCodeHighlightRequester() {
-  return import_react7.default.useContext(CodeHighlightRequestContext);
+  return import_react8.default.useContext(CodeHighlightRequestContext);
 }
 
 // src/renderer/patch-batching.ts
 var import_patch_batching = require("@stream-mdx/core/perf/patch-batching");
 
+// src/renderer/patch-commit-scheduler.ts
+var import_patch_batching2 = require("@stream-mdx/core/perf/patch-batching");
+
 // src/renderer/patch-coalescing.ts
 var import_core3 = require("@stream-mdx/core");
 
@@ -2452,6 +2805,9 @@ var COALESCING_DURATION_ACTIVATE_MS = 6;
 var COALESCING_DURATION_DEACTIVATE_MS = 4;
 var RETAIN_TOUCHED_IN_HISTORY = typeof process !== "undefined" && process.env ? process.env.NODE_ENV !== "production" : true;
 var EMPTY_TOUCHED_SET = /* @__PURE__ */ new Set();
+function shouldSkipCoalescing(patches) {
+  return patches.length <= 1;
+}
 function getDefaultNow() {
   if (typeof performance !== "undefined" && typeof performance.now === "function") {
     return () => performance.now();
@@ -2478,8 +2834,9 @@ function getDefaultCancelRaf() {
 }
 var PatchCommitScheduler = class {
   constructor(params) {
-    this.highQueue = [];
-    this.lowQueue = [];
+    this.semanticQueue = [];
+    this.enrichmentHighQueue = [];
+    this.enrichmentLowQueue = [];
     this.scheduled = false;
     this.flushing = false;
     this.scheduledHandle = null;
@@ -2491,6 +2848,7 @@ var PatchCommitScheduler = class {
     this.scheduleToken = 0;
     this.coalescingDurationSamples = [];
     this.adaptiveBudgetActive = false;
+    this.flushCount = 0;
     this.store = params.store;
     this.onFlush = params.onFlush;
     this.frameBudgetMs = Math.max(1, params.options?.frameBudgetMs ?? 10);
@@ -2506,6 +2864,8 @@ var PatchCommitScheduler = class {
     this.maxLowPriorityBatchesPerFlush = params.options?.maxLowPriorityBatchesPerFlush ?? 2;
     this.urgentQueueThreshold = Math.max(1, params.options?.urgentQueueThreshold ?? 4);
     this.historyLimit = Math.max(1, params.options?.historyLimit ?? 200);
+    this.startupMicrotaskFlushes = Math.max(0, Math.floor(params.options?.startupMicrotaskFlushes ?? 0));
+    this.adaptiveBudgeting = params.options?.adaptiveBudgeting ?? true;
     const requestedBatch = params.options?.batch;
     if (requestedBatch === "microtask") {
       this.batchStrategy = "microtask";
@@ -2532,19 +2892,23 @@ var PatchCommitScheduler = class {
       patches: input.patches,
       meta: input.meta ?? {},
       receivedAt: input.meta?.receivedAt ?? this.now(),
+      kind: input.meta?.kind === "semantic" || input.meta?.kind === "enrichment" ? input.meta.kind : input.patches.some((patch) => (0, import_patch_batching2.getPatchKind)(patch) === "semantic") ? "semantic" : "enrichment",
       priority: input.meta?.priority === "low" ? "low" : "high"
     };
-    if (batch.priority === "low") {
-      this.lowQueue.push(batch);
+    if (batch.kind === "semantic") {
+      batch.priority = "high";
+      this.semanticQueue.push(batch);
+    } else if (batch.priority === "low") {
+      this.enrichmentLowQueue.push(batch);
     } else {
-      this.highQueue.push(batch);
+      this.enrichmentHighQueue.push(batch);
     }
     if (!this.paused) {
       this.schedule();
     }
   }
   flushAll() {
-    if (this.highQueue.length === 0 && this.lowQueue.length === 0 && !this.flushing) {
+    if (this.semanticQueue.length === 0 && this.enrichmentHighQueue.length === 0 && this.enrichmentLowQueue.length === 0 && !this.flushing) {
       return null;
     }
     this.cancelScheduled();
@@ -2554,9 +2918,11 @@ var PatchCommitScheduler = class {
   }
   clear() {
     this.cancelScheduled();
-    this.highQueue = [];
-    this.lowQueue = [];
+    this.semanticQueue = [];
+    this.enrichmentHighQueue = [];
+    this.enrichmentLowQueue = [];
     this.flushing = false;
+    this.flushCount = 0;
     this.coalescingDurationSamples = [];
     this.adaptiveBudgetActive = false;
     this.adaptiveHighBatchCap = void 0;
@@ -2564,10 +2930,10 @@ var PatchCommitScheduler = class {
     this.maybeResolveIdle();
   }
   getPendingCount() {
-    return this.highQueue.length + this.lowQueue.length;
+    return this.semanticQueue.length + this.enrichmentHighQueue.length + this.enrichmentLowQueue.length;
   }
   isIdle() {
-    return !this.flushing && !this.scheduled && this.highQueue.length === 0 && this.lowQueue.length === 0;
+    return !this.flushing && !this.scheduled && this.semanticQueue.length === 0 && this.enrichmentHighQueue.length === 0 && this.enrichmentLowQueue.length === 0;
   }
   awaitIdle() {
     if (this.isIdle()) {
@@ -2607,7 +2973,8 @@ var PatchCommitScheduler = class {
       this.runFlush(this.frameBudgetMs, false);
       this.maybeResolveIdle();
     };
-    if (this.batchStrategy === "microtask" && typeof queueMicrotask === "function") {
+    const useStartupMicrotask = this.batchStrategy !== "microtask" && this.startupMicrotaskFlushes > 0 && this.flushCount < this.startupMicrotaskFlushes && typeof queueMicrotask === "function";
+    if ((this.batchStrategy === "microtask" || useStartupMicrotask) && typeof queueMicrotask === "function") {
       this.scheduledViaRaf = false;
       this.scheduledHandle = token;
       queueMicrotask(execute);
@@ -2637,12 +3004,14 @@ var PatchCommitScheduler = class {
     if (this.paused && !manual) {
       return null;
     }
-    if (this.highQueue.length === 0 && this.lowQueue.length === 0) {
+    if (this.semanticQueue.length === 0 && this.enrichmentHighQueue.length === 0 && this.enrichmentLowQueue.length === 0) {
       return null;
     }
     this.flushing = true;
     const startedAt = this.now();
-    const initialQueueSize = this.highQueue.length + this.lowQueue.length;
+    const initialSemanticQueueSize = this.semanticQueue.length;
+    const initialEnrichmentQueueSize = this.enrichmentHighQueue.length + this.enrichmentLowQueue.length;
+    const initialQueueSize = initialSemanticQueueSize + initialEnrichmentQueueSize;
     const batches = [];
     let totalInputPatches = 0;
     let totalAppliedPatches = 0;
@@ -2657,7 +3026,15 @@ var PatchCommitScheduler = class {
         consumed += 1;
         const applyStart = this.now();
         const queueDelayMs = Math.max(0, applyStart - next.receivedAt);
-        const { patches: coalesced, metrics: coalescingMetrics } = (0, import_core3.coalescePatchesWithMetrics)(next.patches, import_core3.DEFAULT_COALESCE_CONFIG);
+        let coalesced;
+        let coalescingMetrics;
+        if (shouldSkipCoalescing(next.patches)) {
+          coalesced = next.patches;
+        } else {
+          const result = (0, import_core3.coalescePatchesWithMetrics)(next.patches, import_core3.DEFAULT_COALESCE_CONFIG);
+          coalesced = result.patches;
+          coalescingMetrics = result.metrics;
+        }
         const touched = this.store.applyPatches(coalesced, {
           coalesced: true,
           metrics: coalescingMetrics
@@ -2677,6 +3054,7 @@ var PatchCommitScheduler = class {
           receivedAt: next.receivedAt,
           appliedAt: applyStart,
           priority: next.priority,
+          kind: next.kind,
           coalescing: coalescingMetrics
         });
         if (maxBatches && batches.length - startingBatchCount >= maxBatches) {
@@ -2693,27 +3071,32 @@ var PatchCommitScheduler = class {
         queue.splice(0, consumed);
       }
     };
-    const initialHighQueueSize = this.highQueue.length;
+    processQueue(this.semanticQueue, void 0, Number.POSITIVE_INFINITY);
+    const initialHighQueueSize = this.enrichmentHighQueue.length;
     const configuredHighLimit = manual || !this.maxBatchesPerFlush ? void 0 : initialHighQueueSize > this.maxBatchesPerFlush ? void 0 : this.maxBatchesPerFlush;
-    const highBatchLimit = this.adaptiveHighBatchCap ?? configuredHighLimit;
-    processQueue(this.highQueue, highBatchLimit, budgetMs);
+    const highBatchLimit = this.adaptiveBudgeting ? this.adaptiveHighBatchCap ?? configuredHighLimit : configuredHighLimit;
+    processQueue(this.enrichmentHighQueue, highBatchLimit, budgetMs);
     if (manual) {
-      processQueue(this.lowQueue, void 0, Number.POSITIVE_INFINITY);
-    } else if (this.lowQueue.length > 0) {
+      processQueue(this.enrichmentLowQueue, void 0, Number.POSITIVE_INFINITY);
+    } else if (this.enrichmentLowQueue.length > 0) {
       elapsed = this.now() - startedAt;
       const budgetForLow = Math.max(0, this.lowPriorityFrameBudgetMs - elapsed);
-      if (budgetForLow > 0) {
-        const initialLowQueueSize = this.lowQueue.length;
+      const processedHigherPriorityWork = batches.length > 0;
+      if (budgetForLow > 0 || !processedHigherPriorityWork) {
+        const initialLowQueueSize = this.enrichmentLowQueue.length;
         const configuredLowLimit = manual || !this.maxLowPriorityBatchesPerFlush ? void 0 : initialLowQueueSize > this.maxLowPriorityBatchesPerFlush ? void 0 : this.maxLowPriorityBatchesPerFlush;
-        const lowBatchLimit = this.adaptiveLowBatchCap ?? configuredLowLimit;
-        processQueue(this.lowQueue, lowBatchLimit, budgetForLow);
+        const lowBatchLimit = this.adaptiveBudgeting ? this.adaptiveLowBatchCap ?? configuredLowLimit : configuredLowLimit;
+        processQueue(this.enrichmentLowQueue, lowBatchLimit, budgetForLow);
       }
     }
     this.flushing = false;
     const completedAt = this.now();
     const totalDurationMs = completedAt - startedAt;
-    const remaining = this.highQueue.length + this.lowQueue.length;
+    const remainingSemantic = this.semanticQueue.length;
+    const remainingEnrichment = this.enrichmentHighQueue.length + this.enrichmentLowQueue.length;
+    const remaining = remainingSemantic + remainingEnrichment;
     if (batches.length > 0) {
+      this.flushCount += 1;
       try {
         this.onFlush({
           batches,
@@ -2721,7 +3104,11 @@ var PatchCommitScheduler = class {
           totalAppliedPatches,
           totalDurationMs,
           remainingQueueSize: remaining,
+          remainingSemanticQueueSize: remainingSemantic,
+          remainingEnrichmentQueueSize: remainingEnrichment,
           queueDepthBefore: initialQueueSize,
+          semanticQueueDepthBefore: initialSemanticQueueSize,
+          enrichmentQueueDepthBefore: initialEnrichmentQueueSize,
           flushStartedAt: startedAt,
           flushCompletedAt: completedAt
         });
@@ -2732,21 +3119,27 @@ var PatchCommitScheduler = class {
     if (remaining > 0 && !this.paused) {
       this.schedule();
     }
-    const coalescingStats = this.computeCoalescingDurationStats();
-    this.updateAdaptiveBudget(coalescingStats.p95);
-    const adaptiveState = this.snapshotAdaptiveBudget(coalescingStats.p95 ?? null);
+    const coalescingStats = this.adaptiveBudgeting ? this.computeCoalescingDurationStats() : { sampleCount: this.coalescingDurationSamples.length, p95: null };
+    if (this.adaptiveBudgeting) {
+      this.updateAdaptiveBudget(coalescingStats.p95);
+    }
+    const adaptiveState = this.adaptiveBudgeting ? this.snapshotAdaptiveBudget(coalescingStats.p95 ?? null) : void 0;
     const flushResult = batches.length > 0 ? {
       batches,
       totalPatches: totalInputPatches,
       totalAppliedPatches,
       totalDurationMs,
       remainingQueueSize: remaining,
+      remainingSemanticQueueSize: remainingSemantic,
+      remainingEnrichmentQueueSize: remainingEnrichment,
       queueDepthBefore: initialQueueSize,
+      semanticQueueDepthBefore: initialSemanticQueueSize,
+      enrichmentQueueDepthBefore: initialEnrichmentQueueSize,
       flushStartedAt: startedAt,
       flushCompletedAt: completedAt,
       coalescingDurationP95: coalescingStats.p95 ?? void 0,
       coalescingDurationSampleCount: coalescingStats.sampleCount,
-      adaptiveBudgetActive: adaptiveState.active,
+      adaptiveBudgetActive: adaptiveState?.active,
       adaptiveBudgetState: adaptiveState
     } : null;
     if (flushResult) {
@@ -2782,6 +3175,9 @@ var PatchCommitScheduler = class {
     };
   }
   updateAdaptiveBudget(p95) {
+    if (!this.adaptiveBudgeting) {
+      return;
+    }
     if (p95 !== null && p95 > COALESCING_DURATION_ACTIVATE_MS) {
       if (!this.adaptiveBudgetActive) {
         this.adaptiveBudgetActive = true;
@@ -2855,11 +3251,13 @@ var PatchCommitScheduler = class {
   }
   restart() {
     this.cancelScheduled();
-    this.highQueue = [];
-    this.lowQueue = [];
+    this.semanticQueue = [];
+    this.enrichmentHighQueue = [];
+    this.enrichmentLowQueue = [];
     this.flushing = false;
     this.sequence = 0;
     this.history = [];
+    this.flushCount = 0;
     this.scheduleToken++;
     this.paused = false;
     this.coalescingDurationSamples = [];
@@ -2906,6 +3304,12 @@ var PatchCommitScheduler = class {
     if (typeof options.historyLimit !== "undefined") {
       this.setHistoryLimit(options.historyLimit);
     }
+    if (typeof options.startupMicrotaskFlushes !== "undefined") {
+      this.startupMicrotaskFlushes = Math.max(0, Math.floor(options.startupMicrotaskFlushes));
+    }
+    if (typeof options.adaptiveBudgeting !== "undefined") {
+      this.adaptiveBudgeting = options.adaptiveBudgeting;
+    }
     if (typeof options.batch !== "undefined") {
       const requestedBatch = options.batch;
       if (requestedBatch === "microtask") {
@@ -2932,6 +3336,7 @@ var PatchCommitScheduler = class {
 
 // src/renderer/store.ts
 var import_core4 = require("@stream-mdx/core");
+var import_patch_batching3 = require("@stream-mdx/core/perf/patch-batching");
 
 // src/renderer/list-utils.ts
 function updateNodeDepth(node, depth) {
@@ -3027,12 +3432,28 @@ function snapshotToBlock(node) {
   }
   return null;
 }
-var nodeSnapshotCache = /* @__PURE__ */ new Map();
-var childrenSnapshotCache = /* @__PURE__ */ new Map();
+var nodeSnapshotCacheByMap = /* @__PURE__ */ new WeakMap();
+var childrenSnapshotCacheByMap = /* @__PURE__ */ new WeakMap();
 var NODE_SNAPSHOT_CACHE_LIMIT = 5e4;
 var CHILDREN_SNAPSHOT_CACHE_LIMIT = 5e4;
 var NODE_SNAPSHOT_CACHE_BUFFER = Math.max(200, Math.floor(NODE_SNAPSHOT_CACHE_LIMIT * 0.1));
 var CHILDREN_SNAPSHOT_CACHE_BUFFER = Math.max(200, Math.floor(CHILDREN_SNAPSHOT_CACHE_LIMIT * 0.1));
+function getNodeSnapshotCacheForMap(map) {
+  let cache = nodeSnapshotCacheByMap.get(map);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    nodeSnapshotCacheByMap.set(map, cache);
+  }
+  return cache;
+}
+function getChildrenSnapshotCacheForMap(map) {
+  let cache = childrenSnapshotCacheByMap.get(map);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    childrenSnapshotCacheByMap.set(map, cache);
+  }
+  return cache;
+}
 function pruneCache(cache, max, buffer) {
   if (cache.size <= max + buffer) return;
   let remaining = cache.size - max;
@@ -3042,6 +3463,14 @@ function pruneCache(cache, max, buffer) {
     if (remaining <= 0) break;
   }
 }
+function deleteSnapshotCacheEntry(map, id) {
+  getNodeSnapshotCacheForMap(map).delete(id);
+  getChildrenSnapshotCacheForMap(map).delete(id);
+}
+function clearSnapshotCaches(map) {
+  getNodeSnapshotCacheForMap(map).clear();
+  getChildrenSnapshotCacheForMap(map).clear();
+}
 var EMPTY_CHILDREN = Object.freeze([]);
 var EMPTY_NODE_SNAPSHOT = Object.freeze({ version: -1, node: void 0 });
 var EMPTY_CHILDREN_SNAPSHOT = Object.freeze({
@@ -3209,9 +3638,57 @@ function createRootRecord() {
     parentId: null,
     children: [],
     props: {},
-    version: 0
+    version: 0,
+    blockEpoch: 0
   };
 }
+function readNumericEpoch(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return void 0;
+  }
+  return value;
+}
+function readSnapshotBlockEpoch(snapshot) {
+  return readNumericEpoch(snapshot.meta?.blockEpoch);
+}
+function readPatchBlockEpoch(patch) {
+  if (patch.op === "setHTML") {
+    return readNumericEpoch(patch.patchMeta?.blockEpoch);
+  }
+  return readNumericEpoch(patch.meta?.blockEpoch);
+}
+function readPatchParseEpoch(patch) {
+  if (patch.op === "setHTML") {
+    return readNumericEpoch(patch.patchMeta?.parseEpoch);
+  }
+  return readNumericEpoch(patch.meta?.parseEpoch);
+}
+function readPatchTx(patch) {
+  if (patch.op === "setHTML") {
+    return readNumericEpoch(patch.patchMeta?.tx);
+  }
+  return readNumericEpoch(patch.meta?.tx);
+}
+function assignSubtreeBlockEpoch(map, rootId, blockEpoch, touched) {
+  const root = map.get(rootId);
+  if (!root) return;
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) continue;
+    if (node.blockEpoch !== blockEpoch) {
+      node.blockEpoch = blockEpoch;
+      node.version += 1;
+      touched?.add(node.id);
+    }
+    for (const childId of node.children) {
+      const child = map.get(childId);
+      if (child) {
+        stack.push(child);
+      }
+    }
+  }
+}
 function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
@@ -3271,7 +3748,7 @@ function escapeHtml2(value) {
 }
 function stripOuterLineSpan(html) {
   if (!html) return null;
-  const openTagMatch = html.match(/<span[^>]*>/i);
+  const openTagMatch = html.match(/<span[^>]*class="[^"]*\bline\b[^"]*"[^>]*>/i);
   if (!openTagMatch) {
     return null;
   }
@@ -3320,8 +3797,7 @@ function normalizeCodeBlockChildren(nodes, parent, touched) {
     if (node.type !== "code-line") {
       anomalies.push(`type-mismatch:${node.id}:${node.type}`);
       nodes.delete(node.id);
-      nodeSnapshotCache.delete(node.id);
-      childrenSnapshotCache.delete(node.id);
+      deleteSnapshotCacheEntry(nodes, node.id);
       touched.add(node.id);
       continue;
     }
@@ -3365,16 +3841,14 @@ function normalizeCodeBlockChildren(nodes, parent, touched) {
     const existing = nodes.get(desiredId);
     if (existing && existing !== node) {
       nodes.delete(desiredId);
-      nodeSnapshotCache.delete(desiredId);
-      childrenSnapshotCache.delete(desiredId);
+      deleteSnapshotCacheEntry(nodes, desiredId);
       touched.add(desiredId);
       mutated = true;
     }
     if (node.id !== desiredId) {
       const previousId = node.id;
       nodes.delete(node.id);
-      nodeSnapshotCache.delete(previousId);
-      childrenSnapshotCache.delete(previousId);
+      deleteSnapshotCacheEntry(nodes, previousId);
       node.id = desiredId;
       nodes.set(desiredId, node);
       touched.add(desiredId);
@@ -3405,8 +3879,7 @@ function normalizeCodeBlockChildren(nodes, parent, touched) {
   for (const [id, record] of nodes) {
     if (record.parentId === parent.id && record.type === "code-line" && !allowed.has(id)) {
       nodes.delete(id);
-      nodeSnapshotCache.delete(id);
-      childrenSnapshotCache.delete(id);
+      deleteSnapshotCacheEntry(nodes, id);
       touched.add(id);
       mutated = true;
     }
@@ -3490,8 +3963,10 @@ function normalizeCodeLineProps(incoming, previous) {
 }
 function createCodeLineProps(index, text, highlight, tokens) {
   const safeText = typeof text === "string" ? text : "";
-  const sanitized = sanitizeLineInnerHtml(highlight, safeText);
-  const html = sanitized && sanitized.length >= safeText.length ? sanitized : escapeHtml2(safeText);
+  const hasIncomingHighlight = typeof highlight === "string" && highlight.trim().length > 0;
+  const sanitized = hasIncomingHighlight ? sanitizeLineInnerHtml(highlight, safeText) : null;
+  const hasRenderableTokens = tokens !== void 0 && tokens !== null;
+  const html = sanitized && sanitized.length >= safeText.length ? sanitized : hasRenderableTokens ? null : escapeHtml2(safeText);
   const props = {
     index,
     text: safeText,
@@ -3602,6 +4077,18 @@ function validateCodeBlockChildren(nodes, parent) {
       issues.push({ kind: "dangling-node", id });
     }
   }
+  if (parent.block?.isFinalized) {
+    const snapshot = (0, import_core4.createBlockSnapshot)((0, import_core4.cloneBlock)(parent.block));
+    const expectedChildren = ensureArray(snapshot.children).filter((child) => child.type === "code-line");
+    if (expectedChildren.length !== parent.children.length) {
+      issues.push({
+        kind: "line-count-mismatch",
+        id: parent.id,
+        expected: expectedChildren.length,
+        actual: parent.children.length
+      });
+    }
+  }
   return { ok: issues.length === 0, issues };
 }
 function rebuildCodeBlockFromSnapshot(nodes, parent, touched, issues) {
@@ -3618,7 +4105,7 @@ function rebuildCodeBlockFromSnapshot(nodes, parent, touched, issues) {
   }
   const snapshot = (0, import_core4.createBlockSnapshot)((0, import_core4.cloneBlock)(parent.block));
   removeSubtree(nodes, parent.id, touched);
-  const inserted = insertSnapshotAt(nodes, ancestor, index, snapshot);
+  const inserted = insertSnapshotAt(nodes, ancestor, index, snapshot, touched, parent.blockEpoch);
   if (!inserted) {
     return false;
   }
@@ -3641,7 +4128,55 @@ function arraysEqual(a, b) {
   }
   return true;
 }
-function buildNodeFromSnapshot(map, snapshot, parentId) {
+function expectedCodeLineId(parentId, index) {
+  return `${parentId}::line:${index}`;
+}
+function collectStoreInvariantViolations(nodes) {
+  const violations = [];
+  for (const [id, node] of nodes) {
+    if (node.type === "__root__") continue;
+    if (node.children.length > 1) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const childId of node.children) {
+        if (seen.has(childId)) {
+          violations.push(`duplicate child id:${id}:${childId}`);
+        } else {
+          seen.add(childId);
+        }
+      }
+    }
+    if (node.type === "list") {
+      const parent = node.parentId ? nodes.get(node.parentId) : void 0;
+      if (parent?.type === "list-item" && node.children.length === 0) {
+        violations.push(`empty nested list:${id}`);
+      }
+    }
+    if (node.type === "code") {
+      for (let index = 0; index < node.children.length; index += 1) {
+        const childId = node.children[index];
+        const child = nodes.get(childId);
+        if (!child) {
+          violations.push(`missing code-line node:${node.id}:${childId}`);
+          continue;
+        }
+        if (child.type !== "code-line") {
+          violations.push(`non-code child in code block:${node.id}:${child.id}:${child.type}`);
+          continue;
+        }
+        const expectedId = expectedCodeLineId(node.id, index);
+        if (child.id !== expectedId) {
+          violations.push(`code-line id mismatch:${node.id}:${child.id}:${expectedId}`);
+        }
+        const indexProp = typeof child.props?.index === "number" ? child.props.index : null;
+        if (indexProp !== index) {
+          violations.push(`code-line index mismatch:${node.id}:${child.id}:${indexProp}:${index}`);
+        }
+      }
+    }
+  }
+  return violations;
+}
+function buildNodeFromSnapshot(map, snapshot, parentId, blockEpoch) {
   const record = {
     id: snapshot.id,
     type: snapshot.type,
@@ -3651,6 +4186,7 @@ function buildNodeFromSnapshot(map, snapshot, parentId) {
     meta: snapshot.meta ? { ...snapshot.meta } : void 0,
     range: snapshot.range ? { ...snapshot.range } : void 0,
     version: 0,
+    blockEpoch,
     block: snapshotToBlock(snapshot) ?? void 0
   };
   if (record.type === "code") {
@@ -3659,7 +4195,7 @@ function buildNodeFromSnapshot(map, snapshot, parentId) {
   map.set(record.id, record);
   const childSnapshots = ensureArray(snapshot.children);
   for (const child of childSnapshots) {
-    const childRecord = buildNodeFromSnapshot(map, child, record.id);
+    const childRecord = buildNodeFromSnapshot(map, child, record.id, blockEpoch);
     record.children.push(childRecord.id);
   }
   return record;
@@ -3687,8 +4223,7 @@ function removeSubtree(map, id, touched) {
       }
     }
     map.delete(node.id);
-    nodeSnapshotCache.delete(node.id);
-    childrenSnapshotCache.delete(node.id);
+    deleteSnapshotCacheEntry(map, node.id);
     touched.add(node.id);
     for (const childId of node.children) {
       const child = map.get(childId);
@@ -3720,13 +4255,13 @@ function resolveParent(map, path) {
   }
   return map.get(path.blockId);
 }
-function insertSnapshotAt(map, parent, index, snapshot, touched) {
+function insertSnapshotAt(map, parent, index, snapshot, touched, blockEpoch) {
   if (!parent) return null;
   const existingIndex = parent.children.indexOf(snapshot.id);
   if (existingIndex !== -1) {
     removeSubtree(map, parent.children[existingIndex], touched ?? /* @__PURE__ */ new Set());
   }
-  const record = buildNodeFromSnapshot(map, snapshot, parent.id);
+  const record = buildNodeFromSnapshot(map, snapshot, parent.id, blockEpoch ?? readSnapshotBlockEpoch(snapshot) ?? parent.blockEpoch);
   const insertedIds = [];
   const queue = [record];
   while (queue.length > 0) {
@@ -3744,13 +4279,13 @@ function insertSnapshotAt(map, parent, index, snapshot, touched) {
   ensureUniqueChildren(parent, touched);
   return { record, insertedIds };
 }
-function replaceSnapshotAt(map, parent, index, snapshot, touched) {
+function replaceSnapshotAt(map, parent, index, snapshot, touched, blockEpoch) {
   if (!parent) return;
   if (index < 0 || index >= parent.children.length) return;
   const targetId = parent.children[index];
   parent.children.splice(index, 1);
   removeSubtree(map, targetId, touched);
-  const inserted = insertSnapshotAt(map, parent, index, snapshot, touched);
+  const inserted = insertSnapshotAt(map, parent, index, snapshot, touched, blockEpoch);
   if (inserted) {
     for (const id of inserted.insertedIds) {
       touched.add(id);
@@ -3770,6 +4305,24 @@ function createRendererStore(initialBlocks = []) {
   const listeners = /* @__PURE__ */ new Set();
   let notifyScheduled = false;
   let lastCoalescingMetrics = null;
+  let invariantViolations = [];
+  let transientDiagnostics = [];
+  let nextBlockEpoch = 1;
+  const debugCounters = {
+    appendLineGuardRejected: 0,
+    staleEpochRejected: 0,
+    storeInvariantViolationCount: 0
+  };
+  const allocateBlockEpoch = (preferred) => {
+    const resolved = readNumericEpoch(preferred);
+    if (resolved !== void 0) {
+      nextBlockEpoch = Math.max(nextBlockEpoch, resolved + 1);
+      return resolved;
+    }
+    const epoch = nextBlockEpoch;
+    nextBlockEpoch += 1;
+    return epoch;
+  };
   const getRaf = () => {
     if (typeof globalThis !== "undefined" && typeof globalThis.requestAnimationFrame === "function") {
       return globalThis.requestAnimationFrame;
@@ -3801,9 +4354,12 @@ function createRendererStore(initialBlocks = []) {
       }
     }
   }
+  function appendDiagnostic(message) {
+    transientDiagnostics = [...transientDiagnostics, message];
+    invariantViolations = [...invariantViolations, message];
+  }
   function rebuildFromBlocks(blocks) {
-    nodeSnapshotCache.clear();
-    childrenSnapshotCache.clear();
+    clearSnapshotCaches(nodes);
     nodes = /* @__PURE__ */ new Map();
     const root = createRootRecord();
     nodes.set(root.id, root);
@@ -3812,9 +4368,12 @@ function createRendererStore(initialBlocks = []) {
     for (let i = 0; i < blocks.length; i++) {
       const block = (0, import_core4.cloneBlock)(blocks[i]);
       const snapshot = (0, import_core4.createBlockSnapshot)(block);
-      insertSnapshotAt(nodes, root, root.children.length, snapshot);
+      insertSnapshotAt(nodes, root, root.children.length, snapshot, void 0, allocateBlockEpoch(readSnapshotBlockEpoch(snapshot)));
     }
     normalizeAllListDepths(nodes, /* @__PURE__ */ new Set(), import_core4.PATCH_ROOT_ID);
+    transientDiagnostics = [];
+    invariantViolations = collectStoreInvariantViolations(nodes);
+    debugCounters.storeInvariantViolationCount += invariantViolations.length;
     version++;
     blocksDirty = true;
     scheduleNotify();
@@ -3879,11 +4438,57 @@ function createRendererStore(initialBlocks = []) {
           listDepthDirty = true;
         }
       };
-      const applyPropsUpdate = (at, props) => {
+      const semanticTxEpochs = /* @__PURE__ */ new Map();
+      const resolveBlockEpochTarget = (patch, at) => {
+        if ((patch.op === "insertChild" || patch.op === "replaceChild") && at.blockId === import_core4.PATCH_ROOT_ID) {
+          const nodeId = patch.node?.id;
+          return nodeId ? nodes.get(nodeId) : void 0;
+        }
+        return nodes.get(at.blockId) ?? (at.nodeId ? nodes.get(at.nodeId) : void 0);
+      };
+      const rejectStaleEpochPatch = (patch, at) => {
+        const expectedBlockEpoch = readPatchBlockEpoch(patch);
+        const patchTx = readPatchTx(patch);
+        if (expectedBlockEpoch === void 0) {
+          return false;
+        }
+        if ((0, import_patch_batching3.getPatchKind)(patch) !== "semantic" || !at) {
+          return false;
+        }
+        const target = resolveBlockEpochTarget(patch, at);
+        if (!target || target.blockEpoch === expectedBlockEpoch) {
+          return false;
+        }
+        const txEpoch = at.blockId && patchTx !== void 0 ? semanticTxEpochs.get(at.blockId) : void 0;
+        if (txEpoch && txEpoch.tx === patchTx && txEpoch.blockEpoch === target.blockEpoch) {
+          return false;
+        }
+        debugCounters.staleEpochRejected += 1;
+        appendDiagnostic(
+          `stale epoch rejected:${patch.op}:${target.id}:expected=${expectedBlockEpoch}:actual=${target.blockEpoch}`
+        );
+        return true;
+      };
+      const advanceBlockEpoch = (blockId, touchedSet, preferredEpoch, tx) => {
+        if (!blockId || blockId === import_core4.PATCH_ROOT_ID) {
+          return null;
+        }
+        const blockRoot = nodes.get(blockId);
+        if (!blockRoot) {
+          return null;
+        }
+        const nextEpoch = allocateBlockEpoch(preferredEpoch);
+        assignSubtreeBlockEpoch(nodes, blockRoot.id, nextEpoch, touchedSet);
+        if (tx !== void 0) {
+          semanticTxEpochs.set(blockRoot.id, { tx, blockEpoch: nextEpoch });
+        }
+        return nextEpoch;
+      };
+      const applyPropsUpdate = (at, props, preferredEpoch, tx, semanticUpdate = false) => {
         const perfStartLocal = perfEnabled ? getPerfNow() : 0;
         const targetId = at.nodeId ?? at.blockId;
         if (!targetId) return;
-        const target = nodes.get(targetId);
+        let target = nodes.get(targetId);
         if (!target) return;
         const parentType = target.parentId ? nodes.get(target.parentId)?.type : void 0;
         if (debugListPatches && (isListRelated(target.type) || isListRelated(parentType))) {
@@ -3910,6 +4515,9 @@ function createRendererStore(initialBlocks = []) {
             propsChanged = true;
           }
           if (propsChanged) {
+            if (semanticUpdate) {
+              advanceBlockEpoch(at.blockId, touched, preferredEpoch, tx);
+            }
             target.version++;
             touched.add(target.id);
             const parent = target.parentId ? nodes.get(target.parentId) : void 0;
@@ -3973,16 +4581,56 @@ function createRendererStore(initialBlocks = []) {
           }
         }
         let blockChanged = false;
+        let typeChanged = false;
+        let rebuiltFromFinalizedBlock = false;
+        let blockEpochAdvanced = false;
         const incomingBlock = props?.block;
         if (incomingBlock && typeof incomingBlock === "object") {
           target.block = (0, import_core4.cloneBlock)(incomingBlock);
+          const previousType = target.type;
+          const incomingType = typeof target.block.type === "string" ? target.block.type : target.type;
+          if (incomingType !== target.type) {
+            target.type = incomingType;
+            typeChanged = true;
+            if (isListRelated(previousType) || isListRelated(target.type)) {
+              markListDepthDirty(target.id);
+            }
+          }
           if (target.type === "code") {
             applyCodeBlockMetadata(target);
           }
+          if (semanticUpdate) {
+            advanceBlockEpoch(at.blockId, touched, preferredEpoch, tx);
+            blockEpochAdvanced = true;
+          }
+          const shouldRebuildFinalizedTree = !at.nodeId && target.id === at.blockId && Boolean(target.block?.isFinalized) && target.type !== "code" && Boolean(target.parentId);
+          if (shouldRebuildFinalizedTree) {
+            const parent = target.parentId ? nodes.get(target.parentId) : void 0;
+            const index = parent ? parent.children.indexOf(target.id) : -1;
+            if (parent && index !== -1) {
+              const snapshot = (0, import_core4.createBlockSnapshot)((0, import_core4.cloneBlock)(target.block));
+              replaceSnapshotAt(nodes, parent, index, snapshot, touched, target.blockEpoch);
+              mutatedBlocks = true;
+              blockChanged = true;
+              rebuiltFromFinalizedBlock = true;
+              const rebuilt = nodes.get(target.id);
+              if (isListRelated(previousType) || isListRelated(rebuilt?.type)) {
+                markListDepthDirty(target.id);
+              }
+              target = rebuilt ?? target;
+            }
+          }
           mutatedBlocks = true;
           blockChanged = true;
         }
-        if (propsChanged || blockChanged) {
+        if (rebuiltFromFinalizedBlock) {
+          return;
+        }
+        if (propsChanged || blockChanged || typeChanged) {
+          if (semanticUpdate && !blockEpochAdvanced) {
+            advanceBlockEpoch(at.blockId, touched, preferredEpoch, tx);
+            blockEpochAdvanced = true;
+          }
           target.version++;
           touched.add(target.id);
           let parentForNormalization;
@@ -4025,13 +4673,22 @@ function createRendererStore(initialBlocks = []) {
       const applyPatch = (patch) => {
         switch (patch.op) {
           case "insertChild": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
             const parent = resolveParent(nodes, patch.at);
-            const inserted = insertSnapshotAt(nodes, parent, patch.index, patch.node, touched);
+            const inserted = insertSnapshotAt(
+              nodes,
+              parent,
+              patch.index,
+              patch.node,
+              touched,
+              allocateBlockEpoch(readPatchParseEpoch(patch) ?? readSnapshotBlockEpoch(patch.node))
+            );
             if (inserted) {
               for (const id of inserted.insertedIds) {
                 touched.add(id);
               }
               mutatedBlocks = true;
+              advanceBlockEpoch(patch.at.blockId, touched, readPatchParseEpoch(patch), readPatchTx(patch));
               if (isListRelated(inserted.record.type) || isListRelated(parent?.type)) {
                 markListDepthDirty(inserted.record.id);
                 if (parent) {
@@ -4051,6 +4708,7 @@ function createRendererStore(initialBlocks = []) {
             break;
           }
           case "deleteChild": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
             const parent = resolveParent(nodes, patch.at);
             if (!parent) break;
             if (patch.index < 0 || patch.index >= parent.children.length) break;
@@ -4062,6 +4720,7 @@ function createRendererStore(initialBlocks = []) {
               touched.add(parent.id);
               ensureUniqueChildren(parent, touched);
               mutatedBlocks = true;
+              advanceBlockEpoch(patch.at.blockId, touched, readPatchParseEpoch(patch), readPatchTx(patch));
               if (isListRelated(parent.type) || isListRelated(removedNode?.type)) {
                 markListDepthDirty(parent.id);
               }
@@ -4078,11 +4737,20 @@ function createRendererStore(initialBlocks = []) {
             break;
           }
           case "replaceChild": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
             const parent = resolveParent(nodes, patch.at);
             if (!parent) break;
-            replaceSnapshotAt(nodes, parent, patch.index, patch.node, touched);
+            replaceSnapshotAt(
+              nodes,
+              parent,
+              patch.index,
+              patch.node,
+              touched,
+              allocateBlockEpoch(readPatchParseEpoch(patch) ?? readSnapshotBlockEpoch(patch.node))
+            );
             touched.add(parent.id);
             mutatedBlocks = true;
+            advanceBlockEpoch(patch.at.blockId, touched, readPatchParseEpoch(patch), readPatchTx(patch));
             if (isListRelated(parent.type)) {
               markListDepthDirty(parent.id);
             }
@@ -4096,18 +4764,33 @@ function createRendererStore(initialBlocks = []) {
             break;
           }
           case "setProps": {
-            applyPropsUpdate(patch.at, patch.props);
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
+            applyPropsUpdate(patch.at, patch.props, readPatchParseEpoch(patch), readPatchTx(patch), (0, import_patch_batching3.getPatchKind)(patch) === "semantic");
             break;
           }
           case "setPropsBatch": {
             const entries2 = Array.isArray(patch.entries) ? patch.entries : [];
             for (const entry of entries2) {
               if (!entry || !entry.at) continue;
-              applyPropsUpdate(entry.at, entry.props);
+              const entryPatch = {
+                op: "setProps",
+                at: entry.at,
+                props: entry.props,
+                meta: entry.meta ?? patch.meta
+              };
+              if (rejectStaleEpochPatch(entryPatch, entry.at)) continue;
+              applyPropsUpdate(
+                entry.at,
+                entry.props,
+                readPatchParseEpoch(entryPatch),
+                readPatchTx(entryPatch),
+                (0, import_patch_batching3.getPatchKind)(entryPatch) === "semantic"
+              );
             }
             break;
           }
           case "finalize": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
             const target = nodes.get(patch.at.nodeId ?? patch.at.blockId);
             if (!target || !target.block) break;
             if (!target.block.isFinalized) {
@@ -4116,6 +4799,17 @@ function createRendererStore(initialBlocks = []) {
               target.version++;
               touched.add(target.id);
               mutatedBlocks = true;
+              if (!patch.at.nodeId && target.id === patch.at.blockId && target.type !== "code" && target.parentId) {
+                const parent = nodes.get(target.parentId);
+                const index = parent ? parent.children.indexOf(target.id) : -1;
+                if (parent && index !== -1) {
+                  const snapshot = (0, import_core4.createBlockSnapshot)((0, import_core4.cloneBlock)(target.block));
+                  replaceSnapshotAt(nodes, parent, index, snapshot, touched, target.blockEpoch);
+                  if (isListRelated(target.type) || isListRelated(snapshot.type)) {
+                    markListDepthDirty(target.id);
+                  }
+                }
+              }
             }
             if (isListRelated(target.type)) {
               markListDepthDirty(target.id);
@@ -4129,6 +4823,7 @@ function createRendererStore(initialBlocks = []) {
             break;
           }
           case "reorder": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
             const parent = resolveParent(nodes, patch.at);
             if (!parent) break;
             const length = parent.children.length;
@@ -4143,6 +4838,9 @@ function createRendererStore(initialBlocks = []) {
             parent.children.splice(to, 0, ...moved);
             parent.version++;
             touched.add(parent.id);
+            if ((0, import_patch_batching3.getPatchKind)(patch) === "semantic") {
+              advanceBlockEpoch(patch.at.blockId, touched, readPatchParseEpoch(patch), readPatchTx(patch));
+            }
             if (isListRelated(parent.type)) {
               markListDepthDirty(parent.id);
             }
@@ -4158,15 +4856,31 @@ function createRendererStore(initialBlocks = []) {
             break;
           }
           case "appendLines": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
             const parent = resolveParent(nodes, patch.at);
             if (!parent) break;
-            const startIndex = Math.max(0, Math.min(patch.startIndex, parent.children.length));
+            if (parent.type !== "code") {
+              debugCounters.appendLineGuardRejected += 1;
+              appendDiagnostic(`appendLines target not code:${parent.id}:${parent.type}`);
+              break;
+            }
+            const requestedStartIndex = Math.max(0, patch.startIndex);
+            const startIndex = Math.max(0, Math.min(requestedStartIndex, parent.children.length));
             const lineCount = patch.lines?.length ?? 0;
             if (lineCount === 0) break;
+            const prefixMatches = parent.children.every((childId, index) => childId === expectedCodeLineId(parent.id, index));
+            const isStrictTailAppend = requestedStartIndex === parent.children.length;
+            if (!isStrictTailAppend || !prefixMatches) {
+              debugCounters.appendLineGuardRejected += 1;
+              appendDiagnostic(
+                `appendLines guard rejected:${parent.id}:requestedStart=${requestedStartIndex}:childCount=${parent.children.length}:prefixMatches=${prefixMatches}`
+              );
+              break;
+            }
             const originalChildren = parent.children.slice();
             const insertedIds = [];
             const insertedSet = /* @__PURE__ */ new Set();
-            const isTrailingAppend = startIndex >= originalChildren.length;
+            const isTrailingAppend = true;
             let parentChildrenChanged = false;
             let codeLinesMutated = false;
             for (let offset = 0; offset < lineCount; offset++) {
@@ -4208,7 +4922,8 @@ function createRendererStore(initialBlocks = []) {
                   parentId: parent.id,
                   children: [],
                   props: nextLineProps,
-                  version: 0
+                  version: 0,
+                  blockEpoch: parent.blockEpoch
                 };
                 nodes.set(lineId, record);
                 touched.add(lineId);
@@ -4258,6 +4973,7 @@ function createRendererStore(initialBlocks = []) {
             break;
           }
           case "setHTML": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
             const target = nodes.get(patch.at.nodeId ?? patch.at.blockId);
             if (!target) break;
             const sanitized = patch.sanitized ? patch.html : (0, import_core4.sanitizeHTML)(patch.html);
@@ -4300,6 +5016,30 @@ function createRendererStore(initialBlocks = []) {
           applyPatch(patch);
         }
       }
+      const finalizedTableRoots = /* @__PURE__ */ new Set();
+      for (const touchedId of touched) {
+        let cursor = nodes.get(touchedId);
+        while (cursor && cursor.id !== import_core4.PATCH_ROOT_ID) {
+          if (cursor.type === "table" && cursor.block?.isFinalized && cursor.parentId) {
+            finalizedTableRoots.add(cursor.id);
+            break;
+          }
+          cursor = cursor.parentId ? nodes.get(cursor.parentId) : void 0;
+        }
+      }
+      if (finalizedTableRoots.size > 0) {
+        for (const tableId of finalizedTableRoots) {
+          const tableNode = nodes.get(tableId);
+          if (!tableNode || !tableNode.block || !tableNode.parentId) continue;
+          const parent = nodes.get(tableNode.parentId);
+          if (!parent) continue;
+          const index = parent.children.indexOf(tableNode.id);
+          if (index === -1) continue;
+          const snapshot = (0, import_core4.createBlockSnapshot)((0, import_core4.cloneBlock)(tableNode.block));
+          replaceSnapshotAt(nodes, parent, index, snapshot, touched, tableNode.blockEpoch);
+          mutatedBlocks = true;
+        }
+      }
       if (mutatedBlocks) {
         blocksDirty = true;
       }
@@ -4320,6 +5060,8 @@ function createRendererStore(initialBlocks = []) {
           normalizeListDepthsForIds(nodes, touched, listDepthDirtyNodes, import_core4.PATCH_ROOT_ID);
         }
       }
+      invariantViolations = [...collectStoreInvariantViolations(nodes), ...transientDiagnostics];
+      debugCounters.storeInvariantViolationCount += invariantViolations.length;
       if (touched.size > 0 || mutatedBlocks) {
         version++;
         scheduleNotify();
@@ -4368,6 +5110,7 @@ function createRendererStore(initialBlocks = []) {
       if (!record) {
         return EMPTY_NODE_SNAPSHOT;
       }
+      const nodeSnapshotCache = getNodeSnapshotCacheForMap(nodes);
       const cached = nodeSnapshotCache.get(id);
       if (cached && cached.version === record.version && cached.node === record) {
         return cached;
@@ -4387,6 +5130,7 @@ function createRendererStore(initialBlocks = []) {
       if (!record) {
         return EMPTY_CHILDREN_SNAPSHOT;
       }
+      const childrenSnapshotCache = getChildrenSnapshotCacheForMap(nodes);
       const cached = childrenSnapshotCache.get(id);
       if (cached && cached.version === record.version) {
         return cached;
@@ -4396,6 +5140,12 @@ function createRendererStore(initialBlocks = []) {
       pruneCache(childrenSnapshotCache, CHILDREN_SNAPSHOT_CACHE_LIMIT, CHILDREN_SNAPSHOT_CACHE_BUFFER);
       return snapshot;
     },
+    getInvariantViolations() {
+      return invariantViolations.slice();
+    },
+    getDebugCounters() {
+      return { ...debugCounters };
+    },
     getLastCoalescingMetrics() {
       return lastCoalescingMetrics;
     },
@@ -4410,43 +5160,43 @@ function createRendererStore(initialBlocks = []) {
 }
 
 // src/renderer/blocks-renderer.tsx
-var import_react12 = __toESM(require("react"), 1);
+var import_react13 = __toESM(require("react"), 1);
 var import_core6 = require("@stream-mdx/core");
 
 // src/renderer/hooks.ts
-var import_react8 = require("react");
+var import_react9 = require("react");
 function useRendererBlocks(store) {
-  return (0, import_react8.useSyncExternalStore)(
+  return (0, import_react9.useSyncExternalStore)(
     store.subscribe,
     () => store.getBlocks(),
     () => store.getBlocks()
   );
 }
 function useRendererNode(store, id) {
-  const selector = (0, import_react8.useMemo)(() => {
+  const selector = (0, import_react9.useMemo)(() => {
     return () => store.getNodeWithVersion(id);
   }, [store, id]);
-  const snapshot = (0, import_react8.useSyncExternalStore)(store.subscribe, selector, selector);
+  const snapshot = (0, import_react9.useSyncExternalStore)(store.subscribe, selector, selector);
   return snapshot.node;
 }
 function useRendererChildren(store, id) {
-  const selector = (0, import_react8.useMemo)(() => {
+  const selector = (0, import_react9.useMemo)(() => {
     return () => store.getChildrenWithVersion(id);
   }, [store, id]);
-  const snapshot = (0, import_react8.useSyncExternalStore)(store.subscribe, selector, selector);
+  const snapshot = (0, import_react9.useSyncExternalStore)(store.subscribe, selector, selector);
   return snapshot.children;
 }
 
 // src/renderer/node-views.tsx
 var import_core5 = require("@stream-mdx/core");
-var import_react11 = __toESM(require("react"), 1);
+var import_react12 = __toESM(require("react"), 1);
 
 // src/renderer/deferred-render-context.tsx
-var import_react9 = __toESM(require("react"), 1);
-var DeferredRenderContext = import_react9.default.createContext(null);
+var import_react10 = __toESM(require("react"), 1);
+var DeferredRenderContext = import_react10.default.createContext(null);
 
 // src/renderer/virtualized-code.tsx
-var import_react10 = require("react");
+var import_react11 = require("react");
 var DEFAULT_VIRTUALIZED_CODE_CONFIG = {
   enabled: true,
   windowSize: 100,
@@ -4486,11 +5236,11 @@ function calculateCodeWindow(lines, scrollTop, containerHeight, lineHeight, conf
   };
 }
 function useVirtualizedCode(lines, config = DEFAULT_VIRTUALIZED_CODE_CONFIG) {
-  const containerRef = (0, import_react10.useRef)(null);
-  const [scrollTop, setScrollTop] = (0, import_react10.useState)(0);
-  const [containerHeight, setContainerHeight] = (0, import_react10.useState)(0);
-  const lineHeightRef = (0, import_react10.useRef)(20);
-  (0, import_react10.useEffect)(() => {
+  const containerRef = (0, import_react11.useRef)(null);
+  const [scrollTop, setScrollTop] = (0, import_react11.useState)(0);
+  const [containerHeight, setContainerHeight] = (0, import_react11.useState)(0);
+  const lineHeightRef = (0, import_react11.useRef)(20);
+  (0, import_react11.useEffect)(() => {
     if (!containerRef.current || lines.length === 0) return;
     const timeoutId = setTimeout(() => {
       if (!containerRef.current) return;
@@ -4504,12 +5254,12 @@ function useVirtualizedCode(lines, config = DEFAULT_VIRTUALIZED_CODE_CONFIG) {
     }, 0);
     return () => clearTimeout(timeoutId);
   }, [lines.length]);
-  const handleScroll = (0, import_react10.useCallback)((e) => {
+  const handleScroll = (0, import_react11.useCallback)((e) => {
     const target = e.currentTarget;
     setScrollTop(target.scrollTop);
     setContainerHeight(target.clientHeight);
   }, []);
-  (0, import_react10.useEffect)(() => {
+  (0, import_react11.useEffect)(() => {
     if (!containerRef.current) return;
     const resizeObserver = new ResizeObserver((entries2) => {
       for (const entry of entries2) {
@@ -4519,10 +5269,10 @@ function useVirtualizedCode(lines, config = DEFAULT_VIRTUALIZED_CODE_CONFIG) {
     resizeObserver.observe(containerRef.current);
     return () => resizeObserver.disconnect();
   }, []);
-  const window2 = (0, import_react10.useMemo)(() => {
+  const window2 = (0, import_react11.useMemo)(() => {
     return calculateCodeWindow(lines, scrollTop, containerHeight, lineHeightRef.current, config);
   }, [lines, scrollTop, containerHeight, config]);
-  const scrollToLine = (0, import_react10.useCallback)((lineIndex) => {
+  const scrollToLine = (0, import_react11.useCallback)((lineIndex) => {
     if (!containerRef.current) return;
     const targetScrollTop = lineIndex * lineHeightRef.current;
     containerRef.current.scrollTop = targetScrollTop;
@@ -4539,31 +5289,31 @@ function useVirtualizedCode(lines, config = DEFAULT_VIRTUALIZED_CODE_CONFIG) {
 }
 
 // src/renderer/node-views.tsx
-var import_jsx_runtime3 = require("react/jsx-runtime");
+var import_jsx_runtime4 = require("react/jsx-runtime");
 var BlockNodeRenderer = ({ store, blockId, registry }) => {
   const node = useRendererNode(store, blockId);
   const block = node?.block;
   if (!node || !block) return null;
   switch (block.type) {
     case "paragraph":
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ParagraphBlockView, { store, blockId: block.id, registry });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ParagraphBlockView, { store, blockId: block.id, registry });
     case "blockquote":
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(BlockquoteBlockView, { store, blockId: block.id, registry });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(BlockquoteBlockView, { store, blockId: block.id, registry });
     case "list":
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ListBlockView, { store, blockId: block.id, registry, depth: 0 });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ListBlockView, { store, blockId: block.id, registry, depth: 0 });
     case "table":
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(TableBlockView, { store, blockId: block.id, registry });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(TableBlockView, { store, blockId: block.id, registry });
     case "code":
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(CodeBlockView, { store, blockId: block.id, registry });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(CodeBlockView, { store, blockId: block.id, registry });
     case "html":
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(HtmlBlockView, { store, blockId: block.id, registry });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(HtmlBlockView, { store, blockId: block.id, registry });
     case "mdx":
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(MdxBlockView, { store, blockId: block.id, registry });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(MdxBlockView, { store, blockId: block.id, registry });
     default:
       return registry.renderBlock(block);
   }
 };
-var ParagraphBlockView = import_react11.default.memo(({ store, blockId, registry }) => {
+var ParagraphBlockView = import_react12.default.memo(({ store, blockId, registry }) => {
   const node = useRendererNode(store, blockId);
   const block = node?.block;
   const childIds = useRendererChildren(store, blockId);
@@ -4578,12 +5328,12 @@ var ParagraphBlockView = import_react11.default.memo(({ store, blockId, registry
     if (segments2.length > 0) {
       const allowMixedStreaming = Boolean(meta.allowMixedStreaming);
       if (!allowMixedStreaming) {
-        return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "markdown-paragraph streaming-partial", children: raw });
+        return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "markdown-paragraph streaming-partial", children: raw });
       }
       const structured = renderParagraphMixedSegments(segments2, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
       if (structured.length === 1) {
         const [single] = structured;
-        return import_react11.default.isValidElement(single) ? single : single;
+        return import_react12.default.isValidElement(single) ? single : single;
       }
       return structured;
     }
@@ -4601,26 +5351,26 @@ var ParagraphBlockView = import_react11.default.memo(({ store, blockId, registry
         const structured = renderParagraphMixedSegments(derivedSegments, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
         if (structured.length === 1) {
           const [single] = structured;
-          return import_react11.default.isValidElement(single) ? single : single;
+          return import_react12.default.isValidElement(single) ? single : single;
         }
         return structured;
       }
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "markdown-paragraph streaming-partial", children: renderInlineNodes(inlineNodes2, inlineComponents) });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "markdown-paragraph streaming-partial", children: renderInlineNodes(inlineNodes2, inlineComponents) });
     }
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "markdown-paragraph streaming-partial", children: raw });
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "markdown-paragraph streaming-partial", children: raw });
   }
   const propsBlock = node.props?.block;
   const inlineStatus = propsBlock?.payload?.meta?.inlineStatus ?? block.payload.meta?.inlineStatus ?? node.props?.inlineStatus;
   if (inlineStatus && inlineStatus !== "complete") {
     const raw = typeof block.payload.raw === "string" ? block.payload.raw : "";
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "markdown-paragraph", children: raw });
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "markdown-paragraph", children: raw });
   }
   const segments = Array.isArray(block.payload.meta?.mixedSegments) ? block.payload.meta.mixedSegments : void 0;
   if (segments && segments.length > 0) {
     const structured = renderParagraphMixedSegments(segments, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
     if (structured.length === 1) {
       const [single] = structured;
-      return import_react11.default.isValidElement(single) ? single : single;
+      return import_react12.default.isValidElement(single) ? single : single;
     }
     return structured;
   }
@@ -4637,31 +5387,31 @@ var ParagraphBlockView = import_react11.default.memo(({ store, blockId, registry
     const structured = renderParagraphMixedSegments(derivedSegments, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
     if (structured.length === 1) {
       const [single] = structured;
-      return import_react11.default.isValidElement(single) ? single : single;
+      return import_react12.default.isValidElement(single) ? single : single;
     }
     return structured;
   }
   const ParagraphComponent = registry.getBlockComponent("paragraph");
-  const baseElement = import_react11.default.createElement(ParagraphComponent, {
+  const baseElement = import_react12.default.createElement(ParagraphComponent, {
     inlines: block.payload.inline ?? [],
     raw: block.payload.raw,
     meta: block.payload.meta
   });
   if (childIds.length > 0) {
-    const renderedChildren = childIds.map((childId) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
-    if (import_react11.default.isValidElement(baseElement)) {
+    const renderedChildren = childIds.map((childId) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
+    if (import_react12.default.isValidElement(baseElement)) {
       const { children: _ignored, className = "markdown-paragraph", inlines: _inlines, raw: _raw, meta: _meta, ...rest } = baseElement.props ?? {};
-      return import_react11.default.createElement("p", { ...rest, className }, renderedChildren);
+      return import_react12.default.createElement("p", { ...rest, className }, renderedChildren);
     }
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "markdown-paragraph", children: renderedChildren });
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "markdown-paragraph", children: renderedChildren });
   }
-  if (import_react11.default.isValidElement(baseElement)) {
+  if (import_react12.default.isValidElement(baseElement)) {
     return baseElement;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "markdown-paragraph", children: renderInlineNodes(block.payload.inline ?? [], inlineComponents) });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "markdown-paragraph", children: renderInlineNodes(block.payload.inline ?? [], inlineComponents) });
 });
 ParagraphBlockView.displayName = "ParagraphBlockView";
-var BlockquoteBlockView = import_react11.default.memo(({ store, blockId, registry }) => {
+var BlockquoteBlockView = import_react12.default.memo(({ store, blockId, registry }) => {
   const node = useRendererNode(store, blockId);
   const block = node?.block;
   const childIds = useRendererChildren(store, blockId);
@@ -4679,9 +5429,9 @@ var BlockquoteBlockView = import_react11.default.memo(({ store, blockId, registr
     return lines.map((line, idx) => {
       const key = `${keyPrefix}${offset}`;
       offset += line.length + 1;
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { className: "markdown-blockquote-line", children: [
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("span", { className: "markdown-blockquote-line", children: [
         line,
-        idx < lastIndex ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("br", {}) : null
+        idx < lastIndex ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("br", {}) : null
       ] }, key);
     });
   };
@@ -4707,7 +5457,7 @@ var BlockquoteBlockView = import_react11.default.memo(({ store, blockId, registr
             elements.push(htmlNode);
           } else {
             elements.push(
-              import_react11.default.createElement("span", {
+              import_react12.default.createElement("span", {
                 key: `blockquote-html-${block.id}-${segmentIndex}`,
                 className: "markdown-inline-html",
                 /* biome-ignore lint/security/noDangerouslySetInnerHtml: segment content is sanitized by the worker before streaming */
@@ -4719,16 +5469,16 @@ var BlockquoteBlockView = import_react11.default.memo(({ store, blockId, registr
         }
         case "mdx":
           elements.push(
-            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { "data-mdx-status": segment.status ?? "pending", children: segment.value }, `blockquote-mdx-${block.id}-${segmentIndex}`)
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { "data-mdx-status": segment.status ?? "pending", children: segment.value }, `blockquote-mdx-${block.id}-${segmentIndex}`)
           );
           break;
         default: {
           const inline = renderInlineContent(segment.inline, `blockquote-text-inline-${block.id}-${segmentIndex}-`);
           if (inline) {
-            elements.push(/* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react11.default.Fragment, { children: inline }, `blockquote-inline-${block.id}-${segmentIndex}`));
+            elements.push(/* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react12.default.Fragment, { children: inline }, `blockquote-inline-${block.id}-${segmentIndex}`));
           } else {
             elements.push(
-              /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react11.default.Fragment, { children: renderTextWithBreaks(segment.value, `blockquote-text-${block.id}-${segmentIndex}-`) }, `blockquote-text-${block.id}-${segmentIndex}`)
+              /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react12.default.Fragment, { children: renderTextWithBreaks(segment.value, `blockquote-text-${block.id}-${segmentIndex}-`) }, `blockquote-text-${block.id}-${segmentIndex}`)
             );
           }
           break;
@@ -4745,9 +5495,9 @@ var BlockquoteBlockView = import_react11.default.memo(({ store, blockId, registr
     const streamingContent = mixedSegmentElements.length ? mixedSegmentElements : inlineElements ? inlineElements : fallbackElements;
     const shouldShowStreaming = !block.isFinalized && (!streamingContent || Array.isArray(streamingContent) && streamingContent.length === 0);
     const className = shouldShowStreaming ? "markdown-blockquote streaming-partial" : "markdown-blockquote";
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("blockquote", { className, children: streamingContent });
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("blockquote", { className, children: streamingContent });
   }
-  const childContent = childIds.map((childId) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
+  const childContent = childIds.map((childId) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
   const renderedContent = (() => {
     if (mixedSegmentElements.length > 0) {
       return mixedSegmentElements;
@@ -4767,7 +5517,7 @@ var BlockquoteBlockView = import_react11.default.memo(({ store, blockId, registr
     return null;
   })();
   const BlockquoteComponent = registry.getBlockComponent("blockquote");
-  const baseElement = import_react11.default.createElement(
+  const baseElement = import_react12.default.createElement(
     BlockquoteComponent,
     {
       inlines: block.payload.inline ?? [],
@@ -4775,13 +5525,13 @@ var BlockquoteBlockView = import_react11.default.memo(({ store, blockId, registr
     },
     renderedContent
   );
-  if (import_react11.default.isValidElement(baseElement)) {
+  if (import_react12.default.isValidElement(baseElement)) {
     return baseElement;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("blockquote", { className: "markdown-blockquote", children: renderedContent });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("blockquote", { className: "markdown-blockquote", children: renderedContent });
 });
 BlockquoteBlockView.displayName = "BlockquoteBlockView";
-var MixedSegmentView = import_react11.default.memo(({ store, nodeId, inlineComponents }) => {
+var MixedSegmentView = import_react12.default.memo(({ store, nodeId, inlineComponents }) => {
   const node = useRendererNode(store, nodeId);
   if (!node) return null;
   switch (node.type) {
@@ -4809,7 +5559,7 @@ var MixedSegmentView = import_react11.default.memo(({ store, nodeId, inlineCompo
         return rendered;
       }
       if (!html) return null;
-      return import_react11.default.createElement("span", {
+      return import_react12.default.createElement("span", {
         className: "markdown-inline-html",
         /* biome-ignore lint/security/noDangerouslySetInnerHtml: html is sanitized upstream before reaching the renderer */
         dangerouslySetInnerHTML: { __html: html }
@@ -4821,32 +5571,32 @@ var MixedSegmentView = import_react11.default.memo(({ store, nodeId, inlineCompo
       const status = node.props?.status ?? "pending";
       const raw = typeof node.props?.raw === "string" ? node.props?.raw : "";
       if (status === "compiled") {
-        return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "markdown-mdx-inline", "data-mdx-status": "compiled" });
+        return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "markdown-mdx-inline", "data-mdx-status": "compiled" });
       }
       if (status === "error") {
         const message = raw || "MDX error";
-        return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "markdown-mdx-inline text-destructive", "data-mdx-status": "error", children: message });
+        return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "markdown-mdx-inline text-destructive", "data-mdx-status": "error", children: message });
       }
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "markdown-mdx-inline", "data-mdx-status": status, children: status === "compiled" ? "" : raw });
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "markdown-mdx-inline", "data-mdx-status": status, children: status === "compiled" ? "" : raw });
     }
     default:
       return null;
   }
 });
 MixedSegmentView.displayName = "MixedSegmentView";
-var HtmlBlockView = import_react11.default.memo(({ store, blockId, registry }) => {
+var HtmlBlockView = import_react12.default.memo(({ store, blockId, registry }) => {
   const node = useRendererNode(store, blockId);
   if (!node || !node.block) return null;
   return registry.renderBlock(node.block);
 });
 HtmlBlockView.displayName = "HtmlBlockView";
-var MdxBlockView = import_react11.default.memo(({ store, blockId, registry }) => {
+var MdxBlockView = import_react12.default.memo(({ store, blockId, registry }) => {
   const node = useRendererNode(store, blockId);
   if (!node || !node.block) return null;
   return registry.renderBlock(node.block);
 });
 MdxBlockView.displayName = "MdxBlockView";
-var ListBlockView = import_react11.default.memo(
+var ListBlockView = import_react12.default.memo(
   ({ store, blockId, registry, depth = 0 }) => {
     const node = useRendererNode(store, blockId);
     const block = node?.block;
@@ -4855,7 +5605,7 @@ var ListBlockView = import_react11.default.memo(
     const ordered = Boolean(node?.props?.ordered ?? block?.payload.meta?.ordered);
     const Tag = ordered ? "ol" : "ul";
     const listDebugEnabled = isListPatchDebugEnabled();
-    const listItemIds = import_react11.default.useMemo(() => {
+    const listItemIds = import_react12.default.useMemo(() => {
       const ids = [];
       for (const childId of childIds) {
         const childNode = store.getNode(childId);
@@ -4865,7 +5615,7 @@ var ListBlockView = import_react11.default.memo(
       }
       return ids;
     }, [childIds, store]);
-    import_react11.default.useEffect(() => {
+    import_react12.default.useEffect(() => {
       if (!listDebugEnabled) return;
       const childTypes = childIds.map((childId) => store.getNode(childId)?.type ?? "missing");
       console.info("[stream-mdx:list-render]", {
@@ -4880,8 +5630,10 @@ var ListBlockView = import_react11.default.memo(
         isFinalized: block?.isFinalized ?? false
       });
     }, [listDebugEnabled, blockId, depth, ordered, childIds, listItemIds, store, block?.isFinalized]);
-    const listStyle = import_react11.default.useMemo(() => {
-      if (!ordered || listItemIds.length === 0) return void 0;
+    const { listStyle, markerDigits } = import_react12.default.useMemo(() => {
+      if (!ordered || listItemIds.length === 0) {
+        return { listStyle: void 0, markerDigits: 1 };
+      }
       let maxDigits = 1;
       listItemIds.forEach((childId, index) => {
         const childNode = store.getNode(childId);
@@ -4893,20 +5645,26 @@ var ListBlockView = import_react11.default.memo(
         const digits = digitMatch ? digitMatch.length : text.length;
         if (digits > maxDigits) maxDigits = digits;
       });
-      const baseIndent = depth === 0 ? "2.5rem" : depth === 1 ? "2rem" : "1.5rem";
+      const baseIndent = depth === 0 ? "2rem" : depth === 1 ? "1.75rem" : "1.5rem";
+      const extraDigits = Math.max(0, maxDigits - 1);
       return {
-        ["--list-indent"]: `calc(${baseIndent} + ${maxDigits}ch)`
+        markerDigits: maxDigits,
+        listStyle: {
+          ["--list-indent"]: extraDigits > 0 ? `calc(${baseIndent} + ${extraDigits}ch)` : baseIndent,
+          ["--list-marker-digits"]: String(maxDigits)
+        }
       };
     }, [ordered, listItemIds, store, depth]);
     if (listItemIds.length === 0) return null;
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
       Tag,
       {
         className: `markdown-list ${ordered ? "ordered" : "unordered"}`,
         "data-list-depth": depth,
+        "data-marker-digits": ordered ? markerDigits : void 0,
         "data-list-id": listDebugEnabled ? blockId : void 0,
         style: listStyle,
-        children: listItemIds.map((childId, index) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+        children: listItemIds.map((childId, index) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
           ListItemView,
           {
             store,
@@ -4924,7 +5682,7 @@ var ListBlockView = import_react11.default.memo(
   }
 );
 ListBlockView.displayName = "ListBlockView";
-var ListItemView = import_react11.default.memo(({ store, nodeId, inlineComponents, registry, ordered, index, depth }) => {
+var ListItemView = import_react12.default.memo(({ store, nodeId, inlineComponents, registry, ordered, index, depth }) => {
   const node = useRendererNode(store, nodeId);
   const childIds = useRendererChildren(store, nodeId);
   const inline = node?.props?.inline ?? [];
@@ -4939,7 +5697,7 @@ var ListItemView = import_react11.default.memo(({ store, nodeId, inlineComponent
   const counterText = !isTask ? isOrdered ? marker ? marker : `${inferredIndex + 1}.` : "\u2022" : void 0;
   const listDebugEnabled = isListPatchDebugEnabled();
   const inlineLength = inline.length;
-  const [segmentChildIds, contentChildIds] = import_react11.default.useMemo(() => {
+  const [segmentChildIds, contentChildIds] = import_react12.default.useMemo(() => {
     const segments = [];
     const structural = [];
     for (const childId of childIds) {
@@ -4953,34 +5711,34 @@ var ListItemView = import_react11.default.memo(({ store, nodeId, inlineComponent
     }
     return [segments, structural];
   }, [childIds, store]);
-  const segmentElements = import_react11.default.useMemo(() => {
-    return segmentChildIds.map((childId) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
+  const segmentElements = import_react12.default.useMemo(() => {
+    return segmentChildIds.map((childId) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
   }, [segmentChildIds, store, inlineComponents]);
-  const primaryContent = import_react11.default.useMemo(() => {
+  const primaryContent = import_react12.default.useMemo(() => {
     if (segmentChildIds.length > 0) {
       return segmentElements;
     }
     return renderInlineNodes(inline, inlineComponents);
   }, [segmentChildIds, segmentElements, inline, inlineComponents]);
-  const trailingChildren = import_react11.default.useMemo(() => {
+  const trailingChildren = import_react12.default.useMemo(() => {
     return contentChildIds.map((childId) => {
       const childNode = store.getNode(childId);
       if (!childNode) return null;
       switch (childNode.type) {
         case "paragraph": {
           const childInline = childNode.props?.inline ?? [];
-          return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "markdown-list-item-paragraph", children: renderInlineNodes(childInline, inlineComponents) }, childId);
+          return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "markdown-list-item-paragraph", children: renderInlineNodes(childInline, inlineComponents) }, childId);
         }
         case "list":
-          return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ListBlockView, { store, blockId: childId, registry, depth: depth + 1 }, childId);
+          return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(ListBlockView, { store, blockId: childId, registry, depth: depth + 1 }, childId);
         default:
-          return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(BlockNodeRenderer, { store, blockId: childId, registry }, childId);
+          return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(BlockNodeRenderer, { store, blockId: childId, registry }, childId);
       }
     });
   }, [contentChildIds, store, inlineComponents, registry, depth]);
   const filteredChildren = trailingChildren.filter((child) => Boolean(child));
   const hasChildren = filteredChildren.length > 0;
-  import_react11.default.useEffect(() => {
+  import_react12.default.useEffect(() => {
     if (!listDebugEnabled) return;
     const childTypes = childIds.map((childId) => store.getNode(childId)?.type ?? "missing");
     console.info("[stream-mdx:list-item-render]", {
@@ -5016,7 +5774,7 @@ var ListItemView = import_react11.default.memo(({ store, nodeId, inlineComponent
     store,
     block?.isFinalized
   ]);
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
     "li",
     {
       className: `markdown-list-item${isTask ? " markdown-list-item-task" : ""}`,
@@ -5024,44 +5782,44 @@ var ListItemView = import_react11.default.memo(({ store, nodeId, inlineComponent
       "data-list-depth": depth,
       "data-list-item-id": listDebugEnabled ? nodeId : void 0,
       children: [
-        isTask ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "markdown-task", children: [
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("input", { type: "checkbox", className: "markdown-task-checkbox", checked: isChecked, readOnly: true, disabled: true, tabIndex: -1, "aria-checked": isChecked }),
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "markdown-task-content", children: primaryContent })
+        isTask ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "markdown-task", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("input", { type: "checkbox", className: "markdown-task-checkbox", checked: isChecked, readOnly: true, disabled: true, tabIndex: -1, "aria-checked": isChecked }),
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "markdown-task-content", children: primaryContent })
         ] }) : primaryContent,
-        hasChildren ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "markdown-list-item-children", children: filteredChildren }) : null
+        hasChildren ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "markdown-list-item-children", children: filteredChildren }) : null
       ]
     }
   );
 });
 ListItemView.displayName = "ListItemView";
-var TableBlockView = import_react11.default.memo(({ store, blockId, registry }) => {
+var TableBlockView = import_react12.default.memo(({ store, blockId, registry }) => {
   const tableElements = registry.getTableElements();
   const childIds = useRendererChildren(store, blockId);
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(tableElements.Table, { className: "markdown-table w-full caption-bottom text-base", children: childIds.map((sectionId) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(TableSectionView, { store, nodeId: sectionId, registry }, sectionId)) });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(tableElements.Table, { className: "markdown-table w-full caption-bottom text-base", children: childIds.map((sectionId) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(TableSectionView, { store, nodeId: sectionId, registry }, sectionId)) });
 });
 TableBlockView.displayName = "TableBlockView";
-var TableSectionView = import_react11.default.memo(({ store, nodeId, registry }) => {
+var TableSectionView = import_react12.default.memo(({ store, nodeId, registry }) => {
   const node = useRendererNode(store, nodeId);
   if (!node) return null;
   const tableElements = registry.getTableElements();
   if (node.type === "table-header") {
     const childIds = useRendererChildren(store, nodeId);
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(tableElements.Thead, { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(tableElements.Tr, { children: childIds.map((cellId) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(TableCellView, { store, nodeId: cellId, registry }, cellId)) }) });
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(tableElements.Thead, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(tableElements.Tr, { children: childIds.map((cellId) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(TableCellView, { store, nodeId: cellId, registry }, cellId)) }) });
   }
   if (node.type === "table-body") {
     const rowIds = useRendererChildren(store, nodeId);
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(tableElements.Tbody, { children: rowIds.map((rowId) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(TableRowView, { store, nodeId: rowId, registry }, rowId)) });
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(tableElements.Tbody, { children: rowIds.map((rowId) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(TableRowView, { store, nodeId: rowId, registry }, rowId)) });
   }
   return null;
 });
 TableSectionView.displayName = "TableSectionView";
-var TableRowView = import_react11.default.memo(({ store, nodeId, registry }) => {
+var TableRowView = import_react12.default.memo(({ store, nodeId, registry }) => {
   const tableElements = registry.getTableElements();
   const cellIds = useRendererChildren(store, nodeId);
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(tableElements.Tr, { children: cellIds.map((cellId) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(TableCellView, { store, nodeId: cellId, registry }, cellId)) });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(tableElements.Tr, { children: cellIds.map((cellId) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(TableCellView, { store, nodeId: cellId, registry }, cellId)) });
 });
 TableRowView.displayName = "TableRowView";
-var TableCellView = import_react11.default.memo(({ store, nodeId, registry }) => {
+var TableCellView = import_react12.default.memo(({ store, nodeId, registry }) => {
   const node = useRendererNode(store, nodeId);
   const inlineComponents = registry.getInlineComponents();
   const tableElements = registry.getTableElements();
@@ -5071,22 +5829,23 @@ var TableCellView = import_react11.default.memo(({ store, nodeId, registry }) =>
   const align = node.props?.align;
   const content = renderInlineNodes(inline, inlineComponents);
   const alignProps = align ? { align } : void 0;
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Tag, { ...alignProps, children: content });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Tag, { ...alignProps, children: content });
 });
 TableCellView.displayName = "TableCellView";
-var CodeBlockView = import_react11.default.memo(({ store, blockId, registry }) => {
+var CodeBlockView = import_react12.default.memo(({ store, blockId, registry }) => {
   const node = useRendererNode(store, blockId);
   const childIds = useRendererChildren(store, blockId);
   const CodeComponent = registry.getBlockComponent("code");
-  const deferredConfig = import_react11.default.useContext(DeferredRenderContext);
-  const deferredRef = import_react11.default.useRef(null);
+  const deferredConfig = import_react12.default.useContext(DeferredRenderContext);
+  const deferredRef = import_react12.default.useRef(null);
   const shouldRenderDeferred = useDeferredRender(
     deferredRef,
     deferredConfig ? { ...deferredConfig, enabled: true } : { enabled: false }
   );
   if (!node || !node.block) return null;
+  const blockIsFinalized = node.block.isFinalized;
   const nodeVersion = node.version;
-  const lines = import_react11.default.useMemo(() => {
+  const lines = import_react12.default.useMemo(() => {
     const seenIds = /* @__PURE__ */ new Set();
     const seenIndices = /* @__PURE__ */ new Set();
     const deduped = [];
@@ -5115,17 +5874,29 @@ var CodeBlockView = import_react11.default.memo(({ store, blockId, registry }) =
   const lang = typeof node.props?.lang === "string" ? node.props?.lang : node.block.payload.meta?.lang;
   const preAttrs = node.props?.preAttrs ?? void 0;
   const codeAttrs = node.props?.codeAttrs ?? void 0;
+  const blockMeta = node.block.payload.meta ?? void 0;
+  const lazyEnabled = Boolean(blockMeta?.lazyTokenization);
+  const lazyTokenizedUntil = typeof blockMeta?.lazyTokenizedUntil === "number" ? blockMeta.lazyTokenizedUntil : 0;
+  const lazyHighlightedLines = Array.isArray(blockMeta?.highlightedLines) ? blockMeta.highlightedLines.length : 0;
+  const lazyTokenLines = Array.isArray(blockMeta?.tokenLines) ? blockMeta.tokenLines.length : 0;
+  const lazySourceTextLineCount = import_react12.default.useMemo(() => {
+    const raw = typeof node.block?.payload.raw === "string" ? node.block.payload.raw : "";
+    const metaCode = typeof blockMeta?.code === "string" ? blockMeta.code : null;
+    const sourceText = resolveCodeSourceText(raw, metaCode);
+    if (sourceText.length === 0) return 0;
+    return sourceText.split("\n").length;
+  }, [blockMeta, node.block?.payload.raw]);
+  const totalLazyLineCount = Math.max(lines.length, lazyHighlightedLines, lazyTokenLines, lazySourceTextLineCount);
   const virtualizationConfig = DEFAULT_VIRTUALIZED_CODE_CONFIG;
   const virtualizationDisabled = typeof process !== "undefined" && typeof process.env === "object" && process.env.STREAM_MDX_DISABLE_VIRTUALIZED_CODE === "true";
-  const shouldVirtualize = !virtualizationDisabled && virtualizationConfig.enabled && lines.length >= virtualizationConfig.virtualizeThreshold;
+  const canVirtualize = node.block.isFinalized && !lazyEnabled;
+  const shouldVirtualize = canVirtualize && !virtualizationDisabled && virtualizationConfig.enabled && lines.length >= virtualizationConfig.virtualizeThreshold;
   const virtualization = useVirtualizedCode(lines, shouldVirtualize ? virtualizationConfig : { ...virtualizationConfig, enabled: false });
   const highlightRequester = useCodeHighlightRequester();
-  const lazyEnabled = Boolean(node.block.payload.meta?.lazyTokenization);
-  const lazyTokenizedUntil = typeof node.block.payload.meta?.lazyTokenizedUntil === "number" ? node.block.payload.meta.lazyTokenizedUntil : 0;
-  const lastRangeRef = import_react11.default.useRef(null);
-  const rafRef = import_react11.default.useRef(null);
-  const idleRef = import_react11.default.useRef(null);
-  import_react11.default.useEffect(() => {
+  const lastRangeRef = import_react12.default.useRef(null);
+  const rafRef = import_react12.default.useRef(null);
+  const idleRef = import_react12.default.useRef(null);
+  import_react12.default.useEffect(() => {
     if (!shouldVirtualize || !lazyEnabled || !highlightRequester) return;
     const { visibleStart, visibleEnd, startIndex, endIndex } = virtualization.window;
     if (endIndex <= lazyTokenizedUntil) return;
@@ -5202,30 +5973,112 @@ var CodeBlockView = import_react11.default.memo(({ store, blockId, registry }) =
     virtualization.window.startIndex,
     virtualization.window.endIndex
   ]);
-  const highlightedHtml = import_react11.default.useMemo(() => {
-    if (!shouldVirtualize && node.block?.payload.highlightedHtml) {
-      return node.block.payload.highlightedHtml;
+  import_react12.default.useEffect(() => {
+    if (shouldVirtualize || !blockIsFinalized || !lazyEnabled || !highlightRequester) return;
+    if (totalLazyLineCount <= 0 || lazyTokenizedUntil >= totalLazyLineCount) return;
+    const nextRange = {
+      visibleStart: 0,
+      visibleEnd: totalLazyLineCount,
+      prefetchStart: 0,
+      prefetchEnd: totalLazyLineCount,
+      tokenizedUntil: lazyTokenizedUntil
+    };
+    const last = lastRangeRef.current;
+    if (last && last.visibleStart === nextRange.visibleStart && last.visibleEnd === nextRange.visibleEnd && last.prefetchStart === nextRange.prefetchStart && last.prefetchEnd === nextRange.prefetchEnd && last.tokenizedUntil === nextRange.tokenizedUntil) {
+      return;
     }
+    lastRangeRef.current = nextRange;
+    if (rafRef.current !== null && typeof cancelAnimationFrame === "function") {
+      cancelAnimationFrame(rafRef.current);
+    }
+    const requestFullHighlight = () => {
+      highlightRequester({
+        blockId,
+        startLine: 0,
+        endLine: totalLazyLineCount,
+        priority: "visible",
+        reason: "finalize-full"
+      });
+      rafRef.current = null;
+    };
+    if (typeof requestAnimationFrame === "function") {
+      rafRef.current = requestAnimationFrame(requestFullHighlight);
+    } else {
+      requestFullHighlight();
+    }
+  }, [blockId, blockIsFinalized, highlightRequester, lazyEnabled, lazyTokenizedUntil, shouldVirtualize, totalLazyLineCount]);
+  const highlightedHtml = import_react12.default.useMemo(() => {
+    const blockHtml = node.block?.payload.highlightedHtml ?? "";
+    const raw = typeof node.block?.payload.raw === "string" ? node.block.payload.raw : "";
+    const metaCode = typeof node.block?.payload.meta?.code === "string" ? (node.block?.payload.meta).code : null;
+    const sourceText = resolveCodeSourceText(raw, metaCode);
+    const sourceEndsWithNewline = sourceText.endsWith("\n");
+    const sourceLines = sourceText.length > 0 ? sourceText.split("\n") : [];
+    const rawFallbackLines = buildCodeFallbackLines(raw);
+    const deterministicWrapperAttrs = (0, import_core5.getDefaultCodeWrapperAttributes)(lang);
+    const composedPreAttrs = deterministicWrapperAttrs.preAttrs;
+    const composedCodeAttrs = deterministicWrapperAttrs.codeAttrs;
+    const shouldAppendTerminalNewline = (renderedLines) => {
+      if (!sourceEndsWithNewline || renderedLines.length === 0 || lines.length === 0) {
+        return false;
+      }
+      const lastRendered = renderedLines[renderedLines.length - 1];
+      const lastKnown = lines[lines.length - 1];
+      if (!lastRendered || !lastKnown || lastRendered.index !== lastKnown.index || lastRendered.text === "") {
+        return false;
+      }
+      const expectedRenderedLineCount = Math.max(0, sourceLines.length - 1);
+      const expectedLastRenderedLine = sourceLines.length >= 2 ? sourceLines[sourceLines.length - 2] ?? "" : "";
+      return renderedLines.length === expectedRenderedLineCount && lastRendered.text === expectedLastRenderedLine;
+    };
     if (lines.length > 0) {
       const hasLineHtml = lines.some((line) => typeof line.html === "string" && line.html.length > 0);
-      if (!hasLineHtml && node.block?.payload.highlightedHtml) {
-        return node.block.payload.highlightedHtml;
+      if (!hasLineHtml && blockHtml) {
+        return blockHtml;
       }
       if (shouldVirtualize) {
-        return composeHighlightedHtml(virtualization.window.visibleLines, preAttrs, codeAttrs);
+        return composeHighlightedHtml(
+          virtualization.window.visibleLines,
+          composedPreAttrs,
+          composedCodeAttrs,
+          shouldAppendTerminalNewline(virtualization.window.visibleLines)
+        );
       }
-      return composeHighlightedHtml(lines, preAttrs, codeAttrs);
+      return composeHighlightedHtml(lines, composedPreAttrs, composedCodeAttrs, shouldAppendTerminalNewline(lines));
+    }
+    if (!shouldVirtualize && blockHtml) {
+      const hasHighlightedLines = blockHtml.includes('class="line"');
+      if (!hasHighlightedLines && rawFallbackLines.length > 0) {
+        return composeHighlightedHtml(
+          rawFallbackLines,
+          composedPreAttrs,
+          composedCodeAttrs,
+          sourceEndsWithNewline && rawFallbackLines[rawFallbackLines.length - 1]?.text !== ""
+        );
+      }
+      return blockHtml;
     }
-    const blockHtml = node.block?.payload.highlightedHtml ?? "";
     if (blockHtml?.trim().match(/^```[\w-]*\s*$/)) {
-      const raw = node.block?.payload.raw ?? "";
-      if (raw.trim().length > 0) {
-        return composeHighlightedHtml([{ index: 0, text: raw, html: null, id: "temp" }], preAttrs, codeAttrs);
+      if (rawFallbackLines.length > 0) {
+        return composeHighlightedHtml(
+          rawFallbackLines,
+          composedPreAttrs,
+          composedCodeAttrs,
+          sourceEndsWithNewline && rawFallbackLines[rawFallbackLines.length - 1]?.text !== ""
+        );
       }
     }
+    if (!blockHtml && rawFallbackLines.length > 0) {
+      return composeHighlightedHtml(
+        rawFallbackLines,
+        composedPreAttrs,
+        composedCodeAttrs,
+        sourceEndsWithNewline && rawFallbackLines[rawFallbackLines.length - 1]?.text !== ""
+      );
+    }
     return blockHtml;
-  }, [shouldVirtualize, node.block?.payload.highlightedHtml, lines, preAttrs, codeAttrs, virtualization.window.visibleLines, node.block?.payload.raw]);
-  const rendered = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+  }, [blockIsFinalized, shouldVirtualize, node.block?.payload.highlightedHtml, node.block?.payload.meta, lines, lang, virtualization.window.visibleLines, node.block?.payload.raw]);
+  const rendered = /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
     CodeComponent,
     {
       html: highlightedHtml,
@@ -5236,20 +6089,26 @@ var CodeBlockView = import_react11.default.memo(({ store, blockId, registry }) =
       codeAttrs
     }
   );
+  const effectiveLineCount = import_react12.default.useMemo(() => {
+    if (lines.length > 0) {
+      return lines.length;
+    }
+    return 1;
+  }, [lines.length]);
   const codeFrameClass = "not-prose flex flex-col rounded-lg border border-input pt-1 font-mono text-sm";
   const codeMetricsAttrs = {
     "data-code-block": "true",
     "data-block-id": blockId,
     "data-code-virtualized": shouldVirtualize ? "true" : "false",
-    "data-code-total-lines": String(lines.length),
-    "data-code-mounted-lines": String(shouldVirtualize ? virtualization.window.mountedLines : lines.length),
+    "data-code-total-lines": String(effectiveLineCount),
+    "data-code-mounted-lines": String(shouldVirtualize ? virtualization.window.mountedLines : effectiveLineCount),
     "data-code-window-size": String(virtualization.config.windowSize)
   };
   const codeView = shouldVirtualize ? (() => {
     const { containerRef, window: window2, handleScroll, lineHeight } = virtualization;
     const spacerTop = window2.startIndex * lineHeight;
     const spacerBottom = (window2.totalLines - window2.endIndex) * lineHeight;
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("pre", { className: codeFrameClass, ...codeMetricsAttrs, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("pre", { className: codeFrameClass, ...codeMetricsAttrs, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
       "div",
       {
         ref: containerRef,
@@ -5257,13 +6116,13 @@ var CodeBlockView = import_react11.default.memo(({ store, blockId, registry }) =
         style: { overflowY: "auto", overflowX: "hidden", maxHeight: "600px" },
         onScroll: handleScroll,
         children: [
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: { height: spacerTop }, "aria-hidden": "true" }),
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { style: { height: spacerTop }, "aria-hidden": "true" }),
           rendered,
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: { height: spacerBottom }, "aria-hidden": "true" })
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { style: { height: spacerBottom }, "aria-hidden": "true" })
         ]
       }
     ) });
-  })() : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("pre", { className: codeFrameClass, ...codeMetricsAttrs, children: rendered });
+  })() : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("pre", { className: codeFrameClass, ...codeMetricsAttrs, children: rendered });
   const blockComponentMap = registry.getBlockComponentMap();
   const MermaidComponent = Object.prototype.hasOwnProperty.call(blockComponentMap, "mermaid") ? blockComponentMap.mermaid : null;
   if ((lang ?? "").toLowerCase() === "mermaid" && MermaidComponent) {
@@ -5271,14 +6130,14 @@ var CodeBlockView = import_react11.default.memo(({ store, blockId, registry }) =
     const fenced = (0, import_core5.stripCodeFence)(raw);
     const code = fenced.hadFence ? fenced.code : raw;
     if (deferredConfig) {
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { ref: deferredRef, children: shouldRenderDeferred ? import_react11.default.createElement(MermaidComponent, {
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { ref: deferredRef, children: shouldRenderDeferred ? import_react12.default.createElement(MermaidComponent, {
         code,
         renderCode: codeView,
         meta: node.block.payload.meta,
         isFinalized: node.block.isFinalized
       }) : codeView });
     }
-    return import_react11.default.createElement(MermaidComponent, {
+    return import_react12.default.createElement(MermaidComponent, {
       code,
       renderCode: codeView,
       meta: node.block.payload.meta,
@@ -5288,21 +6147,152 @@ var CodeBlockView = import_react11.default.memo(({ store, blockId, registry }) =
   return codeView;
 });
 CodeBlockView.displayName = "CodeBlockView";
-function composeHighlightedHtml(lines, preAttrs, codeAttrs) {
+function composeHighlightedHtml(lines, preAttrs, codeAttrs, appendTerminalNewline = false) {
   const lineMarkup = lines.map((line) => {
-    const content = line.html ?? escapeHtml3(line.text);
+    const content = line.html ?? renderTokenLineHtml(line.tokens) ?? escapeHtml3(line.text);
     const dataLine = Number.isFinite(line.index) ? ` data-line="${line.index + 1}"` : "";
     return `<span class="line"${dataLine}>${content}</span>`;
   }).join("\n");
   const preAttr = attrsToString(preAttrs);
   const codeAttr = attrsToString(codeAttrs);
-  return `<pre${preAttr}><code${codeAttr}>${lineMarkup}
-</code></pre>`;
+  return `<pre${preAttr}><code${codeAttr}>${lineMarkup}${appendTerminalNewline ? "\n" : ""}</code></pre>`;
+}
+var TOKEN_FONT_STYLE_ITALIC = 1;
+var TOKEN_FONT_STYLE_BOLD = 2;
+var TOKEN_FONT_STYLE_UNDERLINE = 4;
+var TOKEN_FONT_STYLE_STRIKETHROUGH = 8;
+function renderTokenLineHtml(tokens) {
+  if (!tokens || !Array.isArray(tokens.spans)) {
+    return null;
+  }
+  return mergeRenderableTokenSpans(tokens.spans).map((span) => renderTokenSpanHtml(span)).join("");
+}
+function renderTokenSpanHtml(span) {
+  const dark = span.v?.dark;
+  const light = span.v?.light;
+  const single = span.s;
+  const styles = [];
+  if (dark?.fg) {
+    styles.push(`--shiki-dark:${dark.fg}`);
+  }
+  if (light?.fg) {
+    styles.push(`--shiki-light:${light.fg}`);
+  }
+  if (!light?.fg && !dark?.fg && single?.fg) {
+    styles.push(`color:${single.fg}`);
+  }
+  const fontStyle = light?.fs ?? dark?.fs ?? single?.fs;
+  if (typeof fontStyle === "number" && fontStyle > 0) {
+    if (fontStyle & TOKEN_FONT_STYLE_ITALIC) {
+      styles.push("font-style: italic");
+    }
+    if (fontStyle & TOKEN_FONT_STYLE_BOLD) {
+      styles.push("font-weight: bold");
+    }
+    const decorations = [];
+    if (fontStyle & TOKEN_FONT_STYLE_UNDERLINE) {
+      decorations.push("underline");
+    }
+    if (fontStyle & TOKEN_FONT_STYLE_STRIKETHROUGH) {
+      decorations.push("line-through");
+    }
+    if (decorations.length > 0) {
+      styles.push(`text-decoration: ${decorations.join(" ")}`);
+    }
+  }
+  const content = escapeHtml3(span.t ?? "");
+  if (styles.length === 0) {
+    return content;
+  }
+  return `<span style="${styles.join(";")}">${content}</span>`;
+}
+function mergeRenderableTokenSpans(spans) {
+  if (spans.length <= 1) {
+    return spans.slice();
+  }
+  const merged = [];
+  let pendingWhitespace = "";
+  for (const span of spans) {
+    const text = typeof span.t === "string" ? span.t : "";
+    if (/^[\t ]+$/.test(text)) {
+      pendingWhitespace += text;
+      continue;
+    }
+    const nextSpan = pendingWhitespace ? { ...span, t: `${pendingWhitespace}${text}` } : span;
+    pendingWhitespace = "";
+    const previous = merged[merged.length - 1];
+    if (previous && sameTokenSpanStyle(previous, nextSpan)) {
+      previous.t += nextSpan.t;
+    } else {
+      merged.push({ ...nextSpan });
+    }
+  }
+  if (pendingWhitespace) {
+    const previous = merged[merged.length - 1];
+    if (previous) {
+      previous.t += pendingWhitespace;
+    } else {
+      merged.push({ t: pendingWhitespace });
+    }
+  }
+  return merged;
+}
+function sameTokenSpanStyle(a, b) {
+  const variantKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(a.v ?? {}),
+    ...Object.keys(b.v ?? {})
+  ]);
+  for (const key of variantKeys) {
+    const aStyle = a.v?.[key];
+    const bStyle = b.v?.[key];
+    if ((aStyle?.fg ?? null) !== (bStyle?.fg ?? null)) return false;
+    if ((aStyle?.bg ?? null) !== (bStyle?.bg ?? null)) return false;
+    if ((aStyle?.fs ?? null) !== (bStyle?.fs ?? null)) return false;
+  }
+  if ((a.s?.fg ?? null) !== (b.s?.fg ?? null)) return false;
+  if ((a.s?.bg ?? null) !== (b.s?.bg ?? null)) return false;
+  if ((a.s?.fs ?? null) !== (b.s?.fs ?? null)) return false;
+  return true;
+}
+function resolveCodeSourceText(raw, metaCode) {
+  if (metaCode !== null) {
+    return metaCode.replace(/\r\n?/g, "\n");
+  }
+  if (!raw) return "";
+  const normalized = raw.replace(/\r\n?/g, "\n");
+  const fenced = (0, import_core5.stripCodeFence)(normalized);
+  return fenced.hadFence ? fenced.code : normalized;
 }
 function attrsToString(attrs) {
   if (!attrs) return "";
   return Object.entries(attrs).map(([key, value]) => ` ${key}="${escapeAttribute(value)}"`).join("");
 }
+function buildCodeFallbackLines(raw) {
+  const normalized = normalizeCodeFallbackRaw(raw);
+  if (normalized.length === 0) {
+    if (/^\s*```[^\n]*\n?\s*$/.test(raw)) {
+      return [{ id: "temp-0", index: 0, text: "", html: null }];
+    }
+    return [];
+  }
+  return normalized.split("\n").map((line, index) => ({
+    id: `temp-${index}`,
+    index,
+    text: line,
+    html: null
+  }));
+}
+function normalizeCodeFallbackRaw(raw) {
+  if (!raw) return "";
+  const normalized = raw.replace(/\r\n?/g, "\n");
+  const fenced = (0, import_core5.stripCodeFence)(normalized);
+  if (!fenced.hadFence) {
+    return normalized.replace(/\n+$/, "");
+  }
+  let code = fenced.code;
+  code = code.replace(/\n+$/, "");
+  return code;
+}
 function escapeHtml3(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
@@ -5311,22 +6301,22 @@ function escapeAttribute(value) {
 }
 
 // src/renderer/blocks-renderer.tsx
-var MarkdownBlocksRenderer = import_react12.default.memo(({ blocks, componentRegistry, className = "markdown-renderer", style, store }) => {
+var MarkdownBlocksRenderer = import_react13.default.memo(({ blocks, componentRegistry, className = "markdown-renderer", style, store }) => {
   if (store) {
-    return import_react12.default.createElement(
+    return import_react13.default.createElement(
       "div",
       {
         className,
         style: { contain: "content", ...style ?? {} }
         // CSS containment for performance
       },
-      import_react12.default.createElement(StoreBackedBlocks, { store, componentRegistry })
+      import_react13.default.createElement(StoreBackedBlocks, { store, componentRegistry })
     );
   }
-  const renderedBlocks = (0, import_react12.useMemo)(() => {
+  const renderedBlocks = (0, import_react13.useMemo)(() => {
     return blocks.map((block) => {
       const key = (0, import_core6.getBlockKey)(block);
-      return import_react12.default.createElement(BlockRenderer, {
+      return import_react13.default.createElement(BlockRenderer, {
         key,
         block,
         componentRegistry,
@@ -5334,7 +6324,7 @@ var MarkdownBlocksRenderer = import_react12.default.memo(({ blocks, componentReg
       });
     });
   }, [blocks, componentRegistry]);
-  return import_react12.default.createElement(
+  return import_react13.default.createElement(
     "div",
     {
       className,
@@ -5344,23 +6334,23 @@ var MarkdownBlocksRenderer = import_react12.default.memo(({ blocks, componentReg
     renderedBlocks
   );
 });
-var StoreBackedBlocks = import_react12.default.memo(
+var StoreBackedBlocks = import_react13.default.memo(
   ({ store, componentRegistry }) => {
     const blockIds = useRendererChildren(store, import_core6.PATCH_ROOT_ID);
-    return import_react12.default.createElement(
-      import_react12.default.Fragment,
+    return import_react13.default.createElement(
+      import_react13.default.Fragment,
       null,
-      blockIds.map((blockId) => import_react12.default.createElement(BlockNodeRenderer, { key: blockId, store, blockId, registry: componentRegistry }))
+      blockIds.map((blockId) => import_react13.default.createElement(BlockNodeRenderer, { key: blockId, store, blockId, registry: componentRegistry }))
     );
   }
 );
 StoreBackedBlocks.displayName = "StoreBackedBlocks";
-var BlockRenderer = import_react12.default.memo(({ block, componentRegistry, isFinalized }) => {
-  const element = (0, import_react12.useMemo)(() => {
+var BlockRenderer = import_react13.default.memo(({ block, componentRegistry, isFinalized }) => {
+  const element = (0, import_react13.useMemo)(() => {
     return componentRegistry.renderBlock(block);
   }, [block, componentRegistry]);
   const className = `markdown-block markdown-block-${block.type} ${isFinalized ? "finalized" : "dirty"}`;
-  return import_react12.default.cloneElement(element, {
+  return import_react13.default.cloneElement(element, {
     className: `${element.props.className || ""} ${className}`.trim(),
     "data-block-id": block.id,
     "data-finalized": isFinalized
@@ -5426,7 +6416,9 @@ var MarkdownRenderer = class {
         lowPriorityFrameBudgetMs: this.config.performance?.lowPriorityFrameBudgetMs,
         urgentQueueThreshold: this.config.performance?.urgentQueueThreshold,
         batch: this.config.performance?.batch,
-        historyLimit: this.config.performance?.historyLimit
+        historyLimit: this.config.performance?.historyLimit,
+        startupMicrotaskFlushes: this.config.performance?.startupMicrotaskFlushes,
+        adaptiveBudgeting: this.config.performance?.adaptiveBudgeting
       }
     });
   }
@@ -5620,18 +6612,8 @@ var MarkdownRenderer = class {
           const receivedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
           const batches = (0, import_patch_batching.splitPatchBatch)(message.patches);
           batches.forEach((batch, index) => {
-            const hasStructural = batch.some((patch) => {
-              switch (patch.op) {
-                case "insertChild":
-                case "replaceChild":
-                case "deleteChild":
-                case "reorder":
-                  return true;
-                default:
-                  return false;
-              }
-            });
-            const priority = hasStructural ? "high" : batch.some(import_patch_batching.isHeavyPatch) ? "low" : "high";
+            const hasSemantic = batch.some((patch) => (0, import_patch_batching.getPatchKind)(patch) === "semantic");
+            const priority = hasSemantic ? "high" : batch.some(import_patch_batching.isHeavyPatch) ? "low" : "high";
             this.patchScheduler.enqueue({
               patches: batch,
               meta: {
@@ -5768,10 +6750,10 @@ var MarkdownRenderer = class {
   }
 };
 function useMarkdownRenderer(config = {}) {
-  const [renderer] = (0, import_react13.useState)(() => new MarkdownRenderer(config));
-  const [blocks, setBlocks] = (0, import_react13.useState)([]);
-  const workerRef = (0, import_react13.useRef)(null);
-  (0, import_react13.useEffect)(() => {
+  const [renderer] = (0, import_react14.useState)(() => new MarkdownRenderer(config));
+  const [blocks, setBlocks] = (0, import_react14.useState)([]);
+  const workerRef = (0, import_react14.useRef)(null);
+  (0, import_react14.useEffect)(() => {
     if (!workerRef.current) {
       const fallbackFactory = () => new Worker("/workers/markdown-worker.js", { type: "module", name: "markdown-v2" });
       const worker = (0, import_worker.createDefaultWorker)() ?? fallbackFactory();
@@ -5786,41 +6768,41 @@ function useMarkdownRenderer(config = {}) {
       }
     };
   }, [renderer]);
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     const unsubscribe = renderer.onUpdate(setBlocks);
     return unsubscribe;
   }, [renderer]);
   const mdxComponents = config.mdx?.components;
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     if (mdxComponents && Object.keys(mdxComponents).length > 0) {
       renderer.setMdxComponents(mdxComponents);
     }
   }, [renderer, mdxComponents]);
-  const append = (0, import_react13.useCallback)(
+  const append = (0, import_react14.useCallback)(
     (text) => {
       renderer.append(text);
     },
     [renderer]
   );
-  const renderStatic = (0, import_react13.useCallback)(
+  const renderStatic = (0, import_react14.useCallback)(
     (text) => {
       return renderer.renderStatic(text);
     },
     [renderer]
   );
-  const setBlockComponents = (0, import_react13.useCallback)(
+  const setBlockComponents = (0, import_react14.useCallback)(
     (components) => {
       renderer.setBlockComponents(components);
     },
     [renderer]
   );
-  const setInlineComponents = (0, import_react13.useCallback)(
+  const setInlineComponents = (0, import_react14.useCallback)(
     (components) => {
       renderer.setInlineComponents(components);
     },
     [renderer]
   );
-  const setMdxComponents = (0, import_react13.useCallback)(
+  const setMdxComponents = (0, import_react14.useCallback)(
     (components) => {
       renderer.setMdxComponents(components);
     },
@@ -5839,24 +6821,24 @@ function useMarkdownRenderer(config = {}) {
 }
 var MarkdownRenderer2 = ({ config, className, onBlocksChange, children }) => {
   const api = useMarkdownRenderer(config);
-  const highlightRequester = (0, import_react13.useCallback)(
+  const highlightRequester = (0, import_react14.useCallback)(
     (request) => {
       api.renderer.requestCodeHighlightRange(request);
     },
     [api.renderer]
   );
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     if (onBlocksChange) {
       onBlocksChange(api.blocks);
     }
   }, [api.blocks, onBlocksChange]);
   if (children) {
-    return import_react13.default.createElement(import_react13.default.Fragment, {}, children(api));
+    return import_react14.default.createElement(import_react14.default.Fragment, {}, children(api));
   }
-  return import_react13.default.createElement(
+  return import_react14.default.createElement(
     CodeHighlightRequestContext.Provider,
     { value: highlightRequester },
-    import_react13.default.createElement(MarkdownBlocksRenderer, {
+    import_react14.default.createElement(MarkdownBlocksRenderer, {
       blocks: api.blocks,
       componentRegistry: api.renderer.getComponentRegistry(),
       className,
@@ -5869,9 +6851,9 @@ function createMarkdownRenderer(config = {}) {
 }
 
 // src/streaming-markdown.tsx
-var import_react14 = __toESM(require("react"), 1);
+var import_react15 = __toESM(require("react"), 1);
 var import_worker2 = require("@stream-mdx/worker");
-var import_jsx_runtime4 = require("react/jsx-runtime");
+var import_jsx_runtime5 = require("react/jsx-runtime");
 var EMPTY_BLOCKS = [];
 function createConfigSignature(input) {
   return JSON.stringify(input);
@@ -5883,13 +6865,13 @@ var MdxCoordinatorBridge = ({ store, mode }) => {
 };
 var MdxPrefetchBridge = ({ store }) => {
   const blocks = useRendererBlocks(store);
-  const prefetchedRuntimeRef = (0, import_react14.useRef)(false);
-  const trackedIdsRef = (0, import_react14.useRef)(/* @__PURE__ */ new Set());
-  const queueRef = (0, import_react14.useRef)(null);
+  const prefetchedRuntimeRef = (0, import_react15.useRef)(false);
+  const trackedIdsRef = (0, import_react15.useRef)(/* @__PURE__ */ new Set());
+  const queueRef = (0, import_react15.useRef)(null);
   if (!queueRef.current) {
     queueRef.current = new MdxPrefetchQueue();
   }
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     const queue = queueRef.current;
     if (!queue) return;
     const nextIds = /* @__PURE__ */ new Map();
@@ -5927,7 +6909,7 @@ var MdxPrefetchBridge = ({ store }) => {
     }
     trackedIdsRef.current = new Set(nextIds.keys());
   }, [blocks]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     return () => {
       queueRef.current?.cancelAll();
     };
@@ -6001,7 +6983,7 @@ function StreamingMarkdownComponent({
   const effectiveScheduling = scheduling ?? DEFAULT_SCHEDULING;
   const adaptiveSwitchEnabled = effectiveScheduling.batch === "microtask" && (scheduling?.adaptiveSwitch ?? true);
   const adaptiveQueueThreshold = scheduling?.adaptiveQueueThreshold ?? (typeof effectiveScheduling.maxBatchesPerFlush === "number" ? effectiveScheduling.maxBatchesPerFlush : DEFAULT_ADAPTIVE_QUEUE_THRESHOLD);
-  const configSignature = (0, import_react14.useMemo)(
+  const configSignature = (0, import_react15.useMemo)(
     () => createConfigSignature({
       features,
       prewarm: prewarmLangs,
@@ -6012,16 +6994,16 @@ function StreamingMarkdownComponent({
     }),
     [features, prewarmLangs, effectiveScheduling, mdxCompileMode, mdxComponents, mdxHydration]
   );
-  const mdxHydrationController = (0, import_react14.useMemo)(() => createMdxHydrationController(mdxHydration), [mdxHydration]);
-  const mdxHydrationContextValue = (0, import_react14.useMemo)(
+  const mdxHydrationController = (0, import_react15.useMemo)(() => createMdxHydrationController(mdxHydration), [mdxHydration]);
+  const mdxHydrationContextValue = (0, import_react15.useMemo)(
     () => ({
       controller: mdxHydrationController,
       options: mdxHydration
     }),
     [mdxHydrationController, mdxHydration]
   );
-  const rendererRef = (0, import_react14.useRef)();
-  const [session, setSession] = (0, import_react14.useState)(0);
+  const rendererRef = (0, import_react15.useRef)();
+  const [session, setSession] = (0, import_react15.useState)(0);
   const rendererKey = `${configSignature}:${session}`;
   const historyLimit = effectiveScheduling.historyLimit ?? DEFAULT_HISTORY_LIMIT;
   if (!rendererRef.current || rendererRef.current.signature !== rendererKey) {
@@ -6040,7 +7022,9 @@ function StreamingMarkdownComponent({
         lowPriorityFrameBudgetMs: effectiveScheduling.lowPriorityFrameBudgetMs,
         urgentQueueThreshold: effectiveScheduling.urgentQueueThreshold,
         batch: effectiveScheduling.batch,
-        historyLimit
+        historyLimit,
+        startupMicrotaskFlushes: effectiveScheduling.startupMicrotaskFlushes,
+        adaptiveBudgeting: effectiveScheduling.adaptiveBudgeting
       },
       mdx: mdxConfig
     };
@@ -6050,7 +7034,7 @@ function StreamingMarkdownComponent({
     };
   }
   const renderer = rendererRef.current.renderer;
-  const highlightRequester = (0, import_react14.useCallback)(
+  const highlightRequester = (0, import_react15.useCallback)(
     (request) => {
       renderer.requestCodeHighlightRange(request);
     },
@@ -6058,15 +7042,15 @@ function StreamingMarkdownComponent({
   );
   const store = renderer.getStore();
   const blocks = useRendererBlocks(store);
-  const adaptiveSwitchedRef = (0, import_react14.useRef)(false);
-  const adaptiveFirstFlushRef = (0, import_react14.useRef)(false);
+  const adaptiveSwitchedRef = (0, import_react15.useRef)(false);
+  const adaptiveFirstFlushRef = (0, import_react15.useRef)(false);
   const mdxMode = mdxCompileMode ?? "server";
-  const [workerReady, setWorkerReady] = (0, import_react14.useState)(false);
-  const workerReadyRef = (0, import_react14.useRef)(false);
-  const [streamStatus, setStreamStatus] = (0, import_react14.useState)("idle");
-  const lastMetricsRef = (0, import_react14.useRef)(null);
-  const patchHistoryRef = (0, import_react14.useRef)([]);
-  (0, import_react14.useEffect)(() => {
+  const [workerReady, setWorkerReady] = (0, import_react15.useState)(false);
+  const workerReadyRef = (0, import_react15.useRef)(false);
+  const [streamStatus, setStreamStatus] = (0, import_react15.useState)("idle");
+  const lastMetricsRef = (0, import_react15.useRef)(null);
+  const patchHistoryRef = (0, import_react15.useRef)([]);
+  (0, import_react15.useEffect)(() => {
     if (typeof window === "undefined" || typeof PerformanceObserver === "undefined") {
       return void 0;
     }
@@ -6090,27 +7074,27 @@ function StreamingMarkdownComponent({
       observer?.disconnect();
     };
   }, []);
-  const previousTextRef = (0, import_react14.useRef)();
-  (0, import_react14.useEffect)(() => {
+  const previousTextRef = (0, import_react15.useRef)();
+  (0, import_react15.useEffect)(() => {
     if (text !== void 0 && text !== previousTextRef.current) {
       previousTextRef.current = text;
       setSession((prev) => prev + 1);
     }
   }, [text]);
-  const previousStreamRef = (0, import_react14.useRef)();
-  (0, import_react14.useEffect)(() => {
+  const previousStreamRef = (0, import_react15.useRef)();
+  (0, import_react15.useEffect)(() => {
     if (stream && stream !== previousStreamRef.current) {
       previousStreamRef.current = stream;
       setSession((prev) => prev + 1);
     }
   }, [stream]);
   const linkSafetyEnabled = Boolean(linkSafety?.enabled);
-  const [linkModalState, setLinkModalState] = (0, import_react14.useState)({
+  const [linkModalState, setLinkModalState] = (0, import_react15.useState)({
     url: "",
     isOpen: false,
     isChecking: false
   });
-  const openLink = (0, import_react14.useMemo)(() => {
+  const openLink = (0, import_react15.useMemo)(() => {
     return (url) => {
       if (typeof window === "undefined") return;
       if (url.startsWith("http://") || url.startsWith("https://")) {
@@ -6120,7 +7104,7 @@ function StreamingMarkdownComponent({
       }
     };
   }, []);
-  const handleLinkClick = (0, import_react14.useMemo)(() => {
+  const handleLinkClick = (0, import_react15.useMemo)(() => {
     return async (url) => {
       if (!linkSafetyEnabled) {
         openLink(url);
@@ -6142,10 +7126,10 @@ function StreamingMarkdownComponent({
       setLinkModalState({ url, isOpen: true, isChecking: false });
     };
   }, [linkSafety, linkSafetyEnabled, openLink]);
-  const handleLinkClose = (0, import_react14.useMemo)(() => {
+  const handleLinkClose = (0, import_react15.useMemo)(() => {
     return () => setLinkModalState((prev) => ({ ...prev, isOpen: false }));
   }, []);
-  const handleLinkConfirm = (0, import_react14.useMemo)(() => {
+  const handleLinkConfirm = (0, import_react15.useMemo)(() => {
     return () => {
       const url = linkModalState.url;
       setLinkModalState((prev) => ({ ...prev, isOpen: false }));
@@ -6154,7 +7138,7 @@ function StreamingMarkdownComponent({
       }
     };
   }, [linkModalState.url, openLink]);
-  const handleLinkCopy = (0, import_react14.useMemo)(() => {
+  const handleLinkCopy = (0, import_react15.useMemo)(() => {
     return () => {
       const url = linkModalState.url;
       if (!url || typeof navigator === "undefined") return;
@@ -6175,7 +7159,7 @@ function StreamingMarkdownComponent({
       }
     };
   }, [linkModalState.url]);
-  const resolvedInlineComponents = (0, import_react14.useMemo)(() => {
+  const resolvedInlineComponents = (0, import_react15.useMemo)(() => {
     if (!linkSafetyEnabled) {
       return inlineComponents;
     }
@@ -6183,9 +7167,9 @@ function StreamingMarkdownComponent({
       const url = typeof href === "string" ? href : "";
       const isIncomplete = url.startsWith("streamdown:incomplete-link") || url.startsWith("stream-mdx:incomplete-link");
       if (!url || isIncomplete) {
-        return import_react14.default.createElement("span", { className: "markdown-link", title }, children);
+        return import_react15.default.createElement("span", { className: "markdown-link", title }, children);
       }
-      return import_react14.default.createElement(
+      return import_react15.default.createElement(
         "button",
         {
           type: "button",
@@ -6202,14 +7186,14 @@ function StreamingMarkdownComponent({
     };
     return { ...inlineComponents ?? {}, link: LinkComponent };
   }, [handleLinkClick, inlineComponents, linkSafetyEnabled]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     setStreamStatus("idle");
   }, [session]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     adaptiveSwitchedRef.current = false;
     adaptiveFirstFlushRef.current = false;
   }, [renderer]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     if (!adaptiveSwitchEnabled) return void 0;
     const unsubscribe = renderer.addFlushListener((result) => {
       if (adaptiveSwitchedRef.current) return;
@@ -6231,12 +7215,12 @@ function StreamingMarkdownComponent({
     });
     return unsubscribe;
   }, [renderer, adaptiveSwitchEnabled, adaptiveQueueThreshold]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     lastMetricsRef.current = null;
     patchHistoryRef.current = [];
     void renderer;
   }, [renderer]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     if (components) {
       renderer.setBlockComponents(components);
     }
@@ -6255,7 +7239,7 @@ function StreamingMarkdownComponent({
       renderer.getComponentRegistry().setHtmlElements(htmlElements);
     }
   }, [renderer, components, mdxComponents, inlineComponents, resolvedInlineComponents, tableElements, htmlElements]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     const removeListener = renderer.addFlushListener((result) => {
       const metrics = summarizeFlush(result);
       lastMetricsRef.current = metrics;
@@ -6273,12 +7257,12 @@ function StreamingMarkdownComponent({
     });
     return removeListener;
   }, [renderer, historyLimit, onMetrics]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     if (patchHistoryRef.current.length > historyLimit) {
       patchHistoryRef.current.splice(0, patchHistoryRef.current.length - historyLimit);
     }
   }, [historyLimit]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     const restartToken = session;
     void restartToken;
     if (process.env.NODE_ENV !== "production" && DEBUG_WORKER) {
@@ -6334,7 +7318,7 @@ function StreamingMarkdownComponent({
       }
     };
   }, [renderer, workerSource, session, onError, managedWorker]);
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     const restartToken = session;
     void restartToken;
     let cancelled = false;
@@ -6397,7 +7381,7 @@ function StreamingMarkdownComponent({
       cancelled = true;
     };
   }, [renderer, text, stream, workerReady, session, onError, managedWorker]);
-  (0, import_react14.useImperativeHandle)(
+  (0, import_react15.useImperativeHandle)(
     ref,
     () => ({
       pause() {
@@ -6451,8 +7435,8 @@ function StreamingMarkdownComponent({
     }),
     [renderer, store]
   );
-  const hasActiveBlocks = (0, import_react14.useMemo)(() => blocks.some((block) => !block.isFinalized), [blocks]);
-  const caretValue = (0, import_react14.useMemo)(() => {
+  const hasActiveBlocks = (0, import_react15.useMemo)(() => blocks.some((block) => !block.isFinalized), [blocks]);
+  const caretValue = (0, import_react15.useMemo)(() => {
     if (!caret) {
       return null;
     }
@@ -6473,7 +7457,7 @@ function StreamingMarkdownComponent({
     ...style ?? {},
     ["--stream-mdx-caret"]: JSON.stringify(caretValue)
   } : style;
-  const deferredConfig = (0, import_react14.useMemo)(() => {
+  const deferredConfig = (0, import_react15.useMemo)(() => {
     if (!deferHeavyBlocks) {
       return null;
     }
@@ -6490,10 +7474,10 @@ function StreamingMarkdownComponent({
     onConfirm: handleLinkConfirm,
     onCopy: handleLinkCopy
   }) : null;
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(MdxHydrationContext.Provider, { value: mdxHydrationContextValue, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(DeferredRenderContext.Provider, { value: deferredConfig, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(MdxPrefetchBridge, { store }),
-    mdxMode === "server" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(MdxCoordinatorBridge, { store, mode: mdxMode }) : null,
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(CodeHighlightRequestContext.Provider, { value: highlightRequester, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(MdxHydrationContext.Provider, { value: mdxHydrationContextValue, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(DeferredRenderContext.Provider, { value: deferredConfig, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(MdxPrefetchBridge, { store }),
+    mdxMode === "server" ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(MdxCoordinatorBridge, { store, mode: mdxMode }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(CodeHighlightRequestContext.Provider, { value: highlightRequester, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
       MarkdownBlocksRenderer,
       {
         blocks: EMPTY_BLOCKS,
@@ -6506,7 +7490,7 @@ function StreamingMarkdownComponent({
     linkModal
   ] }) });
 }
-var StreamingMarkdownWithRef = (0, import_react14.forwardRef)(StreamingMarkdownComponent);
+var StreamingMarkdownWithRef = (0, import_react15.forwardRef)(StreamingMarkdownComponent);
 StreamingMarkdownWithRef.displayName = "StreamingMarkdown";
 var StreamingMarkdown = StreamingMarkdownWithRef;
 function instantiateWorker(source) {
@@ -6613,6 +7597,7 @@ function percentile2(values, ratio) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BottomStickScrollArea,
   ComponentRegistry,
   DEFAULT_COALESCE_CONFIG,
   DEFAULT_VIRTUALIZED_CODE_CONFIG,
@@ -6638,6 +7623,7 @@ function percentile2(values, ratio) {
   defaultInlineComponents,
   getMDXClient,
   getMDXComponentFactory,
+  getPatchKind,
   isHeavyPatch,
   isListPatchDebugEnabled,
   mapHtmlToReact,