markstream-solid 0.0.0-stage → 2.0.23

package/dist/types/component-props.d.ts

@@ -0,0 +1,253 @@
+import type { CodeBlockNode } from 'stream-markdown-parser';
+export interface CodeBlockThemePair {
+    dark: string;
+    light: string;
+}
+export type CodeBlockTheme = string;
+export type CodeBlockThemeProp = CodeBlockTheme | CodeBlockThemePair;
+export type CodeBlockThemes = readonly [dark: CodeBlockTheme, light: CodeBlockTheme];
+export interface CommonCodeBlockProps {
+    showHeader?: boolean;
+    showCopyButton?: boolean;
+    showExpandButton?: boolean;
+}
+export interface CodeBlockDiffHideUnchangedRegionsOptions {
+    enabled?: boolean;
+    contextLineCount?: number;
+    minimumLineCount?: number;
+    revealLineCount?: number;
+}
+export type CodeBlockDiffHideUnchangedRegions = boolean | CodeBlockDiffHideUnchangedRegionsOptions;
+export interface CodeBlockOptions {
+    fontSize?: number;
+    lineHeight?: number;
+    fontFamily?: string;
+    maxHeight?: number;
+    padding?: number;
+    tabSize?: number;
+    disableLineNumbers?: boolean;
+    overflow?: 'scroll' | 'wrap';
+    disableVirtualizationBuffers?: boolean;
+    useCSSClasses?: boolean;
+    useTokenTransformer?: boolean;
+    tokenizeMaxLineLength?: number;
+    tokenizeMaxLength?: number;
+    unsafeCSS?: string;
+    diffStyle?: 'unified' | 'split';
+    diffIndicators?: 'classic' | 'bars' | 'none';
+    disableBackground?: boolean;
+    hunkSeparators?: 'simple' | 'metadata' | 'line-info' | 'line-info-basic';
+    expandUnchanged?: boolean;
+    collapsedContextThreshold?: number;
+    lineDiffType?: 'word-alt' | 'word' | 'char' | 'none';
+    maxLineDiffLength?: number;
+    expansionLineCount?: number;
+    parseDiffOptions?: Record<string, unknown>;
+    lineHoverHighlight?: 'disabled' | 'both' | 'number' | 'line';
+    enableTokenInteractionsOnWhitespace?: boolean;
+    enableGutterUtility?: boolean;
+    enableLineSelection?: boolean;
+    controlledSelection?: boolean;
+    onGutterUtilityClick?: (...args: any[]) => unknown;
+    onLineClick?: (...args: any[]) => unknown;
+    onLineNumberClick?: (...args: any[]) => unknown;
+    onLineEnter?: (...args: any[]) => unknown;
+    onLineLeave?: (...args: any[]) => unknown;
+    onTokenClick?: (...args: any[]) => unknown;
+    onTokenEnter?: (...args: any[]) => unknown;
+    onTokenLeave?: (...args: any[]) => unknown;
+    onLineSelected?: (...args: any[]) => unknown;
+    onLineSelectionStart?: (...args: any[]) => unknown;
+    onLineSelectionChange?: (...args: any[]) => unknown;
+    onLineSelectionEnd?: (...args: any[]) => unknown;
+    getLineIndex?: (...args: any[]) => unknown;
+    renderAnnotation?: (...args: any[]) => unknown;
+    renderGutterUtility?: (...args: any[]) => unknown;
+    onPostRender?: (...args: any[]) => unknown;
+    mergeConflict?: boolean;
+    lineAnnotations?: unknown[];
+    onController?: (controller: any) => void;
+    workerManager?: unknown;
+}
+export interface CodeBlockNodeProps extends CommonCodeBlockProps {
+    node: CodeBlockNode;
+    codeBlockOptions?: CodeBlockOptions;
+    /** Overrides browser clipboard writes. Copy feedback and events wait for completion. */
+    clipboardWriter?: (text: string) => void | Promise<void>;
+    showLineNumbers?: boolean;
+    isDark?: boolean;
+    loading?: boolean;
+    stream?: boolean;
+    theme?: CodeBlockThemeProp;
+    /** @deprecated Use `theme` prop instead. Kept for backward compatibility. */
+    darkTheme?: CodeBlockTheme;
+    /** @deprecated Use `theme` prop instead. Kept for backward compatibility. */
+    lightTheme?: CodeBlockTheme;
+    isShowPreview?: boolean;
+    enableFontSizeControl?: boolean;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    themes?: CodeBlockThemes;
+    showPreviewButton?: boolean;
+    showCollapseButton?: boolean;
+    showFontSizeButtons?: boolean;
+    showTooltips?: boolean;
+    htmlPreviewAllowScripts?: boolean;
+    htmlPreviewSandbox?: string;
+    customId?: string;
+}
+export interface ImageNodeProps {
+    node: {
+        type: 'image';
+        src: string;
+        alt: string;
+        title: string | null;
+        raw: string;
+        loading?: boolean;
+    };
+    fallbackSrc?: string;
+    lazy?: boolean;
+    usePlaceholder?: boolean;
+}
+export interface LinkNodeProps {
+    node: {
+        type: 'link';
+        href: string;
+        title: string | null;
+        text: string;
+        attrs?: [string, string][];
+        children: {
+            type: string;
+            raw: string;
+        }[];
+        raw: string;
+        loading?: boolean;
+        /** `'linkify'` marks links auto-detected from bare text. */
+        markup?: string;
+    };
+    indexKey: number | string;
+    customId?: string;
+    showTooltip?: boolean;
+    color?: string;
+    underlineHeight?: number;
+    underlineBottom?: number | string;
+    animationDuration?: number;
+    animationOpacity?: number;
+    animationTiming?: string;
+    animationIteration?: string | number;
+}
+export interface ReferenceNodeProps {
+    node: {
+        type: 'reference';
+        id: string | number;
+        raw?: string;
+    };
+    messageId?: string;
+    threadId?: string;
+    onClick?: (event: MouseEvent, id: string, messageId?: string, threadId?: string) => void;
+    onMouseEnter?: (event: MouseEvent, id: string, messageId?: string, threadId?: string) => void;
+    onMouseLeave?: (event: MouseEvent, id: string, messageId?: string, threadId?: string) => void;
+}
+export interface PreCodeNodeProps {
+    node: CodeBlockNode;
+    loading?: boolean;
+    showLineNumbers?: boolean;
+    diffInline?: boolean;
+    diffHideUnchangedRegions?: CodeBlockDiffHideUnchangedRegions;
+    /**
+     * Optional reserved visual height for async/loading fallbacks.
+     * Used by virtual-scroll restore paths to avoid a zero/short pending frame.
+     */
+    reservedHeightPx?: number;
+}
+export interface MermaidBlockNodeProps {
+    node: CodeBlockNode;
+    maxHeight?: string | null;
+    estimatedPreviewHeightPx?: number;
+    loading?: boolean;
+    isDark?: boolean;
+    workerTimeoutMs?: number;
+    parseTimeoutMs?: number;
+    renderTimeoutMs?: number;
+    fullRenderTimeoutMs?: number;
+    renderDebounceMs?: number;
+    contentStableDelayMs?: number;
+    previewPollDelayMs?: number;
+    previewPollMaxDelayMs?: number;
+    previewPollMaxAttempts?: number;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showExportButton?: boolean;
+    showFullscreenButton?: boolean;
+    showCollapseButton?: boolean;
+    showZoomControls?: boolean;
+    enableWheelZoom?: boolean;
+    isStrict?: boolean;
+    enableMermaidInteractions?: boolean;
+    showTooltips?: boolean;
+    fitPreviewHeight?: boolean;
+    onRenderError?: (error: unknown, code: string, container: HTMLElement) => boolean | void;
+}
+export interface CodeBlockPreviewPayload {
+    node: CodeBlockNode;
+    artifactType: 'text/html' | 'image/svg+xml';
+    artifactTitle: string;
+    id: string;
+}
+export interface MermaidBlockEvent<TPayload = unknown> {
+    payload?: TPayload;
+    defaultPrevented: boolean;
+    preventDefault: () => void;
+    svgElement?: SVGElement | null;
+    svgString?: string | null;
+}
+export interface D2BlockNodeProps {
+    node: CodeBlockNode;
+    maxHeight?: string | null;
+    estimatedPreviewHeightPx?: number;
+    loading?: boolean;
+    isDark?: boolean;
+    progressiveRender?: boolean;
+    progressiveIntervalMs?: number;
+    themeId?: number | null;
+    darkThemeId?: number | null;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showExportButton?: boolean;
+    showCollapseButton?: boolean;
+}
+export interface InfographicBlockNodeProps {
+    node: CodeBlockNode;
+    maxHeight?: string | null;
+    estimatedPreviewHeightPx?: number;
+    loading?: boolean;
+    isDark?: boolean;
+    showHeader?: boolean;
+    showModeToggle?: boolean;
+    showCopyButton?: boolean;
+    showCollapseButton?: boolean;
+    showExportButton?: boolean;
+    showFullscreenButton?: boolean;
+    showZoomControls?: boolean;
+}
+export interface MathBlockNodeProps {
+    node: {
+        type: 'math_block';
+        content: string;
+        raw: string;
+        loading?: boolean;
+    };
+    indexKey?: number | string;
+    cacheScope?: string | number;
+}
+export interface MathInlineNodeProps {
+    node: {
+        type: 'math_inline';
+        content: string;
+        raw: string;
+        loading?: boolean;
+        markup?: string;
+    };
+}

