@quillmark/wasm 0.92.1 → 0.94.0

package/core/wasm_bg.js

@@ -19,6 +19,64 @@ export class Document {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_document_free(ptr, 0);
     }
+    /**
+     * 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`.
+     * @param {Quill} quill
+     * @param {string} kind
+     * @param {Record<string, unknown>} [fields]
+     * @param {string} [body]
+     */
+    addCard(quill, kind, fields, body) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            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);
+            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);
+        }
+    }
+    /**
+     * **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.
+     *
+     * 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
+     */
+    applyChange(addr, bundle) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Authoring-ergonomics header introducing a blueprint to an LLM/MCP
      * consumer for the given `quillName`. Re-exposes core's canonical text for
@@ -78,6 +136,128 @@ export class Document {
         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.
+     *
+     * 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).
+     * @param {Quill} quill
+     * @param {number} index
+     * @param {string} name
+     * @param {any} value
+     */
+    commitCardField(quill, index, name, value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            const ptr0 = passStringToWasm0(name, 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));
+            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 [`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
+     */
+    commitCardFields(quill, index, fields) {
+        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));
+            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);
+        }
+    }
+    /**
+     * 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
+     */
+    commitField(quill, name, value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            const ptr0 = passStringToWasm0(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));
+            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 [`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
+     */
+    commitFields(quill, fields) {
+        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));
+            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);
+        }
+    }
     /**
      * Schema version this build writes via [`toJson`](Document::to_json).
      * Tracks the `Document` model version (not the running crate version):
@@ -207,11 +387,65 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * 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}
+     */
+    get(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_get(retptr, this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * 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]
+     * @returns {string}
+     */
+    getMarkdown(name) {
+        let deferred2_0;
+        let deferred2_1;
+        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);
+            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);
+        } 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
-     * `Card` (see [`pushCard`](Self::push_card)).
+     * `CardInput` (see [`pushCard`](Self::push_card)).
      * @param {number} index
-     * @param {Card} card
+     * @param {CardInput} card
      */
     insertCard(index, card) {
         try {
@@ -226,6 +460,60 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * **Install** a richtext value at `addr` — **value semantics**, corpus only.
+     * Stores exactly `rt` (a canonical `RichText` corpus 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
+     * site as `install(addr, importMarkdown(md))`, so anchor loss is visible in
+     * 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
+     */
+    install(addr, rt) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_install(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(rt));
+            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);
+        }
+    }
+    /**
+     * Replace this document's contents **in place** from a versioned storage
+     * DTO string — the mutating twin of the static
+     * [`fromJson`](Document::from_json) constructor. Parse-time `warnings` are
+     * cleared. Throws (leaving the document unchanged) on an invalid DTO.
+     *
+     * The cross-WASM-memory `Document` bridge: mutate a document on a
+     * backend-memory clone, then write the mutated state back into the caller's
+     * canonical document with this — the one way to update a live handle across
+     * the linear-memory seam without the caller re-binding its variable.
+     * @param {string} json
+     */
+    loadJson(json) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_loadJson(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);
+        }
+    }
     /**
      * The document's main (entry) card. Allocates and serializes on each
      * call — cache locally if read in a hot loop.
@@ -295,11 +583,40 @@ export class Document {
         }
     }
     /**
-     * Append a card to the end of the card list. Accepts a `Card` (the shape
-     * returned by `cards` / `removeCard` / `quill.seedCard`); build a fresh
-     * one with [`Document.makeCard`](Document::make_card). Throws if
-     * `card.kind` is not a valid kind name.
-     * @param {Card} card
+     * `new Document(quillRef)` — a blank document: a main card carrying only
+     * `$quill`, an empty body, and no composable cards. The programmatic
+     * blank canvas: absent fields resolve at render time (`default`, else
+     * type-empty zero), so nothing the caller did not set reaches the
+     * output. For an example-filled starter use `Quill.seedDocument()`.
+     * Throws on an invalid quill reference. Mirrors Python `Document(quill_ref)`.
+     * @param {string} quill_ref
+     */
+    constructor(quill_ref) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(quill_ref, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_new(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);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            DocumentFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            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 {
@@ -542,12 +859,57 @@ export class Document {
         }
     }
     /**
+     * **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) {
-        const ptr0 = passStringToWasm0(body, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.document_replaceBody(this.__wbg_ptr, ptr0, len0);
+        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
+     * 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
+     * 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
+     * @param {string} markdown
+     * @returns {Delta}
+     */
+    revise(addr, markdown) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_revise(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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * Read the `schema` version tag from a raw storage DTO string without a
@@ -618,6 +980,50 @@ export class Document {
             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
+     */
+    setCardField(index, name, value) {
+        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_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));
+            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);
+        }
+    }
     /**
      * Replace the kind of the card at `index`. Payload and body are untouched;
      * schema-aware migration is the caller's responsibility.
@@ -705,6 +1111,28 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * 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
+     */
+    setFields(fields) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_setFields(retptr, this.__wbg_ptr, addHeapObject(fields));
+            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);
+        }
+    }
     /**
      * Update a payload field on the main card and mark it as `!must_fill`.
      * Throws on invalid name (see [`setField`](Document::set_field)).
@@ -831,48 +1259,6 @@ export class Document {
         const ret = wasm.document_tryFromJson(ptr0, len0);
         return ret === 0 ? undefined : Document.__wrap(ret);
     }
-    /**
-     * Replace the body of the card at `index`. Throws if out of range.
-     * @param {number} index
-     * @param {string} body
-     */
-    updateCardBody(index, 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_updateCardBody(retptr, this.__wbg_ptr, index, 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);
-        }
-    }
-    /**
-     * Update a field on the card at `index`.
-     * Throws if `index` is out of range, `name` is reserved or invalid.
-     * @param {number} index
-     * @param {string} name
-     * @param {any} value
-     */
-    updateCardField(index, name, value) {
-        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_updateCardField(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);
-        }
-    }
     /**
      * @returns {Diagnostic[]}
      */
