@ai-react-markdown/engine 2.11.0 → 2.13.0

package/dist/index.js

@@ -172,8 +172,51 @@ var defaultUrlTransform = (value) => {
   return "";
 };
 
-// src/components/incrementalParse/computeFreezeBoundary.ts
-import { htmlBlockNames } from "micromark-util-html-tag-name";
+// src/components/incrementalParse/freezeScanState.ts
+function freshCheckpoint(defListEnabled, mathFlow, referenceTaint) {
+  return {
+    defListEnabled,
+    mathFlow,
+    referenceTaint,
+    confirmedOffset: 0,
+    candidates: [],
+    defs: /* @__PURE__ */ new Map(),
+    footnoteDefs: /* @__PURE__ */ new Map(),
+    unresolvedRefs: [],
+    tagBalance: /* @__PURE__ */ new Map(),
+    openTotal: 0,
+    p5Tok: { kind: "data" },
+    formPointerMaybeSet: false,
+    openStack: [],
+    mdBlock: { kind: "none" },
+    blankRun: 0,
+    lastBlankStart: -1,
+    hazardVerdict: false,
+    prevLineBlank: true,
+    // doc start counts as a block start
+    prevLineWasText: false,
+    prevLineWasValidDef: false,
+    prevLineOpenContent: false,
+    tableMaybeOpen: false,
+    containerMaybeOpen: false,
+    paragraphHasUnpairedRun: false,
+    openBracket: null,
+    p5SealPending: false,
+    defBlockMaybeOpen: false,
+    fnDefResumable: false,
+    phasePoisonedAt: Infinity,
+    pendingTruncatedTags: [],
+    pendingTruncatedCloses: [],
+    pendingTag: null
+  };
+}
+function pendingFenceCloser(checkpoint) {
+  const cp = checkpoint;
+  if (cp.phasePoisonedAt !== Infinity) return "";
+  if (cp.mdBlock.kind === "fence" && cp.mdBlock.indent === 0) return cp.mdBlock.char.repeat(cp.mdBlock.len);
+  if (cp.mdBlock.kind === "math" && cp.mdBlock.indent === 0) return "$".repeat(cp.mdBlock.len);
+  return "";
+}
 
 // src/components/incrementalParse/mdLineText.ts
 var MD_BLANK_RE = /^[ \t\r]*$/;
@@ -181,6 +224,9 @@ var isMdBlank = (text) => MD_BLANK_RE.test(text);
 var mdTrim = (text) => text.replace(/^[ \t\r]+|[ \t\r]+$/g, "");
 var mdTrimStart = (text) => text.replace(/^[ \t\r]+/, "");
 
+// src/components/incrementalParse/freezeLineSyntax.ts
+import { htmlBlockNames } from "micromark-util-html-tag-name";
+
 // src/components/incrementalParse/referenceTaint.ts
 import { normalizeIdentifier } from "micromark-util-normalize-identifier";
 var FOOTNOTE_DEF_RE = /^ {0,3}\[\^[^\]]*\]:/;
@@ -366,7 +412,7 @@ function settleRefsAndEarliestUnresolved(cp) {
   return earliestUnresolved;
 }
 
-// src/components/incrementalParse/computeFreezeBoundary.ts
+// src/components/incrementalParse/freezeLineSyntax.ts
 var TYPE6_NAMES = new Set(htmlBlockNames);
 var TABLE_PART_NAMES = /* @__PURE__ */ new Set(["td", "th", "tr", "tbody", "thead", "tfoot", "caption", "col", "colgroup"]);
 var DOCUMENT_STRUCTURE_NAMES = /* @__PURE__ */ new Set(["html", "head", "body", "frameset"]);
@@ -617,43 +663,6 @@ function maskIntraLineCodeSpans(text, carryOpen) {
   out += text.slice(cursor);
   return { masked: out, unpaired: false };
 }
-function freshCheckpoint(defListEnabled, mathFlow, referenceTaint) {
-  return {
-    defListEnabled,
-    mathFlow,
-    referenceTaint,
-    confirmedOffset: 0,
-    candidates: [],
-    defs: /* @__PURE__ */ new Map(),
-    footnoteDefs: /* @__PURE__ */ new Map(),
-    unresolvedRefs: [],
-    tagBalance: /* @__PURE__ */ new Map(),
-    openTotal: 0,
-    p5Tok: { kind: "data" },
-    formPointerMaybeSet: false,
-    openStack: [],
-    mdBlock: { kind: "none" },
-    blankRun: 0,
-    lastBlankStart: -1,
-    hazardVerdict: false,
-    prevLineBlank: true,
-    // doc start counts as a block start
-    prevLineWasText: false,
-    prevLineWasValidDef: false,
-    prevLineOpenContent: false,
-    tableMaybeOpen: false,
-    containerMaybeOpen: false,
-    paragraphHasUnpairedRun: false,
-    openBracket: null,
-    p5SealPending: false,
-    defBlockMaybeOpen: false,
-    fnDefResumable: false,
-    phasePoisonedAt: Infinity,
-    pendingTruncatedTags: [],
-    pendingTruncatedCloses: [],
-    pendingTag: null
-  };
-}
 function classifyBlockStart(text, indent, defListEnabled) {
   if (indent >= 4) return true;
   if (LIST_MARKER_RE.test(text) || FOOTNOTE_DEF_RE.test(text)) return true;
@@ -661,71 +670,23 @@ function classifyBlockStart(text, indent, defListEnabled) {
   if (indent === 0) return false;
   return null;
 }
-function computeFreezeBoundary(text, options, resume) {
-  const mathFlow = options.mathFlow ?? true;
-  const referenceTaint = options.referenceTaint ?? true;
-  const prev = resume;
-  const cp = prev && prev.defListEnabled === options.defListEnabled && prev.mathFlow === mathFlow && prev.referenceTaint === referenceTaint && prev.confirmedOffset <= text.length ? prev : freshCheckpoint(options.defListEnabled, mathFlow, referenceTaint);
-  let start = cp.confirmedOffset;
-  let tailLine = null;
-  while (start < text.length) {
-    let end = text.length;
-    let textEnd = text.length;
-    {
-      const nl = text.indexOf("\n", start);
-      const cr = text.indexOf("\r", start);
-      if (cr !== -1 && (nl === -1 || cr < nl)) {
-        textEnd = cr;
-        end = text.charCodeAt(cr + 1) === 10 ? cr + 1 : cr;
-      } else if (nl !== -1) {
-        textEnd = nl;
-        end = nl;
-      }
-    }
-    const confirmed = end < text.length && !(end === text.length - 1 && text.charCodeAt(end) === 13);
-    const lineText = text.slice(start, textEnd);
-    const ln = {
-      start,
-      end,
-      text: lineText,
-      blank: confirmed && isMdBlank(lineText),
-      indent: computeIndent(lineText)
-    };
-    if (!confirmed) {
-      tailLine = ln;
-      break;
-    }
-    processConfirmedLine(cp, ln, text);
-    cp.confirmedOffset = end + 1;
-    start = end + 1;
-  }
-  const earliestUnresolved = settleRefsAndEarliestUnresolved(cp);
-  const defListSettled = (c) => {
-    if (!options.defListEnabled || c.blankRun >= 2) return true;
-    if (c.defListSettled !== null) return c.defListSettled;
-    if (tailLine) return !canBecomeDdLine(tailLine.text, false);
-    return false;
-  };
-  const tailRetroactive = tailLine !== null && tailCarriesRetroactive(tailLine.text);
-  let boundary = 0;
-  for (let i = cp.candidates.length - 1; i >= 0 && !tailRetroactive; i--) {
-    const c = cp.candidates[i];
-    if (!c.htmlBalanced || c.hazard || c.seamRisk) continue;
-    if (c.offset > cp.phasePoisonedAt) continue;
-    if (c.offset > earliestUnresolved) continue;
-    if (!defListSettled(c)) continue;
-    boundary = c.offset;
-    break;
-  }
-  return { boundary, checkpoint: cp };
-}
-function pendingFenceCloser(checkpoint) {
-  const cp = checkpoint;
-  if (cp.phasePoisonedAt !== Infinity) return "";
-  if (cp.mdBlock.kind === "fence" && cp.mdBlock.indent === 0) return cp.mdBlock.char.repeat(cp.mdBlock.len);
-  if (cp.mdBlock.kind === "math" && cp.mdBlock.indent === 0) return "$".repeat(cp.mdBlock.len);
-  return "";
-}
+var SCANNER_NAME_LISTS = [
+  ["type1", TYPE1_NAMES],
+  ["rawText", RAW_TEXT_ELEMENTS],
+  ["type6", TYPE6_NAMES],
+  ["void", VOID_TAGS],
+  ["documentStructure", DOCUMENT_STRUCTURE_NAMES],
+  // Added with F28, and it is the list that would have made F28 visible: the
+  // derived census alphabet partitions names by their membership across THIS
+  // table, so before it existed `frame` shared one 39-name class with `div`
+  // and could never be sampled apart from it.
+  ["noElement", NO_ELEMENT_NAMES],
+  ["tablePart", TABLE_PART_NAMES],
+  ["scopeBarrier", SCOPE_BARRIER_NAMES],
+  ["foreignRoot", new Set(FOREIGN_ROOT_NAMES)]
+];
+
+// src/components/incrementalParse/freezeLineTransition.ts
 function floatingResidue(text, commentOpenAtStart) {
   let out = "";
   let open = commentOpenAtStart;
@@ -1369,24 +1330,66 @@ function processConfirmedLine(cp, ln, text) {
     }
   }
 }
