@ai-matrx/rich-editor 0.0.0 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 0.1.1
+
+The npm-install canary applies the returned changes (it read the result object as text); package contents unchanged.
+
+## 0.1.0
+
+First release — the editor's pure core leaves matrx-frontend `components/rich-editor`:
+`core/*` (markdown parse/serialize over Tiptap's schema, formatting commands, source format,
+save plan, find/replace, paste html/markdown, outline, text metrics, variables, history
+approval, host value, block insert, shortcuts), `in-place/{in-place-session,caret-handoff}`,
+`format/format-target`. Behavior verbatim; the GFM table source/lexer and table lines come from
+`@ai-matrx/rich-content`. The `{{variable}}` name rule (`core/variable-name`) is ported from
+`@ai-matrx/chat`; chat imports it from here at rich-content phase 3.
+
+### Consumer action
+
+- matrx-frontend: import `@ai-matrx/rich-editor/core/<module>` instead of `@/components/rich-editor/core/<module>`.

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 AI Matrx
+Copyright (c) 2026 AI Matrix Engine
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,7 +1,17 @@
 # @ai-matrx/rich-editor
 
-Name reservation and publishing bootstrap only. This version contains no runtime implementation or usable API. Do not adopt it in applications yet.
+The AI Matrx editor over `@ai-matrx/rich-content`: Visual (Tiptap), Source (CodeMirror), Preview,
+the markdown formatting command layer, and edit-in-place. Separate from the engine so consumers
+that only render never install Tiptap or CodeMirror.
 
