@ai-markdown/core 3.2.2 → 3.3.0

package/dist/index.d.cts

@@ -1,116 +1,108 @@
-import { Element, RootContent, Root as Root$1, Nodes } from 'hast';
-import { Root } from 'mdast';
-import { Registry, ChunkData, PipelineOptions, AdvanceOptions } from '@ai-markdown/engine';
-export { isFootnoteSection } from '@ai-markdown/engine';
-
-/** Framework-neutral block planning and dependency fingerprints.
- * Cache ownership and conversion to framework nodes belong to adapters.
- * See apps/docs/content/guides/architecture.md and packages/core/README.md for the contract.
- */
-
+import { Element, Nodes, Root, RootContent } from "hast";
+import { Root as Root$1 } from "mdast";
+import { AdvanceOptions, ChunkData, PipelineOptions, Registry, isFootnoteSection } from "@ai-markdown/engine";
 /** Source-level identity of one renderable hast block. */
 interface BlockInfo {
-    raw: string;
-    startOffset: number;
-    endOffset: number;
-    /**
-     * Line and column at the block's start. Tracked alongside `startOffset`
-     * because two different source documents can produce the same byte offset
-     * for the "same" content (`A\n\nB\n\nTarget` vs `ABCD\n\nTarget` — both
-     * have `Target` starting at offset 6 but on different lines). Custom
-     * components that read `node.position.start.line` would otherwise see
-     * stale data from a false-positive cache hit.
-     */
-    startLine: number;
-    startColumn: number;
-    /** True if the block contains any TAINT_TYPES node — invalidate on globalCtx change. */
-    hasReference: boolean;
-    /**
-     * Structural digest of the block's hast subtree, computed ONLY for blocks
-     * that originate from raw HTML (mdast `html` nodes, or blocks resolved via
-     * the range-containment fallback). Undefined for markdown-native blocks.
-     *
-     * Why it exists: rehype-raw applies the HTML parsing algorithm, so an
-     * UNCLOSED container tag (`<details>` mid-stream, before its `</details>`
-     * arrives) swallows every FOLLOWING top-level sibling into itself —
-     * including the synthetic `<section data-footnotes>`. The block's mdast
-     * identity (raw, position, ctx) is byte-identical across all those frames,
-     * so without this digest the first swallowed snapshot would be a permanent
-     * cache hit: content rendered inside the container freezes, and when the
-     * close tag finally arrives the real nodes re-render at top level while the
-     * stale copies stay trapped in the cached container (the "duplicate
-     * footnote section inside <details>" bug).
-     *
-     * Digest composition — `maxEnd:descendantCount:hasFootnoteSection:swallowedHash`:
-     * - max end offset over the subtree catches swallowed POSITIONED siblings
-     *   (their offsets lie beyond the mdast node's own range);
-     * - descendant count catches position-less synthetic content moving in or
-     *   out (the footnote section's own element carries no position, and its
-     *   li contents point BACK at the definitions' offsets, which can be
-     *   smaller than the container's end — maxEnd alone misses that case);
-     * - the explicit dataFootnotes bit closes the degenerate corner where a
-     *   swallowed section and later real children tie on both numbers;
-     * - a hash of the swallowed extent's SOURCE (`[ownEnd, maxEnd)`) quickly
-     *   rejects most equal-length, equal-shape replacements. A matching hash
-     *   still requires an exact {@link BlockInfo.swallowedSource} comparison.
-     *
-     * Markdown-native blocks (paragraph/list/math/code/…) never receive
-     * reparented content — every hast descendant derives from their own mdast
-     * source range — so they skip the subtree walk entirely. This keeps the
-     * per-frame cost away from huge deterministic subtrees like KaTeX output.
-     */
-    hastDigest?: string;
-    /**
-     * Exact source in the swallowed interval `[ownEnd, maxEnd)` of a raw-HTML
-     * block. The FNV-1a 32-bit hash in `hastDigest` can collide for different
-     * equal-length contents, so a cache hit must compare this string too.
-     * Empty when the block swallowed no source; absent for markdown-native
-     * blocks. Optional to keep existing public block-plan producers compatible.
-     */
-    swallowedSource?: string;
-    /** A raw-HTML container that swallowed the synthesized
-     *  `<section data-footnotes>` (rehype-raw reparents the following siblings
-     *  into an unclosed `<details>` / `<div>` mid-stream). The footer is then
-     *  NOT a top-level plan item, so coordinated mode's "skip the local
-     *  footer, the aggregate renders it" rule never fired and the document
-     *  showed two `<section data-footnotes>` with colliding li ids (2026-08-19
-     *  review r2 P2-9). Coordinated renders strip it from this block's subtree;
-     *  standalone renders keep it exactly where the full parse puts it. */
-    containsFootnoteSection?: boolean;
-    /** TAINT-block 专属：按节点类型分桶的 label set。Normalized 形态（uppercase）。
-     *  Undefined when hasReference === false. */
-    taintLabels?: {
-        footnoteRefLabels: string[];
-        linkRefLabels: string[];
-        imageRefLabels: string[];
-        footnoteDefLabels: string[];
-        /** Chunk-local footnote state the engine baked into this block's
-         *  `footnote-sup` placeholders (`localOccurrence` / `localNumber` come
-         *  from a per-chunk counter over all PRECEDING refs, customMdastHandlers):
-         *  per ref label, refs-before-this-block count and first-appearance
-         *  rank. Same raw + same registry answers but a different prefix (an
-         *  in-place `[^x]`→`[^w]` edit upstream) must miss the cache, or the
-         *  stale occurrence resolves to a null global occurrence and the mark
-         *  vanishes (2026-08-19 review P2-4). Absent when the block has no refs. */
-        footnoteRefLocalCtx?: string;
-        /** Baked `localUrl` / `localTitle` of swallowed `cross-chunk-link` /
-         *  `-image` placeholders, as `[[label, url, title|null]…]` (JSON). The
-         *  render falls back to these when the registry has no canonical def,
-         *  where the fingerprint's `lr:`/`ir:` part is the constant `null` —
-         *  see scanSwallowedSubtree. Absent when nothing was swallowed. */
-        swallowedDefCtx?: string;
-    };
+  raw: string;
+  startOffset: number;
+  endOffset: number;
+  /**
+   * Line and column at the block's start. Tracked alongside `startOffset`
+   * because two different source documents can produce the same byte offset
+   * for the "same" content (`A\n\nB\n\nTarget` vs `ABCD\n\nTarget` — both
+   * have `Target` starting at offset 6 but on different lines). Custom
+   * components that read `node.position.start.line` would otherwise see
+   * stale data from a false-positive cache hit.
+   */
+  startLine: number;
+  startColumn: number;
+  /** True if the block contains any TAINT_TYPES node — invalidate on globalCtx change. */
+  hasReference: boolean;
+  /**
+   * Structural digest of the block's hast subtree, computed ONLY for blocks
+   * that originate from raw HTML (mdast `html` nodes, or blocks resolved via
+   * the range-containment fallback). Undefined for markdown-native blocks.
+   *
+   * Why it exists: rehype-raw applies the HTML parsing algorithm, so an
+   * UNCLOSED container tag (`<details>` mid-stream, before its `</details>`
+   * arrives) swallows every FOLLOWING top-level sibling into itself —
+   * including the synthetic `<section data-footnotes>`. The block's mdast
+   * identity (raw, position, ctx) is byte-identical across all those frames,
+   * so without this digest the first swallowed snapshot would be a permanent
+   * cache hit: content rendered inside the container freezes, and when the
+   * close tag finally arrives the real nodes re-render at top level while the
+   * stale copies stay trapped in the cached container (the "duplicate
+   * footnote section inside <details>" bug).
+   *
+   * Digest composition — `maxEnd:descendantCount:hasFootnoteSection:swallowedHash`:
+   * - max end offset over the subtree catches swallowed POSITIONED siblings
+   *   (their offsets lie beyond the mdast node's own range);
+   * - descendant count catches position-less synthetic content moving in or
+   *   out (the footnote section's own element carries no position, and its
+   *   li contents point BACK at the definitions' offsets, which can be
+   *   smaller than the container's end — maxEnd alone misses that case);
+   * - the explicit dataFootnotes bit closes the degenerate corner where a
+   *   swallowed section and later real children tie on both numbers;
+   * - a hash of the swallowed extent's SOURCE (`[ownEnd, maxEnd)`) quickly
+   *   rejects most equal-length, equal-shape replacements. A matching hash
+   *   still requires an exact {@link BlockInfo.swallowedSource} comparison.
+   *
+   * Markdown-native blocks (paragraph/list/math/code/…) never receive
+   * reparented content — every hast descendant derives from their own mdast
+   * source range — so they skip the subtree walk entirely. This keeps the
+   * per-frame cost away from huge deterministic subtrees like KaTeX output.
+   */
+  hastDigest?: string;
+  /**
+   * Exact source in the swallowed interval `[ownEnd, maxEnd)` of a raw-HTML
+   * block. The FNV-1a 32-bit hash in `hastDigest` can collide for different
+   * equal-length contents, so a cache hit must compare this string too.
+   * Empty when the block swallowed no source; absent for markdown-native
+   * blocks. Optional to keep existing public block-plan producers compatible.
+   */
+  swallowedSource?: string;
+  /** A raw-HTML container that swallowed the synthesized
+   *  `<section data-footnotes>` (rehype-raw reparents the following siblings
+   *  into an unclosed `<details>` / `<div>` mid-stream). The footer is then
+   *  NOT a top-level plan item, so coordinated mode's "skip the local
+   *  footer, the aggregate renders it" rule never fired and the document
+   *  showed two `<section data-footnotes>` with colliding li ids (2026-08-19
+   *  review r2 P2-9). Coordinated renders strip it from this block's subtree;
+   *  standalone renders keep it exactly where the full parse puts it. */
+  containsFootnoteSection?: boolean;
+  /** TAINT-block 专属：按节点类型分桶的 label set。Normalized 形态（uppercase）。
+   *  Undefined when hasReference === false. */
+  taintLabels?: {
+    footnoteRefLabels: string[];
+    linkRefLabels: string[];
+    imageRefLabels: string[];
+    footnoteDefLabels: string[];
+    /** Chunk-local footnote state the engine baked into this block's
+     *  `footnote-sup` placeholders (`localOccurrence` / `localNumber` come
+     *  from a per-chunk counter over all PRECEDING refs, customMdastHandlers):
+     *  per ref label, refs-before-this-block count and first-appearance
+     *  rank. Same raw + same registry answers but a different prefix (an
+     *  in-place `[^x]`→`[^w]` edit upstream) must miss the cache, or the
+     *  stale occurrence resolves to a null global occurrence and the mark
+     *  vanishes (2026-08-19 review P2-4). Absent when the block has no refs. */
+    footnoteRefLocalCtx?: string;
+    /** Baked `localUrl` / `localTitle` of swallowed `cross-chunk-link` /
+     *  `-image` placeholders, as `[[label, url, title|null]…]` (JSON). The
+     *  render falls back to these when the registry has no canonical def,
+     *  where the fingerprint's `lr:`/`ir:` part is the constant `null` —
+     *  see scanSwallowedSubtree. Absent when nothing was swallowed. */
+    swallowedDefCtx?: string;
+  };
 }