-var SCANNER_NAME_LISTS = [
-  ["type1", TYPE1_NAMES],
-  ["rawText", RAW_TEXT_ELEMENTS],
-  ["type6", TYPE6_NAMES],
-  ["void", VOID_TAGS],
-  ["documentStructure", DOCUMENT_STRUCTURE_NAMES],
-  // Added with F28, and it is the list that would have made F28 visible: the
-  // derived census alphabet partitions names by their membership across THIS
-  // table, so before it existed `frame` shared one 39-name class with `div`
-  // and could never be sampled apart from it.
-  ["noElement", NO_ELEMENT_NAMES],
-  ["tablePart", TABLE_PART_NAMES],
-  ["scopeBarrier", SCOPE_BARRIER_NAMES],
-  ["foreignRoot", new Set(FOREIGN_ROOT_NAMES)]
-];
 
-// src/components/incrementalParse/spliceParse.ts
-import { normalizeIdentifier as normalizeIdentifier2 } from "micromark-util-normalize-identifier";
+// src/components/incrementalParse/computeFreezeBoundary.ts
+function computeFreezeBoundary(text, options, resume) {
+  const mathFlow = options.mathFlow ?? true;
+  const referenceTaint = options.referenceTaint ?? true;
+  const prev = resume;
+  const cp = prev && prev.defListEnabled === options.defListEnabled && prev.mathFlow === mathFlow && prev.referenceTaint === referenceTaint && prev.confirmedOffset <= text.length ? prev : freshCheckpoint(options.defListEnabled, mathFlow, referenceTaint);
+  let start = cp.confirmedOffset;
+  let tailLine = null;
+  while (start < text.length) {
+    let end = text.length;
+    let textEnd = text.length;
+    {
+      const nl = text.indexOf("\n", start);
+      const cr = text.indexOf("\r", start);
+      if (cr !== -1 && (nl === -1 || cr < nl)) {
+        textEnd = cr;
+        end = text.charCodeAt(cr + 1) === 10 ? cr + 1 : cr;
+      } else if (nl !== -1) {
+        textEnd = nl;
+        end = nl;
+      }
+    }
+    const confirmed = end < text.length && !(end === text.length - 1 && text.charCodeAt(end) === 13);
+    const lineText = text.slice(start, textEnd);
+    const ln = {
+      start,
+      end,
+      text: lineText,
+      blank: confirmed && isMdBlank(lineText),
+      indent: computeIndent(lineText)
+    };
+    if (!confirmed) {
+      tailLine = ln;
+      break;
+    }
+    processConfirmedLine(cp, ln, text);
+    cp.confirmedOffset = end + 1;
+    start = end + 1;
+  }
+  const earliestUnresolved = settleRefsAndEarliestUnresolved(cp);
+  const defListSettled = (c) => {
+    if (!options.defListEnabled || c.blankRun >= 2) return true;
+    if (c.defListSettled !== null) return c.defListSettled;
+    if (tailLine) return !canBecomeDdLine(tailLine.text, false);
+    return false;
+  };
+  const tailRetroactive = tailLine !== null && tailCarriesRetroactive(tailLine.text);
+  let boundary = 0;
+  for (let i = cp.candidates.length - 1; i >= 0 && !tailRetroactive; i--) {
+    const c = cp.candidates[i];
+    if (!c.htmlBalanced || c.hazard || c.seamRisk) continue;
+    if (c.offset > cp.phasePoisonedAt) continue;
+    if (c.offset > earliestUnresolved) continue;
+    if (!defListSettled(c)) continue;
+    boundary = c.offset;
+    break;
+  }
+  return { boundary, checkpoint: cp };
+}
 
 // src/components/hastPredicates.ts
 function isFootnoteSection(node) {
@@ -1434,121 +1437,7 @@ function attributeHastChildren(mdast, hast, stopAt = Infinity) {
   }
 }
 
-// src/components/incrementalParse/spliceParse.ts
-function collectPrefixInjection(mdast, content, boundary, resume) {
-  const resumeValid = resume != null && resume.boundary <= boundary;
-  if (resumeValid && resume.uninjectable) return { events: resume.events, uninjectable: true };
-  const resumeAt = resumeValid ? resume.boundary : 0;
-  const events = resumeAt > 0 ? cloneEventsForAppend(resume.events) : [];
-  let uninjectable = false;
-  let cacheable = true;
-  const pushRef = (token) => {
-    const last = events[events.length - 1];
-    if (last && last.kind === "refs") last.tokens.push(token);
-    else events.push({ kind: "refs", tokens: [token] });
-  };
-  const visit7 = (node, nested) => {
-    const type = node.type;
-    if (type === "definition") {
-      const start = node.position?.start?.offset;
-      const end = node.position?.end?.offset;
-      if (start !== void 0 && end !== void 0 && start < boundary) {
-        const slice = content.slice(start, end);
-        if (nested && slice.includes("\n")) uninjectable = true;
-        else events.push({ kind: "def", source: slice });
-      }
-      return;
-    }
-    if (type === "footnoteDefinition") {
-      const start = node.position?.start;
-      const end = node.position?.end?.offset;
-      if (start?.offset === void 0 || end === void 0 || start.offset >= boundary) return;
-      if (nested) {
-        uninjectable = true;
-        return;
-      }
-      const lineStart = start.offset - (start.column - 1);
-      events.push({
-        kind: "footnoteDef",
-        source: content.slice(lineStart, end),
-        origStart: lineStart,
-        origLine: start.line
-      });
-      return;
-    }
-    if (type === "footnoteReference") {
-      const start = node.position?.start?.offset;
-      const end = node.position?.end?.offset;
-      if (start === void 0 || end === void 0) {
-        uninjectable = true;
-        return;
-      }
-      pushRef(content.slice(start, end));
-      return;
-    }
-    const children = node.children;
-    if (children) {
-      for (const child of children) visit7(child, true);
-    }
-  };
-  let lastStart = -1;
-  for (const child of mdast.children) {
-    const start = child.position?.start?.offset;
-    if (start !== void 0) {
-      if (start < lastStart) return { events: [], uninjectable: true, cacheable: false };
-      lastStart = start;
-    }
-    if (start === void 0) {
-      if (resumeAt > 0) return collectPrefixInjection(mdast, content, boundary, null);
-      cacheable = false;
-      visit7(child, false);
-      continue;
-    }
-    if (start >= boundary || start < resumeAt) continue;
-    visit7(child, false);
-  }
-  return { events, uninjectable, cacheable };
-}
-function cloneEventsForAppend(events) {
-  const out = events.slice();
-  const last = out[out.length - 1];
-  if (last && last.kind === "refs") out[out.length - 1] = { kind: "refs", tokens: last.tokens.slice() };
-  return out;
-}
-var TERMINATOR_LABEL = "__aimd_injection_terminator__";
-var INJECTION_TERMINATOR = `[${TERMINATOR_LABEL}]: __aimd_sentinel_link__`;
-function tailMentionsTerminator(tailSource) {
-  return normalizeIdentifier2(tailSource).replace(/\[ /g, "[").includes(`[${normalizeIdentifier2(TERMINATOR_LABEL)}`);
-}
-function buildInjectionPrefix(events) {
-  if (events.length === 0) return { text: "", segments: [] };
-  let text = "";
-  let line = 1;
-  const segments = [];
-  for (const event of events) {
-    if (text.length > 0) {
-      text += "\n\n";
-      line += 2;
-    }
-    const injStart = text.length;
-    const source = event.kind === "refs" ? event.tokens.join(" ") : event.source;
-    if (event.kind === "footnoteDef") {
-      segments.push({
-        injStart,
-        injEnd: injStart + source.length,
-        offsetDelta: event.origStart - injStart,
-        lineDelta: event.origLine - line
-      });
-    }
-    text += source;
-    line += countNewlines(source);
-  }
-  return { text: `${text}
-
-${INJECTION_TERMINATOR}
-
-`, segments };
-}
+// src/components/incrementalParse/spliceCoordinates.ts
 function rebaseTree(node, offsetDelta, lineDelta) {
   rebaseTreeDual(node, EMPTY_SEGMENTS, offsetDelta, lineDelta);
 }
@@ -1577,6 +1466,23 @@ function rebaseDualWalk(node, segments, maxEnd, offsetDelta, lineDelta) {
     for (const child of children) rebaseDualWalk(child, segments, maxEnd, offsetDelta, lineDelta);
   }
 }
