@domternal/core 0.6.1 → 0.7.0

package/dist/index.js

@@ -1,11 +1,11 @@
-import { Plugin, PluginKey, Selection, TextSelection, NodeSelection, AllSelection, EditorState } from '@domternal/pm/state';
+import { Plugin, PluginKey, TextSelection, Selection, NodeSelection, AllSelection, EditorState } from '@domternal/pm/state';
 export { PluginKey } from '@domternal/pm/state';
 import { DecorationSet, Decoration, EditorView } from '@domternal/pm/view';
 import { Slice, Fragment, Schema, Node as Node$1, DOMSerializer, DOMParser } from '@domternal/pm/model';
 import { keymap } from '@domternal/pm/keymap';
-import { chainCommands, newlineInCode, createParagraphNear, liftEmptyBlock, splitBlock, baseKeymap, selectNodeBackward as selectNodeBackward$1 } from '@domternal/pm/commands';
+import { splitBlock, chainCommands, newlineInCode, createParagraphNear, liftEmptyBlock, baseKeymap, selectNodeBackward as selectNodeBackward$1 } from '@domternal/pm/commands';
 import { InputRule } from '@domternal/pm/inputrules';
-import { findWrapping, canJoin, liftTarget } from '@domternal/pm/transform';
+import { canJoin, findWrapping, liftTarget } from '@domternal/pm/transform';
 import { liftListItem, sinkListItem, splitListItem, wrapRangeInList } from '@domternal/pm/schema-list';
 import { offset, flip, shift, autoUpdate, hide, computePosition } from '@floating-ui/dom';
 import { find } from 'linkifyjs';
@@ -270,6 +270,10 @@ var ExtensionManager = class {
    * Cached toolbar items (collected lazily)
    */
   _toolbarItems = null;
+  /**
+   * Cached floating-menu items (collected lazily)
+   */
+  _floatingMenuItems = null;
   /**
    * Cached node views (collected lazily)
    */
@@ -343,6 +347,14 @@ var ExtensionManager = class {
     this._toolbarItems ??= this.collectToolbarItems();
     return this._toolbarItems;
   }
+  /**
+   * Gets floating-menu items from all extensions
+   * Cached after first call
+   */
+  get floatingMenuItems() {
+    this._floatingMenuItems ??= this.collectFloatingMenuItems();
+    return this._floatingMenuItems;
+  }
   /**
    * Gets node views from all Node extensions that define addNodeView
    */
@@ -359,6 +371,7 @@ var ExtensionManager = class {
     this._plugins = null;
     this._commands = null;
     this._toolbarItems = null;
+    this._floatingMenuItems = null;
     this._nodeViews = null;
   }
   // === Extension Processing ===
@@ -405,7 +418,7 @@ var ExtensionManager = class {
     });
   }
   /**
-   * Detects duplicate extension names (AD-7: Schema Conflict Detection)
+   * Detects duplicate extension names.
    * @throws Error if duplicate names found
    */
   detectConflicts() {
@@ -706,6 +719,25 @@ var ExtensionManager = class {
     }
     return items;
   }
+  /**
+   * Collects floating-menu items from all extensions via `addFloatingMenuItems()`.
+   */
+  collectFloatingMenuItems() {
+    const items = [];
+    for (const ext of this._extensions) {
+      const addItems = ext.config.addFloatingMenuItems;
+      if (addItems) {
+        const extItems = this.safeCall(
+          () => callOrReturn(addItems, ext),
+          `${ext.name}.addFloatingMenuItems`
+        );
+        if (extItems && extItems.length > 0) {
+          items.push(...extItems);
+        }
+      }
+    }
+    return items;
+  }
   /**
    * Collects node views from all Node extensions.
    * Returns a map of node name to NodeViewConstructor for EditorView.
@@ -1476,7 +1508,7 @@ var Extension = class _Extension {
    * // 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 } })
    */
@@ -1630,25 +1662,12 @@ var Mark = class _Mark extends Extension {
     return new _Mark(config);
   }
   /**
-   * 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) {
     const { isFormatting, ...restOptions } = options;
@@ -1923,6 +1942,40 @@ var unsetAllMarks = () => ({ state, tr, dispatch, editor }) => {
   dispatch(tr);
   return true;
 };
+
+// src/utils/listItemAncestor.ts
+var LIST_ITEM_TYPE_NAMES = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+function findListItemAncestorDepth($pos) {
+  for (let d = $pos.depth; d >= 1; d--) {
+    if (LIST_ITEM_TYPE_NAMES.has($pos.node(d).type.name)) return d;
+  }
+  return -1;
+}
+function isInsideListItem($pos) {
+  return findListItemAncestorDepth($pos) !== -1;
+}
+function isInListItemLabel($pos) {
+  const d = findListItemAncestorDepth($pos);
+  if (d === -1) return false;
+  return $pos.index(d) === 0;
+}
+
+// src/utils/liftCurrentListItem.ts
+function liftCurrentListItem(state, tr) {
+  if (!tr.selection.empty) return false;
+  if (tr.steps.length !== 0) return false;
+  const { $from } = tr.selection;
+  const listItemDepth = findListItemAncestorDepth($from);
+  if (listItemDepth === -1) return false;
+  if ($from.index(listItemDepth) !== 0) return false;
+  const listItemType = $from.node(listItemDepth).type;
+  return liftListItem(listItemType)(state, (liftTr) => {
+    for (const step of liftTr.steps) tr.step(step);
+    if (liftTr.selectionSet) tr.setSelection(liftTr.selection);
+  });
+}
+
+// src/commands/nodeCommands.ts
 var setBlockType = (nodeName, attributes) => ({ state, tr, dispatch }) => {
   const nodeType = state.schema.nodes[nodeName];
   if (!nodeType) {
@@ -1946,7 +1999,26 @@ var setBlockType = (nodeName, attributes) => ({ state, tr, dispatch }) => {
     });
     return found;
   });
-  if (!canApply) return false;
+  if (!canApply) {
+    const liftOk = liftCurrentListItem(state, tr);
+    if (!liftOk) return false;
+    const $reFrom = tr.doc.resolve(tr.selection.from);
+    if ($reFrom.depth < 1) return false;
+    const blockParent = $reFrom.node($reFrom.depth - 1);
+    const blockIndex = $reFrom.index($reFrom.depth - 1);
+    if (!blockParent.canReplaceWith(blockIndex, blockIndex + 1, nodeType)) {
+      return false;
+    }
+    if (!dispatch) return true;
+    tr.setBlockType(
+      tr.selection.from,
+      tr.selection.to,
+      nodeType,
+      (node) => ({ ...node.attrs, ...attributes ?? {} })
+    );
+    dispatch(tr.scrollIntoView());
+    return true;
+  }
   if (!dispatch) return true;
   for (const range of tr.selection.ranges) {
     const from = range.$from.pos;
@@ -1991,9 +2063,22 @@ var wrapIn = (nodeName, attributes) => ({ state, tr, dispatch }) => {
   const range = $from.blockRange($to);
   if (!range) return false;
   const wrapping = findWrapping(range, nodeType, attributes);
-  if (!wrapping) return false;
+  if (wrapping) {
+    if (!dispatch) return true;
+    tr.wrap(range, wrapping).scrollIntoView();
+    dispatch(tr);
+    return true;
+  }
+  const liftOk = liftCurrentListItem(state, tr);
+  if (!liftOk) return false;
+  const $reFrom = tr.doc.resolve(tr.selection.from);
+  const $reTo = tr.doc.resolve(tr.selection.to);
+  const reRange = $reFrom.blockRange($reTo);
+  if (!reRange) return false;
+  const reWrapping = findWrapping(reRange, nodeType, attributes);
+  if (!reWrapping) return false;
   if (!dispatch) return true;
-  tr.wrap(range, wrapping).scrollIntoView();
+  tr.wrap(reRange, reWrapping).scrollIntoView();
   dispatch(tr);
   return true;
 };
@@ -2088,6 +2173,30 @@ var lift = () => ({ tr, dispatch }) => {
   dispatch(tr);
   return true;
 };
+
+// src/utils/listItemCursorContext.ts
+var LIST_ITEM_TYPES = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+function getListItemCursorContext($from) {
+  if ($from.parent.type.name !== "paragraph") return null;
+  const itemDepth = $from.depth - 1;
+  if (itemDepth < 1) return null;
+  const itemNode = $from.node(itemDepth);
+  if (!LIST_ITEM_TYPES.has(itemNode.type.name)) return null;
+  const wrapperDepth = itemDepth - 1;
+  const childIndex = $from.index(itemDepth);
+  return {
+    itemDepth,
+    itemPos: $from.before(itemDepth),
+    wrapperPos: $from.before(wrapperDepth),
+    isInChildrenZone: childIndex > 0,
+    paragraphIsEmpty: $from.parent.content.size === 0,
+    isLastChild: childIndex === itemNode.childCount - 1,
+    childIndex,
+    itemIndexInWrapper: $from.index(wrapperDepth)
+  };
+}
+
+// src/commands/listCommands.ts
 function joinListBackwards(tr, listType) {
   const { $from } = tr.selection;
   for (let d = $from.depth; d >= 0; d--) {
@@ -2234,6 +2343,19 @@ var toggleList = (listNodeName, listItemNodeName, attributes) => ({ state, tr, d
     return true;
   }
   const { from, to } = tr.selection;
+  if (from === to) {
+    const ctx = getListItemCursorContext(tr.selection.$from);
+    if (ctx?.isInChildrenZone) {
+      if (!dispatch) return true;
+      const blockRange = tr.selection.$from.blockRange();
+      if (blockRange && wrapRangeInList(tr, blockRange, listType, attributes)) {
+        joinListBackwards(tr, listType);
+        joinListForwards(tr, listType);
+        dispatch(tr.scrollIntoView());
+        return true;
+      }
+    }
+  }
   const contentBlocks = collectListContext(tr.doc, from, to);
   const allInTargetList = contentBlocks.length > 0 && contentBlocks.every((b) => b.inTargetList);
   const allInSomeList = contentBlocks.length > 0 && contentBlocks.every((b) => b.inSomeList);
@@ -2892,8 +3014,8 @@ var CommandManager = class {
     };
   }
   /**
-   * 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');
@@ -3372,12 +3494,18 @@ var Editor = class extends EventEmitter {
     return this._extensionManager.storage;
   }
   /**
-   * Gets toolbar items registered by all extensions.
-   * Used by framework toolbar components to auto-generate UI.
+   * Toolbar items registered by all extensions.
    */
   get toolbarItems() {
     return this._extensionManager.toolbarItems;
   }
