@ai-react-markdown/core 1.2.9 → 1.4.0

package/dist/index.d.cts

@@ -1,6 +1,22 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ComponentType, PropsWithChildren, CSSProperties } from 'react';
-import { Components } from 'react-markdown';
+import { JSX, ComponentType, PropsWithChildren, CSSProperties, FC } from 'react';
+import { Element, ElementContent } from 'hast';
+
+/**
+ * Public types for the local Markdown wrapper. Ported 1:1 from react-markdown
+ * v10's lib/index.js JSDoc, restructured as TypeScript declarations.
+ *
+ * @module components/markdown/types
+ */
+
+/** Extra fields the wrapper passes to user-supplied tag components. */
+interface ExtraProps {
+    node?: Element | undefined;
+}
+/** Map tag names to user components or other tag names. */
+type Components = {
+    [Key in keyof JSX.IntrinsicElements]?: ComponentType<JSX.IntrinsicElements[Key] & ExtraProps> | keyof JSX.IntrinsicElements;
+};
 
 /**
  * Core type definitions, enums, and default configuration for ai-react-markdown.
@@ -14,9 +30,10 @@ import { Components } from 'react-markdown';
 
 /**
  * Custom component overrides for the markdown renderer.
- * Alias for `react-markdown`'s `Components` type, re-exported under the
- * library's `AIMarkdown` naming convention so consumers don't need a
- * direct `react-markdown` dependency for type imports.
+ * Alias for the local Markdown wrapper's `Components` type (a vendored fork of
+ * react-markdown's), re-exported under the library's `AIMarkdown` naming
+ * convention so consumers don't need a direct `react-markdown` dependency
+ * for type imports.
  */
 type AIMarkdownCustomComponents = Components;
 /**
@@ -27,9 +44,7 @@ declare enum AIMarkdownRenderExtraSyntax {
     /** `==Highlight==` syntax support. */
     HIGHLIGHT = "HIGHLIGHT",
     /** Definition list syntax. @see https://michelf.ca/projects/php-markdown/extra/#def-list */
-    DEFINITION_LIST = "DEFINITION_LIST",
-    /** Superscript (`^text^`) and subscript (`~text~`) syntax. */
-    SUBSCRIPT = "SUBSCRIPT"
+    DEFINITION_LIST = "DEFINITION_LIST"
 }
 /**
  * Display optimization abilities applied during markdown processing.
@@ -46,18 +61,62 @@ declare enum AIMarkdownRenderDisplayOptimizeAbility {
 /**
  * Configuration object controlling which markdown extensions and
  * display optimizations are active during rendering.
+ *
+ * Arrays are typed `readonly` so the interface is assignable from the frozen
+ * {@link defaultAIMarkdownRenderConfig}. Consumers can still pass mutable
+ * arrays since `readonly T[]` is assignable from `T[]`. Note: this is a
+ * compile-time hint only — user-supplied configs are not deep-frozen at
+ * runtime, so the library does not guarantee the object remains unchanged
+ * after it is passed in.
  */
 interface AIMarkdownRenderConfig {
     /** Extra syntax extensions to enable. */
-    extraSyntaxSupported: AIMarkdownRenderExtraSyntax[];
+    readonly extraSyntaxSupported: readonly AIMarkdownRenderExtraSyntax[];
     /** Display optimization abilities to enable. */
-    displayOptimizeAbilities: AIMarkdownRenderDisplayOptimizeAbility[];
+    readonly displayOptimizeAbilities: readonly AIMarkdownRenderDisplayOptimizeAbility[];
+    /**
+     * Whether to enable block-level memoization across renders.
+     *
+     * When `true` (default), the renderer splits each rendered document into
+     * per-block units and memoizes the React subtree of each block by its
+     * source identity (`raw + occurrence + ctx + position`). Unchanged blocks
+     * during streaming skip `toJsxRuntime` and React reconcile work, reducing
+     * per-frame cost roughly proportional to the unchanged fraction of the
+     * document. Output is byte-identical to the disabled path.
+     *
+     * When `false`, the renderer falls back to the legacy bare `<Markdown>`
+     * flow — every render runs the full pipeline end-to-end with no
+     * cross-frame reuse. Useful for debugging, for environments where the
+     * extra `useRef`-backed cache is undesirable, or as an escape hatch if a
+     * future custom rehype plugin interacts badly with the plan abstraction.
+     *
+     * @default true
+     */
+    readonly blockMemoEnabled: boolean;
+    /**
+     * Default `true`. Controls Direction A: whether `<AIMarkdown>` (standalone
+     * mode) protects orphan `footnoteDefinition` nodes from being silently
+     * dropped by `mdast-util-to-hast` when no corresponding `footnoteReference`
+     * exists. Implemented via a custom `footnoteDefinition` handler that
+     * proactively registers the label in `state.footnoteOrder`.
+     *
+     * When `<AIMarkdown>` is wrapped in `<AIMarkdownDocuments>`, this field
+     * is ignored — the wrapper's `preserveOrphanReferences` prop overrides
+     * unconditionally for all chunks under it.
+     */
+    readonly preserveOrphanReferences: boolean;
 }
 /**
  * Sensible default configuration with all extensions and optimizations enabled.
- * Frozen to prevent accidental mutation.
+ * Frozen at both the top level and the inner arrays so this shared singleton
+ * cannot be mutated by any consumer.
  */
