@quillmark/svelte 0.21.0 → 0.23.0

package/NOTICE

@@ -6,14 +6,13 @@ Copyright 2026 Nibs
 This package contains SVG glyph geometry derived from Lucide, carried in source
 rather than installed.
 
-`visual/icons/nodes.ts` holds nineteen verbatim from @lucide/svelte 1.28.0:
+`visual/icons/nodes.ts` holds eighteen verbatim from @lucide/svelte 1.28.0:
 chevron-right, arrow-right, chevron-down, chevron-up, bold, italic, underline,
-strikethrough, code, link, hash, info, plus, x, trash-2, minus, check, calendar
-and calendar-check.
+strikethrough, code, link, info, plus, x, trash-2, minus, check, calendar and
+calendar-check.
 
 `core/codec/table-view.ts` holds grip-horizontal, grip-vertical, align-left,
-align-center, align-right, align-start-horizontal, align-center-horizontal,
-align-end-horizontal and panel-top, derived from an earlier release of the same
+align-center, align-right and panel-top, derived from an earlier release of the same
 project.
 
 ISC License
@@ -34,8 +33,8 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 --------------------------------------------------------------------------------
 
-Thirteen of those glyphs — arrow-right, chevron-down, chevron-right, chevron-up,
-code, hash, info, italic, link, minus, plus, trash-2 and x — are drawn exactly as
+Twelve of those glyphs — arrow-right, chevron-down, chevron-right, chevron-up,
+code, info, italic, link, minus, plus, trash-2 and x — are drawn exactly as
 the Feather project draws them and carry its license as well.
 
 The MIT License (MIT)

package/README.md

@@ -149,7 +149,7 @@ Hand it a different `doc` and the editor **re-keys itself**: every leaf remounts
 
 ### Wording
 
