@ai-react-markdown/core 1.3.0 → 1.4.0

package/dist/index.js

@@ -1,7 +1,7 @@
 "use client";
 
 // src/index.tsx
-import { useMemo as useMemo4, memo as memo3, useId as useId2 } from "react";
+import { useMemo as useMemo6, memo as memo4, useId as useId3 } from "react";
 
 // src/context.tsx
 import { createContext, useContext, useId, useMemo } from "react";
@@ -129,8 +129,8 @@ var root = freeGlobal_default || freeSelf || Function("return this")();
 var root_default = root;
 
 // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Symbol.js
-var Symbol = root_default.Symbol;
-var Symbol_default = Symbol;
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
 
 // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getRawTag.js
 var objectProto = Object.prototype;
@@ -1067,7 +1067,8 @@ var defaultAIMarkdownRenderConfig = Object.freeze({
     "SMARTYPANTS" /* SMARTYPANTS */,
     "PANGU" /* PANGU */
   ]),
-  blockMemoEnabled: true
+  blockMemoEnabled: true,
+  preserveOrphanReferences: true
 });
 
 // src/context.tsx
@@ -1119,6 +1120,13 @@ var AIMarkdownRenderStateProvider = ({
       variant,
       colorScheme,
       documentId: resolvedDocumentId,
+      // URI-fragment safe per-document prefix derived once here so downstream
+      // consumers (MarkdownContent, cross-chunk placeholder components) read
+      // from one canonical source. `encodeURIComponent` runs at the prefix
+      // construction site, not at the documentId storage site, so consumers
+      // accessing `documentId` directly still see the raw React-native value
+      // (e.g. `useId()`'s `_r_0_`) while id="..."/href="#..." bytes are safe.
+      clobberPrefix: `${encodeURIComponent(resolvedDocumentId)}-user-content-`,
       config: mergedConfig
     }),
     [streaming, fontSize, variant, colorScheme, resolvedDocumentId, mergedConfig]
@@ -1439,7 +1447,7 @@ function preprocessAIMDContent(content, extraPreprocessors = defaultExtraPreproc
 }
 
 // src/components/MarkdownContent.tsx
-import { Fragment as Fragment2, memo, useMemo as useMemo2, useRef } from "react";
+import { Fragment as Fragment3, memo as memo2, useCallback as useCallback2, useEffect, useId as useId2, useMemo as useMemo4, useRef as useRef2, useState, useSyncExternalStore as useSyncExternalStore2 } from "react";
 
 // src/components/markdown/Markdown.tsx
 import { unreachable as unreachable2 } from "devlop";
