@owomark/core 0.1.5 → 0.1.7

package/dist/editor-core-DbPhn6aI.d.ts

@@ -0,0 +1,249 @@
+import { a as OwoMarkDocument, O as OwoMarkSelection, V as VirtualSelection, C as CompositionState, B as BlockType, b as BlockContext, c as BlockInsertType, d as BlockContextListener } from './public-zMo7BR9l.js';
+
+type CoreSelectionSnapshot = {
+    linear: OwoMarkSelection | null;
+    virtual: VirtualSelection | null;
+};
+type CoreStateSnapshot = {
+    markdown: string;
+    document: OwoMarkDocument;
+    selection: CoreSelectionSnapshot;
+    composition: CompositionState;
+};
+type BeforeInputIntent = {
+    inputType: string;
+    data: string | null;
+};
+type KeyDownIntent = {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+};
+type PasteIntent = {
+    text: string;
+};
+type CoreApplyAction = 'handled' | 'allow-native' | 'composition-sync';
+type CoreApplyResult = {
+    action: CoreApplyAction;
+    snapshot: CoreStateSnapshot;
+};
+
+/**
+ * Structural Tab / Shift+Tab handling for Markdown containers.
+ * Code fences, blockquotes, and list items are resolved here so EditorCore
+ * only dispatches the intent and keeps its plain-text fallback for
+ * out-of-scope paragraphs.
+ */
+type IndentMode = 'auto' | '2' | '4';
+type IndentOperation = 'code-indent' | 'code-outdent' | 'list-indent' | 'list-outdent' | 'blockquote-indent' | 'blockquote-outdent' | 'noop-illegal-mixed-selection' | 'noop-unsupported-structure';
+type IndentResult = {
+    handled: boolean;
+    value: string;
+    selectionStart: number;
+    selectionEnd: number;
+    indentSize: number;
+    language: string;
+    operation?: IndentOperation;
+};
+declare function resolveIndentSize(language: string, mode: IndentMode): number;
+declare function applyMarkdownIndent(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+    shiftKey: boolean;
+    mode: IndentMode;
+}): IndentResult;
+
+type CommandDefinition = {
+    /** Unique identifier, e.g. 'side-annotation', 'code-fence' */
+    id: string;
+    /** Display label for menu, injected from editor descriptors for built-ins. */
+    label: string;
+    /** Descriptor-backed label key for i18n-capable consumers. */
+    labelKey?: string;
+    /** Optional description shown in menu subtitle */
+    description?: string;
+    /** Keywords for substring matching (e.g. ['brace', 'margin', 'note']) */
+    keywords?: string[];
+    /** Icon identifier or inline SVG string */
+    icon?: string;
+    /** Keyboard shortcut (informational, binding is separate) */
+    shortcut?: string;
+    /** Menu category for grouping, injected from editor descriptors for built-ins. */
+    category?: string;
+    /** Descriptor-backed category key for i18n-capable consumers. */
+    categoryKey?: string;
+    /** Sort priority within category (lower = higher in list, default 100) */
+    priority?: number;
+    /** Whether this command appears in the slash menu (default: true) */
+    slashMenu?: boolean;
+    /** Whether this command is eligible for toolbar display */
+    toolbarEligible?: boolean;
+    /** Predicate: can this command execute given current editor state? */
+    canExecute?: (ctx: CommandContext) => boolean;
+    /**
+     * Execute the command. Supports sync and async.
+     * Core awaits the Promise if returned; adapter may show loading indicator.
+     */
+    execute: (ctx: CommandContext, payload?: unknown) => void | Promise<void>;
+};
+type CommandContext = {
+    /** Current full markdown text (/query already removed when invoked from slash menu) */
+    text: string;
+    /** Linear selection start offset */
+    selectionStart: number;
+    /** Linear selection end offset */
+    selectionEnd: number;
+    /** Low-level: apply a text + selection update to the document (atomic — single undo entry) */
+    applyUpdate: (newText: string, selection: {
+        anchor: number;
+        focus: number;
+    }) => void;
+    /** Access to current document model (read-only) */
+    document: OwoMarkDocument;
+    /** Current block type at cursor */
+    blockType: BlockType;
+    /** Structural depth info for context-aware commands */
+    blockDepth: number;
+    /**
+     * Slash trigger info (only present when invoked from slash menu).
+     * Null when invoked via dispatch() or keyboard shortcut.
+     */
+    triggerInfo: SlashTriggerInfo | null;
+    /** Feature flags from editor config */
+    enableSideAnnotation: boolean;
+    enableMath: boolean;
+    enableComponents: boolean;
+    /** Replace the /query trigger text with new content (cursor placed at end) */
+    replaceTriggerText: (text: string) => void;
+    /** Convert the current block to a different type by replacing its structural prefix */
+    turnIntoBlock: (prefix: string) => void;
+    /** Insert a new block below the current one */
+    insertBlockBelow: (markdown: string) => void;
+    /** Replace the current block with a temporary placeholder block and return its stable block ID. */
+    insertPlaceholderBlock: (markdown: string) => string | null;
+    /** Replace a block by its stable block ID. Returns false if the block no longer exists. */
+    replaceBlockById: (blockId: string, markdown: string) => boolean;
+    /** Remove a block by its stable block ID. Returns false if the block no longer exists. */
+    removeBlockById: (blockId: string) => boolean;
+    /** Insert a template with cursor placed at the specified offset within the template */
+    insertTemplate: (template: string, cursorOffset: number) => void;
+};
+type SlashTriggerInfo = {
+    /** Position of '/' in the document */
+    startOffset: number;
+    /** Cursor position when command was selected */
+    endOffset: number;
+    /** Text typed after '/' (e.g. 'side' for '/side') */
+    query: string;
+};
+type SlashState = {
+    /** Whether the slash menu is currently open */
+    active: boolean;
+    /** Position of '/' in the document */
+    triggerOffset: number;
+    /** Characters typed after '/' */
+    query: string;
+    /** Keyboard-navigated highlight index */
+    selectedIndex: number;
+    /** registry.search(query) result (readonly — consumers must not mutate) */
+    filteredCommands: readonly CommandDefinition[];
+    /** True while async command is executing */
+    pending: boolean;
+};
+type CommandRegistry = {
+    register(def: CommandDefinition): () => void;
+    unregister(id: string): void;
+    get(id: string): CommandDefinition | undefined;
+    getAll(): CommandDefinition[];
+    /** Filter commands matching a query string (for slash menu) */
+    search(query: string): CommandDefinition[];
+};
+type SlashStateListener = (state: SlashState) => void;
+
+/**
+ * Pure logic editor core. Owns document, history, selection, composition,
+ * and input interpretation. No DOM dependency.
+ *
+ * Adapters (React / Vanilla) call Core input methods and subscribe to
+ * state changes. Core never reads or writes DOM.
+ */
+
+/** Callback for sovereign mode: View layer subscribes to Model changes. */
+type DocumentChangeCallback = (doc: OwoMarkDocument, selection: VirtualSelection) => void;
+type OwoMarkCore = {
+    getSnapshot(): CoreStateSnapshot;
+    getMarkdown(): string;
+    getSelection(): OwoMarkSelection | null;
+    getDocument(): OwoMarkDocument;
+    getVirtualSelection(): VirtualSelection | null;
+    getComposition(): CompositionState;
+    setMarkdown(markdown: string): void;
+    replaceMarkdown(markdown: string, selection: OwoMarkSelection): void;
+    dispatch(command: string, payload?: unknown): void;
+    setIndentMode(mode: IndentMode): void;
+    setEnableSideAnnotation(enabled: boolean): void;
+    setEnableMath(enabled: boolean): void;
+    setEnableComponents(enabled: boolean): void;
+    /** Execute a command by its id (for toolbar / external callers). */
+    executeCommandById(id: string, payload?: unknown): void;
+    /**
+     * Apply a document update from an external source (e.g. DOM sync after
+     * unknown inputType or composition end). Core reconciles, updates state,
+     * and emits changes.
+     */
+    syncText(text: string, selection: OwoMarkSelection | null): void;
+    applyBeforeInput(intent: BeforeInputIntent, selection: OwoMarkSelection | null): CoreApplyResult;
+    applyKeyDown(intent: KeyDownIntent, selection: OwoMarkSelection | null): CoreApplyResult;
+    applyPaste(intent: PasteIntent, selection: OwoMarkSelection | null): CoreApplyResult;
+    handleCompositionStart(selection: OwoMarkSelection | null): void;
+    handleCompositionUpdate(): void;
+    handleCompositionEnd(selection: OwoMarkSelection | null, fallbackText?: string | null): CoreApplyResult;
+    updateSelection(selection: OwoMarkSelection): void;
+    /** Get the block context at the current cursor position. */
+    getBlockContext(): BlockContext;
+    /**
+     * Insert a block template at the current cursor position.
+     * Unified entry point for toolbar / command palette.
+     */
+    insertBlock(type: BlockInsertType, options?: {
+        language?: string;
+    }): void;
+    getCommandRegistry(): CommandRegistry;
+    getSlashState(): SlashState;
+    /** Register a custom command. Returns unregister function. */
+    registerCommand(def: CommandDefinition): () => void;
+    /** Execute a slash command by index in filtered list (for menu click/enter). */
+    executeSlashCommand(index: number): void;
+    /** Dismiss the slash menu without executing. */
+    dismissSlashMenu(): void;
+    onChange(callback: (markdown: string) => void): () => void;
+    onSelectionChange(callback: (selection: OwoMarkSelection) => void): () => void;
+    onCompositionStateChange(callback: (active: boolean) => void): () => void;
+    onStateChange(callback: (snapshot: CoreStateSnapshot) => void): () => void;
+    onSlashStateChange(callback: SlashStateListener): () => void;
+    /** Subscribe to block context changes (fires on selection or document change). */
+    onBlockContextChange(callback: BlockContextListener): () => void;
+    /**
+     * Register a document change callback (sovereign mode).
+     * When registered, adapters should render declaratively from the document.
+     */
+    onDocumentChange(callback: DocumentChangeCallback): () => void;
+    /** Dispose timers and internal state. */
+    destroy(): void;
+};
+type CreateOwoMarkCoreOptions = {
+    initialMarkdown?: string;
+    indentMode?: IndentMode;
+    /** Enable side annotation Enter-continuation. Defaults to true. */
+    enableSideAnnotation?: boolean;
+    /** Enable math slash command visibility. Defaults to true. */
+    enableMath?: boolean;
+    /** Enable built-in component commands. Defaults to true. */
+    enableComponents?: boolean;
+};
+declare function createOwoMarkCore(options?: CreateOwoMarkCoreOptions): OwoMarkCore;
+
+export { type BeforeInputIntent as B, type CoreStateSnapshot as C, type DocumentChangeCallback as D, type IndentMode as I, type KeyDownIntent as K, type OwoMarkCore as O, type PasteIntent as P, type SlashState as S, type CommandRegistry as a, type CommandContext as b, type CommandDefinition as c, type CoreApplyAction as d, type CoreApplyResult as e, type CoreSelectionSnapshot as f, type CreateOwoMarkCoreOptions as g, type IndentResult as h, type SlashStateListener as i, type SlashTriggerInfo as j, applyMarkdownIndent as k, createOwoMarkCore as l, resolveIndentSize as r };