-The package ships English and a seam to replace it. `strings` is keyed and **partial**: set what you have translations for, and the rest stay the package's. Several keys are **accessible names** rather than decoration (the card controls, the add trigger, the required marker), so an untranslated surface reads the wrong language to a screen reader. `DEFAULT_VISUAL_STRINGS` is the English, exported so you can compose against it. `<Preview>` takes its own three-key `strings` for the states it shows when there is nothing to paint.
+The package ships English and a seam to replace it. `strings` is keyed and **partial**: set what you have translations for, and the rest stay the package's. Several keys are **accessible names** rather than decoration (the card controls, the add trigger), so an untranslated surface reads the wrong language to a screen reader. `DEFAULT_VISUAL_STRINGS` is the English, exported so you can compose against it. `<Preview>` takes its own three-key `strings` for the states it shows when there is nothing to paint.
 
 ```svelte
 <VisualEditor

package/dist/core/address.d.ts

@@ -50,10 +50,15 @@ export interface Landing {
  * - `{card: i}` → `"cards.<kind>[i].body"`
  * - `{card: i, field}` → `"cards.<kind>[i].<field>"`
  *
+ * `steps` descend from the field to a leaf inside it, the inverse of
+ * {@link nestedAddrForFieldPath}: `{field: 'contact'}` with `['email']` is
+ * `"main.contact.email"`, `{field: 'keywords'}` with `[0]` is `"main.keywords[0]"`. A body
+ * holds no cells, so a field-less address with steps is `undefined`.
+ *
  * `cards[i]` stands in for an unknown or blank kind. The index is the addr's own: no
  * per-kind counting, since `DocPath` addresses cards by document-array index.
  */
-export declare function fieldPathForAddr(addr: Addr, kinds: readonly string[]): DocPath | undefined;
+export declare function fieldPathForAddr(addr: Addr, kinds: readonly string[], steps?: readonly PathStep[]): DocPath | undefined;
 /**
  * A card's own path (`cards.<kind>[i]`), not a leaf's: what a structure op names,
  * where the change is the card rather than anything inside it. `undefined` for an

package/dist/core/address.js

@@ -15,15 +15,24 @@ import { core } from './lifecycle.js';
  * - `{card: i}` → `"cards.<kind>[i].body"`
  * - `{card: i, field}` → `"cards.<kind>[i].<field>"`
  *
+ * `steps` descend from the field to a leaf inside it, the inverse of
+ * {@link nestedAddrForFieldPath}: `{field: 'contact'}` with `['email']` is
+ * `"main.contact.email"`, `{field: 'keywords'}` with `[0]` is `"main.keywords[0]"`. A body
+ * holds no cells, so a field-less address with steps is `undefined`.
+ *
  * `cards[i]` stands in for an unknown or blank kind. The index is the addr's own: no
  * per-kind counting, since `DocPath` addresses cards by document-array index.
  */
-export function fieldPathForAddr(addr, kinds) {
+export function fieldPathForAddr(addr, kinds, steps = []) {
     const head = cardHead(addr.card, kinds);
     if (!head)
         return undefined;
-    const tail = addr.field != null ? { seg: 'field', name: addr.field } : { seg: 'body' };
-    return core().formatDocPath([head, tail]);
+    if (addr.field == null)
+        return steps.length ? undefined : core().formatDocPath([head, { seg: 'body' }]);
+    const segs = [head, { seg: 'field', name: addr.field }];
+    for (const step of steps)
+        segs.push(typeof step === 'number' ? { seg: 'index', index: step } : { seg: 'field', name: step });
+    return core().formatDocPath(segs);
 }
 /**
  * A card's own path (`cards.<kind>[i]`), not a leaf's: what a structure op names,

package/dist/core/bloom.d.ts

@@ -1,8 +1,13 @@
 /**
- * Bloom over `host`'s content: an inset child, so the wash neither tints the host's
- * own background nor fades the text under it. `host` must be positioned.
+ * Run one wash over `host`, a `.qm-wash` box, resolving the dwell off its root so the
+ * number is single-sourced in CSS (`core/rungs.ts`).
  *
- * One wash node per host, reused while it lives: two quick landings on the same leaf
+ * One property, both motion preferences: `--_qm-bloom-dwell` already shortens under
+ * `prefers-reduced-motion` in the derivation, so what is left to `matchMedia` here is
+ * the shape: a hold and a cut carry no ramps, which is a frame list rather than a
+ * number and the one half CSS cannot hand over.
+ *
+ * A run in flight on the same host is cancelled first: two quick landings on one leaf
  * must not stack two alphas over it.
  */
-export declare function bloomInside(host: HTMLElement): void;
+export declare function bloom(host: HTMLElement): void;

package/dist/core/bloom.js

@@ -6,9 +6,11 @@
 // fixed by `--_qm-accent-wash`, so interpolating 0→1→0 keeps the scale in CSS where
 // `color-mix` resolves, instead of in keyframe values a script would have to
 // pre-resolve and re-resolve on a theme change.
+//
+// The wash is the host's `::after` (`.qm-wash`, controls.css), drawn from mount: this
+// module plays it and adds nothing to the tree.
 import { rungStyle } from './rungs.js';
-const BLOOM_CLASS = 'qm-bloom';
-const WASH = 'var(--_qm-accent-wash)';
+const WASH = '::after';
 /** The dwell used when the derivation is out of reach (an unstyled root, or jsdom,
  *  where `getComputedStyle` reports custom properties as empty). A fallback is the
  *  absence of the scale, not a copy of it. */
@@ -25,61 +27,28 @@ const FRAMES = [
 ];
 const FRAMES_REDUCED = [{ opacity: 1 }, { opacity: 1 }];
 /**
- * Run one wash on `el`, resolving the dwell off its root so the number is
- * single-sourced in CSS (`core/rungs.ts`).
+ * Run one wash over `host`, a `.qm-wash` box, resolving the dwell off its root so the
+ * number is single-sourced in CSS (`core/rungs.ts`).
  *
  * One property, both motion preferences: `--_qm-bloom-dwell` already shortens under
  * `prefers-reduced-motion` in the derivation, so what is left to `matchMedia` here is
  * the shape: a hold and a cut carry no ramps, which is a frame list rather than a
  * number and the one half CSS cannot hand over.
- */
-function bloom(el) {
-    if (typeof el.animate !== 'function')
-        return undefined;
-    const reduced = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
-    const raw = rungStyle(el).getPropertyValue('--_qm-bloom-dwell').trim();
-    const n = Number.parseFloat(raw);
-    const duration = !Number.isFinite(n) ? FALLBACK_MS : raw.endsWith('ms') ? n : n * 1000;
-    return el.animate(reduced ? FRAMES_REDUCED : FRAMES, { duration });
-}
-/**
- * Bloom over `host`'s content: an inset child, so the wash neither tints the host's
- * own background nor fades the text under it. `host` must be positioned.
  *
- * One wash node per host, reused while it lives: two quick landings on the same leaf
+ * A run in flight on the same host is cancelled first: two quick landings on one leaf
  * must not stack two alphas over it.
  */
-export function bloomInside(host) {
-    let el = host.querySelector(`:scope > .${BLOOM_CLASS}`);
-    if (el) {
-        // Drop the in-flight run's handlers before cancelling: its `oncancel` would
-        // otherwise remove the node the new run is about to animate.
-        for (const a of el.getAnimations()) {
-            a.onfinish = null;
-            a.oncancel = null;
-            a.cancel();
-        }
-    }
-    else {
-        el = document.createElement('div');
-        el.className = BLOOM_CLASS;
-        Object.assign(el.style, {
-            position: 'absolute',
-            inset: '0',
-            pointerEvents: 'none',
-            borderRadius: 'inherit',
-            background: WASH,
-            opacity: '0'
-        });
-        host.appendChild(el);
-    }
-    const node = el;
-    const anim = bloom(node);
-    if (!anim) {
-        node.remove();
+export function bloom(host) {
+    if (typeof host.animate !== 'function')
         return;
+    for (const a of host.getAnimations({ subtree: true })) {
+        const effect = a.effect;
+        if (effect?.target === host && effect.pseudoElement === WASH)
+            a.cancel();
     }
-    const drop = () => node.remove();
-    anim.onfinish = drop;
-    anim.oncancel = drop;
+    const reduced = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
+    const raw = rungStyle(host).getPropertyValue('--_qm-bloom-dwell').trim();
+    const n = Number.parseFloat(raw);
+    const duration = !Number.isFinite(n) ? FALLBACK_MS : raw.endsWith('ms') ? n : n * 1000;
+    host.animate(reduced ? FRAMES_REDUCED : FRAMES, { duration, pseudoElement: WASH });
 }

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

@@ -1,7 +1,7 @@
 import { type Command } from 'prosemirror-state';
 import type { Schema } from 'prosemirror-model';
 /**
- * The block-atom bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * The block-atom bindings for a block-schema leaf: `{}` for the one-line and plain
  * schemas, which hold no block to be against.
  *
  * Both keys are the same command on opposite sides, because what a delete against an

package/dist/core/codec/atoms.js

@@ -77,7 +77,7 @@ function againstAtom(side) {
     };
 }
 /**
- * The block-atom bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * The block-atom bindings for a block-schema leaf: `{}` for the one-line and plain
  * schemas, which hold no block to be against.
  *
  * Both keys are the same command on opposite sides, because what a delete against an

package/dist/core/codec/blocks.js

@@ -1,6 +1,7 @@
 import { Selection } from 'prosemirror-state';
 import { chainCommands, splitBlock } from 'prosemirror-commands';
 import { canJoin, findWrapping } from 'prosemirror-transform';
+import { withinNesting } from './nesting.js';
 import { takesLineBreak } from './schema.js';
 /** The head of a textblock: where a shorthand fires, and where a pick lands once its
  *  run is consumed. */
@@ -59,7 +60,8 @@ function spaceBreaks(tr, $from, type) {
 }
 /** `wrappingInputRule`'s body: wrap the block range at `pos`, then join a preceding
  *  sibling of the same type — the one boundary the wrap itself opens (`lists.ts`
- *  §cleanup: command-local, never a global pass). */
+ *  §cleanup: command-local, never a global pass). False where no wrap fits, or where
+ *  the one that does nests past `MAX_NESTING_DEPTH` (`nesting.ts`). */
 function wrapAt(tr, pos, type, attrs, joinBefore) {
     const range = tr.doc.resolve(pos).blockRange();
     const wrapping = range && findWrapping(range, type, attrs);
@@ -73,7 +75,7 @@ function wrapAt(tr, pos, type, attrs, joinBefore) {
         (!joinBefore || joinBefore(before))) {
         tr.join(pos - 1);
     }
-    return true;
+    return withinNesting(tr.doc);
 }
 /** `# `: the heading `level` deep. `list_item` is `block+`, so one inside an item is a
  *  shape the content holds and `importMarkdown` produces from `- # title`. */

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