-declare const defaultAIMarkdownRenderConfig: AIMarkdownRenderConfig;
+declare const defaultAIMarkdownRenderConfig: Readonly<{
+    extraSyntaxSupported: readonly AIMarkdownRenderExtraSyntax[];
+    displayOptimizeAbilities: readonly AIMarkdownRenderDisplayOptimizeAbility[];
+    blockMemoEnabled: true;
+    preserveOrphanReferences: true;
+}>;
 /**
  * Arbitrary metadata that consumers can pass through a dedicated React context.
  * Custom renderers can access this via the {@link useAIMarkdownMetadata} hook.
@@ -140,6 +199,30 @@ interface AIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig = AIMarkd
     variant: AIMarkdownVariant;
     /** Active color scheme. */
     colorScheme: AIMarkdownColorScheme;
+    /**
+     * Stable identifier unique to this *logical markdown document*. Used as
+     * the id namespace for clobberable attributes (`id`, hash hrefs) so two
+     * documents on the same page don't cross-link — e.g. clicking a footnote
+     * `[^1]` in message A won't scroll to the `[^1]` definition in message B.
+     *
+     * Named `documentId` (not `instanceId`) intentionally: when one logical
+     * markdown document is split into multiple `<AIMarkdown>` instances
+     * (chunked / streamed rendering), every chunk SHOULD share the same value
+     * so id-prefixes align across the chunks.
+     *
+     * Auto-generated via React's `useId()` (SSR-safe, stable across
+     * re-renders) when not provided by the consumer; consumer-supplied values
+     * always win.
+     */
+    documentId: string;
+    /**
+     * Per-document URI-safe id prefix used by all clobberable attributes
+     * (`id="…"` / `href="#…"`). Derived once by the provider as
+     * `${encodeURIComponent(documentId)}-user-content-` and exposed here so
+     * downstream consumers (placeholder components, cross-chunk anchor logic)
+     * read a single canonical source instead of recomputing locally.
+     */
+    clobberPrefix: string;
     /** Active render configuration. */
     config: TConfig;
 }
@@ -494,16 +577,59 @@ type PartialObjectDeep<ObjectType extends object, Options extends Required<Parti
  * Must be called inside a component rendered as a descendant of `<AIMarkdown>`.
  * Throws if called outside the provider boundary.
  *
- * @typeParam TConfig - Expected configuration shape (defaults to {@link AIMarkdownRenderConfig}).
- * @returns The current render state (does not include metadata — use {@link useAIMarkdownMetadata} for that).
+ * ### `TConfig` is a caller-asserted type, not a derived one
  *
