@quillmark/svelte 0.0.0

package/dist/core/codec/inputrules.js

@@ -0,0 +1,168 @@
+// Input rules: the markdown-shorthand plugin the codec owns (`**`→strong, `*`→em,
+// `~~`→strike, `` ` ``→code, `# `→heading, `- `/`1. `→lists, `> `→blockquote,
+// `---`→divider).
+// Mark rules are hand-rolled (prosemirror-inputrules ships only node rules); block
+// rules reuse `wrappingInputRule` / `textblockTypeInputRule`. These produce
+// transactions the codec already lowers: they add no new lowering surface.
+import { InputRule, inputRules, textblockTypeInputRule, wrappingInputRule } from 'prosemirror-inputrules';
+import { canJoin, findWrapping } from 'prosemirror-transform';
+import { Selection } from 'prosemirror-state';
+/**
+ * A mark input rule: when `regexp` (ending in the closing delimiter) matches
+ * before the caret, wrap capture group 1 in `markType` and drop the delimiters.
+ * `delimLen` is the delimiter length (opening == closing for every rule here).
+ * `match[0]` anatomy is `prefix? open captured close`: the em rule's
+ * `(?:^|[^*])` guard consumes ONE non-delimiter prefix char into the match, so
+ * positions are derived from the KNOWN delimiter/capture lengths, never from
+ * `indexOf` (which both deletes that prefix char and mis-anchors when it
+ * happens to equal the captured text). `[start, end)` spans `match[0]` minus
+ * the just-typed text (not yet inserted when the rule fires), so the trailing
+ * delete covers only the closing-delimiter chars actually in the doc.
+ */
+function markInputRule(regexp, markType, delimLen) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        const captured = match[1];
+        if (captured == null)
+            return null;
+        const tr = state.tr;
+        const prefixLen = match[0].length - (captured.length + 2 * delimLen);
+        const openStart = start + prefixLen;
+        const contentStart = openStart + delimLen;
+        const contentEnd = contentStart + captured.length;
+        // Delete trailing delimiter, then leading, then mark the surviving content.
+        if (end > contentEnd)
+            tr.delete(contentEnd, end);
+        tr.delete(openStart, contentStart);
+        tr.addMark(openStart, openStart + captured.length, markType.create());
+        tr.removeStoredMark(markType); // don't let the mark bleed into the next char
+        return tr;
+    });
+}
+/**
+ * `wrappingInputRule` (whose body this mirrors), plus one normalization: a
+ * `heading` being wrapped becomes a `paragraph` first.
+ *
+ * `list_item` is `block+`, so `list_item > heading` is *representable* and a bare
+ * wrap mints it (a shape no quill renders): the reference quill derives an item's
+ * numbering and indent from the container path and typesets the item's blocks as
+ * body paragraphs (`usaf_memo`'s `render-body`), where a heading resolves to
+ * nothing. This is the wrap-side route into that shape; the `# ` rule guards the
+ * other, in {@link markdownInputRules}.
+ */
+function listWrappingRule(regexp, listType, paragraph, getAttrs, joinPredicate) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        const attrs = getAttrs ? getAttrs(match) : null;
+        const tr = state.tr.delete(start, end);
+        // Positions survive the retype: same content, same size.
+        if (tr.doc.resolve(start).parent.type !== paragraph) {
+            tr.setBlockType(start, start, paragraph);
+        }
+        const $start = tr.doc.resolve(start);
+        const range = $start.blockRange();
+        const wrapping = range && findWrapping(range, listType, attrs);
+        if (!range || !wrapping)
+            return null;
+        tr.wrap(range, wrapping);
+        // Join a preceding list of the same type: the one boundary this rule
+        // itself opens (`lists.ts` §cleanup: command-local, never a global pass).
+        const before = tr.doc.resolve(start - 1).nodeBefore;
+        if (before &&
+            before.type === listType &&
+            canJoin(tr.doc, start - 1) &&
+            (!joinPredicate || joinPredicate(match, before))) {
+            tr.join(start - 1);
+        }
+        return tr;
+    });
+}
+/** The full markdown-shorthand rule set for a block schema. */
+export function markdownInputRules(schema) {
+    const rules = [];
+    const m = schema.marks;
+    // Inline marks. Non-greedy capture between matching delimiters.
+    if (m.strong)
+        rules.push(markInputRule(/\*\*([^*]+)\*\*$/, m.strong, 2));
+    if (m.em)
+        rules.push(markInputRule(/(?:^|[^*])\*([^*]+)\*$/, m.em, 1));
+    if (m.strike)
+        rules.push(markInputRule(/~~([^~]+)~~$/, m.strike, 2));
+    if (m.code)
+        rules.push(markInputRule(/`([^`]+)`$/, m.code, 1));
+    // Block shorthands (only where the schema has the node; the inline schema
+    // omits them, so this stays a no-op there).
+    if (schema.nodes.heading) {
+        // `textblockTypeInputRule`'s body plus one guard: inside a list item, `# `
+        // declines (null) and stays literal text, rather than minting the unrenderable
+        // `list_item > heading` {@link listWrappingRule} normalizes away on the wrap side.
+        const heading = schema.nodes.heading;
+        const item = schema.nodes.list_item;
+        rules.push(new InputRule(/^(#{1,6})\s$/, (state, match, start, end) => {
+            const $start = state.doc.resolve(start);
+            for (let d = $start.depth; d > 0; d--) {
+                if (item && $start.node(d).type === item)
+                    return null;
+            }
+            if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), heading)) {
+                return null;
+            }
+            return state.tr
+                .delete(start, end)
+                .setBlockType(start, start, heading, { level: match[1].length });
+        }));
+    }
+    if (schema.nodes.code_block) {
+        rules.push(textblockTypeInputRule(/^```$/, schema.nodes.code_block));
+    }
+    if (schema.nodes.horizontal_rule && schema.nodes.paragraph) {
+        // A divider is a whole block, so this rule REPLACES its textblock rather than
+        // retyping one: `horizontal_rule` holds no content to retype into.
+        const rule = schema.nodes.horizontal_rule;
+        const paragraph = schema.nodes.paragraph;
+        const item = schema.nodes.list_item;
+        rules.push(new InputRule(/^---$/, (state, _match, start, end) => {
+            const $start = state.doc.resolve(start);
+            // The block ENTIRELY, not a prefix of one. `[start, end)` is the match minus
+            // the just-typed `-`, so the block holds `--` when this fires; anything else
+            // in it is a paragraph being edited, which a replace would eat.
+            if ($start.parentOffset !== 0 || $start.parent.content.size !== end - start) {
+                return null;
+            }
+            // The `# ` rule's guard, for its reason: `list_item` is `block+`, so a
+            // divider inside an item is representable and renders to nothing.
+            for (let d = $start.depth; d > 0; d--) {
+                if (item && $start.node(d).type === item)
+                    return null;
+            }
+            if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), rule)) {
+                return null;
+            }
+            const from = $start.before();
+            const tr = state.tr.replaceWith(from, $start.after(), rule.create());
+            // A divider at the end of a body leaves nowhere to type; the paragraph after
+            // it is the exit, and it is where the caret lands (`slash.ts` §insertBlock
+            // opens the same block for the same reason).
+            const at = from + 1;
+            if (!tr.doc.nodeAt(at))
+                tr.insert(at, paragraph.create());
+            tr.setSelection(Selection.near(tr.doc.resolve(at), 1));
+            return tr;
+        }));
+    }
+    // `- ` / `1. ` at the start of a block, here or nested inside an item. These are
+    // the one pair of shorthands the slash menu ALSO carries: a list opens an item the
+    // caret then lives in, which is what that menu is the set of (`slash.ts`).
+    if (schema.nodes.bullet_list && schema.nodes.paragraph) {
+        rules.push(listWrappingRule(/^\s*([-+*])\s$/, schema.nodes.bullet_list, schema.nodes.paragraph));
+    }
+    if (schema.nodes.ordered_list && schema.nodes.paragraph) {
+        rules.push(listWrappingRule(/^(\d+)\.\s$/, schema.nodes.ordered_list, schema.nodes.paragraph, (match) => ({ start: +match[1] }), (match, node) => node.childCount + node.attrs.start === +match[1]));
+    }
+    if (schema.nodes.blockquote) {
+        rules.push(wrappingInputRule(/^\s*>\s$/, schema.nodes.blockquote));
+    }
+    return rules;
+}
+/** The input-rules plugin the field mounts by default (opt-out via createField). */
+export function inputRulesPlugin(schema) {
+    return inputRules({ rules: markdownInputRules(schema) });
+}

