@quillmark/svelte 0.10.0 → 0.11.0

package/dist/core/codec/schema.js

@@ -1,92 +1,25 @@
 // The PM schema: the codec owns it; decode/encode target it. Nodes mirror the
 // content block kinds (para/heading/code/rule/island) and its container nesting
 // (list_item/quote → lists/blockquote); marks mirror the content formatting set.
-// Each of the three open sets gets an inert carrier so an unrecognized value
-// survives a round-trip: the `unknown` mark, the paragraph's `unknown` attribute,
-// and the `unknown_container` node. `blockSchema` is the full field; `inlineSchema`
-// is the constrained single-textblock form for `richtext(inline)` (one paragraph,
-// 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).
+// Each set is closed upstream, so the schema names its whole vocabulary and carries
+// nothing inert. `blockSchema` is the full field; `inlineSchema` is the constrained
+// single-textblock form for `richtext(inline)` (one paragraph, 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.
+// edges"), so every attribute written here is read back here. Foreign HTML spells none
+// of this package's `data-qm-*` 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 ───────────────────────────────────────────────────────────
-// An `href` is an attribute value and not markup, so the markdown → typed node → DOM
-// path that keeps a document's text from becoming tags never reaches it: what the
-// mark carries is what `toDOM` emits, and `renderContent` paints marks outside a
-// `contenteditable` (the tips card), where a click is a plain one.
-//
-// An allowlist, because the set a document can spell is open: naming the dangerous
-// schemes instead loses to the first one this has not heard of. It holds what the
-// surface has a caller for; a scheme reaching it later is a line.
-const RENDERED_SCHEMES = new Set(['http', 'https', 'mailto', 'tel', 'ftp']);
-/** A scheme and its colon: a letter, then letters, digits, `+`, `-` or `.` (RFC 3986). */
-const SCHEME = /^([a-z][a-z0-9+.-]*):/i;
-/** Dropped before the scheme is read, so a tab spliced into `javascript:` is tested
- *  as what it navigates to. Wider than the URL parser's own tab/newline rule: no
- *  scheme carries a control character, and the strip decides without rewriting. */
-const IGNORED = /[\u0000-\u0020]/g;
-/**
- * Whether a link carrying `href` renders as one. A value with no scheme is relative
- * to the embedding page and has none to refuse.
- *
- * A refused href is unchanged: it stays on the mark and round-trips, so a document
- * survives an editor that declines to make it clickable.
- */
-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;
-}
+import { rendersHref, storableUrl } from './urls.js';
 // ── 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`
-    // last so it wraps outermost; `unknown` after it, non-exclusive so several
-    // distinct unknown marks coexist on one range.
+    // last so it wraps outermost.
     strong: { parseDOM: [{ tag: 'strong' }, { tag: 'b' }], toDOM: () => ['strong', 0] },
     em: { parseDOM: [{ tag: 'em' }, { tag: 'i' }], toDOM: () => ['em', 0] },
     underline: { parseDOM: [{ tag: 'u' }], toDOM: () => ['u', 0] },