package/dist/types/node-renderer-props.d.ts

@@ -0,0 +1,333 @@
+import type { SmoothMarkdownStreamOptions } from 'markstream-core';
+import type { Accessor } from 'solid-js';
+import type { BaseNode, HtmlPolicy, MarkdownIt, ParseOptions } from 'stream-markdown-parser';
+import type { CustomComponentMap, HtmlComponentMap, StreamingComponentMap } from '../customComponents';
+import type { CodeBlockNodeProps, CodeBlockOptions, CodeBlockTheme, CodeBlockThemes, D2BlockNodeProps, InfographicBlockNodeProps, MermaidBlockNodeProps } from './component-props';
+type NodeRendererCodeBlockThemes = CodeBlockNodeProps['themes'];
+export type NodeRendererCodeBlockProps = Partial<Omit<CodeBlockNodeProps, 'node' | 'themes' | 'codeBlockOptions'>> & {
+    themes?: NodeRendererCodeBlockThemes;
+    codeBlockOptions?: never;
+} & Record<string, unknown>;
+export type NodeRendererMode = 'docs' | 'chat' | 'minimal';
+export type NodeRendererTypewriter = boolean | 'simple' | 'precise';
+export type NodeRendererDomMode = 'full' | 'minimal';
+export type MarkstreamVirtualPhase = 'estimating' | 'streaming' | 'measuring' | 'settling' | 'settled' | 'final';
+export type MarkstreamVirtualConfidence = 'estimate' | 'mixed' | 'measured' | 'final';
+export type MarkstreamVirtualReason = 'content' | 'parse' | 'batch' | 'resize' | 'node-resize' | 'async-node' | 'font' | 'theme' | 'final' | 'restore' | 'manual';
+export type MarkstreamVirtualAnchor = {
+    type: 'node';
+    nodeIndex: number;
+    offsetWithinNodePx: number;
+} | {
+    type: 'bottom';
+    distanceFromBottomPx: number;
+};
+export interface MarkstreamMeasuredHeightCacheEntry {
+    index: number;
+    height: number;
+}
+export interface MarkstreamHeightCacheEntry extends MarkstreamMeasuredHeightCacheEntry {
+    /**
+     * Compatibility metadata.
+     *
+     * NodeRenderer exports these fields for newly captured caches, and
+     * standalone virtualScroll.heightCache imports require signature at runtime.
+     */
+    nodeType?: string;
+    signature: string;
+}
+export type MarkstreamHeightCache = MarkstreamHeightCacheEntry[];
+export type MarkstreamInternalHeightCache = MarkstreamMeasuredHeightCacheEntry[];
+export interface MarkstreamVirtualMetrics {
+    sessionKey: string;
+    threadKey?: string;
+    phase: MarkstreamVirtualPhase;
+    nodeCount: number;
+    liveRange: {
+        start: number;
+        end: number;
+    };
+    renderedCount: number;
+    measuredCount: number;
+    estimatedCount: number;
+    averageNodeHeight: number;
+    topSpacerHeight: number;
+    bottomSpacerHeight: number;
+    visibleDomHeight: number;
+    totalHeight: number;
+    width: number;
+    final: boolean;
+    stable: boolean;
+    confidence: MarkstreamVirtualConfidence;
+    reason: MarkstreamVirtualReason;
+}
+export interface MarkstreamVirtualState {
+    sessionKey: string;
+    threadKey?: string;
+    /**
+     * Present only when this renderer is close enough to the scrollRoot viewport
+     * to own a restore anchor. Automatic height/cache state may omit it.
+     */
+    anchor?: MarkstreamVirtualAnchor;
+    /**
+     * true means `anchor` was captured from this renderer's current visible or
+     * near-visible viewport area. false/undefined means the state is primarily
+     * for metrics and height cache.
+     */
+    anchorCaptured?: boolean;
+    metrics: MarkstreamVirtualMetrics;
+    width: number;
+    contentHash?: string;
+    measurementKey?: string;
+    heightCache?: MarkstreamHeightCache;
+}
+export type MarkstreamScrollRoot = HTMLElement | null | undefined;
+export type MarkstreamScrollRootRef = Accessor<MarkstreamScrollRoot>;
+export type MarkstreamScrollRootLike = MarkstreamScrollRoot | MarkstreamScrollRootRef | {
+    $el?: MarkstreamScrollRoot;
+};
+export type MarkstreamScrollRootResolver = () => MarkstreamScrollRootLike;
+export type MarkstreamVirtualScrollHeightCacheOptions = {
+    heightCache?: null | undefined;
+    heightCacheWidth?: number;
+} | {
+    /**
+     * Cached measured node heights.
+     *
+     * When this is supplied outside restoreState, heightCacheWidth is required
+     * so the renderer can reject stale layout caches after width changes.
+     */
+    heightCache: MarkstreamHeightCache;
+    heightCacheWidth: number;
+};
+interface MarkstreamVirtualScrollSharedBaseOptions {
+    scrollRoot?: MarkstreamScrollRootLike | MarkstreamScrollRootResolver;
+    threadKey?: string;
+    restoreState?: MarkstreamVirtualState | null;
+    /**
+     * Apply `restoreState.anchor` to the shared scroll root.
+     *
+     * By default `restoreState` imports compatible height cache only, so several
+     * MarkdownRender instances can mount with persisted state without fighting
+     * over the same outer scroll root.
+     */
+    restoreAnchor?: boolean | string | number;
+    /**
+     * Extra cache invalidation key for layout-affecting host state:
+     * theme, font, density, custom component style revision, stream-diffs line height, etc.
+     */
+    measurementKey?: string | number;
+    settleMode?: 'auto' | 'manual';
+    settledToken?: string | number | boolean;
+    emitIntervalMs?: number;
+    heightDiffThresholdPx?: number;
+    /**
+     * Maximum number of measured node-height records emitted in heightCache.
+     *
+     * Default: 5000. Set <= 0 to export all compatible measured heights.
+     * Large values improve restore precision but increase event/state payload size.
+     */
+    heightCacheLimit?: number;
+}
+export type MarkstreamVirtualScrollSharedOptions = MarkstreamVirtualScrollSharedBaseOptions & MarkstreamVirtualScrollHeightCacheOptions;
+export type MarkstreamVirtualScrollOptions = (MarkstreamVirtualScrollSharedOptions & {
+    enabled: true;
+    sessionKey: string;
+}) | (MarkstreamVirtualScrollSharedOptions & {
+    enabled: boolean;
+    sessionKey: string;
+}) | (MarkstreamVirtualScrollSharedOptions & {
+    enabled?: false;
+    sessionKey?: string;
+});
+export interface MarkstreamCaptureVirtualStateOptions {
+    /**
+     * Default: false for imperative capture.
+     *
+     * Event-driven state emission still uses viewport-gated capture internally,
+     * but a host virtualizer can opt into viewport-gated imperative capture
+     * during thread switch.
+     */
+    requireViewport?: boolean;
+    /**
+     * Default: false.
+     *
+     * When true, captureVirtualState() may include a best-effort node anchor even
+     * if the renderer is not near the viewport. Such anchors are emitted with
+     * anchorCaptured=false and are not auto-restored unless explicitly opted in.
+     */
+    allowFallbackAnchor?: boolean;
+    /**
+     * Default: true.
+     */
+    includeEmptyState?: boolean;
+}
+export interface MarkstreamRendererHandle {
+    getVirtualMetrics: () => MarkstreamVirtualMetrics;
+    captureVirtualState: (options?: MarkstreamCaptureVirtualStateOptions) => MarkstreamVirtualState | null;
+    restoreVirtualState: (state: MarkstreamVirtualState, options?: {
+        /**
+         * Default: false.
+         *
+         * Only works when state.anchor exists. Cache import still works without
+         * anchor.
+         */
+        restoreAnchor?: boolean;
+        restoreToken?: string | number | boolean;
+        /**
+         * Default: false.
+         *
+         * Set true only when the caller knows an anchor with
+         * anchorCaptured=false still belongs to the active viewport context.
+         */
+        allowUncapturedAnchor?: boolean;
+    }) => void;
+    forceMeasure: (reason?: MarkstreamVirtualReason) => Promise<MarkstreamVirtualMetrics>;
+    settle: (options?: {
+        frames?: number;
+        timeoutMs?: number;
+        reason?: MarkstreamVirtualReason;
+        /**
+         * Force-clear pending delayed height-settling timers before returning.
+         * Default: false. Use only when the host knows async layout work is done.
+         */
+        flushPendingTimers?: boolean;
+    }) => Promise<MarkstreamVirtualMetrics>;
+    scrollToNode: (index: number, align?: 'start' | 'center' | 'end' | 'nearest') => void;
+}
+export interface MarkstreamNodeLifecycle {
+    reportHeight: (indexKey: string | number, height: number) => void;
+    markPending: (indexKey: string | number) => void;
+    markSettled: (indexKey: string | number) => void;
+}
+/** @experimental */
+export interface MarkstreamViewportPriorityOptions {
+    /** Root margin for MarkdownRender node-shell visibility. Default: '400px'. */
+    rootMargin?: string;
+    /** Root margin for built-in code block renderers and deferred HTML blocks. Defaults to rootMargin. */
+    heavyBlockMargin?: string;
+    /** Auto-disable threshold for MarkdownRender node-shell deferral only. Default: 640. */
+    maxTargets?: number;
+}
+export interface NodeRendererProps {
+    /** Raw Markdown input. Omit this when you pass pre-parsed nodes instead. */
+    content?: string;
+    /** Pre-parsed Markdown nodes to render without running the internal parser. */
+    nodes?: readonly BaseNode[] | null;
+    /**
+     * Whether the input stream is complete (end-of-stream). When true, the parser
+     * will stop emitting streaming "loading" nodes for unfinished constructs.
+     */
+    final?: boolean;
+    /** Options forwarded to parseMarkdownToStructure when content is provided */
+    parseOptions?: ParseOptions;
+    customMarkdownIt?: (md: MarkdownIt) => MarkdownIt;
+    /** Log parse/render timing and virtualization stats (dev only) */
+    debugPerformance?: boolean;
+    /**
+     * Custom HTML-like tags that participate in streaming mid-state handling
+     * and are emitted as custom nodes (e.g. ['thinking']). Forwarded to `getMarkdown()`.
+     */
+    customHtmlTags?: readonly string[];
+    customComponents?: CustomComponentMap;
+    streamingComponents?: StreamingComponentMap;
+    htmlComponents?: HtmlComponentMap;
+    allowHtml?: boolean;
+    /** Preset renderer tuning. Default keeps the existing docs/rich path. */
+    mode?: NodeRendererMode;
+    /**
+     * DOM structure mode. `minimal` is best-effort and falls back to full DOM
+     * when rendering needs per-node wrappers.
+     */
+    domMode?: NodeRendererDomMode;
+    /** HTML rendering policy for html_block/html_inline nodes. Default: safe */
+    htmlPolicy?: HtmlPolicy;
+    /** Defer built-in heavy nodes until they approach the viewport. Set false to render them immediately. Default: true. */
+    viewportPriority?: boolean;
+    /** Experimental viewport priority observer tuning; not part of the 1.x compatibility promise. */
+    viewportPriorityOptions?: MarkstreamViewportPriorityOptions;
+    /**
+     * Whether code_block renders should stream updates.
+     * When false, code blocks stay in a loading state and render once when final content is ready.
+     * Default: true
+     */
+    codeBlockStream?: boolean;
+    /** Preferred dark stream-diffs theme forwarded to every code block renderer. */
+    codeBlockDarkTheme?: CodeBlockTheme;
+    /** Preferred light stream-diffs theme forwarded to every code block renderer. */
+    codeBlockLightTheme?: CodeBlockTheme;
+    /** Force the built-in fenced-code path to PreCodeNode. Custom code block overrides keep priority. */
+    renderCodeBlocksAsPre?: boolean;
+    /** Minimum width forwarded to CodeBlockNode (px or CSS unit) */
+    codeBlockMinWidth?: string | number;
+    /** Maximum width forwarded to CodeBlockNode (px or CSS unit) */
+    codeBlockMaxWidth?: string | number;
+    /** Runtime options forwarded to stream-diffs-backed CodeBlockNode instances. */
+    codeBlockOptions?: CodeBlockOptions;
+    /** Arbitrary props to forward to every CodeBlockNode */
+    codeBlockProps?: NodeRendererCodeBlockProps;
+    /** Props forwarded to MermaidBlockNode for mermaid fences */
+    mermaidProps?: Partial<Omit<MermaidBlockNodeProps, 'node' | 'loading' | 'isDark'>>;
+    /** Props forwarded to D2BlockNode for d2/d2lang fences */
+    d2Props?: Partial<Omit<D2BlockNodeProps, 'node' | 'loading' | 'isDark'>>;
+    /** Props forwarded to InfographicBlockNode for infographic fences */
+    infographicProps?: Partial<Omit<InfographicBlockNodeProps, 'node' | 'loading' | 'isDark'>>;
+    /** Global tooltip toggle for link/code-block renderers (default: true) */
+    showTooltips?: boolean;
+    /**
+     * Theme-name tuple ordered as `[dark, light]` for stream-diffs-backed code blocks.
+     */
+    themes?: CodeBlockThemes;
+    /** Forces dark mode for built-in renderers such as Mermaid, D2, KaTeX, and code blocks. */
+    isDark?: boolean;
+    /** Scope key used by `setCustomComponents()` and `data-custom-id` style overrides. */
+    customId?: string;
+    indexKey?: number | string;
+    /** Show a blinking typewriter cursor while streamed content grows. `true` uses precise cursor positioning. Applies to `content` mode; ignored when non-empty `nodes` are provided. Default: false */
+    typewriter?: NodeRendererTypewriter;
+    /**
+     * Enable built-in smooth pacing for streaming `content` updates.
+     * - `true`: force-enable smooth streaming (content mode only)
+     * - `false`: force-disable smooth streaming
+     * - `'auto'` (default): enable only when typewriter/incremental mode is active
+     * Applies when rendering from `content` (not `nodes`).
+     * Default: 'auto'
+     */
+    smoothStreaming?: boolean | 'auto';
+    /** Options forwarded to the built-in smooth streaming composable. */
+    smoothStreamingOptions?: SmoothMarkdownStreamOptions;
+    /** Performance tuning knob for the minimum interval in ms between built-in smooth-streaming parse commits. Default: 80. */
+    parseCoalesceMs?: number;
+    /** Enable/disable non-code-node enter and streamed-text fade animations. Default: true */
+    fade?: boolean;
+    /** Enable incremental/batched rendering of nodes to avoid large single flush costs. Default: true */
+    batchRendering?: boolean;
+    /** How many nodes to render immediately before batching kicks in. Default: 40 */
+    initialRenderBatchSize?: number;
+    /** How many additional nodes to render per batch tick. Default: 80 */
+    renderBatchSize?: number;
+    /** Extra delay (ms) before each batch after rAF; helps yield to input. Default: 16 */
+    renderBatchDelay?: number;
+    /** Target budget (ms) for each batch before we shrink subsequent batch sizes. Default: 6 */
+    renderBatchBudgetMs?: number;
+    /** Timeout (ms) for requestIdleCallback slices. Default: 120 */
+    renderBatchIdleTimeoutMs?: number;
+    /** Defer rendering nodes until they are near the viewport */
+    deferNodesUntilVisible?: boolean;
+    /** Maximum number of fully rendered nodes kept in DOM. Default: 220 */
+    maxLiveNodes?: number;
+    /** Number of nodes to keep before/after focus. Default: 60 */
+    liveNodeBuffer?: number;
+    /**
+     * Controls node-level virtualization inside this Markdown document only.
+     *
+     * It does not virtualize a chat/timeline list. Use MarkstreamVirtualTimeline
+     * or useMarkstreamVirtualAdapter for the outer conversation surface.
+     */
+    nodeVirtual?: boolean | 'auto';
+    /** Advanced: report logical height and restore state to an outer virtual scroller. */
+    virtualScroll?: MarkstreamVirtualScrollOptions;
+    /** @internal */
+    renderAsFragment?: boolean;
+}
+export {};

