@quillmark/svelte 0.20.1 → 0.22.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/THEMING.md

@@ -56,7 +56,7 @@ The poles take a colour, not `transparent` or `inherit`: the raised surfaces, th
 | `--qm-bg`        | `#fff` / `#272729`                     | Base surface: a card, and the preview's sheet. Fields, the popover and the column behind the cards each step off it.                                           |
 | `--qm-fg`        | `#1c1c1c` / `#d7dadc`                  | Base ink. Body text, labels, and borders step off it.                                                                                                          |
 | `--qm-accent`    | `#71717a` / `#a1a1aa`                  | Focus rings, active marks, the preview's active field box. The surface spends no hue of its own, so this is the one it wears.                                  |
-| `--qm-danger`    | `#9e1518` / `#f9786c`                  | Error diagnostics, the required marker, the delete glyph.                                                                                                      |
+| `--qm-danger`    | `#9e1518` / `#f9786c`                  | Error diagnostics and the delete glyph.                                                                                                                        |
 | `--qm-font`      | `ui-sans-serif, system-ui, sans-serif` | The editor surface's font family. Controls and buttons take it too, in place of the UA face.                                                                   |
 | `--qm-font-mono` | `ui-monospace, monospace`              | The monospace face: the JSON array control, the tips card.                                                                                                     |
 | `--qm-font-size` | `0.875rem`                             | Chrome text: every control's size, the anchor the ramp derives up (title) and down (label/meta) from, and the anchor a document body sits one small step over. |

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

@@ -1,5 +1,7 @@
 // The block-atom link of the body's Backspace/Delete chains: a delete against an
-// island or a divider selects it, and the press after that deletes it.
+// island or a divider selects it, and the press after that deletes it. A table is the
+// exception, having cells a caret can enter: the press steps into it instead, so a
+// delete against one edits nothing (§`againstAtom`).
 //
 // This is the neighbour half of the rule the leaf already holds for a key typed over a
 // selection (CODEC §"The table island"): a selection is the subject of the next
@@ -12,6 +14,7 @@
 // first item lifts the item, and that stays the item's answer whatever sits above the
 // list.
 import { NodeSelection, TextSelection } from 'prosemirror-state';
+import { tableAt } from './table-view.js';
 /** The caret, when it sits at a textblock edge with an empty selection: the only place
  *  a delete is about a neighbour rather than about a character. `null` everywhere else,
  *  which is where the key keeps its ordinary meaning. */
@@ -44,25 +47,37 @@ function cutAt($pos, side) {
     }
     return null;
 }
