@quillmark/wasm 0.94.0 → 0.96.0

package/core/wasm_bg.js

@@ -21,20 +21,24 @@ export class Document {
     }
     /**
      * Build a composable card of `kind`, typed-commit `fields` onto it, set its
-     * body from optional markdown, and append it — the ABI under
-     * `writer.addCard`. Fuses `makeCard` + typed commit + `pushCard`
-     * transactionally: the card is committed in full before it joins the
-     * document, so a rejected field (or an invalid kind or body) leaves the
-     * document untouched. Field errors throw the same per-field diagnostic
-     * bundle as [`commitFields`](Self::commit_fields), including an
-     * `[EditError::UnknownField]` per undeclared name; an invalid kind or body
-     * throws a single-entry bundle keyed `$kind` / `$body`.
+     * body from optional markdown, and place it — the ABI under `writer.addCard`.
+     * `at` picks the position: absent appends, a number inserts at that index
+     * (`0..=cards.length`), so a positioned typed insert is one atomic call
+     * rather than `addCard` + `moveCard`. Fuses `makeCard` + typed commit +
+     * insertion transactionally: the card is committed in full before it joins
+     * the document, so a rejected field (or an invalid kind, body, or
+     * out-of-range `at`) leaves the document untouched. Field errors throw the
+     * same per-field diagnostic bundle as [`commitFields`](Self::commit_fields),
+     * including an `edit::unknown_field` per undeclared name; an invalid
+     * kind or body, or an out-of-range position, throws a single-entry bundle
+     * keyed `$kind` / `$body`.
      * @param {Quill} quill
      * @param {string} kind
      * @param {Record<string, unknown>} [fields]
      * @param {string} [body]
+     * @param {number} [at]
      */
