@quillmark/svelte 0.0.0

package/dist/core/codec/field.js

@@ -0,0 +1,493 @@
+// The prose leaf: `createField` (VISUAL_EDITOR §Surface). One content field, one
+// PM `EditorState`/`EditorView`, wired to the WASM edit surface. It reads the
+// leaf's `Content`, decodes to a PM state, mounts a view + plugin stack (history,
+// keymap, input rules, the anchor-position plugin), and `dispatchTransaction`:
+//   (a) apply optimistically to the view,
+//   (b) lower the tr to a `ChangeBundle` (or `overwrite` for a field not yet at
+//       content rest, which has nothing to splice),
+//   (c) commit via `doc.applyChange(addr, bundle)`,
+//   (d) fire `onChange` when the transaction COMMITTED, then `onCaretMove` with
+//       the new USV caret, which a bare selection move fires on its own.
+// On an `applyChange` throw the optimistic PM state stays and the failure reports
+// through `onError`: never a crash. Caret continuity across own-edits is the PM
+// `StepMap`; an EXTERNAL content change re-hydrates through `applyExternal`, gated
+// by `reconcile`.
+import { baseKeymap, toggleMark } from 'prosemirror-commands';
+import { gapCursor } from 'prosemirror-gapcursor';
+import { history, redo, undo } from 'prosemirror-history';
+import { keymap } from 'prosemirror-keymap';
+import { EditorState, NodeSelection, Plugin, PluginKey, Selection, TextSelection } from 'prosemirror-state';
+import { Decoration, DecorationSet, EditorView } from 'prosemirror-view';
+import { reportError, errorMessage } from '../errors.js';
+import { decode } from './decode.js';
+import { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
+import { lower, pmToContent, contentEdit } from './encode.js';
+import { anchorsFromContent } from './marks.js';
+import { createReconciler } from './reconcile.js';
+import { inputRulesPlugin } from './inputrules.js';
+import { bodyKeymap } from './keymap.js';
+import { blockSchema, inlineSchema } from './schema.js';
+import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
+import { DEFAULT_SLASH_STRINGS, focusSlashItem, runSlashItem, slashItems, slashPlugin } from './slash.js';
+const anchorKey = new PluginKey('quill-anchors');
+/** Plugin-held anchor positions (PM coords), mapped through every edit's `StepMap`
+ * and mutated by an {@link AnchorEdit} meta (an insert/remove at a selection). */
+function anchorPlugin(seed) {
+    return new Plugin({
+        key: anchorKey,
+        state: {
+            init: () => seed,
+            apply: (tr, anchors) => {
+                let next = tr.docChanged
+                    ? anchors.map((a) => ({ id: a.id, pos: tr.mapping.map(a.pos) }))
+                    : anchors;
+                const edit = tr.getMeta(anchorKey);
+                if (edit?.op === 'add')
+                    next = [...next, { id: edit.id, pos: edit.pos }];
+                else if (edit?.op === 'remove')
+                    next = next.filter((a) => a.id !== edit.id);
+                return next;
+            }
+        }
+    });
+}
+/** Read the leaf's `Content` for `addr`: `reader.getContent` (DOCUMENT_MODEL),
+ * the schema-plane read that decodes through the codec the field's declared type
+ * names. A field value, or the body `Content` when `addr.field` is absent, without
+ * materializing the whole card. Reads are total over the field axis, so an absent
+ * field, a default-only richtext field (e.g. `tag_line`, no stored value until
+ * first edited), reads `undefined`; decode an empty content rather than crash, and
+ * the first edit overwrites it. Only an out-of-range `addr.card` throws, unreachable
+ * here: a removed card unmounts its keyed leaf before a stale index is read.
+ *
+ * Bound rather than verbatim, because the storage form is not the leaf's business
+ * and the verbatim read cannot answer it alone. A field the editor committed rests
+ * as `Content`; a field a markdown parse left rests as the authored STRING, and
+ * what that string MEANS is the declared type's to say: `richtext` is markdown,
+ * `plaintext` is literal text, and reading one as the other silently eats every
+ * `*` the author typed. */
+function readLeaf(reader, addr) {
+    return reader.getContent(addr) ?? emptyContent();
+}
+/** The canonical empty `Content`: one empty `para` line. The zero value a prose
+ * leaf (or an array's prose element) seeds from. */
+export function emptyContent() {
+    return { text: '', lines: [{ containers: [], kind: 'para' }], marks: [], islands: [] };
+}
+/** Whether ops may commit here: the stored value is a `Content` object, so
+ * `applyChange` splices exactly the content the leaf read and PM is showing.
+ *
+ * The two other rest forms both take `overwrite` instead. An UNSET field (`undefined`;
+ * a default-only richtext field before its first edit) has nothing to splice.
+ * An AUTHORED STRING is the trap: `applyChange` reads it as markdown whatever the
+ * declared type is, so on a `plaintext` field its pre-image is not the content the
+ * leaf read and a delta computed against that content lands at the wrong offsets.
+ * Installing over it costs nothing either way, since content-only marks do not
+ * survive markdown and a string therefore carries no anchors to pay. A body always
+ * rests as `Content`. */
+function opsCommittable(doc, addr) {
+    const stored = doc.getStored(addr);
+    return stored !== null && typeof stored === 'object';
+}
+/** The naming attributes for the `contenteditable`. `aria-labelledby` supersedes
+ * `aria-label`: a leaf carrying both is the ambiguity where implementations
+ * disagree about which wins, and `undefined` is returned whole when a leaf takes
+ * neither, since ProseMirror reads the absence, not an empty object. */
+function proseAttributes(opts) {
+    const attrs = {};
+    if (opts.labelledBy)
+        attrs['aria-labelledby'] = opts.labelledBy;
+    else if (opts.label)
+        attrs['aria-label'] = opts.label;
+    if (opts.describedBy)
+        attrs['aria-describedby'] = opts.describedBy;
+    return Object.keys(attrs).length ? attrs : undefined;
+}
+export function createField(opts) {
+    const { doc, addr, container } = opts;
+    const inline = !!opts.inline || !!opts.plaintext;
+    const plaintext = !!opts.plaintext;
+    const schema = inline ? inlineSchema : blockSchema;
+    // Bound once and held: the reader is a `{quill, doc}` pair that reads live, so
+    // every read below sees the commit before it.
+    const reader = opts.quill.reader(doc);
+    // `known` is the codec's view of the stored content: kept in sync after every
+    // own-edit so `reconcile` can tell an external change from the field's own.
+    const reconciler = createReconciler(readLeaf(reader, addr));
+    let index; // rebuilt on every structural change
+    let view;
+    // The ghost's live cell: the placeholder plugin reads it per pass, so moving it
+    // is an assignment plus a re-render rather than a rebuilt plugin stack.
+    let placeholderText = opts.placeholder;
+    // The views nested INSIDE this leaf: one per table cell (`table-view.ts`). The
+    // leaf holds the set because chrome asks the leaf, not the island, which view
+    // holds the caret: the format popover raises over a cell exactly as over the
+    // body, and only the leaf knows both.
+    const nested = new Set();
+    // The menu's offers, derived from the wording per read: the chrome names an item
+    // and the codec runs it, so a locale swap changes the labels and not the picks.
+    const menuItems = () => slashItems(opts.slashStrings?.() ?? DEFAULT_SLASH_STRINGS);
+    const slash = !inline && opts.onSlash ? { items: menuItems, onState: opts.onSlash } : undefined;
+    const state = buildState(reconciler.last);
+    index = buildLineIndex(state.doc);
+    view = new EditorView(container, {
+        state,
+        attributes: proseAttributes(opts),
+        // Islands are block-schema only, so an inline leaf mounts no node view at all.
+        nodeViews: inline
+            ? undefined
+            : {
+                island_block: tableNodeView({
+                    strings: opts.tableStrings ?? (() => DEFAULT_TABLE_STRINGS),
+                    register: (cellView) => {
+                        nested.add(cellView);
+                        return () => nested.delete(cellView);
+                    },
+                    // A focus event does not bubble, so the leaf's own `focus` handler
+                    // never fires for a cell: without this the active address would not
+                    // follow a caret clicked straight into a table.
+                    onCellFocus: () => opts.onFocus?.(addr)
+                })
+            },
+        dispatchTransaction: (tr) => {
+            const oldRt = reconciler.last;
+            const next = view.state.apply(tr);
+            view.updateState(next); // (a) optimistic
+            index = buildLineIndex(next.doc);
+            // Commit a content edit OR an anchor mutation. An anchor insert/remove is
+            // zero-width, so `docChanged` is false: the `anchorKey` meta is what
+            // routes it through the same commit path (the diff emits the anchor op).
+            if (tr.docChanged || tr.getMeta(anchorKey)) {
+                // (d) the change signal, only for what actually landed.
+                if (commitEdit(oldRt, next.doc))
+                    opts.onChange?.(addr);
+            }
+            // The caret, for both structural and selection-only changes: a host
+            // following the caret wants an arrow key, and a host recompiling wants
+            // `onChange`. Reported after the commit, so the edit has landed by the
+            // time the caret names where it is.
+            opts.onCaretMove?.(addr, pmToUsv(index, next.selection.head));
+        },
+        handleDOMEvents: {
+            focus: () => {
+                opts.onFocus?.(addr);
+                return false;
+            }
+        }
+    });
+    function buildState(rt) {
+        const pmDoc = decode(rt, schema, { plaintext });
+        const anchors = plaintext ? [] : anchorsFromContent(rt);
+        // Seed anchor plugin positions in PM coords via a fresh index over pmDoc.
+        const seedIndex = buildLineIndex(pmDoc);
+        const seededAnchors = anchors.map((a) => ({
+            id: a.id,
+            pos: usvToPM(seedIndex, a.pos)
+        }));
+        return EditorState.create({
+            doc: pmDoc,
+            plugins: proseLeafPlugins(schema, {
+                inline,
+                plaintext,
+                slash,
+                noInputRules: opts.noInputRules,
+                // Always installed, so a leaf that mounts without a ghost can still be
+                // given one later; the plugin draws nothing while the text is empty.
+                placeholder: () => placeholderText,
+                afterHistory: [anchorPlugin(seededAnchors)]
+            })
+        });
+    }
+    // (b)+(c): lower the edit to ops and commit, or `overwrite` a field not yet at
+    // content rest. Keep the optimistic PM on throw.
+    // Returns whether anything landed: the caller's change signal, which must not
+    // be a property of which branch the commit took.
+    function commitEdit(oldRt, newDoc) {
+        // The projection and its text splice, each computed ONCE per keystroke: the gate
+        // below, both overwrite fallbacks, and `lower` all read this one `edit`.
+        const edit = contentEdit(oldRt, pmToContent(newDoc));
+        try {
+            // A field not yet at content rest is the only edit that overwrites by choice:
+            // `applyChange` throws on an absent declared field (verified) and mis-reads
+            // an authored string (`opsCommittable`), and neither has anchors to lose.
+            // Every structural edit lowers, island creation included: the island channel
+            // places a slot the `delta` may not carry.
+            if (!opsCommittable(doc, addr)) {
+                doc.overwrite(addr, edit.newRt); // brings the field to content rest
+            }
+            else {
+                // Pre-edit anchors are the stored content's anchors (USV); post-edit
+                // anchors are the plugin's positions (mapped through the tr) as USV.
+                const oldAnchors = plaintext ? [] : anchorsFromContent(oldRt);
+                const newAnchors = plaintext ? [] : readAnchorsUsv(newDoc);
+                doc.applyChange(addr, lower(edit, { oldAnchors, newAnchors }));
+            }
+            reconciler.commit(readLeaf(reader, addr));
+            return true;
+        }
+        catch (e) {
+            // Bound the damage: an op path the gates missed leaves the store STALE
+            // while PM keeps the edit; and because the reconciler then re-diffs
+            // from that stale content, every later edit re-throws and the field
+            // silently stops persisting. Install the full projection instead
+            // (correct store, pays this field's anchors).
+            reportError(opts.onError, {
+                code: 'commit-fallback',
+                severity: 'error',
+                message: `applyChange refused; overwrote the whole field: ${errorMessage(e)}`,
+                cause: e
+            });
+            try {
+                doc.overwrite(addr, edit.newRt);
+                reconciler.commit(readLeaf(reader, addr));
+                return true;
+            }
+            catch (e2) {
+                // Optimistic PM stays; the store is stale for this field from here.
+                reportError(opts.onError, {
+                    code: 'commit-lost',
+                    severity: 'error',
+                    message: `overwrite fallback failed; the stored value is stale while the editor keeps the edit: ${errorMessage(e2)}`,
+                    cause: e2
+                });
+                return false;
+            }
+        }
+    }
+    /** The anchors the plugin currently holds (PM coords); `[]` before the first apply. */
+    const heldAnchors = () => anchorKey.getState(view.state) ?? [];
+    /** Anchor positions in the CURRENT (new) doc, as USV. */
+    function readAnchorsUsv(newDoc) {
+        return heldAnchors().map((a) => ({ id: a.id, pos: pmToUsv(index, a.pos) }));
+    }
+    const controller = {
+        el: container,
+        setCaret(pos) {
+            const pm = usvToPM(index, pos);
+            // `Selection.near`, not `TextSelection.create`: the mapped position can
+            // be non-inline (before an island/rule block, or doc-level in an empty
+            // nested textblock), where a raw TextSelection is invalid.
+            const sel = Selection.near(view.state.doc.resolve(pm));
+            view.dispatch(view.state.tr.setSelection(sel));
+            view.focus();
+        },
+        applyExternal() {
+            const current = readLeaf(reader, addr);
+            if (!reconciler.shouldRehydrate(current))
+                return; // own edit / no change
+            const caretUsv = pmToUsv(index, view.state.selection.head);
+            const fresh = buildState(current);
+            view.updateState(fresh);
+            index = buildLineIndex(fresh.doc);
+            // Best-effort caret continuity across an external change: keep the USV.
+            const pm = usvToPM(index, caretUsv);
+            view.dispatch(view.state.tr.setSelection(Selection.near(fresh.doc.resolve(pm))));
+            reconciler.commit(current);
+        },
+        setPlaceholder(text) {
+            if (text === placeholderText)
+                return;
+            placeholderText = text;
+            // `setProps` re-runs the decoration pass against the unchanged state: no
+            // transaction, so nothing commits and no caret is reported.
+            view.setProps({});
+        },
+        focus() {
+            view.focus();
+        },
+        getContent() {
+            return readLeaf(reader, addr);
+        },
+        insertAnchor(id, pos) {
+            if (plaintext)
+                return; // a plaintext field carries no marks (§Inline mode)
+            if (heldAnchors().some((a) => a.id === id))
+                return; // ids are unique + invariant (0.97 policy)
+            // An anchor commits through `applyChange`, so the field is brought to content
+            // rest first; else the commit's overwrite branch (value semantics) would drop
+            // the just-added anchor.
+            if (!opsCommittable(doc, addr))
+                doc.overwrite(addr, reconciler.last);
+            const pm = usvToPM(index, pos);
+            view.dispatch(view.state.tr.setMeta(anchorKey, { op: 'add', id, pos: pm }));
+        },
+        removeAnchor(id) {
+            if (plaintext)
+                return;
+            if (!heldAnchors().some((a) => a.id === id))
+                return; // absent: nothing to commit
+            view.dispatch(view.state.tr.setMeta(anchorKey, { op: 'remove', id }));
+        },
+        anchorsInRange(from, to) {
+            return heldAnchors()
+                .filter((a) => {
+                const u = pmToUsv(index, a.pos);
+                return u >= from && u <= to;
+            })
+                .map((a) => a.id);
+        },
+        slashFocus(id) {
+            if (slash)
+                focusSlashItem(view, id, slash.items());
+        },
+        slashPick(id) {
+            if (slash)
+                runSlashItem(view, id);
+        },
+        selectionRange() {
+            const { from, to } = view.state.selection;
+            return {
+                from: pmToUsv(index, from),
+                to: pmToUsv(index, to)
+            };
+        },
+        destroy() {
+            view.destroy();
+        }
+    };
+    // The underlying views, exposed as available (undocumented) handles: the
+    // VisualEditor composes views, and tests drive edits through them.
+    const handles = controller;
+    handles.view = view;
+    handles.nestedViews = () => [...nested];
+    handles.focusedView = () => {
+        for (const cellView of nested)
+            if (cellView.hasFocus())
+                return cellView;
+        return view;
+    };
+    return controller;
+}
+/**
+ * The prose-leaf plugin stack (VISUAL_EDITOR §Surface): shared by
+ * {@link createField} and the array-element inline editor (`ProseArrayElement`),
+ * so the two never fork the keymap/plugin ordering. History first, then any
+ * leaf-specific plugins (`afterHistory`: the addressed leaf passes its
+ * anchor-position plugin; a by-value array element passes none), the
+ * markdown-shorthand input rules, then the field keymap over the base keymap, and
+ * last the two that answer to a caret or a selection BESIDE a block: the gap cursor
+ * and {@link pastAtomPlugin}.
+ *
+ * A `plaintext` field carries no marks (decode strips them, the keymap suppresses
+ * Mod-b/i/u), so it also skips the input rules: `inlineSchema` still declares the
+ * mark types, so a `**bold**` rule would apply a strong mark AND eat the literal
+ * delimiters. The inline schema has no block nodes, so those rules are the ONLY
+ * ones it would add: skip all.
+ */
+export function proseLeafPlugins(schema, opts) {
+    const list = [history(), ...(opts.afterHistory ?? [])];
+    if (opts.slash)
+        list.push(slashPlugin(opts.slash));
+    if (!opts.noInputRules && !opts.plaintext)
+        list.push(inputRulesPlugin(schema));
+    list.push(keymap(editorKeymap(schema, opts.inline, opts.plaintext, opts.slash?.items)));
+    list.push(keymap(baseKeymap));
+    // Both answer to a selection over an ATOM, which only a block leaf holds: an
+    // inline leaf is one textblock with no island and no gap to put a cursor in.
+    if (!opts.inline)
+        list.push(gapCursor(), pastAtomPlugin());
+    if (opts.placeholder)
+        list.push(placeholderPlugin(opts.placeholder));
+    return list;
+}
+/**
+ * A printable key over a selected atom writes PAST it. A selection is the subject
+ * of the next command, never a thing armed for
+ * replacement: Backspace deletes it, Mod-C copies it, and a character lands beside
+ * it. A BLOCK island takes a new paragraph after it, an INLINE one the caret after
+ * the image in the same line: one rule, both node types.
+ *
+ * PM routes text input over a non-`TextSelection` through `handleTextInput` before
+ * falling back to replacing the selection, so this one prop is the whole of it.
+ * Paste keeps replacing: a paste is deliberate, and it is the gesture that swaps one
+ * island for another.
+ */
+function pastAtomPlugin() {
+    return new Plugin({
+        props: {
+            handleTextInput(view, _from, _to, text) {
+                const { selection, schema } = view.state;
+                if (!text || !(selection instanceof NodeSelection) || !selection.node.isAtom)
+                    return false;
+                const tr = view.state.tr;
+                const at = selection.to; // just past the node, in both coordinate senses
+                if (selection.node.isInline) {
+                    tr.setSelection(TextSelection.create(tr.doc, at)).insertText(text);
+                }
+                else {
+                    const para = schema.nodes.paragraph.create(null, schema.text(text));
+                    tr.insert(at, para);
+                    tr.setSelection(TextSelection.create(tr.doc, at + para.nodeSize - 1));
+                }
+                view.dispatch(tr.scrollIntoView());
+                return true;
+            }
+        }
+    });
+}
+/**
+ * The empty-leaf ghost placeholder. A node decoration stamps the sole empty
+ * textblock with a class + the ghost text,
+ * which CSS renders via `::before { content: attr(data-placeholder) }`: so the
+ * text never enters the document, the caret path, or a `pmToContent` export. It
+ * vanishes the instant the leaf holds any content (the emptiness test fails).
+ *
+ * `read` is called per decoration pass rather than closed over, so moving the
+ * ghost is a re-render and never a document edit.
+ */
+function placeholderPlugin(read) {
+    return new Plugin({
+        props: {
+            decorations(state) {
+                const text = read();
+                if (!text)
+                    return null;
+                const { doc } = state;
+                const first = doc.firstChild;
+                const empty = doc.childCount === 1 && !!first && first.isTextblock && first.content.size === 0;
+                if (!empty)
+                    return null;
+                return DecorationSet.create(doc, [
+                    Decoration.node(0, first.nodeSize, {
+                        class: 'qm-prose-placeholder',
+                        'data-placeholder': text
+                    })
+                ]);
+            }
+        }
+    });
+}
+/**
+ * The field's keymap: history, mark toggles, and the body's structural keys; Enter
+ * suppressed inline.
+ *
+ * Tab forks on the leaf's ROLE, not on the caret's position. An inline/plaintext
+ * leaf is a form field: Tab stays unbound, so field navigation is open for a shell
+ * keymap (VISUAL_EDITOR §Settled and open). A block-schema body is a document: Tab
+ * is structural, a chain each nested surface prepends to (`keymap.ts`). One key
+ * never means two things within one surface.
+ */
+function editorKeymap(schema, inline, plaintext, slashItems) {
+    const map = {
+        'Mod-z': undo,
+        'Mod-y': redo,
+        'Shift-Mod-z': redo
+    };
+    if (!plaintext) {
+        if (schema.marks.strong)
+            map['Mod-b'] = toggleMark(schema.marks.strong);
+        if (schema.marks.em)
+            map['Mod-i'] = toggleMark(schema.marks.em);
+        if (schema.marks.underline)
+            map['Mod-u'] = toggleMark(schema.marks.underline);
+    }
+    if (inline) {
+        // One textblock only: swallow Enter so no second block is attempted.
+        map['Enter'] = () => true;
+    }
+    else {
+        // Each binding falls through to `baseKeymap` when no link claims the key.
+        Object.assign(map, bodyKeymap(schema, slashItems));
+    }
+    return map;
+}

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

@@ -0,0 +1,22 @@
+import 'prosemirror-view/style/prosemirror.css';
+import 'prosemirror-gapcursor/style/gapcursor.css';
+import './prose.css';
+export { rangeAnchor } from './anchor.js';
+export type { RangeAnchor } from './anchor.js';
+export { createField, emptyContent, proseLeafPlugins } from './field.js';
+export type { CreateFieldOpts, FieldController, LeafViews } from './field.js';
+export { DEFAULT_TABLE_STRINGS } from './table-view.js';
+export type { TableChromeStrings } from './table-view.js';
+export { DEFAULT_SLASH_STRINGS } from './slash.js';
+export type { SlashState, SlashStrings } from './slash.js';
+export { blockSchema, inlineSchema } from './schema.js';
+export { decode, renderContent, usvLength } from './decode.js';
+export { pmToContent, contentEdit, lower } from './encode.js';
+export type { ContentEdit } from './encode.js';
+export { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
+export type { LineIndex } from './positions.js';
+export { createReconciler, contentEqual } from './reconcile.js';
+export type { Reconciler } from './reconcile.js';
+export { inputRulesPlugin } from './inputrules.js';
+export { bodyKeymap } from './keymap.js';
+export { listKeymap } from './lists.js';

package/dist/core/codec/index.js

@@ -0,0 +1,43 @@
+// The codec barrel: the bidirectional bridge between one content field (`Content`)
+// and one ProseMirror document (CODEC). Decode (content → PM), lower (PM tr → a
+// `ChangeBundle` for `applyChange`), the USV↔PM position map, and the `createField`
+// prose leaf. Consumed by the VisualEditor and the codec test suite.
+// ProseMirror's structural base styles and the gap cursor's, then the retint of the
+// hues they mint. Imported HERE because `createField` is what mounts a view: a
+// consumer reaching the codec directly gets them with it, and the order is what makes
+// the retint win.
+import 'prosemirror-view/style/prosemirror.css';
+import 'prosemirror-gapcursor/style/gapcursor.css';
+import './prose.css';
+// What a floating surface anchors to. The visual tier's own surfaces mint one over a
+// selection (`visual/FormatPopover.svelte`), so it is reached off-barrel.
+export { rangeAnchor } from './anchor.js';
+// The prose leaf.
+export { createField, emptyContent, proseLeafPlugins } from './field.js';
+// The table island's chrome vocabulary: the visual tier's `strings` set extends it,
+// so the island's wording is overridden beside every other key.
+export { DEFAULT_TABLE_STRINGS } from './table-view.js';
+// The slash menu: the codec owns the model and the picks, the chrome the words and
+// the pixels (`visual/SlashMenu.svelte` is the only off-barrel caller).
+export { DEFAULT_SLASH_STRINGS } from './slash.js';
+// Schemas (the decode/encode target; the VisualEditor mounts them).
+export { blockSchema, inlineSchema } from './schema.js';
+// Decode / encode / positions (tests + VisualEditor).
+//
+// THE BARREL CARRIES WHAT HAS AN OFF-BARREL CALLER, and nothing else. The mark
+// algebra, the island bridge, the schema predicate, the `diff*` helpers,
+// `scanDoc`, `codePoints`: every one of them is reached by RELATIVE import
+// within `codec/`, so none of them is here. An export nothing imports is surface
+// that still has to stay honest; a symbol earns its line when a caller outside
+// this folder wants it.
+export { decode, renderContent, usvLength } from './decode.js';
+export { pmToContent, contentEdit, lower } from './encode.js';
+export { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
+// Reconciliation gate.
+export { createReconciler, contentEqual } from './reconcile.js';
+// Input rules (`createField` mounts them unless `noInputRules`/`plaintext`).
+export { inputRulesPlugin } from './inputrules.js';
+// The body leaf's structural keys: `createField` binds the composed chains
+// (`bodyKeymap`); the suite drives both it and the list link directly.
+export { bodyKeymap } from './keymap.js';
+export { listKeymap } from './lists.js';

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

@@ -0,0 +1,7 @@
+import { InputRule } from 'prosemirror-inputrules';
+import type { Schema } from 'prosemirror-model';
+import type { Plugin } from 'prosemirror-state';
+/** The full markdown-shorthand rule set for a block schema. */
+export declare function markdownInputRules(schema: Schema): InputRule[];
+/** The input-rules plugin the field mounts by default (opt-out via createField). */
+export declare function inputRulesPlugin(schema: Schema): Plugin;