@domternal/core 0.15.0 → 1.0.1

package/dist/index.d.ts

@@ -806,12 +806,25 @@ declare class ExtensionManager {
     /**
      * Recursively flattens extensions by expanding addExtensions()
      * This allows extension bundles like StarterKit to work
+     *
+     * `autoIncluded` collects everything that arrived through an
+     * `addExtensions()` rather than from the caller's own list, which is what
+     * lets deduplication tell a default apart from a choice.
      */
     private flattenExtensions;
     /**
-     * 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.
+     * Removes duplicate extensions by name.
+     *
+     * A version the caller listed themselves always wins over one a bundle
+     * included on their behalf, and position does not enter into it. Keeping
+     * the last occurrence alone said the same thing only while every bundle was
+     * listed first, which is the habit for StarterKit and no rule at all: an
+     * extension that includes a default and is written LOWER in the list, as
+     * `Export` and its `Print` are, silently replaced the configured copy
+     * above it and the caller's options went missing with it.
+     *
+     * Between two of the same kind the later one still wins, so two bundles
+     * offering the same default resolve as they always have.
      */
     private deduplicateExtensions;
     /**
@@ -968,8 +981,8 @@ declare class ExtensionManager {
  * 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.
+ * Uses hardcoded light-theme defaults (same approach as Google Docs or
+ * Notion). 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)
@@ -2806,12 +2819,479 @@ declare function refocusEditorAfterCommand(view: {
  * supplied one. Returns a richer item set when the editor resolves to the
  * Notion preset (the `preset` option, or the `.dm-notion-mode` class the
  * getter also honors), so the bubble menu mirrors the Notion UX by leading
- * with `ai` and including `link` and `textAlign`.
+ * with the `ai` and `comment` selection actions, then offering the block-type
+ * dropdown and `link` ahead of the formatting marks.
  *
  * Consumers can always override by passing their own `contexts` prop.
  */
 declare function defaultBubbleContexts(editor: Editor): Record<string, string[]>;
 
+/**
+ * Drop the separators that ended up with nothing to separate.
+ *
+ * A menu built from a flat list of names (`['ai', '|', 'bold', ...]`) resolves
+ * each name against the extensions the editor actually loaded, and silently
+ * skips the ones it cannot find. That is what lets one default list serve every
+ * build: an editor without the AI extension simply does not show `ai`. The
+ * separators do not take part in that, because a `|` always resolves. So the
+ * list shrinks around them and they stay, and a bar that was drawn between two
+ * groups is left leading the menu, trailing it, or standing next to another
+ * bar with nothing in between.
+ *
+ * This is the pass that finishes the job. Run it after everything that can
+ * remove an item, which includes schema filtering as well as name resolution:
+ * a separator can be orphaned by a selection whose node type does not allow
+ * the marks on one side of it, and that is decided per transaction rather than
+ * once at construction.
+ *
+ * The trailing buttons a menu appends afterwards are not visible here, so a
+ * caller that appends its own leading separator has to ask whether anything
+ * came before it. What this guarantees is the half it can: the list is empty,
+ * or it begins and ends with something that is not a separator.
+ *
+ * Written against `{ type: string }` rather than a menu's item union because
+ * every surface spells its item type differently and none of the differences
+ * matter here.
+ *
+ * A list with nothing to drop comes back as the SAME array, not a copy. React
+ * and Vue hand this straight to their state, and a fresh array every time is a
+ * re-render every time: this runs once per transaction, and pointer motion
+ * alone dispatches those. Most lists never need collapsing, so most passes
+ * cost nothing.
+ */
+declare function collapseSeparators<T extends {
+    type: string;
+}>(items: readonly T[]): T[];
+
+/**
+ * Extension - Base class for all extensions
+ *
+ * Extensions provide functionality without contributing to the schema.
+ * For schema contributions, use Node (for block/inline nodes) or Mark (for inline formatting).
+ *
+ * Three-tier model:
+ * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
+ * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
+ * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
+ *
+ * @example
+ * const History = Extension.create({
+ *   name: 'history',
+ *   addOptions() {
+ *     return { depth: 100 };
+ *   },
+ *   addKeyboardShortcuts() {
+ *     return {
+ *       'Mod-z': () => this.editor.commands.undo(),
+ *       'Mod-Shift-z': () => this.editor.commands.redo(),
+ *     };
+ *   },
+ * });
+ */
+
+/**
+ * Editor interface for Extension
+ * Forward declaration to avoid circular dependency
+ */
+interface ExtensionEditorInterface {
+    readonly state: EditorState;
+    readonly view: EditorView;
+    readonly schema: unknown;
+    readonly commands: SingleCommands;
+}
+/**
+ * Marks an object as a Domternal extension, recognisably across copies.
+ *
+ * `Symbol.for` rather than `Symbol()`: the whole point is that an extension
+ * built by a SECOND physical copy of this module still carries a mark the
+ * first copy can read. A copy-local symbol would be a different key and every
+ * foreign extension would look like a hand-written object instead.
+ *
+ * The value is deliberately `true` rather than a per-copy token. Which copy an
+ * extension came from is answered by `instanceof Extension`, and that answer is
+ * exact; this only separates "a Domternal extension from somewhere" from "a
+ * plain object somebody passed in", which must keep working as it always has.
+ */
+declare const EXTENSION_BRAND: unique symbol;
+/**
+ * Base class for all extensions
+ *
+ * @typeParam Options - Extension options type
+ * @typeParam Storage - Extension storage type
+ */
+declare class Extension<Options = unknown, Storage = unknown> {
+    /**
+     * Brand read by `ExtensionManager` to tell an extension built by another
+     * copy of `@domternal/core` from a plain object. See `EXTENSION_BRAND`.
+     */
+    readonly [EXTENSION_BRAND] = true;
+    /**
+     * Extension type identifier
+     * Used to distinguish between Extension, Node, and Mark
+     * Subclasses override this to 'node' or 'mark'
+     */
+    readonly type: 'extension' | 'node' | 'mark';
+    /**
+     * Unique extension name
+     */
+    readonly name: string;
+    /**
+     * Extension options (immutable after creation)
+     */
+    readonly options: Options;
+    /**
+     * Extension storage (mutable state)
+     * Accessible via editor.storage[extensionName]
+     */
+    storage: Storage;
+    /**
+     * The original configuration object
+     */
+    readonly config: ExtensionConfig<Options, Storage>;
+    /**
+     * Editor instance (set by ExtensionManager after creation)
+     * null until ExtensionManager binds it
+     */
+    editor: ExtensionEditorInterface | null;
+    /**
+     * Reference to the parent config method when using extend().
+     * Set temporarily during config method execution so overridden
+     * methods can call `this.parent?.()` to invoke the original.
+     */
+    parent?: ((...args: unknown[]) => unknown) | undefined;
+    /**
+     * Protected constructor - use Extension.create() instead
+     */
+    protected constructor(config: ExtensionConfig<Options, Storage>);
+    /**
+     * Creates a new extension instance
+     *
+     * @param config - Extension configuration
+     * @returns New extension instance
+     *
+     * @example
+     * const MyExtension = Extension.create({
+     *   name: 'myExtension',
+     *   addOptions() {
+     *     return { enabled: true };
+     *   },
+     * });
+     */
+    static create<O = unknown, S = unknown>(config: ExtensionConfig<O, S>): Extension<O, S>;
+    /**
+     * Creates a new extension with merged options
+     * Original extension 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 extension instance with merged options
+     *
+     * @example
+     * const configured = MyExtension.configure({ enabled: false });
+     *
+     * @example
+     * // Shallow merge behavior with nested objects:
+     * // Given: options = { nested: { a: 1, b: 2 } }
+     * // configure({ nested: { b: 3 } })
+     * // Result: { nested: { b: 3 } } - 'a' is lost!
+     * // To preserve nested values, spread manually:
+     * // configure({ nested: { ...original.options.nested, b: 3 } })
+     */
+    configure(options: Partial<Options>): Extension<Options, Storage>;
+    /**
+     * Returns a fresh, unbound copy built from the same `config`: `editor` reset to
+     * null and `options`/`storage` re-derived, while `configure()`/`extend()`
+     * results are preserved (they live in `config`). Polymorphic: a `Node`/`Mark`
+     * clones to its own subclass.
+     *
+     * `ExtensionManager` clones every extension so each editor owns its instances
+     * and binding one editor can't mutate extensions shared with another.
+     */
+    clone(): Extension<Options, Storage>;
+    /**
+     * Creates a new extension with extended configuration
+     * Original extension is not modified
+     *
+     * **Note:** Config is merged shallowly using object spread (`...`).
+     * Config properties (like `addCommands`, `addKeyboardShortcuts`) are
+     * replaced entirely, not combined with the base extension's config.
+     *
+     * @param extendedConfig - Configuration to extend/override
+     * @returns New extension instance with extended config
+     *
+     * @example
+     * const Extended = MyExtension.extend({
+     *   name: 'extendedExtension',
+     *   addCommands() {
+     *     return { customCommand: () => ({ tr }) => true };
+     *   },
+     * });
+     *
+     * @example
+     * // To preserve base extension's commands while adding new ones:
+     * const Extended = BaseExtension.extend({
+     *   addCommands() {
+     *     const baseCommands = BaseExtension.config.addCommands?.call(this) ?? {};
+     *     return {
+     *       ...baseCommands,
+     *       newCommand: () => ({ tr }) => true,
+     *     };
+     *   },
+     * });
+     */
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<ExtensionConfigBase<ExtendedOptions, ExtendedStorage>> & ThisType<ExtensionContext<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
+}
+
+/**
+ * Floating menu shown when text is selected. Contextual formatting toolbar.
+ */
+
+declare const bubbleMenuPluginKey: PluginKey<any>;
+interface BubbleMenuOptions {
+    /**
+     * The HTML element that contains the menu.
+     * Must be provided by the user.
+     */
+    element: HTMLElement | null;
+    /**
+     * Duration in ms to wait before showing the menu.
+     * @default 0
+     */
+    updateDelay: number;
+    /**
+     * Function to determine if the menu should be shown.
+     * By default, shows for text selections with actual content in an editable editor.
+     */
+    shouldShow: (props: {
+        editor: Editor;
+        view: EditorView;
+        state: EditorState;
+        from: number;
+        to: number;
+    }) => boolean;
+    /**
+     * Placement of the menu relative to the selection.
+     * @default 'top'
+     */
+    placement: 'top' | 'bottom';
+    /**
+     * Offset in pixels from the selection.
+     * @default 8
+     */
+    offset: number;
+}
+interface CreateBubbleMenuPluginOptions {
+    pluginKey: PluginKey;
+    editor: Editor;
+    element: HTMLElement;
+    shouldShow?: BubbleMenuOptions['shouldShow'];
+    placement?: 'top' | 'bottom';
+    offset?: number;
+    updateDelay?: number;
+}
+/**
+ * Creates a standalone BubbleMenu ProseMirror plugin.
+ * Can be used by framework wrappers (Angular, React, Vue) to create the plugin
+ * independently of the extension system.
+ */
+declare function createBubbleMenuPlugin(options: CreateBubbleMenuPluginOptions): Plugin;
+declare const BubbleMenu: Extension<BubbleMenuOptions, unknown>;
+
+/**
+ * The bubble menu's item pipeline: what the editor registered, what the
+ * selection is, and what the consumer asked for, resolved into the finished
+ * list a menu renders.
+ *
+ * It lives in core because four surfaces need it and each of them is only a
+ * renderer. Vanilla, React, Vue and Angular each carried their own copy of
+ * every function below, four transcriptions of one algorithm kept in step by
+ * hand. They did not stay in step: the separator cleanup that this module now
+ * ends with had to be written four times to fix one defect, which is the
+ * clearest argument that the algorithm was never theirs to hold.
+ *
+ * ProseMirror shapes are duck-typed here rather than imported. A selection or
+ * a schema can arrive from a different copy of prosemirror-state, and
+ * `instanceof` across two copies is false for objects that are otherwise
+ * identical; reading the fields is the check that survives it.
+ */
+
+interface ResolvedPosShape {
+    parent: {
+        type: {
+            name: string;
+            spec: {
+                marks?: string;
+            };
+        };
+    };
+    depth: number;
+    node: (depth: number) => {
+        type: {
+            name: string;
+        };
+    };
+}
+interface SelectionShape {
+    empty: boolean;
+    $from: ResolvedPosShape;
+    $to: ResolvedPosShape;
+    node?: {
+        type: {
+            name: string;
+        };
+    };
+}
+interface BubbleMenuSeparator {
+    type: 'separator';
+    name: string;
+}
+type BubbleMenuItem = ToolbarButton | ToolbarDropdown | BubbleMenuSeparator;
+/**
+ * What a consumer may say about one context: an explicit name list, `true`
+ * for every formatting mark the schema allows there, or `null` for no menu.
+ */
+type BubbleContexts = Record<string, string[] | true | null>;
+interface BubbleItemMaps {
+    itemMap: Map<string, ToolbarButton>;
+    dropdownMap: Map<string, ToolbarDropdown>;
+    /** Bubble defaults indexed by context name (e.g. 'text', 'codeBlock'). */
+    bubbleDefaults: Map<string, BubbleMenuItem[]>;
+}
+/**
+ * Walks `editor.toolbarItems` and indexes them by name. Dropdowns are kept
+ * separately so the bubble menu can resolve them by name (e.g. text-align).
+ *
+ * A dropdown's children are indexed as buttons as well, which is what lets a
+ * consumer name one alignment directly instead of the whole dropdown.
+ */
+declare function buildBubbleItemMaps(editor: Editor): BubbleItemMaps;
+/**
+ * Resolve a name array to BubbleMenuItems via the item/dropdown maps.
+ * Dropdowns take priority over buttons sharing the same name. Pipe `|`
+ * tokens become separator entries.
+ *
+ * A name the editor does not carry is skipped, which is what lets one list
+ * serve every build: a default naming `ai` shows it where the Pro extension
+ * is installed and says nothing where it is not. The separator beside such a
+ * name is not skipped with it, because a `|` always resolves; that is what
+ * `collapseSeparators` is for, and why it has to run after this rather than
+ * inside it.
+ */
+declare function resolveBubbleNames(names: string[], itemMap: Map<string, ToolbarButton>, dropdownMap: Map<string, ToolbarDropdown>): BubbleMenuItem[];
+/**
+ * All `format`-group buttons sorted by priority (used by the `true` shorthand
+ * to show "all format marks for this context").
+ */
+declare function getBubbleFormatItems(itemMap: Map<string, ToolbarButton>): ToolbarButton[];
+/**
+ * Determine the active bubble-menu context based on the selection. Returns
+ * `null` when no context matches (menu should not show).
+ *
+ * Resolution order:
+ * 1. CellSelection (`$anchorCell`) - no menu inside table cell selections
+ * 2. NodeSelection (image, HR, etc.) - return the node's type name
+ * 3. Empty selection - no context (caret-only)
+ * 4. Inside a table cell - return 'table' (when from/to share a cell)
+ * 5. `$from.parent.type.name` if listed in contexts
+ * 6. 'text' if the parent allows marks
+ */
+declare function detectBubbleContext(selection: SelectionShape, ctxs: BubbleContexts): string | null;
+/**
+ * Filter items by what the schema actually allows in the given context.
+ * E.g. inside a `codeBlock` node, marks like Bold/Italic aren't permitted.
+ *
+ * Pass-through for 'text' and 'table' contexts (schema check would be
+ * lossy there because marks are allowed but some items still apply).
+ */
+declare function filterBubbleItemsBySchema(editor: Editor, contextName: string, schemaItems: ToolbarButton[]): ToolbarButton[];
+/** Detect whether `$pos` is inside a table cell (cell or header). */
+declare function isInsideTableCell($pos: ResolvedPosShape): boolean;
+interface ResolveBubbleMenuItemsOptions {
+    editor: Editor;
+    maps: BubbleItemMaps;
+    /** The consumer's `contexts`, or undefined for the fixed-list path. */
+    contexts?: BubbleContexts | undefined;
+    /**
+     * The list to show when `contexts` is absent and the selection is not a
+     * node the editor registered a default for. Already resolved, because it
+     * never changes with the selection.
+     */
+    fallbackItems: BubbleMenuItem[];
+}
+/**
+ * The whole decision, in one place: which list this selection gets, filtered
+ * by what the schema allows, with the orphaned separators removed.
+ *
+ * The cleanup is the last step rather than a step inside name resolution
+ * because filtering removes items too: a selection inside a node type that
+ * refuses a mark strands a separator exactly the way a missing extension
+ * does, and only decides it per transaction.
+ */
+declare function resolveBubbleMenuItems(options: ResolveBubbleMenuItemsOptions): BubbleMenuItem[];
+/**
+ * The default `shouldShow`, which has to agree with the resolution above:
+ * a menu that opens on a selection resolving to nothing is an empty box, and
+ * one that stays shut on a selection with items is a feature nobody can
+ * reach.
+ */
+declare function createBubbleShouldShow(maps: BubbleItemMaps, contexts?: BubbleContexts): BubbleMenuOptions['shouldShow'];
+
+/**
+ * Two packages disagreeing about which copy of `module` they use.
+ *
+ * `message` is the whole story, already formatted: what broke, why it cannot
+ * work, and the one-line fix for each package manager and bundler. Callers
+ * decide only whether to warn or throw.
+ */
+interface ProseMirrorCopyConflict {
+    /** Package whose copies disagree, e.g. `prosemirror-model`. */
+    module: string;
+    /** Package that registered the copy the page settled on. */
+    firstConsumer: string;
+    /** Package that arrived with a different one. */
+    secondConsumer: string;
+    /** Ready-to-print explanation and fix. */
+    message: string;
+}
+/**
+ * Records which copy of `module` a package is using, and reports a conflict
+ * when that disagrees with the copy already registered.
+ *
+ * Returns `null` on the first registration and on every later one that
+ * matches, so the happy path costs one `Map` lookup. Registering a conflicting
+ * copy does NOT replace the recorded one: the first registration wins, which
+ * keeps `firstConsumer` stable no matter how many latecomers arrive.
+ *
+ * @param module Package name, e.g. `prosemirror-model`.
+ * @param copy An export of that package, the same one for every caller. See
+ *   the contract in this file's header.
+ * @param consumer Package doing the registering, used in the message.
+ */
+declare function registerProseMirrorCopy(module: string, copy: object, consumer: string): ProseMirrorCopyConflict | null;
+/**
+ * Registers a copy and throws when it conflicts.
+ *
+ * For the call sites where a duplicate is already fatal and the only question
+ * is which error the developer reads: the collaboration binding, for one,
+ * throws `Can not convert <> to a Fragment` from inside y-prosemirror one call
+ * later, naming neither package involved.
+ *
+ * @throws ExtensionConfigurationError so `new Editor(...)` fails loudly rather
+ *   than being swallowed by the per-extension error isolation.
+ */
+declare function assertSingleProseMirrorCopy(module: string, copy: object, consumer: string): void;
+/**
+ * Registers a copy and warns once per module, for call sites where a duplicate
+ * is a strong signal but not necessarily fatal yet: two editors built from two
+ * copies of the core work fine until a node crosses between them.
+ *
+ * Deduped through `globalThis` as well, so a page holding two copies of this
+ * module still prints one warning rather than one per editor per copy.
+ */
+declare function warnOnDuplicateProseMirrorCopy(module: string, copy: object, consumer: string): ProseMirrorCopyConflict | null;
+
 interface InsertAsListItemChildArgs {
     /** Existing transaction to mutate. Caller dispatches. */
     tr: Transaction;
@@ -3528,168 +4008,6 @@ declare const findChildren: (node: Node$1, predicate: (node: Node$1) => boolean)
 
 declare const defaultBlockAt: (match: ContentMatch) => NodeType | null;
 
-/**
- * Extension - Base class for all extensions
- *
- * Extensions provide functionality without contributing to the schema.
- * For schema contributions, use Node (for block/inline nodes) or Mark (for inline formatting).
- *
- * Three-tier model:
- * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
- * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
- * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
- *
- * @example
- * const History = Extension.create({
- *   name: 'history',
- *   addOptions() {
- *     return { depth: 100 };
- *   },
- *   addKeyboardShortcuts() {
- *     return {
- *       'Mod-z': () => this.editor.commands.undo(),
- *       'Mod-Shift-z': () => this.editor.commands.redo(),
- *     };
- *   },
- * });
- */
-
-/**
- * Editor interface for Extension
- * Forward declaration to avoid circular dependency
- */
-interface ExtensionEditorInterface {
-    readonly state: EditorState;
-    readonly view: EditorView;
-    readonly schema: unknown;
-    readonly commands: SingleCommands;
-}
-/**
- * Base class for all extensions
- *
- * @typeParam Options - Extension options type
- * @typeParam Storage - Extension storage type
- */
-declare class Extension<Options = unknown, Storage = unknown> {
-    /**
-     * Extension type identifier
-     * Used to distinguish between Extension, Node, and Mark
-     * Subclasses override this to 'node' or 'mark'
-     */
-    readonly type: 'extension' | 'node' | 'mark';
-    /**
-     * Unique extension name
-     */
-    readonly name: string;
-    /**
-     * Extension options (immutable after creation)
-     */
-    readonly options: Options;
-    /**
-     * Extension storage (mutable state)
-     * Accessible via editor.storage[extensionName]
-     */
-    storage: Storage;
-    /**
-     * The original configuration object
-     */
-    readonly config: ExtensionConfig<Options, Storage>;
-    /**
-     * Editor instance (set by ExtensionManager after creation)
-     * null until ExtensionManager binds it
-     */
-    editor: ExtensionEditorInterface | null;
-    /**
-     * Reference to the parent config method when using extend().
-     * Set temporarily during config method execution so overridden
-     * methods can call `this.parent?.()` to invoke the original.
-     */
-    parent?: ((...args: unknown[]) => unknown) | undefined;
-    /**
-     * Protected constructor - use Extension.create() instead
-     */
-    protected constructor(config: ExtensionConfig<Options, Storage>);
-    /**
-     * Creates a new extension instance
-     *
-     * @param config - Extension configuration
-     * @returns New extension instance
-     *
-     * @example
-     * const MyExtension = Extension.create({
-     *   name: 'myExtension',
-     *   addOptions() {
-     *     return { enabled: true };
-     *   },
-     * });
-     */
-    static create<O = unknown, S = unknown>(config: ExtensionConfig<O, S>): Extension<O, S>;
-    /**
-     * Creates a new extension with merged options
-     * Original extension 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 extension instance with merged options
-     *
-     * @example
-     * const configured = MyExtension.configure({ enabled: false });
-     *
-     * @example
-     * // Shallow merge behavior with nested objects:
-     * // Given: options = { nested: { a: 1, b: 2 } }
-     * // configure({ nested: { b: 3 } })
-     * // Result: { nested: { b: 3 } } - 'a' is lost!
-     * // To preserve nested values, spread manually:
-     * // configure({ nested: { ...original.options.nested, b: 3 } })
-     */
-    configure(options: Partial<Options>): Extension<Options, Storage>;
-    /**
-     * Returns a fresh, unbound copy built from the same `config`: `editor` reset to
-     * null and `options`/`storage` re-derived, while `configure()`/`extend()`
-     * results are preserved (they live in `config`). Polymorphic: a `Node`/`Mark`
-     * clones to its own subclass.
-     *
-     * `ExtensionManager` clones every extension so each editor owns its instances
-     * and binding one editor can't mutate extensions shared with another.
-     */
-    clone(): Extension<Options, Storage>;
-    /**
-     * Creates a new extension with extended configuration
-     * Original extension is not modified
-     *
-     * **Note:** Config is merged shallowly using object spread (`...`).
-     * Config properties (like `addCommands`, `addKeyboardShortcuts`) are
-     * replaced entirely, not combined with the base extension's config.
-     *
-     * @param extendedConfig - Configuration to extend/override
-     * @returns New extension instance with extended config
-     *
-     * @example
-     * const Extended = MyExtension.extend({
-     *   name: 'extendedExtension',
-     *   addCommands() {
-     *     return { customCommand: () => ({ tr }) => true };
-     *   },
-     * });
-     *
-     * @example
-     * // To preserve base extension's commands while adding new ones:
-     * const Extended = BaseExtension.extend({
-     *   addCommands() {
-     *     const baseCommands = BaseExtension.config.addCommands?.call(this) ?? {};
-     *     return {
-     *       ...baseCommands,
-     *       newCommand: () => ({ tr }) => true,
-     *     };
-     *   },
-     * });
-     */
-    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<ExtensionConfigBase<ExtendedOptions, ExtendedStorage>> & ThisType<ExtensionContext<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
-}
-
 /**
  * Node - Base class for node extensions
  *
@@ -6460,61 +6778,6 @@ interface LinkPopoverOptions {
 }
 declare const LinkPopover: Extension<LinkPopoverOptions, unknown>;
 
-/**
- * Floating menu shown when text is selected. Contextual formatting toolbar.
- */
-
-declare const bubbleMenuPluginKey: PluginKey<any>;
-interface BubbleMenuOptions {
-    /**
-     * The HTML element that contains the menu.
-     * Must be provided by the user.
-     */
-    element: HTMLElement | null;
-    /**
-     * Duration in ms to wait before showing the menu.
-     * @default 0
-     */
-    updateDelay: number;
-    /**
-     * Function to determine if the menu should be shown.
-     * By default, shows for text selections with actual content in an editable editor.
-     */
-    shouldShow: (props: {
-        editor: Editor;
-        view: EditorView;
-        state: EditorState;
-        from: number;
-        to: number;
-    }) => boolean;
-    /**
-     * Placement of the menu relative to the selection.
-     * @default 'top'
-     */
-    placement: 'top' | 'bottom';
-    /**
-     * Offset in pixels from the selection.
-     * @default 8
-     */
-    offset: number;
-}
-interface CreateBubbleMenuPluginOptions {
-    pluginKey: PluginKey;
-    editor: Editor;
-    element: HTMLElement;
-    shouldShow?: BubbleMenuOptions['shouldShow'];
-    placement?: 'top' | 'bottom';
-    offset?: number;
-    updateDelay?: number;
-}
-/**
- * Creates a standalone BubbleMenu ProseMirror plugin.
- * Can be used by framework wrappers (Angular, React, Vue) to create the plugin
- * independently of the extension system.
- */
-declare function createBubbleMenuPlugin(options: CreateBubbleMenuPluginOptions): Plugin;
-declare const BubbleMenu: Extension<BubbleMenuOptions, unknown>;
-
 /**
  * StarterKit Extension
  *
@@ -6650,6 +6913,6 @@ declare const StarterKit: Extension<StarterKitOptions, unknown>;
  * @domternal/core
  * Framework-agnostic ProseMirror editor engine
  */
-declare const VERSION = "0.15.0";
+declare const VERSION = "1.0.1";
 
-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, type CreateFloatingMenuPluginOptions, DEFAULT_BLOCK_COLORS, DEFAULT_BLOCK_COLOR_TYPES, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_NOTION_COLOR_PALETTE, DEFAULT_TEXT_COLORS, Document$1 as Document, Dropcursor, type DropcursorOptions, Editor, type EditorEventName, type EditorEvents, type EditorInstance, type EditorOptions, type EditorPreset, EventEmitter, Extension, type ExtensionConfig, type ExtensionConfigBase, ExtensionConfigurationError, type ExtensionEditor, ExtensionManager, type ExtensionManagerEditor, type ExtensionManagerOptions, FLOATING_MENU_META, FLOATING_MENU_NO_FOCUS, type FindChildResult, type FindParentNodeResult, FloatingMenuController, type FloatingMenuGroup, type FloatingMenuItem, type FloatingMenuItemsOverride, type FloatingMenuKeymap, 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, 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, Placeholder, type PlaceholderOptions, type PositionFloatingOptions, Print, type PrintOptions, type PrintStorage, 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, announce, applyInlineStyles, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, copyThemeClass, createAccumulatingDispatch, createBubbleMenuPlugin, createCanChecker, createChainBuilder, createDocument, createFloatingMenuPlugin, defaultBlockAt, defaultBubbleContexts, defaultFloatingMenuShouldShow, defaultIcons, deleteSelection, findChildren, findListItemAncestorDepth, findParentNode, floatingMenuPluginKey, focus, focusPluginKey, generateHTML, generateJSON, generateText, getListItemCursorContext, getMarkRange, groupFloatingMenuItems, hideFloatingMenu, 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, refocusEditorAfterCommand, resetAttributes, selectAll, selectNodeBackward, selectionDecorationPluginKey, setBlockType, setContent, setMark, showFloatingMenu, splitListForInsert, stripInlineColorConflicts, textInputRule, textblockTypeInputRule, toggleBlockType, toggleList, toggleMark, toggleWrap, uniqueIDPluginKey, unsetAllMarks, unsetMark, updateAttributes, wrapIn, wrappingInputRule, writeToClipboard };
+export { type AnyExtension, type AnyExtensionConfig, type AttributeSpec, type AttributeSpecs, type AutolinkPluginOptions, BaseKeymap, type BaseKeymapOptions, BlockColor, type BlockColorOptions, Blockquote, type BlockquoteOptions, Bold, type BoldOptions, type BubbleContexts, type BubbleItemMaps, BubbleMenu, type BubbleMenuItem, type BubbleMenuOptions, type BubbleMenuSeparator, 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, type CreateFloatingMenuPluginOptions, DEFAULT_BLOCK_COLORS, DEFAULT_BLOCK_COLOR_TYPES, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_NOTION_COLOR_PALETTE, DEFAULT_TEXT_COLORS, Document$1 as Document, Dropcursor, type DropcursorOptions, Editor, type EditorEventName, type EditorEvents, type EditorInstance, type EditorOptions, type EditorPreset, EventEmitter, Extension, type ExtensionConfig, type ExtensionConfigBase, ExtensionConfigurationError, type ExtensionEditor, ExtensionManager, type ExtensionManagerEditor, type ExtensionManagerOptions, FLOATING_MENU_META, FLOATING_MENU_NO_FOCUS, type FindChildResult, type FindParentNodeResult, FloatingMenuController, type FloatingMenuGroup, type FloatingMenuItem, type FloatingMenuItemsOverride, type FloatingMenuKeymap, 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, 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, Placeholder, type PlaceholderOptions, type PositionFloatingOptions, Print, type PrintOptions, type PrintStorage, type ProseMirrorCopyConflict, type Range, type RawCommands, type ResolveBubbleMenuItemsOptions, type ResolvedPosShape, Selection, SelectionDecoration, type SelectionDecorationOptions, type SelectionOptions, type SelectionShape, 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, announce, applyInlineStyles, assertSingleProseMirrorCopy, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildBubbleItemMaps, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, collapseSeparators, copyThemeClass, createAccumulatingDispatch, createBubbleMenuPlugin, createBubbleShouldShow, createCanChecker, createChainBuilder, createDocument, createFloatingMenuPlugin, defaultBlockAt, defaultBubbleContexts, defaultFloatingMenuShouldShow, defaultIcons, deleteSelection, detectBubbleContext, filterBubbleItemsBySchema, findChildren, findListItemAncestorDepth, findParentNode, floatingMenuPluginKey, focus, focusPluginKey, generateHTML, generateJSON, generateText, getBubbleFormatItems, getListItemCursorContext, getMarkRange, groupFloatingMenuItems, hideFloatingMenu, indentBlockAsListChild, inlineStyles, insertAsListItemChild, insertChildrenZoneSibling, insertContent, insertText, invisibleCharsPluginKey, isDocumentEmpty, isInListItemLabel, isInsideListItem, isInsideTableCell, isNodeEmpty, isValidUrl, lift, liftCurrentListItem, liftEmptyChildrenZoneParagraph, linkClickPlugin, linkClickPluginKey, linkExitPlugin, linkExitPluginKey, linkPastePlugin, linkPastePluginKey, markInputRule, markInputRulePatterns, nodeInputRule, outdentBlockFromListItem, placeholderPluginKey, positionFloating, positionFloatingOnce, refocusEditorAfterCommand, registerProseMirrorCopy, resetAttributes, resolveBubbleMenuItems, resolveBubbleNames, selectAll, selectNodeBackward, selectionDecorationPluginKey, setBlockType, setContent, setMark, showFloatingMenu, splitListForInsert, stripInlineColorConflicts, textInputRule, textblockTypeInputRule, toggleBlockType, toggleList, toggleMark, toggleWrap, uniqueIDPluginKey, unsetAllMarks, unsetMark, updateAttributes, warnOnDuplicateProseMirrorCopy, wrapIn, wrappingInputRule, writeToClipboard };