package/dist/index.d.ts

@@ -1,8 +1,17 @@
-import { B as BlockNode, a as BlockContextType, O as OwoMarkSelection, C as CoreStateSnapshot, S as SlashState, b as CommandRegistry, c as OwoMarkDocument, D as DirtyRange, P as PreviewBlockKind, d as PreviewBlock, e as BlockTransform, f as OwoMarkSharedStateController, I as InlineToken, g as InlineTokenType } from './dom-adapter-CTSJe5Uo.js';
-export { h as BeforeInputIntent, i as BlockContext, j as BlockContextListener, k as BlockInsertType, l as BlockType, m as CommandContext, n as CommandDefinition, o as CompositionState, p as CoreApplyAction, q as CoreApplyResult, r as CoreSelectionSnapshot, s as CreateOwoMarkCoreOptions, t as Decorator, u as DecoratorType, v as DocumentChangeCallback, w as DomAdapterInstance, H as HeadingLevel, x as HistoryEntry, y as IndentMode, z as IndentResult, J as JsonPrimitive, A as JsonValue, K as KeyDownIntent, L as Leaf, E as OwoMarkCommands, F as OwoMarkCore, G as OwoMarkEditorInstance, M as OwoMarkEditorLike, N as OwoMarkSharedState, Q as OwoMarkSharedStateStore, R as PasteIntent, T as PreviewDirtyReason, U as SlashStateListener, V as SlashTriggerInfo, W as VirtualPosition, X as VirtualSelection, Y as applyMarkdownIndent, Z as createOwoMarkCore, _ as getBlockIndexForPosition, $ as isVirtualSelectionCollapsed, a0 as linearToVirtual, a1 as linearToVirtualPosition, a2 as resolveIndentSize, a3 as virtualPositionToLinear, a4 as virtualPositionsEqual, a5 as virtualToLinear } from './dom-adapter-CTSJe5Uo.js';
+import { C as CoreStateSnapshot, S as SlashState, a as CommandRegistry } from './editor-core-DbPhn6aI.js';
+export { B as BeforeInputIntent, b as CommandContext, c as CommandDefinition, d as CoreApplyAction, e as CoreApplyResult, f as CoreSelectionSnapshot, g as CreateOwoMarkCoreOptions, D as DocumentChangeCallback, I as IndentMode, h as IndentResult, K as KeyDownIntent, O as OwoMarkCore, P as PasteIntent, i as SlashStateListener, j as SlashTriggerInfo, k as applyMarkdownIndent, l as createOwoMarkCore, r as resolveIndentSize } from './editor-core-DbPhn6aI.js';
+import { g as BlockNode, h as BlockContextType, O as OwoMarkSelection, i as ContainerBlockSyntaxExtension, J as JsonValue, j as ParseMarkdownOptions, a as OwoMarkDocument, k as ConformanceDocument, D as DirtyRange, P as PreviewBlockKind, f as PreviewBlock, l as BlockTransform, m as OwoMarkSharedStateController, n as InlineExtensionPriority, o as InlineSyntaxExtension, T as TokenizeInlineOptions, e as InlineToken, p as TokenizeBlockOptions } from './public-zMo7BR9l.js';
+export { b as BlockContext, d as BlockContextListener, q as BlockExtensionPriority, c as BlockInsertType, r as BlockSyntaxExtension, B as BlockType, s as CLASSLESS_INLINE_TOKEN_TYPES, C as CompositionState, t as ConformanceBlockNode, u as ConformanceContainerNode, v as ConformanceInlineNode, w as ConformanceTableCell, x as ConformanceTableRow, y as ContainerBlockExtensionPriority, z as ContainerFrame, A as ContainerKind, E as CustomBlockRuntimeBinding, F as Decorator, G as DecoratorType, H as HeadingLevel, K as HistoryEntry, L as INLINE_TOKEN_TYPES, M as InlineExtensionHostBlockType, N as InlineScannerMatch, I as InlineTokenType, Q as JsonPrimitive, R as Leaf, S as OwoMarkCommands, U as OwoMarkDocumentTrace, W as OwoMarkEditorLike, X as OwoMarkSharedState, Y as OwoMarkSharedStateStore, Z as ParserDiffScope, _ as ParserExtensionConsumer, $ as ParserExtensionParent, a0 as ParserExtensionScope, a1 as PreviewDirtyReason, a2 as SideAnnotationMemberBlock, a3 as SideAnnotationMemberBlockType, a4 as SideAnnotationSourceKind, a5 as TokenizeBlockExtensionOptions, a6 as VirtualPosition, V as VirtualSelection, a7 as getBlockIndexForPosition, a8 as isVirtualSelectionCollapsed, a9 as linearToVirtual, aa as linearToVirtualPosition, ab as virtualPositionToLinear, ac as virtualPositionsEqual, ad as virtualToLinear } from './public-zMo7BR9l.js';
+export { O as OwoComponentDescriptor, d as OwoEditorEntryDescriptor, f as OwoFeatureFlagKey, g as OwoRuntimeBlockDescriptor, h as OwoSyntaxDescriptor } from './registry-C849sxCo.js';
+export { getSyntaxDescriptor, parseInlineSideAnnotationFromText, stripInlineSideAnnotationTail, stripSideContinuationTail, syntaxRegistry } from './semantic/syntax/index.js';
+export { componentRegistry, getComponentDescriptor, getComponentDescriptorByDirective } from './semantic/components/index.js';
+export { getRuntimeBlockDescriptor, getRuntimeBlockDescriptorByBlockType, getRuntimeBlockDescriptorByPreviewKind, runtimeBlockRegistry } from './semantic/runtime/index.js';
+export { editorEntryRegistry, getEditorEntryDescriptor, getEditorEntryDescriptorByCommandId, resolveEditorEntryPresentation } from './semantic/editor/index.js';
 export { WordBoundaryResult, deleteToLineEnd, deleteToLineStart, deleteWordBackward, deleteWordForward } from './internal/commands/word-boundary.js';
 export { normalizeMarkdownPaste } from './internal/clipboard/paste.js';
 export { enableMapSet, produce } from 'immer';
