@slash-editor/core 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,1191 @@
+import { Editor, Extension, Extensions, Mark, Node, Range } from "@tiptap/core";
+import { Node as Node$1, NodeType } from "@tiptap/pm/model";
+import { EditorState, PluginKey } from "@tiptap/pm/state";
+import { SuggestionProps } from "@tiptap/suggestion";
+import { TableKit, TableKitOptions } from "@tiptap/extension-table";
+import { Doc } from "yjs";
+//#region src/slash-items.d.ts
+interface SlashContext {
+  editor: Editor;
+  /** Document range covering the trigger character and the typed query. */
+  range: Range;
+}
+interface SlashItem {
+  /** Stable identity used for keyboard selection and analytics. */
+  id: string;
+  title: string;
+  /** Section the item is listed under. */
+  group: string;
+  /** One-line hint rendered next to the title. */
+  description?: string;
+  /** Alternative names matched with the same weight as the title. */
+  aliases?: string[];
+  /** Lower-weight search terms that are never displayed. */
+  keywords?: string[];
+  /** Icon key resolved by the UI layer; the core ships no components. */
+  icon?: string;
+  /** Hides the item when the current editor cannot run it. */
+  when?: (editor: Editor) => boolean;
+  run: (context: SlashContext) => void;
+}
+/**
+ * Ranks items against a slash query. Ties keep declaration order, so the item
+ * list doubles as the default ordering of the menu.
+ */
+declare function filterSlashItems(items: SlashItem[], query: string, editor?: Editor): SlashItem[];
+declare const defaultSlashItems: SlashItem[];
+//#endregion
+//#region src/ai-block.d.ts
+/** Lifecycle of a transient `aiBlock` node. */
+type AiActionStatus = "streaming" | "done" | "error";
+interface StreamContext {
+  /** Aborted when the request is superseded by a retry or the block is discarded. */
+  signal: AbortSignal;
+}
+interface AiRequest {
+  /** Slash action id that triggered this request, e.g. `"continue-writing"`. */
+  action: string;
+  /** Instruction sent to the model. */
+  prompt: string;
+  /** Plain-text context the instruction operates on. */
+  context: string;
+}
+/**
+ * Bring-your-own AI backend. `stream` yields incremental text chunks — core
+ * has no opinion on the wire format (SSE, `fetch` streaming, WebSocket),
+ * only on the async-iterable contract, so a real deployment can proxy any
+ * provider behind one endpoint and the demo can swap in a mock for tests.
+ */
+interface StreamAdapter {
+  stream(request: AiRequest, context: StreamContext): AsyncIterable<string>;
+}
+interface PendingEntry$1 {
+  request: AiRequest;
+  adapter: StreamAdapter;
+  controller: AbortController;
+}
+/**
+ * Per-node registry of in-flight/completed AI requests, keyed by the node's
+ * `id`. Unlike `PendingUploadRegistry`, entries are kept on success too —
+ * "try again" always needs the last request/adapter to replay — and are
+ * only dropped (aborting anything still in flight) when the block is
+ * discarded or its streamed text is accepted into the document.
+ */
+declare class PendingAiRegistry {
+  private readonly pending;
+  set(id: string, entry: PendingEntry$1): void;
+  get(id: string): PendingEntry$1 | undefined;
+  delete(id: string): void;
+}
+interface RunAiActionOptions {
+  action: string;
+  prompt: string;
+  context: string;
+  adapter: StreamAdapter;
+}
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    aiBlock: {
+      /** Inserts a transient AI block and starts streaming through `adapter`. */
+      runAiAction: (options: RunAiActionOptions) => ReturnType;
+      /** Re-runs the last request for the node with this id, from scratch. */
+      retryAiAction: (id: string) => ReturnType;
+      /** Replaces the transient node with real paragraph(s) built from its streamed text. */
+      acceptAiAction: (id: string) => ReturnType;
+      /** Removes the transient node without applying anything. */
+      discardAiAction: (id: string) => ReturnType;
+    };
+  }
+}
+interface AiBlockOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+interface AiBlockStorage {
+  pending: PendingAiRegistry;
+}
+/**
+ * A transient block that streams an AI response into the document: never
+ * meant to be the doc's final shape, only a staging area. `status`/`text`/
+ * `error` live in node attrs (part of the doc) so streaming re-renders
+ * through the normal transaction pipeline, the same reasoning `Image`
+ * documents for upload progress — until the user accepts (replaced by real
+ * paragraphs) or discards (removed) it.
+ */
+declare const AiBlock: Node<AiBlockOptions, AiBlockStorage>;
+/** Configures the AI block node. */
+declare function aiBlock(options?: Partial<AiBlockOptions>): Node<AiBlockOptions, AiBlockStorage>;
+interface AiSlashAction {
+  id: string;
+  title: string;
+  description?: string;
+  icon?: string;
+  /** Instruction sent to the model. */
+  prompt: string;
+}
+declare const defaultAiSlashActions: AiSlashAction[];
+interface AiKitOptions {
+  adapter: StreamAdapter;
+  /** @default defaultAiSlashActions */
+  actions: AiSlashAction[];
+  /** Opts out of registering the built-in `aiBlock` node — for a host supplying its own via `extend`. @default true */
+  node: boolean;
+}
+/**
+ * Builds slash items for each configured action, bound to `options.adapter`.
+ * Every action operates on the document text up to the slash trigger — a
+ * slash command never carries a real user text selection the way a bubble
+ * toolbar action does, so there is nothing else to extract context from.
+ */
+declare function createAiSlashItems(options: Pick<AiKitOptions, "adapter" | "actions">): SlashItem[];
+//#endregion
+//#region src/block-drag.d.ts
+type DropMode = "before" | "after" | "inside";
+/** A drag unit's geometry at the moment it was measured. No DOM access, so this is what keeps `resolveDropTarget` pure. */
+interface BlockRect {
+  pos: number;
+  size: number;
+  type: string;
+  left: number;
+  right: number;
+  top: number;
+  bottom: number;
+  /** Immediate container's type — `"doc"` for a top-level block, the list's type for a list item. */
+  parentType: string;
+  /**
+   * Bounds of the nearest ancestor-or-self that is itself a direct doc
+   * child — this block for a top-level block, the enclosing list for a
+   * list item. The escape hatch when `source` can't sit beside `closest`.
+   */
+  containerPos: number;
+  containerSize: number;
+}
+interface DropTarget {
+  /** Document position to insert at, already in the pre-move coordinate space. */
+  pos: number;
+  mode: DropMode;
+  /** The block the decision was made against, so a caller can draw an indicator without another DOM lookup. */
+  rect: BlockRect;
+}
+interface ResolveDropTargetOptions {
+  /** Rightward pointer travel, in px, from the source's left edge that turns a drop into a nest. */
+  indentThreshold: number;
+  /** Whether `target` can legally contain `source` as a child, per the live schema. */
+  canNest: (source: BlockRect, target: BlockRect) => boolean;
+  /** Whether `source` can legally sit next to `target` — i.e. `target`'s own container accepts `source`. */
+  canPlaceBeside: (source: BlockRect, target: BlockRect) => boolean;
+}
+/**
+ * Pure geometry: given the current block rects, the pointer position, and
+ * the block being dragged, decides where it would land. No DOM or schema
+ * access beyond the injected `canNest` predicate, so the gesture rules are
+ * testable without a browser.
+ */
+declare function resolveDropTarget(blocks: readonly BlockRect[], point: {
+  x: number;
+  y: number;
+}, source: BlockRect, options: ResolveDropTargetOptions): DropTarget | null;
+/** Whether `source` can be inserted as one more child at the end of `target`'s existing content. */
+declare function canAppendChild(target: Node$1, source: NodeType): boolean;
+interface BlockTarget {
+  pos: number;
+  size: number;
+  type: string;
+  id: string | null;
+  /** Live rect lookup; re-evaluated on every read so scroll/resize never leaves it stale. */
+  getClientRect: () => DOMRect | null;
+}
+interface BlockDragState {
+  hovered: BlockTarget | null;
+  dragging: BlockTarget | null;
+  drop: (DropTarget & {
+    getClientRect: () => DOMRect | null;
+  }) | null;
+}
+interface BlockDragStorage {
+  state: BlockDragState;
+  /** @internal Subscribers notified after every state change. */
+  listeners: Set<() => void>;
+  /** @internal Set once in `onCreate`; lets `setDragging` nudge a decoration recompute. */
+  editor: Editor | null;
+  /** Subscribes to drag state changes. Returns an unsubscribe function. */
+  subscribe(this: BlockDragStorage, listener: () => void): () => void;
+  setHovered(this: BlockDragStorage, target: BlockTarget | null): void;
+  setDragging(this: BlockDragStorage, target: BlockTarget | null): void;
+  setDrop(this: BlockDragStorage, drop: BlockDragState["drop"]): void;
+}
+declare module "@tiptap/core" {
+  interface Storage {
+    blockDrag: BlockDragStorage;
+  }
+  interface Commands<ReturnType> {
+    blockDrag: {
+      /** Moves the node at `from`/`size` to `to`, as one undo step. */
+      moveBlock: (options: {
+        from: number;
+        size: number;
+        to: number;
+      }) => ReturnType;
+      /** Swaps the block under the selection with its previous sibling. */
+      moveBlockUp: () => ReturnType;
+      /** Swaps the block under the selection with its next sibling. */
+      moveBlockDown: () => ReturnType;
+      /** Inserts a copy of the node at `pos`/`size` right after it. */
+      duplicateBlock: (options: {
+        pos: number;
+        size: number;
+      }) => ReturnType;
+      /** Deletes the node at `pos`/`size`. */
+      deleteBlock: (options: {
+        pos: number;
+        size: number;
+      }) => ReturnType;
+    };
+  }
+}
+declare const blockDragPluginKey: PluginKey<null>;
+interface BlockDragOptions {
+  /**
+   * Pixels to the left of the content box that still resolve to a block,
+   * so hovering the gutter (which is rendered outside the editor DOM)
+   * highlights the row underneath it.
+   *
+   * @default 48
+   */
+  gutterWidth: number;
+  /**
+   * Pixels of rightward pointer travel that turns a drop into a nest.
+   *
+   * @default 32
+   */
+  indentThreshold: number;
+  /**
+   * Pixels from the nearest scrollable ancestor's edge that scrolls it
+   * during a drag.
+   *
+   * @default 48
+   */
+  autoScrollMargin: number;
+  onError?: (error: unknown, context: {
+    editor: Editor;
+  }) => void;
+}
+/**
+ * Hover targeting, pointer-driven reordering, and list nesting for the
+ * block gutter. Geometry is pointer-driven (not HTML5 DnD) so the drop
+ * indicator and the nest gesture stay fully in our control; the gutter
+ * itself is rendered by the registry layer, anchored to `state.hovered`.
+ */
+declare const BlockDrag: Extension<BlockDragOptions, BlockDragStorage>;
+/** Configures the block drag extension. */
+declare function blockDrag(options?: Partial<BlockDragOptions>): Extension<BlockDragOptions, BlockDragStorage>;
+//#endregion
+//#region src/block-id.d.ts
+interface BlockIdOptions {
+  /**
+   * Node type names that receive an id, or `"auto"` to derive them from
+   * every registered extension whose resolved `group` or `content`
+   * expression contains `block`. Mirrors how `getSchemaByResolvedExtensions`
+   * resolves those fields, so function-valued extensions resolve the same
+   * way here as they do in the schema.
+   *
+   * @default "auto"
+   */
+  types: string[] | "auto";
+  /** Node type names excluded from an `"auto"` derivation. */
+  exclude: string[];
+}
+declare const blockIdPluginKey: PluginKey<null>;
+/**
+ * Transactions carrying this meta flag are skipped by the assignment pass.
+ * A future collaboration provider sets it on transactions that apply a
+ * remote change, keeping ids deterministic across peers.
+ */
+declare const BLOCK_ID_REMOTE_META = "blockId:remote";
+/**
+ * Injects a stable `attrs.id` into every block-capable node and renders it
+ * as `data-block-id`, alongside a constant `data-block-type` per node type
+ * for the styling seam. Ids are assigned on insert/parse only, never
+ * regenerated on attribute update or remote change — the invariant the
+ * eventual Yjs identity (M4) depends on.
+ */
+declare const BlockId: Extension<BlockIdOptions, any>;
+/** Configures the block id extension. */
+declare function blockId(options?: Partial<BlockIdOptions>): Extension<BlockIdOptions, any>;
+//#endregion
+//#region src/bubble-toolbar.d.ts
+interface BubbleToolbarItem {
+  /** Stable identity for React keys. */
+  id: string;
+  label: string;
+  /** Icon key resolved by the UI layer; the core ships no components. */
+  icon?: string;
+  /** Whether the button should render pressed for the current selection. */
+  isActive: (editor: Editor) => boolean;
+  run: (editor: Editor) => void;
+  /** Hides the item when the current editor cannot run it. */
+  when?: (editor: Editor) => boolean;
+}
+interface BubbleToolbarState {
+  open: boolean;
+  /** Items visible for the current editor; already filtered by `when`. */
+  items: BubbleToolbarItem[];
+  /** Selection rectangle the toolbar anchors to; `null` while closed. */
+  getClientRect: (() => DOMRect | null) | null;
+}
+interface BubbleToolbarStorage {
+  state: BubbleToolbarState;
+  /** @internal Subscribers notified after every state change. */
+  listeners: Set<() => void>;
+  /** Subscribes to toolbar state changes. Returns an unsubscribe function. */
+  subscribe(this: BubbleToolbarStorage, listener: () => void): () => void;
+  /** @internal Replaces state and notifies subscribers, skipping no-op closed transitions. */
+  setState(this: BubbleToolbarStorage, next: BubbleToolbarState): void;
+}
+interface BubbleToolbarOptions {
+  items: BubbleToolbarItem[] | ((editor: Editor) => BubbleToolbarItem[]);
+}
+declare module "@tiptap/core" {
+  interface Storage {
+    bubbleToolbar: BubbleToolbarStorage;
+  }
+}
+/**
+ * Ranks are irrelevant here (there's no query to match against); this just
+ * hides items the current schema or selection context can't run.
+ */
+declare function filterBubbleToolbarItems(items: BubbleToolbarItem[], editor: Editor): BubbleToolbarItem[];
+declare const defaultBubbleToolbarItems: BubbleToolbarItem[];
+/**
+ * Selection-anchored inline formatting toolbar. Unlike the slash menu, there
+ * is no query to rank: core only decides *whether* the toolbar is visible
+ * and *which* items apply, and the React layer renders it fully controlled
+ * (`item.isActive`/`item.run` are called straight from the demo on click).
+ */
+declare const BubbleToolbar: Extension<BubbleToolbarOptions, BubbleToolbarStorage>;
+/** Configures the bubble toolbar extension. */
+declare function bubbleToolbar(options?: Partial<BubbleToolbarOptions>): Extension<BubbleToolbarOptions, BubbleToolbarStorage>;
+//#endregion
+//#region src/collaboration.d.ts
+/** Local user attributes broadcast to every connected peer's awareness state. */
+interface CollaborationUser {
+  name: string;
+  /** Hex color (`#RRGGBB`); an invalid value renders as `transparent`. */
+  color: string;
+  [key: string]: unknown;
+}
+/**
+ * The awareness surface `collaboration()` needs from a network provider.
+ * `HocuspocusProvider`, `y-websocket`'s `WebsocketProvider`, and `y-webrtc`'s
+ * `WebrtcProvider` all satisfy this shape without a direct dependency on any
+ * one of them — the host picks the transport, core only touches awareness.
+ */
+interface CollaborationProvider {
+  awareness: {
+    setLocalStateField(field: string, value: unknown): void;
+    getStates(): Map<number, Record<string, unknown>>;
+    on(event: "update" | "change", listener: () => void): void;
+    off(event: "update" | "change", listener: () => void): void;
+  };
+}
+interface CollaborationOptions {
+  /** Shared Yjs document. The host owns its lifecycle: creation, persistence, provider wiring. */
+  document: Doc;
+  /**
+   * Name of the Yjs XML fragment within `document` this editor instance
+   * syncs. Change it to sync more than one editor off the same document.
+   *
+   * @default "content"
+   */
+  field?: string;
+  /**
+   * Network/awareness provider. Enables presence carets via
+   * `CollaborationCaret`; omit to sync the document with no presence UI
+   * (e.g. an offline-first `IndexeddbPersistence`-only setup).
+   */
+  provider?: CollaborationProvider;
+  /**
+   * Local user's presence attributes. Only meaningful with `provider` set.
+   *
+   * @default { name: "Anonymous", color: "#94A3B8" }
+   */
+  user?: CollaborationUser;
+}
+/**
+ * Wires a shared Yjs document into the editor via Tiptap's official
+ * `Collaboration`/`CollaborationCaret` extensions (themselves a thin layer
+ * over `y-prosemirror`). `BlockId`'s remote-skip check already recognizes
+ * the `"y-sync$"` transaction meta these extensions set, so ids stay
+ * deterministic across peers with no further wiring.
+ *
+ * Callers must disable local undo/redo (`createBlockKit`'s `history:
+ * false`): Yjs owns the undo stack once a document is shared, and running
+ * both corrupts it.
+ */
+declare function collaboration(options: CollaborationOptions): Extensions;
+//#endregion
+//#region src/columns.d.ts
+interface ColumnsOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+interface ColumnOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    columns: {
+      /** Inserts a `columns` container with `count` empty columns, clamped to 2–6. */
+      setColumns: (count?: number) => ReturnType;
+    };
+  }
+}
+/**
+ * A single column inside `Columns`. Not a `block`-group node itself — it
+ * only exists as `columns`'s child — but its `block+` content still picks
+ * up a `BlockId` (auto mode matches on `content`, not just `group`), giving
+ * every nesting depth stable identity for comment anchoring (M4).
+ */
+declare const Column: Node<ColumnOptions, any>;
+/**
+ * Side-by-side layout container: the first M2 nesting surface beyond
+ * lists. `content: "column{2,}"` bakes the two-column floor into the
+ * schema itself, so there is no separate "remove last column" guard to
+ * maintain — deleting a column below the minimum is simply not a legal
+ * document.
+ */
+declare const Columns: Node<ColumnsOptions, any>;
+/** Configures the columns container node. */
+declare function columns(options?: Partial<ColumnsOptions>): Node<ColumnsOptions, any>;
+/** Configures the column node. */
+declare function column(options?: Partial<ColumnOptions>): Node<ColumnOptions, any>;
+//#endregion
+//#region src/comment.d.ts
+/** A single reply in a comment thread. */
+interface CommentMessage {
+  id: string;
+  author: string;
+  body: string;
+  createdAt: number;
+}
+/** A comment thread as the host's store persists it. Bodies never enter the document. */
+interface CommentThread {
+  id: string;
+  status: "open" | "resolved";
+  messages: CommentMessage[];
+}
+/**
+ * Bring-your-own comment backend. Core anchors comments in the document
+ * (the `comment` mark carries only a `threadId`); thread bodies, authors,
+ * and resolution state live entirely outside the document in a host-owned
+ * store, the same way `UploadAdapter`/`StreamAdapter` keep binary/model
+ * work out of doc attrs. Deleting the anchored text drops the mark but
+ * never the thread — an orphaned thread is a store-side concern, not a
+ * document one.
+ */
+interface CommentThreadStore {
+  createThread(input: {
+    body: string;
+  }): CommentThread | Promise<CommentThread>;
+  addMessage(threadId: string, input: {
+    body: string;
+  }): CommentThread | Promise<CommentThread>;
+  resolveThread(threadId: string): void | Promise<void>;
+  reopenThread(threadId: string): void | Promise<void>;
+  getThread(threadId: string): CommentThread | undefined | Promise<CommentThread | undefined>;
+  listThreads(): CommentThread[] | Promise<CommentThread[]>;
+}
+interface CommentOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+interface CommentState {
+  /** Distinct thread ids anchored under the current selection, in mark order. */
+  activeThreadIds: string[];
+}
+interface CommentStorage {
+  state: CommentState;
+  /** @internal Subscribers notified after every state change. */
+  listeners: Set<() => void>;
+  /** Subscribes to selection-driven comment state. Returns an unsubscribe function. */
+  subscribe(this: CommentStorage, listener: () => void): () => void;
+  /** @internal Replaces state and notifies subscribers, skipping no-op empty transitions. */
+  setState(this: CommentStorage, next: CommentState): void;
+}
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    comment: {
+      /** Anchors `threadId` over the current selection. */
+      setComment: (threadId: string) => ReturnType;
+      /** Removes only `threadId`'s anchors from the current selection. */
+      unsetComment: (threadId: string) => ReturnType;
+      /** Anchors `threadId` if absent from the selection, removes it if present. */
+      toggleComment: (threadId: string) => ReturnType;
+    };
+  }
+  interface Storage {
+    comment: CommentStorage;
+  }
+}
+/**
+ * Distinct `threadId`s anchored under `state`'s selection: every mark
+ * instance touching a non-empty range, or the marks that would apply to
+ * text typed at a collapsed cursor. Pure and DOM-free so it is testable
+ * against a bare `EditorState`.
+ */
+declare function activeThreadIds(state: EditorState): string[];
+/**
+ * Comment anchors are a mark, not a node: `threadId` is the only attribute,
+ * so multiple distinct threads can anchor overlapping ranges (`excludes:
+ * ""` opts out of ProseMirror's default same-type exclusion). Thread
+ * bodies, authors, and resolved state never live here — see
+ * `CommentThreadStore`.
+ */
+declare const Comment: Mark<CommentOptions, CommentStorage>;
+/** Configures the comment mark. */
+declare function comment(options?: Partial<CommentOptions>): Mark<CommentOptions, CommentStorage>;
+//#endregion
+//#region src/embed.d.ts
+interface EmbedOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+type EmbedMode = "bookmark" | "iframe";
+interface SetEmbedOptions {
+  /** Omit to insert an empty placeholder a `NodeView` can fill in later. */
+  url?: string;
+  /** @default "bookmark" */
+  mode?: EmbedMode;
+  title?: string;
+  description?: string;
+  thumbnail?: string;
+}
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    embed: {
+      /** Inserts a bookmark or iframe embed node. */
+      setEmbed: (options?: SetEmbedOptions) => ReturnType;
+    };
+  }
+}
+/**
+ * A block-level external embed: a bookmark link card or a sandboxed
+ * iframe, chosen by `mode`. No upload adapter — the URL (and, for
+ * bookmarks, the optional title/description/thumbnail metadata) is set
+ * directly, either at insert time or later by a `NodeView` reading a
+ * pasted link.
+ */
+declare const Embed: Node<EmbedOptions, any>;
+/** Configures the embed node. */
+declare function embed(options?: Partial<EmbedOptions>): Node<EmbedOptions, any>;
+//#endregion
+//#region src/upload.d.ts
+/** Lifecycle of a media node backed by an {@link UploadAdapter}. */
+type UploadStatus = "uploading" | "ready" | "error";
+interface UploadContext {
+  /** Aborted when the node carrying this upload is deleted before it settles. */
+  signal: AbortSignal;
+}
+interface UploadResult {
+  url: string;
+}
+/**
+ * Bring-your-own upload backend. Nodes never talk to a network directly —
+ * every image/file/video command takes an adapter instance explicitly, so
+ * core stays backend-agnostic and the demo can swap in a mock for tests.
+ */
+interface UploadAdapter<TResult extends UploadResult = UploadResult> {
+  upload(file: File, context: UploadContext): Promise<TResult>;
+}
+interface BlockLocation {
+  pos: number;
+  node: Node$1;
+}
+/**
+ * Finds a node by its `BlockId`-assigned `id` attribute. Pure: takes a doc,
+ * not an editor, so it is testable without a live view.
+ */
+declare function findNodeById(doc: Node$1, id: string): BlockLocation | null;
+interface PendingEntry {
+  file: File;
+  adapter: UploadAdapter;
+  controller: AbortController;
+}
+/**
+ * Per-node-type registry of in-flight/failed uploads, keyed by the node's
+ * `id`. Retrying re-sends the same `File` without asking the user to pick it
+ * again; entries are dropped on success, kept on failure and on abort.
+ *
+ * Files are never stored in node attrs: attrs must stay JSON-serializable
+ * for Yjs (M4), so the pending `File` lives here instead.
+ */
+declare class PendingUploadRegistry {
+  private readonly pending;
+  set(id: string, entry: PendingEntry): void;
+  get(id: string): PendingEntry | undefined;
+  delete(id: string): void;
+}
+interface RunUploadOptions<TResult extends UploadResult> {
+  editor: Editor;
+  typeName: string;
+  id: string;
+  file: File;
+  adapter: UploadAdapter<TResult>;
+  pending: PendingUploadRegistry;
+  /** Maps a successful result onto the node-specific attrs to persist (e.g. `{ src: result.url }`). */
+  toAttrs: (result: TResult) => Record<string, unknown>;
+}
+/**
+ * Starts (or restarts) an upload for a node already present in the
+ * document. Resolves by locating the node through `id` — not a captured
+ * position — since the doc may change while the network request is in
+ * flight. Completion never creates a separate undo step.
+ */
+declare function runUpload<TResult extends UploadResult>(options: RunUploadOptions<TResult>): void;
+interface RetryUploadOptions<TResult extends UploadResult> {
+  editor: Editor;
+  typeName: string;
+  id: string;
+  pending: PendingUploadRegistry;
+  toAttrs: (result: TResult) => Record<string, unknown>;
+  /**
+   * Starts from this file/adapter instead of the last one recorded in
+   * `pending` — the same machinery also covers "attach a file to an empty
+   * placeholder node" (nothing has been attempted yet, so there is no
+   * pending entry to fall back on).
+   */
+  override?: {
+    file: File;
+    adapter: UploadAdapter<TResult>;
+  };
+}
+/**
+ * (Re)starts an upload for a node already in the document: from the last
+ * `File` passed to `runUpload` for this id, or from `override` when the
+ * node has never had an upload attempt (e.g. a placeholder that just had a
+ * file attached). Returns `false` — a no-op — when neither is available.
+ */
+declare function retryUpload<TResult extends UploadResult>(options: RetryUploadOptions<TResult>): boolean;
+//#endregion
+//#region src/file.d.ts
+interface FileOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+interface FileStorage {
+  pending: PendingUploadRegistry;
+}
+/** Inserted with a picked file: uploads through `adapter`; name/size/mime read from the `File` immediately. */
+interface SetFileFromFile {
+  file: File$1;
+  adapter: UploadAdapter;
+}
+/** Inserted directly from a known URL. */
+interface SetFileFromSrc {
+  src: string;
+  name?: string;
+  size?: number | null;
+  mime?: string | null;
+}
+type SetFileOptions = SetFileFromFile | SetFileFromSrc;
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    file: {
+      /** Inserts a file node. Omit the options to insert an empty placeholder. */
+      setFile: (options?: SetFileOptions) => ReturnType;
+      /**
+       * Re-sends the last `File` for the node with this id, or `override`
+       * to attach a file to a node that has never had an upload attempt
+       * (e.g. an empty placeholder).
+       */
+      retryFile: (id: string, override?: {
+        file: File$1;
+        adapter: UploadAdapter;
+      }) => ReturnType;
+    };
+  }
+}
+/**
+ * A block-level generic-file attachment. Same upload/retry shape as
+ * `Image`: `status`/`error` live in doc attrs, the picked `File` lives in
+ * `storage.pending` keyed by `id`. See `image.ts` for the full rationale.
+ */
+declare const File$1: Node<FileOptions, FileStorage>;
+/** Configures the file node. */
+declare function file(options?: Partial<FileOptions>): Node<FileOptions, FileStorage>;
+//#endregion
+//#region src/image.d.ts
+interface ImageOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+interface ImageStorage {
+  pending: PendingUploadRegistry;
+}
+/** Inserted with a picked file: uploads through `adapter`, no `src` until it resolves. */
+interface SetImageFromFile {
+  file: File;
+  adapter: UploadAdapter;
+  alt?: string;
+}
+/** Inserted directly from a known URL: skips the upload adapter entirely. */
+interface SetImageFromSrc {
+  src: string;
+  alt?: string;
+  width?: number | null;
+}
+type SetImageOptions = SetImageFromFile | SetImageFromSrc;
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    image: {
+      /** Inserts an image node. Omit the options to insert an empty placeholder. */
+      setImage: (options?: SetImageOptions) => ReturnType;
+      /**
+       * Re-sends the last `File` for the node with this id, or `override`
+       * to attach a file to a node that has never had an upload attempt
+       * (e.g. an empty placeholder).
+       */
+      retryImage: (id: string, override?: {
+        file: File;
+        adapter: UploadAdapter;
+      }) => ReturnType;
+    };
+  }
+}
+/**
+ * A block-level image, optionally backed by an in-flight `UploadAdapter`
+ * upload. `status`/`error` live in node attrs (part of the doc) so a
+ * completed or failed upload re-renders through the normal transaction
+ * pipeline — no separate subscribe/storage channel like the slash menu or
+ * bubble toolbar, which track ephemeral UI state instead of document state.
+ *
+ * The picked `File` itself never touches attrs (not JSON-serializable, not
+ * Yjs-safe); it lives in `storage.pending`, keyed by the node's `BlockId`,
+ * so `retryImage` can resend it without the user picking again.
+ */
+declare const Image: Node<ImageOptions, ImageStorage>;
+/** Configures the image node. */
+declare function image(options?: Partial<ImageOptions>): Node<ImageOptions, ImageStorage>;
+//#endregion
+//#region src/link-editor.d.ts
+interface LinkEditorState {
+  open: boolean;
+  /** Draft href shown in the popover input. */
+  href: string;
+  /** `true` when editing a link already on the selection; `false` when drafting one over new text. */
+  editing: boolean;
+  /** Selection rectangle the popover anchors to; `null` while closed. */
+  getClientRect: (() => DOMRect | null) | null;
+}
+interface LinkEditorStorage {
+  state: LinkEditorState;
+  /** @internal Subscribers notified after every state change. */
+  listeners: Set<() => void>;
+  /** Subscribes to popover state changes. Returns an unsubscribe function. */
+  subscribe(this: LinkEditorStorage, listener: () => void): () => void;
+  /** @internal Replaces state and notifies subscribers, skipping no-op closed transitions. */
+  setState(this: LinkEditorStorage, next: LinkEditorState): void;
+}
+interface LinkEditorOptions {
+  /** Opens automatically when the selection lands inside an existing link. @default true */
+  autoOpenOnLinkActive: boolean;
+}
+declare module "@tiptap/core" {
+  interface Storage {
+    linkEditor: LinkEditorStorage;
+  }
+  interface Commands<ReturnType> {
+    linkEditor: {
+      /** Opens the popover: prefilled with the active link's href, or empty over a fresh text selection. */
+      openLinkEditor: () => ReturnType;
+      /** Updates the draft href. Local UI state only — it never touches the document. */
+      setLinkEditorHref: (href: string) => ReturnType;
+      /** Closes without applying, refocusing the document. */
+      closeLinkEditor: () => ReturnType;
+    };
+  }
+}
+/** Whether a link can be created (non-empty text selection) or edited (cursor inside one) right now. */
+declare function canOpenLinkEditor(editor: Editor): boolean;
+/**
+ * Selection-anchored link editing popover. Two entry points feed the same
+ * state: a bubble-toolbar "Link" button calls `openLinkEditor` over a fresh
+ * text selection (`editing: false`), and this extension auto-opens itself
+ * (`editing: true`) whenever the cursor lands inside an existing link — a
+ * case a plain "selection is non-empty" check (à la `BubbleToolbar`) can't
+ * catch, since placing a cursor inside a link selects no text.
+ *
+ * Applying or removing the link itself is not a custom command here: once
+ * open, a UI layer calls the `link` mark's own `setLink`/`unsetLink` (from
+ * `@tiptap/extension-link`) directly, the same way `BubbleToolbarItem.run`
+ * calls `toggleBold` directly — this extension only owns popover
+ * visibility and the draft href.
+ *
+ * The popover is never closed by `onTransaction`/`onBlur` alone once open:
+ * its own input needs real DOM focus to type a URL, and a blur there must
+ * not read as "dismiss". Only an explicit command (`closeLinkEditor`, or a
+ * document selection change while `editing`) closes it.
+ */
+declare const LinkEditor: Extension<LinkEditorOptions, LinkEditorStorage>;
+/** Configures the link editor extension. */
+declare function linkEditor(options?: Partial<LinkEditorOptions>): Extension<LinkEditorOptions, LinkEditorStorage>;
+//#endregion
+//#region src/mention.d.ts
+interface MentionItem {
+  /** Stable identity of the mentioned entity (user id, page id, …). */
+  id: string;
+  /** Rendered label, e.g. a display name. */
+  label: string;
+  /** One-line hint rendered next to the label (e.g. an email or handle). */
+  description?: string;
+  /** Icon key resolved by the UI layer; the core ships no components. */
+  icon?: string;
+}
+interface MentionState {
+  open: boolean;
+  /** Text typed after the trigger character. */
+  query: string;
+  /** Items returned by the provider for the current query. */
+  items: MentionItem[];
+  /** Index of the keyboard-highlighted item; `-1` when there are no items. */
+  activeIndex: number;
+  /** `true` while the provider's promise for the current query is in flight. */
+  loading: boolean;
+  /** Caret rectangle the menu anchors to; `null` while closed. */
+  getClientRect: (() => DOMRect | null) | null;
+}
+interface MentionStorage {
+  state: MentionState;
+  /** @internal Subscribers notified after every state change. */
+  listeners: Set<() => void>;
+  /** @internal Live suggestion handle; `null` while the menu is closed. */
+  active: SuggestionProps<MentionItem, MentionItem> | null;
+  /** Subscribes to menu state changes. Returns an unsubscribe function. */
+  subscribe(this: MentionStorage, listener: () => void): () => void;
+  /** Moves the keyboard highlight; the index wraps around the item list. */
+  setActiveIndex(this: MentionStorage, index: number): void;
+  /** Runs an item, defaulting to the highlighted one. */
+  select(this: MentionStorage, index?: number): void;
+  /** Closes the menu and leaves the typed text in the document. */
+  close(this: MentionStorage): void;
+  /** @internal Called by the suggestion plugin on start/update/exit. */
+  setActive(this: MentionStorage, props: SuggestionProps<MentionItem, MentionItem> | null): void;
+}
+interface MentionOptions {
+  /** Trigger character. @default "@" */
+  char: string;
+  /**
+   * Async provider, called for every query with the current query text and
+   * an `AbortSignal` for the in-flight request. `@tiptap/suggestion` aborts
+   * a call itself as soon as a newer keystroke supersedes it.
+   */
+  items: (query: string, context: {
+    editor: Editor;
+    signal: AbortSignal;
+  }) => MentionItem[] | Promise<MentionItem[]>;
+  /** Debounce, in ms, before `items` runs after the user stops typing. @default 150 */
+  debounce: number;
+  /** Minimum query length before `items` runs. @default 0 */
+  minQueryLength: number;
+  HTMLAttributes: Record<string, unknown>;
+  /**
+   * Called when `items` rejects. The menu shows an empty result set either
+   * way, so a mention query never gets stuck loading forever.
+   */
+  onError?: (error: unknown, context: {
+    editor: Editor;
+  }) => void;
+}
+declare module "@tiptap/core" {
+  interface Storage {
+    mention: MentionStorage;
+  }
+  interface Commands<ReturnType> {
+    mention: {
+      /** Inserts a mention node for `item` at the current selection. */
+      insertMention: (item: MentionItem) => ReturnType;
+    };
+  }
+}
+declare const mentionPluginKey: PluginKey<any>;
+/**
+ * `@`-mention node backed by an async, bring-your-own provider. Mirrors
+ * `SlashCommand`'s architecture (a `Suggestion` plugin, per-editor storage
+ * with a `subscribe`/state-machine shape) with one addition: `items` may
+ * return a `Promise`, so `state.loading` reflects an in-flight request the
+ * slash menu never has to model.
+ */
+declare const Mention: Node<MentionOptions, MentionStorage>;
+/** Configures the mention node. `items` is required — there is no default provider. */
+declare function mention(options: Partial<MentionOptions> & Pick<MentionOptions, "items">): Node<MentionOptions, MentionStorage>;
+//#endregion
+//#region src/slash-command.d.ts
+interface SlashMenuState {
+  open: boolean;
+  /** Text typed after the trigger character. */
+  query: string;
+  /** Ranked items for the current query. */
+  items: SlashItem[];
+  /** Index of the keyboard-highlighted item; `-1` when there are no items. */
+  activeIndex: number;
+  /** Caret rectangle the menu anchors to; `null` while closed. */
+  getClientRect: (() => DOMRect | null) | null;
+}
+interface SlashCommandStorage {
+  state: SlashMenuState;
+  /** @internal Subscribers notified after every state change. */
+  listeners: Set<() => void>;
+  /** @internal Live suggestion handle; `null` while the menu is closed. */
+  active: SuggestionProps<SlashItem, SlashItem> | null;
+  /** Subscribes to menu state changes. Returns an unsubscribe function. */
+  subscribe(this: SlashCommandStorage, listener: () => void): () => void;
+  /** Moves the keyboard highlight; the index wraps around the item list. */
+  setActiveIndex(this: SlashCommandStorage, index: number): void;
+  /** Runs an item, defaulting to the highlighted one. */
+  select(this: SlashCommandStorage, index?: number): void;
+  /** Closes the menu and leaves the typed text in the document. */
+  close(this: SlashCommandStorage): void;
+  /** @internal Called by the suggestion plugin on start/update/exit. */
+  setActive(this: SlashCommandStorage, props: SuggestionProps<SlashItem, SlashItem> | null): void;
+}
+interface SlashCommandOptions {
+  /** Trigger character. */
+  char: string;
+  /** Item registry, or a resolver called with the live editor. */
+  items: SlashItem[] | ((editor: Editor) => SlashItem[]);
+  /**
+   * Called when an item's `run` throws. The failing transaction is never
+   * applied, so the document keeps the state it had before the item ran.
+   */
+  onError?: (error: unknown, context: {
+    item: SlashItem;
+    editor: Editor;
+  }) => void;
+}
+declare module "@tiptap/core" {
+  interface Storage {
+    slashCommand: SlashCommandStorage;
+  }
+}
+declare const slashCommandPluginKey: PluginKey<any>;
+declare const SlashCommand: Extension<SlashCommandOptions, SlashCommandStorage>;
+/** Configures the slash menu extension. */
+declare function slashCommand(options?: Partial<SlashCommandOptions>): Extension<SlashCommandOptions, SlashCommandStorage>;
+//#endregion
+//#region src/table.d.ts
+/**
+ * Configures Tiptap's table kit (table/tableRow/tableHeader/tableCell) with
+ * resizable columns on by default — the one behavior worth diverging from
+ * upstream's default, since a fixed-width table is the common Notion-parity
+ * expectation. `insertTable`/`addColumnBefore`/`deleteRow`/… ship from the
+ * upstream extension; slash-editor adds no table-specific commands.
+ */
+declare function table(options?: Partial<TableKitOptions>): import("@tiptap/core").Extension<TableKitOptions, any>;
+//#endregion
+//#region src/video.d.ts
+interface VideoOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+interface VideoStorage {
+  pending: PendingUploadRegistry;
+}
+/** Inserted with a picked file: uploads through `adapter`, no `src` until it resolves. */
+interface SetVideoFromFile {
+  file: File;
+  adapter: UploadAdapter;
+  poster?: string;
+}
+/** Inserted directly from a known URL. */
+interface SetVideoFromSrc {
+  src: string;
+  poster?: string;
+}
+type SetVideoOptions = SetVideoFromFile | SetVideoFromSrc;
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    video: {
+      /** Inserts a video node. Omit the options to insert an empty placeholder. */
+      setVideo: (options?: SetVideoOptions) => ReturnType;
+      /**
+       * Re-sends the last `File` for the node with this id, or `override`
+       * to attach a file to a node that has never had an upload attempt
+       * (e.g. an empty placeholder).
+       */
+      retryVideo: (id: string, override?: {
+        file: File;
+        adapter: UploadAdapter;
+      }) => ReturnType;
+    };
+  }
+}
+/**
+ * A block-level video, same upload/retry shape as `Image`: `status`/`error`
+ * live in doc attrs, the picked `File` lives in `storage.pending` keyed by
+ * `id`. See `image.ts` for the full rationale.
+ */
+declare const Video: Node<VideoOptions, VideoStorage>;
+/** Configures the video node. */
+declare function video(options?: Partial<VideoOptions>): Node<VideoOptions, VideoStorage>;
+//#endregion
+//#region src/block-kit.d.ts
+type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+interface BlockKitOptions {
+  /**
+   * Heading levels offered by the editor.
+   *
+   * @default [1, 2, 3]
+   */
+  headingLevels?: HeadingLevel[];
+  /**
+   * Local undo/redo history.
+   *
+   * Set to `false` when a collaboration provider owns history: Yjs ships its
+   * own undo manager and running both corrupts the undo stack.
+   *
+   * @default true
+   */
+  history?: boolean;
+  /**
+   * Slash menu configuration, or `false` to leave the trigger character inert.
+   *
+   * @default { char: "/", items: defaultSlashItems }
+   */
+  slash?: Partial<SlashCommandOptions> | false;
+  /**
+   * Stable per-block id configuration, or `false` to opt out. Drag
+   * targeting and the future comment/collaboration surfaces depend on it.
+   *
+   * @default { types: "auto" }
+   */
+  blockId?: Partial<BlockIdOptions> | false;
+  /**
+   * Block gutter drag handle: reorder and list nesting. Requires
+   * `blockId`, since drag targets are addressed by id.
+   *
+   * @default {}
+   */
+  drag?: Partial<BlockDragOptions> | false;
+  /**
+   * Selection-anchored inline formatting toolbar, or `false` to opt out.
+   *
+   * @default { items: defaultBubbleToolbarItems }
+   */
+  bubbleToolbar?: Partial<BubbleToolbarOptions> | false;
+  /**
+   * Extensions appended after the baseline set. Later extensions win on
+   * conflicting keymaps, so this is the seam for overriding defaults.
+   */
+  extend?: Extensions;
+  /**
+   * Image node configuration, or `false` to opt out and supply a
+   * `NodeView`-augmented variant via `extend` instead (see `Image`,
+   * exported for `.extend()`).
+   *
+   * @default {}
+   */
+  image?: Partial<ImageOptions> | false;
+  /**
+   * File attachment node configuration, or `false` to opt out.
+   *
+   * @default {}
+   */
+  file?: Partial<FileOptions> | false;
+  /**
+   * Video node configuration, or `false` to opt out.
+   *
+   * @default {}
+   */
+  video?: Partial<VideoOptions> | false;
+  /**
+   * Bookmark/iframe embed node configuration, or `false` to opt out.
+   *
+   * @default {}
+   */
+  embed?: Partial<EmbedOptions> | false;
+  /**
+   * Table kit configuration (resizable columns on by default), or `false`
+   * to opt out.
+   *
+   * @default { table: { resizable: true } }
+   */
+  table?: Partial<TableKitOptions> | false;
+  /**
+   * Columns container configuration, or `false` to opt out.
+   *
+   * @default {}
+   */
+  columns?: Partial<ColumnsOptions> | false;
+  /**
+   * Selection-anchored link editing popover, or `false` to opt out.
+   * Requires the `link` mark, configured on by `createBlockKit` with
+   * `openOnClick: false, enableClickSelection: true` so clicking a link
+   * while editing selects it instead of navigating away.
+   *
+   * @default {}
+   */
+  linkEditor?: Partial<LinkEditorOptions> | false;
+  /**
+   * `@`-mention node with an async, bring-your-own provider. Omit to leave
+   * the trigger character inert — there is no default provider to fall
+   * back to, unlike the always-on `slash` menu.
+   */
+  mention?: (Partial<MentionOptions> & Pick<MentionOptions, "items">) | false;
+  /**
+   * AI slash actions (`Continue writing`, `Summarize`, …) streamed through
+   * a bring-your-own `StreamAdapter`. Omit to leave those slash items out —
+   * there is no default adapter to fall back to.
+   */
+  ai?: (Partial<AiKitOptions> & Pick<AiKitOptions, "adapter">) | false;
+  /**
+   * Shared Yjs document, network provider, and presence config. No
+   * default — omit to run local-only. Forces `history: false` (Yjs owns
+   * the undo stack once a document is shared) regardless of the `history`
+   * option.
+   */
+  collaboration?: CollaborationOptions | false;
+  /**
+   * Comment mark (`threadId` anchor) plus the selection-driven active-thread
+   * state a UI reads to open a thread panel. Thread bodies live in a
+   * host-provided `CommentThreadStore`, never in the document.
+   *
+   * @default {}
+   */
+  comment?: Partial<CommentOptions> | false;
+}
+/**
+ * The baseline block schema: document, text, paragraph, headings, lists,
+ * task lists, blockquote, callout, toggle (details), code block, horizontal
+ * rule, hard break, and the inline marks.
+ *
+ * Emits no class names. UI layers style content through element selectors and
+ * the `data-*` attributes rendered by slash-editor nodes.
+ */
+declare function createBlockKit(options?: BlockKitOptions): Extensions;
+//#endregion
+//#region src/callout.d.ts
+interface CalloutOptions {
+  /**
+   * Emoji shown when a callout is created and no icon attribute is parsed
+   * from HTML.
+   *
+   * @default "💡"
+   */
+  defaultIcon: string;
+  HTMLAttributes: Record<string, unknown>;
+}
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    callout: {
+      /** Wraps the current block range in a callout. */
+      setCallout: () => ReturnType;
+      /** Wraps in a callout, or lifts out of one if already inside. */
+      toggleCallout: () => ReturnType;
+      /** Lifts the current block out of its enclosing callout. */
+      unsetCallout: () => ReturnType;
+    };
+  }
+}
+/**
+ * A highlighted aside with a leading emoji, wrapping arbitrary block content
+ * (`content: block+`) rather than a flat textblock. Nesting follows the
+ * container-node approach used across M1: no universal block wrapper.
+ */
+declare const Callout: Node<CalloutOptions, any>;
+/** Configures the callout node. */
+declare function callout(options?: Partial<CalloutOptions>): Node<CalloutOptions, any>;
+//#endregion
+export { type AiActionStatus, AiBlock, type AiBlockOptions, type AiBlockStorage, type AiKitOptions, type AiRequest, type AiSlashAction, BLOCK_ID_REMOTE_META, BlockDrag, type BlockDragOptions, type BlockDragState, type BlockDragStorage, BlockId, type BlockIdOptions, type BlockKitOptions, type BlockLocation, type BlockRect, type BlockTarget, BubbleToolbar, type BubbleToolbarItem, type BubbleToolbarOptions, type BubbleToolbarState, type BubbleToolbarStorage, Callout, type CalloutOptions, type CollaborationOptions, type CollaborationProvider, type CollaborationUser, Column, type ColumnOptions, Columns, type ColumnsOptions, Comment, type CommentMessage, type CommentOptions, type CommentState, type CommentStorage, type CommentThread, type CommentThreadStore, type DropMode, type DropTarget, Embed, type EmbedMode, type EmbedOptions, File$1 as File, type FileOptions, type FileStorage, type HeadingLevel, Image, type ImageOptions, type ImageStorage, LinkEditor, type LinkEditorOptions, type LinkEditorState, type LinkEditorStorage, Mention, type MentionItem, type MentionOptions, type MentionState, type MentionStorage, PendingAiRegistry, PendingUploadRegistry, type RetryUploadOptions, type RunAiActionOptions, type RunUploadOptions, type SetEmbedOptions, type SetFileFromFile, type SetFileFromSrc, type SetFileOptions, type SetImageFromFile, type SetImageFromSrc, type SetImageOptions, type SetVideoFromFile, type SetVideoFromSrc, type SetVideoOptions, SlashCommand, type SlashCommandOptions, type SlashCommandStorage, type SlashContext, type SlashItem, type SlashMenuState, type StreamAdapter, type StreamContext, TableKit, type TableKitOptions, type UploadAdapter, type UploadContext, type UploadResult, type UploadStatus, Video, type VideoOptions, type VideoStorage, activeThreadIds, aiBlock, blockDrag, blockDragPluginKey, blockId, blockIdPluginKey, bubbleToolbar, callout, canAppendChild, canOpenLinkEditor, collaboration, column, columns, comment, createAiSlashItems, createBlockKit, defaultAiSlashActions, defaultBubbleToolbarItems, defaultSlashItems, embed, file, filterBubbleToolbarItems, filterSlashItems, findNodeById, image, linkEditor, mention, mentionPluginKey, resolveDropTarget, retryUpload, runUpload, slashCommand, slashCommandPluginKey, table, video };