- * @example
+ * The generic parameter is **an assertion the caller makes about the provider
+ * above it** — TypeScript cannot verify that the actual `<AIMarkdown>` in the
+ * tree was configured with a matching `defaultConfig: TConfig`. If you pass a
+ * wider `TConfig` than what the provider actually carries, field access at
+ * compile time will look fine but resolve to `undefined` at runtime.
+ *
+ * The intended pattern is that extension packages (e.g. `@ai-react-markdown/mantine`)
+ * ship their own narrow wrapper hook alongside a matching `defaultConfig`, so the
+ * assertion is made *once* next to the provider configuration and consumers of the
+ * wrapper never touch the raw generic.
+ *
+ * @typeParam TConfig - Caller-asserted configuration shape (defaults to
+ *   {@link AIMarkdownRenderConfig}). Must be aligned with the provider's
+ *   `defaultConfig` — the library does not check this at runtime.
+ * @returns The current render state (does not include metadata — use
+ *   {@link useAIMarkdownMetadata} for that).
+ * @throws If called outside an `<AIMarkdown>` provider tree.
+ *
+ * @example Base usage — no generic, always safe:
  * ```tsx
  * function CustomCodeBlock({ children }: PropsWithChildren) {
  *   const { streaming, config } = useAIMarkdownRenderState();
- *   // ...
+ *   // config: AIMarkdownRenderConfig — guaranteed shape
  * }
  * ```
+ *
+ * @example Wrapper-hook pattern — the intended way to use an extended TConfig:
+ * ```tsx
+ * // In your extension package (pin the assertion in one place):
+ * interface ExtendedConfig extends AIMarkdownRenderConfig {
+ *   themeMode: 'light' | 'dark' | 'auto';
+ * }
+ * export const extendedDefaultConfig: ExtendedConfig = {
+ *   ...defaultAIMarkdownRenderConfig,
+ *   themeMode: 'auto',
+ * };
+ * export const useExtendedRenderState = () =>
+ *   useAIMarkdownRenderState<ExtendedConfig>();
+ *
+ * // Provider is always configured with the matching defaultConfig:
+ * <AIMarkdown defaultConfig={extendedDefaultConfig} ...>{children}</AIMarkdown>
+ *
+ * // Consumers use the narrow wrapper — no raw generic anywhere:
+ * const { config } = useExtendedRenderState();
+ * config.themeMode; // correctly typed and present at runtime
+ * ```
+ *
+ * @see `@ai-react-markdown/mantine` — real-world reference. Its
+ *   `MantineAIMarkdownRenderConfig`, `defaultMantineAIMarkdownRenderConfig`,
+ *   `<MantineAIMarkdown>` (which passes `defaultConfig` by default), and
+ *   `useMantineAIMarkdownRenderState` implement this exact pattern.
  */
 declare function useAIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig>(): AIMarkdownRenderState<TConfig>;
 /**
@@ -513,8 +639,24 @@ declare function useAIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig
  * do not cause re-renders in components that only consume render state
  * (e.g. {@link MarkdownContent}).
  *
- * @typeParam TMetadata - Expected metadata shape (defaults to {@link AIMarkdownMetadata}).
+ * ### `TMetadata` is a caller-asserted type
+ *
+ * Same contract as {@link useAIMarkdownRenderState} — the generic is an
+ * assertion about the `metadata` prop passed to the provider above, not a
+ * value TypeScript can derive.  Unlike render-state config, metadata has no
+ * runtime fallback: if the provider received no `metadata`, the hook returns
+ * `undefined` regardless of the asserted type. Prefer wrapping this hook in
+ * a project-local hook that pins `TMetadata` next to the call site that
+ * actually provides the metadata.
+ *
+ * @typeParam TMetadata - Caller-asserted metadata shape (defaults to
+ *   {@link AIMarkdownMetadata}). Caller is responsible for ensuring the
+ *   provider's `metadata` prop matches this shape.
  * @returns The current metadata, or `undefined` if none was provided.
+ *
+ * @see `@ai-react-markdown/mantine` — `useMantineAIMarkdownMetadata` applies
+ *   the wrapper pattern to this hook, pinning `MantineAIMarkdownMetadata` in
+ *   a single location.
  */
 declare function useAIMarkdownMetadata<TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata>(): TMetadata | undefined;
 /** Props for {@link AIMarkdownRenderStateProvider}. */
@@ -523,6 +665,19 @@ interface AIMarkdownRenderStateProviderProps<TConfig extends AIMarkdownRenderCon
     fontSize: string;
     variant: AIMarkdownVariant;
     colorScheme: AIMarkdownColorScheme;
