@quillmark/wasm 0.96.0 → 0.97.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## v0.97.0 - 2026-07-24
+
+- core: one take_item primitive behind the three payload removers
+- core: fold the incoming-card guard shared by push_card/insert_card
+- tests: dense-prose fix on a muddy reinstatement comment
+- canon/docs: §Card-id identity — the third twin; wasm surface follows
+- core: card $id is the durable handle — unique per document, guarded
+- wasm: add island/mark discriminant guards; USV docs on mapPos/rebase
+- ci: lint the wasm binding's rustdoc to catch intra-doc breakage
+- Canonize anchor-id policy: caller-supplied, unique, invariant
+- Fix stale resolve() docs: body is a sibling, not a `$body` row
+- docs: prune per pruning pass — archive old migrations, cut duplication
+- docs: public integration pages for the high/medium doc gaps
+- docs: dense-prose sweep and accuracy fixes in docs/ and canon
+- docs(wasm): fix broken [`Delta`] intra-doc links (#1034)
+- wasm: rename Document.get → getStored so the verbatim read carries its lane
+
+
 ## v0.96.0 - 2026-07-23
 
 - docs(spec): keep plate JSON out of the markdown spec

package/README.md

@@ -255,9 +255,10 @@ Build a fresh card from a flat field map with
 `{ card?, field? }`, absent `card` = main, absent `field` = body — and a bare
 string is shorthand for `{ field }`. So `doc.storeField("qty", 3)` targets the
 main card's `qty`, `doc.storeField({ card: 2, field: "qty" }, 3)` a composable
-card's. Reads are total over the field axis (`get` → `undefined`, `isFill` → `false` for
+card's. Reads are total over the field axis (`getStored` → `undefined`, `isFill` → `false` for
 an absent field; only an out-of-range card throws); field writes throw on a body
