@quillmark/svelte 0.10.1 → 0.12.0

package/README.md

@@ -40,7 +40,7 @@ const doc = quill.seedDocument();
 
 // An EXISTING document: parsed back from what you stored.
 const doc = Document.fromMarkdown(markdown); // canonical Quillmark markdown
-const doc = Document.fromJson(json); // the versioned storage DTO (`doc.toJson()`)
+const doc = Document.fromStored(json); // the versioned storage DTO (`doc.toStored()`)
 
 const session = await new Engine().open(quill, doc);
 // free() on teardown the handles you MINTED: this quill, this doc, this session.

package/THEMING.md

@@ -123,7 +123,7 @@ import '@quillmark/svelte/preset';
 ```html
 <body class="qm-page">
 	<p class="qm-label">quill</p>
-	<pre class="qm-readout">specimen@1.0.0</pre>
+	<pre class="qm-readout">showcase@1.0.0</pre>
 </body>
 ```
 
@@ -193,7 +193,7 @@ A blanket `:focus-visible` of yours outranks ours, including on the controls tha
 
 ## What is deliberately not public
 
-The three root classes and `.qm-pane` are the whole class contract on the surfaces. Every other `qm-*` class inside them is internal and renames without notice: a class contract over the interior would freeze the DOM shape the surfaces are free to re-cut, and the dials already reach the values a restyle wants. The preset's classes are a contract of their own: they land on _your_ DOM, so they freeze nothing of ours.
+The two root classes and `.qm-pane` are the whole class contract on the surfaces. Every other `qm-*` class inside them is internal and renames without notice: a class contract over the interior would freeze the DOM shape the surfaces are free to re-cut, and the dials already reach the values a restyle wants. The preset's classes are a contract of their own: they land on _your_ DOM, so they freeze nothing of ours.
 
 The derived surface scale (surface / border / ink rungs, the blur radius, the popover's translucency ratio, the recede-opacity ladder, the two leading rungs, the overlay ring widths, the scroll tail) is internal on the same terms, and declared **on** each root element, so setting a rung from an ancestor does nothing. A dial appears when a real consumer needs one; every dial is one more thing a reader has to hold.
 

package/dist/core/address.d.ts

@@ -1,4 +1,4 @@
-import type { Addr, HitGranularity } from '@quillmark/wasm';
+import type { Addr, HitGranularity, PathStep } from '@quillmark/wasm';
 /**
  * A canonical field address: `main.<field>` / `main.body` /
  * `cards.<kind>[<i>].<field>`, cards keyed by absolute document index.
@@ -63,7 +63,7 @@ export declare function cardPath(index: number, kinds: readonly string[]): DocPa
 /**
  * The inverse: a canonical `DocPath` back to the `Addr` the document verbs take, or
  * `undefined` for a path that names no single commit address — a nested or
- * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath} and
+ * array-element path (`main.keywords[0]`, which {@link nestedAddrForFieldPath} and
  * {@link nearestAddrForFieldPath} take instead), a field-rooted one, or a malformed
  * one. A bare card and a `.body` terminal both land on the field-less `{card: i}`
  * the body leaf answers to.
@@ -86,14 +86,21 @@ export declare function addrForFieldPath(path: DocPath): Addr | undefined;
  */
 export declare function nearestAddrForFieldPath(path: DocPath): Addr | undefined;
 /**
- * An array element's address, split: `main.keywords[0]` lands here, and anything
- * {@link addrForFieldPath} can name — or whose trailing segment is not an index —
- * does not. `regions()`, `positionAt` and `formatDocPath` all spell the index
- * segment bracketed, so there is one spelling to read and none to bridge.
+ * A nested address, split: the field's `Addr`, and the steps from it to the leaf.
+ * `main.keywords[0]` is `{field: keywords, steps: [0]}`,
+ * `main.vectors[0].tours[2].title` is `[0, 'tours', 2, 'title']`, and
+ * `main.contact.email` is `['email']`: an index segment reads as a number and a key as
+ * a string, the `PathStep` grammar `reader.getContentAt` walks. Anything
+ * {@link addrForFieldPath} can name — a field, a body, a card — has no steps and lands
+ * here as `undefined`; so does a body with something after it, a body holding no
+ * cells. Whether the schema declares each step is the caller's to check: this module
+ * holds the grammar and no schema. `regions()`, `positionAt` and `formatDocPath` all
+ * spell the index segment bracketed, so there is one spelling to read and none to
+ * bridge.
  */
-export declare function elementAddrForFieldPath(path: DocPath): ElementAddr | undefined;
-/** An array element's address: the array's `Addr`, and which element of it. */
-export interface ElementAddr {
+export declare function nestedAddrForFieldPath(path: DocPath): NestedAddr | undefined;
+/** A nested address: the field's `Addr`, and the steps from it to the leaf. */
+export interface NestedAddr {
     field: Addr;
-    index: number;
+    steps: PathStep[];
 }

package/dist/core/address.js

@@ -37,7 +37,7 @@ export function cardPath(index, kinds) {
 /**
  * The inverse: a canonical `DocPath` back to the `Addr` the document verbs take, or
  * `undefined` for a path that names no single commit address — a nested or
- * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath} and
+ * array-element path (`main.keywords[0]`, which {@link nestedAddrForFieldPath} and
  * {@link nearestAddrForFieldPath} take instead), a field-rooted one, or a malformed
  * one. A bare card and a `.body` terminal both land on the field-less `{card: i}`
  * the body leaf answers to.
@@ -66,21 +66,35 @@ export function nearestAddrForFieldPath(path) {
     return segs && addrForSegs(segs.slice(0, 2));
 }
 /**
- * An array element's address, split: `main.keywords[0]` lands here, and anything
- * {@link addrForFieldPath} can name — or whose trailing segment is not an index —
- * does not. `regions()`, `positionAt` and `formatDocPath` all spell the index
- * segment bracketed, so there is one spelling to read and none to bridge.
+ * A nested address, split: the field's `Addr`, and the steps from it to the leaf.
+ * `main.keywords[0]` is `{field: keywords, steps: [0]}`,
+ * `main.vectors[0].tours[2].title` is `[0, 'tours', 2, 'title']`, and
+ * `main.contact.email` is `['email']`: an index segment reads as a number and a key as
+ * a string, the `PathStep` grammar `reader.getContentAt` walks. Anything
+ * {@link addrForFieldPath} can name — a field, a body, a card — has no steps and lands
+ * here as `undefined`; so does a body with something after it, a body holding no
+ * cells. Whether the schema declares each step is the caller's to check: this module
+ * holds the grammar and no schema. `regions()`, `positionAt` and `formatDocPath` all
+ * spell the index segment bracketed, so there is one spelling to read and none to
+ * bridge.
  */
-export function elementAddrForFieldPath(path) {
+export function nestedAddrForFieldPath(path) {
     const segs = segsOf(path);
-    if (!segs)
+    if (!segs || segs.length < 3)
         return undefined;
-    const last = segs[segs.length - 1];
-    if (last?.seg !== 'index')
+    const field = addrForSegs(segs.slice(0, 2));
+    if (field?.field == null)
         return undefined;
-    const field = addrForSegs(segs.slice(0, -1));
-    // A body has no elements: the parent must name a field.
-    return field?.field != null ? { field, index: last.index } : undefined;
+    const steps = [];
+    for (const seg of segs.slice(2)) {
+        if (seg.seg === 'index')
+            steps.push(seg.index);
+        else if (seg.seg === 'field')
+            steps.push(seg.name);
+        else
+            return undefined;
+    }
+    return { field, steps };
 }
 /** `parseDocPath`, with a malformed path as `undefined` rather than a throw. The gate
  *  is read outside the try: an uninitialized core is not a malformed path, and would

package/dist/core/bloom.js

@@ -6,6 +6,7 @@
 // fixed by `--_qm-accent-wash`, so interpolating 0→1→0 keeps the scale in CSS where
 // `color-mix` resolves, instead of in keyframe values a script would have to
 // pre-resolve and re-resolve on a theme change.
+import { rungStyle } from './rungs.js';
 const BLOOM_CLASS = 'qm-bloom';
 const WASH = 'var(--_qm-accent-wash)';
 /** The dwell used when the derivation is out of reach (an unstyled root, or jsdom,
@@ -24,8 +25,8 @@ const FRAMES = [
 ];
 const FRAMES_REDUCED = [{ opacity: 1 }, { opacity: 1 }];
 /**
- * Run one wash on `el`, resolving the dwell off it so the number is single-sourced
- * in CSS.
+ * Run one wash on `el`, resolving the dwell off its root so the number is
+ * single-sourced in CSS (`core/rungs.ts`).
  *
  * One property, both motion preferences: `--_qm-bloom-dwell` already shortens under
  * `prefers-reduced-motion` in the derivation, so what is left to `matchMedia` here is
@@ -36,7 +37,7 @@ function bloom(el) {
     if (typeof el.animate !== 'function')
         return undefined;
     const reduced = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
-    const raw = getComputedStyle(el).getPropertyValue('--_qm-bloom-dwell').trim();
+    const raw = rungStyle(el).getPropertyValue('--_qm-bloom-dwell').trim();
     const n = Number.parseFloat(raw);
     const duration = !Number.isFinite(n) ? FALLBACK_MS : raw.endsWith('ms') ? n : n * 1000;
     return el.animate(reduced ? FRAMES_REDUCED : FRAMES, { duration });

package/dist/core/codec/blocks.js

@@ -1,6 +1,7 @@
 import { Selection } from 'prosemirror-state';
 import { chainCommands, splitBlock } from 'prosemirror-commands';
 import { canJoin, findWrapping } from 'prosemirror-transform';
+import { takesLineBreak } from './schema.js';
 /** The head of a textblock: where a shorthand fires, and where a pick lands once its
  *  run is consumed. */
 function atHead(state) {
@@ -33,10 +34,29 @@ function retype(name, attrs) {
         const { $from } = state.selection;
         if (!type || !atHead(state) || !fits($from, type))
             return false;
-        dispatch?.(state.tr.setBlockType($from.pos, $from.pos, type, attrs));
+        const tr = state.tr;
+        spaceBreaks(tr, $from, type);
+        dispatch?.(tr.setBlockType($from.pos, $from.pos, type, attrs));
         return true;
     };
 }
+/** Replace every `hard_break` in the caret's block with a space, ahead of a retype into
+ *  a type that holds none. `setBlockType` clears what the new type cannot hold by
+ *  deleting it, which joins the text either side with nothing and glues the words; a
+ *  space is what the break becomes at every other door (`breaks.ts`, `decode.ts`). A
+ *  break and a space are both one position wide, so an earlier replacement leaves every
+ *  later one addressed. */
+function spaceBreaks(tr, $from, type) {
+    const br = tr.doc.type.schema.nodes.hard_break;
+    if (!br || takesLineBreak(type))
+        return;
+    let at = $from.start();
+    $from.parent.forEach((child) => {
+        if (child.type === br)
+            tr.replaceWith(at, at + child.nodeSize, type.schema.text(' ', type.allowedMarks(child.marks)));
+        at += child.nodeSize;
+    });
+}
 /** `wrappingInputRule`'s body: wrap the block range at `pos`, then join a preceding
  *  sibling of the same type — the one boundary the wrap itself opens (`lists.ts`
  *  §cleanup: command-local, never a global pass). */

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

@@ -1,10 +1,18 @@
 import type { Schema } from 'prosemirror-model';
-import { Plugin } from 'prosemirror-state';
+import { Plugin, type Command } from 'prosemirror-state';
 /**
- * Rewrite every `\n` a transaction leaves in a non-`code` textblock to a `hard_break`.
+ * Rewrite every `\n` a transaction leaves in a non-`code` textblock: to a `hard_break`
+ * where the block takes one, to a space where it does not.
  *
  * 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;
+/**
+ * The line-break link of the body's key chains: `{}` for the inline schemas, which
+ * declare no break node. A `richtext(inline)` field is one line by construction
+ * (`Content::is_inline`), so there the key is swallowed beside Enter (`field.ts`)
+ * rather than answered here.
+ */
+export declare function breakKeymap(schema: Schema): Record<string, Command>;

package/dist/core/codec/breaks.js

@@ -1,6 +1,8 @@
-import { Plugin } from 'prosemirror-state';
+import { Plugin, TextSelection } from 'prosemirror-state';
+import { takesLineBreak } from './schema.js';
 /**
- * Rewrite every `\n` a transaction leaves in a non-`code` textblock to a `hard_break`.
+ * Rewrite every `\n` a transaction leaves in a non-`code` textblock: to a `hard_break`
+ * where the block takes one, to a space where it does not.
  *
  * 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
@@ -13,25 +15,79 @@ export function linebreakPlugin(schema) {
             if (!br || !trs.some((tr) => tr.docChanged))
                 return null;
             const at = [];
-            state.doc.descendants((node, pos) => {
+            state.doc.descendants((node, pos, parent) => {
                 // A code block's newlines are its content (`whitespace: 'pre'`).
                 if (node.type.spec.code)
                     return false;
-                if (!node.isText)
+                if (!node.isText || !parent)
                     return true;
+                // A space carries the marks the `\n` it stands in for was under, the way
+                // PM's own `clearIncompatible` fills one: without them a bolded break
+                // leaves an unbolded space, and one mark becomes two in the store.
+                const fill = takesLineBreak(parent.type)
+                    ? br.create()
+                    : schema.text(' ', parent.type.allowedMarks(node.marks));
                 const text = node.text ?? '';
                 for (let i = text.indexOf('\n'); i >= 0; i = text.indexOf('\n', i + 1))
-                    at.push(pos + i);
+                    at.push({ pos: pos + i, fill });
                 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.
+            // A break, a space and the `\n` either replaces are all 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());
+            for (const it of at)
+                tr.replaceWith(it.pos, it.pos + 1, it.fill);
             return tr;
         }
     });
 }
+/**
+ * Shift-Enter: a line break inside the caret's own block — the `continues` line a hard
+ * break is, never a second block.
+ *
+ * A selection that is not a text range is swallowed outright: an island is the subject of
+ * the next command, never a thing armed for replacement (`atoms.ts`). Otherwise the
+ * caret's own block decides. It **declines** in a code block, where the newline Enter
+ * takes already *is* that line and the code link binds the key one surface in
+ * (`code.ts`); it **swallows** the key where the block holds no break (`takesLineBreak`),
+ * a heading being the one of those; everywhere else it inserts the break.
+ *
+ * **Swallowing is the guard, not a spelling of declining.** A key the leaf declines is
+ * the browser's, a contenteditable answers this one with a `<br>`, and a heading that
+ * merely declined would take the space a `<br>` parses to.
+ *
+ * The break takes no marks and the caret keeps them: `decode` mints an unmarked break,
+ * so an inherited mark would leave the leaf holding a shape a re-hydrate swaps out
+ * (CODEC §Encode, one spelling of each shape), while dropping the marks from the
+ * *caret* would end a bold run at a line break the author only meant to wrap at.
+ */
+function insertBreak(schema) {
+    const br = schema.nodes.hard_break;
+    return (state, dispatch) => {
+        if (!(state.selection instanceof TextSelection))
+            return true;
+        const { parent } = state.selection.$from;
+        if (parent.type.spec.code)
+            return false;
+        if (!takesLineBreak(parent.type))
+            return true;
+        if (dispatch) {
+            const marks = state.storedMarks ?? state.selection.$from.marks();
+            dispatch(state.tr.replaceSelectionWith(br.create(), false).setStoredMarks(marks).scrollIntoView());
+        }
+        return true;
+    };
+}
+/**
+ * The line-break link of the body's key chains: `{}` for the inline schemas, which
+ * declare no break node. A `richtext(inline)` field is one line by construction
+ * (`Content::is_inline`), so there the key is swallowed beside Enter (`field.ts`)
+ * rather than answered here.
+ */
+export function breakKeymap(schema) {
+    if (!schema.nodes.hard_break)
+        return {};
+    return { 'Shift-Enter': insertBreak(schema) };
+}

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

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

package/dist/core/codec/code.js

@@ -158,10 +158,12 @@ function retypeAtProseEdge(side) {
  *
  * `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 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.
+ * otherwise splits the item in two, each half holding a code block. `Shift-Enter` is
+ * the same command because it is the same edit: the line break the key means
+ * everywhere else (`breaks.ts`) is, inside a fence, the newline Enter already takes.
+ * Every command here declines away from a code block — inside one for the four keys
+ * about its text, against one for the two about its edge — so the list links keep the
+ * keys elsewhere.
  */
 export function codeKeymap(schema) {
     if (!schema.nodes.code_block)
@@ -170,6 +172,7 @@ export function codeKeymap(schema) {
         Tab: indentInCode,
         'Shift-Tab': outdentInCode,
         Enter: newlineInCode,
+        'Shift-Enter': newlineInCode,
         Backspace: retypeAtProseEdge(-1),
         Delete: retypeAtProseEdge(1)
     };

package/dist/core/codec/decode.js

@@ -3,15 +3,14 @@
 // nodes; a code fence's lines → one `code_block`), nest by shared `containers`
 // prefix (`list_item`/`quote` → lists/blockquote), select the block node by
 // `kind`, apply marks over their `[start,end)` USV ranges (PM splits inline nodes
-// at mark boundaries), and lower island slots to leaf nodes (inline in a `para`
-// line, block on an `island` line). Anchors are not applied here; they are
-// decorations (field.ts). Positions throughout are USV; `Array.from` iterates by
+// at mark boundaries), and lower island slots to leaf nodes (block where a block
+// island's slot stands alone on its line, inline otherwise). Anchors are not
+// applied here; they are decorations (field.ts). Positions throughout are USV; `Array.from` iterates by
 // code point so an astral char is one unit, never a surrogate half.
 import { DOMSerializer } from 'prosemirror-model';
-import { ISLAND_SLOT } from './islands.js';
+import { ISLAND_SLOT, isBlockIsland } from './islands.js';
 import { descriptorOf, markKey, pmMarkFromContent } from './marks.js';
-import { hasMarks, isInlineSchema } from './schema.js';
-import { isAnchorMark, isCodeLine, isHeadingLine, isListItemContainer } from '@quillmark/wasm';
+import { hasMarks, isInlineSchema, takesLineBreak } from './schema.js';
 /** Code points of `s` (USV units): the iteration granularity the content speaks. */
 export function codePoints(s) {
     return Array.from(s);
@@ -50,7 +49,7 @@ export function decode(rt, schema) {
     // plaintext field that acquired one anyway — an older build's popover, a hand-
     // written document — is exactly the content that must open and then heal on the
     // next commit, not throw here.
-    const marks = hasMarks(schema) ? rt.marks.filter((m) => !isAnchorMark(m)) : [];
+    const marks = hasMarks(schema) ? rt.marks.filter((m) => m.type !== 'anchor') : [];
     const cursor = { i: 0, rt };
     if (isInlineSchema(schema)) {
         return decodeInline(rt, schema, lineTexts, starts, marks, cursor);
@@ -96,22 +95,21 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
             continue;
         }
         const here = path[depth];
-        // `ContentContainer` is an open set: a bare `here.container === 'x'` does not
-        // narrow, so the two arms this schema builds are claimed by the boundary's
-        // guard and a literal check, and everything else is an unknown the inert
-        // wrapper carries (CODEC §Open sets); no branch degrades silently.
-        if (isListItemContainer(here)) {
+        if (here.container === 'list_item') {
             // 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, instance } = here;
+            const { ordered, start } = here.attrs;
+            const instance = instanceOf(here);
             let j = i + 1;
             while (j < leaves.length) {
                 const c = atDepth(leaves[j], depth);
-                if (!c || !isListItemContainer(c) || c.ordered !== ordered || c.start !== start)
+                if (!c || c.container !== 'list_item')
+                    break;
+                if (c.attrs.ordered !== ordered || c.attrs.start !== start)
                     break;
                 // `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)
+                if (instanceOf(c) !== instance)
                     break;
                 j++;
             }
@@ -131,9 +129,11 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
             i = j;
             continue;
         }
-        // quote and every unknown container share one shape: a wrapper over the run
-        // of leaves carrying the identical container here (identity by `containerKey`,
-        // so two adjacent unknowns differing only in `attrs` stay two wrappers).
+        // The quote, and the whole of what is left: `satisfies` is the exhaustiveness
+        // check, so a container added upstream is a compile error here rather than a
+        // blockquote it is not. A wrapper over the run of leaves carrying the identical
+        // container here, identity by `containerKey`.
+        here.container;
         const key = containerKey(here);
         let j = i + 1;
         while (j < leaves.length) {
@@ -143,9 +143,7 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
             j++;
         }
         const inner = groupBlocks(schema, leaves.slice(i, j), depth + 1, marks, cursor);
-        out.push(here.container === 'quote'
-            ? schema.nodes.blockquote.create(null, inner)
-            : schema.nodes.unknown_container.create({ container: here.container, attrs: 'attrs' in here ? here.attrs : null }, inner));
+        out.push(schema.nodes.blockquote.create(null, inner));
         i = j;
     }
     return out;
@@ -154,61 +152,79 @@ function atDepth(leaf, depth) {
     return leaf.containers[depth];
 }
 /** The `ordinal` of a leaf's `list_item` at `depth`: only called inside a run the
- * guard has already established, so a miss is unreachable. */
+ * discriminant has already established, so a miss is unreachable. */
 function ordinalAt(leaf, depth) {
     const c = atDepth(leaf, depth);
-    return c && isListItemContainer(c) ? c.ordinal : -1;
+    return c?.container === 'list_item' ? c.attrs.ordinal : -1;
+}
+/** A container's `instance`, absent meaning the zero a canonical read omits. It is what
+ * tells one container from an adjacent sibling of identical shape, which contiguity
+ * alone reads as one, so absent and `0` have to answer alike. */
+function instanceOf(c) {
+    return c.instance ?? 0;
 }
-/** 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. */
+/** Identity of a container for run gathering: its name and its `instance`, NUL-joined
+ * as `markKey` joins a mark's. `list_item` carries its own run rule, so the quote is
+ * what keys here. */
 function containerKey(c) {
-    const id = `${c.container}\u0000${c.instance}`;
-    return 'attrs' in c ? `${id}\u0000${JSON.stringify(c.attrs)}` : id;
+    return `${c.container}\u0000${instanceOf(c)}`;
 }
-/** 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
- * payload-carrying arms read through the boundary's guards; the payload-free arms
- * compare literally, and anything left is unknown. */
+/** A single leaf block node from its segments. Exhaustive over the closed line
+ *  vocabulary, so a kind added upstream is a compile error rather than a silent
+ *  flattening to `para` that the next commit would store. */
 function makeLeaf(schema, leaf, marks, cursor) {
     const line = leaf.line;
-    if (line.kind === 'rule')
-        return schema.nodes.horizontal_rule.create();
-    if (line.kind === 'island') {
-        return schema.nodes.island_block.create(islandAttrs(cursor));
-    }
-    if (isCodeLine(line)) {
-        // One code_block: the segments' texts joined by literal `\n`, no marks.
-        const text = leaf.segments.map((s) => s.text).join('\n');
-        const content = text.length ? [schema.text(text)] : [];
-        return schema.nodes.code_block.create({ lang: line.lang ?? null }, content);
-    }
-    // para / heading / unknown: inline content, `hard_break` between continued segments.
-    const inline = [];
-    leaf.segments.forEach((seg, idx) => {
-        if (idx > 0)
-            inline.push(schema.nodes.hard_break.create());
-        inline.push(...buildInline(schema, seg.text, seg.startUSV, marks, cursor, false));
-    });
-    if (isHeadingLine(line)) {
-        return schema.nodes.heading.create({ level: line.level }, inline);
+    switch (line.kind) {
+        case 'rule':
+            return schema.nodes.horizontal_rule.create();
+        case 'code': {
+            // One code_block: the segments' texts joined by literal `\n`, no marks.
+            const text = leaf.segments.map((s) => s.text).join('\n');
+            const content = text.length ? [schema.text(text)] : [];
+            return schema.nodes.code_block.create({ lang: line.attrs?.lang ?? null }, content);
+        }
+        case 'para':
+        case 'heading': {
+            if (line.kind === 'para' && blockIslandLine(leaf, cursor))
+                return schema.nodes.island_block.create(islandAttrs(cursor));
+            // Inline content, the segment boundary a `hard_break` in a paragraph and a space
+            // in a heading, which takes none (`schema.ts` §`takesLineBreak`). A stored heading
+            // carries no continuation — the store clears one after a block of a single line —
+            // so the space is what keeps a hand-built content decodable.
+            const type = line.kind === 'heading' ? schema.nodes.heading : schema.nodes.paragraph;
+            const inline = [];
+            leaf.segments.forEach((seg, idx) => {
+                if (idx > 0)
+                    inline.push(takesLineBreak(type) ? schema.nodes.hard_break.create() : schema.text(' '));
+                inline.push(...buildInline(schema, seg.text, seg.startUSV, marks, cursor, false));
+            });
+            return line.kind === 'heading'
+                ? type.create({ level: line.attrs.level }, inline)
+                : type.create(null, inline);
+        }
+        default: {
+            const unreached = line;
+            return unreached;
+        }
     }
-    // An unknown kind renders as a paragraph and rides on it, so it re-encodes
-    // verbatim rather than flattening to `para` on the field's first edit.
-    const unknown = line.kind === 'para' ? null : { kind: line.kind, attrs: 'attrs' in line ? line.attrs : null };
-    return schema.nodes.paragraph.create({ unknown }, inline);
 }
-/** Consume the next island entry as PM node attrs (text-order matched to slots):
- *  the whole entry, `loss` included, which an island edit has to write back
- *  (`islands.ts`). A slot with no entry behind it is a malformed content; the empty
- *  attrs keep the decode total rather than throwing on a read. */
+/** Whether a `para` leaf is one block island: a single line holding its slot alone,
+ *  backed by an island whose markup is a block. The island is the one fact; the line
+ *  carries no kind of its own for it. */
+function blockIslandLine(leaf, cursor) {
+    if (leaf.segments.length !== 1 || leaf.segments[0].text !== ISLAND_SLOT)
+        return false;
+    const isl = cursor.rt.islands[cursor.i];
+    return isl != null && isBlockIsland(isl.type);
+}
+/** Consume the next island entry as PM node attrs (text-order matched to slots): the
+ *  whole entry, which an island edit has to write back (`islands.ts`). `null` where a
+ *  slot has no entry behind it, which is a malformed content: the slot draws nothing
+ *  and its line an empty paragraph, so the decode stays total without minting a node
+ *  whose `type` the vocabulary would refuse on the way back. */
 function islandAttrs(cursor) {
     const isl = cursor.rt.islands[cursor.i++];
-    if (!isl)
-        return { id: '', islandType: '', props: null, loss: 'unrepresentable' };
-    return { id: isl.id, islandType: isl.type, props: isl.props, loss: isl.loss };
+    return isl ? { id: isl.id, islandType: isl.type, props: isl.props } : null;
 }
 /**
  * Inline nodes for one segment: split text into maximal runs of a constant mark
@@ -227,20 +243,39 @@ function buildInline(schema, segText, segStartUSV, marks, cursor, stripIslands)
             out.push(schema.text(runText, runMarks));
         runText = '';
     };
+    // A mark set changes only where a mark starts or ends. `marks` is the field's whole
+    // list, so resolving one per code point costs the text against every mark in the
+    // document.
+    const segEndUSV = segStartUSV + cps.length;
+    const spanning = marks.filter((m) => m.start < segEndUSV && m.end > segStartUSV);
+    const edges = new Set();
+    for (const m of spanning) {
+        if (m.start > segStartUSV)
+            edges.add(m.start);
+        if (m.end < segEndUSV)
+            edges.add(m.end);
+    }
+    let active = [];
+    let key = '';
+    let unresolved = true;
     for (let k = 0; k < cps.length; k++) {
         const cp = cps[k];
         const pos = segStartUSV + k;
         if (cp === ISLAND_SLOT) {
             flush();
             const attrs = islandAttrs(cursor);
-            if (!stripIslands && schema.nodes.island_inline) {
+            if (attrs && !stripIslands && schema.nodes.island_inline) {
                 out.push(schema.nodes.island_inline.create(attrs));
             }
             runKey = '\0slot'; // force a fresh run after a slot
+            unresolved = true; // the slot's own position is skipped, edge or not
             continue;
         }
-        const active = marks.filter((m) => m.start <= pos && pos < m.end);
-        const key = markSetKey(active);
+        if (unresolved || edges.has(pos)) {
+            active = spanning.filter((m) => m.start <= pos && pos < m.end);
+            key = markSetKey(active);
+            unresolved = false;
+        }
         if (key !== runKey && runText.length)
             flush();
         if (key !== runKey) {