package/dist/core/codec/islands.d.ts

@@ -0,0 +1,36 @@
+import type { Node as PMNode, NodeSpec } from 'prosemirror-model';
+import type { ContentIsland, TableProps } from '@quillmark/wasm';
+/** The `U+FFFC` object-replacement char that occupies one island slot in `text`. */
+export declare const ISLAND_SLOT = "\uFFFC";
+/** Block island node (a table): one `island`-kind content line. Atom, unselectable content. */
+export declare const islandBlockSpec: NodeSpec;
+/** Inline island node (an image): a `U+FFFC` slot inside a `para` line. */
+export declare const islandInlineSpec: NodeSpec;
+/** A PM island node's attributes: the content entry, spelled the way a node spec
+ *  spells it (`islandType`, because `type` on a PM node is the node type). `loss`
+ *  reads its class off the entry rather than restating the union, which the public
+ *  entry point does not name (DOCUMENT_MODEL §Stability seams). */
+export interface IslandNodeAttrs {
+    id: string;
+    islandType: string;
+    props: unknown;
+    loss: ContentIsland['loss'];
+}
+/** Build a content island entry from a PM island node's attrs (block or inline). */
+export declare function islandEntryFromNode(attrs: IslandNodeAttrs): ContentIsland;
+/** A node's `TableProps`, or `undefined` for any other island: the boundary's own
+ *  guard over the entry the node carries, so the open `type` arm narrows once here
+ *  rather than at each reader. */
+export declare function tablePropsOfNode(node: PMNode): TableProps | undefined;
+/**
+ * The next island id for a field: the positional `isl-{n}` sequence continued past
+ * the highest one the field already holds. A minted id is this tier's to produce
+ * and it is part of the document's canonical bytes (CODEC §Islands), so it is a
+ * counter over the projection in hand — never a UUID, never a clock reading, and
+ * never a re-numbering of the ids already there, which are identities.
+ *
+ * Reads the PM doc rather than the stored content because that is what the caller
+ * (an insert command) holds and what the commit will project: an id minted against
+ * a stale content could collide with one the same transaction places.
+ */
+export declare function mintIslandId(doc: PMNode): string;

