@quillmark/svelte 0.20.1 → 0.22.0

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 } from 'prosemirror-commands';
+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),
@@ -72,41 +74,68 @@ function paragraphAboveList(itemType, paragraph) {
     };
 }
 /**
- * Backspace at the start of a list's first item → lift it: one level out for a
- * nested item, out of the list entirely (to a paragraph) at the top.
+ * Backspace at the start of an item → lift it: one level out for a nested item, out of
+ * the list to a paragraph at the top, whichever item it is. The first press takes off
+ * the item's own shape and joins nothing; the press after is the join
+ * ({@link joinOntoList}).
+ *
+ * Lifting a later item out splits its list, and an ordered list's items past the cut
+ * keep their numbers: the list after what the item held starts where they were, where a
+ * fresh `ordered_list` would count from 1 again.
  */
-function liftAtListStart(itemType) {
+function liftAtItemStart(itemType) {
     return (state, dispatch) => {
         const at = atItemStart(state, itemType);
-        if (!at || at.itemIndex !== 0)
+        if (!at)
             return false;
-        return liftListItem(itemType)(state, dispatch);
+        const list = state.doc.nodeAt(at.listPos);
+        const cut = list?.type.name === 'ordered_list' && !at.nested && at.itemIndex < list.childCount - 1;
+        const listEnd = at.listPos + (list?.nodeSize ?? 0);
+        return liftListItem(itemType)(state, dispatch &&
+            ((tr) => {
+                if (cut)
+                    renumberEndingAt(tr, tr.mapping.map(listEnd, -1), list.attrs.start + at.itemIndex + 1);
+                dispatch(tr);
+            }));
     };
 }
+/** Start the ordered list ending at `end` at `start`: the items a lift cut off, which
+ *  end where the whole list did, past whatever the lifted item held. */
+function renumberEndingAt(tr, end, start) {
+    const list = tr.doc.resolve(end).nodeBefore;
+    if (list?.type.name === 'ordered_list' && list.attrs.start !== start)
+        tr.setNodeMarkup(end - list.nodeSize, undefined, { ...list.attrs, start });
+}
 /**
- * Backspace at the start of any later item → join its text into the previous
- * item's last block, so the two items become one line.
+ * Backspace at the head of a block that stands right after a list → join its text into
+ * the list's last line, as two paragraphs join. The base keymap's answer there wraps the
+ * block into a fresh item instead, which undoes the lift that just took it out of the
+ * list ({@link liftAtItemStart}) and leaves the key toggling.
  *
- * Not the base keymap's `joinBackward`, which merges the block and leaves
- * `list_item(paragraph, paragraph)`: the item's marker gone while its text stays
- * on its own line, which the reference quill typesets as an unnumbered
- * continuation paragraph.
- *
- * Only between two blocks of one kind. A fence is not a line to put another line on,
- * and the join across that edge would retype one side's whole text as the other's
- * (`code.ts`, which refuses the same join between siblings); the base keymap's answer
- * stands here instead, merging the items with each block kept whole.
+ * Between a fence and prose the text does not join: a fence is not a line to put another
+ * line on, and the join would retype one side's whole text as the other's (`code.ts`,
+ * which refuses the same join between siblings). The block moves into the list's last
+ * item whole instead, a block of that item under its first.
  */
-function mergeIntoPreviousItem(itemType) {
+function joinOntoList(itemType) {
     return (state, dispatch, view) => {
-        const at = atItemStart(state, itemType);
-        if (!at || at.itemIndex === 0)
+        const { $from, empty } = state.selection;
+        if (!empty || !$from.parent.isTextblock || $from.parentOffset !== 0)
+            return false;
+        const before = state.doc.resolve($from.before()).nodeBefore;
+        if (before?.firstChild?.type !== itemType)
             return false;
-        const into = lastBlockIn(state.doc.nodeAt(at.listPos)?.child(at.itemIndex - 1));
-        if (!into || !!into.type.spec.code !== !!state.selection.$from.parent.type.spec.code) {
+        const into = lastBlockIn(before);
+        if (!into)
             return false;
+        if (!!into.type.spec.code === !!$from.parent.type.spec.code)
+            return joinTextblockBackward(state, dispatch, view);
+        if (dispatch) {
+            const at = $from.before() - 2;
+            const tr = state.tr.delete($from.before(), $from.after()).insert(at, $from.parent);
+            dispatch(tr.setSelection(TextSelection.create(tr.doc, at + 1)).scrollIntoView());
         }
-        return joinTextblockBackward(state, dispatch, view);
+        return true;
     };
 }
 /** Whether the caret sits inside a `list_item` at any depth: a quote's paragraph
@@ -128,6 +157,10 @@ function inItem($pos, itemType) {
  * The reflection carries the edit and not the caret, which stays where the key was
  * pressed: a lift moves the item below, and Delete does not follow it.
  *
+ * An empty item is the exception: its line is the whole of what Delete edits, so the
+ * item below moves up into it rather than being lifted, and the empty item is spent. A
+ * fence below takes no prose line (`joinOntoList`), so there the empty line goes alone.
+ *
  * Declining wherever the chain does is what keeps this to the list's own seams: a
  * boundary inside one item, and the list's outer edge, stay the base keymap's, where
  * the two keys already answer alike.
@@ -142,13 +175,35 @@ function backspaceBelow(itemType, press) {
         const below = Selection.near(state.doc.resolve($from.after()), 1);
         if (below.from <= $from.pos)
             return false;
+        if ($from.parent.content.size === 0) {
+            if (!!below.$from.parent.type.spec.code === !!$from.parent.type.spec.code)
+                return joinTextblockForward(state, dispatch);
+            if (dispatch) {
+                const tr = state.tr.deleteRange($from.before(), $from.after());
+                dispatch(tr.setSelection(Selection.near(tr.doc.resolve(tr.mapping.map(below.from)), 1)));
+            }
+            return true;
+        }
         const pressed = $from.pos;
         const keepCaret = (tr) => dispatch?.(tr.setSelection(TextSelection.create(tr.doc, tr.mapping.map(pressed))));
         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
@@ -160,11 +215,12 @@ 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`
- * forks on the item's index: the first item lifts, any later one merges. `Delete` is
+ * so the third link lifts a top-level empty item out to a paragraph. `Backspace` lifts
+ * an item at its start, and joins a block onto the list it stands after. `Delete` is
  * that same chain at the seam below rather than a second table of cases beside it, so
  * the two keys cannot come to differ over a seam this link reaches. An empty line is
  * not one: the block link takes it ahead of this chain (`blocks.ts`), the caret's own
@@ -175,11 +231,11 @@ export function listKeymap(schema) {
     const paragraph = schema.nodes.paragraph;
     if (!itemType || !paragraph)
         return {};
-    const backspace = chainCommands(liftAtListStart(itemType), mergeIntoPreviousItem(itemType));
+    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

@@ -29,6 +29,14 @@ li.ProseMirror-selectednode::after {
 	border: var(--_qm-ring);
 	left: calc(var(--_qm-space-4) * -1);
 }
+/* A node selection is drawn while its leaf holds the focus, as a text selection is: a
+   ring left behind on a field the focus has moved off names a subject no key reaches. */
+.ProseMirror:not(:focus-within) .ProseMirror-selectednode {
+	outline: none;
+}
+.ProseMirror:not(:focus-within) li.ProseMirror-selectednode::after {
+	border: none;
+}
 
 /* The gap cursor (`prosemirror-gapcursor`, imported beside this file): a caret
    between two blocks, where the document holds no text position for an ordinary one.
@@ -140,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
@@ -183,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
@@ -227,9 +302,12 @@ li.ProseMirror-selectednode::after {
    empty line the caret holds. Only while the leaf has the focus: the decoration follows
    the selection, which an unfocused leaf keeps. Upright, being chrome about the key
    rather than an invitation in the document's voice, and never over a ghost, which is
-   the leaf's own word for the same empty line. */
+   the leaf's own word for the same empty line. It comes up once the caret has rested
+   there, a new empty line starting the wait over. */
 .ProseMirror-focused .qm-slash-hint:not(.qm-prose-placeholder)[data-slash-hint]::after {
 	content: attr(data-slash-hint);
+	animation: qm-slash-hint-in var(--_qm-reveal) both;
+	animation-delay: var(--_qm-hint-wait);
 	display: block;
 	margin-top: -1lh;
 	white-space: nowrap;
@@ -239,6 +317,12 @@ li.ProseMirror-selectednode::after {
 	pointer-events: none;
 }
 
+@keyframes qm-slash-hint-in {
+	from {
+		opacity: 0;
+	}
+}
+
 /* ── The table island ────────────────────────────────────────────────────────
 
    The one construct in this file with chrome in it. The rest of the stylesheet
@@ -313,19 +397,16 @@ li.ProseMirror-selectednode::after {
 .qm-table {
 	border-collapse: separate;
 	border-spacing: 0;
-	border: var(--_qm-border-width) solid var(--_qm-border);
-	border-radius: var(--_qm-radius-inner);
+	border: var(--_qm-border-width) solid var(--_qm-rule);
+	border-radius: var(--_qm-radius);
 }
-/* Two tiers of rule, because a table draws two different things. The frame and the
-   header's rule are structure and keep the full hairline; the lines between cells are
-   rhythm and drop to the faint rung, so the grid reads as one object with divisions
-   rather than as a stack of boxes. `separate` with zero spacing rather than
-   `collapse`: a collapsed border cannot be rounded, and the two tiers would fight
-   over which one wins an edge. */
+/* One rule at one strength, the frame's and every line between cells, so the grid
+   reads at the weight of the type it holds. `separate` with zero spacing rather than
+   `collapse`: a collapsed border cannot be rounded. */
 .qm-table-cell {
 	position: relative;
-	border-right: var(--_qm-border-width) solid var(--_qm-border-faint);
-	border-bottom: var(--_qm-border-width) solid var(--_qm-border-faint);
+	border-right: var(--_qm-border-width) solid var(--_qm-rule);
+	border-bottom: var(--_qm-border-width) solid var(--_qm-rule);
 	padding: var(--_qm-space) var(--_qm-space-2);
 	vertical-align: top;
 	font-weight: inherit;
@@ -339,13 +420,29 @@ li.ProseMirror-selectednode::after {
 }
 /* The header row is the one weight distinction the island draws: `header` is a
    separate field in the model rather than a flag on a row, so the surface says so.
-   It takes a tone with it, which is the same move a field makes: the well rung, a
-   band cut into the paper rather than a layer stacked on it, and a rung either way
-   rather than a shadow. The rest of a table's type is paper's. */
+   It takes a tone with it, the band rung, a step toward the ink at both poles. The
+   rest of a table's type is paper's. */
 .qm-table-header-row .qm-table-cell {
 	font-weight: var(--_qm-weight-strong);
-	background: var(--_qm-surface-well);
-	border-bottom: var(--_qm-border-width) solid var(--_qm-border);
+	background: var(--_qm-surface-band);
+}
+/* The corner cells take the frame's corner, inside its stroke, so a header's band or a
+   selection's wash keeps to the rounded edge rather than painting a square one over
+   it. The first row is the colgroup's next sibling's, whichever section holds it. */
+.qm-table > colgroup + * > tr:first-child > .qm-table-cell:first-child {
+	border-start-start-radius: calc(var(--_qm-radius) - var(--_qm-border-width));
+}
+.qm-table > colgroup + * > tr:first-child > .qm-table-cell:last-child {
+	border-start-end-radius: calc(var(--_qm-radius) - var(--_qm-border-width));
+}
+.qm-table
+	> :is(:last-child, thead:has(+ tbody:empty))
+	> tr:last-child
+	> .qm-table-cell:first-child {
+	border-end-start-radius: calc(var(--_qm-radius) - var(--_qm-border-width));
+}
+.qm-table > :is(:last-child, thead:has(+ tbody:empty)) > tr:last-child > .qm-table-cell:last-child {
+	border-end-end-radius: calc(var(--_qm-radius) - var(--_qm-border-width));
 }
 /* A cell holds a whole nested view. Its measure floor keeps an empty table from
    collapsing to a row of hairlines with nothing to aim at, and the caret is the
@@ -400,20 +497,16 @@ li.ProseMirror-selectednode::after {
 	color: var(--_qm-ink);
 	cursor: pointer;
 }
-/* The bar every one of them draws: a pill the length of what it acts on, a rhythm rung
-   thick where the target is the tap floor. Stated once, so a grip and an add bar cannot
-   drift into two shapes.
-
-   One tone, not a hover ladder: the control is drawn only while it is the one the
-   pointer is on or the one a gesture is about, so a resting tone under that would be a
-   rung nothing ever reaches. The selected grip's tint below is the one exception, and it
-   says which line the next command acts on rather than where the pointer is. */
+/* The pill every one of them draws, a rhythm rung thick where the target is the tap
+   floor. Stated once, so a grip and an add bar cannot drift into two shapes. The selected
+   grip's tint below says which line the next command acts on rather than where the
+   pointer is. */
 :is(.qm-table-grip-bar, .qm-table-add-bar) {
 	display: flex;
 	align-items: center;
 	justify-content: center;
 	border-radius: var(--_qm-radius-pill);
-	background: var(--_qm-border);
+	background: var(--_qm-surface-band);
 	transition:
 		background-color var(--_qm-duration-fast) var(--_qm-ease-reverse),
 		color var(--_qm-duration-fast) var(--_qm-ease-reverse);
@@ -424,32 +517,34 @@ li.ProseMirror-selectednode::after {
 	width: var(--_qm-space-3);
 	height: var(--_qm-space-3);
 }
-/* A grip runs along the line it names; an add bar runs across the axis it appends to.
-   So the two families map one `data-axis` onto opposite orientations, and orientation
-   is the one thing the rule above cannot share with them: a column's grip is as wide as
-   its column, and the bar that adds a column is as tall as the table. */
-.qm-table-grip[data-axis='column'] .qm-table-grip-bar,
+/* An add bar runs across the axis it appends to, the length of the table; a grip is a
+   short pill centred on the line it names, the tap floor long. */
 .qm-table-add[data-axis='row'] .qm-table-add-bar {
 	width: 100%;
 	height: var(--_qm-space-3);
 }
-.qm-table-grip[data-axis='row'] .qm-table-grip-bar,
 .qm-table-add[data-axis='column'] .qm-table-add-bar {
 	width: var(--_qm-space-3);
 	height: 100%;
 }
+.qm-table-grip[data-axis='column'] .qm-table-grip-bar {
+	width: var(--_qm-tap-min);
+	height: var(--_qm-space-3);
+}
+.qm-table-grip[data-axis='row'] .qm-table-grip-bar {
+	width: var(--_qm-space-3);
+	height: var(--_qm-tap-min);
+}
 
-/* One grip per line, and it is a bar rather than a glyph: what a grip acts on is the
-   row or column it sits against, and spanning that line says so better than an icon
-   could. The bar carries the grip's own marks — two rows of three, the shape a thing
-   you can pick up has everywhere else — so the control reads as draggable before it is
-   dragged.
+/* One grip per line. The pill carries the grip's own marks at the label ink — two rows
+   of three, the shape a thing you can pick up has everywhere else — so the control reads
+   as draggable before it is dragged.
 
-   The target is the band and the bar is drawn inside it: a grip spans its line on one
-   axis and the tap floor on the other, and the bar is drawn thinner inside that. A grip
-   sized to its own bar would be a target the thickness of the mark on it, on a control
-   the pointer has to find. */
+   The target is the band and the pill is drawn inside it: a grip spans its line on one
+   axis and the tap floor on the other. A grip sized to its own pill would be a target
+   the size of the mark on it, on a control the pointer has to find. */
 .qm-table-grip {
+	color: var(--_qm-ink-label);
 	/* The pointer owns this gesture, not the page's scroll: a grip drags. */
 	touch-action: none;
 }
@@ -488,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 has travelled off. The controls' boxes meet at no point, so what is drawn is
-   the one line the pointer has picked out.
+   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-grip:is(:hover, [aria-pressed='true'], .qm-table-lifted) {
+.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. */
@@ -582,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. */