@quillmark/svelte 0.8.0 → 0.9.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

@@ -104,18 +104,16 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
             // 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 instance = here.instance ?? 0;
             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 ?? 0) !== instance)
                     break;
-                prevOrd = c.ordinal;
                 j++;
             }
             const run = leaves.slice(i, j);
@@ -162,11 +160,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 ?? 0}`;
+    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,46 @@ 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;
+    }
+}
+/** `instance` where it tells a container from an identical adjacent sibling. The
+ * canonical form omits a zero, so emitting one would diff against every store read. */
+function discriminate(container, instance) {
+    return instance ? { ...container, instance } : container;
+}
+function scanBlock(acc, node, nodePos, containers, instance) {
     const name = node.type.name;
     const contentStart = nodePos + 1;
     switch (name) {
@@ -84,12 +115,15 @@ 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,
+                discriminate({ container: 'quote' }, instance)
+            ]);
             break;
         case 'unknown_container':
             scanBlocks(acc, node, contentStart, [
                 ...containers,
-                { container: node.attrs.container, attrs: node.attrs.attrs }
+                discriminate({ container: node.attrs.container, attrs: node.attrs.attrs }, instance)
             ]);
             break;
         case 'bullet_list':
@@ -98,12 +132,7 @@ function scanBlock(acc, node, nodePos, containers) {
             const start = ordered ? node.attrs.start : 1;
             let itemPos = contentStart;
             node.forEach((item, _off, index) => {
-                const container = {
-                    container: 'list_item',
-                    ordered,
-                    start,
-                    ordinal: index
-                };
+                const container = discriminate({ container: 'list_item', ordered, start, ordinal: index }, instance);
                 scanBlocks(acc, item, itemPos + 1, [...containers, container]);
                 itemPos += item.nodeSize;
             });
@@ -141,7 +170,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 +234,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 +273,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;

package/dist/core/codec/islands.js

@@ -1,3 +1,16 @@
+// Islands: the `U+FFFC` slot + `ContentIsland` entry ↔ a PM leaf node. A slot
+// inside a `para` line is an inline island (an image); an `island`-kind line is a
+// block island (a table). The node carries `id`, `islandType`, and the opaque
+// `props` verbatim, so an unknown island type round-trips untouched.
+//
+// A props-aware consumer reads the shape straight off the boundary:
+// `ContentIsland.props` is the typed union (`TableProps` for `table`,
+// `ImageProps` for `image`; DOCUMENT_MODEL §Stability seams), so the codec
+// reads it rather than hand-rolling a shape or guard. The open `type` arm means
+// a discriminant check does not auto-narrow `props`; key off `type` and read
+// `props` as the matching upstream type.
+import { Fragment, Slice } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
 import { isTableIsland } from '@quillmark/wasm';
 /** The `U+FFFC` object-replacement char that occupies one island slot in `text`. */
 export const ISLAND_SLOT = '';
@@ -16,17 +29,52 @@ const islandAttrs = {
     props: { default: null },
     loss: { default: 'unrepresentable' }
 };
+// All four attributes cross the DOM: a copy and a paste inside one body run the document
+// through `toDOM`/`parseDOM` (CODEC §"Markdown at the edges"), and an island is a leaf
+// whose tags alone say only `[table]`. `props` crosses as JSON, the form the payload has
+// at the boundary. The names are `data-qm-*` like every other carrier's, and the id is
+// what the rule requires: an island is a leaf, so a rule reading a tag someone else
+// chose would swallow that element's whole subtree.
+/** The DOM an island node writes and reads back, for either spec. */
+function islandDOM(node) {
+    return {
+        'data-qm-island': node.attrs.islandType,
+        'data-qm-island-id': node.attrs.id,
+        'data-qm-island-loss': node.attrs.loss,
+        'data-qm-island-props': JSON.stringify(node.attrs.props ?? null)
+    };
+}
+/** An island node's attributes off that DOM, or `false` where the id is absent. A
+ *  `props` that is not the JSON written above reads as `null`, and one of the wrong
+ *  shape is `undefined` at its reader (§`tablePropsOfNode`): the entry survives as an
+ *  island of its type rather than taking the paste down with it. */
+function islandAttrsFromDOM(el) {
+    const id = el.getAttribute('data-qm-island-id');
+    if (id == null)
+        return false;
+    const raw = el.getAttribute('data-qm-island-props');
+    let props = null;
+    try {
+        props = raw == null ? null : JSON.parse(raw);
+    }
+    catch {
+        props = null;
+    }
+    return {
+        id,
+        islandType: el.getAttribute('data-qm-island') ?? '',
+        props,
+        loss: (el.getAttribute('data-qm-island-loss') ?? 'unrepresentable')
+    };
+}
 /** Block island node (a table): one `island`-kind content line. Atom, unselectable content. */
 export const islandBlockSpec = {
     group: 'block',
     atom: true,
     selectable: true,
     attrs: islandAttrs,
-    toDOM: (node) => [
-        'div',
-        { 'data-island': node.attrs.islandType, 'data-island-id': node.attrs.id },
-        `[${node.attrs.islandType || 'island'}]`
-    ]
+    parseDOM: [{ tag: 'div[data-qm-island]', getAttrs: (el) => islandAttrsFromDOM(el) }],
+    toDOM: (node) => ['div', islandDOM(node), `[${node.attrs.islandType || 'island'}]`]
 };
 /** Inline island node (an image): a `U+FFFC` slot inside a `para` line. */
 export const islandInlineSpec = {
@@ -35,11 +83,8 @@ export const islandInlineSpec = {
     atom: true,
     selectable: true,
     attrs: islandAttrs,
-    toDOM: (node) => [
-        'span',
-        { 'data-island': node.attrs.islandType, 'data-island-id': node.attrs.id },
-        `[${node.attrs.islandType || 'island'}]`
-    ]
+    parseDOM: [{ tag: 'span[data-qm-island]', getAttrs: (el) => islandAttrsFromDOM(el) }],
+    toDOM: (node) => ['span', islandDOM(node), `[${node.attrs.islandType || 'island'}]`]
 };
 /** Build a content island entry from a PM island node's attrs (block or inline). */
 export function islandEntryFromNode(attrs) {
@@ -50,12 +95,25 @@ export function islandEntryFromNode(attrs) {
         loss: attrs.loss
     };
 }
-/** 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. */
+/** The `TableProps` shape, over a value that reached the node off the DOM rather than
+ *  out of a decode: the rectangle every reader indexes (`table.ts`), down to the `text`
+ *  a row's emptiness is read off. */
+function isTableProps(props) {
+    if (typeof props !== 'object' || props === null)
+        return false;
+    const { header, rows, aligns } = props;
+    const cells = (v) => Array.isArray(v) &&
+        v.every((c) => typeof c === 'object' && c !== null && typeof c.text === 'string');
+    return (cells(header) && Array.isArray(aligns) && Array.isArray(rows) && rows.every((row) => cells(row)));
+}
+/** 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 function tablePropsOfNode(node) {
     const entry = islandEntryFromNode(node.attrs);
-    return isTableIsland(entry) ? entry.props : undefined;
+    return isTableIsland(entry) && isTableProps(entry.props) ? entry.props : undefined;
 }
 /**
  * A minter over one document: the positional `isl-{n}` sequence continued past the
@@ -72,7 +130,7 @@ export function tablePropsOfNode(node) {
 export function islandMinter(doc) {
     let next = 0;
     doc.descendants((node) => {
-        if (node.type.name !== 'island_block' && node.type.name !== 'island_inline')
+        if (!isIsland(node))
             return true;
         const m = /^isl-(\d+)$/.exec(node.attrs.id);
         if (m)
@@ -86,3 +144,70 @@ export function islandMinter(doc) {
 export function mintIslandId(doc) {
     return islandMinter(doc)();
 }
+/** Either island node: the test the minter, the id sweep and the paste pass share, so a
+ *  third island shape is one arm rather than three. */
+function isIsland(node) {
+    return node.type.name === 'island_block' || node.type.name === 'island_inline';
+}
+/** The ids a document already holds. */
+function heldIds(doc) {
+    const held = new Set();
+    doc.descendants((node) => {
+        if (!isIsland(node))
+            return true;
+        held.add(node.attrs.id);
+        return false;
+    });
+    return held;
+}
+/** `fragment` with every island whose id is already `taken` re-minted, or `null` where
+ *  none was: an untouched paste stays the slice it arrived as. Every surviving id joins
+ *  the set, so a slice carrying one id twice comes apart in the same pass. */
+function remintIslands(fragment, taken, mint) {
+    const out = [];
+    let changed = false;
+    fragment.forEach((node) => {
+        if (!isIsland(node)) {
+            const inner = node.isLeaf ? null : remintIslands(node.content, taken, mint);
+            changed ||= inner !== null;
+            out.push(inner ? node.copy(inner) : node);
+            return;
+        }
+        let id = node.attrs.id;
+        if (taken.has(id)) {
+            do
+                id = mint();
+            while (taken.has(id));
+            changed = true;
+        }
+        taken.add(id);
+        out.push(id === node.attrs.id ? node : node.type.create({ ...node.attrs, id }, null, node.marks));
+    });
+    return changed ? Fragment.fromArray(out) : null;
+}
+/**
+ * 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 function islandPastePlugin() {
+    return new Plugin({
+        props: {
+            transformPasted: (slice, view) => {
+                const content = remintIslands(slice.content, heldIds(view.state.doc), islandMinter(view.state.doc));
+                return content ? new Slice(content, slice.openStart, slice.openEnd) : slice;
+            }
+        }
+    });
+}

package/dist/core/codec/keymap.js

@@ -1,5 +1,6 @@
 import { chainCommands } from 'prosemirror-commands';
 import { atomKeymap } from './atoms.js';
+import { blockKeymap } from './blocks.js';
 import { codeKeymap } from './code.js';
 import { listKeymap } from './lists.js';
 import { slashKeymap } from './slash.js';
@@ -26,5 +27,5 @@ function chainKeymaps(...maps) {
  * no visible reason. */
 export function bodyKeymap(schema, slash) {
     const links = slash ? [slashKeymap()] : [];
-    return chainKeymaps(...links, codeKeymap(schema), listKeymap(schema), atomKeymap(schema));
+    return chainKeymaps(...links, blockKeymap(schema), codeKeymap(schema), listKeymap(schema), atomKeymap(schema));
 }

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

@@ -17,6 +17,10 @@ import type { Command } from 'prosemirror-state';
  * its own: it splits a non-empty item, and on an empty item it either splits the
  * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
  * so the third link lifts a top-level empty item out to a paragraph. `Backspace`
- * forks on the item's index: the first item lifts, any later one merges.
+ * forks on the item's index: the first item lifts, any later one merges. `Delete` is
+ * that same chain at the seam below rather than a second table of cases beside it, so
+ * the two keys cannot come to differ over a seam this link reaches. An empty line is
+ * not one: the block link takes it ahead of this chain (`blocks.ts`), the caret's own
+ * line being a nearer fact than the boundary under it.
  */
 export declare function listKeymap(schema: Schema): Record<string, Command>;

package/dist/core/codec/lists.js

@@ -1,4 +1,5 @@
 import { liftListItem, sinkListItem, splitListItem } from 'prosemirror-schema-list';
+import { EditorState, Selection, TextSelection } from 'prosemirror-state';
 import { chainCommands, joinTextblockBackward } from 'prosemirror-commands';
 /** The caret's enclosing `list_item` when it sits at the very start of that item's
  * first block: the position both structural keys branch on. `null` otherwise
@@ -20,26 +21,35 @@ function atItemStart(state, itemType) {
         listPos: $from.before(-2)
     };
 }
+/**
+ * The textblock at the end of `node`: `node` itself where it is one, else its last
+ * descendant that is — the block a caret above a boundary lands in, and the block a
+ * join across one reaches, `joinTextblockBackward` walking to the same one. `null` on
+ * an atom (an island, a rule), which `prosemirror-gapcursor` declines to sit beside
+ * too, its `closedBefore` asking this question from the other side.
+ */
+function lastBlockIn(node) {
+    let last = node ?? null;
+    while (last && !last.isTextblock && !last.isAtom)
+        last = last.lastChild;
+    return last?.isTextblock ? last : null;
+}
 /**
  * Whether a caret already fits immediately above the list at `pos`. The node ending
- * there answers for its last child, so a quote counts through its final paragraph;
- * an atom (an island, a rule) does not, and neither does a list opening its parent.
- * Those are the shapes `prosemirror-gapcursor` declines too, its `closedBefore`
- * asking this question from the other side.
+ * there answers for its last child, so a quote counts through its final paragraph; a
+ * list opening its parent has no node there at all.
  */
 function writableAbove(doc, pos) {
-    let before = doc.resolve(pos).nodeBefore;
-    while (before && !before.isTextblock && !before.isAtom)
-        before = before.lastChild;
-    return !!before?.isTextblock;
+    return !!lastBlockIn(doc.resolve(pos).nodeBefore);
 }
 /**
  * Enter at the very start of a top-level list's first item, where nothing above the
  * list takes a caret → an empty paragraph above it, caret staying with the text it
- * pushed down. A list that opens a document, or one under an island or a rule, has
- * nowhere above to write and nothing else that opens one. Where a caret already
- * fits above, the key is the conventional split instead, at every item alike: an
- * escape a writer reaches by pressing Up needs no key of its own.
+ * pushed down. A list under an island or a rule has nowhere above to write and
+ * nothing else that opens one; a list that opens the body is the block link's, which
+ * answers the same fact for every block ahead of this chain (`blocks.ts`). Where a
+ * caret already fits above, the key is the conventional split instead, at every item
+ * alike: an escape a writer reaches by pressing Up needs no key of its own.
  *
  * Also only where the list itself is not inside an item: in a nested list this
  * pushes an empty paragraph into the parent item (`list_item` is `block+`, so the
@@ -81,15 +91,62 @@ function liftAtListStart(itemType) {
  * `list_item(paragraph, paragraph)`: the item's marker gone while its text stays
  * on its own line, which the reference quill typesets as an unnumbered
  * continuation paragraph.
+ *
+ * Only between two blocks of one kind. A fence is not a line to put another line on,
+ * and the join across that edge would retype one side's whole text as the other's
+ * (`code.ts`, which refuses the same join between siblings); the base keymap's answer
+ * stands here instead, merging the items with each block kept whole.
  */
 function mergeIntoPreviousItem(itemType) {
     return (state, dispatch, view) => {
         const at = atItemStart(state, itemType);
         if (!at || at.itemIndex === 0)
             return false;
+        const into = lastBlockIn(state.doc.nodeAt(at.listPos)?.child(at.itemIndex - 1));
+        if (!into || !!into.type.spec.code !== !!state.selection.$from.parent.type.spec.code) {
+            return false;
+        }
         return joinTextblockBackward(state, dispatch, view);
     };
 }
+/** Whether the caret sits inside a `list_item` at any depth: a quote's paragraph
+ * inside an item is still an item's, and a caret outside every list is at no seam of
+ * one. */
+function inItem($pos, itemType) {
+    for (let depth = $pos.depth; depth > 0; depth--) {
+        if ($pos.node(depth).type === itemType)
+            return true;
+    }
+    return false;
+}
+/**
+ * Delete at the very end of a block inside an item → `press`, the Backspace chain, at
+ * the head of the block below: one seam, one edit, whichever side a writer approaches
+ * it from. Not the base keymap's `joinForward`, which merges the blocks and leaves the
+ * `list_item(paragraph, paragraph)` above.
+ *
+ * The reflection carries the edit and not the caret, which stays where the key was
+ * pressed: a lift moves the item below, and Delete does not follow it.
+ *
+ * Declining wherever the chain does is what keeps this to the list's own seams: a
+ * boundary inside one item, and the list's outer edge, stay the base keymap's, where
+ * the two keys already answer alike.
+ */
+function backspaceBelow(itemType, press) {
+    return (state, dispatch) => {
+        const { $from, empty } = state.selection;
+        if (!empty || $from.parentOffset !== $from.parent.content.size)
+            return false;
+        if (!inItem($from, itemType))
+            return false;
+        const below = Selection.near(state.doc.resolve($from.after()), 1);
+        if (below.from <= $from.pos)
+            return false;
+        const pressed = $from.pos;
+        const keepCaret = (tr) => dispatch?.(tr.setSelection(TextSelection.create(tr.doc, tr.mapping.map(pressed))));
+        return press(EditorState.create({ doc: state.doc, selection: below }), dispatch && keepCaret);
+    };
+}
 /**
  * The list bindings for a block-schema leaf: `{}` for the inline/plaintext
  * schemas, which declare no list nodes.
@@ -107,17 +164,23 @@ function mergeIntoPreviousItem(itemType) {
  * its own: it splits a non-empty item, and on an empty item it either splits the
  * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
  * so the third link lifts a top-level empty item out to a paragraph. `Backspace`
- * forks on the item's index: the first item lifts, any later one merges.
+ * forks on the item's index: the first item lifts, any later one merges. `Delete` is
+ * that same chain at the seam below rather than a second table of cases beside it, so
+ * the two keys cannot come to differ over a seam this link reaches. An empty line is
+ * not one: the block link takes it ahead of this chain (`blocks.ts`), the caret's own
+ * line being a nearer fact than the boundary under it.
  */
 export function listKeymap(schema) {
     const itemType = schema.nodes.list_item;
     const paragraph = schema.nodes.paragraph;
     if (!itemType || !paragraph)
         return {};
+    const backspace = chainCommands(liftAtListStart(itemType), mergeIntoPreviousItem(itemType));
     return {
         Tab: sinkListItem(itemType),
         'Shift-Tab': liftListItem(itemType),
         Enter: chainCommands(paragraphAboveList(itemType, paragraph), splitListItem(itemType), liftListItem(itemType)),
-        Backspace: chainCommands(liftAtListStart(itemType), mergeIntoPreviousItem(itemType))
+        Backspace: backspace,
+        Delete: backspaceBelow(itemType, backspace)
     };
 }

package/dist/core/codec/schema.js

@@ -8,6 +8,13 @@
 // no block split, no containers, no islands) and `plaintextSchema` is that one
 // without marks: same decode/lower/position machinery, narrower shape. Anchors are
 // not marks here (decorations).
+//
+// `toDOM` and `parseDOM` are one tier, not two halves of a rendering: a copy and a
+// paste inside one body run the whole document through them (CODEC §"Markdown at the
+// edges"), so every attribute written here is read back here. A carrier's payload
+// crosses as JSON under a `data-qm-*` name, which is the form the content's open sets
+// already have. Foreign HTML spells none of those names, so what a paste takes off the
+// web is unchanged; the one rule that widens that door on purpose is the fence's.
 import { Schema } from 'prosemirror-model';
 import { islandBlockSpec, islandInlineSpec } from './islands.js';
 // ── The href gate ───────────────────────────────────────────────────────────
@@ -37,6 +44,44 @@ export function rendersHref(href) {
     const scheme = SCHEME.exec(href.replace(IGNORED, ''));
     return scheme === null || RENDERED_SCHEMES.has(scheme[1].toLowerCase());
 }
+// ── The open sets' DOM payload ──────────────────────────────────────────────
+// A carrier's tag is a `data-qm-unknown-*` name and its `attrs` are JSON beside it,
+// under one name across all three: an element carries at most one carrier, a
+// paragraph's tag and the mark's sitting on different elements.
+/** The `attrs` half of a carrier, absent where there is none. */
+function packAttrs(attrs) {
+    return attrs == null ? {} : { 'data-qm-unknown-attrs': JSON.stringify(attrs) };
+}
+/** The `attrs` half back off an element. `null` for anything that is not the JSON
+ *  this schema wrote: a hand-built document reaches the same parse a paste does, and a
+ *  carrier's payload is the keyed object upstream spells, never a bare scalar. */
+function unpackAttrs(el) {
+    const raw = el.getAttribute('data-qm-unknown-attrs');
+    if (raw == null)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+// ── The names a carrier may not wear ────────────────────────────────────────
+// A carrier holds a value this build does not know, so a name the model does know is
+// the one it cannot carry: the projection re-emits it with `attrs` beside it
+// (`encode.ts` §`textblockKind`) and the store refuses `attrs` beside a built-in
+// discriminant, failing every write for the rest of the session. `decode` applies the
+// same guard from the other side, where a `para` line mints no carrier.
+/** The line kinds `ContentLineKind` names, which decode maps to a node of their own. */
+const BUILTIN_LINE_KINDS = new Set(['para', 'heading', 'code', 'rule', 'island']);
+/** The containers `ContentContainer` names. */
+const BUILTIN_CONTAINERS = new Set(['list_item', 'quote']);
+/** A carrier's name, or `null` where it is empty or one the model owns. */
+function carrierName(el, attr, builtin) {
+    const name = el.getAttribute(attr);
+    return name && !builtin.has(name) ? name : null;
+}
 // ── Marks (the block and inline schemas share them; plaintext declares none) ─
 const marks = {
     // Order matters: it fixes mark-set sort order and parse precedence. `link`
@@ -51,13 +96,17 @@ const marks = {
         attrs: { href: { default: '' } },
         inclusive: false,
         parseDOM: [
-            { tag: 'a[href]', getAttrs: (el) => ({ href: el.getAttribute('href') }) }
+            { tag: 'a[href]', getAttrs: (el) => ({ href: el.getAttribute('href') }) },
+            { tag: 'span[data-qm-href]', getAttrs: (el) => ({ href: el.getAttribute('data-qm-href') }) }
         ],
         // A refused href draws as a bare span: the text stands, unstyled and
-        // unclickable, and the mark keeps its value for encode.
+        // unclickable, and the mark keeps its value for encode. The value rides on the
+        // span rather than going with the tag — an `href` no renderer will follow is one
+        // the document still holds, and a copy is not the explicit conversion allowed to
+        // lose it.
         toDOM: (mark) => {
             const href = mark.attrs.href;
-            return rendersHref(href) ? ['a', { href }, 0] : ['span', 0];
+            return rendersHref(href) ? ['a', { href }, 0] : ['span', { 'data-qm-href': href }, 0];
         }
     },
     // The open-set escape hatch: an inert mark that renders as a bare span and
@@ -66,9 +115,50 @@ const marks = {
     unknown: {
         attrs: { type: { default: '' }, attrs: { default: null } },
         excludes: '',
-        toDOM: () => ['span', { 'data-unknown': '' }, 0]
+        parseDOM: [
+            {
+                tag: 'span[data-qm-unknown-mark]',
+                // `false` declines the rule, so the text arrives unmarked rather than
+                // carrying a second spelling of a mark this schema already has.
+                getAttrs: (el) => {
+                    const type = carrierName(el, 'data-qm-unknown-mark', BUILTIN_MARKS);
+                    return type ? { type, attrs: unpackAttrs(el) } : false;
+                }
+            }
+        ],
+        toDOM: (mark) => [
+            'span',
+            { 'data-qm-unknown-mark': mark.attrs.type, ...packAttrs(mark.attrs.attrs) },
+            0
+        ]
     }
 };
+/** The mark types the content model names: this schema's own, and `anchor`, which is a
+ *  decoration here rather than a mark (§Marks). Read off the record above, so a mark
+ *  added there closes the carrier's door on its name in the same edit. */
+const BUILTIN_MARKS = new Set([...Object.keys(marks), 'anchor']);
+// ── The fence's language ────────────────────────────────────────────────────
+// The one attribute no keystroke in the visual editor mints: the shorthand fires on
+// the third backtick, before a language could be typed, and a slash command is a name
+// (VISUAL_EDITOR §"Settled and open"). A paste is the gesture that does, and this is
+// what reads it — a fence copied off a highlighted page arrives carrying the language
+// that page stated, one copied inside the body keeps its own.
+/** A `language-x` / `lang-x` token in a class list. */
+const LANG_CLASS = /(?:^|\s)lang(?:uage)?-(\S+)/;
+/** The language a `<pre>` states: `data-lang`, which is what `toDOM` writes, else the
+ *  class convention on the `pre` or on the `code` it wraps. `null` where it states
+ *  none, which is also what an empty value is. */
+function fenceLang(pre) {
+    const stated = pre.getAttribute('data-lang');
+    if (stated)
+        return stated;
+    for (const el of [pre, pre.firstElementChild]) {
+        const match = el && LANG_CLASS.exec(el.getAttribute('class') ?? '');
+        if (match)
+            return match[1];
+    }
+    return null;
+}
 // ── Block nodes ─────────────────────────────────────────────────────────────
 const blockNodes = {
     doc: { content: 'block+' },
@@ -81,10 +171,18 @@ const blockNodes = {
         content: 'inline*',
         group: 'block',
         attrs: { unknown: { default: null } },
-        parseDOM: [{ tag: 'p' }],
+        parseDOM: [
+            {
+                tag: 'p',
+                getAttrs: (el) => {
+                    const kind = carrierName(el, 'data-qm-unknown-line', BUILTIN_LINE_KINDS);
+                    return { unknown: kind ? { kind, attrs: unpackAttrs(el) } : null };
+                }
+            }
+        ],
         toDOM: (node) => {
             const u = node.attrs.unknown;
-            return u ? ['p', { 'data-qm-unknown-line': u.kind }, 0] : ['p', 0];
+            return u ? ['p', { 'data-qm-unknown-line': u.kind, ...packAttrs(u.attrs) }, 0] : ['p', 0];
         }
     },
     heading: {
@@ -103,7 +201,13 @@ const blockNodes = {
         marks: '',
         whitespace: 'pre',
         attrs: { lang: { default: null } },
-        parseDOM: [{ tag: 'pre', preserveWhitespace: 'full' }],
+        parseDOM: [
+            {
+                tag: 'pre',
+                preserveWhitespace: 'full',
+                getAttrs: (el) => ({ lang: fenceLang(el) })
+            }
+        ],
         toDOM: (node) => [
             'pre',
             node.attrs.lang ? { 'data-lang': node.attrs.lang } : {},
@@ -122,7 +226,22 @@ const blockNodes = {
         content: 'list_item+',
         group: 'block',
         attrs: { start: { default: 1 } },
-        parseDOM: [{ tag: 'ol' }],
+        parseDOM: [
+            {
+                tag: 'ol',
+                getAttrs: (el) => {
+                    // A list stating no `start` starts at one, the absence `toDOM` writes for
+                    // it; `Number(null)` would read that absence as zero. A value the store
+                    // would normalize away reads as that absence too: the leaf re-hydrates
+                    // only on an external change (CODEC §Reconciliation), so a PM doc keeping
+                    // one disagrees with the store for the rest of the session. Zero is not
+                    // one — `0.` is an ordinal `importMarkdown` produces and the store keeps.
+                    const stated = el.getAttribute('start');
+                    const start = stated ? Number(stated) : 1;
+                    return { start: Number.isSafeInteger(start) && start >= 0 ? start : 1 };
+                }
+            }
+        ],
         toDOM: (node) => node.attrs.start === 1 ? ['ol', 0] : ['ol', { start: node.attrs.start }, 0]
     },
     bullet_list: {
@@ -146,17 +265,39 @@ const blockNodes = {
         group: 'block',
         defining: true,
         attrs: { container: { default: '' }, attrs: { default: null } },
-        toDOM: (node) => ['div', { 'data-qm-unknown-container': node.attrs.container }, 0]
+        parseDOM: [
+            {
+                tag: 'div[data-qm-unknown-container]',
+                // `false` declines the rule, so the div's children flow at the enclosing
+                // level — which is how a transparent container renders anyway.
+                getAttrs: (el) => {
+                    const container = carrierName(el, 'data-qm-unknown-container', BUILTIN_CONTAINERS);
+                    return container ? { container, attrs: unpackAttrs(el) } : false;
+                }
+            }
+        ],
+        toDOM: (node) => [
+            'div',
+            {
+                'data-qm-unknown-container': node.attrs.container,
+                ...packAttrs(node.attrs.attrs)
+            },
+            0
+        ]
     },
     island_block: islandBlockSpec
 };
 // ── Inline nodes ────────────────────────────────────────────────────────────
 const inlineLeafNodes = {
     text: { group: 'inline' },
+    // `linebreakReplacement` is what makes a join across a `code_block`'s edge
+    // lossless: `Transform.join` and `setBlockType` convert its `\n`s to breaks
+    // rather than flattening them to spaces, and a break is a `continues` line.
     hard_break: {
         inline: true,
         group: 'inline',
         selectable: false,
+        linebreakReplacement: true,
         parseDOM: [{ tag: 'br' }],
         toDOM: () => ['br']
     },

package/dist/core/codec/table-view.js

@@ -158,8 +158,8 @@ class TableIslandView {
         this.getPos = getPos;
         this.deps = deps;
         this.dom = el('div', 'qm-island qm-table-island');
-        this.dom.setAttribute('data-island', node.attrs.islandType);
-        this.dom.setAttribute('data-island-id', node.attrs.id);
+        this.dom.setAttribute('data-qm-island', node.attrs.islandType);
+        this.dom.setAttribute('data-qm-island-id', node.attrs.id);
         this.dom.addEventListener('mousedown', this.onPointerDown);
         this.render();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.8.0",
+	"version": "0.9.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -66,7 +66,7 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.108.3-0",
+		"@quillmark/wasm": ">=0.109.0-0",
 		"svelte": "^5.0.0"
 	},
 	"dependencies": {