@quillmark/svelte 0.8.0 → 0.10.0

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

@@ -1,4 +1,4 @@
-import type { Attrs, Node as PMNode } from 'prosemirror-model';
+import type { Attrs, Node as PMNode, 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`. */
@@ -35,3 +35,7 @@ export declare function consuming(state: EditorState, from: number, to: number,
     tr: Transaction;
     produced: Transaction;
 } | null;
+/** 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. */
+export declare function blockKeymap(schema: Schema): Record<string, Command>;

package/dist/core/codec/blocks.js

@@ -1,4 +1,5 @@
 import { Selection } from 'prosemirror-state';
+import { chainCommands, splitBlock } from 'prosemirror-commands';
 import { canJoin, findWrapping } from 'prosemirror-transform';
 /** The head of a textblock: where a shorthand fires, and where a pick lands once its
  *  run is consumed. */
@@ -161,3 +162,123 @@ export function consuming(state, from, to, command) {
     tr.setSelection(Selection.fromJSON(tr.doc, produced.selection.toJSON()));
     return { tr, produced };
 }
+/** The head of the body's first block: one position per open token above the caret,
+ *  and nothing before it. */
+function atBodyStart($from) {
+    return $from.pos === $from.depth;
+}
+/**
+ * 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.
+ *
+ * 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.
+ */
+const paragraphAtBodyStart = (state, dispatch) => {
+    const paragraph = state.schema.nodes.paragraph;
+    const { $from, empty } = state.selection;
+    if (!paragraph || !empty || !atBodyStart($from))
+        return false;
+    if ($from.parent.content.size === 0)
+        return false;
+    if ($from.depth === 1 && $from.parent.isTextblock && !$from.parent.type.spec.code)
+        return false;
+    dispatch?.(state.tr.insert(0, paragraph.create()).scrollIntoView());
+    return true;
+};
+/**
+ * Enter in an empty fence that opens the body → the fence, retyped to a paragraph.
+ *
+ * An empty first item exits its list and an empty first quoted paragraph lifts out of
+ * the quote, each leaving the one paragraph a caret above needs. A fence answers with
+ * `newlineInCode` instead — a line inside the block, in the direction already open —
+ * so the empty fence a body's first ` ``` ` mints holds a caret with nothing above it
+ * and no key that mints one.
+ *
+ * Retyping rather than inserting above, for the reason those exits leave one paragraph
+ * and not two: an empty fence carries nothing to keep.
+ */
+const paragraphFromEmptyFence = (state, dispatch) => {
+    const paragraph = state.schema.nodes.paragraph;
+    const { $from, empty } = state.selection;
+    if (!paragraph || !empty || !atBodyStart($from))
+        return false;
+    if (!$from.parent.type.spec.code || $from.parent.content.size !== 0)
+        return false;
+    if (!fits($from, paragraph))
+        return false;
+    dispatch?.(state.tr.setBlockType($from.pos, $from.pos, paragraph).scrollIntoView());
+    return true;
+};
+/**
+ * Enter over a selection spanning two textblocks: take the selection, then split
+ * what is left, both in one transaction.
+ *
+ * The edit upstream's `splitBlock` means, computed against a document that exists.
+ * It deletes the selection inside its own transaction and then reads the default
+ * block's fit off the *pre-delete* document — `$from.node(splitDepth - 1)` against an
+ * index resolved in the new one — so where the range starts at the head of a
+ * `defining` block and ends inside a list, it retypes a `list_item` to a paragraph
+ * and throws `RangeError` out of the keystroke.
+ */
+const splitAcrossBlocks = (state, dispatch) => {
+    const { $from, $to, empty } = state.selection;
+    if (empty || $from.parent === $to.parent)
+        return false;
+    if (!dispatch)
+        return true;
+    const tr = state.tr.deleteSelection();
+    splitBlock(state.apply(tr), (split) => {
+        for (const step of split.steps)
+            tr.step(step);
+        tr.setSelection(Selection.fromJSON(tr.doc, split.selection.toJSON()));
+    });
+    dispatch(tr.scrollIntoView());
+    return true;
+};
+/**
+ * Delete on an empty textblock → take the line, whatever stands below moving up
+ * whole and keeping what it is.
+ *
+ * The links below it leave the line standing: the base keymap joins the block below
+ * into it — a list's first item lifted out to fill it, its marker gone — and the atom
+ * link arms an island for the press after. Upstream takes the line only where the
+ * sibling holds the same kind of content, so a heading below keeps its level where a
+ * bullet loses its marker.
+ *
+ * Declines where the parent cannot spare the block: an empty item and an empty quote
+ * 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.
+ */
+const takeEmptyLine = (state, dispatch) => {
+    const { $from, empty } = state.selection;
+    if (!empty || !$from.parent.isTextblock || $from.parent.content.size !== 0)
+        return false;
+    const index = $from.index(-1);
+    if (!$from.node(-1).canReplace(index, index + 1))
+        return false;
+    if (!Selection.findFrom(state.doc.resolve($from.after()), 1))
+        return false;
+    dispatch?.(state.tr.delete($from.before(), $from.after()).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. */
+export function blockKeymap(schema) {
+    if (!schema.nodes.paragraph)
+        return {};
+    return {
+        Enter: chainCommands(paragraphAtBodyStart, paragraphFromEmptyFence, splitAcrossBlocks),
+        Delete: takeEmptyLine
+    };
+}

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

@@ -0,0 +1,10 @@
+import type { Schema } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+/**
+ * Rewrite every `\n` a transaction leaves in a non-`code` textblock to a `hard_break`.
+ *
+ * Reads the schema rather than a flag: the inline schemas declare neither node, and
+ * nothing puts a `\n` in one — a paste parses its whitespace away and the keys type
+ * characters.
+ */
+export declare function linebreakPlugin(schema: Schema): Plugin;

package/dist/core/codec/breaks.js

@@ -0,0 +1,37 @@
+import { Plugin } from 'prosemirror-state';
+/**
+ * Rewrite every `\n` a transaction leaves in a non-`code` textblock to a `hard_break`.
+ *
+ * Reads the schema rather than a flag: the inline schemas declare neither node, and
+ * nothing puts a `\n` in one — a paste parses its whitespace away and the keys type
+ * characters.
+ */
+export function linebreakPlugin(schema) {
+    const br = schema.nodes.hard_break;
+    return new Plugin({
+        appendTransaction(trs, _before, state) {
+            if (!br || !trs.some((tr) => tr.docChanged))
+                return null;
+            const at = [];
+            state.doc.descendants((node, pos) => {
+                // A code block's newlines are its content (`whitespace: 'pre'`).
+                if (node.type.spec.code)
+                    return false;
+                if (!node.isText)
+                    return true;
+                const text = node.text ?? '';
+                for (let i = text.indexOf('\n'); i >= 0; i = text.indexOf('\n', i + 1))
+                    at.push(pos + i);
+                return true;
+            });
+            if (!at.length)
+                return null;
+            // A break and the `\n` it replaces are both one position wide, so an earlier
+            // replacement leaves every later one addressed.
+            const tr = state.tr;
+            for (const pos of at)
+                tr.replaceWith(pos, pos + 1, br.create());
+            return tr;
+        }
+    });
+}

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

@@ -7,6 +7,8 @@ import { type Command } from 'prosemirror-state';
  * `Enter` is upstream's `newlineInCode`, and it is load-bearing rather than
  * cosmetic: inside a `list_item > code_block` the list link's `splitListItem`
  * otherwise splits the item in two, each half holding a code block. Every command
- * here declines outside a code block, so the list links keep the keys elsewhere.
+ * here declines away from a code block — inside one for the three keys about its
+ * text, 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

@@ -76,8 +76,13 @@ 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 then out of the leaf, which is the body's
- * keyboard exit from inside a code block (VISUAL_EDITOR §Chrome).
+ * 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.
  */
 const outdentInCode = (state, dispatch) => {
     const block = codeBlockAt(state);
@@ -98,6 +103,55 @@ const outdentInCode = (state, dispatch) => {
     }
     return true;
 };
+/**
+ * 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.
+ */
+function blockAgainst(state, side) {
+    const { $from, empty } = state.selection;
+    if (!empty || !$from.parent.isTextblock)
+        return null;
+    if ($from.parentOffset !== (side < 0 ? 0 : $from.parent.content.size))
+        return null;
+    const $edge = state.doc.resolve(side < 0 ? $from.before() : $from.after());
+    const node = side < 0 ? $edge.nodeBefore : $edge.nodeAfter;
+    if (!node?.isTextblock)
+        return null;
+    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.
+ *
+ * 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.
+ *
+ * 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) {
+    return (state, dispatch) => {
+        const paragraph = state.schema.nodes.paragraph;
+        const edge = blockAgainst(state, side);
+        if (!paragraph || !edge)
+            return false;
+        const { $from } = state.selection;
+        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());
+        return true;
+    };
+}
 /**
  * The `code_block` link of the body's key chains: `{}` for the inline/plaintext
  * schemas, which declare no code node.
@@ -105,7 +159,9 @@ const outdentInCode = (state, dispatch) => {
  * `Enter` is upstream's `newlineInCode`, and it is load-bearing rather than
  * cosmetic: inside a `list_item > code_block` the list link's `splitListItem`
  * otherwise splits the item in two, each half holding a code block. Every command
- * here declines outside a code block, so the list links keep the keys elsewhere.
+ * here declines away from a code block — inside one for the three keys about its
+ * text, 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)
@@ -113,6 +169,8 @@ export function codeKeymap(schema) {
     return {
         Tab: indentInCode,
         'Shift-Tab': outdentInCode,
-        Enter: newlineInCode
+        Enter: newlineInCode,
+        Backspace: retypeAtProseEdge(-1),
+        Delete: retypeAtProseEdge(1)
     };
 }

package/dist/core/codec/decode.js

@@ -103,19 +103,16 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
         if (isListItemContainer(here)) {
             // Gather the maximal run of sibling `list_item` leaves at this depth
             // (same ordered/start), then split it into items by `ordinal`.
-            const { ordered, start } = here;
+            const { ordered, start, instance } = here;
             let j = i + 1;
-            let prevOrd = here.ordinal;
             while (j < leaves.length) {
                 const c = atDepth(leaves[j], depth);
                 if (!c || !isListItemContainer(c) || c.ordered !== ordered || c.start !== start)
                     break;
-                // An ordinal reset is an adjacent sibling list (content preserves the
-                // shape): merging it here would re-encode `[0,1,0]` as `[0,1,2]`,
-                // breaking the decode round-trip on the first edit.
-                if (c.ordinal < prevOrd)
+                // `instance` is the boundary between two adjacent lists; the normalizer
+                // numbers a run's `ordinal`s gaplessly from 0, so a reset carries none.
+                if (c.instance !== instance)
                     break;
-                prevOrd = c.ordinal;
                 j++;
             }
             const run = leaves.slice(i, j);
@@ -162,11 +159,14 @@ function ordinalAt(leaf, depth) {
     const c = atDepth(leaf, depth);
     return c && isListItemContainer(c) ? c.ordinal : -1;
 }
-/** Identity of a container for run gathering: its name plus its payload, NUL-joined
- * as `markKey` joins a mark's, so no `attrs` content can forge a name boundary.
- * Every arm but `list_item` (which has its own run rule) keys here. */
+/** Identity of a container for run gathering: its name, its `instance` and its payload,
+ * NUL-joined as `markKey` joins a mark's, so no `attrs` content can forge a name
+ * boundary. `instance` is what tells one container from an adjacent sibling of identical
+ * shape, which contiguity alone reads as one. Every arm but `list_item` (which has its
+ * own run rule) keys here. */
 function containerKey(c) {
-    return 'attrs' in c ? `${c.container}\u0000${JSON.stringify(c.attrs)}` : c.container;
+    const id = `${c.container}\u0000${c.instance}`;
+    return 'attrs' in c ? `${id}\u0000${JSON.stringify(c.attrs)}` : id;
 }
 /** A single leaf block node (para/heading/code/rule/island, or an unknown kind
  * carried on a paragraph) from its segments. `kind` is an open set, so the two

package/dist/core/codec/encode.js

@@ -35,15 +35,41 @@ export function pmToContent(doc) {
     const { text, lines, marks, islands } = scanDoc(doc);
     return { text, lines, marks, islands };
 }
-/** Walk a block-content fragment; `contentStart` is the PM pos before its first child. */
+/** Walk a block-content fragment; `contentStart` is the PM pos before its first child.
+ * Two container siblings of one run shape read as a single container — contiguity plus
+ * an equal path is what the store means by "the same one" — so each alternates its
+ * `instance` against the sibling before it. Sibling adjacency is the whole scope: a
+ * container one level in has a differing path above it, which already tells it apart. */
 function scanBlocks(acc, parent, contentStart, containers) {
     let pm = contentStart;
+    let prevShape = null;
+    let instance = 0;
     parent.forEach((child) => {
-        scanBlock(acc, child, pm, containers);
+        const shape = runShape(child);
+        instance = shape !== null && shape === prevShape ? instance ^ 1 : 0;
+        prevShape = shape;
+        scanBlock(acc, child, pm, containers, instance);
         pm += child.nodeSize;
     });
 }
-function scanBlock(acc, node, nodePos, containers) {
+/** A block's container run shape, `ordinal` and `instance` aside; null where it opens
+ * no container. A list's `start` is not in it — the store welds two runs differing only
+ * there — and an unknown's `attrs` is, as `containerKey` reads it on the way back. */
+function runShape(node) {
+    switch (node.type.name) {
+        case 'blockquote':
+            return 'quote';
+        case 'bullet_list':
+            return 'list\u0000bullet';
+        case 'ordered_list':
+            return 'list\u0000ordered';
+        case 'unknown_container':
+            return `unknown\u0000${node.attrs.container}\u0000${JSON.stringify(node.attrs.attrs)}`;
+        default:
+            return null;
+    }
+}
+function scanBlock(acc, node, nodePos, containers, instance) {
     const name = node.type.name;
     const contentStart = nodePos + 1;
     switch (name) {
@@ -84,12 +110,12 @@ function scanBlock(acc, node, nodePos, containers) {
             acc.lastContentEndPm = nodePos + 1;
             break;
         case 'blockquote':
-            scanBlocks(acc, node, contentStart, [...containers, { container: 'quote' }]);
+            scanBlocks(acc, node, contentStart, [...containers, { container: 'quote', instance }]);
             break;
         case 'unknown_container':
             scanBlocks(acc, node, contentStart, [
                 ...containers,
-                { container: node.attrs.container, attrs: node.attrs.attrs }
+                { container: node.attrs.container, attrs: node.attrs.attrs, instance }
             ]);
             break;
         case 'bullet_list':
@@ -102,7 +128,8 @@ function scanBlock(acc, node, nodePos, containers) {
                     container: 'list_item',
                     ordered,
                     start,
-                    ordinal: index
+                    ordinal: index,
+                    instance
                 };
                 scanBlocks(acc, item, itemPos + 1, [...containers, container]);
                 itemPos += item.nodeSize;
@@ -141,7 +168,16 @@ function scanInline(acc, block, contentStart, containers, kind) {
     let pm = contentStart;
     block.forEach((child) => {
         if (child.isText) {
-            emitText(acc, child.text ?? '', pm, child.marks);
+            const text = child.text ?? '';
+            emitText(acc, text, pm, child.marks);
+            // A `\n` in a textblock that is not `whitespace: 'pre'` is the same line
+            // boundary a hard break is: `paragraph` is `inline*`, so the schema admits
+            // one, and `joinTextblocksAround` — a bare `replaceStep` running neither
+            // `clearIncompatible` nor `replaceNewlines` — leaves one. It rides the text
+            // run, where PM and USV advance together.
+            const breaks = text.split('\n').length - 1;
+            for (let i = 0; i < breaks; i++)
+                acc.lines.push({ containers, continues: true, ...kind });
         }
         else if (child.type.name === 'hard_break') {
             // A within-block hard break: the content `\n` (a `continues` line).
@@ -196,7 +232,7 @@ export function contentEdit(oldRt, newRt) {
 export function lower(edit, opts = {}) {
     const { oldRt, newRt } = edit;
     const { delta, islandOps, insertedAt } = splitIslands(edit);
-    const lineOps = diffLines(oldRt, newRt);
+    const lineOps = diffLines(oldRt, newRt, edit.delta);
     const markOps = diffMarks(oldRt, newRt, delta, insertedAt, opts);
     const bundle = {};
     if (delta)
@@ -235,9 +271,39 @@ function diffText(oldText, newText) {
         ops.push({ retain: s });
     return { ops };
 }
-/** Per-line `setContainers` / `setKind` / `setContinues` when line metadata changed; else none. */
-function diffLines(oldRt, newRt) {
-    if (lineMetaEqual(oldRt.lines, newRt.lines))
+/**
+ * Whether the splice moves a line boundary — a `\n` deleted, or one inserted. Where
+ * it does not, every line keeps the metadata it had and equal metadata on both sides
+ * is the whole story. Where it does, the store's split/join inheritance decides what
+ * each line ends up carrying, and an array that still matches position for position
+ * says nothing about it: one splice that both joins a boundary and opens another
+ * leaves the line count and the metadata array unchanged while the kinds slide.
+ */
+function movesBoundary(oldText, delta) {
+    if (!delta)
+        return false;
+    let at = 0;
+    let cps;
+    for (const op of delta.ops) {
+        if ('retain' in op)
+            at += op.retain;
+        else if ('insert' in op) {
+            if (op.insert.includes('\n'))
+                return true;
+        }
+        else {
+            cps ??= codePoints(oldText);
+            if (cps.slice(at, at + op.delete).includes('\n'))
+                return true;
+            at += op.delete;
+        }
+    }
+    return false;
+}
+/** Per-line `setContainers` / `setKind` / `setContinues` when line metadata changed or
+ *  the splice moved a boundary; else none. */
+function diffLines(oldRt, newRt, delta) {
+    if (!movesBoundary(oldRt.text, delta) && lineMetaEqual(oldRt.lines, newRt.lines))
         return [];
     const ops = [];
     // Force every new line's metadata. Redundant ops are safe no-ops (verified),

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

@@ -152,10 +152,11 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
  * {@link createField} and the by-value inline editor (`ProseValue`), so the two
  * never fork the keymap/plugin ordering. History first, then any leaf-specific
  * plugins (`afterHistory`: the addressed leaf passes its anchor-position plugin;
- * a by-value leaf passes none), the
- * markdown-shorthand input rules, then the field keymap over the base keymap, and
- * last the two that answer to a caret or a selection beside a block: the gap cursor
- * and {@link pastAtomPlugin}.
+ * a by-value leaf passes none), then {@link linebreakPlugin}, which normalizes what
+ * the rest of the stack leaves, then the markdown-shorthand input rules, the field
+ * keymap over the base keymap, and last the three that answer to a block leaf's own
+ * shapes: the gap cursor, {@link pastAtomPlugin}, and the island paste pass
+ * (`islands.ts`).
  *
  * Every mark-shaped plugin reads the schema rather than a flag: over
  * `plaintextSchema` the shorthand rules build nothing (each is guarded on its mark

package/dist/core/codec/field.js

@@ -22,9 +22,11 @@ import { reportError, errorMessage } from '../errors.js';
 import { decode } from './decode.js';
 import { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 import { lower, pmToContent, contentEdit } from './encode.js';
+import { islandPastePlugin } from './islands.js';
 import { anchorsFromContent } from './marks.js';
 import { createReconciler } from './reconcile.js';
 import { inputRulesPlugin } from './inputrules.js';
+import { linebreakPlugin } from './breaks.js';
 import { bodyKeymap } from './keymap.js';
 import { blockSchema, inlineSchema, plaintextSchema } from './schema.js';
 import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
@@ -391,10 +393,11 @@ export function createField(opts) {
  * {@link createField} and the by-value inline editor (`ProseValue`), so the two
  * never fork the keymap/plugin ordering. History first, then any leaf-specific
  * plugins (`afterHistory`: the addressed leaf passes its anchor-position plugin;
- * a by-value leaf passes none), the
- * markdown-shorthand input rules, then the field keymap over the base keymap, and
- * last the two that answer to a caret or a selection beside a block: the gap cursor
- * and {@link pastAtomPlugin}.
+ * a by-value leaf passes none), then {@link linebreakPlugin}, which normalizes what
+ * the rest of the stack leaves, then the markdown-shorthand input rules, the field
+ * keymap over the base keymap, and last the three that answer to a block leaf's own
+ * shapes: the gap cursor, {@link pastAtomPlugin}, and the island paste pass
+ * (`islands.ts`).
  *
  * Every mark-shaped plugin reads the schema rather than a flag: over
  * `plaintextSchema` the shorthand rules build nothing (each is guarded on its mark
@@ -402,17 +405,17 @@ export function createField(opts) {
  * typed without a second rule saying so.
  */
 export function proseLeafPlugins(schema, opts) {
-    const list = [history(), ...(opts.afterHistory ?? [])];
+    const list = [history(), ...(opts.afterHistory ?? []), linebreakPlugin(schema)];
     if (opts.slash)
         list.push(slashPlugin(opts.slash));
     if (!opts.noInputRules)
         list.push(inputRulesPlugin(schema));
     list.push(keymap(editorKeymap(schema, opts.inline, !!opts.slash)));
     list.push(keymap(baseKeymap));
-    // Both answer to something only a block leaf holds: an inline leaf is one textblock
-    // with no island and no gap to put a cursor in.
+    // All three answer to something only a block leaf holds: an inline leaf is one
+    // textblock with no island and no gap to put a cursor in.
     if (!opts.inline)
-        list.push(gapCursor(), pastAtomPlugin());
+        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin());
     if (opts.placeholder)
         list.push(placeholderPlugin(opts.placeholder));
     return list;

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

@@ -1,4 +1,5 @@
-import type { Node as PMNode, NodeSpec } from 'prosemirror-model';
+import { type Node as PMNode, type NodeSpec } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
 import type { ContentIsland, TableProps } from '@quillmark/wasm';
 /** The `U+FFFC` object-replacement char that occupies one island slot in `text`. */
 export declare const ISLAND_SLOT = "\uFFFC";
@@ -18,9 +19,11 @@ export interface IslandNodeAttrs {
 }
 /** Build a content island entry from a PM island node's attrs (block or inline). */
 export declare function islandEntryFromNode(attrs: IslandNodeAttrs): ContentIsland;
-/** A node's `TableProps`, or `undefined` for any other island: the boundary's own
- *  guard over the entry the node carries, so the open `type` arm narrows once here
- *  rather than at each reader. */
+/** A node's `TableProps`, or `undefined` for any other island and for a payload of the
+ *  wrong shape: the boundary's own guard over the entry the node carries, so the open
+ *  `type` arm narrows once here rather than at each reader. The type says which reader,
+ *  the shape says whether it can read; every caller draws the placeholder for
+ *  `undefined` (`table-view.ts` §`render`). */
 export declare function tablePropsOfNode(node: PMNode): TableProps | undefined;
 /**
  * A minter over one document: the positional `isl-{n}` sequence continued past the
@@ -38,3 +41,20 @@ export declare function islandMinter(doc: PMNode): () => string;
 /** The next island id for a field: one draw from {@link islandMinter}, which is what a
  *  command placing exactly one island wants. */
 export declare function mintIslandId(doc: PMNode): string;
+/**
+ * The paste's island pass: an id the field already holds is re-minted on the way in.
+ *
+ * An id is an identity in the content and unique across the field, so two islands
+ * wearing one is a projection the store has no shape for. A copy rather than a cut is
+ * where that arrives, and a paste out of a second field is the other; a cut pasted back
+ * collides with nothing and keeps the identity it had.
+ *
+ * The test is the document as it stands, which a drag moving a selection over an island
+ * reads one too many: the original is still there when the slice is transformed and gone
+ * when it lands, so that island arrives under a fresh id. A fresh id costs it nothing a
+ * duplicate would cost the whole field.
+ *
+ * A plugin prop rather than a view option: the leaf mounts the codec's plugin stack, and
+ * which nodes carry an identity is the codec's to know.
+ */
+export declare function islandPastePlugin(): Plugin;