-
 /** Dev invariant: every block hast child must retain its mdast `position`. */
-declare function hasMdastSource(node: Element): boolean;
+export declare function hasMdastSource(node: Element): boolean;
 /**
  * Compute {@link BlockInfo.hastDigest} for a raw-HTML block: iterative walk
  * over the hast subtree collecting (max end offset, descendant count,
  * contains-footnote-section). See the field's JSDoc for why each component
  * is load-bearing. Exported for tests.
  */
-declare function computeHtmlBlockDigest(el: Element, source?: string, ownEnd?: number): string;
+export declare function computeHtmlBlockDigest(el: Element, source?: string, ownEnd?: number): string;
 /** {@link computeHtmlBlockDigest} plus the subtree's max end offset — the end
  *  of the SWALLOWED extent, which callers need to ask what fell inside.
  *
@@ -124,9 +116,9 @@ declare function computeHtmlBlockDigest(el: Element, source?: string, ownEnd?: n
  *  opening tag. The descendant walk covers it a second time. Verified in
  *  2026-08-20 A1 across 162 container/tail shapes: destroying either source
  *  alone changes nothing, destroying both under-taints 130 of them. */
-declare function computeHtmlBlockDigestWithExtent(el: Element, source?: string, ownEnd?: number): {
-    digest: string;
-    maxEnd: number;
+export declare function computeHtmlBlockDigestWithExtent(el: Element, source?: string, ownEnd?: number): {
+  digest: string;
+  maxEnd: number;
 };
 /**
  * One step of the document render plan, in source order.
@@ -145,45 +137,45 @@ declare function computeHtmlBlockDigestWithExtent(el: Element, source?: string,
  *   in a single slot keyed by `globalCtx`.
  */
 type RenderItem = {
-    kind: 'block';
-    el: Element;
-    key: string;
-    info: BlockInfo;
+  kind: 'block';
+  el: Element;
+  key: string;
+  info: BlockInfo;
 } | {
-    kind: 'inline';
-    el: RootContent;
-    key: string;
+  kind: 'inline';
+  el: RootContent;
+  key: string;
 } | {
-    kind: 'synthetic';
-    el: Element;
-    key: string;
+  kind: 'synthetic';
+  el: Element;
+  key: string;
 };
 /** Extra render-time facts {@link buildBlocks} cannot read off the trees. */
 interface BuildBlocksOptions {
-    /** Full document when planning only a tail. Its ordered reference and
-     * definition context seeds numbering and invalidation for tail blocks. */
-    contextMdast?: Root;
-    /**
-     * Labels this chunk phantom-injected because another chunk defines them
-     * (already normalized). The coordinated handlers keep these out of
-     * `state.footnoteOrder`, so the cache key's rank must keep them out too —
-     * see the note in the rank pass. Empty / omitted in standalone mode, where
-     * no phantom injection happened.
-     */
-    phantomFootnoteLabels?: ReadonlySet<string>;
+  /** Full document when planning only a tail. Its ordered reference and
+   * definition context seeds numbering and invalidation for tail blocks. */
+  contextMdast?: Root$1;
+  /**
+   * Labels this chunk phantom-injected because another chunk defines them
+   * (already normalized). The coordinated handlers keep these out of
+   * `state.footnoteOrder`, so the cache key's rank must keep them out too —
+   * see the note in the rank pass. Empty / omitted in standalone mode, where
+   * no phantom injection happened.
+   */
+  phantomFootnoteLabels?: ReadonlySet<string>;
 }
 /** Result of {@link buildBlocks}. */
 interface BuildBlocksResult {
-    /** Render plan in document order — drives the adapter’s block cache. */
-    plan: RenderItem[];
-    /** JSON-stringified ordered list of TAINT-typed nodes in document order. */
-    globalCtx: string;
-    /** Flat list of `BlockInfo` for cacheable blocks, in document order. */
-    blocks: BlockInfo[];
-    /** 1:1 with `blocks` — the hast Element each BlockInfo refers to. */
-    blockHasts: Element[];
-    /** Synthesized footnote section, if present. */
-    synthetic?: Element;
+  /** Render plan in document order — drives the adapter’s block cache. */
+  plan: RenderItem[];
+  /** JSON-stringified ordered list of TAINT-typed nodes in document order. */
+  globalCtx: string;
+  /** Flat list of `BlockInfo` for cacheable blocks, in document order. */
+  blocks: BlockInfo[];
+  /** 1:1 with `blocks` — the hast Element each BlockInfo refers to. */
+  blockHasts: Element[];
+  /** Synthesized footnote section, if present. */
+  synthetic?: Element;
 }
 /**
  * Build the document render plan + ctx digest from a parsed mdast and its
@@ -217,7 +209,7 @@ interface BuildBlocksResult {
  * numbering), then JSON-stringifies the collected tuples. That string is the
  * invalidation key for tainted blocks and the synthetic footnote section.
  */
-declare function buildBlocks(mdast: Root, hast: Root$1, source: string, options?: BuildBlocksOptions): BuildBlocksResult;
+export declare function buildBlocks(mdast: Root$1, hast: Root, source: string, options?: BuildBlocksOptions): BuildBlocksResult;
 /**
  * Compute a per-block cache fingerprint from the registry slice this block
  * actually depends on (footnote/link/image refs and footnote defs). Two blocks
@@ -232,9 +224,8 @@ declare function buildBlocks(mdast: Root, hast: Root$1, source: string, options?
  * @param thisChunkSym- The Symbol of the chunk this rendering belongs to (for canonical-vs-this comparison).
  * @param clobberPrefix - The documentId-derived id prefix; included so href/id changes invalidate.
  */
-declare function computeBlockFingerprint(taintLabels: NonNullable<BlockInfo['taintLabels']>, registry: Registry, thisChunkSym: symbol, clobberPrefix: string): string;
-
-type BlockPlanner = (mdast: Root, hast: Root$1, source: string, options?: BuildBlocksOptions) => BuildBlocksResult;
+export declare function computeBlockFingerprint(taintLabels: NonNullable<BlockInfo['taintLabels']>, registry: Registry, thisChunkSym: symbol, clobberPrefix: string): string;
+type BlockPlanner = (mdast: Root$1, hast: Root, source: string, options?: BuildBlocksOptions) => BuildBlocksResult;
 /** Reuse the engine's retained prefix plans, including reference blocks.
  * Reference prefixes require full-document context when planning the tail.
  * Raw HTML and definition regions retain complete planning: their ownership
@@ -242,42 +233,40 @@ type BlockPlanner = (mdast: Root, hast: Root$1, source: string, options?: BuildB
  * guesses, establish which trees the incremental engine actually retained.
  * Top-level traversal remains O(blocks); reference context still visits the
  * full mdast when needed, while per-block HAST planning is tail-only. */
-declare function createBlockPlanner(): BlockPlanner;
-
+export declare function createBlockPlanner(): BlockPlanner;
 /** Minimal write capability; registration and cleanup remain with the adapter. */
 interface ContributionRegistry {
-    contributeChunkData(symbol: symbol, data: ChunkData): void;
+  contributeChunkData(symbol: symbol, data: ChunkData): void;
 }
 interface ContributionOptions {
-    pipeline: {
-        mdast: Root;
-        hast: Root$1;
-    };
-    ownLabels: {
-        footnoteLabels: Set<string>;
-        linkLabels: Set<string>;
-    };
-    registry: ContributionRegistry | null;
-    targetPhantoms: {
-        missingFootnotes: Set<string>;
-        missingLinks: Set<string>;
-    };
-    sym: symbol | null;
-    clobberPrefix: string;
-    /** Stable identity tuple of parse inputs. Source equality alone cannot
-     * validate definition bodies after a plugin or schema change. */
-    chain: readonly unknown[];
+  pipeline: {
+    mdast: Root$1;
+    hast: Root;
+  };
+  ownLabels: {
+    footnoteLabels: Set<string>;
+    linkLabels: Set<string>;
+  };
+  registry: ContributionRegistry | null;
+  targetPhantoms: {
+    missingFootnotes: Set<string>;
+    missingLinks: Set<string>;
+  };
+  sym: symbol | null;
+  clobberPrefix: string;
+  /** Stable identity tuple of parse inputs. Source equality alone cannot
+   * validate definition bodies after a plugin or schema change. */
+  chain: readonly unknown[];
 }
 interface ContributionSession {
-    commit(options: ContributionOptions): void;
+  commit(options: ContributionOptions): void;
 }
 /** Create one contribution publisher per mounted chunk.
  * Call commit only in the host's commit/effect phase, after registration.
  * Constructing a session does not register or publish anything. A discarded
  * render must never call commit. The host owns registration and cleanup.
  */
-declare function createContributionSession(): ContributionSession;
-
+export declare function createContributionSession(): ContributionSession;
 /**
  * Turn-taking coordinator for smooth-streaming chunks that share a
  * `documentId` under `<AIMarkdownDocuments>`.
@@ -307,42 +296,42 @@ declare function createContributionSession(): ContributionSession;
  * @module components/smoothStream/coordinator
  */
 interface SmoothCoordinator {
-    /** Chunk mount-order chunkId list. **Read-only** — mutation corrupts the
-     *  release predicate for every successor. */
-    readonly order: readonly string[];
-    /** Chunk IDs that have reported done. Sticky: entries are only removed
-     *  when the chunk unregisters. **Read-only.** */
-    readonly done: ReadonlySet<string>;
-    /** Reveal-progress heartbeat, ms timestamps from the reporting chunk's
-     *  clock. Written WITHOUT a version bump (see module doc). */
-    readonly lastProgressAt: ReadonlyMap<string, number>;
-    /** Monotonic counter bumped by every gating-relevant mutation
-     *  (register / unregister / done transition). */
-    readonly version: number;
-    subscribe(cb: () => void): () => void;
-    /** Allocate (or refcount-reuse, for Strict Mode remounts) this chunk's
-     *  slot at the current end of the mount order. */
-    register(chunkId: string): void;
-    /** Refcount decrement with microtask-deferred reclaim; the last release
-     *  removes the chunk from the order (waking successors) and, when the
-     *  coordinator empties, fires the container's `onEmpty`. */
-    release(chunkId: string): void;
-    /** Sticky, idempotent: the first call per chunk bumps the version; the
-     *  transition is never retracted while the chunk stays mounted (a
-     *  predecessor that un-finishes must not re-gate successors). */
-    markDone(chunkId: string): void;
-    /** Heartbeat stamp — no version bump, no fanout. */
-    stampProgress(chunkId: string, at: number): void;
-    /** True when every registered chunk BEFORE `chunkId` in the order has
-     *  reported done. Unregistered predecessors don't exist here, so they
-     *  never block. A `chunkId` that is not (yet) registered itself is
-     *  treated as sitting AFTER every registered chunk — a pre-registration
-     *  query must not release a chunk whose predecessors are still
-     *  revealing. */
-    isReleased(chunkId: string): boolean;
-    /** The earliest not-done registered chunk before `chunkId`, or null.
-     *  Read by the dev-only stuck-flag warning timer. */
-    earliestBlockerOf(chunkId: string): string | null;
+  /** Chunk mount-order chunkId list. **Read-only** — mutation corrupts the
+   *  release predicate for every successor. */
+  readonly order: readonly string[];
+  /** Chunk IDs that have reported done. Sticky: entries are only removed
+   *  when the chunk unregisters. **Read-only.** */
+  readonly done: ReadonlySet<string>;
+  /** Reveal-progress heartbeat, ms timestamps from the reporting chunk's
+   *  clock. Written WITHOUT a version bump (see module doc). */
+  readonly lastProgressAt: ReadonlyMap<string, number>;
+  /** Monotonic counter bumped by every gating-relevant mutation
+   *  (register / unregister / done transition). */
+  readonly version: number;
+  subscribe(cb: () => void): () => void;
+  /** Allocate (or refcount-reuse, for Strict Mode remounts) this chunk's
+   *  slot at the current end of the mount order. */
+  register(chunkId: string): void;
+  /** Refcount decrement with microtask-deferred reclaim; the last release
+   *  removes the chunk from the order (waking successors) and, when the
+   *  coordinator empties, fires the container's `onEmpty`. */
+  release(chunkId: string): void;
+  /** Sticky, idempotent: the first call per chunk bumps the version; the
+   *  transition is never retracted while the chunk stays mounted (a
+   *  predecessor that un-finishes must not re-gate successors). */
+  markDone(chunkId: string): void;
+  /** Heartbeat stamp — no version bump, no fanout. */
+  stampProgress(chunkId: string, at: number): void;
+  /** True when every registered chunk BEFORE `chunkId` in the order has
+   *  reported done. Unregistered predecessors don't exist here, so they
+   *  never block. A `chunkId` that is not (yet) registered itself is
+   *  treated as sitting AFTER every registered chunk — a pre-registration
+   *  query must not release a chunk whose predecessors are still
+   *  revealing. */
+  isReleased(chunkId: string): boolean;
+  /** The earliest not-done registered chunk before `chunkId`, or null.
+   *  Read by the dev-only stuck-flag warning timer. */
+  earliestBlockerOf(chunkId: string): string | null;
 }
 /** Outcome of one stuck-flag warning timer firing (dev-only diagnostics). */
 type GateWarnVerdict = 'warn' | 'rearm' | 'clear';
@@ -360,54 +349,30 @@ type GateWarnVerdict = 'warn' | 'rearm' | 'clear';
  *   threshold while this chunk stayed gated — the predecessor's
  *   `streaming` flag is likely stuck.
  */
-declare function evaluateGateWarn(coordinator: SmoothCoordinator, chunkId: string, nowMs: number, thresholdMs: number): GateWarnVerdict;
-
+export declare function evaluateGateWarn(coordinator: SmoothCoordinator, chunkId: string, nowMs: number, thresholdMs: number): GateWarnVerdict;
 /** Create one turn-taking scope.
  * Why: sibling chunks coordinate reveal without a framework or DOM dependency.
  * Recommended pattern: register after mount, report sticky completion, release on unmount.
  * Footguns: registration order controls reveal; completion cannot be retracted.
  */
-declare function createSmoothCoordinator(onEmpty?: () => void): SmoothCoordinator;
-
-/**
- * Source-tail classification for the streaming cursor.
- *
- * The cursor's DOM walk cannot know whether the source tail is in the body
- * or inside a footnote definition — mdast-util-to-hast relocates every
- * definition into the synthetic end-of-document footer, decoupling the
- * footer's DOM position from source position. This module answers the
- * question at the mdast level, where micromark has already made every
- * grammar decision (lazy continuation lines, container nesting, blank-line
- * attachment, label escapes): the renderer derives a signal per frame from
- * the tree it is about to render and stamps it on a DOM marker the cursor
- * shell reads in the same commit.
- *
- * Deliberately NOT a text scan of the trailing lines: a hand-rolled
- * back-walk would be a third parallel grammar in the repo and provably
- * mis-classifies lazy continuations (`[^1]: line\nline2` keeps line2 in
- * the definition with zero indentation), resurfacing the exact bug this
- * exists to fix.
- *
- * @module components/streamingCursor/tailSignal
- */
-
-type TailSignal = 
+export declare function createSmoothCoordinator(onEmpty?: () => void): SmoothCoordinator;
+type TailSignal =
 /** The source tail is inside a footnote definition — its text renders in
  *  the footnote footer's `<li>` for `identifier` (mdast's case-folded
  *  form), not at the body tail. */
 {
-    kind: 'footnote-def';
-    identifier: string;
-}
+  kind: 'footnote-def';
+  identifier: string;
+} |
 /** The source tail is inside a link-reference definition — it renders
  *  nothing at all; the cursor should hide rather than point at stale
  *  body text. */