@@ -0,0 +1,21 @@
+import type { Node as PMNode } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+/** A leaf's character cap: the schema's `max:`, and whether the count drops trailing
+ *  whitespace, which a one-line `text` does and nothing else. */
+export interface TextCap {
+    max: number;
+    trimEnd?: boolean;
+    /** The count, at mount and after every change to the document. */
+    onCount?: (count: number) => void;
+}
+/** The characters `doc` holds as `FieldSchema::char_count` counts them: Unicode scalar
+ *  values of the plain projection, islands counting nothing and trailing line breaks
+ *  none. */
+export declare function capCount(doc: PMNode, trimEnd?: boolean): number;
+/**
+ * Refuses a transaction leaving the leaf past `max`, so a keystroke at the cap lands
+ * nothing, and cuts a paste to what fits. Past the cap, a transaction passes where it
+ * leaves the count no higher, so a value stored over the cap still edits down; undo and
+ * redo pass, each restoring a state the leaf already held.
+ */
+export declare function capPlugin(cap: TextCap): Plugin;

package/dist/core/codec/cap.js

@@ -0,0 +1,63 @@
+import { isHistoryTransaction } from 'prosemirror-history';
+import { Plugin } from 'prosemirror-state';
+import { usvLength } from './decode.js';
+import { scanDoc } from './encode.js';
+import { ISLAND_SLOT } from './islands.js';
+/** The characters `doc` holds as `FieldSchema::char_count` counts them: Unicode scalar
+ *  values of the plain projection, islands counting nothing and trailing line breaks
+ *  none. */
+export function capCount(doc, trimEnd = false) {
+    const text = scanDoc(doc).text.replaceAll(ISLAND_SLOT, '');
+    return usvLength(trimEnd ? text.trimEnd() : text.replace(/[\n\r]+$/, ''));
+}
+/**
+ * Refuses a transaction leaving the leaf past `max`, so a keystroke at the cap lands
+ * nothing, and cuts a paste to what fits. Past the cap, a transaction passes where it
+ * leaves the count no higher, so a value stored over the cap still edits down; undo and
+ * redo pass, each restoring a state the leaf already held.
+ */
+export function capPlugin(cap) {
+    const count = (doc) => capCount(doc, cap.trimEnd);
+    return new Plugin({
+        filterTransaction: (tr) => {
+            if (!tr.docChanged || isHistoryTransaction(tr))
+                return true;
+            const after = count(tr.doc);
+            return after <= cap.max || after <= count(tr.before);
+        },
+        props: {
+            handlePaste: (view, _event, slice) => {
+                const { state } = view;
+                const pasted = () => state.tr.replaceSelection(slice);
+                if (count(pasted().doc) <= cap.max)
+                    return false;
+                const tr = pasted();
+                const start = tr.mapping.map(state.selection.from, -1);
+                const end = tr.mapping.map(state.selection.to, 1);
+                const fits = (cut) => count(pasted().delete(cut, end).doc) <= cap.max;
+                if (!fits(start))
+                    return true;
+                let lo = start;
+                let hi = end;
+                while (hi - lo > 1) {
+                    const mid = (lo + hi) >> 1;
+                    if (fits(mid))
+                        lo = mid;
+                    else
+                        hi = mid;
+                }
+                view.dispatch(tr.delete(lo, end).scrollIntoView().setMeta('uiEvent', 'paste'));
+                return true;
+            }
+        },
+        view: (v) => {
+            cap.onCount?.(count(v.state.doc));
+            return {
+                update: (next, prev) => {
+                    if (next.state.doc !== prev.doc)
+                        cap.onCount?.(count(next.state.doc));
+                }
+            };
+        }
+    });
+}

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