package/dist/core/codec/islands.js

@@ -0,0 +1,82 @@
+import { isTableIsland } from '@quillmark/wasm';
+/** The `U+FFFC` object-replacement char that occupies one island slot in `text`. */
+export const ISLAND_SLOT = '';
+// The four island node attributes carry the content entry verbatim: `id` is the
+// stable identity (rebases like an anchor), `islandType` the discriminator, `props`
+// the opaque payload the codec preserves byte-for-byte across a round-trip, and
+// `loss` how faithfully markdown can carry it. `loss` is AUTHORED, not derived:
+// `applyChange` stores the class an island op gives it and re-derives nothing, so
+// an entry that did not carry its own would promote a degraded table to lossless
+// on the first cell edit. The default is the class an unknown one reads as, so a
+// node no decode produced under-claims rather than over-claims; decode always
+// supplies the stored value.
+const islandAttrs = {
+    id: { default: '' },
+    islandType: { default: '' },
+    props: { default: null },
+    loss: { default: 'unrepresentable' }
+};
+/** Block island node (a table): one `island`-kind content line. Atom, unselectable content. */
+export const islandBlockSpec = {
+    group: 'block',
+    atom: true,
+    selectable: true,
+    attrs: islandAttrs,
+    toDOM: (node) => [
+        'div',
+        { 'data-island': node.attrs.islandType, 'data-island-id': node.attrs.id },
+        `[${node.attrs.islandType || 'island'}]`
+    ]
+};
+/** Inline island node (an image): a `U+FFFC` slot inside a `para` line. */
+export const islandInlineSpec = {
+    group: 'inline',
+    inline: true,
+    atom: true,
+    selectable: true,
+    attrs: islandAttrs,
+    toDOM: (node) => [
+        'span',
+        { 'data-island': node.attrs.islandType, 'data-island-id': node.attrs.id },
+        `[${node.attrs.islandType || 'island'}]`
+    ]
+};
+/** Build a content island entry from a PM island node's attrs (block or inline). */
+export function islandEntryFromNode(attrs) {
+    return {
+        id: attrs.id,
+        type: attrs.islandType,
+        props: attrs.props,
+        loss: attrs.loss
+    };
+}
+/** A node's `TableProps`, or `undefined` for any other island: the boundary's own
+ *  guard over the entry the node carries, so the open `type` arm narrows once here
+ *  rather than at each reader. */
+export function tablePropsOfNode(node) {
+    const entry = islandEntryFromNode(node.attrs);
+    return isTableIsland(entry) ? entry.props : undefined;
+}
+/**
+ * The next island id for a field: the positional `isl-{n}` sequence continued past
+ * the highest one the field already holds. A minted id is this tier's to produce
+ * and it is part of the document's canonical bytes (CODEC §Islands), so it is a
+ * counter over the projection in hand — never a UUID, never a clock reading, and
+ * never a re-numbering of the ids already there, which are identities.
+ *
+ * Reads the PM doc rather than the stored content because that is what the caller
+ * (an insert command) holds and what the commit will project: an id minted against
+ * a stale content could collide with one the same transaction places.
+ */
+export function mintIslandId(doc) {
+    let next = 0;
+    doc.descendants((node) => {
+        if (node.type.name !== 'island_block' && node.type.name !== 'island_inline')
+            return true;
+        const m = /^isl-(\d+)$/.exec(node.attrs.id);
+        if (m)
+            next = Math.max(next, Number(m[1]) + 1);
+        return false;
+    });
+    return `isl-${next}`;
+}