-The planned editor provides visual, source, and preview modes, formatting controls, and editing in place, built on `@ai-matrx/rich-content`. Its intended source home is `aidream/apps/shared/rich-editor` in [AI-Matrix-Engine/aidream](https://github.com/AI-Matrix-Engine/aidream).
+0.1.0 ships the editor's pure core: markdown ⇄ ProseMirror parse/serialize, the formatting
+commands (`core/markdown-format`), the save plan (splice save), find/replace, paste, outline,
+text metrics, variables, the edit-in-place session and caret handoff. The Visual/Source/Preview
+surfaces follow.
 
-License: MIT.
+```ts
+import { formatMarkdown } from "@ai-matrx/rich-editor/core/markdown-format";
+formatMarkdown("Ship the release today", 9, 16, "bold"); // → changes producing **release**
+```
+
+Peers: `react`, `react-dom` (>= 19). MIT licensed.

package/dist/core/block-insert.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A BLOCK INSERTED "BEFORE" / "AFTER" THE SELECTION LANDS BETWEEN BLOCKS —
+ * never inside a word, and from ANY selection.
+ *
+ * `insertText(text, "after")` used to split the paragraph AT the caret, so a
+ * reference inserted with the caret inside "of" became "o" + block + "f"
+ * (G5 review, 2026-10-02). Then it split at the caret textblock's edge — which
+ * threw `TransformError: Inserted content deeper than insertion position`
+ * whenever the selection was NOT in a textblock: a selected island (the chip a
+ * previous insert left selected), ⌘A, a position between two top-level blocks
+ * (G8B review, 2026-10-02: picking a chat after a right-click with no click in
+ * the text did nothing and left the dialog open).
+ *
+ * Now the block goes to the TOP-LEVEL boundary beside the selection's block
+ * (before its start / after its end) — a position that exists for every
+ * selection — and the caret lands just after what was inserted. Guard:
+ * `__tests__/block-insert.test.ts` sweeps every position × selection kind.
+ */
+import { type Node as PMNode, type Schema } from "@tiptap/pm/model";
+import type { Transaction } from "@tiptap/pm/state";
+/** The top-level boundary a block goes to, relative to [from, to]. */
+export declare function blockInsertPosition(doc: PMNode, from: number, to: number, where: "before" | "after"): number;
+/**
+ * Insert markdown as its own block(s) before / after the selection's block.
+ * Throws nothing it can avoid; returns false when the text parses to nothing.
+ */
+export declare function insertMarkdownBlock(tr: Transaction, schema: Schema, text: string, where: "before" | "after"): boolean;

package/dist/core/block-insert.js

@@ -0,0 +1,24 @@
+import { Fragment, Slice } from "@tiptap/pm/model";
+import { Selection } from "@tiptap/pm/state";
+import { markdownToSlice } from "./paste-markdown.js";
+function blockInsertPosition(doc, from, to, where) {
+  const clamp = (pos) => Math.max(0, Math.min(pos, doc.content.size));
+  const $pos = doc.resolve(clamp(where === "before" ? from : to));
+  if ($pos.depth === 0) return $pos.pos;
+  return where === "before" ? $pos.before(1) : $pos.after(1);
+}
+function insertMarkdownBlock(tr, schema, text, where) {
+  const { from, to } = tr.selection;
+  const at = blockInsertPosition(tr.doc, from, to, where);
+  const parsed = markdownToSlice(text, schema);
+  if (parsed.size === 0) return false;
+  const blocks = new Slice(Fragment.from(parsed.content), 0, 0);
+  tr.replace(at, at, blocks);
+  const end = tr.mapping.map(at, 1);
+  tr.setSelection(Selection.near(tr.doc.resolve(Math.min(end, tr.doc.content.size)), 1));
+  return true;
+}
+export {
+  blockInsertPosition,
+  insertMarkdownBlock
+};

package/dist/core/caret-context.d.ts

@@ -0,0 +1,24 @@
+/** The text around a click in the rendered view. */
+export interface CaretContext {
+    /** Up to `CONTEXT_CHARS` rendered characters before the click. */
+    before: string;
+    /** Up to `CONTEXT_CHARS` rendered characters after the click. */
+    after: string;
+}
+export declare const CONTEXT_CHARS = 40;
+/**
+ * Where the caret goes in `text` (an index 0..text.length), or null when the
+ * context cannot be found. Tries the longest context first (before + after),
+ * then shorter ones, then each side alone; the first occurrence wins.
+ */
+export declare function locateCaret(text: string, context: CaretContext): number | null;
+/**
+ * The context of a point in a rendered element: the text before and after the
+ * DOM position (`node`, `offset`) within `root`.
+ */
+export declare function caretContextAt(root: Node, node: Node, offset: number): CaretContext | null;
+/** The DOM position under a viewport point (both browser APIs). */
+export declare function domPointAt(doc: Document, x: number, y: number): {
+    node: Node;
+    offset: number;
+} | null;

package/dist/core/caret-context.js

@@ -0,0 +1,73 @@
+const CONTEXT_CHARS = 40;
+function collapse(text) {
+  let flat = "";
+  const at = [];
+  let lastSpace = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (/\s/.test(ch)) {
+      if (lastSpace) continue;
+      lastSpace = true;
+      flat += " ";
+    } else {
+      lastSpace = false;
+      flat += ch;
+    }
+    at.push(i);
+  }
+  return { flat, at };
+}
+function locateCaret(text, context) {
+  const { flat, at } = collapse(text);
+  const before = collapse(context.before).flat;
+  const after = collapse(context.after).flat;
+  const toOriginal = (flatIndex) => flatIndex >= at.length ? text.length : at[flatIndex];
+  for (const len of [CONTEXT_CHARS, 24, 12, 6, 3]) {
+    const b = before.slice(-len);
+    const a = after.slice(0, len);
+    if (!b && !a) continue;
+    const idx = flat.indexOf(b + a);
+    if (idx >= 0 && (b + a).length >= Math.min(3, before.length + after.length)) return toOriginal(idx + b.length);
+  }
+  for (const len of [CONTEXT_CHARS, 12, 4]) {
+    const a = after.slice(0, len);
+    if (a.trim().length >= 3) {
+      const idx = flat.indexOf(a);
+      if (idx >= 0) return toOriginal(idx);
+    }
+    const b = before.slice(-len);
+    if (b.trim().length >= 3) {
+      const idx = flat.indexOf(b);
+      if (idx >= 0) return toOriginal(idx + b.length);
+    }
+  }
+  return null;
+}
+function caretContextAt(root, node, offset) {
+  if (!root.contains(node)) return null;
+  const doc = root.ownerDocument;
+  if (!doc) return null;
+  const head = doc.createRange();
+  head.selectNodeContents(root);
+  head.setEnd(node, offset);
+  const tail = doc.createRange();
+  tail.selectNodeContents(root);
+  tail.setStart(node, offset);
+  const before = head.toString();
+  const after = tail.toString();
+  return { before: before.slice(-CONTEXT_CHARS), after: after.slice(0, CONTEXT_CHARS) };
+}
+function domPointAt(doc, x, y) {
+  const withPosition = doc;
+  const position = withPosition.caretPositionFromPoint?.(x, y);
+  if (position) return { node: position.offsetNode, offset: position.offset };
+  const range = withPosition.caretRangeFromPoint?.(x, y);
+  if (range) return { node: range.startContainer, offset: range.startOffset };
+  return null;
+}
+export {
+  CONTEXT_CHARS,
+  caretContextAt,
+  domPointAt,
+  locateCaret
+};

