@quillmark/svelte 0.0.0

package/dist/core/codec/encode.js

@@ -0,0 +1,480 @@
+import { mapPos, isAnchorMark } from '@quillmark/wasm';
+import { codePoints, usvLength } from './decode.js';
+import { ISLAND_SLOT, islandEntryFromNode } from './islands.js';
+import { contentDescriptorFromPM, descriptorOf, markKey } from './marks.js';
+import { valueEqual } from './reconcile.js';
+/** Append `s` to the accumulated text, advancing the running USV length. */
+function appendText(acc, s) {
+    acc.text += s;
+    acc.usvEnd += usvLength(s);
+}
+/**
+ * Walk a PM document once, producing the content projection AND the position-map
+ * runs (they share the traversal so they can never disagree). This is the single
+ * source both `pmToContent` and the position map draw from.
+ */
+export function scanDoc(doc) {
+    const acc = {
+        text: '',
+        lines: [],
+        marks: [],
+        islands: [],
+        runs: [],
+        pmEnd: doc.content.size,
+        usvEnd: 0,
+        rawMarks: [],
+        lastContentEndPm: 0
+    };
+    scanBlocks(acc, doc, 0, []);
+    acc.marks = mergeMarks(acc.rawMarks);
+    return acc;
+}
+/** `pmToContent`: the pure inverse of decode (drops the position runs). */
+export function pmToContent(doc) {
+    const { text, lines, marks, islands } = scanDoc(doc);
+    return { text, lines, marks, islands };
+}
+/** Walk a block-content fragment; `contentStart` is the PM pos before its first child. */
+function scanBlocks(acc, parent, contentStart, containers) {
+    let pm = contentStart;
+    parent.forEach((child) => {
+        scanBlock(acc, child, pm, containers);
+        pm += child.nodeSize;
+    });
+}
+function scanBlock(acc, node, nodePos, containers) {
+    const name = node.type.name;
+    const contentStart = nodePos + 1;
+    switch (name) {
+        case 'paragraph':
+        case 'heading': {
+            // One kind value per block: the opening line and its hard-break
+            // continuations read the SAME object, so they cannot disagree.
+            const kind = textblockKind(node);
+            beginLine(acc, contentStart, containers, kind);
+            scanInline(acc, node, contentStart, containers, kind);
+            acc.lastContentEndPm = contentStart + node.content.size;
+            break;
+        }
+        case 'code_block': {
+            const lang = node.attrs.lang ?? undefined;
+            const kind = lang != null ? { kind: 'code', lang } : { kind: 'code' };
+            beginLine(acc, contentStart, containers, kind);
+            const codeText = node.textContent;
+            if (codeText.length)
+                emitText(acc, codeText, contentStart, []);
+            // Internal `\n`s already sit in the text (and its run); add the extra
+            // content lines they imply as `continues` code lines.
+            const extra = codeText.split('\n').length - 1;
+            for (let i = 0; i < extra; i++)
+                acc.lines.push({ containers, continues: true, ...kind });
+            acc.lastContentEndPm = contentStart + node.content.size;
+            break;
+        }
+        case 'horizontal_rule':
+            beginLine(acc, nodePos, containers, { kind: 'rule' });
+            acc.lastContentEndPm = nodePos + 1;
+            break;
+        case 'island_block':
+            beginLine(acc, nodePos, containers, { kind: 'island' });
+            acc.runs.push({ kind: 'atom', pmStart: nodePos, usvStart: acc.usvEnd });
+            appendText(acc, ISLAND_SLOT);
+            acc.islands.push(islandEntryFromNode(node.attrs));
+            acc.lastContentEndPm = nodePos + 1;
+            break;
+        case 'blockquote':
+            scanBlocks(acc, node, contentStart, [...containers, { container: 'quote' }]);
+            break;
+        case 'unknown_container':
+            scanBlocks(acc, node, contentStart, [
+                ...containers,
+                { container: node.attrs.container, attrs: node.attrs.attrs }
+            ]);
+            break;
+        case 'bullet_list':
+        case 'ordered_list': {
+            const ordered = name === 'ordered_list';
+            const start = ordered ? node.attrs.start : 1;
+            let itemPos = contentStart;
+            node.forEach((item, _off, index) => {
+                const container = {
+                    container: 'list_item',
+                    ordered,
+                    start,
+                    ordinal: index
+                };
+                scanBlocks(acc, item, itemPos + 1, [...containers, container]);
+                itemPos += item.nodeSize;
+            });
+            break;
+        }
+        default:
+            // Unknown block type: treat as an empty paragraph line (defensive).
+            beginLine(acc, contentStart, containers, { kind: 'para' });
+            acc.lastContentEndPm = contentStart;
+    }
+}
+/** A textblock's line kind: a heading's `level`, or (for a paragraph) `para`, or
+ * the unknown kind it carries (schema.ts) re-emitted verbatim. */
+function textblockKind(node) {
+    if (node.type.name === 'heading')
+        return { kind: 'heading', level: node.attrs.level };
+    const u = node.attrs.unknown;
+    return u ? { kind: u.kind, attrs: u.attrs } : { kind: 'para' };
+}
+/** Open a new content line: emit the boundary `\n` (except the first line) + record. */
+function beginLine(acc, thisContentStart, containers, kind) {
+    if (acc.lines.length > 0) {
+        acc.runs.push({
+            kind: 'nl',
+            pmStart: acc.lastContentEndPm,
+            pmEnd: thisContentStart,
+            usvStart: acc.usvEnd
+        });
+        appendText(acc, '\n');
+    }
+    acc.lines.push({ containers, ...kind });
+}
+/** Walk a textblock's inline content; emit text/atom/hard-break runs + marks. */
+function scanInline(acc, block, contentStart, containers, kind) {
+    let pm = contentStart;
+    block.forEach((child) => {
+        if (child.isText) {
+            emitText(acc, child.text ?? '', pm, child.marks);
+        }
+        else if (child.type.name === 'hard_break') {
+            // A within-block hard break: the content `\n` (a `continues` line).
+            acc.runs.push({ kind: 'nl', pmStart: pm, pmEnd: pm + 1, usvStart: acc.usvEnd });
+            appendText(acc, '\n');
+            acc.lines.push({ containers, continues: true, ...kind });
+        }
+        else if (child.type.name === 'island_inline') {
+            acc.runs.push({ kind: 'atom', pmStart: pm, usvStart: acc.usvEnd });
+            appendText(acc, ISLAND_SLOT);
+            acc.islands.push(islandEntryFromNode(child.attrs));
+        }
+        pm += child.nodeSize;
+    });
+}
+/** Append a text node's chars: one position run + a content mark per formatting/unknown mark. */
+function emitText(acc, s, pmStart, marks) {
+    if (!s.length)
+        return;
+    const usvStart = acc.usvEnd;
+    acc.runs.push({ kind: 'text', pmStart, usvStart, s });
+    appendText(acc, s);
+    for (const mark of marks) {
+        acc.rawMarks.push({
+            start: usvStart,
+            end: acc.usvEnd,
+            ...contentDescriptorFromPM(mark)
+        });
+    }
+}
+/**
+ * Merge adjacent/overlapping same-descriptor marks into maximal ranges: the
+ * per-text-node marks the walk emits, folded into the content's normalized form.
+ * Same two primitives the mark diff runs on (`groupFormatting` + `union`), so the
+ * projection and the diff group and merge by one rule.
+ */
+function mergeMarks(raw) {
+    const out = [];
+    for (const g of groupFormatting(raw, (m) => ({ start: m.start, end: m.end })).values()) {
+        for (const iv of union(g.intervals))
+            out.push({ ...iv, ...g.descriptor });
+    }
+    // Stable, content-like order: by start, then end.
+    return out.sort((a, b) => a.start - b.start || a.end - b.end);
+}
+/** The edit `oldRt` → `newRt`: diffs the text once. */
+export function contentEdit(oldRt, newRt) {
+    const delta = diffText(oldRt.text, newRt.text);
+    return delta ? { oldRt, newRt, delta } : { oldRt, newRt };
+}
+/** Lower an edit to a `ChangeBundle`: the old→new content diff, as ops. */
+export function lower(edit, opts = {}) {
+    const { oldRt, newRt } = edit;
+    const { delta, islandOps, insertedAt } = splitIslands(edit);
+    const lineOps = diffLines(oldRt, newRt);
+    const markOps = diffMarks(oldRt, newRt, delta, insertedAt, opts);
+    const bundle = {};
+    if (delta)
+        bundle.delta = delta;
+    if (islandOps.length)
+        bundle.islandOps = islandOps;
+    if (lineOps.length)
+        bundle.lineOps = lineOps;
+    if (markOps.length)
+        bundle.markOps = markOps;
+    return bundle;
+}
+/** A minimal single-splice text delta over USV code points, or `undefined` if equal. */
+function diffText(oldText, newText) {
+    if (oldText === newText)
+        return undefined;
+    const a = codePoints(oldText);
+    const b = codePoints(newText);
+    let p = 0;
+    const min = Math.min(a.length, b.length);
+    while (p < min && a[p] === b[p])
+        p++;
+    let s = 0;
+    while (s < min - p && a[a.length - 1 - s] === b[b.length - 1 - s])
+        s++;
+    const ops = [];
+    if (p > 0)
+        ops.push({ retain: p });
+    const del = a.length - p - s;
+    if (del > 0)
+        ops.push({ delete: del });
+    const ins = b.slice(p, b.length - s).join('');
+    if (ins.length > 0)
+        ops.push({ insert: ins });
+    if (s > 0)
+        ops.push({ retain: s });
+    return { ops };
+}
+/** Per-line `setContainers` / `setKind` / `setContinues` when line metadata changed; else none. */
+function diffLines(oldRt, newRt) {
+    if (lineMetaEqual(oldRt.lines, newRt.lines))
+        return [];
+    const ops = [];
+    // Force every new line's metadata. Redundant ops are safe no-ops (verified),
+    // so this is correct regardless of how the delta's split/join inheritance left
+    // the intermediate metadata. `continues` is a boundary property of the `\n`
+    // preceding a line: line 0 has no predecessor, never carries it, and the op
+    // rejects it there, so it's set only for lines ≥ 1.
+    for (let i = 0; i < newRt.lines.length; i++) {
+        const l = newRt.lines[i];
+        ops.push({ op: 'setContainers', line: i, containers: l.containers });
+        ops.push(kindOp(i, l));
+        if (i > 0)
+            ops.push({ op: 'setContinues', line: i, continues: !!l.continues });
+    }
+    return ops;
+}
+/** A line minus its `containers` / `continues` envelope: exactly `setKind`'s
+ * payload, which the boundary names `ContentLineKind`. Lifting it whole is what
+ * keeps this arm-agnostic: `kind` is an OPEN set, so an arm-by-arm switch would
+ * have to guess at the unknown arm's payload and would drift on every arm
+ * upstream adds. */
+function kindPart(l) {
+    const { containers: _containers, continues: _continues, ...kind } = l;
+    return kind;
+}
+function kindOp(line, l) {
+    return { op: 'setKind', line, ...kindPart(l) };
+}
+function lineMetaEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (!!a[i].continues !== !!b[i].continues)
+            return false;
+        if (kindKey(a[i]) !== kindKey(b[i]))
+            return false;
+        if (JSON.stringify(a[i].containers) !== JSON.stringify(b[i].containers))
+            return false;
+    }
+    return true;
+}
+/** A line kind's comparison key: key-order-insensitive, because the two sides come
+ * from different producers (a WASM read and this scan). */
+function kindKey(l) {
+    return JSON.stringify(Object.entries(kindPart(l)).sort(([x], [y]) => (x < y ? -1 : 1)));
+}
+/**
+ * Split the edit's islands off the text splice. `applyChange` throws
+ * `IslandSlotInInsert` on a `delta` that types a slot, so a slot NEVER rides the
+ * delta: every slot inside the splice's inserted region is stripped from it and
+ * placed by `{ op: 'insert', at }`, which carries the backing entry in the same
+ * op. Every other island kept its slot, so a changed payload is `{ op: 'set' }`,
+ * addressed by the id both sides carry. A DELETED island needs no op at all: the
+ * delta that removes its slot drops the entry.
+ *
+ * `at` is the slot's position in the FINAL text: inserts apply left to right, so
+ * by the time the k-th lands, the k slots before it are back in place.
+ *
+ * The pairing is positional for `insert` and by id for `set`, which is what each
+ * addresses by. An id the store does not carry emits nothing rather than a `set`
+ * that would throw `UnknownIslandId`: nothing mints or renames an island id, so
+ * it is unreachable.
+ */
+function splitIslands(edit) {
+    const { oldRt, newRt, delta } = edit;
+    const slots = slotPositions(newRt.text);
+    const { start, end } = insertedRegion(delta);
+    const oldById = new Map(oldRt.islands.map((isl) => [isl.id, isl]));
+    const islandOps = [];
+    const insertedAt = [];
+    newRt.islands.forEach((isl, i) => {
+        const at = slots[i];
+        if (at !== undefined && at >= start && at < end) {
+            islandOps.push({ op: 'insert', at, ...isl });
+            insertedAt.push(at);
+        }
+        else {
+            const before = oldById.get(isl.id);
+            if (before && !valueEqual(before, isl))
+                islandOps.push({ op: 'set', ...isl });
+        }
+    });
+    return {
+        delta: insertedAt.length && delta ? withoutSlots(delta) : delta,
+        islandOps,
+        insertedAt
+    };
+}
+/** The USV positions of `text`'s island slots, in document order: the i-th is the
+ *  i-th island's, since the scan appends an entry per slot it writes. */
+function slotPositions(text) {
+    const out = [];
+    let usv = 0;
+    for (const cp of text) {
+        if (cp === ISLAND_SLOT)
+            out.push(usv);
+        usv++;
+    }
+    return out;
+}
+/** The splice's inserted region `[start, end)` in FINAL coords. `diffText` emits
+ *  one `[retain?][delete?][insert?][retain?]`, so the leading retain is where the
+ *  insert lands and its length is how far it reaches. */
+function insertedRegion(delta) {
+    if (!delta)
+        return { start: 0, end: 0 };
+    const lead = delta.ops[0];
+    const start = lead && 'retain' in lead ? lead.retain : 0;
+    const insert = delta.ops.find((op) => 'insert' in op);
+    return { start, end: start + (insert ? usvLength(insert.insert) : 0) };
+}
+/** The delta with every island slot removed from its insert, or `undefined` when
+ *  that leaves nothing but retains. Retain/delete arithmetic reads the OLD text,
+ *  so dropping inserted characters leaves the rest of the splice intact. */
+function withoutSlots(delta) {
+    const ops = [];
+    let splices = false;
+    for (const op of delta.ops) {
+        if ('insert' in op) {
+            const kept = op.insert.split(ISLAND_SLOT).join('');
+            if (kept.length) {
+                ops.push({ insert: kept });
+                splices = true;
+            }
+        }
+        else {
+            if ('delete' in op)
+                splices = true;
+            ops.push(op);
+        }
+    }
+    return splices ? { ops } : undefined;
+}
+/**
+ * A post-delta position carried through the bundle's island inserts, which move
+ * text exactly as the delta does and rebase marks by the same rule (start-assoc
+ * `after`, end-assoc `before`; an anchor is a point and holds `before`). Ascending
+ * `at`s apply left to right, so each comparison reads the RUNNING position.
+ */
+function shiftPastIslands(pos, insertedAt, assoc) {
+    let p = pos;
+    for (const at of insertedAt)
+        if (assoc === 'after' ? p >= at : p > at)
+            p++;
+    return p;
+}
+/** Formatting/unknown marks → add/remove ops; anchors → add/removeAnchor by id. */
+function diffMarks(oldRt, newRt, delta, insertedAt, opts) {
+    const ops = [];
+    // Rebase old marks through BOTH text-moving channels to final coords, exactly
+    // as `applyChange` does internally (start assoc `after`, end assoc `before`).
+    const rebase = (pos, assoc) => shiftPastIslands(delta ? mapPos(delta, pos, assoc) : pos, insertedAt, assoc);
+    // Group both sides by descriptor key (excluding anchors).
+    const oldGroups = groupFormatting(oldRt.marks, (m) => ({
+        start: rebase(m.start, 'after'),
+        end: rebase(m.end, 'before')
+    }));
+    const newGroups = groupFormatting(newRt.marks, (m) => ({ start: m.start, end: m.end }));
+    const keys = new Set([...oldGroups.keys(), ...newGroups.keys()]);
+    for (const key of keys) {
+        const oldG = oldGroups.get(key);
+        const newG = newGroups.get(key);
+        const descriptor = (newG ?? oldG).descriptor;
+        const oldCov = union((oldG?.intervals ?? []).filter((iv) => iv.end > iv.start));
+        const newCov = union((newG?.intervals ?? []).filter((iv) => iv.end > iv.start));
+        for (const iv of subtract(oldCov, newCov))
+            ops.push({ op: 'remove', start: iv.start, end: iv.end, ...descriptor });
+        for (const iv of subtract(newCov, oldCov))
+            ops.push({ op: 'add', start: iv.start, end: iv.end, ...descriptor });
+    }
+    // Anchors: diff the decoration sets by id (positions already in final coords).
+    if (opts.oldAnchors || opts.newAnchors) {
+        const oldA = new Map((opts.oldAnchors ?? []).map((a) => [
+            a.id,
+            shiftPastIslands(delta ? mapPos(delta, a.pos, 'after') : a.pos, insertedAt, 'before')
+        ]));
+        const newA = new Map((opts.newAnchors ?? []).map((a) => [a.id, a.pos]));
+        for (const [id, pos] of newA) {
+            if (!oldA.has(id) || oldA.get(id) !== pos) {
+                if (oldA.has(id))
+                    ops.push({ op: 'removeAnchor', id });
+                ops.push({ op: 'add', start: pos, end: pos, type: 'anchor', id });
+            }
+        }
+        for (const id of oldA.keys())
+            if (!newA.has(id))
+                ops.push({ op: 'removeAnchor', id });
+    }
+    return ops;
+}
+/** Group non-anchor marks by descriptor key, mapping each to an interval. */
+function groupFormatting(marks, toInterval) {
+    const groups = new Map();
+    for (const m of marks) {
+        if (isAnchorMark(m))
+            continue;
+        const descriptor = descriptorOf(m);
+        const key = markKey(descriptor);
+        let g = groups.get(key);
+        if (!g) {
+            g = { descriptor, intervals: [] };
+            groups.set(key, g);
+        }
+        g.intervals.push(toInterval(m));
+    }
+    return groups;
+}
+/** Union a set of intervals into sorted, disjoint, maximal intervals. */
+function union(intervals) {
+    if (!intervals.length)
+        return [];
+    const sorted = [...intervals].sort((a, b) => a.start - b.start || a.end - b.end);
+    const out = [{ ...sorted[0] }];
+    for (let i = 1; i < sorted.length; i++) {
+        const last = out[out.length - 1];
+        if (sorted[i].start <= last.end)
+            last.end = Math.max(last.end, sorted[i].end);
+        else
+            out.push({ ...sorted[i] });
+    }
+    return out;
+}
+/** Interval-set subtraction `a \ b` (both assumed unioned/sorted). */
+function subtract(a, b) {
+    const out = [];
+    for (const iv of a) {
+        let cursor = iv.start;
+        for (const cut of b) {
+            if (cut.end <= cursor || cut.start >= iv.end)
+                continue;
+            if (cut.start > cursor)
+                out.push({ start: cursor, end: Math.min(cut.start, iv.end) });
+            cursor = Math.max(cursor, cut.end);
+            if (cursor >= iv.end)
+                break;
+        }
+        if (cursor < iv.end)
+            out.push({ start: cursor, end: iv.end });
+    }
+    return out.filter((iv) => iv.end > iv.start);
+}

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