package/dist/useSmoothMarkdownStream.d.ts

@@ -0,0 +1,22 @@
+import type { SmoothMarkdownStreamOptions } from 'markstream-core';
+export declare function useSmoothMarkdownStream(options?: SmoothMarkdownStreamOptions): {
+    snapshot: import("solid-js").Accessor<import("markstream-core").SmoothMarkdownStreamSnapshot>;
+    source: () => string;
+    visible: () => string;
+    done: () => boolean;
+    final: () => boolean;
+    caughtUp: () => boolean;
+    pendingChars: () => number;
+    getSnapshot: () => import("markstream-core").SmoothMarkdownStreamSnapshot;
+    subscribe: (listener: import("markstream-core").SmoothStreamNotify) => () => void;
+    enqueue: (chunk: string) => void;
+    finish: (options?: {
+        flush?: boolean;
+    }) => void;
+    flush: () => void;
+    reset: (initialMarkdown?: string) => void;
+    pause: () => void;
+    resume: () => void;
+    destroy: () => void;
+    dispose: () => void;
+};

package/dist/utils/clipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyTextToClipboard(source: string): Promise<boolean>;

package/dist/utils/d2RenderSalt.d.ts

@@ -0,0 +1 @@
+export declare function createD2RenderSalt(prefix?: string): string;

