@multiplatform.one/rich-text 6.3.0 → 6.4.1

package/src/editor/TiptapEditor.tsx

@@ -20,27 +20,6 @@ import {
   useState,
 } from "react";
 import { useEditor, EditorContent } from "@tiptap/react";
-import { Extension } from "@tiptap/core";
-import StarterKit from "@tiptap/starter-kit";
-import Placeholder from "@tiptap/extension-placeholder";
-import TextAlign from "@tiptap/extension-text-align";
-import { Color } from "@tiptap/extension-color";
-import { TextStyle } from "@tiptap/extension-text-style";
-import { Highlight } from "@tiptap/extension-highlight";
-import { Subscript } from "@tiptap/extension-subscript";
-import { Superscript } from "@tiptap/extension-superscript";
-import TaskList from "@tiptap/extension-task-list";
-import TaskItem from "@tiptap/extension-task-item";
-import Image from "@tiptap/extension-image";
-import Typography from "@tiptap/extension-typography";
-import CharacterCount from "@tiptap/extension-character-count";
-import { Details, DetailsContent, DetailsSummary } from "@tiptap/extension-details";
-
-import { Table } from "@tiptap/extension-table";
-import { TableRow } from "@tiptap/extension-table-row";
-import { TableHeader } from "@tiptap/extension-table-header";
-import { TableCell } from "@tiptap/extension-table-cell";
-import { common, createLowlight } from "lowlight";
 import { View, getTokens, styled, useTheme, useThemeName } from "tamagui";
 import { isWeb } from "@tamagui/constants";
 import { menuRowFrame, useResolvedKnobs } from "@multiplatform.one/theme";
@@ -50,21 +29,13 @@ import { defaultEditorState } from "../types";
 import { RichEditorContext } from "../context";
 import { t } from "../shared/t";
 import { getEditorCSS } from "./editorStyles";
-import { SlashCommands } from "./SlashCommands";
-import { MarkdownPaste } from "./MarkdownPaste";
-import { BlockDragHandle } from "./BlockDragHandle";
-import { MediaUpload } from "./media";
+import { buildEditorExtensions } from "./extensions";
+import { isCommandInCapabilities } from "./capabilities";
 import { createMentionExtension } from "./mentions";
-import { EmojiSuggestion } from "./emoji";
-import { InlineMath } from "./mathematics";
-import { CodeBlockWithPreview, PreviewChromeStore, setPreviewChrome } from "./codeBlockPreview";
+import { setPreviewChrome } from "./codeBlockPreview";
 import { htmlToMarkdown, markdownToHtml } from "./markdown";
 import { cleanPastedHtml } from "./pasteCleanup";
-import {
-  SuggestionChromeStore,
-  fallbackSuggestionChrome,
-  type SuggestionChrome,
-} from "./suggestionPopup";
+import { fallbackSuggestionChrome, type SuggestionChrome } from "./suggestionPopup";
 import { getEditorStateFromTiptap } from "./useEditorState";
 import { BubbleToolbar } from "../toolbar/BubbleToolbar";
 import { LinkBubble } from "../toolbar/LinkBubble";
@@ -73,159 +44,9 @@ import { ImageBubble } from "../toolbar/ImageBubble";
 import { TableBubble } from "../toolbar/TableBubble";
 import { MathBubble } from "../toolbar/MathBubble";
 
-const lowlight = createLowlight(common);
-
 /** Enter/exit fade for bubbles and suggestion popups (0 when animation none) */
 const MOTION_MS = 120;
 
