@stream-mdx/worker 0.2.0 → 0.4.0

package/dist/direct.cjs

@@ -0,0 +1,3978 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/worker-dom-stub.ts
+var characterEntities;
+var init_worker_dom_stub = __esm({
+  "src/worker-dom-stub.ts"() {
+    "use strict";
+    characterEntities = __toESM(require("character-entities"), 1);
+    if (typeof document === "undefined") {
+      const entityMap = characterEntities;
+      globalThis.document = {
+        compatMode: "CSS1Compat",
+        createElement() {
+          return {
+            _inner: "",
+            set innerHTML(value) {
+              this._inner = value;
+            },
+            get innerHTML() {
+              return this._inner;
+            },
+            get textContent() {
+              const match = /^&([^;]+);$/.exec(this._inner);
+              if (match) {
+                const entity = entityMap[match[1]];
+                if (typeof entity === "string") {
+                  return entity;
+                }
+              }
+              return this._inner;
+            }
+          };
+        }
+      };
+    }
+    if (typeof globalThis.DOMParser === "undefined") {
+      class DOMParserStub {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        parseFromString(content, _type) {
+          const text = content ?? "";
+          const noop = () => null;
+          const emptyList = () => [];
+          return {
+            textContent: text,
+            innerHTML: text,
+            documentElement: { textContent: text, innerHTML: text },
+            body: {
+              innerHTML: text,
+              textContent: text,
+              firstChild: null,
+              querySelector: noop,
+              querySelectorAll: emptyList,
+              appendChild: noop,
+              removeChild: noop
+            },
+            createElement() {
+              return {
+                innerHTML: "",
+                textContent: "",
+                querySelector: noop,
+                querySelectorAll: emptyList,
+                appendChild: noop,
+                removeChild: noop
+              };
+            },
+            querySelector: noop,
+            querySelectorAll: emptyList
+          };
+        }
+      }
+      globalThis.DOMParser = DOMParserStub;
+    }
+  }
+});
+
+// src/parser/block-types.ts
+function normalizeNodeName(nodeType) {
+  if (!nodeType) return "";
+  if (nodeType.startsWith("ATXHeading")) {
+    return "ATXHeading";
+  }
+  if (nodeType.startsWith("SetextHeading")) {
+    return "SetextHeading";
+  }
+  return nodeType;
+}
+function isBlockLevelNode(nodeType) {
+  const normalized = normalizeNodeName(nodeType);
+  if (normalized === "BulletList" || normalized === "OrderedList") {
+    return true;
+  }
+  return BLOCK_NODE_TYPES.has(normalized);
+}
+function mapLezerNodeToBlockType(nodeType) {
+  const normalized = normalizeNodeName(nodeType);
+  switch (normalized) {
+    case "ATXHeading":
+    case "SetextHeading":
+      return "heading";
+    case "Paragraph":
+      return "paragraph";
+    case "FencedCode":
+    case "IndentedCode":
+      return "code";
+    case "Blockquote":
+      return "blockquote";
+    case "BulletList":
+    case "OrderedList":
+      return "list";
+    case "HTMLBlock":
+      return "html";
+    case "ThematicBreak":
+    case "HorizontalRule":
+      return "hr";
+    default:
+      return "paragraph";
+  }
+}
+var BLOCK_NODE_TYPES;
+var init_block_types = __esm({
+  "src/parser/block-types.ts"() {
+    "use strict";
+    BLOCK_NODE_TYPES = /* @__PURE__ */ new Set([
+      "Paragraph",
+      "Blockquote",
+      "FencedCode",
+      "IndentedCode",
+      "BulletList",
+      "OrderedList",
+      "HTMLBlock",
+      "ThematicBreak",
+      "HorizontalRule",
+      "ATXHeading",
+      "SetextHeading"
+    ]);
+  }
+});
+
+// src/perf/patch-heuristics.ts
+function isParagraphBoundaryPatch(patch) {
+  if (patch.op === "finalize") {
+    return true;
+  }
+  if ((patch.op === "insertChild" || patch.op === "replaceChild") && patch.node && typeof patch.node === "object" && patch.node.type === "paragraph") {
+    return true;
+  }
+  if (patch.op === "setProps" && typeof patch.at?.nodeId === "string" && patch.at.nodeId.includes("paragraph")) {
+    return true;
+  }
+  return false;
+}
+function countParagraphBoundaries(patches) {
+  let count = 0;
+  for (const patch of patches) {
+    if (isParagraphBoundaryPatch(patch)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function computeParagraphPatchLimit(patches, {
+  largePatchThreshold = 80,
+  baseLimit = 64,
+  finalizeLimit = 48
+} = {}) {
+  if (!Array.isArray(patches) || patches.length < largePatchThreshold) {
+    return null;
+  }
+  const paragraphBoundaries = countParagraphBoundaries(patches);
+  if (paragraphBoundaries === 0) {
+    return null;
+  }
+  const hasFinalize = patches.some((patch) => patch.op === "finalize");
+  if (hasFinalize) {
+    return Math.min(Math.max(16, finalizeLimit), patches.length);
+  }
+  const scaledLimit = Math.max(32, Math.min(baseLimit, baseLimit - (paragraphBoundaries - 1) * 8));
+  return Math.min(scaledLimit, patches.length);
+}
+var init_patch_heuristics = __esm({
+  "src/perf/patch-heuristics.ts"() {
+    "use strict";
+  }
+});
+
+// src/lazy-tokenization.ts
+function clampLazyRange(startLine, endLine, totalLines) {
+  const clampedStart = Math.max(0, Math.min(Math.floor(startLine), totalLines));
+  const clampedEnd = Math.max(clampedStart, Math.min(Math.floor(endLine), totalLines));
+  return { startLine: clampedStart, endLine: clampedEnd };
+}
+function compareLazyPriority(a, b) {
+  return (PRIORITY_ORDER[a] ?? 0) - (PRIORITY_ORDER[b] ?? 0);
+}
+function mergeLazyRequests(existing, next) {
+  const priority = compareLazyPriority(existing.priority, next.priority) >= 0 ? existing.priority : next.priority;
+  const startLine = Math.min(existing.startLine, next.startLine);
+  const endLine = Math.max(existing.endLine, next.endLine);
+  const useNextTimestamp = compareLazyPriority(next.priority, existing.priority) >= 0;
+  return {
+    blockId: existing.blockId,
+    startLine,
+    endLine,
+    priority,
+    requestedAt: useNextTimestamp ? next.requestedAt : existing.requestedAt
+  };
+}
+function lazyRequestRangeSize(request) {
+  return Math.max(0, request.endLine - request.startLine);
+}
+var PRIORITY_ORDER;
+var init_lazy_tokenization = __esm({
+  "src/lazy-tokenization.ts"() {
+    "use strict";
+    PRIORITY_ORDER = {
+      visible: 2,
+      prefetch: 1
+    };
+  }
+});
+
+// src/mdx-compile.ts
+function collectMdxDependencies(source) {
+  const dependencies = /* @__PURE__ */ new Set();
+  const importRegex = /(?:import|export)\s+[^'"]*?\sfrom\s+['"]([^'"]+)['"]/g;
+  let match;
+  while (true) {
+    match = importRegex.exec(source);
+    if (match === null) {
+      break;
+    }
+    dependencies.add(match[1]);
+  }
+  return Array.from(dependencies);
+}
+async function compileMdxContent(source) {
+  const isDev = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env?.NODE_ENV === "development";
+  const compiled = await (0, import_mdx.compile)(source, {
+    outputFormat: "function-body",
+    development: isDev,
+    remarkPlugins: [import_remark_gfm.default, import_remark_math.default],
+    rehypePlugins: [
+      import_rehype_slug.default,
+      [
+        import_rehype_katex.default,
+        {
+          throwOnError: false,
+          errorColor: "#cc0000",
+          strict: false
+        }
+      ]
+    ],
+    jsxImportSource: "react"
+  });
+  return {
+    code: String(compiled),
+    dependencies: collectMdxDependencies(source)
+  };
+}
+var import_mdx, import_rehype_katex, import_rehype_slug, import_remark_gfm, import_remark_math;
+var init_mdx_compile = __esm({
+  "src/mdx-compile.ts"() {
+    "use strict";
+    import_mdx = require("@mdx-js/mdx");
+    import_rehype_katex = __toESM(require("rehype-katex"), 1);
+    import_rehype_slug = __toESM(require("rehype-slug"), 1);
+    import_remark_gfm = __toESM(require("remark-gfm"), 1);
+    import_remark_math = __toESM(require("remark-math"), 1);
+  }
+});
+
+// src/worker.ts
+var worker_exports = {};
+function clampInt(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function readNumericEnv(key) {
+  try {
+    if (typeof process !== "undefined" && process.env && process.env[key]) {
+      const parsed = Number(process.env[key]);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function sliceAppendChunk(text, maxChars) {
+  if (text.length <= maxChars) {
+    return { chunk: text, rest: "" };
+  }
+  const newlineIndex = text.lastIndexOf("\n", maxChars);
+  const cut = newlineIndex > 0 && maxChars - newlineIndex <= APPEND_NEWLINE_GRACE ? newlineIndex + 1 : maxChars;
+  return { chunk: text.slice(0, cut), rest: text.slice(cut) };
+}
+function waitForNextTick() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+function isDebugEnabled(flag) {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      if (flag === "mdx" && process.env.NEXT_PUBLIC_STREAMING_DEBUG_MDX === "1") return true;
+      if (flag === "worker" && process.env.NEXT_PUBLIC_STREAMING_DEBUG_WORKER === "1") return true;
+    }
+  } catch {
+  }
+  try {
+    const g = globalThis;
+    if (flag === "mdx" && g.__STREAMING_DEBUG__?.mdx) return true;
+    if (flag === "worker" && g.__STREAMING_DEBUG__?.worker) return true;
+  } catch {
+  }
+  return false;
+}
+function now() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function roundMetric(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.round(value * 1e3) / 1e3;
+}
+function setActiveMetricsCollector(collector) {
+  activeMetricsCollector = collector;
+}
+function getActiveMetricsCollector() {
+  return activeMetricsCollector;
+}
+function estimatePatchSize(patches) {
+  if (!sharedTextEncoder) return 0;
+  try {
+    return sharedTextEncoder.encode(JSON.stringify(patches)).length;
+  } catch {
+    return 0;
+  }
+}
+function countChangedBlocksFromPatches(patches) {
+  if (!patches || patches.length === 0) return 0;
+  const ids = /* @__PURE__ */ new Set();
+  for (const patch of patches) {
+    const blockId = patch.at?.blockId;
+    if (blockId) {
+      ids.add(blockId);
+    }
+  }
+  return ids.size;
+}
+function partitionPatchesForCredits(patches, maxImmediate) {
+  let combined = patches;
+  if (deferredPatchQueue.length > 0) {
+    combined = deferredPatchQueue.concat(patches);
+    deferredPatchQueue = [];
+  }
+  if (combined.length === 0) {
+    return [];
+  }
+  const immediate = [];
+  const deferred = [];
+  let heavyBudget = (0, import_core3.computeHeavyPatchBudget)(workerCredits);
+  let nonStructuralImmediate = 0;
+  const isStructuralPatch = (patch) => {
+    switch (patch.op) {
+      case "insertChild":
+      case "deleteChild":
+      case "replaceChild":
+      case "reorder":
+        return true;
+      default:
+        return false;
+    }
+  };
+  for (const patch of combined) {
+    if (isStructuralPatch(patch)) {
+      immediate.push(patch);
+      continue;
+    }
+    const heavy = (0, import_patch_batching.isHeavyPatch)(patch);
+    if (heavy) {
+      if (heavyBudget <= 0) {
+        if (deferred.length < MAX_DEFERRED_PATCHES) {
+          deferred.push(patch);
+          continue;
+        }
+      } else {
+        heavyBudget -= 1;
+      }
+    }
+    if (typeof maxImmediate === "number" && nonStructuralImmediate >= maxImmediate) {
+      deferred.push(patch);
+      continue;
+    }
+    immediate.push(patch);
+    nonStructuralImmediate += 1;
+  }
+  deferredPatchQueue = deferred;
+  return immediate;
+}
+function flushDeferredPatches() {
+  if (workerCredits <= 0 || deferredPatchQueue.length === 0) {
+    return;
+  }
+  const immediate = partitionPatchesForCredits([], MAX_DEFERRED_FLUSH_PATCHES);
+  if (immediate.length === 0) {
+    return;
+  }
+  const metricsCollector = new WorkerMetricsCollector(workerGrammarEngine);
+  metricsCollector.setBlocksProduced(blocks.length);
+  const tx = ++txCounter;
+  const patchBytes = estimatePatchSize(immediate);
+  metricsCollector.finalizePatch(tx, immediate.length, deferredPatchQueue.length, patchBytes);
+  const changedBlocks = countChangedBlocksFromPatches(immediate);
+  const patchMetrics = metricsCollector.toPatchMetrics(changedBlocks);
+  postMessage({
+    type: "PATCH",
+    tx,
+    patches: immediate,
+    metrics: patchMetrics
+  });
+  emitMetricsSample(metricsCollector);
+  if (getActiveMetricsCollector() === metricsCollector) {
+    setActiveMetricsCollector(null);
+  }
+}
+function emitMetricsSample(collector) {
+  if (!collector) return;
+  const metrics = collector.toPerformanceMetrics();
+  if (!metrics) return;
+  postMessage({
+    type: "METRICS",
+    metrics
+  });
+}
+function mapToNumberRecord(map, roundValues = false) {
+  const result = {};
+  for (const [key, value] of map.entries()) {
+    if (!Number.isFinite(value)) continue;
+    if (value === 0) continue;
+    result[key] = roundValues ? roundMetric(value) : value;
+  }
+  return result;
+}
+function mapToHighlightRecord(map) {
+  const result = {};
+  for (const [key, value] of map.entries()) {
+    if (!value || value.count <= 0 || !Number.isFinite(value.time)) continue;
+    const total = roundMetric(value.time);
+    result[key] = {
+      count: value.count,
+      totalMs: total,
+      avgMs: roundMetric(total / value.count)
+    };
+  }
+  return result;
+}
+function parseInlineStreaming(content) {
+  const prepared = (0, import_core.prepareInlineStreamingContent)(content, { formatAnticipation: formatAnticipationConfig, math: enableMath });
+  if (prepared.kind === "raw") {
+    return { inline: [{ kind: "text", text: content }], status: prepared.status };
+  }
+  let preparedContent = prepared.content;
+  let appended = prepared.appended;
+  if (formatAnticipationConfig.regex) {
+    const regexAppend = inlineParser.getRegexAnticipationAppend(content);
+    if (regexAppend) {
+      preparedContent += regexAppend;
+      appended += regexAppend;
+    }
+  }
+  const status = appended.length > 0 ? "anticipated" : prepared.status;
+  return {
+    inline: inlineParser.parse(preparedContent, { cache: false }),
+    status
+  };
+}
+function slugifyHeading(text) {
+  const normalized = text.trim().toLowerCase().replace(/[\u0000-\u001f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  return normalized;
+}
+function buildTocHeadings(blocksInput) {
+  const headings = [];
+  for (const block of blocksInput) {
+    if (block.type !== "heading") continue;
+    const meta = block.payload.meta ?? {};
+    const rawHeading = typeof block.payload.raw === "string" ? block.payload.raw : "";
+    const headingText = typeof meta.headingText === "string" && meta.headingText.trim().length > 0 ? meta.headingText : (0, import_core.removeHeadingMarkers)(rawHeading).trim();
+    const levelFromMeta = typeof meta.headingLevel === "number" ? meta.headingLevel : 1;
+    const level = Math.min(Math.max(levelFromMeta, 1), 6);
+    const id = typeof meta.headingId === "string" && meta.headingId.trim().length > 0 ? meta.headingId : slugifyHeading(headingText) || "heading";
+    headings.push({
+      id,
+      text: headingText,
+      level,
+      blockId: block.id
+    });
+  }
+  return headings;
+}
+function tocSignatureFor(headings) {
+  if (headings.length === 0) return "";
+  return headings.map((heading) => `${heading.id}:${heading.level}:${heading.text}`).join("|");
+}
+function maybeBuildTocPatch(blocksInput) {
+  const nextHeadings = buildTocHeadings(blocksInput);
+  const nextSignature = tocSignatureFor(nextHeadings);
+  tocHeadings = nextHeadings;
+  if (nextSignature === tocSignature) {
+    return null;
+  }
+  tocSignature = nextSignature;
+  return {
+    op: "setProps",
+    at: { blockId: import_core.PATCH_ROOT_ID },
+    props: {
+      tocHeadings: nextHeadings
+    }
+  };
+}
+async function initialize(initialContent = "", prewarmLangs = [], docPlugins, mdxOptions) {
+  performanceTimer = new import_core.PerformanceTimer();
+  blocks = [];
+  lastTree = null;
+  currentContent = "";
+  deferredPatchQueue = [];
+  tocHeadings = [];
+  tocSignature = "";
+  resetIncrementalHighlightState();
+  lazyTokenizationStates.clear();
+  lazyTokenizationQueue.clear();
+  lazyTokenizationScheduled = false;
+  lazyTokenizationProcessing = false;
+  mdxCompileMode = mdxOptions?.compileMode ?? "server";
+  try {
+    if (DEBUG_MDX) {
+      console.debug("[markdown-worker] init", { mdxCompileMode });
+    }
+  } catch {
+  }
+  clearWorkerMdxCaches();
+  const enable = {
+    footnotes: docPlugins?.footnotes ?? true,
+    html: docPlugins?.html ?? true,
+    mdx: docPlugins?.mdx ?? true,
+    tables: docPlugins?.tables ?? true,
+    callouts: docPlugins?.callouts ?? false,
+    math: docPlugins?.math ?? true,
+    formatAnticipation: docPlugins?.formatAnticipation ?? false,
+    codeHighlighting: docPlugins?.codeHighlighting,
+    liveCodeHighlighting: docPlugins?.liveCodeHighlighting ?? false,
+    liveTokenization: docPlugins?.liveTokenization ?? true,
+    emitHighlightTokens: docPlugins?.emitHighlightTokens ?? true,
+    emitDiffBlocks: docPlugins?.emitDiffBlocks ?? false
+  };
+  enableMath = enable.math;
+  formatAnticipationConfig = (0, import_core.normalizeFormatAnticipation)(enable.formatAnticipation);
+  if (enable.codeHighlighting === "incremental" || enable.codeHighlighting === "live" || enable.codeHighlighting === "final") {
+    codeHighlightingMode = enable.codeHighlighting;
+  } else {
+    codeHighlightingMode = enable.liveCodeHighlighting ? "live" : "final";
+  }
+  if (docPlugins?.outputMode === "html" || docPlugins?.outputMode === "tokens" || docPlugins?.outputMode === "both") {
+    highlightOutputMode = docPlugins.outputMode;
+  } else {
+    highlightOutputMode = "html";
+  }
+  emitHighlightTokens = enable.emitHighlightTokens;
+  emitDiffBlocks = enable.emitDiffBlocks;
+  liveTokenizationEnabled = enable.liveTokenization;
+  if (docPlugins?.lazyTokenization) {
+    lazyTokenizationEnabled = docPlugins.lazyTokenization.enabled ?? true;
+    const desiredThreshold = docPlugins.lazyTokenization.thresholdLines ?? DEFAULT_LAZY_TOKENIZATION_THRESHOLD;
+    lazyTokenizationThresholdLines = clampInt(desiredThreshold, MIN_LAZY_TOKENIZATION_THRESHOLD, MAX_LAZY_TOKENIZATION_THRESHOLD);
+  } else {
+    lazyTokenizationEnabled = true;
+    lazyTokenizationThresholdLines = DEFAULT_LAZY_TOKENIZATION_THRESHOLD;
+  }
+  if (Array.isArray(docPlugins?.mdxComponentNames) && docPlugins?.mdxComponentNames.length > 0) {
+    mdxComponentAllowlist = new Set(docPlugins.mdxComponentNames);
+  } else {
+    mdxComponentAllowlist = null;
+  }
+  inlineParser = new import_core2.InlineParser({ enableMath });
+  documentPluginState.inlineParser = inlineParser;
+  if (enable.footnotes) (0, import_plugins.registerFootnotesPlugin)();
+  if (enable.tables) import_plugins.globalDocumentPluginRegistry.register(import_plugins.TablesPlugin);
+  if (enable.callouts) import_plugins.globalDocumentPluginRegistry.register(import_plugins.CalloutsPlugin);
+  if (enable.html) import_plugins.globalDocumentPluginRegistry.register(import_plugins.HTMLBlockPlugin);
+  if (enable.mdx) import_plugins.globalDocumentPluginRegistry.register(import_plugins.MDXDetectionPlugin);
+  performanceTimer.mark("highlighter-init");
+  const coreLangs = ["javascript", "typescript", "json", "text", "markdown", "diff"];
+  const initialLangs = [...coreLangs, ...prewarmLangs];
+  highlighter = await (0, import_shiki.createHighlighter)({
+    engine: (0, import_engine_javascript.createJavaScriptRegexEngine)(),
+    langs: initialLangs,
+    themes: ["github-dark", "github-light"]
+  });
+  const highlighterTime = performanceTimer.measure("highlighter-init");
+  if (initialContent) {
+    currentContent = initialContent;
+    const result = await parseAll(initialContent);
+    blocks = result.blocks;
+    lastTree = result.lastTree;
+  }
+  txCounter = 0;
+  postMessage({
+    type: "INITIALIZED",
+    blocks
+  });
+  if (blocks.length > 0) {
+    await emitDocumentPatch(blocks);
+  }
+}
+async function handleAppend(text) {
+  let remaining = text;
+  let batchStartedAt = now();
+  while (remaining.length > 0) {
+    const { chunk, rest } = sliceAppendChunk(remaining, APPEND_CHUNK_SIZE);
+    remaining = rest;
+    performanceTimer.mark("append-operation");
+    const metricsCollector = new WorkerMetricsCollector(workerGrammarEngine);
+    setActiveMetricsCollector(metricsCollector);
+    await appendAndReparse(chunk, metricsCollector);
+    const hadPatchMetrics = metricsCollector.patchCount > 0;
+    const totalTime = performanceTimer.measure("append-operation");
+    if (getActiveMetricsCollector() === metricsCollector) {
+      setActiveMetricsCollector(null);
+    }
+    if (!hadPatchMetrics && totalTime !== null && Number.isFinite(totalTime)) {
+      postMessage({
+        type: "METRICS",
+        metrics: {
+          parseMs: roundMetric(totalTime),
+          parseTime: roundMetric(totalTime),
+          blocksProduced: blocks.length,
+          grammarEngine: workerGrammarEngine
+        }
+      });
+    }
+    if (remaining.length > 0 && now() - batchStartedAt >= APPEND_BATCH_MS) {
+      await waitForNextTick();
+      batchStartedAt = now();
+    }
+  }
+}
+async function parseAll(content, options = {}) {
+  performanceTimer.mark("parse-all");
+  const metrics = getActiveMetricsCollector();
+  metrics?.markParseStart();
+  const tree = import_markdown.parser.parse(content);
+  let extractedBlocks = await extractBlocks(tree, content, options);
+  extractedBlocks = runDocumentPlugins(extractedBlocks, content);
+  performanceTimer.measure("parse-all");
+  metrics?.markParseEnd();
+  metrics?.setBlocksProduced(extractedBlocks.length);
+  return {
+    blocks: extractedBlocks,
+    lastTree: tree
+  };
+}
+async function appendAndReparse(appendedText, metrics) {
+  performanceTimer.mark("incremental-parse");
+  metrics?.markParseStart();
+  const newContent = currentContent + appendedText;
+  const changeRanges = computeChangedRanges(currentContent, newContent);
+  let newTree = lastTree ? import_markdown.parser.parse(newContent, lastTree.fragments) : import_markdown.parser.parse(newContent);
+  let changedBlocks = await extractBlocks(newTree, newContent);
+  changedBlocks = runDocumentPlugins(changedBlocks, newContent);
+  const lastRange = changedBlocks.length > 0 ? changedBlocks[changedBlocks.length - 1]?.payload?.range : void 0;
+  const lastTo = typeof lastRange?.to === "number" ? lastRange.to : 0;
+  if (lastTo < newContent.length - 1) {
+    const tail = newContent.slice(lastTo).trim();
+    if (tail.length > 0) {
+      const fullTree = import_markdown.parser.parse(newContent);
+      let fullBlocks = await extractBlocks(fullTree, newContent);
+      fullBlocks = runDocumentPlugins(fullBlocks, newContent);
+      const fullLast = fullBlocks.length > 0 ? fullBlocks[fullBlocks.length - 1]?.payload?.range?.to ?? 0 : 0;
+      if (fullLast >= newContent.length - 1 || fullBlocks.length >= changedBlocks.length) {
+        newTree = fullTree;
+        changedBlocks = fullBlocks;
+      }
+    }
+  }
+  const prevBlocks = blocks;
+  blocks = changedBlocks;
+  lastTree = newTree;
+  currentContent = newContent;
+  pruneLazyTokenizationStates(blocks);
+  performanceTimer.measure("incremental-parse");
+  metrics?.markParseEnd();
+  metrics?.setBlocksProduced(blocks.length);
+  await emitBlockDiffPatches(prevBlocks, changedBlocks, changeRanges, metrics);
+}
+async function extractBlocks(tree, content, options = {}) {
+  try {
+    headingIdCounts = /* @__PURE__ */ new Map();
+    const blocks2 = [];
+    const cursor = tree.cursor();
+    if (cursor.firstChild()) {
+      do {
+        const nodeType = cursor.type.name;
+        const from = cursor.from;
+        const to = cursor.to;
+        const raw = content.slice(from, to);
+        if (isBlockLevelNode(nodeType)) {
+          const blockType = mapLezerNodeToBlockType(nodeType);
+          const block = await createBlock(blockType, raw, from, to, content, options);
+          if (block && raw.trim()) {
+            blocks2.push(block);
+          }
+        }
+      } while (cursor.nextSibling());
+    }
+    if (blocks2.length === 0) {
+      return await extractBlocksSimple(content, options);
+    }
+    return blocks2;
+  } catch (error) {
+    const details = error instanceof Error ? { name: error.name, message: error.message, stack: error.stack } : error;
+    console.warn("Lezer parsing failed, falling back to simple parsing:", details);
+    return await extractBlocksSimple(content, options);
+  }
+}
+async function extractBlocksSimple(content, options = {}) {
+  const blocks2 = [];
+  const lines = content.split("\n");
+  let currentParagraph = [];
+  let currentPos = 0;
+  const finalizeParagraph = async () => {
+    if (currentParagraph.length > 0) {
+      const raw = currentParagraph.join("\n");
+      const from = currentPos - raw.length;
+      const to = currentPos;
+      let blockType = "paragraph";
+      if (raw.match(/^#{1,6}\s+/)) {
+        blockType = "heading";
+      } else if (raw.match(/^```/)) {
+        blockType = "code";
+      } else if (raw.match(/^>/)) {
+        blockType = "blockquote";
+      } else if (raw.match(/^[-*+]\s+|^\d+\.\s+/)) {
+        blockType = "list";
+      }
+      const block = await createBlock(blockType, raw, from, to, content, options);
+      if (block) {
+        blocks2.push(block);
+      }
+      currentParagraph = [];
+    }
+  };
+  for (const line of lines) {
+    currentPos += line.length + 1;
+    if (line.trim() === "") {
+      await finalizeParagraph();
+    } else {
+      currentParagraph.push(line);
+    }
+  }
+  await finalizeParagraph();
+  return blocks2;
+}
+async function createBlock(type, raw, from, to, fullContent, options = {}) {
+  if (!raw.trim()) return null;
+  const id = (0, import_core.generateBlockId)(`${from}:${type}`, type);
+  const isFinalized = options.forceFinalize ? true : to < fullContent.length - 1;
+  const block = {
+    id,
+    type,
+    isFinalized,
+    payload: {
+      raw,
+      range: { from, to }
+    }
+  };
+  await enrichBlock(block);
+  return block;
+}
+async function enrichBlock(block) {
+  performanceTimer.mark("enrich-block");
+  const metrics = getActiveMetricsCollector();
+  metrics?.countBlockType(block.type);
+  const rawLength = typeof block.payload.raw === "string" ? block.payload.raw.length : 0;
+  metrics?.recordBlockSize(block.type, rawLength);
+  switch (block.type) {
+    case "heading": {
+      const rawHeading = typeof block.payload.raw === "string" ? block.payload.raw : "";
+      const normalizedHeading = (0, import_core.removeHeadingMarkers)(rawHeading);
+      const headingLevel = Math.min(Math.max(rawHeading.match(/^#{1,6}/)?.[0].length ?? 1, 1), 6);
+      const baseSlug = slugifyHeading(normalizedHeading) || "heading";
+      const nextCount = (headingIdCounts.get(baseSlug) ?? 0) + 1;
+      headingIdCounts.set(baseSlug, nextCount);
+      const headingId = nextCount > 1 ? `${baseSlug}-${nextCount}` : baseSlug;
+      block.payload.meta = {
+        ...block.payload.meta ?? {},
+        headingLevel,
+        headingText: normalizedHeading,
+        headingId
+      };
+      if (block.isFinalized) {
+        block.payload.raw = normalizedHeading;
+        block.payload.inline = inlineParser.parse(normalizedHeading);
+        if (shouldTrackInlineStatus() && block.payload.meta) {
+          block.payload.meta.inlineStatus = void 0;
+        }
+      } else {
+        const parsed = parseInlineStreaming(normalizedHeading);
+        block.payload.inline = parsed.inline;
+        if (shouldTrackInlineStatus() && block.payload.meta) {
+          block.payload.meta.inlineStatus = parsed.status;
+        }
+      }
+      break;
+    }
+    case "blockquote": {
+      const normalized = (0, import_core.normalizeBlockquoteText)(block.payload.raw ?? "");
+      block.payload.raw = normalized;
+      const streamingParsed = !block.isFinalized ? parseInlineStreaming(normalized) : null;
+      const inlineParse = block.isFinalized ? (value) => inlineParser.parse(value) : (value) => parseInlineStreaming(value).inline;
+      const mixedOptions = !block.isFinalized && shouldAllowMixedStreaming() ? {
+        html: formatAnticipationConfig.html ? { autoClose: true, maxNewlines: MIXED_CONTENT_AUTOCLOSE_NEWLINES } : void 0,
+        mdx: formatAnticipationConfig.mdx ? { autoClose: true, maxNewlines: MIXED_CONTENT_AUTOCLOSE_NEWLINES, componentAllowlist: mdxComponentAllowlist ?? void 0 } : void 0
+      } : void 0;
+      const segments = (0, import_core.extractMixedContentSegments)(normalized, void 0, inlineParse, mixedOptions);
+      const currentMeta = block.payload.meta ?? {};
+      const nextMeta = {
+        ...currentMeta,
+        normalizedText: normalized
+      };
+      if (segments.length > 0) {
+        nextMeta.mixedSegments = segments;
+      } else {
+        nextMeta.mixedSegments = void 0;
+      }
+      if (shouldTrackInlineStatus()) {
+        nextMeta.inlineStatus = block.isFinalized ? void 0 : streamingParsed?.status;
+      }
+      if (Object.keys(nextMeta).length > 0) {
+        block.payload.meta = nextMeta;
+      } else {
+        block.payload.meta = void 0;
+      }
+      if (block.isFinalized) {
+        block.payload.inline = inlineParser.parse(normalized);
+      } else {
+        block.payload.inline = streamingParsed?.inline ?? [{ kind: "text", text: normalized }];
+      }
+      break;
+    }
+    case "paragraph": {
+      const rawParagraph = typeof block.payload.raw === "string" ? block.payload.raw : "";
+      const streamingParsed = !block.isFinalized ? parseInlineStreaming(rawParagraph) : null;
+      const inlineParse = block.isFinalized ? (value) => inlineParser.parse(value) : (value) => parseInlineStreaming(value).inline;
+      block.payload.inline = block.isFinalized ? inlineParse(rawParagraph) : streamingParsed?.inline ?? [{ kind: "text", text: rawParagraph }];
+      const currentMeta = block.payload.meta ?? {};
+      const nextMeta = { ...currentMeta };
+      let metaChanged = false;
+      const allowMixedStreaming = shouldAllowMixedStreaming();
+      if (shouldTrackInlineStatus()) {
+        const desired = block.isFinalized ? void 0 : streamingParsed?.status;
+        if (desired !== void 0) {
+          if (!Object.prototype.hasOwnProperty.call(nextMeta, "inlineStatus") || nextMeta.inlineStatus !== desired) {
+            nextMeta.inlineStatus = desired;
+            metaChanged = true;
+          }
+        } else if (Object.prototype.hasOwnProperty.call(nextMeta, "inlineStatus")) {
+          nextMeta.inlineStatus = void 0;
+          metaChanged = true;
+        }
+      } else if (Object.prototype.hasOwnProperty.call(nextMeta, "inlineStatus")) {
+        nextMeta.inlineStatus = void 0;
+        metaChanged = true;
+      }
+      const baseOffset = typeof block.payload.range?.from === "number" ? block.payload.range.from : void 0;
+      const protectedRanges = [];
+      if (enableMath) {
+        protectedRanges.push(...collectMathProtectedRanges(rawParagraph));
+      }
+      const autolinkRanges = collectAutolinkProtectedRanges(rawParagraph);
+      if (autolinkRanges.length > 0) {
+        protectedRanges.push(...autolinkRanges);
+      }
+      const shouldExtractSegments = typeof rawParagraph === "string" && (rawParagraph.includes("<") || rawParagraph.includes("{"));
+      if (shouldExtractSegments) {
+        const mixedOptions = !block.isFinalized && shouldAllowMixedStreaming() ? {
+          html: formatAnticipationConfig.html ? { autoClose: true, maxNewlines: MIXED_CONTENT_AUTOCLOSE_NEWLINES } : void 0,
+          mdx: formatAnticipationConfig.mdx ? { autoClose: true, maxNewlines: MIXED_CONTENT_AUTOCLOSE_NEWLINES, componentAllowlist: mdxComponentAllowlist ?? void 0 } : void 0
+        } : void 0;
+        const protectedRangesAbsolute = typeof baseOffset === "number" && protectedRanges.length > 0 ? protectedRanges.map((range) => ({
+          ...range,
+          from: baseOffset + range.from,
+          to: baseOffset + range.to
+        })) : void 0;
+        const mixedSegmentOptions = mixedOptions || protectedRangesAbsolute ? {
+          ...mixedOptions,
+          protectedRanges: protectedRangesAbsolute
+        } : void 0;
+        const segments = (0, import_core.extractMixedContentSegments)(rawParagraph, baseOffset, (value) => inlineParse(value), mixedSegmentOptions);
+        const htmlRanges = collectHtmlProtectedRangesFromSegments(segments, baseOffset);
+        if (htmlRanges.length > 0) {
+          protectedRanges.push(...htmlRanges);
+        }
+        if (segments.length > 0) {
+          nextMeta.mixedSegments = segments;
+          metaChanged = true;
+          if (allowMixedStreaming) {
+            nextMeta.allowMixedStreaming = true;
+            metaChanged = true;
+          } else if (Object.prototype.hasOwnProperty.call(nextMeta, "allowMixedStreaming")) {
+            nextMeta.allowMixedStreaming = void 0;
+            metaChanged = true;
+          }
+        } else if (Object.prototype.hasOwnProperty.call(nextMeta, "mixedSegments")) {
+          nextMeta.mixedSegments = void 0;
+          metaChanged = true;
+          if (Object.prototype.hasOwnProperty.call(nextMeta, "allowMixedStreaming")) {
+            nextMeta.allowMixedStreaming = void 0;
+            metaChanged = true;
+          }
+        }
+      } else if (Object.prototype.hasOwnProperty.call(nextMeta, "mixedSegments")) {
+        nextMeta.mixedSegments = void 0;
+        metaChanged = true;
+        if (Object.prototype.hasOwnProperty.call(nextMeta, "allowMixedStreaming")) {
+          nextMeta.allowMixedStreaming = void 0;
+          metaChanged = true;
+        }
+      }
+      if (protectedRanges.length > 0) {
+        nextMeta.protectedRanges = protectedRanges;
+        metaChanged = true;
+      } else if (Object.prototype.hasOwnProperty.call(nextMeta, "protectedRanges")) {
+        nextMeta.protectedRanges = void 0;
+        metaChanged = true;
+      }
+      if (metaChanged) {
+        if (Object.keys(nextMeta).length > 0) {
+          block.payload.meta = nextMeta;
+        } else {
+          block.payload.meta = void 0;
+        }
+      } else if (!block.payload.meta || Object.keys(block.payload.meta).length === 0) {
+        block.payload.meta = void 0;
+      }
+      break;
+    }
+    case "code":
+      await enrichCodeBlock(block);
+      break;
+    case "html": {
+      const rawHtml = typeof block.payload.raw === "string" ? block.payload.raw : "";
+      const sanitized = (0, import_core2.sanitizeHtmlInWorker)(rawHtml);
+      block.payload.sanitizedHtml = sanitized;
+      const nextMeta = { ...block.payload.meta || {}, sanitized: true };
+      if (rawHtml) {
+        nextMeta.protectedRanges = [{ from: 0, to: rawHtml.length, kind: "html-block" }];
+      }
+      block.payload.meta = nextMeta;
+      break;
+    }
+    case "list":
+      enrichListBlock(block);
+      break;
+  }
+  if (block.type === "paragraph" || block.type === "html") {
+    const maybeMeta = block.payload.meta;
+    const protectedRanges = Array.isArray(maybeMeta?.protectedRanges) ? maybeMeta?.protectedRanges : void 0;
+    const blockRange = block.payload.range;
+    const baseOffset = typeof blockRange?.from === "number" ? blockRange.from : 0;
+    const normalizedRanges = protectedRanges && protectedRanges.length > 0 ? protectedRanges.map((range) => ({
+      ...range,
+      from: baseOffset + range.from,
+      to: baseOffset + range.to
+    })) : void 0;
+    const mdxOptions = normalizedRanges && normalizedRanges.length > 0 ? { protectedRanges: normalizedRanges, baseOffset } : baseOffset ? { baseOffset } : void 0;
+    const mdxDetectStart = now();
+    let shouldConvertToMDX = (0, import_core.detectMDX)(block.payload.raw, mdxOptions);
+    if (!shouldConvertToMDX && block.type === "html") {
+      const fallbackOptions = baseOffset ? { baseOffset } : void 0;
+      shouldConvertToMDX = (0, import_core.detectMDX)(block.payload.raw, fallbackOptions);
+    }
+    metrics?.recordMdxDetect(now() - mdxDetectStart);
+    if (shouldConvertToMDX && protectedRanges && protectedRanges.length > 0 && block.type !== "html") {
+      const exprPattern = /\{[^{}]+\}/g;
+      let match;
+      while (true) {
+        match = exprPattern.exec(block.payload.raw);
+        if (match === null) {
+          break;
+        }
+        const start = match.index;
+        const end = start + match[0].length;
+        const covered = protectedRanges.some((range) => range.from <= start && range.to >= end);
+        if (!covered) {
+          shouldConvertToMDX = true;
+          break;
+        }
+        shouldConvertToMDX = false;
+      }
+    }
+    if (shouldConvertToMDX) {
+      if (DEBUG_MDX) {
+        try {
+          console.debug("[markdown-worker] mdx detected", { blockId: block.id, originalType: block.type });
+        } catch {
+        }
+      }
+      const originalType = block.type;
+      block.payload.meta = { ...block.payload.meta, originalType };
+      block.type = "mdx";
+    } else if (DEBUG_MDX && loggedMdxSkipCount < MAX_MDX_SKIP_LOGS) {
+      if (block.payload.raw && block.payload.raw.includes("<Preview")) {
+        loggedMdxSkipCount += 1;
+        try {
+          console.debug("[markdown-worker] mdx detection skipped", {
+            blockId: block.id,
+            originalType: block.type,
+            len: block.payload.raw.length,
+            protected: Array.isArray(block.payload.meta?.protectedRanges) ? block.payload.meta.protectedRanges.length : 0,
+            sample: block.payload.raw.slice(0, 120)
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  await updateMdxCompilationState(block);
+  const enrichDuration = performanceTimer.measure("enrich-block");
+  metrics?.recordEnrich(enrichDuration);
+  metrics?.recordBlockEnrich(block.type, enrichDuration);
+}
+function collectMathProtectedRanges(content) {
+  if (!content) return [];
+  const ranges = [];
+  const inlineStack = [];
+  const displayStack = [];
+  const length = content.length;
+  let i = 0;
+  while (i < length) {
+    const char = content[i];
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char !== "$") {
+      i++;
+      continue;
+    }
+    const isDouble = i + 1 < length && content[i + 1] === "$";
+    if (isDouble) {
+      if (displayStack.length > 0) {
+        const start = displayStack.pop();
+        ranges.push({ from: start, to: i + 2, kind: "math-display" });
+      } else {
+        displayStack.push(i);
+      }
+      i += 2;
+      continue;
+    }
+    if (inlineStack.length > 0) {
+      const start = inlineStack.pop();
+      ranges.push({ from: start, to: i + 1, kind: "math-inline" });
+    } else {
+      inlineStack.push(i);
+    }
+    i++;
+  }
+  return ranges;
+}
+function collectAutolinkProtectedRanges(content) {
+  if (!content) return [];
+  const ranges = [];
+  const autolinkPattern = /<((?:https?:\/\/|mailto:)[^>\s]+)>/gi;
+  let match = autolinkPattern.exec(content);
+  while (match !== null) {
+    ranges.push({ from: match.index, to: match.index + match[0].length, kind: "autolink" });
+    match = autolinkPattern.exec(content);
+  }
+  return ranges;
+}
+function collectHtmlProtectedRangesFromSegments(segments, baseOffset) {
+  if (!segments || segments.length === 0) return [];
+  if (typeof baseOffset !== "number" || !Number.isFinite(baseOffset)) {
+    return [];
+  }
+  const ranges = [];
+  for (const segment of segments) {
+    if (segment.kind !== "html") continue;
+    const range = segment.range;
+    if (!range) continue;
+    const from = range.from - baseOffset;
+    const to = range.to - baseOffset;
+    if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from) continue;
+    ranges.push({ from, to, kind: "html-inline" });
+  }
+  return ranges;
+}
+function escapeHtmlText(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderShikiToken(token) {
+  const dark = token.variants.dark;
+  const light = token.variants.light;
+  const styles = [];
+  if (dark?.color) {
+    styles.push(`--shiki-dark:${dark.color}`);
+  }
+  if (light?.color) {
+    styles.push(`--shiki-light:${light.color}`);
+  }
+  const fontStyle = light?.fontStyle ?? dark?.fontStyle;
+  if (typeof fontStyle === "number" && fontStyle > 0) {
+    if (fontStyle & FONT_STYLE_ITALIC) {
+      styles.push("font-style: italic");
+    }
+    if (fontStyle & FONT_STYLE_BOLD) {
+      styles.push("font-weight: bold");
+    }
+    const decorations = [];
+    if (fontStyle & FONT_STYLE_UNDERLINE) {
+      decorations.push("underline");
+    }
+    if (fontStyle & FONT_STYLE_STRIKETHROUGH) {
+      decorations.push("line-through");
+    }
+    if (decorations.length > 0) {
+      styles.push(`text-decoration: ${decorations.join(" ")}`);
+    }
+  }
+  const styleAttr = styles.length > 0 ? ` style="${styles.join(";")}"` : "";
+  return `<span${styleAttr}>${escapeHtmlText(token.content)}</span>`;
+}
+function getTokenFontStyle(token) {
+  const dark = token.variants?.dark?.fontStyle ?? 0;
+  const light = token.variants?.light?.fontStyle ?? 0;
+  return (typeof dark === "number" ? dark : 0) | (typeof light === "number" ? light : 0);
+}
+function mergeWhitespaceTokens(tokens) {
+  return tokens.map((line) => {
+    const merged = [];
+    let carryContent = "";
+    let carryOffset = 0;
+    let carryVariants = null;
+    line.forEach((token, idx) => {
+      const fontStyle = getTokenFontStyle(token);
+      const couldMerge = (fontStyle & FONT_STYLE_UNDERLINE) === 0;
+      if (couldMerge && /^\s+$/.test(token.content) && line[idx + 1]) {
+        if (!carryContent) {
+          carryOffset = token.offset ?? 0;
+          carryVariants = token.variants;
+        }
+        carryContent += token.content;
+        return;
+      }
+      if (carryContent) {
+        if (couldMerge) {
+          merged.push({ ...token, offset: carryOffset, content: carryContent + token.content });
+        } else {
+          merged.push({ content: carryContent, offset: carryOffset, variants: carryVariants ?? token.variants });
+          merged.push(token);
+        }
+        carryContent = "";
+        carryOffset = 0;
+        carryVariants = null;
+        return;
+      }
+      merged.push(token);
+    });
+    return merged;
+  });
+}
+function renderShikiLines(tokens) {
+  const merged = mergeWhitespaceTokens(tokens);
+  return merged.map((lineTokens) => lineTokens.map(renderShikiToken).join(""));
+}
+function detectDiffLanguage(lang, meta) {
+  const normalized = (lang || "").trim().toLowerCase();
+  if (!normalized) {
+    return { isDiff: false, diffLang: "diff", baseLang: null };
+  }
+  let baseLang = null;
+  if (normalized === "diff" || normalized === "udiff" || normalized === "diff-unified") {
+    baseLang = null;
+  } else if (normalized.startsWith("diff-")) {
+    baseLang = normalized.slice("diff-".length) || null;
+  } else if (normalized.endsWith("-diff")) {
+    baseLang = normalized.slice(0, Math.max(0, normalized.length - "-diff".length)) || null;
+  } else {
+    return { isDiff: false, diffLang: "diff", baseLang: null };
+  }
+  if (!baseLang) {
+    const metaLang = typeof meta.lang === "string" ? meta.lang : typeof meta.language === "string" ? meta.language : typeof meta.base === "string" ? meta.base : null;
+    if (metaLang) {
+      baseLang = metaLang;
+    } else {
+      const metaKeys = Object.keys(meta);
+      if (metaKeys.length > 0) {
+        baseLang = metaKeys[0] ?? null;
+      }
+    }
+  }
+  return {
+    isDiff: true,
+    diffLang: "diff",
+    baseLang: baseLang ? (0, import_core.normalizeLang)(String(baseLang)) : null
+  };
+}
+function parseDiffHunkHeader(line) {
+  const match = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
+  if (!match) return null;
+  return {
+    oldStart: Number.parseInt(match[1] ?? "0", 10),
+    newStart: Number.parseInt(match[3] ?? "0", 10)
+  };
+}
+function isDiffMetaLine(line) {
+  if (!line) return false;
+  return line.startsWith("diff ") || line.startsWith("index ") || line.startsWith("new file") || line.startsWith("deleted file") || line.startsWith("similarity index") || line.startsWith("rename from") || line.startsWith("rename to") || line.startsWith("mode ") || line.startsWith("\\\\ No newline");
+}
+function parseUnifiedDiffLine(line, cursor) {
+  if (line.startsWith("@@")) {
+    const header = parseDiffHunkHeader(line);
+    if (header) {
+      cursor.oldLine = header.oldStart;
+      cursor.newLine = header.newStart;
+    }
+    return { text: line, kind: "hunk", prefix: "", content: line, oldNo: null, newNo: null };
+  }
+  if (line.startsWith("--- ") || line.startsWith("+++ ") || isDiffMetaLine(line)) {
+    return { text: line, kind: "meta", prefix: "", content: line, oldNo: null, newNo: null };
+  }
+  if (line.startsWith("+")) {
+    if (line.startsWith("+++")) {
+      return { text: line, kind: "meta", prefix: "", content: line, oldNo: null, newNo: null };
+    }
+    const newNo = cursor.newLine;
+    if (cursor.newLine !== null) cursor.newLine += 1;
+    return { text: line, kind: "add", prefix: "+", content: line.slice(1), oldNo: null, newNo };
+  }
+  if (line.startsWith("-")) {
+    if (line.startsWith("---")) {
+      return { text: line, kind: "meta", prefix: "", content: line, oldNo: null, newNo: null };
+    }
+    const oldNo = cursor.oldLine;
+    if (cursor.oldLine !== null) cursor.oldLine += 1;
+    return { text: line, kind: "remove", prefix: "-", content: line.slice(1), oldNo, newNo: null };
+  }
+  if (line.startsWith(" ")) {
+    const oldNo = cursor.oldLine;
+    const newNo = cursor.newLine;
+    if (cursor.oldLine !== null) cursor.oldLine += 1;
+    if (cursor.newLine !== null) cursor.newLine += 1;
+    return { text: line, kind: "context", prefix: " ", content: line.slice(1), oldNo, newNo };
+  }
+  return { text: line, kind: "meta", prefix: "", content: line, oldNo: null, newNo: null };
+}
+function normalizeDiffPath(value) {
+  if (!value) return null;
+  let path = value.trim();
+  if (!path || path === "/dev/null") return null;
+  if (path.startsWith('"') && path.endsWith('"') || path.startsWith("'") && path.endsWith("'")) {
+    path = path.slice(1, -1);
+  }
+  if (path.startsWith("a/") || path.startsWith("b/")) {
+    path = path.slice(2);
+  }
+  return path || null;
+}
+function extractDiffFilePath(line) {
+  if (line.startsWith("diff --git")) {
+    const match = line.match(/^diff --git\\s+(\\S+)\\s+(\\S+)/);
+    if (match) {
+      return normalizeDiffPath(match[2] ?? match[1] ?? null);
+    }
+  }
+  if (line.startsWith("+++ ") || line.startsWith("--- ")) {
+    const path = normalizeDiffPath(line.slice(4));
+    return path;
+  }
+  if (line.startsWith("rename to ")) {
+    return normalizeDiffPath(line.slice("rename to ".length));
+  }
+  return null;
+}
+function looksLikeUnifiedDiff(lines) {
+  if (lines.length === 0) return false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git") || line.startsWith("@@") || line.startsWith("+++ ") || line.startsWith("--- ")) {
+      return true;
+    }
+  }
+  return false;
+}
+function guessLanguageFromPath(filePath) {
+  if (!filePath) return null;
+  const parts = filePath.split(/[\\\\/]/);
+  const file = parts[parts.length - 1] ?? "";
+  const idx = file.lastIndexOf(".");
+  if (idx <= 0 || idx >= file.length - 1) return null;
+  const ext = file.slice(idx + 1);
+  return (0, import_core.normalizeLang)(ext);
+}
+function guessLanguageFromDiffLines(lines) {
+  for (const line of lines) {
+    const filePath = extractDiffFilePath(line);
+    if (filePath) {
+      const guessed = guessLanguageFromPath(filePath);
+      if (guessed) return guessed;
+    }
+  }
+  return null;
+}
+function toDiffLineKind(kind) {
+  if (kind === "remove") return "del";
+  return kind;
+}
+function toThemedLine(tokenLine, theme) {
+  if (!tokenLine) return null;
+  return tokenLine.spans.map((span) => {
+    const style = span.s ?? span.v?.[theme];
+    const color = typeof style?.fg === "string" ? style.fg : null;
+    const fontStyle = typeof style?.fs === "number" ? style.fs : null;
+    return {
+      content: span.t,
+      color,
+      fontStyle
+    };
+  });
+}
+function stripPrefixFromThemedLine(tokens, prefix) {
+  if (!tokens || !prefix) return tokens;
+  if (tokens.length === 0) return tokens;
+  const first = tokens[0];
+  if (first.content === prefix) {
+    return tokens.slice(1);
+  }
+  if (first.content.startsWith(prefix)) {
+    const trimmed = first.content.slice(prefix.length);
+    const next = trimmed ? [{ ...first, content: trimmed }, ...tokens.slice(1)] : tokens.slice(1);
+    return next;
+  }
+  return tokens;
+}
+function buildDiffBlocksFromLines(lines, rawLines, tokenLines, defaultLanguage) {
+  const blocks2 = [];
+  let current = null;
+  let currentRaw = [];
+  let additions = 0;
+  let deletions = 0;
+  const finalize = () => {
+    if (!current) return;
+    current.additions = additions;
+    current.deletions = deletions;
+    if (currentRaw.length > 0) {
+      current.unified = currentRaw.join("\n");
+    }
+    blocks2.push(current);
+    current = null;
+    currentRaw = [];
+    additions = 0;
+    deletions = 0;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const raw = rawLines[i] ?? line.text;
+    const filePath = extractDiffFilePath(raw);
+    if (raw.startsWith("diff --git")) {
+      finalize();
+    }
+    if (!current) {
+      current = {
+        kind: "diff",
+        filePath: filePath ?? null,
+        language: filePath ? guessLanguageFromPath(filePath) ?? defaultLanguage : defaultLanguage,
+        lines: [],
+        additions: null,
+        deletions: null,
+        unified: null
+      };
+    } else if (filePath && !current.filePath) {
+      current.filePath = filePath;
+      if (!current.language) {
+        current.language = guessLanguageFromPath(filePath) ?? defaultLanguage;
+      }
+    }
+    if (line.kind === "add") additions += 1;
+    if (line.kind === "remove") deletions += 1;
+    let themed = tokenLines ? toThemedLine(tokenLines[i] ?? null, "dark") : null;
+    if (line.kind === "add" || line.kind === "remove" || line.kind === "context") {
+      themed = stripPrefixFromThemedLine(themed, line.prefix);
+    }
+    const entry = {
+      kind: toDiffLineKind(line.kind),
+      oldNo: line.oldNo ?? null,
+      newNo: line.newNo ?? null,
+      raw,
+      tokens: themed ?? null
+    };
+    current.lines.push(entry);
+    currentRaw.push(raw);
+  }
+  finalize();
+  return blocks2;
+}
+function tokenizeDiffRun(lines, language, grammarState) {
+  if (!highlighter) {
+    return { tokens: [], nextGrammarState: grammarState };
+  }
+  const content = lines.map((line) => line.content).join("\\n");
+  if (!content && lines.length > 0) {
+    return { tokens: lines.map(() => []), nextGrammarState: grammarState };
+  }
+  const tokens = highlighter.codeToTokensWithThemes(content, {
+    lang: language,
+    themes: CODE_HIGHLIGHT_THEMES,
+    grammarState
+  });
+  const nextGrammarState = highlighter.getLastGrammarState(tokens);
+  return { tokens, nextGrammarState };
+}
+function buildDiffTokenLines(lines, language, grammarState) {
+  const output = [];
+  let idx = 0;
+  let nextOldState = grammarState.old;
+  let nextNewState = grammarState.new;
+  while (idx < lines.length) {
+    const line = lines[idx];
+    if (line.kind === "meta" || line.kind === "hunk") {
+      output.push({ spans: [{ t: line.text }] });
+      idx += 1;
+      continue;
+    }
+    const runKind = line.kind;
+    const run = [];
+    while (idx < lines.length && lines[idx].kind === runKind) {
+      run.push(lines[idx]);
+      idx += 1;
+    }
+    try {
+      if (runKind === "add") {
+        const { tokens, nextGrammarState } = tokenizeDiffRun(run, language, nextNewState);
+        nextNewState = nextGrammarState;
+        const tokenLines = renderTokenLines(tokens);
+        for (let i = 0; i < run.length; i++) {
+          const prefixSpan = { t: run[i].prefix };
+          const lineTokens = tokenLines[i] ?? null;
+          if (!lineTokens || lineTokens.spans.length === 0) {
+            const fullText = `${run[i].prefix}${run[i].content}`;
+            output.push(fullText.length > 0 ? { spans: [{ t: fullText }] } : { spans: [] });
+          } else {
+            output.push({ spans: [prefixSpan, ...lineTokens.spans] });
+          }
+        }
+        continue;
+      }
+      if (runKind === "remove") {
+        const { tokens, nextGrammarState } = tokenizeDiffRun(run, language, nextOldState);
+        nextOldState = nextGrammarState;
+        const tokenLines = renderTokenLines(tokens);
+        for (let i = 0; i < run.length; i++) {
+          const prefixSpan = { t: run[i].prefix };
+          const lineTokens = tokenLines[i] ?? null;
+          if (!lineTokens || lineTokens.spans.length === 0) {
+            const fullText = `${run[i].prefix}${run[i].content}`;
+            output.push(fullText.length > 0 ? { spans: [{ t: fullText }] } : { spans: [] });
+          } else {
+            output.push({ spans: [prefixSpan, ...lineTokens.spans] });
+          }
+        }
+        continue;
+      }
+      if (runKind === "context") {
+        const { tokens, nextGrammarState } = tokenizeDiffRun(run, language, nextNewState);
+        nextNewState = nextGrammarState;
+        if (run.length > 0) {
+          const oldResult = tokenizeDiffRun(run, language, nextOldState);
+          nextOldState = oldResult.nextGrammarState;
+        }
+        const tokenLines = renderTokenLines(tokens);
+        for (let i = 0; i < run.length; i++) {
+          const prefixSpan = { t: run[i].prefix };
+          const lineTokens = tokenLines[i] ?? null;
+          if (!lineTokens || lineTokens.spans.length === 0) {
+            const fullText = `${run[i].prefix}${run[i].content}`;
+            output.push(fullText.length > 0 ? { spans: [{ t: fullText }] } : { spans: [] });
+          } else {
+            output.push({ spans: [prefixSpan, ...lineTokens.spans] });
+          }
+        }
+        continue;
+      }
+    } catch (error) {
+      console.warn("Diff tokenization failed for", language, error);
+    }
+    for (let i = 0; i < run.length; i++) {
+      const fullText = run[i].text;
+      output.push(fullText.length > 0 ? { spans: [{ t: fullText }] } : { spans: [] });
+    }
+  }
+  return { tokenLines: output, grammarState: { old: nextOldState, new: nextNewState } };
+}
+function toTokenStyle(style) {
+  if (!style) return void 0;
+  const fg = typeof style.color === "string" ? style.color : void 0;
+  const fs = typeof style.fontStyle === "number" && style.fontStyle > 0 ? style.fontStyle : void 0;
+  if (!fg && fs === void 0) return void 0;
+  return { fg, fs };
+}
+function toTokenSpan(token) {
+  const dark = toTokenStyle(token.variants.dark);
+  const light = toTokenStyle(token.variants.light);
+  const span = { t: token.content };
+  if (dark || light) {
+    span.v = {};
+    if (dark) span.v.dark = dark;
+    if (light) span.v.light = light;
+  }
+  return span;
+}
+function renderTokenLines(tokens) {
+  return tokens.map((lineTokens) => ({
+    spans: lineTokens.map((token) => toTokenSpan(token))
+  }));
+}
+function resetIncrementalHighlightState(blockId) {
+  if (blockId) {
+    incrementalHighlightStates.delete(blockId);
+    return;
+  }
+  incrementalHighlightStates.clear();
+}
+function getIncrementalHighlightState(blockId, lang) {
+  const existing = incrementalHighlightStates.get(blockId);
+  if (!existing || existing.lang !== lang) {
+    const fresh = {
+      lang,
+      tokenLang: void 0,
+      processedLength: 0,
+      pendingLine: "",
+      highlightedLines: [],
+      tokenLines: [],
+      diffKind: [],
+      oldNo: [],
+      newNo: [],
+      diffCursor: void 0,
+      diffGrammar: void 0,
+      grammarState: void 0
+    };
+    incrementalHighlightStates.set(blockId, fresh);
+    return fresh;
+  }
+  return existing;
+}
+async function resolveHighlightLanguage(requestedLanguage) {
+  if (!highlighter) return "text";
+  const loadedLangs = highlighter.getLoadedLanguages();
+  if (!loadedLangs.includes(requestedLanguage)) {
+    try {
+      await highlighter.loadLanguage(requestedLanguage);
+    } catch (loadError) {
+      console.warn(`Failed to load language ${requestedLanguage}, falling back to text:`, loadError);
+    }
+  }
+  const nextLangs = highlighter.getLoadedLanguages();
+  return nextLangs.includes(requestedLanguage) ? requestedLanguage : "text";
+}
+function makeLazySignature(codeBody, lang, tokenLang, diffEnabled) {
+  const head = codeBody.slice(0, 32);
+  const tail = codeBody.slice(Math.max(0, codeBody.length - 32));
+  return `${lang}|${tokenLang}|${diffEnabled ? "diff" : "plain"}|${codeBody.length}|${head}|${tail}`;
+}
+function getOrInitLazyState(blockId, signature, lineCount, lang, tokenLang, diffEnabled) {
+  const existing = lazyTokenizationStates.get(blockId);
+  if (existing && existing.signature === signature && existing.highlightedLines.length === lineCount) {
+    return existing;
+  }
+  const fresh = {
+    signature,
+    lang,
+    tokenLang,
+    processedLines: 0,
+    highlightedLines: new Array(lineCount).fill(null),
+    tokenLines: new Array(lineCount).fill(null),
+    diffKind: new Array(lineCount).fill(null),
+    oldNo: new Array(lineCount).fill(null),
+    newNo: new Array(lineCount).fill(null),
+    diffCursor: diffEnabled ? { oldLine: null, newLine: null } : void 0,
+    diffGrammar: diffEnabled ? {} : void 0,
+    grammarState: void 0
+  };
+  lazyTokenizationStates.set(blockId, fresh);
+  return fresh;
+}
+function shouldLazyTokenizeBlock(lineCount, hasHighlighter, hasHighlightableContent) {
+  if (!lazyTokenizationEnabled) return false;
+  if (!hasHighlighter || !hasHighlightableContent) return false;
+  return lineCount >= lazyTokenizationThresholdLines;
+}
+function pruneLazyTokenizationStates(nextBlocks) {
+  if (lazyTokenizationStates.size === 0) return;
+  const ids = new Set(nextBlocks.map((block) => block.id));
+  for (const key of lazyTokenizationStates.keys()) {
+    if (!ids.has(key)) {
+      lazyTokenizationStates.delete(key);
+    }
+  }
+}
+function enqueueLazyTokenization(request) {
+  if (!lazyTokenizationEnabled) return;
+  const existing = lazyTokenizationQueue.get(request.blockId);
+  const next = existing ? mergeLazyRequests(existing, request) : request;
+  lazyTokenizationQueue.set(request.blockId, next);
+  if (!lazyTokenizationScheduled) {
+    lazyTokenizationScheduled = true;
+    setTimeout(() => {
+      lazyTokenizationScheduled = false;
+      void processLazyTokenizationQueue();
+    }, 0);
+  }
+}
+function selectNextLazyRequest() {
+  let selected = null;
+  for (const request of lazyTokenizationQueue.values()) {
+    if (!selected) {
+      selected = request;
+      continue;
+    }
+    const priorityDiff = compareLazyPriority(request.priority, selected.priority);
+    if (priorityDiff > 0) {
+      selected = request;
+      continue;
+    }
+    if (priorityDiff === 0 && request.requestedAt < selected.requestedAt) {
+      selected = request;
+    }
+  }
+  return selected;
+}
+async function processLazyTokenizationQueue() {
+  if (lazyTokenizationProcessing) return;
+  lazyTokenizationProcessing = true;
+  try {
+    while (lazyTokenizationQueue.size > 0) {
+      const next = selectNextLazyRequest();
+      if (!next) break;
+      lazyTokenizationQueue.delete(next.blockId);
+      await handleLazyTokenizationRequest(next);
+    }
+  } finally {
+    lazyTokenizationProcessing = false;
+  }
+}
+async function handleLazyTokenizationRequest(request) {
+  if (!lazyTokenizationEnabled || !highlighter) return;
+  const index = blocks.findIndex((block2) => block2.id === request.blockId);
+  if (index === -1) return;
+  const block = blocks[index];
+  if (block.type !== "code" || !block.isFinalized) return;
+  const raw = block.payload.raw ?? "";
+  const { code, info, hadFence } = (0, import_core2.stripCodeFence)(raw);
+  const { lang, meta } = (0, import_core.parseCodeFenceInfo)(info);
+  const codeBody = hadFence ? code : (0, import_core2.dedentIndentedCode)(raw);
+  const codeLines = (0, import_core.extractCodeLines)(raw);
+  let diffInfo = detectDiffLanguage(lang, meta);
+  if (!diffInfo.isDiff && emitDiffBlocks && looksLikeUnifiedDiff(codeLines)) {
+    diffInfo = {
+      isDiff: true,
+      diffLang: "diff",
+      baseLang: guessLanguageFromDiffLines(codeLines)
+    };
+  }
+  const requestedLanguage = diffInfo.isDiff ? diffInfo.diffLang : lang || "text";
+  const tokenLanguage = diffInfo.isDiff ? diffInfo.baseLang ?? "text" : requestedLanguage;
+  const hasHighlightableContent = codeBody.trim().length > 0;
+  if (!shouldLazyTokenizeBlock(codeLines.length, Boolean(highlighter), hasHighlightableContent)) {
+    return;
+  }
+  const wantsHtml = highlightOutputMode === "html" || highlightOutputMode === "both";
+  const wantsTokens = (highlightOutputMode === "tokens" || highlightOutputMode === "both") && emitHighlightTokens;
+  const diffEnabled = diffInfo.isDiff && wantsTokens;
+  if (!wantsHtml && !wantsTokens) return;
+  const { startLine, endLine } = clampLazyRange(request.startLine, request.endLine, codeLines.length);
+  if (endLine <= startLine) return;
+  let resolvedLanguage = requestedLanguage;
+  let resolvedTokenLanguage = tokenLanguage;
+  if (wantsHtml) {
+    resolvedLanguage = await resolveHighlightLanguage(requestedLanguage);
+  }
+  if (wantsTokens) {
+    resolvedTokenLanguage = await resolveHighlightLanguage(tokenLanguage);
+  }
+  const signature = makeLazySignature(codeBody, resolvedLanguage, resolvedTokenLanguage, diffEnabled);
+  const state = getOrInitLazyState(block.id, signature, codeLines.length, resolvedLanguage, resolvedTokenLanguage, diffEnabled);
+  if (state.processedLines < 0 || state.processedLines > codeLines.length) {
+    state.processedLines = 0;
+  }
+  const targetEnd = Math.min(endLine, codeLines.length);
+  if (targetEnd <= state.processedLines) {
+    return;
+  }
+  const metricsCollector = new WorkerMetricsCollector(workerGrammarEngine);
+  setActiveMetricsCollector(metricsCollector);
+  metricsCollector.setBlocksProduced(blocks.length);
+  const prevSnapshot = await blockToNodeSnapshot(block);
+  const tokenizationStart = now();
+  const segmentLines = codeLines.slice(state.processedLines, targetEnd);
+  if (segmentLines.length > 0) {
+    if (wantsHtml || wantsTokens && !diffEnabled) {
+      try {
+        const sharedLanguage = wantsHtml ? resolvedLanguage : resolvedTokenLanguage;
+        const tokens = highlighter.codeToTokensWithThemes(segmentLines.join("\n"), {
+          lang: sharedLanguage,
+          themes: CODE_HIGHLIGHT_THEMES,
+          grammarState: state.grammarState
+        });
+        if (wantsHtml) {
+          const htmlLines = renderShikiLines(tokens);
+          for (let i = 0; i < htmlLines.length; i += 1) {
+            state.highlightedLines[state.processedLines + i] = htmlLines[i] ?? null;
+          }
+        }
+        if (wantsTokens && !diffEnabled) {
+          const tokenLines = renderTokenLines(tokens);
+          for (let i = 0; i < tokenLines.length; i += 1) {
+            state.tokenLines[state.processedLines + i] = tokenLines[i] ?? null;
+          }
+        }
+        state.grammarState = highlighter.getLastGrammarState(tokens);
+      } catch (error) {
+        console.warn("Lazy tokenization failed for", requestedLanguage, error);
+        if (wantsHtml) {
+          for (let i = 0; i < segmentLines.length; i += 1) {
+            state.highlightedLines[state.processedLines + i] = null;
+          }
+        }
+        if (wantsTokens && !diffEnabled) {
+          for (let i = 0; i < segmentLines.length; i += 1) {
+            state.tokenLines[state.processedLines + i] = null;
+          }
+        }
+      }
+    }
+    if (wantsTokens && diffEnabled) {
+      const cursor = state.diffCursor ?? { oldLine: null, newLine: null };
+      const diffLines = segmentLines.map((line) => parseUnifiedDiffLine(line, cursor));
+      for (let i = 0; i < diffLines.length; i += 1) {
+        const line = diffLines[i];
+        const idx = state.processedLines + i;
+        state.diffKind[idx] = line.kind;
+        state.oldNo[idx] = line.oldNo ?? null;
+        state.newNo[idx] = line.newNo ?? null;
+      }
+      try {
+        const { tokenLines, grammarState } = buildDiffTokenLines(diffLines, resolvedTokenLanguage, state.diffGrammar ?? {});
+        for (let i = 0; i < tokenLines.length; i += 1) {
+          state.tokenLines[state.processedLines + i] = tokenLines[i] ?? null;
+        }
+        state.diffGrammar = grammarState;
+      } catch (error) {
+        console.warn("Lazy diff tokenization failed for", tokenLanguage, error);
+        for (let i = 0; i < diffLines.length; i += 1) {
+          const idx = state.processedLines + i;
+          const line = diffLines[i];
+          state.tokenLines[idx] = line.text.length > 0 ? { spans: [{ t: line.text }] } : { spans: [] };
+        }
+      }
+      state.diffCursor = cursor;
+    }
+  }
+  state.processedLines = targetEnd;
+  const tokenizationDuration = now() - tokenizationStart;
+  metricsCollector.recordShiki(tokenizationDuration);
+  metricsCollector.recordHighlightForLanguage(resolvedLanguage, tokenizationDuration);
+  metricsCollector.recordLazyTokenization(
+    lazyRequestRangeSize({ ...request, startLine, endLine }),
+    now() - request.requestedAt,
+    lazyTokenizationQueue.size
+  );
+  const updated = (0, import_core.cloneBlock)(block);
+  updated.payload.highlightedHtml = void 0;
+  const effectiveLang = wantsHtml ? resolvedLanguage : resolvedTokenLanguage;
+  const nextMeta = { ...updated.payload.meta ?? {}, ...meta, lang: effectiveLang };
+  nextMeta.lazyTokenization = true;
+  nextMeta.lazyTokenizedUntil = state.processedLines;
+  if (wantsHtml) {
+    nextMeta.highlightedLines = state.highlightedLines;
+  } else if ("highlightedLines" in nextMeta) {
+    delete nextMeta.highlightedLines;
+  }
+  if (wantsTokens) {
+    nextMeta.tokenLines = state.tokenLines;
+    if (diffEnabled) {
+      nextMeta.diffKind = state.diffKind;
+      nextMeta.oldNo = state.oldNo;
+      nextMeta.newNo = state.newNo;
+    } else {
+      if ("diffKind" in nextMeta) delete nextMeta.diffKind;
+      if ("oldNo" in nextMeta) delete nextMeta.oldNo;
+      if ("newNo" in nextMeta) delete nextMeta.newNo;
+    }
+  } else if ("tokenLines" in nextMeta) {
+    delete nextMeta.tokenLines;
+    if ("diffKind" in nextMeta) delete nextMeta.diffKind;
+    if ("oldNo" in nextMeta) delete nextMeta.oldNo;
+    if ("newNo" in nextMeta) delete nextMeta.newNo;
+  }
+  if (emitDiffBlocks && diffInfo.isDiff) {
+    const cursor = { oldLine: null, newLine: null };
+    const diffLines = codeLines.map((line) => parseUnifiedDiffLine(line, cursor));
+    nextMeta.diffBlocks = buildDiffBlocksFromLines(diffLines, codeLines, wantsTokens ? state.tokenLines : null, diffInfo.baseLang ?? null);
+  } else if ("diffBlocks" in nextMeta) {
+    delete nextMeta.diffBlocks;
+  }
+  updated.payload.meta = nextMeta;
+  blocks[index] = updated;
+  const nextSnapshot = await blockToNodeSnapshot(updated);
+  const patches = [];
+  diffNodeSnapshot(updated.id, prevSnapshot, nextSnapshot, patches, metricsCollector);
+  if (patches.length > 0) {
+    dispatchPatchBatch(patches, metricsCollector);
+  } else {
+    emitMetricsSample(metricsCollector);
+    if (getActiveMetricsCollector() === metricsCollector) {
+      setActiveMetricsCollector(null);
+    }
+  }
+}
+async function enrichCodeBlock(block) {
+  performanceTimer.mark("highlight-code");
+  const metrics = getActiveMetricsCollector();
+  const raw = block.payload.raw ?? "";
+  const { code, info, hadFence } = (0, import_core2.stripCodeFence)(raw);
+  const { lang, meta } = (0, import_core.parseCodeFenceInfo)(info);
+  let diffInfo = detectDiffLanguage(lang, meta);
+  const codeBody = hadFence ? code : (0, import_core2.dedentIndentedCode)(raw);
+  const codeLines = (0, import_core.extractCodeLines)(raw);
+  if (!diffInfo.isDiff && emitDiffBlocks && looksLikeUnifiedDiff(codeLines)) {
+    diffInfo = {
+      isDiff: true,
+      diffLang: "diff",
+      baseLang: guessLanguageFromDiffLines(codeLines)
+    };
+  }
+  const requestedLanguage = diffInfo.isDiff ? diffInfo.diffLang : lang || "text";
+  const tokenLanguage = diffInfo.isDiff ? diffInfo.baseLang ?? "text" : requestedLanguage;
+  const baseMeta = block.payload.meta ?? {};
+  let resolvedLanguage = requestedLanguage;
+  let resolvedTokenLanguage = tokenLanguage;
+  const hasHighlighter = Boolean(highlighter);
+  const hasHighlightableContent = codeBody.trim().length > 0;
+  const wantsHtml = highlightOutputMode === "html" || highlightOutputMode === "both";
+  const wantsTokens = (highlightOutputMode === "tokens" || highlightOutputMode === "both") && emitHighlightTokens;
+  const wantsTokensNow = wantsTokens && (block.isFinalized || liveTokenizationEnabled);
+  if (!block.isFinalized) {
+    if (codeHighlightingMode === "final" || !hasHighlighter || !hasHighlightableContent) {
+      resetIncrementalHighlightState(block.id);
+      block.payload.highlightedHtml = void 0;
+      const nextMeta2 = { ...baseMeta, ...meta, lang: resolvedLanguage };
+      nextMeta2.code = codeBody;
+      if ("highlightedLines" in nextMeta2) {
+        delete nextMeta2.highlightedLines;
+      }
+      if ("tokenLines" in nextMeta2) {
+        delete nextMeta2.tokenLines;
+      }
+      if ("diffKind" in nextMeta2) {
+        delete nextMeta2.diffKind;
+      }
+      if ("oldNo" in nextMeta2) {
+        delete nextMeta2.oldNo;
+      }
+      if ("newNo" in nextMeta2) {
+        delete nextMeta2.newNo;
+      }
+      if ("diffBlocks" in nextMeta2) {
+        delete nextMeta2.diffBlocks;
+      }
+      block.payload.meta = nextMeta2;
+      return;
+    }
+    if (codeHighlightingMode === "incremental") {
+      if (hasHighlighter) {
+        if (wantsHtml) {
+          resolvedLanguage = await resolveHighlightLanguage(requestedLanguage);
+        }
+        if (wantsTokens) {
+          resolvedTokenLanguage = await resolveHighlightLanguage(tokenLanguage);
+        }
+      }
+      let state = getIncrementalHighlightState(block.id, resolvedLanguage);
+      if (wantsTokens && state.tokenLang && state.tokenLang !== resolvedTokenLanguage) {
+        resetIncrementalHighlightState(block.id);
+        state = getIncrementalHighlightState(block.id, resolvedLanguage);
+      }
+      if (codeBody.length < state.processedLength) {
+        resetIncrementalHighlightState(block.id);
+        state = getIncrementalHighlightState(block.id, resolvedLanguage);
+      }
+      state.tokenLang = wantsTokens ? resolvedTokenLanguage : void 0;
+      const appended = codeBody.slice(state.processedLength);
+      const combined = state.pendingLine + appended;
+      const diffEnabled = diffInfo.isDiff && wantsTokensNow;
+      if (combined.length > 0) {
+        const parts = combined.split("\n");
+        const completeLines = parts.slice(0, -1);
+        const tail = parts.length > 0 ? parts[parts.length - 1] ?? "" : "";
+        if (completeLines.length > 0) {
+          if (wantsHtml || wantsTokensNow && !diffEnabled) {
+            try {
+              const sharedLanguage = wantsHtml ? resolvedLanguage : resolvedTokenLanguage;
+              const tokens = highlighter?.codeToTokensWithThemes(completeLines.join("\n"), {
+                lang: sharedLanguage,
+                themes: CODE_HIGHLIGHT_THEMES,
+                grammarState: state.grammarState
+              });
+              if (wantsHtml) {
+                const htmlLines = renderShikiLines(tokens);
+                state.highlightedLines.push(...htmlLines);
+              }
+              if (wantsTokensNow && !diffEnabled) {
+                const tokenLines2 = renderTokenLines(tokens);
+                state.tokenLines.push(...tokenLines2);
+              }
+              state.grammarState = highlighter?.getLastGrammarState(tokens);
+            } catch (error) {
+              console.warn("Incremental highlighting failed for", requestedLanguage, error);
+              if (wantsHtml) {
+                state.highlightedLines.push(...completeLines.map(() => null));
+              }
+              if (wantsTokensNow && !diffEnabled) {
+                state.tokenLines.push(...completeLines.map(() => null));
+              }
+            }
+          }
+          if (wantsTokensNow && diffEnabled) {
+            const cursor = state.diffCursor ?? { oldLine: null, newLine: null };
+            const diffLines = completeLines.map((line) => parseUnifiedDiffLine(line, cursor));
+            state.diffCursor = cursor;
+            state.diffKind.push(...diffLines.map((line) => line.kind));
+            state.oldNo.push(...diffLines.map((line) => line.oldNo ?? null));
+            state.newNo.push(...diffLines.map((line) => line.newNo ?? null));
+            try {
+              const { tokenLines: tokenLines2, grammarState } = buildDiffTokenLines(diffLines, resolvedTokenLanguage, state.diffGrammar ?? {});
+              state.tokenLines.push(...tokenLines2);
+              state.diffGrammar = grammarState;
+            } catch (error) {
+              console.warn("Incremental diff tokenization failed for", tokenLanguage, error);
+              state.tokenLines.push(
+                ...diffLines.map((line) => line.text.length > 0 ? { spans: [{ t: line.text }] } : { spans: [] })
+              );
+            }
+          }
+        }
+        state.pendingLine = tail ?? "";
+      }
+      state.processedLength = codeBody.length;
+      state.lang = resolvedLanguage;
+      block.payload.highlightedHtml = void 0;
+      const effectiveLang2 = wantsHtml ? resolvedLanguage : resolvedTokenLanguage;
+      const nextMeta2 = { ...baseMeta, ...meta, lang: effectiveLang2 };
+      nextMeta2.code = codeBody;
+      if (wantsHtml) {
+        nextMeta2.highlightedLines = state.highlightedLines;
+      } else if ("highlightedLines" in nextMeta2) {
+        delete nextMeta2.highlightedLines;
+      }
+      if (wantsTokensNow) {
+        nextMeta2.tokenLines = state.tokenLines;
+        if (diffEnabled) {
+          nextMeta2.diffKind = state.diffKind;
+          nextMeta2.oldNo = state.oldNo;
+          nextMeta2.newNo = state.newNo;
+        } else {
+          if ("diffKind" in nextMeta2) delete nextMeta2.diffKind;
+          if ("oldNo" in nextMeta2) delete nextMeta2.oldNo;
+          if ("newNo" in nextMeta2) delete nextMeta2.newNo;
+        }
+      } else if ("tokenLines" in nextMeta2) {
+        delete nextMeta2.tokenLines;
+        if ("diffKind" in nextMeta2) delete nextMeta2.diffKind;
+        if ("oldNo" in nextMeta2) delete nextMeta2.oldNo;
+        if ("newNo" in nextMeta2) delete nextMeta2.newNo;
+      }
+      if (emitDiffBlocks && diffInfo.isDiff && liveTokenizationEnabled) {
+        const cursor = { oldLine: null, newLine: null };
+        const diffLines = codeLines.map((line) => parseUnifiedDiffLine(line, cursor));
+        nextMeta2.diffBlocks = buildDiffBlocksFromLines(diffLines, codeLines, wantsTokensNow ? state.tokenLines : null, diffInfo.baseLang ?? null);
+      } else if ("diffBlocks" in nextMeta2) {
+        delete nextMeta2.diffBlocks;
+      }
+      block.payload.meta = nextMeta2;
+      const highlightDuration2 = performanceTimer.measure("highlight-code");
+      metrics?.recordShiki(highlightDuration2);
+      metrics?.recordHighlightForLanguage(resolvedLanguage, highlightDuration2);
+      return;
+    }
+  }
+  resetIncrementalHighlightState(block.id);
+  if (block.isFinalized && shouldLazyTokenizeBlock(codeLines.length, hasHighlighter, hasHighlightableContent) && (wantsHtml || wantsTokens)) {
+    if (hasHighlighter) {
+      if (wantsHtml) {
+        resolvedLanguage = await resolveHighlightLanguage(requestedLanguage);
+      }
+      if (wantsTokens) {
+        resolvedTokenLanguage = await resolveHighlightLanguage(tokenLanguage);
+      }
+    }
+    const diffEnabled = diffInfo.isDiff && wantsTokens;
+    const signature = makeLazySignature(codeBody, resolvedLanguage, resolvedTokenLanguage, diffEnabled);
+    const state = getOrInitLazyState(block.id, signature, codeLines.length, resolvedLanguage, resolvedTokenLanguage, diffEnabled);
+    const effectiveLang2 = wantsHtml ? resolvedLanguage : resolvedTokenLanguage;
+    const nextMeta2 = { ...baseMeta, ...meta, lang: effectiveLang2 };
+    nextMeta2.code = codeBody;
+    nextMeta2.lazyTokenization = true;
+    nextMeta2.lazyTokenizedUntil = state.processedLines;
+    if (wantsHtml) {
+      nextMeta2.highlightedLines = state.highlightedLines;
+    } else if ("highlightedLines" in nextMeta2) {
+      delete nextMeta2.highlightedLines;
+    }
+    if (wantsTokens) {
+      nextMeta2.tokenLines = state.tokenLines;
+      if (diffEnabled) {
+        nextMeta2.diffKind = state.diffKind;
+        nextMeta2.oldNo = state.oldNo;
+        nextMeta2.newNo = state.newNo;
+      } else {
+        if ("diffKind" in nextMeta2) delete nextMeta2.diffKind;
+        if ("oldNo" in nextMeta2) delete nextMeta2.oldNo;
+        if ("newNo" in nextMeta2) delete nextMeta2.newNo;
+      }
+    } else if ("tokenLines" in nextMeta2) {
+      delete nextMeta2.tokenLines;
+      if ("diffKind" in nextMeta2) delete nextMeta2.diffKind;
+      if ("oldNo" in nextMeta2) delete nextMeta2.oldNo;
+      if ("newNo" in nextMeta2) delete nextMeta2.newNo;
+    }
+    if (emitDiffBlocks && diffInfo.isDiff) {
+      const cursor = { oldLine: null, newLine: null };
+      const diffLines = codeLines.map((line) => parseUnifiedDiffLine(line, cursor));
+      nextMeta2.diffBlocks = buildDiffBlocksFromLines(diffLines, codeLines, wantsTokens ? state.tokenLines : null, diffInfo.baseLang ?? null);
+    } else if ("diffBlocks" in nextMeta2) {
+      delete nextMeta2.diffBlocks;
+    }
+    block.payload.highlightedHtml = void 0;
+    block.payload.meta = nextMeta2;
+    return;
+  }
+  let tokenLines;
+  let diffKind;
+  let diffOldNo;
+  let diffNewNo;
+  if (wantsHtml) {
+    let cachedHighlight = block.isFinalized ? getHighlightCacheEntry(requestedLanguage, codeBody) : null;
+    if (!cachedHighlight && highlighter && hasHighlightableContent) {
+      try {
+        resolvedLanguage = await resolveHighlightLanguage(requestedLanguage);
+        const highlighted = highlighter.codeToHtml(codeBody, {
+          lang: resolvedLanguage,
+          themes: CODE_HIGHLIGHT_THEMES,
+          defaultColor: false
+        });
+        const enhanced = enhanceHighlightedHtml(highlighted, resolvedLanguage);
+        block.payload.highlightedHtml = enhanced;
+        if (block.isFinalized) {
+          setHighlightCacheEntry(resolvedLanguage, codeBody, enhanced);
+          if (resolvedLanguage !== requestedLanguage) {
+            setHighlightCacheEntry(requestedLanguage, codeBody, enhanced);
+          }
+        }
+        cachedHighlight = getHighlightCacheEntry(resolvedLanguage, codeBody);
+      } catch (error) {
+        console.warn("Highlighting failed for", requestedLanguage, error);
+        resolvedLanguage = "text";
+      }
+    }
+    if (cachedHighlight) {
+      resolvedLanguage = cachedHighlight.lang;
+      block.payload.highlightedHtml = cachedHighlight.html;
+    }
+  } else {
+    block.payload.highlightedHtml = void 0;
+  }
+  if (wantsTokens) {
+    if (diffInfo.isDiff) {
+      if (hasHighlighter) {
+        resolvedTokenLanguage = await resolveHighlightLanguage(tokenLanguage);
+      }
+      const diffLines = codeBody.length > 0 ? codeBody.split("\n") : [];
+      const cursor = { oldLine: null, newLine: null };
+      const diffInfoLines = diffLines.map((line) => parseUnifiedDiffLine(line, cursor));
+      diffKind = diffInfoLines.map((line) => line.kind);
+      diffOldNo = diffInfoLines.map((line) => line.oldNo ?? null);
+      diffNewNo = diffInfoLines.map((line) => line.newNo ?? null);
+      if (!hasHighlighter || !hasHighlightableContent) {
+        tokenLines = diffInfoLines.map((line) => line.text.length > 0 ? { spans: [{ t: line.text }] } : { spans: [] });
+      } else {
+        try {
+          const result = buildDiffTokenLines(diffInfoLines, resolvedTokenLanguage, {});
+          tokenLines = result.tokenLines;
+        } catch (error) {
+          console.warn("Diff tokenization failed for", tokenLanguage, error);
+          tokenLines = diffInfoLines.map((line) => line.text.length > 0 ? { spans: [{ t: line.text }] } : { spans: [] });
+        }
+      }
+    } else {
+      const lineCount = codeBody.length > 0 ? codeBody.split("\n").length : 0;
+      if (!hasHighlighter || !hasHighlightableContent) {
+        tokenLines = new Array(lineCount).fill(null);
+      } else {
+        try {
+          resolvedTokenLanguage = await resolveHighlightLanguage(tokenLanguage);
+          const tokens = highlighter?.codeToTokensWithThemes(codeBody, {
+            lang: resolvedTokenLanguage,
+            themes: CODE_HIGHLIGHT_THEMES
+          });
+          tokenLines = renderTokenLines(tokens);
+        } catch (error) {
+          console.warn("Tokenization failed for", requestedLanguage, error);
+          tokenLines = new Array(lineCount).fill(null);
+        }
+      }
+    }
+  }
+  const effectiveLang = wantsHtml ? resolvedLanguage : resolvedTokenLanguage;
+  const nextMeta = { ...baseMeta, ...meta, lang: effectiveLang };
+  nextMeta.code = codeBody;
+  if ("highlightedLines" in nextMeta) {
+    delete nextMeta.highlightedLines;
+  }
+  if (wantsTokens) {
+    nextMeta.tokenLines = tokenLines ?? [];
+    if (diffKind) {
+      nextMeta.diffKind = diffKind;
+      nextMeta.oldNo = diffOldNo ?? [];
+      nextMeta.newNo = diffNewNo ?? [];
+    } else {
+      if ("diffKind" in nextMeta) delete nextMeta.diffKind;
+      if ("oldNo" in nextMeta) delete nextMeta.oldNo;
+      if ("newNo" in nextMeta) delete nextMeta.newNo;
+    }
+  } else if ("tokenLines" in nextMeta) {
+    delete nextMeta.tokenLines;
+    if ("diffKind" in nextMeta) delete nextMeta.diffKind;
+    if ("oldNo" in nextMeta) delete nextMeta.oldNo;
+    if ("newNo" in nextMeta) delete nextMeta.newNo;
+  }
+  if (emitDiffBlocks && diffInfo.isDiff) {
+    const cursor = { oldLine: null, newLine: null };
+    const diffLines = codeLines.map((line) => parseUnifiedDiffLine(line, cursor));
+    nextMeta.diffBlocks = buildDiffBlocksFromLines(diffLines, codeLines, wantsTokens ? tokenLines ?? null : null, diffInfo.baseLang ?? null);
+  } else if ("diffBlocks" in nextMeta) {
+    delete nextMeta.diffBlocks;
+  }
+  block.payload.meta = nextMeta;
+  const highlightDuration = performanceTimer.measure("highlight-code");
+  metrics?.recordShiki(highlightDuration);
+  metrics?.recordHighlightForLanguage(resolvedLanguage, highlightDuration);
+}
+function makeHighlightCacheKey(language, code) {
+  return `${language}::${code}`;
+}
+function getHighlightCacheEntry(language, code) {
+  if (!language || !code) return null;
+  return CODE_HIGHLIGHT_CACHE.get(makeHighlightCacheKey(language, code)) ?? null;
+}
+function setHighlightCacheEntry(language, code, html) {
+  if (!language || !code || typeof html !== "string") return;
+  const key = makeHighlightCacheKey(language, code);
+  CODE_HIGHLIGHT_CACHE.set(key, { html, lang: language });
+  if (CODE_HIGHLIGHT_CACHE.size > MAX_CODE_HIGHLIGHT_CACHE_ENTRIES) {
+    const oldest = CODE_HIGHLIGHT_CACHE.keys().next().value;
+    if (oldest) {
+      CODE_HIGHLIGHT_CACHE.delete(oldest);
+    }
+  }
+}
+function enhanceHighlightedHtml(html, language) {
+  if (!html) return html;
+  let lineIndex = 0;
+  const withLineNumbers = html.replace(/<span class="line"/g, (match) => {
+    if (/data-line="\d+"/.test(match)) {
+      return match;
+    }
+    lineIndex += 1;
+    return `${match} data-line="${lineIndex}"`;
+  });
+  const enhancedCode = withLineNumbers.replace(/<code([^>]*)>/, (match, attrs) => {
+    const attrMap = parseAttributeString(attrs);
+    attrMap["data-language"] = language || "text";
+    if (!attrMap["data-theme"]) {
+      attrMap["data-theme"] = "github-dark github-light";
+    }
+    if (!attrMap.style) {
+      attrMap.style = "display: grid;";
+    } else if (!/display\s*:/.test(attrMap.style)) {
+      attrMap.style = `${attrMap.style.trim().replace(/;$/, "")};display: grid;`;
+    }
+    return `<code${serializeAttributes(attrMap)}>`;
+  });
+  return enhancedCode.replace(/<pre([^>]*)>/, (match, attrs) => {
+    const attrMap = parseAttributeString(attrs);
+    attrMap["data-language"] = language || "text";
+    if (attrMap.tabindex !== void 0) {
+      attrMap.tabindex = void 0;
+    }
+    attrMap.style = sanitizeShikiStyle(attrMap.style);
+    if (attrMap.style === void 0 || attrMap.style.length === 0) {
+      attrMap.style = void 0;
+    }
+    return `<pre${serializeAttributes(attrMap)}>`;
+  });
+}
+function parseAttributeString(fragment) {
+  const attrs = {};
+  if (!fragment) return attrs;
+  const regex = /([a-zA-Z_:][\w:.-]*)\s*=\s*"([^"]*)"/g;
+  let match;
+  while (true) {
+    match = regex.exec(fragment);
+    if (match === null) {
+      break;
+    }
+    const [, name, value] = match;
+    attrs[name] = value;
+  }
+  return attrs;
+}
+function serializeAttributes(attrs) {
+  return Object.entries(attrs).map(([key, value]) => ` ${key}="${value}"`).join("");
+}
+function sanitizeShikiStyle(style) {
+  const sanitized = [];
+  if (style) {
+    for (const rawEntry of style.split(";")) {
+      const entry = rawEntry.trim();
+      if (!entry) continue;
+      const separatorIndex = entry.indexOf(":");
+      if (separatorIndex === -1) continue;
+      const name = entry.slice(0, separatorIndex).trim();
+      const value = entry.slice(separatorIndex + 1).trim();
+      const lowerName = name.toLowerCase();
+      if (lowerName.startsWith("background")) {
+        continue;
+      }
+      if (lowerName === "--shiki-dark-bg" || lowerName === "--shiki-light-bg") {
+        continue;
+      }
+      sanitized.push(`${name}:${value}`);
+    }
+  }
+  sanitized.push("--shiki-dark-bg: transparent");
+  sanitized.push("--shiki-light-bg: transparent");
+  return sanitized.length > 0 ? sanitized.join(";") : void 0;
+}
+function clearWorkerMdxCaches() {
+  WORKER_MDX_CACHE.clear();
+  WORKER_MDX_INFLIGHT.clear();
+}
+function cacheWorkerMdxModule(key, module2) {
+  const stored = {
+    ...module2,
+    dependencies: module2.dependencies ? [...module2.dependencies] : void 0
+  };
+  if (!WORKER_MDX_CACHE.has(key) && WORKER_MDX_CACHE.size >= MAX_WORKER_MDX_CACHE_ENTRIES) {
+    const oldest = WORKER_MDX_CACHE.keys().next().value;
+    if (typeof oldest === "string") {
+      WORKER_MDX_CACHE.delete(oldest);
+    }
+  }
+  WORKER_MDX_CACHE.set(key, stored);
+}
+async function getOrCompileMdxModuleForBlock(block) {
+  const cacheKey = block.id;
+  const cached = WORKER_MDX_CACHE.get(cacheKey);
+  if (cached) {
+    return {
+      ...cached,
+      dependencies: cached.dependencies ? [...cached.dependencies] : void 0
+    };
+  }
+  const inflight = WORKER_MDX_INFLIGHT.get(cacheKey);
+  if (inflight) {
+    const result = await inflight;
+    return {
+      ...result,
+      dependencies: result.dependencies ? [...result.dependencies] : void 0
+    };
+  }
+  const source = block.payload.raw ?? "";
+  const compilePromise = (async () => {
+    const { code, dependencies } = await compileMdxContent(source);
+    const module2 = {
+      id: `worker:${cacheKey}`,
+      code,
+      dependencies,
+      source: "worker"
+    };
+    cacheWorkerMdxModule(cacheKey, module2);
+    return module2;
+  })();
+  WORKER_MDX_INFLIGHT.set(cacheKey, compilePromise);
+  try {
+    const compiled = await compilePromise;
+    return {
+      ...compiled,
+      dependencies: compiled.dependencies ? [...compiled.dependencies] : void 0
+    };
+  } finally {
+    WORKER_MDX_INFLIGHT.delete(cacheKey);
+  }
+}
+async function updateMdxCompilationState(block) {
+  try {
+    if (DEBUG_MDX) {
+      console.debug("[markdown-worker] mdx update", { blockId: block.id, type: block.type, finalized: block.isFinalized, compileMode: mdxCompileMode });
+    }
+  } catch {
+  }
+  if (block.type !== "mdx") {
+    if ("compiledMdxModule" in block.payload) {
+      block.payload.compiledMdxModule = void 0;
+    }
+    return;
+  }
+  if (mdxCompileMode !== "worker") {
+    if ("compiledMdxModule" in block.payload) {
+      block.payload.compiledMdxModule = void 0;
+    }
+    return;
+  }
+  const baseMeta = block.payload.meta ?? {};
+  const pendingMeta = { ...baseMeta, mdxStatus: "pending" };
+  if ("mdxError" in pendingMeta) {
+    pendingMeta.mdxError = void 0;
+  }
+  block.payload.meta = pendingMeta;
+  if (!block.isFinalized) {
+    block.payload.compiledMdxModule = null;
+    block.payload.compiledMdxRef = { id: "pending" };
+    return;
+  }
+  try {
+    const module2 = await getOrCompileMdxModuleForBlock(block);
+    block.payload.compiledMdxModule = {
+      ...module2,
+      dependencies: module2.dependencies ? [...module2.dependencies] : void 0
+    };
+    block.payload.compiledMdxRef = { id: module2.id };
+    const nextMeta = {
+      ...block.payload.meta ?? {},
+      mdxStatus: "compiled"
+    };
+    if ("mdxError" in nextMeta) {
+      nextMeta.mdxError = void 0;
+    }
+    block.payload.meta = nextMeta;
+    if (DEBUG_MDX) {
+      try {
+        console.debug("[markdown-worker] mdx compiled", { blockId: block.id, id: module2.id, deps: module2.dependencies?.length ?? 0 });
+      } catch {
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "MDX compilation failed";
+    block.payload.compiledMdxModule = null;
+    block.payload.compiledMdxRef = void 0;
+    const errorMeta = {
+      ...block.payload.meta ?? {},
+      mdxStatus: "error",
+      mdxError: message
+    };
+    block.payload.meta = errorMeta;
+    if (DEBUG_MDX) {
+      try {
+        console.error("[markdown-worker] mdx compile failed", { blockId: block.id, error: message });
+      } catch {
+      }
+    }
+  }
+}
+function enrichListBlock(block) {
+  const lines = block.payload.raw.split("\n");
+  const itemsRaw = [];
+  let current = null;
+  const bulletRe = /^[-*+]\s+(.*)$/;
+  const orderedRe = /^\d+\.\s+(.*)$/;
+  for (const line of lines) {
+    const trimmed = line.trimEnd();
+    const bare = trimmed.trimStart();
+    const bulletMatch = bare.match(bulletRe);
+    const orderedMatch = bare.match(orderedRe);
+    if (bulletMatch || orderedMatch) {
+      if (current) {
+        itemsRaw.push(current.join("\n"));
+      }
+      const content = (bulletMatch ? bulletMatch[1] : orderedMatch?.[1]) ?? "";
+      current = [content];
+    } else if (current) {
+      current.push(bare);
+    }
+  }
+  if (current) {
+    itemsRaw.push(current.join("\n"));
+  }
+  const items = itemsRaw.map((raw) => inlineParser.parse(raw));
+  const isOrdered = /^\d+\./.test(lines[0]?.trimStart() || "");
+  block.payload.meta = {
+    ordered: isOrdered,
+    items,
+    formatAnticipation: block.isFinalized ? void 0 : formatAnticipationConfig,
+    mathEnabled: enableMath
+  };
+}
+function runDocumentPlugins(inputBlocks, content) {
+  const blocks2 = inputBlocks.slice();
+  const aggregatedProtected = [];
+  for (const block of blocks2) {
+    const meta = block.payload.meta;
+    const rawRanges = Array.isArray(meta?.protectedRanges) ? meta.protectedRanges : void 0;
+    if (!rawRanges || rawRanges.length === 0) continue;
+    const base = typeof block.payload.range?.from === "number" ? block.payload.range.from : null;
+    if (base === null) continue;
+    for (const range of rawRanges) {
+      if (typeof range.from !== "number" || typeof range.to !== "number") continue;
+      aggregatedProtected.push({
+        ...range,
+        from: base + range.from,
+        to: base + range.to
+      });
+    }
+  }
+  const { syntheticBlocks } = import_plugins.globalDocumentPluginRegistry.run({
+    content,
+    blocks: blocks2,
+    state: documentPluginState,
+    protectedRanges: aggregatedProtected
+  });
+  const filtered = blocks2.filter((b) => b.type !== "footnotes");
+  if (syntheticBlocks && syntheticBlocks.length > 0) {
+    const tail = filtered[filtered.length - 1];
+    const hasDirtyTail = tail ? !tail.isFinalized : false;
+    if (hasDirtyTail) {
+      return filtered;
+    }
+    filtered.push(...syntheticBlocks);
+  }
+  return filtered;
+}
+function isBlockLike(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  if (typeof candidate.id !== "string" || typeof candidate.type !== "string") return false;
+  return typeof candidate.payload === "object" && candidate.payload !== null;
+}
+async function enrichNestedCodeBlocks(snapshot, allowHighlight) {
+  if (!allowHighlight || !highlighter) {
+    return;
+  }
+  const stack = [snapshot];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    const props = current.props ?? {};
+    const maybeBlock = props.block;
+    if (isBlockLike(maybeBlock) && maybeBlock.type === "code") {
+      const block = (0, import_core.cloneBlock)(maybeBlock);
+      const hasHighlight = typeof block.payload.highlightedHtml === "string" && block.payload.highlightedHtml.trim().length > 0;
+      if (!hasHighlight) {
+        await enrichCodeBlock(block);
+        const updated = (0, import_core.createBlockSnapshot)(block);
+        current.type = updated.type;
+        current.props = updated.props;
+        current.meta = updated.meta;
+        current.range = updated.range;
+        current.children = updated.children;
+        continue;
+      }
+    }
+    const children = current.children ?? [];
+    for (let idx = children.length - 1; idx >= 0; idx--) {
+      const child = children[idx];
+      if (child) {
+        stack.push(child);
+      }
+    }
+  }
+}
+async function blockToNodeSnapshot(block) {
+  const snapshot = (0, import_core.createBlockSnapshot)((0, import_core.cloneBlock)(block));
+  await enrichNestedCodeBlocks(snapshot, Boolean(block.isFinalized));
+  return snapshot;
+}
+async function emitDocumentPatch(currentBlocks) {
+  const patches = [];
+  const tocPatch = maybeBuildTocPatch(currentBlocks);
+  for (let index = 0; index < currentBlocks.length; index++) {
+    const block = currentBlocks[index];
+    if (!block) continue;
+    patches.push({
+      op: "insertChild",
+      at: { blockId: import_core.PATCH_ROOT_ID },
+      index,
+      node: await blockToNodeSnapshot(block)
+    });
+  }
+  if (tocPatch) {
+    patches.push(tocPatch);
+  }
+  if (patches.length > 0) {
+    postMessage({
+      type: "PATCH",
+      tx: ++txCounter,
+      patches
+    });
+  }
+}
+async function emitBlockDiffPatches(previousBlocks, nextBlocks, changedRanges, metrics) {
+  const patches = [];
+  const tocPatch = maybeBuildTocPatch(nextBlocks);
+  if (previousBlocks === nextBlocks) return;
+  let prefix = 0;
+  const maxPrefix = Math.min(previousBlocks.length, nextBlocks.length);
+  while (prefix < maxPrefix && previousBlocks[prefix].id === nextBlocks[prefix].id) {
+    prefix++;
+  }
+  let prevTail = previousBlocks.length - 1;
+  let nextTail = nextBlocks.length - 1;
+  while (prevTail >= prefix && nextTail >= prefix && previousBlocks[prevTail].id === nextBlocks[nextTail].id) {
+    prevTail--;
+    nextTail--;
+  }
+  const removeCount = prevTail >= prefix ? prevTail - prefix + 1 : 0;
+  const addCount = nextTail >= prefix ? nextTail - prefix + 1 : 0;
+  if (removeCount === addCount) {
+    for (let offset = 0; offset < addCount; offset++) {
+      const targetIndex = prefix + offset;
+      patches.push({
+        op: "replaceChild",
+        at: { blockId: import_core.PATCH_ROOT_ID },
+        index: targetIndex,
+        node: await blockToNodeSnapshot(nextBlocks[targetIndex])
+      });
+    }
+  } else {
+    for (let i = removeCount - 1; i >= 0; i--) {
+      patches.push({
+        op: "deleteChild",
+        at: { blockId: import_core.PATCH_ROOT_ID },
+        index: prefix + i
+      });
+    }
+    for (let offset = 0; offset < addCount; offset++) {
+      const insertIndex = prefix + offset;
+      const block = (0, import_core.cloneBlock)(nextBlocks[insertIndex]);
+      patches.push({
+        op: "insertChild",
+        at: { blockId: import_core.PATCH_ROOT_ID },
+        index: insertIndex,
+        node: await blockToNodeSnapshot(block)
+      });
+    }
+  }
+  metrics?.markDiffStart();
+  const { patches: contentPatches, changedBlockCount } = await diffBlockContent(previousBlocks, nextBlocks, changedRanges, metrics);
+  metrics?.markDiffEnd();
+  const combined = patches.concat(contentPatches);
+  if (tocPatch) {
+    combined.push(tocPatch);
+  }
+  let paragraphLimit = null;
+  if (workerCredits < 0.9) {
+    const dynamicBase = workerCredits < 0.5 ? 48 : 96;
+    const dynamicFinalize = workerCredits < 0.5 ? 40 : 64;
+    paragraphLimit = computeParagraphPatchLimit(combined, {
+      baseLimit: dynamicBase,
+      finalizeLimit: dynamicFinalize
+    });
+  }
+  const immediatePatches = partitionPatchesForCredits(combined, paragraphLimit === null ? void 0 : paragraphLimit);
+  if (deferredPatchQueue.length > maxDeferredQueueSize) {
+    maxDeferredQueueSize = deferredPatchQueue.length;
+  }
+  let structuralCount = 0;
+  for (const patch of patches) {
+    if (patch.op === "insertChild" || patch.op === "deleteChild" || patch.op === "replaceChild" || patch.op === "reorder") {
+      structuralCount += 1;
+    }
+  }
+  lastDiffSummary = {
+    prevCount: previousBlocks.length,
+    nextCount: nextBlocks.length,
+    prefix,
+    removeCount,
+    addCount,
+    structuralPatches: structuralCount,
+    contentPatches: contentPatches.length,
+    immediatePatches: immediatePatches.length,
+    deferredQueue: deferredPatchQueue.length
+  };
+  if (addCount > 0 || removeCount > 0 || structuralCount > 0 || deferredPatchQueue.length > 0) {
+    lastStructuralDiffSummary = { ...lastDiffSummary };
+  }
+  if (immediatePatches.length > 0) {
+    maxEmittedBlockCount = Math.max(maxEmittedBlockCount, nextBlocks.length);
+  }
+  if (structuralCount > 0) {
+    maxStructuralBlockCount = Math.max(maxStructuralBlockCount, nextBlocks.length);
+  }
+  if (nextBlocks.length >= 60 && removeCount === 0 && addCount === 0) {
+    const sliceStart = Math.max(0, Math.min(55, nextBlocks.length - 1));
+    const sliceEnd = Math.min(nextBlocks.length, sliceStart + 8);
+    const toPreview = (block) => ({
+      id: block.id,
+      type: block.type,
+      raw: typeof block.payload.raw === "string" ? block.payload.raw.slice(0, 80) : ""
+    });
+    lastHighCountNoStructural = {
+      nextCount: nextBlocks.length,
+      sliceStart,
+      prevSlice: previousBlocks.slice(sliceStart, sliceEnd).map(toPreview),
+      nextSlice: nextBlocks.slice(sliceStart, sliceEnd).map(toPreview)
+    };
+  }
+  if (immediatePatches.length === 0) {
+    if (metrics) {
+      metrics.finalizePatch(txCounter, 0, deferredPatchQueue.length, 0);
+      emitMetricsSample(metrics);
+      if (getActiveMetricsCollector() === metrics) {
+        setActiveMetricsCollector(null);
+      }
+    }
+    return;
+  }
+  dispatchPatchBatch(immediatePatches, metrics);
+}
+function dispatchPatchBatch(patches, metrics) {
+  if (!patches || patches.length === 0) {
+    return;
+  }
+  const tx = ++txCounter;
+  const patchBytes = metrics ? estimatePatchSize(patches) : 0;
+  metrics?.finalizePatch(tx, patches.length, deferredPatchQueue.length, patchBytes);
+  const changedBlockReport = countChangedBlocksFromPatches(patches);
+  const patchMetrics = metrics ? metrics.toPatchMetrics(changedBlockReport) : {
+    patchCount: patches.length,
+    changedBlocks: changedBlockReport
+  };
+  const message = {
+    type: "PATCH",
+    tx,
+    patches,
+    metrics: patchMetrics
+  };
+  metrics?.beginSerialize();
+  postMessage(message);
+  metrics?.endSerialize();
+  emitMetricsSample(metrics ?? null);
+  if (metrics && getActiveMetricsCollector() === metrics) {
+    setActiveMetricsCollector(null);
+  }
+}
+async function diffBlockContent(previousBlocks, nextBlocks, changedRanges, metrics) {
+  const patches = [];
+  const prevMap = new Map(previousBlocks.map((block) => [block.id, block]));
+  const changedBlockIds = collectChangedBlockIds(previousBlocks, nextBlocks, changedRanges);
+  for (const nextBlock of nextBlocks) {
+    const prevBlock = prevMap.get(nextBlock.id);
+    if (!prevBlock) continue;
+    if (prevBlock.type === "mdx" && nextBlock.type === "mdx") {
+      preserveMdxMetadata(prevBlock, nextBlock);
+    }
+    if (changedBlockIds.size > 0 && !changedBlockIds.has(nextBlock.id) && (0, import_core.blocksStructurallyEqual)(prevBlock, nextBlock)) {
+      continue;
+    }
+    if (changedBlockIds.size === 0 && (0, import_core.blocksStructurallyEqual)(prevBlock, nextBlock)) continue;
+    if (nextBlock.type === "html") {
+      const nextSanitized = nextBlock.payload.sanitizedHtml ?? (0, import_core2.sanitizeHtmlInWorker)(nextBlock.payload.raw ?? "");
+      const prevSanitized = prevBlock.payload.sanitizedHtml ?? "";
+      if (prevSanitized !== nextSanitized || prevBlock.payload.raw !== nextBlock.payload.raw) {
+        const cloned = (0, import_core.cloneBlock)(nextBlock);
+        cloned.payload.sanitizedHtml = nextSanitized;
+        patches.push({
+          op: "setHTML",
+          at: { blockId: nextBlock.id },
+          html: nextSanitized,
+          policy: "markdown-renderer-v2",
+          block: cloned,
+          meta: nextBlock.payload.meta ? { ...nextBlock.payload.meta } : void 0,
+          sanitized: true
+        });
+      }
+      continue;
+    }
+    const prevSnapshot = await blockToNodeSnapshot(prevBlock);
+    const nextSnapshot = await blockToNodeSnapshot(nextBlock);
+    diffNodeSnapshot(nextBlock.id, prevSnapshot, nextSnapshot, patches, metrics);
+  }
+  return { patches, changedBlockCount: changedBlockIds.size };
+}
+function preserveMdxMetadata(previous, next) {
+  const prevRaw = previous.payload.raw ?? "";
+  const nextRaw = next.payload.raw ?? "";
+  if (prevRaw !== nextRaw) {
+    return;
+  }
+  if (previous.payload.compiledMdxRef && !next.payload.compiledMdxRef) {
+    next.payload.compiledMdxRef = { ...previous.payload.compiledMdxRef };
+  }
+  if (previous.payload.compiledMdxModule && !next.payload.compiledMdxModule) {
+    next.payload.compiledMdxModule = {
+      ...previous.payload.compiledMdxModule,
+      dependencies: previous.payload.compiledMdxModule.dependencies ? [...previous.payload.compiledMdxModule.dependencies] : void 0
+    };
+  } else if (previous.payload.compiledMdxModule === null && typeof next.payload.compiledMdxModule === "undefined") {
+    next.payload.compiledMdxModule = null;
+  }
+  const prevMeta = previous.payload.meta ?? null;
+  if (!prevMeta) {
+    return;
+  }
+  const currentMeta = next.payload.meta ?? void 0;
+  const mergedMeta = currentMeta ? { ...currentMeta } : {};
+  let metaChanged = false;
+  if (typeof prevMeta.mdxStatus === "string" && mergedMeta.mdxStatus === void 0) {
+    mergedMeta.mdxStatus = prevMeta.mdxStatus;
+    metaChanged = true;
+  }
+  if (typeof prevMeta.mdxError === "string" && mergedMeta.mdxError === void 0) {
+    mergedMeta.mdxError = prevMeta.mdxError;
+    metaChanged = true;
+  }
+  if (metaChanged || !currentMeta) {
+    next.payload.meta = mergedMeta;
+  }
+}
+function diffNodeSnapshot(blockId, prevNode, nextNode, patches, metrics) {
+  const prevProps = prevNode.props ?? {};
+  const nextProps = nextNode.props ?? {};
+  if (!shallowEqual(prevProps, nextProps)) {
+    patches.push({
+      op: "setProps",
+      at: { blockId, nodeId: prevNode.id },
+      props: nextProps ?? {}
+    });
+  }
+  const prevChildren = prevNode.children ?? [];
+  const nextChildren = nextNode.children ?? [];
+  if (prevNode.type === "list" && nextNode.type === "list") {
+    diffListChildren(blockId, prevNode, prevChildren, nextChildren, patches, metrics);
+    return;
+  }
+  if (prevNode.type === "code" && nextNode.type === "code") {
+    const commonLength = Math.min(prevChildren.length, nextChildren.length);
+    let divergeIndex = 0;
+    while (divergeIndex < commonLength && prevChildren[divergeIndex].id === nextChildren[divergeIndex].id) {
+      diffNodeSnapshot(blockId, prevChildren[divergeIndex], nextChildren[divergeIndex], patches, metrics);
+      divergeIndex++;
+    }
+    const onlyAppend = divergeIndex === prevChildren.length && nextChildren.length >= prevChildren.length && prevChildren.every((child, idx) => child.id === nextChildren[idx].id);
+    if (onlyAppend && nextChildren.length > prevChildren.length) {
+      const startIndex = prevChildren.length;
+      const appended = nextChildren.slice(startIndex);
+      const hasTokenLines = appended.some((child) => Object.prototype.hasOwnProperty.call(child.props ?? {}, "tokens"));
+      const hasDiffKind = appended.some((child) => Object.prototype.hasOwnProperty.call(child.props ?? {}, "diffKind"));
+      const hasOldNo = appended.some((child) => Object.prototype.hasOwnProperty.call(child.props ?? {}, "oldNo"));
+      const hasNewNo = appended.some((child) => Object.prototype.hasOwnProperty.call(child.props ?? {}, "newNo"));
+      patches.push({
+        op: "appendLines",
+        at: { blockId, nodeId: prevNode.id },
+        startIndex,
+        lines: appended.map((child) => {
+          const text = typeof child.props?.text === "string" ? child.props?.text : "";
+          return text;
+        }),
+        highlight: appended.map((child) => typeof child.props?.html === "string" ? child.props?.html : null),
+        ...hasTokenLines ? {
+          tokens: appended.map(
+            (child) => Object.prototype.hasOwnProperty.call(child.props ?? {}, "tokens") ? child.props?.tokens : null
+          )
+        } : {},
+        ...hasDiffKind ? {
+          diffKind: appended.map(
+            (child) => Object.prototype.hasOwnProperty.call(child.props ?? {}, "diffKind") ? child.props?.diffKind : null
+          )
+        } : {},
+        ...hasOldNo ? {
+          oldNo: appended.map(
+            (child) => Object.prototype.hasOwnProperty.call(child.props ?? {}, "oldNo") ? child.props?.oldNo : null
+          )
+        } : {},
+        ...hasNewNo ? {
+          newNo: appended.map(
+            (child) => Object.prototype.hasOwnProperty.call(child.props ?? {}, "newNo") ? child.props?.newNo : null
+          )
+        } : {}
+      });
+      metrics?.recordAppendLines(appended.length);
+      return;
+    }
+  }
+  const minLen = Math.min(prevChildren.length, nextChildren.length);
+  let prefix = 0;
+  while (prefix < minLen && prevChildren[prefix].id === nextChildren[prefix].id) {
+    diffNodeSnapshot(blockId, prevChildren[prefix], nextChildren[prefix], patches, metrics);
+    prefix++;
+  }
+  let suffix = 0;
+  while (suffix < minLen - prefix && prevChildren[prevChildren.length - 1 - suffix].id === nextChildren[nextChildren.length - 1 - suffix].id) {
+    const prevIdx = prevChildren.length - 1 - suffix;
+    const nextIdx = nextChildren.length - 1 - suffix;
+    diffNodeSnapshot(blockId, prevChildren[prevIdx], nextChildren[nextIdx], patches, metrics);
+    suffix++;
+  }
+  const prevMid = prevChildren.slice(prefix, prevChildren.length - suffix);
+  const nextMid = nextChildren.slice(prefix, nextChildren.length - suffix);
+  if (prevMid.length === 0 && nextMid.length === 0) {
+    return;
+  }
+  if (prevMid.length === nextMid.length && prevMid.length > 0) {
+    const prevIds = prevMid.map((child) => child.id);
+    const nextIds = nextMid.map((child) => child.id);
+    if (haveSameMultiset(prevIds, nextIds)) {
+      const currentOrder = prevIds.slice();
+      const reorderOps = [];
+      for (let targetIdx = 0; targetIdx < nextIds.length; targetIdx++) {
+        const desiredId = nextIds[targetIdx];
+        if (currentOrder[targetIdx] === desiredId) {
+          continue;
+        }
+        const sourceIdx = currentOrder.indexOf(desiredId);
+        if (sourceIdx === -1) continue;
+        reorderOps.push({
+          from: prefix + sourceIdx,
+          to: prefix + targetIdx
+        });
+        const [moved] = currentOrder.splice(sourceIdx, 1);
+        currentOrder.splice(targetIdx, 0, moved);
+      }
+      for (const op of reorderOps) {
+        patches.push({
+          op: "reorder",
+          at: { blockId, nodeId: prevNode.id },
+          from: op.from,
+          to: op.to,
+          count: 1
+        });
+      }
+      const prevMap = new Map(prevMid.map((child) => [child.id, child]));
+      for (const child of nextMid) {
+        const previous = prevMap.get(child.id);
+        if (previous) {
+          diffNodeSnapshot(blockId, previous, child, patches, metrics);
+        }
+      }
+      return;
+    }
+  }
+  for (let i = prevChildren.length - 1 - suffix; i >= prefix; i--) {
+    patches.push({
+      op: "deleteChild",
+      at: { blockId, nodeId: prevNode.id },
+      index: i
+    });
+  }
+  for (let i = prefix; i < nextChildren.length - suffix; i++) {
+    patches.push({
+      op: "insertChild",
+      at: { blockId, nodeId: prevNode.id },
+      index: i,
+      node: nextChildren[i]
+    });
+  }
+}
+function shallowEqual(a, b) {
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    const valA = a[key];
+    const valB = b[key];
+    if (typeof valA === "object" || typeof valB === "object") {
+      if (JSON.stringify(valA) !== JSON.stringify(valB)) return false;
+    } else if (valA !== valB) {
+      return false;
+    }
+  }
+  return true;
+}
+function haveSameMultiset(a, b) {
+  if (a.length !== b.length) return false;
+  const counts = /* @__PURE__ */ new Map();
+  for (const id of a) {
+    counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+  for (const id of b) {
+    const next = (counts.get(id) ?? 0) - 1;
+    if (next < 0) return false;
+    counts.set(id, next);
+  }
+  return Array.from(counts.values()).every((val) => val === 0);
+}
+function diffListChildren(blockId, listNode, prevChildren, nextChildren, patches, metrics) {
+  const prevLength = prevChildren.length;
+  const nextLength = nextChildren.length;
+  if (prevLength === 0 && nextLength === 0) {
+    return;
+  }
+  const commonLength = Math.min(prevLength, nextLength);
+  let prefix = 0;
+  while (prefix < commonLength && prevChildren[prefix].id === nextChildren[prefix].id) {
+    diffNodeSnapshot(blockId, prevChildren[prefix], nextChildren[prefix], patches, metrics);
+    prefix++;
+  }
+  if (prefix === prevLength && prefix === nextLength) {
+    return;
+  }
+  if (prefix === prevLength && nextLength > prevLength) {
+    for (let i = prefix; i < nextLength; i++) {
+      patches.push({
+        op: "insertChild",
+        at: { blockId, nodeId: listNode.id },
+        index: i,
+        node: nextChildren[i]
+      });
+    }
+    return;
+  }
+  if (prefix === nextLength && prevLength > nextLength) {
+    for (let i = prevLength - 1; i >= nextLength; i--) {
+      patches.push({
+        op: "deleteChild",
+        at: { blockId, nodeId: listNode.id },
+        index: i
+      });
+    }
+    return;
+  }
+  let suffix = 0;
+  while (suffix < commonLength - prefix && prevChildren[prevLength - 1 - suffix].id === nextChildren[nextLength - 1 - suffix].id) {
+    const prevIdx = prevLength - 1 - suffix;
+    const nextIdx = nextLength - 1 - suffix;
+    diffNodeSnapshot(blockId, prevChildren[prevIdx], nextChildren[nextIdx], patches, metrics);
+    suffix++;
+  }
+  const prevMidStart = prefix;
+  const prevMidEnd = prevLength - suffix;
+  const nextMidStart = prefix;
+  const nextMidEnd = nextLength - suffix;
+  const prevMidLen = Math.max(0, prevMidEnd - prevMidStart);
+  const nextMidLen = Math.max(0, nextMidEnd - nextMidStart);
+  if (prevMidLen === 0 && nextMidLen === 0) {
+    return;
+  }
+  if (prevMidLen === 0 && nextMidLen > 0) {
+    for (let i = nextMidStart; i < nextMidEnd; i++) {
+      patches.push({
+        op: "insertChild",
+        at: { blockId, nodeId: listNode.id },
+        index: i,
+        node: nextChildren[i]
+      });
+    }
+    return;
+  }
+  if (prevMidLen > 0 && nextMidLen === 0) {
+    for (let i = prevMidEnd - 1; i >= prevMidStart; i--) {
+      patches.push({
+        op: "deleteChild",
+        at: { blockId, nodeId: listNode.id },
+        index: i
+      });
+    }
+    return;
+  }
+  const prevMid = prevChildren.slice(prevMidStart, prevMidEnd);
+  const nextMid = nextChildren.slice(nextMidStart, nextMidEnd);
+  const sharedMid = Math.min(prevMid.length, nextMid.length);
+  let midPrefix = 0;
+  while (midPrefix < sharedMid && prevMid[midPrefix].id === nextMid[midPrefix].id) {
+    diffNodeSnapshot(blockId, prevMid[midPrefix], nextMid[midPrefix], patches, metrics);
+    midPrefix++;
+  }
+  if (midPrefix === prevMid.length && midPrefix === nextMid.length) {
+    return;
+  }
+  if (midPrefix === prevMid.length && nextMid.length > prevMid.length) {
+    for (let i = nextMidStart + midPrefix; i < nextMidEnd; i++) {
+      patches.push({
+        op: "insertChild",
+        at: { blockId, nodeId: listNode.id },
+        index: i,
+        node: nextChildren[i]
+      });
+    }
+    return;
+  }
+  if (midPrefix === nextMid.length && prevMid.length > nextMid.length) {
+    for (let i = prevMidEnd - 1; i >= prevMidStart + midPrefix; i--) {
+      patches.push({
+        op: "deleteChild",
+        at: { blockId, nodeId: listNode.id },
+        index: i
+      });
+    }
+    return;
+  }
+  const remainingPrevMid = prevMid.slice(midPrefix);
+  const remainingNextMid = nextMid.slice(midPrefix);
+  if (remainingPrevMid.length === remainingNextMid.length && remainingPrevMid.every((child, idx) => child.id === remainingNextMid[idx].id)) {
+    for (let idx = 0; idx < remainingPrevMid.length; idx++) {
+      diffNodeSnapshot(blockId, remainingPrevMid[idx], remainingNextMid[idx], patches, metrics);
+    }
+    return;
+  }
+  for (let i = prevMidEnd - 1; i >= prevMidStart + midPrefix; i--) {
+    patches.push({
+      op: "deleteChild",
+      at: { blockId, nodeId: listNode.id },
+      index: i
+    });
+  }
+  for (let i = nextMidStart + midPrefix; i < nextMidEnd; i++) {
+    patches.push({
+      op: "insertChild",
+      at: { blockId, nodeId: listNode.id },
+      index: i,
+      node: nextChildren[i]
+    });
+  }
+}
+function computeChangedRanges(previous, next) {
+  if (previous === next) {
+    return [];
+  }
+  let from = 0;
+  const minLen = Math.min(previous.length, next.length);
+  while (from < minLen && previous.charCodeAt(from) === next.charCodeAt(from)) {
+    from++;
+  }
+  let toA = previous.length;
+  let toB = next.length;
+  while (toA > from && toB > from && previous.charCodeAt(toA - 1) === next.charCodeAt(toB - 1)) {
+    toA--;
+    toB--;
+  }
+  return [
+    {
+      fromA: from,
+      toA,
+      fromB: from,
+      toB
+    }
+  ];
+}
+function collectChangedBlockIds(previousBlocks, nextBlocks, ranges) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!ranges || ranges.length === 0) {
+    return ids;
+  }
+  for (const range of ranges) {
+    addIntersectingBlocks(ids, previousBlocks, range.fromA, range.toA);
+    addIntersectingBlocks(ids, nextBlocks, range.fromB, range.toB);
+  }
+  return ids;
+}
+function addIntersectingBlocks(target, blocks2, from, to) {
+  if (from === to) {
+    for (const block of blocks2) {
+      const range = block.payload.range;
+      if (!range) continue;
+      if (from >= range.from && from <= range.to) {
+        target.add(block.id);
+        break;
+      }
+    }
+    return;
+  }
+  for (const block of blocks2) {
+    const range = block.payload.range;
+    if (!range) continue;
+    if (rangesIntersect(range.from, range.to, from, to)) {
+      target.add(block.id);
+    }
+  }
+}
+function rangesIntersect(aFrom, aTo, bFrom, bTo) {
+  return Math.max(aFrom, bFrom) <= Math.min(aTo, bTo);
+}
+function reportWorkerError(error, phase, meta) {
+  const payload = error instanceof Error ? { name: error.name, message: error.message, stack: error.stack } : { message: typeof error === "string" ? error : JSON.stringify(error) };
+  postMessage({
+    type: "ERROR",
+    phase,
+    error: payload,
+    meta,
+    timestamp: Date.now()
+  });
+}
+async function finalizeAllBlocks() {
+  const metricsCollector = new WorkerMetricsCollector(workerGrammarEngine);
+  setActiveMetricsCollector(metricsCollector);
+  const prevBlocks = blocks.map((block) => (0, import_core.cloneBlock)(block));
+  const finalizePatches = [];
+  const finalizeTargets = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    if (!block.isFinalized) {
+      block.isFinalized = true;
+      finalizeTargets.add(block.id);
+      finalizePatches.push({
+        op: "finalize",
+        at: { blockId: block.id }
+      });
+    }
+  }
+  if (finalizePatches.length > 0) {
+    postMessage({
+      type: "PATCH",
+      tx: ++txCounter,
+      patches: finalizePatches
+    });
+  }
+  const { blocks: reparsedBlocks, lastTree: reparsedTree } = await parseAll(currentContent, { forceFinalize: true });
+  for (const block of reparsedBlocks) {
+    block.isFinalized = true;
+    await updateMdxCompilationState(block);
+  }
+  blocks = reparsedBlocks;
+  lastTree = reparsedTree;
+  metricsCollector.setBlocksProduced(blocks.length);
+  const fullRange = [
+    {
+      fromA: 0,
+      toA: currentContent.length,
+      fromB: 0,
+      toB: currentContent.length
+    }
+  ];
+  await emitBlockDiffPatches(prevBlocks, blocks, fullRange, metricsCollector);
+  if (prevBlocks && prevBlocks.length > 0) {
+    const finalizeSetProps = [];
+    for (const block of blocks) {
+      if (!block.isFinalized || !finalizeTargets.has(block.id)) continue;
+      finalizeSetProps.push({
+        op: "setProps",
+        at: { blockId: block.id, nodeId: block.id },
+        props: {
+          block: (0, import_core.cloneBlock)(block)
+        }
+      });
+    }
+    if (finalizeSetProps.length > 0) {
+      dispatchPatchBatch(finalizeSetProps, metricsCollector);
+    }
+  }
+  if (deferredPatchQueue.length > 0) {
+    const previousCredits = workerCredits;
+    workerCredits = 1;
+    const maxIterations = Math.ceil(deferredPatchQueue.length / MAX_DEFERRED_FLUSH_PATCHES) + 8;
+    for (let i = 0; i < maxIterations && deferredPatchQueue.length > 0; i++) {
+      const before = deferredPatchQueue.length;
+      flushDeferredPatches();
+      if (deferredPatchQueue.length >= before) {
+        break;
+      }
+    }
+    workerCredits = previousCredits;
+  }
+  postMessage({
+    type: "FINALIZED"
+  });
+  if (getActiveMetricsCollector() === metricsCollector) {
+    setActiveMetricsCollector(null);
+  }
+}
+function handleMdxStatus(blockId, update) {
+  if (mdxCompileMode === "worker") {
+    return;
+  }
+  const index = blocks.findIndex((b) => b.id === blockId);
+  if (index === -1) return;
+  const previous = blocks[index];
+  const updated = (0, import_core.cloneBlock)(previous);
+  updated.payload = {
+    ...updated.payload,
+    compiledMdxRef: update.compiledRef ?? updated.payload.compiledMdxRef,
+    meta: {
+      ...updated.payload.meta ?? {},
+      mdxStatus: update.status,
+      ...update.error ? { mdxError: update.error } : {}
+    }
+  };
+  blocks[index] = updated;
+  postMessage({
+    type: "PATCH",
+    tx: ++txCounter,
+    patches: [
+      {
+        op: "setProps",
+        at: { blockId },
+        props: {
+          block: updated
+        }
+      }
+    ]
+  });
+}
+async function processWorkerMessage(msg) {
+  switch (msg.type) {
+    case "INIT":
+      await initialize(msg.initialContent, msg.prewarmLangs ?? [], msg.docPlugins, msg.mdx);
+      return;
+    case "APPEND":
+      await handleAppend(msg.text);
+      return;
+    case "FINALIZE":
+      await finalizeAllBlocks();
+      return;
+    case "DEBUG_STATE": {
+      const blockTypeCounts = {};
+      for (const block of blocks) {
+        const key = block.type ?? "unknown";
+        blockTypeCounts[key] = (blockTypeCounts[key] || 0) + 1;
+      }
+      let lastBlockType;
+      let lastBlockRange;
+      let lastBlockRawTail;
+      const headingTexts = [];
+      const tailBlocks = [];
+      const headBlocks = [];
+      const duplicateBlockIds = [];
+      const seenBlockIds = /* @__PURE__ */ new Set();
+      const headingIndices = {};
+      for (const block of blocks) {
+        if (seenBlockIds.has(block.id)) {
+          if (duplicateBlockIds.length < 8) {
+            duplicateBlockIds.push(block.id);
+          }
+        } else {
+          seenBlockIds.add(block.id);
+        }
+      }
+      if (blocks.length > 0) {
+        const lastBlock = blocks[blocks.length - 1];
+        lastBlockType = lastBlock.type;
+        const range = lastBlock.payload.range;
+        if (range && typeof range.from === "number" && typeof range.to === "number") {
+          lastBlockRange = { from: range.from, to: range.to };
+        }
+        const raw = typeof lastBlock.payload.raw === "string" ? lastBlock.payload.raw : "";
+        lastBlockRawTail = raw ? raw.slice(Math.max(0, raw.length - 240)) : void 0;
+        for (const block of blocks) {
+          if (block.type === "heading" && typeof block.payload.raw === "string") {
+            headingTexts.push(block.payload.raw);
+          }
+        }
+        const targets = ["HTML and MDX Testing", "Inline Code", "Code Blocks", "Media", "Tables", "Footnotes"];
+        for (let i = 0; i < blocks.length; i++) {
+          const block = blocks[i];
+          if (block.type === "heading" && typeof block.payload.raw === "string") {
+            if (targets.includes(block.payload.raw)) {
+              headingIndices[block.payload.raw] = i;
+            }
+          }
+        }
+        const tailStart = Math.max(0, blocks.length - 8);
+        for (let i = tailStart; i < blocks.length; i++) {
+          const block = blocks[i];
+          const raw2 = typeof block.payload.raw === "string" ? block.payload.raw : "";
+          tailBlocks.push({
+            id: block.id,
+            type: block.type,
+            raw: raw2.slice(0, 120)
+          });
+        }
+        const headEnd = Math.min(8, blocks.length);
+        for (let i = 0; i < headEnd; i++) {
+          const block = blocks[i];
+          const raw2 = typeof block.payload.raw === "string" ? block.payload.raw : "";
+          headBlocks.push({
+            id: block.id,
+            type: block.type,
+            raw: raw2.slice(0, 120)
+          });
+        }
+      }
+      const contentTail = currentContent.slice(Math.max(0, currentContent.length - 500));
+      postMessage({
+        type: "DEBUG_STATE",
+        state: {
+          contentLength: currentContent.length,
+          contentTail,
+          blockCount: blocks.length,
+          blockTypeCounts,
+          lastBlockType,
+          lastBlockRange,
+          lastBlockRawTail,
+          headingTexts,
+          headBlocks,
+          tailBlocks,
+          headingIndices,
+          lastDiffSummary,
+          lastStructuralDiffSummary,
+          maxEmittedBlockCount,
+          maxDeferredQueueSize,
+          maxStructuralBlockCount,
+          lastHighCountNoStructural,
+          duplicateBlockIds,
+          duplicateBlockCount: duplicateBlockIds.length,
+          hasInlineCodeHeading: currentContent.includes("# Inline Code"),
+          hasCodeBlocksHeading: currentContent.includes("# Code Blocks"),
+          hasMediaHeading: currentContent.includes("# Media")
+        }
+      });
+      return;
+    }
+    case "DUMP_BLOCKS": {
+      postMessage({
+        type: "DUMP_BLOCKS",
+        blocks,
+        tocHeadings
+      });
+      return;
+    }
+    case "TOKENIZE_RANGE": {
+      const priority = msg.priority === "prefetch" ? "prefetch" : "visible";
+      enqueueLazyTokenization({
+        blockId: msg.blockId,
+        startLine: msg.startLine,
+        endLine: msg.endLine,
+        priority,
+        requestedAt: now()
+      });
+      return;
+    }
+    case "MDX_COMPILED":
+      handleMdxStatus(msg.blockId, {
+        compiledRef: { id: msg.compiledId },
+        status: "compiled"
+      });
+      return;
+    case "MDX_ERROR":
+      handleMdxStatus(msg.blockId, {
+        compiledRef: void 0,
+        status: "error",
+        error: msg.error
+      });
+      return;
+    case "SET_CREDITS":
+      workerCredits = Math.max(0, Math.min(1, Number(msg.credits ?? 0)));
+      if (workerCredits > 0) {
+        flushDeferredPatches();
+      }
+      return;
+    default:
+      console.warn("Unknown message type:", msg);
+  }
+}
+var import_markdown, import_engine_javascript, import_shiki, import_core, import_core2, import_core3, import_patch_batching, import_plugins, highlighter, blocks, lastTree, currentContent, inlineParser, performanceTimer, documentPluginState, txCounter, workerGrammarEngine, workerCredits, lastDiffSummary, lastStructuralDiffSummary, maxEmittedBlockCount, maxDeferredQueueSize, maxStructuralBlockCount, tocHeadings, tocSignature, headingIdCounts, lastHighCountNoStructural, MAX_DEFERRED_PATCHES, deferredPatchQueue, MAX_DEFERRED_FLUSH_PATCHES, CODE_HIGHLIGHT_CACHE, MAX_CODE_HIGHLIGHT_CACHE_ENTRIES, incrementalHighlightStates, lazyTokenizationStates, lazyTokenizationQueue, lazyTokenizationScheduled, lazyTokenizationProcessing, DEFAULT_LAZY_TOKENIZATION_THRESHOLD, MIN_LAZY_TOKENIZATION_THRESHOLD, MAX_LAZY_TOKENIZATION_THRESHOLD, lazyTokenizationEnabled, lazyTokenizationThresholdLines, CODE_HIGHLIGHT_THEMES, mdxCompileMode, formatAnticipationConfig, codeHighlightingMode, highlightOutputMode, emitHighlightTokens, emitDiffBlocks, liveTokenizationEnabled, enableMath, mdxComponentAllowlist, WORKER_MDX_CACHE, WORKER_MDX_INFLIGHT, MAX_WORKER_MDX_CACHE_ENTRIES, loggedMdxSkipCount, MAX_MDX_SKIP_LOGS, MIXED_CONTENT_AUTOCLOSE_NEWLINES, DEFAULT_APPEND_CHUNK_SIZE, DEFAULT_APPEND_BATCH_MS, MIN_APPEND_CHUNK_SIZE, MAX_APPEND_CHUNK_SIZE, MIN_APPEND_BATCH_MS, MAX_APPEND_BATCH_MS, APPEND_NEWLINE_GRACE, APPEND_CHUNK_SIZE, APPEND_BATCH_MS, DEBUG_MDX, sharedTextEncoder, shouldTrackInlineStatus, shouldAllowMixedStreaming, WorkerMetricsCollector, activeMetricsCollector, FONT_STYLE_ITALIC, FONT_STYLE_BOLD, FONT_STYLE_UNDERLINE, FONT_STYLE_STRIKETHROUGH, messageQueue;
+var init_worker = __esm({
+  "src/worker.ts"() {
+    "use strict";
+    init_worker_dom_stub();
+    import_markdown = require("@lezer/markdown");
+    import_engine_javascript = require("@shikijs/engine-javascript");
+    import_shiki = require("shiki");
+    import_core = require("@stream-mdx/core");
+    import_core2 = require("@stream-mdx/core");
+    import_core3 = require("@stream-mdx/core");
+    import_patch_batching = require("@stream-mdx/core/perf/patch-batching");
+    import_plugins = require("@stream-mdx/plugins");
+    init_block_types();
+    init_patch_heuristics();
+    init_lazy_tokenization();
+    init_mdx_compile();
+    highlighter = null;
+    blocks = [];
+    lastTree = null;
+    currentContent = "";
+    documentPluginState = {};
+    txCounter = 0;
+    workerGrammarEngine = "js";
+    workerCredits = 1;
+    lastDiffSummary = null;
+    lastStructuralDiffSummary = null;
+    maxEmittedBlockCount = 0;
+    maxDeferredQueueSize = 0;
+    maxStructuralBlockCount = 0;
+    tocHeadings = [];
+    tocSignature = "";
+    headingIdCounts = /* @__PURE__ */ new Map();
+    lastHighCountNoStructural = null;
+    MAX_DEFERRED_PATCHES = 400;
+    deferredPatchQueue = [];
+    MAX_DEFERRED_FLUSH_PATCHES = 120;
+    CODE_HIGHLIGHT_CACHE = /* @__PURE__ */ new Map();
+    MAX_CODE_HIGHLIGHT_CACHE_ENTRIES = 200;
+    incrementalHighlightStates = /* @__PURE__ */ new Map();
+    lazyTokenizationStates = /* @__PURE__ */ new Map();
+    lazyTokenizationQueue = /* @__PURE__ */ new Map();
+    lazyTokenizationScheduled = false;
+    lazyTokenizationProcessing = false;
+    DEFAULT_LAZY_TOKENIZATION_THRESHOLD = 200;
+    MIN_LAZY_TOKENIZATION_THRESHOLD = 50;
+    MAX_LAZY_TOKENIZATION_THRESHOLD = 1e4;
+    lazyTokenizationEnabled = true;
+    lazyTokenizationThresholdLines = DEFAULT_LAZY_TOKENIZATION_THRESHOLD;
+    CODE_HIGHLIGHT_THEMES = { dark: "github-dark", light: "github-light" };
+    mdxCompileMode = "server";
+    formatAnticipationConfig = (0, import_core.normalizeFormatAnticipation)(false);
+    codeHighlightingMode = "final";
+    highlightOutputMode = "html";
+    emitHighlightTokens = true;
+    emitDiffBlocks = false;
+    liveTokenizationEnabled = true;
+    enableMath = true;
+    mdxComponentAllowlist = null;
+    WORKER_MDX_CACHE = /* @__PURE__ */ new Map();
+    WORKER_MDX_INFLIGHT = /* @__PURE__ */ new Map();
+    MAX_WORKER_MDX_CACHE_ENTRIES = 128;
+    loggedMdxSkipCount = 0;
+    MAX_MDX_SKIP_LOGS = 20;
+    MIXED_CONTENT_AUTOCLOSE_NEWLINES = 2;
+    DEFAULT_APPEND_CHUNK_SIZE = 1400;
+    DEFAULT_APPEND_BATCH_MS = 12;
+    MIN_APPEND_CHUNK_SIZE = 256;
+    MAX_APPEND_CHUNK_SIZE = 12e3;
+    MIN_APPEND_BATCH_MS = 4;
+    MAX_APPEND_BATCH_MS = 50;
+    APPEND_NEWLINE_GRACE = 200;
+    APPEND_CHUNK_SIZE = clampInt(
+      readNumericEnv("NEXT_PUBLIC_STREAMING_APPEND_CHUNK") ?? DEFAULT_APPEND_CHUNK_SIZE,
+      MIN_APPEND_CHUNK_SIZE,
+      MAX_APPEND_CHUNK_SIZE
+    );
+    APPEND_BATCH_MS = clampInt(
+      readNumericEnv("NEXT_PUBLIC_STREAMING_APPEND_BATCH_MS") ?? DEFAULT_APPEND_BATCH_MS,
+      MIN_APPEND_BATCH_MS,
+      MAX_APPEND_BATCH_MS
+    );
+    DEBUG_MDX = isDebugEnabled("mdx");
+    sharedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+    shouldTrackInlineStatus = () => formatAnticipationConfig.inline || formatAnticipationConfig.mathInline || formatAnticipationConfig.mathBlock;
+    shouldAllowMixedStreaming = () => formatAnticipationConfig.html || formatAnticipationConfig.mdx;
+    WorkerMetricsCollector = class {
+      constructor(grammarEngine) {
+        this.parseStart = null;
+        this.diffStart = null;
+        this.serializeStart = null;
+        this.parseMs = 0;
+        this.enrichMs = 0;
+        this.diffMs = 0;
+        this.serializeMs = 0;
+        this.shikiMs = 0;
+        this.mdxDetectMs = 0;
+        this.patchBytes = 0;
+        this.patchCount = 0;
+        this.queueDepth = 0;
+        this.blocksProduced = 0;
+        this.blockTypeCounts = /* @__PURE__ */ new Map();
+        this.blockTypeDurations = /* @__PURE__ */ new Map();
+        this.blockTypeSizes = /* @__PURE__ */ new Map();
+        this.highlightByLanguage = /* @__PURE__ */ new Map();
+        this.appendLineBatchCount = 0;
+        this.appendLineTotalLines = 0;
+        this.appendLineMaxLines = 0;
+        this.lazyTokenizationRequests = 0;
+        this.lazyTokenizationRangeTotal = 0;
+        this.lazyTokenizationRangeMax = 0;
+        this.lazyTokenizationLatencyTotal = 0;
+        this.lazyTokenizationLatencyMax = 0;
+        this.lazyTokenizationMaxQueue = 0;
+        this.grammarEngine = grammarEngine;
+        this.startedAt = now();
+      }
+      markParseStart() {
+        this.parseStart = now();
+      }
+      markParseEnd() {
+        if (this.parseStart === null) return;
+        this.parseMs += Math.max(0, now() - this.parseStart);
+        this.parseStart = null;
+      }
+      recordEnrich(duration) {
+        if (!Number.isFinite(duration ?? Number.NaN)) return;
+        this.enrichMs += Math.max(0, Number(duration));
+      }
+      recordShiki(duration) {
+        if (!Number.isFinite(duration ?? Number.NaN)) return;
+        this.shikiMs += Math.max(0, Number(duration));
+      }
+      recordMdxDetect(duration) {
+        if (!Number.isFinite(duration ?? Number.NaN)) return;
+        this.mdxDetectMs += Math.max(0, Number(duration));
+      }
+      countBlockType(type) {
+        if (!type) return;
+        this.blockTypeCounts.set(type, (this.blockTypeCounts.get(type) ?? 0) + 1);
+      }
+      recordBlockSize(type, size) {
+        if (!type || !Number.isFinite(size ?? Number.NaN)) return;
+        const current = this.blockTypeSizes.get(type) ?? 0;
+        this.blockTypeSizes.set(type, current + Math.max(0, Number(size)));
+      }
+      recordBlockEnrich(type, duration) {
+        if (!type || !Number.isFinite(duration ?? Number.NaN)) return;
+        const previous = this.blockTypeDurations.get(type) ?? 0;
+        this.blockTypeDurations.set(type, previous + Math.max(0, Number(duration)));
+      }
+      recordHighlightForLanguage(lang, duration) {
+        if (!lang || !Number.isFinite(duration ?? Number.NaN)) return;
+        const entry = this.highlightByLanguage.get(lang) ?? { time: 0, count: 0 };
+        entry.time += Math.max(0, Number(duration));
+        entry.count += 1;
+        this.highlightByLanguage.set(lang, entry);
+      }
+      recordAppendLines(lineCount) {
+        if (!Number.isFinite(lineCount ?? Number.NaN)) return;
+        const normalized = Math.max(0, Math.floor(Number(lineCount)));
+        if (normalized <= 0) return;
+        this.appendLineBatchCount += 1;
+        this.appendLineTotalLines += normalized;
+        if (normalized > this.appendLineMaxLines) {
+          this.appendLineMaxLines = normalized;
+        }
+      }
+      recordLazyTokenization(rangeLines, latencyMs, queueDepth) {
+        if (Number.isFinite(rangeLines ?? Number.NaN)) {
+          const normalized = Math.max(0, Math.floor(Number(rangeLines)));
+          this.lazyTokenizationRequests += 1;
+          this.lazyTokenizationRangeTotal += normalized;
+          if (normalized > this.lazyTokenizationRangeMax) {
+            this.lazyTokenizationRangeMax = normalized;
+          }
+        }
+        if (Number.isFinite(latencyMs ?? Number.NaN)) {
+          const normalizedLatency = Math.max(0, Number(latencyMs));
+          this.lazyTokenizationLatencyTotal += normalizedLatency;
+          if (normalizedLatency > this.lazyTokenizationLatencyMax) {
+            this.lazyTokenizationLatencyMax = normalizedLatency;
+          }
+        }
+        if (Number.isFinite(queueDepth ?? Number.NaN)) {
+          const normalizedQueue = Math.max(0, Math.floor(Number(queueDepth)));
+          if (normalizedQueue > this.lazyTokenizationMaxQueue) {
+            this.lazyTokenizationMaxQueue = normalizedQueue;
+          }
+        }
+      }
+      markDiffStart() {
+        this.diffStart = now();
+      }
+      markDiffEnd() {
+        if (this.diffStart === null) return;
+        this.diffMs += Math.max(0, now() - this.diffStart);
+        this.diffStart = null;
+      }
+      beginSerialize() {
+        this.serializeStart = now();
+      }
+      endSerialize() {
+        if (this.serializeStart === null) return;
+        this.serializeMs += Math.max(0, now() - this.serializeStart);
+        this.serializeStart = null;
+      }
+      finalizePatch(tx, patchCount, queueDepth, patchBytes) {
+        this.tx = tx;
+        this.patchCount = patchCount;
+        this.queueDepth = queueDepth;
+        this.patchBytes = patchBytes;
+      }
+      setBlocksProduced(count) {
+        this.blocksProduced = count;
+      }
+      toPatchMetrics(changedBlocks) {
+        return {
+          patchCount: this.patchCount,
+          changedBlocks,
+          diffTime: roundMetric(this.diffMs),
+          parseTime: roundMetric(this.parseMs),
+          enrichTime: this.enrichMs ? roundMetric(this.enrichMs) : void 0,
+          queueDepth: this.queueDepth || void 0,
+          patchBytes: this.patchBytes || void 0,
+          appendLineBatches: this.appendLineBatchCount || void 0,
+          appendLineTotalLines: this.appendLineTotalLines || void 0,
+          appendLineMaxLines: this.appendLineMaxLines || void 0
+        };
+      }
+      toPerformanceMetrics() {
+        return {
+          tx: this.tx,
+          timestamp: this.startedAt,
+          parseMs: roundMetric(this.parseMs),
+          parseTime: roundMetric(this.parseMs),
+          enrichMs: this.enrichMs ? roundMetric(this.enrichMs) : void 0,
+          diffMs: this.diffMs ? roundMetric(this.diffMs) : void 0,
+          serializeMs: this.serializeMs ? roundMetric(this.serializeMs) : void 0,
+          highlightTime: this.shikiMs ? roundMetric(this.shikiMs) : void 0,
+          shikiMs: this.shikiMs ? roundMetric(this.shikiMs) : void 0,
+          mdxDetectMs: this.mdxDetectMs ? roundMetric(this.mdxDetectMs) : void 0,
+          patchBytes: this.patchBytes || void 0,
+          patchCount: this.patchCount || void 0,
+          queueDepth: this.queueDepth || void 0,
+          blocksProduced: this.blocksProduced || void 0,
+          grammarEngine: this.grammarEngine,
+          blockCountByType: mapToNumberRecord(this.blockTypeCounts),
+          blockEnrichMsByType: mapToNumberRecord(this.blockTypeDurations, true),
+          blockSizeByType: mapToNumberRecord(this.blockTypeSizes),
+          highlightByLanguage: mapToHighlightRecord(this.highlightByLanguage),
+          appendLineBatches: this.appendLineBatchCount || void 0,
+          appendLineTotalLines: this.appendLineTotalLines || void 0,
+          appendLineMaxLines: this.appendLineMaxLines || void 0,
+          lazyTokenization: this.lazyTokenizationRequests > 0 ? {
+            requests: this.lazyTokenizationRequests,
+            avgRangeLines: roundMetric(this.lazyTokenizationRangeTotal / this.lazyTokenizationRequests),
+            maxRangeLines: this.lazyTokenizationRangeMax,
+            avgLatencyMs: roundMetric(this.lazyTokenizationLatencyTotal / this.lazyTokenizationRequests),
+            maxLatencyMs: roundMetric(this.lazyTokenizationLatencyMax),
+            maxQueue: this.lazyTokenizationMaxQueue
+          } : void 0
+        };
+      }
+    };
+    activeMetricsCollector = null;
+    FONT_STYLE_ITALIC = 1;
+    FONT_STYLE_BOLD = 2;
+    FONT_STYLE_UNDERLINE = 4;
+    FONT_STYLE_STRIKETHROUGH = 8;
+    messageQueue = Promise.resolve();
+    self.onmessage = (e) => {
+      const msg = e.data;
+      const task = messageQueue.then(async () => {
+        try {
+          await processWorkerMessage(msg);
+        } catch (error) {
+          console.error("Worker error:", error);
+          reportWorkerError(error, msg.type, { phase: msg.type });
+        }
+      }).catch((error) => {
+        console.error("Worker queue error:", error);
+        reportWorkerError(error, msg.type, { phase: msg.type, queue: true });
+      });
+      messageQueue = task;
+      return task;
+    };
+  }
+});
+
+// src/direct.ts
+var direct_exports = {};
+__export(direct_exports, {
+  compileMarkdownSnapshotDirect: () => compileMarkdownSnapshotDirect
+});
+module.exports = __toCommonJS(direct_exports);
+
+// src/direct-compile.ts
+var import_core4 = require("@stream-mdx/core");
+var globalBridge = globalThis;
+var runtimePromise = null;
+var nodeCacheRuntimePromise = null;
+var activeQueue = null;
+var compileChain = Promise.resolve();
+var originalPostMessage;
+function withCompileLock(fn) {
+  let resolveChain;
+  const next = new Promise((resolve) => {
+    resolveChain = resolve;
+  });
+  const previous = compileChain;
+  compileChain = next;
+  return previous.catch(() => void 0).then(async () => {
+    try {
+      return await fn();
+    } finally {
+      resolveChain();
+    }
+  });
+}
+async function ensureWorkerRuntimeLoaded() {
+  if (runtimePromise) return runtimePromise;
+  runtimePromise = (async () => {
+    const scope = globalBridge.self ?? {};
+    globalBridge.self = scope;
+    if (!originalPostMessage && typeof globalBridge.postMessage === "function") {
+      originalPostMessage = globalBridge.postMessage.bind(globalBridge);
+    }
+    globalBridge.postMessage = (message) => {
+      if (activeQueue) {
+        activeQueue.push(message);
+        return;
+      }
+      if (originalPostMessage) {
+        try {
+          originalPostMessage(message);
+        } catch {
+        }
+      }
+    };
+    await Promise.resolve().then(() => (init_worker(), worker_exports));
+    if (typeof scope.onmessage !== "function") {
+      throw new Error("[stream-mdx] direct compile runtime failed to initialize worker onmessage.");
+    }
+    return scope;
+  })();
+  return runtimePromise;
+}
+function isPromiseLike(value) {
+  return Boolean(value && typeof value.then === "function");
+}
+async function dispatchWorkerMessage(scope, message, timeoutMs) {
+  const queue = [];
+  activeQueue = queue;
+  try {
+    const task = scope.onmessage ? scope.onmessage({ data: message }) : void 0;
+    const awaited = isPromiseLike(task) ? task.then(() => void 0) : Promise.resolve();
+    await withTimeout(awaited, timeoutMs, `[stream-mdx] direct compile timed out during ${message.type}`);
+    await waitForQueueSettle(queue);
+    return queue;
+  } finally {
+    activeQueue = null;
+  }
+}
+async function waitForQueueSettle(queue, maxWaitMs = 64) {
+  const start = Date.now();
+  let lastLength = queue.length;
+  let idleTicks = 0;
+  while (Date.now() - start < maxWaitMs) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    if (queue.length === lastLength) {
+      idleTicks += 1;
+    } else {
+      lastLength = queue.length;
+      idleTicks = 0;
+    }
+    if (idleTicks >= 2) return;
+  }
+}
+async function withTimeout(promise, timeoutMs, label) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return await promise;
+  }
+  return await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(label)), timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+function firstWorkerError(messages) {
+  const errorMessage = messages.find((message) => message.type === "ERROR");
+  if (!errorMessage) return null;
+  return `Worker error (${errorMessage.phase}): ${errorMessage.error.message}`;
+}
+function extractPatches(messages) {
+  return messages.filter((message) => message.type === "PATCH");
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    const primitive = JSON.stringify(value);
+    return primitive === void 0 ? "null" : primitive;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+  const body = entries.map(([key, val]) => `${JSON.stringify(key)}:${stableStringify(val)}`).join(",");
+  return `{${body}}`;
+}
+function fallbackHash(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `fnv1a_${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+async function sha256Hex(input) {
+  try {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) return fallbackHash(input);
+    const bytes = new TextEncoder().encode(input);
+    const digest = await subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  } catch {
+    return fallbackHash(input);
+  }
+}
+async function buildHashes(text, init, hashSalt) {
+  const hashPayload = stableStringify({
+    text,
+    init: init ?? null,
+    salt: hashSalt ?? null
+  });
+  const configPayload = stableStringify({
+    init: init ?? null,
+    salt: hashSalt ?? null
+  });
+  const [hash, contentHash, configHash] = await Promise.all([
+    sha256Hex(hashPayload),
+    sha256Hex(text),
+    sha256Hex(configPayload)
+  ]);
+  return { hash, contentHash, configHash };
+}
+async function getNodeCacheRuntime() {
+  if (nodeCacheRuntimePromise) return nodeCacheRuntimePromise;
+  nodeCacheRuntimePromise = (async () => {
+    try {
+      const dynamicImport = new Function("specifier", "return import(specifier);");
+      const fsModule = await dynamicImport("node:fs/promises");
+      const pathModule = await dynamicImport("node:path");
+      const pathApi = pathModule.default ?? pathModule;
+      return {
+        fs: fsModule,
+        path: pathApi
+      };
+    } catch {
+      return null;
+    }
+  })();
+  return nodeCacheRuntimePromise;
+}
+async function resolveCachePath(cache, cacheKey) {
+  if (!cache) return null;
+  const runtime = await getNodeCacheRuntime();
+  if (!runtime) return null;
+  return runtime.path.join(cache.dir, `${sanitizeCacheKey(cacheKey)}.json`);
+}
+async function readSnapshotCache(cachePath, hash) {
+  const runtime = await getNodeCacheRuntime();
+  if (!runtime) return null;
+  try {
+    const raw = await runtime.fs.readFile(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.version !== 1 || parsed.hash !== hash || !Array.isArray(parsed.blocks)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeSnapshotCache(cachePath, artifact) {
+  const runtime = await getNodeCacheRuntime();
+  if (!runtime) return;
+  try {
+    await runtime.fs.mkdir(runtime.path.dirname(cachePath), { recursive: true });
+    await runtime.fs.writeFile(cachePath, JSON.stringify(artifact, null, 2), "utf8");
+  } catch {
+  }
+}
+function sanitizeCacheKey(value) {
+  return value.replace(/[^a-z0-9._-]+/gi, "_");
+}
+async function compileMarkdownSnapshotDirect(options) {
+  return await withCompileLock(async () => {
+    const { text, init, hashSalt, cache, timeoutMs = 3e4, settleMs = 50, finalize = true } = options;
+    const { hash, contentHash, configHash } = await buildHashes(text, init, hashSalt);
+    const cacheKey = cache?.key ?? hash;
+    const cachePath = await resolveCachePath(cache, cacheKey);
+    if (cachePath) {
+      const cached = await readSnapshotCache(cachePath, hash);
+      if (cached) {
+        const snapshot2 = (0, import_core4.createInitialSnapshot)(cached.blocks);
+        return {
+          blocks: snapshot2.blocks,
+          snapshot: snapshot2,
+          artifact: cached,
+          fromCache: true
+        };
+      }
+    }
+    const scope = await ensureWorkerRuntimeLoaded();
+    const initMessages = await dispatchWorkerMessage(
+      scope,
+      {
+        type: "INIT",
+        initialContent: text,
+        prewarmLangs: init?.prewarmLangs,
+        docPlugins: init?.docPlugins,
+        mdx: init?.mdx
+      },
+      timeoutMs
+    );
+    const initError = firstWorkerError(initMessages);
+    if (initError) {
+      throw new Error(initError);
+    }
+    const initialized = initMessages.find((message) => message.type === "INITIALIZED");
+    if (!initialized) {
+      throw new Error("[stream-mdx] direct compile failed: worker did not emit INITIALIZED.");
+    }
+    const snapshot = (0, import_core4.createInitialSnapshot)(initialized.blocks);
+    for (const patch of extractPatches(initMessages)) {
+      snapshot.blocks = (0, import_core4.applyPatchBatch)(snapshot, patch.patches);
+    }
+    if (finalize) {
+      const finalizeMessages = await dispatchWorkerMessage(scope, { type: "FINALIZE" }, timeoutMs);
+      const finalizeError = firstWorkerError(finalizeMessages);
+      if (finalizeError) {
+        throw new Error(finalizeError);
+      }
+      for (const patch of extractPatches(finalizeMessages)) {
+        snapshot.blocks = (0, import_core4.applyPatchBatch)(snapshot, patch.patches);
+      }
+    } else {
+      await new Promise((resolve) => setTimeout(resolve, settleMs));
+    }
+    const artifact = {
+      version: 1,
+      schemaId: "streammdx.snapshot.v1",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      hash,
+      contentHash,
+      configHash,
+      hashSalt: hashSalt ?? void 0,
+      blocks: snapshot.blocks,
+      tocHeadings: (() => {
+        const root = snapshot.nodes.get(import_core4.PATCH_ROOT_ID);
+        const maybe = root?.props?.tocHeadings;
+        return Array.isArray(maybe) ? maybe : void 0;
+      })(),
+      init: init ? {
+        docPlugins: init.docPlugins,
+        mdx: init.mdx,
+        prewarmLangs: init.prewarmLangs
+      } : void 0
+    };
+    if (cachePath && !cache?.readOnly) {
+      await writeSnapshotCache(cachePath, artifact);
+    }
+    return {
+      blocks: snapshot.blocks,
+      snapshot,
+      artifact,
+      fromCache: false
+    };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileMarkdownSnapshotDirect
+});