+    /**
+     * Logical-document identifier used as the id namespace for clobberable
+     * attributes (id / hash hrefs). Optional — when omitted, the provider
+     * auto-generates one via {@link useId} so the provider stays drop-in
+     * usable for direct consumers (e.g. extension packages that don't go
+     * through `<AIMarkdown>`).
+     *
+     * Pass the SAME value to multiple providers / `<AIMarkdown>` instances
+     * when they render chunks of the same logical document — their id
+     * prefixes will align so cross-chunk anchors and (once the parser sees
+     * the full doc) footnote navigation work.
+     */
+    documentId?: string;
     /**
      * Base default config to merge against. When omitted, falls back to
      * {@link defaultAIMarkdownRenderConfig}. Sub-packages (e.g. mantine) can
@@ -572,6 +727,14 @@ type AIMDContentPreprocessor = (content: string) => string;
  * returned, preventing unnecessary re-renders in downstream `useMemo` / `useEffect`
  * consumers that depend on reference equality.
  *
+ * The ref is updated in a layout effect (not during render) so that the cached
+ * reference only advances on COMMITTED renders. In concurrent mode a render
+ * may be discarded (e.g. by Suspense); writing to the ref during render would
+ * let values from discarded renders pollute the cache and leak into subsequent
+ * committed renders. Layout effects run synchronously right after commit, which
+ * closes the window where a same-tick re-render could otherwise observe a stale
+ * `ref.current` and hand back an outdated reference.
+ *
  * @typeParam T - The value type.
  * @param value - The potentially new value to stabilize.
  * @returns The previous reference when deep-equal, otherwise the new value.
@@ -584,6 +747,138 @@ type AIMDContentPreprocessor = (content: string) => string;
  */
 declare function useStableValue<T>(value: T): T;
 