package/dist/core/codec/keymap.d.ts

@@ -0,0 +1,13 @@
+import type { Schema } from 'prosemirror-model';
+import type { Command } from 'prosemirror-state';
+import { type SlashItem } from './slash.js';
+/** The block-schema body's structural keys: `{}` for the inline/plaintext schemas,
+ * whose leaves declare neither lists nor code blocks. The argument list IS the
+ * precedence order VISUAL_EDITOR §Chrome states, so a new link is one more argument
+ * at its place in that order rather than a nesting to read inside out.
+ *
+ * The slash menu is innermost of the three, and it is conditional rather than
+ * schema-gated: the keys exist only where a menu can be DRAWN (`slashItems` present),
+ * because Enter and Escape claimed by a surface nobody can see is a body that
+ * swallows two keys for no visible reason. */
+export declare function bodyKeymap(schema: Schema, slashItems?: () => SlashItem[]): Record<string, Command>;

package/dist/core/codec/keymap.js

@@ -0,0 +1,29 @@
+import { chainCommands } from 'prosemirror-commands';
+import { codeKeymap } from './code.js';
+import { listKeymap } from './lists.js';
+import { slashKeymap } from './slash.js';
+/** One chain per key, the maps taken in precedence order: on a key several bind, an
+ * earlier map's command runs first and the next runs only if it declines. A key one
+ * map alone binds is its own. No input is mutated. */
+function chainKeymaps(...maps) {
+    const out = {};
+    for (const map of maps) {
+        for (const [key, cmd] of Object.entries(map)) {
+            out[key] = out[key] ? chainCommands(out[key], cmd) : cmd;
+        }
+    }
+    return out;
+}
+/** The block-schema body's structural keys: `{}` for the inline/plaintext schemas,
+ * whose leaves declare neither lists nor code blocks. The argument list IS the
+ * precedence order VISUAL_EDITOR §Chrome states, so a new link is one more argument
+ * at its place in that order rather than a nesting to read inside out.
+ *
+ * The slash menu is innermost of the three, and it is conditional rather than
+ * schema-gated: the keys exist only where a menu can be DRAWN (`slashItems` present),
+ * because Enter and Escape claimed by a surface nobody can see is a body that
+ * swallows two keys for no visible reason. */
+export function bodyKeymap(schema, slashItems) {
+    const links = slashItems ? [slashKeymap(slashItems)] : [];
+    return chainKeymaps(...links, codeKeymap(schema), listKeymap(schema));
+}

