@quillmark/svelte 0.12.0 → 0.14.0

package/dist/core/codec/field.js

@@ -5,30 +5,32 @@
 //   (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)`,
+//   (c) commit via `doc.applyChange(addr, bundle)`, or a `plaintext` leaf's whole
+//       text through the typed writer,
 //   (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`.
+// by `reconcile` except where the hold it re-evaluates flips.
 import { baseKeymap, toggleMark } from 'prosemirror-commands';
 import { gapCursor } from 'prosemirror-gapcursor';
 import { history, redo, undo } from 'prosemirror-history';
 import { keymap } from 'prosemirror-keymap';
+import { Fragment, Slice } from 'prosemirror-model';
 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 { decode, fitsLeaf } from './decode.js';
 import { usvToPM, pmToUsv, buildLineIndex, lineIndexOf } from './positions.js';
 import { lower, pmToContent, scanContent, scanDoc, contentEdit } from './encode.js';
 import { islandPastePlugin } from './islands.js';
 import { anchorsFromContent } from './marks.js';
-import { createReconciler } from './reconcile.js';
+import { contentEqual, createReconciler } from './reconcile.js';
 import { inputRulesPlugin } from './inputrules.js';
 import { linebreakPlugin } from './breaks.js';
 import { bodyKeymap } from './keymap.js';
-import { blockSchema, inlineSchema, plaintextSchema } from './schema.js';
+import { blockSchema, isBlockSchema, leafSchema, plainSchema } from './schema.js';
 import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
 import { focusSlashItem, runSlashItem, slashPlugin } from './slash.js';
 const anchorKey = new PluginKey('quill-anchors');