- | {
-    kind: 'invisible-def';
-}
+{
+  kind: 'invisible-def';
+} |
 /** The source tail is ordinary body content — the DOM-tail heuristic is
  *  correct as-is. */
- | null;
+null;
 /**
  * Classify the source tail of `mdast`.
  *
@@ -422,114 +387,83 @@ type TailSignal =
  *   several phantoms is a normal shape) and classifies the first real
  *   node.
  */
-declare function deriveTailSignal(mdast: Root, contentLength: number): TailSignal;
-
-/** Assemble document footnotes as HAST without framework nodes or DOM access. */
-
-declare function buildAggregateTree(registry: Registry, clobberPrefix: string, preserveOrphanReferences?: boolean): Element | null;
-
-/**
- * Structural clone of a hast subtree for render-time use.
- *
- * Copies exactly what the render-time mutators touch — every node object,
- * its `children` array (the allow/disallow filters splice it), and its
- * `properties` object (`urlTransform` overwrites `href`/`src`) — while
- * SHARING `position`, arbitrary nested plugin data, string values, and individual property values
- * by reference. This is both cheaper than a JSON round-trip (no string
- * intermediate; `position` objects, typically over half of a serialized
- * hast, are never materialized) and exact for any tree the pipeline
- * produces (no lossy JSON semantics to reason about).
- *
- * @module components/cloneHastForRender
- */
-
+export declare function deriveTailSignal(mdast: Root$1, contentLength: number): TailSignal;
+export declare function buildAggregateTree(registry: Registry, clobberPrefix: string, preserveOrphanReferences?: boolean): Element | null;
 /** See module docs. Safe for any hast node union member. */