+/**
+ * Cross-chunk shared state. Holds per-chunk contributions (refs, defs,
+ * linkDefs) keyed by Symbol identity allocated via useId reactId, with
+ * refcount + microtask-deferred reclamation for React Strict Mode safety.
+ *
+ * @module components/documentRegistry
+ */
+
+interface FootnoteDef {
+    /** Already-normalized identifier (uppercase). Used as dictionary key for
+     *  case-insensitive cross-chunk lookups. */
+    identifier: string;
+    /** mdast's case-folded identifier — the exact string mdast-util-to-hast
+     *  emits in `<li id="${clobberPrefix}fn-${sourceIdentifier}">` and that
+     *  `FootnoteSupNumber` mirrors in its anchor href. Needed so the aggregate
+     *  footer's `<li id>` and backref href match the inline `<sup>`'s href
+     *  exactly (otherwise hash navigation breaks). Optional so unit-test
+     *  fixtures don't need to fabricate it; production data always supplies it. */
+    sourceIdentifier?: string;
+    /** Content extracted from the source markdown footnote definition. */
+    contentSource: string;
+    /** Per-def hast body (the def's mdast children after mdast-util-to-hast
+     *  conversion). Drives AggregateFootnotesIfLast to render the consolidated
+     *  footer at the end of each document's last chunk. Optional so unit-test
+     *  fixtures can build minimal FootnoteDef objects without producing hast. */
+    bodyHast?: ElementContent[];
+}
+interface LinkDef {
+    /** Already-normalized identifier (uppercase). */
+    identifier: string;
+    url: string;
+    title?: string;
+}
+type RefKind = 'footnote' | 'link' | 'image';
+interface RefRecord {
+    /** Already-normalized identifier (uppercase). */
+    label: string;
+    /** Which markdown reference space this entry belongs to. Footnote refs,
+     *  link refs, and image refs occupy disjoint namespaces in GFM, so they
+     *  must be filtered separately when computing footnote numbers / refcounts. */
+    kind: RefKind;
+    referenceType?: 'full' | 'collapsed' | 'shortcut';
+}
+interface ChunkData {
+    refs: RefRecord[];
+    defs: Map<string, FootnoteDef>;
+    linkDefs: Map<string, LinkDef>;
+    ownFootnoteLabels: Set<string>;
+    ownLinkLabels: Set<string>;
+}
+interface Registry {
+    /** Chunk mount-order Symbol list. **Read-only from outside the registry.**
+     *  Direct mutation (`.push`, `.splice`, index assignment) corrupts
+     *  footnote numbering, "last chunk" detection, and eviction. Use the
+     *  `allocateSymbol` / `releaseSymbol` / `registerChunk` API instead. */
+    readonly chunkOrder: readonly symbol[];
+    /** Chunk Symbol → contribution payload. **Read-only from outside.**
+     *  Use `contributeChunkData` / `contributeLabels` / `registerChunk` to
+     *  publish; direct `.set` / `.delete` bypasses version bumps and
+     *  subscriber wake-ups. */
+    readonly chunkData: ReadonlyMap<symbol, ChunkData>;
+    /** Union of own-def labels across all chunks. PASS 0.5 phantom-injection
+     *  driver. **Read-only from outside.** The registry derives this from
+     *  per-chunk contributions; direct mutation breaks the derivation. */
+    readonly labelSet: {
+        readonly footnoteLabels: ReadonlySet<string>;
+        readonly linkLabels: ReadonlySet<string>;
+    };
+    /** Monotonic version counter bumped by every mutation. **Read-only from
+     *  outside** — consumers should observe via `subscribe`, not by writing. */
+    readonly version: number;
+    /** Allocate (or reuse, for Strict Mode remount) the chunk Symbol for
+     *  `reactId` AND publish this chunk's own def labels (footnotes + links)
+     *  in one call. Canonical pair API used by `MarkdownContent`'s allocate
+     *  effect — combining the two reduces the pair to a single registry
+     *  version step, which downstream consumers see as one wake-up rather
+     *  than two (the second was already coalesced by microtask, but this
+     *  keeps the version monotonic-by-1-per-mount which makes debugging
+     *  easier). The granular `allocateSymbol` / `contributeLabels` methods
+     *  remain available for tests that need to exercise each step. */
+    registerChunk(reactId: string, footnotes: Set<string>, links: Set<string>): symbol;
+    allocateSymbol(reactId: string): symbol;
+    releaseSymbol(reactId: string): void;
+    contributeLabels(symbol: symbol, footnotes: Set<string>, links: Set<string>): void;
+    contributeChunkData(symbol: symbol, data: ChunkData): void;
+    subscribe(cb: () => void): () => void;
+    canonicalFootnoteFor(label: string): symbol | null;
+    canonicalLinkFor(label: string): symbol | null;
+    globalNumber(label: string): number | null;
+    resolveLinkDef(label: string): LinkDef | null;
+    getRefsForLabel(label: string): number;
+    /** Map a chunk-local footnote-ref occurrence index (1-based, as emitted by
+     *  `customMdastHandlers`) to the corresponding document-wide occurrence
+     *  index across all chunks. Used by `FootnoteSupNumber` to build a unique
+     *  `id="fnref-X-N"` for each ref instance and by `AggregateFootnotesIfLast`
+     *  to enumerate per-occurrence backrefs. Returns `null` if the ref isn't
+     *  registered yet (registry mid-flight). */
+    globalOccurrenceForRef(chunkSym: symbol, label: string, localOccurrence: number): number | null;
+}
+
+/**
+ * Optional outer wrapper enabling cross-chunk coordination for any
+ * `<AIMarkdown>` instances rendered as descendants. Each unique
+ * `documentId` partitions its own Registry.
+ *
+ * Without this wrapper, `<AIMarkdown>` instances render independently
+ * (current behavior). With it, multiple chunks sharing a `documentId`
+ * coordinate footnote numbering, linkReference/imageReference resolution,
+ * and anchor jumps across chunks.
+ *
+ * @module components/AIMarkdownDocuments
+ */
+
+interface AIMarkdownDocumentsProps extends PropsWithChildren {
+    /**
+     * Default `true`. Unconditionally controls orphan-reference protection
+     * for all chunks under this wrapper, overriding their individual
+     * `config.preserveOrphanReferences`. Does not control cross-chunk
+     * coordination itself (that's gated by wrapper presence + `documentId`).
+     */
+    preserveOrphanReferences?: boolean;
+}
+declare const AIMarkdownDocuments: FC<AIMarkdownDocumentsProps>;
+/**
+ * Returns the registry for the given `documentId`, or `null` if:
+ *  - `<AIMarkdown>` is not inside an `<AIMarkdownDocuments>` wrapper, OR
+ *  - `documentId` is undefined / empty string.
+ *
+ * Callers should treat `null` as "no coordination; run standalone path."
+ */
+declare function useDocumentRegistry(documentId: string | undefined): Registry | null;
+
 /**
  * Props for the `<AIMarkdown>` component.
  *
@@ -632,12 +927,34 @@ interface AIMarkdownProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRen
     variant?: AIMarkdownVariant;
     /** Color scheme name. Defaults to `'light'`. */
     colorScheme?: AIMarkdownColorScheme;