package/dist/core/codec/lists.d.ts

@@ -0,0 +1,22 @@
+import type { Schema } from 'prosemirror-model';
+import type { Command } from 'prosemirror-state';
+/**
+ * The list bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * schemas, which declare no list nodes.
+ *
+ * `Tab` / `Shift-Tab` hold the list link of the body's Tab chain. Surfaces that own
+ * Tab more locally under the same rule (`prose/canon/VISUAL_EDITOR.md` §Chrome)
+ * prepend a link ahead of these in `keymap.ts`: a `code_block` takes literal
+ * indentation (`code.ts`), an island takes cell traversal once added. Outside all
+ * of them every link returns false and the key is NOT swallowed: Tab keeps its
+ * default meaning, which is the body's only keyboard exit and the open seam for a
+ * shell structural keymap (VISUAL_EDITOR §Settled and open).
+ *
+ * `Enter` is a chain in precedence order: the paragraph-above gesture, then
+ * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
+ * its own: it splits a non-empty item, and on an empty item it either splits the
+ * WRAPPING item (a nested empty item, so Enter lifts exactly one level) or bails
+ * so the third link lifts a top-level empty item out to a paragraph. `Backspace`
+ * forks on the item's index: the first item lifts, any later one merges.
+ */
+export declare function listKeymap(schema: Schema): Record<string, Command>;

package/dist/core/codec/lists.js

@@ -0,0 +1,104 @@
+import { liftListItem, sinkListItem, splitListItem } from 'prosemirror-schema-list';
+import { chainCommands, joinTextblockBackward } from 'prosemirror-commands';
+/** The caret's enclosing `list_item` when it sits at the very start of that item's
+ * FIRST block: the position both structural keys branch on. `null` otherwise
+ * (mid-text, a non-first block of a multi-paragraph item, a non-empty selection),
+ * which is where the key keeps its ordinary meaning. */
+function atItemStart(state, itemType) {
+    const { $from, empty } = state.selection;
+    if (!empty || $from.parentOffset !== 0)
+        return null;
+    if ($from.depth < 3)
+        return null; // doc > list > item > block is the shallowest
+    if ($from.node(-1).type !== itemType)
+        return null;
+    if ($from.index(-1) !== 0)
+        return null; // a later block of the item
+    return {
+        itemIndex: $from.index(-2),
+        nested: $from.node(-3).type === itemType,
+        listPos: $from.before(-2)
+    };
+}
+/**
+ * Enter at the very start of a top-level list's first item → an empty paragraph
+ * above the list, caret staying with the text it pushed down.
+ *
+ * Only where the list itself is not inside an item: in a NESTED list this pushes
+ * an empty paragraph into the parent item (`list_item` is `block+`, so the shape
+ * is representable and wrong), where the conventional split (an empty item above)
+ * is what the next link does. An empty first item falls through to that same
+ * link, which exits the list instead.
+ */
+function paragraphAboveList(itemType, paragraph) {
+    return (state, dispatch) => {
+        const at = atItemStart(state, itemType);
+        if (!at || at.nested || at.itemIndex !== 0)
+            return false;
+        if (state.selection.$from.parent.content.size === 0)
+            return false;
+        if (dispatch)
+            dispatch(state.tr.insert(at.listPos, paragraph.create()).scrollIntoView());
+        return true;
+    };
+}
+/**
+ * Backspace at the start of a list's FIRST item → lift it: one level out for a
+ * nested item, out of the list entirely (to a paragraph) at the top.
+ */
+function liftAtListStart(itemType) {
+    return (state, dispatch) => {
+        const at = atItemStart(state, itemType);
+        if (!at || at.itemIndex !== 0)
+            return false;
+        return liftListItem(itemType)(state, dispatch);
+    };
+}
+/**
+ * Backspace at the start of any LATER item → join its text into the previous
+ * item's last block, so the two items become one line.
+ *
+ * Not the base keymap's `joinBackward`, which merges the BLOCK and leaves
+ * `list_item(paragraph, paragraph)`: the item's marker gone while its text stays
+ * on its own line, which the reference quill typesets as an unnumbered
+ * continuation paragraph.
+ */
+function mergeIntoPreviousItem(itemType) {
+    return (state, dispatch, view) => {
+        const at = atItemStart(state, itemType);
+        if (!at || at.itemIndex === 0)
+            return false;
+        return joinTextblockBackward(state, dispatch, view);
+    };
+}
+/**
+ * The list bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * schemas, which declare no list nodes.
+ *
+ * `Tab` / `Shift-Tab` hold the list link of the body's Tab chain. Surfaces that own
+ * Tab more locally under the same rule (`prose/canon/VISUAL_EDITOR.md` §Chrome)
+ * prepend a link ahead of these in `keymap.ts`: a `code_block` takes literal
+ * indentation (`code.ts`), an island takes cell traversal once added. Outside all
+ * of them every link returns false and the key is NOT swallowed: Tab keeps its
+ * default meaning, which is the body's only keyboard exit and the open seam for a
+ * shell structural keymap (VISUAL_EDITOR §Settled and open).
+ *
+ * `Enter` is a chain in precedence order: the paragraph-above gesture, then
+ * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
+ * its own: it splits a non-empty item, and on an empty item it either splits the
+ * WRAPPING item (a nested empty item, so Enter lifts exactly one level) or bails
+ * so the third link lifts a top-level empty item out to a paragraph. `Backspace`
+ * forks on the item's index: the first item lifts, any later one merges.
+ */
+export function listKeymap(schema) {
+    const itemType = schema.nodes.list_item;
+    const paragraph = schema.nodes.paragraph;
+    if (!itemType || !paragraph)
+        return {};
+    return {
+        Tab: sinkListItem(itemType),
+        'Shift-Tab': liftListItem(itemType),
+        Enter: chainCommands(paragraphAboveList(itemType, paragraph), splitListItem(itemType), liftListItem(itemType)),
+        Backspace: chainCommands(liftAtListStart(itemType), mergeIntoPreviousItem(itemType))
+    };
+}