@@ -96,8 +29,11 @@ const marks = {
         attrs: { href: { default: '' } },
         inclusive: false,
         parseDOM: [
-            { tag: 'a[href]', getAttrs: (el) => ({ href: el.getAttribute('href') }) },
-            { tag: 'span[data-qm-href]', getAttrs: (el) => ({ href: el.getAttribute('data-qm-href') }) }
+            { tag: 'a[href]', getAttrs: (el) => ({ href: storableUrl(el.getAttribute('href') ?? '') }) },
+            {
+                tag: 'span[data-qm-href]',
+                getAttrs: (el) => ({ href: storableUrl(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. The value rides on the
@@ -108,35 +44,8 @@ const marks = {
             const href = mark.attrs.href;
             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
-    // re-emits its stored `type`/`attrs` on encode. `excludes: ''` lets marks of
-    // this type with different attrs share a range (they are distinct families).
-    unknown: {
-        attrs: { type: { default: '' }, attrs: { default: null } },
-        excludes: '',
-        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
@@ -162,31 +71,18 @@ function fenceLang(pre) {
 // ── Block nodes ─────────────────────────────────────────────────────────────
 const blockNodes = {
     doc: { content: 'block+' },
-    // `unknown` carries a line `kind` this build does not know (`{ kind, attrs }`,
-    // else null). A paragraph is how such a line renders, so the carrier is an
-    // attribute rather than a node type: every paragraph command already reaches it,
-    // and retyping it to a heading or a list drops the attribute: an explicit
-    // conversion, which is the one place the unknown kind should be lost.
     paragraph: {
         content: 'inline*',
         group: 'block',
-        attrs: { unknown: { default: null } },
-        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, ...packAttrs(u.attrs) }, 0] : ['p', 0];
-        }
+        parseDOM: [{ tag: 'p' }],
+        toDOM: () => ['p', 0]
     },
+    // A heading holds no `hard_break`: it is a block of one line, so the store clears a
+    // `continues` after one and markdown has no syntax for a break inside it. Declaring
+    // it out is what makes that structural — a paste parses the `<br>` away and a
+    // conversion onto a heading drops it, rather than each door holding the rule.
     heading: {
-        content: 'inline*',
+        content: '(text | island_inline)*',
         group: 'block',
         defining: true,
         attrs: { level: { default: 1 } },
@@ -256,35 +152,6 @@ const blockNodes = {
         parseDOM: [{ tag: 'li' }],
         toDOM: () => ['li', 0]
     },
-    // A container this build does not know: a transparent wrapper that renders as a
-    // bare block (its children flow at the enclosing level, which is how upstream
-    // renders it) and re-emits its `container`/`attrs` on encode. `defining` so a
-    // lift out of it is deliberate rather than a backspace away.
-    unknown_container: {
-        content: 'block+',
-        group: 'block',
-        defining: true,
-        attrs: { container: { default: '' }, attrs: { default: null } },
-        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 ────────────────────────────────────────────────────────────
@@ -339,3 +206,10 @@ export function hasMarks(schema) {
 export function isInlineSchema(schema) {
     return !schema.nodes.blockquote;
 }
+/** Whether `type` can hold a within-block line break, which a heading cannot (§`heading`).
+ *  What a `\n` landing in a textblock is rewritten to turns on it (`breaks.ts`), and so
+ *  does what decode puts between a block's continued segments. */
+export function takesLineBreak(type) {
+    const br = type.schema.nodes.hard_break;
+    return !!br && type.contentMatch.matchType(br) !== null;
+}

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

@@ -14,7 +14,7 @@
 // field's, so one undo stack covers the leaf), no anchor plugin (an anchor in a cell
 // is preserved, never minted), and no placeholder.
 //
-// The chrome is A band and A selection (CODEC §"The table island"), and it raises
+// The chrome is a band and a selection (CODEC §"The table island"), and it raises
 // nothing. Every control is absolutely positioned out of the grid, so the band is in no
 // row and no column of it; `codec/prose.css` draws the band and the selection wash both.
 import { baseKeymap, chainCommands, toggleMark } from 'prosemirror-commands';
@@ -142,7 +142,8 @@ class TableIslandView {
     drag;
     sweep;
     /** The grips, by the line each acts on: what selection paint and a drag reach for
-     *  without a query. The typed twin of `cells`. */
+     *  without a query. The typed twin of `cells`, `Line` included — a key parsed back
+     *  into one is the `data-` attribute `MountedCell.box` refuses. */
     grips = new Map();
     /** The grid's own box, and the containing block every out-of-flow control is placed
      *  against. Not the scroller: an absolute inside a scroll container is placed
@@ -175,13 +176,17 @@ class TableIslandView {
             return true;
         }
         // Same rectangle: reseed only the cells whose value the nested view is not
-        // already showing. The cell that produced this update projects to exactly what
-        // it stored, so it compares equal and keeps its caret; an undo or an external
+        // already showing. The cell that produced this update wrote exactly what it is
+        // showing, so it compares equal and keeps its caret; an undo or an external
         // re-hydrate does not, and takes the fresh state.
+        //
+        // Against `shown` rather than a projection of the doc: this runs on every outer
+        // transaction, which is every keystroke in the table, and projecting each cell
+        // costs a `mapMarks` across the WASM boundary wherever one holds an anchor.
         this.rendered = props;
         for (const mounted of this.cells) {
             const stored = cellAt(props, mounted.r, mounted.c);
-            if (cellEqual(stored, cellFromDoc(mounted.view.state.doc, stored)))
+            if (cellEqual(stored, mounted.shown))
                 continue;
             const head = mounted.view.state.selection.head;
             const fresh = EditorState.create({
@@ -189,6 +194,7 @@ class TableIslandView {
                 plugins: cellPlugins(this.cellKeys(mounted.r, mounted.c))
             });
             mounted.view.updateState(fresh);
+            mounted.shown = stored;
             // Best-effort caret continuity, the rule a field's own re-hydrate takes: keep
             // the offset, clamped into the text that is there now. A fresh state resolves
             // its selection to the start of the cell, so an undo would otherwise put the
@@ -272,19 +278,39 @@ class TableIslandView {
             this.caretBeside(point);
     };
     /** The cell a press inside the frame belongs to: the nearest by rect, which for a
-     *  press on a border or a cell's own padding is the cell it is against. */
+     *  press on a border or a cell's own padding is the cell it is against.
+     *
+     *  A row's cells share a vertical extent and a column's a horizontal one, and the
+     *  distance is a hypotenuse of the two, so the nearest cell is the nearest row
+     *  crossed with the nearest column: the header row and the first column answer for
+     *  the whole grid. R+C rects rather than R×C, for the reason a line drag measures
+     *  once — at 20x8 that is 27 forced layouts a press instead of 160. */
     focusNearestCell(point) {
-        let best;
-        let nearest = Infinity;
+        let row;
+        let column;
+        let nearestRow = Infinity;
+        let nearestColumn = Infinity;
         for (const mounted of this.cells) {
-            const at = distance(mounted.host.getBoundingClientRect(), point);
-            if (at >= nearest)
+            if (mounted.c !== 0 && mounted.r !== 0)
                 continue;
-            nearest = at;
-            best = mounted;
+            const box = mounted.host.getBoundingClientRect();
+            if (mounted.c === 0) {
+                const at = Math.max(box.top - point.y, 0, point.y - box.bottom);
+                if (at < nearestRow) {
+                    nearestRow = at;
+                    row = mounted.r;
+                }
+            }
+            if (mounted.r === 0) {
+                const at = Math.max(box.left - point.x, 0, point.x - box.right);
+                if (at < nearestColumn) {
+                    nearestColumn = at;
+                    column = mounted.c;
+                }
+            }
         }
-        if (best)
-            this.focusCell(best.r, best.c);
+        if (row !== undefined && column !== undefined)
+            this.focusCell(row, column);
     }
     /** A caret beside the island, on the side the press landed: a gap cursor where the
      *  document holds no text position there, and the neighbouring block's own edge
@@ -388,9 +414,10 @@ class TableIslandView {
     }
     // ── The selection ─────────────────────────────────────────────────────────
     /** The rectangle a line covers, which is what selecting one means: a grip draws no
-     *  second kind of selection, it draws this one. */
-    lineCells(line) {
-        const props = this.props();
+     *  second kind of selection, it draws this one. `props` is the caller's where it
+     *  reads a line per grip ({@link TableIslandView.paintSelection}): each `props()`
+     *  revalidates the whole table. */
+    lineCells(line, props = this.props()) {
         return line.axis === 'row'
             ? { r0: line.index, c0: 0, r1: line.index, c1: columnCount(props) - 1 }
             : { r0: 0, c0: line.index, r1: rowCount(props) - 1, c1: line.index };
@@ -442,6 +469,10 @@ class TableIslandView {
             : undefined;
     }
     select(cells) {
+        // A sweep resolves a rectangle per pointer move and most of them are the one
+        // already held, which is a repaint of the state that is up.
+        if (this.selected && sameCells(this.selected, cells))
+            return;
         // One subject at a time: a cell selection retires an island one, or the surface
         // paints a washed row inside an outlined table and the next Backspace has two
         // honest readings.
@@ -468,11 +499,9 @@ class TableIslandView {
      *  and a selection is exactly the state that must not cost the carets in them. */
     paintSelection() {
         const held = this.selected;
-        for (const [key, grip] of this.grips) {
-            const [axis, index] = key.split(':');
-            const line = { axis: axis, index: Number(index) };
-            grip.setAttribute('aria-pressed', String(!!held && sameCells(held, this.lineCells(line))));
-        }
+        const props = this.props();
+        for (const { line, grip } of this.grips.values())
+            grip.setAttribute('aria-pressed', String(!!held && sameCells(held, this.lineCells(line, props))));
         for (const cell of this.cells)
             cell.box.toggleAttribute('data-selected', !!held && cell.r >= held.r0 && cell.r <= held.r1 && cell.c >= held.c0 && cell.c <= held.c1);
     }
@@ -556,6 +585,10 @@ class TableIslandView {
     onGripDown = (line, grip, event) => {
         if (event.button !== 0)
             return;
+        // The previous gesture ends first, as `armSweep`'s does: `endDrag` reads
+        // `this.drag` to know which grip to unbind, so a second press over a live drag
+        // would orphan the first grip's listeners and its pointer capture.
+        this.endDrag();
         this.drag = {
             line,
             origin: { x: event.clientX, y: event.clientY },
@@ -833,7 +866,7 @@ class TableIslandView {
         bar.appendChild(svg(GRIP[line.axis]));
         btn.appendChild(bar);
         btn.addEventListener('pointerdown', (e) => this.onGripDown(line, btn, e));
-        this.grips.set(lineKey(line), btn);
+        this.grips.set(lineKey(line), { line, grip: btn });
         return btn;
     }
     /** A trailing bar: the whole edge past the last line of its axis, and the one way a
@@ -863,9 +896,10 @@ class TableIslandView {
     mountCell(box, host, r, c, s) {
         const props = this.props();
         const name = s.tableCell(r === 0 ? s.tableHeaderRow : s.tableRow(r), s.tableColumn(c + 1));
+        const seed = cellAt(props, r, c);
         const view = new EditorView(host, {
             state: EditorState.create({
-                doc: decode(cellContent(cellAt(props, r, c)), inlineSchema),
+                doc: decode(cellContent(seed), inlineSchema),
                 plugins: cellPlugins(this.cellKeys(r, c))
             }),
             attributes: { 'aria-label': name, class: 'qm-table-cell-editor' },
@@ -885,7 +919,9 @@ class TableIslandView {
                 // reseed it comes back as changes no cell's own doc.
                 this.clearSelection();
                 const now = this.props();
-                this.write(withCell(now, r, c, cellFromDoc(next.doc, cellAt(now, r, c))));
+                const cell = cellFromDoc(next.doc, cellAt(now, r, c));
+                mounted.shown = cell;
+                this.write(withCell(now, r, c, cell));
             },
             handleDOMEvents: {
                 focus: () => {
@@ -895,7 +931,18 @@ class TableIslandView {
                 }
             }
         });
-        this.cells.push({ view, host, box, unregister: this.deps.register(view), r, c });
+        // `seed` is what the doc above was decoded from, and decode∘project is identity
+        // (`table.ts`, the cell codec), so it is what this view is showing.
+        const mounted = {
+            view,
+            host,
+            box,
+            shown: seed,
+            unregister: this.deps.register(view),
+            r,
+            c
+        };
+        this.cells.push(mounted);
     }
     // ── Ops ───────────────────────────────────────────────────────────────────
     /** The table this view is currently showing; the zero table if the node stopped
@@ -1029,6 +1076,10 @@ class TableIslandView {
             'Alt-ArrowRight': line('column', 1, true),
             Tab: () => this.step(r, c, 1),
             'Shift-Tab': () => this.step(r, c, -1),
+            // A cell is one line (`normalize` rewrites a cell newline to a space), so the
+            // key the body answers with a break is claimed here and does nothing: Enter
+            // already means the next row, and an unclaimed key is the browser's `<br>`.
+            'Shift-Enter': () => true,
             Enter: () => {
                 // Over a rectangle it hands the caret back, which is the line verbs' own
                 // exit: the caret never left the cell, so there is nowhere else to put it.

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

@@ -88,14 +88,15 @@ export declare function cellContent(cell: TableCell): Content;
  * the field plugin's coordinate space (the field's position map holds one `atom`
  * run for the whole table), so nothing here can mint one and the popover withholds
  * its `anchor` button while the caret is in a cell. Preserving them still means
- * rebasing: a cell edit is a splice like any other, so each held anchor maps through
- * the cell's own text delta by the rule `applyChange` uses on a field's
- * (start-assoc `after`), and a mark the splice deleted through lands where the
- * splice left it rather than pointing past the text.
+ * rebasing: a cell edit is a splice like any other, so `mapMarks` carries each held
+ * anchor through the cell's own delta by the rule the store applies to a field's,
+ * and a mark the splice deleted through lands where the splice left it rather than
+ * pointing past the text.
  */
 export declare function cellFromDoc(doc: PMNode, prior: TableCell): TableCell;
 /** Whether two cells are the same value: what tells an own edit (the projection the
- *  view just produced) from an external one (an undo, a re-hydrate) without a flag. */
+ *  view just produced) from an external one (an undo, a re-hydrate) without a flag.
+ *  The marks structurally, for the reason `reconcile.ts` states. */
 export declare function cellEqual(a: TableCell, b: TableCell): boolean;
 /** Whether two tables have the same rectangle and alignment: the change that forces
  *  a rebuild rather than a per-cell reseed. */

package/dist/core/codec/table.js

@@ -1,23 +1,6 @@
-// The table island's model: the cell codec (a `TableCell` ↔ one inline-schema PM
-// doc) and the rectangularizing constructors every row and column op goes through
-// (CODEC §Islands, §"The table island").
-//
-// `TableProps` normalizes to one column count shared by `header`, every row, and
-// `aligns`, so a ragged table is not a state the content can hold. The editor keeps
-// its optimistic PM and re-hydrates only on an external change (CODEC
-// §Reconciliation), so an op that emitted a ragged table would leave the store
-// rectangularized and PM ragged with no error channel and no repair. Every
-// constructor here therefore ends in {@link normalizeTable}, and a caller reaches
-// the shape only through them.
-//
-// A cell is its own content unit: `marks` are USV offsets into that cell's `text`,
-// not into `Content.text`. That is the second coordinate space, and the inline mode
-// the codec already runs (one paragraph, no containers, no islands) is exactly its
-// shape, so a cell decodes and projects through the same machinery a
-// `richtext(inline)` field does.
-import { isAnchorMark } from '@quillmark/wasm';
 import { core } from '../lifecycle.js';
 import { contentEdit, pmToContent } from './encode.js';
+import { valueEqual } from './reconcile.js';
 /** The alignments a column can take: the four the content declares, `none` first
  *  because it is what a column arrives at and what a set is cleared back to. */
 export const ALIGNS = ['none', 'left', 'center', 'right'];
@@ -219,32 +202,32 @@ export function cellContent(cell) {
  * the field plugin's coordinate space (the field's position map holds one `atom`
  * run for the whole table), so nothing here can mint one and the popover withholds
  * its `anchor` button while the caret is in a cell. Preserving them still means
- * rebasing: a cell edit is a splice like any other, so each held anchor maps through
- * the cell's own text delta by the rule `applyChange` uses on a field's
- * (start-assoc `after`), and a mark the splice deleted through lands where the
- * splice left it rather than pointing past the text.
+ * rebasing: a cell edit is a splice like any other, so `mapMarks` carries each held
+ * anchor through the cell's own delta by the rule the store applies to a field's,
+ * and a mark the splice deleted through lands where the splice left it rather than
+ * pointing past the text.
  */
 export function cellFromDoc(doc, prior) {
     const projected = pmToContent(doc);
     const text = projected.text;
-    const anchors = prior.marks.filter(isAnchorMark);
+    const anchors = prior.marks.filter((m) => m.type === 'anchor');
     if (!anchors.length)
         return { text, marks: projected.marks };
-    const delta = contentEdit(cellContent(prior), cellContent({ text, marks: [] })).delta;
-    const { mapPos } = core();
-    const rebased = anchors.map((a) => {
-        const pos = delta ? mapPos(delta, a.start, 'after') : a.start;
-        return { ...a, start: pos, end: pos };
-    });
+    const before = cellContent(prior);
+    const delta = contentEdit(before, cellContent({ text, marks: [] })).delta;
+    const rebased = core()
+        .mapMarks(before, delta ? { delta } : {})
+        .filter((m) => m.type === 'anchor');
     return {
         text,
         marks: [...projected.marks, ...rebased].sort((a, b) => a.start - b.start || a.end - b.end)
     };
 }
 /** Whether two cells are the same value: what tells an own edit (the projection the
- *  view just produced) from an external one (an undo, a re-hydrate) without a flag. */
+ *  view just produced) from an external one (an undo, a re-hydrate) without a flag.
+ *  The marks structurally, for the reason `reconcile.ts` states. */
 export function cellEqual(a, b) {
-    return a.text === b.text && JSON.stringify(a.marks) === JSON.stringify(b.marks);
+    return a.text === b.text && valueEqual(a.marks, b.marks);
 }
 /** Whether two tables have the same rectangle and alignment: the change that forces
  *  a rebuild rather than a per-cell reseed. */

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

@@ -0,0 +1,20 @@
+/**
+ * Whether a link carrying `href` renders as one. A value with no scheme is relative
+ * to the embedding page and has none to refuse.
+ *
+ * A refused href is unchanged: it stays on the mark and round-trips, so a document
+ * survives an editor that declines to make it clickable.
+ */
+export declare function rendersHref(href: string): boolean;
+/**
+ * A url the store will take: the one character class the authored lane refuses, a CR
+ * or an LF, percent-encoded. CommonMark admits no line ending in a link destination,
+ * so `MarkOp.add` of a `link`, an `image` island op and `overwrite` all throw on one —
+ * and both of a leaf's commit lanes throwing is a field that stops persisting for the
+ * session, since the PM doc still holds the mark on the next keystroke.
+ *
+ * Applied where a value enters the model from outside it (a paste's `href`, the link
+ * prompt), which is the only door that can produce one: `importMarkdown` mints none,
+ * and `toMarkdown` writes the same `%0A` / `%0D`.
+ */
+export declare function storableUrl(url: string): string;

package/dist/core/codec/urls.js

@@ -0,0 +1,45 @@
+// URLs at the model's edge. A link's `href` and an image island's `url` are the two
+// values a document carries that a renderer follows, and both enter the model from
+// outside it — a paste's markup, the link prompt. One module because the two rules are
+// one rule: what renders, and what the store will take.
+// ── The href gate ───────────────────────────────────────────────────────────
+// An `href` is an attribute value and not markup, so the markdown → typed node → DOM
+// path that keeps a document's text from becoming tags never reaches it: what the
+// mark carries is what `toDOM` emits, and `renderContent` paints marks outside a
+// `contenteditable` (the tips card), where a click is a plain one.
+//
+// An allowlist, because the set a document can spell is open: naming the dangerous
+// schemes instead loses to the first one this has not heard of. It holds what the
+// surface has a caller for; a scheme reaching it later is a line.
+const RENDERED_SCHEMES = new Set(['http', 'https', 'mailto', 'tel', 'ftp']);
+/** A scheme and its colon: a letter, then letters, digits, `+`, `-` or `.` (RFC 3986). */
+const SCHEME = /^([a-z][a-z0-9+.-]*):/i;
+/** Dropped before the scheme is read, so a tab spliced into `javascript:` is tested
+ *  as what it navigates to. Wider than the URL parser's own tab/newline rule: no
+ *  scheme carries a control character, and the strip decides without rewriting. */
+const IGNORED = /[\u0000-\u0020]/g;
+/**
+ * Whether a link carrying `href` renders as one. A value with no scheme is relative
+ * to the embedding page and has none to refuse.
+ *
+ * A refused href is unchanged: it stays on the mark and round-trips, so a document
+ * survives an editor that declines to make it clickable.
+ */
+export function rendersHref(href) {
+    const scheme = SCHEME.exec(href.replace(IGNORED, ''));
+    return scheme === null || RENDERED_SCHEMES.has(scheme[1].toLowerCase());
+}
+/**
+ * A url the store will take: the one character class the authored lane refuses, a CR
+ * or an LF, percent-encoded. CommonMark admits no line ending in a link destination,
+ * so `MarkOp.add` of a `link`, an `image` island op and `overwrite` all throw on one —
+ * and both of a leaf's commit lanes throwing is a field that stops persisting for the
+ * session, since the PM doc still holds the mark on the next keystroke.
+ *
+ * Applied where a value enters the model from outside it (a paste's `href`, the link
+ * prompt), which is the only door that can produce one: `importMarkdown` mints none,
+ * and `toMarkdown` writes the same `%0A` / `%0D`.
+ */
+export function storableUrl(url) {
+    return url.replace(/\r/g, '%0D').replace(/\n/g, '%0A');
+}

package/dist/preset/recipes.css

@@ -112,7 +112,7 @@ html:has(.qm-workspace) {
 	display: none;
 }
 
-/* One mount at A time under the threshold, rather than two of them abreast. Half a narrow
+/* One mount at a time under the threshold, rather than two of them abreast. Half a narrow
    viewport is under the width either surface reads at, so the split stops being one and
    the tracks become views of the same room: the host says which with `data-qm-show`, and
    the attribute names the track rather than what is in it, so nothing here knows an editor

package/dist/preset/scale.css

@@ -1,10 +1,13 @@
-/* The host'S derivation: the same public dials in, a closed `--qmh-*` scale for the
+/* The host's derivation: the same public dials in, a closed `--qmh-*` scale for the
    page around the surfaces out. `core/theme.css` is the same shape one level down
    (dials in, `--_qm-*` out), and the two are calibrated against each other: the
-   figures here are the figures there (the ground step's ramp, 8% hover, 17%
-   border, 45% ink, the ring's width, the status hue at both poles) and the
+   figures here are the figures there (the ground step's ramp, 8% hover, the
+   ring's width, the status hue at both poles) and the
    dial means the same plane in both, so a host plate and a card on it land on the same
-   tone at both poles and a host page meets an editor's own column exactly. The well
+   tone at both poles and a host page meets an editor's own column exactly. The border
+   and ink rungs are each calibrated for their own plane rather than shared: a page's
+   chrome is read at one size against one ground, a card's interior at several against
+   the rungs under it, so the mixes are not the same figure. The well
    under the ground has no counterpart here: a host's own controls are boxed and carry a
    hairline, so nothing on a page needs the step an edgeless field does.