@@ -1,7 +1,7 @@
 import type { Schema } from 'prosemirror-model';
 import { type Command } from 'prosemirror-state';
 /**
- * The `code_block` link of the body's key chains: `{}` for the inline/plaintext
+ * The `code_block` link of the body's key chains: `{}` for the one-line and plain
  * schemas, which declare no code node.
  *
  * `Enter` is upstream's `newlineInCode`, and it is load-bearing rather than

package/dist/core/codec/code.js

@@ -182,7 +182,7 @@ const belowFinalFence = (state, dispatch) => {
     return true;
 };
 /**
- * The `code_block` link of the body's key chains: `{}` for the inline/plaintext
+ * The `code_block` link of the body's key chains: `{}` for the one-line and plain
  * schemas, which declare no code node.
  *
  * `Enter` is upstream's `newlineInCode`, and it is load-bearing rather than

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

@@ -18,10 +18,10 @@ export declare function renderContent(rt: Content, schema: Schema): Node;
 /** Decode a `Content` to a PM document under `schema`. */
 export declare function decode(rt: Content, schema: Schema): PMNode;
 /** Whether `rt` decodes under an inline schema with nothing but whitespace dropped:
- *  upstream's `inline` rule, or one plain line and the empty one a trailing `\n`
- *  opens. That newline is the one a YAML `|` scalar keeps in a `plaintext` value,
- *  which upstream refuses (`trailingNewline`) and the inline decode drops. Marks are
- *  the schema's own business (`plaintextSchema` declares none). */
+ *  upstream's one-line rule, or one plain line and the empty one a trailing `\n`
+ *  opens. That newline is the one a YAML `|` scalar keeps in a `text` value, which
+ *  upstream ignores and the inline decode drops. Marks are the schema's own business
+ *  (`plaintextSchema` declares none). */
 export declare function fitsInline(rt: Content): boolean;
 /** Whether `rt` decodes under `plainSchema` losing nothing but its marks, which the
  *  next commit heals (CODEC §Inline mode): upstream's `isPlain`, asked of the content
@@ -29,7 +29,7 @@ export declare function fitsInline(rt: Content): boolean;
 export declare function fitsPlain(rt: Content): boolean;
 /** Whether a leaf so declared edits `rt` losing nothing: {@link fitsInline} narrowed
  *  and {@link fitsPlain} plain, past which the decode drops what the first commit would
- *  store; on the block schema anything but an element or a task item ({@link editable}),
+ *  store; on the block schema anything but an element ({@link editable}),
  *  and an island where the leaf mounts no island view (`islands`), which draws as its
  *  placeholder tag, an atom a keystroke deletes unseen. What a leaf held over the rest
  *  reads. */

