@quillmark/svelte 0.8.0 → 0.10.0

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();
     }