@surrealdb/ui 1.0.70 → 1.0.72

package/dist/ui.d.ts

@@ -1,28 +1,45 @@
 import { ActionIconProps } from '@mantine/core';
 import { AlertProps } from '@mantine/core';
+import { BadgeProps } from '@mantine/core';
 import { BoxProps } from '@mantine/core';
 import { ButtonProps } from '@mantine/core';
+import { CodeProps } from '@mantine/core';
 import { Command } from '@codemirror/view';
+import { Command as Command_2 } from 'prosemirror-state';
 import { EditorSelection } from '@codemirror/state';
+import { EditorState } from 'prosemirror-state';
 import { EditorView } from '@codemirror/view';
+import { EditorView as EditorView_2 } from 'prosemirror-view';
 import { ElementProps } from '@mantine/core';
 import { Extension } from '@codemirror/state';
 import { FC } from 'react';
+import { Fragment } from 'prosemirror-model';
+import { GroupProps } from '@mantine/core';
 import { Highlighter } from '@lezer/highlight';
 import { HighlightStyle } from '@codemirror/language';
 import { HTMLAttributes } from 'react';
 import { ImageProps } from '@mantine/core';
+import { InputRule } from 'prosemirror-inputrules';
 import { KeyBinding } from '@codemirror/view';
 import { MantineColor } from '@mantine/core';
 import { MantineColorScheme } from '@mantine/core';
 import { MantineFontSize } from '@mantine/core';
 import { MantineThemeOverride } from '@mantine/core';
+import { MarkSpec } from 'prosemirror-model';
+import { MarkType } from 'prosemirror-model';
+import { Node as Node_2 } from 'prosemirror-model';
+import { NodeSpec } from 'prosemirror-model';
+import { NodeViewConstructor } from 'prosemirror-view';
 import { PaperProps } from '@mantine/core';
+import { PluginKey } from 'prosemirror-state';
 import type * as React_2 from 'react';
 import { ReactNode } from 'react';
 import { RefObject } from 'react';
+import { ResolvedPos } from 'prosemirror-model';
+import { Schema } from 'prosemirror-model';
 import { StackProps } from '@mantine/core';
 import { StateField } from '@codemirror/state';
+import { TabsProps as TabsProps_2 } from '@mantine/core';
 
 /**
  * A keybind used to accept a completion
@@ -46,7 +63,7 @@ export declare const addCursorVerticallyKeymap: readonly KeyBinding[];
 
 declare type AnyFn = (...rest: any[]) => any;
 
-export declare type AnyNode = BlockNode | InlineNode | SummaryNode | ListItemNode | TableRowNode | TableCellNode;
+export declare type AnyNode = BlockNode | InlineNode | SummaryNode | ListItemNode | TableRowNode | TableCellNode | TabItemNode;
 
 /**
  * Apply automatic folding to objects/arrays at the specified depth level
@@ -55,7 +72,82 @@ export declare type AnyNode = BlockNode | InlineNode | SummaryNode | ListItemNod
  */
 export declare function applyAutoFolding(view: EditorView, autoCollapseDepth: number): void;
 