-declare function cloneHastForRender<T extends Nodes>(node: T): T;
-
-/** Per-consumer parse state and full/incremental fallback policy.
- * The host decides whether a next frame is expected (false for SSR), owns
- * this session, and resets it when render policy invalidates retained trees.
- * Parsing does not register chunks or publish document contributions.
- * Fallback order: incremental → full pipeline → plain-text frame, the last
- * step ONLY for the engine's raw-depth signal (see plainTextTrees); any
- * other full-pipeline throw, a consumer plugin's included, escapes `parse`.
- */
-
+export declare function cloneHastForRender<T extends Nodes>(node: T): T;
 interface PipelineTrees {
-    mdast: Root;
-    hast: Root$1;
+  mdast: Root$1;
+  hast: Root;
 }
 interface PipelineSession {
-    /** Drop retained incremental state. Does not dispose host subscriptions. */
-    reset(): void;
-    /** Read-only borrowed trees: clone before destructive rendering. */
-    parse(options: PipelineFrameOptions): PipelineTrees;
+  /** Drop retained incremental state. Does not dispose host subscriptions. */
+  reset(): void;
+  /** Read-only borrowed trees: clone before destructive rendering. */
+  parse(options: PipelineFrameOptions): PipelineTrees;
 }
 type RemarkRehypeOptions = NonNullable<PipelineOptions['remarkRehypeOptions']>;
 interface PipelineFrameOptions {
-    content: string;
-    targetPhantoms: {
-        missingFootnotes: Set<string>;
-        missingLinks: Set<string>;
-    };
-    remarkPlugins: PipelineOptions['remarkPlugins'];
-    rehypePlugins: PipelineOptions['rehypePlugins'];
-    remarkRehypeOptions: PipelineOptions['remarkRehypeOptions'];
-    handlers?: RemarkRehypeOptions['handlers'];
-    preserveForBodyHarvest: boolean;
-    documentId: string;
-    provenance: string;
-    /** False for a one-shot server render; no browser-global probe is needed. */
-    incrementalParse: boolean;
-    defListEnabled: boolean;
-    /** Whether `remarkPlugins` parses GFM task-list items. Default `false`
-     *  (the boundary scanner keeps every `[x]` as reference taint). The
-     *  adapters pass `true` because they build the chain with
-     *  `buildCoreRemarkPlugins`, which always includes remark-gfm. A box
-     *  whose paragraph a `$$` opener closed is released only when
-     *  `mathFlow` is `true` as well. */
-    gfmTaskListItems?: boolean;
-    /** Whether `remarkPlugins` parses `$$` flow math (remark-math). Passed
-     *  through to the engine in all three states: `true` declares it (a
-     *  `$$` region is verbatim math), `false` declares its absence (`$$`
-     *  lines are paragraph text), and omitted leaves it unknown — the
-     *  scanner then takes the union of both grammars, which is correct for
-     *  either chain and freezes less around `$$`. The adapters pass `true`
-     *  because `buildCoreRemarkPlugins` always includes remark-math; a
-     *  caller with its own chain should declare the real value and may
-     *  leave it out when unsure. */
-    mathFlow?: boolean;
-    measure?: AdvanceOptions['measure'];
+  content: string;
+  targetPhantoms: {
+    missingFootnotes: Set<string>;
+    missingLinks: Set<string>;
+  };
+  remarkPlugins: PipelineOptions['remarkPlugins'];
+  rehypePlugins: PipelineOptions['rehypePlugins'];
+  remarkRehypeOptions: PipelineOptions['remarkRehypeOptions'];
+  handlers?: RemarkRehypeOptions['handlers'];
+  preserveForBodyHarvest: boolean;
+  documentId: string;
+  provenance: string;
+  /** False for a one-shot server render; no browser-global probe is needed. */
+  incrementalParse: boolean;
+  defListEnabled: boolean;
+  /** Whether `remarkPlugins` parses GFM task-list items. Default `false`
+   *  (the boundary scanner keeps every `[x]` as reference taint). The
+   *  adapters pass `true` because they build the chain with
+   *  `buildCoreRemarkPlugins`, which always includes remark-gfm. A box
+   *  whose paragraph a `$$` opener closed is released only when
+   *  `mathFlow` is `true` as well. */
+  gfmTaskListItems?: boolean;
+  /** Whether `remarkPlugins` parses `$$` flow math (remark-math). Passed
+   *  through to the engine in all three states: `true` declares it (a
+   *  `$$` region is verbatim math), `false` declares its absence (`$$`
+   *  lines are paragraph text), and omitted leaves it unknown — the
+   *  scanner then takes the union of both grammars, which is correct for
+   *  either chain and freezes less around `$$`. The adapters pass `true`
+   *  because `buildCoreRemarkPlugins` always includes remark-math; a
+   *  caller with its own chain should declare the real value and may
+   *  leave it out when unsure. */
+  mathFlow?: boolean;
+  measure?: AdvanceOptions['measure'];
 }