@@ -0,0 +1,171 @@
+import type { Schema } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import type { Document, Content, Addr, Quill } from '@quillmark/wasm';
+import type { EditorErrorHandler } from '../errors.js';
+import { type TableChromeStrings } from './table-view.js';
+import { type SlashItem, type SlashState, type SlashStrings } from './slash.js';
+/** Options for {@link createField}. */
+export interface CreateFieldOpts {
+    doc: Document;
+    /** The schema the leaf reads through: `quill.reader(doc).getContent` decodes by
+     *  declared type, which is the only thing that says whether a stored string is
+     *  markdown or literal text. */
+    quill: Quill;
+    addr: Addr;
+    container: HTMLElement;
+    /** Constrained single-textblock schema (a `richtext(inline)` field). */
+    inline?: boolean;
+    /** Inline + marks/islands stripped (a `plaintext` field). Implies `inline`. */
+    plaintext?: boolean;
+    /** Suppress the markdown-shorthand input rules. */
+    noInputRules?: boolean;
+    /** The island chrome's wording, read LIVE (per render) so a consumer swapping
+     *  locale mid-session re-renders rather than freezing it at mount. Absent leaves
+     *  the package's English; an inline leaf never asks (it holds no island). */
+    tableStrings?: () => TableChromeStrings;
+    /** The slash menu's wording, read live for the same reason. */
+    slashStrings?: () => SlashStrings;
+    /**
+     * The slash menu's live state, or `undefined` when it is closed: the channel the
+     * chrome draws from (`visual/SlashMenu.svelte`).
+     *
+     * Its PRESENCE is what mounts the menu at all. The trigger and its keys are the
+     * leaf's, but a surface only a keyboard can reach (claiming Enter, Escape and the
+     * arrows with nothing on screen) is worse than no surface, so the door exists
+     * exactly where something can draw it. A constrained inline leaf never has one:
+     * it holds no island and no block to convert.
+     */
+    onSlash?(state: SlashState | undefined): void;
+    /** Accessible name → `aria-label` on the `contenteditable`. For a leaf NOTHING
+     * else names: an array element (the field label plus its 1-based index), the
+     * card body (no visible label at all). A leaf with a field label takes
+     * `labelledBy` instead: `for` cannot reach a `contenteditable`, which is not a
+     * labelable element, so the association runs the other way. */
+    label?: string;
+    /** The field label's own id → `aria-labelledby`, which supersedes `label`. */
+    labelledBy?: string;
+    /** The parked `description` → `aria-describedby`; announced after the name. */
+    describedBy?: string;
+    /** Ghost text shown on the empty leaf: the resolved `default:` a field ghosts,
+     * or a body's invitation. The INITIAL value; {@link
+     * FieldController.setPlaceholder} moves it after mount. Empty/absent
+     * shows no ghost. */
+    placeholder?: string;
+    onFocus?(addr: Addr): void;
+    /** Fired with the new USV caret after an edit or a selection move. */
+    onCaretMove?(addr: Addr, pos: number): void;
+    /**
+     * Fired after an edit COMMITTED to the document: the leaf's change signal, and
+     * the reason it is not `onCaretMove`. That one also fires on a bare selection
+     * move, so a host driving a recompile off it recompiles on every arrow key.
+     *
+     * Fires for every commit regardless of which branch it took (`applyChange`, the
+     * first-edit `overwrite`, the fallback `overwrite`) and for an anchor mutation,
+     * which changes no text. A commit that failed outright (`commit-lost`) does not
+     * fire it: nothing landed.
+     */
+    onChange?(addr: Addr): void;
+    /** Recovered failures on the commit path ({@link EditorErrorHandler}). */
+    onError?: EditorErrorHandler;
+}
+/** The prose-leaf handle (VISUAL_EDITOR §Surface). */
+export interface FieldController {
+    /** The mounted `container`: the leaf's element, for a caller that has to reach the
+     *  DOM the view sits in (the arrival wash, `core/bloom.ts`) rather than re-find it. */
+    readonly el: HTMLElement;
+    /** Place the caret at USV `pos` (preview onCaretPick → usvToPM → here). */
+    setCaret(pos: number): void;
+    /** External content change → re-hydrate this leaf (gated by reconcile). */
+    applyExternal(): void;
+    /**
+     * Move the empty-leaf ghost after mount: a card retyped to another kind takes
+     * its new kind's wording without remounting, which it must not do (the leaf key
+     * is the card's session id, so a remount would cost the caret).
+     *
+     * Refreshes the decoration WITHOUT a transaction: a placeholder is chrome, and
+     * a transaction would fire `onCaretMove` at a moment the caret did not move.
+     */
+    setPlaceholder(text: string | undefined): void;
+    focus(): void;
+    /** The current stored content for this addr (for tests / reconcile). */
+    getContent(): Content;
+    /**
+     * Insert an identity anchor `id` at USV `pos`: the seam that gives
+     * `anchor` the toggle the six formatting marks have. Zero-width; it folds into the
+     * plugin's position set and commits through the mark-diff `anchor` op, so it
+     * survives later edits like any anchor. The id is caller-supplied and must be
+     * unique + invariant (the 0.97 anchor-id policy); a duplicate id is a no-op.
+     */
+    insertAnchor(id: string, pos: number): void;
+    /** Remove the identity anchor `id` (the inverse of {@link insertAnchor}); a no-op if absent. */
+    removeAnchor(id: string): void;
+    /** Ids of the anchors within USV range `[from, to]`: a selection's anchor state. */
+    anchorsInRange(from: number, to: number): string[];
+    /**
+     * Move the slash menu's cursor onto item `id`: what a POINTER entering an item
+     * calls. The keyboard cursor and the pointer's highlight are one state, so the
+     * chrome moves the one the keys already drive rather than painting a second.
+     */
+    slashFocus(id: string): void;
+    /** Run slash item `id` (a click on one): the same path Enter takes. A no-op with
+     *  no menu open, which is the state a stale click lands in. */
+    slashPick(id: string): void;
+    /** The current PM selection as a USV `{ from, to }` range (the boundary currency). */
+    selectionRange(): {
+        from: number;
+        to: number;
+    };
+    destroy(): void;
+}
+/**
+ * The ProseMirror handles a chrome surface reaches a mounted leaf through. Not part
+ * of {@link FieldController}: they are PM internals, and a consumer's contract is the
+ * controller's verbs. The format popover is the one caller and it needs both:
+ * `view` to name the leaf's own document, `focusedView` to act on wherever the caret
+ * actually is, which inside a table island is a NESTED cell view (`table-view.ts`).
+ * The two being different is exactly what tells the popover to withhold its
+ * `anchor` button: an anchor is the FIELD's coordinate space, and a cell is not in it.
+ */
+export interface LeafViews {
+    view: EditorView;
+    focusedView(): EditorView;
+    /** Every view nested inside this leaf, in mount order: one per table cell. */
+    nestedViews(): EditorView[];
+}
+/** The canonical empty `Content`: one empty `para` line. The zero value a prose
+ * leaf (or an array's prose element) seeds from. */
+export declare function emptyContent(): Content;
+export declare function createField(opts: CreateFieldOpts): FieldController;
+/**
+ * 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 declare function proseLeafPlugins(schema: Schema, opts: {
+    inline: boolean;
+    plaintext: boolean;
+    /** The slash menu's model and its report channel; absent mounts no menu and
+     *  leaves Enter/Escape/the arrows to the links below (`keymap.ts`). */
+    slash?: {
+        items: () => SlashItem[];
+        onState: (state: SlashState | undefined) => void;
+    };
+    noInputRules?: boolean;
+    /** Read live, not captured: the ghost can move after mount
+     *  ({@link FieldController.setPlaceholder}), and a re-hydration rebuilds this
+     *  stack, so the plugin must ask rather than hold. */
+    placeholder?: () => string | undefined;
+    afterHistory?: Plugin[];
+}): Plugin[];