@quillmark/svelte 0.27.0 → 0.28.0

package/dist/core/codec/encode.js

@@ -9,9 +9,8 @@ function appendText(acc, 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.
+ * Walk a PM document once, producing the content projection and the position-map runs; sharing the
+ * traversal means they cannot disagree.
  */
 export function scanDoc(doc) {
     const acc = {
@@ -28,8 +27,10 @@ export function scanDoc(doc) {
     acc.marks = mergeMarks(acc.rawMarks);
     return acc;
 }
-/** The content projection a scan carries (drops the position runs): what a caller
- *  holding a `Scan` reads instead of walking the document a second time. */
+/**
+ * The content projection a scan carries, for a caller holding a `Scan` that would otherwise walk
+ * again.
+ */
 export function scanContent(s) {
     const { text, lines, marks, islands } = s;
     return { text, lines, marks, islands };
@@ -38,11 +39,12 @@ export function scanContent(s) {
 export function pmToContent(doc) {
     return scanContent(scanDoc(doc));
 }
-/** Walk a block-content fragment; `contentStart` is the PM pos before its first child.
- * Two container siblings of one run shape read as a single container — contiguity plus
- * an equal path is what the store means by "the same one" — so each alternates its
- * `instance` against the sibling before it. Sibling adjacency is the whole scope: a
- * container one level in has a differing path above it, which already tells it apart. */
+/**
+ * Walk a block-content fragment; `contentStart` is the PM pos before its first child. Two container
+ * siblings of one run shape read as a single container (contiguity plus an equal path is the
+ * store's "same one"), so each alternates its `instance` against the sibling before it; a container
+ * one level in already differs in path above it.
+ */
 function scanBlocks(acc, parent, contentStart, containers) {
     let pm = contentStart;
     let prevShape = null;
@@ -55,9 +57,10 @@ function scanBlocks(acc, parent, contentStart, containers) {
         pm += child.nodeSize;
     });
 }
-/** A block's container run shape, `ordinal` and `instance` aside; null where it opens
- * no container. A list's `start` is not in it — the store welds two runs differing only
- * there. */
+/**
+ * A block's container run shape, `ordinal` and `instance` aside; null where it opens no container.
+ * A list's `start` is not in it: the store welds two runs differing only there.
+ */
 function runShape(node) {
     switch (node.type.name) {
         case 'blockquote':
@@ -145,9 +148,10 @@ function textblockKind(node) {
         return { kind: 'heading', attrs: { level: node.attrs.level } };
     return { kind: 'para' };
 }
-/** A container with its run `instance`, spelled only where it is not the zero a
- * canonical read omits: the projection is compared against such a read
- * (`lineMetaEqual`), so the two have to spell one container one way. */
+/**
+ * A container with its run `instance`, spelled only where it is not the zero a canonical read
+ * omits, so the projection and `lineMetaEqual` spell one container one way.
+ */
 function withInstance(container, instance) {
     return instance === 0 ? container : { ...container, instance };
 }
@@ -171,11 +175,9 @@ function scanInline(acc, block, contentStart, containers, kind) {
         if (child.isText) {
             const text = child.text ?? '';
             emitText(acc, text, pm, child.marks);
-            // A `\n` in a textblock that is not `whitespace: 'pre'` is the same line
-            // boundary a hard break is: `paragraph` is `inline*`, so the schema admits
-            // one, and `joinTextblocksAround` — a bare `replaceStep` running neither
-            // `clearIncompatible` nor `replaceNewlines` — leaves one. It rides the text
-            // run, where PM and USV advance together.
+            // A `\n` in a textblock that is not `whitespace: 'pre'` is the same line boundary a
+            // hard break is: `joinTextblocksAround` (a bare `replaceStep`) leaves one. It rides the
+            // text run, where PM and USV advance together.
             const breaks = text.split('\n').length - 1;
             for (let i = 0; i < breaks; i++)
                 acc.lines.push({ containers, continues: true, ...kind });
@@ -206,10 +208,8 @@ function emitText(acc, s, pmStart, marks) {
     }
 }
 /**
- * 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.
+ * Merge adjacent/overlapping same-descriptor marks into maximal ranges, by the same primitives the
+ * mark diff runs on (`groupFormatting` + `union`).
  */
 function mergeMarks(raw) {
     const out = [];
@@ -271,12 +271,10 @@ function diffText(oldText, newText) {
     return { ops };
 }
 /**
- * Whether the splice moves a line boundary — a `\n` deleted, or one inserted. Where
- * it does not, every line keeps the metadata it had and equal metadata on both sides
- * is the whole story. Where it does, the store's split/join inheritance decides what
- * each line ends up carrying, and an array that still matches position for position
- * says nothing about it: one splice that both joins a boundary and opens another
- * leaves the line count and the metadata array unchanged while the kinds slide.
+ * Whether the splice moves a line boundary (a `\n` deleted or inserted). Where it does not, equal
+ * metadata on both sides is the whole story. Where it does, the store's split/join inheritance
+ * decides what each line carries: one splice that joins a boundary and opens another leaves the
+ * line count and metadata array unchanged while the kinds slide.
  */
 function movesBoundary(oldText, delta) {
     if (!delta)
@@ -305,11 +303,8 @@ function diffLines(oldRt, newRt, delta) {
     if (!movesBoundary(oldRt.text, delta) && 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.
+    // Force every new line's metadata; redundant ops are safe no-ops. `continues` is a property of
+    // the `\n` preceding a line, so line 0 never carries it and it is 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 });
@@ -319,9 +314,10 @@ function diffLines(oldRt, newRt, delta) {
     }
     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, so an arm added upstream reaches the op by construction. */
+/**
+ * A line minus its `containers` / `continues` envelope: exactly `setKind`'s payload
+ * (`ContentLineKind`). Lifted whole, so an arm added upstream reaches the op by construction.
+ */
 function kindPart(l) {
     const { containers: _containers, continues: _continues, ...kind } = l;
     return kind;
@@ -342,28 +338,23 @@ function lineMetaEqual(a, b) {
     }
     return true;
 }
-/** A line kind's comparison key: key-order-insensitive at every depth, because the two
- * sides come from different producers (a WASM read and this scan) and a kind carries a
- * nested `attrs` bag. */
+/**
+ * A line kind's comparison key, key-order-insensitive at every depth: the sides come from different
+ * producers (a WASM read and this scan) and a kind carries a nested `attrs` bag.
+ */
 function kindKey(l) {
     return canonicalJson(kindPart(l));
 }
 /**
- * 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.
+ * Split the edit's islands off the text splice. `applyChange` throws `IslandSlotInInsert` on a
+ * `delta` that types a slot, so every slot inside the splice's inserted region is stripped from it
+ * and placed by `{ op: 'insert', at }`, which carries the backing entry. Every other island kept
+ * its slot, so a changed payload is `{ op: 'set' }` by the id both sides carry. A deleted island
+ * needs no op: the delta that removes its slot drops the entry.
  *
- * 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.
+ * `at` is the slot's position in the final text: inserts apply left to right, so by the k-th, the k
+ * slots before it are in place. An id the store does not carry emits nothing (it would throw
+ * `UnknownIslandId`); nothing mints or renames an island id, so that is unreachable.
  */
 function splitIslands(edit) {
     const { oldRt, newRt, delta } = edit;
@@ -386,8 +377,7 @@ function splitIslands(edit) {
     });
     return { delta: inserts && delta ? withoutSlots(delta) : delta, islandOps };
 }
-/** 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. */
+/** The USV positions of `text`'s island slots, in document order: the i-th is the i-th island's. */
 function slotPositions(text) {
     const out = [];
     let usv = 0;
@@ -398,9 +388,10 @@ function slotPositions(text) {
     }
     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. */
+/**
+ * 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.
+ */
 function insertedRegion(delta) {
     if (!delta)
         return { start: 0, end: 0 };
@@ -409,9 +400,10 @@ function insertedRegion(delta) {
     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. */
+/**
+ * The delta with every island slot removed from its insert, or `undefined` when only retains
+ * remain.
+ */
 function withoutSlots(delta) {
     const ops = [];
     let splices = false;
@@ -431,9 +423,10 @@ function withoutSlots(delta) {
     }
     return splices ? { ops } : undefined;
 }
-/** Formatting marks → add/remove ops; anchors → add/removeAnchor by id. A `MarkOp`'s
- * `add` / `remove` is a `ContentMark` under an op, so a descriptor spreads in whole and
- * the wire's `attrs` spelling is the one a checker admits. */
+/**
+ * Formatting marks → add/remove ops; anchors → add/removeAnchor by id. A descriptor spreads in
+ * whole, so the wire's `attrs` spelling is the one a checker admits.
+ */
 function diffMarks(oldRt, newRt, moved, opts) {
     const ops = [];
     // The store's answer for where `moved`'s text channels leave the field's marks;

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

@@ -9,9 +9,10 @@ import { 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. */
+    /**
+     * The schema the leaf reads through: the declared type decides whether a stored string is
+     * markdown or literal text.
+     */
     quill: Quill;
     addr: Addr;
     container: HTMLElement;
@@ -24,53 +25,44 @@ export interface CreateFieldOpts {
      *  `aria-describedby` while it holds. */
     heldNoteId?: string;
     /**
-     * Fired when the leaf holds or releases, and at mount when it mounts held. A one-line
-     * leaf, or a `text` one, is held over a value its schema cannot
-     * hold (`fitsLeaf`, upstream's `isInline` and `isPlain`): the decode would join lines
-     * and drop containers and islands for the first commit to store. Any leaf is held
-     * over what is read and not edited: an element, a definition list, a footnote and an
-     * equation (CODEC §Decode). A held leaf draws
-     * its content on the block schema, read-only, and commits nothing. Judged of the value
-     * each mount and re-hydrate reads, so {@link FieldController.applyExternal} is what
-     * re-evaluates it.
+     * Fired when the leaf holds or releases, and at mount when it mounts held. A one-line or `text`
+     * leaf is held over a value its schema cannot hold (`fitsLeaf`): the decode would join lines
+     * and drop containers and islands. Any leaf is held over what is read and not edited: a font
+     * family, a footnote, an equation (CODEC §Decode). A held leaf draws on the block schema,
+     * read-only, and commits nothing. Judged on each mount and re-hydrate ({@link
+     * FieldController.applyExternal}).
      */
     onHold?(held: boolean): void;
     /** 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). */
+    /**
+     * The island chrome's wording, read live so a locale swap re-renders. Absent leaves the
+     * package's English.
+     */
     tableStrings?: () => TableChromeStrings;
     /**
-     * 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.
+     * 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, so the keys never
+     * claim Enter, Escape and the arrows with nothing on screen. A constrained inline leaf never
+     * has one.
      */
     onSlash?(state: SlashState | undefined): void;
-    /** The slash surface's wording, read per decoration pass. Absent leaves the
-     *  package's English; read only beside {@link onSlash}, the hint being the menu's. */
+    /** The slash surface's wording, read per decoration pass; read only beside {@link onSlash}. */
     slashStrings?: () => SlashStrings;
-    /** 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. */
+    /**
+     * Accessible name → `aria-label` on the `contenteditable`, for a leaf nothing else names (an
+     * array element, the card body). A leaf with a field label takes `labelledBy` instead: `for`
+     * cannot reach a `contenteditable`.
+     */
     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;
     /**
-     * The resolved `default:` where it prints: the content an unset field's leaf holds,
-     * marked `data-default` on the editable for the default rung. Nothing is written
-     * until an edit, which commits the whole leaf as authored: the default taken, with
-     * the edit in it. The initial value; {@link FieldController.setFallback} moves it
-     * after mount.
+     * The resolved `default:` where it prints: the content an unset field's leaf holds, marked
+     * `data-default`. Nothing is written until an edit, which commits the whole leaf with the edit
+     * in it. Initial value; {@link FieldController.setFallback} moves it.
      */
     fallback?: Content;
     /** Ghost text shown on the empty leaf: the `none` an unset optional field prints, or
@@ -91,15 +83,10 @@ export interface CreateFieldOpts {
     /** 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`, a `text` leaf's typed write)
-     * and for an anchor mutation,
-     * which changes no text. A commit that failed outright (`commit-lost`) does not
-     * fire it: nothing landed.
+     * Fired after an edit committed to the document: the leaf's change signal. Unlike `onCaretMove`
+     * it does not fire on a bare selection move. Fires for every commit branch and for an anchor
+     * mutation (which changes no text); a commit that failed outright (`commit-lost`) does not fire
+     * it.
      */
     onChange?(addr: Addr): void;
     /** Recovered failures on the commit path ({@link EditorErrorHandler}). */
@@ -116,12 +103,9 @@ export interface FieldController {
      *  re-evaluate its hold against the value now stored. */
     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.
+     * Move the empty-leaf ghost after mount (a card retyped to another kind takes its new wording;
+     * a remount would cost the caret). Refreshes the decoration without a transaction, which would
+     * fire `onCaretMove` with no caret move.
      */
     setPlaceholder(text: string | undefined): void;
     /** Move the default an unset leaf holds after mount: a retype or a quill swap
@@ -131,11 +115,9 @@ export interface FieldController {
     /** 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.
+     * Insert an identity anchor `id` at USV `pos`. Zero-width; it folds into the plugin's position
+     * set and commits through the mark-diff `anchor` op. The id is caller-supplied and must be
+     * unique and invariant; 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. */
@@ -143,9 +125,8 @@ export interface FieldController {
     /** 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 the command `name`: 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.
+     * Move the slash menu's cursor onto the command `name` (a pointer entering an item): the
+     * keyboard cursor and the pointer highlight are one state.
      */
     slashFocus(name: string): void;
     /** Run the command `name` (a click on its item): the same path Enter takes. A no-op
@@ -159,13 +140,11 @@ export interface FieldController {
     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.
+ * The ProseMirror handles a chrome surface reaches a mounted leaf through; not part of {@link
+ * FieldController}. The format popover needs both: `view` names the leaf's own document,
+ * `focusedView` acts wherever the caret is, which inside a table island is a nested cell view
+ * (`table-view.ts`). Their differing is what tells the popover to withhold its `anchor` button: a
+ * cell is not in the field's coordinate space.
  */
 export interface LeafViews {
     view: EditorView;
@@ -173,17 +152,15 @@ export interface LeafViews {
     /** Every view nested inside this leaf, in mount order: one per table cell. */
     nestedViews(): EditorView[];
 }
-/** The canonical empty `Content`: one empty `para` line. The empty a prose
- * leaf (or an array's prose element) seeds from. */
+/** The canonical empty `Content`: one empty `para` line. */
 export declare function emptyContent(): Content;
 /** Whether `rt` is the empty leaf: {@link emptyContent}, nothing typed and no shape left. */
 export declare function isEmptyContent(rt: Content): boolean;
-/** The naming attributes for the `contenteditable`, shared by every prose leaf
- * (`ProseValue` takes it too, so an addressed leaf and a by-value one name their
- * regions by one rule). `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. */
+/**
+ * The naming attributes for the `contenteditable`, shared with `ProseValue`. `aria-labelledby`
+ * supersedes `aria-label`, and `undefined` is returned whole when a leaf takes neither, since
+ * ProseMirror reads the absence.
+ */
 export declare function proseAttributes(opts: {
     label?: string;
     labelledBy?: string;
@@ -198,36 +175,26 @@ export declare function heldAttributes(opts: {
 }, noteId: string | undefined): Record<string, string>;
 export declare function createField(opts: CreateFieldOpts): FieldController;
 /**
- * The prose-leaf plugin stack (VISUAL_EDITOR §Surface): shared by
- * {@link createField} and the by-value editor (`ProseValue`), so the two
- * never fork the keymap/plugin ordering. History first, with the plugin that starts an
- * undo step at each block-moving edit (`undo.ts`), then any leaf-specific
- * plugins (`afterHistory`: the addressed leaf passes its anchor-position plugin;
- * a by-value leaf passes none), then {@link linebreakPlugin}, which normalizes what
- * the rest of the stack leaves, then the markdown-shorthand input rules and the
- * Backspace that takes one back, the field keymap over the base keymap, the URL paste
- * that links a selection (`link-paste.ts`), and last the ones that answer to a block
- * leaf's own shapes: the gap cursor, {@link pastAtomPlugin}, the island paste pass
- * (`islands.ts`), the table paste (`table-paste.ts`), the markdown paste
- * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`). A one-line leaf's
- * paste joins its lines (`line-paste.ts`).
+ * The prose-leaf plugin stack (VISUAL_EDITOR §Surface), shared by {@link createField} and
+ * `ProseValue` so the two never fork the plugin ordering. History first with the step-splitting
+ * plugin (`undo.ts`), then `afterHistory` plugins (the addressed leaf's anchor plugin), {@link
+ * linebreakPlugin}, the markdown-shorthand input rules and their Backspace, the field keymap over
+ * the base keymap, the URL paste that links a selection (`link-paste.ts`), and last the block
+ * leaf's own shapes: the gap cursor, {@link pastAtomPlugin}, the island paste (`islands.ts`), table
+ * paste (`table-paste.ts`), markdown paste (`markdown-paste.ts`) and the task checkbox
+ * (`tasks.ts`). A one-line leaf's paste joins its lines (`line-paste.ts`).
  *
- * Every mark-shaped plugin reads the schema rather than a flag: over either mark-free
- * schema the shorthand rules build nothing (each is guarded on its mark type), the
- * toggles bind no key and a pasted URL stays text, so a `**bold**` keeps the delimiters
- * its author typed without a second rule saying so.
+ * Mark-shaped plugins read the schema rather than a flag: over a mark-free schema the shorthand
+ * rules build nothing, the toggles bind no key and a pasted URL stays text.
  */
 export declare function proseLeafPlugins(schema: Schema, opts: {
     inline: boolean;
-    /** The slash menu's report channel; absent mounts no menu and leaves
-     *  Enter/Escape/the arrows to the links below (`keymap.ts`). */
+    /** The slash menu's report channel; absent mounts no menu (`keymap.ts`). */
     slash?: (state: SlashState | undefined) => void;
     /** The empty line's hint, read live; drawn only beside `slash`. */
     slashHint?: () => string | undefined;
     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. */
+    /** Read live: the ghost can move after mount and a re-hydration rebuilds this stack. */
     placeholder?: () => string | undefined;
     /** {@link CreateFieldOpts.placeholderUntilEdit}. */
     placeholderUntilEdit?: boolean;