@slash-editor/core 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2514 @@
+import { Extension, Mark, Node, callOrReturn, combineTransactionSteps, findChildrenInRange, getChangedRanges, getExtensionField, isTextSelection, mergeAttributes, posToDOMRect } from "@tiptap/core";
+import { Fragment } from "@tiptap/pm/model";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+import { StarterKit } from "@tiptap/starter-kit";
+import { Details, DetailsContent, DetailsSummary } from "@tiptap/extension-details";
+import { TaskItem, TaskList } from "@tiptap/extension-list";
+import { Collaboration } from "@tiptap/extension-collaboration";
+import { CollaborationCaret } from "@tiptap/extension-collaboration-caret";
+import { Suggestion } from "@tiptap/suggestion";
+import { TableKit } from "@tiptap/extension-table";
+//#region src/upload.ts
+/**
+* Finds a node by its `BlockId`-assigned `id` attribute. Pure: takes a doc,
+* not an editor, so it is testable without a live view.
+*/
+function findNodeById(doc, id) {
+	let found = null;
+	doc.descendants((node, pos) => {
+		if (found) return false;
+		if (node.attrs.id === id) {
+			found = {
+				pos,
+				node
+			};
+			return false;
+		}
+		return true;
+	});
+	return found;
+}
+/**
+* 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.
+*/
+var PendingUploadRegistry = class {
+	pending = /* @__PURE__ */ new Map();
+	set(id, entry) {
+		this.pending.get(id)?.controller.abort();
+		this.pending.set(id, entry);
+	}
+	get(id) {
+		return this.pending.get(id);
+	}
+	delete(id) {
+		this.pending.delete(id);
+	}
+};
+function applyAttrs(editor, typeName, id, patch) {
+	const location = findNodeById(editor.state.doc, id);
+	if (!location || location.node.type.name !== typeName) return;
+	const tr = editor.state.tr.setNodeMarkup(location.pos, void 0, {
+		...location.node.attrs,
+		...patch
+	}).setMeta("addToHistory", false);
+	editor.view.dispatch(tr);
+}
+/**
+* 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.
+*/
+function runUpload(options) {
+	const { editor, typeName, id, file, adapter, pending, toAttrs } = options;
+	const controller = new AbortController();
+	pending.set(id, {
+		file,
+		adapter,
+		controller
+	});
+	adapter.upload(file, { signal: controller.signal }).then((result) => {
+		if (controller.signal.aborted) return;
+		pending.delete(id);
+		applyAttrs(editor, typeName, id, {
+			status: "ready",
+			error: null,
+			...toAttrs(result)
+		});
+	}).catch((error) => {
+		if (controller.signal.aborted) return;
+		applyAttrs(editor, typeName, id, {
+			status: "error",
+			error: error instanceof Error ? error.message : "Upload failed"
+		});
+	});
+}
+/**
+* (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.
+*/
+function retryUpload(options) {
+	const { editor, typeName, id, pending, toAttrs, override } = options;
+	const entry = override ?? pending.get(id);
+	if (!entry) return false;
+	applyAttrs(editor, typeName, id, {
+		status: "uploading",
+		error: null
+	});
+	runUpload({
+		editor,
+		typeName,
+		id,
+		file: entry.file,
+		adapter: entry.adapter,
+		pending,
+		toAttrs
+	});
+	return true;
+}
+//#endregion
+//#region src/ai-block.ts
+/**
+* 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.
+*/
+var PendingAiRegistry = class {
+	pending = /* @__PURE__ */ new Map();
+	set(id, entry) {
+		this.pending.get(id)?.controller.abort();
+		this.pending.set(id, entry);
+	}
+	get(id) {
+		return this.pending.get(id);
+	}
+	delete(id) {
+		this.pending.get(id)?.controller.abort();
+		this.pending.delete(id);
+	}
+};
+function applyAiAttrs(editor, id, patch) {
+	const location = findNodeById(editor.state.doc, id);
+	if (!location || location.node.type.name !== AiBlock.name) return;
+	const tr = editor.state.tr.setNodeMarkup(location.pos, void 0, {
+		...location.node.attrs,
+		...patch
+	}).setMeta("addToHistory", false);
+	editor.view.dispatch(tr);
+}
+/** Starts (or restarts) a stream for a node already present in the document. */
+function runAiStream(editor, id, request, adapter, pending) {
+	const controller = new AbortController();
+	pending.set(id, {
+		request,
+		adapter,
+		controller
+	});
+	(async () => {
+		try {
+			let text = "";
+			for await (const chunk of adapter.stream(request, { signal: controller.signal })) {
+				if (controller.signal.aborted) return;
+				text += chunk;
+				applyAiAttrs(editor, id, {
+					text,
+					status: "streaming",
+					error: null
+				});
+			}
+			if (controller.signal.aborted) return;
+			applyAiAttrs(editor, id, { status: "done" });
+		} catch (error) {
+			if (controller.signal.aborted) return;
+			applyAiAttrs(editor, id, {
+				status: "error",
+				error: error instanceof Error ? error.message : "AI request failed"
+			});
+		}
+	})();
+}
+/**
+* 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.
+*/
+const AiBlock = Node.create({
+	name: "aiBlock",
+	group: "block",
+	atom: true,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	addStorage() {
+		return { pending: new PendingAiRegistry() };
+	},
+	addAttributes() {
+		return {
+			action: { default: "" },
+			prompt: { default: "" },
+			text: { default: "" },
+			status: {
+				default: "streaming",
+				parseHTML: (element) => element.getAttribute("data-status") ?? "streaming",
+				renderHTML: (attributes) => ({ "data-status": attributes.status })
+			},
+			error: {
+				default: null,
+				parseHTML: (element) => element.getAttribute("data-error"),
+				renderHTML: (attributes) => attributes.error ? { "data-error": attributes.error } : {}
+			}
+		};
+	},
+	parseHTML() {
+		return [{ tag: `div[data-type="${this.name}"]` }];
+	},
+	renderHTML({ HTMLAttributes, node }) {
+		return [
+			"div",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { "data-type": this.name }),
+			node.attrs.text || ""
+		];
+	},
+	addCommands() {
+		return {
+			runAiAction: (options) => ({ commands, dispatch }) => {
+				const id = crypto.randomUUID();
+				const request = {
+					action: options.action,
+					prompt: options.prompt,
+					context: options.context
+				};
+				const inserted = commands.insertContent({
+					type: this.name,
+					attrs: {
+						id,
+						action: request.action,
+						prompt: request.prompt,
+						text: "",
+						status: "streaming",
+						error: null
+					}
+				});
+				if (inserted && dispatch) queueMicrotask(() => {
+					runAiStream(this.editor, id, request, options.adapter, this.storage.pending);
+				});
+				return inserted;
+			},
+			retryAiAction: (id) => ({ state, dispatch }) => {
+				const entry = this.storage.pending.get(id);
+				const location = findNodeById(state.doc, id);
+				if (!entry || !location || location.node.type.name !== this.name) return false;
+				if (dispatch) queueMicrotask(() => {
+					applyAiAttrs(this.editor, id, {
+						text: "",
+						status: "streaming",
+						error: null
+					});
+					runAiStream(this.editor, id, entry.request, entry.adapter, this.storage.pending);
+				});
+				return true;
+			},
+			acceptAiAction: (id) => ({ state, tr, dispatch }) => {
+				const location = findNodeById(state.doc, id);
+				if (!location || location.node.type.name !== this.name) return false;
+				if (dispatch) {
+					const text = location.node.attrs.text ?? "";
+					const paragraphNode = state.schema.nodes.paragraph;
+					const lines = text.split(/\n{2,}/).map((line) => line.trim()).filter(Boolean);
+					const nodes = paragraphNode && (lines.length > 0 ? lines.map((line) => paragraphNode.create(null, state.schema.text(line))) : [paragraphNode.create()]);
+					tr.replaceWith(location.pos, location.pos + location.node.nodeSize, nodes ? Fragment.fromArray(nodes) : Fragment.empty);
+				}
+				this.storage.pending.delete(id);
+				return true;
+			},
+			discardAiAction: (id) => ({ state, tr, dispatch }) => {
+				const location = findNodeById(state.doc, id);
+				if (!location || location.node.type.name !== this.name) return false;
+				if (dispatch) tr.delete(location.pos, location.pos + location.node.nodeSize);
+				this.storage.pending.delete(id);
+				return true;
+			}
+		};
+	}
+});
+/** Configures the AI block node. */
+function aiBlock(options = {}) {
+	return AiBlock.configure(options);
+}
+const defaultAiSlashActions = [
+	{
+		id: "continue-writing",
+		title: "Continue writing",
+		description: "AI extends the text above the cursor",
+		icon: "sparkles",
+		prompt: "Continue writing the document naturally, matching its tone and style. Write only the continuation, with no preamble."
+	},
+	{
+		id: "summarize",
+		title: "Summarize",
+		description: "AI summarizes the text above the cursor",
+		icon: "sparkles",
+		prompt: "Summarize the following text in a few concise sentences."
+	},
+	{
+		id: "brainstorm-ideas",
+		title: "Brainstorm ideas",
+		description: "AI lists ideas related to the text above the cursor",
+		icon: "sparkles",
+		prompt: "Brainstorm a short bullet list of ideas related to the following text."
+	},
+	{
+		id: "fix-spelling-grammar",
+		title: "Fix spelling & grammar",
+		description: "AI rewrites the text above the cursor, correcting mistakes",
+		icon: "sparkles",
+		prompt: "Rewrite the following text, correcting spelling and grammar mistakes only, and preserve its meaning and tone."
+	}
+];
+const AI_GROUP = "AI";
+/**
+* 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.
+*/
+function createAiSlashItems(options) {
+	return (options.actions ?? defaultAiSlashActions).map((action) => ({
+		id: action.id,
+		title: action.title,
+		group: AI_GROUP,
+		description: action.description,
+		aliases: ["ai"],
+		keywords: ["ai", "assistant"],
+		icon: action.icon ?? "sparkles",
+		when: (editor) => editor.schema.nodes[AiBlock.name] !== void 0,
+		run: ({ editor, range }) => {
+			const context = editor.state.doc.textBetween(0, range.from, "\n\n").slice(-4e3);
+			editor.chain().focus().deleteRange(range).runAiAction({
+				action: action.id,
+				prompt: action.prompt,
+				context,
+				adapter: options.adapter
+			}).run();
+		}
+	}));
+}
+//#endregion
+//#region src/block-drag.ts
+/**
+* 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.
+*/
+function resolveDropTarget(blocks, point, source, options) {
+	const candidates = blocks.filter((block) => block.pos < source.pos || block.pos >= source.pos + source.size);
+	if (candidates.length === 0) return null;
+	let closest = candidates[0];
+	let closestDistance = Number.POSITIVE_INFINITY;
+	for (const block of candidates) {
+		const distance = Math.abs(point.y - (block.top + block.bottom) / 2);
+		if (distance < closestDistance) {
+			closest = block;
+			closestDistance = distance;
+		}
+	}
+	if (point.x - source.left > options.indentThreshold && options.canNest(source, closest)) return {
+		pos: closest.pos + closest.size - 1,
+		mode: "inside",
+		rect: closest
+	};
+	const after = point.y >= (closest.top + closest.bottom) / 2;
+	if (options.canPlaceBeside(source, closest)) return after ? {
+		pos: closest.pos + closest.size,
+		mode: "after",
+		rect: closest
+	} : {
+		pos: closest.pos,
+		mode: "before",
+		rect: closest
+	};
+	return after ? {
+		pos: closest.containerPos + closest.containerSize,
+		mode: "after",
+		rect: closest
+	} : {
+		pos: closest.containerPos,
+		mode: "before",
+		rect: closest
+	};
+}
+/** Deletes `[from, from + size)` and reinserts it at `to`, adjusting for the shift the deletion causes. */
+function performMove(tr, from, size, to) {
+	const slice = tr.doc.slice(from, from + size);
+	const adjustedTo = to > from ? to - size : to;
+	tr.delete(from, from + size);
+	tr.insert(adjustedTo, slice.content);
+}
+/** Whether `source` can be inserted as one more child at the end of `target`'s existing content. */
+function canAppendChild(target, source) {
+	return target.contentMatchAt(target.childCount).matchType(source) !== null;
+}
+/** Whether a node of `sourceType` can appear anywhere in `parentType`'s content, per its starting content match. */
+function canBeChildType(schema, sourceType, parentType) {
+	const parent = schema.nodes[parentType];
+	const source = schema.nodes[sourceType];
+	return parent !== void 0 && source !== void 0 && parent.contentMatch.matchType(source) !== null;
+}
+/**
+* The draggable unit containing `$pos`: a direct child of the document, or a
+* list item at any nesting depth. A paragraph inside a list item carries its
+* own block id (see `BlockId`) but is not itself a drag unit — dragging
+* moves the whole list item, matching Notion's per-row handle.
+*/
+function resolveBlockAt($pos) {
+	for (let depth = $pos.depth; depth >= 1; depth--) {
+		const node = $pos.node(depth);
+		if (depth === 1 || node.type.name === "listItem") return {
+			pos: $pos.before(depth),
+			node
+		};
+	}
+	return null;
+}
+/** Every drag unit's live position, for sibling lookups and the rect cache. */
+function findSibling(doc, target, direction) {
+	const $inside = doc.resolve(target.pos + 1);
+	const parentDepth = $inside.depth - 1;
+	if (parentDepth < 0) return null;
+	const parent = $inside.node(parentDepth);
+	const siblingIndex = $inside.index(parentDepth) + direction;
+	if (siblingIndex < 0 || siblingIndex >= parent.childCount) return null;
+	let siblingPos = $inside.start(parentDepth);
+	for (let i = 0; i < siblingIndex; i++) siblingPos += parent.child(i).nodeSize;
+	return {
+		pos: siblingPos,
+		size: parent.child(siblingIndex).nodeSize
+	};
+}
+const blockDragPluginKey = new PluginKey("blockDrag");
+const CLOSED_STATE = Object.freeze({
+	hovered: null,
+	dragging: null,
+	drop: null
+});
+function findScrollParent(element) {
+	let node = element.parentElement;
+	while (node) {
+		const overflowY = getComputedStyle(node).overflowY;
+		if ((overflowY === "auto" || overflowY === "scroll") && node.scrollHeight > node.clientHeight) return node;
+		node = node.parentElement;
+	}
+	return document.scrollingElement instanceof HTMLElement ? document.scrollingElement : null;
+}
+function autoScroll(view, clientY, margin) {
+	const scrollParent = findScrollParent(view.dom);
+	if (!scrollParent) return;
+	const box = scrollParent.getBoundingClientRect();
+	if (clientY < box.top + margin) scrollParent.scrollTop -= box.top + margin - clientY;
+	else if (clientY > box.bottom - margin) scrollParent.scrollTop += clientY - (box.bottom - margin);
+}
+function toBlockTarget(view, pos) {
+	const node = view.state.doc.nodeAt(pos);
+	if (!node) return null;
+	return {
+		pos,
+		size: node.nodeSize,
+		type: node.type.name,
+		id: typeof node.attrs.id === "string" ? node.attrs.id : null,
+		getClientRect: () => {
+			const dom = view.nodeDOM(pos);
+			return dom instanceof HTMLElement ? dom.getBoundingClientRect() : null;
+		}
+	};
+}
+/**
+* Resolves the block under viewport coordinates from cached rects, not
+* `posAtCoords`: the gutter and a block's own left padding are empty space
+* with no caret position there, where `posAtCoords` reliably returns
+* nothing. Matches the smallest (most specific) rect whose vertical range
+* contains the pointer, so a list item wins over its enclosing list.
+*/
+function resolveHover(view, clientX, clientY, gutterWidth, rects) {
+	const box = view.dom.getBoundingClientRect();
+	if (clientY < box.top || clientY > box.bottom || clientX < box.left - gutterWidth || clientX > box.right) return null;
+	let match = null;
+	for (const rect of rects) {
+		if (clientY < rect.top || clientY > rect.bottom) continue;
+		if (!match || rect.bottom - rect.top < match.bottom - match.top) match = rect;
+	}
+	return match ? toBlockTarget(view, match.pos) : null;
+}
+function computeRects(view) {
+	const rects = [];
+	view.state.doc.descendants((node, pos, parent) => {
+		if (!parent || parent.type.name !== "doc" && node.type.name !== "listItem") return;
+		const dom = view.nodeDOM(pos);
+		if (dom instanceof HTMLElement) {
+			const rect = dom.getBoundingClientRect();
+			const $pos = view.state.doc.resolve(pos);
+			const depth = $pos.depth;
+			const container = depth === 0 ? {
+				pos,
+				size: node.nodeSize
+			} : {
+				pos: $pos.before(depth),
+				size: $pos.node(depth).nodeSize
+			};
+			rects.push({
+				pos,
+				size: node.nodeSize,
+				type: node.type.name,
+				left: rect.left,
+				right: rect.right,
+				top: rect.top,
+				bottom: rect.bottom,
+				parentType: $pos.node(depth).type.name,
+				containerPos: container.pos,
+				containerSize: container.size
+			});
+		}
+	});
+	return rects;
+}
+/**
+* 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`.
+*/
+const BlockDrag = Extension.create({
+	name: "blockDrag",
+	addOptions() {
+		return {
+			gutterWidth: 48,
+			indentThreshold: 32,
+			autoScrollMargin: 48
+		};
+	},
+	addStorage() {
+		return {
+			state: CLOSED_STATE,
+			listeners: /* @__PURE__ */ new Set(),
+			editor: null,
+			subscribe(listener) {
+				this.listeners.add(listener);
+				return () => this.listeners.delete(listener);
+			},
+			setHovered(target) {
+				if (this.state.hovered === target) return;
+				this.state = {
+					...this.state,
+					hovered: target
+				};
+				this.listeners.forEach((listener) => listener());
+			},
+			setDragging(target) {
+				this.state = {
+					...this.state,
+					dragging: target,
+					drop: target ? this.state.drop : null
+				};
+				this.listeners.forEach((listener) => listener());
+				const { editor } = this;
+				if (editor && !editor.isDestroyed) editor.view.dispatch(editor.state.tr.setMeta("addToHistory", false));
+			},
+			setDrop(drop) {
+				this.state = {
+					...this.state,
+					drop
+				};
+				this.listeners.forEach((listener) => listener());
+			}
+		};
+	},
+	onCreate() {
+		this.storage.editor = this.editor;
+	},
+	addCommands() {
+		return {
+			moveBlock: ({ from, size, to }) => ({ tr, dispatch, state }) => {
+				if (!state.doc.nodeAt(from)) return false;
+				if (dispatch) performMove(tr, from, size, to);
+				return true;
+			},
+			moveBlockUp: () => ({ tr, dispatch, state }) => {
+				const target = resolveBlockAt(state.selection.$from);
+				const sibling = target && findSibling(state.doc, target, -1);
+				if (!target || !sibling) return false;
+				if (dispatch) performMove(tr, target.pos, target.node.nodeSize, sibling.pos);
+				return true;
+			},
+			moveBlockDown: () => ({ tr, dispatch, state }) => {
+				const target = resolveBlockAt(state.selection.$from);
+				const sibling = target && findSibling(state.doc, target, 1);
+				if (!target || !sibling) return false;
+				if (dispatch) performMove(tr, target.pos, target.node.nodeSize, sibling.pos + sibling.size);
+				return true;
+			},
+			duplicateBlock: ({ pos, size }) => ({ tr, dispatch, state }) => {
+				const node = state.doc.nodeAt(pos);
+				if (!node || node.nodeSize !== size) return false;
+				if (dispatch) tr.insert(pos + size, node.copy(node.content));
+				return true;
+			},
+			deleteBlock: ({ pos, size }) => ({ tr, dispatch, state }) => {
+				const node = state.doc.nodeAt(pos);
+				if (!node || node.nodeSize !== size) return false;
+				if (dispatch) tr.delete(pos, pos + size);
+				return true;
+			}
+		};
+	},
+	addKeyboardShortcuts() {
+		return {
+			"Alt-Shift-ArrowUp": () => this.editor.commands.moveBlockUp(),
+			"Alt-Shift-ArrowDown": () => this.editor.commands.moveBlockDown()
+		};
+	},
+	addProseMirrorPlugins() {
+		const { editor } = this;
+		const { gutterWidth, indentThreshold, autoScrollMargin, onError } = this.options;
+		const getStorage = () => editor.storage.blockDrag;
+		return [new Plugin({
+			key: blockDragPluginKey,
+			props: { decorations: (state) => {
+				const dragging = getStorage().state.dragging;
+				if (!dragging) return null;
+				const node = state.doc.nodeAt(dragging.pos);
+				if (!node) return null;
+				return DecorationSet.create(state.doc, [Decoration.node(dragging.pos, dragging.pos + node.nodeSize, { "data-dragging": "" })]);
+			} },
+			view: (view) => {
+				let rects = [];
+				let rectsDirty = true;
+				const handlePointerMove = (event) => {
+					if (event.pointerType === "touch") return;
+					const storage = getStorage();
+					if (rectsDirty) {
+						rects = computeRects(view);
+						rectsDirty = false;
+					}
+					if (!storage.state.dragging) {
+						storage.setHovered(resolveHover(view, event.clientX, event.clientY, gutterWidth, rects));
+						return;
+					}
+					const { dragging } = storage.state;
+					const source = rects.find((rect) => rect.pos === dragging.pos);
+					if (!source) {
+						storage.setDrop(null);
+						return;
+					}
+					const drop = resolveDropTarget(rects, {
+						x: event.clientX,
+						y: event.clientY
+					}, source, {
+						indentThreshold,
+						canNest: (fromRect, toRect) => {
+							const targetNode = view.state.doc.nodeAt(toRect.pos);
+							const sourceType = view.state.schema.nodes[fromRect.type];
+							return targetNode !== null && sourceType !== void 0 && canAppendChild(targetNode, sourceType);
+						},
+						canPlaceBeside: (fromRect, toRect) => canBeChildType(view.state.schema, fromRect.type, toRect.parentType)
+					});
+					storage.setDrop(drop && {
+						...drop,
+						getClientRect: () => {
+							const { rect, mode } = drop;
+							if (mode === "before") return new DOMRect(rect.left, rect.top - 1, rect.right - rect.left, 2);
+							if (mode === "after") return new DOMRect(rect.left, rect.bottom - 1, rect.right - rect.left, 2);
+							return new DOMRect(rect.left + 24, rect.bottom - 1, rect.right - rect.left - 24, 2);
+						}
+					});
+					autoScroll(view, event.clientY, autoScrollMargin);
+				};
+				const handlePointerUp = () => {
+					const storage = getStorage();
+					const { dragging, drop } = storage.state;
+					if (dragging && drop) try {
+						editor.commands.moveBlock({
+							from: dragging.pos,
+							size: dragging.size,
+							to: drop.pos
+						});
+					} catch (error) {
+						if (onError) onError(error, { editor });
+						else throw error;
+					}
+					storage.setDragging(null);
+					storage.setDrop(null);
+				};
+				const handleKeyDown = (event) => {
+					if (event.key === "Escape" && getStorage().state.dragging) {
+						getStorage().setDragging(null);
+						getStorage().setDrop(null);
+					}
+				};
+				document.addEventListener("pointermove", handlePointerMove);
+				document.addEventListener("pointerup", handlePointerUp);
+				document.addEventListener("pointercancel", handlePointerUp);
+				document.addEventListener("keydown", handleKeyDown);
+				return {
+					update: () => {
+						rectsDirty = true;
+					},
+					destroy: () => {
+						document.removeEventListener("pointermove", handlePointerMove);
+						document.removeEventListener("pointerup", handlePointerUp);
+						document.removeEventListener("pointercancel", handlePointerUp);
+						document.removeEventListener("keydown", handleKeyDown);
+					}
+				};
+			}
+		})];
+	}
+});
+/** Configures the block drag extension. */
+function blockDrag(options = {}) {
+	return BlockDrag.configure(options);
+}
+//#endregion
+//#region src/block-id.ts
+const blockIdPluginKey = new PluginKey("blockId");
+/**
+* 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.
+*/
+const BLOCK_ID_REMOTE_META = "blockId:remote";
+/**
+* y-prosemirror stores its sync plugin's meta under this literal string: a
+* `PluginKey("y-sync")` resolves to `"y-sync$"` the first time one is
+* constructed. Checking the string lets remote Yjs transactions be
+* recognized without depending on `@tiptap/y-tiptap`/`y-prosemirror` at M1.
+*/
+const Y_SYNC_META_KEY = "y-sync$";
+const ID_LENGTH = 12;
+const ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_";
+/** 12 chars from a 64-symbol alphabet: ~72 bits, collision-safe without a registry check. */
+function generateBlockId() {
+	const bytes = new Uint8Array(ID_LENGTH);
+	crypto.getRandomValues(bytes);
+	let id = "";
+	for (const byte of bytes) id += ID_ALPHABET[byte % 64];
+	return id;
+}
+function isBlockExpression(value) {
+	return typeof value === "string" && /\bblock\b/.test(value);
+}
+/**
+* Node types eligible for a block id: `group` membership in `block`, or a
+* `content` expression that requires block children (list items, future
+* `details`/`callout`). Depth is irrelevant — a paragraph inside a list item
+* gets its own id alongside the list item's, since comment anchoring and
+* block permissions (M4) need identity at every level, not just drag units.
+*/
+function deriveBlockTypes(extensions, exclude) {
+	const types = [];
+	for (const extension of extensions) {
+		if (extension.type !== "node" || exclude.includes(extension.name)) continue;
+		const context = {
+			name: extension.name,
+			options: extension.options,
+			storage: extension.storage
+		};
+		if (callOrReturn(getExtensionField(extension, "topNode", context))) continue;
+		const group = callOrReturn(getExtensionField(extension, "group", context));
+		const content = callOrReturn(getExtensionField(extension, "content", context));
+		if (isBlockExpression(group) || isBlockExpression(content)) types.push(extension.name);
+	}
+	return types;
+}
+/** Counts live ids per type set, so a pasted duplicate can be told apart from the original it was copied from. */
+function collectIdCounts(doc, types) {
+	const counts = /* @__PURE__ */ new Map();
+	doc.descendants((node) => {
+		if (types.has(node.type.name) && typeof node.attrs.id === "string") counts.set(node.attrs.id, (counts.get(node.attrs.id) ?? 0) + 1);
+	});
+	return counts;
+}
+/** Node types carrying an `id` attribute in the live schema — the set `addGlobalAttributes` produced. */
+function blockIdTypes(schema) {
+	const types = /* @__PURE__ */ new Set();
+	for (const [name, type] of Object.entries(schema.nodes)) if (type.spec.attrs && "id" in type.spec.attrs) types.add(name);
+	return types;
+}
+/**
+* Assigns a fresh id to every node in `ranges` that has none, or whose id is
+* shared with another node in the document. Attribute-only changes never
+* move content, so positions collected up front stay valid for the whole
+* pass without remapping.
+*/
+function assignBlockIds(tr, ranges, types, counts) {
+	let changed = false;
+	for (const range of ranges) for (const { node, pos } of findChildrenInRange(tr.doc, range, (candidate) => types.has(candidate.type.name))) {
+		const id = node.attrs.id;
+		if (!(typeof id !== "string" || (counts.get(id) ?? 0) > 1)) continue;
+		if (typeof id === "string") counts.set(id, (counts.get(id) ?? 1) - 1);
+		const nextId = generateBlockId();
+		counts.set(nextId, 1);
+		tr.setNodeAttribute(pos, "id", nextId);
+		changed = true;
+	}
+	return changed;
+}
+/**
+* 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.
+*/
+const BlockId = Extension.create({
+	name: "blockId",
+	addOptions() {
+		return {
+			types: "auto",
+			exclude: []
+		};
+	},
+	addGlobalAttributes() {
+		return (this.options.types === "auto" ? deriveBlockTypes(this.extensions, this.options.exclude) : this.options.types).map((type) => ({
+			types: [type],
+			attributes: { id: {
+				default: null,
+				parseHTML: (element) => element.getAttribute("data-block-id"),
+				renderHTML: (attrs) => ({
+					"data-block-type": type,
+					...typeof attrs.id === "string" ? { "data-block-id": attrs.id } : {}
+				})
+			} }
+		}));
+	},
+	onCreate() {
+		const { editor } = this;
+		const types = blockIdTypes(editor.schema);
+		const tr = editor.state.tr;
+		const counts = collectIdCounts(tr.doc, types);
+		if (assignBlockIds(tr, [{
+			from: 0,
+			to: tr.doc.content.size
+		}], types, counts)) {
+			tr.setMeta("addToHistory", false);
+			editor.view.dispatch(tr);
+		}
+	},
+	addProseMirrorPlugins() {
+		const { editor } = this;
+		return [new Plugin({
+			key: blockIdPluginKey,
+			appendTransaction: (transactions, oldState, newState) => {
+				if (transactions.some((tr) => tr.getMeta("blockId:remote") || tr.getMeta(Y_SYNC_META_KEY))) return null;
+				if (!transactions.some((tr) => tr.docChanged)) return null;
+				const types = blockIdTypes(editor.schema);
+				const tr = newState.tr;
+				const counts = collectIdCounts(tr.doc, types);
+				return assignBlockIds(tr, getChangedRanges(combineTransactionSteps(oldState.doc, [...transactions])).map((change) => change.newRange), types, counts) ? tr : null;
+			}
+		})];
+	}
+});
+/** Configures the block id extension. */
+function blockId(options = {}) {
+	return BlockId.configure(options);
+}
+//#endregion
+//#region src/link-editor.ts
+function hasLinkMark(editor) {
+	return editor.schema.marks.link !== void 0;
+}
+/** Whether a link can be created (non-empty text selection) or edited (cursor inside one) right now. */
+function canOpenLinkEditor(editor) {
+	if (!hasLinkMark(editor) || !editor.isEditable) return false;
+	const { from, to, empty } = editor.state.selection;
+	return editor.isActive("link") || !empty && editor.state.doc.textBetween(from, to).length > 0;
+}
+const CLOSED$3 = Object.freeze({
+	open: false,
+	href: "",
+	editing: false,
+	getClientRect: null
+});
+function computeAutoState(editor) {
+	if (!editor.isEditable || !editor.isActive("link")) return CLOSED$3;
+	const { from, to } = editor.state.selection;
+	return {
+		open: true,
+		href: editor.getAttributes("link").href ?? "",
+		editing: true,
+		getClientRect: () => posToDOMRect(editor.view, from, to)
+	};
+}
+/**
+* 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.
+*/
+const LinkEditor = Extension.create({
+	name: "linkEditor",
+	addOptions() {
+		return { autoOpenOnLinkActive: true };
+	},
+	addStorage() {
+		return {
+			state: CLOSED$3,
+			listeners: /* @__PURE__ */ new Set(),
+			subscribe(listener) {
+				this.listeners.add(listener);
+				return () => this.listeners.delete(listener);
+			},
+			setState(next) {
+				if (!this.state.open && !next.open) return;
+				this.state = next;
+				this.listeners.forEach((listener) => listener());
+			}
+		};
+	},
+	addCommands() {
+		return {
+			openLinkEditor: () => ({ editor }) => {
+				if (!canOpenLinkEditor(editor)) return false;
+				const { from, to } = editor.state.selection;
+				editor.storage.linkEditor.setState({
+					open: true,
+					href: editor.getAttributes("link").href ?? "",
+					editing: editor.isActive("link"),
+					getClientRect: () => posToDOMRect(editor.view, from, to)
+				});
+				return true;
+			},
+			setLinkEditorHref: (href) => ({ editor }) => {
+				if (!editor.storage.linkEditor.state.open) return false;
+				editor.storage.linkEditor.setState({
+					...editor.storage.linkEditor.state,
+					href
+				});
+				return true;
+			},
+			closeLinkEditor: () => ({ editor }) => {
+				editor.view.focus();
+				editor.storage.linkEditor.setState(CLOSED$3);
+				return true;
+			}
+		};
+	},
+	onTransaction() {
+		if (this.storage.state.open && !this.storage.state.editing) return;
+		if (!this.options.autoOpenOnLinkActive) {
+			if (this.storage.state.open) this.storage.setState(CLOSED$3);
+			return;
+		}
+		this.storage.setState(computeAutoState(this.editor));
+	}
+});
+/** Configures the link editor extension. */
+function linkEditor(options = {}) {
+	return LinkEditor.configure(options);
+}
+//#endregion
+//#region src/bubble-toolbar.ts
+function hasMark(editor, name) {
+	return editor.schema.marks[name] !== void 0;
+}
+/**
+* Ranks are irrelevant here (there's no query to match against); this just
+* hides items the current schema or selection context can't run.
+*/
+function filterBubbleToolbarItems(items, editor) {
+	return items.filter((item) => item.when?.(editor) ?? true);
+}
+const defaultBubbleToolbarItems = [
+	{
+		id: "bold",
+		label: "Bold",
+		icon: "bold",
+		when: (editor) => hasMark(editor, "bold"),
+		isActive: (editor) => editor.isActive("bold"),
+		run: (editor) => {
+			editor.chain().focus().toggleBold().run();
+		}
+	},
+	{
+		id: "italic",
+		label: "Italic",
+		icon: "italic",
+		when: (editor) => hasMark(editor, "italic"),
+		isActive: (editor) => editor.isActive("italic"),
+		run: (editor) => {
+			editor.chain().focus().toggleItalic().run();
+		}
+	},
+	{
+		id: "strike",
+		label: "Strikethrough",
+		icon: "strikethrough",
+		when: (editor) => hasMark(editor, "strike"),
+		isActive: (editor) => editor.isActive("strike"),
+		run: (editor) => {
+			editor.chain().focus().toggleStrike().run();
+		}
+	},
+	{
+		id: "code",
+		label: "Inline code",
+		icon: "code",
+		when: (editor) => hasMark(editor, "code"),
+		isActive: (editor) => editor.isActive("code"),
+		run: (editor) => {
+			editor.chain().focus().toggleCode().run();
+		}
+	},
+	{
+		id: "link",
+		label: "Link",
+		icon: "link",
+		when: (editor) => canOpenLinkEditor(editor),
+		isActive: (editor) => editor.isActive("link"),
+		run: (editor) => {
+			editor.commands.openLinkEditor();
+		}
+	}
+];
+const CLOSED$2 = Object.freeze({
+	open: false,
+	items: Object.freeze([]),
+	getClientRect: null
+});
+/**
+* Computes toolbar visibility from the live selection: open only for a
+* non-empty text selection in a focused, editable view with at least one
+* runnable item. Node selections (e.g. a whole callout) never show it.
+*/
+function computeState(editor, options) {
+	const { view, state } = editor;
+	const { selection, doc } = state;
+	const { empty, from, to } = selection;
+	if (!editor.isEditable || !view.hasFocus() || empty || !isTextSelection(selection) || !doc.textBetween(from, to).length) return CLOSED$2;
+	const items = filterBubbleToolbarItems(typeof options.items === "function" ? options.items(editor) : options.items, editor);
+	if (items.length === 0) return CLOSED$2;
+	return {
+		open: true,
+		items,
+		getClientRect: () => posToDOMRect(view, from, to)
+	};
+}
+/**
+* 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).
+*/
+const BubbleToolbar = Extension.create({
+	name: "bubbleToolbar",
+	addOptions() {
+		return { items: defaultBubbleToolbarItems };
+	},
+	addStorage() {
+		return {
+			state: CLOSED$2,
+			listeners: /* @__PURE__ */ new Set(),
+			subscribe(listener) {
+				this.listeners.add(listener);
+				return () => this.listeners.delete(listener);
+			},
+			setState(next) {
+				if (!this.state.open && !next.open) return;
+				this.state = next;
+				this.listeners.forEach((listener) => listener());
+			}
+		};
+	},
+	onTransaction() {
+		this.storage.setState(computeState(this.editor, this.options));
+	},
+	onFocus() {
+		this.storage.setState(computeState(this.editor, this.options));
+	},
+	onBlur() {
+		this.storage.setState(CLOSED$2);
+	}
+});
+/** Configures the bubble toolbar extension. */
+function bubbleToolbar(options = {}) {
+	return BubbleToolbar.configure(options);
+}
+//#endregion
+//#region src/callout.ts
+/**
+* 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.
+*/
+const Callout = Node.create({
+	name: "callout",
+	group: "block",
+	content: "block+",
+	defining: true,
+	addOptions() {
+		return {
+			defaultIcon: "💡",
+			HTMLAttributes: {}
+		};
+	},
+	addAttributes() {
+		return { icon: {
+			default: this.options.defaultIcon,
+			parseHTML: (element) => element.getAttribute("data-icon") ?? this.options.defaultIcon,
+			renderHTML: (attributes) => ({ "data-icon": attributes.icon })
+		} };
+	},
+	parseHTML() {
+		return [{ tag: `div[data-type="${this.name}"]` }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"div",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { "data-type": this.name }),
+			0
+		];
+	},
+	addCommands() {
+		return {
+			setCallout: () => ({ commands }) => commands.wrapIn(this.name),
+			toggleCallout: () => ({ commands }) => commands.toggleWrap(this.name),
+			unsetCallout: () => ({ commands }) => commands.lift(this.name)
+		};
+	}
+});
+/** Configures the callout node. */
+function callout(options = {}) {
+	return Callout.configure(options);
+}
+//#endregion
+//#region src/collaboration.ts
+const DEFAULT_USER = {
+	name: "Anonymous",
+	color: "#94A3B8"
+};
+function isHexColor(value) {
+	return typeof value === "string" && /^#[0-9a-fA-F]{6}$/.test(value);
+}
+/**
+* Renders a remote caret as `data-*` attributes rather than the upstream
+* extension's default `collaboration-carets__*` class names, matching this
+* project's rule that core emits no class names — the demo styles carets
+* through `.slash-content` like every other node.
+*/
+function buildCaret(user) {
+	const color = isHexColor(user.color) ? user.color : "transparent";
+	const name = typeof user.name === "string" && user.name.length > 0 ? user.name : "Anonymous";
+	const caret = document.createElement("span");
+	caret.setAttribute("data-collab-caret", "");
+	caret.style.borderColor = color;
+	const label = document.createElement("span");
+	label.setAttribute("data-collab-caret-label", "");
+	label.style.backgroundColor = color;
+	label.textContent = name;
+	caret.append(label);
+	return caret;
+}
+function buildSelection(user) {
+	if (!isHexColor(user.color)) return {};
+	return {
+		nodeName: "span",
+		"data-collab-selection": "",
+		style: `background-color: ${user.color}33`
+	};
+}
+/**
+* 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.
+*/
+function collaboration(options) {
+	const { document, field = "content", provider, user } = options;
+	return [Collaboration.configure({
+		document,
+		field
+	}), ...provider ? [CollaborationCaret.configure({
+		provider,
+		user: user ?? DEFAULT_USER,
+		render: buildCaret,
+		selectionRender: buildSelection
+	})] : []];
+}
+//#endregion
+//#region src/columns.ts
+const MIN_COLUMNS = 2;
+const MAX_COLUMNS = 6;
+const DEFAULT_COLUMNS = 2;
+/**
+* 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).
+*/
+const Column = Node.create({
+	name: "column",
+	content: "block+",
+	isolating: true,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	parseHTML() {
+		return [{ tag: `div[data-type="${this.name}"]` }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"div",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { "data-type": this.name }),
+			0
+		];
+	}
+});
+/**
+* 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.
+*/
+const Columns = Node.create({
+	name: "columns",
+	group: "block",
+	content: "column{2,}",
+	isolating: true,
+	defining: true,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	parseHTML() {
+		return [{ tag: `div[data-type="${this.name}"]` }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"div",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { "data-type": this.name }),
+			0
+		];
+	},
+	addCommands() {
+		return { setColumns: (count = DEFAULT_COLUMNS) => ({ commands }) => {
+			const clamped = Math.min(MAX_COLUMNS, Math.max(MIN_COLUMNS, Math.round(count)));
+			return commands.insertContent({
+				type: this.name,
+				content: Array.from({ length: clamped }, () => ({
+					type: "column",
+					content: [{ type: "paragraph" }]
+				}))
+			});
+		} };
+	}
+});
+/** Configures the columns container node. */
+function columns(options = {}) {
+	return Columns.configure(options);
+}
+/** Configures the column node. */
+function column(options = {}) {
+	return Column.configure(options);
+}
+//#endregion
+//#region src/comment.ts
+const EMPTY_STATE = Object.freeze({ activeThreadIds: [] });
+/**
+* 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`.
+*/
+function activeThreadIds(state) {
+	const markType = state.schema.marks.comment;
+	if (!markType) return [];
+	const { selection } = state;
+	const ids = /* @__PURE__ */ new Set();
+	if (selection.empty) {
+		const marks = state.storedMarks ?? selection.$from.marks();
+		for (const mark of marks) if (mark.type === markType) ids.add(mark.attrs.threadId);
+		return [...ids];
+	}
+	state.doc.nodesBetween(selection.from, selection.to, (node) => {
+		for (const mark of node.marks) if (mark.type === markType) ids.add(mark.attrs.threadId);
+	});
+	return [...ids];
+}
+/**
+* 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`.
+*/
+const Comment = Mark.create({
+	name: "comment",
+	excludes: "",
+	inclusive: false,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	addAttributes() {
+		return { threadId: {
+			default: null,
+			parseHTML: (element) => element.getAttribute("data-thread-id"),
+			renderHTML: (attributes) => attributes.threadId ? { "data-thread-id": attributes.threadId } : {}
+		} };
+	},
+	parseHTML() {
+		return [{ tag: `span[data-type="${this.name}"]` }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"span",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { "data-type": this.name }),
+			0
+		];
+	},
+	addStorage() {
+		return {
+			state: EMPTY_STATE,
+			listeners: /* @__PURE__ */ new Set(),
+			subscribe(listener) {
+				this.listeners.add(listener);
+				return () => this.listeners.delete(listener);
+			},
+			setState(next) {
+				if (this.state.activeThreadIds.length === 0 && next.activeThreadIds.length === 0) return;
+				this.state = next;
+				this.listeners.forEach((listener) => listener());
+			}
+		};
+	},
+	addCommands() {
+		return {
+			setComment: (threadId) => ({ commands }) => commands.setMark(this.name, { threadId }),
+			unsetComment: (threadId) => ({ tr, state, dispatch }) => {
+				const markType = state.schema.marks[this.name];
+				if (!markType) return false;
+				if (dispatch) {
+					const { from, to } = state.selection;
+					tr.removeMark(from, to, markType.create({ threadId }));
+				}
+				return true;
+			},
+			toggleComment: (threadId) => ({ state, commands }) => activeThreadIds(state).includes(threadId) ? commands.unsetComment(threadId) : commands.setComment(threadId)
+		};
+	},
+	onTransaction() {
+		this.storage.setState({ activeThreadIds: activeThreadIds(this.editor.state) });
+	}
+});
+/** Configures the comment mark. */
+function comment(options = {}) {
+	return Comment.configure(options);
+}
+//#endregion
+//#region src/embed.ts
+function optionalAttrs(node) {
+	const attrs = {};
+	if (node.attrs.title) attrs["data-title"] = node.attrs.title;
+	if (node.attrs.description) attrs["data-description"] = node.attrs.description;
+	if (node.attrs.thumbnail) attrs["data-thumbnail"] = node.attrs.thumbnail;
+	return attrs;
+}
+/**
+* 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.
+*/
+const Embed = Node.create({
+	name: "embed",
+	group: "block",
+	atom: true,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	addAttributes() {
+		return {
+			url: { default: null },
+			mode: { default: "bookmark" },
+			title: { default: null },
+			description: { default: null },
+			thumbnail: { default: null }
+		};
+	},
+	parseHTML() {
+		return [{
+			tag: `iframe[data-type="${this.name}"]`,
+			getAttrs: (element) => ({
+				url: element.getAttribute("src"),
+				mode: "iframe",
+				title: element.getAttribute("data-title"),
+				description: element.getAttribute("data-description"),
+				thumbnail: element.getAttribute("data-thumbnail")
+			})
+		}, {
+			tag: `a[data-type="${this.name}"]`,
+			getAttrs: (element) => ({
+				url: element.getAttribute("href"),
+				mode: "bookmark",
+				title: element.getAttribute("data-title"),
+				description: element.getAttribute("data-description"),
+				thumbnail: element.getAttribute("data-thumbnail")
+			})
+		}];
+	},
+	renderHTML({ HTMLAttributes, node }) {
+		const shared = mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+			"data-type": this.name,
+			"data-mode": node.attrs.mode,
+			...optionalAttrs(node)
+		});
+		if (node.attrs.mode === "iframe") return ["iframe", mergeAttributes(shared, {
+			...node.attrs.url ? { src: node.attrs.url } : {},
+			loading: "lazy",
+			referrerpolicy: "no-referrer",
+			sandbox: "allow-scripts allow-same-origin allow-popups"
+		})];
+		return [
+			"a",
+			mergeAttributes(shared, {
+				...node.attrs.url ? { href: node.attrs.url } : {},
+				target: "_blank",
+				rel: "noopener noreferrer"
+			}),
+			node.attrs.title ?? node.attrs.url ?? "Untitled link"
+		];
+	},
+	addCommands() {
+		return { setEmbed: (options = {}) => ({ commands }) => commands.insertContent({
+			type: this.name,
+			attrs: {
+				id: crypto.randomUUID(),
+				url: options.url ?? null,
+				mode: options.mode ?? "bookmark",
+				title: options.title ?? null,
+				description: options.description ?? null,
+				thumbnail: options.thumbnail ?? null
+			}
+		}) };
+	}
+});
+/** Configures the embed node. */
+function embed(options = {}) {
+	return Embed.configure(options);
+}
+//#endregion
+//#region src/file.ts
+function initialAttrs$2(id, options) {
+	if (options && "file" in options) {
+		const { file } = options;
+		return {
+			id,
+			src: null,
+			name: file.name,
+			size: file.size,
+			mime: file.type || null,
+			status: "uploading",
+			error: null
+		};
+	}
+	return {
+		id,
+		src: options?.src ?? null,
+		name: options?.name ?? null,
+		size: options?.size ?? null,
+		mime: options?.mime ?? null,
+		status: "ready",
+		error: null
+	};
+}
+/**
+* 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.
+*/
+const File = Node.create({
+	name: "file",
+	group: "block",
+	atom: true,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	addStorage() {
+		return { pending: new PendingUploadRegistry() };
+	},
+	addAttributes() {
+		return {
+			src: { default: null },
+			name: { default: null },
+			size: {
+				default: null,
+				parseHTML: (element) => {
+					const value = element.getAttribute("data-size");
+					return value ? Number(value) : null;
+				},
+				renderHTML: (attributes) => attributes.size != null ? { "data-size": String(attributes.size) } : {}
+			},
+			mime: {
+				default: null,
+				parseHTML: (element) => element.getAttribute("data-mime"),
+				renderHTML: (attributes) => attributes.mime ? { "data-mime": attributes.mime } : {}
+			},
+			status: {
+				default: "ready",
+				parseHTML: (element) => element.getAttribute("data-status") ?? "ready",
+				renderHTML: (attributes) => ({ "data-status": attributes.status })
+			},
+			error: {
+				default: null,
+				parseHTML: (element) => element.getAttribute("data-error"),
+				renderHTML: (attributes) => attributes.error ? { "data-error": attributes.error } : {}
+			}
+		};
+	},
+	parseHTML() {
+		return [{ tag: `div[data-type="${this.name}"]` }];
+	},
+	renderHTML({ HTMLAttributes, node }) {
+		return [
+			"div",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { "data-type": this.name }),
+			[
+				"a",
+				{
+					href: node.attrs.src ?? void 0,
+					download: node.attrs.name ?? void 0,
+					target: "_blank",
+					rel: "noopener noreferrer"
+				},
+				node.attrs.name ?? "Untitled file"
+			]
+		];
+	},
+	addCommands() {
+		return {
+			setFile: (options) => ({ commands, dispatch }) => {
+				const id = crypto.randomUUID();
+				const inserted = commands.insertContent({
+					type: this.name,
+					attrs: initialAttrs$2(id, options)
+				});
+				if (inserted && dispatch && options && "file" in options) {
+					const { file, adapter } = options;
+					queueMicrotask(() => {
+						runUpload({
+							editor: this.editor,
+							typeName: this.name,
+							id,
+							file,
+							adapter,
+							pending: this.storage.pending,
+							toAttrs: (result) => ({ src: result.url })
+						});
+					});
+				}
+				return inserted;
+			},
+			retryFile: (id, override) => ({ dispatch }) => {
+				const hasEntry = override !== void 0 || this.storage.pending.get(id) !== void 0;
+				if (!dispatch || !hasEntry) return hasEntry;
+				queueMicrotask(() => {
+					retryUpload({
+						editor: this.editor,
+						typeName: this.name,
+						id,
+						pending: this.storage.pending,
+						toAttrs: (result) => ({ src: result.url }),
+						override
+					});
+				});
+				return true;
+			}
+		};
+	}
+});
+/** Configures the file node. */
+function file(options = {}) {
+	return File.configure(options);
+}
+//#endregion
+//#region src/image.ts
+function initialAttrs$1(id, options) {
+	if (options && "file" in options) return {
+		id,
+		src: null,
+		alt: options.alt ?? null,
+		width: null,
+		status: "uploading",
+		error: null
+	};
+	return {
+		id,
+		src: options?.src ?? null,
+		alt: options?.alt ?? null,
+		width: options?.width ?? null,
+		status: "ready",
+		error: null
+	};
+}
+/**
+* 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.
+*/
+const Image = Node.create({
+	name: "image",
+	group: "block",
+	atom: true,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	addStorage() {
+		return { pending: new PendingUploadRegistry() };
+	},
+	addAttributes() {
+		return {
+			src: { default: null },
+			alt: { default: null },
+			width: {
+				default: null,
+				parseHTML: (element) => {
+					const value = element.getAttribute("width");
+					return value ? Number(value) : null;
+				}
+			},
+			status: {
+				default: "ready",
+				parseHTML: (element) => element.getAttribute("data-status") ?? "ready",
+				renderHTML: (attributes) => ({ "data-status": attributes.status })
+			},
+			error: {
+				default: null,
+				parseHTML: (element) => element.getAttribute("data-error"),
+				renderHTML: (attributes) => attributes.error ? { "data-error": attributes.error } : {}
+			}
+		};
+	},
+	parseHTML() {
+		return [{ tag: "img[src]" }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return ["img", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { "data-type": this.name })];
+	},
+	addCommands() {
+		return {
+			setImage: (options) => ({ commands, dispatch }) => {
+				const id = crypto.randomUUID();
+				const inserted = commands.insertContent({
+					type: this.name,
+					attrs: initialAttrs$1(id, options)
+				});
+				if (inserted && dispatch && options && "file" in options) {
+					const { file, adapter } = options;
+					queueMicrotask(() => {
+						runUpload({
+							editor: this.editor,
+							typeName: this.name,
+							id,
+							file,
+							adapter,
+							pending: this.storage.pending,
+							toAttrs: (result) => ({ src: result.url })
+						});
+					});
+				}
+				return inserted;
+			},
+			retryImage: (id, override) => ({ dispatch }) => {
+				const hasEntry = override !== void 0 || this.storage.pending.get(id) !== void 0;
+				if (!dispatch || !hasEntry) return hasEntry;
+				queueMicrotask(() => {
+					retryUpload({
+						editor: this.editor,
+						typeName: this.name,
+						id,
+						pending: this.storage.pending,
+						toAttrs: (result) => ({ src: result.url }),
+						override
+					});
+				});
+				return true;
+			}
+		};
+	}
+});
+/** Configures the image node. */
+function image(options = {}) {
+	return Image.configure(options);
+}
+//#endregion
+//#region src/mention.ts
+const mentionPluginKey = new PluginKey("mention");
+const CLOSED$1 = Object.freeze({
+	open: false,
+	query: "",
+	items: Object.freeze([]),
+	activeIndex: -1,
+	loading: false,
+	getClientRect: null
+});
+/**
+* `@`-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.
+*/
+const Mention = Node.create({
+	name: "mention",
+	group: "inline",
+	inline: true,
+	atom: true,
+	selectable: true,
+	addOptions() {
+		return {
+			char: "@",
+			items: () => [],
+			debounce: 150,
+			minQueryLength: 0,
+			HTMLAttributes: {}
+		};
+	},
+	addAttributes() {
+		return {
+			id: {
+				default: null,
+				parseHTML: (element) => element.getAttribute("data-id")
+			},
+			label: {
+				default: null,
+				parseHTML: (element) => element.textContent?.replace(/^@/, "") ?? null
+			}
+		};
+	},
+	parseHTML() {
+		return [{ tag: `span[data-type="${this.name}"]` }];
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		return [
+			"span",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+				"data-type": this.name,
+				"data-id": node.attrs.id
+			}),
+			`@${node.attrs.label}`
+		];
+	},
+	renderText({ node }) {
+		return `@${node.attrs.label}`;
+	},
+	addCommands() {
+		return { insertMention: (item) => ({ chain }) => chain().insertContent({
+			type: this.name,
+			attrs: {
+				id: item.id,
+				label: item.label
+			}
+		}).insertContent(" ").run() };
+	},
+	addStorage() {
+		return {
+			state: CLOSED$1,
+			listeners: /* @__PURE__ */ new Set(),
+			active: null,
+			subscribe(listener) {
+				this.listeners.add(listener);
+				return () => this.listeners.delete(listener);
+			},
+			setActive(props) {
+				this.active = props;
+				if (!props) {
+					if (this.state !== CLOSED$1) {
+						this.state = CLOSED$1;
+						this.listeners.forEach((listener) => listener());
+					}
+					return;
+				}
+				const sameItems = this.state.items.length === props.items.length && this.state.items.every((item, index) => item === props.items[index]);
+				this.state = {
+					open: true,
+					query: props.query,
+					items: props.items,
+					activeIndex: props.items.length === 0 ? -1 : sameItems ? this.state.activeIndex : 0,
+					loading: props.loading,
+					getClientRect: props.clientRect ?? null
+				};
+				this.listeners.forEach((listener) => listener());
+			},
+			setActiveIndex(index) {
+				const { items } = this.state;
+				if (!this.state.open || items.length === 0) return;
+				const wrapped = (index % items.length + items.length) % items.length;
+				if (wrapped !== this.state.activeIndex) {
+					this.state = {
+						...this.state,
+						activeIndex: wrapped
+					};
+					this.listeners.forEach((listener) => listener());
+				}
+			},
+			select(index) {
+				const item = this.state.items[index ?? this.state.activeIndex];
+				if (this.active && item) this.active.command(item);
+			},
+			close() {
+				this.active?.editor.commands.focus();
+				this.setActive(null);
+			}
+		};
+	},
+	addProseMirrorPlugins() {
+		const { editor } = this;
+		const getStorage = () => editor.storage.mention;
+		const { onError } = this.options;
+		return [Suggestion({
+			editor,
+			char: this.options.char,
+			pluginKey: mentionPluginKey,
+			allowSpaces: false,
+			debounce: this.options.debounce,
+			minQueryLength: this.options.minQueryLength,
+			items: async ({ query, signal }) => {
+				try {
+					return await this.options.items(query, {
+						editor,
+						signal
+					});
+				} catch (error) {
+					if (signal.aborted) return [];
+					onError?.(error, { editor });
+					return [];
+				}
+			},
+			command: ({ editor: instance, range, props: item }) => {
+				instance.chain().focus().insertContentAt(range, [{
+					type: "mention",
+					attrs: {
+						id: item.id,
+						label: item.label
+					}
+				}, {
+					type: "text",
+					text: " "
+				}]).run();
+			},
+			render: () => ({
+				onStart: (props) => getStorage().setActive(props),
+				onUpdate: (props) => getStorage().setActive(props),
+				onExit: () => getStorage().setActive(null),
+				onKeyDown: ({ event }) => {
+					const storage = getStorage();
+					if (!storage.state.open) return false;
+					switch (event.key) {
+						case "ArrowDown":
+							storage.setActiveIndex(storage.state.activeIndex + 1);
+							return true;
+						case "ArrowUp":
+							storage.setActiveIndex(storage.state.activeIndex - 1);
+							return true;
+						case "Enter":
+						case "Tab":
+							if (storage.state.items.length === 0) return false;
+							storage.select();
+							return true;
+						default: return false;
+					}
+				}
+			})
+		})];
+	}
+});
+/** Configures the mention node. `items` is required — there is no default provider. */
+function mention(options) {
+	return Mention.configure(options);
+}
+//#endregion
+//#region src/slash-items.ts
+const TITLE_PREFIX = 100;
+const TITLE_WORD_PREFIX = 80;
+const ALIAS_PREFIX = 60;
+const TITLE_SUBSTRING = 40;
+const KEYWORD_MATCH = 20;
+function score(item, query) {
+	const title = item.title.toLowerCase();
+	if (title.startsWith(query)) return TITLE_PREFIX;
+	if (title.split(/\s+/).some((word) => word.startsWith(query))) return TITLE_WORD_PREFIX;
+	if (item.aliases?.some((alias) => alias.toLowerCase().startsWith(query))) return ALIAS_PREFIX;
+	if (title.includes(query)) return TITLE_SUBSTRING;
+	if (item.keywords?.some((keyword) => keyword.toLowerCase().includes(query))) return KEYWORD_MATCH;
+	return 0;
+}
+/**
+* Ranks items against a slash query. Ties keep declaration order, so the item
+* list doubles as the default ordering of the menu.
+*/
+function filterSlashItems(items, query, editor) {
+	const available = editor ? items.filter((item) => item.when?.(editor) ?? true) : items;
+	const normalized = query.trim().toLowerCase();
+	if (!normalized) return available;
+	return available.map((item) => ({
+		item,
+		score: score(item, normalized)
+	})).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score).map((entry) => entry.item);
+}
+const BASIC = "Basic blocks";
+const MEDIA = "Media";
+const STRUCTURE = "Structure";
+function hasNode(editor, name) {
+	return editor.schema.nodes[name] !== void 0;
+}
+const defaultSlashItems = [
+	{
+		id: "paragraph",
+		title: "Text",
+		group: BASIC,
+		description: "Plain paragraph",
+		aliases: ["paragraph", "plain"],
+		keywords: ["body", "p"],
+		icon: "text",
+		when: (editor) => hasNode(editor, "paragraph"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setParagraph().run();
+		}
+	},
+	{
+		id: "heading-1",
+		title: "Heading 1",
+		group: BASIC,
+		description: "Large section title",
+		aliases: ["h1", "title"],
+		keywords: ["#"],
+		icon: "heading-1",
+		when: (editor) => hasNode(editor, "heading"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setNode("heading", { level: 1 }).run();
+		}
+	},
+	{
+		id: "heading-2",
+		title: "Heading 2",
+		group: BASIC,
+		description: "Medium section title",
+		aliases: ["h2", "subtitle"],
+		keywords: ["##"],
+		icon: "heading-2",
+		when: (editor) => hasNode(editor, "heading"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setNode("heading", { level: 2 }).run();
+		}
+	},
+	{
+		id: "heading-3",
+		title: "Heading 3",
+		group: BASIC,
+		description: "Small section title",
+		aliases: ["h3"],
+		keywords: ["###"],
+		icon: "heading-3",
+		when: (editor) => hasNode(editor, "heading"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setNode("heading", { level: 3 }).run();
+		}
+	},
+	{
+		id: "bullet-list",
+		title: "Bulleted list",
+		group: BASIC,
+		description: "Unordered list",
+		aliases: ["ul", "bullet"],
+		keywords: ["-", "*"],
+		icon: "list",
+		when: (editor) => hasNode(editor, "bulletList"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).toggleBulletList().run();
+		}
+	},
+	{
+		id: "ordered-list",
+		title: "Numbered list",
+		group: BASIC,
+		description: "Ordered list",
+		aliases: ["ol", "numbered"],
+		keywords: ["1."],
+		icon: "list-ordered",
+		when: (editor) => hasNode(editor, "orderedList"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).toggleOrderedList().run();
+		}
+	},
+	{
+		id: "task-list",
+		title: "To-do list",
+		group: BASIC,
+		description: "Checklist with checkboxes",
+		aliases: [
+			"todo",
+			"checklist",
+			"checkbox"
+		],
+		keywords: ["[]", "[ ]"],
+		icon: "list-checks",
+		when: (editor) => hasNode(editor, "taskList"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).toggleTaskList().run();
+		}
+	},
+	{
+		id: "blockquote",
+		title: "Quote",
+		group: BASIC,
+		description: "Capture a quotation",
+		aliases: ["quote", "citation"],
+		keywords: [">"],
+		icon: "quote",
+		when: (editor) => hasNode(editor, "blockquote"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).toggleBlockquote().run();
+		}
+	},
+	{
+		id: "callout",
+		title: "Callout",
+		group: BASIC,
+		description: "Highlighted aside",
+		aliases: [
+			"note",
+			"info",
+			"tip"
+		],
+		keywords: ["!"],
+		icon: "message-square",
+		when: (editor) => hasNode(editor, "callout"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setCallout().run();
+		}
+	},
+	{
+		id: "toggle",
+		title: "Toggle list",
+		group: BASIC,
+		description: "Collapsible content",
+		aliases: [
+			"details",
+			"collapse",
+			"dropdown"
+		],
+		keywords: ["toggle"],
+		icon: "chevron-right",
+		when: (editor) => hasNode(editor, "details"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setDetails().run();
+		}
+	},
+	{
+		id: "code-block",
+		title: "Code block",
+		group: BASIC,
+		description: "Monospaced code",
+		aliases: ["code", "snippet"],
+		keywords: ["```"],
+		icon: "code",
+		when: (editor) => hasNode(editor, "codeBlock"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setCodeBlock().run();
+		}
+	},
+	{
+		id: "horizontal-rule",
+		title: "Divider",
+		group: BASIC,
+		description: "Visual separator",
+		aliases: [
+			"divider",
+			"hr",
+			"rule"
+		],
+		keywords: ["---"],
+		icon: "minus",
+		when: (editor) => hasNode(editor, "horizontalRule"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setHorizontalRule().run();
+		}
+	},
+	{
+		id: "image",
+		title: "Image",
+		group: MEDIA,
+		description: "Upload or embed an image",
+		aliases: [
+			"image",
+			"picture",
+			"photo"
+		],
+		keywords: ["img"],
+		icon: "image",
+		when: (editor) => hasNode(editor, "image"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setImage().run();
+		}
+	},
+	{
+		id: "file",
+		title: "File",
+		group: MEDIA,
+		description: "Upload or attach a file",
+		aliases: [
+			"file",
+			"attachment",
+			"upload"
+		],
+		keywords: ["doc", "pdf"],
+		icon: "paperclip",
+		when: (editor) => hasNode(editor, "file"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setFile().run();
+		}
+	},
+	{
+		id: "video",
+		title: "Video",
+		group: MEDIA,
+		description: "Upload or embed a video",
+		aliases: ["video", "movie"],
+		keywords: ["mp4"],
+		icon: "video",
+		when: (editor) => hasNode(editor, "video"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setVideo().run();
+		}
+	},
+	{
+		id: "embed",
+		title: "Embed",
+		group: MEDIA,
+		description: "Bookmark or iframe a link",
+		aliases: [
+			"embed",
+			"bookmark",
+			"link",
+			"iframe"
+		],
+		keywords: ["url"],
+		icon: "link",
+		when: (editor) => hasNode(editor, "embed"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setEmbed().run();
+		}
+	},
+	{
+		id: "table",
+		title: "Table",
+		group: STRUCTURE,
+		description: "Rows and columns of cells",
+		aliases: ["table", "grid"],
+		keywords: ["spreadsheet"],
+		icon: "table",
+		when: (editor) => hasNode(editor, "table"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).insertTable({
+				rows: 3,
+				cols: 3,
+				withHeaderRow: true
+			}).run();
+		}
+	},
+	{
+		id: "columns",
+		title: "Columns",
+		group: STRUCTURE,
+		description: "Side-by-side layout",
+		aliases: ["columns", "layout"],
+		keywords: ["split"],
+		icon: "columns",
+		when: (editor) => hasNode(editor, "columns"),
+		run: ({ editor, range }) => {
+			editor.chain().focus().deleteRange(range).setColumns(2).run();
+		}
+	}
+];
+//#endregion
+//#region src/slash-command.ts
+const slashCommandPluginKey = new PluginKey("slashCommand");
+const CLOSED = Object.freeze({
+	open: false,
+	query: "",
+	items: Object.freeze([]),
+	activeIndex: -1,
+	getClientRect: null
+});
+const SlashCommand = Extension.create({
+	name: "slashCommand",
+	addOptions() {
+		return {
+			char: "/",
+			items: defaultSlashItems
+		};
+	},
+	addStorage() {
+		return {
+			state: CLOSED,
+			listeners: /* @__PURE__ */ new Set(),
+			active: null,
+			subscribe(listener) {
+				this.listeners.add(listener);
+				return () => this.listeners.delete(listener);
+			},
+			setActive(props) {
+				this.active = props;
+				if (!props) {
+					if (this.state !== CLOSED) {
+						this.state = CLOSED;
+						this.listeners.forEach((listener) => listener());
+					}
+					return;
+				}
+				const sameItems = this.state.items.length === props.items.length && this.state.items.every((item, index) => item === props.items[index]);
+				this.state = {
+					open: true,
+					query: props.query,
+					items: props.items,
+					activeIndex: props.items.length === 0 ? -1 : sameItems ? this.state.activeIndex : 0,
+					getClientRect: props.clientRect ?? null
+				};
+				this.listeners.forEach((listener) => listener());
+			},
+			setActiveIndex(index) {
+				const { items } = this.state;
+				if (!this.state.open || items.length === 0) return;
+				const wrapped = (index % items.length + items.length) % items.length;
+				if (wrapped !== this.state.activeIndex) {
+					this.state = {
+						...this.state,
+						activeIndex: wrapped
+					};
+					this.listeners.forEach((listener) => listener());
+				}
+			},
+			select(index) {
+				const item = this.state.items[index ?? this.state.activeIndex];
+				if (this.active && item) this.active.command(item);
+			},
+			close() {
+				this.active?.editor.commands.focus();
+				this.setActive(null);
+			}
+		};
+	},
+	addProseMirrorPlugins() {
+		const { editor } = this;
+		const getStorage = () => editor.storage.slashCommand;
+		const { onError } = this.options;
+		const resolveItems = () => typeof this.options.items === "function" ? this.options.items(editor) : this.options.items;
+		return [Suggestion({
+			editor,
+			char: this.options.char,
+			pluginKey: slashCommandPluginKey,
+			allowSpaces: false,
+			allow: ({ state, range }) => !state.doc.resolve(range.from).parent.type.spec.code,
+			items: ({ query }) => filterSlashItems(resolveItems(), query, editor),
+			command: ({ editor: instance, range, props: item }) => {
+				try {
+					item.run({
+						editor: instance,
+						range
+					});
+				} catch (error) {
+					if (onError) onError(error, {
+						item,
+						editor: instance
+					});
+					else throw error;
+				}
+			},
+			render: () => ({
+				onStart: (props) => getStorage().setActive(props),
+				onUpdate: (props) => getStorage().setActive(props),
+				onExit: () => getStorage().setActive(null),
+				onKeyDown: ({ event }) => {
+					const storage = getStorage();
+					if (!storage.state.open) return false;
+					switch (event.key) {
+						case "ArrowDown":
+							storage.setActiveIndex(storage.state.activeIndex + 1);
+							return true;
+						case "ArrowUp":
+							storage.setActiveIndex(storage.state.activeIndex - 1);
+							return true;
+						case "Enter":
+						case "Tab":
+							if (storage.state.items.length === 0) return false;
+							storage.select();
+							return true;
+						default: return false;
+					}
+				}
+			})
+		})];
+	}
+});
+/** Configures the slash menu extension. */
+function slashCommand(options = {}) {
+	return SlashCommand.configure(options);
+}
+//#endregion
+//#region src/table.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.
+*/
+function table(options = {}) {
+	const { table: tableOption, ...rest } = options;
+	return TableKit.configure({
+		table: tableOption === void 0 ? { resizable: true } : tableOption,
+		...rest
+	});
+}
+//#endregion
+//#region src/video.ts
+function initialAttrs(id, options) {
+	if (options && "file" in options) return {
+		id,
+		src: null,
+		poster: options.poster ?? null,
+		status: "uploading",
+		error: null
+	};
+	return {
+		id,
+		src: options?.src ?? null,
+		poster: options?.poster ?? null,
+		status: "ready",
+		error: null
+	};
+}
+/**
+* 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.
+*/
+const Video = Node.create({
+	name: "video",
+	group: "block",
+	atom: true,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	addStorage() {
+		return { pending: new PendingUploadRegistry() };
+	},
+	addAttributes() {
+		return {
+			src: { default: null },
+			poster: { default: null },
+			status: {
+				default: "ready",
+				parseHTML: (element) => element.getAttribute("data-status") ?? "ready",
+				renderHTML: (attributes) => ({ "data-status": attributes.status })
+			},
+			error: {
+				default: null,
+				parseHTML: (element) => element.getAttribute("data-error"),
+				renderHTML: (attributes) => attributes.error ? { "data-error": attributes.error } : {}
+			}
+		};
+	},
+	parseHTML() {
+		return [{ tag: "video[src]" }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return ["video", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+			"data-type": this.name,
+			controls: ""
+		})];
+	},
+	addCommands() {
+		return {
+			setVideo: (options) => ({ commands, dispatch }) => {
+				const id = crypto.randomUUID();
+				const inserted = commands.insertContent({
+					type: this.name,
+					attrs: initialAttrs(id, options)
+				});
+				if (inserted && dispatch && options && "file" in options) {
+					const { file, adapter } = options;
+					queueMicrotask(() => {
+						runUpload({
+							editor: this.editor,
+							typeName: this.name,
+							id,
+							file,
+							adapter,
+							pending: this.storage.pending,
+							toAttrs: (result) => ({ src: result.url })
+						});
+					});
+				}
+				return inserted;
+			},
+			retryVideo: (id, override) => ({ dispatch }) => {
+				const hasEntry = override !== void 0 || this.storage.pending.get(id) !== void 0;
+				if (!dispatch || !hasEntry) return hasEntry;
+				queueMicrotask(() => {
+					retryUpload({
+						editor: this.editor,
+						typeName: this.name,
+						id,
+						pending: this.storage.pending,
+						toAttrs: (result) => ({ src: result.url }),
+						override
+					});
+				});
+				return true;
+			}
+		};
+	}
+});
+/** Configures the video node. */
+function video(options = {}) {
+	return Video.configure(options);
+}
+//#endregion
+//#region src/block-kit.ts
+const DEFAULT_HEADING_LEVELS = [
+	1,
+	2,
+	3
+];
+/**
+* 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.
+*/
+function createBlockKit(options = {}) {
+	const { headingLevels = DEFAULT_HEADING_LEVELS, history = true, slash, blockId: blockIdOptions, drag, bubbleToolbar: bubbleToolbarOptions, image: imageOptions, file: fileOptions, video: videoOptions, embed: embedOptions, table: tableOptions, columns: columnsOptions, linkEditor: linkEditorOptions, mention: mentionOptions, ai: aiOptions, collaboration: collaborationOptions, comment: commentOptions, extend = [] } = options;
+	const resolvedAi = aiOptions ? {
+		actions: defaultAiSlashActions,
+		node: true,
+		...aiOptions
+	} : void 0;
+	const resolvedHistory = collaborationOptions ? false : history;
+	return [
+		StarterKit.configure({
+			heading: { levels: headingLevels },
+			undoRedo: resolvedHistory ? {} : false,
+			link: {
+				openOnClick: false,
+				enableClickSelection: true
+			}
+		}),
+		TaskList,
+		TaskItem.configure({ nested: true }),
+		Callout,
+		Details.configure({ persist: true }),
+		DetailsSummary,
+		DetailsContent,
+		...imageOptions === false ? [] : [image(imageOptions)],
+		...fileOptions === false ? [] : [file(fileOptions)],
+		...videoOptions === false ? [] : [video(videoOptions)],
+		...embedOptions === false ? [] : [embed(embedOptions)],
+		...tableOptions === false ? [] : [table(tableOptions)],
+		...columnsOptions === false ? [] : [columns(columnsOptions), column()],
+		...resolvedAi && resolvedAi.node !== false ? [aiBlock()] : [],
+		...mentionOptions === false || !mentionOptions ? [] : [mention(mentionOptions)],
+		...slash === false ? [] : [slashCommand({
+			...slash,
+			items: slash?.items ?? (() => [...defaultSlashItems, ...resolvedAi ? createAiSlashItems(resolvedAi) : []])()
+		})],
+		...blockIdOptions === false ? [] : [blockId(blockIdOptions)],
+		...drag === false ? [] : [blockDrag(drag)],
+		...bubbleToolbarOptions === false ? [] : [bubbleToolbar(bubbleToolbarOptions)],
+		...linkEditorOptions === false ? [] : [linkEditor(linkEditorOptions)],
+		...collaborationOptions === false || !collaborationOptions ? [] : [...collaboration(collaborationOptions)],
+		...commentOptions === false ? [] : [comment(commentOptions)],
+		...extend
+	];
+}
+//#endregion
+export { AiBlock, BLOCK_ID_REMOTE_META, BlockDrag, BlockId, BubbleToolbar, Callout, Column, Columns, Comment, Embed, File, Image, LinkEditor, Mention, PendingAiRegistry, PendingUploadRegistry, SlashCommand, TableKit, Video, 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 };