@quillmark/svelte 0.10.0 → 0.11.0

package/dist/core/codec/encode.js

@@ -1,9 +1,8 @@
-import { isAnchorMark } from '@quillmark/wasm';
 import { core } from '../lifecycle.js';
 import { codePoints, usvLength } from './decode.js';
 import { ISLAND_SLOT, islandEntryFromNode } from './islands.js';
-import { contentDescriptorFromPM, descriptorOf, markKey } from './marks.js';
-import { valueEqual } from './reconcile.js';
+import { anchorsFromContent, contentDescriptorFromPM, descriptorOf, markKey } from './marks.js';
+import { canonicalJson, valueEqual } from './reconcile.js';
 /** Append `s` to the accumulated text, advancing the running USV length. */
 function appendText(acc, s) {
     acc.text += s;
@@ -21,7 +20,6 @@ export function scanDoc(doc) {
         marks: [],
         islands: [],
         runs: [],
-        pmEnd: doc.content.size,
         usvEnd: 0,
         rawMarks: [],
         lastContentEndPm: 0
@@ -30,10 +28,15 @@ export function scanDoc(doc) {
     acc.marks = mergeMarks(acc.rawMarks);
     return acc;
 }
+/** 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 function scanContent(s) {
+    const { text, lines, marks, islands } = s;
+    return { text, lines, marks, islands };
+}
 /** `pmToContent`: the pure inverse of decode (drops the position runs). */
 export function pmToContent(doc) {
-    const { text, lines, marks, islands } = scanDoc(doc);
-    return { text, lines, marks, islands };
+    return scanContent(scanDoc(doc));
 }
 /** Walk a block-content fragment; `contentStart` is the PM pos before its first child.
  * Two container siblings of one run shape read as a single container — contiguity plus
@@ -54,7 +57,7 @@ function scanBlocks(acc, parent, contentStart, containers) {
 }
 /** A block's container run shape, `ordinal` and `instance` aside; null where it opens
  * no container. A list's `start` is not in it — the store welds two runs differing only
- * there — and an unknown's `attrs` is, as `containerKey` reads it on the way back. */
+ * there. */
 function runShape(node) {
     switch (node.type.name) {
         case 'blockquote':
@@ -63,8 +66,6 @@ function runShape(node) {
             return 'list\u0000bullet';
         case 'ordered_list':
             return 'list\u0000ordered';
-        case 'unknown_container':
-            return `unknown\u0000${node.attrs.container}\u0000${JSON.stringify(node.attrs.attrs)}`;
         default:
             return null;
     }
@@ -85,7 +86,7 @@ function scanBlock(acc, node, nodePos, containers, instance) {
         }
         case 'code_block': {
             const lang = node.attrs.lang ?? undefined;
-            const kind = lang != null ? { kind: 'code', lang } : { kind: 'code' };
+            const kind = lang != null ? { kind: 'code', attrs: { lang } } : { kind: 'code' };
             beginLine(acc, contentStart, containers, kind);
             const codeText = node.textContent;
             if (codeText.length)
@@ -110,12 +111,9 @@ function scanBlock(acc, node, nodePos, containers, instance) {
             acc.lastContentEndPm = nodePos + 1;
             break;
         case 'blockquote':
-            scanBlocks(acc, node, contentStart, [...containers, { container: 'quote', instance }]);
-            break;
-        case 'unknown_container':
             scanBlocks(acc, node, contentStart, [
                 ...containers,
-                { container: node.attrs.container, attrs: node.attrs.attrs, instance }
+                withInstance({ container: 'quote' }, instance)
             ]);
             break;
         case 'bullet_list':
@@ -124,13 +122,7 @@ function scanBlock(acc, node, nodePos, containers, instance) {
             const start = ordered ? node.attrs.start : 1;
             let itemPos = contentStart;
             node.forEach((item, _off, index) => {
-                const container = {
-                    container: 'list_item',
-                    ordered,
-                    start,
-                    ordinal: index,
-                    instance
-                };
+                const container = withInstance({ container: 'list_item', attrs: { ordered, start, ordinal: index } }, instance);
                 scanBlocks(acc, item, itemPos + 1, [...containers, container]);
                 itemPos += item.nodeSize;
             });
@@ -142,13 +134,17 @@ function scanBlock(acc, node, nodePos, containers, instance) {
             acc.lastContentEndPm = contentStart;
     }
 }
-/** A textblock's line kind: a heading's `level`, or (for a paragraph) `para`, or
- * the unknown kind it carries (schema.ts) re-emitted verbatim. */
+/** A textblock's line kind: a heading's `level`, or (for a paragraph) `para`. */
 function textblockKind(node) {
     if (node.type.name === 'heading')
-        return { kind: 'heading', level: node.attrs.level };
-    const u = node.attrs.unknown;
-    return u ? { kind: u.kind, attrs: u.attrs } : { kind: 'para' };
+        return { kind: 'heading', attrs: { level: node.attrs.level } };
+    return { kind: 'para' };
+}
+/** A container with its run `instance`, spelled only where it is not the zero a
+ * canonical read omits: the projection is compared against such a read
+ * (`lineMetaEqual`), so the two have to spell one container one way. */
+function withInstance(container, instance) {
+    return instance === 0 ? container : { ...container, instance };
 }
 /** Open a new content line: emit the boundary `\n` (except the first line) + record. */
 function beginLine(acc, thisContentStart, containers, kind) {
@@ -201,11 +197,7 @@ function emitText(acc, s, pmStart, marks) {
     acc.runs.push({ kind: 'text', pmStart, usvStart, s });
     appendText(acc, s);
     for (const mark of marks) {
-        acc.rawMarks.push({
-            start: usvStart,
-            end: acc.usvEnd,
-            ...contentDescriptorFromPM(mark)
-        });
+        acc.rawMarks.push({ start: usvStart, end: acc.usvEnd, ...contentDescriptorFromPM(mark) });
     }
 }
 /**
@@ -216,7 +208,7 @@ function emitText(acc, s, pmStart, marks) {
  */
 function mergeMarks(raw) {
     const out = [];
-    for (const g of groupFormatting(raw, (m) => ({ start: m.start, end: m.end })).values()) {
+    for (const g of groupFormatting(raw).values()) {
         for (const iv of union(g.intervals))
             out.push({ ...iv, ...g.descriptor });
     }
@@ -231,9 +223,10 @@ export function contentEdit(oldRt, newRt) {
 /** Lower an edit to a `ChangeBundle`: the old→new content diff, as ops. */
 export function lower(edit, opts = {}) {
     const { oldRt, newRt } = edit;
-    const { delta, islandOps, insertedAt } = splitIslands(edit);
+    const { delta, islandOps } = splitIslands(edit);
     const lineOps = diffLines(oldRt, newRt, edit.delta);
-    const markOps = diffMarks(oldRt, newRt, delta, insertedAt, opts);
+    // The text-moving channels first: the mark diff reads them back off the bundle,
+    // so what it rebases against is what `applyChange` will be handed.
     const bundle = {};
     if (delta)
         bundle.delta = delta;
@@ -241,6 +234,7 @@ export function lower(edit, opts = {}) {
         bundle.islandOps = islandOps;
     if (lineOps.length)
         bundle.lineOps = lineOps;
+    const markOps = diffMarks(oldRt, newRt, bundle, opts);
     if (markOps.length)
         bundle.markOps = markOps;
     return bundle;
@@ -321,10 +315,8 @@ function diffLines(oldRt, newRt, delta) {
     return ops;
 }
 /** A line minus its `containers` / `continues` envelope: exactly `setKind`'s
- * payload, which the boundary names `ContentLineKind`. Lifting it whole is what
- * keeps this arm-agnostic: `kind` is an open set, so an arm-by-arm switch would
- * have to guess at the unknown arm's payload and would drift on every arm
- * upstream adds. */
+ * payload, which the boundary names `ContentLineKind`. Lifting it whole is what keeps
+ * this arm-agnostic, so an arm added upstream reaches the op by construction. */
 function kindPart(l) {
     const { containers: _containers, continues: _continues, ...kind } = l;
     return kind;
@@ -340,15 +332,16 @@ function lineMetaEqual(a, b) {
             return false;
         if (kindKey(a[i]) !== kindKey(b[i]))
             return false;
-        if (JSON.stringify(a[i].containers) !== JSON.stringify(b[i].containers))
+        if (!valueEqual(a[i].containers, b[i].containers))
             return false;
     }
     return true;
 }
-/** A line kind's comparison key: key-order-insensitive, because the two sides come
- * from different producers (a WASM read and this scan). */
+/** A line kind's comparison key: key-order-insensitive at every depth, because the two
+ * sides come from different producers (a WASM read and this scan) and a kind carries a
+ * nested `attrs` bag. */
 function kindKey(l) {
-    return JSON.stringify(Object.entries(kindPart(l)).sort(([x], [y]) => (x < y ? -1 : 1)));
+    return canonicalJson(kindPart(l));
 }
 /**
  * Split the edit's islands off the text splice. `applyChange` throws
@@ -373,12 +366,12 @@ function splitIslands(edit) {
     const { start, end } = insertedRegion(delta);
     const oldById = new Map(oldRt.islands.map((isl) => [isl.id, isl]));
     const islandOps = [];
-    const insertedAt = [];
+    let inserts = 0;
     newRt.islands.forEach((isl, i) => {
         const at = slots[i];
         if (at !== undefined && at >= start && at < end) {
             islandOps.push({ op: 'insert', at, ...isl });
-            insertedAt.push(at);
+            inserts++;
         }
         else {
             const before = oldById.get(isl.id);
@@ -386,11 +379,7 @@ function splitIslands(edit) {
                 islandOps.push({ op: 'set', ...isl });
         }
     });
-    return {
-        delta: insertedAt.length && delta ? withoutSlots(delta) : delta,
-        islandOps,
-        insertedAt
-    };
+    return { delta: inserts && delta ? withoutSlots(delta) : delta, islandOps };
 }
 /** The USV positions of `text`'s island slots, in document order: the i-th is the
  *  i-th island's, since the scan appends an entry per slot it writes. */
@@ -437,33 +426,17 @@ function withoutSlots(delta) {
     }
     return splices ? { ops } : undefined;
 }
-/**
- * A post-delta position carried through the bundle's island inserts, which move
- * text exactly as the delta does and rebase marks by the same rule (start-assoc
- * `after`, end-assoc `before`; an anchor is a point and holds `before`). Ascending
- * `at`s apply left to right, so each comparison reads the running position.
- */
-function shiftPastIslands(pos, insertedAt, assoc) {
-    let p = pos;
-    for (const at of insertedAt)
-        if (assoc === 'after' ? p >= at : p > at)
-            p++;
-    return p;
-}
-/** Formatting/unknown marks → add/remove ops; anchors → add/removeAnchor by id. */
-function diffMarks(oldRt, newRt, delta, insertedAt, opts) {
+/** Formatting marks → add/remove ops; anchors → add/removeAnchor by id. A `MarkOp`'s
+ * `add` / `remove` is a `ContentMark` under an op, so a descriptor spreads in whole and
+ * the wire's `attrs` spelling is the one a checker admits. */
+function diffMarks(oldRt, newRt, moved, opts) {
     const ops = [];
-    // Read the gate once per diff rather than once per mark.
-    const { mapPos } = core();
-    // Rebase old marks through both text-moving channels to final coords, exactly
-    // as `applyChange` does internally (start assoc `after`, end assoc `before`).
-    const rebase = (pos, assoc) => shiftPastIslands(delta ? mapPos(delta, pos, assoc) : pos, insertedAt, assoc);
+    // The store's answer for where `moved`'s text channels leave the field's marks;
+    // `markOps` are the difference from it.
+    const rebased = core().mapMarks(oldRt, moved);
     // Group both sides by descriptor key (excluding anchors).
-    const oldGroups = groupFormatting(oldRt.marks, (m) => ({
-        start: rebase(m.start, 'after'),
-        end: rebase(m.end, 'before')
-    }));
-    const newGroups = groupFormatting(newRt.marks, (m) => ({ start: m.start, end: m.end }));
+    const oldGroups = groupFormatting(rebased);
+    const newGroups = groupFormatting(newRt.marks);
     const keys = new Set([...oldGroups.keys(), ...newGroups.keys()]);
     for (const key of keys) {
         const oldG = oldGroups.get(key);
@@ -477,17 +450,14 @@ function diffMarks(oldRt, newRt, delta, insertedAt, opts) {
             ops.push({ op: 'add', start: iv.start, end: iv.end, ...descriptor });
     }
     // Anchors: diff the decoration sets by id (positions already in final coords).
-    if (opts.oldAnchors || opts.newAnchors) {
-        const oldA = new Map((opts.oldAnchors ?? []).map((a) => [
-            a.id,
-            shiftPastIslands(delta ? mapPos(delta, a.pos, 'after') : a.pos, insertedAt, 'before')
-        ]));
-        const newA = new Map((opts.newAnchors ?? []).map((a) => [a.id, a.pos]));
+    if (opts.newAnchors) {
+        const oldA = new Map(anchorsFromContent({ marks: rebased }).map((a) => [a.id, a.pos]));
+        const newA = new Map(opts.newAnchors.map((a) => [a.id, a.pos]));
         for (const [id, pos] of newA) {
             if (!oldA.has(id) || oldA.get(id) !== pos) {
                 if (oldA.has(id))
                     ops.push({ op: 'removeAnchor', id });
-                ops.push({ op: 'add', start: pos, end: pos, type: 'anchor', id });
+                ops.push({ op: 'add', start: pos, end: pos, type: 'anchor', attrs: { id } });
             }
         }
         for (const id of oldA.keys())
@@ -496,11 +466,11 @@ function diffMarks(oldRt, newRt, delta, insertedAt, opts) {
     }
     return ops;
 }
-/** Group non-anchor marks by descriptor key, mapping each to an interval. */
-function groupFormatting(marks, toInterval) {
+/** Group non-anchor marks by descriptor key. */
+function groupFormatting(marks) {
     const groups = new Map();
     for (const m of marks) {
-        if (isAnchorMark(m))
+        if (m.type === 'anchor')
             continue;
         const descriptor = descriptorOf(m);
         const key = markKey(descriptor);
@@ -509,7 +479,7 @@ function groupFormatting(marks, toInterval) {
             g = { descriptor, intervals: [] };
             groups.set(key, g);
         }
-        g.intervals.push(toInterval(m));
+        g.intervals.push({ start: m.start, end: m.end });
     }
     return groups;
 }

package/dist/core/codec/field.js

@@ -20,8 +20,8 @@ import { EditorState, NodeSelection, Plugin, PluginKey, Selection, TextSelection
 import { Decoration, DecorationSet, EditorView } from 'prosemirror-view';
 import { reportError, errorMessage } from '../errors.js';
 import { decode } from './decode.js';
-import { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
-import { lower, pmToContent, contentEdit } from './encode.js';
+import { usvToPM, pmToUsv, buildLineIndex, lineIndexOf } from './positions.js';
+import { lower, pmToContent, scanContent, scanDoc, contentEdit } from './encode.js';
 import { islandPastePlugin } from './islands.js';
 import { anchorsFromContent } from './marks.js';
 import { createReconciler } from './reconcile.js';
@@ -33,7 +33,11 @@ import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
 import { focusSlashItem, runSlashItem, slashPlugin } from './slash.js';
 const anchorKey = new PluginKey('quill-anchors');
 /** Plugin-held anchor positions (PM coords), mapped through every edit's `StepMap`
- * and mutated by an {@link AnchorEdit} meta (an insert/remove at a selection). */
+ * and mutated by an {@link AnchorEdit} meta (an insert/remove at a selection).
+ *
+ * The `-1` is the store's rule for a point, not PM's default: `applyChange` rebases a
+ * zero-width mark `before`, so text typed at an anchor's own position lands after it
+ * and the mark diff has no op to spend reconciling this set with the store. */
 function anchorPlugin(seed) {
     return new Plugin({
         key: anchorKey,
@@ -41,7 +45,7 @@ function anchorPlugin(seed) {
             init: () => seed,
             apply: (tr, anchors) => {
                 let next = tr.docChanged
-                    ? anchors.map((a) => ({ id: a.id, pos: tr.mapping.map(a.pos) }))
+                    ? anchors.map((a) => ({ id: a.id, pos: tr.mapping.map(a.pos, -1) }))
                     : anchors;
                 const edit = tr.getMeta(anchorKey);
                 if (edit?.op === 'add')
@@ -134,8 +138,9 @@ export function createField(opts) {
     // The menu's report channel, and the whole of what a leaf holds of it: the
     // vocabulary is the codec's own constant (`slash.ts`), not a wording to derive.
     const slash = inline ? undefined : opts.onSlash;
-    const state = buildState(reconciler.last);
-    index = buildLineIndex(state.doc);
+    const seeded = buildState(reconciler.last);
+    const state = seeded.state;
+    index = seeded.index;
     // The clearance PM's reveal keeps around the caret, in this leaf's own line box.
     // Its default is 5px, which is a caret visible and unusable: the next line typed
     // lands past the fold, the reason the preview's own scroll clears a target by the
@@ -173,13 +178,19 @@ export function createField(opts) {
             const oldRt = reconciler.last;
             const next = view.state.apply(tr);
             view.updateState(next); // (a) optimistic
-            index = buildLineIndex(next.doc);
+            // One walk per structural change: the index and the projection the commit
+            // diffs both come off it. A selection-only transaction leaves the document
+            // it was built from, so the index over it still holds.
+            const scan = tr.docChanged ? scanDoc(next.doc) : undefined;
+            if (scan)
+                index = lineIndexOf(scan);
             // Commit a content edit or an anchor mutation. An anchor insert/remove is
             // zero-width, so `docChanged` is false: the `anchorKey` meta is what
             // routes it through the same commit path (the diff emits the anchor op).
             if (tr.docChanged || tr.getMeta(anchorKey)) {
                 // (d) the change signal, only for what actually landed.
-                if (commitEdit(oldRt, next.doc))
+                const newRt = scan ? scanContent(scan) : pmToContent(next.doc);
+                if (commitEdit(oldRt, newRt))
                     opts.onChange?.(addr);
             }
             // The caret, for both structural and selection-only changes: a host
@@ -195,6 +206,8 @@ export function createField(opts) {
             }
         }
     });
+    /** The state, and the index over the document it was built from: the seed reads one
+     *  and every caller wants the same one, and `buildLineIndex` is a whole walk. */
     function buildState(rt) {
         const pmDoc = decode(rt, schema);
         const anchors = plaintext ? [] : anchorsFromContent(rt);
@@ -204,7 +217,7 @@ export function createField(opts) {
             id: a.id,
             pos: usvToPM(seedIndex, a.pos)
         }));
-        return EditorState.create({
+        const built = EditorState.create({
             doc: pmDoc,
             plugins: proseLeafPlugins(schema, {
                 inline,
@@ -216,15 +229,17 @@ export function createField(opts) {
                 afterHistory: [anchorPlugin(seededAnchors)]
             })
         });
+        return { state: built, index: seedIndex };
     }
     // (b)+(c): lower the edit to ops and commit, or `overwrite` a field not yet at
     // content rest. Keep the optimistic PM on throw.
     // Returns whether anything landed: the caller's change signal, which must not
     // be a property of which branch the commit took.
-    function commitEdit(oldRt, newDoc) {
-        // The projection and its text splice, each computed once per keystroke: the gate
-        // below, both overwrite fallbacks, and `lower` all read this one `edit`.
-        const edit = contentEdit(oldRt, pmToContent(newDoc));
+    function commitEdit(oldRt, newRt) {
+        // The text splice, computed once per keystroke: the gate below, both overwrite
+        // fallbacks, and `lower` all read this one `edit`. The projection is the
+        // caller's, off the same walk that rebuilt the index.
+        const edit = contentEdit(oldRt, newRt);
         try {
             // A field not yet at content rest is the only edit that overwrites by choice:
             // `applyChange` throws on an absent declared field (verified) and mis-reads
@@ -235,11 +250,10 @@ export function createField(opts) {
                 doc.overwrite(addr, edit.newRt); // brings the field to content rest
             }
             else {
-                // Pre-edit anchors are the stored content's anchors (USV); post-edit
-                // anchors are the plugin's positions (mapped through the tr) as USV.
-                const oldAnchors = plaintext ? [] : anchorsFromContent(oldRt);
-                const newAnchors = plaintext ? [] : readAnchorsUsv(newDoc);
-                doc.applyChange(addr, lower(edit, { oldAnchors, newAnchors }));
+                // Post-edit anchors are the plugin's positions (mapped through the tr) as
+                // USV; the pre-edit set is `oldRt`'s own, which `lower` reads for itself.
+                const newAnchors = plaintext ? [] : readAnchorsUsv();
+                doc.applyChange(addr, lower(edit, { newAnchors }));
             }
             reconciler.commit(readLeaf(reader, addr));
             return true;
@@ -275,8 +289,9 @@ export function createField(opts) {
     }
     /** The anchors the plugin currently holds (PM coords); `[]` before the first apply. */
     const heldAnchors = () => anchorKey.getState(view.state) ?? [];
-    /** Anchor positions in the current (new) doc, as USV. */
-    function readAnchorsUsv(newDoc) {
+    /** The plugin's anchor positions as USV, against `index` — which `dispatchTransaction`
+     *  rebuilt over the new document before the commit this reads for. */
+    function readAnchorsUsv() {
         return heldAnchors().map((a) => ({ id: a.id, pos: pmToUsv(index, a.pos) }));
     }
     const controller = {
@@ -303,11 +318,11 @@ export function createField(opts) {
                 return; // own edit / no change
             const caretUsv = pmToUsv(index, view.state.selection.head);
             const fresh = buildState(current);
-            view.updateState(fresh);
-            index = buildLineIndex(fresh.doc);
+            view.updateState(fresh.state);
+            index = fresh.index;
             // Best-effort caret continuity across an external change: keep the USV.
             const pm = usvToPM(index, caretUsv);
-            view.dispatch(view.state.tr.setSelection(Selection.near(fresh.doc.resolve(pm))));
+            view.dispatch(view.state.tr.setSelection(Selection.near(fresh.state.doc.resolve(pm))));
             reconciler.commit(current);
         },
         setPlaceholder(text) {
@@ -511,8 +526,12 @@ function editorKeymap(schema, inline, slash) {
     if (schema.marks.underline)
         map['Mod-u'] = toggleMark(schema.marks.underline);
     if (inline) {
-        // One textblock only: swallow Enter so no second block is attempted.
+        // One textblock only: swallow Enter so no second block is attempted. One *line*
+        // only too (`Content::is_inline`), so Shift-Enter goes with it: the schema
+        // declares no break node, and a declined key is the browser's, whose native
+        // `<br>` is the one thing that could put a second line in a field that holds one.
         map['Enter'] = () => true;
+        map['Shift-Enter'] = () => true;
     }
     else {
         // Each binding falls through to `baseKeymap` when no link claims the key.

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

@@ -9,7 +9,8 @@ export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 export type { TableChromeStrings } from './table-view.js';
 export { DEFAULT_SLASH_STRINGS } from './slash.js';
 export type { SlashState, SlashStrings } from './slash.js';
-export { blockSchema, inlineSchema, plaintextSchema, hasMarks, rendersHref } from './schema.js';
+export { blockSchema, inlineSchema, plaintextSchema, hasMarks } from './schema.js';
+export { rendersHref, storableUrl } from './urls.js';
 export { decode, renderContent, usvLength } from './decode.js';
 export { pmToContent, contentEdit, lower } from './encode.js';
 export type { ContentEdit } from './encode.js';

package/dist/core/codec/index.js

@@ -21,9 +21,12 @@ export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 // the pixels (`visual/SlashMenu.svelte` is the only off-barrel caller).
 export { DEFAULT_SLASH_STRINGS } from './slash.js';
 // Schemas (the decode/encode target; the VisualEditor mounts them). `hasMarks` is
-// what a mark surface asks before offering itself over a leaf, and `rendersHref` the
-// link gate the prompt re-asks on submit (`visual/links.ts`).
-export { blockSchema, inlineSchema, plaintextSchema, hasMarks, rendersHref } from './schema.js';
+// what a mark surface asks before offering itself over a leaf.
+export { blockSchema, inlineSchema, plaintextSchema, hasMarks } from './schema.js';
+// The url edge: `rendersHref` is the link gate the prompt re-asks on submit, and
+// `storableUrl` the encode the store's own refusal requires of the value it takes
+// (`visual/links.ts`).
+export { rendersHref, storableUrl } from './urls.js';
 // Decode / encode / positions (tests + VisualEditor).
 //
 // The barrel carries what has an off-barrel caller, and nothing else. A symbol

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

@@ -8,22 +8,26 @@ export declare const islandBlockSpec: NodeSpec;
 /** Inline island node (an image): a `U+FFFC` slot inside a `para` line. */
 export declare const islandInlineSpec: NodeSpec;
 /** A PM island node's attributes: the content entry, spelled the way a node spec
- *  spells it (`islandType`, because `type` on a PM node is the node type). `loss`
- *  reads its class off the entry rather than restating the union, which the public
- *  entry point does not name (DOCUMENT_MODEL §Stability seams). */
+ *  spells it (`islandType`, because `type` on a PM node is the node type). `islandType`
+ *  and `loss` read their sets off the entry rather than restating them, the public entry
+ *  point naming neither (DOCUMENT_MODEL §Stability seams). */
 export interface IslandNodeAttrs {
     id: string;
-    islandType: string;
+    islandType: ContentIsland['type'];
     props: unknown;
     loss: ContentIsland['loss'];
 }
-/** Build a content island entry from a PM island node's attrs (block or inline). */
+/** Build a content island entry from a PM island node's attrs (block or inline). The
+ *  cast pairs a closed `type` with a `props` that crossed the DOM as opaque JSON. The
+ *  store is lenient about a table's shape — it fills what it can and keeps the rest —
+ *  so a payload the arm does not hold is stored rather than refused, and `undefined` at
+ *  its reader is what the surface draws the placeholder for (§`tablePropsOfNode`). */
 export declare function islandEntryFromNode(attrs: IslandNodeAttrs): ContentIsland;
 /** A node's `TableProps`, or `undefined` for any other island and for a payload of the
- *  wrong shape: the boundary's own guard over the entry the node carries, so the open
- *  `type` arm narrows once here rather than at each reader. The type says which reader,
- *  the shape says whether it can read; every caller draws the placeholder for
- *  `undefined` (`table-view.ts` §`render`). */
+ *  wrong shape: the boundary's own guard over the entry the node carries, so a `props`
+ *  that crossed the DOM is read once here rather than at each reader. The type says
+ *  which reader, the shape says whether it can read; every caller draws the placeholder
+ *  for `undefined` (`table-view.ts` §`render`). */
 export declare function tablePropsOfNode(node: PMNode): TableProps | undefined;
 /**
  * A minter over one document: the positional `isl-{n}` sequence continued past the