+function rebasePoint(point, offsetDelta, lineDelta) {
+  return {
+    line: point.line + lineDelta,
+    column: point.column,
+    offset: point.offset !== void 0 ? point.offset + offsetDelta : void 0
+  };
+}
+function countNewlines(text, end = text.length) {
+  let count = 0;
+  for (let i = text.indexOf("\n"); i !== -1 && i < end; i = text.indexOf("\n", i + 1)) count += 1;
+  for (let i = text.indexOf("\r"); i !== -1 && i < end; i = text.indexOf("\r", i + 1)) {
+    if (text.charCodeAt(i + 1) !== 10) count += 1;
+  }
+  return count;
+}
+
+// src/components/incrementalParse/spliceHtmlGuards.ts
 var TABLE_PART_TAG_RE = /<(?:td|th|tr|tbody|thead|tfoot|caption|col|colgroup)\b/i;
 var TABLE_TOKEN_RE = /<(\/?)(table|td|th|tr|tbody|thead|tfoot|caption|col|colgroup)\b/gi;
 function hasStrayTablePart(values) {
@@ -1658,127 +1564,26 @@ function rawTextRegionCrossesOut(values) {
   }
   return false;
 }
-function spliceTrees(input) {
-  const { prevMdast, prevHast, tailMdast, tailHast, content, boundary, injectionPrefix, injectedSegments } = input;
-  const injectedLen = injectionPrefix.length;
-  const injectedLines = countNewlines(injectionPrefix);
-  const prefixLines = countNewlines(content, boundary);
-  const offsetDelta = boundary - injectedLen;
-  const lineDelta = prefixLines - injectedLines;
-  const prefixMdast = [];
-  for (const child of prevMdast.children) {
-    const start = child.position?.start?.offset;
-    if (start !== void 0 && start < boundary) prefixMdast.push(child);
-  }
-  const attrs = attributeHastChildren(prevMdast, prevHast, boundary);
-  const cutRegion = [];
-  for (let i = 0; i < prevHast.children.length; i++) {
-    if (attrs[i] < boundary) {
-      const node2 = prevHast.children[i];
-      const end = node2.position?.end?.offset;
-      if (end !== void 0 && end > boundary) return null;
-      if (isTrailingLiteralText(node2)) {
-        const prev = i > 0 ? prevHast.children[i - 1] : void 0;
-        if (!prev || prev.type !== "element" || prev.position === void 0) return null;
-        if (!ownsTrailingLiteral(prev, node2, prefixMdast))
-          return null;
-      }
-      cutRegion.push(node2);
-      continue;
-    }
-    const node = prevHast.children[i];
-    if (i > 0 && attrs[i - 1] < boundary && prevHast.children[i - 1].type === "element" && isTrailingLiteralText(node) && // …and only when that element really IS an html block's output: a
-    // raw literal can only trail an `html` mdast node. A position-less
-    // text after a `<p>` is the NEXT block's remnant — a stray end tag
-    // (`</t>\na`) parse5 dropped, whose text merged with the wrap
-    // separator — owned by the tail, which re-parses it; freezing it
-    // here duplicated it (v2.4.0 review P3). Falls through to the
-    // remnant look-ahead below, which bails to a full parse. And the
-    // literal must really be THAT block's trailing text: the block's raw
-    // source ends with it. A dropped-tag block right after a frozen html
-    // element (`</details>\n\n</t>\ntext`) puts its remnant in the same
-    // position, and freezing it duplicated it (release soak of the fix).
-    ownsTrailingLiteral(prevHast.children[i - 1], node, prefixMdast)) {
-      cutRegion.push(node);
-      break;
-    }
-    for (let j = i; j < prevHast.children.length; j++) {
-      const look = prevHast.children[j];
-      if (look.type === "element" || look.position !== void 0) break;
-      if (isTrailingLiteralText(look)) return null;
-    }
-    break;
-  }
-  const tailMdastChildren = tailMdast.children.filter((child) => {
-    const start = child.position?.start?.offset;
-    return !(start !== void 0 && start < injectedLen);
-  });
-  const tailWrapVisible = tailMdastChildren.some((child) => !isWrapInvisible(child));
-  const prefixHtmlValues = prefixMdast.flatMap((c) => c.type === "html" ? [c.value] : []);
-  if (hasStrayTablePart(prefixHtmlValues)) return null;
-  if (rawTextRegionCrossesOut(prefixHtmlValues)) return null;
-  const leadingHtml = [];
-  for (const child of tailMdastChildren) {
-    if (isWrapInvisible(child)) continue;
-    if (child.type !== "html") break;
-    if (STRAY_SYNTHESIZED_END_TAG_RE.test(child.value) || TABLE_PART_TAG_RE.test(child.value)) return null;
-    leadingHtml.push(child.value);
+function isSanitizeStrippedConstruct(value) {
+  const v = value.trim();
+  return v.startsWith("<!--") && v.endsWith("-->") || v.startsWith("<?") && v.endsWith("?>") || v.startsWith("<![CDATA[") && v.endsWith("]]>") || /^<![A-Za-z]/.test(v) && !/^<!doctype/i.test(v) && v.endsWith(">");
+}
+function isExactSanitizeStrippedConstruct(value) {
+  if (value.startsWith("<!--")) {
+    if (value.length < 7 || !value.endsWith("-->")) return false;
+    const close = value.indexOf("-->", 4);
+    const bangClose = value.indexOf("--!>", 4);
+    if (close !== value.length - 3) return false;
+    return bangClose === -1 || bangClose > close;
   }
-  if (headRoutedCaptureUnclosed(leadingHtml)) return null;
-  const aligned = alignPrefixCut(prefixMdast, cutRegion, tailWrapVisible);
-  if (aligned === null) return null;
-  const hastChildren = aligned.children;
-  const interiorFinalLiteral = aligned.interiorFinalLiteral;
-  const stripResult = stripInjectedHast(tailMdast, tailHast, injectedLen, tailWrapVisible);
-  if (stripResult === null) return null;
-  const strippedTailHast = stripResult.rest;
-  for (const child of tailMdastChildren) rebaseTree(child, offsetDelta, lineDelta);
-  for (const child of strippedTailHast) rebaseTreeDual(child, injectedSegments, offsetDelta, lineDelta);
-  const mdastChildren = prefixMdast.concat(tailMdastChildren);
-  const seamMergeVerdict = stripResult.remnantMerged ?? tailLeadingTextIsHoist(tailMdastChildren, strippedTailHast);
-  if (seamMergeVerdict === null) return null;
-  const seamMergeAllowed = seamMergeVerdict;
-  let firstTailChild = true;
-  for (const child of strippedTailHast) {
-    const tailEnd = hastChildren[hastChildren.length - 1];
-    if (firstTailChild && child.type === "text" && child.position !== void 0) {
-      return null;
-    }
-    if (firstTailChild && tailEnd && tailEnd.type === "text" && child.type === "text" && child.position === void 0) {
-      if (interiorFinalLiteral && tailEnd.value.trim() !== "") {
-        if (seamMergeAllowed) return null;
-        firstTailChild = false;
-        hastChildren.push(child);
-        continue;
-      }
-      const literalSeam = tailEnd.value.trim() !== "" && !tailWrapVisible;
-      if (seamMergeAllowed || literalSeam) {
-        hastChildren[hastChildren.length - 1] = { type: "text", value: tailEnd.value + child.value };
-        firstTailChild = false;
-        continue;
-      }
-    }
-    firstTailChild = false;
-    hastChildren.push(child);
+  if (/^<!doctype/i.test(value)) return false;
+  if (value.startsWith("<?") || /^<!(?:[A-Za-z]|\[CDATA\[)/.test(value)) {
+    return value.indexOf(">") === value.length - 1;
   }
-  if (!hastChildren.some((child) => child.position !== void 0)) return null;
-  const docStart = { line: 1, column: 1, offset: 0 };
-  const mdastRootPosition = tailMdast.position ? { start: docStart, end: rebasePoint(tailMdast.position.end, offsetDelta, lineDelta) } : prevMdast.position;
-  const hastRootPosition = mdastRootPosition;
-  const mdast = { type: "root", children: mdastChildren };
-  if (mdastRootPosition) mdast.position = mdastRootPosition;
-  const hast = { type: "root", children: hastChildren };
-  if (hastRootPosition) hast.position = hastRootPosition;
-  if (prevHast.data !== void 0) hast.data = prevHast.data;
-  return { mdast, hast };
-}
-function rebasePoint(point, offsetDelta, lineDelta) {
-  return {
-    line: point.line + lineDelta,
-    column: point.column,
-    offset: point.offset !== void 0 ? point.offset + offsetDelta : void 0
-  };
+  return false;
 }
+
+// src/components/incrementalParse/prefixAlignment.ts
 function isWrapInvisible(node) {
   return node.type === "definition" || node.type === "footnoteDefinition";
 }
@@ -1920,96 +1725,303 @@ function stripInjectedHast(tailMdast, tailHast, injectedLen, tailWrapVisible) {
       idx += 1;
       continue;
     }
-    const start = node.position?.start?.offset;
-    if (start === void 0 || start >= injectedLen) return null;
-    consumed += 1;
-    idx += 1;
+    const start = node.position?.start?.offset;
+    if (start === void 0 || start >= injectedLen) return null;
+    consumed += 1;
+    idx += 1;
+  }
+  if (consumed < injectedVisibleCount) return null;
+  let remnant = "";
+  let remnantMerged = null;
+  if (tailWrapVisible) {
+    const gap = children[idx];
+    if (!gap || !isSeparatorText(gap)) return null;
+    remnant = gap.value.slice(1);
+    remnantMerged = remnant !== "";
+    idx += 1;
+  }
+  const rest = children.slice(idx);
+  if (remnant !== "") rest.unshift({ type: "text", value: remnant });
+  return { rest, remnantMerged };
+}
+function tailLeadingTextIsHoist(tailMdastChildren, tailHastChildren) {
+  const firstText = tailHastChildren[0];
+  const firstVisible = tailMdastChildren.find((c) => !isWrapInvisible(c));
+  if (firstVisible?.type === "html" && STRAY_SYNTHESIZED_END_TAG_RE.test(firstVisible.value)) return null;
+  if (!firstText) return false;
+  if (!isSeparatorText(firstText)) {
+    if (firstText.type === "text" && firstText.position === void 0 && firstVisible?.type === "html") {
+      if (/^\s*<\/[A-Za-z][A-Za-z0-9-]*\s*>/.test(firstVisible.value)) return true;
+      if (isSanitizeStrippedConstruct(firstVisible.value)) return false;
+      return null;
+    }
+    return false;
+  }
+  if (!firstVisible) return false;
+  const firstContent = tailHastChildren.find((c) => !isSeparatorText(c));
+  if (firstContent) {
+    const start = firstContent.position?.start?.offset;
+    const vStart = firstVisible.position?.start?.offset;
+    const vEnd = firstVisible.position?.end?.offset;
+    if (start !== void 0 && vStart !== void 0 && vEnd !== void 0) {
+      if (start >= vStart && start < vEnd) return true;
+    }
+  }
+  if (firstVisible.type === "math") return false;
+  if (firstVisible.type === "html" && isSanitizeStrippedConstruct(firstVisible.value)) return false;
+  return null;
+}
+function isSeparatorText(node) {
+  return node.type === "text" && node.position === void 0 && node.value.trim() === "";
+}
+function ownsTrailingLiteral(el, literal, prefixMdast) {
+  const start = el.position?.start?.offset;
+  if (start === void 0) return false;
+  const owner = prefixMdast.find((c) => c.type === "html" && c.position?.start?.offset === start);
+  if (!owner || owner.type !== "html") return false;
+  const text = literal.value.trim();
+  return text !== "" && owner.value.trimEnd().endsWith(text);
+}
+function isTrailingLiteralText(node) {
+  return node.type === "text" && node.position === void 0 && node.value.trim() !== "";
+}
+function countTrailingNewlines(value) {
+  let n = 0;
+  for (let i = value.length - 1; i >= 0 && value[i] === "\n"; i--) n += 1;
+  return n;
+}
+
+// src/components/incrementalParse/prefixInjection.ts
+import { normalizeIdentifier as normalizeIdentifier2 } from "micromark-util-normalize-identifier";
+function collectPrefixInjection(mdast, content, boundary, resume) {
+  const resumeValid = resume != null && resume.boundary <= boundary;
+  if (resumeValid && resume.uninjectable) return { events: resume.events, uninjectable: true };
+  const resumeAt = resumeValid ? resume.boundary : 0;
+  const events = resumeAt > 0 ? cloneEventsForAppend(resume.events) : [];
+  let uninjectable = false;
+  let cacheable = true;
+  const pushRef = (token) => {
+    const last = events[events.length - 1];
+    if (last && last.kind === "refs") last.tokens.push(token);
+    else events.push({ kind: "refs", tokens: [token] });
+  };
+  const visit7 = (node, nested) => {
+    const type = node.type;
+    if (type === "definition") {
+      const start = node.position?.start?.offset;
+      const end = node.position?.end?.offset;
+      if (start !== void 0 && end !== void 0 && start < boundary) {
+        const slice = content.slice(start, end);
+        if (nested && slice.includes("\n")) uninjectable = true;
+        else events.push({ kind: "def", source: slice });
+      }
+      return;
+    }
+    if (type === "footnoteDefinition") {
+      const start = node.position?.start;
+      const end = node.position?.end?.offset;
+      if (start?.offset === void 0 || end === void 0 || start.offset >= boundary) return;
+      if (nested) {
+        uninjectable = true;
+        return;
+      }
+      const lineStart = start.offset - (start.column - 1);
+      events.push({
+        kind: "footnoteDef",
+        source: content.slice(lineStart, end),
+        origStart: lineStart,
+        origLine: start.line
+      });
+      return;
+    }
+    if (type === "footnoteReference") {
+      const start = node.position?.start?.offset;
+      const end = node.position?.end?.offset;
+      if (start === void 0 || end === void 0) {
+        uninjectable = true;
+        return;
+      }
+      pushRef(content.slice(start, end));
+      return;
+    }
+    const children = node.children;
+    if (children) {
+      for (const child of children) visit7(child, true);
+    }
+  };
+  let lastStart = -1;
+  for (const child of mdast.children) {
+    const start = child.position?.start?.offset;
+    if (start !== void 0) {
+      if (start < lastStart) return { events: [], uninjectable: true, cacheable: false };
+      lastStart = start;
+    }
+    if (start === void 0) {
+      if (resumeAt > 0) return collectPrefixInjection(mdast, content, boundary, null);
+      cacheable = false;
+      visit7(child, false);
+      continue;
+    }
+    if (start >= boundary || start < resumeAt) continue;
+    visit7(child, false);
+  }
+  return { events, uninjectable, cacheable };
+}
+function cloneEventsForAppend(events) {
+  const out = events.slice();
+  const last = out[out.length - 1];
+  if (last && last.kind === "refs") out[out.length - 1] = { kind: "refs", tokens: last.tokens.slice() };
+  return out;
+}
+var TERMINATOR_LABEL = "__aimd_injection_terminator__";
+var INJECTION_TERMINATOR = `[${TERMINATOR_LABEL}]: __aimd_sentinel_link__`;
+function tailMentionsTerminator(tailSource) {
+  return normalizeIdentifier2(tailSource).replace(/\[ /g, "[").includes(`[${normalizeIdentifier2(TERMINATOR_LABEL)}`);
+}
+function buildInjectionPrefix(events) {
+  if (events.length === 0) return { text: "", segments: [] };
+  let text = "";
+  let line = 1;
+  const segments = [];
+  for (const event of events) {
+    if (text.length > 0) {
+      text += "\n\n";
+      line += 2;
+    }
+    const injStart = text.length;
+    const source = event.kind === "refs" ? event.tokens.join(" ") : event.source;
+    if (event.kind === "footnoteDef") {
+      segments.push({
+        injStart,
+        injEnd: injStart + source.length,
+        offsetDelta: event.origStart - injStart,
+        lineDelta: event.origLine - line
+      });
+    }
+    text += source;
+    line += countNewlines(source);
+  }
+  return { text: `${text}
+
+${INJECTION_TERMINATOR}
+
+`, segments };
+}
+
+// src/components/incrementalParse/spliceParse.ts
+function spliceTrees(input) {
+  const { prevMdast, prevHast, tailMdast, tailHast, content, boundary, injectionPrefix, injectedSegments } = input;
+  const injectedLen = injectionPrefix.length;
+  const injectedLines = countNewlines(injectionPrefix);
+  const prefixLines = countNewlines(content, boundary);
+  const offsetDelta = boundary - injectedLen;
+  const lineDelta = prefixLines - injectedLines;
+  const prefixMdast = [];
+  for (const child of prevMdast.children) {
+    const start = child.position?.start?.offset;
+    if (start !== void 0 && start < boundary) prefixMdast.push(child);
+  }
+  const attrs = attributeHastChildren(prevMdast, prevHast, boundary);
+  const cutRegion = [];
+  for (let i = 0; i < prevHast.children.length; i++) {
+    if (attrs[i] < boundary) {
+      const node2 = prevHast.children[i];
+      const end = node2.position?.end?.offset;
+      if (end !== void 0 && end > boundary) return null;
+      if (isTrailingLiteralText(node2)) {
+        const prev = i > 0 ? prevHast.children[i - 1] : void 0;
+        if (!prev || prev.type !== "element" || prev.position === void 0) return null;
+        if (!ownsTrailingLiteral(prev, node2, prefixMdast))
+          return null;
+      }
+      cutRegion.push(node2);
+      continue;
+    }
+    const node = prevHast.children[i];
+    if (i > 0 && attrs[i - 1] < boundary && prevHast.children[i - 1].type === "element" && isTrailingLiteralText(node) && // …and only when that element really IS an html block's output: a
+    // raw literal can only trail an `html` mdast node. A position-less
+    // text after a `<p>` is the NEXT block's remnant — a stray end tag
+    // (`</t>\na`) parse5 dropped, whose text merged with the wrap
+    // separator — owned by the tail, which re-parses it; freezing it
+    // here duplicated it (v2.4.0 review P3). Falls through to the
+    // remnant look-ahead below, which bails to a full parse. And the
+    // literal must really be THAT block's trailing text: the block's raw
+    // source ends with it. A dropped-tag block right after a frozen html
+    // element (`</details>\n\n</t>\ntext`) puts its remnant in the same
+    // position, and freezing it duplicated it (release soak of the fix).
+    ownsTrailingLiteral(prevHast.children[i - 1], node, prefixMdast)) {
+      cutRegion.push(node);
+      break;
+    }
+    for (let j = i; j < prevHast.children.length; j++) {
+      const look = prevHast.children[j];
+      if (look.type === "element" || look.position !== void 0) break;
+      if (isTrailingLiteralText(look)) return null;
+    }
+    break;
   }
-  if (consumed < injectedVisibleCount) return null;
-  let remnant = "";
-  let remnantMerged = null;
-  if (tailWrapVisible) {
-    const gap = children[idx];
-    if (!gap || !isSeparatorText(gap)) return null;
-    remnant = gap.value.slice(1);
-    remnantMerged = remnant !== "";
-    idx += 1;
+  const tailMdastChildren = tailMdast.children.filter((child) => {
+    const start = child.position?.start?.offset;
+    return !(start !== void 0 && start < injectedLen);
+  });
+  const tailWrapVisible = tailMdastChildren.some((child) => !isWrapInvisible(child));
+  const prefixHtmlValues = prefixMdast.flatMap((c) => c.type === "html" ? [c.value] : []);
+  if (hasStrayTablePart(prefixHtmlValues)) return null;
+  if (rawTextRegionCrossesOut(prefixHtmlValues)) return null;
+  const leadingHtml = [];
+  for (const child of tailMdastChildren) {
+    if (isWrapInvisible(child)) continue;
+    if (child.type !== "html") break;
+    if (STRAY_SYNTHESIZED_END_TAG_RE.test(child.value) || TABLE_PART_TAG_RE.test(child.value)) return null;
+    leadingHtml.push(child.value);
   }
-  const rest = children.slice(idx);
-  if (remnant !== "") rest.unshift({ type: "text", value: remnant });
-  return { rest, remnantMerged };
-}
-function tailLeadingTextIsHoist(tailMdastChildren, tailHastChildren) {
-  const firstText = tailHastChildren[0];
-  const firstVisible = tailMdastChildren.find((c) => !isWrapInvisible(c));
-  if (firstVisible?.type === "html" && STRAY_SYNTHESIZED_END_TAG_RE.test(firstVisible.value)) return null;
-  if (!firstText) return false;
-  if (!isSeparatorText(firstText)) {
-    if (firstText.type === "text" && firstText.position === void 0 && firstVisible?.type === "html") {
-      if (/^\s*<\/[A-Za-z][A-Za-z0-9-]*\s*>/.test(firstVisible.value)) return true;
-      if (isSanitizeStrippedConstruct(firstVisible.value)) return false;
+  if (headRoutedCaptureUnclosed(leadingHtml)) return null;
+  const aligned = alignPrefixCut(prefixMdast, cutRegion, tailWrapVisible);
+  if (aligned === null) return null;
+  const hastChildren = aligned.children;
+  const interiorFinalLiteral = aligned.interiorFinalLiteral;
+  const stripResult = stripInjectedHast(tailMdast, tailHast, injectedLen, tailWrapVisible);
+  if (stripResult === null) return null;
+  const strippedTailHast = stripResult.rest;
+  for (const child of tailMdastChildren) rebaseTree(child, offsetDelta, lineDelta);
+  for (const child of strippedTailHast) rebaseTreeDual(child, injectedSegments, offsetDelta, lineDelta);
+  const mdastChildren = prefixMdast.concat(tailMdastChildren);
+  const seamMergeVerdict = stripResult.remnantMerged ?? tailLeadingTextIsHoist(tailMdastChildren, strippedTailHast);
+  if (seamMergeVerdict === null) return null;
+  const seamMergeAllowed = seamMergeVerdict;
+  let firstTailChild = true;
+  for (const child of strippedTailHast) {
+    const tailEnd = hastChildren[hastChildren.length - 1];
+    if (firstTailChild && child.type === "text" && child.position !== void 0) {
       return null;
     }
-    return false;
-  }
-  if (!firstVisible) return false;
-  const firstContent = tailHastChildren.find((c) => !isSeparatorText(c));
-  if (firstContent) {
-    const start = firstContent.position?.start?.offset;
-    const vStart = firstVisible.position?.start?.offset;
-    const vEnd = firstVisible.position?.end?.offset;
-    if (start !== void 0 && vStart !== void 0 && vEnd !== void 0) {
-      if (start >= vStart && start < vEnd) return true;
+    if (firstTailChild && tailEnd && tailEnd.type === "text" && child.type === "text" && child.position === void 0) {
+      if (interiorFinalLiteral && tailEnd.value.trim() !== "") {
+        if (seamMergeAllowed) return null;
+        firstTailChild = false;
+        hastChildren.push(child);
+        continue;
+      }
+      const literalSeam = tailEnd.value.trim() !== "" && !tailWrapVisible;
+      if (seamMergeAllowed || literalSeam) {
+        hastChildren[hastChildren.length - 1] = { type: "text", value: tailEnd.value + child.value };
+        firstTailChild = false;
+        continue;
+      }
     }
+    firstTailChild = false;
+    hastChildren.push(child);
   }
-  if (firstVisible.type === "math") return false;
-  if (firstVisible.type === "html" && isSanitizeStrippedConstruct(firstVisible.value)) return false;
-  return null;
-}
-function isSanitizeStrippedConstruct(value) {
-  const v = value.trim();
-  return v.startsWith("<!--") && v.endsWith("-->") || v.startsWith("<?") && v.endsWith("?>") || v.startsWith("<![CDATA[") && v.endsWith("]]>") || /^<![A-Za-z]/.test(v) && !/^<!doctype/i.test(v) && v.endsWith(">");
-}
-function isExactSanitizeStrippedConstruct(value) {
-  if (value.startsWith("<!--")) {
-    if (value.length < 7 || !value.endsWith("-->")) return false;
-    const close = value.indexOf("-->", 4);
-    const bangClose = value.indexOf("--!>", 4);
-    if (close !== value.length - 3) return false;
-    return bangClose === -1 || bangClose > close;
-  }
-  if (/^<!doctype/i.test(value)) return false;
-  if (value.startsWith("<?") || /^<!(?:[A-Za-z]|\[CDATA\[)/.test(value)) {
-    return value.indexOf(">") === value.length - 1;
-  }
-  return false;
-}
-function isSeparatorText(node) {
-  return node.type === "text" && node.position === void 0 && node.value.trim() === "";
-}
-function ownsTrailingLiteral(el, literal, prefixMdast) {
-  const start = el.position?.start?.offset;
-  if (start === void 0) return false;
-  const owner = prefixMdast.find((c) => c.type === "html" && c.position?.start?.offset === start);
-  if (!owner || owner.type !== "html") return false;
-  const text = literal.value.trim();
-  return text !== "" && owner.value.trimEnd().endsWith(text);
-}
-function isTrailingLiteralText(node) {
-  return node.type === "text" && node.position === void 0 && node.value.trim() !== "";
-}
-function countTrailingNewlines(value) {
-  let n = 0;
-  for (let i = value.length - 1; i >= 0 && value[i] === "\n"; i--) n += 1;
-  return n;
-}
-function countNewlines(text, end = text.length) {
-  let count = 0;
-  for (let i = text.indexOf("\n"); i !== -1 && i < end; i = text.indexOf("\n", i + 1)) count += 1;
-  for (let i = text.indexOf("\r"); i !== -1 && i < end; i = text.indexOf("\r", i + 1)) {
-    if (text.charCodeAt(i + 1) !== 10) count += 1;
-  }
-  return count;
+  if (!hastChildren.some((child) => child.position !== void 0)) return null;
+  const docStart = { line: 1, column: 1, offset: 0 };
+  const mdastRootPosition = tailMdast.position ? { start: docStart, end: rebasePoint(tailMdast.position.end, offsetDelta, lineDelta) } : prevMdast.position;
+  const hastRootPosition = mdastRootPosition;
+  const mdast = { type: "root", children: mdastChildren };
+  if (mdastRootPosition) mdast.position = mdastRootPosition;
+  const hast = { type: "root", children: hastChildren };
+  if (hastRootPosition) hast.position = hastRootPosition;
+  if (prevHast.data !== void 0) hast.data = prevHast.data;
+  return { mdast, hast };
 }
 
 // src/components/incrementalParse/advanceIncrementalParse.ts
@@ -2131,6 +2143,38 @@ function normalizeForMatch(s) {
   return normalizeIdentifier3(s);
 }
 
+// src/components/blankLineScanner.ts
+function createBlankLineScanner() {
+  let end = 0;
+  let newline = false;
+  let cr = false;
+  return (source, from = 0) => {
+    if (from === 0) {
+      end = 0;
+      newline = false;
+      cr = false;
+    }
+    for (let i = from; i < source.length; i++) {
+      const c = source[i];
+      if (c === "\n") {
+        if (newline) {
+          end = i + 1;
+          newline = false;
+        } else newline = true;
+        cr = false;
+      } else if (newline) {
+        if ((c === " " || c === "	") && !cr) continue;
+        if (c === "\r" && !cr) cr = true;
+        else {
+          newline = false;
+          cr = false;
+        }
+      }
+    }
+    return end;
+  };
+}
+
 // src/components/collectDefLabels.ts
 var SCANNER_BOUNDARY_PROFILE = { defListEnabled: false, mathFlow: false, referenceTaint: false };
 function buildProcessor() {
@@ -2162,19 +2206,12 @@ var setsEqual = (a, b) => {
   for (const v of a) if (!b.has(v)) return false;
   return true;
 };
-var BLANK_LINE_RE = /\r?\n[ \t]*\r?\n/g;
-function lastRegionStart(source) {
-  BLANK_LINE_RE.lastIndex = 0;
-  let start = 0;
-  for (let m = BLANK_LINE_RE.exec(source); m !== null; m = BLANK_LINE_RE.exec(source)) {
-    start = m.index + m[0].length;
-  }
-  return start;
-}
 var DEF_LINE_START_RE = /^[ \t>*+\d.)-]*\[(?:[^\]\\]|\\[\s\S])*\]:/m;
 function createDefLabelScanner(parse = collectDefLabels) {
   let prevSource = null;
   let prevLabels = null;
+  const scanBlankLines = createBlankLineScanner();
+  let regionStart = 0;
   let frozenEnd = 0;
   let frozenFootnotes = /* @__PURE__ */ new Set();
   let frozenLinks = /* @__PURE__ */ new Set();
@@ -2187,13 +2224,16 @@ function createDefLabelScanner(parse = collectDefLabels) {
   };
   return {
     scan(source) {
+      if (source === prevSource && prevLabels !== null) return prevLabels;
+      const previousRegionStart = regionStart;
+      const appended = prevSource !== null && source.startsWith(prevSource);
+      regionStart = scanBlankLines(source, appended ? prevSource.length : 0);
       let isAppend = false;
       if (prevSource !== null && prevLabels !== null) {
         if (source === prevSource) return prevLabels;
         if (source.startsWith(prevSource)) {
           isAppend = true;
-          const regionStart = lastRegionStart(prevSource);
-          const region = prevSource.slice(regionStart) + source.slice(prevSource.length);
+          const region = source.slice(previousRegionStart);
           if (!DEF_LINE_START_RE.test(region)) {
             prevSource = source;
             return prevLabels;
@@ -2426,8 +2466,115 @@ function* extractContributions(mdast, options = {}) {
   for (const c of out) yield c;
 }
 
+// src/components/registryIndex.ts
+function buildRegistryIndex(registry) {
+  const index = {
+    footnotes: /* @__PURE__ */ new Map(),
+    links: /* @__PURE__ */ new Map(),
+    numbers: /* @__PURE__ */ new Map(),
+    counts: /* @__PURE__ */ new Map(),
+    occurrences: /* @__PURE__ */ new Map(),
+    labelOccurrences: /* @__PURE__ */ new Map()
+  };
+  for (const sym of registry.chunkOrder) {
+    const data = registry.chunkData.get(sym);
+    if (!data) continue;
+    for (const label of data.defs.keys()) if (!index.footnotes.has(label)) index.footnotes.set(label, sym);
+    for (const label of data.linkDefs.keys()) if (!index.links.has(label)) index.links.set(label, sym);
+    const local = /* @__PURE__ */ new Map();
+    index.occurrences.set(sym, local);
+    for (const ref of data.refs) {
+      if (ref.kind !== "footnote") continue;
+      const label = ref.label;
+      if (!index.numbers.has(label)) index.numbers.set(label, index.numbers.size + 1);
+      const total = (index.counts.get(label) ?? 0) + 1;
+      index.counts.set(label, total);
+      const prior = local.get(label);
+      if (prior) prior.count++;
+      else {
+        const range = { start: total, count: 1 };
+        local.set(label, range);
+        let byChunk = index.labelOccurrences.get(label);
+        if (!byChunk) index.labelOccurrences.set(label, byChunk = /* @__PURE__ */ new Map());
+        byChunk.set(sym, range);
+      }
+    }
+  }
+  return index;
+}
+
+// src/components/registrySubscriptions.ts
+function equal(a, b) {
+  if (a.owner !== b.owner || a.url !== b.url || a.title !== b.title || a.number !== b.number || a.count !== b.count)
+    return false;
+  if (a.occurrences?.size !== b.occurrences?.size) return false;
+  if (a.occurrences) {
+    for (const [chunk, range] of a.occurrences) {
+      const next = b.occurrences?.get(chunk);
+      if (!next || next.start !== range.start || next.count !== range.count) return false;
+    }
+  }
+  return true;
+}
+function createRegistrySubscriptions(read) {
+  const groups = { link: /* @__PURE__ */ new Map(), footnote: /* @__PURE__ */ new Map() };
+  const snapshot = (kind, label, { registry, index }) => {
+    if (kind === "link") {
+      const owner = index.links.get(label);
+      const def = owner ? registry.chunkData.get(owner)?.linkDefs.get(label) : void 0;
+      return { owner, url: def?.url, title: def?.title };
+    }
+    return {
+      owner: index.footnotes.get(label),
+      number: index.numbers.get(label),
+      count: index.counts.get(label),
+      occurrences: index.labelOccurrences.get(label)
+    };
+  };
+  return {
+    subscribe(kind, rawLabel, cb) {
+      const label = normalizeId(rawLabel);
+      const map = groups[kind];
+      let group = map.get(label);
+      if (!group) {
+        group = { snapshot: snapshot(kind, label, read()), listeners: /* @__PURE__ */ new Set() };
+        map.set(label, group);
+      }
+      const listener = () => cb();
+      group.listeners.add(listener);
+      return () => {
+        group.listeners.delete(listener);
+        if (group.listeners.size === 0 && map.get(label) === group) map.delete(label);
+      };
+    },
+    collect() {
+      if (groups.link.size === 0 && groups.footnote.size === 0) return [];
+      const state = read();
+      const callbacks = [];
+      for (const kind of ["link", "footnote"]) {
+        for (const [label, group] of groups[kind]) {
+          const next = snapshot(kind, label, state);
+          if (!equal(group.snapshot, next)) callbacks.push(...group.listeners);
+          group.snapshot = next;
+        }
+      }
+      return callbacks;
+    }
+  };
+}
+
 // src/components/documentRegistry.ts
 function createRegistry(onEmpty) {
+  let index;
+  let indexedVersion = -1;
+  const getIndex = () => {
+    if (!index || indexedVersion !== reg.version) {
+      index = buildRegistryIndex(reg);
+      indexedVersion = reg.version;
+    }
+    return index;
+  };
+  const labels = createRegistrySubscriptions(() => ({ registry: reg, index: getIndex() }));
   const reg = {
     chunkOrder: [],
     chunkData: /* @__PURE__ */ new Map(),
@@ -2578,73 +2725,29 @@ function createRegistry(onEmpty) {
         this._subscribers.delete(cb);
       };
     },
+    subscribeLabel(kind, label, cb) {
+      return labels.subscribe(kind, label, cb);
+    },
     canonicalFootnoteFor(label) {
-      const id = normalizeId(label);
-      for (const sym of this.chunkOrder) {
-        const data = this.chunkData.get(sym);
-        if (data?.defs.has(id)) return sym;
-      }
-      return null;
+      return getIndex().footnotes.get(normalizeId(label)) ?? null;
     },
     canonicalLinkFor(label) {
-      const id = normalizeId(label);
-      for (const sym of this.chunkOrder) {
-        const data = this.chunkData.get(sym);
-        if (data?.linkDefs.has(id)) return sym;
-      }
-      return null;
+      return getIndex().links.get(normalizeId(label)) ?? null;
     },
     globalNumber(label) {
-      const id = normalizeId(label);
-      let n = 0;
-      const seen = /* @__PURE__ */ new Set();
-      for (const sym of this.chunkOrder) {
-        const data = this.chunkData.get(sym);
-        if (!data) continue;
-        for (const ref of data.refs) {
-          if (ref.kind !== "footnote") continue;
-          if (!seen.has(ref.label)) {
-            seen.add(ref.label);
-            n++;
-            if (ref.label === id) return n;
-          }
-        }
-      }
-      return null;
+      return getIndex().numbers.get(normalizeId(label)) ?? null;
     },
     resolveLinkDef(label) {
-      const sym = this.canonicalLinkFor(label);
-      if (!sym) return null;
-      return this.chunkData.get(sym)?.linkDefs.get(normalizeId(label)) ?? null;
+      const id = normalizeId(label);
+      const sym = getIndex().links.get(id);
+      return sym ? this.chunkData.get(sym)?.linkDefs.get(id) ?? null : null;
     },
     getRefsForLabel(label) {
-      const id = normalizeId(label);
-      let n = 0;
-      for (const sym of this.chunkOrder) {
-        const data = this.chunkData.get(sym);
-        if (!data) continue;
-        for (const ref of data.refs) {
-          if (ref.kind === "footnote" && ref.label === id) n++;
-        }
-      }
-      return n;
+      return getIndex().counts.get(normalizeId(label)) ?? 0;
     },
     globalOccurrenceForRef(chunkSym, label, localOccurrence) {
-      const id = normalizeId(label);
-      let global2 = 0;
-      for (const sym of this.chunkOrder) {
-        const data = this.chunkData.get(sym);
-        if (!data) continue;
-        let localCount = 0;
-        for (const ref of data.refs) {
-          if (ref.kind !== "footnote") continue;
-          if (ref.label !== id) continue;
-          localCount++;
-          global2++;
-          if (sym === chunkSym && localCount === localOccurrence) return global2;
-        }
-      }
-      return null;
+      const range = getIndex().occurrences.get(chunkSym)?.get(normalizeId(label));
+      return range && Number.isInteger(localOccurrence) && localOccurrence > 0 && localOccurrence <= range.count ? range.start + localOccurrence - 1 : null;
     },
     _notify() {
       this.version++;
@@ -2652,7 +2755,9 @@ function createRegistry(onEmpty) {
       this._notifyScheduled = true;
       queueMicrotask(() => {
         this._notifyScheduled = false;
+        const labelCallbacks = labels.collect();
         for (const cb of [...this._subscribers]) cb();
+        for (const cb of labelCallbacks) cb();
       });
     }
   };
@@ -2709,7 +2814,7 @@ var ENGINE_PLACEHOLDER_TAGS = /* @__PURE__ */ new Set([
   "cross-chunk-image"
 ]);
 var ENGINE_PROVENANCE_PROPERTY = "engineProvenance";
-function walk(parent, provenance) {
+function walk(parent, provenance, ancestors) {
   const children = parent.children;
   let i = 0;
   while (i < children.length) {
@@ -2720,21 +2825,32 @@ function walk(parent, provenance) {
       const genuine = provenance !== "" && typeof stamped === "string" && stamped === provenance;
       if (genuine) {
         delete props[ENGINE_PROVENANCE_PROPERTY];
-        walk(node, provenance);
+        if (ancestors && (node.tagName === "cross-chunk-link" || node.tagName === "cross-chunk-image")) {
+          (node.data ??= {}).referenceAncestors = ancestors.slice();
+        }
+        ancestors?.push(
+          node.tagName === "cross-chunk-link" ? "a" : node.tagName === "cross-chunk-image" ? "img" : node.tagName
+        );
+        walk(node, provenance, ancestors);
+        ancestors?.pop();
         i += 1;
       } else {
         children.splice(i, 1, ...node.children);
       }
       continue;
     }
-    if (node.type === "element") walk(node, provenance);
+    if (node.type === "element") {
+      ancestors?.push(node.tagName);
+      walk(node, provenance, ancestors);
+      ancestors?.pop();
+    }
     i += 1;
   }
 }
 function rehypeVerifyEngineTags(options) {
   const provenance = options?.provenance ?? "";
   return function transformer(tree) {
-    walk(tree, provenance);
+    walk(tree, provenance, options?.referenceAncestors ? [] : void 0);
   };
 }
 
@@ -2755,16 +2871,18 @@ import remarkRemoveComments from "remark-remove-comments";
 // src/components/rehypeRebaseHashLinks.ts
 import { visit as visit5 } from "unist-util-visit";
 var DEFAULT_PREFIX = "user-content-";
+function rebaseHashHref(href, prefix) {
+  const hashPrefix = "#" + prefix;
+  return href.startsWith("#") && !href.startsWith(hashPrefix) ? hashPrefix + href.slice(1) : href;
+}
 var rehypeRebaseHashLinks = (options) => {
   const prefix = options?.prefix ?? DEFAULT_PREFIX;
-  const hashPrefix = "#" + prefix;
   return (tree) => {
     visit5(tree, "element", (node) => {
       if (node.tagName !== "a") return;
       const href = node.properties?.href;
       if (typeof href !== "string" || !href.startsWith("#")) return;
-      if (href.startsWith(hashPrefix)) return;
-      node.properties.href = hashPrefix + href.slice(1);
+      node.properties.href = rebaseHashHref(href, prefix);
     });
   };
 };
@@ -2850,7 +2968,15 @@ function buildCoreRehypePlugins(sanitizeSchema2, clobberPrefix, options) {
     [rehypeRaw, { passThrough: [] }],
     // Unwrap forged engine placeholders BEFORE sanitize admits their tag
     // names. Only when the caller holds a credential (see the option's doc).
-    ...options ? [[rehypeVerifyEngineTags, { provenance: options.provenance }]] : [],
+    ...options ? [
+      [
+        rehypeVerifyEngineTags,
+        {
+          provenance: options.provenance,
+          ...sanitizeSchema2.ancestors?.a || sanitizeSchema2.ancestors?.img ? { referenceAncestors: true } : {}
+        }
+      ]
+    ] : [],
     // Sanitize HTML while allowing <mark> (highlight), KaTeX class names,
     // and any extra protocols the caller permitted via the `sanitizeSchema`
     // prop. Override `clobberPrefix` with the instance-scoped value — the
@@ -2924,11 +3050,9 @@ function buildCrossChunkHandlers() {
         type: "element",
         tagName: "cross-chunk-link",
         properties: {
-          // `label` is the ORIGINAL source text (mdast's `label` field), NOT
-          // the normalized `identifier`. The placeholder uses it to construct
-          // hrefs that line up with mdast-util-to-hast's default `<li id>`
-          // which also preserves source case. Registry lookups normalize
-          // internally, so cross-chunk case-insensitive matching still works.
+          // Display labels decode escapes; registry identifiers must retain
+          // those bytes. Never use the display label as the lookup key.
+          identifier: node.identifier,
           label: node.label ?? node.identifier,
           referenceType: node.referenceType,
           documentId: s.options.documentId,
@@ -2947,6 +3071,7 @@ function buildCrossChunkHandlers() {
         type: "element",
         tagName: "cross-chunk-image",
         properties: {
+          identifier: node.identifier,
           label: node.label ?? node.identifier,
           referenceType: node.referenceType,
           alt: node.alt ?? "",
@@ -4209,8 +4334,8 @@ var sanitizeSchema = deepFreeze(
     attributes: {
       ...defaultSchema.attributes,
       code: mergeClassNameAllowlist(defaultSchema.attributes?.code, ["math-inline", "math-display"]),
-      "cross-chunk-link": ["label", "referenceType", "documentId", "localUrl", "localTitle"],
-      "cross-chunk-image": ["label", "referenceType", "documentId", "alt", "localUrl", "localTitle"],
+      "cross-chunk-link": ["identifier", "label", "referenceType", "documentId", "localUrl", "localTitle"],
+      "cross-chunk-image": ["identifier", "label", "referenceType", "documentId", "alt", "localUrl", "localTitle"],
       "footnote-sup": ["label", "localOccurrence", "localNumber", "documentId"]
     },
     strip: [.../* @__PURE__ */ new Set([...defaultSchema.strip || [], ...STRIPPED_TAGS])]
@@ -4246,6 +4371,49 @@ function sanitizeCrossChunkUrl(rawUrl, key, tagName, urlTransform, schema) {
   return String(transformed);
 }
 
+// src/components/resolveCrossChunkReference.ts
+import rehypeSanitize2 from "rehype-sanitize";
+import { normalizeUri as normalizeUri3 } from "micromark-util-sanitize-uri";
+function resolveCrossChunkReference(input, schema, urlTransform, clobberPrefix) {
+  const key = input.tagName === "a" ? "href" : "src";
+  const element = {
+    type: "element",
+    tagName: input.tagName,
+    properties: {
+      [key]: normalizeUri3(input.url),
+      ...input.tagName === "img" ? { alt: input.alt ?? "" } : {},
+      ...input.title !== void 0 ? { title: input.title } : {}
+    },
+    children: input.tagName === "a" ? [{ type: "text", value: "__reference_children__" }] : []
+  };
+  const requiredAncestors = schema.ancestors?.[input.tagName];
+  const recordedAncestors = input.node?.data?.referenceAncestors;
+  let finalSchema = schema;
+  if (requiredAncestors && Array.isArray(recordedAncestors) && requiredAncestors.some((tag) => recordedAncestors.includes(tag))) {
+    const ancestors = { ...schema.ancestors };
+    delete ancestors[input.tagName];
+    finalSchema = { ...schema, ancestors };
+  }
+  const root2 = rehypeSanitize2({ ...finalSchema, clobberPrefix })({ type: "root", children: [element] });
+  const node = root2.children[0];
+  if (node?.type !== "element") return { element: null, keepChildren: node?.type === "text" };
+  if (node.tagName === "a" && typeof node.properties.href === "string") {
+    node.properties.href = rebaseHashHref(node.properties.href, clobberPrefix);
+  }
+  node.children = input.node?.children ?? [];
+  if (input.node?.position) node.position = input.node.position;
+  buildTransform({
+    allowedElements: void 0,
+    disallowedElements: void 0,
+    allowElement: void 0,
+    skipHtml: void 0,
+    unwrapDisallowed: void 0,
+    urlTransform
+  })(node, 0, root2);
+  node.children = [];
+  return { element: node, keepChildren: false };
+}
+
 // src/plugins/defs.ts
 function getEnginePluginInternals(plugin) {
   const candidate = plugin;
@@ -4450,6 +4618,8 @@ var createSmoothStreamController = (options = {}) => {
   let source = "";
   let visibleEnd = 0;
   let pending = [];
+  let pendingHead = 0;
+  const pendingCount = () => pending.length - pendingHead;
   let tentativeEnd = 0;
   let finished = false;
   let seam;
@@ -4494,7 +4664,7 @@ var createSmoothStreamController = (options = {}) => {
     cancelFrame = void 0;
   };
   const ensureScheduled = () => {
-    if (disposed || cancelFrame || pending.length === 0) return;
+    if (disposed || cancelFrame || pendingCount() === 0) return;
     lastTickAt = now();
     credit = 0;
     cancelFrame = schedule(tick);
@@ -4508,31 +4678,38 @@ var createSmoothStreamController = (options = {}) => {
     const params = resolveParams();
     let rate;
     if (finished && drainDeadlineAt !== void 0) {
-      rate = Math.max(params.minCharsPerSecond, pending.length * 1e3 / Math.max(1, drainDeadlineAt - t));
+      rate = Math.max(params.minCharsPerSecond, pendingCount() * 1e3 / Math.max(1, drainDeadlineAt - t));
     } else if (gapWindow.length > 0 && lastArrivalAt !== void 0) {
       const gaps = gapWindow.map((s) => s.gap).sort((a, b) => a - b);
       const intervalQ = gaps[Math.min(gaps.length - 1, Math.floor(gaps.length * INTERVAL_QUANTILE))];
       const horizon = Math.max(16, Math.min(params.bufferFactor * intervalQ + HORIZON_PAD_MS, params.maxLagMs));
       const deadline = Math.max(lastArrivalAt + horizon, t + DEADLINE_FLOOR_MS);
-      rate = Math.max(params.minCharsPerSecond, pending.length * 1e3 / Math.max(1, deadline - t));
+      rate = Math.max(params.minCharsPerSecond, pendingCount() * 1e3 / Math.max(1, deadline - t));
     } else {
-      rate = Math.max(params.minCharsPerSecond, pending.length * 1e3 / Math.max(1, params.correctionTauMs));
+      rate = Math.max(params.minCharsPerSecond, pendingCount() * 1e3 / Math.max(1, params.correctionTauMs));
     }
     credit += rate * dt / 1e3;
-    const reveal = Math.min(Math.floor(credit), pending.length);
+    const reveal = Math.min(Math.floor(credit), pendingCount());
     if (reveal > 0) {
-      visibleEnd = pending[reveal - 1];
-      pending = pending.slice(reveal);
-      credit = pending.length > 0 ? credit - reveal : 0;
+      visibleEnd = pending[pendingHead + reveal - 1];
+      pendingHead += reveal;
+      if (pendingHead === pending.length) {
+        pending = [];
+        pendingHead = 0;
+      } else if (pendingHead >= 1024 && pendingHead * 2 >= pending.length) {
+        pending = pending.slice(pendingHead);
+        pendingHead = 0;
+      }
+      credit = pendingCount() > 0 ? credit - reveal : 0;
       notify();
     }
-    if (!disposed && !cancelFrame && pending.length > 0) cancelFrame = schedule(tick);
+    if (!disposed && !cancelFrame && pendingCount() > 0) cancelFrame = schedule(tick);
   };
   const resegmentTail = () => {
-    if (seam !== void 0 && seam < source.length && pending[pending.length - 1] === seam) {
+    if (pendingCount() > 0 && seam !== void 0 && seam < source.length && pending[pending.length - 1] === seam) {
       pending.pop();
     }
-    const from = pending.length > 0 ? pending[pending.length - 1] : visibleEnd;
+    const from = pendingCount() > 0 ? pending[pending.length - 1] : visibleEnd;
     let anchor = from;
     if (seam !== void 0 && from <= seam) {
       anchor = Math.max(0, from - RESUME_LOOKBACK);
@@ -4566,6 +4743,7 @@ var createSmoothStreamController = (options = {}) => {
     visibleEnd = next.length;
     tentativeEnd = next.length;
     pending = [];
+    pendingHead = 0;
     seam = next.length;
     credit = 0;
     cancelScheduled();
@@ -4597,7 +4775,7 @@ var createSmoothStreamController = (options = {}) => {
       if (finished) return;
       finished = true;
       lastArrivalAt = void 0;
-      if (tentativeEnd > (pending.length > 0 ? pending[pending.length - 1] : visibleEnd)) {
+      if (tentativeEnd > (pendingCount() > 0 ? pending[pending.length - 1] : visibleEnd)) {
         pending.push(tentativeEnd);
       }
       const params = resolveParams();
@@ -4623,10 +4801,11 @@ var createSmoothStreamController = (options = {}) => {
     snap,
     flush() {
       disposed = false;
-      const target = finished ? source.length : pending.length > 0 ? pending[pending.length - 1] : visibleEnd;
+      const target = finished ? source.length : pendingCount() > 0 ? pending[pending.length - 1] : visibleEnd;
       if (target <= visibleEnd) return;
       visibleEnd = target;
       pending = [];
+      pendingHead = 0;
       credit = 0;
       cancelScheduled();
       notify();
@@ -5476,6 +5655,7 @@ export {
   rehypeRebaseHashLinks_default as rehypeRebaseHashLinks,
   rehypeVerifyEngineTags,
   removeComments,
+  resolveCrossChunkReference,
   sanitizeCrossChunkUrl,
   sanitizeSchema,
   shortenDocumentId,