@@ -1003,9 +1389,10 @@ export class Quill {
     }
     /**
      * Document schema for the quill: the user-fillable fields plus their
-     * `ui` hints (group / order / showWhen). The single field-metadata
-     * surface — drives form editors and LLM/MCP consumers alike. Returns the
-     * `QuillSchema` shape.
+     * `ui` hints (title / group / compact / multiline). The single
+     * field-metadata surface — drives form editors and LLM/MCP consumers
+     * alike. Key order in `fields`/`properties` is declaration order — the
+     * ordering contract. Returns the `QuillSchema` shape.
      * @returns {QuillSchema}
      */
     get schema() {
@@ -1113,10 +1500,10 @@ export class Quill {
      *
      * Forwards the canonical `validation::*` diagnostics — same `code`,
      * `path`, and `hint` the engine emits — including the non-fatal
-     * `validation::field_absent` completeness signal that `render` demotes.
-     * Field values, defaults, and order are not part of this surface: read
-     * them from the `Document` payload and `Quill.schema` (fields carry
-     * `ui.order`).
+     * `validation::must_fill` warning for each `!must_fill` marker left in
+     * the document. Field values, defaults, and order are not part of this
+     * surface: read them from the `Document` payload and `Quill.schema`
+     * (schema key order is display order).
      * @param {Document} doc
      * @returns {Diagnostic[]}
      */
@@ -1139,16 +1526,132 @@ 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
+ * @returns {string}
+ */
+export function exportMarkdown(rt) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.exportMarkdown(retptr, addHeapObject(rt));
+        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 `RichText` corpus — 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}
+ */
+export function importMarkdown(markdown) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.importMarkdown(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);
+    }
+}
+
 /**
  * Initialize the WASM module with panic hooks for better error messages
  */
 export function init() {
     wasm.init();
 }
+
+/**
+ * Map a base corpus 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`.
+ * @param {Delta} delta
+ * @param {number} pos
+ * @param {Assoc} assoc
+ * @returns {number}
+ */
+export function mapPos(delta, pos, assoc) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.mapPos(retptr, addHeapObject(delta), pos, addHeapObject(assoc));
+        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);
+    }
+}
+
+/**
+ * Rebase `markdown` onto a `base` corpus — the pure, document-free twin of
+ * `revise`: cold-import + `diff_import`, returning the new `corpus` 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
+ * @param {string} markdown
+ * @returns {{ corpus: RichText; delta: Delta }}
+ */
+export function rebase(base, markdown) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.rebase(retptr, addHeapObject(base), 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);
+    }
+}
 export function __wbg_Error_960c155d3d49e4c2(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
 }
+export function __wbg_Number_32bf70a599af1d4b(arg0) {
+    const ret = Number(getObject(arg0));
+    return ret;
+}
 export function __wbg_String_8564e559799eccda(arg0, arg1) {
     const ret = String(getObject(arg1));
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);