package/dist/core/clipboard-text.d.ts

@@ -0,0 +1,5 @@
+import { Extension, getTextSerializersFromSchema } from "@tiptap/core";
+import type { Node as PMNode } from "@tiptap/pm/model";
+export declare function clipboardTextBetween(doc: PMNode, from: number, to: number, serializers: ReturnType<typeof getTextSerializersFromSchema>): string;
+/** Outranks Tiptap's core clipboardTextSerializer (the first plugin with the prop wins). */
+export declare const ClipboardPlainText: Extension<any, any>;

package/dist/core/clipboard-text.js

@@ -0,0 +1,47 @@
+import { Extension, getTextSerializersFromSchema } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+const BLOCK_SEPARATOR = "\n\n";
+function clipboardTextBetween(doc, from, to, serializers) {
+  let text = "";
+  let pending = false;
+  const append = (piece) => {
+    if (!piece) return;
+    if (pending && text) text += BLOCK_SEPARATOR;
+    pending = false;
+    text += piece;
+  };
+  doc.nodesBetween(from, to, (node, pos, parent, index) => {
+    if (node.isBlock) pending = true;
+    const serialize = serializers[node.type.name];
+    if (serialize) {
+      if (parent) append(serialize({ node, pos, parent, index, range: { from, to } }));
+      return false;
+    }
+    if (node.isText) append((node.text ?? "").slice(Math.max(from, pos) - pos, to - pos));
+    return true;
+  });
+  return text;
+}
+const ClipboardPlainText = Extension.create({
+  name: "clipboardPlainText",
+  priority: 1e3,
+  addProseMirrorPlugins() {
+    const { editor } = this;
+    return [
+      new Plugin({
+        key: new PluginKey("clipboardPlainText"),
+        props: {
+          clipboardTextSerializer: () => {
+            const { doc, selection, schema } = editor.state;
+            const serializers = getTextSerializersFromSchema(schema);
+            return [...selection.ranges].sort((a, b) => a.$from.pos - b.$from.pos).map(({ $from, $to }) => clipboardTextBetween(doc, $from.pos, $to.pos, serializers)).join(BLOCK_SEPARATOR);
+          }
+        }
+      })
+    ];
+  }
+});
+export {
+  ClipboardPlainText,
+  clipboardTextBetween
+};

package/dist/core/commands.d.ts