+  /**
+   * Floating-menu items registered by all extensions, rendered as the
+   * block-insert menu shown on empty paragraphs.
+   */
+  get floatingMenuItems() {
+    return this._extensionManager.floatingMenuItems;
+  }
   // === Active State Methods ===
   /**
    * Checks if a node or mark is currently active
@@ -3628,9 +3756,8 @@ var Editor = class extends EventEmitter {
   }
   // === Dynamic Plugin Management ===
   /**
-   * Registers a ProseMirror plugin dynamically at runtime.
-   * Used by framework wrappers (e.g. Angular BubbleMenu component) to add
-   * plugins after the editor is created.
+   * Registers a ProseMirror plugin dynamically at runtime, after the editor
+   * has been created. Safe to call repeatedly with the same plugin key.
    */
   registerPlugin(plugin) {
     if (plugin.spec.key?.get(this.view.state)) return;
@@ -3745,7 +3872,7 @@ var Editor = class extends EventEmitter {
         ...this.options.editable ?? true ? {} : { "aria-readonly": "true" }
       }),
       ...Object.keys(nodeViews).length > 0 ? { nodeViews } : {},
-      // Clipboard transform — apply user-provided transform (e.g. inlineStyles) on copy/cut
+      // Clipboard transform - apply user-provided transform (e.g. inlineStyles) on copy/cut
       ...this.options.clipboardHTMLTransform ? this.buildClipboardSerializer(this.options.clipboardHTMLTransform, this._extensionManager.schema) : {},
       // Handle focus/blur events
       handleDOMEvents: {
@@ -3878,8 +4005,225 @@ function positionFloatingOnce(reference, floating, options) {
   });
 }
 
+// src/utils/clipboard.ts
+async function writeToClipboard(text) {
+  if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } catch {
+    }
+  }
+  if (typeof document === "undefined") return false;
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.style.position = "fixed";
+  textarea.style.top = "-1000px";
+  textarea.style.left = "-1000px";
+  textarea.style.opacity = "0";
+  textarea.setAttribute("readonly", "");
+  document.body.appendChild(textarea);
+  try {
+    textarea.select();
+    textarea.setSelectionRange(0, text.length);
+    return document.execCommand("copy");
+  } catch {
+    return false;
+  } finally {
+    textarea.remove();
+  }
+}
+
+// src/utils/defaultBubbleContexts.ts
+var NOTION_MODE_CLASS = "dm-notion-mode";
+var NOTION_TEXT_CONTEXT = Object.freeze([
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "code",
+  "|",
+  "link",
+  "|",
+  "textAlign"
+]);
+var STANDARD_TEXT_CONTEXT = Object.freeze([
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "code",
+  "|",
+  "link"
+]);
+function defaultBubbleContexts(editor) {
+  const inNotionMode = editor.view.dom.closest("." + NOTION_MODE_CLASS) !== null;
+  const text = inNotionMode ? NOTION_TEXT_CONTEXT : STANDARD_TEXT_CONTEXT;
+  return { text: [...text] };
+}
+
+// src/utils/insertAsListItemChild.ts
+var LIST_ITEM_TYPES2 = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var LIST_WRAPPER_TYPES = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
+function insertAsListItemChild(args) {
+  const { tr, wrapperPos, targetItemPos, blockNode, sourceRange } = args;
+  if (wrapperPos < 0 || wrapperPos >= tr.doc.content.size) return { ok: false };
+  const wrapper = tr.doc.nodeAt(wrapperPos);
+  if (!wrapper || !LIST_WRAPPER_TYPES.has(wrapper.type.name)) return { ok: false };
+  if (wrapper.childCount === 0) return { ok: false };
+  let targetItem;
+  let targetItemStart;
+  if (targetItemPos !== void 0) {
+    if (targetItemPos < 0 || targetItemPos >= tr.doc.content.size) return { ok: false };
+    const candidate = tr.doc.nodeAt(targetItemPos);
+    if (!candidate || !LIST_ITEM_TYPES2.has(candidate.type.name)) return { ok: false };
+    if (targetItemPos < wrapperPos + 1 || targetItemPos >= wrapperPos + wrapper.nodeSize) {
+      return { ok: false };
+    }
+    targetItem = candidate;
+    targetItemStart = targetItemPos;
+  } else {
+    const last = wrapper.lastChild;
+    if (!last || !LIST_ITEM_TYPES2.has(last.type.name)) return { ok: false };
+    let pos = wrapperPos + 1;
+    for (let i = 0; i < wrapper.childCount - 1; i++) {
+      pos += wrapper.child(i).nodeSize;
+    }
+    targetItem = last;
+    targetItemStart = pos;
+  }
+  if (!targetItem.canReplaceWith(targetItem.childCount, targetItem.childCount, blockNode.type)) {
+    return { ok: false };
+  }
+  const targetItemContentEnd = targetItemStart + targetItem.nodeSize - 1;
+  if (sourceRange) {
+    const { from, to } = sourceRange;
+    if (targetItemContentEnd >= from && targetItemContentEnd <= to) {
+      return { ok: false };
+    }
+    tr.delete(from, to);
+    const adjustedInsertPos = targetItemContentEnd > from ? targetItemContentEnd - (to - from) : targetItemContentEnd;
+    tr.insert(adjustedInsertPos, blockNode);
+    return { ok: true, insertedAt: adjustedInsertPos };
+  }
+  tr.insert(targetItemContentEnd, blockNode);
+  return { ok: true, insertedAt: targetItemContentEnd };
+}
+function liftEmptyChildrenZoneParagraph(state, dispatch, ctx) {
+  if (!ctx.isInChildrenZone || !ctx.paragraphIsEmpty) return false;
+  const { $from } = state.selection;
+  if ($from.parent.type.name !== "paragraph") return false;
+  if ($from.parent.content.size !== 0) return false;
+  const paragraphType = state.schema.nodes["paragraph"];
+  if (!paragraphType) return false;
+  const range = $from.blockRange();
+  if (range) {
+    const target = liftTarget(range);
+    if (target !== null) {
+      if (!dispatch) return true;
+      const tr2 = state.tr.lift(range, target);
+      const oldParaStart = $from.before($from.depth);
+      const newParaStart = tr2.mapping.map(oldParaStart);
+      tr2.setSelection(TextSelection.create(tr2.doc, newParaStart + 1));
+      dispatch(tr2.scrollIntoView());
+      return true;
+    }
+  }
+  const paraStart = $from.before($from.depth);
+  const paraEnd = $from.after($from.depth);
+  const itemNode = state.doc.nodeAt(ctx.itemPos);
+  if (!itemNode) return false;
+  const itemEnd = ctx.itemPos + itemNode.nodeSize;
+  const wrapperNode = state.doc.nodeAt(ctx.wrapperPos);
+  if (!wrapperNode) return false;
+  const wrapperEnd = ctx.wrapperPos + wrapperNode.nodeSize;
+  const isLastItem = ctx.itemIndexInWrapper === wrapperNode.childCount - 1;
+  const wrapperParentDepth = ctx.itemDepth - 2;
+  if (wrapperParentDepth < 0) return false;
+  const wrapperParent = $from.node(wrapperParentDepth);
+  const wrapperIndexInParent = $from.index(wrapperParentDepth);
+  if (!wrapperParent.canReplaceWith(
+    wrapperIndexInParent + 1,
+    wrapperIndexInParent + 1,
+    paragraphType
+  )) {
+    return false;
+  }
+  if (!dispatch) return true;
+  const newPara = paragraphType.create();
+  const tr = state.tr;
+  if (isLastItem) {
+    tr.delete(paraStart, paraEnd);
+    const insertPos = tr.mapping.map(wrapperEnd);
+    tr.insert(insertPos, newPara);
+    tr.setSelection(TextSelection.create(tr.doc, insertPos + 1));
+  } else {
+    tr.delete(paraStart, paraEnd);
+    const splitAt = tr.mapping.map(itemEnd);
+    tr.split(splitAt, 1);
+    const insertPos = splitAt + 1;
+    tr.insert(insertPos, newPara);
+    tr.setSelection(TextSelection.create(tr.doc, insertPos + 1));
+  }
+  dispatch(tr.scrollIntoView());
+  return true;
+}
+function insertChildrenZoneSibling(state, dispatch, ctx) {
+  if (!ctx.isInChildrenZone || !ctx.paragraphIsEmpty) return false;
+  const paragraphType = state.schema.nodes["paragraph"];
+  if (!paragraphType) return false;
+  const { $from } = state.selection;
+  if ($from.parent.type.name !== "paragraph") return false;
+  if ($from.parent.content.size !== 0) return false;
+  if (!dispatch) return true;
+  const insertPos = $from.after($from.depth);
+  const tr = state.tr.insert(insertPos, paragraphType.create());
+  tr.setSelection(TextSelection.create(tr.doc, insertPos + 1));
+  dispatch(tr.scrollIntoView());
+  return true;
+}
+function splitListForInsert(state, tr) {
+  if (!tr.selection.empty) return null;
+  if (tr.steps.length !== 0) return null;
+  const { $from } = tr.selection;
+  const listItemDepth = findListItemAncestorDepth($from);
+  if (listItemDepth === -1) return null;
+  if ($from.index(listItemDepth) !== 0) return null;
+  const listDepth = listItemDepth - 1;
+  const listItemNode = $from.node(listItemDepth);
+  const labelParagraph = listItemNode.firstChild;
+  const labelIsEmpty = listItemNode.childCount === 1 && (labelParagraph?.content.size ?? 0) === 0;
+  if (labelIsEmpty) {
+    const listItemType = listItemNode.type;
+    let safetyLimit = 10;
+    while (safetyLimit-- > 0) {
+      const stepState = state.apply(tr);
+      const liftOk = liftListItem(listItemType)(stepState, (liftTr) => {
+        for (const step of liftTr.steps) tr.step(step);
+        if (liftTr.selectionSet) tr.setSelection(liftTr.selection);
+      });
+      if (!liftOk) break;
+      if (!isInsideListItem(tr.selection.$from)) break;
+    }
+    const $afterLift = tr.selection.$from;
+    if (isInsideListItem($afterLift)) return null;
+    return { from: $afterLift.before(), to: $afterLift.after() };
+  }
+  const listNode = $from.node(listDepth);
+  const indexInList = $from.index(listDepth);
+  const isLast = indexInList === listNode.childCount - 1;
+  if (isLast) {
+    const pos2 = $from.after(listDepth);
+    return { from: pos2, to: pos2 };
+  }
+  const splitPos = $from.after(listItemDepth);
+  tr.split(splitPos, 1);
+  const pos = splitPos + 1;
+  return { from: pos, to: pos };
+}
+
 // src/Node.ts
