@ai-markdown/core 3.0.0-beta.1

package/dist/index.d.ts

@@ -0,0 +1,497 @@
+import * as hast from 'hast';
+import { Element, RootContent, Root as Root$1, Nodes } from 'hast';
+import * as mdast from 'mdast';
+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 docs/architecture.md and packages/core/README.md for the contract.
+ */
+
+/** 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)`) catches
+     *   an equal-length, equal-shape single-frame replacement of the
+     *   swallowed siblings, which leaves every count unchanged.
+     *
+     * 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;
+    /** 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;
+/**
+ * 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;
+/** {@link computeHtmlBlockDigest} plus the subtree's max end offset — the end
+ *  of the SWALLOWED extent, which callers need to ask what fell inside.
+ *
+ *  Both position sources here are HAST offsets, and every use of the extent
+ *  is unsafe in the SHORT direction (too small and a swallowed reference
+ *  escapes the taint test, so an edit to a definition outside the container
+ *  leaves a stale href in the cache). They are redundant on purpose: the
+ *  container's own end already reaches past the swallowed blocks, because
+ *  `rehype-raw` reparses the raw string and closes the element wherever
+ *  parse5 does — NOT where the mdast `html` node ends, which is just the
+ *  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;
+};
+/**
+ * One step of the document render plan, in source order.
+ *
+ * The plan covers EVERY top-level hast child so that the adapter’s block cache
+ * can preserve react-markdown's byte-equivalent output — including the whitespace
+ * `text` nodes that `mdast-util-to-hast` inserts between block elements.
+ *
+ * - `block`: a hast element with an mdast counterpart, eligible for caching by
+ *   `(raw, occurrence index, ctx, startOffset)`.
+ * - `inline`: a non-element top-level child (whitespace text, comment, …) or
+ *   an element that has no mdast counterpart but is still safe to render.
+ *   These are rendered every frame without caching — they are typically
+ *   single whitespace characters.
+ * - `synthetic`: the synthesized footnote `<section data-footnotes>`, cached
+ *   in a single slot keyed by `globalCtx`.
+ */
+type RenderItem = {
+    kind: 'block';
+    el: Element;
+    key: string;
+    info: BlockInfo;
+} | {
+    kind: 'inline';
+    el: RootContent;
+    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>;
+}
+/** 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;
+}
+/**
+ * Build the document render plan + ctx digest from a parsed mdast and its
+ * rendered hast.
+ *
+ * Plan construction is driven by `hast.children` (NOT `mdast.children`):
+ * pipeline transformers like `remarkSqueezeParagraphs` and
+ * `remarkRemoveComments` drop blocks, so the rendered hast may have fewer
+ * top-level children than the parsed mdast. Driving by hast guarantees the
+ * plan covers exactly what will be rendered.
+ *
+ * Each hast top-level child becomes one plan item:
+ * - `<section data-footnotes>` → `synthetic` (cached in a single slot)
+ * - element with mdast counterpart → `block` (cacheable by raw + occurrence + ctx + offset)
+ * - text / comment / element-without-counterpart → `inline` (rendered fresh every frame)
+ *
+ * The mdast counterpart of a block element is found by source offset using
+ * a two-tier lookup: an exact-offset Map (mdast-util-to-hast's default 1:1
+ * propagation), then range-containment `findLast` fallback for cases like
+ * `rehype-raw` splitting one mdast `html` node into multiple hast siblings
+ * (e.g. `   <div>Hi</div>` — leading spaces shift the `<div>` offset
+ * inside the parent html node's source range).
+ *
+ * In dev, a hast block whose offset matches no mdast counterpart at all
+ * throws — that means a rehype plugin synthesized positions outside the
+ * source range, which is a bug worth surfacing. In production it falls
+ * through to an `inline` plan item so user content is never silently lost.
+ *
+ * `globalCtx` walks the full mdast for footnote/link/image refs and
+ * definitions in document order (no dedupe — order matters for footnote
+ * 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;
+/**
+ * Compute a per-block cache fingerprint from the registry slice this block
+ * actually depends on (footnote/link/image refs and footnote defs). Two blocks
+ * with the same fingerprint render byte-equal output; if any encoded value
+ * differs, the block must re-render.
+ *
+ * Encoding format (deterministic, stable across versions):
+ *   `<clobberPrefix>|fn:<L>=<globalNumber>|fl:<[[L,prior,rank]…]>|lr:<L>=<url>|<title>|ir:<L>=<url>|fd:<L>=<canonical>/<refCount>`
+ *
+ * @param taintLabels - Per-block label dependency footprint (from BlockInfo.taintLabels).
+ * @param registry    - Shared cross-chunk registry.
+ * @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;
+
+/** 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
+ * need not be one-to-one. Identity checks, not source-text
+ * 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(): (mdast: Root, hast: Root$1, source: string, options?: BuildBlocksOptions) => BuildBlocksResult;
+
+/** Minimal write capability; registration and cleanup remain with the adapter. */
+interface ContributionRegistry {
+    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[];
+}
+/** 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(): {
+    commit({ pipeline, ownLabels, registry, targetPhantoms, sym, clobberPrefix, chain }: ContributionOptions): void;
+};
+
+/**
+ * Turn-taking coordinator for smooth-streaming chunks that share a
+ * `documentId` under `<AIMarkdownDocuments>`.
+ *
+ * Each `useDocumentSmoothStream` chunk registers here in mount order and
+ * reports a sticky `done` (source stopped AND reveal drained). A chunk that
+ * mounted with empty content stays gated until every REGISTERED chunk
+ * earlier in the order is done — so the chunks read as one typewriter:
+ * chunk N reveals completely, then chunk N+1 starts.
+ *
+ * The structure deliberately mirrors `documentRegistry`'s proven patterns
+ * (chunkId-keyed refcount with microtask-deferred reclaim for Strict Mode,
+ * monotonic version + microtask-coalesced subscriber fanout, `onEmpty`
+ * container eviction) without touching the registry itself: the def
+ * registry and this coordinator share only the `documentId` scope. Chunks
+ * that never register (non-smooth chunks, opted-out chunks) simply do not
+ * exist here and can never block a successor; an unmounting chunk leaves
+ * the order, so a virtualized-away predecessor releases its successors by
+ * construction.
+ *
+ * `lastProgressAt` is the reveal-progress heartbeat behind the dev-only
+ * stuck-flag warning. Writes to it intentionally do NOT bump `version` and
+ * do NOT fan out — stamping happens once per reveal frame, and a fanout to
+ * every sibling chunk per frame would be a performance bug. Nothing
+ * subscribes to it; the pending chunk's warning timer reads it on demand.
+ *
+ * @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;
+}
+/** Outcome of one stuck-flag warning timer firing (dev-only diagnostics). */
+type GateWarnVerdict = 'warn' | 'rearm' | 'clear';
+/**
+ * The warn / re-arm / clear decision behind the dev-only stuck-flag
+ * warning, extracted as a pure function so the judgment is unit-testable
+ * in node — the `setTimeout` wiring in `useDocumentSmoothStream` reduces
+ * to "call this when the timer fires".
+ *
+ * - `'clear'`: no blocker left — the release is propagating; stop.
+ * - `'rearm'`: the earliest blocker showed reveal progress within the
+ *   threshold — a slow model still emitting, not a stuck flag; check
+ *   again later.
+ * - `'warn'`: the blocker has made no visible progress for a full
+ *   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;
+
+/** 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 = 
+/** 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;
+}
+/** 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';
+}
+/** The source tail is ordinary body content — the DOM-tail heuristic is
+ *  correct as-is. */
+ | null;
+/**
+ * Classify the source tail of `mdast`.
+ *
+ * @param mdast - The tree the renderer is about to render (post-pipeline
+ *   parse output; the incremental path's spliced tree carries correct
+ *   positions on real nodes).
+ * @param contentLength - Length of the PREPROCESSED content string the
+ *   renderer parsed (not the caller's raw prop). Phantom definitions are
+ *   injected as an appended suffix before parsing, so every node whose
+ *   start offset sits at or past the real content's end is a phantom — the
+ *   scan walks backwards past ALL of them (a real trailing def plus
+ *   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`, `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
+ */
+
+/** See module docs. Safe for any hast node union member. */
+declare function cloneHastForRender<T extends Nodes>(node: T): T;
+
+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;
+    measure?: AdvanceOptions['measure'];
+}
+declare function createPipelineSession(): {
+    reset(): void;
+    parse({ content, targetPhantoms, remarkPlugins, rehypePlugins, remarkRehypeOptions, handlers, preserveForBodyHarvest, documentId, provenance, incrementalParse, defListEnabled, measure: measureHere, }: PipelineFrameOptions): {
+        mdast: mdast.Root;
+        hast: hast.Root;
+    };
+};
+
+interface DefinitionLabels {
+    footnoteLabels: ReadonlySet<string>;
+    linkLabels: ReadonlySet<string>;
+}
+type PhantomTargets = PipelineFrameOptions['targetPhantoms'];
+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;
+}
+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;
+};
+/** 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 BuildBlocksOptions, type BuildBlocksResult, type ContributionOptions, type ContributionPolicyInputs, type ContributionRegistry, type CoordinationPolicy, type DefinitionLabels, type GateWarnVerdict, type PhantomTargets, type PipelineFrameOptions, type RenderItem, type SmoothCoordinator, type TailSignal, buildAggregateTree, buildBlocks, buildContributionChain, cloneHastForRender, computeBlockFingerprint, computeHtmlBlockDigest, computeHtmlBlockDigestWithExtent, createBlockPlanner, createContributionSession, createPipelineSession, createSmoothCoordinator, deriveCoordinationPolicy, derivePhantomTargets, deriveTailSignal, evaluateGateWarn, hasMdastSource };