@@ -0,0 +1,65 @@
+import type { Editor } from "@tiptap/core";
+import { type Node as PMNode } from "@tiptap/pm/model";
+export type CalloutType = "NOTE" | "TIP" | "IMPORTANT" | "WARNING" | "CAUTION";
+export declare const CALLOUT_TYPES: readonly CalloutType[];
+export declare const TASK_OPEN = "[ ] ";
+export declare const TASK_DONE = "[x] ";
+/** A fenced code block with a fence longer than any backtick run in the code. */
+export declare function fenceMarkdown(language: string, code?: string): string;
+export declare function mathBlockMarkdown(tex?: string): string;
+/** Kind JSON exactly as agents emit it: `__kind` first, pretty-printed. */
+export declare function kindMarkdown(kind: string, data?: Record<string, unknown>): string;
+/** Top-level index and position of the block that holds the selection. */
+declare function topLevelAt(editor: Editor): {
+    index: number;
+    pos: number;
+    node: PMNode;
+} | null;
+/**
+ * Insert a block island at the cursor: an empty paragraph is replaced, a
+ * non-empty one gets the island after it. Returns the island's position.
+ */
+export declare function insertIsland(editor: Editor, raw: string, islandType: string): number;
+export declare function insertCodeBlock(editor: Editor, language?: string): number;
+export declare function insertMathBlock(editor: Editor, tex?: string): number;
+export declare function insertPageBreak(editor: Editor): number;
+export declare function insertKind(editor: Editor, kind: string, data?: Record<string, unknown>): number;
+/** An inline island (variable, inline math) at the cursor. */
+export declare function insertInlineIsland(editor: Editor, raw: string, islandType: string): boolean;
+export declare function insertVariable(editor: Editor, name: string): boolean;
+export declare function insertInlineMath(editor: Editor, tex: string): boolean;
+/** Replace an island's bytes — the one explicit island edit. */
+export declare function replaceIslandRaw(editor: Editor, pos: number, raw: string): boolean;
+export declare function removeNodeAt(editor: Editor, pos: number): boolean;
+export declare function setCallout(editor: Editor, type: CalloutType | null): boolean;
+/** Turn the current list (or paragraph) into a checklist, or back. */
+export declare function toggleTaskList(editor: Editor): boolean;
+export declare function toggleTaskChecked(editor: Editor, itemPos: number): boolean;
+/** Footnote numbers already used in the document text. */
+export declare function nextFootnoteNumber(text: string): number;
+/**
+ * Insert a footnote reference at the cursor and its definition at the end of
+ * the document; the cursor lands in the definition.
+ */
+export declare function insertFootnote(editor: Editor): number;
+/**
+ * Move the block holding the cursor one step up or down among its siblings
+ * (a paragraph inside a stored block moves inside it; a whole stored block or
+ * island moves among the document's blocks).
+ */
+export declare function moveBlock(editor: Editor, direction: "up" | "down"): boolean;
+/** ```lang typed on its own line + Enter → a code block island. */
+export declare function fenceFromParagraph(editor: Editor): boolean;
+/** The top-level node (and its position) at a document position. */
+export declare function topLevelNodeAt(doc: PMNode, pos: number): {
+    node: PMNode;
+    pos: number;
+} | null;
+export { topLevelAt };
+export type ColumnAlignment = "left" | "center" | "right" | null;
+/**
+ * Align the column the cursor is in: every cell of that column gets the
+ * alignment, so the GFM delimiter row (the only place markdown stores it) is
+ * rewritten and nothing else in the table moves.
+ */
+export declare function setColumnAlign(editor: Editor, align: ColumnAlignment): boolean;

package/dist/core/commands.js