-/**
- * Tab / Shift-Tab indentation inside code blocks.
- * Inserts or removes 2 spaces at the cursor (or start of each selected line).
- */
-const CodeBlockTabIndent = Extension.create({
-  name: "codeBlockTabIndent",
-  addKeyboardShortcuts() {
-    return {
-      Tab: ({ editor }) => {
-        if (!editor.isActive("codeBlock")) return false;
-        const { state, dispatch } = editor.view;
-        const { from, to } = state.selection;
-
-        if (from === to) {
-          dispatch(state.tr.insertText("  ", from, to));
-          return true;
-        }
-
-        const doc = state.doc;
-        const lines: { start: number }[] = [];
-        doc.nodesBetween(from, to, (node, pos) => {
-          if (node.isTextblock) {
-            lines.push({ start: pos + 1 });
-          }
-        });
-        if (lines.length === 0) {
-          dispatch(state.tr.insertText("  ", from, to));
-          return true;
-        }
-
-        let tr = state.tr;
-        let offset = 0;
-        for (const line of lines) {
-          const lineStart = line.start + offset;
-          tr = tr.insertText("  ", lineStart);
-          offset += 2;
-        }
-        dispatch(tr);
-        return true;
-      },
-      "Shift-Tab": ({ editor }) => {
-        if (!editor.isActive("codeBlock")) return false;
-        const { state, dispatch } = editor.view;
-        const { from, to, $from } = state.selection;
-
-        if (from === to) {
-          const lineStart = from - $from.parentOffset;
-          const text = state.doc.textBetween(lineStart, from);
-          const leadingSpaces = text.match(/^ {1,2}/)?.[0];
-          if (leadingSpaces) {
-            dispatch(state.tr.delete(lineStart, lineStart + leadingSpaces.length));
-          }
-          return true;
-        }
-
-        const doc = state.doc;
-        let tr = state.tr;
-        let offset = 0;
-        doc.nodesBetween(from, to, (node, pos) => {
-          if (node.isTextblock) {
-            const lineStart = pos + 1 + offset;
-            const text = tr.doc.textBetween(
-              lineStart,
-              Math.min(lineStart + node.content.size, tr.doc.content.size),
-            );
-            const leadingSpaces = text.match(/^ {1,2}/)?.[0];
-            if (leadingSpaces) {
-              tr = tr.delete(lineStart, lineStart + leadingSpaces.length);
-              offset -= leadingSpaces.length;
-            }
-          }
-        });
-        dispatch(tr);
-        return true;
-      },
-    };
-  },
-});
-
-/**
- * Override Shift-Enter and Mod-Enter to create new paragraphs instead of
- * hard breaks (<br>). Mirrors GitLab's approach: HardBreak node stays
- * registered (so <br> in pasted HTML is preserved) but its keyboard
- * shortcuts are replaced with the default enter (split paragraph) behavior.
- */
-const ParagraphEnterKeys = Extension.create({
-  name: "paragraphEnterKeys",
-  priority: 1000,
-  addKeyboardShortcuts() {
-    return {
-      "Shift-Enter": ({ editor }) =>
-        editor.commands.first([
-          () => editor.commands.newlineInCode(),
-          () => editor.commands.splitListItem("listItem"),
-          () => editor.commands.createParagraphNear(),
-          () => editor.commands.liftEmptyBlock(),
-          () => editor.commands.splitBlock(),
-        ]),
-      "Mod-Enter": ({ editor }) =>
-        editor.commands.first([
-          () => editor.commands.newlineInCode(),
-          () => editor.commands.createParagraphNear(),
-          () => editor.commands.liftEmptyBlock(),
-          () => editor.commands.splitBlock(),
-        ]),
-    };
-  },
-});
-
-/**
- * Tab/Shift-Tab indent/dedent and Alt+Arrow move for list items.
- * Tab sinks (indents), Shift-Tab lifts (dedents).
- * Alt+Up/Down moves the list item up or down among siblings.
- */
-const ListItemKeys = Extension.create({
-  name: "listItemKeys",
-  addKeyboardShortcuts() {
-    return {
-      Tab: ({ editor }) => {
-        if (editor.isActive("codeBlock")) return false;
-        if (
-          editor.isActive("bulletList") ||
-          editor.isActive("orderedList") ||
-          editor.isActive("taskList")
-        ) {
-          return (
-            editor.commands.sinkListItem("listItem") || editor.commands.sinkListItem("taskItem")
-          );
-        }
-        return false;
-      },
-      "Shift-Tab": ({ editor }) => {
-        if (editor.isActive("codeBlock")) return false;
-        if (
-          editor.isActive("bulletList") ||
-          editor.isActive("orderedList") ||
-          editor.isActive("taskList")
-        ) {
-          return (
-            editor.commands.liftListItem("listItem") || editor.commands.liftListItem("taskItem")
-          );
-        }
-        return false;
-      },
-    };
-  },
-});
-
 // ===========================================================================
 // Types
 // ===========================================================================