@@ -1585,10 +1593,10 @@ function validateOptions(options) {
 }
 function parseStage(options) {
   validateOptions(options);
-  const processor = createProcessor(options);
+  const processor2 = createProcessor(options);
   const file = createFile(options);
-  const mdast = processor.parse(file);
-  return { processor, file, mdast };
+  const mdast = processor2.parse(file);
+  return { processor: processor2, file, mdast };
 }
 function transformStage(parsed) {
   return parsed.processor.runSync(parsed.mdast, parsed.file);
@@ -1644,12 +1652,16 @@ function mergeClassNameAllowlist(existing, extraClassNames) {
   entries[idx] = merged;
   return entries;
 }
+var crossChunkTags = ["cross-chunk-link", "cross-chunk-image", "footnote-sup"];
 var sanitizeSchema = {
   ...defaultSchema,
-  tagNames: [...defaultSchema.tagNames || [], "mark"],
+  tagNames: [...defaultSchema.tagNames || [], "mark", ...crossChunkTags],
   attributes: {
     ...defaultSchema.attributes,
-    code: mergeClassNameAllowlist(defaultSchema.attributes?.code, ["math-inline", "math-display"])
+    code: mergeClassNameAllowlist(defaultSchema.attributes?.code, ["math-inline", "math-display"]),
+    "cross-chunk-link": ["label", "referenceType", "documentId"],
+    "cross-chunk-image": ["label", "referenceType", "documentId", "alt"],
+    "footnote-sup": ["label", "localOccurrence", "documentId"]
   }
 };
 
@@ -1671,12 +1683,51 @@ var rehypeRebaseHashLinks = (options) => {
 };
 var rehypeRebaseHashLinks_default = rehypeRebaseHashLinks;
 
+// src/components/rehypeFooterAdorn.ts
+import { visit as visit3 } from "unist-util-visit";
+var FOOTNOTE_LABEL_ID_RE = /(?:^|-)footnote-label$/;
+function isFootnoteLabelH2(node) {
+  if (node.type !== "element") return false;
+  const el = node;
+  if (el.tagName !== "h2") return false;
+  const id = el.properties?.id;
+  return typeof id === "string" && FOOTNOTE_LABEL_ID_RE.test(id);
+}
+function isHr(node) {
+  if (node.type !== "element") return false;
+  return node.tagName === "hr";
+}
+function rehypeFooterAdorn() {
+  return (tree) => {
+    visit3(tree, "element", (n) => {
+      const el = n;
+      if (el.tagName !== "section") return;
+      if (!(el.properties && "dataFootnotes" in el.properties)) return;
+      const filtered = el.children.filter((c) => !isFootnoteLabelH2(c));
+      if (!filtered.some(isHr)) {
+        const hr = {
+          type: "element",
+          tagName: "hr",
+          properties: {},
+          children: []
+        };
+        filtered.unshift(hr);
+      }
+      el.children = filtered;
+      if (!el.properties) el.properties = {};
+      if (!("ariaLabel" in el.properties)) {
+        el.properties.ariaLabel = "Footnotes";
+      }
+    });
+  };
+}
+
 // src/components/MarkdownContent.tsx
 import remarkBreaks from "remark-breaks";
 import remarkCjkFriendly from "remark-cjk-friendly";
 import remarkCjkFriendlyGfmStrikethrough from "remark-cjk-friendly-gfm-strikethrough";
 import remarkEmoji from "remark-emoji";
-import remarkGfm from "remark-gfm";
+import remarkGfm2 from "remark-gfm";
 import remarkMath from "remark-math";
 import { remarkDefinitionList, defListHastHandlers } from "remark-definition-list";
 import { remarkMark as remarkMarkHighlight } from "remark-mark-highlight";
@@ -1686,7 +1737,17 @@ import remarkPangu from "remark-pangu";
 import remarkRemoveComments from "remark-remove-comments";
 
 // src/components/blockMemo.ts
-import { visit as visit3 } from "unist-util-visit";
+import { visit as visit4 } from "unist-util-visit";
+
+// src/components/normalizeId.ts
+function normalizeId(s) {
+  return s.replace(/\s+/g, " ").toUpperCase();
+}
+function normalizeForMatch(s) {
+  return s.replace(/\\(.)/g, "$1").replace(/\s+/g, " ").toUpperCase();
+}
+
+// src/components/blockMemo.ts
 var TAINT_TYPES = /* @__PURE__ */ new Set([
   "footnoteReference",
   "footnoteDefinition",
@@ -1713,14 +1774,41 @@ function hasMdastSource(node) {
 var FOOTNOTE_SECTION_KEY = "__footnote_section__";
 function buildBlocks(mdast, hast, source) {
   const mdastByOffset = /* @__PURE__ */ new Map();
+  const mdastRanges = [];
   for (const child of mdast.children) {
     const off = child.position?.start.offset;
+    const endOff = child.position?.end.offset;
     if (off !== void 0) {
       mdastByOffset.set(off, child);
     }
+    if (off !== void 0 && endOff !== void 0) {
+      mdastRanges.push({ start: off, end: endOff, node: child });
+    }
+  }
+  if (process.env.NODE_ENV !== "production") {
+    for (let i = 1; i < mdastRanges.length; i++) {
+      if (mdastRanges[i].start < mdastRanges[i - 1].start) {
+        throw new Error(
+          "block-memo: mdast.children not sorted by source offset \u2014 a remark plugin is reordering top-level children."
+        );
+      }
+    }
+  }
+  function findContainingMdast(offset) {
+    let lo = 0;
+    let hi = mdastRanges.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (mdastRanges[mid].start <= offset) lo = mid + 1;
+      else hi = mid;
+    }
+    const idx = lo - 1;
+    if (idx < 0) return void 0;
+    const r = mdastRanges[idx];
+    return offset < r.end ? r.node : void 0;
   }
   const ctxParts = [];
-  visit3(mdast, (n) => {
+  visit4(mdast, (n) => {
     if (!CTX_TYPES.has(n.type)) return;
     if (n.type === "footnoteReference") ctxParts.push(["fr", n.identifier]);
     else if (n.type === "footnoteDefinition") ctxParts.push(["fd", n.identifier, extractRaw(n, source)]);
@@ -1754,11 +1842,7 @@ function buildBlocks(mdast, hast, source) {
     }
     let mdastNode = mdastByOffset.get(hastOffset);
     if (!mdastNode) {
-      mdastNode = mdast.children.findLast((child) => {
-        const startOff = child.position?.start.offset;
-        const endOff = child.position?.end.offset;
-        return startOff !== void 0 && endOff !== void 0 && startOff <= hastOffset && hastOffset < endOff;
-      });
+      mdastNode = findContainingMdast(hastOffset);
     }
     if (!mdastNode) {
       if (process.env.NODE_ENV !== "production") {
@@ -1774,12 +1858,19 @@ function buildBlocks(mdast, hast, source) {
       continue;
     }
     let hasReference = false;
-    visit3(mdastNode, (n) => {
-      if (TAINT_TYPES.has(n.type)) {
-        hasReference = true;
-        return false;
-      }
-      return void 0;
+    const footnoteRefLabels = [];
+    const linkRefLabels = [];
+    const imageRefLabels = [];
+    const footnoteDefLabels = [];
+    visit4(mdastNode, (n) => {
+      if (!TAINT_TYPES.has(n.type)) return;
+      hasReference = true;
+      const id = "identifier" in n ? normalizeId(String(n.identifier)) : null;
+      if (id === null) return;
+      if (n.type === "footnoteReference") footnoteRefLabels.push(id);
+      else if (n.type === "linkReference") linkRefLabels.push(id);
+      else if (n.type === "imageReference") imageRefLabels.push(id);
+      else if (n.type === "footnoteDefinition") footnoteDefLabels.push(id);
     });
     const mdastPos = mdastNode.position;
     if (!mdastPos || mdastPos.start.offset === void 0 || mdastPos.end.offset === void 0) {
@@ -1791,7 +1882,10 @@ function buildBlocks(mdast, hast, source) {
       endOffset: mdastPos.end.offset,
       startLine: mdastPos.start.line,
       startColumn: mdastPos.start.column,
-      hasReference
+      hasReference,
+      ...hasReference ? {
+        taintLabels: { footnoteRefLabels, linkRefLabels, imageRefLabels, footnoteDefLabels }
+      } : {}
     };
     blocks.push(info);
     blockHasts.push(el);
@@ -1799,6 +1893,25 @@ function buildBlocks(mdast, hast, source) {
   }
   return { plan, globalCtx, blocks, blockHasts, synthetic };
 }
+function computeBlockFingerprint(taintLabels, registry, thisChunkSym, clobberPrefix) {
+  const parts = [clobberPrefix];
+  for (const label of taintLabels.footnoteRefLabels) {
+    parts.push(`fn:${label}=${registry.globalNumber(label) ?? "null"}`);
+  }
+  for (const label of taintLabels.linkRefLabels) {
+    const def = registry.resolveLinkDef(label);
+    parts.push(`lr:${label}=${def?.url ?? "null"}|${def?.title ?? ""}`);
+  }
+  for (const label of taintLabels.imageRefLabels) {
+    const def = registry.resolveLinkDef(label);
+    parts.push(`ir:${label}=${def?.url ?? "null"}|${def?.title ?? ""}`);
+  }
+  for (const label of taintLabels.footnoteDefLabels) {
+    const isCanonical = registry.canonicalFootnoteFor(label) === thisChunkSym ? 1 : 0;
+    parts.push(`fd:${label}=${isCanonical}/${registry.getRefsForLabel(label)}`);
+  }
+  return parts.join("|");
+}
 function renderBlocksWithCache(cacheRef, plan, globalCtx, postOptions) {
   const prev = cacheRef.current;
   const next = { blocks: /* @__PURE__ */ new Map() };
@@ -1821,10 +1934,18 @@ function renderBlocksWithCache(cacheRef, plan, globalCtx, postOptions) {
       continue;
     }
     if (item.kind === "synthetic") {
+      if (postOptions.registry && postOptions.thisChunkSymbol) {
+        continue;
+      }
       const cached = prev.footnoteSection;
-      const node2 = cached && cached.ctx === globalCtx ? cached.node : renderHastSubtree(item.el, postOptions);
-      next.footnoteSection = { ctx: globalCtx, node: node2 };
-      rendered.push({ node: node2, reactKey: item.reactKey });
+      let node;
+      if (cached && cached.ctx === globalCtx) {
+        node = cached.node;
+      } else {
+        node = renderHastSubtree(item.el, postOptions);
+      }
+      next.footnoteSection = { ctx: globalCtx, node };
+      rendered.push({ node, reactKey: item.reactKey });
       continue;
     }
     const block = item.info;
@@ -1834,25 +1955,832 @@ function renderBlocksWithCache(cacheRef, plan, globalCtx, postOptions) {
       next.blocks.set(block.raw, bucket);
     }
     const occ = bucket.length;
-    const blockCtx = block.hasReference ? globalCtx : "";
-    const entry = prev.blocks.get(block.raw)?.[occ];
-    const valid = entry !== void 0 && entry.ctx === blockCtx && entry.startOffset === block.startOffset && entry.startLine === block.startLine && entry.startColumn === block.startColumn;
-    const node = valid ? entry.node : renderHastSubtree(item.el, postOptions);
-    bucket.push({
-      node,
-      ctx: blockCtx,
-      startOffset: block.startOffset,
-      startLine: block.startLine,
-      startColumn: block.startColumn
-    });
-    rendered.push({ node, reactKey: item.reactKey });
+    if (block.hasReference) {
+      const useFingerprint = postOptions.registry && block.taintLabels && postOptions.thisChunkSymbol && postOptions.clobberPrefix !== void 0;
+      const blockCtx = useFingerprint ? computeBlockFingerprint(
+        block.taintLabels,
+        postOptions.registry,
+        postOptions.thisChunkSymbol,
+        postOptions.clobberPrefix
+      ) : globalCtx;
+      const entry = prev.blocks.get(block.raw)?.[occ];
+      const valid = entry !== void 0 && entry.ctx === blockCtx && entry.startOffset === block.startOffset && entry.startLine === block.startLine && entry.startColumn === block.startColumn;
+      let node;
+      if (valid) {
+        node = entry.node;
+      } else {
+        node = renderHastSubtree(item.el, postOptions);
+      }
+      bucket.push({
+        node,
+        ctx: blockCtx,
+        startOffset: block.startOffset,
+        startLine: block.startLine,
+        startColumn: block.startColumn
+      });
+      rendered.push({ node, reactKey: item.reactKey });
+      continue;
+    }
+    {
+      const entry = prev.blocks.get(block.raw)?.[occ];
+      const valid = entry !== void 0 && entry.ctx === "" && entry.startOffset === block.startOffset && entry.startLine === block.startLine && entry.startColumn === block.startColumn;
+      const node = valid ? entry.node : renderHastSubtree(item.el, postOptions);
+      bucket.push({
+        node,
+        ctx: "",
+        startOffset: block.startOffset,
+        startLine: block.startLine,
+        startColumn: block.startColumn
+      });
+      rendered.push({ node, reactKey: item.reactKey });
+    }
   }
   cacheRef.current = next;
   return rendered;
 }
 
+// src/components/collectDefLabels.ts
+import { unified as unified2 } from "unified";
+import remarkParse2 from "remark-parse";
+import remarkGfm from "remark-gfm";
+import { visit as visit5 } from "unist-util-visit";
+function buildProcessor() {
+  return unified2().use(remarkParse2).use(remarkGfm);
+}
+var _processor = null;
+function processor() {
+  if (!_processor) _processor = buildProcessor();
+  return _processor;
+}
+function collectDefLabels(source) {
+  if (!source) {
+    return { footnoteLabels: /* @__PURE__ */ new Set(), linkLabels: /* @__PURE__ */ new Set() };
+  }
+  const mdast = processor().parse(source);
+  const footnoteLabels = /* @__PURE__ */ new Set();
+  const linkLabels = /* @__PURE__ */ new Set();
+  visit5(mdast, (node) => {
+    if (node.type === "footnoteDefinition" && "identifier" in node) {
+      footnoteLabels.add(normalizeId(node.identifier));
+    } else if (node.type === "definition" && "identifier" in node) {
+      linkLabels.add(normalizeId(node.identifier));
+    }
+  });
+  return { footnoteLabels, linkLabels };
+}
+
+// src/components/AIMarkdownDocuments.tsx
+import { createContext as createContext2, useContext as useContext2, useMemo as useMemo2, useRef } from "react";
+
+// src/components/documentRegistry.ts
+function createRegistry(onEmpty) {
+  const reg = {
+    chunkOrder: [],
+    chunkData: /* @__PURE__ */ new Map(),
+    labelSet: { footnoteLabels: /* @__PURE__ */ new Set(), linkLabels: /* @__PURE__ */ new Set() },
+    version: 0,
+    _reactIdMap: /* @__PURE__ */ new Map(),
+    _subscribers: /* @__PURE__ */ new Set(),
+    _notifyScheduled: false,
+    allocateSymbol(reactId) {
+      const existing = this._reactIdMap.get(reactId);
+      if (existing) {
+        existing.refcount++;
+        return existing.symbol;
+      }
+      const sym = Symbol(reactId);
+      this._reactIdMap.set(reactId, { symbol: sym, refcount: 1 });
+      this.chunkOrder.push(sym);
+      this._notify();
+      return sym;
+    },
+    registerChunk(reactId, footnotes, links) {
+      const sym = this.allocateSymbol(reactId);
+      this.contributeLabels(sym, footnotes, links);
+      return sym;
+    },
+    releaseSymbol(reactId) {
+      const entry = this._reactIdMap.get(reactId);
+      if (!entry) return;
+      entry.refcount--;
+      if (entry.refcount === 0) {
+        queueMicrotask(() => {
+          const latest = this._reactIdMap.get(reactId);
+          if (latest && latest.refcount === 0) {
+            this._reactIdMap.delete(reactId);
+            const idx = this.chunkOrder.indexOf(entry.symbol);
+            if (idx !== -1) this.chunkOrder.splice(idx, 1);
+            this.chunkData.delete(entry.symbol);
+            const nextFn = /* @__PURE__ */ new Set();
+            const nextLink = /* @__PURE__ */ new Set();
+            for (const cd of this.chunkData.values()) {
+              for (const l of cd.ownFootnoteLabels) nextFn.add(l);
+              for (const l of cd.ownLinkLabels) nextLink.add(l);
+            }
+            this.labelSet.footnoteLabels = nextFn;
+            this.labelSet.linkLabels = nextLink;
+            this._notify();
+            if (this.chunkOrder.length === 0 && this.chunkData.size === 0 && onEmpty) {
+              onEmpty();
+            }
+          }
+        });
+      }
+    },
+    contributeLabels(symbol, footnotes, links) {
+      const data = this.chunkData.get(symbol);
+      if (data) {
+        data.ownFootnoteLabels = footnotes;
+        data.ownLinkLabels = links;
+      } else {
+        this.chunkData.set(symbol, {
+          refs: [],
+          defs: /* @__PURE__ */ new Map(),
+          linkDefs: /* @__PURE__ */ new Map(),
+          ownFootnoteLabels: footnotes,
+          ownLinkLabels: links
+        });
+      }
+      const newFn = /* @__PURE__ */ new Set();
+      const newLink = /* @__PURE__ */ new Set();
+      for (const cd of this.chunkData.values()) {
+        for (const l of cd.ownFootnoteLabels) newFn.add(l);
+        for (const l of cd.ownLinkLabels) newLink.add(l);
+      }
+      this.labelSet.footnoteLabels = newFn;
+      this.labelSet.linkLabels = newLink;
+      this._notify();
+    },
+    contributeChunkData(symbol, data) {
+      this.chunkData.set(symbol, data);
+      this.labelSet.footnoteLabels = /* @__PURE__ */ new Set();
+      this.labelSet.linkLabels = /* @__PURE__ */ new Set();
+      for (const cd of this.chunkData.values()) {
+        for (const l of cd.ownFootnoteLabels) this.labelSet.footnoteLabels.add(l);
+        for (const l of cd.ownLinkLabels) this.labelSet.linkLabels.add(l);
+      }
+      this._notify();
+    },
+    subscribe(cb) {
+      this._subscribers.add(cb);
+      return () => {
+        this._subscribers.delete(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;
+    },
+    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;
+    },
+    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;
+    },
+    resolveLinkDef(label) {
+      const sym = this.canonicalLinkFor(label);
+      if (!sym) return null;
+      return this.chunkData.get(sym)?.linkDefs.get(normalizeId(label)) ?? 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;
+    },
+    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;
+    },
+    _notify() {
+      this.version++;
+      if (this._notifyScheduled) return;
+      this._notifyScheduled = true;
+      queueMicrotask(() => {
+        this._notifyScheduled = false;
+        for (const cb of [...this._subscribers]) cb();
+      });
+    }
+  };
+  return reg;
+}
+
+// src/components/AIMarkdownDocuments.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var AIMarkdownDocumentsContext = createContext2(null);
+var AIMarkdownDocuments = ({ preserveOrphanReferences = true, children }) => {
+  const parent = useContext2(AIMarkdownDocumentsContext);
+  if (parent !== null) {
+    throw new Error(
+      "<AIMarkdownDocuments> must not be nested inside another <AIMarkdownDocuments>. Use a single top-level wrapper per coordinated scope."
+    );
+  }
+  const registriesRef = useRef(/* @__PURE__ */ new Map());
+  const value = useMemo2(
+    () => ({
+      preserveOrphanReferences,
+      getRegistry(documentId) {
+        let r = registriesRef.current.get(documentId);
+        if (!r) {
+          const created = createRegistry(() => {
+            if (registriesRef.current.get(documentId) === created) {
+              registriesRef.current.delete(documentId);
+            }
+          });
+          r = created;
+          registriesRef.current.set(documentId, r);
+        }
+        return r;
+      }
+    }),
+    [preserveOrphanReferences]
+  );
+  return /* @__PURE__ */ jsx3(AIMarkdownDocumentsContext.Provider, { value, children });
+};
+function useDocumentRegistry(documentId) {
+  const ctx = useContext2(AIMarkdownDocumentsContext);
+  if (!ctx || !documentId) return null;
+  return ctx.getRegistry(documentId);
+}
+function usePreserveOrphanReferences(fallback) {
+  const ctx = useContext2(AIMarkdownDocumentsContext);
+  return ctx?.preserveOrphanReferences ?? fallback;
+}
+
+// src/components/remarkInjectPhantomDefs.ts
+var SENTINEL_LINK_URL = "__aimd_sentinel_link__";
+var SENTINEL_FN_CONTENT = "__aimd_sentinel_fn__";
+function augmentSourceWithPhantoms(source, phantoms) {
+  if (phantoms.missingFootnotes.size === 0 && phantoms.missingLinks.size === 0) {
+    return source;
+  }
+  let suffix = "\n\n";
+  for (const label of phantoms.missingLinks) {
+    suffix += `[${label}]: ${SENTINEL_LINK_URL}
+`;
+  }
+  for (const label of phantoms.missingFootnotes) {
+    suffix += `[^${label}]: ${SENTINEL_FN_CONTENT}
+`;
+  }
+  return source + suffix;
+}
+
+// src/components/customMdastHandlers.ts
+function buildCrossChunkHandlers() {
+  return {
+    footnoteDefinition: (state, node) => {
+      const s = state;
+      const id = normalizeId(node.identifier);
+      if (s.options.phantomFootnoteLabels.has(id)) {
+        return void 0;
+      }
+      if (s.options.preserveOrphan && !s.footnoteOrder.includes(id)) {
+        s.footnoteOrder.push(id);
+      }
+      return void 0;
+    },
+    linkReference: ((state, node) => {
+      const s = state;
+      const id = normalizeId(node.identifier);
+      const resolved = s.definitionById.has(id);
+      if (!resolved) {
+        return void 0;
+      }
+      return {
+        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.
+          label: node.label ?? node.identifier,
+          referenceType: node.referenceType,
+          documentId: s.options.documentId
+        },
+        children: s.all(node)
+      };
+    }),
+    imageReference: ((state, node) => {
+      const s = state;
+      const id = normalizeId(node.identifier);
+      const resolved = s.definitionById.has(id);
+      if (!resolved) return void 0;
+      return {
+        type: "element",
+        tagName: "cross-chunk-image",
+        properties: {
+          label: node.label ?? node.identifier,
+          referenceType: node.referenceType,
+          alt: node.alt ?? "",
+          documentId: s.options.documentId
+        },
+        children: []
+      };
+    }),
+    footnoteReference: ((state, node) => {
+      const s = state;
+      const id = normalizeId(node.identifier);
+      const localOccurrence = (s.footnoteCounts.get(id) ?? 0) + 1;
+      s.footnoteCounts.set(id, localOccurrence);
+      if (s.options.phantomFootnoteLabels.has(id)) {
+        return {
+          type: "element",
+          tagName: "footnote-sup",
+          properties: {
+            label: node.identifier,
+            localOccurrence,
+            documentId: s.options.documentId
+          },
+          children: []
+        };
+      }
+      if (!s.footnoteOrder.includes(id)) s.footnoteOrder.push(id);
+      return {
+        type: "element",
+        tagName: "footnote-sup",
+        properties: {
+          label: node.identifier,
+          localOccurrence,
+          documentId: s.options.documentId
+        },
+        children: []
+      };
+    })
+  };
+}
+
+// src/components/crossChunkPlaceholders.tsx
+import { isValidElement, useCallback, useContext as useContext3, useSyncExternalStore } from "react";
+
+// src/components/chunkSymbolContext.ts
+import { createContext as createContext3 } from "react";
+var ChunkSymbolContext = createContext3(null);
+
+// src/components/crossChunkPlaceholders.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var SSR_NUM_SNAPSHOT = () => 0;
+var SSR_DEF_SNAPSHOT = () => null;
+function coerceLocalOccurrence(v) {
+  if (v === void 0) return null;
+  if (typeof v === "number") return Number.isFinite(v) && v >= 1 ? Math.trunc(v) : null;
+  const n = Number(v);
+  return Number.isFinite(n) && n >= 1 ? Math.trunc(n) : null;
+}
+function FootnoteSupNumber({ label, localOccurrence: localOccurrenceRaw }) {
+  const localOccurrence = coerceLocalOccurrence(localOccurrenceRaw);
+  const { documentId, clobberPrefix } = useAIMarkdownRenderState();
+  const registry = useDocumentRegistry(documentId);
+  const chunkSym = useContext3(ChunkSymbolContext);
+  const subscribe = useCallback((cb) => registry ? registry.subscribe(cb) : () => {
+  }, [registry]);
+  const getSnapshot = useCallback(() => registry?.version ?? 0, [registry]);
+  useSyncExternalStore(subscribe, getSnapshot, SSR_NUM_SNAPSHOT);
+  const num = registry?.globalNumber(label) ?? null;
+  if (num === null) return null;
+  if (localOccurrence !== null && !chunkSym) return null;
+  const globalOcc = registry && chunkSym && localOccurrence !== null ? registry.globalOccurrenceForRef(chunkSym, label, localOccurrence) : null;
+  if (localOccurrence !== null && globalOcc === null) return null;
+  const occSuffix = globalOcc !== null && globalOcc > 1 ? `-${globalOcc}` : "";
+  return /* @__PURE__ */ jsx4("sup", { children: /* @__PURE__ */ jsx4("a", { href: `#${clobberPrefix}fn-${label}`, id: `${clobberPrefix}fnref-${label}${occSuffix}`, "data-footnote-ref": true, children: num }) });
+}
+function reactNodeToText(node) {
+  if (node === null || node === void 0 || typeof node === "boolean") return "";
+  if (typeof node === "string") return node;
+  if (typeof node === "number" || typeof node === "bigint") return String(node);
+  if (Array.isArray(node)) return node.map(reactNodeToText).join("");
+  if (isValidElement(node)) {
+    return reactNodeToText(node.props.children);
+  }
+  return "";
+}
+function literalLink(rt, label, children) {
+  const text = reactNodeToText(children);
+  switch (rt) {
+    case "full":
+      return `[${text}][${label}]`;
+    case "collapsed":
+      return `[${label}][]`;
+    case "shortcut":
+    default:
+      return `[${label}]`;
+  }
+}
+function CrossChunkLink({ label, referenceType, children }) {
+  const { documentId } = useAIMarkdownRenderState();
+  const registry = useDocumentRegistry(documentId);
+  const subscribe = useCallback((cb) => registry ? registry.subscribe(cb) : () => {
+  }, [registry]);
+  const getSnapshot = useCallback(() => registry?.resolveLinkDef(label) ?? null, [registry, label]);
+  const def = useSyncExternalStore(subscribe, getSnapshot, SSR_DEF_SNAPSHOT);
+  if (!def) {
+    return literalLink(referenceType, label, children);
+  }
+  return /* @__PURE__ */ jsx4("a", { href: def.url, title: def.title, children });
+}
+function literalImage(rt, label, alt) {
+  switch (rt) {
+    case "full":
+      return `![${alt}][${label}]`;
+    case "collapsed":
+      return `![${alt}][]`;
+    case "shortcut":
+    default:
+      return `![${label}]`;
+  }
+}
+function CrossChunkImage({ label, referenceType, alt = "" }) {
+  const { documentId } = useAIMarkdownRenderState();
+  const registry = useDocumentRegistry(documentId);
+  const subscribe = useCallback((cb) => registry ? registry.subscribe(cb) : () => {
+  }, [registry]);
+  const getSnapshot = useCallback(() => registry?.resolveLinkDef(label) ?? null, [registry, label]);
+  const def = useSyncExternalStore(subscribe, getSnapshot, SSR_DEF_SNAPSHOT);
+  if (!def) {
+    return literalImage(referenceType, label, alt);
+  }
+  return /* @__PURE__ */ jsx4("img", { src: def.url, alt, title: def.title });
+}
+var crossChunkComponents = {
+  "footnote-sup": FootnoteSupNumber,
+  "cross-chunk-link": CrossChunkLink,
+  "cross-chunk-image": CrossChunkImage
+};
+
+// src/components/extractContributions.ts
+import { SKIP, visit as visit6 } from "unist-util-visit";
+function* extractContributions(mdast, options = {}) {
+  const phantomFn = options.phantomFootnoteLabels;
+  const out = [];
+  visit6(mdast, (n) => {
+    if (n.type === "footnoteReference") {
+      out.push({
+        kind: "ref",
+        refKind: "footnote",
+        label: normalizeId(n.identifier)
+      });
+    } else if (n.type === "linkReference") {
+      const r = n;
+      out.push({ kind: "ref", refKind: "link", label: normalizeId(r.identifier), referenceType: r.referenceType });
+    } else if (n.type === "imageReference") {
+      const r = n;
+      out.push({ kind: "ref", refKind: "image", label: normalizeId(r.identifier), referenceType: r.referenceType });
+    } else if (n.type === "footnoteDefinition") {
+      const d = n;
+      const label = normalizeId(d.identifier);
+      if (phantomFn?.has(label)) return SKIP;
+      const content = JSON.stringify(d.children ?? []);
+      out.push({ kind: "fnDef", label, sourceIdentifier: d.identifier, content });
+      return SKIP;
+    } else if (n.type === "definition") {
+      const d = n;
+      if (d.url === SENTINEL_LINK_URL) return;
+      out.push({ kind: "linkDef", label: normalizeId(d.identifier), url: d.url, title: d.title });
+    }
+  });
+  for (const c of out) yield c;
+}
+
+// src/components/extractDefBodiesFromHast.ts
+import { SKIP as SKIP2, visit as visit7 } from "unist-util-visit";
+var FN_LI_ID_RE = /(?:^|-)user-content-fn-(.+)$/;
+function sourceIdFromFootnoteLiId(idProp, clobberPrefix) {
+  let raw = null;
+  if (clobberPrefix !== void 0) {
+    const exactPrefix = `${clobberPrefix}fn-`;
+    if (idProp.startsWith(exactPrefix)) raw = idProp.slice(exactPrefix.length);
+  }
+  if (raw === null) {
+    const m = idProp.match(FN_LI_ID_RE);
+    raw = m ? m[1] : null;
+  }
+  if (raw === null) return null;
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    return raw;
+  }
+}
+function isBackrefAnchor(c) {
+  if (c.type !== "element") return false;
+  const el = c;
+  if (el.tagName !== "a") return false;
+  return Boolean(el.properties && "dataFootnoteBackref" in el.properties);
+}
+function isWhitespaceText(c) {
+  if (c.type !== "text") return false;
+  return /^\s*$/.test(c.value);
+}
+function lastMeaningfulIdx(children) {
+  for (let i = children.length - 1; i >= 0; i--) {
+    if (!isWhitespaceText(children[i])) return i;
+  }
+  return -1;
+}
+function dropTrailingBackrefs(children) {
+  let trailingWsStart = children.length;
+  while (trailingWsStart > 0 && isWhitespaceText(children[trailingWsStart - 1])) {
+    trailingWsStart--;
+  }
+  let scan = trailingWsStart;
+  let peeledAny = false;
+  while (scan > 0) {
+    const t = children[scan - 1];
+    if (!isBackrefAnchor(t)) break;
+    peeledAny = true;
+    scan -= 1;
+    if (scan > 0 && children[scan - 1].type === "text" && children[scan - 1].value === " ") {
+      scan -= 1;
+    }
+  }
+  if (!peeledAny) return children;
+  const trailing = children.slice(trailingWsStart);
+  if (scan > 0) {
+    const last = children[scan - 1];
+    if (last.type === "text") {
+      const v = last.value;
+      if (v.endsWith(" ") && !/^\s*$/.test(v)) {
+        return [...children.slice(0, scan - 1), { ...last, value: v.slice(0, -1) }, ...trailing];
+      }
+    }
+  }
+  return [...children.slice(0, scan), ...trailing];
+}
+function stripBackrefs(liChildren) {
+  if (liChildren.length === 0) return liChildren;
+  const lastIdx = lastMeaningfulIdx(liChildren);
+  if (lastIdx < 0) return liChildren;
+  const last = liChildren[lastIdx];
+  if (isBackrefAnchor(last)) {
+    return dropTrailingBackrefs(liChildren);
+  }
+  if (last.type === "element" && last.tagName === "p") {
+    const p = last;
+    const newPChildren = dropTrailingBackrefs(p.children);
+    if (newPChildren === p.children) return liChildren;
+    return liChildren.map((c, i) => i === lastIdx ? { ...p, children: newPChildren } : c);
+  }
+  return liChildren;
+}
+function stripLocalOccurrenceFromFootnoteSups(children) {
+  let changed = false;
+  const out = [];
+  for (const c of children) {
+    if (c.type === "element") {
+      const el = c;
+      let nextEl = el;
+      if (el.tagName === "footnote-sup" && el.properties && "localOccurrence" in el.properties) {
+        const { localOccurrence: _drop, ...rest } = el.properties;
+        nextEl = { ...el, properties: rest };
+        changed = true;
+      }
+      const newChildren = stripLocalOccurrenceFromFootnoteSups(nextEl.children);
+      if (newChildren !== nextEl.children) {
+        nextEl = { ...nextEl, children: newChildren };
+        changed = true;
+      }
+      out.push(nextEl);
+    } else {
+      out.push(c);
+    }
+  }
+  return changed ? out : children;
+}
+function extractDefBodiesFromHast(hast, clobberPrefix) {
+  const out = /* @__PURE__ */ new Map();
+  visit7(hast, "element", (sectionNode) => {
+    const sec = sectionNode;
+    if (sec.tagName !== "section") return;
+    if (!(sec.properties && "dataFootnotes" in sec.properties)) return;
+    visit7(sec, "element", (liNode) => {
+      const li = liNode;
+      if (li.tagName !== "li") return;
+      const idProp = li.properties?.id;
+      if (typeof idProp !== "string") return;
+      const sourceId = sourceIdFromFootnoteLiId(idProp, clobberPrefix);
+      if (sourceId === null) return;
+      const normalized = normalizeId(sourceId);
+      const stripped = stripBackrefs(li.children);
+      out.set(normalized, stripLocalOccurrenceFromFootnoteSups(stripped));
+    });
+    return SKIP2;
+  });
+  return out;
+}
+
+// src/components/aggregateFootnotesIfLast.tsx
+import { memo, useMemo as useMemo3 } from "react";
+import { Fragment as Fragment2, jsx as jsx5 } from "react/jsx-runtime";
+function cloneHast(node) {
+  return JSON.parse(JSON.stringify(node));
+}
+function isWhitespaceText2(c) {
+  return c.type === "text" && /^\s*$/.test(c.value);
+}
+function lastMeaningfulIdx2(children) {
+  for (let i = children.length - 1; i >= 0; i--) {
+    if (!isWhitespaceText2(children[i])) return i;
+  }
+  return -1;
+}
+function buildBackref(href, occurrence, globalNumber) {
+  const children = [{ type: "text", value: "\u21A9" }];
+  if (occurrence > 1) {
+    children.push({
+      type: "element",
+      tagName: "sup",
+      properties: {},
+      children: [{ type: "text", value: String(occurrence) }]
+    });
+  }
+  const ariaLabel = occurrence === 1 ? `Back to reference ${globalNumber}` : `Back to reference ${globalNumber}-${occurrence}`;
+  return {
+    type: "element",
+    tagName: "a",
+    properties: {
+      href,
+      dataFootnoteBackref: "",
+      className: ["data-footnote-backref"],
+      ariaLabel
+    },
+    children
+  };
+}
+function buildAggregateTree(registry, clobberPrefix, preserveOrphanReferences = false) {
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const sym of registry.chunkOrder) {
+    const data = registry.chunkData.get(sym);
+    if (!data) continue;
+    for (const ref of data.refs) {
+      if (ref.kind !== "footnote") continue;
+      if (seen.has(ref.label)) continue;
+      seen.add(ref.label);
+      const canonicalSym = registry.canonicalFootnoteFor(ref.label);
+      if (!canonicalSym) continue;
+      const def = registry.chunkData.get(canonicalSym)?.defs.get(ref.label);
+      if (!def) continue;
+      const n = registry.globalNumber(ref.label);
+      if (n === null) continue;
+      const sourceIdentifier = def.sourceIdentifier ?? ref.label;
+      ordered.push({
+        normalizedLabel: ref.label,
+        sourceIdentifier,
+        bodyHast: def.bodyHast ?? [],
+        n,
+        withBackref: true
+      });
+    }
+  }
+  if (preserveOrphanReferences) {
+    for (const sym of registry.chunkOrder) {
+      const data = registry.chunkData.get(sym);
+      if (!data) continue;
+      for (const [label, def] of data.defs) {
+        if (seen.has(label)) continue;
+        if (registry.canonicalFootnoteFor(label) !== sym) continue;
+        seen.add(label);
+        ordered.push({
+          normalizedLabel: label,
+          sourceIdentifier: def.sourceIdentifier ?? label,
+          bodyHast: def.bodyHast ?? [],
+          n: null,
+          withBackref: false
+        });
+      }
+    }
+  }
+  if (ordered.length === 0) return null;
+  const liElements = ordered.map(({ normalizedLabel, sourceIdentifier, bodyHast, n, withBackref }) => {
+    const liChildren = bodyHast.map((c) => cloneHast(c));
+    if (withBackref) {
+      const totalRefs = registry.getRefsForLabel(normalizedLabel);
+      const tailIdx = lastMeaningfulIdx2(liChildren);
+      const tail = tailIdx !== -1 ? liChildren[tailIdx] : null;
+      const dest = tail && tail.type === "element" && tail.tagName === "p" ? tail : null;
+      const appended = [];
+      for (let i = 1; i <= Math.max(totalRefs, 1); i++) {
+        appended.push({ type: "text", value: " " });
+        const href = i === 1 ? `#${clobberPrefix}fnref-${sourceIdentifier}` : `#${clobberPrefix}fnref-${sourceIdentifier}-${i}`;
+        appended.push(buildBackref(href, i, n ?? 0));
+      }
+      if (dest) {
+        dest.children = [...dest.children, ...appended];
+      } else if (tailIdx !== -1) {
+        liChildren.splice(tailIdx + 1, 0, ...appended);
+      } else {
+        liChildren.push(...appended);
+      }
+    }
+    return {
+      type: "element",
+      tagName: "li",
+      properties: {
+        id: `${clobberPrefix}fn-${sourceIdentifier}`,
+        ...n !== null ? { value: n } : {}
+      },
+      children: liChildren
+    };
+  });
+  return {
+    type: "element",
+    tagName: "section",
+    properties: {
+      className: ["footnotes"],
+      dataFootnotes: true,
+      // a11y: name the section landmark so screen readers still announce it
+      // even though the visible "Footnotes" h2 is omitted in coordinated mode.
+      ariaLabel: "Footnotes"
+    },
+    children: [
+      // Conventional separator above the footnote list. The default
+      // mdast-util-to-hast footer doesn't emit one (GitHub renders the
+      // separation via CSS `border-top` on `.footnotes`); we render a literal
+      // `<hr>` so the visual break is preserved without sanitize-friendly CSS.
+      {
+        type: "element",
+        tagName: "hr",
+        properties: {},
+        children: []
+      },
+      {
+        type: "element",
+        tagName: "ol",
+        properties: {},
+        children: liElements
+      }
+    ]
+  };
+}
+var AggregateFootnotesIfLastImpl = ({
+  registry,
+  thisChunkSym,
+  clobberPrefix,
+  postOptions,
+  preserveOrphanReferences = false
+}) => {
+  const tree = useMemo3(
+    () => buildAggregateTree(registry, clobberPrefix, preserveOrphanReferences),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [registry, registry.version, clobberPrefix, preserveOrphanReferences]
+  );
+  const order = registry.chunkOrder;
+  if (order.length === 0) return null;
+  if (order[order.length - 1] !== thisChunkSym) return null;
+  if (!tree) return null;
+  return /* @__PURE__ */ jsx5(Fragment2, { children: renderHastSubtree(cloneHast(tree), postOptions) });
+};
+var AggregateFootnotesIfLast = memo(AggregateFootnotesIfLastImpl);
+AggregateFootnotesIfLast.displayName = "AggregateFootnotesIfLast";
+
 // src/components/MarkdownContent.tsx
-import { Fragment as Fragment3, jsx as jsx3 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+var REGISTRY_SSR_SNAPSHOT = () => 0;
 var DisplayOptimizeRemarkPluginMap = {
   ["REMOVE_COMMENTS" /* REMOVE_COMMENTS */]: remarkRemoveComments,
   ["SMARTYPANTS" /* SMARTYPANTS */]: remarkSmartypants,
@@ -1863,7 +2791,7 @@ var ExtraSyntaxRemarkPluginMap = {
   ["DEFINITION_LIST" /* DEFINITION_LIST */]: remarkDefinitionList
 };
 var DefaultCustomComponents = {};
-var BlockMemoizedRenderer = memo(
+var BlockMemoizedRenderer = memo2(
   ({ content, usedComponents, remarkPlugins, rehypePlugins, remarkRehypeOptions }) => {
     const urlTransform = void 0;
     const allowedElements = void 0;
@@ -1871,8 +2799,30 @@ var BlockMemoizedRenderer = memo(
     const allowElement = void 0;
     const skipHtml = void 0;
     const unwrapDisallowed = void 0;
-    const cacheRef = useRef(createCache());
-    const depsRef = useRef({
+    const { documentId, clobberPrefix, config } = useAIMarkdownRenderState();
+    const reactId = useId2();
+    const registry = useDocumentRegistry(documentId);
+    const [allocation, setAllocation] = useState(null);
+    const sym = allocation && allocation.registry === registry ? allocation.sym : null;
+    const subscribeRegistry = useCallback2(
+      (cb) => registry ? registry.subscribe(cb) : () => {
+      },
+      [registry]
+    );
+    const getRegistryVersion = useCallback2(() => registry?.version ?? 0, [registry]);
+    useSyncExternalStore2(subscribeRegistry, getRegistryVersion, REGISTRY_SSR_SNAPSHOT);
+    const ownLabels = useMemo4(() => collectDefLabels(content ?? ""), [content]);
+    useEffect(() => {
+      if (!registry) return;
+      const s = registry.registerChunk(reactId, ownLabels.footnoteLabels, ownLabels.linkLabels);
+      setAllocation({ registry, sym: s });
+      return () => {
+        registry.releaseSymbol(reactId);
+        setAllocation(null);
+      };
+    }, [reactId, registry, ownLabels]);
+    const cacheRef = useRef2(createCache());
+    const depsRef = useRef2({
       usedComponents,
       remarkPlugins,
       rehypePlugins,
@@ -1882,9 +2832,11 @@ var BlockMemoizedRenderer = memo(
       disallowedElements,
       allowElement,
       skipHtml,
-      unwrapDisallowed
+      unwrapDisallowed,
+      registry,
+      symbol: sym
     });
-    if (depsRef.current.usedComponents !== usedComponents || depsRef.current.remarkPlugins !== remarkPlugins || depsRef.current.rehypePlugins !== rehypePlugins || depsRef.current.remarkRehypeOptions !== remarkRehypeOptions || depsRef.current.urlTransform !== urlTransform || depsRef.current.allowedElements !== allowedElements || depsRef.current.disallowedElements !== disallowedElements || depsRef.current.allowElement !== allowElement || depsRef.current.skipHtml !== skipHtml || depsRef.current.unwrapDisallowed !== unwrapDisallowed) {
+    if (depsRef.current.usedComponents !== usedComponents || depsRef.current.remarkPlugins !== remarkPlugins || depsRef.current.rehypePlugins !== rehypePlugins || depsRef.current.remarkRehypeOptions !== remarkRehypeOptions || depsRef.current.urlTransform !== urlTransform || depsRef.current.allowedElements !== allowedElements || depsRef.current.disallowedElements !== disallowedElements || depsRef.current.allowElement !== allowElement || depsRef.current.skipHtml !== skipHtml || depsRef.current.unwrapDisallowed !== unwrapDisallowed || depsRef.current.registry !== registry || depsRef.current.symbol !== sym) {
       cacheRef.current = createCache();
       depsRef.current = {
         usedComponents,
@@ -1896,39 +2848,201 @@ var BlockMemoizedRenderer = memo(
         disallowedElements,
         allowElement,
         skipHtml,
-        unwrapDisallowed
+        unwrapDisallowed,
+        registry,
+        symbol: sym
       };
     }
-    const parsed = useMemo2(
-      () => parseStage({
-        children: content,
+    const targetPhantomsRef = useRef2({
+      missingFootnotes: /* @__PURE__ */ new Set(),
+      missingLinks: /* @__PURE__ */ new Set()
+    });
+    const targetPhantoms = useMemo4(() => {
+      let nextFootnotes;
+      let nextLinks;
+      if (!registry) {
+        nextFootnotes = /* @__PURE__ */ new Set();
+        nextLinks = /* @__PURE__ */ new Set();
+      } else {
+        const normalized = normalizeForMatch(content ?? "");
+        nextFootnotes = /* @__PURE__ */ new Set();
+        nextLinks = /* @__PURE__ */ new Set();
+        for (const label of registry.labelSet.footnoteLabels) {
+          if (ownLabels.footnoteLabels.has(label)) continue;
+          if (normalized.includes(label)) nextFootnotes.add(label);
+        }
+        for (const label of registry.labelSet.linkLabels) {
+          if (ownLabels.linkLabels.has(label)) continue;
+          if (normalized.includes(label)) nextLinks.add(label);
+        }
+      }
+      const prev = targetPhantomsRef.current;
+      if (nextFootnotes.size === prev.missingFootnotes.size && nextLinks.size === prev.missingLinks.size && [...nextFootnotes].every((l) => prev.missingFootnotes.has(l)) && [...nextLinks].every((l) => prev.missingLinks.has(l))) {
+        return prev;
+      }
+      const next = { missingFootnotes: nextFootnotes, missingLinks: nextLinks };
+      targetPhantomsRef.current = next;
+      return next;
+    }, [registry, registry?.version, content, ownLabels]);
+    const effectivePreserveOrphan = usePreserveOrphanReferences(config.preserveOrphanReferences);
+    const preserveForBodyHarvest = effectivePreserveOrphan || Boolean(registry && sym);
+    const handlers = useMemo4(() => {
+      if (registry) return buildCrossChunkHandlers();
+      if (effectivePreserveOrphan) {
+        const { footnoteDefinition } = buildCrossChunkHandlers();
+        return { footnoteDefinition };
+      }
+      return void 0;
+    }, [registry, effectivePreserveOrphan]);
+    const parsed = useMemo4(() => {
+      const augmented = augmentSourceWithPhantoms(content ?? "", targetPhantoms);
+      const baseHandlers = remarkRehypeOptions?.handlers ?? {};
+      const mergedRemarkRehypeOptions = handlers ? {
+        ...remarkRehypeOptions,
+        handlers: { ...baseHandlers, ...handlers },
+        // Phantom label sets are empty in standalone mode (no PASS 0.5
+        // injection happened); the footnoteDefinition handler still reads
+        // them via `state.options.phantomFootnoteLabels.has(id)`, which
+        // returns false for every id → orphan-protect path proceeds.
+        phantomFootnoteLabels: targetPhantoms.missingFootnotes,
+        phantomLinkLabels: targetPhantoms.missingLinks,
+        preserveOrphan: preserveForBodyHarvest,
+        documentId
+      } : {
+        ...remarkRehypeOptions
+      };
+      return parseStage({
+        children: augmented,
         remarkPlugins,
         rehypePlugins,
-        remarkRehypeOptions
-      }),
-      [content, remarkPlugins, rehypePlugins, remarkRehypeOptions]
-    );
-    const hast = useMemo2(() => transformStage(parsed), [parsed]);
-    const built = useMemo2(() => buildBlocks(parsed.mdast, hast, content), [parsed.mdast, hast, content]);
-    const postOptions = useMemo2(
+        remarkRehypeOptions: mergedRemarkRehypeOptions
+      });
+    }, [
+      content,
+      targetPhantoms,
+      remarkPlugins,
+      rehypePlugins,
+      remarkRehypeOptions,
+      handlers,
+      preserveForBodyHarvest,
+      documentId
+    ]);
+    const hast = useMemo4(() => transformStage(parsed), [parsed]);
+    const built = useMemo4(() => buildBlocks(parsed.mdast, hast, content ?? ""), [parsed.mdast, hast, content]);
+    const postOptions = useMemo4(
       () => ({
-        components: usedComponents,
+        components: { ...crossChunkComponents, ...usedComponents },
         urlTransform,
         allowedElements,
         disallowedElements,
         allowElement,
         skipHtml,
-        unwrapDisallowed
+        unwrapDisallowed,
+        // v6 fingerprint cache fields:
+        registry: registry ?? void 0,
+        thisChunkSymbol: sym ?? void 0,
+        clobberPrefix
       }),
-      [usedComponents, urlTransform, allowedElements, disallowedElements, allowElement, skipHtml, unwrapDisallowed]
+      // `sym` is now real state (setSym after allocateSymbol), so it's a
+      // proper dep and postOptions refreshes when allocation completes.
+      // `registry?.version` stays in deps so the per-block fingerprint cache
+      // path sees the latest registry version on every coordinated update.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [
+        usedComponents,
+        urlTransform,
+        allowedElements,
+        disallowedElements,
+        allowElement,
+        skipHtml,
+        unwrapDisallowed,
+        registry,
+        registry?.version,
+        sym,
+        clobberPrefix
+      ]
     );
+    const lastContributionRef = useRef2(null);
+    useEffect(() => {
+      if (!registry || !sym) return;
+      const refs = [];
+      const defMeta = /* @__PURE__ */ new Map();
+      const linkDefs = /* @__PURE__ */ new Map();
+      for (const node of extractContributions(parsed.mdast, {
+        phantomFootnoteLabels: targetPhantoms.missingFootnotes
+      })) {
+        if (node.kind === "ref") {
+          refs.push({ label: node.label, kind: node.refKind, referenceType: node.referenceType });
+        } else if (node.kind === "fnDef") {
+          defMeta.set(node.label, {
+            identifier: node.label,
+            sourceIdentifier: node.sourceIdentifier,
+            contentSource: node.content
+          });
+        } else if (node.kind === "linkDef") {
+          linkDefs.set(node.label, { identifier: node.label, url: node.url, title: node.title });
+        }
+      }
+      const fp = JSON.stringify({
+        r: refs,
+        d: Array.from(defMeta.entries()).map(([k, v]) => [k, v.sourceIdentifier, v.contentSource]),
+        l: Array.from(linkDefs.entries()).map(([k, v]) => [k, v.url, v.title ?? ""]),
+        ofn: Array.from(ownLabels.footnoteLabels).sort(),
+        ol: Array.from(ownLabels.linkLabels).sort(),
+        // Include targetPhantoms in the fingerprint: a phantom→resolved
+        // transition (another chunk publishes a def for a label this chunk
+        // references inside one of its OWN def bodies) changes the rendered
+        // hast — the `<cross-chunk-link>` / `<cross-chunk-image>` placeholder
+        // disappears and a real `<a>` / `<img>` takes its place — without
+        // touching this chunk's refs / defMeta / linkDefs / ownLabels. Without
+        // including the phantom snapshot in the fingerprint, the fp check
+        // would short-circuit and the registry would keep stale bodyHast
+        // forever, leaving the aggregate footer rendering the placeholder
+        // long after the label was resolved.
+        tpfn: Array.from(targetPhantoms.missingFootnotes).sort(),
+        tpl: Array.from(targetPhantoms.missingLinks).sort()
+      });
+      if (lastContributionRef.current?.registry === registry && lastContributionRef.current.symbol === sym && lastContributionRef.current.fp === fp) {
+        return;
+      }
+      const bodiesByLabel = extractDefBodiesFromHast(hast, clobberPrefix);
+      const defs = /* @__PURE__ */ new Map();
+      for (const [label, meta] of defMeta) {
+        defs.set(label, {
+          identifier: meta.identifier,
+          sourceIdentifier: meta.sourceIdentifier,
+          contentSource: meta.contentSource,
+          bodyHast: bodiesByLabel.get(label) ?? []
+        });
+      }
+      lastContributionRef.current = { registry, symbol: sym, fp };
+      registry.contributeChunkData(sym, {
+        refs,
+        defs,
+        linkDefs,
+        ownFootnoteLabels: ownLabels.footnoteLabels,
+        ownLinkLabels: ownLabels.linkLabels
+      });
+    }, [parsed, ownLabels, registry, targetPhantoms, sym, hast, clobberPrefix]);
     const rendered = renderBlocksWithCache(cacheRef, built.plan, built.globalCtx, postOptions);
-    return /* @__PURE__ */ jsx3(Fragment3, { children: rendered.map(({ node, reactKey }) => /* @__PURE__ */ jsx3(Fragment2, { children: node }, reactKey)) });
+    return /* @__PURE__ */ jsxs2(ChunkSymbolContext.Provider, { value: sym, children: [
+      rendered.map(({ node, reactKey }) => /* @__PURE__ */ jsx6(Fragment3, { children: node }, reactKey)),
+      registry && sym ? /* @__PURE__ */ jsx6(
+        AggregateFootnotesIfLast,
+        {
+          registry,
+          thisChunkSym: sym,
+          clobberPrefix,
+          postOptions,
+          preserveOrphanReferences: effectivePreserveOrphan
+        }
+      ) : null
+    ] });
   }
 );
 BlockMemoizedRenderer.displayName = "BlockMemoizedRenderer";
-var LegacyRenderer = memo(
-  ({ content, usedComponents, remarkPlugins, rehypePlugins, remarkRehypeOptions }) => /* @__PURE__ */ jsx3(
+var LegacyRenderer = memo2(
+  ({ content, usedComponents, remarkPlugins, rehypePlugins, remarkRehypeOptions }) => /* @__PURE__ */ jsx6(
     Markdown_default,
     {
       remarkPlugins,
@@ -1940,26 +3054,25 @@ var LegacyRenderer = memo(
   )
 );
 LegacyRenderer.displayName = "LegacyRenderer";
-var AIMarkdownContent = memo(({ content, customComponents }) => {
-  const { config, documentId } = useAIMarkdownRenderState();
-  const clobberPrefix = `${encodeURIComponent(documentId)}-user-content-`;
-  const { extraSyntaxRemarkPlugins, enableDefinitionList } = useMemo2(
+var AIMarkdownContent = memo2(({ content, customComponents }) => {
+  const { config, clobberPrefix } = useAIMarkdownRenderState();
+  const { extraSyntaxRemarkPlugins, enableDefinitionList } = useMemo4(
     () => ({
       extraSyntaxRemarkPlugins: config.extraSyntaxSupported.map((syntax) => ExtraSyntaxRemarkPluginMap[syntax]),
       enableDefinitionList: config.extraSyntaxSupported.includes("DEFINITION_LIST" /* DEFINITION_LIST */)
     }),
     [config.extraSyntaxSupported]
   );
-  const displayOptimizeRemarkPlugins = useMemo2(() => {
+  const displayOptimizeRemarkPlugins = useMemo4(() => {
     return config.displayOptimizeAbilities.map((ability) => DisplayOptimizeRemarkPluginMap[ability]);
   }, [config.displayOptimizeAbilities]);
-  const usedComponents = useMemo2(() => {
+  const usedComponents = useMemo4(() => {
     return customComponents ? { ...DefaultCustomComponents, ...customComponents } : DefaultCustomComponents;
   }, [customComponents]);
-  const remarkPlugins = useMemo2(
+  const remarkPlugins = useMemo4(
     () => [
       // --- Core plugins (always active) ---
-      remarkGfm,
+      remarkGfm2,
       [
         remarkMath,
         {
@@ -1981,7 +3094,7 @@ var AIMarkdownContent = memo(({ content, customComponents }) => {
     ],
     [extraSyntaxRemarkPlugins, displayOptimizeRemarkPlugins]
   );
-  const rehypePlugins = useMemo2(
+  const rehypePlugins = useMemo4(
     () => [
       // Allow raw HTML through so rehype-sanitize can handle it.
       [rehypeRaw, { passThrough: [] }],
@@ -1989,6 +3102,11 @@ var AIMarkdownContent = memo(({ content, customComponents }) => {
       // Override `clobberPrefix` with the instance-scoped value so every id
       // and clobberable attribute is namespaced to this `<AIMarkdown>` instance.
       [rehypeSanitize, { ...sanitizeSchema, clobberPrefix }],
+      // Normalize the auto-generated `<section data-footnotes>`: strip the
+      // sr-only `<h2>Footnotes</h2>` label and prepend `<hr>`. Keeps standalone
+      // single-doc rendering visually consistent with the cross-chunk aggregate
+      // footer (which builds the same shape from scratch).
+      rehypeFooterAdorn,
       // Re-prefix intra-document hash hrefs so they match the ids that
       // rehype-sanitize just clobbered. Must use the SAME prefix as the schema
       // above — that's why both read from `clobberPrefix`.
@@ -1998,7 +3116,7 @@ var AIMarkdownContent = memo(({ content, customComponents }) => {
     ],
     [clobberPrefix]
   );
-  const remarkRehypeOptions = useMemo2(
+  const remarkRehypeOptions = useMemo4(
     () => ({
       allowDangerousHtml: true,
       // Suppress mdast-util-to-hast's `user-content-` prefix on footnote
@@ -2015,7 +3133,7 @@ var AIMarkdownContent = memo(({ content, customComponents }) => {
     [enableDefinitionList]
   );
   const Renderer = config.blockMemoEnabled ? BlockMemoizedRenderer : LegacyRenderer;
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx6(
     Renderer,
     {
       content,
@@ -2030,7 +3148,7 @@ AIMarkdownContent.displayName = "AIMarkdownContent";
 var MarkdownContent_default = AIMarkdownContent;
 
 // src/hooks/useStableValue.ts
-import { useRef as useRef2, useLayoutEffect, useEffect } from "react";
+import { useRef as useRef3, useLayoutEffect, useEffect as useEffect2 } from "react";
 
 // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setCacheAdd.js
 var HASH_UNDEFINED3 = "__lodash_hash_undefined__";
@@ -2450,9 +3568,9 @@ function isEqual(value, other) {
 var isEqual_default = isEqual;
 
 // src/hooks/useStableValue.ts
-var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect2;
 function useStableValue(value) {
-  const ref = useRef2(value);
+  const ref = useRef3(value);
   const prev = ref.current;
   const stableValue = isEqual_default(prev, value) ? prev : value;
   useIsomorphicLayoutEffect(() => {
@@ -2462,21 +3580,21 @@ function useStableValue(value) {
 }
 
 // src/components/typography/Default.tsx
-import { memo as memo2, useMemo as useMemo3 } from "react";
-import { jsx as jsx4 } from "react/jsx-runtime";
-var DefaultTypography = memo2(({ children, fontSize, variant, colorScheme, style }) => {
-  const className = useMemo3(
+import { memo as memo3, useMemo as useMemo5 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var DefaultTypography = memo3(({ children, fontSize, variant, colorScheme, style }) => {
+  const className = useMemo5(
     () => ["aim-typography-root", variant, colorScheme].filter(Boolean).join(" "),
     [variant, colorScheme]
   );
-  const mergedStyle = useMemo3(() => ({ width: "100%", fontSize, ...style }), [fontSize, style]);
-  return /* @__PURE__ */ jsx4("div", { className, style: mergedStyle, children });
+  const mergedStyle = useMemo5(() => ({ width: "100%", fontSize, ...style }), [fontSize, style]);
+  return /* @__PURE__ */ jsx7("div", { className, style: mergedStyle, children });
 });
 DefaultTypography.displayName = "DefaultTypography";
 var Default_default = DefaultTypography;
 
 // src/index.tsx
-import { jsx as jsx5 } from "react/jsx-runtime";
+import { jsx as jsx8 } from "react/jsx-runtime";
 var AIMarkdownComponent = ({
   streaming = false,
   content,
@@ -2493,18 +3611,18 @@ var AIMarkdownComponent = ({
   documentId
 }) => {
   const usedFontSize = fontSize === void 0 ? "0.9375rem" : typeof fontSize === "number" ? `${fontSize}px` : fontSize;
-  const generatedId = useId2();
+  const generatedId = useId3();
   const usedDocumentId = documentId && documentId.length > 0 ? documentId : generatedId;
   const stableDefaultConfig = useStableValue(defaultConfig);
   const stableConfig = useStableValue(config);
   const stablePreprocessors = useStableValue(contentPreprocessors);
   const stableCustomComponents = useStableValue(customComponents);
-  const usedContent = useMemo4(
+  const usedContent = useMemo6(
     () => content ? preprocessAIMDContent(content, stablePreprocessors) : content,
     [content, stablePreprocessors]
   );
-  const typographyStyle = useMemo4(() => ({ "--aim-font-size-root": usedFontSize }), [usedFontSize]);
-  return /* @__PURE__ */ jsx5(AIMarkdownMetadataProvider, { metadata, children: /* @__PURE__ */ jsx5(
+  const typographyStyle = useMemo6(() => ({ "--aim-font-size-root": usedFontSize }), [usedFontSize]);
+  return /* @__PURE__ */ jsx8(AIMarkdownMetadataProvider, { metadata, children: /* @__PURE__ */ jsx8(
     context_default,
     {
       streaming,
@@ -2514,29 +3632,31 @@ var AIMarkdownComponent = ({
       documentId: usedDocumentId,
       defaultConfig: stableDefaultConfig,
       config: stableConfig,
-      children: /* @__PURE__ */ jsx5(
+      children: /* @__PURE__ */ jsx8(
         Typography,
         {
           fontSize: usedFontSize,
           variant,
           colorScheme,
           style: typographyStyle,
-          children: ExtraStyles ? /* @__PURE__ */ jsx5(ExtraStyles, { children: /* @__PURE__ */ jsx5(MarkdownContent_default, { content: usedContent, customComponents: stableCustomComponents }) }) : /* @__PURE__ */ jsx5(MarkdownContent_default, { content: usedContent, customComponents: stableCustomComponents })
+          children: ExtraStyles ? /* @__PURE__ */ jsx8(ExtraStyles, { children: /* @__PURE__ */ jsx8(MarkdownContent_default, { content: usedContent, customComponents: stableCustomComponents }) }) : /* @__PURE__ */ jsx8(MarkdownContent_default, { content: usedContent, customComponents: stableCustomComponents })
         }
       )
     }
   ) });
 };
-var AIMarkdown = memo3(AIMarkdownComponent);
+var AIMarkdown = memo4(AIMarkdownComponent);
 AIMarkdown.displayName = "AIMarkdown";
 var index_default = AIMarkdown;
 export {
+  AIMarkdownDocuments,
   AIMarkdownRenderDisplayOptimizeAbility,
   AIMarkdownRenderExtraSyntax,
   index_default as default,
   defaultAIMarkdownRenderConfig,
   useAIMarkdownMetadata,
   useAIMarkdownRenderState,
+  useDocumentRegistry,
   useStableValue
 };
 //# sourceMappingURL=index.js.map