-/** Select the block atom the caret is against, rather than deleting it. Declines when
- *  the neighbour is anything a caret can enter, so a paragraph, a heading, a quote and
- *  a list all keep the join the base keymap gives them. */
-function selectAtom(side) {
-    return (state, dispatch) => {
+/** The press against a block atom: select it, rather than deleting it, or step into a
+ *  mounted table, its last cell from below and its first from above. An empty line under
+ *  a table goes with the step, its Backspace having nothing of its own to edit. Declines
+ *  when the neighbour is anything else a caret can enter, so a paragraph, a heading, a
+ *  quote and a list all keep the join the base keymap gives them. */
+function againstAtom(side) {
+    return (state, dispatch, view) => {
         const $head = atEdge(state, side);
         const $cut = $head && cutAt($head, side);
-        if (!$cut)
+        if (!$head || !$cut)
             return false;
         const node = side < 0 ? $cut.nodeBefore : $cut.nodeAfter;
         if (!node || !node.isAtom || !node.isBlock || !NodeSelection.isSelectable(node))
             return false;
         const at = side < 0 ? $cut.pos - node.nodeSize : $cut.pos;
-        dispatch?.(state.tr.setSelection(NodeSelection.create(state.doc, at)).scrollIntoView());
+        const table = view && tableAt(view, at);
+        if (!table) {
+            dispatch?.(state.tr.setSelection(NodeSelection.create(state.doc, at)).scrollIntoView());
+            return true;
+        }
+        if (!dispatch)
+            return true;
+        const index = $head.index(-1);
+        if (side < 0 && $head.parent.content.size === 0 && $head.node(-1).canReplace(index, index + 1))
+            dispatch(state.tr.delete($head.before(), $head.after()));
+        table.enter(side);
         return true;
     };
 }
 /**
- * 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
@@ -72,7 +87,7 @@ export function atomKeymap(schema) {
     if (!schema.nodes.island_block)
         return {};
     return {
-        Backspace: selectAtom(-1),
-        Delete: selectAtom(1)
+        Backspace: againstAtom(-1),
+        Delete: againstAtom(1)
     };
 }

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

@@ -3,11 +3,11 @@ import type { Command, EditorState, Transaction } from 'prosemirror-state';
 /** `# `: the heading `level` deep. `list_item` is `block+`, so one inside an item is a
  *  shape the content holds and `importMarkdown` produces from `- # title`. */
 export declare function toHeading(level: number): Command;
-/** A fence. The exit paragraph after it is the one a block island mints for the same
- *  reason, sharpened: a code block is the one block a gap cursor will not sit beside
- *  either, so a fence at the end of a body leaves the caret nowhere to go. The caret
- *  stays in the fence, not in the exit it minted. */
-export declare function toCodeBlock(): Command;
+/** A fence, carrying `attrs` (its `lang`). The exit paragraph after it is the one a
+ *  block island mints for the same reason, sharpened: a code block is the one block a
+ *  gap cursor will not sit beside either, so a fence at the end of a body leaves the
+ *  caret nowhere to go. The caret stays in the fence, not in the exit it minted. */
+export declare function toCodeBlock(attrs?: Attrs): Command;
 /** `---`. A divider is a whole block, so this replaces its textblock rather than
  *  retyping one: `horizontal_rule` holds no content to retype into, and an empty block
  *  is the whole of what it may replace — anything else in one is a paragraph being

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,24 +75,24 @@ 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`. */
 export function toHeading(level) {
     return retype('heading', { level });
 }
-/** A fence. The exit paragraph after it is the one a block island mints for the same
- *  reason, sharpened: a code block is the one block a gap cursor will not sit beside
- *  either, so a fence at the end of a body leaves the caret nowhere to go. The caret
- *  stays in the fence, not in the exit it minted. */
-export function toCodeBlock() {
+/** A fence, carrying `attrs` (its `lang`). The exit paragraph after it is the one a
+ *  block island mints for the same reason, sharpened: a code block is the one block a
+ *  gap cursor will not sit beside either, so a fence at the end of a body leaves the
+ *  caret nowhere to go. The caret stays in the fence, not in the exit it minted. */
+export function toCodeBlock(attrs) {
     return (state, dispatch) => {
         const { code_block: code, paragraph } = state.schema.nodes;
         const { $from } = state.selection;
         if (!code || !paragraph || !atHead(state) || !fits($from, code))
             return false;
-        const tr = state.tr.setBlockType($from.pos, $from.pos, code);
+        const tr = state.tr.setBlockType($from.pos, $from.pos, code, attrs);
         const at = tr.doc.resolve($from.pos).after();
         if (!tr.doc.nodeAt(at))
             tr.insert(at, paragraph.create());
@@ -322,6 +324,22 @@ const takeEmptyLine = (state, dispatch) => {
     dispatch?.(state.tr.delete($from.before(), $from.after()).scrollIntoView());
     return true;
 };
+/**
+ * Backspace at a heading's head → a paragraph, where it stands, and the press after is
+ * the join. The first press takes off the block's own shape, which is the whole of what
+ * it edits: the base keymap's join would merge the heading's text into the block above
+ * and lose the heading with it, and at the body's start it does nothing at all.
+ */
+const unheading = (state, dispatch) => {
+    const paragraph = state.schema.nodes.paragraph;
+    const { $from } = state.selection;
+    if (!paragraph || !atHead(state) || $from.parent.type.name !== 'heading')
+        return false;
+    if (!fits($from, paragraph))
+        return false;
+    dispatch?.(state.tr.setBlockType($from.pos, $from.pos, paragraph).scrollIntoView());
+    return true;
+};
 /** The body-wide link of the leaf's key chains: `{}` for a schema with no paragraph
  *  to mint. Outermost of the structural links, being about the body, or about the
  *  caret's own line, rather than about the surface either stands in. */
@@ -330,6 +348,7 @@ export function blockKeymap(schema) {
         return {};
     return {
         Enter: chainCommands(paragraphAtBodyStart, paragraphFromEmptyFence, splitAcrossBlocks),
+        Backspace: unheading,
         Delete: takeEmptyLine
     };
 }

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
@@ -9,8 +9,8 @@ import { type Command } from 'prosemirror-state';
  * otherwise splits the item in two, each half holding a code block. `Shift-Enter` is
  * the same command because it is the same edit: the line break the key means
  * everywhere else (`breaks.ts`) is, inside a fence, the newline Enter already takes.
- * Every command here declines away from a code block — inside one for the four keys
- * about its text, against one for the two about its edge — so the list links keep the
- * keys elsewhere.
+ * Every command here declines away from a code block — inside one for the keys about
+ * its text and its last line, against one for the two about its edge — so the list
+ * links keep the keys elsewhere.
  */
 export declare function codeKeymap(schema: Schema): Record<string, Command>;

package/dist/core/codec/code.js

@@ -1,4 +1,4 @@
-import { TextSelection } from 'prosemirror-state';
+import { Selection, TextSelection } from 'prosemirror-state';
 import { newlineInCode } from 'prosemirror-commands';
 /** One indent level. */
 const UNIT = '  ';
@@ -107,7 +107,7 @@ const outdentInCode = (state, dispatch) => {
  * The textblock the caret's own block stands directly against on `side`: its sibling
  * under one parent, which is the only neighbour a press joins the text of. `null` at a
  * container's edge, where the base keymap moves the whole block in or out rather than
- * joining anything, and so retypes nothing.
+ * joining anything, and so changes nothing here.
  */
 function blockAgainst(state, side) {
     const { $from, empty } = state.selection;
@@ -122,22 +122,22 @@ function blockAgainst(state, side) {
     return { node, pos: side < 0 ? $edge.pos - node.nodeSize : $edge.pos };
 }
 /**
- * Backspace at a fence's head or Delete at its end, and the same two presses from the
- * block on the other side: retype the code block to a paragraph, and join nothing. The
- * press after that is an ordinary join between two prose blocks.
+ * Backspace or Delete at a fence's edge, from either side, edits only the block the caret
+ * is in.
  *
- * The join itself retypes one side's whole text as the other's kind on one keystroke —
- * a fence's lines as prose, or a typed line as code — which is the destruction
- * `atoms.ts` refuses for a neighbouring island, with nothing drawn first to say what is
- * about to go. This is `toCodeBlock`'s inverse in its place (`blocks.ts`), and it takes
- * no text with it: `linebreakReplacement` carries the fence's newlines across as breaks
- * (`schema.ts`). The caret stays in the block it was in.
+ * Inside the fence, a press at its head or its end retypes it to a paragraph and joins
+ * nothing: `toCodeBlock`'s inverse in its place (`blocks.ts`), taking no text with it,
+ * since `linebreakReplacement` carries the fence's newlines across as breaks
+ * (`schema.ts`). The press after that is an ordinary join between two prose blocks.
+ *
+ * From the prose block against it, the caret steps into the fence, to the end it faces,
+ * and the fence is left as it is: a join would retype one side's whole text as the
+ * other's kind, and a retype from outside edits a block the caret is not in. An empty
+ * line under a fence goes with the step, its Backspace having nothing of its own to edit.
  *
  * Declines where both sides are code and where neither is: those joins retype nothing.
- * An empty block on either side never reaches this at all: the block link takes the
- * empty line ahead of the chain (`blocks.ts`), and there is no text to retype.
  */
-function retypeAtProseEdge(side) {
+function atProseEdge(side) {
     return (state, dispatch) => {
         const paragraph = state.schema.nodes.paragraph;
         const edge = blockAgainst(state, side);
@@ -147,13 +147,42 @@ function retypeAtProseEdge(side) {
         const inside = !!$from.parent.type.spec.code;
         if (inside === !!edge.node.type.spec.code)
             return false;
-        const at = inside ? $from.pos : edge.pos + 1;
-        dispatch?.(state.tr.setBlockType(at, at, paragraph).scrollIntoView());
+        if (inside) {
+            dispatch?.(state.tr.setBlockType($from.pos, $from.pos, paragraph).scrollIntoView());
+            return true;
+        }
+        const tr = state.tr;
+        const index = $from.index(-1);
+        if (side < 0 && $from.parent.content.size === 0 && $from.node(-1).canReplace(index, index + 1))
+            tr.delete($from.before(), $from.after());
+        const into = side < 0 ? edge.pos + edge.node.nodeSize - 1 : edge.pos + 1;
+        dispatch?.(tr.setSelection(TextSelection.create(tr.doc, into)).scrollIntoView());
         return true;
     };
 }
+/** ↓ on the last line of a fence nothing follows → a paragraph after it, the caret
+ *  there: no block stands below to arrow to, and a gap cursor will not sit beside a
+ *  fence. */
+const belowFinalFence = (state, dispatch) => {
+    const paragraph = state.schema.nodes.paragraph;
+    const { $from, empty } = state.selection;
+    if (!paragraph || !empty || !$from.parent.type.spec.code)
+        return false;
+    if ($from.parent.textBetween($from.parentOffset, $from.parent.content.size).includes('\n'))
+        return false;
+    const $after = state.doc.resolve($from.after());
+    if (Selection.findFrom($after, 1))
+        return false;
+    if (!$after.parent.canReplaceWith($after.index(), $after.index(), paragraph))
+        return false;
+    if (dispatch) {
+        const tr = state.tr.insert($after.pos, paragraph.create());
+        dispatch(tr.setSelection(TextSelection.create(tr.doc, $after.pos + 1)).scrollIntoView());
+    }
+    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
@@ -161,9 +190,9 @@ function retypeAtProseEdge(side) {
  * otherwise splits the item in two, each half holding a code block. `Shift-Enter` is
  * the same command because it is the same edit: the line break the key means
  * everywhere else (`breaks.ts`) is, inside a fence, the newline Enter already takes.
- * Every command here declines away from a code block — inside one for the four keys
- * about its text, against one for the two about its edge — so the list links keep the
- * keys elsewhere.
+ * Every command here declines away from a code block — inside one for the keys about
+ * its text and its last line, against one for the two about its edge — so the list
+ * links keep the keys elsewhere.
  */
 export function codeKeymap(schema) {
     if (!schema.nodes.code_block)
@@ -173,7 +202,8 @@ export function codeKeymap(schema) {
         'Shift-Tab': outdentInCode,
         Enter: newlineInCode,
         'Shift-Enter': newlineInCode,
-        Backspace: retypeAtProseEdge(-1),
-        Delete: retypeAtProseEdge(1)
+        Backspace: atProseEdge(-1),
+        Delete: atProseEdge(1),
+        ArrowDown: belowFinalFence
     };
 }

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. */