-address. `getMarkdown` is the body markdown read (a `CardAddr`; a field's
+address. `getStored` is the verbatim transport read, distinct from the interpreted
+`quill.reader(doc).get`; `getMarkdown` is the body markdown read (a `CardAddr`; a field's
 markdown is read through `quill.reader(doc).get(field)`). Card-scoped verbs take a
 `CardAddr` (`{ card? }`) first: `doc.getExt({ card: 2 })`, and the batch below.
 

package/backends/pdfform/wasm.d.ts

@@ -102,7 +102,14 @@ export type ContentContainer =
 | { container: "list_item"; ordered: boolean; start: number; ordinal: number }
 | { container: "quote" };
 
-/** A mark over char range `[start, end)` into `Content.text`. */
+/** A mark over char range `[start, end)` into `Content.text`. The open `type`
+ * arm blocks discriminant narrowing (as on `ContentIsland`), so read a
+ * payload-carrying arm behind its guard — `isLinkMark` (`url`) / `isAnchorMark`
+ * (`id`), from `@quillmark/wasm/runtime`; the bare arms carry no payload. An
+ * `anchor`'s `id` is a caller-supplied, opaque handle, unique per `Content` and
+ * invariant while the mark lives (positions rebase, the id never does); it has no
+ * markdown projection and survives only through the edit lane. See DOCUMENT_STORAGE
+ * § Anchor-id identity. */
 export type ContentMark = { start: number; end: number } & (
 | { type: "strong" | "emph" | "underline" | "strike" | "code" }
 | { type: "link"; url: string }
@@ -138,7 +145,8 @@ export interface ImageProps {
  * open set: the engine pins `props` as `TableProps` for `table` and `ImageProps`
  * for `image`; an island of any other type round-trips with opaque `props`. Like
  * `ContentMark`, the open `type` arm means a discriminant check does not itself
- * narrow `props` — key off `type` and read `props` as the matching shape. */
+ * narrow `props` — read `props` as the matching shape behind the `isTableIsland` /
+ * `isImageIsland` guards (from `@quillmark/wasm/runtime`), which narrow it. */
 export type ContentIsland = {
     id: string;
     /** How faithfully the markdown projection can carry this island. */
@@ -191,7 +199,10 @@ export type Assoc = "before" | "after";
 /**
  * A mark edit in final-text coordinates (post-delta, post-line-op). `add` /
  * `remove` carry the `ContentMark` vocabulary (`{ type, … }`); `removeAnchor`
- * drops one identity anchor by id.
+ * drops one identity anchor by id. An `add` of an `anchor` requires a non-empty
+ * `id` not already live in the field — a collision or the empty id throws
+ * (ids are caller-supplied and unique per `Content`; DOCUMENT_STORAGE
+ * § Anchor-id identity).
  */
 export type MarkOp =
 | ({ op: "add" | "remove"; start: number; end: number } & (
@@ -580,10 +591,10 @@ export class Document {
      */
     card(index: number): Card;
     /**
-     * The index of the first composable card whose `$id` equals `id`, or
-     * `undefined` when none carries it. Resolves the canonical durable address
+     * The index of the composable card whose `$id` equals `id`, or
+     * `undefined` when none carries it. Resolves the durable card handle
      * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
-     * non-unique by design, so the first match wins.
+     * unique per document, so at most one card matches.
      */
     cardIndexById(id: string): number | undefined;
     clone(): Document;
@@ -625,17 +636,6 @@ export class Document {
      * Parse markdown into a typed Document. Throws on parse errors.
      */
     static fromMarkdown(markdown: string): Document;
-    /**
-     * Read the value at `addr` — the raw stored payload value of a field (a
-     * content object for a richtext field, a scalar/array/object otherwise), or
-     * the **body content** when `addr.field` is absent. A bare string is `Addr`
-     * shorthand for `{ field }`. Reads are total over the field axis: an absent
-     * field is `undefined`; only an out-of-range `addr.card` throws
-     * `edit::index_out_of_range`. Reads need no schema, so they live on
-     * `Document`, not the typed writer; for the markdown projection of a
-     * richtext value use [`getMarkdown`](Self::get_markdown).
-     */
-    get(addr: Addr | string): unknown;
     /**
      * The whole `$ext` map at `addr` (a card address, absent `card` = main), or
      * `undefined` when the card carries none. The fine-grained `$ext` read —
@@ -662,6 +662,19 @@ export class Document {
      * type (#978). An out-of-range `addr.card` throws.
      */
     getMarkdown(addr?: CardAddr): string;
+    /**
+     * Read the **verbatim stored value** at `addr` — the raw payload value of a
+     * field (a content object for a richtext field, a scalar/array/object
+     * otherwise), or the **body content** when `addr.field` is absent. A bare
+     * string is `Addr` shorthand for `{ field }`. Reads are total over the field
+     * axis: an absent field is `undefined`; only an out-of-range `addr.card`
+     * throws `edit::index_out_of_range`. Needs no schema, so it lives on
+     * `Document` — the read echo of the verbatim `store*` write, distinct from
+     * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
+     * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
+     * `reader.get` (a field's declared type).
+     */
+    getStored(addr: Addr | string): unknown;
     /**
      * Insert a card — the single insertion verb: `at` absent appends, a number
      * inserts at that index (must be in `0..=cards.length`). Accepts a
@@ -762,7 +775,7 @@ export class Document {
     removeSeedNamespace(card_kind: string): any;
     /**
      * **Revise** the richtext value at `addr` from a markdown string — **edit
-     * semantics**, the default write path, returning the text [`Delta`]. Imports
+     * semantics**, the default write path, returning the text `Delta`. Imports
      * the markdown, diffs it against the current value, rebases surviving
      * identity anchors, and returns the change an editor bridge maps its own
      * positions through (`mapPos`). An absent `addr.field` targets the body, an
@@ -1029,7 +1042,8 @@ export class Quill {
      * The resolved-value view of `doc` against this quill's schema — for every
      * declared field the value the render projection would use and the
      * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
-     * one call. The card body rides the `fields` map under the `$body` key.
+     * one call. The card body is a `body` sibling on its card (row `name`
+     * `"body"`), never a row in `fields` — `null` when the kind enables no body.
      *
      * Value and provenance only: completeness and errors stay `validate`'s
      * (a consumer merges it with its own diagnostic producers regardless), and
@@ -1178,10 +1192,11 @@ export function importMarkdown(markdown: string): Content;
 export function init(): void;
 
 /**
- * Map a base content position through a `delta` to its new position — the pure
- * position-mapping codec an editor bridge composes to hold a caret stable
- * across a `revise`. `assoc` decides the side of a same-position insertion
- * (`"after"` moves past it). Throws on a malformed `delta`.
+ * Map a base content position — a USV index into `Content.text`, not a UTF-16
+ * offset — through a `delta` to its new USV position: the pure position-mapping
+ * codec an editor bridge composes to hold a caret stable across a `revise`.
+ * `assoc` decides the side of a same-position insertion (`"after"` moves past
+ * it). Throws on a malformed `delta`.
  */
 export function mapPos(delta: Delta, pos: number, assoc: Assoc): number;
 
@@ -1197,8 +1212,9 @@ export function parseDocPath(path: string): DocPathSeg[];
 /**
  * Rebase `markdown` onto a `base` content — the pure, document-free twin of
  * `revise`: cold-import + `diff_import`, returning the new `content` and the
- * text `delta` (surviving anchors rebased). Use it to compute a revise without
- * a document in hand; `revise(addr, md)` fuses this with the store for
- * atomicity. Throws on an over-nested markdown input or a non-content `base`.
+ * text `delta` (its offsets USV indices into `Content.text`, surviving anchors
+ * rebased). Use it to compute a revise without a document in hand; `revise(addr,
+ * md)` fuses this with the store for atomicity. Throws on an over-nested
+ * markdown input or a non-content `base`.
  */
 export function rebase(base: Content, markdown: string): { content: Content; delta: Delta };

package/backends/pdfform/wasm_bg.js

@@ -131,7 +131,7 @@ export class Document {
     /**
      * Interpreted read at `addr`, resolving the field's declared `type` from
      * `quill` — the stable ABI under the runtime `reader.get` / `reader.card(i).get`.
-     * The schema-plane twin of the quill-free [`get`](Self::get): a `richtext`
+     * The schema-plane twin of the quill-free [`getStored`](Self::get_stored): a `richtext`
      * field returns its markdown projection, every other declared type its
      * canonical value verbatim, so a consumer holding the quill reads by field
      * meaning rather than by wire shape.
@@ -176,7 +176,7 @@ export class Document {
      * surviving anchors rebase (as [`revise`](Self::revise)), then the diffed
      * result is schema-conformed, so a `richtext(inline)` field rejects a
      * multi-block result with `edit::field_richtext_not_inline`. Returns the
-     * text [`Delta`].
+     * text `Delta`.
      *
      * `addr` must name a field (a bare string is `{ field }`); a body address
      * throws (a body carries no field schema — use [`revise`](Self::revise)). A
@@ -290,10 +290,10 @@ export class Document {
         return ret >>> 0;
     }
     /**
-     * The index of the first composable card whose `$id` equals `id`, or
-     * `undefined` when none carries it. Resolves the canonical durable address
+     * The index of the composable card whose `$id` equals `id`, or
+     * `undefined` when none carries it. Resolves the durable card handle
      * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
-     * non-unique by design, so the first match wins.
+     * unique per document, so at most one card matches.
      * @param {string} id
      * @returns {number | undefined}
      */
@@ -457,33 +457,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * Read the value at `addr` — the raw stored payload value of a field (a
-     * content object for a richtext field, a scalar/array/object otherwise), or
-     * the **body content** when `addr.field` is absent. A bare string is `Addr`
-     * shorthand for `{ field }`. Reads are total over the field axis: an absent
-     * field is `undefined`; only an out-of-range `addr.card` throws
-     * `edit::index_out_of_range`. Reads need no schema, so they live on
-     * `Document`, not the typed writer; for the markdown projection of a
-     * richtext value use [`getMarkdown`](Self::get_markdown).
-     * @param {Addr | string} addr
-     * @returns {unknown}
-     */
-    get(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_get(retptr, this.__wbg_ptr, addHeapObject(addr));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
     /**
      * The whole `$ext` map at `addr` (a card address, absent `card` = main), or
      * `undefined` when the card carries none. The fine-grained `$ext` read —
@@ -561,6 +534,35 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Read the **verbatim stored value** at `addr` — the raw payload value of a
+     * field (a content object for a richtext field, a scalar/array/object
+     * otherwise), or the **body content** when `addr.field` is absent. A bare
+     * string is `Addr` shorthand for `{ field }`. Reads are total over the field
+     * axis: an absent field is `undefined`; only an out-of-range `addr.card`
+     * throws `edit::index_out_of_range`. Needs no schema, so it lives on
+     * `Document` — the read echo of the verbatim `store*` write, distinct from
+     * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
+     * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
+     * `reader.get` (a field's declared type).
+     * @param {Addr | string} addr
+     * @returns {unknown}
+     */
+    getStored(addr) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_getStored(retptr, this.__wbg_ptr, addHeapObject(addr));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Insert a card — the single insertion verb: `at` absent appends, a number
      * inserts at that index (must be in `0..=cards.length`). Accepts a
@@ -917,7 +919,7 @@ export class Document {
     }
     /**
      * **Revise** the richtext value at `addr` from a markdown string — **edit
-     * semantics**, the default write path, returning the text [`Delta`]. Imports
+     * semantics**, the default write path, returning the text `Delta`. Imports
      * the markdown, diffs it against the current value, rebases surviving
      * identity anchors, and returns the change an editor bridge maps its own
      * positions through (`mapPos`). An absent `addr.field` targets the body, an
@@ -1691,7 +1693,8 @@ export class Quill {
      * The resolved-value view of `doc` against this quill's schema — for every
      * declared field the value the render projection would use and the
      * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
-     * one call. The card body rides the `fields` map under the `$body` key.
+     * one call. The card body is a `body` sibling on its card (row `name`
+     * `"body"`), never a row in `fields` — `null` when the kind enables no body.
      *
      * Value and provenance only: completeness and errors stay `validate`'s
      * (a consumer merges it with its own diagnostic producers regardless), and
@@ -2064,10 +2067,11 @@ export function init() {
 }
 
 /**
- * Map a base content position through a `delta` to its new position — the pure
- * position-mapping codec an editor bridge composes to hold a caret stable
- * across a `revise`. `assoc` decides the side of a same-position insertion
- * (`"after"` moves past it). Throws on a malformed `delta`.
+ * Map a base content position — a USV index into `Content.text`, not a UTF-16
+ * offset — through a `delta` to its new USV position: the pure position-mapping
+ * codec an editor bridge composes to hold a caret stable across a `revise`.
+ * `assoc` decides the side of a same-position insertion (`"after"` moves past
+ * it). Throws on a malformed `delta`.
  * @param {Delta} delta
  * @param {number} pos
  * @param {Assoc} assoc
@@ -2119,9 +2123,10 @@ export function parseDocPath(path) {
 /**
  * Rebase `markdown` onto a `base` content — the pure, document-free twin of
  * `revise`: cold-import + `diff_import`, returning the new `content` and the
- * text `delta` (surviving anchors rebased). Use it to compute a revise without
- * a document in hand; `revise(addr, md)` fuses this with the store for
- * atomicity. Throws on an over-nested markdown input or a non-content `base`.
+ * text `delta` (its offsets USV indices into `Content.text`, surviving anchors
+ * rebased). Use it to compute a revise without a document in hand; `revise(addr,
+ * md)` fuses this with the store for atomicity. Throws on an over-nested
+ * markdown input or a non-content `base`.
  * @param {Content} base
  * @param {string} markdown
  * @returns {{ content: Content; delta: Delta }}

package/backends/pdfform/wasm_bg.wasm.d.ts

@@ -23,10 +23,10 @@ export const document_formatDiagnostic: (a: number, b: number) => void;
 export const document_formatRules: (a: number) => void;
 export const document_fromJson: (a: number, b: number, c: number) => void;
 export const document_fromMarkdown: (a: number, b: number, c: number) => void;
-export const document_get: (a: number, b: number, c: number) => void;
 export const document_getExt: (a: number, b: number, c: number) => void;
 export const document_getExtNamespace: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document_getMarkdown: (a: number, b: number, c: number) => void;
+export const document_getStored: (a: number, b: number, c: number) => void;
 export const document_insertCard: (a: number, b: number, c: number, d: number) => void;
 export const document_install: (a: number, b: number, c: number, d: number) => void;
 export const document_isFill: (a: number, b: number, c: number) => void;

package/backends/typst/wasm.d.ts

@@ -102,7 +102,14 @@ export type ContentContainer =
 | { container: "list_item"; ordered: boolean; start: number; ordinal: number }
 | { container: "quote" };
 
-/** A mark over char range `[start, end)` into `Content.text`. */
+/** A mark over char range `[start, end)` into `Content.text`. The open `type`
+ * arm blocks discriminant narrowing (as on `ContentIsland`), so read a
+ * payload-carrying arm behind its guard — `isLinkMark` (`url`) / `isAnchorMark`
+ * (`id`), from `@quillmark/wasm/runtime`; the bare arms carry no payload. An
+ * `anchor`'s `id` is a caller-supplied, opaque handle, unique per `Content` and
+ * invariant while the mark lives (positions rebase, the id never does); it has no
+ * markdown projection and survives only through the edit lane. See DOCUMENT_STORAGE
+ * § Anchor-id identity. */
 export type ContentMark = { start: number; end: number } & (
 | { type: "strong" | "emph" | "underline" | "strike" | "code" }
 | { type: "link"; url: string }
@@ -138,7 +145,8 @@ export interface ImageProps {
  * open set: the engine pins `props` as `TableProps` for `table` and `ImageProps`
  * for `image`; an island of any other type round-trips with opaque `props`. Like
  * `ContentMark`, the open `type` arm means a discriminant check does not itself
- * narrow `props` — key off `type` and read `props` as the matching shape. */
+ * narrow `props` — read `props` as the matching shape behind the `isTableIsland` /
+ * `isImageIsland` guards (from `@quillmark/wasm/runtime`), which narrow it. */
 export type ContentIsland = {
     id: string;
     /** How faithfully the markdown projection can carry this island. */
@@ -191,7 +199,10 @@ export type Assoc = "before" | "after";
 /**
  * A mark edit in final-text coordinates (post-delta, post-line-op). `add` /
  * `remove` carry the `ContentMark` vocabulary (`{ type, … }`); `removeAnchor`
- * drops one identity anchor by id.
+ * drops one identity anchor by id. An `add` of an `anchor` requires a non-empty
+ * `id` not already live in the field — a collision or the empty id throws
+ * (ids are caller-supplied and unique per `Content`; DOCUMENT_STORAGE
+ * § Anchor-id identity).
  */
 export type MarkOp =
 | ({ op: "add" | "remove"; start: number; end: number } & (
@@ -580,10 +591,10 @@ export class Document {
      */
     card(index: number): Card;
     /**
-     * The index of the first composable card whose `$id` equals `id`, or
-     * `undefined` when none carries it. Resolves the canonical durable address
+     * The index of the composable card whose `$id` equals `id`, or
+     * `undefined` when none carries it. Resolves the durable card handle
      * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
-     * non-unique by design, so the first match wins.
+     * unique per document, so at most one card matches.
      */
     cardIndexById(id: string): number | undefined;
     clone(): Document;
@@ -625,17 +636,6 @@ export class Document {
      * Parse markdown into a typed Document. Throws on parse errors.
      */
     static fromMarkdown(markdown: string): Document;
-    /**
-     * Read the value at `addr` — the raw stored payload value of a field (a
-     * content object for a richtext field, a scalar/array/object otherwise), or
-     * the **body content** when `addr.field` is absent. A bare string is `Addr`
-     * shorthand for `{ field }`. Reads are total over the field axis: an absent
-     * field is `undefined`; only an out-of-range `addr.card` throws
-     * `edit::index_out_of_range`. Reads need no schema, so they live on
-     * `Document`, not the typed writer; for the markdown projection of a
-     * richtext value use [`getMarkdown`](Self::get_markdown).
-     */
-    get(addr: Addr | string): unknown;
     /**
      * The whole `$ext` map at `addr` (a card address, absent `card` = main), or
      * `undefined` when the card carries none. The fine-grained `$ext` read —
@@ -662,6 +662,19 @@ export class Document {
      * type (#978). An out-of-range `addr.card` throws.
      */
     getMarkdown(addr?: CardAddr): string;
+    /**
+     * Read the **verbatim stored value** at `addr` — the raw payload value of a
+     * field (a content object for a richtext field, a scalar/array/object
+     * otherwise), or the **body content** when `addr.field` is absent. A bare
+     * string is `Addr` shorthand for `{ field }`. Reads are total over the field
+     * axis: an absent field is `undefined`; only an out-of-range `addr.card`
+     * throws `edit::index_out_of_range`. Needs no schema, so it lives on
+     * `Document` — the read echo of the verbatim `store*` write, distinct from
+     * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
+     * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
+     * `reader.get` (a field's declared type).
+     */
+    getStored(addr: Addr | string): unknown;
     /**
      * Insert a card — the single insertion verb: `at` absent appends, a number
      * inserts at that index (must be in `0..=cards.length`). Accepts a
@@ -762,7 +775,7 @@ export class Document {
     removeSeedNamespace(card_kind: string): any;
     /**
      * **Revise** the richtext value at `addr` from a markdown string — **edit
-     * semantics**, the default write path, returning the text [`Delta`]. Imports
+     * semantics**, the default write path, returning the text `Delta`. Imports
      * the markdown, diffs it against the current value, rebases surviving
      * identity anchors, and returns the change an editor bridge maps its own
      * positions through (`mapPos`). An absent `addr.field` targets the body, an
@@ -1029,7 +1042,8 @@ export class Quill {
      * The resolved-value view of `doc` against this quill's schema — for every
      * declared field the value the render projection would use and the
      * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
-     * one call. The card body rides the `fields` map under the `$body` key.
+     * one call. The card body is a `body` sibling on its card (row `name`
+     * `"body"`), never a row in `fields` — `null` when the kind enables no body.
      *
      * Value and provenance only: completeness and errors stay `validate`'s
      * (a consumer merges it with its own diagnostic producers regardless), and
@@ -1178,10 +1192,11 @@ export function importMarkdown(markdown: string): Content;
 export function init(): void;
 
 /**
- * Map a base content position through a `delta` to its new position — the pure
- * position-mapping codec an editor bridge composes to hold a caret stable
- * across a `revise`. `assoc` decides the side of a same-position insertion
- * (`"after"` moves past it). Throws on a malformed `delta`.
+ * Map a base content position — a USV index into `Content.text`, not a UTF-16
+ * offset — through a `delta` to its new USV position: the pure position-mapping
+ * codec an editor bridge composes to hold a caret stable across a `revise`.
+ * `assoc` decides the side of a same-position insertion (`"after"` moves past
+ * it). Throws on a malformed `delta`.
  */
 export function mapPos(delta: Delta, pos: number, assoc: Assoc): number;
 
@@ -1197,8 +1212,9 @@ export function parseDocPath(path: string): DocPathSeg[];
 /**
  * Rebase `markdown` onto a `base` content — the pure, document-free twin of
  * `revise`: cold-import + `diff_import`, returning the new `content` and the
- * text `delta` (surviving anchors rebased). Use it to compute a revise without
- * a document in hand; `revise(addr, md)` fuses this with the store for
- * atomicity. Throws on an over-nested markdown input or a non-content `base`.
+ * text `delta` (its offsets USV indices into `Content.text`, surviving anchors
+ * rebased). Use it to compute a revise without a document in hand; `revise(addr,
+ * md)` fuses this with the store for atomicity. Throws on an over-nested
+ * markdown input or a non-content `base`.
  */
 export function rebase(base: Content, markdown: string): { content: Content; delta: Delta };

package/backends/typst/wasm_bg.js

@@ -131,7 +131,7 @@ export class Document {
     /**
      * Interpreted read at `addr`, resolving the field's declared `type` from
      * `quill` — the stable ABI under the runtime `reader.get` / `reader.card(i).get`.
-     * The schema-plane twin of the quill-free [`get`](Self::get): a `richtext`
+     * The schema-plane twin of the quill-free [`getStored`](Self::get_stored): a `richtext`
      * field returns its markdown projection, every other declared type its
      * canonical value verbatim, so a consumer holding the quill reads by field
      * meaning rather than by wire shape.
@@ -176,7 +176,7 @@ export class Document {
      * surviving anchors rebase (as [`revise`](Self::revise)), then the diffed
      * result is schema-conformed, so a `richtext(inline)` field rejects a
      * multi-block result with `edit::field_richtext_not_inline`. Returns the
-     * text [`Delta`].
+     * text `Delta`.
      *
      * `addr` must name a field (a bare string is `{ field }`); a body address
      * throws (a body carries no field schema — use [`revise`](Self::revise)). A
@@ -290,10 +290,10 @@ export class Document {
         return ret >>> 0;
     }
     /**
-     * The index of the first composable card whose `$id` equals `id`, or
-     * `undefined` when none carries it. Resolves the canonical durable address
+     * The index of the composable card whose `$id` equals `id`, or
+     * `undefined` when none carries it. Resolves the durable card handle
      * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
-     * non-unique by design, so the first match wins.
+     * unique per document, so at most one card matches.
      * @param {string} id
      * @returns {number | undefined}
      */
@@ -457,33 +457,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * Read the value at `addr` — the raw stored payload value of a field (a
-     * content object for a richtext field, a scalar/array/object otherwise), or
-     * the **body content** when `addr.field` is absent. A bare string is `Addr`
-     * shorthand for `{ field }`. Reads are total over the field axis: an absent
-     * field is `undefined`; only an out-of-range `addr.card` throws
-     * `edit::index_out_of_range`. Reads need no schema, so they live on
-     * `Document`, not the typed writer; for the markdown projection of a
-     * richtext value use [`getMarkdown`](Self::get_markdown).
-     * @param {Addr | string} addr
-     * @returns {unknown}
-     */
-    get(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_get(retptr, this.__wbg_ptr, addHeapObject(addr));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
     /**
      * The whole `$ext` map at `addr` (a card address, absent `card` = main), or
      * `undefined` when the card carries none. The fine-grained `$ext` read —
@@ -561,6 +534,35 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Read the **verbatim stored value** at `addr` — the raw payload value of a
+     * field (a content object for a richtext field, a scalar/array/object
+     * otherwise), or the **body content** when `addr.field` is absent. A bare
+     * string is `Addr` shorthand for `{ field }`. Reads are total over the field
+     * axis: an absent field is `undefined`; only an out-of-range `addr.card`
+     * throws `edit::index_out_of_range`. Needs no schema, so it lives on
+     * `Document` — the read echo of the verbatim `store*` write, distinct from
+     * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
+     * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
+     * `reader.get` (a field's declared type).
+     * @param {Addr | string} addr
+     * @returns {unknown}
+     */
+    getStored(addr) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_getStored(retptr, this.__wbg_ptr, addHeapObject(addr));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Insert a card — the single insertion verb: `at` absent appends, a number
      * inserts at that index (must be in `0..=cards.length`). Accepts a
@@ -917,7 +919,7 @@ export class Document {
     }
     /**
      * **Revise** the richtext value at `addr` from a markdown string — **edit
-     * semantics**, the default write path, returning the text [`Delta`]. Imports
+     * semantics**, the default write path, returning the text `Delta`. Imports
      * the markdown, diffs it against the current value, rebases surviving
      * identity anchors, and returns the change an editor bridge maps its own
      * positions through (`mapPos`). An absent `addr.field` targets the body, an
@@ -1691,7 +1693,8 @@ export class Quill {
      * The resolved-value view of `doc` against this quill's schema — for every
      * declared field the value the render projection would use and the
      * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
-     * one call. The card body rides the `fields` map under the `$body` key.
+     * one call. The card body is a `body` sibling on its card (row `name`
+     * `"body"`), never a row in `fields` — `null` when the kind enables no body.
      *
      * Value and provenance only: completeness and errors stay `validate`'s
      * (a consumer merges it with its own diagnostic producers regardless), and
@@ -2064,10 +2067,11 @@ export function init() {
 }
 
 /**
- * Map a base content position through a `delta` to its new position — the pure
- * position-mapping codec an editor bridge composes to hold a caret stable
- * across a `revise`. `assoc` decides the side of a same-position insertion
- * (`"after"` moves past it). Throws on a malformed `delta`.
+ * Map a base content position — a USV index into `Content.text`, not a UTF-16
+ * offset — through a `delta` to its new USV position: the pure position-mapping
+ * codec an editor bridge composes to hold a caret stable across a `revise`.
+ * `assoc` decides the side of a same-position insertion (`"after"` moves past
+ * it). Throws on a malformed `delta`.
  * @param {Delta} delta
  * @param {number} pos
  * @param {Assoc} assoc
@@ -2119,9 +2123,10 @@ export function parseDocPath(path) {
 /**
  * Rebase `markdown` onto a `base` content — the pure, document-free twin of
  * `revise`: cold-import + `diff_import`, returning the new `content` and the
- * text `delta` (surviving anchors rebased). Use it to compute a revise without
- * a document in hand; `revise(addr, md)` fuses this with the store for
- * atomicity. Throws on an over-nested markdown input or a non-content `base`.
+ * text `delta` (its offsets USV indices into `Content.text`, surviving anchors
+ * rebased). Use it to compute a revise without a document in hand; `revise(addr,
+ * md)` fuses this with the store for atomicity. Throws on an over-nested
+ * markdown input or a non-content `base`.
  * @param {Content} base
  * @param {string} markdown
  * @returns {{ content: Content; delta: Delta }}

package/backends/typst/wasm_bg.wasm.d.ts

@@ -23,10 +23,10 @@ export const document_formatDiagnostic: (a: number, b: number) => void;
 export const document_formatRules: (a: number) => void;
 export const document_fromJson: (a: number, b: number, c: number) => void;
 export const document_fromMarkdown: (a: number, b: number, c: number) => void;
-export const document_get: (a: number, b: number, c: number) => void;
 export const document_getExt: (a: number, b: number, c: number) => void;
 export const document_getExtNamespace: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document_getMarkdown: (a: number, b: number, c: number) => void;
+export const document_getStored: (a: number, b: number, c: number) => void;
 export const document_insertCard: (a: number, b: number, c: number, d: number) => void;
 export const document_install: (a: number, b: number, c: number, d: number) => void;
 export const document_isFill: (a: number, b: number, c: number) => void;

package/core/wasm.d.ts

@@ -102,7 +102,14 @@ export type ContentContainer =
 | { container: "list_item"; ordered: boolean; start: number; ordinal: number }
 | { container: "quote" };
 
-/** A mark over char range `[start, end)` into `Content.text`. */
+/** A mark over char range `[start, end)` into `Content.text`. The open `type`
+ * arm blocks discriminant narrowing (as on `ContentIsland`), so read a
+ * payload-carrying arm behind its guard — `isLinkMark` (`url`) / `isAnchorMark`
+ * (`id`), from `@quillmark/wasm/runtime`; the bare arms carry no payload. An
+ * `anchor`'s `id` is a caller-supplied, opaque handle, unique per `Content` and
+ * invariant while the mark lives (positions rebase, the id never does); it has no
+ * markdown projection and survives only through the edit lane. See DOCUMENT_STORAGE
+ * § Anchor-id identity. */
 export type ContentMark = { start: number; end: number } & (
 | { type: "strong" | "emph" | "underline" | "strike" | "code" }
 | { type: "link"; url: string }
@@ -138,7 +145,8 @@ export interface ImageProps {
  * open set: the engine pins `props` as `TableProps` for `table` and `ImageProps`
  * for `image`; an island of any other type round-trips with opaque `props`. Like
  * `ContentMark`, the open `type` arm means a discriminant check does not itself
- * narrow `props` — key off `type` and read `props` as the matching shape. */
+ * narrow `props` — read `props` as the matching shape behind the `isTableIsland` /
+ * `isImageIsland` guards (from `@quillmark/wasm/runtime`), which narrow it. */
 export type ContentIsland = {
     id: string;
     /** How faithfully the markdown projection can carry this island. */
@@ -191,7 +199,10 @@ export type Assoc = "before" | "after";
 /**
  * A mark edit in final-text coordinates (post-delta, post-line-op). `add` /
  * `remove` carry the `ContentMark` vocabulary (`{ type, … }`); `removeAnchor`
- * drops one identity anchor by id.
+ * drops one identity anchor by id. An `add` of an `anchor` requires a non-empty
+ * `id` not already live in the field — a collision or the empty id throws
+ * (ids are caller-supplied and unique per `Content`; DOCUMENT_STORAGE
+ * § Anchor-id identity).
  */
 export type MarkOp =
 | ({ op: "add" | "remove"; start: number; end: number } & (
@@ -451,10 +462,10 @@ export class Document {
      */
     card(index: number): Card;
     /**
-     * The index of the first composable card whose `$id` equals `id`, or
-     * `undefined` when none carries it. Resolves the canonical durable address
+     * The index of the composable card whose `$id` equals `id`, or
+     * `undefined` when none carries it. Resolves the durable card handle
      * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
-     * non-unique by design, so the first match wins.
+     * unique per document, so at most one card matches.
      */
     cardIndexById(id: string): number | undefined;
     clone(): Document;
@@ -496,17 +507,6 @@ export class Document {
      * Parse markdown into a typed Document. Throws on parse errors.
      */
     static fromMarkdown(markdown: string): Document;
-    /**
-     * Read the value at `addr` — the raw stored payload value of a field (a
-     * content object for a richtext field, a scalar/array/object otherwise), or
-     * the **body content** when `addr.field` is absent. A bare string is `Addr`
-     * shorthand for `{ field }`. Reads are total over the field axis: an absent
-     * field is `undefined`; only an out-of-range `addr.card` throws
-     * `edit::index_out_of_range`. Reads need no schema, so they live on
-     * `Document`, not the typed writer; for the markdown projection of a
-     * richtext value use [`getMarkdown`](Self::get_markdown).
-     */
-    get(addr: Addr | string): unknown;
     /**
      * The whole `$ext` map at `addr` (a card address, absent `card` = main), or
      * `undefined` when the card carries none. The fine-grained `$ext` read —
@@ -533,6 +533,19 @@ export class Document {
      * type (#978). An out-of-range `addr.card` throws.
      */
     getMarkdown(addr?: CardAddr): string;
+    /**
+     * Read the **verbatim stored value** at `addr` — the raw payload value of a
+     * field (a content object for a richtext field, a scalar/array/object
+     * otherwise), or the **body content** when `addr.field` is absent. A bare
+     * string is `Addr` shorthand for `{ field }`. Reads are total over the field
+     * axis: an absent field is `undefined`; only an out-of-range `addr.card`
+     * throws `edit::index_out_of_range`. Needs no schema, so it lives on
+     * `Document` — the read echo of the verbatim `store*` write, distinct from
+     * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
+     * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
+     * `reader.get` (a field's declared type).
+     */
+    getStored(addr: Addr | string): unknown;
     /**
      * Insert a card — the single insertion verb: `at` absent appends, a number
      * inserts at that index (must be in `0..=cards.length`). Accepts a
@@ -633,7 +646,7 @@ export class Document {
     removeSeedNamespace(card_kind: string): any;
     /**
      * **Revise** the richtext value at `addr` from a markdown string — **edit
-     * semantics**, the default write path, returning the text [`Delta`]. Imports
+     * semantics**, the default write path, returning the text `Delta`. Imports
      * the markdown, diffs it against the current value, rebases surviving
      * identity anchors, and returns the change an editor bridge maps its own
      * positions through (`mapPos`). An absent `addr.field` targets the body, an
@@ -776,7 +789,8 @@ export class Quill {
      * The resolved-value view of `doc` against this quill's schema — for every
      * declared field the value the render projection would use and the
      * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
-     * one call. The card body rides the `fields` map under the `$body` key.
+     * one call. The card body is a `body` sibling on its card (row `name`
+     * `"body"`), never a row in `fields` — `null` when the kind enables no body.
      *
      * Value and provenance only: completeness and errors stay `validate`'s
      * (a consumer merges it with its own diagnostic producers regardless), and
@@ -891,10 +905,11 @@ export function importMarkdown(markdown: string): Content;
 export function init(): void;
 
 /**
- * Map a base content position through a `delta` to its new position — the pure
- * position-mapping codec an editor bridge composes to hold a caret stable
- * across a `revise`. `assoc` decides the side of a same-position insertion
- * (`"after"` moves past it). Throws on a malformed `delta`.
+ * Map a base content position — a USV index into `Content.text`, not a UTF-16
+ * offset — through a `delta` to its new USV position: the pure position-mapping
+ * codec an editor bridge composes to hold a caret stable across a `revise`.
+ * `assoc` decides the side of a same-position insertion (`"after"` moves past
+ * it). Throws on a malformed `delta`.
  */
 export function mapPos(delta: Delta, pos: number, assoc: Assoc): number;
 
@@ -910,8 +925,9 @@ export function parseDocPath(path: string): DocPathSeg[];
 /**
  * Rebase `markdown` onto a `base` content — the pure, document-free twin of
  * `revise`: cold-import + `diff_import`, returning the new `content` and the
- * text `delta` (surviving anchors rebased). Use it to compute a revise without
- * a document in hand; `revise(addr, md)` fuses this with the store for
- * atomicity. Throws on an over-nested markdown input or a non-content `base`.
+ * text `delta` (its offsets USV indices into `Content.text`, surviving anchors
+ * rebased). Use it to compute a revise without a document in hand; `revise(addr,
+ * md)` fuses this with the store for atomicity. Throws on an over-nested
+ * markdown input or a non-content `base`.
  */
 export function rebase(base: Content, markdown: string): { content: Content; delta: Delta };

package/core/wasm_bg.js

@@ -131,7 +131,7 @@ export class Document {
     /**
      * Interpreted read at `addr`, resolving the field's declared `type` from
      * `quill` — the stable ABI under the runtime `reader.get` / `reader.card(i).get`.
-     * The schema-plane twin of the quill-free [`get`](Self::get): a `richtext`
+     * The schema-plane twin of the quill-free [`getStored`](Self::get_stored): a `richtext`
      * field returns its markdown projection, every other declared type its
      * canonical value verbatim, so a consumer holding the quill reads by field
      * meaning rather than by wire shape.
@@ -176,7 +176,7 @@ export class Document {
      * surviving anchors rebase (as [`revise`](Self::revise)), then the diffed
      * result is schema-conformed, so a `richtext(inline)` field rejects a
      * multi-block result with `edit::field_richtext_not_inline`. Returns the
-     * text [`Delta`].
+     * text `Delta`.
      *
      * `addr` must name a field (a bare string is `{ field }`); a body address
      * throws (a body carries no field schema — use [`revise`](Self::revise)). A
@@ -290,10 +290,10 @@ export class Document {
         return ret >>> 0;
     }
     /**
-     * The index of the first composable card whose `$id` equals `id`, or
-     * `undefined` when none carries it. Resolves the canonical durable address
+     * The index of the composable card whose `$id` equals `id`, or
+     * `undefined` when none carries it. Resolves the durable card handle
      * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
-     * non-unique by design, so the first match wins.
+     * unique per document, so at most one card matches.
      * @param {string} id
      * @returns {number | undefined}
      */
@@ -457,33 +457,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * Read the value at `addr` — the raw stored payload value of a field (a
-     * content object for a richtext field, a scalar/array/object otherwise), or
-     * the **body content** when `addr.field` is absent. A bare string is `Addr`
-     * shorthand for `{ field }`. Reads are total over the field axis: an absent
-     * field is `undefined`; only an out-of-range `addr.card` throws
-     * `edit::index_out_of_range`. Reads need no schema, so they live on
-     * `Document`, not the typed writer; for the markdown projection of a
-     * richtext value use [`getMarkdown`](Self::get_markdown).
-     * @param {Addr | string} addr
-     * @returns {unknown}
-     */
-    get(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_get(retptr, this.__wbg_ptr, addHeapObject(addr));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
     /**
      * The whole `$ext` map at `addr` (a card address, absent `card` = main), or
      * `undefined` when the card carries none. The fine-grained `$ext` read —
@@ -561,6 +534,35 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Read the **verbatim stored value** at `addr` — the raw payload value of a
+     * field (a content object for a richtext field, a scalar/array/object
+     * otherwise), or the **body content** when `addr.field` is absent. A bare
+     * string is `Addr` shorthand for `{ field }`. Reads are total over the field
+     * axis: an absent field is `undefined`; only an out-of-range `addr.card`
+     * throws `edit::index_out_of_range`. Needs no schema, so it lives on
+     * `Document` — the read echo of the verbatim `store*` write, distinct from
+     * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
+     * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
+     * `reader.get` (a field's declared type).
+     * @param {Addr | string} addr
+     * @returns {unknown}
+     */
+    getStored(addr) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_getStored(retptr, this.__wbg_ptr, addHeapObject(addr));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Insert a card — the single insertion verb: `at` absent appends, a number
      * inserts at that index (must be in `0..=cards.length`). Accepts a
@@ -917,7 +919,7 @@ export class Document {
     }
     /**
      * **Revise** the richtext value at `addr` from a markdown string — **edit
-     * semantics**, the default write path, returning the text [`Delta`]. Imports
+     * semantics**, the default write path, returning the text `Delta`. Imports
      * the markdown, diffs it against the current value, rebases surviving
      * identity anchors, and returns the change an editor bridge maps its own
      * positions through (`mapPos`). An absent `addr.field` targets the body, an
@@ -1375,7 +1377,8 @@ export class Quill {
      * The resolved-value view of `doc` against this quill's schema — for every
      * declared field the value the render projection would use and the
      * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
-     * one call. The card body rides the `fields` map under the `$body` key.
+     * one call. The card body is a `body` sibling on its card (row `name`
+     * `"body"`), never a row in `fields` — `null` when the kind enables no body.
      *
      * Value and provenance only: completeness and errors stay `validate`'s
      * (a consumer merges it with its own diagnostic producers regardless), and
@@ -1638,10 +1641,11 @@ export function init() {
 }
 
 /**
- * Map a base content position through a `delta` to its new position — the pure
- * position-mapping codec an editor bridge composes to hold a caret stable
- * across a `revise`. `assoc` decides the side of a same-position insertion
- * (`"after"` moves past it). Throws on a malformed `delta`.
+ * Map a base content position — a USV index into `Content.text`, not a UTF-16
+ * offset — through a `delta` to its new USV position: the pure position-mapping
+ * codec an editor bridge composes to hold a caret stable across a `revise`.
+ * `assoc` decides the side of a same-position insertion (`"after"` moves past
+ * it). Throws on a malformed `delta`.
  * @param {Delta} delta
  * @param {number} pos
  * @param {Assoc} assoc
@@ -1693,9 +1697,10 @@ export function parseDocPath(path) {
 /**
  * Rebase `markdown` onto a `base` content — the pure, document-free twin of
  * `revise`: cold-import + `diff_import`, returning the new `content` and the
- * text `delta` (surviving anchors rebased). Use it to compute a revise without
- * a document in hand; `revise(addr, md)` fuses this with the store for
- * atomicity. Throws on an over-nested markdown input or a non-content `base`.
+ * text `delta` (its offsets USV indices into `Content.text`, surviving anchors
+ * rebased). Use it to compute a revise without a document in hand; `revise(addr,
+ * md)` fuses this with the store for atomicity. Throws on an over-nested
+ * markdown input or a non-content `base`.
  * @param {Content} base
  * @param {string} markdown
  * @returns {{ content: Content; delta: Delta }}

package/core/wasm_bg.wasm.d.ts

@@ -21,10 +21,10 @@ export const document_formatDiagnostic: (a: number, b: number) => void;
 export const document_formatRules: (a: number) => void;
 export const document_fromJson: (a: number, b: number, c: number) => void;
 export const document_fromMarkdown: (a: number, b: number, c: number) => void;
-export const document_get: (a: number, b: number, c: number) => void;
 export const document_getExt: (a: number, b: number, c: number) => void;
 export const document_getExtNamespace: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document_getMarkdown: (a: number, b: number, c: number) => void;
+export const document_getStored: (a: number, b: number, c: number) => void;
 export const document_insertCard: (a: number, b: number, c: number, d: number) => void;
 export const document_install: (a: number, b: number, c: number, d: number) => void;
 export const document_isFill: (a: number, b: number, c: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.96.0",
+  "version": "0.97.0",
   "description": "WebAssembly bindings for Quillmark, a schema-driven document engine",
   "type": "module",
   "license": "MIT OR Apache-2.0",

package/runtime/runtime.d.ts

@@ -79,8 +79,9 @@ export type {
 } from '../core/wasm.js';
 
 // The resolved-value view — the return shape of `quill.resolve(doc)`. Value
-// + source rung per declared field (the body rides the fields map under
-// `$body`); diagnostics stay `quill.validate`, guidance stays `quill.schema`.
+// + source rung per declared field (the body is a `body` sibling on its card,
+// never a row in `fields`); diagnostics stay `quill.validate`, guidance stays
+// `quill.schema`.
 // Declared in the core build's generated `.d.ts` via a
 // `typescript_custom_section`; re-exported here so the single public entry
 // point names them.
@@ -120,6 +121,37 @@ export interface QuillmarkError extends Error {
  */
 export declare function isQuillmarkError(e: unknown): e is QuillmarkError;
 
+// ── Open-set discriminant guards ────────────────────────────────────────────
+// `ContentIsland.type` / `ContentMark.type` are open sets — each union has a
+// residual `{ type: string; … }` arm, so a bare discriminant check never narrows
+// the payload (TS keeps the residual arm live, since a `string` can equal the
+// literal). These guards are the checked narrowing path for the pinned arms; an
+// unrecognized `type` fails every guard and keeps its opaque payload. Only the
+// payload-carrying arms get a guard — the bare marks
+// (`strong`/`emph`/`underline`/`strike`/`code`) narrow to nothing.
+
+import type { ContentIsland, TableProps, ImageProps, ContentMark } from '../core/wasm.js';
+
+/** Narrow a {@link ContentIsland} to the pinned `table` arm (`props: TableProps`). */
+export declare function isTableIsland(
+	island: ContentIsland
+): island is ContentIsland & { type: 'table'; props: TableProps };
+
+/** Narrow a {@link ContentIsland} to the pinned `image` arm (`props: ImageProps`). */
+export declare function isImageIsland(
+	island: ContentIsland
+): island is ContentIsland & { type: 'image'; props: ImageProps };
+
+/** Narrow a {@link ContentMark} to the `link` arm (carries `url`). */
+export declare function isLinkMark(
+	mark: ContentMark
+): mark is ContentMark & { type: 'link'; url: string };
+
+/** Narrow a {@link ContentMark} to the `anchor` arm (carries `id`). */
+export declare function isAnchorMark(
+	mark: ContentMark
+): mark is ContentMark & { type: 'anchor'; id: string };
+
 // ── Canonical render-side types ─────────────────────────────────────────────
 // These are the BACKEND-NEUTRAL render contract of the plural-backend API. They
 // are defined HERE (not re-exported from one private backend) because no single
@@ -630,7 +662,7 @@ export declare class CardWriter {
  * text, every other type its canonical value verbatim. Holds both handles by
  * reference and owns neither — nothing to `free()`.
  *
- * The schema authority is the point: unlike the quill-free transport `Document.get`,
+ * The schema authority is the point: unlike the quill-free transport `Document.getStored`,
  * a name the schema does not declare throws `UnknownField` (a typo) rather than
  * reading back `undefined`, and a content field holding a value that does not
  * decode throws `FieldRichtextDecode`. A field's markdown lives here, not on the

package/runtime/runtime.js

@@ -98,6 +98,49 @@ export function isQuillmarkError(e) {
 	return e instanceof Error && Array.isArray(/** @type {any} */ (e).diagnostics);
 }
 
+// ── Open-set discriminant guards ────────────────────────────────────────────
+// `ContentIsland.type` and `ContentMark.type` are OPEN sets: each union carries
+// a residual `{ type: string; … }` arm, so a bare `x.type === 'table'` check
+// never narrows the payload — TS keeps the residual arm live (a `string` can be
+// `'table'`), leaving `props` / the mark payload opaque at every consumer. These
+// are the checked narrowing path: on the true branch the payload's pinned shape
+// is asserted. Only the payload-carrying arms get a guard — an island always
+// carries `props`, a `link` mark carries `url`, an `anchor` mark carries `id`;
+// the bare marks (`strong`/`emph`/`underline`/`strike`/`code`) narrow to
+// nothing. An unrecognized `type` fails every guard and keeps its opaque payload.
+
+/**
+ * @param {import('../core/wasm.js').ContentIsland} island
+ * @returns {island is import('../core/wasm.js').ContentIsland & { type: 'table'; props: import('../core/wasm.js').TableProps }}
+ */
+export function isTableIsland(island) {
+	return island.type === 'table';
+}
+
+/**
+ * @param {import('../core/wasm.js').ContentIsland} island
+ * @returns {island is import('../core/wasm.js').ContentIsland & { type: 'image'; props: import('../core/wasm.js').ImageProps }}
+ */
+export function isImageIsland(island) {
+	return island.type === 'image';
+}
+
+/**
+ * @param {import('../core/wasm.js').ContentMark} mark
+ * @returns {mark is import('../core/wasm.js').ContentMark & { type: 'link'; url: string }}
+ */
+export function isLinkMark(mark) {
+	return mark.type === 'link';
+}
+
+/**
+ * @param {import('../core/wasm.js').ContentMark} mark
+ * @returns {mark is import('../core/wasm.js').ContentMark & { type: 'anchor'; id: string }}
+ */
+export function isAnchorMark(mark) {
+	return mark.type === 'anchor';
+}
+
 // Backend builds are NEVER statically imported here — that would pull a
 // multi-MB binary into the eager graph and defeat lazy loading. Each entry is a
 // DESCRIPTOR: `load` is a thunk returning a dynamic `import()` (a backend's
@@ -754,7 +797,7 @@ Quill.prototype.writer = function writer(doc) {
 };
 
 // ── Typed-reader sugar: the schema-plane read surface ──────────────────────────
-// The read twin of the writer above. The transport `Document.get` is schema-free
+// The read twin of the writer above. The transport `Document.getStored` is schema-free
 // — a `Document` cannot say which fields are richtext, so an unknown field name
 // reads back `undefined` rather than as the typo it is. Binding the quill's
 // schema (`_readerGet` takes the handle, like the `commit*` verbs) lets one `get`