@domternal/core 0.6.1 → 0.7.0

package/dist/index.cjs

@@ -271,6 +271,10 @@ var ExtensionManager = class {
    * Cached toolbar items (collected lazily)
    */
   _toolbarItems = null;
+  /**
+   * Cached floating-menu items (collected lazily)
+   */
+  _floatingMenuItems = null;
   /**
    * Cached node views (collected lazily)
    */
@@ -344,6 +348,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
    */
@@ -360,6 +372,7 @@ var ExtensionManager = class {
     this._plugins = null;
     this._commands = null;
     this._toolbarItems = null;
+    this._floatingMenuItems = null;
     this._nodeViews = null;
   }
   // === Extension Processing ===
@@ -406,7 +419,7 @@ var ExtensionManager = class {
     });
   }
   /**
-   * Detects duplicate extension names (AD-7: Schema Conflict Detection)
+   * Detects duplicate extension names.
    * @throws Error if duplicate names found
    */
   detectConflicts() {
@@ -707,6 +720,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.
@@ -1477,7 +1509,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 } })
    */
@@ -1631,25 +1663,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;
@@ -1924,6 +1943,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 schemaList.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) {
@@ -1947,7 +2000,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;
@@ -1992,9 +2064,22 @@ var wrapIn = (nodeName, attributes) => ({ state, tr, dispatch }) => {
   const range = $from.blockRange($to);
   if (!range) return false;
   const wrapping = transform.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 = transform.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;
 };
@@ -2089,6 +2174,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--) {
@@ -2235,6 +2344,19 @@ var toggleList = (listNodeName, listItemNodeName, attributes) => ({ state: state
     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 && schemaList.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);
@@ -2893,8 +3015,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');
@@ -3373,12 +3495,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
@@ -3629,9 +3757,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;
@@ -3746,7 +3873,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: {
@@ -3879,8 +4006,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$1, dispatch, ctx) {
+  if (!ctx.isInChildrenZone || !ctx.paragraphIsEmpty) return false;
+  const { $from } = state$1.selection;
+  if ($from.parent.type.name !== "paragraph") return false;
+  if ($from.parent.content.size !== 0) return false;
+  const paragraphType = state$1.schema.nodes["paragraph"];
+  if (!paragraphType) return false;
+  const range = $from.blockRange();
+  if (range) {
+    const target = transform.liftTarget(range);
+    if (target !== null) {
+      if (!dispatch) return true;
+      const tr2 = state$1.tr.lift(range, target);
+      const oldParaStart = $from.before($from.depth);
+      const newParaStart = tr2.mapping.map(oldParaStart);
+      tr2.setSelection(state.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$1.doc.nodeAt(ctx.itemPos);
+  if (!itemNode) return false;
+  const itemEnd = ctx.itemPos + itemNode.nodeSize;
+  const wrapperNode = state$1.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$1.tr;
+  if (isLastItem) {
+    tr.delete(paraStart, paraEnd);
+    const insertPos = tr.mapping.map(wrapperEnd);
+    tr.insert(insertPos, newPara);
+    tr.setSelection(state.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(state.TextSelection.create(tr.doc, insertPos + 1));
+  }
+  dispatch(tr.scrollIntoView());
+  return true;
+}
+function insertChildrenZoneSibling(state$1, dispatch, ctx) {
+  if (!ctx.isInChildrenZone || !ctx.paragraphIsEmpty) return false;
+  const paragraphType = state$1.schema.nodes["paragraph"];
+  if (!paragraphType) return false;
+  const { $from } = state$1.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$1.tr.insert(insertPos, paragraphType.create());
+  tr.setSelection(state.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 = schemaList.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
@@ -3942,25 +4286,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 = {
@@ -4134,7 +4465,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;
@@ -4469,6 +4800,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 ---
@@ -4528,24 +5115,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*",
@@ -4578,7 +5170,7 @@ var Paragraph = Node.create({
     };
   }
 });
-var Heading = Node.create({
+var Heading = Node2.create({
   name: "heading",
   group: "block",
   content: "inline*",
@@ -4641,6 +5233,33 @@ var Heading = Node.create({
         return editor?.commands["toggleHeading"]?.({ level }) ?? false;
       };
     });
+    shortcuts["Enter"] = () => {
+      if (!editor) return false;
+      const { state: state$1, view } = editor;
+      const { selection } = state$1;
+      if (!selection.empty) return false;
+      const { $from } = selection;
+      if ($from.parent.type.name !== "heading") return false;
+      const paragraphType = state$1.schema.nodes["paragraph"];
+      if (!paragraphType) return false;
+      if ($from.parent.content.size === 0) {
+        view.dispatch(
+          state$1.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$1.doc.resolve(after);
+      const indexAfter = $after.index();
+      if (!$after.parent.canReplaceWith(indexAfter, indexAfter, paragraphType)) {
+        return false;
+      }
+      const tr = state$1.tr.insert(after, paragraphType.create());
+      tr.setSelection(state.TextSelection.create(tr.doc, after + 1));
+      view.dispatch(tr.scrollIntoView());
+      return true;
+    };
     return shortcuts;
   },
   addToolbarItems() {
@@ -4682,6 +5301,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 = {};
@@ -4755,7 +5398,7 @@ var Heading = Node.create({
 });
 
 // src/nodes/Blockquote.ts
-var Blockquote = Node.create({
+var Blockquote = Node2.create({
   name: "blockquote",
   group: "block",
   content: "block+",
@@ -4808,6 +5451,21 @@ var Blockquote = Node.create({
       }
     ];
   },
+  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) {
@@ -4818,7 +5476,7 @@ var Blockquote = Node.create({
     ];
   }
 });
-var CodeBlock = Node.create({
+var CodeBlock = Node2.create({
   name: "codeBlock",
   group: "block",
   content: "text*",
@@ -4938,6 +5596,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) {
@@ -4955,6 +5628,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];
@@ -5001,10 +5675,39 @@ var ListKeymap = Extension.create({
       Backspace: () => {
         const editor = this.editor;
         if (!editor) return false;
-        const { state, view } = editor;
-        const { $from, empty } = state.selection;
+        const { state: state$1, view } = editor;
+        const { $from, empty } = state$1.selection;
         if (!empty || $from.parentOffset !== 0) return false;
-        const listItemType = state.schema.nodes[this.options.listItem];
+        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$1.doc.nodesBetween(listStart, listEnd, (n, p) => {
+                if (n.isTextblock) lastTextblockEnd = p + 1 + n.content.size;
+                return true;
+              });
+              if (lastTextblockEnd !== -1) {
+                const tr = state$1.tr.delete(paraStart, paraEnd);
+                const next = idx + 1 < container.childCount ? container.child(idx + 1) : null;
+                if (next?.type === prev.type && transform.canJoin(tr.doc, paraStart)) {
+                  tr.join(paraStart);
+                }
+                tr.setSelection(state.TextSelection.create(tr.doc, lastTextblockEnd));
+                view.dispatch(tr.scrollIntoView());
+                return true;
+              }
+            }
+          }
+        }
+        const listItemType = state$1.schema.nodes[this.options.listItem];
         if (!listItemType) return false;
         let listItemDepth = -1;
         for (let d = $from.depth; d > 0; d--) {
@@ -5019,7 +5722,7 @@ var ListKeymap = Extension.create({
         if (firstChild?.isTextblock) {
           const posInListItem = $from.pos - $from.start(listItemDepth);
           if (posInListItem <= 1) {
-            return schemaList.liftListItem(listItemType)(state, view.dispatch);
+            return schemaList.liftListItem(listItemType)(state$1, view.dispatch);
           }
         }
         return false;
@@ -5029,9 +5732,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 {
@@ -5054,6 +5759,15 @@ var ListItem = Node.create({
         const { state: state$1, view } = this.editor;
         const { $from } = state$1.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$1, view.dispatch, ctx)) return true;
+          } else {
+            if (commands.splitBlock(state$1, view.dispatch)) return true;
+          }
+        }
         if (schemaList.splitListItem(this.nodeType)(state$1, view.dispatch)) return true;
         const listDepth = $from.depth - 2;
         const taskItemType = state$1.schema.nodes["taskItem"];
@@ -5072,13 +5786,25 @@ var ListItem = Node.create({
           }
         }
         return schemaList.liftListItem(this.nodeType)(state$1, 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+",
@@ -5117,6 +5843,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 {
@@ -5145,7 +5889,7 @@ var BulletList = Node.create({
 });
 
 // src/nodes/OrderedList.ts
-var OrderedList = Node.create({
+var OrderedList = Node2.create({
   name: "orderedList",
   group: "block list",
   content: "listItem+",
@@ -5202,6 +5946,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 {
@@ -5232,7 +5992,7 @@ var OrderedList = Node.create({
     ];
   }
 });
-var HorizontalRule = Node.create({
+var HorizontalRule = Node2.create({
   name: "horizontalRule",
   group: "block",
   addOptions() {
@@ -5253,19 +6013,31 @@ var HorizontalRule = Node.create({
         const { $from } = tr.selection;
         const parent = $from.parent;
         if (!parent.isTextblock) return false;
+        const paragraphType = state$1.schema.nodes["paragraph"];
+        const hrNode = this.nodeType.create();
+        const trailingParagraph = paragraphType?.create();
+        const nodes = trailingParagraph ? [hrNode, trailingParagraph] : [hrNode];
+        const listRange = splitListForInsert(state$1, tr);
+        if (listRange) {
+          if (!dispatch) return true;
+          tr.replaceWith(listRange.from, listRange.to, nodes);
+          const sel = state.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$1.schema.nodes["paragraph"]?.create();
-            const nodes = paragraph ? [this.nodeType.create(), paragraph] : [this.nodeType.create()];
             tr.replaceWith(from, to, nodes);
             const sel = state.TextSelection.findFrom(tr.doc.resolve(from + 1), 1);
             if (sel) tr.setSelection(sel);
           } else {
             const end = $from.after();
-            const paragraph = state$1.schema.nodes["paragraph"]?.create();
-            const nodes = paragraph ? [this.nodeType.create(), paragraph] : [this.nodeType.create()];
             tr.insert(end, nodes);
             const sel = state.TextSelection.findFrom(tr.doc.resolve(end + 1), 1);
             if (sel) tr.setSelection(sel);
@@ -5289,6 +6061,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) {
@@ -5319,7 +6106,7 @@ var HorizontalRule = Node.create({
 });
 
 // src/nodes/HardBreak.ts
-var HardBreak = Node.create({
+var HardBreak = Node2.create({
   name: "hardBreak",
   group: "inline",
   inline: true,
@@ -5379,9 +6166,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 {
@@ -5435,6 +6297,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 {
@@ -5470,7 +6336,16 @@ var TaskItem = Node.create({
         const { state: state$1, view } = this.editor;
         const { $from } = state$1.selection;
         if ($from.depth < 1 || $from.node(-1).type !== this.nodeType) return false;
-        if (schemaList.splitListItem(this.nodeType)(state$1, 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$1, view.dispatch, ctx)) return true;
+          } else {
+            if (commands.splitBlock(state$1, view.dispatch)) return true;
+          }
+        }
+        if (schemaList.splitListItem(this.nodeType, { checked: false })(state$1, view.dispatch)) return true;
         if ($from.parent.content.size === 0) {
           const listItemType = state$1.schema.nodes["listItem"];
           if (listItemType) {
@@ -5526,6 +6401,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) {
@@ -5545,7 +6426,7 @@ var TaskItem = Node.create({
 });
 
 // src/nodes/TaskList.ts
-var TaskList = Node.create({
+var TaskList = Node2.create({
   name: "taskList",
   group: "block list",
   content: "taskItem+",
@@ -5606,6 +6487,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];
   },
@@ -6531,7 +7428,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 {};
         }
       },
@@ -6800,6 +7698,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$1, dispatch) {
+  const { selection } = state$1;
+  let blockIndex;
+  let blockNode;
+  let blockStart;
+  let blockEnd;
+  if (selection instanceof state.NodeSelection) {
+    const node = selection.node;
+    const $pos = selection.$from;
+    if ($pos.depth !== 0) return false;
+    if (isCursorInsideListItem(state$1)) return false;
+    blockIndex = $pos.index(0);
+    blockNode = node;
+    blockStart = selection.from;
+    blockEnd = selection.to;
+  } else {
+    if (!selection.empty) return false;
+    if (isCursorInsideListItem(state$1)) 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$1.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$1.doc.child(i).nodeSize;
+  }
+  const tr = state$1.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(state.Selection.near(tr.doc.resolve(result.insertedAt + 1)));
+  dispatch(tr.scrollIntoView());
+  return true;
+}
+function outdentBlockFromListItem(state$1, dispatch) {
+  const { selection } = state$1;
+  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$1.tr;
+  const blockSize = blockEnd - blockStart;
+  tr.delete(blockStart, blockEnd);
+  const insertAt = wrapperEnd - blockSize;
+  tr.insert(insertAt, blockNode);
+  tr.setSelection(state.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 state.PluginKey("characterCount");
 var CharacterCount = Extension.create({
   name: "characterCount",
@@ -7226,6 +8241,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;
@@ -7311,15 +8330,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]: generateID()
+            [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]: id
+          });
+          return;
+        }
+        seen.add(existingID);
       });
     };
     return [
@@ -7356,7 +8391,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 {
@@ -7746,9 +8922,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 };
+            }
           }
         }
       }
@@ -7756,13 +8942,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;
       }
     };
   },
@@ -7864,9 +9065,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 };
+            }
           }
         }
       }
@@ -7875,9 +9086,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;
@@ -7893,12 +9107,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;
             }
@@ -7906,11 +9120,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;
       }
     };
   },
@@ -8154,6 +9383,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",
@@ -8242,9 +9526,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();
@@ -8501,6 +9793,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;
   };
@@ -8577,8 +9870,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();
       };
@@ -8678,132 +9973,6 @@ var BubbleMenu = Extension.create({
     ];
   }
 });
-var floatingMenuPluginKey = new state.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 state.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({
@@ -8846,6 +10015,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;
@@ -8860,6 +10030,7 @@ Object.defineProperty(exports, "PluginKey", {
   get: function () { return state.PluginKey; }
 });
 exports.BaseKeymap = BaseKeymap;
+exports.BlockColor = BlockColor;
 exports.Blockquote = Blockquote;
 exports.Bold = Bold;
 exports.BubbleMenu = BubbleMenu;
@@ -8871,7 +10042,10 @@ exports.ClearFormatting = ClearFormatting;
 exports.Code = Code;
 exports.CodeBlock = CodeBlock;
 exports.CommandManager = CommandManager;
+exports.DEFAULT_BLOCK_COLORS = DEFAULT_BLOCK_COLORS;
+exports.DEFAULT_BLOCK_COLOR_TYPES = DEFAULT_BLOCK_COLOR_TYPES;
 exports.DEFAULT_HIGHLIGHT_COLORS = DEFAULT_HIGHLIGHT_COLORS;
+exports.DEFAULT_NOTION_COLOR_PALETTE = DEFAULT_NOTION_COLOR_PALETTE;
 exports.DEFAULT_TEXT_COLORS = DEFAULT_TEXT_COLORS;
 exports.Document = Document;
 exports.Dropcursor = Dropcursor;
@@ -8879,7 +10053,8 @@ exports.Editor = Editor;
 exports.EventEmitter = EventEmitter;
 exports.Extension = Extension;
 exports.ExtensionManager = ExtensionManager;
-exports.FloatingMenu = FloatingMenu;
+exports.FLOATING_MENU_NO_FOCUS = FLOATING_MENU_NO_FOCUS;
+exports.FloatingMenuController = FloatingMenuController;
 exports.Focus = Focus;
 exports.FontFamily = FontFamily;
 exports.FontSize = FontSize;
@@ -8891,17 +10066,20 @@ exports.History = History;
 exports.HorizontalRule = HorizontalRule;
 exports.InvisibleChars = InvisibleChars;
 exports.Italic = Italic;
+exports.LIST_ITEM_TYPE_NAMES = LIST_ITEM_TYPE_NAMES;
 exports.LineHeight = LineHeight;
 exports.Link = Link;
 exports.LinkPopover = LinkPopover;
+exports.ListIndent = ListIndent;
 exports.ListItem = ListItem;
 exports.ListKeymap = ListKeymap;
 exports.Mark = Mark;
-exports.Node = Node;
+exports.Node = Node2;
+exports.NotionColorPicker = NotionColorPicker;
 exports.OrderedList = OrderedList;
 exports.Paragraph = Paragraph;
 exports.Placeholder = Placeholder;
-exports.Selection = Selection3;
+exports.Selection = Selection4;
 exports.SelectionDecoration = SelectionDecoration;
 exports.StarterKit = StarterKit;
 exports.Strike = Strike;
@@ -8934,27 +10112,36 @@ exports.createBubbleMenuPlugin = createBubbleMenuPlugin;
 exports.createCanChecker = createCanChecker;
 exports.createChainBuilder = createChainBuilder;
 exports.createDocument = createDocument;
-exports.createFloatingMenuPlugin = createFloatingMenuPlugin;
 exports.defaultBlockAt = defaultBlockAt;
+exports.defaultBubbleContexts = defaultBubbleContexts;
 exports.defaultIcons = defaultIcons;
 exports.deleteSelection = deleteSelection;
 exports.findChildren = findChildren;
+exports.findListItemAncestorDepth = findListItemAncestorDepth;
 exports.findParentNode = findParentNode;
-exports.floatingMenuPluginKey = floatingMenuPluginKey;
 exports.focus = focus;
 exports.focusPluginKey = focusPluginKey;
 exports.generateHTML = generateHTML;
 exports.generateJSON = generateJSON;
 exports.generateText = generateText;
+exports.getListItemCursorContext = getListItemCursorContext;
 exports.getMarkRange = getMarkRange;
+exports.groupFloatingMenuItems = groupFloatingMenuItems;
+exports.indentBlockAsListChild = indentBlockAsListChild;
 exports.inlineStyles = inlineStyles;
+exports.insertAsListItemChild = insertAsListItemChild;
+exports.insertChildrenZoneSibling = insertChildrenZoneSibling;
 exports.insertContent = insertContent;
 exports.insertText = insertText;
 exports.invisibleCharsPluginKey = invisibleCharsPluginKey;
 exports.isDocumentEmpty = isDocumentEmpty;
+exports.isInListItemLabel = isInListItemLabel;
+exports.isInsideListItem = isInsideListItem;
 exports.isNodeEmpty = isNodeEmpty;
 exports.isValidUrl = isValidUrl;
 exports.lift = lift;
+exports.liftCurrentListItem = liftCurrentListItem;
+exports.liftEmptyChildrenZoneParagraph = liftEmptyChildrenZoneParagraph;
 exports.linkClickPlugin = linkClickPlugin;
 exports.linkClickPluginKey = linkClickPluginKey;
 exports.linkExitPlugin = linkExitPlugin;
@@ -8964,6 +10151,7 @@ exports.linkPastePluginKey = linkPastePluginKey;
 exports.markInputRule = markInputRule;
 exports.markInputRulePatterns = markInputRulePatterns;
 exports.nodeInputRule = nodeInputRule;
+exports.outdentBlockFromListItem = outdentBlockFromListItem;
 exports.placeholderPluginKey = placeholderPluginKey;
 exports.positionFloating = positionFloating;
 exports.positionFloatingOnce = positionFloatingOnce;
@@ -8974,6 +10162,8 @@ exports.selectionDecorationPluginKey = selectionDecorationPluginKey;
 exports.setBlockType = setBlockType;
 exports.setContent = setContent;
 exports.setMark = setMark;
+exports.splitListForInsert = splitListForInsert;
+exports.stripInlineColorConflicts = stripInlineColorConflicts;
 exports.textInputRule = textInputRule;
 exports.textblockTypeInputRule = textblockTypeInputRule;
 exports.toggleBlockType = toggleBlockType;
@@ -8986,5 +10176,6 @@ exports.unsetMark = unsetMark;
 exports.updateAttributes = updateAttributes;
 exports.wrapIn = wrapIn;
 exports.wrappingInputRule = wrappingInputRule;
+exports.writeToClipboard = writeToClipboard;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map