@quillmark/svelte 0.10.0 → 0.11.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

@@ -24,6 +24,8 @@ Nothing to import and nothing to set. The package pulls its own stylesheet, and
 
 **Placing and sizing**: each surface carries a stable root class (`.qm-editor`, `.qm-preview`), so you can place it from your own stylesheet without a wrapper. Each also takes a `class` prop that merges onto the same element, which is the better handle when you have one to give.
 
+A surface's width is the one you give it. Each contains its own inline size, so what a document holds — a table is as wide as its columns — scrolls inside the mount rather than widening the column the mount stands in.
+
 **Taking the column back**: our selectors compute at specificity zero (below), so `padding: 0` or a `background` of your own on `.qm-editor` wins outright. Nothing is locked.
 
 ## Make it yours
@@ -121,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>
 ```
 
@@ -191,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/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

@@ -10,8 +10,7 @@
 import { DOMSerializer } from 'prosemirror-model';
 import { ISLAND_SLOT } 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,73 @@ 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 'island': {
+            const attrs = islandAttrs(cursor);
+            return attrs ? schema.nodes.island_block.create(attrs) : schema.nodes.paragraph.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': {
+            // 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. */
+ *  (`islands.ts`). `null` where a slot has no entry behind it, which is a malformed
+ *  content: the slot draws an empty paragraph or nothing at all, 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, loss: isl.loss } : null;
 }
 /**
  * Inline nodes for one segment: split text into maximal runs of a constant mark
@@ -227,20 +237,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) {

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

@@ -21,8 +21,6 @@ export interface Scan {
     marks: ContentMark[];
     islands: ContentIsland[];
     runs: PosRun[];
-    /** Total PM position at the end of the document content (doc.content.size). */
-    pmEnd: number;
     /** Total USV length of `text`. */
     usvEnd: number;
 }
@@ -32,15 +30,14 @@ export interface Scan {
  * source both `pmToContent` and the position map draw from.
  */
 export declare function scanDoc(doc: PMNode): Scan;
+/** The content projection a scan carries (drops the position runs): what a caller
+ *  holding a `Scan` reads instead of walking the document a second time. */
+export declare function scanContent(s: Scan): Content;
 /** `pmToContent`: the pure inverse of decode (drops the position runs). */
 export declare function pmToContent(doc: PMNode): Content;
 interface LowerOpts {
-    /** Anchor decoration positions before the edit (post-nothing); see field.ts. */
-    oldAnchors?: {
-        id: string;
-        pos: number;
-    }[];
-    /** Anchor decoration positions after the edit, in final (new) USV coords. */
+    /** Anchor decoration positions after the edit, in final (new) USV coords. The
+     *  pre-edit set is `oldRt`'s own, so only the projection's is passed in. */
     newAnchors?: {
         id: string;
         pos: number;