+import { O as OwoMarkScrollProjectionSnapshot, c as OwoMarkScrollProjectionSegment, S as SourceKey, a as OwoMarkSurfaceGeometrySnapshot, V as ViewportMetrics, G as GlobalScrollPosition } from './types-DMqYF6Zn.js';
+export { C as ContentId, d as Geometry, b as OwoMarkScrollController, e as OwoMarkScrollDegradedReason, f as OwoMarkSurfaceGeometrySegment, g as OwoMarkSurfaceGeometrySnapshotStatus, h as ScrollProjectionSegmentKind, i as ScrollResolutionResult, j as ScrollSurface, k as ScrollToScrollPositionOptions, l as ScrollToScrollPositionResult } from './types-DMqYF6Zn.js';
 
 /**
  * Resolve the extended BlockContextType from a BlockNode.
@@ -39,19 +48,34 @@ type CoreEventHub = {
 
 declare function createCommandRegistry(): CommandRegistry;
 
+declare const CARDS_FAMILY_CUSTOM_BLOCK_KEY = "cards-family";
+type CardsFamilyTone = 'neutral' | 'info' | 'warning';
+type CardsFamilyCard = {
+    title: string | null;
+    tone: CardsFamilyTone | null;
+    bodyMarkdown: string;
+};
+type CardsFamilyAttributes = {
+    layout: {
+        cols: 2;
+    };
+    cards: CardsFamilyCard[];
+};
+declare function isCardsFamilyAttributes(value: JsonValue | undefined): value is CardsFamilyAttributes;
+declare const cardsFamilyContainerExtension: ContainerBlockSyntaxExtension;
+
 type BlockIdGenerator = () => string;
 /** Create a per-instance block ID generator. */
 declare function createBlockIdGenerator(): BlockIdGenerator;
 /** Reset the default block ID counter (for testing). */
 declare function resetBlockIdCounter(): void;
