@quillmark/svelte 0.21.0 → 0.23.0

package/dist/core/codec/field.js

@@ -5,8 +5,8 @@
 //   (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)`, or a `plaintext` leaf's whole
-//       text through the typed writer,
+//   (c) commit via `doc.applyChange(addr, bundle)`, or a `text` 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
@@ -24,6 +24,7 @@ import { reportError, errorMessage } from '../errors.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 { capPlugin } from './cap.js';
 import { islandPastePlugin } from './islands.js';
 import { anchorsFromContent } from './marks.js';
 import { contentEqual, createReconciler } from './reconcile.js';
@@ -33,7 +34,10 @@ import { bodyKeymap } from './keymap.js';
 import { blockSchema, isBlockSchema, leafSchema, plainSchema } from './schema.js';
 import { linkPastePlugin } from './link-paste.js';
 import { markdownPastePlugin } from './markdown-paste.js';
+import { nestingPlugin } from './nesting.js';
 import { tablePastePlugin } from './table-paste.js';
+import { tableCopyPlugin } from './table-copy.js';
+import { taskPlugin } from './tasks.js';
 import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
 import { DEFAULT_SLASH_STRINGS, focusSlashItem, runSlashItem, slashPlugin } from './slash.js';
 const anchorKey = new PluginKey('quill-anchors');