package/dist/core/codec/marks.d.ts

@@ -0,0 +1,37 @@
+import type { Mark, Schema } from 'prosemirror-model';
+import type { ContentMark } from '@quillmark/wasm';
+/** A PM mark from a content formatting/unknown mark, or `null` for an anchor. */
+export declare function pmMarkFromContent(schema: Schema, m: ContentMark): Mark | null;
+/**
+ * A content mark descriptor from a PM mark (range-free): the `{ type, … }` half
+ * of a `ContentMark` / `MarkOp`. `strong`/`emph`/… collapse to their content
+ * name; the `unknown` mark re-emits its stored `type`/`attrs` verbatim.
+ */
+export declare function contentDescriptorFromPM(mark: Mark): Record<string, unknown>;
+/**
+ * The range-free `{ type, … }` half of a content mark: `contentDescriptorFromPM`'s
+ * content-side twin, and what a `MarkOp` carries beside its range. An anchor keys
+ * on its type alone: its `id` is identity, not a formatting family, and the diff
+ * routes anchors by id on a separate channel.
+ */
+export declare function descriptorOf(m: ContentMark): Record<string, unknown>;
+/**
+ * A stable grouping key for the mark diff: marks sharing a key union into one
+ * coverage set. Formatting keys on its type; a link keys on type+url and an
+ * unknown on type+attrs, because `applyChange`'s `remove` matches type AND attrs
+ * (verified), so different urls / attrs are independent mark families.
+ */
+export declare function markKey(descriptor: Record<string, unknown>): string;
+/** A held anchor position: an identity id at a USV content offset (zero-width). */
+export interface AnchorPos {
+    id: string;
+    pos: number;
+}
+/**
+ * The identity anchors of a `Content` as `{ id, pos }` in USV: the seed for the
+ * field's anchor-position plugin and the `oldAnchors` the mark diff rebases.
+ * Anchors are zero-width, so `start` is the position.
+ */
+export declare function anchorsFromContent(rt: {
+    marks: ContentMark[];
+}): AnchorPos[];

package/dist/core/codec/marks.js

