@quillmark/svelte 0.23.0 → 0.25.0

package/README.md

@@ -14,12 +14,12 @@ npm install @quillmark/svelte
 
 Each subpath is its own module root; a bundler pulls only what the entry you import reaches.
 
-| Import                      | Surface                                                                                                               |
-| --------------------------- | --------------------------------------------------------------------------------------------------------------------- |
-| `@quillmark/svelte/core`    | What the surfaces share: the `DocPath`/`Place` address vocabulary, the `EditorError` channel, `init`. Framework-free. |
-| `@quillmark/svelte/preview` | The live preview: `createPreview` + `<Preview>`. Reaches nothing editor-side.                                         |
-| `@quillmark/svelte/visual`  | The federated WYSIWYG: `<VisualEditor>`, the codec's `createField` prose leaf.                                        |
-| `@quillmark/svelte`         | Re-exports `/core`.                                                                                                   |
+| Import                      | Surface                                                                                                                |
+| --------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `@quillmark/svelte/core`    | What the surfaces share: the `DocPath`/`Place` address vocabulary, the `EditorError` channel, `init`. No UI framework. |
+| `@quillmark/svelte/preview` | The live preview: `createPreview` + `<Preview>`. Reaches nothing editor-side.                                          |
+| `@quillmark/svelte/visual`  | The federated WYSIWYG: `<VisualEditor>`, the codec's `createField` prose leaf.                                         |
+| `@quillmark/svelte`         | Re-exports `/core`.                                                                                                    |
 
 ## Open a session
 
@@ -29,8 +29,7 @@ The **consumer** owns the session and the handles, and drives every edit; the su
 import { Engine } from '@quillmark/wasm';
 import { init } from '@quillmark/svelte/core';
 
-// One-time, and the only door to Quill and Document: the artifact exports
-// neither statically.
+// Quill and Document are exported only through init(), which loads the wasm once.
 const { Quill, Document } = await init();
 
 const quill = Quill.fromTree(tree); // tree: Map<string, Uint8Array> of the quill dir

package/THEMING.md

@@ -175,7 +175,7 @@ An app that mounts an editor beside a preview over one session needs a screen to
 | `.qm-switch`    | The band that says which track is showing, and nothing at the widths where both are. Its controls read as even halves and stand at the touch floor (`--qmh-tap`, 44px); depth past that is yours. |
 | `.qm-frame`     | The mounting site: an edge, a corner, and the clip that holds a surface to them. What is inside it is the surface's own.                                                                          |
 
-The narrow shape is one mount at a time, not two of them stacked: half a narrow viewport is under the width either surface reads at. The track you are not showing is `display: none`, so it leaves the tab order, hit-testing and the accessibility tree together: you need no `inert` on it, and no breakpoint in your JS, since the only state you hold is which of the two you last asked for. Keep both mounted: the hidden pane keeps its pixels, its caret and its scroll, and comes back to them — it rasters nothing at a box it has none of, and repaints only where it returns to a box of another width. A preview scroll asked for while it was hidden is held and run on the way back, so it opens at the caret rather than several edits behind it. A click that lands in the hidden pane is the one thing the shape adds to your wiring, so send the caret and reveal the track together, or the hit goes somewhere the reader cannot see.
+The narrow shape is one mount at a time, not two of them stacked: half a narrow viewport is under the width either surface reads at. The track you are not showing is `display: none`, so it leaves the tab order, hit-testing and the accessibility tree together: you need no `inert` on it, and no breakpoint in your JS, since the only state you hold is which of the two you last asked for. Keep both mounted: the hidden pane keeps its pixels, its caret and its scroll, and comes back to them — it rasters nothing at a box it has none of, and repaints only where it returns to a box that draws its pages at another scale. A preview scroll asked for while it was hidden is held and run on the way back, so it opens at the caret rather than several edits behind it. A click that lands in the hidden pane is the one thing the shape adds to your wiring, so send the caret and reveal the track together, or the hit goes somewhere the reader cannot see.
 
 The shape is shared; the look of a band is not. Your wordmark, your nav and the depth of your head are the most app-specific things on the screen, and a preset that drew them would hand every tool built on this the same face, so they read `--qmh-*` like everything else and you write the rules. `.qm-split`'s gap is a default rather than a fact about splitting: close it to `0` and carry a hairline on one pane if you want the two mounts to meet instead of stand apart.
 

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