@@ -75,8 +79,8 @@ function anchorPlugin(seed) {
  * and the verbatim read cannot answer it alone. A field the editor committed rests
  * as `Content`; a field a markdown parse left rests as the authored string, and
  * what that string means is the declared type's to say: `richtext` is markdown,
- * `plaintext` is literal text, and reading one as the other silently eats every
- * `*` the author typed. */
+ * `text` is literal text, and reading one as the other silently eats every `*` the
+ * author typed. */
 function readLeaf(reader, addr) {
     return reader.getContent(addr) ?? emptyContent();
 }
@@ -85,14 +89,18 @@ function readLeaf(reader, addr) {
 export function emptyContent() {
     return { text: '', lines: [{ containers: [], kind: 'para' }], marks: [], islands: [] };
 }
+/** Whether `rt` is the empty leaf: {@link emptyContent}, nothing typed and no shape left. */
+export function isEmptyContent(rt) {
+    return contentEqual(rt, emptyContent());
+}
 /** Whether ops may commit here: the stored value is a `Content` object, so
  * `applyChange` splices exactly the content the leaf read and PM is showing.
  *
  * The two other rest forms both take `overwrite` instead. An unset field (`undefined`;
  * a default-only richtext field before its first edit) has nothing to splice, 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}). */
+ * string carries no anchors to pay. A body always rests as `Content`. A `text` 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';
@@ -162,7 +170,7 @@ export function createField(opts) {
     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.
+    // `not_single_line` on a one-line `text` field.
     const holds = (rt) => !fitsLeaf(rt, { inline, plaintext, islands: true });
     let held = holds(reconciler.last);
     const named = proseAttributes(opts) ?? {};
@@ -210,6 +218,9 @@ export function createField(opts) {
         dispatchTransaction: (tr) => {
             const oldRt = reconciler.last;
             const next = view.state.apply(tr);
+            // A filtered transaction (`nesting.ts`) leaves the state as it was.
+            if (next === view.state)
+                return;
             // 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)))
@@ -272,6 +283,7 @@ export function createField(opts) {
                 // given one later; the plugin draws nothing while the text is empty.
                 placeholder: () => placeholderText,
                 placeholderUntilEdit: opts.placeholderUntilEdit,
+                cap: opts.cap,
                 afterHistory: [anchorPlugin(seededAnchors)]
             })
         });
@@ -282,6 +294,8 @@ 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 (opts.emptyUnsets && heldAnchors().length === 0 && isEmptyContent(newRt))
+            return commitUnset();
         if (plaintext)
             return commitPlain(newRt.text);
         // The text splice, computed once per keystroke: the gate below, both overwrite
@@ -335,8 +349,8 @@ 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
+     * A `text` 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.
@@ -348,7 +362,7 @@ export function createField(opts) {
         try {
             const name = addr.field;
             if (name === undefined)
-                throw new Error('a plaintext leaf names a field');
+                throw new Error('a text leaf names a field');
             (addr.card === undefined ? writer : writer.card(addr.card)).set(name, text);
             reconciler.commit(readLeaf(reader, addr));
             return true;
@@ -363,6 +377,23 @@ export function createField(opts) {
             return false;
         }
     }
+    /** An emptied optional leaf's commit: the field removed, back to unanswered. */
+    function commitUnset() {
+        try {
+            doc.removeField(addr);
+            reconciler.commit(readLeaf(reader, addr));
+            return true;
+        }
+        catch (e) {
+            reportError(opts.onError, {
+                code: 'commit-lost',
+                severity: 'error',
+                message: `the field could not be removed; 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`
@@ -437,7 +468,7 @@ export function createField(opts) {
             return readLeaf(reader, addr);
         },
         insertAnchor(id, pos) {
-            // A plaintext field carries no marks (§Inline mode), and a held one commits nothing.
+            // A text field carries no marks (§Inline mode), and a held one commits nothing.
             if (plaintext || held)
                 return;
             if (heldAnchors().some((a) => a.id === id))
@@ -509,16 +540,21 @@ export function createField(opts) {
  * 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.
  */
 export function proseLeafPlugins(schema, opts) {
-    const list = [history(), ...(opts.afterHistory ?? []), linebreakPlugin(schema)];
+    const list = [
+        history(),
+        ...(opts.cap ? [capPlugin(opts.cap)] : []),
+        ...(opts.afterHistory ?? []),
+        linebreakPlugin(schema)
+    ];
     if (opts.slash)
         list.push(slashPlugin(opts.slash, opts.slashHint));
     if (!opts.noInputRules)
@@ -530,7 +566,7 @@ export function proseLeafPlugins(schema, opts) {
     // Each answers 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(), tablePastePlugin(), markdownPastePlugin());
+        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), tableCopyPlugin(), markdownPastePlugin(), taskPlugin(), nestingPlugin());
     if (schema === plainSchema)
         list.push(plainClipboardPlugin());
     if (opts.placeholder)
@@ -641,9 +677,9 @@ function ghostPlugin(opts) {
 /**
  * The field's keymap: history, mark toggles, and the body's structural keys; Enter
  * suppressed inline. The toggles are bound per mark type the schema declares, so a
- * plaintext leaf leaves Mod-b/i/u to the browser.
+ * `text` leaf leaves Mod-b/i/u to the browser.
  *
- * Tab forks on the leaf's role, not on the caret's position. An inline/plaintext
+ * Tab forks on the leaf's role, not on the caret's position. A one-line or `text`
  * leaf is a form field: Tab stays unbound, so field navigation is open for a shell
  * keymap (VISUAL_EDITOR §Settled and open). A block-schema body is a document: Tab
  * is structural, a chain each nested surface prepends to (`keymap.ts`). One key

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

@@ -1,7 +1,9 @@
 export { rangeAnchor } from './anchor.js';
 export type { RangeAnchor } from './anchor.js';
-export { createField, emptyContent, heldAttributes, proseAttributes, proseLeafPlugins } from './field.js';
+export { createField, emptyContent, heldAttributes, isEmptyContent, proseAttributes, proseLeafPlugins } from './field.js';
 export type { CreateFieldOpts, FieldController, LeafViews } from './field.js';
+export { capCount } from './cap.js';
+export type { TextCap } from './cap.js';
 export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 export type { TableChromeStrings } from './table-view.js';
 export { DEFAULT_SLASH_STRINGS } from './slash.js';

package/dist/core/codec/index.js

@@ -13,7 +13,8 @@ import './prose.css';
 // selection (`visual/FormatPopover.svelte`), so it is reached off-barrel.
 export { rangeAnchor } from './anchor.js';
 // The prose leaf.
-export { createField, emptyContent, heldAttributes, proseAttributes, proseLeafPlugins } from './field.js';
+export { createField, emptyContent, heldAttributes, isEmptyContent, proseAttributes, proseLeafPlugins } from './field.js';
+export { capCount } from './cap.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';
@@ -37,7 +38,7 @@ export { pmToContent, contentEdit, lower } from './encode.js';
 export { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 // Reconciliation gate.
 export { createReconciler, contentEqual, valueEqual } from './reconcile.js';
-// Input rules (`createField` mounts them unless `noInputRules`/`plaintext`).
+// Input rules (`createField` mounts them unless `noInputRules`, or over a mark-free schema).
 export { inputRulesPlugin } from './inputrules.js';
 // The body leaf's structural keys: `createField` binds the composed chains
 // (`bodyKeymap`); the suite drives both it and the list link directly.

package/dist/core/codec/inputrules.js

@@ -58,7 +58,7 @@ export function markdownInputRules(schema) {
     const rules = [];
     const m = schema.marks;
     // Inline marks. Non-greedy capture between matching delimiters. Built only where the
-    // schema has the mark: the inline schema omits them, and a plaintext one declares none
+    // schema has the mark: the inline schema omits them, and a `text` one declares none
     // at all.
     if (m.strong)
         rules.push(markInputRule(/\*\*([^*]+)\*\*$/, m.strong, 2));

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

@@ -1,7 +1,7 @@
 import type { Schema } from 'prosemirror-model';
 import type { Command } from 'prosemirror-state';
 /**
- * The list bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * The list bindings for a block-schema leaf: `{}` for the one-line and plain
  * schemas, which declare no list nodes.
  *
  * `Tab` / `Shift-Tab` hold the list link of the body's Tab chain. Surfaces that own
@@ -13,7 +13,8 @@ import type { Command } from 'prosemirror-state';
  * shell structural keymap (VISUAL_EDITOR §Settled and open).
  *
  * `Enter` is a chain in precedence order: the escape-above gesture, then
- * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
+ * `splitListItem` (`splitTaskItem`, which leaves a task item's new half an open task),
+ * then `liftListItem`. The middle link carries two behaviors of
  * its own: it splits a non-empty item, and on an empty item it either splits the
  * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
  * so the third link lifts a top-level empty item out to a paragraph. `Backspace` lifts

package/dist/core/codec/lists.js

@@ -1,6 +1,8 @@
-import { liftListItem, sinkListItem, splitListItem } from 'prosemirror-schema-list';
+import { liftListItem, sinkListItem } from 'prosemirror-schema-list';
 import { EditorState, Selection, TextSelection } from 'prosemirror-state';
 import { chainCommands, joinTextblockBackward, joinTextblockForward } from 'prosemirror-commands';
+import { withinNesting } from './nesting.js';
+import { splitTaskItem } from './tasks.js';
 /** The caret's enclosing `list_item` when it sits at the very start of that item's
  * first block: the position both structural keys branch on. `null` otherwise
  * (mid-text, a non-first block of a multi-paragraph item, a non-empty selection),
@@ -187,8 +189,21 @@ function backspaceBelow(itemType, press) {
         return press(EditorState.create({ doc: state.doc, selection: below }), dispatch && keepCaret);
     };
 }
+/** Tab → `sinkListItem`, declined where the sink would nest past `MAX_NESTING_DEPTH`
+ *  (`nesting.ts`), so Tab there leaves the body as it does on an item with nothing to
+ *  sink under. */
+function sinkWithin(itemType) {
+    const sink = sinkListItem(itemType);
+    return (state, dispatch) => {
+        let sunk;
+        if (!sink(state, (tr) => (sunk = tr)) || !sunk || !withinNesting(sunk.doc))
+            return false;
+        dispatch?.(sunk);
+        return true;
+    };
+}
 /**
- * The list bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * The list bindings for a block-schema leaf: `{}` for the one-line and plain
  * schemas, which declare no list nodes.
  *
  * `Tab` / `Shift-Tab` hold the list link of the body's Tab chain. Surfaces that own
@@ -200,7 +215,8 @@ function backspaceBelow(itemType, press) {
  * shell structural keymap (VISUAL_EDITOR §Settled and open).
  *
  * `Enter` is a chain in precedence order: the escape-above gesture, then
- * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
+ * `splitListItem` (`splitTaskItem`, which leaves a task item's new half an open task),
+ * then `liftListItem`. The middle link carries two behaviors of
  * its own: it splits a non-empty item, and on an empty item it either splits the
  * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
  * so the third link lifts a top-level empty item out to a paragraph. `Backspace` lifts
@@ -217,9 +233,9 @@ export function listKeymap(schema) {
         return {};
     const backspace = chainCommands(liftAtItemStart(itemType), joinOntoList(itemType));
     return {
-        Tab: sinkListItem(itemType),
+        Tab: sinkWithin(itemType),
         'Shift-Tab': liftListItem(itemType),
-        Enter: chainCommands(paragraphAboveList(itemType, paragraph), splitListItem(itemType), liftListItem(itemType)),
+        Enter: chainCommands(paragraphAboveList(itemType, paragraph), splitTaskItem(itemType), liftListItem(itemType)),
         Backspace: backspace,
         Delete: backspaceBelow(itemType, backspace)
     };

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

@@ -0,0 +1,20 @@
+import type { Node as PMNode } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+/** The store's bound on the containers around one line: a commit nesting past it is
+ *  refused, and `@quillmark/wasm` exports no constant to read it from. */
+export declare const MAX_NESTING_DEPTH = 12;
+/** The most containers any block in `doc` stands inside, counted as the store counts
+ *  them: a `list_item` or a `blockquote` is one, the list around an item none, and no
+ *  node holds an element (`decode.ts`). */
+export declare function nestingDepth(doc: PMNode): number;
+/** Whether `doc` nests within {@link MAX_NESTING_DEPTH}: what a command that nests asks
+ *  of the doc it would dispatch. */
+export declare function withinNesting(doc: PMNode): boolean;
+/**
+ * Refuses a transaction leaving `doc` past {@link MAX_NESTING_DEPTH}, which the commit
+ * would lose: a paste or a drop into a deep item, whose slice the import bounded alone.
+ * The nesting commands ask first and keep their key; this is what reaches the rest, and
+ * a refused paste lands nothing. Past the bound, a transaction passes where it leaves the
+ * deepest level no deeper, so a body that arrived that deep keeps its Enter.
+ */
+export declare function nestingPlugin(): Plugin;

package/dist/core/codec/nesting.js

@@ -0,0 +1,62 @@
+import { Plugin } from 'prosemirror-state';
+import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform';
+/** The store's bound on the containers around one line: a commit nesting past it is
+ *  refused, and `@quillmark/wasm` exports no constant to read it from. */
+export const MAX_NESTING_DEPTH = 12;
+/** The most containers any block in `doc` stands inside, counted as the store counts
+ *  them: a `list_item` or a `blockquote` is one, the list around an item none, and no
+ *  node holds an element (`decode.ts`). */
+export function nestingDepth(doc) {
+    const walk = (node, depth) => {
+        let deepest = depth;
+        node.forEach((child) => {
+            if (child.isTextblock || child.isAtom)
+                return;
+            const name = child.type.name;
+            const d = depth + (name === 'list_item' || name === 'blockquote' ? 1 : 0);
+            deepest = Math.max(deepest, walk(child, d));
+        });
+        return deepest;
+    };
+    return walk(doc, 0);
+}
+/** Whether `doc` nests within {@link MAX_NESTING_DEPTH}: what a command that nests asks
+ *  of the doc it would dispatch. */
+export function withinNesting(doc) {
+    return nestingDepth(doc) <= MAX_NESTING_DEPTH;
+}
+/** Whether a step of `tr` can move a block under another container: any replace but
+ *  inline content inside one textblock, which is every keystroke's. Mark and attribute
+ *  steps move no node. */
+function mayNest(tr) {
+    return tr.steps.some((step, i) => {
+        if (step instanceof ReplaceAroundStep)
+            return true;
+        if (!(step instanceof ReplaceStep))
+            return false;
+        const doc = tr.docs[i];
+        const $from = doc.resolve(step.from);
+        if (!$from.parent.isTextblock || !$from.sameParent(doc.resolve(step.to)))
+            return true;
+        let block = false;
+        step.slice.content.forEach((node) => (block ||= node.isBlock));
+        return block;
+    });
+}
+/**
+ * Refuses a transaction leaving `doc` past {@link MAX_NESTING_DEPTH}, which the commit
+ * would lose: a paste or a drop into a deep item, whose slice the import bounded alone.
+ * The nesting commands ask first and keep their key; this is what reaches the rest, and
+ * a refused paste lands nothing. Past the bound, a transaction passes where it leaves the
+ * deepest level no deeper, so a body that arrived that deep keeps its Enter.
+ */
+export function nestingPlugin() {
+    return new Plugin({
+        filterTransaction: (tr) => {
+            if (!tr.docChanged || !mayNest(tr))
+                return true;
+            const after = nestingDepth(tr.doc);
+            return after <= MAX_NESTING_DEPTH || after <= nestingDepth(tr.before);
+        }
+    });
+}

package/dist/core/codec/prose.css

@@ -148,6 +148,20 @@ li.ProseMirror-selectednode::after {
 	font-size: inherit;
 }
 
+/* A fence's language at the label rung in its top corner, read off the `data-lang` the
+   node writes (`schema.ts`). Generated content, so it is never text the caret reaches
+   or a copy takes; the code's lines wrap around it. Read-only: the language is changed
+   in source mode. */
+.ProseMirror pre[data-lang]::before {
+	content: attr(data-lang);
+	float: inline-end;
+	margin-inline-start: var(--_qm-space-3);
+	font-size: var(--_qm-text-label);
+	color: var(--_qm-ink-label);
+	user-select: none;
+	pointer-events: none;
+}
+
 /* A link takes the surface's ink (the UA's blue is the `#8cf` defect again) and a
    dotted underline. Dotted rather than solid because `underline` is a mark in the
    same schema, and a solid rule renders an authored `<u>` and a link identically in a
@@ -191,6 +205,59 @@ li.ProseMirror-selectednode::after {
 	list-style: revert;
 }
 
+/* A task item's checkbox (`tasks.ts`) stands after the item's marker and ahead of its
+   first line, the text wrapping back under it, as the paper sets the box. Its face is a
+   matrix tick's: the input drawn `appearance: none` as an edged well, held at the
+   accent, the check glyph over it in the surface ink. A disabled box is a held leaf's
+   or a copy's, and takes no press. */
+.ProseMirror .qm-task {
+	position: relative;
+	float: left;
+	display: flex;
+	align-items: center;
+	height: 1lh;
+	margin-right: var(--_qm-space-2);
+}
+.ProseMirror .qm-task-box {
+	appearance: none;
+	margin: 0;
+	width: var(--_qm-glyph-control);
+	height: var(--_qm-glyph-control);
+	border: var(--_qm-border-width) solid var(--_qm-border);
+	border-radius: calc(var(--_qm-radius-inner) / 2);
+	background: var(--_qm-surface-well);
+	cursor: pointer;
+	transition:
+		background-color var(--_qm-duration-fast) var(--_qm-ease-reverse),
+		border-color var(--_qm-duration-fast) var(--_qm-ease-reverse);
+}
+.ProseMirror .qm-task-box:checked {
+	background: var(--_qm-accent);
+	border-color: var(--_qm-accent);
+}
+.ProseMirror .qm-task-box:disabled {
+	cursor: default;
+}
+.ProseMirror .qm-task-box:focus-visible {
+	outline: var(--_qm-ring);
+	outline-offset: var(--_qm-ring-offset);
+}
+.ProseMirror .qm-task-mark {
+	position: absolute;
+	top: 50%;
+	left: 0;
+	width: var(--_qm-glyph-control);
+	height: var(--_qm-glyph-control);
+	translate: 0 -50%;
+	pointer-events: none;
+	color: var(--_qm-surface);
+	opacity: 0;
+	transition: opacity var(--_qm-duration-fast) var(--_qm-ease-reverse);
+}
+.ProseMirror .qm-task:has(:checked) .qm-task-mark {
+	opacity: 1;
+}
+
 /* Six levels, one weight, no size step. The quill reads no level at all, so a size
    ramp here would be the editor predicting a hierarchy the paper does not set; the
    level stays in the model, which is where the codec round-trips it. It is also all
@@ -516,37 +583,24 @@ li.ProseMirror-selectednode::after {
 	height: var(--_qm-tap-min);
 }
 /* The reveal is the control's own (CODEC §"The table island"): one comes up while the
-   pointer is on that control, while it holds the focus, or while it is what a gesture is
-   about — the selected line's grip, and the lifted one, which is drawn through a drag the
+   pointer is on that control, or while it is what a gesture is about — the selected line's grip, and the lifted one, which is drawn through a drag the
    pointer has travelled off. A cell under the pointer draws its row's and its column's
    grips (`table-view.ts` §`onHover`), one pill on each axis and none anywhere else.
 
    Opacity rather than absence, so every control keeps its box and is hit-tested wherever
-   it sits. A grip's reach is the pointer's alone and it holds no focus, so it carries no
-   focus rung: what a keyboard draws a line with is the cell the selection runs through
-   (`table-view.ts` §`cellKeys`), and the wash and the selected grip's tint are what say
-   so. The two bars are in the tab order, the Tab that declines off the last cell landing
-   on them, so the rung there draws one a keyboard has reached. */
+   it sits. A grip's reach and a bar's are the pointer's alone and neither holds focus, so
+   neither carries a focus rung: what a keyboard draws a line with is the cell the
+   selection runs through (`table-view.ts` §`cellKeys`), and the wash and the selected
+   grip's tint are what say so. */
 :is(.qm-table-grip, .qm-table-add) {
 	opacity: 0;
 	transition: opacity var(--_qm-duration-fast) var(--_qm-ease-reverse);
 }
-.qm-table-add:is(:hover, :focus-visible),
+.qm-table-add:hover,
 .qm-table-grip:is([data-near], :hover, [aria-pressed='true'], .qm-table-lifted) {
 	opacity: 1;
 }
 
-/* The ring, on the two add bars and nowhere else in this file. A prose leaf's focus
-   indicator is its caret and a cell's is too, so the outline is dropped there; a control
-   that comes up out of nothing has the reveal, and a ring under a keyboard is what says
-   the focus is there rather than on the paper behind it. Declared here rather than
-   reached for as `.qm-focus-ring`: that recipe is the visual tier's stylesheet, and the
-   island is inside the leaf, which is the codec's. */
-.qm-table-add:focus-visible {
-	outline: var(--_qm-ring);
-	outline-offset: var(--_qm-ring-offset);
-}
-
 /* A weighted table spans the leaf, laid out fixed, so the stored weights are the
    proportions its columns draw, as the page's fractional columns span the text block
    (`table-view.ts` §`weigh`). An auto-fit table keeps its content's width. */
@@ -610,7 +664,7 @@ li.ProseMirror-selectednode::after {
 	display: none;
 }
 /* The header toggle hangs under the first row's last cell, flush with the grid's
-   trailing edge, clear of whatever a held row raises over its first. */
+   trailing edge. */
 .qm-table-align[data-header] {
 	margin-inline: auto 0;
 }

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

@@ -23,7 +23,7 @@ export declare const plaintextSchema: Schema<string, never>;
  */
 export declare const cellSchema: Schema<"hard_break", string>;
 /**
- * A `plaintext` field without `inline`: paragraphs and hard breaks, no marks, no
+ * A `text` field declaring `multiline: true`: 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.
  *
@@ -38,7 +38,7 @@ export declare function leafSchema(opts: {
     plaintext?: boolean;
     inline?: boolean;
 }): Schema;
-/** Whether `schema` can carry formatting at all: false for the two plaintext schemas.
+/** Whether `schema` can carry formatting at all: false for the two mark-free schemas.
  *  What a mark command asks before it offers itself. */
 export declare function hasMarks(schema: Schema): boolean;
 /** True for the one-line schemas, which declare no `hard_break`; decode branches on it. */

package/dist/core/codec/schema.js

@@ -3,9 +3,9 @@
 // (list_item/quote → lists/blockquote); marks mirror the content formatting set.
 // Each set is closed upstream, so the schema names its whole vocabulary and carries
 // nothing inert. `blockSchema` is the full field; `inlineSchema` is the constrained
-// single-textblock form for `richtext(inline)` (one paragraph, no block split, no
-// containers, no islands) and `plaintextSchema` is that one without marks, for
-// `plaintext(inline)`; `plainSchema` is a `plaintext` field without `inline`,
+// single-textblock form for a one-line `richtext` (one paragraph, no block split, no
+// containers, no islands) and `plaintextSchema` is that one without marks, for a
+// one-line `text`; `plainSchema` is a `text` field declaring `multiline: true`,
 // paragraphs and hard breaks and nothing else; `cellSchema` is the inline form with
 // hard breaks, for a table cell. Same decode/lower/position machinery,
 // narrower shapes. Anchors are not marks here (decorations).
@@ -18,6 +18,7 @@
 // marks, a `<table>` being the block leaf's clipboard parser's (`table-paste.ts`).
 import { Schema } from 'prosemirror-model';
 import { islandBlockSpec, islandInlineSpec } from './islands.js';
+import { taskBody, taskChecked, taskDOM } from './tasks.js';
 import { rendersHref, storableUrl } from './urls.js';
 // ── Marks spelled as style ──────────────────────────────────────────────────
 // A word processor writes formatting as a span's inline style rather than as a tag:
@@ -193,11 +194,19 @@ const blockNodes = {
         parseDOM: [{ tag: 'ul' }],
         toDOM: () => ['ul', 0]
     },
+    // `checked` is a task item's, `null` on every other item (`tasks.ts`).
     list_item: {
         content: 'block+',
         defining: true,
-        parseDOM: [{ tag: 'li' }],
-        toDOM: () => ['li', 0]
+        attrs: { checked: { default: null } },
+        parseDOM: [
+            {
+                tag: 'li',
+                getAttrs: (el) => ({ checked: taskChecked(el) }),
+                contentElement: taskBody
+            }
+        ],
+        toDOM: (node) => node.attrs.checked === null ? ['li', 0] : taskDOM(node.attrs.checked)
     },
     island_block: islandBlockSpec
 };
@@ -254,7 +263,7 @@ export const cellSchema = new Schema({
     marks
 });
 /**
- * A `plaintext` field without `inline`: paragraphs and hard breaks, no marks, no
+ * A `text` field declaring `multiline: true`: 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.
  *
@@ -278,7 +287,7 @@ export function leafSchema(opts) {
         return opts.inline ? plaintextSchema : plainSchema;
     return opts.inline ? inlineSchema : blockSchema;
 }
-/** Whether `schema` can carry formatting at all: false for the two plaintext schemas.
+/** Whether `schema` can carry formatting at all: false for the two mark-free schemas.
  *  What a mark command asks before it offers itself. */
 export function hasMarks(schema) {
     return Object.keys(schema.marks).length > 0;

package/dist/core/codec/table-copy.d.ts

@@ -0,0 +1,17 @@
+import { Plugin } from 'prosemirror-state';
+import type { TableProps } from '@quillmark/wasm';
+/** A block of cells, both corners inclusive, in the row space `table.ts` names. */
+export interface CellRange {
+    r0: number;
+    c0: number;
+    r1: number;
+    c1: number;
+}
+/** The cells of `range` as a `<table>`, the header row in a `<thead>` where the range
+ *  holds it and the table has one. The cells carry their marks and breaks, and nothing
+ *  of the table's layout. */
+export declare function tableElement(props: TableProps, range?: CellRange): HTMLTableElement;
+/** The cells of `range` as tab-separated text, a line a row. */
+export declare function tableText(props: TableProps, range?: CellRange): string;
+/** A block leaf's copy: a table in the slice writes as a table in both spellings. */
+export declare function tableCopyPlugin(): Plugin;