package/dist/core/codec/decode.js

@@ -47,9 +47,9 @@ export function decode(rt, schema) {
         acc += usvLength(lineTexts[i]) + 1; // +1 for the `\n` boundary
     }
     // A mark-free schema (`plaintextSchema`) has nothing to apply them with, and a
-    // plaintext field that acquired one anyway — an older build's popover, a hand-
-    // written document — is exactly the content that must open and then heal on the
-    // next commit, not throw here.
+    // `text` field that acquired one anyway — an older build's popover, a hand-written
+    // document — is exactly the content that must open and then heal on the next
+    // commit, not throw here.
     const marks = hasMarks(schema) ? rt.marks.filter((m) => m.type !== 'anchor') : [];
     const cursor = { i: 0, rt };
     if (isInlineSchema(schema)) {
@@ -74,10 +74,10 @@ export function decode(rt, schema) {
     return schema.nodes.doc.create(null, blocks.length ? blocks : schema.nodes.paragraph.create());
 }
 /** Whether `rt` decodes under an inline schema with nothing but whitespace dropped:
- *  upstream's `inline` rule, or one plain line and the empty one a trailing `\n`
- *  opens. That newline is the one a YAML `|` scalar keeps in a `plaintext` value,
- *  which upstream refuses (`trailingNewline`) and the inline decode drops. Marks are
- *  the schema's own business (`plaintextSchema` declares none). */
+ *  upstream's one-line rule, or one plain line and the empty one a trailing `\n`
+ *  opens. That newline is the one a YAML `|` scalar keeps in a `text` value, which
+ *  upstream ignores and the inline decode drops. Marks are the schema's own business
+ *  (`plaintextSchema` declares none). */
 export function fitsInline(rt) {
     if (core().isInline(rt))
         return true;
@@ -96,7 +96,7 @@ export function fitsPlain(rt) {
 }
 /** Whether a leaf so declared edits `rt` losing nothing: {@link fitsInline} narrowed
  *  and {@link fitsPlain} plain, past which the decode drops what the first commit would
- *  store; on the block schema anything but an element or a task item ({@link editable}),
+ *  store; on the block schema anything but an element ({@link editable}),
  *  and an island where the leaf mounts no island view (`islands`), which draws as its
  *  placeholder tag, an atom a keystroke deletes unseen. What a leaf held over the rest
  *  reads. */
@@ -107,10 +107,10 @@ export function fitsLeaf(rt, leaf) {
         return fitsPlain(rt);
     return (leaf.islands || rt.islands.length === 0) && rt.lines.every(editable);
 }
-/** Whether every container on `line` is one the block schema edits: an element, and a
- *  task item's `checked`, decode to no node, so the first commit would drop them. */
+/** Whether every container on `line` is one the block schema edits: an element decodes
+ *  to no node, so the first commit would drop it. */
 function editable(line) {
-    return line.containers.every((c) => c.container === 'quote' || (c.container === 'list_item' && c.attrs.checked === undefined));
+    return line.containers.every((c) => c.container === 'quote' || c.container === 'list_item');
 }
 /** Inline decode: one paragraph, containers and islands stripped. */
 function decodeInline(rt, schema, lineTexts, starts, marks, cursor) {
@@ -184,7 +184,7 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
                 let l = k + 1;
                 while (l < run.length && ordinalAt(run[l], depth) === ord)
                     l++;
-                items.push(schema.nodes.list_item.create(null, groupBlocks(schema, run.slice(k, l), depth + 1, marks, cursor)));
+                items.push(schema.nodes.list_item.create({ checked: checkedAt(run[k], depth) }, groupBlocks(schema, run.slice(k, l), depth + 1, marks, cursor)));
                 k = l;
             }
             const listType = ordered ? schema.nodes.ordered_list : schema.nodes.bullet_list;
@@ -235,6 +235,12 @@ function ordinalAt(leaf, depth) {
     const c = atDepth(leaf, depth);
     return c?.container === 'list_item' ? c.attrs.ordinal : -1;
 }
+/** A task item's `checked` at `depth`, `null` on any other item: what the item's lines
+ * carry alike, so its first line answers for it. */
+function checkedAt(leaf, depth) {
+    const c = atDepth(leaf, depth);
+    return c?.container === 'list_item' ? (c.attrs.checked ?? null) : null;
+}
 /** A container's `instance`, absent meaning the zero a canonical read omits. It is what
  * tells one container from an adjacent sibling of identical shape, which contiguity
  * alone reads as one, so absent and `0` have to answer alike. */

package/dist/core/codec/encode.js

@@ -122,7 +122,12 @@ function scanBlock(acc, node, nodePos, containers, instance) {
             const start = ordered ? node.attrs.start : 1;
             let itemPos = contentStart;
             node.forEach((item, _off, index) => {
-                const container = withInstance({ container: 'list_item', attrs: { ordered, start, ordinal: index } }, instance);
+                const checked = item.attrs.checked;
+                const attrs = { ordered, start, ordinal: index };
+                const container = withInstance({
+                    container: 'list_item',
+                    attrs: checked === null ? attrs : { ...attrs, checked }
+                }, instance);
                 scanBlocks(acc, item, itemPos + 1, [...containers, container]);
                 itemPos += item.nodeSize;
             });

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

@@ -3,6 +3,7 @@ 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 TextCap } from './cap.js';
 import { type TableChromeStrings } from './table-view.js';
 import { type SlashState, type SlashStrings } from './slash.js';
 /** Options for {@link createField}. */
@@ -14,20 +15,20 @@ export interface CreateFieldOpts {
     quill: Quill;
     addr: Addr;
     container: HTMLElement;
-    /** Constrained single-textblock schema (a field declaring `inline`). */
+    /** Constrained single-textblock schema (a one-line field). */
     inline?: boolean;
-    /** A mark-free schema (a `plaintext` field): literal text, no formatting and no
+    /** A mark-free schema (a `text` field): literal text, no formatting and no
      *  anchors, in paragraphs and hard breaks or, with `inline`, one textblock. */
     plaintext?: boolean;
     /** The id of the note the caller draws inside `container` for a held leaf →
      *  `aria-describedby` while it holds. */
     heldNoteId?: string;
     /**
-     * Fired when the leaf holds or releases, and at mount when it mounts held. A leaf
-     * declaring `inline`, or a `plaintext` one, is held over a value its schema cannot
+     * 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 an element or a task item, which no node holds. A held leaf draws
+     * over an element, which no node holds. 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.
@@ -75,10 +76,16 @@ export interface CreateFieldOpts {
      * a body's invitation. The initial value; {@link FieldController.setPlaceholder}
      * moves it after mount. Empty/absent shows no ghost. */
     placeholder?: string;
+    /** The schema's `max:` on the field: a character count no edit takes the leaf past
+     *  (`cap.ts`). */
+    cap?: TextCap;
     /** The placeholder goes at the leaf's first edit: the edit answers the leaf, and
      * emptied it holds an empty answer, which prints empty. Absent, the placeholder
      * returns whenever the leaf is empty. */
     placeholderUntilEdit?: boolean;
+    /** An edit leaving the leaf empty removes the field: an optional cell (`t?`), whose
+     * unanswered `none` is what the empty leaf draws and an empty answer would hide. */
+    emptyUnsets?: boolean;
     onFocus?(addr: Addr): void;
     /** Fired with the new USV caret after an edit or a selection move. */
     onCaretMove?(addr: Addr, pos: number): void;
@@ -88,8 +95,8 @@ export interface CreateFieldOpts {
      * 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 `plaintext` leaf's typed
-     * write) and for an anchor mutation,
+     * 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.
      */
@@ -168,6 +175,8 @@ export interface LeafViews {
 /** The canonical empty `Content`: one empty `para` line. The empty a prose
  * leaf (or an array's prose element) seeds from. */
 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
@@ -197,10 +206,10 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
  * 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`) and the markdown paste
- * (`markdown-paste.ts`).
+ * (`islands.ts`), the table paste (`table-paste.ts`), the markdown paste
+ * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`).
  *
- * Every mark-shaped plugin reads the schema rather than a flag: over either plaintext
+ * 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.
@@ -219,5 +228,8 @@ export declare function proseLeafPlugins(schema: Schema, opts: {
     placeholder?: () => string | undefined;
     /** {@link CreateFieldOpts.placeholderUntilEdit}. */
     placeholderUntilEdit?: boolean;
+    /** {@link CreateFieldOpts.cap}. Ahead of every other paste handler, which a paste
+     *  it cuts never reaches. */
+    cap?: TextCap;
     afterHistory?: Plugin[];
 }): Plugin[];