-var Node = class _Node extends Extension {
+var Node2 = class _Node extends Extension {
   /**
    * Node type identifier
    * Distinguishes nodes from extensions and marks
@@ -3941,25 +4285,12 @@ var Node = class _Node extends Extension {
     return new _Node(config);
   }
   /**
-   * 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) {
     const newConfig = {
@@ -4133,7 +4464,7 @@ var ToolbarController = class _ToolbarController {
   _activeMap = /* @__PURE__ */ new Map();
   /** Disabled state for each button (keyed by item.name) */
   _disabledMap = /* @__PURE__ */ new Map();
-  /** Expanded state for emitEvent buttons — true when their panel is open */
+  /** Expanded state for emitEvent buttons - true when their panel is open */
   _expandedMap = /* @__PURE__ */ new Map();
   /** Currently open dropdown name (null = none) */
   _openDropdown = null;
@@ -4468,6 +4799,262 @@ var ToolbarController = class _ToolbarController {
   }
 };
 
+// src/utils/groupFloatingMenuItems.ts
+function groupFloatingMenuItems(items) {
+  const map = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const item of items) {
+    const name = item.group ?? "";
+    let list = map.get(name);
+    if (!list) {
+      list = [];
+      map.set(name, list);
+      order.push(name);
+    }
+    list.push(item);
+  }
+  const groups = [];
+  for (const name of order) {
+    const list = (map.get(name) ?? []).slice();
+    list.sort((a, b) => (b.priority ?? 100) - (a.priority ?? 100));
+    groups.push({ name, items: list });
+  }
+  return groups;
+}
+
+// src/FloatingMenuController.ts
+var FLOATING_MENU_NO_FOCUS = -1;
+var FloatingMenuController = 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, override) {
+    const defaults = editor.floatingMenuItems;
+    if (!override) return defaults;
+    if (Array.isArray(override)) return override;
+    try {
+      return override(defaults, editor);
+    } catch {
+      return defaults;
+    }
+  }
+  /**
+   * 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, item) {
+    if (typeof item.command === "function") {
+      item.command(editor);
+      return;
+    }
+    const commands = editor.commands;
+    const cmd = commands[item.command];
+    if (!cmd) return;
+    if (item.commandArgs?.length) {
+      cmd(...item.commandArgs);
+    } else {
+      cmd();
+    }
+  }
+  editor;
+  onChange;
+  override;
+  transactionHandler = null;
+  _groups = [];
+  _flatItems = [];
+  _disabledMap = /* @__PURE__ */ new Map();
+  _focusedIndex = FLOATING_MENU_NO_FOCUS;
+  constructor(editor, onChange, override) {
+    this.editor = editor;
+    this.onChange = onChange;
+    this.override = override;
+    this.rebuild();
+  }
+  // === Getters ===
+  get groups() {
+    return this._groups;
+  }
+  get flatItems() {
+    return this._flatItems;
+  }
+  get disabledMap() {
+    return this._disabledMap;
+  }
+  get focusedIndex() {
+    return this._focusedIndex;
+  }
+  /** True when keyboard focus is inside the menu (at least one item focused). */
+  get isEntered() {
+    return this._focusedIndex >= 0;
+  }
+  get itemCount() {
+    return this._flatItems.length;
+  }
+  // === State Methods ===
+  isDisabled(item) {
+    return this._disabledMap.get(item.name) ?? false;
+  }
+  /**
+   * Executes an item's command, then closes the menu keyboard focus.
+   * Callers should refocus the editor after calling this.
+   */
+  execute(item) {
+    if (this.isDisabled(item)) return;
+    _FloatingMenuController.executeItem(this.editor, item);
+    this._focusedIndex = FLOATING_MENU_NO_FOCUS;
+    this.onChange();
+  }
+  /**
+   * 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() {
+    const items = _FloatingMenuController.resolveItems(this.editor, this.override);
+    this._groups = this.groupItems(items);
+    this._flatItems = this._groups.flatMap((g) => g.items);
+    if (this._focusedIndex >= this._flatItems.length) {
+      this._focusedIndex = FLOATING_MENU_NO_FOCUS;
+    }
+    this.updateDisabledStates();
+  }
+  // === Keyboard Navigation (roving tabindex) ===
+  /** Enter keyboard focus on the menu (first item). Called by the plugin's keymap. */
+  enterMenu() {
+    if (this._flatItems.length === 0) {
+      this._focusedIndex = FLOATING_MENU_NO_FOCUS;
+      return this._focusedIndex;
+    }
+    this._focusedIndex = 0;
+    this.onChange();
+    return this._focusedIndex;
+  }
+  /** Leave keyboard focus (Escape). Refocus of the editor is the caller's job. */
+  leaveMenu() {
+    if (this._focusedIndex === FLOATING_MENU_NO_FOCUS) return;
+    this._focusedIndex = FLOATING_MENU_NO_FOCUS;
+    this.onChange();
+  }
+  /** ArrowDown - wrap to first at end. */
+  next() {
+    if (this._flatItems.length === 0) return FLOATING_MENU_NO_FOCUS;
+    const cur = this._focusedIndex < 0 ? -1 : this._focusedIndex;
+    this._focusedIndex = (cur + 1) % this._flatItems.length;
+    this.onChange();
+    return this._focusedIndex;
+  }
+  /** ArrowUp - wrap to last at start. */
+  prev() {
+    if (this._flatItems.length === 0) return FLOATING_MENU_NO_FOCUS;
+    const len = this._flatItems.length;
+    const cur = this._focusedIndex < 0 ? len : this._focusedIndex;
+    this._focusedIndex = (cur - 1 + len) % len;
+    this.onChange();
+    return this._focusedIndex;
+  }
+  first() {
+    if (this._flatItems.length === 0) return FLOATING_MENU_NO_FOCUS;
+    this._focusedIndex = 0;
+    this.onChange();
+    return this._focusedIndex;
+  }
+  last() {
+    if (this._flatItems.length === 0) return FLOATING_MENU_NO_FOCUS;
+    this._focusedIndex = this._flatItems.length - 1;
+    this.onChange();
+    return this._focusedIndex;
+  }
+  /** Set focused index directly (e.g. on pointer hover). */
+  setFocusedIndex(index) {
+    if (index < 0 || index >= this._flatItems.length) return;
+    if (this._focusedIndex === index) return;
+    this._focusedIndex = index;
+    this.onChange();
+  }
+  /** Get focused item (or null). */
+  focusedItem() {
+    return this._flatItems[this._focusedIndex] ?? null;
+  }
+  /** Get flat index of item by name (for wrappers binding roving tabindex). */
+  getFlatIndex(name) {
+    return this._flatItems.findIndex((i) => i.name === name);
+  }
+  // === Lifecycle ===
+  /** Subscribes to editor transactions for disabled-state tracking. */
+  subscribe() {
+    this.transactionHandler = () => {
+      this.updateDisabledStates();
+    };
+    this.editor.on("transaction", this.transactionHandler);
+  }
+  /** Unsubscribes and clears internal state. */
+  destroy() {
+    if (this.transactionHandler) {
+      this.editor.off("transaction", this.transactionHandler);
+      this.transactionHandler = null;
+    }
+    this._groups = [];
+    this._flatItems = [];
+    this._disabledMap.clear();
+    this._focusedIndex = FLOATING_MENU_NO_FOCUS;
+  }
+  // === Internal ===
+  /**
+   * 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.
+   */
+  groupItems(items) {
+    return groupFloatingMenuItems(items);
+  }
+  /**
+   * 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.
+   */
+  updateDisabledStates() {
+    let changed = false;
+    let canProxy = null;
+    try {
+      canProxy = this.editor.can();
+    } catch {
+      canProxy = null;
+    }
+    for (const item of this._flatItems) {
+      const was = this._disabledMap.get(item.name) ?? false;
+      let now = false;
+      if (item.isDisabled) {
+        try {
+          now = item.isDisabled(this.editor);
+        } catch {
+          now = false;
+        }
+      } else if (typeof item.command === "string" && canProxy) {
+        try {
+          const canCmd = canProxy[item.command];
+          if (canCmd) {
+            now = item.commandArgs?.length ? !canCmd(...item.commandArgs) : !canCmd();
+          }
+        } catch {
+          now = false;
+        }
+      }
+      if (was !== now) {
+        this._disabledMap.set(item.name, now);
+        changed = true;
+      }
+    }
+    if (changed) this.onChange();
+  }
+};
+
 // src/icons/phosphor.ts
 var defaultIcons = {
   // --- Format: Inline ---
@@ -4527,24 +5114,29 @@ var defaultIcons = {
   arrowClockwise: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M240,56v48a8,8,0,0,1-8,8H184a8,8,0,0,1,0-16H211.4L184.81,71.64l-.25-.24a80,80,0,1,0-1.67,114.78,8,8,0,0,1,11,11.63A95.44,95.44,0,0,1,128,224h-1.32A96,96,0,1,1,195.75,60L224,85.8V56a8,8,0,1,1,16,0Z"/></svg>',
   // --- Table ---
   table: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M224,48H32a8,8,0,0,0-8,8V192a16,16,0,0,0,16,16H216a16,16,0,0,0,16-16V56A8,8,0,0,0,224,48ZM40,112H80v32H40Zm56,0H216v32H96ZM216,64V96H40V64ZM40,160H80v32H40Zm176,32H96V160H216v32Z"/></svg>',
-  gridNine: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M216,48H40A16,16,0,0,0,24,64V192a16,16,0,0,0,16,16H216a16,16,0,0,0,16-16V64A16,16,0,0,0,216,48ZM104,144V112h48v32Zm48,16v32H104V160ZM40,112H88v32H40Zm64-16V64h48V96Zm64,16h48v32H168Zm48-16H168V64h48ZM88,64V96H40V64ZM40,160H88v32H40Zm176,32H168V160h48v32Z"/></svg>'
+  gridNine: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M216,48H40A16,16,0,0,0,24,64V192a16,16,0,0,0,16,16H216a16,16,0,0,0,16-16V64A16,16,0,0,0,216,48ZM104,144V112h48v32Zm48,16v32H104V160ZM40,112H88v32H40Zm64-16V64h48V96Zm64,16h48v32H168Zm48-16H168V64h48ZM88,64V96H40V64ZM40,160H88v32H40Zm176,32H168V160h48v32Z"/></svg>',
+  // --- Block Handle / Context Menu ---
+  plus: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M224,128a8,8,0,0,1-8,8H136v80a8,8,0,0,1-16,0V136H40a8,8,0,0,1,0-16h80V40a8,8,0,0,1,16,0v80h80A8,8,0,0,1,224,128Z"/></svg>',
+  dotsSixVertical: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M108,60A16,16,0,1,1,92,44,16,16,0,0,1,108,60Zm56,16A16,16,0,1,0,148,60,16,16,0,0,0,164,76ZM92,112a16,16,0,1,0,16,16A16,16,0,0,0,92,112Zm72,0a16,16,0,1,0,16,16A16,16,0,0,0,164,112ZM92,180a16,16,0,1,0,16,16A16,16,0,0,0,92,180Zm72,0a16,16,0,1,0,16,16A16,16,0,0,0,164,180Z"/></svg>',
+  dotsThree: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M140,128a12,12,0,1,1-12-12A12,12,0,0,1,140,128ZM64,116a12,12,0,1,0,12,12A12,12,0,0,0,64,116Zm128,0a12,12,0,1,0,12,12A12,12,0,0,0,192,116Z"/></svg>',
+  copy: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M216,32H88a8,8,0,0,0-8,8V80H40a8,8,0,0,0-8,8V216a8,8,0,0,0,8,8H168a8,8,0,0,0,8-8V176h40a8,8,0,0,0,8-8V40A8,8,0,0,0,216,32ZM160,208H48V96H160Zm48-48H176V88a8,8,0,0,0-8-8H96V48H208Z"/></svg>'
 };
 
 // src/nodes/Document.ts
-var Document = Node.create({
+var Document = Node2.create({
   name: "doc",
   topNode: true,
   content: "block+"
 });
 
 // src/nodes/Text.ts
-var Text = Node.create({
+var Text = Node2.create({
   name: "text",
   group: "inline"
 });
 
 // src/nodes/Paragraph.ts
-var Paragraph = Node.create({
+var Paragraph = Node2.create({
   name: "paragraph",
   group: "block",
   content: "inline*",
@@ -4577,7 +5169,7 @@ var Paragraph = Node.create({
     };
   }
 });
-var Heading = Node.create({
+var Heading = Node2.create({
   name: "heading",
   group: "block",
   content: "inline*",
@@ -4640,6 +5232,33 @@ var Heading = Node.create({
         return editor?.commands["toggleHeading"]?.({ level }) ?? false;
       };
     });
+    shortcuts["Enter"] = () => {
+      if (!editor) return false;
+      const { state, view } = editor;
+      const { selection } = state;
+      if (!selection.empty) return false;
+      const { $from } = selection;
+      if ($from.parent.type.name !== "heading") return false;
+      const paragraphType = state.schema.nodes["paragraph"];
+      if (!paragraphType) return false;
+      if ($from.parent.content.size === 0) {
+        view.dispatch(
+          state.tr.setNodeMarkup($from.before($from.depth), paragraphType).scrollIntoView()
+        );
+        return true;
+      }
+      if ($from.parentOffset !== $from.parent.content.size) return false;
+      const after = $from.after($from.depth);
+      const $after = state.doc.resolve(after);
+      const indexAfter = $after.index();
+      if (!$after.parent.canReplaceWith(indexAfter, indexAfter, paragraphType)) {
+        return false;
+      }
+      const tr = state.tr.insert(after, paragraphType.create());
+      tr.setSelection(TextSelection.create(tr.doc, after + 1));
+      view.dispatch(tr.scrollIntoView());
+      return true;
+    };
     return shortcuts;
   },
   addToolbarItems() {
@@ -4681,6 +5300,30 @@ var Heading = Node.create({
       }
     ];
   },
+  addFloatingMenuItems() {
+    const iconMap = {
+      1: "textHOne",
+      2: "textHTwo",
+      3: "textHThree"
+    };
+    const descriptionMap = {
+      1: "Big section heading",
+      2: "Medium section heading",
+      3: "Small section heading"
+    };
+    return this.options.levels.filter((level) => level <= 3).map((level) => ({
+      name: `heading-${String(level)}`,
+      label: `Heading ${String(level)}`,
+      description: descriptionMap[level] ?? "Section heading",
+      icon: iconMap[level] ?? "textH",
+      group: "Basic",
+      priority: 210 - level * 10,
+      keywords: ["heading", `h${String(level)}`, "title"],
+      shortcut: "#".repeat(level) + " ",
+      command: "toggleHeading",
+      commandArgs: [{ level }]
+    }));
+  },
   addProseMirrorPlugins() {
     const { options, editor } = this;
     const codeToLevel = {};
@@ -4754,7 +5397,7 @@ var Heading = Node.create({
 });
 
 // src/nodes/Blockquote.ts
-var Blockquote = Node.create({
+var Blockquote = Node2.create({
   name: "blockquote",
   group: "block",
   content: "block+",
@@ -4807,17 +5450,32 @@ var Blockquote = Node.create({
       }
     ];
   },
-  addInputRules() {
-    const { nodeType } = this;
-    if (!nodeType) {
-      return [];
-    }
+  addFloatingMenuItems() {
+    return [
+      {
+        name: "blockquote",
+        label: "Quote",
+        description: "Capture a quote",
+        icon: "quotes",
+        group: "Basic",
+        priority: 170,
+        keywords: ["quote", "blockquote", "citation"],
+        shortcut: "> ",
+        command: "toggleBlockquote"
+      }
+    ];
+  },
+  addInputRules() {
+    const { nodeType } = this;
+    if (!nodeType) {
+      return [];
+    }
     return [
       wrappingInputRule({ find: /^\s*>\s$/, type: nodeType })
     ];
   }
 });
-var CodeBlock = Node.create({
+var CodeBlock = Node2.create({
   name: "codeBlock",
   group: "block",
   content: "text*",
@@ -4937,6 +5595,21 @@ var CodeBlock = Node.create({
       }
     ];
   },
+  addFloatingMenuItems() {
+    return [
+      {
+        name: "code-block",
+        label: "Code block",
+        description: "Capture a code snippet",
+        icon: "codeBlock",
+        group: "Basic",
+        priority: 160,
+        keywords: ["code", "snippet", "pre"],
+        shortcut: "``` ",
+        command: "toggleCodeBlock"
+      }
+    ];
+  },
   addInputRules() {
     const { nodeType } = this;
     if (!nodeType) {
@@ -4954,6 +5627,7 @@ var CodeBlock = Node.create({
     ];
   }
 });
+var LIST_GROUP_TYPES = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
 function getListItemContext(editor, listItemName) {
   const { state, view } = editor;
   const listItemType = state.schema.nodes[listItemName];
@@ -5003,6 +5677,35 @@ var ListKeymap = Extension.create({
         const { state, view } = editor;
         const { $from, empty } = state.selection;
         if (!empty || $from.parentOffset !== 0) return false;
+        if ($from.parent.type.name === "paragraph" && $from.parent.content.size === 0 && $from.depth >= 1) {
+          const containerDepth = $from.depth - 1;
+          const idx = $from.index(containerDepth);
+          if (idx > 0) {
+            const container = $from.node(containerDepth);
+            const prev = container.child(idx - 1);
+            if (LIST_GROUP_TYPES.has(prev.type.name)) {
+              const paraStart = $from.before($from.depth);
+              const paraEnd = $from.after($from.depth);
+              const listEnd = paraStart;
+              const listStart = listEnd - prev.nodeSize;
+              let lastTextblockEnd = -1;
+              state.doc.nodesBetween(listStart, listEnd, (n, p) => {
+                if (n.isTextblock) lastTextblockEnd = p + 1 + n.content.size;
+                return true;
+              });
+              if (lastTextblockEnd !== -1) {
+                const tr = state.tr.delete(paraStart, paraEnd);
+                const next = idx + 1 < container.childCount ? container.child(idx + 1) : null;
+                if (next?.type === prev.type && canJoin(tr.doc, paraStart)) {
+                  tr.join(paraStart);
+                }
+                tr.setSelection(TextSelection.create(tr.doc, lastTextblockEnd));
+                view.dispatch(tr.scrollIntoView());
+                return true;
+              }
+            }
+          }
+        }
         const listItemType = state.schema.nodes[this.options.listItem];
         if (!listItemType) return false;
         let listItemDepth = -1;
@@ -5028,9 +5731,11 @@ var ListKeymap = Extension.create({
 });
 
 // src/nodes/ListItem.ts
-var ListItem = Node.create({
+var ListItem = Node2.create({
   name: "listItem",
-  content: "block+",
+  // Notion-strict: paragraph must be the first child (the "label" line aligned
+  // with the bullet); additional blocks render below as nested children.
+  content: "paragraph block*",
   defining: true,
   addOptions() {
     return {
@@ -5053,6 +5758,15 @@ var ListItem = Node.create({
         const { state, view } = this.editor;
         const { $from } = state.selection;
         if ($from.depth < 1 || $from.node(-1).type !== this.nodeType) return false;
+        if ($from.parent.type.name !== "paragraph") return false;
+        const ctx = getListItemCursorContext($from);
+        if (ctx?.isInChildrenZone) {
+          if (ctx.paragraphIsEmpty) {
+            if (insertChildrenZoneSibling(state, view.dispatch, ctx)) return true;
+          } else {
+            if (splitBlock(state, view.dispatch)) return true;
+          }
+        }
         if (splitListItem(this.nodeType)(state, view.dispatch)) return true;
         const listDepth = $from.depth - 2;
         const taskItemType = state.schema.nodes["taskItem"];
@@ -5071,13 +5785,25 @@ var ListItem = Node.create({
           }
         }
         return liftListItem(this.nodeType)(state, view.dispatch);
+      },
+      Backspace: () => {
+        if (!this.editor || !this.nodeType) return false;
+        const { state, view } = this.editor;
+        const { $from, empty } = state.selection;
+        if (!empty || $from.parentOffset !== 0) return false;
+        if ($from.parent.content.size !== 0) return false;
+        const ctx = getListItemCursorContext($from);
+        if (ctx && ctx.isInChildrenZone && ctx.paragraphIsEmpty) {
+          if (liftEmptyChildrenZoneParagraph(state, view.dispatch, ctx)) return true;
+        }
+        return false;
       }
     };
   }
 });
 
 // src/nodes/BulletList.ts
-var BulletList = Node.create({
+var BulletList = Node2.create({
   name: "bulletList",
   group: "block list",
   content: "listItem+",
@@ -5116,6 +5842,24 @@ var BulletList = Node.create({
       }
     ];
   },
+  addFloatingMenuItems() {
+    return [
+      {
+        name: "bullet-list",
+        label: "Bulleted list",
+        description: "Create a simple bulleted list",
+        icon: "listBullets",
+        group: "Lists",
+        priority: 200,
+        keywords: ["bullet", "list", "unordered", "ul"],
+        shortcut: "- ",
+        command: "toggleBulletList",
+        // Don't offer "Bulleted list" while cursor is already inside one,
+        // otherwise picking it lifts the user out of the list.
+        hideWhenInside: ["bulletList"]
+      }
+    ];
+  },
   addKeyboardShortcuts() {
     const { editor } = this;
     return {
@@ -5144,7 +5888,7 @@ var BulletList = Node.create({
 });
 
 // src/nodes/OrderedList.ts
-var OrderedList = Node.create({
+var OrderedList = Node2.create({
   name: "orderedList",
   group: "block list",
   content: "listItem+",
@@ -5201,6 +5945,22 @@ var OrderedList = Node.create({
       }
     ];
   },
+  addFloatingMenuItems() {
+    return [
+      {
+        name: "ordered-list",
+        label: "Numbered list",
+        description: "Create a numbered list",
+        icon: "listNumbers",
+        group: "Lists",
+        priority: 190,
+        keywords: ["ordered", "numbered", "list", "ol", "1."],
+        shortcut: "1. ",
+        command: "toggleOrderedList",
+        hideWhenInside: ["orderedList"]
+      }
+    ];
+  },
   addKeyboardShortcuts() {
     const { editor } = this;
     return {
@@ -5231,7 +5991,7 @@ var OrderedList = Node.create({
     ];
   }
 });
-var HorizontalRule = Node.create({
+var HorizontalRule = Node2.create({
   name: "horizontalRule",
   group: "block",
   addOptions() {
@@ -5252,19 +6012,31 @@ var HorizontalRule = Node.create({
         const { $from } = tr.selection;
         const parent = $from.parent;
         if (!parent.isTextblock) return false;
+        const paragraphType = state.schema.nodes["paragraph"];
+        const hrNode = this.nodeType.create();
+        const trailingParagraph = paragraphType?.create();
+        const nodes = trailingParagraph ? [hrNode, trailingParagraph] : [hrNode];
+        const listRange = splitListForInsert(state, tr);
+        if (listRange) {
+          if (!dispatch) return true;
+          tr.replaceWith(listRange.from, listRange.to, nodes);
+          const sel = TextSelection.findFrom(
+            tr.doc.resolve(listRange.from + 1),
+            1
+          );
+          if (sel) tr.setSelection(sel);
+          dispatch(tr.scrollIntoView());
+          return true;
+        }
         if (dispatch) {
           if (parent.content.size === 0 && parent.type.name === "paragraph") {
             const from = $from.before();
             const to = $from.after();
-            const paragraph = state.schema.nodes["paragraph"]?.create();
-            const nodes = paragraph ? [this.nodeType.create(), paragraph] : [this.nodeType.create()];
             tr.replaceWith(from, to, nodes);
             const sel = TextSelection.findFrom(tr.doc.resolve(from + 1), 1);
             if (sel) tr.setSelection(sel);
           } else {
             const end = $from.after();
-            const paragraph = state.schema.nodes["paragraph"]?.create();
-            const nodes = paragraph ? [this.nodeType.create(), paragraph] : [this.nodeType.create()];
             tr.insert(end, nodes);
             const sel = TextSelection.findFrom(tr.doc.resolve(end + 1), 1);
             if (sel) tr.setSelection(sel);
@@ -5288,6 +6060,21 @@ var HorizontalRule = Node.create({
       }
     ];
   },
+  addFloatingMenuItems() {
+    return [
+      {
+        name: "horizontal-rule",
+        label: "Divider",
+        description: "Insert a horizontal rule",
+        icon: "minus",
+        group: "Basic",
+        priority: 150,
+        keywords: ["divider", "hr", "line", "separator", "horizontal rule"],
+        shortcut: "--- ",
+        command: "setHorizontalRule"
+      }
+    ];
+  },
   addInputRules() {
     const { nodeType } = this;
     if (!nodeType) {
@@ -5318,7 +6105,7 @@ var HorizontalRule = Node.create({
 });
 
 // src/nodes/HardBreak.ts
-var HardBreak = Node.create({
+var HardBreak = Node2.create({
   name: "hardBreak",
   group: "inline",
   inline: true,
@@ -5378,9 +6165,84 @@ var HardBreak = Node.create({
     };
   }
 });
-var TaskItem = Node.create({
+
+// src/nodes/TaskItemNodeView.ts
+var TaskItemNodeView = class {
+  dom;
+  contentDOM;
+  label;
+  input;
+  view;
+  nodeType;
+  getPos;
+  node;
+  constructor({ options, node, view, getPos }) {
+    this.view = view;
+    this.nodeType = node.type;
+    this.node = node;
+    this.getPos = getPos;
+    this.dom = document.createElement("li");
+    for (const [key, value] of Object.entries(options.HTMLAttributes)) {
+      if (value !== null && value !== void 0) {
+        this.dom.setAttribute(key, typeof value === "string" ? value : JSON.stringify(value));
+      }
+    }
+    this.dom.setAttribute("data-type", "taskItem");
+    this.dom.setAttribute("data-checked", node.attrs["checked"] ? "true" : "false");
+    this.label = document.createElement("label");
+    this.label.setAttribute("contenteditable", "false");
+    this.input = document.createElement("input");
+    this.input.type = "checkbox";
+    this.input.checked = !!node.attrs["checked"];
+    this.input.disabled = !view.editable;
+    this.input.setAttribute("aria-label", "Task status");
+    this.label.appendChild(this.input);
+    this.dom.appendChild(this.label);
+    this.contentDOM = document.createElement("div");
+    this.dom.appendChild(this.contentDOM);
+    this.input.addEventListener("change", this.handleChange);
+  }
+  handleChange = (event) => {
+    event.preventDefault();
+    if (!this.view.editable) {
+      this.input.checked = !!this.node.attrs["checked"];
+      return;
+    }
+    const pos = this.getPos();
+    if (pos === void 0) return;
+    const { state, dispatch } = this.view;
+    const tr = state.tr.setNodeMarkup(pos, void 0, {
+      ...this.node.attrs,
+      checked: this.input.checked
+    });
+    dispatch(tr);
+  };
+  update(node) {
+    if (node.type !== this.nodeType) return false;
+    this.node = node;
+    const checked = !!node.attrs["checked"];
+    this.dom.setAttribute("data-checked", checked ? "true" : "false");
+    this.input.checked = checked;
+    this.input.disabled = !this.view.editable;
+    return true;
+  }
+  stopEvent(event) {
+    return event.target instanceof Node && this.label.contains(event.target);
+  }
+  ignoreMutation(mutation) {
+    return mutation.target instanceof Node && this.label.contains(mutation.target);
+  }
+  destroy() {
+    this.input.removeEventListener("change", this.handleChange);
+  }
+};
+
+// src/nodes/TaskItem.ts
+var TaskItem = Node2.create({
   name: "taskItem",
-  content: "block+",
+  // Paragraph must be the first child so flex alignment binds to the label
+  // baseline; a heading-first child would visually break the checkbox.
+  content: "paragraph block*",
   defining: true,
   addOptions() {
     return {
@@ -5434,6 +6296,10 @@ var TaskItem = Node.create({
       ["div", 0]
     ];
   },
+  addNodeView() {
+    const options = this.options;
+    return (node, view, getPos) => new TaskItemNodeView({ options, node, view, getPos });
+  },
   addCommands() {
     const { name } = this;
     return {
@@ -5469,7 +6335,16 @@ var TaskItem = Node.create({
         const { state, view } = this.editor;
         const { $from } = state.selection;
         if ($from.depth < 1 || $from.node(-1).type !== this.nodeType) return false;
-        if (splitListItem(this.nodeType)(state, view.dispatch)) return true;
+        if ($from.parent.type.name !== "paragraph") return false;
+        const ctx = getListItemCursorContext($from);
+        if (ctx?.isInChildrenZone) {
+          if (ctx.paragraphIsEmpty) {
+            if (insertChildrenZoneSibling(state, view.dispatch, ctx)) return true;
+          } else {
+            if (splitBlock(state, view.dispatch)) return true;
+          }
+        }
+        if (splitListItem(this.nodeType, { checked: false })(state, view.dispatch)) return true;
         if ($from.parent.content.size === 0) {
           const listItemType = state.schema.nodes["listItem"];
           if (listItemType) {
@@ -5525,6 +6400,12 @@ var TaskItem = Node.create({
         const { state, view } = this.editor;
         const { $from, empty } = state.selection;
         if (!empty || $from.parentOffset !== 0) return false;
+        if ($from.parent.content.size === 0) {
+          const ctx = getListItemCursorContext($from);
+          if (ctx && ctx.isInChildrenZone && ctx.paragraphIsEmpty) {
+            if (liftEmptyChildrenZoneParagraph(state, view.dispatch, ctx)) return true;
+          }
+        }
         let taskItemDepth = -1;
         for (let d = $from.depth; d > 0; d--) {
           if ($from.node(d).type === this.nodeType) {
@@ -5544,7 +6425,7 @@ var TaskItem = Node.create({
 });
 
 // src/nodes/TaskList.ts
-var TaskList = Node.create({
+var TaskList = Node2.create({
   name: "taskList",
   group: "block list",
   content: "taskItem+",
@@ -5605,6 +6486,22 @@ var TaskList = Node.create({
       }
     ];
   },
+  addFloatingMenuItems() {
+    return [
+      {
+        name: "task-list",
+        label: "To-do list",
+        description: "Track tasks with a checkbox list",
+        icon: "listChecks",
+        group: "Lists",
+        priority: 180,
+        keywords: ["todo", "task", "checkbox", "check"],
+        shortcut: "[ ] ",
+        command: "toggleTaskList",
+        hideWhenInside: ["taskList"]
+      }
+    ];
+  },
   addExtensions() {
     return [TaskItem];
   },
@@ -6530,7 +7427,8 @@ var TextStyle = Mark.create({
         getAttrs: (element) => {
           if (typeof element === "string") return false;
           const hasStyles = element.hasAttribute("style");
-          if (!hasStyles) return false;
+          const hasColorTokens = element.hasAttribute("data-text-color") || element.hasAttribute("data-bg-color");
+          if (!hasStyles && !hasColorTokens) return false;
           return {};
         }
       },
@@ -6799,6 +7697,123 @@ var Placeholder = Extension.create({
     ];
   }
 });
+var LIST_ITEM_TYPES3 = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var LIST_WRAPPER_TYPES2 = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
+function isCursorInsideListItem(state) {
+  const { $from } = state.selection;
+  for (let d = $from.depth; d > 0; d--) {
+    if (LIST_ITEM_TYPES3.has($from.node(d).type.name)) return true;
+  }
+  return false;
+}
+function indentBlockAsListChild(state, dispatch) {
+  const { selection } = state;
+  let blockIndex;
+  let blockNode;
+  let blockStart;
+  let blockEnd;
+  if (selection instanceof NodeSelection) {
+    const node = selection.node;
+    const $pos = selection.$from;
+    if ($pos.depth !== 0) return false;
+    if (isCursorInsideListItem(state)) return false;
+    blockIndex = $pos.index(0);
+    blockNode = node;
+    blockStart = selection.from;
+    blockEnd = selection.to;
+  } else {
+    if (!selection.empty) return false;
+    if (isCursorInsideListItem(state)) return false;
+    const { $from } = selection;
+    if ($from.depth !== 1) return false;
+    blockIndex = $from.index(0);
+    blockNode = $from.node(1);
+    blockStart = $from.before(1);
+    blockEnd = $from.after(1);
+  }
+  if (blockIndex === 0) return false;
+  const prevSibling = state.doc.child(blockIndex - 1);
+  if (!LIST_WRAPPER_TYPES2.has(prevSibling.type.name)) return false;
+  let wrapperPos = 0;
+  for (let i = 0; i < blockIndex - 1; i++) {
+    wrapperPos += state.doc.child(i).nodeSize;
+  }
+  const tr = state.tr;
+  const result = insertAsListItemChild({
+    tr,
+    wrapperPos,
+    blockNode,
+    sourceRange: { from: blockStart, to: blockEnd }
+  });
+  if (!result.ok || result.insertedAt === void 0) return false;
+  if (!dispatch) return true;
+  tr.setSelection(Selection.near(tr.doc.resolve(result.insertedAt + 1)));
+  dispatch(tr.scrollIntoView());
+  return true;
+}
+function outdentBlockFromListItem(state, dispatch) {
+  const { selection } = state;
+  if (!selection.empty) return false;
+  const { $from } = selection;
+  let listItemDepth = -1;
+  for (let d = $from.depth; d > 0; d--) {
+    if (LIST_ITEM_TYPES3.has($from.node(d).type.name)) {
+      listItemDepth = d;
+      break;
+    }
+  }
+  if (listItemDepth === -1) return false;
+  const blockDepth = listItemDepth + 1;
+  if ($from.depth < blockDepth) return false;
+  const listItem = $from.node(listItemDepth);
+  const blockIndexInItem = $from.index(listItemDepth);
+  if (blockIndexInItem === 0) return false;
+  if (blockIndexInItem !== listItem.childCount - 1) return false;
+  const wrapperDepth = listItemDepth - 1;
+  if (wrapperDepth < 0) return false;
+  const liIndexInWrapper = $from.index(wrapperDepth);
+  const wrapper = $from.node(wrapperDepth);
+  if (liIndexInWrapper !== wrapper.childCount - 1) return false;
+  if (wrapperDepth - 1 < 0) return false;
+  const wrapperParent = $from.node(wrapperDepth - 1);
+  const wrapperIndexInParent = $from.index(wrapperDepth - 1);
+  const blockNode = $from.node(blockDepth);
+  if (!wrapperParent.canReplaceWith(
+    wrapperIndexInParent + 1,
+    wrapperIndexInParent + 1,
+    blockNode.type
+  )) {
+    return false;
+  }
+  if (!dispatch) return true;
+  const blockStart = $from.before(blockDepth);
+  const blockEnd = $from.after(blockDepth);
+  const wrapperEnd = $from.after(wrapperDepth);
+  const tr = state.tr;
+  const blockSize = blockEnd - blockStart;
+  tr.delete(blockStart, blockEnd);
+  const insertAt = wrapperEnd - blockSize;
+  tr.insert(insertAt, blockNode);
+  tr.setSelection(Selection.near(tr.doc.resolve(insertAt + 1)));
+  dispatch(tr.scrollIntoView());
+  return true;
+}
+var ListIndent = Extension.create({
+  name: "listIndent",
+  addKeyboardShortcuts() {
+    const { editor } = this;
+    return {
+      Tab: () => {
+        if (!editor) return false;
+        return indentBlockAsListChild(editor.state, editor.view.dispatch);
+      },
+      "Shift-Tab": () => {
+        if (!editor) return false;
+        return outdentBlockFromListItem(editor.state, editor.view.dispatch);
+      }
+    };
+  }
+});
 var characterCountPluginKey = new PluginKey("characterCount");
 var CharacterCount = Extension.create({
   name: "characterCount",
@@ -7225,6 +8240,10 @@ var LineHeight = Extension.create({
   }
 });
 function generateUUID() {
+  if (typeof globalThis !== "undefined") {
+    const c = globalThis.crypto;
+    if (c && typeof c.randomUUID === "function") return c.randomUUID();
+  }
   return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
     const r = Math.random() * 16 | 0;
     const v = c === "x" ? r : r & 3 | 8;
@@ -7310,15 +8329,31 @@ var UniqueID = Extension.create({
       );
     };
     const assignMissingIDs = (doc, tr) => {
+      const seen = /* @__PURE__ */ new Set();
       doc.descendants((node, pos) => {
         if (!types.includes(node.type.name)) return;
         const existingID = node.attrs[attributeName];
         if (!existingID) {
-          tr.setNodeMarkup(pos, void 0, {
+          let id = generateID();
+          while (seen.has(id)) id = generateID();
+          seen.add(id);
+          tr.setNodeMarkup(tr.mapping.map(pos), void 0, {
+            ...node.attrs,
+            [attributeName]: id
+          });
+          return;
+        }
+        if (seen.has(existingID)) {
+          let id = generateID();
+          while (seen.has(id)) id = generateID();
+          seen.add(id);
+          tr.setNodeMarkup(tr.mapping.map(pos), void 0, {
             ...node.attrs,
-            [attributeName]: generateID()
+            [attributeName]: id
           });
+          return;
         }
+        seen.add(existingID);
       });
     };
     return [
@@ -7355,7 +8390,148 @@ var UniqueID = Extension.create({
     ];
   }
 });
-var Selection3 = Extension.create({
+
+// src/extensions/BlockColor.ts
+var DEFAULT_BLOCK_COLORS = [
+  "gray",
+  "brown",
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "pink",
+  "red"
+];
+var DEFAULT_BLOCK_COLOR_TYPES = [
+  "paragraph",
+  "heading",
+  "blockquote",
+  "bulletList",
+  "orderedList",
+  "taskList",
+  "listItem",
+  "taskItem"
+];
+function stripInlineColorConflicts(tr, state, from, to, which) {
+  const textStyleType = state.schema.marks["textStyle"];
+  if (!textStyleType) return;
+  const inlineKeys = [];
+  if (which === "text" || which === "both") inlineKeys.push("color", "colorToken");
+  if (which === "bg" || which === "both") inlineKeys.push("backgroundColor", "backgroundColorToken");
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isText) return true;
+    const existing = node.marks.find((m) => m.type === textStyleType);
+    if (!existing) return false;
+    const hasConflict = inlineKeys.some((k) => existing.attrs[k] !== null && existing.attrs[k] !== void 0);
+    if (!hasConflict) return false;
+    const start = Math.max(pos, from);
+    const end = Math.min(pos + node.nodeSize, to);
+    const newAttrs = { ...existing.attrs };
+    for (const k of inlineKeys) newAttrs[k] = null;
+    const stillUsed = Object.values(newAttrs).some((v) => v !== null && v !== void 0);
+    tr.removeMark(start, end, existing);
+    if (stillUsed) tr.addMark(start, end, textStyleType.create(newAttrs));
+    return false;
+  });
+}
+var BlockColor = Extension.create({
+  name: "blockColor",
+  addOptions() {
+    return {
+      types: DEFAULT_BLOCK_COLOR_TYPES,
+      bgColors: DEFAULT_BLOCK_COLORS,
+      textColors: DEFAULT_BLOCK_COLORS
+    };
+  },
+  // Defensive fallback: an empty `bgColors`/`textColors` array would render
+  // a broken Colors UI (section title with only the null-reset swatch).
+  // Replace empties with the default palette so users who pass `{}` as an
+  // override still get a working picker. Runs AFTER `addOptions()` merges
+  // user config with defaults, so this only fires for explicit empty arrays.
+  onBeforeCreate() {
+    if (this.options.bgColors.length === 0) this.options.bgColors = DEFAULT_BLOCK_COLORS;
+    if (this.options.textColors.length === 0) this.options.textColors = DEFAULT_BLOCK_COLORS;
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          bgColor: {
+            default: null,
+            parseHTML: (element) => element.getAttribute("data-bg-color"),
+            renderHTML: (attributes) => {
+              const v = attributes["bgColor"];
+              if (!v) return null;
+              return { "data-bg-color": v };
+            }
+          },
+          textColor: {
+            default: null,
+            parseHTML: (element) => element.getAttribute("data-text-color"),
+            renderHTML: (attributes) => {
+              const v = attributes["textColor"];
+              if (!v) return null;
+              return { "data-text-color": v };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    const types = this.options.types;
+    const bgColors = this.options.bgColors;
+    const textColors = this.options.textColors;
+    function findTargetPos(state) {
+      const { $from } = state.selection;
+      for (let depth = $from.depth; depth >= 0; depth--) {
+        const node = $from.node(depth);
+        if (types.includes(node.type.name)) {
+          return depth === 0 ? 0 : $from.before(depth);
+        }
+      }
+      return null;
+    }
+    function setAttr(attr, palette) {
+      return (color) => ({ state, dispatch }) => {
+        if (color !== null && !palette.includes(color)) return false;
+        const pos = findTargetPos(state);
+        if (pos === null) return false;
+        const node = state.doc.nodeAt(pos);
+        if (!node) return false;
+        if (dispatch) {
+          const tr = state.tr.setNodeMarkup(pos, void 0, { ...node.attrs, [attr]: color });
+          stripInlineColorConflicts(tr, state, pos, pos + node.nodeSize, attr === "textColor" ? "text" : "bg");
+          dispatch(tr);
+        }
+        return true;
+      };
+    }
+    return {
+      setBlockBgColor: setAttr("bgColor", bgColors),
+      setBlockTextColor: setAttr("textColor", textColors),
+      unsetBlockColors: () => ({ state, dispatch }) => {
+        const pos = findTargetPos(state);
+        if (pos === null) return false;
+        const node = state.doc.nodeAt(pos);
+        if (!node) return false;
+        if (dispatch) {
+          const tr = state.tr.setNodeMarkup(pos, void 0, {
+            ...node.attrs,
+            bgColor: null,
+            textColor: null
+          });
+          stripInlineColorConflicts(tr, state, pos, pos + node.nodeSize, "both");
+          dispatch(tr);
+        }
+        return true;
+      }
+    };
+  }
+});
+var Selection4 = Extension.create({
   name: "selection",
   addStorage() {
     return {
@@ -7745,9 +8921,19 @@ var TextColor = Extension.create({
             },
             renderHTML: (attributes) => {
               const color = attributes["color"];
-              if (!color) return null;
+              const token = attributes["colorToken"];
+              if (!color || token) return null;
               return { style: `color: ${color}` };
             }
+          },
+          colorToken: {
+            default: null,
+            parseHTML: (element) => element.getAttribute("data-text-color"),
+            renderHTML: (attributes) => {
+              const token = attributes["colorToken"];
+              if (!token) return null;
+              return { "data-text-color": token };
+            }
           }
         }
       }
@@ -7755,13 +8941,28 @@ var TextColor = Extension.create({
   },
   addCommands() {
     return {
+      // Hex-based color. Mutual exclusion: clears the named token so the
+      // legacy hex picker and Notion-style picker can't write conflicting
+      // values to the same mark.
       setTextColor: (color) => ({ commands }) => {
-        return commands.setMark("textStyle", { color });
+        return commands.setMark("textStyle", { color, colorToken: null });
       },
       unsetTextColor: () => ({ commands }) => {
         if (!commands.setMark("textStyle", { color: null })) return false;
         commands.removeEmptyTextStyle();
         return true;
+      },
+      // Named-token color. Mutual exclusion: clears the hex `color` so the
+      // theme-aware data attribute is the only source of truth.
+      setTextColorToken: (token) => ({ commands }) => {
+        if (!commands.setMark("textStyle", { colorToken: token, color: null })) return false;
+        if (token === null) commands.removeEmptyTextStyle();
+        return true;
+      },
+      unsetTextColorToken: () => ({ commands }) => {
+        if (!commands.setMark("textStyle", { colorToken: null })) return false;
+        commands.removeEmptyTextStyle();
+        return true;
       }
     };
   },
@@ -7863,9 +9064,19 @@ var Highlight = Extension.create({
             },
             renderHTML: (attributes) => {
               const bg = attributes["backgroundColor"];
-              if (!bg) return null;
+              const token = attributes["backgroundColorToken"];
+              if (!bg || token) return null;
               return { style: `background-color: ${bg}` };
             }
+          },
+          backgroundColorToken: {
+            default: null,
+            parseHTML: (element) => element.getAttribute("data-bg-color"),
+            renderHTML: (attributes) => {
+              const token = attributes["backgroundColorToken"];
+              if (!token) return null;
+              return { "data-bg-color": token };
+            }
           }
         }
       }
@@ -7874,9 +9085,12 @@ var Highlight = Extension.create({
   addCommands() {
     const defaultColor = this.options.defaultColor;
     return {
+      // Hex-based highlight. Mutual exclusion: clears any named bg token so
+      // the legacy hex picker and the Notion-style picker can't write
+      // conflicting values to the same mark.
       setHighlight: (attributes) => ({ commands }) => {
         const color = attributes?.color ?? defaultColor;
-        return commands.setMark("textStyle", { backgroundColor: color });
+        return commands.setMark("textStyle", { backgroundColor: color, backgroundColorToken: null });
       },
       unsetHighlight: () => ({ commands }) => {
         if (!commands.setMark("textStyle", { backgroundColor: null })) return false;
@@ -7892,12 +9106,12 @@ var Highlight = Extension.create({
         if (empty) {
           const marks = state.storedMarks ?? state.doc.resolve(from).marks();
           const mark = markType.isInSet(marks);
-          hasHighlight = !!mark?.attrs["backgroundColor"];
+          hasHighlight = !!mark?.attrs["backgroundColor"] || !!mark?.attrs["backgroundColorToken"];
         } else {
           state.doc.nodesBetween(from, to, (node) => {
             if (hasHighlight) return false;
             const mark = markType.isInSet(node.marks);
-            if (mark?.attrs["backgroundColor"]) {
+            if (mark?.attrs["backgroundColor"] || mark?.attrs["backgroundColorToken"]) {
               hasHighlight = true;
               return false;
             }
@@ -7905,11 +9119,26 @@ var Highlight = Extension.create({
           });
         }
         if (hasHighlight) {
-          commands.setMark("textStyle", { backgroundColor: null });
+          commands.setMark("textStyle", { backgroundColor: null, backgroundColorToken: null });
           commands.removeEmptyTextStyle();
           return true;
         }
-        return commands.setMark("textStyle", { backgroundColor: color });
+        return commands.setMark("textStyle", { backgroundColor: color, backgroundColorToken: null });
+      },
+      // Named-token highlight. Mutual exclusion: clears the hex
+      // backgroundColor so the theme-aware data attribute is the sole source
+      // of truth.
+      setBackgroundColorToken: (token) => ({ commands }) => {
+        if (!commands.setMark("textStyle", { backgroundColorToken: token, backgroundColor: null })) {
+          return false;
+        }
+        if (token === null) commands.removeEmptyTextStyle();
+        return true;
+      },
+      unsetBackgroundColorToken: () => ({ commands }) => {
+        if (!commands.setMark("textStyle", { backgroundColorToken: null })) return false;
+        commands.removeEmptyTextStyle();
+        return true;
       }
     };
   },
@@ -8153,6 +9382,61 @@ var FontSize = Extension.create({
   }
 });
 
+// src/extensions/NotionColorPicker.ts
+var DEFAULT_NOTION_COLOR_PALETTE = Object.freeze([
+  "gray",
+  "brown",
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "pink",
+  "red"
+]);
+var NotionColorPicker = Extension.create({
+  name: "notionColorPicker",
+  // The picker writes textStyle.colorToken / textStyle.backgroundColorToken,
+  // so TextStyle must be present. TextColor and Highlight are recommended
+  // (they own those attribute schemas) but not strictly required: a host app
+  // could supply its own attribute providers if it really wants to.
+  dependencies: ["textStyle"],
+  addOptions() {
+    return {
+      palette: DEFAULT_NOTION_COLOR_PALETTE
+    };
+  },
+  addStorage() {
+    return {
+      isOpen: false
+    };
+  },
+  addToolbarItems() {
+    return [
+      {
+        type: "button",
+        name: "notionColor",
+        // emitEvent takes priority over `command` at click time. The `command`
+        // field is required by the ToolbarButton schema, so we point it at a
+        // harmless built-in that fires only if a host disables the popover UI.
+        command: "focus",
+        // The "A with an underline" glyph is the closest match in our icon
+        // set; the framework wrapper can repaint the underline to reflect
+        // the current selection's color.
+        icon: "textAUnderline",
+        label: "Text and background color",
+        emitEvent: "notionColorOpen",
+        group: "textStyle",
+        priority: 250,
+        // Bubble-menu-only: the legacy hex pickers (TextColor / Highlight)
+        // stay in the main toolbar; this token-based picker is a Notion-mode
+        // affordance surfaced beside the text-format buttons in the bubble.
+        toolbar: false
+      }
+    ];
+  }
+});
+
 // src/extensions/ClearFormatting.ts
 var ClearFormatting = Extension.create({
   name: "clearFormatting",
@@ -8241,9 +9525,17 @@ function linkPopoverPlugin({ editor, markType, protocols }) {
         return new DOMRect(coords.left, coords.top, 0, coords.bottom - coords.top);
       }
     };
+    if (anchorElement) {
+      const editorEl = anchorElement.closest(".dm-editor");
+      if (editorEl && el.parentElement !== editorEl) {
+        editorEl.appendChild(el);
+      }
+    } else if (el.parentElement !== document.body) {
+      document.body.appendChild(el);
+    }
     cleanupFloating?.();
     cleanupFloating = positionFloating(reference, el, {
-      placement: "bottom",
+      placement: anchorElement ? "bottom-start" : "bottom",
       offsetValue: 4
     });
     input.focus();
@@ -8500,6 +9792,7 @@ function createBubbleMenuPlugin(options) {
     if (!target) return;
     if (element.contains(target)) return;
     if (editor.view.dom.contains(target)) return;
+    if (target instanceof HTMLElement && target.closest("[data-dm-editor-ui]")) return;
     hideMenu();
     suppressed = true;
   };
@@ -8576,8 +9869,10 @@ function createBubbleMenuPlugin(options) {
         });
       };
       const onBlur = ({ event }) => {
-        if (event.relatedTarget && element.contains(event.relatedTarget)) {
-          return;
+        const related = event.relatedTarget;
+        if (related instanceof HTMLElement) {
+          if (element.contains(related)) return;
+          if (related.closest("[data-dm-editor-ui]")) return;
         }
         hideMenu();
       };
@@ -8677,132 +9972,6 @@ var BubbleMenu = Extension.create({
     ];
   }
 });
-var floatingMenuPluginKey = new PluginKey("floatingMenu");
-function defaultShouldShow2({
-  editor,
-  state
-}) {
-  if (!editor.isEditable) return false;
-  const { selection } = state;
-  const { $from, empty } = selection;
-  if (!empty) return false;
-  if ($from.parent.type.name !== "paragraph") return false;
-  if ($from.parent.content.size !== 0) return false;
-  if ($from.parentOffset !== 0) return false;
-  return true;
-}
-function createFloatingMenuPlugin(options) {
-  const {
-    pluginKey,
-    editor,
-    element,
-    shouldShow = defaultShouldShow2,
-    offset: offset2 = 0
-  } = options;
-  if (!element.getAttribute("role")) {
-    element.setAttribute("role", "toolbar");
-    element.setAttribute("aria-label", "Floating menu");
-  }
-  let cleanupFloating = null;
-  const updatePosition = (view) => {
-    const { selection } = view.state;
-    const { $from } = selection;
-    const depth = $from.depth;
-    const startPos = $from.start(depth);
-    const domNode = view.nodeDOM(startPos - 1);
-    if (domNode instanceof HTMLElement) {
-      cleanupFloating?.();
-      cleanupFloating = positionFloatingOnce(domNode, element, {
-        placement: "bottom-start",
-        offsetValue: offset2
-      });
-      element.setAttribute("data-show", "");
-    }
-  };
-  const hideMenu = () => {
-    cleanupFloating?.();
-    cleanupFloating = null;
-    element.removeAttribute("data-show");
-  };
-  hideMenu();
-  return new Plugin({
-    key: pluginKey,
-    view: (editorView) => {
-      const editorEl = editorView.dom.closest(".dm-editor");
-      if (editorEl && element.parentElement !== editorEl) {
-        editorEl.appendChild(element);
-      }
-      const onFocus = () => {
-        const visible = shouldShow({
-          editor,
-          view: editor.view,
-          state: editor.view.state
-        });
-        if (visible) {
-          updatePosition(editor.view);
-        } else {
-          hideMenu();
-        }
-      };
-      const onBlur = ({ event }) => {
-        if (event.relatedTarget && element.contains(event.relatedTarget)) {
-          return;
-        }
-        hideMenu();
-      };
-      editor.on("focus", onFocus);
-      editor.on("blur", onBlur);
-      return {
-        update: (view) => {
-          const visible = shouldShow({
-            editor,
-            view,
-            state: view.state
-          });
-          if (visible) {
-            updatePosition(view);
-          } else {
-            hideMenu();
-          }
-        },
-        destroy: () => {
-          hideMenu();
-          editor.off("focus", onFocus);
-          editor.off("blur", onBlur);
-        }
-      };
-    }
-  });
-}
-var FloatingMenu = Extension.create({
-  name: "floatingMenu",
-  addOptions() {
-    return {
-      element: null,
-      shouldShow: defaultShouldShow2,
-      offset: 0
-    };
-  },
-  addProseMirrorPlugins() {
-    const { element, shouldShow, offset: offset2 } = this.options;
-    if (!element) {
-      return [];
-    }
-    const editor = this.editor;
-    if (!editor) {
-      return [];
-    }
-    return [
-      createFloatingMenuPlugin({
-        pluginKey: floatingMenuPluginKey,
-        editor,
-        element,
-        shouldShow,
-        offset: offset2
-      })
-    ];
-  }
-});
 
 // src/extensions/StarterKit.ts
 var StarterKit = Extension.create({
@@ -8845,6 +10014,7 @@ var StarterKit = Extension.create({
     maybeAdd(Gapcursor, this.options.gapcursor);
     maybeAdd(TrailingNode, this.options.trailingNode);
     maybeAdd(ListKeymap, this.options.listKeymap);
+    maybeAdd(ListIndent, this.options.listIndent);
     maybeAdd(LinkPopover, this.options.linkPopover);
     maybeAdd(SelectionDecoration, this.options.selectionDecoration);
     return extensions;
@@ -8854,6 +10024,6 @@ var StarterKit = Extension.create({
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { BaseKeymap, Blockquote, Bold, BubbleMenu, BulletList, CanChecker, ChainBuilder, CharacterCount, ClearFormatting, Code, CodeBlock, CommandManager, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_TEXT_COLORS, Document, Dropcursor, Editor, EventEmitter, Extension, ExtensionManager, FloatingMenu, Focus, FontFamily, FontSize, Gapcursor, HardBreak, Heading, Highlight, History, HorizontalRule, InvisibleChars, Italic, LineHeight, Link, LinkPopover, ListItem, ListKeymap, Mark, Node, OrderedList, Paragraph, Placeholder, Selection3 as Selection, SelectionDecoration, StarterKit, Strike, Subscript, Superscript, TaskItem, TaskList, Text, TextAlign, TextColor, TextStyle, ToolbarController, TrailingNode, Typography, Underline, UniqueID, VERSION, 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 { BaseKeymap, BlockColor, Blockquote, Bold, BubbleMenu, BulletList, CanChecker, ChainBuilder, CharacterCount, ClearFormatting, Code, CodeBlock, CommandManager, DEFAULT_BLOCK_COLORS, DEFAULT_BLOCK_COLOR_TYPES, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_NOTION_COLOR_PALETTE, DEFAULT_TEXT_COLORS, Document, Dropcursor, Editor, EventEmitter, Extension, ExtensionManager, FLOATING_MENU_NO_FOCUS, FloatingMenuController, Focus, FontFamily, FontSize, Gapcursor, HardBreak, Heading, Highlight, History, HorizontalRule, InvisibleChars, Italic, LIST_ITEM_TYPE_NAMES, LineHeight, Link, LinkPopover, ListIndent, ListItem, ListKeymap, Mark, Node2 as Node, NotionColorPicker, OrderedList, Paragraph, Placeholder, Selection4 as Selection, SelectionDecoration, StarterKit, Strike, Subscript, Superscript, TaskItem, TaskList, Text, TextAlign, TextColor, TextStyle, ToolbarController, TrailingNode, Typography, Underline, UniqueID, VERSION, applyInlineStyles, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map