@@ -262,6 +83,7 @@ export const TiptapEditor = memo(
   forwardRef<RichEditorRef, TiptapEditorProps>(
     (
       {
+        capabilities = "full",
         initialContent = "",
         initialJSON,
         placeholder: placeholderProp,
@@ -318,93 +140,19 @@ export const TiptapEditor = memo(
         onChangeRef.current = onChange;
       });
 
+      // Capability surface is fixed at mount (extension lists cannot swap
+      // live); the canonical list comes from the one factory the capability
+      // specs also verify (LC-52).
+      const [extensions] = useState(() =>
+        buildEditorExtensions({ capabilities, placeholder, mentionExtension }),
+      );
+
       const editor = useEditor({
-        extensions: [
-          StarterKit.configure({
-            heading: {
-              levels: [1, 2, 3, 4, 5, 6],
-              HTMLAttributes: { dir: "auto" },
-            },
-            paragraph: {
-              HTMLAttributes: { dir: "auto" },
-            },
-            link: {
-              openOnClick: false,
-              HTMLAttributes: {
-                rel: "noopener noreferrer",
-                target: "_blank",
-              },
-            },
-            bulletList: {
-              keepMarks: true,
-            },
-            orderedList: {
-              keepMarks: true,
-            },
-            codeBlock: false,
-            hardBreak: false,
-          }),
-          CodeBlockWithPreview.configure({
-            lowlight,
-            exitOnTripleEnter: true,
-            exitOnArrowDown: false,
-          }),
-          ParagraphEnterKeys,
-          CodeBlockTabIndent,
-          ListItemKeys,
-          // superscriptTwo/Three would mangle typed TeX (`$E=mc^2$` became
-          // `E=mc²` before the math input rule ran) — off, rest stays.
-          Typography.configure({
-            superscriptTwo: false,
-            superscriptThree: false,
-          }),
-          CharacterCount,
-          SlashCommands,
-          MarkdownPaste,
-          MediaUpload,
-          SuggestionChromeStore,
-          PreviewChromeStore,
-          EmojiSuggestion,
-          InlineMath,
-          // Collapsible sections (GitLab <details> parity). persist: true
-          // is the extension's supported mode: its node view re-syncs the
-          // open state from node.attrs on every update, so ephemeral
-          // (persist: false) toggles get reverted by the next transaction.
-          // The open state therefore lives in the doc and serializes as
-          // `<details open>` — valid GitLab markdown.
-          Details.configure({ persist: true }),
-          DetailsSummary,
-          DetailsContent,
-          ...(mentionExtension ? [mentionExtension] : []),
-          BlockDragHandle,
-          Table.configure({ resizable: true }),
-          TableRow,
-          TableHeader,
-          TableCell,
-          Placeholder.configure({
-            placeholder,
-          }),
-          TextAlign.configure({
-            types: ["heading", "paragraph"],
-            defaultAlignment: "left",
-          }),
-          TextStyle,
-          Color,
-          Highlight.configure({
-            multicolor: true,
-          }),
-          Subscript,
-          Superscript,
-          TaskList,
-          TaskItem.configure({
-            nested: true,
-          }),
-          Image.configure({
-            inline: true,
-            allowBase64: true,
-          }),
-        ],
-        content: initialJSON || initialContent,
+        extensions,
+        // In markdown capabilities the incoming string IS markdown
+        content:
+          initialJSON ||
+          (capabilities === "markdown" ? markdownToHtml(initialContent) : initialContent),
         editable,
         autofocus: autoFocus,
         // No htmlFor target exists for the contenteditable — name it directly
@@ -426,7 +174,12 @@ export const TiptapEditor = memo(
           changeRafRef.current = requestAnimationFrame(() => {
             const html = editor.getHTML();
             const json = editor.getJSON();
-            onChangeRef.current?.(html, json);
+            // Markdown capabilities serialize the content OUT as markdown —
+            // the host's value stays a markdown string end to end.
+            onChangeRef.current?.(
+              capabilities === "markdown" ? htmlToMarkdown(html) : html,
+              json,
+            );
           });
         },
         onTransaction: ({ editor }) => {
@@ -505,15 +258,23 @@ export const TiptapEditor = memo(
         }
       }, [editorMode, editor, markdownSource]);
 
-      const handleMarkdownChange = useCallback((e: React.ChangeEvent<HTMLTextAreaElement>) => {
-        const md = e.target.value;
-        setMarkdownSource(md);
-        onChangeRef.current?.(markdownToHtml(md), null);
-      }, []);
+      const handleMarkdownChange = useCallback(
+        (e: React.ChangeEvent<HTMLTextAreaElement>) => {
+          const md = e.target.value;
+          setMarkdownSource(md);
+          // Markdown capabilities emit the markdown source itself; the full
+          // surface keeps its HTML onChange contract.
+          onChangeRef.current?.(capabilities === "markdown" ? md : markdownToHtml(md), null);
+        },
+        [capabilities],
+      );
 
       const executeCommand = useCallback(
         (command: EditorCommand, payload?: any) => {
           if (!editor) return;
+          // Capability guard: outside the surface the command's extension is
+          // not registered, so the chained method would not even exist.
+          if (!isCommandInCapabilities(command, capabilities)) return;
 
           const chain = editor.chain().focus();
 
@@ -688,8 +449,13 @@ export const TiptapEditor = memo(
           getState: () => getEditorStateFromTiptap(editor),
           getHTML: () => editor?.getHTML() || "",
           getJSON: () => editor?.getJSON() || null,
+          getMarkdown: () => htmlToMarkdown(editor?.getHTML() || ""),
           setHTML: (html: string) => editor?.commands.setContent(html),
           setJSON: (json: any) => editor?.commands.setContent(json),
+          // External value sync (not a user edit): emitUpdate false so the
+          // host's own set does not echo back through onChange.
+          setMarkdown: (markdown: string) =>
+            editor?.commands.setContent(markdownToHtml(markdown), { emitUpdate: false }),
           focus: () => editor?.commands.focus(),
           blur: () => editor?.commands.blur(),
         }),
@@ -757,17 +523,23 @@ export const TiptapEditor = memo(
           {isWeb && <style>{editorCSS}</style>}
           {showBubbleToolbar && (
             <>
-              <BubbleToolbar editor={editor} editorRef={internalRef} state={defaultEditorState} />
+              <BubbleToolbar
+                editor={editor}
+                editorRef={internalRef}
+                state={defaultEditorState}
+                capabilities={capabilities}
+              />
               <LinkBubble editor={editor} />
               <CodeBlockBubble editor={editor} />
               <ImageBubble editor={editor} />
-              <TableBubble editor={editor} />
+              <TableBubble editor={editor} capabilities={capabilities} />
             </>
           )}
           {/* Always mounted (unlike the optional bubbles): it is the ONLY
               edit path for inline math atoms — without it a typed `$x$`
-              node would be a dead end. */}
-          {editable && <MathBubble editor={editor} />}
+              node would be a dead end. Markdown capabilities have no inline
+              math node, so the bubble has nothing to edit and stays out. */}
+          {editable && capabilities !== "markdown" && <MathBubble editor={editor} />}
           <EditorContent
             editor={editor}
             style={fullscreen ? { flex: "1 1 0%", minHeight: 0, overflowY: "auto" } : undefined}

package/src/editor/capabilities.spec.ts

@@ -0,0 +1,190 @@
+/**
+ * VERIFY arm for LC-52 MARKDOWN-EXPRESSIBLE-EDITING.
+ *
+ * Proves the markdown capability surface is a real constraint, not a
+ * visual one: non-markdown extensions are NOT registered on the editor
+ * (their commands do not exist), and markdown in → edit → markdown out
+ * round-trips for the whole GFM-expressible set.
+ */
+import { describe, expect, it } from "vitest";
+import { Editor } from "@tiptap/core";
+import { MARKDOWN_COMMANDS, isCommandInCapabilities } from "./capabilities";
+import { buildEditorExtensions } from "./extensions";
+import { htmlToMarkdown, markdownToHtml } from "./markdown";
+import type { EditorCommand } from "../types";
+
+function createEditor(capabilities: "full" | "markdown", content = "<p>hello</p>") {
+  return new Editor({
+    element: document.createElement("div"),
+    extensions: buildEditorExtensions({ capabilities }),
+    content,
+  });
+}
+
+const NON_MARKDOWN_COMMANDS: EditorCommand[] = [
+  "underline",
+  "highlight",
+  "textColor",
+  "subscript",
+  "superscript",
+  "alignLeft",
+  "alignCenter",
+  "alignRight",
+  "alignJustify",
+  "mergeCells",
+  "splitCell",
+];
+
+describe("isCommandInCapabilities", () => {
+  it("allows everything in full capabilities", () => {
+    for (const command of [...MARKDOWN_COMMANDS, ...NON_MARKDOWN_COMMANDS]) {
+      expect(isCommandInCapabilities(command, "full")).toBe(true);
+    }
+  });
+
+  it("rejects non-markdown commands in markdown capabilities", () => {
+    for (const command of NON_MARKDOWN_COMMANDS) {
+      expect(isCommandInCapabilities(command, "markdown")).toBe(false);
+    }
+  });
+
+  it("keeps the GFM-expressible commands in markdown capabilities", () => {
+    for (const command of MARKDOWN_COMMANDS) {
+      expect(isCommandInCapabilities(command, "markdown")).toBe(true);
+    }
+  });
+});
+
+describe("markdown capabilities: extension registration", () => {
+  it("does not register underline/highlight/color/align/sub/sup extensions", () => {
+    const editor = createEditor("markdown");
+    const names = new Set(editor.extensionManager.extensions.map((e) => e.name));
+    expect(names.has("underline")).toBe(false);
+    expect(names.has("highlight")).toBe(false);
+    expect(names.has("textStyle")).toBe(false);
+    expect(names.has("color")).toBe(false);
+    expect(names.has("textAlign")).toBe(false);
+    expect(names.has("subscript")).toBe(false);
+    expect(names.has("superscript")).toBe(false);
+    expect(names.has("inlineMath")).toBe(false);
+    expect(names.has("details")).toBe(false);
+    editor.destroy();
+  });
+
+  it("commands markdown cannot express do not exist on the editor", () => {
+    const editor = createEditor("markdown");
+    const commands = editor.commands as unknown as Record<string, unknown>;
+    expect(commands.toggleUnderline).toBeUndefined();
+    expect(commands.toggleHighlight).toBeUndefined();
+    expect(commands.setColor).toBeUndefined();
+    expect(commands.setTextAlign).toBeUndefined();
+    expect(commands.toggleSubscript).toBeUndefined();
+    expect(commands.toggleSuperscript).toBeUndefined();
+    editor.destroy();
+  });
+
+  it("full capabilities keep the whole surface (control)", () => {
+    const editor = createEditor("full");
+    const names = new Set(editor.extensionManager.extensions.map((e) => e.name));
+    expect(names.has("underline")).toBe(true);
+    expect(names.has("highlight")).toBe(true);
+    expect(names.has("textAlign")).toBe(true);
+    const commands = editor.commands as unknown as Record<string, unknown>;
+    expect(typeof commands.toggleUnderline).toBe("function");
+    expect(typeof commands.toggleHighlight).toBe("function");
+    editor.destroy();
+  });
+
+  it("keeps the markdown-expressible surface registered", () => {
+    const editor = createEditor("markdown");
+    const commands = editor.commands as unknown as Record<string, unknown>;
+    for (const name of [
+      "toggleBold",
+      "toggleItalic",
+      "toggleStrike",
+      "toggleCode",
+      "toggleHeading",
+      "toggleBulletList",
+      "toggleOrderedList",
+      "toggleTaskList",
+      "toggleBlockquote",
+      "toggleCodeBlock",
+      "setLink",
+      "setImage",
+      "setHorizontalRule",
+      "insertTable",
+    ]) {
+      expect(typeof commands[name], name).toBe("function");
+    }
+    editor.destroy();
+  });
+
+  it("parses pasted underline/highlight HTML without those marks", () => {
+    const editor = createEditor(
+      "markdown",
+      "<p><u>under</u> and <mark>marked</mark> and <strong>bold</strong></p>",
+    );
+    const html = editor.getHTML();
+    expect(html).not.toContain("<u>");
+    expect(html).not.toContain("<mark>");
+    expect(html).toContain("<strong>bold</strong>");
+    editor.destroy();
+  });
+});
+
+describe("markdown round-trip (markdown in → edit → markdown out)", () => {
+  const roundTrip = (markdown: string): string => {
+    const editor = createEditor("markdown", markdownToHtml(markdown));
+    const out = htmlToMarkdown(editor.getHTML());
+    editor.destroy();
+    return out;
+  };
+
+  it("preserves headings, emphasis, strike, and inline code", () => {
+    const out = roundTrip(
+      "# Title\n\nSome **bold** and _italic_ and ~~gone~~ and `code` text.\n\n## Sub",
+    );
+    expect(out).toContain("# Title");
+    expect(out).toContain("**bold**");
+    expect(out).toContain("_italic_");
+    expect(out).toContain("~~gone~~");
+    expect(out).toContain("`code`");
+    expect(out).toContain("## Sub");
+  });
+
+  it("preserves bullet, ordered, and task lists", () => {
+    const out = roundTrip("- one\n- two\n\n1. first\n2. second\n\n- [x] done\n- [ ] todo");
+    expect(out).toMatch(/[-*] {1,3}one/);
+    expect(out).toMatch(/1\. {1,2}first/);
+    expect(out).toContain("[x] done");
+    expect(out).toContain("[ ] todo");
+  });
+
+  it("preserves blockquotes, fenced code, hr, links, and images", () => {
+    const out = roundTrip(
+      "> quoted\n\n```js\nconst a = 1;\n```\n\n---\n\n[site](https://example.com) ![alt](https://example.com/i.png)",
+    );
+    expect(out).toContain("> quoted");
+    expect(out).toContain("```");
+    expect(out).toContain("const a = 1;");
+    // any valid markdown thematic break (turndown emits "* * *")
+    expect(out).toMatch(/^(-{3,}|_{3,}|(\* ?){3,})$/m);
+    expect(out).toContain("[site](https://example.com)");
+    expect(out).toContain("![alt](https://example.com/i.png)");
+  });
+
+  it("preserves GFM pipe tables", () => {
+    const out = roundTrip("| Name | Role |\n| --- | --- |\n| Ada | Analyst |");
+    expect(out).toContain("| Name | Role |");
+    expect(out).toContain("| --- | --- |");
+    expect(out).toContain("| Ada | Analyst |");
+  });
+
+  it("edits made through markdown commands serialize to markdown", () => {
+    const editor = createEditor("markdown", markdownToHtml("plain text"));
+    editor.commands.selectAll();
+    editor.commands.toggleBold();
+    expect(htmlToMarkdown(editor.getHTML())).toContain("**plain text**");
+    editor.destroy();
+  });
+});

package/src/editor/capabilities.ts

@@ -0,0 +1,76 @@
+/**
+ * Editor capability presets.
+ *
+ * "markdown" constrains the WYSIWYG editor to exactly what GFM markdown can
+ * express (owner ruling, LC-52 MARKDOWN-EXPRESSIBLE-EDITING): bold, italic,
+ * strikethrough, inline code, links, headings, bullet/ordered/task lists,
+ * blockquote, fenced code blocks, images, horizontal rule, and simple pipe
+ * tables. Everything markdown cannot express — underline, highlight, text
+ * color, alignment, sub/superscript, collapsible details, inline math,
+ * mention chips, table cell merge/split — is ABSENT in this mode: the
+ * extensions are not registered (commands do not exist) and the toolbar
+ * controls do not render.
+ *
+ * This module is the single source of truth both the runtime (extension
+ * factory, toolbars, executeCommand guard) and the VERIFY specs consume.
+ */
+
+import type { EditorCapabilities, EditorCommand } from "../types";
+
+/** Commands expressible in GFM markdown (the "markdown" capability surface) */
+export const MARKDOWN_COMMANDS: ReadonlySet<EditorCommand> = new Set<EditorCommand>([
+  "bold",
+  "italic",
+  "strike",
+  "code",
+  "heading1",
+  "heading2",
+  "heading3",
+  "heading4",
+  "heading5",
+  "heading6",
+  "paragraph",
+  "bulletList",
+  "orderedList",
+  "taskList",
+  "blockquote",
+  "codeBlock",
+  "link",
+  "image",
+  "undo",
+  "redo",
+  "horizontalRule",
+  "clearFormatting",
+  // GFM pipe tables (simple grid — mergeCells/splitCell are NOT expressible)
+  "insertTable",
+  "addColumnBefore",
+  "addColumnAfter",
+  "deleteColumn",
+  "addRowBefore",
+  "addRowAfter",
+  "deleteRow",
+  "deleteTable",
+  "toggleHeaderRow",
+]);
+
+/** True when the command exists in the given capability surface */
+export function isCommandInCapabilities(
+  command: EditorCommand,
+  capabilities: EditorCapabilities = "full",
+): boolean {
+  if (capabilities === "full") return true;
+  return MARKDOWN_COMMANDS.has(command);
+}
+
+/**
+ * Slash-menu items excluded in markdown capabilities. Mermaid stays out of
+ * the INSERT surface to keep it strictly GFM (a hand-typed ``` fence still
+ * produces a plain code block); math and details have no markdown syntax.
+ * Emoji stays — it inserts a plain unicode character (just text).
+ */
+export const MARKDOWN_EXCLUDED_SLASH_IDS: readonly string[] = [
+  "mermaid",
+  "mathBlock",
+  "inlineMath",
+  "details",
+];