@@ -1,4 +1,4 @@
-import type { Attrs, Node as PMNode, Schema } from 'prosemirror-model';
+import type { Attrs, Schema } from 'prosemirror-model';
 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`. */
@@ -17,19 +17,36 @@ export declare function insertDivider(): Command;
  *  content holds, where a list wrapping one mints an item whose only content is an
  *  item. */
 export declare function wrapInQuote(): Command;
-/** `- ` / `1. `. `joinBefore` is the shorthand's ordinal test: `2. ` continues the list
- *  above where `7. ` opens one. */
-export declare function wrapInList(ordered: boolean, attrs?: Attrs | null, joinBefore?: (node: PMNode) => boolean): Command;
+/** `- ` / `1. `. Beside a list of its kind the line joins it, whatever `N` is typed: a
+ *  number comes from position. Elsewhere `N. ` is the number the new list counts from,
+ *  and at the head of an item the shorthand is the item's (§`listAtItem`), `N` reading
+ *  the same way; a marker the item already shows is taken as typed and changes nothing. */
+export declare function wrapInList(ordered: boolean, attrs?: Attrs | null): Command;
+/**
+ * `a. `, `(1) `, `(a) `: the markers a nested level draws, typed at the head of a nested
+ * item's first line, where the item already is the thing typed. Taken as typed and
+ * changing nothing, as `N. ` on an item of a numbered list is: the marker comes from the
+ * item's position and the quill's style for its depth, never from the text. Anywhere
+ * else these stay text, being no markdown list marker.
+ */
+export declare function takeNestedMarker(): Command;
 /**
  * A list pick, at whatever caret the writer has. `atHead` is the shorthand's guard,
  * where a prefix firing mid-sentence would eat a dash; a pick is a gesture at the caret.
  *
  * At the end of a non-empty block it opens a fresh empty item below it, Enter then `- `
  * as one gesture. Anywhere else it wraps the whole block, the smaller surprise: a writer
- * who meant to split presses Enter first. It passes no `joinBefore`, so it continues
- * whatever list is above.
+ * who meant to split presses Enter first. In an item's first block it is the shorthand's
+ * item gesture (§`listAtItem`), offered only where that changes something.
  */
 export declare function pickList(ordered: boolean): Command;
+/**
+ * The bullet pick where it puts a line under an item one level deeper than the caret
+ * stood, and nowhere else: the pick a subparagraph names. Outside every item the bullet
+ * it would mint stands at the first level, and on a list's first item the bullet pick
+ * retypes the list instead.
+ */
+export declare function pickSubList(): Command;
 /**
  * Run `command` in place of the text at `[from, to)`: one transaction carrying the
  * delete and the command's own steps. One rather than two because two would be two

package/dist/core/codec/blocks.js

@@ -1,8 +1,10 @@
 import { Selection } from 'prosemirror-state';
 import { chainCommands, splitBlock } from 'prosemirror-commands';
+import { sinkListItem } from 'prosemirror-schema-list';
 import { canJoin, findWrapping } from 'prosemirror-transform';
 import { withinNesting } from './nesting.js';
 import { takesLineBreak } from './schema.js';
+import { joinLists } from './touching.js';
 /** The head of a textblock: where a shorthand fires, and where a pick lands once its
  *  run is consumed. */
 function atHead(state) {
@@ -15,12 +17,9 @@ function fits($from, type) {
     return $from.node(-1).canReplaceWith($from.index(-1), $from.indexAfter(-1), type);
 }
 /**
- * The head of an item that already exists: where a list shorthand is the text an author
- * typed rather than a shorthand at all.
- *
- * Firing there wraps the item's own paragraph in a fresh list, minting an item whose
- * only content is another item — a level with nothing on it. Tab is the indent gesture
- * and lands the shape a nesting is supposed to have, under the previous sibling. A
+ * The first block of an item that already exists: where a list gesture retypes the
+ * item's list rather than wrapping the block, which would mint an item whose only
+ * content is another item, a level with nothing on it. Tab is the indent gesture. A
  * later block of the item is not this case: wrapping a continuation paragraph is how a
  * sub-list opens under text.
  */
@@ -58,23 +57,23 @@ function spaceBreaks(tr, $from, type) {
         at += child.nodeSize;
     });
 }
-/** `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). 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) {
+/** `wrappingInputRule`'s body: wrap the block range at `pos`, then join a sibling of
+ *  the same type — the boundaries the wrap itself opens (`lists.ts` §cleanup:
+ *  command-local, never a global pass). A list joins on both sides (`touching.ts`), a
+ *  quote the one above. False where no wrap fits, or where the one that does nests past
+ *  `MAX_NESTING_DEPTH` (`nesting.ts`). */
+function wrapAt(tr, pos, type, attrs) {
     const range = tr.doc.resolve(pos).blockRange();
     const wrapping = range && findWrapping(range, type, attrs);
     if (!range || !wrapping)
         return false;
     tr.wrap(range, wrapping);
-    const before = tr.doc.resolve(pos - 1).nodeBefore;
-    if (before &&
-        before.type === type &&
-        canJoin(tr.doc, pos - 1) &&
-        (!joinBefore || joinBefore(before))) {
-        tr.join(pos - 1);
-    }
+    const wrapped = tr.doc.nodeAt(range.start);
+    if (wrapped)
+        joinLists(tr, range.start + wrapped.nodeSize);
+    const before = tr.doc.resolve(range.start).nodeBefore;
+    if (before && before.type === type && canJoin(tr.doc, range.start))
+        tr.join(range.start);
     return withinNesting(tr.doc);
 }
 /** `# `: the heading `level` deep. `list_item` is `block+`, so one inside an item is a
@@ -138,10 +137,96 @@ export function wrapInQuote() {
         return true;
     };
 }
-/** `- ` / `1. `. `joinBefore` is the shorthand's ordinal test: `2. ` continues the list
- *  above where `7. ` opens one. */
-export function wrapInList(ordered, attrs = null, joinBefore) {
-    return (state, dispatch) => atHead(state) && wrapBlock(state, dispatch, ordered, attrs, joinBefore);
+/** `- ` / `1. `. Beside a list of its kind the line joins it, whatever `N` is typed: a
+ *  number comes from position. Elsewhere `N. ` is the number the new list counts from,
+ *  and at the head of an item the shorthand is the item's (§`listAtItem`), `N` reading
+ *  the same way; a marker the item already shows is taken as typed and changes nothing. */
+export function wrapInList(ordered, attrs = null) {
+    return (state, dispatch) => {
+        if (!atHead(state))
+            return false;
+        const { $from } = state.selection;
+        if (openingAnItem($from, state.schema.nodes.list_item))
+            return listAtItem(ordered, attrs?.start ?? null, true)(state, dispatch);
+        return wrapBlock(state, dispatch, ordered, attrs);
+    };
+}
+/**
+ * `a. `, `(1) `, `(a) `: the markers a nested level draws, typed at the head of a nested
+ * item's first line, where the item already is the thing typed. Taken as typed and
+ * changing nothing, as `N. ` on an item of a numbered list is: the marker comes from the
+ * item's position and the quill's style for its depth, never from the text. Anywhere
+ * else these stay text, being no markdown list marker.
+ */
+export function takeNestedMarker() {
+    return (state, dispatch) => {
+        const item = state.schema.nodes.list_item;
+        const { $from } = state.selection;
+        if (!atHead(state) || !openingAnItem($from, item) || $from.depth < 3)
+            return false;
+        if ($from.node(-3).type !== item)
+            return false;
+        dispatch?.(state.tr);
+        return true;
+    };
+}
+/**
+ * A list gesture in an item's first block. On a list's first item it retypes the list,
+ * every item with it: a list is one kind, and that item is where a writer changes it.
+ * `number` is the shorthand's `N`, the list's `start`, the one door back to 1 for a list
+ * that arrived counting from elsewhere. On a later item, a list of the other kind is a
+ * sub-list: the item sinks under the one above, as Tab sinks it, into a list of that
+ * kind — `- ` in a new numbered paragraph is its first lettered subparagraph, never the
+ * whole memo turned to bullets. A sub-list already standing there of that kind takes the
+ * item as its next.
+ *
+ * A gesture that changes nothing — the kind the item's list already is, and on a first
+ * item the number it already counts from — goes unoffered as a pick. As a shorthand
+ * (`take`) it is claimed and changes nothing, so the run is consumed: a writer typing
+ * `2. Second` into the second item meant the number the item already shows, and an item
+ * reading `2. 2. Second` is the one outcome no writer typed for. Backspace on the press
+ * after gives the text back.
+ */
+function listAtItem(ordered, number, take = false) {
+    return (state, dispatch) => {
+        const { $from } = state.selection;
+        const type = state.schema.nodes[ordered ? 'ordered_list' : 'bullet_list'];
+        const item = state.schema.nodes.list_item;
+        if (!type || !item || $from.depth < 2)
+            return false;
+        const list = $from.node(-2);
+        const unchanged = () => {
+            if (take)
+                dispatch?.(state.tr);
+            return take;
+        };
+        if ($from.index(-2) === 0) {
+            const start = number ?? (list.type === type ? list.attrs.start : 1);
+            if (list.type === type && (!ordered || start === list.attrs.start))
+                return unchanged();
+            dispatch?.(state.tr.setNodeMarkup($from.before(-2), type, ordered ? { start } : null));
+            return true;
+        }
+        if (list.type === type)
+            return unchanged();
+        let sunk;
+        if (!sinkListItem(item)(state, (tr) => (sunk = tr)) || !sunk)
+            return false;
+        const tr = sunk;
+        const $at = tr.doc.resolve(tr.mapping.map($from.pos));
+        const nested = $at.node(-2);
+        if (nested.childCount === 1 && nested.type !== type) {
+            const at = $at.before(-2);
+            tr.setNodeMarkup(at, type, ordered ? { start: number ?? 1 } : null);
+            const before = tr.doc.resolve(at).nodeBefore;
+            if (before?.type === type && canJoin(tr.doc, at))
+                tr.join(at);
+        }
+        if (!withinNesting(tr.doc))
+            return false;
+        dispatch?.(tr.scrollIntoView());
+        return true;
+    };
 }
 /**
  * A list pick, at whatever caret the writer has. `atHead` is the shorthand's guard,
@@ -149,8 +234,8 @@ export function wrapInList(ordered, attrs = null, joinBefore) {
  *
  * At the end of a non-empty block it opens a fresh empty item below it, Enter then `- `
  * as one gesture. Anywhere else it wraps the whole block, the smaller surprise: a writer
- * who meant to split presses Enter first. It passes no `joinBefore`, so it continues
- * whatever list is above.
+ * who meant to split presses Enter first. In an item's first block it is the shorthand's
+ * item gesture (§`listAtItem`), offered only where that changes something.
  */
 export function pickList(ordered) {
     return (state, dispatch) => {
@@ -172,14 +257,47 @@ export function pickList(ordered) {
         return true;
     };
 }
+/** How many items the caret stands in. */
+function itemDepth($pos, item) {
+    let n = 0;
+    for (let depth = $pos.depth; depth > 0; depth--)
+        if ($pos.node(depth).type === item)
+            n++;
+    return n;
+}
+/**
+ * The bullet pick where it puts a line under an item one level deeper than the caret
+ * stood, and nowhere else: the pick a subparagraph names. Outside every item the bullet
+ * it would mint stands at the first level, and on a list's first item the bullet pick
+ * retypes the list instead.
+ */
+export function pickSubList() {
+    const pick = pickList(false);
+    return (state, dispatch) => {
+        const item = state.schema.nodes.list_item;
+        const depth = item ? itemDepth(state.selection.$from, item) : 0;
+        if (!depth)
+            return false;
+        let picked;
+        if (!pick(state, (tr) => (picked = tr)) || !picked)
+            return false;
+        if (itemDepth(picked.selection.$from, item) <= depth)
+            return false;
+        dispatch?.(picked);
+        return true;
+    };
+}
 /** Wrap the caret's whole block in a list, wherever in the block the caret sits: the
- *  wrap opens at the block's head, so it joins the list above as the shorthand's does. */
-function wrapBlock(state, dispatch, ordered, attrs, joinBefore) {
+ *  wrap opens at the block's head, so it joins the lists beside it as the shorthand's
+ *  does. */
+function wrapBlock(state, dispatch, ordered, attrs) {
     const { paragraph, list_item: item } = state.schema.nodes;
     const list = state.schema.nodes[ordered ? 'ordered_list' : 'bullet_list'];
     const { $from } = state.selection;
-    if (!list || !paragraph || openingAnItem($from, item))
+    if (!list || !paragraph)
         return false;
+    if (openingAnItem($from, item))
+        return listAtItem(ordered, null)(state, dispatch);
     const pos = $from.start();
     const tr = state.tr;
     // A paragraph item wherever this fires: `# ` inside the item is the gesture that
@@ -187,7 +305,7 @@ function wrapBlock(state, dispatch, ordered, attrs, joinBefore) {
     // that shape. Positions survive the retype — same content, same size.
     if ($from.parent.type !== paragraph)
         tr.setBlockType(pos, pos, paragraph);
-    if (!wrapAt(tr, pos, list, attrs, joinBefore))
+    if (!wrapAt(tr, pos, list, attrs))
         return false;
     dispatch?.(tr);
     return true;
@@ -224,18 +342,18 @@ function atBodyStart($from) {
  * Enter at the very start of a body whose first block takes no caret above it → an
  * empty paragraph there, the caret staying with the text it pushed down.
  *
- * A code block, a quote and a list are the blocks `prosemirror-gapcursor` declines
- * to sit beside, and nothing else mints a block above one: three keystrokes on an
- * empty body (` ``` `, `> `, `- `) put one first, and a document carrying one there
- * can never be given a title. The argument is `paragraphAboveList`'s, about the
- * block rather than about lists, so this link comes first and that one holds the
- * position it alone reaches, a list under an island or a rule.
+ * A code block and a quote are blocks `prosemirror-gapcursor` declines to sit beside,
+ * and nothing else mints a block above one: two keystrokes on an empty body (` ``` `,
+ * `> `) put one first, and a document carrying one there could never be given a title.
  *
  * Declines wherever the first block is a plain textblock, whose Enter-split already
- * leaves a paragraph above, and on an empty one, which the links after it answer.
+ * leaves a paragraph above, and on an empty one, which the links after it answer. An
+ * item's first line of prose declines too: Enter at its head is the list's new first
+ * item, as at every item, and the empty item's own Enter lifts it out to the paragraph a
+ * title takes. A fence opening that item is the fence case and takes the paragraph.
  */
 const paragraphAtBodyStart = (state, dispatch) => {
-    const paragraph = state.schema.nodes.paragraph;
+    const { paragraph, list_item: item } = state.schema.nodes;
     const { $from, empty } = state.selection;
     if (!paragraph || !empty || !atBodyStart($from))
         return false;
@@ -243,6 +361,8 @@ const paragraphAtBodyStart = (state, dispatch) => {
         return false;
     if ($from.depth === 1 && $from.parent.isTextblock && !$from.parent.type.spec.code)
         return false;
+    if (item && $from.depth >= 2 && $from.node(-1).type === item && !$from.parent.type.spec.code)
+        return false;
     dispatch?.(state.tr.insert(0, paragraph.create()).scrollIntoView());
     return true;
 };
@@ -310,7 +430,8 @@ const splitAcrossBlocks = (state, dispatch) => {
  * are the whole of what holds them, and the key is whichever link answers a construct
  * with nothing in it. An empty fence is not that case — the doc spares it, and it
  * carries no text to lose. Declines with nothing after it too: a line with no next
- * line is Backspace's.
+ * line is Backspace's. The line was the one thing between two lists of a kind, they
+ * are one list after it.
  */
 const takeEmptyLine = (state, dispatch) => {
     const { $from, empty } = state.selection;
@@ -321,7 +442,11 @@ const takeEmptyLine = (state, dispatch) => {
         return false;
     if (!Selection.findFrom(state.doc.resolve($from.after()), 1))
         return false;
-    dispatch?.(state.tr.delete($from.before(), $from.after()).scrollIntoView());
+    if (dispatch) {
+        const tr = state.tr.delete($from.before(), $from.after());
+        joinLists(tr, $from.before());
+        dispatch(tr.scrollIntoView());
+    }
     return true;
 };
 /**

package/dist/core/codec/code.js

@@ -75,14 +75,9 @@ const indentInCode = (state, dispatch) => {
 /**
  * Shift-Tab in a code block: remove one indent level from every covered line.
  *
- * Declines when no covered line carries an indent, so the key is not swallowed: it
- * falls through to the list link and, outside a list, on out of the leaf — the
- * body's keyboard exit from inside a code block (VISUAL_EDITOR §Chrome). Inside
- * a `list_item > code_block` the list link claims it and lifts the item out
- * (`tests/codec/code-keys.test.ts`), so a fence in an item has no keyboard exit in
- * either direction — Tab is a code block's whole point and takes the key
- * unconditionally. What a body's keyboard exit should be settles in the shell keymap
- * (VISUAL_EDITOR §Settled and open), not here.
+ * Declines when no covered line carries an indent, so the key falls through to the
+ * list link: inside a `list_item > code_block` it lifts the item out
+ * (`tests/codec/code-keys.test.ts`), and outside a list the body holds it (`keymap.ts`).
  */
 const outdentInCode = (state, dispatch) => {
     const block = codeBlockAt(state);

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

@@ -29,7 +29,8 @@ 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 ({@link editable}),
+ *  store; on the block schema anything but a construct read and not edited — an element,
+ *  a definition list ({@link editable}), a footnote or an equation (`isEditedIsland`) —
  *  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

@@ -8,7 +8,7 @@
 // applied here; they are decorations (field.ts). Positions throughout are USV; `Array.from` iterates by
 // code point so an astral char is one unit, never a surrogate half.
 import { DOMSerializer } from 'prosemirror-model';
-import { ISLAND_SLOT, isBlockIsland } from './islands.js';
+import { ISLAND_SLOT, isBlockIsland, isEditedIsland } from './islands.js';
 import { descriptorOf, markKey, pmMarkFromContent } from './marks.js';
 import { core } from '../lifecycle.js';
 import { hasMarks, isBlockSchema, isInlineSchema, takesLineBreak } from './schema.js';
@@ -96,7 +96,8 @@ 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 ({@link editable}),
+ *  store; on the block schema anything but a construct read and not edited — an element,
+ *  a definition list ({@link editable}), a footnote or an equation (`isEditedIsland`) —
  *  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. */
@@ -105,11 +106,16 @@ export function fitsLeaf(rt, leaf) {
         return fitsInline(rt);
     if (leaf.plaintext)
         return fitsPlain(rt);
-    return (leaf.islands || rt.islands.length === 0) && rt.lines.every(editable);
+    if (!leaf.islands && rt.islands.length)
+        return false;
+    return rt.islands.every((isl) => isEditedIsland(isl.type)) && rt.lines.every(editable);
 }
-/** Whether every container on `line` is one the block schema edits: an element decodes
- *  to no node, so the first commit would drop it. */
+/** Whether the block schema edits `line`'s kind and every container on it: a term draws
+ *  as a paragraph and an element and a description as the blocks they wrap, so the first
+ *  commit would drop each. */
 function editable(line) {
+    if (line.kind === 'term')
+        return false;
     return line.containers.every((c) => c.container === 'quote' || c.container === 'list_item');
 }
 /** Inline decode: one paragraph, containers and islands stripped. */
@@ -192,9 +198,9 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
             i = j;
             continue;
         }
-        if (here.container === 'element') {
-            // No node holds an element, and a leaf holding one is held (`fitsLeaf`), so
-            // what it wraps draws in place, read-only.
+        if (here.container === 'element' || here.container === 'description') {
+            // No node holds an element or a description, and a leaf holding one is held
+            // (`fitsLeaf`), so what it wraps draws in place, read-only.
             const key = containerKey(here);
             let j = i + 1;
             while (j < leaves.length) {
@@ -249,7 +255,7 @@ function instanceOf(c) {
 }
 /** Identity of a container for run gathering: its name, its `instance` and an element's
  * attributes, NUL-joined as `markKey` joins a mark's. `list_item` carries its own run
- * rule, so the quote and the element are what key here. */
+ * rule, so the rest are what key here. */
 function containerKey(c) {
     const attrs = c.container === 'element' ? JSON.stringify(c.attrs) : '';
     return `${c.container}\u0000${instanceOf(c)}\u0000${attrs}`;
@@ -269,13 +275,15 @@ function makeLeaf(schema, leaf, marks, cursor) {
             return schema.nodes.code_block.create({ lang: line.attrs?.lang ?? null }, content);
         }
         case 'para':
+        case 'term':
         case 'heading': {
-            if (line.kind === 'para' && blockIslandLine(leaf, cursor))
+            if (line.kind !== 'heading' && blockIslandLine(leaf, cursor))
                 return schema.nodes.island_block.create(islandAttrs(cursor));
             // Inline content, the segment boundary a `hard_break` in a paragraph and a space
             // in a heading, which takes none (`schema.ts` §`takesLineBreak`). A stored heading
             // carries no continuation — the store clears one after a block of a single line —
-            // so the space is what keeps a hand-built content decodable.
+            // so the space is what keeps a hand-built content decodable. A term draws as a
+            // paragraph, read-only (`fitsLeaf`).
             const type = line.kind === 'heading' ? schema.nodes.heading : schema.nodes.paragraph;
             const inline = [];
             leaf.segments.forEach((seg, idx) => {

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

@@ -28,7 +28,8 @@ export interface CreateFieldOpts {
      * leaf, or a `text` one, is held over a value its schema cannot
      * hold (`fitsLeaf`, upstream's `isInline` and `isPlain`): the decode would join lines
      * and drop containers and islands for the first commit to store. Any leaf is held
-     * over an element, which no node holds. A held leaf draws
+     * over what is read and not edited: an element, a definition list, a footnote and an
+     * equation (CODEC §Decode). A held leaf draws
      * its content on the block schema, read-only, and commits nothing. Judged of the value
      * each mount and re-hydrate reads, so {@link FieldController.applyExternal} is what
      * re-evaluates it.
@@ -199,7 +200,8 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
 /**
  * The prose-leaf plugin stack (VISUAL_EDITOR §Surface): shared by
  * {@link createField} and the by-value editor (`ProseValue`), so the two
- * never fork the keymap/plugin ordering. History first, then any leaf-specific
+ * never fork the keymap/plugin ordering. History first, with the plugin that starts an
+ * undo step at each block-moving edit (`undo.ts`), then any leaf-specific
  * plugins (`afterHistory`: the addressed leaf passes its anchor-position plugin;
  * a by-value leaf passes none), then {@link linebreakPlugin}, which normalizes what
  * the rest of the stack leaves, then the markdown-shorthand input rules and the
@@ -207,7 +209,8 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
  * 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`), the markdown paste
- * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`).
+ * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`). A one-line leaf's
+ * paste joins its lines (`line-paste.ts`).
  *
  * 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

package/dist/core/codec/field.js

@@ -31,10 +31,13 @@ import { contentEqual, createReconciler } from './reconcile.js';
 import { inputRulesPlugin, undoRuleKeymap } from './inputrules.js';
 import { linebreakPlugin } from './breaks.js';
 import { bodyKeymap } from './keymap.js';
-import { blockSchema, isBlockSchema, leafSchema, plainSchema } from './schema.js';
+import { blockSchema, isBlockSchema, isInlineSchema, leafSchema, plainSchema } from './schema.js';
 import { linkPastePlugin } from './link-paste.js';
+import { linePastePlugin } from './line-paste.js';
+import { listPastePlugin } from './list-paste.js';
 import { markdownPastePlugin } from './markdown-paste.js';
 import { nestingPlugin } from './nesting.js';
+import { undoStepPlugin } from './undo.js';
 import { tablePastePlugin } from './table-paste.js';
 import { tableCopyPlugin } from './table-copy.js';
 import { taskPlugin } from './tasks.js';
@@ -533,7 +536,8 @@ export function createField(opts) {
 /**
  * The prose-leaf plugin stack (VISUAL_EDITOR §Surface): shared by
  * {@link createField} and the by-value editor (`ProseValue`), so the two
- * never fork the keymap/plugin ordering. History first, then any leaf-specific
+ * never fork the keymap/plugin ordering. History first, with the plugin that starts an
+ * undo step at each block-moving edit (`undo.ts`), then any leaf-specific
  * plugins (`afterHistory`: the addressed leaf passes its anchor-position plugin;
  * a by-value leaf passes none), then {@link linebreakPlugin}, which normalizes what
  * the rest of the stack leaves, then the markdown-shorthand input rules and the
@@ -541,7 +545,8 @@ export function createField(opts) {
  * 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`), the markdown paste
- * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`).
+ * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`). A one-line leaf's
+ * paste joins its lines (`line-paste.ts`).
  *
  * 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
@@ -551,6 +556,7 @@ export function createField(opts) {
 export function proseLeafPlugins(schema, opts) {
     const list = [
         history(),
+        undoStepPlugin(),
         ...(opts.cap ? [capPlugin(opts.cap)] : []),
         ...(opts.afterHistory ?? []),
         linebreakPlugin(schema)
@@ -566,9 +572,11 @@ 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(), tableCopyPlugin(), markdownPastePlugin(), taskPlugin(), nestingPlugin());
+        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), tableCopyPlugin(), markdownPastePlugin(), listPastePlugin(), taskPlugin(), nestingPlugin());
     if (schema === plainSchema)
         list.push(plainClipboardPlugin());
+    if (isInlineSchema(schema))
+        list.push(linePastePlugin());
     if (opts.placeholder)
         list.push(ghostPlugin(opts));
     return list;

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

@@ -3,6 +3,7 @@ export type { RangeAnchor } from './anchor.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 { joinLines, pastedLines } from './line-paste.js';
 export type { TextCap } from './cap.js';
 export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 export type { TableChromeStrings } from './table-view.js';
@@ -20,3 +21,4 @@ export type { Reconciler } from './reconcile.js';
 export { inputRulesPlugin } from './inputrules.js';
 export { bodyKeymap } from './keymap.js';
 export { listKeymap } from './lists.js';
+export { toggleList } from './list-toggle.js';

package/dist/core/codec/index.js

@@ -15,6 +15,7 @@ export { rangeAnchor } from './anchor.js';
 // The prose leaf.
 export { createField, emptyContent, heldAttributes, isEmptyContent, proseAttributes, proseLeafPlugins } from './field.js';
 export { capCount } from './cap.js';
+export { joinLines, pastedLines } from './line-paste.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';
@@ -44,3 +45,6 @@ export { inputRulesPlugin } from './inputrules.js';
 // (`bodyKeymap`); the suite drives both it and the list link directly.
 export { bodyKeymap } from './keymap.js';
 export { listKeymap } from './lists.js';
+// The list toggle the keymap binds to Mod-Shift-7/8, and the selection toolbar's list
+// buttons run (`visual/FormatPopover.svelte`).
+export { toggleList } from './list-toggle.js';