-    addCard(quill, kind, fields, body) {
+    _addCard(quill, kind, fields, body, at) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(quill, Quill);
@@ -42,7 +46,7 @@ export class Document {
             const len0 = WASM_VECTOR_LEN;
             var ptr1 = isLikeNone(body) ? 0 : passStringToWasm0(body, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             var len1 = WASM_VECTOR_LEN;
-            wasm.document_addCard(retptr, this.__wbg_ptr, quill.__wbg_ptr, ptr0, len0, isLikeNone(fields) ? 0 : addHeapObject(fields), ptr1, len1);
+            wasm.document__addCard(retptr, this.__wbg_ptr, quill.__wbg_ptr, ptr0, len0, isLikeNone(fields) ? 0 : addHeapObject(fields), ptr1, len1, isLikeNone(at) ? 0x100000001 : (at) >>> 0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -53,21 +57,39 @@ export class Document {
         }
     }
     /**
-     * **Apply** a committed corpus edit `bundle` (`{ delta?, lineOps?, markOps? }`)
-     * at `addr` — the editor splice: text delta first, then line ops, then mark
-     * ops (mark ranges in post-delta coordinates), each all-or-nothing. An absent
-     * `addr.field` targets the body, an absent `addr.card` the main card.
+     * Typed field write at `addr`, resolving the field's schema `type` from
+     * `quill` — the stable ABI under the runtime `writer.set` / `writer.card(i).set`.
+     * The one write verb for **every** field type (richtext, scalar, array,
+     * object); the schema carries the `inline` constraint, so no type token or
+     * flag is passed. A richtext-typed field stores the canonical content, so
+     * identity marks (anchors, island ids) and content-only marks (e.g.
+     * `underline`) live on it and survive compiles and the storage DTO. Values
+     * use the encoding the seam already speaks: a content object or markdown
+     * string for richtext, a scalar/array/object otherwise.
      *
-     * Throws on an out-of-range card, a field that is not richtext, a malformed
-     * bundle, or an op that applies out of bounds (the value is unchanged on a
-     * failed apply).
-     * @param {Addr} addr
-     * @param {ChangeBundle} bundle
+     * A bare string is `Addr` shorthand for `{ field }`; `{ card, field }`
+     * targets a composable card (its `$kind` resolves the schema). A body
+     * address throws — a body has no field schema; write it with `writer.setBody`
+     * / `revise`. A field declared in the schema is strict-committed (a mismatch
+     * throws now, not at render); a name the schema does not declare throws
+     * `edit::unknown_field` rather than falling to the opaque store — on
+     * the typed path it is a typo. Use [`storeField`](Document::store_field) for
+     * opaque storage. Also throws `edit::field_conform` /
+     * `edit::field_richtext_decode` / `edit::field_richtext_not_inline`
+     * on a typed mismatch, `edit::invalid_field_name` on a malformed name,
+     * and `edit::index_out_of_range` on an out-of-range card.
+     *
+     * The `quill` handle is passed per call because a `Document` carries only a
+     * `$quill` reference, not the resolved schema.
+     * @param {Quill} quill
+     * @param {Addr | string} addr
+     * @param {any} value
      */
-    applyChange(addr, bundle) {
+    _commitField(quill, addr, value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_applyChange(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(bundle));
+            _assertClass(quill, Quill);
+            wasm.document__commitField(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), addHeapObject(value));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -78,46 +100,63 @@ export class Document {
         }
     }
     /**
-     * Authoring-ergonomics header introducing a blueprint to an LLM/MCP
-     * consumer for the given `quillName`. Re-exposes core's canonical text for
-     * JS consumers; any surface that draws from the same core source stays
-     * uniform.
-     * @param {string} quill_name
-     * @returns {string}
+     * Batched twin of [`commitField`](Document::commit_field): typed-commit
+     * several fields on the card `addr` targets atomically, resolving each
+     * field's schema `type` from `quill`. `addr` is a **card address**
+     * (`{ card }`, absent = main; a present `field` throws). All-or-nothing with
+     * the same per-field-diagnostic error contract as
+     * [`storeFields`](Document::store_fields) — nothing is applied on error and
+     * the thrown error's `diagnostics` carry one entry per offending field,
+     * including an `edit::unknown_field` for any name the schema does not
+     * declare, so a whole-form submit sees every typo in one pass. Throws on an
+     * out-of-range card.
+     * @param {Quill} quill
+     * @param {CardAddr} addr
+     * @param {Record<string, unknown>} fields
      */
-    static blueprintInstruction(quill_name) {
-        let deferred2_0;
-        let deferred2_1;
+    _commitFields(quill, addr, fields) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(quill_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_blueprintInstruction(retptr, ptr0, len0);
+            _assertClass(quill, Quill);
+            wasm.document__commitFields(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), addHeapObject(fields));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            if (r1) {
+                throw takeObject(r0);
+            }
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
         }
     }
     /**
-     * Number of composable cards (excludes the main card). O(1).
-     * @returns {number}
-     */
-    get cardCount() {
-        const ret = wasm.document_cardCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {Card[]}
+     * 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`
+     * 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.
+     *
+     * A bare string is `Addr` shorthand for `{ field }`; `{ card, field }`
+     * targets a composable card (its `$kind` resolves the schema). Returns
+     * `undefined` for an **absent** field. An absent `addr.field` reads the body
+     * markdown — quill-free, mirroring [`getMarkdown`](Self::get_markdown), since
+     * a body's type is a format fact, not a schema fact. A name the schema does
+     * not declare throws `edit::unknown_field` (the authority `getMarkdown`
+     * lacks — there an unknown name reads back `undefined`); a `richtext` field
+     * holding a value that does not decode throws `edit::field_richtext_decode`;
+     * an out-of-range `addr.card` throws.
+     *
+     * The `quill` handle is passed per call because a `Document` carries only a
+     * `$quill` reference, not the resolved schema.
+     * @param {Quill} quill
+     * @param {Addr | string} addr
+     * @returns {unknown}
      */
-    get cards() {
+    _readerGet(quill, addr) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_cards(retptr, this.__wbg_ptr);
+            _assertClass(quill, Quill);
+            wasm.document__readerGet(retptr, this.__wbg_ptr, quill.__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);
@@ -130,59 +169,59 @@ export class Document {
         }
     }
     /**
-     * @returns {Document}
-     */
-    clone() {
-        const ret = wasm.document_clone(this.__wbg_ptr);
-        return Document.__wrap(ret);
-    }
-    /**
-     * Typed field write on the composable card at `index` — the card-indexed
-     * twin of [`commitField`](Document::commit_field). Resolves the field's
-     * type from the card's `$kind` schema in `quill` and strict-commits it.
+     * Revise the richtext field at `addr` from markdown, typed *and*
+     * anchor-preserving — the ABI under `writer.reviseField`. Resolves the
+     * field's schema from `quill` (main card, or the addressed card's `$kind`)
+     * and defers to [`TypedWriter::revise_field`](quillmark_core::TypedWriter::revise_field):
+     * 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`].
      *
-     * Throws `[EditError::IndexOutOfRange]` when `index` is out of range, and
-     * the same typed-mismatch / name errors as `commitField` — including
-     * `[EditError::UnknownField]` for a field the card-kind schema does not
-     * declare (an unknown `$kind` has no schema, so every field is undeclared).
+     * `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
+     * name the schema does not declare throws `edit::unknown_field`. Throws
+     * on an out-of-range card. Hidden from the `.d.ts`; the visible verb is
+     * `writer.reviseField` in the runtime layer.
      * @param {Quill} quill
-     * @param {number} index
-     * @param {string} name
-     * @param {any} value
+     * @param {Addr | string} addr
+     * @param {string} markdown
+     * @returns {Delta}
      */
-    commitCardField(quill, index, name, value) {
+    _reviseField(quill, addr, markdown) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(quill, Quill);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.document_commitCardField(retptr, this.__wbg_ptr, quill.__wbg_ptr, index, ptr0, len0, addHeapObject(value));
+            wasm.document__reviseField(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Batched twin of [`commitCardField`](Document::commit_card_field):
-     * typed-commit several fields on the card at `index` atomically, resolving
-     * each field's type from the card's `$kind` schema in `quill`. All-or-nothing
-     * with the same per-field-diagnostic contract as
-     * [`commitFields`](Document::commit_fields), including an
-     * `[EditError::UnknownField]` diagnostic per undeclared name. Throws
-     * `[EditError::IndexOutOfRange]` when `index` is out of range.
-     * @param {Quill} quill
-     * @param {number} index
-     * @param {Record<string, unknown>} fields
+     * **Apply** a committed content edit `bundle` (`{ delta?, lineOps?, markOps? }`)
+     * at `addr` — the editor splice: text delta first, then line ops, then mark
+     * ops (mark ranges in final-text coordinates), each all-or-nothing. An absent
+     * `addr.field` targets the body, an absent `addr.card` the main card.
+     *
+     * Throws on an out-of-range card, a field that is not richtext, a malformed
+     * bundle, or an op that applies out of bounds (the value is unchanged on a
+     * failed apply).
+     * @param {Addr | string} addr
+     * @param {ChangeBundle} bundle
      */
-    commitCardFields(quill, index, fields) {
+    applyChange(addr, bundle) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            wasm.document_commitCardFields(retptr, this.__wbg_ptr, quill.__wbg_ptr, index, addHeapObject(fields));
+            wasm.document_applyChange(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(bundle));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -193,71 +232,102 @@ export class Document {
         }
     }
     /**
-     * Typed field write on the main card, resolving the field's schema `type`
-     * from `quill` — the one write verb for **every** field type (richtext,
-     * scalar, array, object). The schema carries the `inline` constraint, so no
-     * type token or flag is passed. A richtext-typed field stores the canonical
-     * corpus, so identity marks (anchors, island ids) and corpus-only marks
-     * (e.g. `underline`) live on it and survive compiles and the storage DTO.
-     * Values use the encoding the seam already speaks: a corpus object
-     * or markdown string for richtext, a scalar/array/object otherwise.
-     *
-     * A field declared in the schema is strict-committed — a mismatch throws
-     * now, not at render. A name the schema does not declare throws
-     * `[EditError::UnknownField]` rather than falling to the opaque store: on
-     * the typed path it is a typo. Use [`setField`](Document::set_field) when
-     * opaque storage is the intent. Also throws `[EditError::FieldConform]` /
-     * `[EditError::FieldRichtextDecode]` / `[EditError::FieldRichtextNotInline]`
-     * on a typed mismatch and `[EditError::InvalidFieldName]` on a malformed
-     * name.
-     *
-     * The `quill` handle is passed per call because a `Document` carries only a
-     * `$quill` reference, not the resolved schema.
-     * @param {Quill} quill
-     * @param {string} name
-     * @param {any} value
+     * Authoring-ergonomics header introducing a blueprint to an LLM/MCP
+     * consumer for the given `quillName`. Re-exposes core's canonical text for
+     * JS consumers; any surface that draws from the same core source stays
+     * uniform.
+     * @param {string} quill_name
+     * @returns {string}
      */
-    commitField(quill, name, value) {
+    static blueprintInstruction(quill_name) {
+        let deferred2_0;
+        let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(quill_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.document_commitField(retptr, this.__wbg_ptr, quill.__wbg_ptr, ptr0, len0, addHeapObject(value));
+            wasm.document_blueprintInstruction(retptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            deferred2_0 = r0;
+            deferred2_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * A single composable card by index — the whole `Card`, the card-indexed
+     * twin of the [`main`](Self::main) getter, so reading one card need not
+     * materialize every card via [`cards`](Self::cards). An out-of-range
+     * `index` throws `edit::index_out_of_range`, matching the card write
+     * verbs.
+     * @param {number} index
+     * @returns {Card}
+     */
+    card(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_card(retptr, this.__wbg_ptr, index);
+            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);
         }
     }
     /**
-     * Batched twin of [`commitField`](Document::commit_field): typed-commit
-     * several main-card fields atomically, resolving each field's schema `type`
-     * from `quill`. All-or-nothing with the same per-field-diagnostic error
-     * contract as [`setFields`](Document::set_fields) — nothing is applied on
-     * error and the thrown error's `diagnostics` carry one entry per offending
-     * field, including an `[EditError::UnknownField]` for any name the schema
-     * does not declare, so a whole-form submit sees every typo in one pass.
-     * @param {Quill} quill
-     * @param {Record<string, unknown>} fields
+     * Number of composable cards (excludes the main card). O(1).
+     * @returns {number}
+     */
+    get cardCount() {
+        const ret = wasm.document_cardCount(this.__wbg_ptr);
+        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
+     * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
+     * non-unique by design, so the first match wins.
+     * @param {string} id
+     * @returns {number | undefined}
      */
-    commitFields(quill, fields) {
+    cardIndexById(id) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.document_cardIndexById(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Card[]}
+     */
+    get cards() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            wasm.document_commitFields(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(fields));
+            wasm.document_cards(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @returns {Document}
+     */
+    clone() {
+        const ret = wasm.document_clone(this.__wbg_ptr);
+        return Document.__wrap(ret);
+    }
     /**
      * Schema version this build writes via [`toJson`](Document::to_json).
      * Tracks the `Document` model version (not the running crate version):
@@ -388,20 +458,70 @@ export class Document {
         }
     }
     /**
-     * Read a main-card field's stored value — the raw payload value (a corpus
-     * object for a richtext field, a scalar/array/object otherwise), or
-     * `undefined` when the field is absent. The quill-free read: 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 {string} name
-     * @returns {any}
+     * 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 —
+     * your own state without serializing the whole card. Throws on a present
+     * `field` (a card address takes only `card`) or an out-of-range card.
+     * @param {CardAddr} [addr]
+     * @returns {Record<string, unknown> | undefined}
+     */
+    getExt(addr) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_getExt(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 value stored under `$ext[ns]` at `addr` (a card address, absent `card`
+     * = main), or `undefined`. The namespace-scoped `$ext` read — your own slot
+     * without a whole-card serialize, and non-destructive (unlike
+     * `removeExtNamespace`). Throws on a present `field` or an out-of-range card.
+     * @param {CardAddr} addr
+     * @param {string} ns
+     * @returns {unknown}
      */
-    get(name) {
+    getExtNamespace(addr, ns) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(ns, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.document_get(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.document_getExtNamespace(retptr, this.__wbg_ptr, addHeapObject(addr), ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -414,43 +534,47 @@ export class Document {
         }
     }
     /**
-     * The markdown projection of a main-card field (`name` given) or the main
-     * body (`name` omitted) — the on-demand, lossy export (corpus-only marks do
-     * not survive markdown), returning `""` for an absent field. Re-coins,
-     * lazily and by name, the projection the eager `fieldMarkdown` /
-     * `bodyMarkdown` getters dropped in #925; call it only when markdown is what
-     * you need out.
-     * @param {string} [name]
+     * The **body** markdown projection — the main body, or a composable card's
+     * body (`{ card }`) — the on-demand, lossy export (content-only marks do not
+     * survive markdown). A body's type is a format fact, not a schema fact, so
+     * this read stays quill-free; a body is never absent.
+     *
+     * `addr` is an optional **card address** (`{ card }`, absent = main). A
+     * present `field` throws — a field's markdown is read through the
+     * schema-plane `quill.reader(doc).get(field)`, which interprets by declared
+     * type (#978). An out-of-range `addr.card` throws.
+     * @param {CardAddr} [addr]
      * @returns {string}
      */
-    getMarkdown(name) {
-        let deferred2_0;
-        let deferred2_1;
+    getMarkdown(addr) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            var ptr0 = isLikeNone(name) ? 0 : passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            var len0 = WASM_VECTOR_LEN;
-            wasm.document_getMarkdown(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.document_getMarkdown(retptr, this.__wbg_ptr, addHeapObject(addr));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
         }
     }
     /**
-     * Insert a card at `index` (must be in `0..=cards.length`). Accepts a
-     * `CardInput` (see [`pushCard`](Self::push_card)).
-     * @param {number} index
+     * Insert a card — the single insertion verb: `at` absent appends, a number
+     * inserts at that index (must be in `0..=cards.length`). Accepts a
+     * `CardInput` — a card read back (`cards` / `removeCard` / `quill.seedCard`),
+     * a [`makeCard`](Document::make_card) result, or a bare `{ kind, body }`
+     * (every returned `Card` is a valid `CardInput`). Throws if `card.kind` is
+     * not a valid kind name, or if `at` is out of range.
      * @param {CardInput} card
+     * @param {number} [at]
      */
-    insertCard(index, card) {
+    insertCard(card, at) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_insertCard(retptr, this.__wbg_ptr, index, addHeapObject(card));
+            wasm.document_insertCard(retptr, this.__wbg_ptr, addHeapObject(card), isLikeNone(at) ? 0x100000001 : (at) >>> 0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -461,8 +585,8 @@ export class Document {
         }
     }
     /**
-     * **Install** a richtext value at `addr` — **value semantics**, corpus only.
-     * Stores exactly `rt` (a canonical `RichText` corpus object); the identity
+     * **Install** a richtext value at `addr` — **value semantics**, content only.
+     * Stores exactly `rt` (a canonical `Content` content object); the identity
      * anchors of any previous value are gone. An absent `addr.field` targets the
      * body, an absent `addr.card` the main card. For "here's new markdown," use
      * [`revise`](Document::revise); the cold-import path is spelled at the call
@@ -470,9 +594,9 @@ export class Document {
      * source.
      *
      * Throws on an out-of-range card, a malformed field name, or an `rt` that is
-     * not a canonical corpus object.
-     * @param {Addr} addr
-     * @param {RichText} rt
+     * not a canonical content object.
+     * @param {Addr | string} addr
+     * @param {Content} rt
      */
     install(addr, rt) {
         try {
@@ -487,6 +611,29 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Whether the field at `addr` is marked `!must_fill`. A bare string is `Addr`
+     * shorthand for `{ field }`. `false` for an absent field (truthful — it isn't
+     * marked) and for a body address (a body is never a fill). Only an
+     * out-of-range `addr.card` throws.
+     * @param {Addr | string} addr
+     * @returns {boolean}
+     */
+    isFill(addr) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_isFill(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 r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Replace this document's contents **in place** from a versioned storage
      * DTO string — the mutating twin of the static
@@ -536,10 +683,10 @@ export class Document {
     }
     /**
      * Build a fresh `Card` from a kind and a flat field map — the ergonomic
-     * constructor for `pushCard` / `insertCard`. `fields` is an optional
+     * constructor for `insertCard`. `fields` is an optional
      * `Record<string, unknown>` (each entry becomes a card field, in
      * insertion order); `body` defaults to `""`. Kind validity is checked by
-     * `pushCard` / `insertCard`, not here.
+     * `insertCard`, not here.
      * @param {string} kind
      * @param {Record<string, unknown>} [fields]
      * @param {string} [body]
@@ -610,27 +757,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * Append a card to the end of the card list. Accepts a `CardInput` — a card
-     * read back (`cards` / `removeCard` / `quill.seedCard`), a
-     * [`makeCard`](Document::make_card) result, or a bare `{ kind, body }`
-     * (every returned `Card` is a valid `CardInput`). Throws if `card.kind` is
-     * not a valid kind name.
-     * @param {CardInput} card
-     */
-    pushCard(card) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_pushCard(retptr, this.__wbg_ptr, addHeapObject(card));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
     /**
      * @returns {string}
      */
@@ -694,87 +820,17 @@ export class Document {
         }
     }
     /**
-     * Remove the `$ext` map from the composable card at `index` *entirely*,
-     * returning the previous map or `undefined`. Throws if out of range.
-     * Prefer `removeCardExtNamespace` to clear only one consumer's slot.
-     * @param {number} index
-     * @returns {Record<string, unknown> | undefined}
-     */
-    removeCardExt(index) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_removeCardExt(retptr, this.__wbg_ptr, index);
-            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);
-        }
-    }
-    /**
-     * Remove `namespace` from the composable card's `$ext` map, returning the
-     * value stored there or `undefined`; clears `$ext` entirely once empty.
-     * The card-indexed twin of `removeExtNamespace`. Throws if out of range.
-     * @param {number} index
-     * @param {string} namespace
-     * @returns {any}
-     */
-    removeCardExtNamespace(index, namespace) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(namespace, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_removeCardExtNamespace(retptr, this.__wbg_ptr, index, ptr0, len0);
-            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);
-        }
-    }
-    /**
-     * Remove a field on the card at `index`. Returns the removed value or
-     * `undefined`. Throws if `index` is out of range or `name` is invalid.
-     * @param {number} index
-     * @param {string} name
-     * @returns {any}
-     */
-    removeCardField(index, name) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_removeCardField(retptr, this.__wbg_ptr, index, ptr0, len0);
-            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);
-        }
-    }
-    /**
-     * Remove the `$ext` map from the main card *entirely*, returning the
-     * previous map or `undefined`. This is a blunt escape hatch that discards
-     * every namespace at once — prefer `removeExtNamespace` to clear only your
-     * own slot while leaving sibling consumers' state intact.
+     * Remove the `$ext` map on the card `addr` targets *entirely*, returning the
+     * previous map or `undefined` — a blunt escape hatch that discards every
+     * namespace at once (prefer `removeExtNamespace`). `addr` is a card address
+     * (absent = main). Throws on a present `field` or an out-of-range card.
+     * @param {CardAddr} [addr]
      * @returns {Record<string, unknown> | undefined}
      */
-    removeExt() {
+    removeExt(addr) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_removeExt(retptr, this.__wbg_ptr);
+            wasm.document_removeExt(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);
@@ -787,19 +843,20 @@ export class Document {
         }
     }
     /**
-     * Remove `namespace` from the main card's `$ext` map, returning the value
-     * stored there or `undefined`. This is the recommended way to clear `$ext`
-     * state: sibling namespaces survive, and when the last namespace is removed
-     * the `$ext` entry is dropped entirely (not left as `$ext: {}`).
-     * @param {string} namespace
+     * Remove `$ext[ns]` on the card `addr` targets, returning its value or
+     * `undefined`; drops `$ext` once empty. `addr` is a card address (absent =
+     * main). Preserves sibling namespaces. Throws on a present `field` or an
+     * out-of-range card.
+     * @param {CardAddr} addr
+     * @param {string} ns
      * @returns {any}
      */
-    removeExtNamespace(namespace) {
+    removeExtNamespace(addr, ns) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(namespace, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(ns, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.document_removeExtNamespace(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.document_removeExtNamespace(retptr, this.__wbg_ptr, addHeapObject(addr), ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -812,17 +869,17 @@ export class Document {
         }
     }
     /**
-     * Remove a payload field on the main card, returning the removed value or
-     * `undefined`. Throws if `name` does not match `[A-Za-z_][A-Za-z0-9_]*`.
-     * @param {string} name
+     * Remove a field at `addr`, returning the removed value or `undefined`. A
+     * bare string is `Addr` shorthand for `{ field }`. One `remove` verb serves
+     * every write lane. A body address throws; throws on an out-of-range card or
+     * a malformed name.
+     * @param {Addr | string} addr
      * @returns {any}
      */
-    removeField(name) {
+    removeField(addr) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_removeField(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.document_removeField(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);
@@ -836,8 +893,8 @@ export class Document {
     }
     /**
      * Remove `cardKind` from the main card's `$seed` map, returning its
-     * overlay or `undefined`; drops `$seed` entirely once empty. Sibling
-     * kinds survive.
+     * overlay or `undefined`; drops `$seed` entirely once empty. Sibling kinds
+     * survive. `$seed` is main-only, so this takes no address.
      * @param {string} card_kind
      * @returns {any}
      */
@@ -858,28 +915,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * **Deprecated** — alias for `revise({}, markdown)`, kept one release cycle.
-     * Revise the main card's body from a markdown string (edit semantics: a
-     * `diff_import` that rebases surviving anchors). Discards the text delta;
-     * call [`revise`](Document::revise) to receive it.
-     * @param {string} body
-     */
-    replaceBody(body) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(body, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_replaceBody(retptr, this.__wbg_ptr, ptr0, len0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
     /**
      * **Revise** the richtext value at `addr` from a markdown string — **edit
      * semantics**, the default write path, returning the text [`Delta`]. Imports
@@ -889,8 +924,8 @@ export class Document {
      * absent `addr.card` the main card; an absent field cold-imports from empty.
      *
      * Throws on an out-of-range card, a malformed field name, a present
-     * non-corpus field value, or an over-nested markdown input.
-     * @param {Addr} addr
+     * non-content field value, or an over-nested markdown input.
+     * @param {Addr | string} addr
      * @param {string} markdown
      * @returns {Delta}
      */
@@ -938,88 +973,27 @@ export class Document {
         }
     }
     /**
-     * Replace the `$ext` map on the composable card at `index`. Throws if out
-     * of range or `value` is not a plain object. Named to mirror `setExt` on
-     * the main card; `setCardExtNamespace` is the sibling-safe alternative.
-     * @param {number} index
-     * @param {any} value
-     */
-    setCardExt(index, value) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_setCardExt(retptr, this.__wbg_ptr, index, addHeapObject(value));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Merge `value` into the composable card's `$ext` map under `namespace`,
-     * preserving sibling namespaces. The card-indexed twin of `setExtNamespace`.
-     * Throws if out of range or `value` cannot be serialized.
-     * @param {number} index
-     * @param {string} namespace
-     * @param {any} value
-     */
-    setCardExtNamespace(index, namespace, value) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(namespace, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_setCardExtNamespace(retptr, this.__wbg_ptr, index, ptr0, len0, addHeapObject(value));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Set a field on the card at `index` — the card-indexed twin of
-     * [`setField`](Document::set_field). Stores the value opaquely.
-     * Throws if `index` is out of range, `name` is reserved or invalid.
-     * @param {number} index
-     * @param {string} name
-     * @param {any} value
+     * The main card's `$seed` overlay object for `kind` (the `$seed[kind]`
+     * entry), or `undefined` when absent. The cheap read that feeds
+     * `quill.seedCard(kind, overlay)` without serializing the whole main card
+     * via [`main`](Self::main) to fish out one key — and it keeps `seedCard`
+     * pure: the quill still never reads the document.
+     * @param {string} kind
+     * @returns {Record<string, unknown> | undefined}
      */
-    setCardField(index, name, value) {
+    seedOverlay(kind) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.document_setCardField(retptr, this.__wbg_ptr, index, ptr0, len0, addHeapObject(value));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Batched twin of [`setCardField`](Document::set_card_field): set
-     * several fields on the card at `index` atomically. Same all-or-nothing,
-     * one-diagnostic-per-field contract as [`setFields`](Document::set_fields).
-     * Throws if `index` is out of range.
-     * @param {number} index
-     * @param {Record<string, unknown>} fields
-     */
-    setCardFields(index, fields) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_setCardFields(retptr, this.__wbg_ptr, index, addHeapObject(fields));
+            wasm.document_seedOverlay(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -1047,16 +1021,15 @@ export class Document {
         }
     }
     /**
-     * Replace the opaque `$ext` map on the main card. `value` must be a plain
-     * object; throws otherwise. `$ext` carries out-of-band consumer state and
-     * never reaches the rendered output. Pass `{}` to record an explicit
-     * empty `$ext`.
-     * @param {any} value
+     * Replace the QUILL reference string. Throws if `ref_str` is invalid.
+     * @param {string} ref_str
      */
-    setExt(value) {
+    setQuillRef(ref_str) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_setExt(retptr, this.__wbg_ptr, addHeapObject(value));
+            const ptr0 = passStringToWasm0(ref_str, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_setQuillRef(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -1067,19 +1040,18 @@ export class Document {
         }
     }
     /**
-     * Merge `value` into the main card's `$ext` map under `namespace`, creating
-     * the map when absent and replacing any existing value at that key. Sibling
-     * namespaces are preserved, so independent consumers (`$ext.editor`,
-     * `$ext.agent`, …) don't clobber each other.
-     * @param {string} namespace
+     * Replace the opaque `$ext` map on the card `addr` targets (a card address,
+     * absent `card` = main). `value` must be a plain object. `$ext` carries
+     * out-of-band consumer state and never reaches the rendered output; pass
+     * `{}` for an explicit empty `$ext`. Quill-free and verbatim — an opaque
+     * `store` verb. Throws on a present `field` or an out-of-range card.
+     * @param {CardAddr} addr
      * @param {any} value
      */
-    setExtNamespace(namespace, value) {
+    storeExt(addr, value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(namespace, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_setExtNamespace(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(value));
+            wasm.document_storeExt(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(value));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -1090,18 +1062,20 @@ export class Document {
         }
     }
     /**
-     * Update a payload field on the main card. Clears any existing `!must_fill` marker.
-     *
-     * Throws if `name` does not match `[A-Za-z_][A-Za-z0-9_]*`.
-     * @param {string} name
+     * Merge `value` into `$ext[ns]` on the card `addr` targets, preserving
+     * sibling namespaces — the recommended `$ext` write. `addr` is a card
+     * address (absent = main). Quill-free and verbatim — an opaque `store` verb.
+     * Throws on a present `field` or an out-of-range card.
+     * @param {CardAddr} addr
+     * @param {string} ns
      * @param {any} value
      */
-    setField(name, value) {
+    storeExtNamespace(addr, ns, value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(ns, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.document_setField(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(value));
+            wasm.document_storeExtNamespace(retptr, this.__wbg_ptr, addHeapObject(addr), ptr0, len0, addHeapObject(value));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -1112,18 +1086,21 @@ export class Document {
         }
     }
     /**
-     * Set several main-card payload fields atomically from a plain object,
-     * clearing any `!must_fill` marker on each key. Nothing is applied on
-     * error; the thrown error's `diagnostics` array carries one entry per
-     * offending field (`path` = field name), so externally-sourced names
-     * (database columns, form keys) surface every violation in one pass.
-     * Mirrors Python `set_fields`.
-     * @param {Record<string, unknown>} fields
+     * Store a field verbatim at `addr` — the opaque store (**store** = verbatim,
+     * coercion deferred to render; the typed write is
+     * [`commitField`](Document::commit_field)). A bare string is `Addr`
+     * shorthand for `{ field }`, so `doc.storeField("qty", 3)` reads as written;
+     * `{ card: 2, field: "qty" }` targets a composable card. Clears any
+     * `!must_fill` marker. A body address (no `field`) throws — a body is never
+     * opaque; write it with `revise` / `install` / `writer.setBody`. Throws on
+     * an out-of-range card or a malformed name.
+     * @param {Addr | string} addr
+     * @param {any} value
      */
-    setFields(fields) {
+    storeField(addr, value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_setFields(retptr, this.__wbg_ptr, addHeapObject(fields));
+            wasm.document_storeField(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(value));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -1134,17 +1111,21 @@ export class Document {
         }
     }
     /**
-     * Update a payload field on the main card and mark it as `!must_fill`.
-     * Throws on invalid name (see [`setField`](Document::set_field)).
-     * @param {string} name
-     * @param {any} value
+     * Store several fields verbatim and atomically on the card `addr` targets —
+     * the opaque store's batch. `addr` is a **card address** (`{ card }`, absent
+     * = main); a present `field` throws. The batch verb takes the address first
+     * and is never shape-overloaded, because `card` is a legal field name:
+     * `storeFields({}, fields)` is the main card, `storeFields({ card: 2 },
+     * fields)` a composable one — never ambiguous with "set field `card`".
+     * Nothing is applied on error; the thrown error's `diagnostics` carry one
+     * entry per offending field. Throws on an out-of-range card.
+     * @param {CardAddr} addr
+     * @param {Record<string, unknown>} fields
      */
-    setFill(name, value) {
+    storeFields(addr, fields) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_setFill(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(value));
+            wasm.document_storeFields(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(fields));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -1155,15 +1136,17 @@ export class Document {
         }
     }
     /**
-     * Replace the QUILL reference string. Throws if `ref_str` is invalid.
-     * @param {string} ref_str
+     * Store a field verbatim at `addr` and mark it `!must_fill` — the opaque
+     * store's fill variant, card-capable (a bare string or `{ field }` for main,
+     * `{ card, field }` for a composable card). A body address throws. Same
+     * validation as [`storeField`](Document::store_field).
+     * @param {Addr | string} addr
+     * @param {any} value
      */
-    setQuillRef(ref_str) {
+    storeFill(addr, value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(ref_str, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_setQuillRef(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.document_storeFill(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(value));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -1174,19 +1157,20 @@ export class Document {
         }
     }
     /**
-     * Merge a card-kind's seed `overlay` into the main card's `$seed` map
-     * under `cardKind`, preserving sibling kinds. Sets the starting values
-     * new cards of that kind spawn with. Throws if `overlay` cannot be
-     * serialized or nests too deep.
+     * Merge a card-kind's seed `overlay` into the **main** card's `$seed` map
+     * under `cardKind`, preserving sibling kinds — `$seed` lives on the main
+     * card by model, so this takes no address. Sets the starting values new
+     * cards of that kind spawn with. Quill-free and verbatim — an opaque `store`
+     * verb. Throws if `overlay` cannot be serialized or nests too deep.
      * @param {string} card_kind
      * @param {any} overlay
      */
-    setSeedNamespace(card_kind, overlay) {
+    storeSeedNamespace(card_kind, overlay) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(card_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.document_setSeedNamespace(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(overlay));
+            wasm.document_storeSeedNamespace(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(overlay));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -1387,6 +1371,34 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * 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.
+     *
+     * Value and provenance only: completeness and errors stay `validate`'s
+     * (a consumer merges it with its own diagnostic producers regardless), and
+     * schema guidance reads from `Quill.schema`.
+     * @param {Document} doc
+     * @returns {Resolved}
+     */
+    resolve(doc) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(doc, Document);
+            wasm.quill_resolve(retptr, this.__wbg_ptr, doc.__wbg_ptr);
+            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);
+        }
+    }
     /**
      * Document schema for the quill: the user-fillable fields plus their
      * `ui` hints (title / group / compact / multiline). The single
@@ -1415,9 +1427,9 @@ export class Quill {
      * layering an optional per-kind seed `overlay` over the schema-example
      * base (`overlay › example › absent`). Returns `undefined` if `cardKind`
      * is not declared in this quill's schema, else a `Card` that feeds
-     * straight into `Document.pushCard` / `insertCard`.
+     * straight into `Document.insertCard`.
      *
-     * Pass `document.main.seed?.[cardKind]` as `overlay` so a card added to a
+     * Pass `document.seedOverlay(cardKind)` as `overlay` so a card added to a
      * template-derived document inherits its curated starting values; omit it
      * (or pass `undefined` / `null`) for the bare schema seed. `overlay` is a
      * plain object — this reads the document, it does not mutate it.
@@ -1527,10 +1539,10 @@ export class Quill {
 if (Symbol.dispose) Quill.prototype[Symbol.dispose] = Quill.prototype.free;
 
 /**
- * Export a canonical `RichText` corpus to its markdown projection — the pure
- * codec that replaces the eager `bodyMarkdown` / `fieldMarkdown` precomputes
- * (`exportMarkdown(card.body)`). Throws if `rt` is not a canonical corpus.
- * @param {RichText} rt
+ * Export a canonical `Content` content to its markdown projection — the pure
+ * on-demand codec behind `exportMarkdown(card.body)`. Throws if `rt` is not a
+ * canonical content.
+ * @param {Content} rt
  * @returns {string}
  */
 export function exportMarkdown(rt) {
@@ -1559,12 +1571,46 @@ export function exportMarkdown(rt) {
 }
 
 /**
- * Import a markdown string to a canonical `RichText` corpus — the pure,
+ * Serialize structured [`DocPathSeg`] segments back to the canonical path
+ * string — the inverse of `parseDocPath`, for a consumer that builds a path
+ * rather than reads one. Throws on a segment array the deserializer rejects,
+ * and on an empty segment array (symmetric with `parseDocPath("")`, which
+ * throws "empty path").
+ * @param {DocPathSeg[]} segs
+ * @returns {string}
+ */
+export function formatDocPath(segs) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.formatDocPath(retptr, addHeapObject(segs));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr1 = r0;
+        var len1 = r1;
+        if (r3) {
+            ptr1 = 0; len1 = 0;
+            throw takeObject(r2);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Import a markdown string to a canonical `Content` content — the pure,
  * document-free codec. Pair with `install(addr, importMarkdown(md))` to spell
  * the cold (anchor-losing) write at the call site; prefer `revise` for edit
  * semantics. Throws on an over-nested input.
  * @param {string} markdown
- * @returns {RichText}
+ * @returns {Content}
  */
 export function importMarkdown(markdown) {
     try {
@@ -1592,7 +1638,7 @@ export function init() {
 }
 
 /**
- * Map a base corpus position through a `delta` to its new position — the pure
+ * 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`.
@@ -1618,14 +1664,41 @@ export function mapPos(delta, pos, assoc) {
 }
 
 /**
- * Rebase `markdown` onto a `base` corpus — the pure, document-free twin of
- * `revise`: cold-import + `diff_import`, returning the new `corpus` and the
+ * Parse a canonical document-model `Diagnostic.path`
+ * (`cards.<kind>[<i>].<field>`, `main.body`, `recipients[0].name`) into its
+ * structured [`DocPathSeg`] segments — the exported inverse of the engine's
+ * one path serializer, so a consumer routes on segments instead of regexing
+ * the string. Throws on a malformed path.
+ * @param {string} path
+ * @returns {DocPathSeg[]}
+ */
+export function parseDocPath(path) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.parseDocPath(retptr, ptr0, len0);
+        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);
+    }
+}
+
+/**
+ * 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-corpus `base`.
- * @param {RichText} base
+ * atomicity. Throws on an over-nested markdown input or a non-content `base`.
+ * @param {Content} base
  * @param {string} markdown
- * @returns {{ corpus: RichText; delta: Delta }}
+ * @returns {{ content: Content; delta: Delta }}
  */
 export function rebase(base, markdown) {
     try {