@@ -0,0 +1,74 @@
+import { isAnchorMark, isLinkMark } from '@quillmark/wasm';
+/** Content formatting types that map 1:1 to a same-named PM mark. */
+const PLAIN_FORMATTING = new Set(['strong', 'underline', 'strike', 'code']);
+/** A PM mark from a content formatting/unknown mark, or `null` for an anchor. */
+export function pmMarkFromContent(schema, m) {
+    if (isAnchorMark(m))
+        return null;
+    if (m.type === 'emph')
+        return schema.marks.em.create();
+    if (isLinkMark(m))
+        return schema.marks.link.create({ href: m.url });
+    if (PLAIN_FORMATTING.has(m.type))
+        return schema.marks[m.type].create();
+    // Anything else is an unknown mark: inert, renders nothing, round-trips verbatim.
+    return schema.marks.unknown.create({
+        type: m.type,
+        attrs: m.attrs ?? null
+    });
+}
+/**
+ * A content mark descriptor from a PM mark (range-free): the `{ type, … }` half
+ * of a `ContentMark` / `MarkOp`. `strong`/`emph`/… collapse to their content
+ * name; the `unknown` mark re-emits its stored `type`/`attrs` verbatim.
+ */
+export function contentDescriptorFromPM(mark) {
+    const name = mark.type.name;
+    if (name === 'em')
+        return { type: 'emph' };
+    if (name === 'link')
+        return { type: 'link', url: mark.attrs.href };
+    if (name === 'unknown')
+        return { type: mark.attrs.type, attrs: mark.attrs.attrs };
+    // strong / underline / strike / code
+    return { type: name };
+}
+/**
+ * The range-free `{ type, … }` half of a content mark: `contentDescriptorFromPM`'s
+ * content-side twin, and what a `MarkOp` carries beside its range. An anchor keys
+ * on its type alone: its `id` is identity, not a formatting family, and the diff
+ * routes anchors by id on a separate channel.
+ */
+export function descriptorOf(m) {
+    if (isLinkMark(m))
+        return { type: 'link', url: m.url };
+    if ('attrs' in m && !isAnchorMark(m))
+        return { type: m.type, attrs: m.attrs };
+    return { type: m.type };
+}
+/**
+ * A stable grouping key for the mark diff: marks sharing a key union into one
+ * coverage set. Formatting keys on its type; a link keys on type+url and an
+ * unknown on type+attrs, because `applyChange`'s `remove` matches type AND attrs
+ * (verified), so different urls / attrs are independent mark families.
+ */
+export function markKey(descriptor) {
+    const type = descriptor.type;
+    if (type === 'link')
+        return `link\u0000${String(descriptor.url)}`;
+    if (descriptor.attrs !== undefined)
+        return `${type}\u0000${JSON.stringify(descriptor.attrs)}`;
+    return type;
+}
+/**
+ * The identity anchors of a `Content` as `{ id, pos }` in USV: the seed for the
+ * field's anchor-position plugin and the `oldAnchors` the mark diff rebases.
+ * Anchors are zero-width, so `start` is the position.
+ */
+export function anchorsFromContent(rt) {
+    const out = [];
+    for (const m of rt.marks)
+        if (isAnchorMark(m))
+            out.push({ id: m.id, pos: m.start });
+    return out;
+}

package/dist/core/codec/positions.d.ts

@@ -0,0 +1,17 @@
+import type { Node as PMNode } from 'prosemirror-model';
+import { type PosRun } from './encode.js';
+/** A prebuilt line→position index for a PM doc, rebuilt on structural change. */
+export interface LineIndex {
+    runs: PosRun[];
+    usvEnd: number;
+    /** PM position at the end of the last content run (the caret-max). */
+    pmEndContent: number;
+    /** PM content position of the first line (the caret for an empty doc). */
+    firstContentStart: number;
+}
+/** Build the position index for `doc` (walks it once via the shared scanner). */
+export declare function buildLineIndex(doc: PMNode): LineIndex;
+/** USV content offset → PM position. */
+export declare function usvToPM(index: LineIndex, usvPos: number): number;
+/** PM position → USV content offset. */
+export declare function pmToUsv(index: LineIndex, pmPos: number): number;