@@ -0,0 +1,299 @@
+import { Fragment } from "@tiptap/pm/model";
+import { NodeSelection, TextSelection } from "@tiptap/pm/state";
+import { PAGE_BREAK_MARKDOWN } from "@ai-matrx/print/directives";
+import { fenceOpenerOf } from "@ai-matrx/content-ir/source";
+const CALLOUT_TYPES = ["NOTE", "TIP", "IMPORTANT", "WARNING", "CAUTION"];
+const TASK_OPEN = "[ ] ";
+const TASK_DONE = "[x] ";
+function fenceMarkdown(language, code = "") {
+  let longest = 0;
+  for (const run of code.match(/`+/g) ?? []) longest = Math.max(longest, run.length);
+  const fence = "`".repeat(Math.max(3, longest + 1));
+  return `${fence}${language}
+${code}
+${fence}`;
+}
+function mathBlockMarkdown(tex = "") {
+  return `$$
+${tex}
+$$`;
+}
+function kindMarkdown(kind, data = {}) {
+  const { __kind: _ignored, ...rest } = data;
+  return JSON.stringify({ __kind: kind, ...rest }, null, 2);
+}
+function topLevelAt(editor) {
+  const { doc, selection } = editor.state;
+  const $from = selection.$from;
+  const index = $from.depth === 0 ? $from.index(0) : $from.index(0);
+  if (index >= doc.childCount) return null;
+  let pos = 0;
+  for (let i = 0; i < index; i += 1) pos += doc.child(i).nodeSize;
+  return { index, pos, node: doc.child(index) };
+}
+function insertIsland(editor, raw, islandType) {
+  const { state } = editor;
+  const type = state.schema.nodes.islandBlock;
+  if (!type) return -1;
+  const island = type.create({ raw, islandType, complete: true });
+  const { $from } = state.selection;
+  let at = -1;
+  editor.commands.command(({ tr }) => {
+    const parent = $from.parent;
+    if (state.selection instanceof NodeSelection) {
+      at = state.selection.to;
+      tr.insert(at, island);
+    } else if (parent.isTextblock && parent.content.size === 0 && $from.depth > 0) {
+      at = $from.before($from.depth);
+      tr.replaceWith(at, $from.after($from.depth), island);
+    } else {
+      at = $from.depth > 0 ? $from.after(Math.min($from.depth, 2) || 1) : $from.pos;
+      tr.insert(at, island);
+    }
+    tr.setSelection(NodeSelection.create(tr.doc, at));
+    return true;
+  });
+  return at;
+}
+function insertCodeBlock(editor, language = "") {
+  return insertIsland(editor, fenceMarkdown(language), "fence");
+}
+function insertMathBlock(editor, tex = "") {
+  return insertIsland(editor, mathBlockMarkdown(tex), "math_block");
+}
+function insertPageBreak(editor) {
+  return insertIsland(editor, PAGE_BREAK_MARKDOWN, "html_comment");
+}
+function insertKind(editor, kind, data = {}) {
+  return insertIsland(editor, kindMarkdown(kind, data), "json");
+}
+function insertInlineIsland(editor, raw, islandType) {
+  const type = editor.state.schema.nodes.inlineIsland;
+  if (!type) return false;
+  return editor.chain().focus().command(({ tr }) => {
+    tr.replaceSelectionWith(type.create({ raw, islandType }), false);
+    return true;
+  }).run();
+}
+function insertVariable(editor, name) {
+  return insertInlineIsland(editor, `{{${name}}}`, "variable");
+}
+function insertInlineMath(editor, tex) {
+  return insertInlineIsland(editor, `$${tex}$`, "math_inline");
+}
+function replaceIslandRaw(editor, pos, raw) {
+  const node = editor.state.doc.nodeAt(pos);
+  if (!node || node.type.name !== "islandBlock" && node.type.name !== "inlineIsland" && node.type.name !== "sourceLocked") {
+    return false;
+  }
+  if (node.attrs.raw === raw) return true;
+  return editor.commands.command(({ tr }) => {
+    tr.setNodeMarkup(pos, void 0, { ...node.attrs, raw });
+    return true;
+  });
+}
+function removeNodeAt(editor, pos) {
+  const node = editor.state.doc.nodeAt(pos);
+  if (!node) return false;
+  return editor.commands.command(({ tr }) => {
+    tr.delete(pos, pos + node.nodeSize);
+    return true;
+  });
+}
+function setCallout(editor, type) {
+  const { $from } = editor.state.selection;
+  for (let depth = $from.depth; depth > 0; depth -= 1) {
+    const node = $from.node(depth);
+    if (node.type.name === "blockquote") {
+      const pos = $from.before(depth);
+      return editor.commands.command(({ tr }) => {
+        tr.setNodeMarkup(pos, void 0, { ...node.attrs, mdAlert: type ? `[!${type}]` : null });
+        return true;
+      });
+    }
+  }
+  if (!type) return false;
+  return editor.chain().focus().toggleBlockquote().command(({ tr }) => {
+    const $pos = tr.selection.$from;
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+      const node = $pos.node(depth);
+      if (node.type.name === "blockquote") {
+        tr.setNodeMarkup($pos.before(depth), void 0, { ...node.attrs, mdAlert: `[!${type}]` });
+        return true;
+      }
+    }
+    return false;
+  }).run();
+}
+function toggleTaskList(editor) {
+  const { $from } = editor.state.selection;
+  let itemDepth = -1;
+  for (let depth = $from.depth; depth > 0; depth -= 1) {
+    if ($from.node(depth).type.name === "listItem") {
+      itemDepth = depth;
+      break;
+    }
+  }
+  if (itemDepth === -1) {
+    if (!editor.chain().focus().toggleBulletList().run()) return false;
+    return toggleTaskList(editor);
+  }
+  const list = $from.node(itemDepth - 1);
+  const listPos = $from.before(itemDepth - 1);
+  const makeTask = list.firstChild?.attrs.mdTask === null || list.firstChild?.attrs.mdTask === void 0;
+  return editor.commands.command(({ tr }) => {
+    list.forEach((item, offset) => {
+      tr.setNodeMarkup(listPos + 1 + offset, void 0, {
+        ...item.attrs,
+        mdTask: makeTask ? item.attrs.mdTask ?? TASK_OPEN : null
+      });
+    });
+    return true;
+  });
+}
+function toggleTaskChecked(editor, itemPos) {
+  const item = editor.state.doc.nodeAt(itemPos);
+  if (!item || item.type.name !== "listItem" || item.attrs.mdTask === null) return false;
+  const checked = /\[[xX]\]/.test(String(item.attrs.mdTask));
+  return editor.commands.command(({ tr }) => {
+    tr.setNodeMarkup(itemPos, void 0, { ...item.attrs, mdTask: checked ? TASK_OPEN : TASK_DONE });
+    return true;
+  });
+}
+function nextFootnoteNumber(text) {
+  let max = 0;
+  for (const match of text.matchAll(/\[\^(\d+)\]/g)) max = Math.max(max, Number(match[1]));
+  return max + 1;
+}
+function insertFootnote(editor) {
+  const n = nextFootnoteNumber(editor.state.doc.textContent);
+  const paragraph = editor.state.schema.nodes.paragraph;
+  if (!paragraph) return -1;
+  editor.commands.command(({ tr }) => {
+    tr.insertText(`[^${n}]`);
+    const end = tr.doc.content.size;
+    tr.insert(end, paragraph.create(null, editor.state.schema.text(`[^${n}]: `)));
+    tr.setSelection(TextSelection.create(tr.doc, tr.doc.content.size - 1));
+    return true;
+  });
+  return n;
+}
+function moveBlock(editor, direction) {
+  const { state } = editor;
+  const selection = state.selection;
+  let depth;
+  const $from = selection.$from;
+  if (selection instanceof NodeSelection && $from.depth === 0) depth = 0;
+  else depth = $from.depth >= 2 && $from.node(1).type.name === "sourceBlock" && $from.node(1).childCount > 1 ? 1 : 0;
+  const parent = $from.node(depth);
+  const index = $from.index(depth);
+  const target = direction === "up" ? index - 1 : index + 1;
+  if (target < 0 || target >= parent.childCount) return false;
+  const start = depth === 0 ? 0 : $from.start(depth);
+  const offsetOf = (i) => {
+    let pos = start;
+    for (let k = 0; k < i; k += 1) pos += parent.child(k).nodeSize;
+    return pos;
+  };
+  const first = direction === "up" ? target : index;
+  const firstNode = parent.child(first);
+  const secondNode = parent.child(first + 1);
+  const from = offsetOf(first);
+  const movingFrom = offsetOf(index);
+  const selectionOffset = selection.from - movingFrom;
+  return editor.commands.command(({ tr }) => {
+    tr.replaceWith(from, from + firstNode.nodeSize + secondNode.nodeSize, Fragment.from([secondNode, firstNode]));
+    const movedTo = direction === "up" ? from : from + secondNode.nodeSize;
+    tr.setSelection(
+      selection instanceof NodeSelection ? NodeSelection.create(tr.doc, movedTo) : TextSelection.near(tr.doc.resolve(Math.min(movedTo + selectionOffset, tr.doc.content.size)))
+    );
+    return true;
+  });
+}
+function fenceFromParagraph(editor) {
+  const { $from, empty } = editor.state.selection;
+  if (!empty || !$from.parent.isTextblock || $from.parent.type.name !== "paragraph") return false;
+  const text = $from.parent.textContent;
+  const opener = fenceOpenerOf(text);
+  const fence = opener ? opener.char.repeat(opener.ticks) : "";
+  if (!opener || text !== `${fence}${opener.lang}` || !/^[\w+#.-]*$/.test(opener.lang)) return false;
+  const match = [text, fence, opener.lang];
+  const pos = $from.before($from.depth);
+  const island = editor.state.schema.nodes.islandBlock?.create({
+    raw: `${match[1]}${match[2]}
+
+${match[1]}`,
+    islandType: "fence",
+    complete: true
+  });
+  if (!island) return false;
+  return editor.commands.command(({ tr }) => {
+    tr.replaceWith(pos, pos + $from.parent.nodeSize, island);
+    tr.setSelection(NodeSelection.create(tr.doc, pos));
+    return true;
+  });
+}
+function topLevelNodeAt(doc, pos) {
+  let offset = 0;
+  for (let i = 0; i < doc.childCount; i += 1) {
+    const node = doc.child(i);
+    if (pos >= offset && pos < offset + node.nodeSize) return { node, pos: offset };
+    offset += node.nodeSize;
+  }
+  return null;
+}
+function setColumnAlign(editor, align) {
+  const { $from } = editor.state.selection;
+  let cellDepth = -1;
+  for (let depth = $from.depth; depth > 0; depth -= 1) {
+    const name = $from.node(depth).type.name;
+    if (name === "tableCell" || name === "tableHeader") {
+      cellDepth = depth;
+      break;
+    }
+  }
+  if (cellDepth < 2) return false;
+  const column = $from.index(cellDepth - 1);
+  const table = $from.node(cellDepth - 2);
+  const tablePos = $from.before(cellDepth - 2);
+  return editor.commands.command(({ tr }) => {
+    let rowPos = tablePos + 1;
+    table.forEach((row) => {
+      let cellPos = rowPos + 1;
+      row.forEach((cell, _offset, index) => {
+        if (index === column) tr.setNodeMarkup(cellPos, void 0, { ...cell.attrs, align });
+        cellPos += cell.nodeSize;
+      });
+      rowPos += row.nodeSize;
+    });
+    return true;
+  });
+}
+export {
+  CALLOUT_TYPES,
+  TASK_DONE,
+  TASK_OPEN,
+  fenceFromParagraph,
+  fenceMarkdown,
+  insertCodeBlock,
+  insertFootnote,
+  insertInlineIsland,
+  insertInlineMath,
+  insertIsland,
+  insertKind,
+  insertMathBlock,
+  insertPageBreak,
+  insertVariable,
+  kindMarkdown,
+  mathBlockMarkdown,
+  moveBlock,
+  nextFootnoteNumber,
+  removeNodeAt,
+  replaceIslandRaw,
+  setCallout,
+  setColumnAlign,
+  toggleTaskChecked,
+  toggleTaskList,
+  topLevelAt,
+  topLevelNodeAt
+};

package/dist/core/extensions.d.ts

@@ -0,0 +1,29 @@
+import { Extension, Mark, Node, type Extensions } from "@tiptap/core";
+/** Node types that carry an `mdId` (their source identity in the baseline). */
+export declare const MD_ID_NODE_TYPES: readonly ["paragraph", "heading", "bulletList", "orderedList", "listItem", "blockquote", "horizontalRule", "sourceLocked"];
+export declare const SourceBlockNode: Node<any, any>;
+export declare const IslandBlockNode: Node<any, any>;
+export declare const SourceLockedNode: Node<any, any>;
+export declare const InlineIslandNode: Node<any, any>;
+/** Records how the source spelled each construct (see header). */
+export declare const MarkdownFidelityAttributes: Extension<any, any>;
+/**
+ * An author's backslash escape (`\*`, `\_`, `\#`…): the reader sees the
+ * literal character, the stored bytes keep the backslash. The text node holds
+ * the bare character under this mark and the serializer writes `\` before each
+ * ASCII punctuation character in it. Not inclusive, so text typed beside it is
+ * plain (the editor never ADDS an escape); combinable with every other mark.
+ */
+export declare const EscapedText: Mark<any, any>;
+export interface RichEditorExtensionOptions {
+    /** Placeholder shown in an empty document. */
+    placeholder?: string;
+    /** Told when a paste changed shape on the way in (merged table cells split). */
+    onPasteNotice?: (message: string) => void;
+}
+/**
+ * The extension list both the browser editor and the headless corpus use.
+ * The React layer swaps in node views for the three atoms; the schema is
+ * identical either way.
+ */
+export declare function createRichEditorExtensions(options?: RichEditorExtensionOptions): Extensions;