@ai-markdown/core 3.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,905 @@
+// src/blockPlan.ts
+import { SKIP, visit } from "unist-util-visit";
+import { isFootnoteSection, normalizeId } from "@ai-markdown/engine";
+var TAINT_TYPES = /* @__PURE__ */ new Set([
+  "footnoteReference",
+  "footnoteDefinition",
+  "linkReference",
+  "imageReference",
+  "definition"
+]);
+var CTX_TYPES = TAINT_TYPES;
+function extractRaw(node, source) {
+  if (!node.position) return "";
+  return source.slice(node.position.start.offset, node.position.end.offset);
+}
+function hasMdastSource(node) {
+  return node.position !== void 0;
+}
+function computeHtmlBlockDigest(el, source, ownEnd) {
+  return computeHtmlBlockDigestWithExtent(el, source, ownEnd).digest;
+}
+function computeHtmlBlockDigestWithExtent(el, source, ownEnd) {
+  let maxEnd = el.position?.end?.offset ?? 0;
+  let count = 0;
+  let hasFootnoteSection = false;
+  const stack = [...el.children];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    count++;
+    const end = node.position?.end?.offset;
+    if (end !== void 0 && end > maxEnd) {
+      maxEnd = end;
+    }
+    if (node.type === "element") {
+      if (isFootnoteSection(node)) {
+        hasFootnoteSection = true;
+      }
+      for (const child of node.children) {
+        stack.push(child);
+      }
+    }
+  }
+  const swallowed = source !== void 0 && ownEnd !== void 0 && maxEnd > ownEnd ? source.slice(ownEnd, maxEnd) : "";
+  return { digest: `${maxEnd}:${count}:${hasFootnoteSection ? 1 : 0}:${fnv1a(swallowed)}`, maxEnd };
+}
+function fnv1a(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(36);
+}
+var EMPTY_LABELS = /* @__PURE__ */ new Set();
+var FOOTNOTE_SECTION_KEY = "__footnote_section__";
+function buildBlocks(mdast, hast, source, options = {}) {
+  const phantomFootnotes = options.phantomFootnoteLabels ?? EMPTY_LABELS;
+  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 (false) {
+    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 = [];
+  const taintOffsets = [];
+  const firstTaintAtOrAfter = (offset) => {
+    let lo = 0;
+    let hi = taintOffsets.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (taintOffsets[mid] < offset) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  };
+  visit(options.contextMdast ?? mdast, (n) => {
+    if (!CTX_TYPES.has(n.type)) return;
+    const at = n.position?.start?.offset;
+    if (at !== void 0) taintOffsets.push(at);
+    if (n.type === "footnoteReference") ctxParts.push(["fr", n.identifier]);
+    else if (n.type === "footnoteDefinition") ctxParts.push(["fd", n.identifier, extractRaw(n, source)]);
+    else if (n.type === "linkReference") ctxParts.push(["lr", n.identifier]);
+    else if (n.type === "imageReference") ctxParts.push(["ir", n.identifier]);
+    else if (n.type === "definition") ctxParts.push(["d", n.identifier, n.url, n.title ?? null]);
+  });
+  if (false) {
+    for (let i = 1; i < taintOffsets.length; i++) {
+      if (taintOffsets[i] < taintOffsets[i - 1]) {
+        throw new Error(
+          "block-memo: taint node start offsets are not source-ordered \u2014 a remark plugin is reordering nodes or emitting bad positions."
+        );
+      }
+    }
+  }
+  const globalCtx = JSON.stringify(ctxParts);
+  const plan = [];
+  const blocks = [];
+  const blockHasts = [];
+  let synthetic;
+  const refLocalCtx = /* @__PURE__ */ new Map();
+  {
+    const counts = /* @__PURE__ */ new Map();
+    const ranks = /* @__PURE__ */ new Map();
+    const rankOf = (id) => {
+      if (phantomFootnotes.has(id)) return -1;
+      let rank = ranks.get(id);
+      if (rank === void 0) {
+        rank = ranks.size;
+        ranks.set(id, rank);
+      }
+      return rank;
+    };
+    visit(options.contextMdast ?? mdast, (n) => {
+      if (n.type === "footnoteDefinition") {
+        rankOf(normalizeId(String(n.identifier)));
+        return SKIP;
+      }
+      if (n.type !== "footnoteReference") return;
+      const id = normalizeId(String(n.identifier));
+      const prior = counts.get(id) ?? 0;
+      refLocalCtx.set(n, [prior, rankOf(id)]);
+      counts.set(id, prior + 1);
+    });
+  }
+  for (let i = 0; i < hast.children.length; i++) {
+    const hastChild = hast.children[i];
+    if (hastChild.type !== "element") {
+      const off = hastChild.position?.start.offset;
+      const key = off !== void 0 ? `inline-${off}` : `inline-i${i}`;
+      plan.push({ kind: "inline", el: hastChild, key });
+      continue;
+    }
+    const el = hastChild;
+    if (isFootnoteSection(el)) {
+      synthetic = el;
+      plan.push({ kind: "synthetic", el, key: FOOTNOTE_SECTION_KEY });
+      continue;
+    }
+    const hastOffset = el.position?.start.offset;
+    if (hastOffset === void 0) {
+      plan.push({ kind: "inline", el, key: `inline-i${i}` });
+      continue;
+    }
+    let mdastNode = mdastByOffset.get(hastOffset);
+    let viaRangeFallback = false;
+    if (!mdastNode) {
+      mdastNode = findContainingMdast(hastOffset);
+      viaRangeFallback = mdastNode !== void 0;
+    }
+    if (!mdastNode) {
+      if (false) {
+        throw new Error(
+          `block-memo: hast block at offset ${hastOffset} has no mdast counterpart. A rehype plugin may have synthesized positions outside source. tagName=${el.tagName}`
+        );
+      }
+      plan.push({ kind: "inline", el, key: `inline-${hastOffset}` });
+      continue;
+    }
+    if (mdastNode.type === "footnoteDefinition") {
+      plan.push({ kind: "inline", el, key: `inline-${hastOffset}` });
+      continue;
+    }
+    const isRawHtmlBlock = mdastNode.type === "html" || viaRangeFallback;
+    let hasReference = false;
+    const swallowed = isRawHtmlBlock ? scanSwallowedSubtree(el) : null;
+    const footnoteRefLabels = [];
+    const linkRefLabels = [];
+    const imageRefLabels = [];
+    const footnoteDefLabels = [];
+    const local = [];
+    visit(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);
+        const ctx = refLocalCtx.get(n);
+        if (ctx) local.push([id, ctx[0], ctx[1]]);
+      } else if (n.type === "linkReference") linkRefLabels.push(id);
+      else if (n.type === "imageReference") imageRefLabels.push(id);
+      else if (n.type === "footnoteDefinition") footnoteDefLabels.push(id);
+    });
+    if (swallowed !== null && swallowed.hasReference) {
+      hasReference = true;
+      footnoteRefLabels.push(...swallowed.refLabels);
+      linkRefLabels.push(...swallowed.linkLabels);
+      imageRefLabels.push(...swallowed.imageLabels);
+      local.push(...swallowed.local);
+    }
+    const footnoteRefLocalCtx = local.length > 0 ? JSON.stringify(local) : void 0;
+    const swallowedDefCtx = swallowed !== null && swallowed.bakedDefs.length > 0 ? JSON.stringify(swallowed.bakedDefs) : void 0;
+    const mdastPos = mdastNode.position;
+    if (!mdastPos || mdastPos.start?.offset === void 0 || mdastPos.end?.offset === void 0) {
+      plan.push({ kind: "inline", el, key: `inline-${hastOffset}` });
+      continue;
+    }
+    let hastDigest;
+    let swallowedTaint = false;
+    if (isRawHtmlBlock) {
+      const d = computeHtmlBlockDigestWithExtent(el, source, mdastPos.end.offset);
+      hastDigest = d.digest;
+      const first = firstTaintAtOrAfter(mdastPos.end.offset);
+      swallowedTaint = first < taintOffsets.length && taintOffsets[first] < d.maxEnd;
+    }
+    if (swallowedTaint) hasReference = true;
+    const info = {
+      raw: extractRaw(mdastNode, source),
+      startOffset: mdastPos.start.offset,
+      endOffset: mdastPos.end.offset,
+      startLine: mdastPos.start.line,
+      startColumn: mdastPos.start.column,
+      hasReference,
+      ...hastDigest !== void 0 ? { hastDigest } : {},
+      ...swallowed?.hasFootnoteSection ? { containsFootnoteSection: true } : {},
+      ...hasReference ? {
+        taintLabels: {
+          footnoteRefLabels,
+          linkRefLabels,
+          imageRefLabels,
+          footnoteDefLabels,
+          ...footnoteRefLocalCtx !== void 0 ? { footnoteRefLocalCtx } : {},
+          ...swallowedDefCtx !== void 0 ? { swallowedDefCtx } : {}
+        }
+      } : {}
+    };
+    blocks.push(info);
+    blockHasts.push(el);
+    plan.push({ kind: "block", el, info, key: `block-${hastOffset}` });
+  }
+  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"}`);
+  }
+  if (taintLabels.footnoteRefLocalCtx !== void 0) parts.push(`fl:${taintLabels.footnoteRefLocalCtx}`);
+  if (taintLabels.swallowedDefCtx !== void 0) parts.push(`sd:${taintLabels.swallowedDefCtx}`);
+  for (const label of taintLabels.linkRefLabels) {
+    const def = registry.resolveLinkDef(label);
+    parts.push(`lr:${label}=${def ? JSON.stringify([def.url, def.title ?? null]) : "null"}`);
+  }
+  for (const label of taintLabels.imageRefLabels) {
+    const def = registry.resolveLinkDef(label);
+    parts.push(`ir:${label}=${def ? JSON.stringify([def.url, def.title ?? null]) : "null"}`);
+  }
+  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("|");
+}
+var PLACEHOLDER_TAGS = /* @__PURE__ */ new Set(["footnote-sup", "cross-chunk-link", "cross-chunk-image"]);
+function scanSwallowedSubtree(el) {
+  const refLabels = [];
+  const linkLabels = [];
+  const imageLabels = [];
+  const local = [];
+  const bakedDefs = [];
+  let hasReference = false;
+  let hasFootnoteSection = false;
+  visit(el, "element", (node) => {
+    if (isFootnoteSection(node)) {
+      hasFootnoteSection = true;
+      hasReference = true;
+      return;
+    }
+    const props = node.properties ?? {};
+    if (PLACEHOLDER_TAGS.has(node.tagName)) {
+      hasReference = true;
+      const identifier = props.identifier ?? props.label;
+      const label = identifier === void 0 ? null : normalizeId(String(identifier));
+      if (label === null) return;
+      if (node.tagName === "footnote-sup") {
+        refLabels.push(label);
+        const occ = Number(props.localOccurrence);
+        const num = Number(props.localNumber);
+        local.push([label, Number.isFinite(occ) ? occ : -1, Number.isFinite(num) ? num : -1]);
+        return;
+      }
+      if (node.tagName === "cross-chunk-link") linkLabels.push(label);
+      else imageLabels.push(label);
+      if (typeof props.localUrl === "string") {
+        bakedDefs.push([label, props.localUrl, typeof props.localTitle === "string" ? props.localTitle : null]);
+      }
+      return;
+    }
+    if (node.tagName === "a" && props.dataFootnoteRef !== void 0) hasReference = true;
+  });
+  return { hasReference, refLabels, linkLabels, imageLabels, local, bakedDefs, hasFootnoteSection };
+}
+
+// src/blockPlanner.ts
+import { visit as visit2 } from "unist-util-visit";
+var UNPAIRED_TYPES = /* @__PURE__ */ new Set(["html", "definition", "footnoteDefinition"]);
+function createBlockPlanner() {
+  let previous;
+  const eligible = /* @__PURE__ */ new WeakMap();
+  const isEligible = (node) => {
+    let result = eligible.get(node);
+    if (result === void 0) {
+      result = true;
+      visit2(node, (child) => {
+        if (UNPAIRED_TYPES.has(child.type)) result = false;
+      });
+      eligible.set(node, result);
+    }
+    return result;
+  };
+  return (mdast, hast, source, options = {}) => {
+    let m = 0;
+    let h = 0;
+    let reusedContext = false;
+    if (previous && source.startsWith(previous.source) && options.phantomFootnoteLabels === previous.phantoms) {
+      while (m < mdast.children.length) {
+        const node = mdast.children[m];
+        const el = hast.children[h];
+        const item = previous.result.plan[h];
+        if (node !== previous.mdast.children[m] || el !== previous.hast.children[h] || !el || el.type !== "element" || !item || item.kind !== "block" || item.info.startOffset !== node.position?.start.offset || !isEligible(node))
+          break;
+        reusedContext ||= item.info.hasReference;
+        m++;
+        h++;
+        while (h < hast.children.length) {
+          const gap = hast.children[h];
+          if (gap !== previous.hast.children[h] || gap.type !== "text" || /\S/.test(gap.value)) break;
+          h++;
+        }
+      }
+    }
+    let result;
+    if (m > 0 && previous) {
+      const tail = buildBlocks(
+        { ...mdast, children: mdast.children.slice(m) },
+        { ...hast, children: hast.children.slice(h) },
+        source,
+        reusedContext ? { ...options, contextMdast: options.contextMdast ?? mdast } : options
+      );
+      const prefix = previous.result.plan.slice(0, h);
+      const prefixBlocks = prefix.filter(
+        (item) => item.kind === "block"
+      );
+      result = {
+        ...tail,
+        plan: [
+          ...prefix,
+          ...tail.plan.map(
+            (item) => /^inline-i\d+$/.test(item.key) ? { ...item, key: `inline-i${Number(item.key.slice(8)) + h}` } : item
+          )
+        ],
+        blocks: [...prefixBlocks.map((item) => item.info), ...tail.blocks],
+        blockHasts: [...prefixBlocks.map((item) => item.el), ...tail.blockHasts]
+      };
+    } else result = buildBlocks(mdast, hast, source, options);
+    previous = { mdast, hast, source, result, phantoms: options.phantomFootnoteLabels };
+    return result;
+  };
+}
+
+// src/contribution.ts
+import { extractContributions, extractDefBodiesFromHast } from "@ai-markdown/engine";
+function createContributionSession() {
+  let lastContribution = null;
+  return {
+    commit({ pipeline, ownLabels, registry, targetPhantoms, sym, clobberPrefix, chain }) {
+      if (!registry || !sym) return;
+      const refs = [];
+      const defMeta = /* @__PURE__ */ new Map();
+      const linkDefs = /* @__PURE__ */ new Map();
+      for (const node of extractContributions(pipeline.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()
+      });
+      const last = lastContribution;
+      if (last?.registry === registry && last.symbol === sym && last.fp === fp && last.chain.length === chain.length && last.chain.every((dep, i) => dep === chain[i])) {
+        return;
+      }
+      const bodiesByLabel = extractDefBodiesFromHast(pipeline.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) ?? []
+        });
+      }
+      lastContribution = { registry, symbol: sym, fp, chain };
+      registry.contributeChunkData(sym, {
+        refs,
+        defs,
+        linkDefs,
+        ownFootnoteLabels: ownLabels.footnoteLabels,
+        ownLinkLabels: ownLabels.linkLabels
+      });
+    }
+  };
+}
+
+// src/smoothCoordinator.ts
+function createSmoothCoordinator(onEmpty) {
+  const order = [];
+  const done = /* @__PURE__ */ new Set();
+  const lastProgressAt = /* @__PURE__ */ new Map();
+  const coord = {
+    order,
+    done,
+    lastProgressAt,
+    version: 0,
+    _refcounts: /* @__PURE__ */ new Map(),
+    _subscribers: /* @__PURE__ */ new Set(),
+    _notifyScheduled: false,
+    register(chunkId) {
+      const count = this._refcounts.get(chunkId) ?? 0;
+      this._refcounts.set(chunkId, count + 1);
+      if (count === 0 && !order.includes(chunkId)) {
+        order.push(chunkId);
+        this._notify();
+      }
+    },
+    release(chunkId) {
+      const count = this._refcounts.get(chunkId);
+      if (count === void 0) return;
+      if (count > 1) {
+        this._refcounts.set(chunkId, count - 1);
+        return;
+      }
+      this._refcounts.set(chunkId, 0);
+      queueMicrotask(() => {
+        if (this._refcounts.get(chunkId) !== 0) return;
+        this._refcounts.delete(chunkId);
+        const idx = order.indexOf(chunkId);
+        if (idx !== -1) order.splice(idx, 1);
+        done.delete(chunkId);
+        lastProgressAt.delete(chunkId);
+        this._notify();
+        if (order.length === 0 && onEmpty) onEmpty();
+      });
+    },
+    markDone(chunkId) {
+      if (done.has(chunkId)) return;
+      done.add(chunkId);
+      this._notify();
+    },
+    stampProgress(chunkId, at) {
+      lastProgressAt.set(chunkId, at);
+    },
+    isReleased(chunkId) {
+      for (const id of order) {
+        if (id === chunkId) return true;
+        if (!done.has(id)) return false;
+      }
+      return true;
+    },
+    earliestBlockerOf(chunkId) {
+      for (const id of order) {
+        if (id === chunkId) return null;
+        if (!done.has(id)) return id;
+      }
+      return null;
+    },
+    subscribe(cb) {
+      this._subscribers.add(cb);
+      return () => {
+        this._subscribers.delete(cb);
+      };
+    },
+    _notify() {
+      this.version++;
+      if (this._notifyScheduled) return;
+      this._notifyScheduled = true;
+      queueMicrotask(() => {
+        this._notifyScheduled = false;
+        for (const cb of [...this._subscribers]) cb();
+      });
+    }
+  };
+  return coord;
+}
+function evaluateGateWarn(coordinator, chunkId, nowMs, thresholdMs) {
+  const blocker = coordinator.earliestBlockerOf(chunkId);
+  if (!blocker) return "clear";
+  const progressedAt = coordinator.lastProgressAt.get(blocker) ?? 0;
+  return nowMs - progressedAt < thresholdMs ? "rearm" : "warn";
+}
+
+// src/coordinator.ts
+function createSmoothCoordinator2(onEmpty) {
+  return createSmoothCoordinator(onEmpty);
+}
+
+// src/tailSignal.ts
+var DESCEND_THROUGH = /* @__PURE__ */ new Set(["blockquote", "list", "listItem", "footnoteDefinition"]);
+function deriveTailSignal(mdast, contentLength) {
+  const children = mdast.children;
+  let index = children.length - 1;
+  while (index >= 0) {
+    const offset = children[index].position?.start?.offset;
+    if (offset !== void 0 && offset >= contentLength) {
+      index--;
+      continue;
+    }
+    break;
+  }
+  if (index < 0) return null;
+  let node = children[index];
+  let deepestFootnoteDef = null;
+  for (; ; ) {
+    if (node.type === "footnoteDefinition") deepestFootnoteDef = node;
+    if (node.type === "definition") {
+      return { kind: "invisible-def" };
+    }
+    if (!DESCEND_THROUGH.has(node.type)) break;
+    const kids = node.children;
+    if (!kids || kids.length === 0) break;
+    node = kids[kids.length - 1];
+  }
+  return deepestFootnoteDef ? { kind: "footnote-def", identifier: deepestFootnoteDef.identifier } : null;
+}
+
+// src/aggregateFootnotes.ts
+import { footnoteSafeId, lastMeaningfulIdx } from "@ai-markdown/engine";
+
+// src/cloneHastForRender.ts
+function cloneHastForRender(node) {
+  const copy = { ...node };
+  const withChildren = copy;
+  if (Array.isArray(withChildren.children)) {
+    withChildren.children = withChildren.children.map((child) => cloneHastForRender(child));
+  }
+  const withProperties = copy;
+  if (withProperties.properties) {
+    withProperties.properties = { ...withProperties.properties };
+  }
+  return copy;
+}
+
+// src/aggregateFootnotes.ts
+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 safeId = footnoteSafeId(sourceIdentifier);
+    const liChildren = bodyHast.map((c) => cloneHastForRender(c));
+    if (withBackref) {
+      const totalRefs = registry.getRefsForLabel(normalizedLabel);
+      const tailIdx = lastMeaningfulIdx(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-${safeId}` : `#${clobberPrefix}fnref-${safeId}-${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-${safeId}`,
+        // Stringified: @types/hast (≥3.0.5) types li's `value` as string;
+        // React serializes value={3} and value="3" to identical markup.
+        ...n !== null ? { value: String(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
+      }
+    ]
+  };
+}
+
+// src/pipelineSession.ts
+import {
+  advanceIncrementalParse,
+  buildPhantomSuffix,
+  phantomSuffixCloser,
+  parseStage,
+  transformStage
+} from "@ai-markdown/engine";
+var unmeasured = (_stage, fn) => fn();
+function createPipelineSession() {
+  let state = null;
+  return {
+    reset() {
+      state = null;
+    },
+    parse({
+      content,
+      targetPhantoms,
+      remarkPlugins,
+      rehypePlugins,
+      remarkRehypeOptions,
+      handlers,
+      preserveForBodyHarvest,
+      documentId,
+      provenance,
+      incrementalParse,
+      defListEnabled,
+      measure: measureHere = unmeasured
+    }) {
+      const phantomDefs = buildPhantomSuffix(targetPhantoms);
+      const phantomSuffix = phantomDefs === "" ? "" : phantomSuffixCloser(content ?? "") + phantomDefs;
+      const augmented = (content ?? "") + phantomSuffix;
+      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,
+        // The SAME value `buildCoreRehypePlugins` received — the
+        // verifier unwraps every placeholder stamped with anything else.
+        provenance
+      } : {
+        ...remarkRehypeOptions
+      };
+      if (!incrementalParse) {
+        state = null;
+        const parsed = measureHere(
+          "parse",
+          () => parseStage({
+            children: augmented,
+            remarkPlugins,
+            rehypePlugins,
+            remarkRehypeOptions: mergedRemarkRehypeOptions
+          })
+        );
+        const hastRoot = measureHere("transform", () => transformStage(parsed));
+        return { mdast: parsed.mdast, hast: hastRoot };
+      }
+      try {
+        const result = advanceIncrementalParse(state, content ?? "", {
+          remarkPlugins,
+          rehypePlugins,
+          remarkRehypeOptions: mergedRemarkRehypeOptions,
+          // Identity tuple over every parse input beyond the content itself.
+          // Deliberately covers MORE than the G3 flush's 12 fields (handlers /
+          // preserveForBodyHarvest / documentId can change without touching
+          // any G3 field — e.g. a `preserveOrphanReferences` flip). The
+          // phantom label sets are deliberately NOT here: their churn tracks
+          // the suffix (always re-parsed with the tail), never the prefix.
+          depsKey: [
+            remarkPlugins,
+            rehypePlugins,
+            remarkRehypeOptions,
+            handlers,
+            preserveForBodyHarvest,
+            documentId,
+            // Explicit even though `rehypePlugins` already carries it: a
+            // credential change must never reuse trees stamped under the
+            // old one.
+            provenance
+          ],
+          defListEnabled,
+          phantomSuffix,
+          measure: measureHere
+        });
+        state = result.nextState;
+        return { mdast: result.mdast, hast: result.hast };
+      } catch (error) {
+        state = null;
+        if (false) {
+          console.error("[ai-react-markdown] incremental parse failed \u2014 full parse fallback for this frame:", error);
+        }
+        const parsed = measureHere(
+          "parse",
+          () => parseStage({
+            children: augmented,
+            remarkPlugins,
+            rehypePlugins,
+            remarkRehypeOptions: mergedRemarkRehypeOptions
+          })
+        );
+        const hastRoot = measureHere("transform", () => transformStage(parsed));
+        return { mdast: parsed.mdast, hast: hastRoot };
+      }
+    }
+  };
+}
+
+// src/coordinationPreparation.ts
+import { buildCrossChunkHandlers, normalizeForMatch } from "@ai-markdown/engine";
+function derivePhantomTargets({ content, ownLabels, labels }, previous) {
+  const missingFootnotes = /* @__PURE__ */ new Set();
+  const missingLinks = /* @__PURE__ */ new Set();
+  if (labels) {
+    const footnotes = [...labels.footnoteLabels].filter((label) => !ownLabels.footnoteLabels.has(label));
+    const links = [...labels.linkLabels].filter((label) => !ownLabels.linkLabels.has(label));
+    if (footnotes.length || links.length) {
+      const normalized = normalizeForMatch(content);
+      for (const label of footnotes) if (normalized.includes(label)) missingFootnotes.add(label);
+      for (const label of links) if (normalized.includes(label)) missingLinks.add(label);
+    }
+  }
+  if (previous && missingFootnotes.size === previous.missingFootnotes.size && missingLinks.size === previous.missingLinks.size && [...missingFootnotes].every((label) => previous.missingFootnotes.has(label)) && [...missingLinks].every((label) => previous.missingLinks.has(label)))
+    return previous;
+  return { missingFootnotes, missingLinks };
+}
+function deriveCoordinationPolicy({
+  coordinated,
+  registered,
+  preserveOrphanReferences
+}, previous) {
+  const mode = coordinated ? "coordinated" : preserveOrphanReferences ? "orphan" : "standalone";
+  const preserveForBodyHarvest = preserveOrphanReferences || coordinated && registered;
+  if (previous?.mode === mode && previous.preserveForBodyHarvest === preserveForBodyHarvest) return previous;
+  const handlers = previous?.mode === mode ? previous.handlers : mode === "coordinated" ? buildCrossChunkHandlers() : mode === "orphan" ? { footnoteDefinition: buildCrossChunkHandlers().footnoteDefinition } : void 0;
+  return { mode, handlers, preserveForBodyHarvest };
+}
+function buildContributionChain(inputs) {
+  return [
+    inputs.remarkPlugins,
+    inputs.rehypePlugins,
+    inputs.remarkRehypeOptions,
+    inputs.handlers,
+    inputs.preserveForBodyHarvest,
+    inputs.clobberPrefix,
+    inputs.documentId,
+    inputs.provenance
+  ];
+}
+export {
+  buildAggregateTree,
+  buildBlocks,
+  buildContributionChain,
+  cloneHastForRender,
+  computeBlockFingerprint,
+  computeHtmlBlockDigest,
+  computeHtmlBlockDigestWithExtent,
+  createBlockPlanner,
+  createContributionSession,
+  createPipelineSession,
+  createSmoothCoordinator2 as createSmoothCoordinator,
+  deriveCoordinationPolicy,
+  derivePhantomTargets,
+  deriveTailSignal,
+  evaluateGateWarn,
+  hasMdastSource,
+  isFootnoteSection
+};
+//# sourceMappingURL=index.js.map