-declare function createPipelineSession(): PipelineSession;
-
+export declare function createPipelineSession(): PipelineSession;
 interface DefinitionLabels {
-    footnoteLabels: ReadonlySet<string>;
-    linkLabels: ReadonlySet<string>;
+  footnoteLabels: ReadonlySet<string>;
+  linkLabels: ReadonlySet<string>;
 }
 type PhantomTargets = PipelineFrameOptions['targetPhantoms'];
-declare function derivePhantomTargets({ content, ownLabels, labels }: {
-    content: string;
-    ownLabels: DefinitionLabels;
-    labels: DefinitionLabels | null;
+export declare function derivePhantomTargets({ content, ownLabels, labels }: {
+  content: string;
+  ownLabels: DefinitionLabels;
+  labels: DefinitionLabels | null;
 }, previous?: PhantomTargets): PhantomTargets;
 interface CoordinationPolicy {
-    mode: 'coordinated' | 'orphan' | 'standalone';
-    handlers: PipelineFrameOptions['handlers'];
-    preserveForBodyHarvest: boolean;
+  mode: 'coordinated' | 'orphan' | 'standalone';
+  handlers: PipelineFrameOptions['handlers'];
+  preserveForBodyHarvest: boolean;
 }
-declare function deriveCoordinationPolicy({ coordinated, registered, preserveOrphanReferences, }: {
-    coordinated: boolean;
-    registered: boolean;
-    /** The host has already resolved any wrapper-level override. */
-    preserveOrphanReferences: boolean;
+export declare function deriveCoordinationPolicy({ coordinated, registered, preserveOrphanReferences }: {
+  coordinated: boolean;
+  registered: boolean;
+  /** The host has already resolved any wrapper-level override. */
+  preserveOrphanReferences: boolean;
 }, previous?: CoordinationPolicy): CoordinationPolicy;
 type ContributionPolicyInputs = Pick<PipelineFrameOptions, 'remarkPlugins' | 'rehypePlugins' | 'remarkRehypeOptions' | 'handlers' | 'preserveForBodyHarvest' | 'documentId' | 'provenance'> & {
-    clobberPrefix: string;
+  clobberPrefix: string;
 };
 /** Source/phantom/registry/symbol changes are compared by the publisher itself.
  * This tuple covers the remaining inputs that can alter harvested bodies.
  */
-declare function buildContributionChain(inputs: ContributionPolicyInputs): readonly unknown[];
-
-export { type BlockInfo, type BlockPlanner, type BuildBlocksOptions, type BuildBlocksResult, type ContributionOptions, type ContributionPolicyInputs, type ContributionRegistry, type ContributionSession, type CoordinationPolicy, type DefinitionLabels, type GateWarnVerdict, type PhantomTargets, type PipelineFrameOptions, type PipelineSession, type PipelineTrees, type RenderItem, type SmoothCoordinator, type TailSignal, buildAggregateTree, buildBlocks, buildContributionChain, cloneHastForRender, computeBlockFingerprint, computeHtmlBlockDigest, computeHtmlBlockDigestWithExtent, createBlockPlanner, createContributionSession, createPipelineSession, createSmoothCoordinator, deriveCoordinationPolicy, derivePhantomTargets, deriveTailSignal, evaluateGateWarn, hasMdastSource };
+export declare function buildContributionChain(inputs: ContributionPolicyInputs): readonly unknown[];
+export { type BlockInfo, type BlockPlanner, type BuildBlocksOptions, type BuildBlocksResult, type ContributionOptions, type ContributionPolicyInputs, type ContributionRegistry, type ContributionSession, type CoordinationPolicy, type DefinitionLabels, type GateWarnVerdict, type PhantomTargets, type PipelineFrameOptions, type PipelineSession, type PipelineTrees, type RenderItem, type SmoothCoordinator, type TailSignal, isFootnoteSection };