@stream-mdx/react 0.4.0 → 0.5.0

package/dist/server.cjs

@@ -102,7 +102,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;
@@ -972,7 +972,11 @@ var defaultInlineComponents = {
     const n = number ?? "?";
     const href = number ? `#fn:${n}` : void 0;
     const id = number ? `fnref:${n}` : void 0;
-    return import_react6.default.createElement("sup", { className: "footnote-ref" }, import_react6.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 = {
@@ -1115,7 +1119,7 @@ var defaultBlockComponents = {
       dangerouslySetInnerHTML: { __html: htmlString }
     });
   },
-  mdx: ({ compiledRef, compiledModule, status, errorMessage, raw }) => {
+  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);
@@ -1216,7 +1220,6 @@ 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_react6.default.createElement("pre", { className: "markdown-mdx-fallback" }, raw) : null;
     const allowRetry = Boolean(internalError || renderError);
     const retryButton = allowRetry ? import_react6.default.createElement(
       "button",
@@ -1228,9 +1231,10 @@ var defaultBlockComponents = {
       "Retry hydration"
     ) : null;
     const errorPanel = import_react6.default.createElement(
-      "div",
-      { className: "markdown-mdx-error" },
-      import_react6.default.createElement(import_react6.default.Fragment, null, import_react6.default.createElement("strong", null, "MDX failed"), import_react6.default.createElement("div", null, message))
+      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_react6.default.createElement(
@@ -1253,14 +1257,13 @@ var defaultBlockComponents = {
       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
       );
     }
@@ -1287,7 +1290,16 @@ var defaultBlockComponents = {
         { key: item.number, id: `fn:${item.number}` },
         renderInlineNodes(item.inlines, defaultInlineComponents),
         " ",
-        import_react6.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_react6.default.createElement("section", { className: "footnotes" }, import_react6.default.createElement("hr", {}), import_react6.default.createElement("ol", {}, listItems));
@@ -1835,6 +1847,7 @@ var DeferredRenderContext = import_react8.default.createContext(null);
 
 // src/renderer/store.ts
 var import_core4 = require("@stream-mdx/core");
+var import_patch_batching = require("@stream-mdx/core/perf/patch-batching");
 
 // src/renderer/list-utils.ts
 function updateNodeDepth(node, depth) {
@@ -1933,12 +1946,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;
@@ -1948,6 +1977,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({
@@ -2115,9 +2152,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 : [];
 }
@@ -2177,7 +2262,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;
   }
@@ -2226,8 +2311,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;
     }
@@ -2271,16 +2355,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);
@@ -2311,8 +2393,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;
     }
@@ -2396,8 +2477,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,
@@ -2508,6 +2591,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) {
@@ -2524,7 +2619,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;
   }
@@ -2547,7 +2642,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,
@@ -2557,6 +2700,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") {
@@ -2565,7 +2709,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;
@@ -2593,8 +2737,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);
@@ -2626,13 +2769,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) {
@@ -2650,13 +2793,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);
@@ -2676,6 +2819,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;
@@ -2707,9 +2868,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);
@@ -2718,9 +2882,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();
@@ -2785,11 +2952,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_batching.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))) {
@@ -2816,6 +3029,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;
@@ -2879,16 +3095,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;
@@ -2931,13 +3187,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) {
@@ -2957,6 +3222,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;
@@ -2968,6 +3234,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);
               }
@@ -2984,11 +3251,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);
             }
@@ -3002,18 +3278,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_batching.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_batching.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) {
@@ -3022,6 +3313,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);
@@ -3035,6 +3337,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;
@@ -3049,6 +3352,9 @@ function createRendererStore(initialBlocks = []) {
             parent.children.splice(to, 0, ...moved);
             parent.version++;
             touched.add(parent.id);
+            if ((0, import_patch_batching.getPatchKind)(patch) === "semantic") {
+              advanceBlockEpoch(patch.at.blockId, touched, readPatchParseEpoch(patch), readPatchTx(patch));
+            }
             if (isListRelated(parent.type)) {
               markListDepthDirty(parent.id);
             }
@@ -3064,15 +3370,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++) {
@@ -3114,7 +3436,8 @@ function createRendererStore(initialBlocks = []) {
                   parentId: parent.id,
                   children: [],
                   props: nextLineProps,
-                  version: 0
+                  version: 0,
+                  blockEpoch: parent.blockEpoch
                 };
                 nodes.set(lineId, record);
                 touched.add(lineId);
@@ -3164,6 +3487,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);
@@ -3206,6 +3530,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;
       }
@@ -3226,6 +3574,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();
@@ -3274,6 +3624,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;
@@ -3293,6 +3644,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;
@@ -3302,6 +3654,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;
     },
@@ -3750,8 +4108,10 @@ var ListBlockView = import_react10.default.memo(
         isFinalized: block?.isFinalized ?? false
       });
     }, [listDebugEnabled, blockId, depth, ordered, childIds, listItemIds, store, block?.isFinalized]);
-    const listStyle = import_react10.default.useMemo(() => {
-      if (!ordered || listItemIds.length === 0) return void 0;
+    const { listStyle, markerDigits } = import_react10.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);
@@ -3763,9 +4123,14 @@ var ListBlockView = import_react10.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;
@@ -3774,6 +4139,7 @@ var ListBlockView = import_react10.default.memo(
       {
         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_runtime.jsx)(
@@ -3955,6 +4321,7 @@ var CodeBlockView = import_react10.default.memo(({ store, blockId, registry }) =
     deferredConfig ? { ...deferredConfig, enabled: true } : { enabled: false }
   );
   if (!node || !node.block) return null;
+  const blockIsFinalized = node.block.isFinalized;
   const nodeVersion = node.version;
   const lines = import_react10.default.useMemo(() => {
     const seenIds = /* @__PURE__ */ new Set();
@@ -3985,13 +4352,25 @@ var CodeBlockView = import_react10.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_react10.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_react10.default.useRef(null);
   const rafRef = import_react10.default.useRef(null);
   const idleRef = import_react10.default.useRef(null);
@@ -4072,29 +4451,111 @@ var CodeBlockView = import_react10.default.memo(({ store, blockId, registry }) =
     virtualization.window.startIndex,
     virtualization.window.endIndex
   ]);
-  const highlightedHtml = import_react10.default.useMemo(() => {
-    if (!shouldVirtualize && node.block?.payload.highlightedHtml) {
-      return node.block.payload.highlightedHtml;
+  import_react10.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_react10.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]);
+  }, [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_runtime.jsx)(
     CodeComponent,
     {
@@ -4106,13 +4567,19 @@ var CodeBlockView = import_react10.default.memo(({ store, blockId, registry }) =
       codeAttrs
     }
   );
+  const effectiveLineCount = import_react10.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 ? (() => {
@@ -4158,21 +4625,152 @@ var CodeBlockView = import_react10.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;");
 }