@@ -84,13 +86,10 @@ export function emptyContent() {
  * `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`. */
+ * a default-only richtext field before its first edit) has nothing to splice, and an
+ * authored string nothing to lose: content-only marks do not survive markdown, so a
+ * string carries no anchors to pay. A body always rests as `Content`. A `plaintext`
+ * leaf never asks: it commits through the writer ({@link createField}). */
 function opsCommittable(doc, addr) {
     const stored = doc.getStored(addr);
     return stored !== null && typeof stored === 'object';
@@ -111,25 +110,46 @@ export function proseAttributes(opts) {
         attrs['aria-describedby'] = opts.describedBy;
     return Object.keys(attrs).length ? attrs : undefined;
 }
+/** A held leaf's attributes, described by its note as well. A non-editable view is no
+ *  textbox to assistive tech or to Tab, so a held leaf states both itself. */
+export function heldAttributes(opts, noteId) {
+    const describedBy = [opts.describedBy, noteId].filter(Boolean).join(' ') || undefined;
+    return {
+        ...proseAttributes({ ...opts, describedBy }),
+        role: 'textbox',
+        'aria-readonly': 'true',
+        'aria-multiline': 'true',
+        tabindex: '0'
+    };
+}
 export function createField(opts) {
     const { doc, addr, container } = opts;
-    const inline = !!opts.inline || !!opts.plaintext;
+    const inline = !!opts.inline;
     const plaintext = !!opts.plaintext;
     // The declared type picks the schema, and the schema is the whole of what
     // `plaintext` suppresses: no mark types to toggle, to paste in, or to mint a
     // shorthand with (`schema.ts`).
-    const schema = plaintext ? plaintextSchema : inline ? inlineSchema : blockSchema;
+    const schema = leafSchema({ plaintext, inline });
+    const block = isBlockSchema(schema);
     // 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
+    const writer = opts.quill.writer(doc);
+    let fallback = opts.fallback;
+    /** What the leaf holds: the stored content, else the default an unset field shows. */
+    const shown = () => reader.getContent(addr) ?? fallback ?? emptyContent();
+    /** Whether the leaf holds a default nobody has written: the `data-default` mark. */
+    const unwritten = () => !!fallback && doc.getStored(addr) == null;
+    let defaulted = unwritten();
+    // `known` is the codec's view of what the leaf holds: 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));
+    const reconciler = createReconciler(shown());
     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.
+    // The ghosts' live cells: the ghost plugin reads them per pass, so moving one is
+    // an assignment plus a re-render rather than a rebuilt plugin stack.
     let placeholderText = opts.placeholder;
+    let exampleText = opts.example;
     // 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
@@ -137,7 +157,15 @@ export function createField(opts) {
     const nested = new Set();
     // The menu's report channel, and the whole of what a leaf holds of it: the
     // vocabulary is the codec's own constant (`slash.ts`), not a wording to derive.
-    const slash = inline ? undefined : opts.onSlash;
+    const slash = block ? opts.onSlash : undefined;
+    // Judged of the value being mounted rather than read off a diagnostic: a routed set
+    // can predate the value it arrives with, and `validation::not_plain` stands in for
+    // `not_inline` on a `plaintext(inline)` field.
+    const holds = (rt) => !fitsLeaf(rt, { inline, plaintext });
+    let held = holds(reconciler.last);
+    const named = proseAttributes(opts) ?? {};
+    const defaultNamed = { ...named, 'data-default': '' };
+    const heldNamed = heldAttributes(opts, opts.heldNoteId);
     const seeded = buildState(reconciler.last);
     const state = seeded.state;
     index = seeded.index;
@@ -150,17 +178,19 @@ export function createField(opts) {
     // where `check:style` cannot read it.
     const lineBox = Number.parseFloat(getComputedStyle(container).lineHeight);
     const clearance = Number.isFinite(lineBox) ? lineBox : undefined;
-    view = new EditorView(container, {
+    // Prepended, so what the caller draws inside `container` (a held leaf's note)
+    // follows the text it is about.
+    view = new EditorView((dom) => container.prepend(dom), {
         state,
-        attributes: proseAttributes(opts),
+        editable: () => !held,
+        attributes: () => (held ? heldNamed : defaulted ? defaultNamed : named),
         // Both terms, one line each: when a flagged dispatch moves the scrollport
         // (`scrollThreshold`) and what it leaves at the edge (`scrollMargin`).
         scrollThreshold: clearance,
         scrollMargin: clearance,
-        // Islands are block-schema only, so an inline leaf mounts no node view at all.
-        nodeViews: inline
-            ? undefined
-            : {
+        // Islands are block-schema only, so any other leaf mounts no node view at all.
+        nodeViews: block
+            ? {
                 island_block: tableNodeView({
                     strings: opts.tableStrings ?? (() => DEFAULT_TABLE_STRINGS),
                     register: (cellView) => {
@@ -173,10 +203,15 @@ export function createField(opts) {
                     onCellFocus: () => opts.onFocus?.(addr),
                     clearance
                 })
-            },
+            }
+            : undefined,
         dispatchTransaction: (tr) => {
             const oldRt = reconciler.last;
             const next = view.state.apply(tr);
+            // An edit takes a held default: the commit below writes the whole leaf, so the
+            // mark goes in the same update that draws the edit.
+            if (!held && (tr.docChanged || tr.getMeta(anchorKey)))
+                defaulted = false;
             view.updateState(next); // (a) optimistic
             // One walk per structural change: the index and the projection the commit
             // diffs both come off it. A selection-only transaction leaves the document
@@ -187,7 +222,7 @@ export function createField(opts) {
             // 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)) {
+            if (!held && (tr.docChanged || tr.getMeta(anchorKey))) {
                 // (d) the change signal, only for what actually landed.
                 const newRt = scan ? scanContent(scan) : pmToContent(next.doc);
                 if (commitEdit(oldRt, newRt))
@@ -209,6 +244,13 @@ export function createField(opts) {
     /** The state, and the index over the document it was built from: the seed reads one
      *  and every caller wants the same one, and `buildLineIndex` is a whole walk. */
     function buildState(rt) {
+        if (held) {
+            const pmDoc = decode(rt, blockSchema);
+            return {
+                state: EditorState.create({ doc: pmDoc }),
+                index: buildLineIndex(pmDoc)
+            };
+        }
         const pmDoc = decode(rt, schema);
         const anchors = plaintext ? [] : anchorsFromContent(rt);
         // Seed anchor plugin positions in PM coords via a fresh index over pmDoc.
@@ -226,6 +268,8 @@ export function createField(opts) {
                 // 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,
+                placeholderUntilEdit: opts.placeholderUntilEdit,
+                example: () => exampleText,
                 afterHistory: [anchorPlugin(seededAnchors)]
             })
         });
@@ -236,14 +280,16 @@ export function createField(opts) {
     // Returns whether anything landed: the caller's change signal, which must not
     // be a property of which branch the commit took.
     function commitEdit(oldRt, newRt) {
+        if (plaintext)
+            return commitPlain(newRt.text);
         // The text splice, computed once per keystroke: the gate below, both overwrite
         // fallbacks, and `lower` all read this one `edit`. The projection is the
         // caller's, off the same walk that rebuilt the index.
         const edit = contentEdit(oldRt, newRt);
         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.
+            // `applyChange` throws on an absent declared field (verified), and neither an
+            // absent field nor an authored string has anchors to lose (`opsCommittable`).
             // Every structural edit lowers, island creation included: the island channel
             // places a slot the `delta` may not carry.
             if (!opsCommittable(doc, addr)) {
@@ -252,8 +298,7 @@ export function createField(opts) {
             else {
                 // Post-edit anchors are the plugin's positions (mapped through the tr) as
                 // USV; the pre-edit set is `oldRt`'s own, which `lower` reads for itself.
-                const newAnchors = plaintext ? [] : readAnchorsUsv();
-                doc.applyChange(addr, lower(edit, { newAnchors }));
+                doc.applyChange(addr, lower(edit, { newAnchors: readAnchorsUsv() }));
             }
             reconciler.commit(readLeaf(reader, addr));
             return true;
@@ -287,6 +332,35 @@ export function createField(opts) {
             }
         }
     }
+    /**
+     * A `plaintext` leaf's commit: its whole text through the typed writer, which rests
+     * the field as that literal string (CODEC §Inline mode). A content object is the
+     * other rest form, and `toMarkdown` emits one as markdown: a break spelled as a
+     * backslash, a `*` and a trailing space escaped, a blank line doubled, so the value
+     * reads back changed. The leaf carries no anchors, so the op path has none to keep.
+     *
+     * A refusal lands nothing and has no fallback, the other rest form being the
+     * corruption; the next edit writes the whole text again.
+     */
+    function commitPlain(text) {
+        try {
+            const name = addr.field;
+            if (name === undefined)
+                throw new Error('a plaintext leaf names a field');
+            (addr.card === undefined ? writer : writer.card(addr.card)).set(name, text);
+            reconciler.commit(readLeaf(reader, addr));
+            return true;
+        }
+        catch (e) {
+            reportError(opts.onError, {
+                code: 'commit-lost',
+                severity: 'error',
+                message: `the typed writer refused the text; the stored value is stale while the editor keeps the edit: ${errorMessage(e)}`,
+                cause: e
+            });
+            return false;
+        }
+    }
     /** The anchors the plugin currently holds (PM coords); `[]` before the first apply. */
     const heldAnchors = () => anchorKey.getState(view.state) ?? [];
     /** The plugin's anchor positions as USV, against `index` — which `dispatchTransaction`
@@ -313,17 +387,28 @@ export function createField(opts) {
             view.dispatch(view.state.tr.setSelection(sel).scrollIntoView());
         },
         applyExternal() {
-            const current = readLeaf(reader, addr);
-            if (!reconciler.shouldRehydrate(current))
-                return; // own edit / no change
+            const current = shown();
+            const flipped = holds(current) !== held;
+            const wasDefaulted = defaulted;
+            defaulted = unwritten();
+            if (!flipped && !reconciler.shouldRehydrate(current)) {
+                // Own edit / no change; a default written as itself changes the mark alone.
+                if (defaulted !== wasDefaulted)
+                    view.setProps({});
+                return;
+            }
+            if (flipped)
+                held = !held;
             const caretUsv = pmToUsv(index, view.state.selection.head);
             const fresh = buildState(current);
-            view.updateState(fresh.state);
             index = fresh.index;
-            // 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.state.doc.resolve(pm))));
+            // Best-effort caret continuity across an external change: keep the USV. Set
+            // rather than dispatched, so a leaf the caret is not in reports no caret move.
+            const sel = Selection.near(fresh.state.doc.resolve(usvToPM(index, caretUsv)));
+            view.updateState(fresh.state.apply(fresh.state.tr.setSelection(sel)));
             reconciler.commit(current);
+            if (flipped)
+                opts.onHold?.(held);
         },
         setPlaceholder(text) {
             if (text === placeholderText)
@@ -333,6 +418,18 @@ export function createField(opts) {
             // transaction, so nothing commits and no caret is reported.
             view.setProps({});
         },
+        setExample(text) {
+            if (text === exampleText)
+                return;
+            exampleText = text;
+            view.setProps({});
+        },
+        setFallback(content) {
+            if (content === fallback || (content && fallback && contentEqual(content, fallback)))
+                return;
+            fallback = content;
+            controller.applyExternal();
+        },
         focus() {
             view.focus();
             // The placement rung's reveal: no caret to flag a transaction with, so the
@@ -344,8 +441,9 @@ export function createField(opts) {
             return readLeaf(reader, addr);
         },
         insertAnchor(id, pos) {
-            if (plaintext)
-                return; // a plaintext field carries no marks (§Inline mode)
+            // A plaintext field carries no marks (§Inline mode), and a held one commits nothing.
+            if (plaintext || held)
+                return;
             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
@@ -401,11 +499,13 @@ export function createField(opts) {
                 return cellView;
         return view;
     };
+    if (held)
+        opts.onHold?.(true);
     return controller;
 }
 /**
  * The prose-leaf plugin stack (VISUAL_EDITOR §Surface): shared by
- * {@link createField} and the by-value inline editor (`ProseValue`), so the two
+ * {@link createField} and the by-value editor (`ProseValue`), 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 leaf passes none), then {@link linebreakPlugin}, which normalizes what
@@ -414,10 +514,10 @@ export function createField(opts) {
  * shapes: the gap cursor, {@link pastAtomPlugin}, and the island paste pass
  * (`islands.ts`).
  *
- * Every mark-shaped plugin reads the schema rather than a flag: over
- * `plaintextSchema` the shorthand rules build nothing (each is guarded on its mark
- * type) and the toggles bind no key, so a `**bold**` keeps the delimiters its author
- * typed without a second rule saying so.
+ * Every mark-shaped plugin reads the schema rather than a flag: over either plaintext
+ * schema the shorthand rules build nothing (each is guarded on its mark type) and the
+ * toggles bind no key, so a `**bold**` keeps the delimiters its author typed without
+ * a second rule saying so.
  */
 export function proseLeafPlugins(schema, opts) {
     const list = [history(), ...(opts.afterHistory ?? []), linebreakPlugin(schema)];
@@ -427,14 +527,33 @@ export function proseLeafPlugins(schema, opts) {
         list.push(inputRulesPlugin(schema));
     list.push(keymap(editorKeymap(schema, opts.inline, !!opts.slash)));
     list.push(keymap(baseKeymap));
-    // All three answer to something 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)
+    // All three answer to something only the block schema holds: any other leaf is
+    // textblocks alone, with no island and no gap to put a cursor in.
+    if (isBlockSchema(schema))
         list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin());
-    if (opts.placeholder)
-        list.push(placeholderPlugin(opts.placeholder));
+    if (schema === plainSchema)
+        list.push(plainClipboardPlugin());
+    if (opts.placeholder || opts.example)
+        list.push(ghostPlugin(opts));
     return list;
 }
+/**
+ * A plain leaf's clipboard text is literal, one line per `\n` both ways. Upstream's
+ * defaults read pasted text as blocks split on any run of newlines, which drops a
+ * blank line the value holds as content, and write a copy's blocks joined by a blank
+ * line and its breaks as nothing.
+ */
+function plainClipboardPlugin() {
+    const { paragraph } = plainSchema.nodes;
+    return new Plugin({
+        props: {
+            clipboardTextParser: (text) => new Slice(Fragment.from(text
+                .split(/\r\n?|\n/)
+                .map((line) => paragraph.create(null, line ? plainSchema.text(line) : null))), 1, 1),
+            clipboardTextSerializer: (slice) => slice.content.textBetween(0, slice.content.size, '\n', '\n')
+        }
+    });
+}
 /**
  * A printable key over a selected atom writes past it. A selection is the subject
  * of the next command, never a thing armed for
@@ -471,33 +590,50 @@ function pastAtomPlugin() {
     });
 }
 /**
- * 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
+ * The empty leaf's ghosts. A node decoration stamps the sole empty textblock with a
+ * class and the ghost text, which `prose.css` draws from the attributes: so the text
+ * never enters the document, the caret path, or a `pmToContent` export, and 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.
+ * `data-placeholder` is drawn at rest, and `data-example` where there is none, and in
+ * its stead while the view holds the focus. The example is stamped only until the
+ * state's first edit, after which the leaf has been answered, and so is a placeholder
+ * under `placeholderUntilEdit`. An inline leaf's
+ * ghost keeps to the one line the leaf is (`qm-prose-placeholder-line`).
+ *
+ * The texts are read per decoration pass rather than closed over, so moving a ghost is
+ * a re-render and never a document edit.
  */
-function placeholderPlugin(read) {
+function ghostPlugin(opts) {
+    const key = new PluginKey('qm-ghost');
     return new Plugin({
+        key,
+        state: {
+            init: () => false,
+            apply: (tr, edited) => edited || tr.docChanged
+        },
         props: {
             decorations(state) {
-                const text = read();
-                if (!text)
+                const edited = key.getState(state);
+                const text = edited && opts.placeholderUntilEdit ? undefined : opts.placeholder?.();
+                const example = edited ? undefined : opts.example?.();
+                if (!text && !example)
                     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
-                    })
-                ]);
+                const attrs = {
+                    class: opts.inline
+                        ? 'qm-prose-placeholder qm-prose-placeholder-line'
+                        : 'qm-prose-placeholder'
+                };
+                if (text)
+                    attrs['data-placeholder'] = text;
+                if (example)
+                    attrs['data-example'] = example;
+                return DecorationSet.create(doc, [Decoration.node(0, first.nodeSize, attrs)]);
             }
         }
     });

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

@@ -3,15 +3,15 @@ import 'prosemirror-gapcursor/style/gapcursor.css';
 import './prose.css';
 export { rangeAnchor } from './anchor.js';
 export type { RangeAnchor } from './anchor.js';
-export { createField, emptyContent, proseAttributes, proseLeafPlugins } from './field.js';
+export { createField, emptyContent, heldAttributes, proseAttributes, 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, plaintextSchema, hasMarks } from './schema.js';
+export { blockSchema, inlineSchema, plaintextSchema, plainSchema, leafSchema, hasMarks } from './schema.js';
 export { rendersHref, storableUrl } from './urls.js';
-export { decode, renderContent, usvLength } from './decode.js';
+export { decode, fitsInline, fitsLeaf, fitsPlain, 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';

package/dist/core/codec/index.js

@@ -13,7 +13,7 @@ import './prose.css';
 // selection (`visual/FormatPopover.svelte`), so it is reached off-barrel.
 export { rangeAnchor } from './anchor.js';
 // The prose leaf.
-export { createField, emptyContent, proseAttributes, proseLeafPlugins } from './field.js';
+export { createField, emptyContent, heldAttributes, proseAttributes, 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';
@@ -22,7 +22,7 @@ export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 export { DEFAULT_SLASH_STRINGS } from './slash.js';
 // Schemas (the decode/encode target; the VisualEditor mounts them). `hasMarks` is
 // what a mark surface asks before offering itself over a leaf.
-export { blockSchema, inlineSchema, plaintextSchema, hasMarks } from './schema.js';
+export { blockSchema, inlineSchema, plaintextSchema, plainSchema, leafSchema, hasMarks } from './schema.js';
 // The url edge: `rendersHref` is the link gate the prompt re-asks on submit, and
 // `storableUrl` the encode the store's own refusal requires of the value it takes
 // (`visual/links.ts`).
@@ -32,7 +32,7 @@ export { rendersHref, storableUrl } from './urls.js';
 // The barrel carries what has an off-barrel caller, and nothing else. A symbol
 // reached only by relative import within `codec/` stays off it: an export nothing
 // imports is surface that still has to stay honest.
-export { decode, renderContent, usvLength } from './decode.js';
+export { decode, fitsInline, fitsLeaf, fitsPlain, renderContent, usvLength } from './decode.js';
 export { pmToContent, contentEdit, lower } from './encode.js';
 export { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 // Reconciliation gate.

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

@@ -1,9 +1,10 @@
 import type { Schema } from 'prosemirror-model';
 import type { Command } from 'prosemirror-state';
-/** 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.
+/** A multi-block leaf's structural keys, each link binding only what its schema
+ * declares: over `plainSchema`, which holds neither lists nor code blocks nor islands,
+ * the block link and the break link alone. 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 (`slash`), because Enter

package/dist/core/codec/keymap.js

@@ -17,10 +17,11 @@ function chainKeymaps(...maps) {
     }
     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.
+/** A multi-block leaf's structural keys, each link binding only what its schema
+ * declares: over `plainSchema`, which holds neither lists nor code blocks nor islands,
+ * the block link and the break link alone. 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 (`slash`), because Enter

package/dist/core/codec/prose.css

@@ -71,6 +71,14 @@ li.ProseMirror-selectednode::after {
 	margin-top: var(--_qm-space-3);
 }
 
+/* A plain leaf's paragraph is a line of literal text (`schema.ts` §`plainSchema`), and
+   a boundary between two stores the one `\n` a hard break does. So no rhythm: a gap
+   would draw a blank line the value does not hold, and the two spellings of one string
+   would read apart. */
+.ProseMirror > [data-qm-line] + [data-qm-line] {
+	margin-top: 0;
+}
+
 /* A blockquote's UA indent was its only mark, and the reset above takes it. The rule
    and the inset carry it instead: the same hairline every surface reads, so a quote
    reads as set apart without a fill or a second box. */
@@ -187,6 +195,40 @@ li.ProseMirror-selectednode::after {
 	font-weight: var(--_qm-weight-strong);
 }
 
+/* The empty leaf's ghost (`field.ts`, `ghostPlugin`): a node decoration's data
+   attributes, so the text stays out of the document. At the rung every control's
+   placeholder takes; the italic is what a leaf with no written neighbour has instead
+   of the step to `ink`.
+
+   After the empty line rather than before it, and pulled up one line box onto it: the
+   caret keeps the start of that line, and a ghost's lines past the first grow the
+   leaf rather than hang over what follows it. A block leaf's ghost wraps and keeps the
+   breaks it was written with, a `body.example` being a document's worth; an inline
+   leaf's keeps to the one line the leaf is. The example is drawn at rest where there
+   is no placeholder, and stands in for the placeholder while the leaf holds the focus.
+
+   Drawn only where there is text to draw: an empty box pulled up a line would take
+   the empty line with it. */
+.ProseMirror .qm-prose-placeholder[data-placeholder]::after,
+.ProseMirror .qm-prose-placeholder[data-example]::after {
+	content: attr(data-placeholder);
+	display: block;
+	margin-top: -1lh;
+	white-space: pre-line;
+	color: var(--_qm-ink-label);
+	font-style: italic;
+	pointer-events: none;
+}
+.ProseMirror .qm-prose-placeholder[data-example]:not([data-placeholder])::after,
+.ProseMirror-focused .qm-prose-placeholder[data-example]::after {
+	content: attr(data-example);
+}
+.ProseMirror .qm-prose-placeholder.qm-prose-placeholder-line::after {
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+
 /* ── The table island ────────────────────────────────────────────────────────
 
    The one construct in this file with chrome in it. The rest of the stylesheet

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

@@ -7,8 +7,8 @@ export declare const blockSchema: Schema<string, string>;
  *  a table cell, which is the same content unit). */
 export declare const inlineSchema: Schema<string, string>;
 /**
- * The inline schema with no mark types at all: a `plaintext` field, whose value is
- * literal text the boundary refuses to coerce back once it carries a mark.
+ * The inline schema with no mark types at all: a `plaintext(inline)` field, whose
+ * value is literal text the boundary refuses to coerce back once it carries a mark.
  *
  * Declaring none is what makes that structural rather than a rule each path
  * restates: `toggleMark` has no type to apply, the mark input rules build nothing,
@@ -16,11 +16,30 @@ export declare const inlineSchema: Schema<string, string>;
  * carrying (CODEC §Inline mode).
  */
 export declare const plaintextSchema: Schema<string, never>;
-/** Whether `schema` can carry formatting at all: false for {@link plaintextSchema}
- *  alone. What a mark command asks before it offers itself. */
+/**
+ * A `plaintext` field without `inline`: paragraphs and hard breaks, no marks, no
+ * islands, no containers, which is the shape `Content::is_plain` admits. Mark-free
+ * for the reason {@link plaintextSchema} is.
+ *
+ * A paragraph and a break both store one `\n`, so a paragraph here is a line and
+ * says so (`data-qm-line`): `prose.css` draws a run of them at the leading, and a
+ * boundary reads as the one line down that a break does.
+ */
+export declare const plainSchema: Schema<"text" | "doc" | "paragraph" | "hard_break", never>;
+/** The schema a leaf of the declared type mounts: `inline` narrows either type to one
+ *  textblock, and `plaintext` takes its marks away. */
+export declare function leafSchema(opts: {
+    plaintext?: boolean;
+    inline?: boolean;
+}): Schema;
+/** Whether `schema` can carry formatting at all: false for the two plaintext schemas.
+ *  What a mark command asks before it offers itself. */
 export declare function hasMarks(schema: Schema): boolean;
-/** True for the constrained inline schema (no block containers); decode branches on it. */
+/** True for the one-line schemas, which declare no `hard_break`; decode branches on it. */
 export declare function isInlineSchema(schema: Schema): boolean;
+/** True for {@link blockSchema}, the one holding blocks past the paragraph: what a
+ *  leaf's island, gap-cursor and slash machinery mounts on. */
+export declare function isBlockSchema(schema: Schema): boolean;
 /** Whether `type` can hold a within-block line break, which a heading cannot (§`heading`).
  *  What a `\n` landing in a textblock is rewritten to turns on it (`breaks.ts`), and so
  *  does what decode puts between a block's continued segments. */