+    /**
+     * Stable identifier for the *logical markdown document* this `<AIMarkdown>`
+     * is rendering. Used as the id namespace for all clobberable attributes
+     * (`id`, hash hrefs) so two documents on the same page do not cross-link —
+     * e.g. clicking a footnote `[^1]` in message A will not scroll to the
+     * `[^1]` definition in message B.
+     *
+     * Why `documentId` and not `instanceId`: when one logical document is
+     * split across multiple `<AIMarkdown>` instances (chunked / streamed
+     * rendering), every chunk should share the SAME `documentId` so their
+     * id-prefixes line up. The id is per-document, not per-React-instance.
+     *
+     * When omitted, an id is auto-generated via React's `useId()` (SSR-safe
+     * and stable across re-renders). Pass an explicit value when you need
+     * deterministic ids (snapshot tests, cross-component deep links) or when
+     * multiple instances render the same logical document.
+     *
+     * Consumer-supplied values pass through `encodeURIComponent` at the prefix
+     * construction site, so any string is safe — including ids with reserved
+     * characters like `:`, `/`, or spaces.
+     */
+    documentId?: string;
 }
 /**
  * Root component that preprocesses markdown content and renders it through
  * a configurable remark/rehype pipeline wrapped in typography and style layers.
  */
-declare const AIMarkdownComponent: <TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TRenderData extends AIMarkdownMetadata = AIMarkdownMetadata>({ streaming, content, fontSize, contentPreprocessors, customComponents, defaultConfig, config, metadata, Typography, ExtraStyles, variant, colorScheme, }: AIMarkdownProps<TConfig, TRenderData>) => react_jsx_runtime.JSX.Element;
+declare const AIMarkdownComponent: <TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TRenderData extends AIMarkdownMetadata = AIMarkdownMetadata>({ streaming, content, fontSize, contentPreprocessors, customComponents, defaultConfig, config, metadata, Typography, ExtraStyles, variant, colorScheme, documentId, }: AIMarkdownProps<TConfig, TRenderData>) => react_jsx_runtime.JSX.Element;
 declare const _default: typeof AIMarkdownComponent;
 
-export { type AIMDContentPreprocessor, type AIMarkdownColorScheme, type AIMarkdownCustomComponents, type AIMarkdownExtraStylesComponent, type AIMarkdownExtraStylesProps, type AIMarkdownMetadata, type AIMarkdownProps, type AIMarkdownRenderConfig, AIMarkdownRenderDisplayOptimizeAbility, AIMarkdownRenderExtraSyntax, type AIMarkdownRenderState, type AIMarkdownTypographyComponent, type AIMarkdownTypographyProps, type AIMarkdownVariant, type PartialDeep, _default as default, defaultAIMarkdownRenderConfig, useAIMarkdownMetadata, useAIMarkdownRenderState, useStableValue };
+export { type AIMDContentPreprocessor, type AIMarkdownColorScheme, type AIMarkdownCustomComponents, AIMarkdownDocuments, type AIMarkdownDocumentsProps, type AIMarkdownExtraStylesComponent, type AIMarkdownExtraStylesProps, type AIMarkdownMetadata, type AIMarkdownProps, type AIMarkdownRenderConfig, AIMarkdownRenderDisplayOptimizeAbility, AIMarkdownRenderExtraSyntax, type AIMarkdownRenderState, type AIMarkdownTypographyComponent, type AIMarkdownTypographyProps, type AIMarkdownVariant, type ChunkData, type FootnoteDef, type LinkDef, type PartialDeep, type RefKind, type RefRecord, type Registry, _default as default, defaultAIMarkdownRenderConfig, useAIMarkdownMetadata, useAIMarkdownRenderState, useDocumentRegistry, useStableValue };