-export declare type BlockNode = HeadingNode | ParagraphNode | CodeNode | BlockquoteNode | ListNode | TableNode | ThematicBreakNode | DivNode | DetailsNode | ImageNode;
+/**
+ * A block in the editor document. Blocks have a stable `id`,
+ * a `type` determining their behavior, `props` for type-specific
+ * attributes, optional inline `content`, and optional nested
+ * `children` blocks.
+ */
+export declare interface Block {
+    id: string;
+    type: BlockType;
+    props: Record<string, unknown>;
+    content?: InlineContent[];
+    children?: Block[];
+}
+
+export declare const BlockEditor: FC<BlockEditorProps>;
+
+/**
+ * Controller interface for interacting with a block editor instance.
+ * Created by the `useBlockEditor` hook and passed to the `BlockEditor`
+ * component.
+ */
+export declare interface BlockEditorController {
+    /** Ref to attach to the editor's mount point DOM element. */
+    ref: RefObject<HTMLDivElement | null>;
+    /** Whether the ProseMirror EditorView has been mounted. */
+    mounted: boolean;
+    /** Access the underlying ProseMirror EditorView. Throws if not mounted. */
+    getEditor: () => EditorView_2;
+    /** Convert the current document to a Block[] JSON model. */
+    getBlocks: () => Block[];
+    /** Find a block by ID, searching recursively through children. */
+    getBlock: (id: string) => Block | undefined;
+    /** Find the sibling block before the block with the given ID. */
+    getPreviousBlock: (id: string) => Block | undefined;
+    /** Find the sibling block after the block with the given ID. */
+    getNextBlock: (id: string) => Block | undefined;
+    /** Append blocks to the end of the document. IDs are generated automatically. */
+    appendBlocks: (...blocks: BlockInput[]) => void;
+    /** Insert blocks after the block with the given reference ID. IDs are generated automatically. */
+    insertBlocks: (referenceId: string, ...blocks: BlockInput[]) => void;
+}
+
+export declare interface BlockEditorOptions {
+    initialBlocks?: Block[];
+    readOnly?: boolean;
+    placeholder?: string;
+    registry?: BlockTypeRegistry;
+    customBlocks?: BlockTypeDefinition[];
+    exclude?: string[];
+    onChangeBlocks?: (blocks: Block[]) => void;
+}
+
+export declare interface BlockEditorProps extends BoxProps {
+    controller: BlockEditorController & {
+        portalManager: PortalManager;
+    };
+    autoFocus?: boolean;
+    readOnly?: boolean;
+    hideGutter?: boolean;
+}
+
+export declare const blockHandlePluginKey: PluginKey<BlockHandleState>;
+
+declare interface BlockHandleState {
+    hoveredBlockPos: number | null;
+    hoveredBlockNode: Node_2 | null;
+    dropIndicatorPos: number | null;
+}
+
+/**
+ * Input type for creating blocks via the controller API.
+ * Omits `id` since IDs are generated internally.
+ */
+export declare type BlockInput = Omit<Block, "id">;
+
+export declare type BlockNode = HeadingNode | ParagraphNode | CodeNode | BlockquoteNode | ListNode | TableNode | ThematicBreakNode | DivNode | DetailsNode | ImageNode | CheckNode | RailroadDiagramNode | SurrealistMiniNode | VersionNode | SinceNode | LabelNode | TabsNode;
 
 export declare interface BlockquoteNode {
     type: "blockquote";
@@ -67,6 +159,130 @@ export declare interface BlockquoteNode {
     noteTitle?: string;
 }
 
+export declare const blockquoteSpec: NodeSpec;
+
+/** SSR-compatible read-only renderer for Block[] data. */
+export declare const BlockRenderer: FC<BlockRendererComponentProps>;
+
+export declare interface BlockRendererComponentProps {
+    /** The blocks to render. */
+    blocks: Block[];
+    /** Registry providing block type definitions with readOnlyRender components. */
+    registry?: BlockTypeRegistry;
+    /** Root container class name. */
+    className?: string;
+}
+
+/** Props for custom block renderers used with BlockRenderer. */
+export declare interface BlockRendererProps {
+    block: Block;
+    inlineContent?: ReactNode;
+    children?: ReactNode;
+}
+
+/** Props for read-only block rendering. */
+declare interface BlockRendererProps_2 {
+    block: Block;
+    inlineContent?: ReactNode;
+    children?: ReactNode;
+}
+
+/** Configuration for creating a block type definition without raw ProseMirror NodeSpec. */
+export declare interface BlockSpecConfig {
+    /** Unique block type identifier (hyphenated, e.g. "callout"). */
+    type: string;
+    /** Map of prop names to their defaults. Generates NodeSpec attrs automatically. */
+    propSchema?: Record<string, PropDefault>;
+    /** Content model shorthand: "inline" for text, "blocks" for nested blocks, "none" for atoms. */
+    content?: "inline" | "blocks" | "none";
+    /** React component for rendering this block in the editor. */
+    render?: FC<ReactNodeViewProps>;
+    /** Slash menu entry for inserting this block. */
+    slashMenuItem?: Omit<SlashMenuItem, "type">;
+    /** Raw NodeSpec overrides for advanced use cases. Merged after generated spec. */
+    nodeSpecOverrides?: Partial<NodeSpec>;
+}
+
+/** Convert a Block[] JSON model to a ProseMirror document node. */
+export declare function blocksToDoc(blocks: Block[], schema: Schema): Node_2;
+
+/** Convert a single Block to a ProseMirror blockContainer node. */
+export declare function blockToNode(block: Block, schema: Schema): Node_2;
+
+/** Identifies the type of a block in the editor document. Extensible via string. */
+export declare type BlockType = "text" | "list-item" | "checklist-item" | "blockquote" | "table" | "table-row" | "table-cell" | "columns" | "column" | "divider" | "collapsible-item" | "code-block" | (string & {});
+
+/**
+ * Defines a block type that can be registered with a BlockTypeRegistry.
+ * Includes the ProseMirror NodeSpec, optional React component for
+ * rendering, slash menu entry, input rule, and behavior declarations.
+ */
+export declare interface BlockTypeDefinition {
+    type: string;
+    /** ProseMirror node name. Defaults to `type` if not specified. */
+    nodeName?: string;
+    nodeSpec: NodeSpec;
+    /** React component for rendering this block via NodeView. */
+    component?: FC<ReactNodeViewProps>;
+    /** Whether the NodeView should be non-editable (atom). */
+    atom?: boolean;
+    /** Slash menu entries for inserting this block. */
+    slashMenuItems?: SlashMenuItem[];
+    /** Input rules for markdown-style shortcuts. */
+    inputRules?: InputRule[];
+    /**
+     * Factory to create ProseMirror node(s) when this block is inserted
+     * via the slash menu. Returns a blockContainer node.
+     */
+    createNode?: (schema: Schema) => Node_2;
+    /** Declares list-like enter/backspace behavior. */
+    listBehavior?: ListBehavior;
+    /** When true, the Enter key is not handled (falls through to ProseMirror default). */
+    enterPassthrough?: boolean;
+    /** Extract Block.props from a ProseMirror node (doc -> JSON conversion). */
+    toBlockProps?: (node: Node_2) => Record<string, unknown>;
+    /** Convert Block.props to ProseMirror node attrs (JSON -> doc conversion). */
+    fromBlockProps?: (props: Record<string, unknown>) => Record<string, unknown>;
+    /** Custom logic for converting a Block to a ProseMirror inner node. */
+    createInnerNode?: (block: Block, schema: Schema) => Node_2;
+    /** Whether this block has inline text content. Auto-detected from nodeSpec if not set. */
+    hasInlineContent?: boolean;
+    /** Whether this block renders children inside itself (e.g. blockquote, table, columns). */
+    isContainerBlock?: boolean;
+    /** Label shown in the toolbar's block type dropdown. */
+    toolbarLabel?: string | ((node: Node_2) => string);
+    /** Options for the toolbar's block type conversion dropdown. */
+    toolbarOptions?: {
+        label: string;
+        attrs?: Record<string, unknown>;
+    }[];
+    /** React component for rendering this block in read-only mode. */
+    readOnlyRender?: FC<BlockRendererProps_2>;
+}
+
+/**
+ * Registry for block types. Register definitions before
+ * passing to `useBlockEditor` so the schema, slash menu, and
+ * node views are extended automatically.
+ */
+export declare class BlockTypeRegistry {
+    private definitions;
+    /** Register a block type definition. */
+    register(definition: BlockTypeDefinition): void;
+    /** Look up a registered definition by block type name. */
+    get(type: string): BlockTypeDefinition | undefined;
+    /** Look up a registered definition by ProseMirror node name. */
+    getByNodeName(nodeName: string): BlockTypeDefinition | undefined;
+    /** Return all registered definitions. */
+    getAll(): BlockTypeDefinition[];
+    /** Collect ProseMirror NodeSpecs from all registered definitions. */
+    getNodeSpecs(): Record<string, NodeSpec>;
+    /** Collect slash menu items from all registered definitions. */
+    getSlashMenuItems(): SlashMenuItem[];
+    /** Collect input rules from all registered definitions. */
+    getInputRules(): InputRule[];
+}
+
 export declare interface BooleanHandle {
     open: () => void;
     close: () => void;
@@ -235,6 +451,37 @@ export declare interface BreakNode {
     style?: string;
 }
 
+/**
+ * Build a ProseMirror Schema from the registry's block type definitions.
+ * The registry must already have all desired block types registered.
+ * Use `customMarks` to add custom mark specs alongside the built-in ones.
+ */
+export declare function buildSchema(registry?: BlockTypeRegistry, _exclude?: string[], customMarks?: Record<string, MarkSpec>): Schema;
+
+export declare const builtInMarks: Record<string, MarkSpec>;
+
+export declare function Check({ children, ...props }: CheckProps): ReactNode;
+
+export declare const checklistItemSpec: NodeSpec;
+
+export declare interface CheckNode {
+    type: "check";
+    children: InlineNode[];
+    className?: string;
+    id?: string;
+    style?: string;
+}
+
+export declare interface CheckProps extends GroupProps {
+    children?: ReactNode;
+}
+
+declare interface ChoiceNode {
+    type: "Choice";
+    default?: number;
+    children: RailroadNode[];
+}
+
 export declare function clsx(...args: unknown[]): string;
 
 /**
@@ -251,6 +498,8 @@ export declare interface CodeBlockProps extends Omit<PaperProps, "children" | "s
     withLineNumbers?: boolean;
 }
 
+export declare const codeBlockSpec: NodeSpec;
+
 export declare const CodeEditor: FC<CodeEditorProps>;
 
 export declare interface CodeEditorProps extends BoxProps {
@@ -272,10 +521,21 @@ export declare interface CodeNode {
     style?: string;
 }
 
+export declare const collapsibleItemSpec: NodeSpec;
+
 export declare type ColorScheme = keyof ThemeConfig;
 
 declare type ColorScheme_2 = keyof ThemeConfig_2;
 
+export declare const columnSpec: NodeSpec;
+
+export declare const columnsSpec: NodeSpec;
+
+declare interface CommentNode {
+    type: "Comment";
+    text: string;
+}
+
 /**
  * Common extensions applied to all CodeMirror editors
  */
@@ -294,11 +554,57 @@ declare type ComponentMap = {
     [T in AnyNode["type"]]: ComponentFunction<T>;
 };
 
+/**
+ * Factory function to create a BlockEditorController from refs.
+ * Used internally by `useBlockEditor`.
+ */
+export declare function createBlockEditorController(ref: RefObject<HTMLDivElement | null>, editorViewRef: RefObject<EditorView_2 | null>, mountedRef: {
+    current: boolean;
+}): BlockEditorController;
+
+/**
+ * Create a BlockTypeDefinition from a simplified config.
+ * Generates `nodeSpec` (including `parseDOM`/`toDOM`) automatically from `propSchema`.
+ * The raw `nodeSpec` field on `BlockTypeDefinition` remains available via `nodeSpecOverrides`.
+ */
+export declare function createBlockSpec(config: BlockSpecConfig): BlockTypeDefinition;
+
 /**
  * Create a style highlighter for the given color scheme and syntax theme
  */
 export declare function createHighlighter(colorScheme: MantineColorScheme): Highlighter;
 
+/**
+ * Create an InlineContentDefinition from a simplified config.
+ * Generates a ProseMirror inline node spec with appropriate attrs and DOM serialization.
+ */
+export declare function createInlineContentSpec(config: InlineContentSpecConfig): InlineContentDefinition;
+
+export declare function createMarkKeymap(schema: Schema): Record<string, Command_2>;
+
+/**
+ * Create a ProseMirror NodeViewConstructor that renders a React
+ * component via the PortalManager. The component receives
+ * `ReactNodeViewProps` and can use `contentRef` to mark its
+ * editable content area.
+ *
+ * **Focus resolution:** When a new NodeView is created and the
+ * ProseMirror selection falls inside it, `contentDOM` is already
+ * in the DOM tree so ProseMirror can sync its cursor. After React
+ * renders the portal, `contentRef` re-parents `contentDOM` and
+ * re-syncs the DOM selection automatically.
+ *
+ * **`data-focus` convention:** For blocks that need custom focus
+ * behavior (e.g. atom blocks wrapping a `<CodeEditor>`), add a
+ * `data-focus` attribute to the element that should receive DOM
+ * focus. After React renders, the NodeView will call `.focus()`
+ * on the first `[data-focus]` element if the ProseMirror selection
+ * is inside this block.
+ */
+export declare function createReactNodeView(Component: FC<ReactNodeViewProps>, options?: {
+    contentEditable?: boolean;
+}): NodeViewConstructor;
+
 /**
  * Create a new serialized editor state from a document string.
  *
@@ -342,6 +648,14 @@ export declare interface DetailsProps extends Omit<BoxProps, "component" | "chil
     children: ReactNode;
 }
 
+export declare interface DiagramNode {
+    type: "Diagram";
+    padding?: [number, number, number, number];
+    children: RailroadNode[];
+}
+
+export declare const dividerSpec: NodeSpec;
+
 export declare interface DivNode {
     type: "div";
     children: BlockNode[];
@@ -350,6 +664,9 @@ export declare interface DivNode {
     style?: string;
 }
 
+/** Convert a ProseMirror document node to a Block[] JSON model. */
+export declare function docToBlocks(doc: Node_2): Block[];
+
 export declare interface EditorController {
     ref: RefObject<HTMLDivElement | null>;
     mounted: boolean;
@@ -369,6 +686,7 @@ export declare interface EditorOptions {
     state?: EditorStateSnapshot;
     readOnly?: boolean;
     extensions?: Extension;
+    language?: Language;
     lineNumbers?: boolean;
     onMounted?: (editor: EditorView) => void;
     onChangeDocument?: (document: string) => void;
@@ -396,6 +714,8 @@ export declare interface EmphasisNode {
  */
 export declare function enterNode(state: ParserState, nodeType: string, node: BlockNode | SummaryNode): void;
 
+export declare function executeSlashCommand(view: EditorView_2, schema: Schema, menuState: SlashMenuState, item: SlashMenuItem): void;
+
 /**
  * Exit a node (pop from stack and validate)
  */
@@ -412,6 +732,42 @@ export declare interface ExtractedCode {
  */
 export declare function extractTest(input: string): ExtractedCode;
 
+export declare function filterItems(items: SlashMenuItem[], query: string): SlashMenuItem[];
+
+/**
+ * Walk up from a resolved position to find the nearest ancestor
+ * node matching the given type name.
+ *
+ * @returns The ancestor's absolute position, depth, and node, or null if not found.
+ */
+export declare function findAncestor($pos: ResolvedPos, typeName: string): {
+    pos: number;
+    depth: number;
+    node: Node_2;
+} | null;
+
+/** Find the position and node of a blockContainer by its ID attribute. */
+export declare function findBlockPos(doc: Node_2, id: string): {
+    pos: number;
+    node: Node_2;
+} | undefined;
+
+/**
+ * Find the nearest blockContainer ancestor's position from a
+ * resolved position.
+ */
+export declare function findContainerPos($pos: ResolvedPos): number | null;
+
+/** Convert a ProseMirror inline Fragment to an InlineContent[] array. */
+export declare function fragmentToInline(fragment: Fragment): InlineContent[];
+
+/**
+ * Generate a 24-character hex string suitable for use as a
+ * stable block identifier. Uses `crypto.getRandomValues` for
+ * collision resistance.
+ */
+export declare function generateRandomId(): string;
+
 export declare interface HeadingNode {
     type: "heading";
     depth: 1 | 2 | 3 | 4 | 5 | 6;
@@ -799,8 +1155,52 @@ export declare interface InlineCodeNode {
     style?: string;
 }
 
+/** A piece of inline content within a block, either styled text, a link, or custom inline content. */
+export declare type InlineContent = {
+    type: "text";
+    text: string;
+    styles?: TextStyles;
+} | {
+    type: "link";
+    href: string;
+    content: InlineContent[];
+} | {
+    type: string;
+    props: Record<string, unknown>;
+};
+
+/** Definition of a custom inline content type. */
+export declare interface InlineContentDefinition {
+    type: string;
+    nodeSpec: NodeSpec;
+    component: FC<ReactNodeViewProps>;
+    triggerCharacter?: string;
+}
+
+/** Configuration for creating a custom inline content type. */
+export declare interface InlineContentSpecConfig {
+    /** Unique type identifier for this inline content. */
+    type: string;
+    /** Map of prop names to their defaults. */
+    propSchema?: Record<string, InlinePropDefault>;
+    /** Whether this inline content contains styled text ("styled") or not ("none"). */
+    content?: "styled" | "none";
+    /** React component for rendering this inline content. */
+    render: FC<ReactNodeViewProps>;
+    /** Character that triggers a suggestion menu for inserting this inline content (e.g. "@"). */
+    triggerCharacter?: string;
+}
+
 export declare type InlineNode = TextNode | LinkNode | InlineCodeNode | StrongNode | EmphasisNode | BreakNode | ImageNode;
 
+/** Schema for a single inline content prop with a default value. */
+export declare interface InlinePropDefault {
+    default: string | number | boolean;
+}
+
+/** Convert an InlineContent[] array to a ProseMirror inline Fragment. */
+export declare function inlineToFragment(content: InlineContent[], schema: Schema): Fragment;
+
 /**
  * Check if a code point is an emoji
  * Simplified ranges - merged consecutive ranges
@@ -812,6 +1212,22 @@ export declare function isEmojiCodePoint(code: number): boolean;
  */
 export declare function isSelfClosingTag(tagName: string): boolean;
 
+export declare function Label({ label, ...props }: LabelProps): ReactNode;
+
+export declare interface LabelNode {
+    type: "label";
+    label: string;
+    className?: string;
+    id?: string;
+    style?: string;
+}
+
+export declare interface LabelProps extends Omit<BadgeProps, "children"> {
+    label: string;
+}
+
+declare type Language = "csharp" | "rust" | "javascript" | "typescript" | "surrealql" | "json" | "yaml" | "java" | "go" | "python" | "html" | "cli" | "php" | "syntax";
+
 export declare interface LinkNode {
     type: "link";
     url: string;
@@ -822,6 +1238,14 @@ export declare interface LinkNode {
     style?: string;
 }
 
+/** Declares list-like enter/backspace behavior for a block type. */
+export declare interface ListBehavior {
+    /** Create a new sibling node when Enter is pressed. */
+    createSibling: (schema: Schema) => Node_2;
+    /** Text prefix to insert when backspacing an empty item back to text. */
+    backspacePrefix?: string;
+}
+
 export declare interface ListItemNode {
     type: "listItem";
     checked?: boolean;
@@ -832,6 +1256,8 @@ export declare interface ListItemNode {
     style?: string;
 }
 
+export declare const listItemSpec: NodeSpec;
+
 export declare interface ListNode {
     type: "list";
     variant?: "ordered" | "unordered" | "checklist";
@@ -848,6 +1274,8 @@ export declare interface ListNode {
  */
 export declare const MANTINE_THEME: MantineThemeOverride;
 
+export declare function markActive(state: EditorState, type: MarkType): boolean;
+
 /**
  * Main Markdown component that parses markdown and renders it
  * Applies stylesheet and spacing
@@ -870,10 +1298,64 @@ export declare interface MarkdownProps {
     componentProps?: MarkdownComponentProps;
 }
 
+export declare interface MiniConfig {
+    url?: string;
+    dataset?: "surreal-deal-store-mini" | `/${string}.surql`;
+    setup?: string;
+    query?: string;
+    variables?: string | Record<string, unknown>;
+    theme?: "auto" | "light" | "dark";
+    orientation?: "horizontal" | "vertical";
+    appearance?: "normal" | "compact" | "plain";
+    transparent?: boolean;
+    autorun?: boolean;
+    corners?: string;
+    nonumbers?: boolean;
+}
+
+export declare class MiniController {
+    private frameRef;
+    constructor(frameRef: RefObject<HTMLIFrameElement | null>);
+    private get ref();
+    private post;
+    /**
+     * Updates the currently displayed query or variables in the mini
+     */
+    setEditor(options: {
+        query?: string;
+        variables?: string;
+    }): void;
+    /**
+     * Clears the query response
+     */
+    clearResponse(): void;
+    /**
+     * Sets the mini to show either the query or variables editor
+     */
+    setEditorMode(mode: "query" | "variables"): void;
+    /**
+     * Sets the output/result mode to combined, single, graph, table or live
+     */
+    setResultMode(mode: "combined" | "single" | "graph" | "table" | "live"): void;
+    /**
+     * Runs the query with the variables as they are currently set
+     */
+    runQuery(): void;
+    /**
+     * Executes a given query in the background
+     */
+    executeQuery(query: string): void;
+}
+
 declare type NodeOfType<T extends AnyNode["type"]> = Extract<AnyNode, {
     type: T;
 }>;
 
+declare interface NonTerminalNode {
+    type: "NonTerminal";
+    text: string;
+}
+
 /**
  * Note/Callout component with variants: note, important, warning, caution
  */
@@ -889,6 +1371,18 @@ export declare interface NoteProps extends Omit<AlertProps, "title" | "children"
     children: ReactNode;
 }
 
+declare interface OneOrMoreNode {
+    type: "OneOrMore";
+    child: RailroadNode;
+    repeat?: RailroadNode;
+}
+
+declare interface OptionalNode {
+    type: "Optional";
+    skip?: boolean;
+    child: RailroadNode;
+}
+
 export declare interface ParagraphNode {
     type: "paragraph";
     children: InlineNode[];
@@ -906,6 +1400,8 @@ export declare function parseAttributes(attrString: string): Record<string, stri
 
 export declare function parseBlockquote(state: ParserState): void;
 
+export declare function parseCheckTag(state: ParserState, attrs: Record<string, string>): void;
+
 export declare function parseCodeBlock(state: ParserState): void;
 
 export declare function parseDetailsTag(state: ParserState, attrs: Record<string, string>): void;
@@ -993,6 +1489,8 @@ export declare function parseTableAlignment(line: string): Array<"left" | "right
  */
 export declare function parseTableRow(line: string, isHeader?: boolean): TableCellNode[];
 
+export declare function parseTabsTag(state: ParserState, attrs: Record<string, string>): void;
+
 export declare function parseText(text: string, startIndex: number): {
     node: TextNode;
     endIndex: number;
@@ -1448,6 +1946,40 @@ export declare const pictoZed: string;
 
 export declare const pictoZoomIn: string;
 
+declare interface PortalEntry {
+    key: string;
+    component: ReactNode;
+    container: HTMLElement;
+}
+
+declare type PortalListener = () => void;
+
+/**
+ * Manages React portals for ProseMirror NodeViews. Coordinates
+ * between ProseMirror's synchronous DOM lifecycle and React's
+ * async rendering via a portal registry and subscription model.
+ */
+export declare class PortalManager {
+    private portals;
+    private listeners;
+    private cachedEntries;
+    register(entry: PortalEntry): void;
+    update(key: string, component: ReactNode): void;
+    remove(key: string): void;
+    getEntries(): PortalEntry[];
+    subscribe(listener: PortalListener): () => void;
+    private invalidate;
+}
+
+export declare function PortalOutlet({ manager }: {
+    manager: PortalManager;
+}): ReactNode;
+
+export declare function PortalProvider({ manager, children, }: {
+    manager: PortalManager;
+    children: ReactNode;
+}): ReactNode;
+
 /**
  * Process highlight regions in code
  */
@@ -1456,6 +1988,11 @@ export declare function processHighlightRegions(code: string): {
     processedCode: string;
 };
 
+/** Schema for a single block prop with a default value. */
+export declare interface PropDefault {
+    default: string | number | boolean;
+}
+
 /**
  * Validate and process code attributes
  */
@@ -1478,6 +2015,32 @@ export declare function pushImage(attrs: Record<string, string>): ImageNode;
  */
 export declare function pushSummary(attrs: Record<string, string>): SummaryNode;
 
+export declare function RailroadDiagram({ ast, ...props }: RailroadDiagramProps): ReactNode;
+
+export declare interface RailroadDiagramNode {
+    type: "railroadDiagram";
+    ast?: DiagramNode;
+    className?: string;
+    id?: string;
+    style?: string;
+}
+
+export declare interface RailroadDiagramProps extends BoxProps {
+    ast?: DiagramNode;
+}
+
+export declare type RailroadNode = DiagramNode | SequenceNode | TerminalNode | NonTerminalNode | OptionalNode | ChoiceNode | OneOrMoreNode | ZeroOrMoreNode | CommentNode;
+
+/** Props passed to React components rendered inside ProseMirror NodeViews. */
+export declare interface ReactNodeViewProps {
+    node: Node_2;
+    view: EditorView_2;
+    getPos: () => number | undefined;
+    contentRef: (element: HTMLElement | null) => void;
+    selected: boolean;
+    updateAttrs: (attrs: Record<string, unknown>) => void;
+}
+
 /**
  * Read tag name from HTML tag starting at index
  * Returns tag name and end index
@@ -1487,6 +2050,17 @@ export declare function readTagName(text: string, startIndex: number): {
     endIndex: number;
 };
 
+/**
+ * Register all built-in block type definitions with the registry and
+ * return the fully-built ProseMirror Schema.
+ *
+ * Performs a two-phase bootstrap:
+ * 1. Registers nodeSpecs using a minimal stub schema (no input rules)
+ * 2. Builds the real schema from the registry, then re-registers
+ *    definitions with proper input rules that reference real node types.
+ */
+export declare function registerBuiltInBlocks(registry: BlockTypeRegistry, exclude?: string[]): Schema;
+
 /**
  * Render parsed markdown AST to React elements
  * Direct AST-to-React conversion with component mapping
@@ -1505,11 +2079,18 @@ export declare interface RenderMarkdownProps extends StackProps {
     componentProps?: MarkdownComponentProps;
 }
 
+export declare function resolveDropPosition(view: EditorView_2, clientY: number): number | null;
+
 export declare interface Root {
     type: "root";
     children: BlockNode[];
 }
 
+declare interface SequenceNode {
+    type: "Sequence";
+    children: RailroadNode[];
+}
+
 /**
  * Set the contents of the editor
  *
@@ -1518,6 +2099,44 @@ export declare interface Root {
  */
 export declare function setEditorText(editor: EditorView, text: string): void;
 
+export declare function Since({ v, prefix, ...props }: SinceProps): ReactNode;
+
+export declare interface SinceNode {
+    type: "since";
+    v: string;
+    prefix?: string;
+    className?: string;
+    id?: string;
+    style?: string;
+}
+
+export declare interface SinceProps extends Omit<BadgeProps, "children"> {
+    v: string;
+    prefix?: string;
+}
+
+/** Describes an entry in the slash command menu. */
+export declare interface SlashMenuItem {
+    type: string;
+    label: string;
+    description?: string;
+    icon?: ReactNode;
+    shortcut?: string;
+    /** Create a ProseMirror blockContainer node for this menu item. */
+    createNode?: (schema: Schema, id: string) => Node_2;
+}
+
+export declare const slashMenuPluginKey: PluginKey<SlashMenuState>;
+
+declare interface SlashMenuState {
+    open: boolean;
+    blockPos: number | null;
+    triggerPos: number;
+    query: string;
+    selectedIndex: number;
+    items: SlashMenuItem[];
+}
+
 export declare type SortDirection = "asc" | "desc" | undefined;
 
 export declare interface SortHandle<T = DefaultSort> {
@@ -1562,8 +2181,48 @@ export declare interface SummaryProps extends Omit<BoxProps, "component" | "chil
     children: ReactNode;
 }
 
+export declare function SurrealistMini({ config, frameRef, ...props }: SurrealistMiniProps): ReactNode;
+
+export declare interface SurrealistMiniNode {
+    type: "surrealistMini";
+    url?: string;
+    dataset?: string;
+    setup?: string;
+    query?: string;
+    variables?: string;
+    theme?: string;
+    orientation?: string;
+    appearance?: string;
+    transparent?: string;
+    autorun?: string;
+    className?: string;
+    id?: string;
+    style?: string;
+}
+
+export declare interface SurrealistMiniProps extends BoxProps {
+    config?: MiniConfig;
+    frameRef?: RefObject<HTMLIFrameElement | null>;
+}
+
 export declare const SYNTAX_THEME_CONFIG: ThemeConfig;
 
+export declare interface TabItem {
+    label: string;
+    icon?: string;
+    content: ReactNode;
+}
+
+export declare interface TabItemNode {
+    type: "tabItem";
+    label: string;
+    icon?: string;
+    children: BlockNode[];
+    className?: string;
+    id?: string;
+    style?: string;
+}
+
 export declare interface TableCellNode {
     type: "tableCell";
     children: AnyNode[];
@@ -1573,6 +2232,8 @@ export declare interface TableCellNode {
     isHeader: boolean;
 }
 
+export declare const tableCellSpec: NodeSpec;
+
 export declare interface TableNode {
     type: "table";
     align?: Array<"left" | "right" | "center" | null>;
@@ -1590,6 +2251,33 @@ export declare interface TableRowNode {
     style?: string;
 }
 
+export declare const tableRowSpec: NodeSpec;
+
+export declare const tableSpec: NodeSpec;
+
+export declare function Tabs({ items, syncKey, ...props }: TabsProps): ReactNode;
+
+export declare interface TabsNode {
+    type: "tabs";
+    syncKey?: string;
+    children: TabItemNode[];
+    className?: string;
+    id?: string;
+    style?: string;
+}
+
+export declare interface TabsProps extends Omit<TabsProps_2, "children" | "value" | "onChange"> {
+    items: TabItem[];
+    syncKey?: string;
+}
+
+declare interface TerminalNode {
+    type: "Terminal";
+    text: string;
+}
+
+export declare const textBlockSpec: NodeSpec;
+
 export declare interface TextNode {
     type: "text";
     value: string;
@@ -1598,6 +2286,15 @@ export declare interface TextNode {
     style?: string;
 }
 
+/** Rich text style flags applied to inline text content. */
+export declare interface TextStyles {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    code?: boolean;
+}
+
 export declare interface ThematicBreakNode {
     type: "thematicBreak";
     className?: string;
@@ -1630,11 +2327,35 @@ export declare interface ThemedImageProps extends ImageProps {
     colorScheme?: "light" | "dark";
 }
 
+/** Map a camelCase ProseMirror node name to the hyphenated BlockType string. */
+export declare function toBlockType(nodeName: string): string;
+
+/** Map a hyphenated BlockType string to the camelCase ProseMirror node name. */
+export declare function toNodeName(blockType: string): string;
+
+export declare const toolbarPluginKey: PluginKey<ToolbarState>;
+
+declare interface ToolbarState {
+    show: boolean;
+    from: number;
+    to: number;
+}
+
 /**
  * Type-specific visitor function
  */
 export declare type TypeVisitor<T extends AnyNode> = (node: T, index: number | undefined, parent: AnyNode | Root | null) => undefined | boolean | void;
 
+export declare function useBlockEditor(options?: BlockEditorOptions): BlockEditorController & {
+    portalManager: PortalManager;
+};
+
+/**
+ * Create a memoized BlockTypeRegistry from an array of block type definitions.
+ * Definitions should be module-level constants for stable references.
+ */
+export declare function useBlockRegistry(definitions: BlockTypeDefinition[]): BlockTypeRegistry;
+
 export declare function useEditor(options?: EditorOptions): EditorController;
 
 /**
@@ -1647,6 +2368,8 @@ export declare function useEditor(options?: EditorOptions): EditorController;
  */
 export declare function useLater<T extends unknown[]>(doLater: (...args: T) => unknown): (...args: T) => void;
 
+export declare function useMiniController(): [RefObject<HTMLIFrameElement | null>, MiniController];
+
 export declare function useSort<T = DefaultSort>(options?: SortOptions<T>): SortHandle<T>;
 
 /**
@@ -1669,6 +2392,20 @@ export declare function useSwitch(initialState?: boolean, callbacks?: {
     onClose?: () => void;
 }): readonly [boolean, BooleanHandle];
 
+export declare function Version({ version, ...props }: VersionProps): ReactNode;
+
+export declare interface VersionNode {
+    type: "version";
+    version?: string;
+    className?: string;
+    id?: string;
+    style?: string;
+}
+
+export declare interface VersionProps extends CodeProps {
+    version: string;
+}
+
 /**
  * Visit all nodes in the tree
  */
@@ -1686,15 +2423,14 @@ export declare type Visitor = (node: AnyNode, index: number | undefined, parent:
  */
 export declare const VIVID_THEME: ThemeConfig_2;
 
+declare interface ZeroOrMoreNode {
+    type: "ZeroOrMore";
+    child: RailroadNode;
+    repeat?: RailroadNode;
+}
+
 export { }
 
-declare module "@mantine/core" {
-    type ExtendedCustomColors = "obsidian" | "slate" | import("@mantine/core").DefaultMantineColor;
-    interface MantineThemeColorsOverride {
-        colors: Record<ExtendedCustomColors, import("@mantine/core").MantineColorsTuple>;
-    }
-}
-
 declare module "@mantine/core" {
     type SurrealVariant = "surreal";
     type SurrealInputVariant = SurrealVariant | "filled";
@@ -1799,6 +2535,13 @@ declare module "@mantine/core" {
     }
 }
 
+declare module "@mantine/core" {
+    type ExtendedCustomColors = "obsidian" | "slate" | import("@mantine/core").DefaultMantineColor;
+    interface MantineThemeColorsOverride {
+        colors: Record<ExtendedCustomColors, import("@mantine/core").MantineColorsTuple>;
+    }
+}
+
 declare module "@mantine/core" {
     type ExtendedCustomSizes = import("@mantine/core").DefaultMantineSize | "2xl" | "3xl";
     interface MantineThemeSizesOverride {