package/dist/utils/footnoteTarget.d.ts

@@ -0,0 +1 @@
+export declare function findFootnoteElement(source: EventTarget | null | undefined, id: string): Element | null;

package/dist/utils/index.d.ts

@@ -0,0 +1,8 @@
+export { NodeLifecycleContext as MARKSTREAM_NODE_LIFECYCLE_KEY, useMarkstreamNodeLifecycle } from '../components/lifecycle';
+export * from '../icon-themes';
+export { isCodeBlockRuntimeReady, preloadCodeBlockRuntime } from '../optional/streamDiffs';
+export * from './katex-threshold';
+export * from './languageIcon';
+export * from './performance-monitor';
+export * from './safeRaf';
+export * from 'stream-markdown-parser';

package/dist/utils/katex-threshold.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Recommend when to use Worker based on formula count and complexity.
+ *
+ * N_threshold ≈ floor(B / (R × (1 - H)))
+ * - B: main-thread budget (ms), e.g. 50ms or a stricter 16.7ms
+ * - R: avg render time per unique formula (ms)
+ * - H: cache hit rate (0~1)
+ */
+export interface ThresholdInput {
+    R: number;
+    H?: number;
+    B?: number;
+}
+export declare function recommendWorkerThreshold({ R, H, B }: ThresholdInput): number;
+export declare function estimateRByFormula(sample: string): 'simple' | 'medium' | 'complex';
+export declare function defaultRByClass(cls: 'simple' | 'medium' | 'complex'): number;
+export declare function recommendNForSamples(formulas: string[], opts?: {
+    H?: number;
+    B?: number;
+}): number;

package/dist/utils/languageIcon.d.ts

@@ -0,0 +1,8 @@
+export type LanguageIconResolver = (lang: string) => string | undefined | null;
+export declare const languageIconsRevision: import("solid-js").Accessor<number>;
+export declare function setLanguageIconResolver(resolver?: LanguageIconResolver | null): void;
+export declare function normalizeLanguageIdentifier(lang?: string | null): string;
+export declare function resolveLanguageId(lang?: string | null): string;
+export declare function preloadExtendedLanguageIcons(): Promise<void>;
+export declare function getLanguageIcon(lang: string): string;
+export declare const languageMap: Record<string, string>;

package/dist/utils/mermaidRenderId.d.ts

@@ -0,0 +1 @@
+export declare function createMermaidRenderId(prefix?: string): string;

package/dist/utils/normalizeKaTeXRenderInput.d.ts

@@ -0,0 +1 @@
+export declare function normalizeKaTeXRenderInput(content: string): string;