@domternal/core 0.6.2 → 0.7.1

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { Schema, Node as Node$1, DOMOutputSpec, NodeType, Mark as Mark$1, MarkType, Attrs, DOMParser, ResolvedPos, ContentMatch, NodeSpec, MarkSpec } from '@domternal/pm/model';
+import { Schema, Node as Node$1, DOMOutputSpec, NodeType, Mark as Mark$1, MarkType, Attrs, ResolvedPos, DOMParser, ContentMatch, NodeSpec, MarkSpec } from '@domternal/pm/model';
 import { Transaction, EditorState, Plugin, PluginKey, Selection as Selection$1 } from '@domternal/pm/state';
 export { PluginKey } from '@domternal/pm/state';
 import { InputRule } from '@domternal/pm/inputrules';
-import { EditorView, NodeViewConstructor } from '@domternal/pm/view';
+import { NodeViewConstructor, EditorView } from '@domternal/pm/view';
 import { Placement } from '@floating-ui/dom';
 
 /**
@@ -131,8 +131,7 @@ interface ErrorEventProps$1 {
     context: string;
 }
 /**
- * All editor events with their payload types
- * Used by EventEmitter for type-safe event handling
+ * All editor events with their payload types.
  */
 interface EditorEvents {
     /** Fired before editor is created - can modify options */
@@ -169,6 +168,10 @@ interface EditorEvents {
     linkEdit: {
         anchorElement?: HTMLElement;
     };
+    /** Fired when the Notion color picker should open, with the trigger as anchor. */
+    notionColorOpen: {
+        anchorElement?: HTMLElement | null;
+    };
 }
 /**
  * Event names as a type
@@ -212,11 +215,9 @@ type FocusPosition = boolean | 'start' | 'end' | 'all' | number | null;
  */
 interface EditorOptions {
     /**
-     * ProseMirror Schema for the editor
-     *
-     * Step 1.3: Required (no extensions system yet)
-     * Step 2+: Optional if extensions are provided (schema built from extensions)
+     * ProseMirror Schema for the editor.
      *
+     * Optional when `extensions` is provided (schema is built from them).
      * The schema must contain at least 'doc' and 'text' nodes.
      */
     schema?: Schema;
@@ -354,12 +355,12 @@ type Command = (props: CommandProps) => boolean;
  *   return true;
  * };
  */
-type CommandSpec$1<Args extends unknown[] = []> = (...args: Args) => Command;
+type CommandSpec<Args extends unknown[] = []> = (...args: Args) => Command;
 /**
  * Internal command storage used by CommandManager and ExtensionManager.
  * Holds commands as a generic record for dynamic runtime collection.
  */
-type CommandMap = Record<string, CommandSpec$1<unknown[]>>;
+type CommandMap = Record<string, CommandSpec<unknown[]>>;
 /**
  * Typed command interface for the public API.
  *
@@ -384,7 +385,7 @@ interface RawCommands {
  * These are accessed via editor.commands.commandName()
  */
 type SingleCommands = {
-    [K in keyof RawCommands]: RawCommands[K] extends CommandSpec$1<infer Args> ? (...args: Args) => boolean : never;
+    [K in keyof RawCommands]: RawCommands[K] extends CommandSpec<infer Args> ? (...args: Args) => boolean : never;
 };
 /**
  * Information about a command chain failure
@@ -402,7 +403,7 @@ interface ChainFailure {
  * These are accessed via editor.chain().commandName().run()
  */
 type ChainedCommands = {
-    [K in keyof RawCommands]: RawCommands[K] extends CommandSpec$1<infer Args> ? (...args: Args) => ChainedCommands : never;
+    [K in keyof RawCommands]: RawCommands[K] extends CommandSpec<infer Args> ? (...args: Args) => ChainedCommands : never;
 } & {
     /** Execute the command chain */
     run: () => boolean;
@@ -414,7 +415,7 @@ type ChainedCommands = {
  * These are accessed via editor.can().commandName()
  */
 type CanCommands = {
-    [K in keyof RawCommands]: RawCommands[K] extends CommandSpec$1<infer Args> ? (...args: Args) => boolean : never;
+    [K in keyof RawCommands]: RawCommands[K] extends CommandSpec<infer Args> ? (...args: Args) => boolean : never;
 } & {
     /** Start a chain check */
     chain: () => CanChainedCommands;
@@ -423,7 +424,7 @@ type CanCommands = {
  * Chained commands for dry-run checking
  */
 type CanChainedCommands = {
-    [K in keyof RawCommands]: RawCommands[K] extends CommandSpec$1<infer Args> ? (...args: Args) => CanChainedCommands : never;
+    [K in keyof RawCommands]: RawCommands[K] extends CommandSpec<infer Args> ? (...args: Args) => CanChainedCommands : never;
 } & {
     /** Check if the entire chain can be executed */
     run: () => boolean;
@@ -480,7 +481,7 @@ interface ToolbarButton {
      * How to check if this button is active.
      * - string: extension name passed to `editor.isActive(name)`
      * - object: `{ name, attributes }` passed to `editor.isActive(name, attributes)`
-     * - array: OR-check — active if ANY entry matches (useful for attributes on multiple node types)
+     * - array: OR-check - active if ANY entry matches (useful for attributes on multiple node types)
      * - undefined: button has no active state (e.g. undo/redo)
      */
     isActive?: string | {
@@ -602,1485 +603,1600 @@ interface ToolbarLayoutDropdown {
 /**
  * A single entry in a toolbar layout array.
  *
- * - `string` — item name (e.g. `'bold'`) or separator (`'|'`)
- * - `ToolbarLayoutDropdown` — custom dropdown grouping
+ * - `string` - item name (e.g. `'bold'`) or separator (`'|'`)
+ * - `ToolbarLayoutDropdown` - custom dropdown grouping
  */
 type ToolbarLayoutEntry = string | ToolbarLayoutDropdown;
 
 /**
- * Extension configuration types
+ * Callback type for event handlers
+ * - Events with payload: (data: T) => void
+ * - Events without payload (undefined): () => void
+ */
+type EventCallback<T> = T extends undefined ? () => void : (data: T) => void;
+/**
+ * Generic, type-safe event emitter
  *
- * These types define the configuration object passed to Extension.create(),
- * Node.create(), and Mark.create() factory methods.
+ * @example
+ * ```typescript
+ * interface MyEvents {
+ *   update: { value: number };
+ *   destroy: undefined;
+ * }
+ *
+ * const emitter = new EventEmitter<MyEvents>();
+ * emitter.on('update', ({ value }) => console.log(value));
+ * emitter.on('destroy', () => console.log('destroyed'));
+ * ```
  */
+declare class EventEmitter<Events extends {
+    [K in keyof Events]: unknown;
+} = Record<string, never>> {
+    protected callbacks: Map<keyof Events, Set<(data: unknown) => void>>;
+    /**
+     * Register an event listener
+     */
+    on<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>): this;
+    /**
+     * Remove an event listener, or all listeners for an event if no callback specified
+     */
+    off<E extends keyof Events>(event: E, callback?: EventCallback<Events[E]>): this;
+    /**
+     * Emit an event to all registered listeners
+     * Uses .call(this) to preserve context for callbacks
+     */
+    emit<E extends keyof Events>(event: E, ...args: Events[E] extends undefined ? [] : [Events[E]]): this;
+    /**
+     * Register an event listener that fires only once
+     */
+    once<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>): this;
+    /**
+     * Remove all listeners for a specific event, or all events if no event specified
+     */
+    removeAllListeners(event?: keyof Events): this;
+    /**
+     * Get the number of listeners for a specific event
+     */
+    listenerCount(event: keyof Events): number;
+    /**
+     * Get all event names that have listeners
+     */
+    eventNames(): (keyof Events)[];
+}
 
 /**
- * Editor instance type (forward declaration)
+ * ExtensionManager - manages extensions and schema.
+ *
+ * Handles:
+ * - Extension lifecycle (flatten, resolve, bind)
+ * - Schema building from Node/Mark extensions
+ * - Plugin collection from all extensions
+ * - Extension storage management
+ * - Conflict detection (duplicate extension names)
  */
-interface ExtensionEditor {
-    readonly state: EditorState;
-    readonly view: EditorView;
-    readonly schema: unknown;
-    readonly commands: SingleCommands;
+
+/**
+ * Error event props for safeCall
+ */
+interface ErrorEventProps {
+    error: Error;
+    context: string;
 }
 /**
- * Any extension type (forward declaration)
+ * Editor interface for ExtensionManager
+ * Forward declaration to avoid circular dependency
  */
-interface AnyExtensionConfig {
-    name: string;
-    type?: 'extension' | 'node' | 'mark';
+interface ExtensionManagerEditor {
+    readonly schema: Schema;
+    emit?(event: 'error', props: ErrorEventProps): void;
 }
 /**
- * Global attribute specification for injecting attributes into multiple node/mark types.
- * Used by extensions like TextAlign to add alignment to heading, paragraph, etc.
+ * Context attached to node view constructors for framework wrappers.
+ * Accessible via `(constructor as any).__domternalContext`.
  */
-interface GlobalAttributeSpec {
+interface NodeViewContext {
+    editor: ExtensionManagerEditor;
+    extension: {
+        name: string;
+        options: Record<string, unknown>;
+    };
+}
+/**
+ * Options for ExtensionManager constructor
+ */
+interface ExtensionManagerOptions {
     /**
-     * Default value for the attribute.
+     * Extensions to process
+     * If provided, schema is built from extensions
      */
-    default?: unknown;
+    extensions?: AnyExtension[] | undefined;
     /**
-     * Parse attribute value from HTML element.
-     * @param element - The DOM element to parse from
-     * @returns The parsed attribute value
+     * Direct schema. If provided, extensions are ignored for schema building.
      */
-    parseHTML?: (element: HTMLElement) => unknown;
+    schema?: Schema | undefined;
+}
+declare class ExtensionManager {
     /**
-     * Render attribute value to HTML attributes.
-     * @param attributes - The node/mark attributes
-     * @returns Object of HTML attributes to set, or null/empty to skip
+     * Processed extensions (flattened, sorted by priority)
      */
-    renderHTML?: (attributes: Record<string, unknown>) => Record<string, string> | null;
-}
-/**
- * Global attributes definition for injecting into node/mark types.
- */
-interface GlobalAttributes {
+    private readonly _extensions;
     /**
-     * Node or mark type names to add these attributes to.
-     * @example ['heading', 'paragraph']
+     * ProseMirror schema (built from extensions or passed directly)
      */
-    types: string[];
+    private readonly _schema;
     /**
-     * Attribute specifications to add.
-     * @example { textAlign: { default: 'left', parseHTML: (el) => el.style.textAlign } }
+     * Reference to the editor instance
      */
-    attributes: Record<string, GlobalAttributeSpec>;
-}
-/**
- * Context interface that describes what `this` will be in config methods.
- * This enables proper typing of `this.options`, `this.editor`, etc.
- * without creating circular dependencies.
- *
- * @typeParam Options - Extension options type
- * @typeParam Storage - Extension storage type
- */
-interface ExtensionContext<Options = unknown, Storage = unknown> {
-    /** Extension type identifier */
-    readonly type: 'extension' | 'node' | 'mark';
-    /** Unique extension name */
-    readonly name: string;
-    /** Extension options (immutable after creation) */
-    readonly options: Options;
-    /** Extension storage (mutable state) */
-    storage: Storage;
-    /** Editor instance (null until bound by ExtensionManager) */
-    editor: ExtensionEditor | null;
+    readonly editor: ExtensionManagerEditor;
     /**
-     * Reference to the parent config method when using extend().
-     * Available only inside overridden config methods.
-     * Use `this.parent?.()` to call the parent's version of the current method.
+     * Extension storage (keyed by extension name)
      */
-    parent?: ((...args: unknown[]) => unknown) | undefined;
-}
-/**
- * Base configuration properties for all extension types.
- * This interface contains just the properties without ThisType,
- * allowing Node and Mark configs to use their own context types.
- *
- * @typeParam Options - Extension options type
- * @typeParam Storage - Extension storage type
- */
-interface ExtensionConfigBase<Options = unknown, Storage = unknown> {
+    private readonly _storage;
     /**
-     * Unique extension name
-     * Used for identification, storage access, and error messages
+     * Whether the manager has been destroyed
      */
-    name: string;
+    private isDestroyed;
     /**
-     * Extension priority (higher = loaded first)
-     *
-     * Reserved ranges:
-     * - 900-1000: Core nodes (Document, Text, Paragraph)
-     * - 500-899: Standard extensions (Heading, Bold, etc.)
-     * - 100-499: Default range for user extensions
-     * - 0-99: Low priority extensions (run after everything)
-     *
-     * @default 100
+     * Cached plugins (built lazily)
      */
-    priority?: number;
+    private _plugins;
     /**
-     * Required extensions that must be present
-     * ExtensionManager throws if any dependency is missing
-     *
-     * @example
-     * dependencies: ['bulletList', 'orderedList']
+     * Cached commands (collected lazily)
      */
-    dependencies?: string[];
+    private _commands;
     /**
-     * Default options for this extension
-     * Called during extension creation with `this` bound to the extension
+     * Cached toolbar items (collected lazily)
      */
-    addOptions?: () => Options;
+    private _toolbarItems;
     /**
-     * Initial storage state for this extension
-     * Storage is mutable and accessible via editor.storage[extensionName]
+     * Cached floating-menu items (collected lazily)
      */
-    addStorage?: () => Storage;
+    private _floatingMenuItems;
     /**
-     * Commands this extension provides
-     * Commands are accessible via editor.commands.commandName()
-     *
-     * @example
-     * addCommands() {
-     *   return {
-     *     toggleBold: () => ({ commands }) => commands.toggleMark('bold'),
-     *   };
-     * }
+     * Cached node views (collected lazily)
      */
-    addCommands?: () => Record<string, (...args: never[]) => Command>;
+    private _nodeViews;
     /**
-     * Keyboard shortcuts for this extension
-     * Keys are shortcut strings (e.g., 'Mod-b'), values are handler functions
+     * Creates a new ExtensionManager
      *
-     * @example
-     * addKeyboardShortcuts() {
-     *   return {
-     *     'Mod-b': () => this.editor.commands.toggleBold(),
-     *   };
-     * }
+     * @param options - Extensions or direct schema
+     * @param editor - Editor instance
      */
-    addKeyboardShortcuts?: () => Record<string, KeyboardShortcutCommand>;
+    constructor(options: ExtensionManagerOptions, editor: ExtensionManagerEditor);
     /**
-     * Input rules (markdown-style shortcuts)
-     * Triggered when user types matching patterns
-     *
-     * @example
-     * addInputRules() {
-     *   return [
-     *     textblockTypeInputRule(/^## $/, this.type),
-     *   ];
-     * }
+     * Gets the processed extensions array
      */
-    addInputRules?: () => InputRule[];
+    get extensions(): readonly AnyExtension[];
     /**
-     * ProseMirror plugins for this extension
+     * Gets the ProseMirror schema
      */
-    addProseMirrorPlugins?: () => Plugin[];
+    get schema(): Schema;
     /**
-     * Nested extensions (for extension bundles like StarterKit)
-     * These extensions are flattened and processed like top-level extensions
+     * Gets extension storage (accessed via editor.storage)
      */
-    addExtensions?: () => AnyExtensionConfig[];
+    get storage(): Record<string, unknown>;
     /**
-     * Global attributes to add to multiple node/mark types.
-     * Useful for extensions like TextAlign that need to add attributes
-     * to several nodes (heading, paragraph, etc.) without modifying each.
-     *
-     * @example
-     * addGlobalAttributes() {
-     *   return [{
-     *     types: ['heading', 'paragraph'],
-     *     attributes: {
-     *       textAlign: {
-     *         default: 'left',
-     *         parseHTML: (element) => element.style.textAlign || 'left',
-     *         renderHTML: (attrs) => attrs.textAlign !== 'left'
-     *           ? { style: `text-align: ${attrs.textAlign}` }
-     *           : null,
-     *       },
-     *     },
-     *   }];
-     * }
-     */
-    addGlobalAttributes?: () => GlobalAttributes[];
-    /**
-     * Toolbar items this extension contributes.
-     * Framework toolbar components read these to auto-generate buttons.
-     *
-     * @example
-     * addToolbarItems() {
-     *   return [{
-     *     type: 'button',
-     *     name: 'bold',
-     *     command: 'toggleBold',
-     *     isActive: 'bold',
-     *     icon: 'textB',
-     *     label: 'Bold',
-     *     shortcut: 'Mod-b',
-     *     group: 'format',
-     *   }];
-     * }
+     * Gets plugins from all extensions
+     * Cached after first call
      */
-    addToolbarItems?: () => ToolbarItem[];
+    get plugins(): Plugin[];
     /**
-     * Called before editor is created
-     * Can be used to modify editor options
+     * Gets commands from all extensions
      */
-    onBeforeCreate?: () => void;
+    get commands(): CommandMap;
     /**
-     * Called when editor is fully initialized and ready
+     * Gets toolbar items from all extensions
+     * Cached after first call
      */
-    onCreate?: () => void;
+    get toolbarItems(): ToolbarItem[];
     /**
-     * Called when document content changes
+     * Gets floating-menu items from all extensions
+     * Cached after first call
      */
-    onUpdate?: () => void;
+    get floatingMenuItems(): FloatingMenuItem[];
     /**
-     * Called when selection changes (without content change)
+     * Gets node views from all Node extensions that define addNodeView
      */
-    onSelectionUpdate?: () => void;
+    get nodeViews(): Record<string, NodeViewConstructor>;
     /**
-     * Called on every transaction
-     * Can be used to intercept or modify transactions
+     * Clears all caches (plugins, commands)
+     * Call when extensions change dynamically
      */
-    onTransaction?: (props: {
-        transaction: Transaction;
-    }) => void;
+    clearAllCaches(): void;
     /**
-     * Called when editor receives focus
+     * Recursively flattens extensions by expanding addExtensions()
+     * This allows extension bundles like StarterKit to work
      */
-    onFocus?: (props: {
-        event: FocusEvent;
-    }) => void;
+    private flattenExtensions;
     /**
-     * Called when editor loses focus
+     * Removes duplicate extensions by name, keeping the last occurrence.
+     * This allows parent extensions to auto-include children via addExtensions()
+     * while letting users override with explicitly configured versions.
      */
-    onBlur?: (props: {
-        event: FocusEvent;
-    }) => void;
+    private deduplicateExtensions;
     /**
-     * Called when editor is being destroyed
-     * Use for cleanup (remove event listeners, etc.)
+     * Sorts extensions by priority (higher priority first)
+     * Default priority is 100
      */
-    onDestroy?: () => void;
-}
-/**
- * Full configuration type for Extension.create()
- * Combines base properties with ThisType for proper `this` typing.
- *
- * @typeParam Options - Extension options type
- * @typeParam Storage - Extension storage type
- */
-type ExtensionConfig<Options = unknown, Storage = unknown> = ExtensionConfigBase<Options, Storage> & ThisType<ExtensionContext<Options, Storage>>;
-
-/**
- * Attribute specification for Node and Mark extensions
- *
- * Used by addAttributes() to define node/mark attributes
- * with parsing, rendering, and validation rules.
- *
- * @example
- * addAttributes() {
- *   return {
- *     level: {
- *       default: 1,
- *       parseHTML: (element) => parseInt(element.tagName.charAt(1), 10),
- *       renderHTML: (attributes) => ({ 'data-level': attributes.level }),
- *     },
- *   };
- * }
- */
-/**
- * Specification for a single attribute
- */
-interface AttributeSpec {
+    private resolveExtensions;
     /**
-     * Default value for the attribute
-     * Used when the attribute is not explicitly set
+     * Detects duplicate extension names.
+     * @throws Error if duplicate names found
      */
-    default?: unknown;
+    private detectConflicts;
     /**
-     * Whether this attribute is rendered to the DOM
-     * @default true
+     * Validates that all extension dependencies are present
+     * @throws Error if required dependency is missing
      */
-    rendered?: boolean;
+    private checkDependencies;
     /**
-     * Keep this attribute when splitting the node
-     * For example, heading level should be kept when pressing Enter
-     * @default true
+     * Sets editor reference on all extensions
      */
-    keepOnSplit?: boolean;
+    private bindEditorToExtensions;
     /**
-     * Validate attribute value (ProseMirror 1.22.0+).
-     * When a string, a `|`-separated list of primitive types
-     * (`"number"`, `"string"`, `"boolean"`, `"null"`, `"undefined"`).
-     * When a function, it should throw if the value is invalid.
-     *
-     * @example
-     * validate: 'number'
-     * validate: 'string|null'
-     * validate: (value) => { if (typeof value !== 'number') throw new Error('expected number'); }
+     * Collects global attributes from all extensions.
+     * Returns a map of type name -> attribute specs to merge.
      */
-    validate?: string | ((value: unknown) => void);
+    private collectGlobalAttributes;
     /**
-     * Parse attribute value from HTML element
-     * Called during HTML parsing to extract attribute value
-     *
-     * @param element - The HTML element being parsed
-     * @returns The attribute value
-     *
-     * @example
-     * parseHTML: (element) => element.getAttribute('data-level')
+     * Applies global attributes to a node or mark spec.
+     * Merges extra attrs into spec.attrs, wraps parseDOM getAttrs to parse
+     * global attributes from DOM elements, and wraps toDOM to inject rendered
+     * global HTML attributes into the output.
      */
-    parseHTML?: (element: HTMLElement) => unknown;
+    private applyGlobalAttributes;
     /**
-     * Render attribute to HTML attributes object
-     * Called during HTML serialization
-     *
-     * @param attributes - All attributes of the node/mark
-     * @returns HTML attributes object or null to skip
-     *
-     * @example
-     * renderHTML: (attributes) => ({ 'data-level': attributes.level })
+     * Builds ProseMirror Schema from Node and Mark extensions
      */
-    renderHTML?: (attributes: Record<string, unknown>) => Record<string, string | number | boolean | null | undefined> | null;
-}
-/**
- * Collection of attribute specifications
- * Keyed by attribute name
- */
-type AttributeSpecs = Record<string, AttributeSpec>;
-
-/**
- * Node configuration types
- *
- * These types define the configuration object passed to Node.create()
- * for creating ProseMirror node extensions.
- */
-
-/**
- * Editor interface for Node context
- * Includes schema with nodes for NodeType getter
- */
-interface NodeEditorContext {
-    readonly state: EditorState;
-    readonly view: EditorView;
-    readonly schema: {
-        nodes: Record<string, NodeType>;
-    };
-    readonly commands: Record<string, (...args: unknown[]) => boolean>;
-}
-/**
- * Context interface for Node config methods.
- * Extends ExtensionContext with node-specific properties.
- * This enables proper typing of `this.options`, `this.nodeType`, etc.
- *
- * @typeParam Options - Node options type
- * @typeParam Storage - Node storage type
- */
-interface NodeContext<Options = unknown, Storage = unknown> extends Omit<ExtensionContext<Options, Storage>, 'editor' | 'type'> {
-    /** Node type identifier */
-    readonly type: 'node';
-    /** Editor instance with schema access */
-    editor: NodeEditorContext | null;
-    /** ProseMirror NodeType (null until editor is initialized) */
-    readonly nodeType: NodeType | null;
-}
-/**
- * Parse rule for converting HTML to ProseMirror node
- * Simplified version of ProseMirror's ParseRule
- */
-interface NodeParseRule {
+    private buildSchema;
     /**
-     * CSS selector or tag name to match
-     * @example 'p', 'h1', 'div.my-class'
+     * Initializes storage for all extensions
      */
-    tag?: string;
+    private initializeStorage;
     /**
-     * Match by CSS style
-     * @example 'font-weight'
+     * Builds all ProseMirror plugins from extensions
      */
-    style?: string;
+    private buildPlugins;
     /**
-     * Priority for this rule (higher = checked first)
-     * @default 50
+     * Collects keyboard shortcuts from all extensions
+     * Returns ProseMirror-compatible commands for keymap plugin
+     *
+     * Note: Extensions should return PM-compatible commands from addKeyboardShortcuts()
      */
-    priority?: number;
+    private collectKeyboardShortcuts;
     /**
-     * Whether to consume the matched element
-     * @default true
+     * Collects input rules from all extensions
      */
-    consuming?: boolean;
+    private collectInputRules;
     /**
-     * Context required for this rule to match
-     * ProseMirror content expression
+     * Collects commands from all extensions
+     *
+     * Note: Commands with the same name will be overwritten by later extensions
+     * (lower priority extensions override higher priority). This is intentional
+     * to allow customization of built-in commands.
      */
-    context?: string;
+    private collectCommands;
     /**
-     * Get attributes from the matched element
-     * Return null/undefined to skip this rule
+     * Collects toolbar items from all extensions
      */
-    getAttrs?: ((node: HTMLElement) => Record<string, unknown> | null | undefined) | null;
+    private collectToolbarItems;
     /**
-     * Get content from the matched element
-     * Return false to use default content parsing
+     * Collects floating-menu items from all extensions via `addFloatingMenuItems()`.
      */
-    getContent?: (node: HTMLElement, schema: unknown) => unknown;
+    private collectFloatingMenuItems;
     /**
-     * How to preserve whitespace
-     */
-    preserveWhitespace?: boolean | 'full';
-}
-/**
- * Props passed to renderHTML function
- */
-interface NodeRenderHTMLProps {
-    /**
-     * The ProseMirror node being rendered
-     */
-    node: Node$1;
-    /**
-     * Merged HTML attributes from all sources
-     */
-    HTMLAttributes: Record<string, unknown>;
-}
-/**
- * Node-specific configuration properties (schema-related)
- */
-interface NodeSchemaProperties {
-    /**
-     * Node group(s) this node belongs to
-     * Used in content expressions
+     * Collects node views from all Node extensions.
+     * Returns a map of node name to NodeViewConstructor for EditorView.
      *
-     * @example 'block', 'inline', 'block list'
-     * Can be a function that returns the group string (useful for dynamic group based on options)
+     * Each constructor is annotated with `__domternalContext` containing
+     * the editor and extension metadata so framework wrappers (React, Vue)
+     * can access them without changing the ProseMirror calling convention.
      */
-    group?: string | (() => string);
+    private collectNodeViews;
     /**
-     * Content expression defining allowed children
-     * Uses ProseMirror content expression syntax
-     *
-     * @example 'inline*', 'block+', 'paragraph block*'
+     * Validates that the schema has required nodes
+     * @throws Error if schema is missing 'doc' or 'text' nodes
      */
-    content?: string;
+    validateSchema(): void;
     /**
-     * Whether this is an inline node
-     * Can be a function for dynamic inline based on options
-     * @default false
+     * Cleans up the extension manager
+     * Calls onDestroy on all extensions and clears all caches
      */
-    inline?: boolean | (() => boolean);
+    destroy(): void;
     /**
-     * Whether this node is an atom (no direct content editing)
-     * Cursor moves around atoms, not into them
+     * Safely executes a function, catching and reporting errors
+     * Prevents a single extension error from crashing the entire editor
      *
-     * @example true for images, mentions, emoji
-     */
-    atom?: boolean;
-    /**
-     * Whether the node can be selected as a whole
-     * @default true for leaf nodes, false for others
-     */
-    selectable?: boolean;
-    /**
-     * Whether the node can be dragged
-     * @default false
-     */
-    draggable?: boolean;
-    /**
-     * Whether this node represents code
-     * Affects text input handling (disables smart quotes, etc.)
-     */
-    code?: boolean;
-    /**
-     * How whitespace is handled in this node
-     * - 'pre': preserve whitespace (like <pre>)
-     * - 'normal': collapse whitespace (default)
+     * Handles both synchronous errors and async promise rejections.
+     *
+     * @param fn - Function to execute
+     * @param context - Context for error reporting (e.g., 'Bold.onUpdate')
+     * @returns The function result, or undefined if an error occurred
      */
-    whitespace?: 'pre' | 'normal';
+    safeCall<T>(fn: () => T, context: string): T | undefined;
     /**
-     * Whether this node isolates marks at its boundaries
-     * Marks don't extend across isolating boundaries
+     * Calls onBeforeCreate on all extensions
      */
-    isolating?: boolean;
+    callOnBeforeCreate(): void;
     /**
-     * Whether a gap cursor is allowed inside this node.
-     * Set to false to prevent gapcursor from appearing inside this node.
-     * Set to true to force gapcursor even if the default heuristic disallows it.
-     * When undefined, uses ProseMirror's default heuristic.
+     * Calls onCreate on all extensions
      */
-    allowGapCursor?: boolean;
+    callOnCreate(): void;
     /**
-     * Table role for prosemirror-tables integration.
-     * Nodes with a tableRole are discovered by prosemirror-tables via spec.tableRole.
-     * One of: 'table', 'row', 'cell', 'header_cell'
+     * Calls onUpdate on all extensions
      */
-    tableRole?: 'table' | 'row' | 'cell' | 'header_cell';
+    callOnUpdate(): void;
     /**
-     * Whether this is a top-level node (document root)
-     * Only one node should have this set to true
+     * Calls onSelectionUpdate on all extensions
      */
-    topNode?: boolean;
+    callOnSelectionUpdate(): void;
     /**
-     * Whether this node defines its own scope
-     * Content and marks don't leak out of defining nodes
+     * Calls onTransaction on all extensions
+     * @param props - Transaction props
      */
-    defining?: boolean;
+    callOnTransaction(props: {
+        transaction: Transaction;
+    }): void;
     /**
-     * Which marks are allowed in this node
-     * Empty string means no marks allowed
-     *
-     * @example '', '_', 'bold italic'
+     * Calls onFocus on all extensions
+     * @param props - Focus event props
      */
-    marks?: string;
+    callOnFocus(props: {
+        event: FocusEvent;
+    }): void;
     /**
-     * Custom text for leaf nodes
-     * Used by getText() and textContent
-     *
-     * @example '\n' for hard break
+     * Calls onBlur on all extensions
+     * @param props - Blur event props
      */
-    leafText?: string | ((node: Node$1) => string);
+    callOnBlur(props: {
+        event: FocusEvent;
+    }): void;
+}
+
+/**
+ * Inline Styles Utility
+ *
+ * Applies inline CSS styles to serialized HTML so it renders correctly
+ * when pasted outside the editor (email clients, CMS, Google Docs, etc.).
+ *
+ * Uses hardcoded light-theme defaults (same approach as Google Docs, Notion,
+ * TinyMCE). Optionally accepts overrides for custom styling.
+ *
+ * Only structural styles are inlined (borders, padding, margins, fonts).
+ * Colors are NOT inlined - explicit colors (TextColor, Highlight, cell bg)
+ * are already inline from renderHTML, and default text color is browser default.
+ */
+interface InlineStyleOverrides {
+    blockquoteBorder?: string;
+    blockquoteColor?: string;
+    tableBorder?: string;
+    tableHeaderBg?: string;
+    codeBg?: string;
+    codeFont?: string;
+    codeBorder?: string;
+    codeBlockBg?: string;
+    codeBlockFont?: string;
+    hrBorder?: string;
+    linkColor?: string;
+    detailsBorder?: string;
+    detailsBg?: string;
     /**
-     * Define node attributes
-     * Returns attribute specifications
-     *
-     * @example
-     * addAttributes() {
-     *   return {
-     *     level: { default: 1 },
-     *   };
-     * }
+     * How to export table column widths from `data-colwidth` attributes.
+     * - `'percent'` (default): convert to percentage widths on first-row cells
+     * - `'pixel'`: convert to pixel widths on first-row cells, table gets fixed width
+     * - `'none'`: leave `data-colwidth` as-is, no width styles applied
      */
-    addAttributes?: () => AttributeSpecs;
+    tableColumnWidths?: 'percent' | 'pixel' | 'none';
     /**
-     * Parse rules for converting HTML to this node
-     * Each rule defines how to match and parse HTML elements
+     * Optional callback to syntax-highlight code blocks.
+     * Receives the raw text content and optional language, returns highlighted HTML
+     * with `<span class="hljs-*">` markup (or any spans with inline styles).
      *
      * @example
-     * parseHTML() {
-     *   return [
-     *     { tag: 'p' },
-     *     { tag: 'div', priority: 10 },
-     *   ];
-     * }
-     */
-    parseHTML?: () => NodeParseRule[];
-    /**
-     * Render this node to DOM
-     * Returns DOMOutputSpec (tag, attributes, children)
+     * ```ts
+     * import { createLowlight, common } from 'lowlight';
+     * import { toHtml } from 'hast-util-to-html';
+     * const lowlight = createLowlight(common);
      *
-     * @example
-     * renderHTML({ node, HTMLAttributes }) {
-     *   return ['p', HTMLAttributes, 0];
-     * }
-     */
-    renderHTML?: (props: NodeRenderHTMLProps) => DOMOutputSpec;
-    /**
-     * Custom node view constructor
-     * For complex interactive nodes
-     */
-    addNodeView?: () => NodeViewConstructor;
-    /**
-     * Additional ProseMirror plugins for this node
-     * Called during plugin collection
+     * inlineStyles(html, {
+     *   codeHighlighter: (code, language) => {
+     *     if (language && lowlight.registered(language)) {
+     *       return toHtml(lowlight.highlight(language, code));
+     *     }
+     *     return null; // no highlighting
+     *   },
+     * });
+     * ```
      */
-    addProseMirrorPlugins?: () => Plugin[];
+    codeHighlighter?: (code: string, language: string | null) => string | null;
 }
 /**
- * Configuration for Node extensions
- * Combines ExtensionConfig base with node-specific schema properties.
- * Uses ThisType<NodeContext> to provide proper typing for `this` in config methods.
+ * Applies inline styles to all elements in a container.
+ * Exported for use in clipboardSerializer (operates on DOM directly).
+ */
+declare function applyInlineStyles(container: HTMLElement, overrides?: InlineStyleOverrides): void;
+/**
+ * Takes an HTML string and returns it with inline CSS styles applied
+ * to all elements, so it renders correctly outside the editor.
  *
- * @typeParam Options - Node options type
- * @typeParam Storage - Node storage type
+ * @param html - Serialized HTML string from editor.getHTML()
+ * @param overrides - Optional style overrides for custom theming
  *
  * @example
- * const Paragraph = Node.create({
- *   name: 'paragraph',
- *   group: 'block',
- *   content: 'inline*',
- *   parseHTML() {
- *     // `this` is properly typed here!
- *     return [{ tag: 'p' }];
- *   },
- *   renderHTML({ HTMLAttributes }) {
- *     return ['p', HTMLAttributes, 0];
- *   },
+ * ```ts
+ * // Default light-theme styles
+ * const styled = inlineStyles(editor.getHTML());
+ *
+ * // With custom overrides
+ * const styled = inlineStyles(editor.getHTML(), {
+ *   blockquoteBorder: '5px solid red',
+ *   linkColor: '#ff6600',
  * });
+ * ```
  */
-type NodeConfig<Options = unknown, Storage = unknown> = ExtensionConfigBase<Options, Storage> & NodeSchemaProperties & ThisType<NodeContext<Options, Storage>>;
+declare function inlineStyles(html: string, overrides?: InlineStyleOverrides): string;
 
 /**
- * Mark configuration types
+ * Editor - Main editor class wrapping ProseMirror
  *
- * These types define the configuration object passed to Mark.create()
- * for creating ProseMirror mark extensions.
+ * Manages extensions, schema, commands, and the ProseMirror EditorView/State.
  */
 
 /**
- * Editor interface for Mark context
- * Includes schema with marks for MarkType getter
- */
-interface MarkEditorContext {
-    readonly state: EditorState;
-    readonly view: EditorView;
-    readonly schema: {
-        marks: Record<string, MarkType>;
-    };
-    readonly commands: Record<string, (...args: unknown[]) => boolean>;
-}
-/**
- * Context interface for Mark config methods.
- * Extends ExtensionContext with mark-specific properties.
- * This enables proper typing of `this.options`, `this.markType`, etc.
+ * Main editor class
  *
- * @typeParam Options - Mark options type
- * @typeParam Storage - Mark storage type
- */
-interface MarkContext<Options = unknown, Storage = unknown> extends Omit<ExtensionContext<Options, Storage>, 'editor' | 'type'> {
-    /** Mark type identifier */
-    readonly type: 'mark';
-    /** Editor instance with schema access */
-    editor: MarkEditorContext | null;
-    /** ProseMirror MarkType (null until editor is initialized) */
-    readonly markType: MarkType | null;
-}
-/**
- * Parse rule for converting HTML to ProseMirror mark
- * Simplified version of ProseMirror's ParseRule for marks
+ * Wraps ProseMirror's EditorView and EditorState with a cleaner API.
+ *
+ * @example
+ * ```ts
+ * import { Editor } from '@domternal/core';
+ * import { Schema } from '@domternal/pm/model';
+ *
+ * const schema = new Schema({
+ *   nodes: { doc: { content: 'paragraph+' }, paragraph: { content: 'text*' }, text: {} }
+ * });
+ *
+ * const editor = new Editor({
+ *   schema,
+ *   element: document.getElementById('editor'),
+ *   content: '<p>Hello world</p>',
+ * });
+ *
+ * // Get content
+ * const json = editor.getJSON();
+ * const html = editor.getHTML();
+ *
+ * // Set content
+ * editor.commands.setContent('<p>New content</p>');
+ *
+ * // Cleanup
+ * editor.destroy();
+ * ```
  */
-interface MarkParseRule {
+declare class Editor extends EventEmitter<EditorEvents> {
     /**
-     * CSS selector or tag name to match
-     * @example 'strong', 'b', 'span.bold'
+     * Editor configuration options
      */
-    tag?: string;
+    private options;
     /**
-     * Match by CSS style property
-     * Can include expected value after '='
-     * @example 'font-weight', 'font-weight=bold'
+     * Manages extensions and schema
+     * @internal Exposed for CommandManager, not for public use
      */
-    style?: string;
+    private _extensionManager;
     /**
-     * Priority for this rule (higher = checked first)
-     * @default 50
+     * Gets the extension manager
+     * @internal For CommandManager use only
      */
-    priority?: number;
+    get extensionManager(): ExtensionManager;
     /**
-     * Whether to consume the matched element
-     * @default true
+     * Manages commands
      */
-    consuming?: boolean;
+    private commandManager;
     /**
-     * Get attributes from the matched element
-     * Return null/undefined to skip this rule
-     * Return false to explicitly not match
-     *
-     * For style rules, receives the style value as string
+     * ProseMirror EditorView instance
      */
-    getAttrs?: ((node: HTMLElement | string) => Record<string, unknown> | false | null) | null;
-}
-/**
- * Props passed to renderHTML function for marks
- */
-interface MarkRenderHTMLProps {
+    view: EditorView;
     /**
-     * The ProseMirror mark being rendered
+     * Whether the editor has been destroyed
      */
-    mark: Mark$1;
+    private _isDestroyed;
     /**
-     * Merged HTML attributes from all sources
+     * Timer for autofocus (cleared on destroy to prevent memory leaks)
      */
-    HTMLAttributes: Record<string, unknown>;
-}
-/**
- * Mark-specific configuration properties (schema-related)
- */
-interface MarkSchemaProperties {
+    private _autofocusTimer;
     /**
-     * Whether this mark should be active when the cursor
-     * is at its end (or beginning for marks that open).
-     *
-     * When true, typing at the mark's boundary continues the mark.
-     * When false, typing creates unmarked content.
+     * Creates a new Editor instance
      *
-     * @default true
+     * @param options - Editor configuration
+     * @throws Error if running in SSR environment (no window)
+     * @throws Error if schema is not provided
      */
-    inclusive?: boolean | (() => boolean);
+    constructor(options: EditorOptions);
     /**
-     * Marks that this mark excludes (cannot coexist with)
-     *
-     * - '_' excludes all marks
-     * - Space-separated mark names exclude specific marks
-     * - Empty string or undefined means no exclusions
-     *
-     * @example 'code' - excludes code mark
-     * @example 'bold italic' - excludes bold and italic
-     * @example '_' - excludes all other marks
+     * Gets the current EditorState
      */
-    excludes?: string;
+    get state(): EditorState;
     /**
-     * Mark group(s) this mark belongs to
-     * Used in node's marks property
-     *
-     * @example 'formatting', 'inline'
+     * Gets the ProseMirror schema
      */
-    group?: string;
+    get schema(): Schema;
     /**
-     * Whether this mark can span multiple nodes
-     *
-     * When true (default), the mark persists across inline nodes.
-     * When false, the mark only applies within a single text node.
-     *
-     * @default true
+     * Checks if the editor is editable
      */
-    spanning?: boolean;
+    get isEditable(): boolean;
     /**
-     * Whether this mark represents visual formatting.
+     * Checks if the editor content is empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Checks if the editor has focus
+     */
+    get isFocused(): boolean;
+    /**
+     * Checks if the editor has been destroyed
+     */
+    get isDestroyed(): boolean;
+    /**
+     * Gets single commands for immediate execution
+     * @example editor.commands.focus('end')
+     */
+    get commands(): SingleCommands;
+    /**
+     * Creates a command chain for batched execution
+     * @example editor.chain().focus().insertText('Hello').run()
+     */
+    chain(): ChainedCommands;
+    /**
+     * Checks if commands can be executed (dry-run)
+     * @example if (editor.can().toggleBold()) { ... }
+     */
+    can(): CanCommands;
+    /**
+     * Gets extension storage
+     * Access via: editor.storage.extensionName.propertyName
+     */
+    get storage(): Record<string, unknown>;
+    /**
+     * Toolbar items registered by all extensions.
+     */
+    get toolbarItems(): ToolbarItem[];
+    /**
+     * Floating-menu items registered by all extensions, rendered as the
+     * block-insert menu shown on empty paragraphs.
+     */
+    get floatingMenuItems(): FloatingMenuItem[];
+    /**
+     * Checks if a node or mark is currently active
      *
-     * Used by `unsetAllMarks` to decide which marks to remove.
-     * Marks with `isFormatting: false` survive clear formatting
-     * (e.g., links, comments, annotations).
+     * For toolbar button states - returns true if:
+     * - For marks: the current selection has the mark applied
+     * - For nodes: the cursor is inside that node type
      *
-     * Can be overridden via `.configure()`:
-     * ```ts
-     * Link.configure({ isFormatting: true }) // make links clearable
-     * ```
+     * @param nameOrAttributes - Extension name, or object with name and attributes
+     * @param attributes - Optional attributes to match (for node/mark specific states)
      *
-     * @default true
+     * @example
+     * editor.isActive('bold') // → true if bold mark is active
+     * editor.isActive('heading', { level: 2 }) // → true if in h2
+     * editor.isActive({ name: 'textAlign', attributes: { align: 'center' } })
      */
-    isFormatting?: boolean;
+    isActive(nameOrAttributes: string | {
+        name: string;
+        attributes?: Record<string, unknown>;
+    }, attributes?: Record<string, unknown>): boolean;
     /**
-     * Define mark attributes
-     * Returns attribute specifications
+     * Gets attributes of the currently active node or mark
+     *
+     * Returns empty object if the node/mark is not found or not active.
+     *
+     * @param name - Extension name (node or mark)
      *
      * @example
-     * addAttributes() {
-     *   return {
-     *     color: { default: null },
-     *   };
-     * }
+     * editor.getAttributes('heading') // → { level: 2 }
+     * editor.getAttributes('link') // → { href: 'https://...', target: '_blank' }
      */
-    addAttributes?: () => AttributeSpecs;
+    getAttributes(name: string): Record<string, unknown>;
     /**
-     * Parse rules for converting HTML to this mark
-     * Each rule defines how to match and parse HTML elements
+     * Helper to match attributes
+     * Returns true if target contains all key/value pairs from source
+     */
+    private matchAttributes;
+    /**
+     * Gets the document content as JSON
+     */
+    getJSON(): JSONContent;
+    /**
+     * Gets the document content as HTML string
      *
-     * @example
-     * parseHTML() {
-     *   return [
-     *     { tag: 'strong' },
-     *     { tag: 'b' },
-     *     { style: 'font-weight', getAttrs: (value) => /bold|[5-9]\d{2}/.test(value) && null },
-     *   ];
-     * }
+     * @param options - Optional settings
+     * @param options.styled - When true (or an override object), applies inline CSS
+     *   styles so the HTML renders correctly outside the editor (email, CMS, etc.)
      */
-    parseHTML?: () => MarkParseRule[];
+    getHTML(options?: {
+        styled?: boolean | InlineStyleOverrides;
+    }): string;
     /**
-     * Render this mark to DOM
-     * Returns DOMOutputSpec (tag, attributes, hole)
+     * Gets the document content as plain text
      *
-     * The 0 in the return array indicates where child content goes.
+     * @param options - Options for text extraction
+     * @param options.blockSeparator - String to insert between blocks (default: '\n\n')
+     */
+    getText(options?: {
+        blockSeparator?: string;
+    }): string;
+    /**
+     * Executes a command with proper CommandProps
+     * @internal
+     */
+    private runCommand;
+    /**
+     * Sets the editor content
      *
-     * @example
-     * renderHTML({ mark, HTMLAttributes }) {
-     *   return ['strong', HTMLAttributes, 0];
-     * }
+     * @param content - JSON or HTML content
+     * @param emitUpdate - Whether to emit update event (default: true)
+     * @returns true if content was set successfully, false if content was invalid
      */
-    renderHTML?: (props: MarkRenderHTMLProps) => DOMOutputSpec;
+    setContent(content: Content, emitUpdate?: boolean): boolean;
+    /**
+     * Clears the editor content
+     *
+     * @param emitUpdate - Whether to emit update event (default: true)
+     * @returns true if content was cleared successfully
+     */
+    clearContent(emitUpdate?: boolean): boolean;
+    /**
+     * Sets whether the editor is editable
+     *
+     * @param editable - Whether the editor should be editable
+     */
+    setEditable(editable: boolean): this;
+    /**
+     * Focuses the editor
+     *
+     * @param position - Where to place cursor (default: null = just focus)
+     */
+    focus(position?: FocusPosition): this;
+    /**
+     * Removes focus from the editor
+     */
+    blur(): this;
+    /**
+     * Registers a ProseMirror plugin dynamically at runtime, after the editor
+     * has been created. Safe to call repeatedly with the same plugin key.
+     */
+    registerPlugin(plugin: Plugin): void;
+    /**
+     * Unregisters a ProseMirror plugin by its PluginKey.
+     * Uses PluginKey.get() to identify the plugin to remove.
+     */
+    unregisterPlugin(key: PluginKey): void;
+    /**
+     * Destroys the editor and cleans up resources
+     *
+     * After calling destroy(), the editor instance should not be used.
+     */
+    destroy(): void;
+    /**
+     * Builds a clipboardSerializer that applies a transform function to HTML on copy/cut.
+     */
+    private buildClipboardSerializer;
+    /**
+     * Creates the editor instance
+     */
+    private createEditor;
+    /**
+     * Handles ProseMirror transactions
+     */
+    private dispatchTransaction;
+    /**
+     * Emit method - needed for CommandManager interface
+     */
+    emit<E extends keyof EditorEvents>(event: E, ...args: EditorEvents[E] extends undefined ? [] : [EditorEvents[E]]): this;
 }
+
 /**
- * Configuration for Mark extensions
- * Combines ExtensionConfigBase with mark-specific schema properties.
- * Uses ThisType<MarkContext> to provide proper typing for `this` in config methods.
+ * FloatingMenu configuration types
  *
- * @typeParam Options - Mark options type
- * @typeParam Storage - Mark storage type
- *
- * @example
- * const Bold = Mark.create({
- *   name: 'bold',
- *   parseHTML() {
- *     // `this` is properly typed here!
- *     return [{ tag: 'strong' }, { tag: 'b' }];
- *   },
- *   renderHTML({ HTMLAttributes }) {
- *     return ['strong', HTMLAttributes, 0];
- *   },
- * });
+ * Types for block-insert items contributed by extensions via the
+ * `addFloatingMenuItems()` hook. Framework wrappers read these items
+ * and render a WAI-ARIA menu shown on empty paragraphs.
  */
-type MarkConfig<Options = unknown, Storage = unknown> = ExtensionConfigBase<Options, Storage> & MarkSchemaProperties & ThisType<MarkContext<Options, Storage>>;
 
 /**
- * Callback type for event handlers
- * - Events with payload: (data: T) => void
- * - Events without payload (undefined): () => void
- */
-type EventCallback<T> = T extends undefined ? () => void : (data: T) => void;
-/**
- * Generic, type-safe event emitter
+ * A single entry in the floating menu.
+ *
+ * Unlike `ToolbarButton`, floating-menu items represent one-shot insert
+ * actions (no toggle / active state), carry an optional `description` for
+ * Notion-style two-line rendering, and expose `keywords` for future
+ * slash-command filtering.
  *
  * @example
- * ```typescript
- * interface MyEvents {
- *   update: { value: number };
- *   destroy: undefined;
+ * {
+ *   name: 'heading-1',
+ *   label: 'Heading 1',
+ *   description: 'Big section heading',
+ *   icon: 'textHOne',
+ *   group: 'Basic',
+ *   shortcut: '# ',
+ *   command: 'toggleHeading',
+ *   commandArgs: [{ level: 1 }],
  * }
- *
- * const emitter = new EventEmitter<MyEvents>();
- * emitter.on('update', ({ value }) => console.log(value));
- * emitter.on('destroy', () => console.log('destroyed'));
- * ```
  */
-declare class EventEmitter<Events extends {
-    [K in keyof Events]: unknown;
-} = Record<string, never>> {
-    protected callbacks: Map<keyof Events, Set<(data: unknown) => void>>;
-    /**
-     * Register an event listener
-     */
-    on<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>): this;
-    /**
-     * Remove an event listener, or all listeners for an event if no callback specified
-     */
-    off<E extends keyof Events>(event: E, callback?: EventCallback<Events[E]>): this;
-    /**
-     * Emit an event to all registered listeners
-     * Uses .call(this) to preserve context for callbacks
-     */
-    emit<E extends keyof Events>(event: E, ...args: Events[E] extends undefined ? [] : [Events[E]]): this;
+interface FloatingMenuItem {
+    /** Unique identifier (used as React key, aria id, and dedup key when merging). */
+    name: string;
+    /** Primary label shown to the user. */
+    label: string;
+    /** Optional secondary line shown under the label. */
+    description?: string;
+    /** Icon key resolved against the editor's IconSet. Optional. */
+    icon?: string;
     /**
-     * Register an event listener that fires only once
+     * Group heading. Items with the same group render under a shared
+     * `<div role="group" aria-label={group}>` section.
+     * @default '' (no group heading)
      */
-    once<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>): this;
+    group?: string;
+    /** Sort order within group (higher first). @default 100 */
+    priority?: number;
+    /** Keywords for future slash-command fuzzy filtering. */
+    keywords?: string[];
+    /** Visible keyboard-shortcut hint (e.g. `# `, `Mod-Alt-1`). */
+    shortcut?: string;
     /**
-     * Remove all listeners for a specific event, or all events if no event specified
+     * Command to execute on activation.
+     *
+     * - String: key of `editor.commands`; invoked with `commandArgs`.
+     * - Function: arbitrary callback receiving the editor. Use when the
+     *   action is not a registered command (e.g. opening a popover).
      */
-    removeAllListeners(event?: keyof Events): this;
+    command: string | ((editor: Editor) => void);
+    /** Arguments for string commands. Ignored when `command` is a function. */
+    commandArgs?: unknown[];
     /**
-     * Get the number of listeners for a specific event
+     * Custom disabled predicate. When omitted, the controller dry-runs the
+     * command via `editor.can()` (string commands only) to detect availability.
      */
-    listenerCount(event: keyof Events): number;
+    isDisabled?: (editor: Editor) => boolean;
     /**
-     * Get all event names that have listeners
+     * Node-type names that, when present as ancestors of the cursor, cause
+     * the slash menu to hide this item. Useful for list/task-list entries:
+     * e.g. `['bulletList']` removes "Bulleted list" from the menu while the
+     * cursor is already inside a bullet list, so picking it doesn't lift
+     * the user out of the list unexpectedly.
      */
-    eventNames(): (keyof Events)[];
+    hideWhenInside?: string[];
 }
-
 /**
- * ExtensionManager - Manages extensions and schema
+ * Override form accepted by `FloatingMenu.configure({ items })`.
  *
- * Handles:
- * - Extension lifecycle (flatten, resolve, bind)
- * - Schema building from Node/Mark extensions
- * - Plugin collection from all extensions
- * - Extension storage management
- * - Conflict detection (AD-7)
+ * - Array: replaces the collected defaults entirely.
+ * - Function: transforms the defaults (filter / reorder / extend).
  */
+type FloatingMenuItemsOverride = FloatingMenuItem[] | ((defaults: FloatingMenuItem[], editor: Editor) => FloatingMenuItem[]);
 
 /**
- * Error event props for safeCall
+ * Extension configuration types
+ *
+ * These types define the configuration object passed to Extension.create(),
+ * Node.create(), and Mark.create() factory methods.
  */
-interface ErrorEventProps {
-    error: Error;
-    context: string;
-}
+
 /**
- * Editor interface for ExtensionManager
- * Forward declaration to avoid circular dependency
+ * Editor instance type (forward declaration)
  */
-interface ExtensionManagerEditor {
-    readonly schema: Schema;
-    emit?(event: 'error', props: ErrorEventProps): void;
+interface ExtensionEditor {
+    readonly state: EditorState;
+    readonly view: EditorView;
+    readonly schema: unknown;
+    readonly commands: SingleCommands;
 }
 /**
- * Context attached to node view constructors for framework wrappers.
- * Accessible via `(constructor as any).__domternalContext`.
+ * Any extension type (forward declaration)
  */
-interface NodeViewContext {
-    editor: ExtensionManagerEditor;
-    extension: {
-        name: string;
-        options: Record<string, unknown>;
-    };
+interface AnyExtensionConfig {
+    name: string;
+    type?: 'extension' | 'node' | 'mark';
 }
 /**
- * Options for ExtensionManager constructor
+ * Global attribute specification for injecting attributes into multiple node/mark types.
+ * Used by extensions like TextAlign to add alignment to heading, paragraph, etc.
  */
-interface ExtensionManagerOptions {
-    /**
-     * Extensions to process
-     * If provided, schema is built from extensions
-     */
-    extensions?: AnyExtension[] | undefined;
-    /**
-     * Direct schema (backward compatibility with Step 1.3)
-     * If provided, extensions are ignored for schema building
-     */
-    schema?: Schema | undefined;
-}
-declare class ExtensionManager {
+interface GlobalAttributeSpec {
     /**
-     * Processed extensions (flattened, sorted by priority)
+     * Default value for the attribute.
      */
-    private readonly _extensions;
+    default?: unknown;
     /**
-     * ProseMirror schema (built from extensions or passed directly)
+     * Parse attribute value from HTML element.
+     * @param element - The DOM element to parse from
+     * @returns The parsed attribute value
      */
-    private readonly _schema;
+    parseHTML?: (element: HTMLElement) => unknown;
     /**
-     * Reference to the editor instance
+     * Render attribute value to HTML attributes.
+     * @param attributes - The node/mark attributes
+     * @returns Object of HTML attributes to set, or null/empty to skip
      */
-    readonly editor: ExtensionManagerEditor;
+    renderHTML?: (attributes: Record<string, unknown>) => Record<string, string> | null;
+}
+/**
+ * Global attributes definition for injecting into node/mark types.
+ */
+interface GlobalAttributes {
     /**
-     * Extension storage (keyed by extension name)
+     * Node or mark type names to add these attributes to.
+     * @example ['heading', 'paragraph']
      */
-    private readonly _storage;
+    types: string[];
     /**
-     * Whether the manager has been destroyed
+     * Attribute specifications to add.
+     * @example { textAlign: { default: 'left', parseHTML: (el) => el.style.textAlign } }
      */
-    private isDestroyed;
+    attributes: Record<string, GlobalAttributeSpec>;
+}
+/**
+ * Context interface that describes what `this` will be in config methods.
+ * This enables proper typing of `this.options`, `this.editor`, etc.
+ * without creating circular dependencies.
+ *
+ * @typeParam Options - Extension options type
+ * @typeParam Storage - Extension storage type
+ */
+interface ExtensionContext<Options = unknown, Storage = unknown> {
+    /** Extension type identifier */
+    readonly type: 'extension' | 'node' | 'mark';
+    /** Unique extension name */
+    readonly name: string;
+    /** Extension options (immutable after creation) */
+    readonly options: Options;
+    /** Extension storage (mutable state) */
+    storage: Storage;
+    /** Editor instance (null until bound by ExtensionManager) */
+    editor: ExtensionEditor | null;
     /**
-     * Cached plugins (built lazily)
+     * Reference to the parent config method when using extend().
+     * Available only inside overridden config methods.
+     * Use `this.parent?.()` to call the parent's version of the current method.
      */
-    private _plugins;
-    /**
-     * Cached commands (collected lazily)
-     */
-    private _commands;
+    parent?: ((...args: unknown[]) => unknown) | undefined;
+}
+/**
+ * Base configuration properties for all extension types.
+ * This interface contains just the properties without ThisType,
+ * allowing Node and Mark configs to use their own context types.
+ *
+ * @typeParam Options - Extension options type
+ * @typeParam Storage - Extension storage type
+ */
+interface ExtensionConfigBase<Options = unknown, Storage = unknown> {
     /**
-     * Cached toolbar items (collected lazily)
+     * Unique extension name
+     * Used for identification, storage access, and error messages
      */
-    private _toolbarItems;
+    name: string;
     /**
-     * Cached node views (collected lazily)
+     * Extension priority (higher = loaded first)
+     *
+     * Reserved ranges:
+     * - 900-1000: Core nodes (Document, Text, Paragraph)
+     * - 500-899: Standard extensions (Heading, Bold, etc.)
+     * - 100-499: Default range for user extensions
+     * - 0-99: Low priority extensions (run after everything)
+     *
+     * @default 100
      */
-    private _nodeViews;
+    priority?: number;
     /**
-     * Creates a new ExtensionManager
+     * Required extensions that must be present
+     * ExtensionManager throws if any dependency is missing
      *
-     * @param options - Extensions or direct schema
-     * @param editor - Editor instance
+     * @example
+     * dependencies: ['bulletList', 'orderedList']
      */
-    constructor(options: ExtensionManagerOptions, editor: ExtensionManagerEditor);
+    dependencies?: string[];
     /**
-     * Gets the processed extensions array
+     * Default options for this extension
+     * Called during extension creation with `this` bound to the extension
      */
-    get extensions(): readonly AnyExtension[];
+    addOptions?: () => Options;
     /**
-     * Gets the ProseMirror schema
+     * Initial storage state for this extension
+     * Storage is mutable and accessible via editor.storage[extensionName]
      */
-    get schema(): Schema;
+    addStorage?: () => Storage;
     /**
-     * Gets extension storage (accessed via editor.storage)
+     * Commands this extension provides
+     * Commands are accessible via editor.commands.commandName()
+     *
+     * @example
+     * addCommands() {
+     *   return {
+     *     toggleBold: () => ({ commands }) => commands.toggleMark('bold'),
+     *   };
+     * }
      */
-    get storage(): Record<string, unknown>;
+    addCommands?: () => Record<string, (...args: never[]) => Command>;
     /**
-     * Gets plugins from all extensions
-     * Cached after first call
+     * Keyboard shortcuts for this extension
+     * Keys are shortcut strings (e.g., 'Mod-b'), values are handler functions
+     *
+     * @example
+     * addKeyboardShortcuts() {
+     *   return {
+     *     'Mod-b': () => this.editor.commands.toggleBold(),
+     *   };
+     * }
      */
-    get plugins(): Plugin[];
+    addKeyboardShortcuts?: () => Record<string, KeyboardShortcutCommand>;
     /**
-     * Gets commands from all extensions
+     * Input rules (markdown-style shortcuts)
+     * Triggered when user types matching patterns
+     *
+     * @example
+     * addInputRules() {
+     *   return [
+     *     textblockTypeInputRule(/^## $/, this.type),
+     *   ];
+     * }
      */
-    get commands(): CommandMap;
+    addInputRules?: () => InputRule[];
     /**
-     * Gets toolbar items from all extensions
-     * Cached after first call
+     * ProseMirror plugins for this extension
      */
-    get toolbarItems(): ToolbarItem[];
+    addProseMirrorPlugins?: () => Plugin[];
     /**
-     * Gets node views from all Node extensions that define addNodeView
+     * Nested extensions (for extension bundles like StarterKit)
+     * These extensions are flattened and processed like top-level extensions
      */
-    get nodeViews(): Record<string, NodeViewConstructor>;
+    addExtensions?: () => AnyExtensionConfig[];
     /**
-     * Clears all caches (plugins, commands)
-     * Call when extensions change dynamically
+     * Global attributes to add to multiple node/mark types.
+     * Useful for extensions like TextAlign that need to add attributes
+     * to several nodes (heading, paragraph, etc.) without modifying each.
+     *
+     * @example
+     * addGlobalAttributes() {
+     *   return [{
+     *     types: ['heading', 'paragraph'],
+     *     attributes: {
+     *       textAlign: {
+     *         default: 'left',
+     *         parseHTML: (element) => element.style.textAlign || 'left',
+     *         renderHTML: (attrs) => attrs.textAlign !== 'left'
+     *           ? { style: `text-align: ${attrs.textAlign}` }
+     *           : null,
+     *       },
+     *     },
+     *   }];
+     * }
      */
-    clearAllCaches(): void;
+    addGlobalAttributes?: () => GlobalAttributes[];
     /**
-     * Recursively flattens extensions by expanding addExtensions()
-     * This allows extension bundles like StarterKit to work
+     * Toolbar items this extension contributes.
+     * Framework toolbar components read these to auto-generate buttons.
+     *
+     * @example
+     * addToolbarItems() {
+     *   return [{
+     *     type: 'button',
+     *     name: 'bold',
+     *     command: 'toggleBold',
+     *     isActive: 'bold',
+     *     icon: 'textB',
+     *     label: 'Bold',
+     *     shortcut: 'Mod-b',
+     *     group: 'format',
+     *   }];
+     * }
      */
-    private flattenExtensions;
+    addToolbarItems?: () => ToolbarItem[];
     /**
-     * Removes duplicate extensions by name, keeping the last occurrence.
-     * This allows parent extensions to auto-include children via addExtensions()
-     * while letting users override with explicitly configured versions.
+     * Floating-menu items this extension contributes.
+     * Block-insert menu shown on empty paragraphs aggregates these items
+     * across all extensions. Framework wrappers render them as a WAI-ARIA
+     * menu with groups, arrow-key navigation, and Enter to execute.
+     *
+     * @example
+     * addFloatingMenuItems() {
+     *   return [{
+     *     name: 'heading-1',
+     *     label: 'Heading 1',
+     *     description: 'Big section heading',
+     *     icon: 'textHOne',
+     *     group: 'Basic',
+     *     command: 'toggleHeading',
+     *     commandArgs: [{ level: 1 }],
+     *   }];
+     * }
      */
-    private deduplicateExtensions;
+    addFloatingMenuItems?: () => FloatingMenuItem[];
     /**
-     * Sorts extensions by priority (higher priority first)
-     * Default priority is 100
+     * Called before editor is created
+     * Can be used to modify editor options
      */
-    private resolveExtensions;
+    onBeforeCreate?: () => void;
     /**
-     * Detects duplicate extension names (AD-7: Schema Conflict Detection)
-     * @throws Error if duplicate names found
+     * Called when editor is fully initialized and ready
      */
-    private detectConflicts;
+    onCreate?: () => void;
     /**
-     * Validates that all extension dependencies are present
-     * @throws Error if required dependency is missing
+     * Called when document content changes
      */
-    private checkDependencies;
+    onUpdate?: () => void;
     /**
-     * Sets editor reference on all extensions
+     * Called when selection changes (without content change)
      */
-    private bindEditorToExtensions;
+    onSelectionUpdate?: () => void;
     /**
-     * Collects global attributes from all extensions.
-     * Returns a map of type name -> attribute specs to merge.
+     * Called on every transaction
+     * Can be used to intercept or modify transactions
      */
-    private collectGlobalAttributes;
+    onTransaction?: (props: {
+        transaction: Transaction;
+    }) => void;
     /**
-     * Applies global attributes to a node or mark spec.
-     * Merges extra attrs into spec.attrs, wraps parseDOM getAttrs to parse
-     * global attributes from DOM elements, and wraps toDOM to inject rendered
-     * global HTML attributes into the output.
+     * Called when editor receives focus
      */
-    private applyGlobalAttributes;
+    onFocus?: (props: {
+        event: FocusEvent;
+    }) => void;
     /**
-     * Builds ProseMirror Schema from Node and Mark extensions
+     * Called when editor loses focus
      */
-    private buildSchema;
+    onBlur?: (props: {
+        event: FocusEvent;
+    }) => void;
     /**
-     * Initializes storage for all extensions
+     * Called when editor is being destroyed
+     * Use for cleanup (remove event listeners, etc.)
      */
-    private initializeStorage;
+    onDestroy?: () => void;
+}
+/**
+ * Full configuration type for Extension.create()
+ * Combines base properties with ThisType for proper `this` typing.
+ *
+ * @typeParam Options - Extension options type
+ * @typeParam Storage - Extension storage type
+ */
+type ExtensionConfig<Options = unknown, Storage = unknown> = ExtensionConfigBase<Options, Storage> & ThisType<ExtensionContext<Options, Storage>>;
+
+/**
+ * Attribute specification for Node and Mark extensions
+ *
+ * Used by addAttributes() to define node/mark attributes
+ * with parsing, rendering, and validation rules.
+ *
+ * @example
+ * addAttributes() {
+ *   return {
+ *     level: {
+ *       default: 1,
+ *       parseHTML: (element) => parseInt(element.tagName.charAt(1), 10),
+ *       renderHTML: (attributes) => ({ 'data-level': attributes.level }),
+ *     },
+ *   };
+ * }
+ */
+/**
+ * Specification for a single attribute
+ */
+interface AttributeSpec {
     /**
-     * Builds all ProseMirror plugins from extensions
+     * Default value for the attribute
+     * Used when the attribute is not explicitly set
      */
-    private buildPlugins;
+    default?: unknown;
     /**
-     * Collects keyboard shortcuts from all extensions
-     * Returns ProseMirror-compatible commands for keymap plugin
-     *
-     * Note: Extensions should return PM-compatible commands from addKeyboardShortcuts()
+     * Whether this attribute is rendered to the DOM
+     * @default true
      */
-    private collectKeyboardShortcuts;
+    rendered?: boolean;
     /**
-     * Collects input rules from all extensions
+     * Keep this attribute when splitting the node
+     * For example, heading level should be kept when pressing Enter
+     * @default true
      */
-    private collectInputRules;
+    keepOnSplit?: boolean;
     /**
-     * Collects commands from all extensions
+     * Validate attribute value (ProseMirror 1.22.0+).
+     * When a string, a `|`-separated list of primitive types
+     * (`"number"`, `"string"`, `"boolean"`, `"null"`, `"undefined"`).
+     * When a function, it should throw if the value is invalid.
      *
-     * Note: Commands with the same name will be overwritten by later extensions
-     * (lower priority extensions override higher priority). This is intentional
-     * to allow customization of built-in commands.
-     */
-    private collectCommands;
-    /**
-     * Collects toolbar items from all extensions
+     * @example
+     * validate: 'number'
+     * validate: 'string|null'
+     * validate: (value) => { if (typeof value !== 'number') throw new Error('expected number'); }
      */
-    private collectToolbarItems;
+    validate?: string | ((value: unknown) => void);
     /**
-     * Collects node views from all Node extensions.
-     * Returns a map of node name to NodeViewConstructor for EditorView.
+     * Parse attribute value from HTML element
+     * Called during HTML parsing to extract attribute value
      *
-     * Each constructor is annotated with `__domternalContext` containing
-     * the editor and extension metadata so framework wrappers (React, Vue)
-     * can access them without changing the ProseMirror calling convention.
-     */
-    private collectNodeViews;
-    /**
-     * Validates that the schema has required nodes
-     * @throws Error if schema is missing 'doc' or 'text' nodes
-     */
-    validateSchema(): void;
-    /**
-     * Cleans up the extension manager
-     * Calls onDestroy on all extensions and clears all caches
+     * @param element - The HTML element being parsed
+     * @returns The attribute value
+     *
+     * @example
+     * parseHTML: (element) => element.getAttribute('data-level')
      */
-    destroy(): void;
+    parseHTML?: (element: HTMLElement) => unknown;
     /**
-     * Safely executes a function, catching and reporting errors
-     * Prevents a single extension error from crashing the entire editor
+     * Render attribute to HTML attributes object
+     * Called during HTML serialization
      *
-     * Handles both synchronous errors and async promise rejections.
+     * @param attributes - All attributes of the node/mark
+     * @returns HTML attributes object or null to skip
      *
-     * @param fn - Function to execute
-     * @param context - Context for error reporting (e.g., 'Bold.onUpdate')
-     * @returns The function result, or undefined if an error occurred
-     */
-    safeCall<T>(fn: () => T, context: string): T | undefined;
-    /**
-     * Calls onBeforeCreate on all extensions
+     * @example
+     * renderHTML: (attributes) => ({ 'data-level': attributes.level })
      */
-    callOnBeforeCreate(): void;
+    renderHTML?: (attributes: Record<string, unknown>) => Record<string, string | number | boolean | null | undefined> | null;
+}
+/**
+ * Collection of attribute specifications
+ * Keyed by attribute name
+ */
+type AttributeSpecs = Record<string, AttributeSpec>;
+
+/**
+ * Node configuration types
+ *
+ * These types define the configuration object passed to Node.create()
+ * for creating ProseMirror node extensions.
+ */
+
+/**
+ * Editor interface for Node context
+ * Includes schema with nodes for NodeType getter
+ */
+interface NodeEditorContext {
+    readonly state: EditorState;
+    readonly view: EditorView;
+    readonly schema: {
+        nodes: Record<string, NodeType>;
+    };
+    readonly commands: Record<string, (...args: unknown[]) => boolean>;
+}
+/**
+ * Context interface for Node config methods.
+ * Extends ExtensionContext with node-specific properties.
+ * This enables proper typing of `this.options`, `this.nodeType`, etc.
+ *
+ * @typeParam Options - Node options type
+ * @typeParam Storage - Node storage type
+ */
+interface NodeContext<Options = unknown, Storage = unknown> extends Omit<ExtensionContext<Options, Storage>, 'editor' | 'type'> {
+    /** Node type identifier */
+    readonly type: 'node';
+    /** Editor instance with schema access */
+    editor: NodeEditorContext | null;
+    /** ProseMirror NodeType (null until editor is initialized) */
+    readonly nodeType: NodeType | null;
+}
+/**
+ * Parse rule for converting HTML to ProseMirror node
+ * Simplified version of ProseMirror's ParseRule
+ */
+interface NodeParseRule {
     /**
-     * Calls onCreate on all extensions
+     * CSS selector or tag name to match
+     * @example 'p', 'h1', 'div.my-class'
      */
-    callOnCreate(): void;
+    tag?: string;
     /**
-     * Calls onUpdate on all extensions
+     * Match by CSS style
+     * @example 'font-weight'
      */
-    callOnUpdate(): void;
+    style?: string;
     /**
-     * Calls onSelectionUpdate on all extensions
+     * Priority for this rule (higher = checked first)
+     * @default 50
      */
-    callOnSelectionUpdate(): void;
+    priority?: number;
     /**
-     * Calls onTransaction on all extensions
-     * @param props - Transaction props
+     * Whether to consume the matched element
+     * @default true
      */
-    callOnTransaction(props: {
-        transaction: Transaction;
-    }): void;
+    consuming?: boolean;
     /**
-     * Calls onFocus on all extensions
-     * @param props - Focus event props
+     * Context required for this rule to match
+     * ProseMirror content expression
      */
-    callOnFocus(props: {
-        event: FocusEvent;
-    }): void;
+    context?: string;
     /**
-     * Calls onBlur on all extensions
-     * @param props - Blur event props
+     * Get attributes from the matched element
+     * Return null/undefined to skip this rule
      */
-    callOnBlur(props: {
-        event: FocusEvent;
-    }): void;
-}
-
-/**
- * Inline Styles Utility
- *
- * Applies inline CSS styles to serialized HTML so it renders correctly
- * when pasted outside the editor (email clients, CMS, Google Docs, etc.).
- *
- * Uses hardcoded light-theme defaults (same approach as Google Docs, Notion,
- * TinyMCE). Optionally accepts overrides for custom styling.
- *
- * Only structural styles are inlined (borders, padding, margins, fonts).
- * Colors are NOT inlined — explicit colors (TextColor, Highlight, cell bg)
- * are already inline from renderHTML, and default text color is browser default.
- */
-interface InlineStyleOverrides {
-    blockquoteBorder?: string;
-    blockquoteColor?: string;
-    tableBorder?: string;
-    tableHeaderBg?: string;
-    codeBg?: string;
-    codeFont?: string;
-    codeBorder?: string;
-    codeBlockBg?: string;
-    codeBlockFont?: string;
-    hrBorder?: string;
-    linkColor?: string;
-    detailsBorder?: string;
-    detailsBg?: string;
+    getAttrs?: ((node: HTMLElement) => Record<string, unknown> | null | undefined) | null;
     /**
-     * How to export table column widths from `data-colwidth` attributes.
-     * - `'percent'` (default): convert to percentage widths on first-row cells
-     * - `'pixel'`: convert to pixel widths on first-row cells, table gets fixed width
-     * - `'none'`: leave `data-colwidth` as-is, no width styles applied
+     * Get content from the matched element
+     * Return false to use default content parsing
      */
-    tableColumnWidths?: 'percent' | 'pixel' | 'none';
+    getContent?: (node: HTMLElement, schema: unknown) => unknown;
     /**
-     * Optional callback to syntax-highlight code blocks.
-     * Receives the raw text content and optional language, returns highlighted HTML
-     * with `<span class="hljs-*">` markup (or any spans with inline styles).
-     *
-     * @example
-     * ```ts
-     * import { createLowlight, common } from 'lowlight';
-     * import { toHtml } from 'hast-util-to-html';
-     * const lowlight = createLowlight(common);
-     *
-     * inlineStyles(html, {
-     *   codeHighlighter: (code, language) => {
-     *     if (language && lowlight.registered(language)) {
-     *       return toHtml(lowlight.highlight(language, code));
-     *     }
-     *     return null; // no highlighting
-     *   },
-     * });
-     * ```
+     * How to preserve whitespace
      */
-    codeHighlighter?: (code: string, language: string | null) => string | null;
+    preserveWhitespace?: boolean | 'full';
 }
 /**
- * Applies inline styles to all elements in a container.
- * Exported for use in clipboardSerializer (operates on DOM directly).
- */
-declare function applyInlineStyles(container: HTMLElement, overrides?: InlineStyleOverrides): void;
-/**
- * Takes an HTML string and returns it with inline CSS styles applied
- * to all elements, so it renders correctly outside the editor.
- *
- * @param html - Serialized HTML string from editor.getHTML()
- * @param overrides - Optional style overrides for custom theming
- *
- * @example
- * ```ts
- * // Default light-theme styles
- * const styled = inlineStyles(editor.getHTML());
- *
- * // With custom overrides
- * const styled = inlineStyles(editor.getHTML(), {
- *   blockquoteBorder: '5px solid red',
- *   linkColor: '#ff6600',
- * });
- * ```
- */
-declare function inlineStyles(html: string, overrides?: InlineStyleOverrides): string;
-
-/**
- * Editor - Main editor class wrapping ProseMirror
- *
- * Manages extensions, schema, commands, and the ProseMirror EditorView/State.
- */
-
-/**
- * Main editor class
- *
- * Wraps ProseMirror's EditorView and EditorState with a cleaner API.
- *
- * @example
- * ```ts
- * import { Editor } from '@domternal/core';
- * import { Schema } from '@domternal/pm/model';
- *
- * const schema = new Schema({
- *   nodes: { doc: { content: 'paragraph+' }, paragraph: { content: 'text*' }, text: {} }
- * });
- *
- * const editor = new Editor({
- *   schema,
- *   element: document.getElementById('editor'),
- *   content: '<p>Hello world</p>',
- * });
- *
- * // Get content
- * const json = editor.getJSON();
- * const html = editor.getHTML();
- *
- * // Set content
- * editor.commands.setContent('<p>New content</p>');
- *
- * // Cleanup
- * editor.destroy();
- * ```
+ * Props passed to renderHTML function
  */
-declare class Editor extends EventEmitter<EditorEvents> {
-    /**
-     * Editor configuration options
-     */
-    private options;
-    /**
-     * Manages extensions and schema
-     * @internal Exposed for CommandManager, not for public use
-     */
-    private _extensionManager;
+interface NodeRenderHTMLProps {
     /**
-     * Gets the extension manager
-     * @internal For CommandManager use only
+     * The ProseMirror node being rendered
      */
-    get extensionManager(): ExtensionManager;
+    node: Node$1;
     /**
-     * Manages commands
+     * Merged HTML attributes from all sources
      */
-    private commandManager;
+    HTMLAttributes: Record<string, unknown>;
+}
+/**
+ * Node-specific configuration properties (schema-related)
+ */
+interface NodeSchemaProperties {
     /**
-     * ProseMirror EditorView instance
+     * Node group(s) this node belongs to
+     * Used in content expressions
+     *
+     * @example 'block', 'inline', 'block list'
+     * Can be a function that returns the group string (useful for dynamic group based on options)
      */
-    view: EditorView;
+    group?: string | (() => string);
     /**
-     * Whether the editor has been destroyed
+     * Content expression defining allowed children
+     * Uses ProseMirror content expression syntax
+     *
+     * @example 'inline*', 'block+', 'paragraph block*'
      */
-    private _isDestroyed;
+    content?: string;
     /**
-     * Timer for autofocus (cleared on destroy to prevent memory leaks)
+     * Whether this is an inline node
+     * Can be a function for dynamic inline based on options
+     * @default false
      */
-    private _autofocusTimer;
+    inline?: boolean | (() => boolean);
     /**
-     * Creates a new Editor instance
+     * Whether this node is an atom (no direct content editing)
+     * Cursor moves around atoms, not into them
      *
-     * @param options - Editor configuration
-     * @throws Error if running in SSR environment (no window)
-     * @throws Error if schema is not provided
+     * @example true for images, mentions, emoji
      */
-    constructor(options: EditorOptions);
+    atom?: boolean;
     /**
-     * Gets the current EditorState
+     * Whether the node can be selected as a whole
+     * @default true for leaf nodes, false for others
      */
-    get state(): EditorState;
+    selectable?: boolean;
     /**
-     * Gets the ProseMirror schema
+     * Whether the node can be dragged
+     * @default false
      */
-    get schema(): Schema;
+    draggable?: boolean;
     /**
-     * Checks if the editor is editable
+     * Whether this node represents code
+     * Affects text input handling (disables smart quotes, etc.)
      */
-    get isEditable(): boolean;
+    code?: boolean;
     /**
-     * Checks if the editor content is empty
+     * How whitespace is handled in this node
+     * - 'pre': preserve whitespace (like <pre>)
+     * - 'normal': collapse whitespace (default)
      */
-    get isEmpty(): boolean;
+    whitespace?: 'pre' | 'normal';
     /**
-     * Checks if the editor has focus
+     * Whether this node isolates marks at its boundaries
+     * Marks don't extend across isolating boundaries
      */
-    get isFocused(): boolean;
+    isolating?: boolean;
     /**
-     * Checks if the editor has been destroyed
+     * Whether a gap cursor is allowed inside this node.
+     * Set to false to prevent gapcursor from appearing inside this node.
+     * Set to true to force gapcursor even if the default heuristic disallows it.
+     * When undefined, uses ProseMirror's default heuristic.
      */
-    get isDestroyed(): boolean;
+    allowGapCursor?: boolean;
     /**
-     * Gets single commands for immediate execution
-     * @example editor.commands.focus('end')
+     * Table role for prosemirror-tables integration.
+     * Nodes with a tableRole are discovered by prosemirror-tables via spec.tableRole.
+     * One of: 'table', 'row', 'cell', 'header_cell'
      */
-    get commands(): SingleCommands;
+    tableRole?: 'table' | 'row' | 'cell' | 'header_cell';
     /**
-     * Creates a command chain for batched execution
-     * @example editor.chain().focus().insertText('Hello').run()
+     * Whether this is a top-level node (document root)
+     * Only one node should have this set to true
      */
-    chain(): ChainedCommands;
+    topNode?: boolean;
     /**
-     * Checks if commands can be executed (dry-run)
-     * @example if (editor.can().toggleBold()) { ... }
+     * Whether this node defines its own scope
+     * Content and marks don't leak out of defining nodes
      */
-    can(): CanCommands;
+    defining?: boolean;
     /**
-     * Gets extension storage
-     * Access via: editor.storage.extensionName.propertyName
+     * Which marks are allowed in this node
+     * Empty string means no marks allowed
+     *
+     * @example '', '_', 'bold italic'
      */
-    get storage(): Record<string, unknown>;
+    marks?: string;
     /**
-     * Gets toolbar items registered by all extensions.
-     * Used by framework toolbar components to auto-generate UI.
+     * Custom text for leaf nodes returned by `getText()` / `textContent`.
+     *
+     * @example '\n' for hard break
      */
-    get toolbarItems(): ToolbarItem[];
+    leafText?: string | ((node: Node$1) => string);
     /**
-     * Checks if a node or mark is currently active
-     *
-     * For toolbar button states - returns true if:
-     * - For marks: the current selection has the mark applied
-     * - For nodes: the cursor is inside that node type
-     *
-     * @param nameOrAttributes - Extension name, or object with name and attributes
-     * @param attributes - Optional attributes to match (for node/mark specific states)
+     * Define node attributes
+     * Returns attribute specifications
      *
      * @example
-     * editor.isActive('bold') // → true if bold mark is active
-     * editor.isActive('heading', { level: 2 }) // → true if in h2
-     * editor.isActive({ name: 'textAlign', attributes: { align: 'center' } })
+     * addAttributes() {
+     *   return {
+     *     level: { default: 1 },
+     *   };
+     * }
      */
-    isActive(nameOrAttributes: string | {
-        name: string;
-        attributes?: Record<string, unknown>;
-    }, attributes?: Record<string, unknown>): boolean;
+    addAttributes?: () => AttributeSpecs;
     /**
-     * Gets attributes of the currently active node or mark
-     *
-     * Returns empty object if the node/mark is not found or not active.
+     * Parse rules for converting HTML to this node
+     * Each rule defines how to match and parse HTML elements
      *
-     * @param name - Extension name (node or mark)
+     * @example
+     * parseHTML() {
+     *   return [
+     *     { tag: 'p' },
+     *     { tag: 'div', priority: 10 },
+     *   ];
+     * }
+     */
+    parseHTML?: () => NodeParseRule[];
+    /**
+     * Render this node to DOM
+     * Returns DOMOutputSpec (tag, attributes, children)
      *
      * @example
-     * editor.getAttributes('heading') // → { level: 2 }
-     * editor.getAttributes('link') // → { href: 'https://...', target: '_blank' }
+     * renderHTML({ node, HTMLAttributes }) {
+     *   return ['p', HTMLAttributes, 0];
+     * }
      */
-    getAttributes(name: string): Record<string, unknown>;
+    renderHTML?: (props: NodeRenderHTMLProps) => DOMOutputSpec;
     /**
-     * Helper to match attributes
-     * Returns true if target contains all key/value pairs from source
+     * Custom node view constructor
+     * For complex interactive nodes
      */
-    private matchAttributes;
+    addNodeView?: () => NodeViewConstructor;
     /**
-     * Gets the document content as JSON
+     * Additional ProseMirror plugins for this node
+     * Called during plugin collection
      */
-    getJSON(): JSONContent;
+    addProseMirrorPlugins?: () => Plugin[];
+}
+/**
+ * Configuration for Node extensions
+ * Combines ExtensionConfig base with node-specific schema properties.
+ * Uses ThisType<NodeContext> to provide proper typing for `this` in config methods.
+ *
+ * @typeParam Options - Node options type
+ * @typeParam Storage - Node storage type
+ *
+ * @example
+ * const Paragraph = Node.create({
+ *   name: 'paragraph',
+ *   group: 'block',
+ *   content: 'inline*',
+ *   parseHTML() {
+ *     // `this` is properly typed here!
+ *     return [{ tag: 'p' }];
+ *   },
+ *   renderHTML({ HTMLAttributes }) {
+ *     return ['p', HTMLAttributes, 0];
+ *   },
+ * });
+ */
+type NodeConfig<Options = unknown, Storage = unknown> = ExtensionConfigBase<Options, Storage> & NodeSchemaProperties & ThisType<NodeContext<Options, Storage>>;
+
+/**
+ * Mark configuration types
+ *
+ * These types define the configuration object passed to Mark.create()
+ * for creating ProseMirror mark extensions.
+ */
+
+/**
+ * Editor interface for Mark context
+ * Includes schema with marks for MarkType getter
+ */
+interface MarkEditorContext {
+    readonly state: EditorState;
+    readonly view: EditorView;
+    readonly schema: {
+        marks: Record<string, MarkType>;
+    };
+    readonly commands: Record<string, (...args: unknown[]) => boolean>;
+}
+/**
+ * Context interface for Mark config methods.
+ * Extends ExtensionContext with mark-specific properties.
+ * This enables proper typing of `this.options`, `this.markType`, etc.
+ *
+ * @typeParam Options - Mark options type
+ * @typeParam Storage - Mark storage type
+ */
+interface MarkContext<Options = unknown, Storage = unknown> extends Omit<ExtensionContext<Options, Storage>, 'editor' | 'type'> {
+    /** Mark type identifier */
+    readonly type: 'mark';
+    /** Editor instance with schema access */
+    editor: MarkEditorContext | null;
+    /** ProseMirror MarkType (null until editor is initialized) */
+    readonly markType: MarkType | null;
+}
+/**
+ * Parse rule for converting HTML to ProseMirror mark
+ * Simplified version of ProseMirror's ParseRule for marks
+ */
+interface MarkParseRule {
     /**
-     * Gets the document content as HTML string
-     *
-     * @param options - Optional settings
-     * @param options.styled - When true (or an override object), applies inline CSS
-     *   styles so the HTML renders correctly outside the editor (email, CMS, etc.)
+     * CSS selector or tag name to match
+     * @example 'strong', 'b', 'span.bold'
      */
-    getHTML(options?: {
-        styled?: boolean | InlineStyleOverrides;
-    }): string;
+    tag?: string;
     /**
-     * Gets the document content as plain text
-     *
-     * @param options - Options for text extraction
-     * @param options.blockSeparator - String to insert between blocks (default: '\n\n')
+     * Match by CSS style property
+     * Can include expected value after '='
+     * @example 'font-weight', 'font-weight=bold'
      */
-    getText(options?: {
-        blockSeparator?: string;
-    }): string;
+    style?: string;
     /**
-     * Executes a command with proper CommandProps
-     * @internal
+     * Priority for this rule (higher = checked first)
+     * @default 50
      */
-    private runCommand;
+    priority?: number;
     /**
-     * Sets the editor content
-     *
-     * @param content - JSON or HTML content
-     * @param emitUpdate - Whether to emit update event (default: true)
-     * @returns true if content was set successfully, false if content was invalid
+     * Whether to consume the matched element
+     * @default true
      */
-    setContent(content: Content, emitUpdate?: boolean): boolean;
+    consuming?: boolean;
     /**
-     * Clears the editor content
+     * Get attributes from the matched element
+     * Return null/undefined to skip this rule
+     * Return false to explicitly not match
      *
-     * @param emitUpdate - Whether to emit update event (default: true)
-     * @returns true if content was cleared successfully
+     * For style rules, receives the style value as string
      */
-    clearContent(emitUpdate?: boolean): boolean;
+    getAttrs?: ((node: HTMLElement | string) => Record<string, unknown> | false | null) | null;
+}
+/**
+ * Props passed to renderHTML function for marks
+ */
+interface MarkRenderHTMLProps {
     /**
-     * Sets whether the editor is editable
-     *
-     * @param editable - Whether the editor should be editable
+     * The ProseMirror mark being rendered
      */
-    setEditable(editable: boolean): this;
+    mark: Mark$1;
     /**
-     * Focuses the editor
-     *
-     * @param position - Where to place cursor (default: null = just focus)
+     * Merged HTML attributes from all sources
      */
-    focus(position?: FocusPosition): this;
+    HTMLAttributes: Record<string, unknown>;
+}
+/**
+ * Mark-specific configuration properties (schema-related)
+ */
+interface MarkSchemaProperties {
     /**
-     * Removes focus from the editor
+     * Whether this mark should be active when the cursor
+     * is at its end (or beginning for marks that open).
+     *
+     * When true, typing at the mark's boundary continues the mark.
+     * When false, typing creates unmarked content.
+     *
+     * @default true
      */
-    blur(): this;
+    inclusive?: boolean | (() => boolean);
     /**
-     * Registers a ProseMirror plugin dynamically at runtime.
-     * Used by framework wrappers (e.g. Angular BubbleMenu component) to add
-     * plugins after the editor is created.
+     * Marks that this mark excludes (cannot coexist with)
+     *
+     * - '_' excludes all marks
+     * - Space-separated mark names exclude specific marks
+     * - Empty string or undefined means no exclusions
+     *
+     * @example 'code' - excludes code mark
+     * @example 'bold italic' - excludes bold and italic
+     * @example '_' - excludes all other marks
      */
-    registerPlugin(plugin: Plugin): void;
+    excludes?: string;
     /**
-     * Unregisters a ProseMirror plugin by its PluginKey.
-     * Uses PluginKey.get() to identify the plugin to remove.
+     * Mark group(s) this mark belongs to
+     * Used in node's marks property
+     *
+     * @example 'formatting', 'inline'
      */
-    unregisterPlugin(key: PluginKey): void;
+    group?: string;
     /**
-     * Destroys the editor and cleans up resources
+     * Whether this mark can span multiple nodes
      *
-     * After calling destroy(), the editor instance should not be used.
+     * When true (default), the mark persists across inline nodes.
+     * When false, the mark only applies within a single text node.
+     *
+     * @default true
      */
-    destroy(): void;
+    spanning?: boolean;
     /**
-     * Builds a clipboardSerializer that applies a transform function to HTML on copy/cut.
+     * Whether this mark represents visual formatting.
+     *
+     * Used by `unsetAllMarks` to decide which marks to remove.
+     * Marks with `isFormatting: false` survive clear formatting
+     * (e.g., links, comments, annotations).
+     *
+     * Can be overridden via `.configure()`:
+     * ```ts
+     * Link.configure({ isFormatting: true }) // make links clearable
+     * ```
+     *
+     * @default true
      */
-    private buildClipboardSerializer;
+    isFormatting?: boolean;
     /**
-     * Creates the editor instance
+     * Define mark attributes
+     * Returns attribute specifications
+     *
+     * @example
+     * addAttributes() {
+     *   return {
+     *     color: { default: null },
+     *   };
+     * }
      */
-    private createEditor;
+    addAttributes?: () => AttributeSpecs;
     /**
-     * Handles ProseMirror transactions
+     * Parse rules for converting HTML to this mark
+     * Each rule defines how to match and parse HTML elements
+     *
+     * @example
+     * parseHTML() {
+     *   return [
+     *     { tag: 'strong' },
+     *     { tag: 'b' },
+     *     { style: 'font-weight', getAttrs: (value) => /bold|[5-9]\d{2}/.test(value) && null },
+     *   ];
+     * }
      */
-    private dispatchTransaction;
+    parseHTML?: () => MarkParseRule[];
     /**
-     * Emit method - needed for CommandManager interface
+     * Render this mark to DOM
+     * Returns DOMOutputSpec (tag, attributes, hole)
+     *
+     * The 0 in the return array indicates where child content goes.
+     *
+     * @example
+     * renderHTML({ mark, HTMLAttributes }) {
+     *   return ['strong', HTMLAttributes, 0];
+     * }
      */
-    emit<E extends keyof EditorEvents>(event: E, ...args: EditorEvents[E] extends undefined ? [] : [EditorEvents[E]]): this;
+    renderHTML?: (props: MarkRenderHTMLProps) => DOMOutputSpec;
 }
+/**
+ * Configuration for Mark extensions
+ * Combines ExtensionConfigBase with mark-specific schema properties.
+ * Uses ThisType<MarkContext> to provide proper typing for `this` in config methods.
+ *
+ * @typeParam Options - Mark options type
+ * @typeParam Storage - Mark storage type
+ *
+ * @example
+ * const Bold = Mark.create({
+ *   name: 'bold',
+ *   parseHTML() {
+ *     // `this` is properly typed here!
+ *     return [{ tag: 'strong' }, { tag: 'b' }];
+ *   },
+ *   renderHTML({ HTMLAttributes }) {
+ *     return ['strong', HTMLAttributes, 0];
+ *   },
+ * });
+ */
+type MarkConfig<Options = unknown, Storage = unknown> = ExtensionConfigBase<Options, Storage> & MarkSchemaProperties & ThisType<MarkContext<Options, Storage>>;
 
 /**
  * Focus command - focuses the editor at the specified position
@@ -2092,30 +2208,30 @@ declare class Editor extends EventEmitter<EditorEvents> {
  *   - number: Specific position
  *   - null/false: Just focus without changing selection
  */
-declare const focus: CommandSpec$1<[position?: FocusPosition]>;
+declare const focus: CommandSpec<[position?: FocusPosition]>;
 /**
  * Blur command - removes focus from the editor
  */
-declare const blur: CommandSpec$1;
+declare const blur: CommandSpec;
 /**
  * SelectAll command - selects all content in the editor
  *
  * Uses AllSelection to select the entire document.
  * Uses tr.doc to support chain context.
  */
-declare const selectAll: CommandSpec$1;
+declare const selectAll: CommandSpec;
 /**
  * SelectNodeBackward command - selects the node before the cursor
  *
  * When the cursor is at the start of a textblock, this selects the node before it.
  */
-declare const selectNodeBackward: CommandSpec$1;
+declare const selectNodeBackward: CommandSpec;
 /**
  * DeleteSelection command - deletes the current selection
  *
  * Uses tr.selection to support chain context.
  */
-declare const deleteSelection: CommandSpec$1;
+declare const deleteSelection: CommandSpec;
 
 /**
  * Options for setContent command
@@ -2147,28 +2263,28 @@ interface ClearContentOptions {
  * @param content - JSON or HTML content
  * @param options - Options for setting content
  */
-declare const setContent: CommandSpec$1<[content: Content, options?: SetContentOptions]>;
+declare const setContent: CommandSpec<[content: Content, options?: SetContentOptions]>;
 /**
  * ClearContent command - clears the editor content to empty state
  *
  * @param options - Options for clearing content
  */
-declare const clearContent: CommandSpec$1<[options?: ClearContentOptions]>;
+declare const clearContent: CommandSpec<[options?: ClearContentOptions]>;
 /**
  * InsertText command - inserts text at the current selection
  *
  * @param text - Text to insert
  */
-declare const insertText: CommandSpec$1<[text: string]>;
+declare const insertText: CommandSpec<[text: string]>;
 /**
  * InsertContent command - inserts content at the current selection
  *
  * @param content - The content to insert (JSON object, array, or HTML string)
  */
-declare const insertContent: CommandSpec$1<[content: Content]>;
+declare const insertContent: CommandSpec<[content: Content]>;
 
 /**
- * Mark commands — toggleMark, setMark, unsetMark, unsetAllMarks
+ * Mark commands - toggleMark, setMark, unsetMark, unsetAllMarks
  */
 
 /**
@@ -2181,20 +2297,20 @@ declare const insertContent: CommandSpec$1<[content: Content]>;
  * @param markName - The name of the mark to toggle
  * @param attributes - Optional attributes for the mark
  */
-declare const toggleMark: CommandSpec$1<[markName: string, attributes?: Attrs]>;
+declare const toggleMark: CommandSpec<[markName: string, attributes?: Attrs]>;
 /**
  * SetMark command - adds a mark to the current selection
  *
  * @param markName - The name of the mark to set
  * @param attributes - Optional attributes for the mark
  */
-declare const setMark: CommandSpec$1<[markName: string, attributes?: Attrs]>;
+declare const setMark: CommandSpec<[markName: string, attributes?: Attrs]>;
 /**
  * UnsetMark command - removes a mark from the current selection
  *
  * @param markName - The name of the mark to remove
  */
-declare const unsetMark: CommandSpec$1<[markName: string]>;
+declare const unsetMark: CommandSpec<[markName: string]>;
 /**
  * UnsetAllMarks command - removes all formatting marks from the current selection
  *
@@ -2204,7 +2320,7 @@ declare const unsetMark: CommandSpec$1<[markName: string]>;
  *
  * Returns false for empty selections (no range to clear).
  */
-declare const unsetAllMarks: CommandSpec$1;
+declare const unsetAllMarks: CommandSpec;
 
 /**
  * SetBlockType command - changes the block type of the selection
@@ -2216,7 +2332,7 @@ declare const unsetAllMarks: CommandSpec$1;
  * @param nodeName - The name of the node type to set
  * @param attributes - Optional attributes for the node
  */
-declare const setBlockType: CommandSpec$1<[nodeName: string, attributes?: Attrs]>;
+declare const setBlockType: CommandSpec<[nodeName: string, attributes?: Attrs]>;
 /**
  * ToggleBlockType command - toggles between a block type and a default type
  *
@@ -2228,7 +2344,7 @@ declare const setBlockType: CommandSpec$1<[nodeName: string, attributes?: Attrs]
  * @param defaultNodeName - The name of the default node type (usually 'paragraph')
  * @param attributes - Optional attributes for the node
  */
-declare const toggleBlockType: CommandSpec$1<[nodeName: string, defaultNodeName: string, attributes?: Attrs]>;
+declare const toggleBlockType: CommandSpec<[nodeName: string, defaultNodeName: string, attributes?: Attrs]>;
 /**
  * WrapIn command - wraps the selection in a node type
  *
@@ -2237,7 +2353,7 @@ declare const toggleBlockType: CommandSpec$1<[nodeName: string, defaultNodeName:
  * @param nodeName - The name of the wrapping node type
  * @param attributes - Optional attributes for the node
  */
-declare const wrapIn: CommandSpec$1<[nodeName: string, attributes?: Attrs]>;
+declare const wrapIn: CommandSpec<[nodeName: string, attributes?: Attrs]>;
 /**
  * ToggleWrap command - toggles wrapping of the selection in a node type
  *
@@ -2248,14 +2364,14 @@ declare const wrapIn: CommandSpec$1<[nodeName: string, attributes?: Attrs]>;
  * @param nodeName - The name of the wrapping node type
  * @param attributes - Optional attributes for the node
  */
-declare const toggleWrap: CommandSpec$1<[nodeName: string, attributes?: Attrs]>;
+declare const toggleWrap: CommandSpec<[nodeName: string, attributes?: Attrs]>;
 /**
  * Lift command - lifts the current block out of its parent wrapper
  *
  * Uses tr.doc/tr.selection for chain compatibility.
  * For example, lifts a paragraph out of a blockquote.
  */
-declare const lift: CommandSpec$1;
+declare const lift: CommandSpec;
 
 /**
  * ToggleList command - toggles a list type on the current selection
@@ -2268,10 +2384,10 @@ declare const lift: CommandSpec$1;
  * @param listItemNodeName - The name of the list item node type (usually 'listItem')
  * @param attributes - Optional attributes for the list node
  */
-declare const toggleList: CommandSpec$1<[listNodeName: string, listItemNodeName: string, attributes?: Attrs]>;
+declare const toggleList: CommandSpec<[listNodeName: string, listItemNodeName: string, attributes?: Attrs]>;
 
 /**
- * Attribute commands — updateAttributes, resetAttributes
+ * Attribute commands - updateAttributes, resetAttributes
  */
 
 /**
@@ -2282,7 +2398,7 @@ declare const toggleList: CommandSpec$1<[listNodeName: string, listItemNodeName:
  * @param typeOrName - The node type name or NodeType to update
  * @param attributes - The attributes to merge into existing attributes
  */
-declare const updateAttributes: CommandSpec$1<[typeOrName: string, attributes: Record<string, unknown>]>;
+declare const updateAttributes: CommandSpec<[typeOrName: string, attributes: Record<string, unknown>]>;
 /**
  * ResetAttributes command - resets an attribute to its default value
  *
@@ -2292,7 +2408,7 @@ declare const updateAttributes: CommandSpec$1<[typeOrName: string, attributes: R
  * @param typeOrName - The node type name to update
  * @param attributeName - The name of the attribute to reset
  */
-declare const resetAttributes: CommandSpec$1<[typeOrName: string, attributeName: string]>;
+declare const resetAttributes: CommandSpec<[typeOrName: string, attributeName: string]>;
 
 /**
  * Built-in commands for @domternal/core
@@ -2370,8 +2486,8 @@ declare class CommandManager {
      */
     private buildCommandProps;
     /**
-     * Single commands that execute immediately
-     * Uses Proxy to dynamically generate command methods (ID-1)
+     * Single commands that execute immediately.
+     * Uses a Proxy to dynamically generate command methods.
      *
      * @example
      * editor.commands.focus('end');
@@ -2430,61 +2546,252 @@ interface PositionFloatingOptions {
     trackScroll?: boolean;
 }
 /**
- * Positions a floating element relative to a reference element or virtual rect,
- * and keeps it positioned on scroll, resize, and layout shifts.
- *
- * Uses `autoUpdate` from floating-ui with `animationFrame` polling for
- * jitter-free scroll tracking (rAF syncs with browser paint).
- *
- * Includes `hide` middleware — when the reference element is scrolled out of
- * view, the floating element is hidden via `visibility: hidden`.
- *
- * The floating element must have `position: fixed`.
- *
- * Returns a cleanup function. **Always call it** when hiding or destroying
- * the floating element to stop listeners and prevent memory leaks.
- *
- * @example
- * ```ts
- * // Start auto-positioning (follows scroll/resize)
- * const cleanup = positionFloating(buttonEl, dropdownEl, {
- *   placement: 'bottom-start',
- * });
- *
- * // Virtual reference (e.g. cursor position — must return fresh coords)
- * const virtualEl = {
- *   getBoundingClientRect: () => {
- *     const coords = view.coordsAtPos(pos);
- *     return new DOMRect(coords.left, coords.top, 0, coords.bottom - coords.top);
- *   },
- * };
- * const cleanup = positionFloating(virtualEl, tooltipEl, { placement: 'top' });
+ * Positions a floating element relative to a reference element or virtual rect,
+ * and keeps it positioned on scroll, resize, and layout shifts.
+ *
+ * Uses `autoUpdate` from floating-ui with `animationFrame` polling for
+ * jitter-free scroll tracking (rAF syncs with browser paint).
+ *
+ * Includes `hide` middleware - when the reference element is scrolled out of
+ * view, the floating element is hidden via `visibility: hidden`.
+ *
+ * The floating element must have `position: fixed`.
+ *
+ * Returns a cleanup function. **Always call it** when hiding or destroying
+ * the floating element to stop listeners and prevent memory leaks.
+ *
+ * @example
+ * ```ts
+ * // Start auto-positioning (follows scroll/resize)
+ * const cleanup = positionFloating(buttonEl, dropdownEl, {
+ *   placement: 'bottom-start',
+ * });
+ *
+ * // Virtual reference (e.g. cursor position - must return fresh coords)
+ * const virtualEl = {
+ *   getBoundingClientRect: () => {
+ *     const coords = view.coordsAtPos(pos);
+ *     return new DOMRect(coords.left, coords.top, 0, coords.bottom - coords.top);
+ *   },
+ * };
+ * const cleanup = positionFloating(virtualEl, tooltipEl, { placement: 'top' });
+ *
+ * // Stop when done
+ * cleanup();
+ * ```
+ */
+declare function positionFloating(reference: Element | {
+    getBoundingClientRect: () => DOMRect;
+}, floating: HTMLElement, options?: PositionFloatingOptions): () => void;
+/**
+ * Positions a floating element using `strategy: 'absolute'` so it scrolls
+ * together with its offsetParent - zero jitter by design.
+ *
+ * Ideal for dropdowns inside scroll containers (e.g. emoji suggestion inside
+ * `.dm-editor`) and toolbar dropdowns. The absolute coordinates are stable
+ * across scrolls - only `flip`/`shift` decisions change on scroll, producing
+ * a discrete jump rather than continuous jitter.
+ *
+ * The floating element must have `position: absolute` and its offsetParent
+ * must have `position: relative`.
+ *
+ * Returns a cleanup function - call it when hiding or destroying the
+ * floating element.
+ */
+declare function positionFloatingOnce(reference: Element | {
+    getBoundingClientRect: () => DOMRect;
+}, floating: HTMLElement, options?: PositionFloatingOptions): () => void;
+
+/**
+ * Clipboard helper - writes plain text to the system clipboard.
+ *
+ * Tries the modern async Clipboard API first; if unavailable or denied
+ * (Safari private mode, insecure context, missing user gesture), falls
+ * back to a hidden textarea + `document.execCommand('copy')`.
+ *
+ * Returns `true` on success, `false` on failure. Never throws - callers
+ * decide how to surface failure (toast, re-throw, silent).
+ *
+ * @example
+ * ```ts
+ * const ok = await writeToClipboard('https://example.com#block-abc123');
+ * if (!ok) showError('Copy failed');
+ * ```
+ */
+declare function writeToClipboard(text: string): Promise<boolean>;
+
+/**
+ * Copies `dm-theme-*` classes from the editor's host element onto a
+ * floating element that lives OUTSIDE `.dm-editor` (typically portaled
+ * to `document.body` to escape `overflow: hidden`). Without the copy
+ * the `.dm-theme-dark` cascade does not reach the floating element and
+ * it renders with light-theme defaults on a dark page.
+ *
+ * Call this whenever the floating element is shown - cheap and
+ * idempotent. Removes stale theme classes from the target first so
+ * runtime theme toggles propagate on the next show.
+ */
+declare function copyThemeClass(view: {
+    dom: Element;
+}, target: Element): void;
+
+/**
+ * Default `contexts` map for a bubble menu when the consumer has not
+ * supplied one. Returns a richer item set when the editor (or any
+ * ancestor) carries the `.dm-notion-mode` class - that class is the
+ * project-wide signal that the host is rendering Notion-style UX, so
+ * the bubble menu mirrors it by including `link` and `textAlign`.
+ *
+ * Consumers can always override by passing their own `contexts` prop.
+ */
+declare function defaultBubbleContexts(editor: Editor): Record<string, string[]>;
+
+interface InsertAsListItemChildArgs {
+    /** Existing transaction to mutate. Caller dispatches. */
+    tr: Transaction;
+    /** Position of the list wrapper node (bulletList / orderedList / taskList) in `tr.doc`. */
+    wrapperPos: number;
+    /**
+     * Position of the target list item node (= position right BEFORE the
+     * item) in `tr.doc`. When omitted, the wrapper's LAST child is used,
+     * matching the Tab keyboard behaviour ("indent into last item").
+     */
+    targetItemPos?: number;
+    /** Block node to append as the LAST child of the target item. */
+    blockNode: Node$1;
+    /**
+     * Optional source range to delete in the SAME transaction (when
+     * MOVING an existing block instead of creating a new one). Position
+     * math handles source-before-vs-after-target ordering automatically.
+     */
+    sourceRange?: {
+        from: number;
+        to: number;
+    };
+}
+interface InsertAsListItemChildResult {
+    /** True when schema accepted the insertion and `tr` was mutated. */
+    ok: boolean;
+    /**
+     * Position right BEFORE the inserted block in the resulting doc.
+     * Caller can resolve `insertedAt + 1` to place the caret inside the
+     * inserted block. Only present when `ok === true`.
+     */
+    insertedAt?: number;
+}
+/**
+ * Insert `blockNode` as the LAST child of a list item (target item or, when
+ * omitted, the wrapper's last item). When `sourceRange` is set, the source
+ * range is removed in the same transaction so the op is a clean MOVE.
+ * Returns `{ ok: false }` WITHOUT mutating `tr` on schema reject so callers
+ * can fall through to a sibling-mode fallback.
+ */
+declare function insertAsListItemChild(args: InsertAsListItemChildArgs): InsertAsListItemChildResult;
+
+/**
+ * Cursor context relative to the INNERMOST containing list/task item,
+ * resolved only when the cursor's parent paragraph is a DIRECT child of
+ * that item. Innermost so nested lists hand control to the deepest item;
+ * direct-child so paragraphs inside blockquote/table-cell/etc. inside a
+ * list item fall through to the container's own Enter/Backspace.
+ */
+interface ListItemCursorContext {
+    /** Depth of the containing list item ancestor in the resolved pos. */
+    itemDepth: number;
+    /** Position right BEFORE the containing list item in the doc. */
+    itemPos: number;
+    /** Position right BEFORE the containing list wrapper (one depth above the item). */
+    wrapperPos: number;
+    /** `true` when the parent paragraph is not the first child of the list item. */
+    isInChildrenZone: boolean;
+    /** `true` when the parent paragraph has no inline content. */
+    paragraphIsEmpty: boolean;
+    /** `true` when the parent paragraph is the LAST child of the list item. */
+    isLastChild: boolean;
+    /** Index of the parent paragraph within the list item (0 = label). */
+    childIndex: number;
+    /** Index of the containing list item within its wrapper. */
+    itemIndexInWrapper: number;
+}
+/**
+ * Resolve list-item cursor context. Returns `null` when the cursor's
+ * shape does not match `(wrapper > item > paragraph)`; callers should
+ * fall through to default Enter/Backspace in that case.
+ */
+declare function getListItemCursorContext($from: ResolvedPos): ListItemCursorContext | null;
+
+/**
+ * Lift an empty children-zone paragraph out of its list/task item as a
+ * top-level sibling. PM's `liftTarget` covers the common case; we fall
+ * back to manual delete-and-insert when it returns null (empty p sandwiched
+ * before a non-paragraph would leave the after-cut half violating the
+ * `paragraph block*` schema).
+ */
+declare function liftEmptyChildrenZoneParagraph(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, ctx: ListItemCursorContext): boolean;
+
+/**
+ * Insert an empty paragraph as next sibling inside the same list/task item,
+ * keeping the cursor in the children-zone so Enter accumulates blocks at the
+ * same nesting level (Notion semantics). Exit paths are Backspace on empty,
+ * Shift+Tab, or Enter on the empty label paragraph.
+ */
+declare function insertChildrenZoneSibling(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, ctx: ListItemCursorContext): boolean;
+
+/**
+ * Activation conditions (single-cursor only):
+ *   - selection is empty (single caret)
+ *   - cursor's nearest list-item ancestor exists
+ *   - cursor's containing block is at index 0 (label slot) of that item
+ *   - `tr` has no prior steps (lift steps captured from a fresh state must
+ *     replay against the same starting state as `tr`)
+ *
+ * Returns true if the lift was applied to `tr`. The caller can keep
+ * chaining work on `tr` (e.g. `setBlockType`, `wrapIn`) on the new
+ * top-level paragraph.
+ */
+declare function liftCurrentListItem(state: EditorState, tr: Transaction): boolean;
+
+interface SplitListForInsertRange {
+    from: number;
+    to: number;
+}
+/**
+ * Activation conditions (single-cursor only):
+ *   - selection is empty
+ *   - cursor's nearest list-item ancestor exists
+ *   - cursor's containing block is at index 0 (label slot) of that item
+ *   - `tr` has no prior steps
  *
- * // Stop when done
- * cleanup();
- * ```
+ * @returns A range where the caller should call `tr.replaceWith(from, to,
+ *   [block, optionalTrailingParagraph])`, or `null` if the cursor isn't
+ *   in a list-item label.
  */
-declare function positionFloating(reference: Element | {
-    getBoundingClientRect: () => DOMRect;
-}, floating: HTMLElement, options?: PositionFloatingOptions): () => void;
+declare function splitListForInsert(state: EditorState, tr: Transaction): SplitListForInsertRange | null;
+
 /**
- * Positions a floating element using `strategy: 'absolute'` so it scrolls
- * together with its offsetParent — zero jitter by design.
- *
- * Ideal for dropdowns inside scroll containers (e.g. emoji suggestion inside
- * `.dm-editor`) and toolbar dropdowns. The absolute coordinates are stable
- * across scrolls — only `flip`/`shift` decisions change on scroll, producing
- * a discrete jump rather than continuous jitter.
- *
- * The floating element must have `position: absolute` and its offsetParent
- * must have `position: relative`.
+ * Shared helpers for locating a list/task item ancestor of a resolved
+ * position. Centralises the `LIST_ITEM_TYPE_NAMES` constant + ancestor
+ * walk so the four+ consumers (liftCurrentListItem, splitListForInsert,
+ * TaskItem keymap, Details proactive lift, slash menu filtering) stay
+ * in sync.
+ */
+
+declare const LIST_ITEM_TYPE_NAMES: Set<string>;
+/**
+ * Returns the depth at which the nearest list/task item ancestor sits,
+ * or -1 if none.
  *
- * Returns a cleanup function — call it when hiding or destroying the
- * floating element.
+ * Walks UP from `$pos.depth` toward 1 (we skip depth 0 = doc itself).
  */
-declare function positionFloatingOnce(reference: Element | {
-    getBoundingClientRect: () => DOMRect;
-}, floating: HTMLElement, options?: PositionFloatingOptions): () => void;
+declare function findListItemAncestorDepth($pos: ResolvedPos): number;
+/** Convenience: true when the cursor has a list/task item ancestor. */
+declare function isInsideListItem($pos: ResolvedPos): boolean;
+/**
+ * True when the cursor sits in the LABEL paragraph (index 0) of its
+ * nearest list/task item ancestor. Used to gate Notion-style "operate
+ * on the label" commands (slash menu CONVERT, INSERT, etc.).
+ */
+declare function isInListItemLabel($pos: ResolvedPos): boolean;
 
 /**
  * Create a ProseMirror document from content
@@ -3160,7 +3467,7 @@ declare class Extension<Options = unknown, Storage = unknown> {
      * // Shallow merge behavior with nested objects:
      * // Given: options = { nested: { a: 1, b: 2 } }
      * // configure({ nested: { b: 3 } })
-     * // Result: { nested: { b: 3 } } — 'a' is lost!
+     * // Result: { nested: { b: 3 } } - 'a' is lost!
      * // To preserve nested values, spread manually:
      * // configure({ nested: { ...original.options.nested, b: 3 } })
      */
@@ -3289,25 +3596,12 @@ declare class Node<Options = unknown, Storage = unknown> extends Extension<Optio
      */
     static create<O = unknown, S = unknown>(config: NodeConfig<O, S>): Node<O, S>;
     /**
-     * Creates a new node with merged options
-     * Original node is not modified
-     *
-     * **Note:** Options are merged shallowly using object spread (`...`).
-     * Nested objects are replaced entirely, not deeply merged.
-     *
-     * @param options - Options to merge with existing options
-     * @returns New node instance with merged options
+     * Creates a new node with merged options. Original node is not modified.
+     * Options merge shallowly (object spread); see {@link Extension.configure}
+     * for the nested-object gotcha and a workaround.
      *
      * @example
      * const CustomParagraph = Paragraph.configure({ HTMLAttributes: { class: 'custom' } });
-     *
-     * @example
-     * // Shallow merge behavior with nested objects:
-     * // Given: options = { HTMLAttributes: { class: 'a', id: 'b' } }
-     * // configure({ HTMLAttributes: { class: 'c' } })
-     * // Result: { HTMLAttributes: { class: 'c' } } — 'id' is lost!
-     * // To preserve nested values, spread manually:
-     * // configure({ HTMLAttributes: { ...original.options.HTMLAttributes, class: 'c' } })
      */
     configure(options: Partial<Options>): Node<Options, Storage>;
     /**
@@ -3351,7 +3645,7 @@ declare class Node<Options = unknown, Storage = unknown> extends Extension<Optio
 }
 
 /**
- * ToolbarController — Headless, framework-agnostic toolbar state machine
+ * ToolbarController - Headless, framework-agnostic toolbar state machine
  *
  * Manages toolbar item collection, grouping, active state tracking,
  * dropdown state, and keyboard navigation. Framework wrappers (Angular,
@@ -3359,7 +3653,7 @@ declare class Node<Options = unknown, Storage = unknown> extends Extension<Optio
  *
  * @example
  * const controller = new ToolbarController(editor, () => {
- *   // Called on every state change — trigger framework re-render
+ *   // Called on every state change - trigger framework re-render
  * });
  * controller.subscribe();
  * // ... use controller.groups, controller.activeMap, etc.
@@ -3419,7 +3713,7 @@ declare class ToolbarController {
     private _activeMap;
     /** Disabled state for each button (keyed by item.name) */
     private _disabledMap;
-    /** Expanded state for emitEvent buttons — true when their panel is open */
+    /** Expanded state for emitEvent buttons - true when their panel is open */
     private _expandedMap;
     /** Currently open dropdown name (null = none) */
     private _openDropdown;
@@ -3518,6 +3812,124 @@ declare class ToolbarController {
     private checkButtonExpanded;
 }
 
+/**
+ * A group of floating-menu items sharing the same `group` value.
+ */
+interface FloatingMenuGroup {
+    name: string;
+    items: FloatingMenuItem[];
+}
+/**
+ * Groups items by their `group` property, preserving extension insertion
+ * order of groups. Within each group, items are sorted by `priority`
+ * descending (higher first, default 100).
+ *
+ * Shared between `FloatingMenuController` (which renders grouped item lists
+ * for FloatingMenu + framework wrappers) and `createSlashSuggestionRenderer`
+ * (the popup shown by SlashCommand). Having one implementation keeps visual
+ * grouping consistent across every trigger mechanism.
+ */
+declare function groupFloatingMenuItems(items: FloatingMenuItem[]): FloatingMenuGroup[];
+
+/**
+ * FloatingMenuController - Headless, framework-agnostic state machine for the
+ * block-insert floating menu.
+ *
+ * Mirrors the shape of ToolbarController: collects items from extensions,
+ * groups them, tracks focused index for roving-tabindex keyboard navigation,
+ * and executes commands. Framework wrappers (Angular, React, Vue) bind their
+ * templates to this controller.
+ *
+ * @example
+ * const controller = new FloatingMenuController(editor, () => {
+ *   // onChange - re-render
+ * });
+ * controller.subscribe();
+ * // ... controller.groups, controller.focusedIndex, controller.execute(item)
+ * controller.destroy();
+ */
+
+/** -1 means no item is focused (menu not entered via keyboard). */
+declare const FLOATING_MENU_NO_FOCUS = -1;
+declare class FloatingMenuController {
+    /**
+     * Resolves an `items` option (array | function) against the editor's
+     * default floating-menu items. Exposed as static so the plugin can
+     * resolve once at init without constructing a controller.
+     */
+    static resolveItems(editor: Editor, override?: FloatingMenuItemsOverride): FloatingMenuItem[];
+    /**
+     * Executes a floating-menu item's command on the editor.
+     * String commands are dispatched via `editor.commands[name](...args)`;
+     * function commands are called directly.
+     */
+    static executeItem(editor: Editor, item: FloatingMenuItem): void;
+    private editor;
+    private onChange;
+    private override;
+    private transactionHandler;
+    private _groups;
+    private _flatItems;
+    private _disabledMap;
+    private _focusedIndex;
+    constructor(editor: Editor, onChange: () => void, override?: FloatingMenuItemsOverride);
+    get groups(): FloatingMenuGroup[];
+    get flatItems(): FloatingMenuItem[];
+    get disabledMap(): ReadonlyMap<string, boolean>;
+    get focusedIndex(): number;
+    /** True when keyboard focus is inside the menu (at least one item focused). */
+    get isEntered(): boolean;
+    get itemCount(): number;
+    isDisabled(item: FloatingMenuItem): boolean;
+    /**
+     * Executes an item's command, then closes the menu keyboard focus.
+     * Callers should refocus the editor after calling this.
+     */
+    execute(item: FloatingMenuItem): void;
+    /**
+     * Rebuilds items from the editor. Call when the editor's extensions
+     * change (rare) or on explicit refresh. Notification is delegated to
+     * `updateDisabledStates` which fires `onChange` only when a disabled
+     * state flipped - wrappers that need to react to pure group-structure
+     * changes do so by bumping their own render signal after constructing
+     * / re-using the controller (see framework wrapper usage).
+     */
+    rebuild(): void;
+    /** Enter keyboard focus on the menu (first item). Called by the plugin's keymap. */
+    enterMenu(): number;
+    /** Leave keyboard focus (Escape). Refocus of the editor is the caller's job. */
+    leaveMenu(): void;
+    /** ArrowDown - wrap to first at end. */
+    next(): number;
+    /** ArrowUp - wrap to last at start. */
+    prev(): number;
+    first(): number;
+    last(): number;
+    /** Set focused index directly (e.g. on pointer hover). */
+    setFocusedIndex(index: number): void;
+    /** Get focused item (or null). */
+    focusedItem(): FloatingMenuItem | null;
+    /** Get flat index of item by name (for wrappers binding roving tabindex). */
+    getFlatIndex(name: string): number;
+    /** Subscribes to editor transactions for disabled-state tracking. */
+    subscribe(): void;
+    /** Unsubscribes and clears internal state. */
+    destroy(): void;
+    /**
+     * Groups items by `group` preserving insertion order, then sorts by
+     * priority (higher first) within each group. Delegates to the shared
+     * utility so `SlashCommand`'s renderer and this controller always
+     * produce identical ordering.
+     */
+    private groupItems;
+    /**
+     * Updates disabled state for each item. Uses custom predicate when
+     * provided; otherwise tries a dry-run against `editor.can()[command]`.
+     * Only notifies on change to avoid noisy re-renders.
+     */
+    private updateDisabledStates;
+}
+
 declare const defaultIcons: IconSet;
 
 /**
@@ -3619,25 +4031,12 @@ declare class Mark<Options = unknown, Storage = unknown> extends Extension<Optio
      */
     static create<O = unknown, S = unknown>(config: MarkConfig<O, S>): Mark<O, S>;
     /**
-     * Creates a new mark with merged options
-     * Original mark is not modified
-     *
-     * **Note:** Options are merged shallowly using object spread (`...`).
-     * Nested objects are replaced entirely, not deeply merged.
-     *
-     * @param options - Options to merge with existing options
-     * @returns New mark instance with merged options
+     * Creates a new mark with merged options. Original mark is not modified.
+     * Options merge shallowly (object spread); see {@link Extension.configure}
+     * for the nested-object gotcha and a workaround.
      *
      * @example
      * const CustomBold = Bold.configure({ HTMLAttributes: { class: 'custom-bold' } });
-     *
-     * @example
-     * // Shallow merge behavior with nested objects:
-     * // Given: options = { HTMLAttributes: { class: 'a', id: 'b' } }
-     * // configure({ HTMLAttributes: { class: 'c' } })
-     * // Result: { HTMLAttributes: { class: 'c' } } — 'id' is lost!
-     * // To preserve nested values, spread manually:
-     * // configure({ HTMLAttributes: { ...original.options.HTMLAttributes, class: 'c' } })
      */
     configure(options: Partial<Options> & {
         isFormatting?: boolean;
@@ -4086,14 +4485,19 @@ interface OrderedListOptions {
 declare const OrderedList: Node<OrderedListOptions, unknown>;
 
 /**
- * ListItem Node
+ * Enter / Backspace state machine for listItem (cursor's parent must be a paragraph):
  *
- * Individual list item that can contain paragraphs and nested blocks.
- * Used by BulletList and OrderedList.
+ *  LABEL paragraph (childIndex 0):
+ *    Enter, empty     -> liftListItem (exit empty bullet)
+ *    Enter, non-empty -> splitListItem (new sibling listItem)
+ *    Backspace, empty -> falls through to ListKeymap (liftListItem)
  *
- * Keyboard shortcuts:
- * - Enter: Split list item at cursor, or lift out of list if item is empty
- * - Tab/Shift-Tab: Handled by ListKeymap extension (included via addExtensions)
+ *  CHILDREN-ZONE paragraph (childIndex > 0):
+ *    Enter, empty     -> insertChildrenZoneSibling (accumulate inside the item)
+ *    Enter, non-empty -> splitBlock (both halves stay inside the same item)
+ *    Backspace, empty -> liftEmptyChildrenZoneParagraph (exit as top-level)
+ *
+ * Tab / Shift-Tab handled by the ListKeymap extension.
  */
 
 interface ListItemOptions {
@@ -4155,17 +4559,21 @@ interface TaskListOptions {
 declare const TaskList: Node<TaskListOptions, unknown>;
 
 /**
- * TaskItem Node
+ * Enter / Backspace state machine for taskItem (cursor's parent must be a paragraph):
  *
- * Individual task/checkbox item that can contain paragraphs and nested blocks.
- * Used by TaskList.
+ *  LABEL paragraph (childIndex 0):
+ *    Enter, empty     -> splitListItem fall-through, then taskItem-in-listItem
+ *                        promotion (nested orderedList > listItem > taskList > taskItem
+ *                        context), else liftListItem.
+ *    Enter, non-empty -> splitListItem (new sibling taskItem)
+ *    Backspace, empty -> liftListItem (exit empty checkbox)
  *
- * Keyboard shortcuts:
- * - Enter: Split task item at cursor
- * - Tab: Sink (indent) task item
- * - Shift-Tab: Lift (outdent) task item
- * - Backspace: Lift task item when at start of empty-ish item (converts to paragraph)
- * - Mod-Enter: Toggle task checked state
+ *  CHILDREN-ZONE paragraph (childIndex > 0):
+ *    Enter, empty     -> insertChildrenZoneSibling (accumulate inside the item)
+ *    Enter, non-empty -> splitBlock (both halves stay inside the same item)
+ *    Backspace, empty -> liftEmptyChildrenZoneParagraph (exit as top-level)
+ *
+ * Tab / Shift-Tab sink / lift the item; Mod-Enter toggles checked state.
  */
 
 declare module '@domternal/core' {
@@ -4376,9 +4784,6 @@ declare module '@domternal/core' {
     }
 }
 
-/**
- * Options for the Link mark
- */
 interface LinkOptions {
     /**
      * HTML attributes to add to the rendered element
@@ -4882,6 +5287,61 @@ interface ListKeymapOptions {
 }
 declare const ListKeymap: Extension<ListKeymapOptions, unknown>;
 
+/**
+ * Keyboard indent across list boundaries. `Tab` on a top-level block whose
+ * previous sibling is a list moves the block INTO the last item as a nested
+ * child; `Shift-Tab` reverses for a block sitting as the last child of the
+ * last item.
+ *
+ * Trigger is intentionally narrow so ListKeymap retains in-list Tab/Shift-Tab
+ * (`sinkListItem` / `liftListItem`). Schema is validated via `canReplaceWith`;
+ * invalid placements are a clean no-op so the keymap chain falls through.
+ *
+ * Intentional design restrictions (NOT bugs to "fix"):
+ *  - Tab indents into the IMMEDIATE last item only, not recursively into a
+ *    deeper "deepest last item". Users get deeper nesting via repeated Tab
+ *    inside the now-nested context (then ListKeymap takes over).
+ *  - Tab only fires for cursors in TOP-LEVEL blocks (depth === 1). Cursors
+ *    inside other containers (blockquote, table cell) fall through.
+ *  - Shift-Tab only fires when the block is BOTH the last child of its
+ *    item AND the item is the last in its wrapper. Mid-position outdent
+ *    would require splitting the list item, which is deferred.
+ *
+ * Registration order: must come AFTER ListKeymap so this extension's keymap
+ * runs FIRST and can defer to ListKeymap for in-list flows.
+ */
+
+/**
+ * `Tab` handler: indent a top-level block as the last child of the
+ * last item of the immediately-preceding list wrapper. Returns true
+ * when the operation succeeded (and dispatched, if `dispatch` is
+ * provided), false when any precondition fails so the keymap chain
+ * can fall through to the next handler.
+ */
+declare function indentBlockAsListChild(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
+/**
+ * `Shift-Tab` handler: lift a non-label nested block out of its list
+ * item to become a top-level sibling AFTER the list wrapper. Only
+ * fires for the strict end-of-end case (last child of last item) so
+ * the lift is deterministic and never needs to split a list item.
+ *
+ * Precondition table:
+ *   - cursor empty
+ *   - cursor textblock parent is NOT a paragraph (so we never
+ *     accidentally outdent the label; ListKeymap.Shift-Tab handles
+ *     in-label cases via liftListItem)
+ *   - the cursor's enclosing list item exists in the ancestry
+ *   - the cursor's containing block is a DIRECT child of the list
+ *     item (depth = listItemDepth + 1) - keeps the math local to
+ *     immediate li children rather than reaching deeper into nested
+ *     containers
+ *   - the block is the LAST child of the list item
+ *   - the list item is the LAST child of its wrapper
+ *   - the wrapper's parent accepts the block as a sibling (schema)
+ */
+declare function outdentBlockFromListItem(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
+declare const ListIndent: Extension<unknown, unknown>;
+
 /**
  * CharacterCount Extension
  *
@@ -5113,25 +5573,8 @@ interface LineHeightOptions {
 declare const LineHeight: Extension<LineHeightOptions, unknown>;
 
 /**
- * UniqueID Extension
- *
- * Automatically assigns unique IDs to specified node types.
- * Useful for collaborative editing, linking, and history tracking.
- *
- * @example
- * ```ts
- * import { UniqueID } from '@domternal/core';
- *
- * const editor = new Editor({
- *   extensions: [
- *     // ... other extensions
- *     UniqueID.configure({
- *       types: ['paragraph', 'heading'],
- *       attributeName: 'id',
- *     }),
- *   ],
- * });
- * ```
+ * Canonical block-id system. Assigns ids to configured node types and is
+ * read by TableOfContents and BlockContextMenu.
  */
 
 declare const uniqueIDPluginKey: PluginKey<any>;
@@ -5159,6 +5602,70 @@ interface UniqueIDOptions {
 }
 declare const UniqueID: Extension<UniqueIDOptions, unknown>;
 
+/**
+ * Tints whole blocks via `bgColor` / `textColor` attributes rendered as
+ * `data-bg-color` / `data-text-color`. Theme's `_block-colors.scss` maps
+ * names to CSS custom properties with light/dark variants. `null` clears
+ * the attribute; unknown palette names are rejected by commands.
+ */
+
+declare module '@domternal/core' {
+    interface RawCommands {
+        setBlockBgColor: CommandSpec<[color: string | null]>;
+        setBlockTextColor: CommandSpec<[color: string | null]>;
+        unsetBlockColors: CommandSpec;
+    }
+}
+/**
+ * Notion's public palette. Names are semantic (not tied to specific hex);
+ * the stylesheet owns the actual colors so themes can customize them.
+ * `'default'` is implicit - represented by `null` (no data attribute).
+ */
+declare const DEFAULT_BLOCK_COLORS: string[];
+/**
+ * Default set of block types that receive the color attributes. `codeBlock`
+ * is intentionally excluded - `<pre><code>` already has its own background
+ * that would conflict visually. Similarly, details-content blocks have
+ * their own affordance. Callers can extend via `types` option.
+ */
+declare const DEFAULT_BLOCK_COLOR_TYPES: string[];
+interface BlockColorOptions {
+    /**
+     * Node types that receive `bgColor` / `textColor` attributes.
+     * @default DEFAULT_BLOCK_COLOR_TYPES
+     */
+    types: string[];
+    /**
+     * Palette used by the `setBlockBgColor` command. Commands reject values
+     * outside this list (no-op + false return) so host apps can curate
+     * what's selectable.
+     * @default DEFAULT_BLOCK_COLORS
+     */
+    bgColors: string[];
+    /**
+     * Palette used by the `setBlockTextColor` command.
+     * @default DEFAULT_BLOCK_COLORS
+     */
+    textColors: string[];
+}
+/**
+ * Strip any inline `textStyle` marks inside [from, to] that carry the inline
+ * counterpart of a block-level color attribute. Mutates the transaction in
+ * place. This makes "last action wins": applying a block color erases
+ * conflicting inline colors so the new block tint isn't visually hidden by
+ * old span overrides.
+ *
+ * `which` may be 'text', 'bg', or 'both' - 'both' handles the unset case
+ * in a single pass so the two strip operations don't step on each other's
+ * replaced mark instances.
+ *
+ * Exported so `BlockContextMenu` (which writes node attrs directly via
+ * `setNodeMarkup` instead of going through `setBlockBgColor` /
+ * `setBlockTextColor`) shares the same conflict-stripping behavior.
+ */
+declare function stripInlineColorConflicts(tr: Transaction, state: EditorState, from: number, to: number, which: 'text' | 'bg' | 'both'): void;
+declare const BlockColor: Extension<BlockColorOptions, unknown>;
+
 /**
  * Selection Extension
  *
@@ -5237,7 +5744,7 @@ declare const Selection: Extension<SelectionOptions, SelectionStorage>;
  * clicks outside the editor (approach A - same as Google Docs / Notion).
  *
  * Toolbar and bubble-menu buttons call `event.preventDefault()` on
- * `mousedown`, so they never trigger blur — the selection stays intact
+ * `mousedown`, so they never trigger blur - the selection stays intact
  * while the user interacts with editor UI.
  */
 
@@ -5358,6 +5865,8 @@ declare module '@domternal/core' {
     interface RawCommands {
         setTextColor: CommandSpec<[color: string]>;
         unsetTextColor: CommandSpec;
+        setTextColorToken: CommandSpec<[token: string | null]>;
+        unsetTextColorToken: CommandSpec;
     }
 }
 /**
@@ -5419,6 +5928,8 @@ declare module '@domternal/core' {
         toggleHighlight: CommandSpec<[attributes?: {
             color?: string;
         }]>;
+        setBackgroundColorToken: CommandSpec<[token: string | null]>;
+        unsetBackgroundColorToken: CommandSpec;
     }
 }
 /**
@@ -5534,6 +6045,59 @@ interface FontSizeOptions {
 }
 declare const FontSize: Extension<FontSizeOptions, unknown>;
 
+/**
+ * NotionColorPicker Extension
+ *
+ * Provides toolbar registration for a Notion-style inline color picker that
+ * drives the `colorToken` / `backgroundColorToken` attributes on the textStyle
+ * mark (added by TextColor and Highlight).
+ *
+ * Owns:
+ * - The shared named-token palette (default: 9 Notion-style colors).
+ * - A bubble-menu-only toolbar item (`notionColor`) that emits a custom
+ *   `notionColorOpen` event when clicked. Framework wrappers listen for the
+ *   event and render the actual picker panel.
+ *
+ * The panel renders the full palette every time it opens; no MRU/recent
+ * tracking is kept because all 18 swatches (9 text + 9 bg) fit in one view.
+ *
+ * @example
+ * ```ts
+ * import { TextStyle, TextColor, Highlight, NotionColorPicker } from '@domternal/core';
+ *
+ * const editor = new Editor({
+ *   extensions: [
+ *     TextStyle,
+ *     TextColor,
+ *     Highlight,
+ *     NotionColorPicker,
+ *   ],
+ * });
+ * ```
+ */
+
+/**
+ * Default named tokens. Match the BlockColor palette + theme tokens
+ * (`--dm-block-text-<token>`, `--dm-block-bg-<token>`) so light and dark
+ * themes render the right hex without any extra CSS work.
+ */
+declare const DEFAULT_NOTION_COLOR_PALETTE: readonly string[];
+interface NotionColorPickerOptions {
+    /**
+     * Named tokens shown in the picker. Each token must have matching
+     * `--dm-block-text-<token>` and `--dm-block-bg-<token>` CSS variables in
+     * the active theme; tokens with no theme support render as transparent
+     * swatches.
+     * @default DEFAULT_NOTION_COLOR_PALETTE
+     */
+    palette: readonly string[];
+}
+interface NotionColorPickerStorage {
+    /** Whether the picker panel is currently open. UI sets this. */
+    isOpen: boolean;
+}
+declare const NotionColorPicker: Extension<NotionColorPickerOptions, NotionColorPickerStorage>;
+
 /**
  * ClearFormatting Extension
  *
@@ -5569,33 +6133,7 @@ interface LinkPopoverOptions {
 declare const LinkPopover: Extension<LinkPopoverOptions, unknown>;
 
 /**
- * BubbleMenu Extension
- *
- * Shows a floating menu when text is selected in the editor.
- * Useful for formatting toolbars that appear contextually.
- *
- * Styles are included automatically via `@domternal/theme` (`_bubble-menu.scss`).
- *
- * @example
- * ```ts
- * import { BubbleMenu } from '@domternal/core';
- *
- * // Create menu element
- * const menuElement = document.getElementById('bubble-menu');
- *
- * const editor = new Editor({
- *   extensions: [
- *     // ... other extensions
- *     BubbleMenu.configure({
- *       element: menuElement,
- *       shouldShow: ({ editor, state, from, to }) => {
- *         // Only show for text selections
- *         return !state.selection.empty;
- *       },
- *     }),
- *   ],
- * });
- * ```
+ * Floating menu shown when text is selected. Contextual formatting toolbar.
  */
 
 declare const bubbleMenuPluginKey: PluginKey<any>;
@@ -5649,76 +6187,6 @@ interface CreateBubbleMenuPluginOptions {
 declare function createBubbleMenuPlugin(options: CreateBubbleMenuPluginOptions): Plugin;
 declare const BubbleMenu: Extension<BubbleMenuOptions, unknown>;
 
-/**
- * FloatingMenu Extension
- *
- * Shows a floating menu when the cursor is in an empty paragraph.
- * Useful for showing block-level insertion options.
- *
- * @example
- * ```ts
- * import { FloatingMenu } from '@domternal/core';
- *
- * // Create menu element
- * const menuElement = document.getElementById('floating-menu');
- *
- * const editor = new Editor({
- *   extensions: [
- *     // ... other extensions
- *     FloatingMenu.configure({
- *       element: menuElement,
- *       shouldShow: ({ editor, state }) => {
- *         const { $from, empty } = state.selection;
- *         // Show in empty paragraphs
- *         return empty &&
- *           $from.parent.type.name === 'paragraph' &&
- *           $from.parent.content.size === 0;
- *       },
- *     }),
- *   ],
- * });
- * ```
- *
- * Styles are included automatically via `@domternal/theme` (`_floating-menu.scss`).
- */
-
-declare const floatingMenuPluginKey: PluginKey<any>;
-interface FloatingMenuOptions {
-    /**
-     * The HTML element that contains the menu.
-     * Must be provided by the user.
-     */
-    element: HTMLElement | null;
-    /**
-     * Function to determine if the menu should be shown.
-     * By default, shows when the cursor is in an empty paragraph.
-     */
-    shouldShow: (props: {
-        editor: Editor;
-        view: EditorView;
-        state: EditorState;
-    }) => boolean;
-    /**
-     * Offset in pixels from the cursor position.
-     * @default 0
-     */
-    offset: number;
-}
-interface CreateFloatingMenuPluginOptions {
-    pluginKey: PluginKey;
-    editor: Editor;
-    element: HTMLElement;
-    shouldShow?: FloatingMenuOptions['shouldShow'];
-    offset?: number;
-}
-/**
- * Creates a standalone FloatingMenu ProseMirror plugin.
- * Can be used by framework wrappers (Angular, React, Vue) to create the plugin
- * independently of the extension system.
- */
-declare function createFloatingMenuPlugin(options: CreateFloatingMenuPluginOptions): Plugin;
-declare const FloatingMenu: Extension<FloatingMenuOptions, unknown>;
-
 /**
  * StarterKit Extension
  *
@@ -5827,6 +6295,13 @@ interface StarterKitOptions {
      * Set to false to disable the ListKeymap extension, or pass options to configure it.
      */
     listKeymap?: false | Partial<ListKeymapOptions>;
+    /**
+     * Set to false to disable the ListIndent extension. ListIndent adds
+     * Tab / Shift-Tab keymap that indents a top-level block under the
+     * previous list (and outdents back). Registered AFTER ListKeymap so
+     * the in-list-item Tab/Shift-Tab keep priority.
+     */
+    listIndent?: false;
     /**
      * Set to false to disable the LinkPopover extension, or pass options to configure it.
      */
@@ -5846,4 +6321,4 @@ declare const StarterKit: Extension<StarterKitOptions, unknown>;
  */
 declare const VERSION = "0.1.0";
 
-export { type AnyExtension, type AnyExtensionConfig, type AttributeSpec, type AttributeSpecs, type AutolinkPluginOptions, BaseKeymap, type BaseKeymapOptions, Blockquote, type BlockquoteOptions, Bold, type BoldOptions, BubbleMenu, type BubbleMenuOptions, type BuildCommandPropsOptions, BulletList, type BulletListOptions, type CanChainedCommands, CanChecker, type CanCheckerEditor, type CanCheckerOptions, type CanCommands, ChainBuilder, type ChainBuilderEditor, type ChainBuilderOptions, type ChainFailure, type ChainedCommands, CharacterCount, type CharacterCountOptions, type CharacterCountStorage, type ClearContentOptions, ClearFormatting, Code, CodeBlock, type CodeBlockOptions, type CodeOptions, type Command, type CommandEditor, CommandManager, type CommandManagerEditor, type CommandMap, type CommandProps, type CommandPropsEditor, type CommandSpec$1 as CommandSpec, type Content, type ContentErrorProps, type CreateBubbleMenuPluginOptions, type CreateDocumentOptions, type CreateEventProps, type CreateFloatingMenuPluginOptions, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_TEXT_COLORS, type DeleteEventProps, Document$1 as Document, type DropEventProps, Dropcursor, type DropcursorOptions, Editor, type EditorEventName, type EditorEvents, type EditorInstance, type EditorOptions, EventEmitter, Extension, type ExtensionConfig, type ExtensionEditor, ExtensionManager, type ExtensionManagerEditor, type ExtensionManagerOptions, type FindChildResult, type FindParentNodeResult, FloatingMenu, type FloatingMenuOptions, Focus, type FocusEventProps, type FocusOptions, type FocusPosition, FontFamily, type FontFamilyOptions, FontSize, type FontSizeOptions, Gapcursor, type GenerateHTMLOptions, type GenerateJSONOptions, type GenerateTextOptions, type GlobalAttributeSpec, type GlobalAttributes, HardBreak, type HardBreakOptions, Heading, type HeadingOptions, Highlight, type HighlightOptions, History, type HistoryOptions, HorizontalRule, type HorizontalRuleOptions, type IconSet, type InlineStyleOverrides, InvisibleChars, type InvisibleCharsOptions, type InvisibleCharsStorage, type IsNodeEmptyOptions, type IsValidUrlOptions, Italic, type ItalicOptions, type JSONAttribute, type JSONContent, type JSONMark, type KeyboardShortcutCommand, LineHeight, type LineHeightOptions, Link, type LinkAttributes, type LinkClickPluginOptions, type LinkExitPluginOptions, type LinkOptions, type LinkPastePluginOptions, LinkPopover, type LinkPopoverOptions, ListItem, type ListItemOptions, ListKeymap, type ListKeymapOptions, Mark, type MarkConfig, type MarkInputRuleOptions, type MarkParseRule, type MarkRange, type MarkRenderHTMLProps, type MountEventProps, Node, type NodeConfig, type NodeInputRuleOptions, type NodeParseRule, type NodeRenderHTMLProps, type NodeViewContext, OrderedList, type OrderedListOptions, Paragraph, type ParagraphOptions, type PasteEventProps, Placeholder, type PlaceholderOptions, type PositionFloatingOptions, type Range, type RawCommands, Selection, SelectionDecoration, type SelectionDecorationOptions, type SelectionOptions, type SelectionStorage, type SetContentOptions, type SingleCommands, StarterKit, type StarterKitOptions, Strike, type StrikeOptions, Subscript, type SubscriptOptions, Superscript, type SuperscriptOptions, TaskItem, type TaskItemOptions, TaskList, type TaskListOptions, Text, TextAlign, type TextAlignOptions, TextColor, type TextColorOptions, type TextInputRuleOptions, TextStyle, type TextStyleOptions, type TextblockTypeInputRuleOptions, type ToolbarButton, ToolbarController, type ToolbarControllerEditor, type ToolbarDropdown, type ToolbarGroup, type ToolbarItem, type ToolbarLayoutDropdown, type ToolbarLayoutEntry, type ToolbarSeparator, TrailingNode, type TrailingNodeOptions, type TransactionEventProps, Typography, type TypographyOptions, Underline, type UnderlineOptions, UniqueID, type UniqueIDOptions, VERSION, type WrappingInputRuleOptions, applyInlineStyles, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, createAccumulatingDispatch, createBubbleMenuPlugin, createCanChecker, createChainBuilder, createDocument, createFloatingMenuPlugin, defaultBlockAt, defaultIcons, deleteSelection, findChildren, findParentNode, floatingMenuPluginKey, focus, focusPluginKey, generateHTML, generateJSON, generateText, getMarkRange, inlineStyles, insertContent, insertText, invisibleCharsPluginKey, isDocumentEmpty, isNodeEmpty, isValidUrl, lift, linkClickPlugin, linkClickPluginKey, linkExitPlugin, linkExitPluginKey, linkPastePlugin, linkPastePluginKey, markInputRule, markInputRulePatterns, nodeInputRule, placeholderPluginKey, positionFloating, positionFloatingOnce, resetAttributes, selectAll, selectNodeBackward, selectionDecorationPluginKey, setBlockType, setContent, setMark, textInputRule, textblockTypeInputRule, toggleBlockType, toggleList, toggleMark, toggleWrap, uniqueIDPluginKey, unsetAllMarks, unsetMark, updateAttributes, wrapIn, wrappingInputRule };
+export { type AnyExtension, type AnyExtensionConfig, type AttributeSpec, type AttributeSpecs, type AutolinkPluginOptions, BaseKeymap, type BaseKeymapOptions, BlockColor, type BlockColorOptions, Blockquote, type BlockquoteOptions, Bold, type BoldOptions, BubbleMenu, type BubbleMenuOptions, type BuildCommandPropsOptions, BulletList, type BulletListOptions, type CanChainedCommands, CanChecker, type CanCheckerEditor, type CanCheckerOptions, type CanCommands, ChainBuilder, type ChainBuilderEditor, type ChainBuilderOptions, type ChainFailure, type ChainedCommands, CharacterCount, type CharacterCountOptions, type CharacterCountStorage, type ClearContentOptions, ClearFormatting, Code, CodeBlock, type CodeBlockOptions, type CodeOptions, type Command, type CommandEditor, CommandManager, type CommandManagerEditor, type CommandMap, type CommandProps, type CommandPropsEditor, type CommandSpec, type Content, type ContentErrorProps, type CreateBubbleMenuPluginOptions, type CreateDocumentOptions, type CreateEventProps, DEFAULT_BLOCK_COLORS, DEFAULT_BLOCK_COLOR_TYPES, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_NOTION_COLOR_PALETTE, DEFAULT_TEXT_COLORS, type DeleteEventProps, Document$1 as Document, type DropEventProps, Dropcursor, type DropcursorOptions, Editor, type EditorEventName, type EditorEvents, type EditorInstance, type EditorOptions, EventEmitter, Extension, type ExtensionConfig, type ExtensionEditor, ExtensionManager, type ExtensionManagerEditor, type ExtensionManagerOptions, FLOATING_MENU_NO_FOCUS, type FindChildResult, type FindParentNodeResult, FloatingMenuController, type FloatingMenuGroup, type FloatingMenuItem, type FloatingMenuItemsOverride, Focus, type FocusEventProps, type FocusOptions, type FocusPosition, FontFamily, type FontFamilyOptions, FontSize, type FontSizeOptions, Gapcursor, type GenerateHTMLOptions, type GenerateJSONOptions, type GenerateTextOptions, type GlobalAttributeSpec, type GlobalAttributes, HardBreak, type HardBreakOptions, Heading, type HeadingOptions, Highlight, type HighlightOptions, History, type HistoryOptions, HorizontalRule, type HorizontalRuleOptions, type IconSet, type InlineStyleOverrides, type InsertAsListItemChildArgs, type InsertAsListItemChildResult, InvisibleChars, type InvisibleCharsOptions, type InvisibleCharsStorage, type IsNodeEmptyOptions, type IsValidUrlOptions, Italic, type ItalicOptions, type JSONAttribute, type JSONContent, type JSONMark, type KeyboardShortcutCommand, LIST_ITEM_TYPE_NAMES, LineHeight, type LineHeightOptions, Link, type LinkAttributes, type LinkClickPluginOptions, type LinkExitPluginOptions, type LinkOptions, type LinkPastePluginOptions, LinkPopover, type LinkPopoverOptions, ListIndent, ListItem, type ListItemCursorContext, type ListItemOptions, ListKeymap, type ListKeymapOptions, Mark, type MarkConfig, type MarkInputRuleOptions, type MarkParseRule, type MarkRange, type MarkRenderHTMLProps, type MountEventProps, Node, type NodeConfig, type NodeInputRuleOptions, type NodeParseRule, type NodeRenderHTMLProps, type NodeViewContext, NotionColorPicker, type NotionColorPickerOptions, type NotionColorPickerStorage, OrderedList, type OrderedListOptions, Paragraph, type ParagraphOptions, type PasteEventProps, Placeholder, type PlaceholderOptions, type PositionFloatingOptions, type Range, type RawCommands, Selection, SelectionDecoration, type SelectionDecorationOptions, type SelectionOptions, type SelectionStorage, type SetContentOptions, type SingleCommands, type SplitListForInsertRange, StarterKit, type StarterKitOptions, Strike, type StrikeOptions, Subscript, type SubscriptOptions, Superscript, type SuperscriptOptions, TaskItem, type TaskItemOptions, TaskList, type TaskListOptions, Text, TextAlign, type TextAlignOptions, TextColor, type TextColorOptions, type TextInputRuleOptions, TextStyle, type TextStyleOptions, type TextblockTypeInputRuleOptions, type ToolbarButton, ToolbarController, type ToolbarControllerEditor, type ToolbarDropdown, type ToolbarGroup, type ToolbarItem, type ToolbarLayoutDropdown, type ToolbarLayoutEntry, type ToolbarSeparator, TrailingNode, type TrailingNodeOptions, type TransactionEventProps, Typography, type TypographyOptions, Underline, type UnderlineOptions, UniqueID, type UniqueIDOptions, VERSION, type WrappingInputRuleOptions, applyInlineStyles, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, copyThemeClass, createAccumulatingDispatch, createBubbleMenuPlugin, createCanChecker, createChainBuilder, createDocument, defaultBlockAt, defaultBubbleContexts, defaultIcons, deleteSelection, findChildren, findListItemAncestorDepth, findParentNode, focus, focusPluginKey, generateHTML, generateJSON, generateText, getListItemCursorContext, getMarkRange, groupFloatingMenuItems, indentBlockAsListChild, inlineStyles, insertAsListItemChild, insertChildrenZoneSibling, insertContent, insertText, invisibleCharsPluginKey, isDocumentEmpty, isInListItemLabel, isInsideListItem, isNodeEmpty, isValidUrl, lift, liftCurrentListItem, liftEmptyChildrenZoneParagraph, linkClickPlugin, linkClickPluginKey, linkExitPlugin, linkExitPluginKey, linkPastePlugin, linkPastePluginKey, markInputRule, markInputRulePatterns, nodeInputRule, outdentBlockFromListItem, placeholderPluginKey, positionFloating, positionFloatingOnce, resetAttributes, selectAll, selectNodeBackward, selectionDecorationPluginKey, setBlockType, setContent, setMark, splitListForInsert, stripInlineColorConflicts, textInputRule, textblockTypeInputRule, toggleBlockType, toggleList, toggleMark, toggleWrap, uniqueIDPluginKey, unsetAllMarks, unsetMark, updateAttributes, wrapIn, wrappingInputRule, writeToClipboard };