-declare function parseMarkdownToDocument(markdown: string, genId?: BlockIdGenerator): OwoMarkDocument;
-/**
- * Reconcile old and new block arrays using head+tail scanning.
- * Unchanged blocks at the head and tail preserve old identity (including ID).
- * Middle blocks (inserted, deleted, or modified) use new identity.
- */
+
+declare function parseMarkdownToDocument(markdown: string, genIdOrOptions?: BlockIdGenerator | ParseMarkdownOptions, parseOptions?: ParseMarkdownOptions): OwoMarkDocument;
+
 declare function reconcileBlocks(oldBlocks: readonly BlockNode[], newBlocks: readonly BlockNode[]): BlockNode[];
+
 declare function serializeDocument(doc: OwoMarkDocument): string;
+
 declare function getBlockById(doc: OwoMarkDocument, blockId: string): BlockNode | undefined;
 declare function getBlockIndexById(doc: OwoMarkDocument, blockId: string): number;
 declare function getBlockAtOffset(doc: OwoMarkDocument, offset: number): {
@@ -60,30 +84,21 @@ declare function getBlockAtOffset(doc: OwoMarkDocument, offset: number): {
 };
 declare function getBlockStartOffset(doc: OwoMarkDocument, blockIndex: number): number;
 
-/**
- * Convert a DOM Selection/Range to a linear character offset relative to
- * the editor root element.
- */
-declare function domRangeToOffset(root: HTMLElement, range: {
-    startContainer: Node;
-    startOffset: number;
-    endContainer: Node;
-    endOffset: number;
-}): OwoMarkSelection | null;
-/**
- * Convert a linear character offset back to a DOM Range within the editor root.
- */
-declare function offsetToDomRange(root: HTMLElement, selection: OwoMarkSelection): Range | null;
-/**
- * Restore a selection on the editor root from linear offsets.
- */
-declare function restoreSelection(root: HTMLElement, selection: OwoMarkSelection): void;
-/**
- * Read current DOM selection as linear offsets.
- */
-declare function readSelection(root: HTMLElement): OwoMarkSelection | null;
-/** Invalidate the cached block element list. Call after every DOM render. */
-declare function invalidateBlockCache(root: HTMLElement): void;
+type MdastNode = {
+    type: string;
+    value?: string;
+    depth?: number;
+    ordered?: boolean;
+    checked?: boolean | null;
+    lang?: string | null;
+    align?: (string | null)[];
+    children?: MdastNode[];
+    url?: string;
+    alt?: string;
+};
+declare function buildConformanceDocument(blocks: readonly BlockNode[]): ConformanceDocument;
+declare function hydrateOwoMarkDocument(blocks: readonly BlockNode[]): OwoMarkDocument;
+declare function buildConformanceMdastRoot(document: Pick<OwoMarkDocument, 'conformance'>): MdastNode;
 
 /**
  * Merge a new dirty block index into an existing dirty range.
@@ -130,12 +145,6 @@ declare function deriveRenderKey(raw: string, kind: PreviewBlockKind, themeKey?:
  */
 
 declare function projectToPreviewBlocks(doc: OwoMarkDocument, themeKey?: string, transforms?: BlockTransform[]): PreviewBlock[];
-/**
- * Compare two preview block arrays and return the dirty range.
- * Uses two-pointer scan to find the tightest changed range (EV3).
- * Returns null if no blocks changed.
- * endBlock is always clamped to valid newBlocks range (RISK-3).
- */
 declare function computePreviewDirtyRange(oldBlocks: PreviewBlock[], newBlocks: PreviewBlock[]): {
     startBlock: number;
     endBlock: number;
@@ -156,17 +165,21 @@ type CreateSharedStateOptions = {
 };
 declare function createSharedStateStore(options?: CreateSharedStateOptions): OwoMarkSharedStateController;
 
-/**
- * Tokenize inline Markdown content into decoration tokens.
- * Pure function, no DOM dependency.
- */
-declare function tokenizeInline(raw: string, baseOffset?: number): InlineToken[];
+declare function createDelimitedInlineExtension(config: {
+    key: string;
+    opener: string;
+    closer?: string;
+    priority?: InlineExtensionPriority;
+    canNestIn?: InlineSyntaxExtension['canNestIn'];
+    diffScope?: InlineSyntaxExtension['diffScope'];
+}): InlineSyntaxExtension;
+declare function tokenizeInline(raw: string, baseOffset?: number, options?: TokenizeInlineOptions): InlineToken[];
 
 /**
  * Tokenize a single block's raw text into InlineToken[].
  * Block-level markers (heading #, list bullet, etc.) get their own token types.
  */
-declare function tokenizeBlock(raw: string, blockType: string, baseOffset?: number): InlineToken[];
+declare function tokenizeBlock(raw: string, blockType: string, baseOffset?: number, options?: TokenizeBlockOptions): InlineToken[];
 
 /**
  * Enter key handling: list continuation, blockquote continuation,
@@ -300,47 +313,6 @@ type ImageSizeSyntax = 'obsidian' | 'pandoc' | 'mou' | 'none';
  */
 declare function createImageSizeTransform(syntax?: ImageSizeSyntax): BlockTransform;
 
-/**
- * Incremental DOM patch: only re-render dirty blocks.
- */
-
-/**
- * Full render: build entire editor DOM from document model.
- */
-declare function fullRender(root: HTMLElement, doc: OwoMarkDocument): void;
-/**
- * Incremental patch: only re-render blocks in dirty range.
- */
-declare function patchDirtyBlocks(root: HTMLElement, doc: OwoMarkDocument, dirty: DirtyRange): void;
-/**
- * Detect changed blocks between old and new document, then render minimally.
- * Falls back to full render when block count changes or no dirty blocks found
- * despite text difference (structural shift).
- */
-declare function detectAndRenderDirty(root: HTMLElement, oldDoc: OwoMarkDocument, newDoc: OwoMarkDocument, fullFallback?: boolean): void;
-
-/**
- * Render a block's inline tokens into DOM nodes within a block container.
- * Each block is a <div data-owo-block="index"> containing text/span nodes.
- */
-
-declare const TOKEN_TO_CLASS: Record<InlineTokenType, string>;
-declare const BLOCK_TYPE_TO_CLASS: Record<string, string>;
-declare function createBlockElement(doc: Document, tokens: InlineToken[], blockIndex: number, blockType: string, headingLevel?: number, depth?: number): HTMLDivElement;
-/**
- * Update an existing block element's content with new tokens.
- * Returns true if the block was modified.
- */
-declare function updateBlockElement(doc: Document, existing: HTMLDivElement, tokens: InlineToken[], blockType: string, headingLevel?: number, depth?: number): boolean;
-
-declare const BQ_STEP: number;
-/**
- * Build the CSS box-shadow value for nested blockquote bars.
- * Returns null when depth <= 1 (no extra bars needed — the first bar is
- * rendered by the block's own border/class styling).
- */
-declare function buildBlockquoteBarsBoxShadow(depth: number): string | null;
-
 /** A flattened row for virtual list computation. */
 type VirtualRow = {
     blockIndex: number;
@@ -362,4 +334,23 @@ declare function buildVirtualRows(blocks: readonly BlockNode[], heightCache: Map
 /** Compute the visible range given scroll state. */
 declare function computeVisibleRange(rows: VirtualRow[], scrollTop: number, viewportHeight: number, overscan?: number): VisibleRange;
 
-export { BLOCK_TYPE_TO_CLASS, BQ_STEP, BlockContextType, type BlockIdGenerator, BlockNode, BlockTransform, CommandRegistry, type CommandResult, type CoreEventHub, type CoreSlashStateListener, CoreStateSnapshot, type CreateSharedStateOptions, DirtyRange, type ImageSizeSyntax, InlineToken, InlineTokenType, NOT_HANDLED, OwoMarkDocument, OwoMarkSelection, OwoMarkSharedStateController, PreviewBlock, PreviewBlockKind, SlashState, TOKEN_TO_CLASS, type VirtualRow, type VisibleRange, buildBlockquoteBarsBoxShadow, buildVirtualRows, computePreviewDirtyRange, computeVisibleRange, createBlockElement, createBlockIdGenerator, createCommandRegistry, createImageSizeTransform, createSharedStateStore, deriveBlockId, deriveRenderKey, deriveSourceKey, detectAndRenderDirty, domRangeToOffset, estimateEditorBlockHeight, expandDirtyRange, expandWithContext, fullRender, getBlockAtOffset, getBlockById, getBlockIndexById, getBlockStartOffset, handleCharInput, handleMarkdownEnter, handleSmartBackspace, handleSmartDelete, insertCodeFence, insertImage, insertLink, insertMathBlock, insertSideAnnotation, insertTable, invalidateBlockCache, offsetToDomRange, parseMarkdownToDocument, patchDirtyBlocks, projectToPreviewBlocks, readSelection, reconcileBlocks, resetBlockIdCounter, resolveBlockContextType, restoreSelection, serializeDocument, toggleBold, toggleItalic, tokenizeBlock, tokenizeInline, updateBlockElement };
+declare function projectToScrollSegments(previewBlocks: readonly PreviewBlock[]): OwoMarkScrollProjectionSegment[];
+declare function buildScrollProjectionSnapshot(previewBlocks: readonly PreviewBlock[], documentRevision: number): OwoMarkScrollProjectionSnapshot;
+
+type ProgressSegment = {
+    sourceKey: SourceKey;
+    startLine: number;
+    endLine: number;
+    progressStart: number;
+    progressEnd: number;
+    top: number;
+    bottom: number;
+    height: number;
+    measured: boolean;
+};
+declare const DEFAULT_VIEWPORT_ANCHOR_RATIO = 0.35;
+declare function buildProgressSegments(projection: OwoMarkScrollProjectionSnapshot, geometry: OwoMarkSurfaceGeometrySnapshot): ProgressSegment[];
+declare function resolveScrollPosition(projection: OwoMarkScrollProjectionSnapshot, geometry: OwoMarkSurfaceGeometrySnapshot, viewport: ViewportMetrics, viewportAnchorRatio?: number): GlobalScrollPosition | null;
+declare function resolveScrollTopFromPosition(position: GlobalScrollPosition, projection: OwoMarkScrollProjectionSnapshot, geometry: OwoMarkSurfaceGeometrySnapshot, viewportHeight: number, scrollHeight: number, viewportAnchorRatio?: number): number | null;
+
+export { BlockContextType, type BlockIdGenerator, BlockNode, BlockTransform, CARDS_FAMILY_CUSTOM_BLOCK_KEY, type CardsFamilyAttributes, type CardsFamilyCard, type CardsFamilyTone, CommandRegistry, type CommandResult, ConformanceDocument, ContainerBlockSyntaxExtension, type CoreEventHub, type CoreSlashStateListener, CoreStateSnapshot, type CreateSharedStateOptions, DEFAULT_VIEWPORT_ANCHOR_RATIO, DirtyRange, GlobalScrollPosition, type ImageSizeSyntax, InlineExtensionPriority, InlineSyntaxExtension, InlineToken, JsonValue, NOT_HANDLED, OwoMarkDocument, OwoMarkScrollProjectionSegment, OwoMarkScrollProjectionSnapshot, OwoMarkSelection, OwoMarkSharedStateController, OwoMarkSurfaceGeometrySnapshot, ParseMarkdownOptions, PreviewBlock, PreviewBlockKind, type ProgressSegment, SlashState, SourceKey, TokenizeBlockOptions, TokenizeInlineOptions, ViewportMetrics, type VirtualRow, type VisibleRange, buildConformanceDocument, buildConformanceMdastRoot, buildProgressSegments, buildScrollProjectionSnapshot, buildVirtualRows, cardsFamilyContainerExtension, computePreviewDirtyRange, computeVisibleRange, createBlockIdGenerator, createCommandRegistry, createDelimitedInlineExtension, createImageSizeTransform, createSharedStateStore, deriveBlockId, deriveRenderKey, deriveSourceKey, estimateEditorBlockHeight, expandDirtyRange, expandWithContext, getBlockAtOffset, getBlockById, getBlockIndexById, getBlockStartOffset, handleCharInput, handleMarkdownEnter, handleSmartBackspace, handleSmartDelete, hydrateOwoMarkDocument, insertCodeFence, insertImage, insertLink, insertMathBlock, insertSideAnnotation, insertTable, isCardsFamilyAttributes, parseMarkdownToDocument, projectToPreviewBlocks, projectToScrollSegments, reconcileBlocks, resetBlockIdCounter, resolveBlockContextType, resolveScrollPosition, resolveScrollTopFromPosition, serializeDocument, toggleBold, toggleItalic, tokenizeBlock, tokenizeInline };