@quillmark/wasm 0.103.0 → 0.105.0

package/backends/pdfform/wasm.js

@@ -24,16 +24,12 @@ export class Document {
     /**
      * Build a composable card of `kind`, typed-commit `fields` onto it, set its
      * 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`.
+     * `at` absent appends, a number inserts at that index (`0..=cards.length`).
+     * Transactional: 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
+     * bundle as [`commitFields`](Self::commit_fields); an invalid kind or body,
+     * or a bad position, throws a single-entry bundle keyed `$kind` / `$body`.
      * @param {Quill} quill
      * @param {string} kind
      * @param {Record<string, unknown>} [fields]
@@ -60,26 +56,22 @@ export class Document {
     }
     /**
      * 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.
+     * `quill`: the stable ABI under the runtime `writer.set`. One verb for every
+     * field type; the schema carries the `inline` constraint, so no type token
+     * is passed. A richtext-typed field stores canonical content, so identity
+     * marks (anchors, island ids) and content-only marks survive compiles and
+     * the storage DTO. Values use the encoding the seam already speaks: content
+     * object or markdown string for richtext, scalar/array/object otherwise.
      *
-     * 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.reviseBody`
-     * / `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_coercion_failed` /
-     * `edit::field_decode` / `edit::field_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.
+     * A bare string is `Addr` shorthand for `{ field }`. A body address throws,
+     * having no field schema. A declared field is strict-committed, so a
+     * mismatch throws now rather than at render, and an undeclared name throws
+     * `edit::unknown_field` rather than falling to the opaque store — use
+     * [`storeField`](Document::store_field) for that. Also throws
+     * `edit::field_coercion_failed` / `edit::field_decode` /
+     * `edit::field_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.
@@ -103,15 +95,12 @@ export class Document {
     }
     /**
      * 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.
+     * several fields on the card `addr` targets atomically. `addr` is a **card
+     * address** (absent = main; a present `field` throws). Same per-field
+     * diagnostic contract as [`storeFields`](Document::store_fields) — nothing
+     * applied on error, one `diagnostics` entry per offending field, including
+     * `edit::unknown_field` for undeclared names. Throws on an out-of-range
+     * card.
      * @param {Quill} quill
      * @param {CardAddr} addr
      * @param {Record<string, unknown>} fields
@@ -132,21 +121,17 @@ export class Document {
     }
     /**
      * Interpreted read at `addr`, resolving the field's declared `type` from
-     * `quill`: the stable ABI under the runtime `reader.get` / `reader.card(i).get`.
-     * The schema-plane twin of the quill-free [`getStored`](Self::get_stored): a `richtext`
-     * field returns its markdown projection, every other declared type its
-     * canonical value verbatim, so a consumer holding the quill reads by field
-     * meaning rather than by wire shape.
+     * `quill`: the stable ABI under the runtime `reader.get`. The schema-plane
+     * twin of [`getStored`](Self::get_stored) — a `richtext` field returns its
+     * markdown projection, every other declared type its canonical value
+     * verbatim.
      *
      * 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 [`bodyMarkdown`](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 `bodyMarkdown`
-     * lacks: there an unknown name reads back `undefined`); a `richtext` field
-     * holding a value that does not decode throws `edit::field_decode`;
-     * an out-of-range `addr.card` throws.
+     * targets a composable card. An **absent** field returns `undefined`, and an
+     * absent `addr.field` reads the body markdown. An undeclared name throws
+     * `edit::unknown_field` (the authority `bodyMarkdown` lacks), a `richtext`
+     * value that does not decode throws `edit::field_decode`, and 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.
@@ -172,25 +157,19 @@ export class Document {
     }
     /**
      * Interpreted **`Content`** read at `addr`: the stable ABI under the runtime
-     * `reader.getContent` / `reader.card(i).getContent`. The `Content` twin of
-     * [`reader.get`](Self::reader_get), which projects; this decodes the stored
-     * value through the codec the field's declared type names (`richtext` as
-     * markdown, `plaintext` as literal text) and returns the canonical `Content`.
+     * `reader.getContent`. Where [`reader.get`](Self::reader_get) projects, this
+     * decodes the stored value through the codec the field's declared type names
+     * and returns canonical `Content`. Total over the storage form: a committed
+     * field and a parsed one both read back as a `Content`, so a content editor
+     * stops branching on how the document was built.
      *
-     * Total over the storage form: a committed field holds a content object and
-     * a parsed one holds the authored string, and both read back as a `Content`
-     * here, so a consumer mounting a content editor stops branching on how the
-     * document was built.
-     *
-     * A bare string is `Addr` shorthand for `{ field }`; `{ card, field }`
-     * targets a composable card. Returns `undefined` for an **absent** field. An
-     * absent `addr.field` reads the **body** `Content`, quill-free, mirroring
-     * [`getStored`](Self::get_stored). Throws `edit::unknown_field` for a name
-     * the schema does not declare, `edit::field_not_content` for a declared type
-     * that is not a content leaf (`array<richtext>` carries content and still has
-     * no one `Content`), `edit::field_decode` for a stored value
-     * that decodes under neither encoding, and `edit::index_out_of_range` for a
-     * bad `addr.card`.
+     * A bare string is `Addr` shorthand for `{ field }`. An **absent** field
+     * returns `undefined`, and an absent `addr.field` reads the body `Content`.
+     * Throws `edit::unknown_field` for an undeclared name,
+     * `edit::field_not_content` for a declared type that is not a content leaf
+     * (`array<richtext>` carries content and still has no one `Content`),
+     * `edit::field_decode` for a value that decodes under neither encoding, and
+     * `edit::index_out_of_range` for a bad `addr.card`.
      * @param {Quill} quill
      * @param {Addr | string} addr
      * @returns {Content | undefined}
@@ -212,23 +191,59 @@ export class Document {
         }
     }
     /**
-     * Revise the content field at `addr` from authored text, 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_not_inline`. Returns the
-     * text `Delta`.
+     * Interpreted **`Content`** read of a value nested inside the composite
+     * field at `addr`: the stable ABI under the runtime `reader.getContentAt`,
+     * and [`reader.getContent`](Self::reader_get_content) with the path spelled
+     * out. `path` is a `PathStep[]` from the field to the leaf — `[0]` an
+     * element of an `array<richtext>`, `["motto"]` an `object`'s content
+     * property, `[1, "notes"]` a leaf under both.
+     *
+     * The codec is the leaf's declared type's, so the caller stops deciding
+     * what an element's stored bytes mean. Total over the storage form, as the
+     * whole-field read is.
      *
-     * The codec is the declared type's: `richtext` diffs markdown, `plaintext`
-     * the literal text.
+     * `undefined` when the field is absent **and when `path` names nothing in
+     * the stored value**: a repeater's row index goes stale between derive and
+     * read, and absence there is a read, not a fault. Throws
+     * `edit::unknown_field` for an undeclared name at any depth,
+     * `edit::field_not_content` when `path` resolves to no content leaf,
+     * `edit::field_decode` for a value that decodes under neither encoding
+     * (anchored at the addressed path), and `edit::index_out_of_range` for a
+     * bad `addr.card`. A body address throws: a body has no nested content
+     * address.
+     * @param {Quill} quill
+     * @param {Addr | string} addr
+     * @param {PathStep[]} path
+     * @returns {Content | undefined}
+     */
+    _readerGetContentAt(quill, addr, path) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            wasm.document__readerGetContentAt(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), addHeapObject(path));
+            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);
+        }
+    }
+    /**
+     * Revise the content field at `addr` from authored text, typed *and*
+     * anchor-preserving: the ABI under `writer.reviseField`. Surviving anchors
+     * rebase as in [`revise`](Self::revise), then the diffed result is
+     * schema-conformed, so a `richtext(inline)` field rejects a multi-block
+     * result with `edit::field_not_inline`. Returns the text `Delta`. The codec
+     * is the declared type's: `richtext` diffs markdown, `plaintext` literal
+     * text.
      *
-     * `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.
+     * `addr` must name a field; a body address throws, since a body carries no
+     * field schema (use [`revise`](Self::revise)). An undeclared name throws
+     * `edit::unknown_field`, an out-of-range card throws.
      * @param {Quill} quill
      * @param {Addr | string} addr
      * @param {string} text
@@ -253,19 +268,16 @@ export class Document {
         }
     }
     /**
-     * **Apply** a committed content edit `bundle`
-     * (`{ delta?, islandOps?, lineOps?, markOps? }`) at `addr`, the editor
-     * splice: text delta first, then island ops, 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.
-     *
-     * The island channel keeps a table or image edit on the op path: it moves
-     * the island alone, so the anchors elsewhere in the field survive an edit
+     * **Apply** a committed content edit `bundle` at `addr`, the editor splice:
+     * text delta first, then island ops, then line ops, then mark ops (mark
+     * ranges in final-text coordinates), all-or-nothing. An absent `addr.field`
+     * targets the body, an absent `addr.card` the main card. The island channel
+     * moves an island alone, so anchors elsewhere in the field survive an edit
      * `overwrite` would clear.
      *
      * 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).
+     * bundle, or an op that applies out of bounds; the value is unchanged on a
+     * failed apply.
      * @param {Addr | string} addr
      * @param {ChangeBundle} bundle
      */
@@ -283,10 +295,8 @@ 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.
+     * Authoring-ergonomics header introducing a blueprint to an LLM/MCP consumer
+     * for the given `quillName`, re-exposed from core.
      * @param {string} quill_name
      * @returns {string}
      */
@@ -309,15 +319,13 @@ export class Document {
         }
     }
     /**
-     * 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.
+     * The **body** markdown projection: an 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, and 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. An out-of-range `addr.card` throws.
+     * `addr` is an optional card address (absent = main). A present `field`
+     * throws: read a field's markdown through `quill.reader(doc).get(field)`,
+     * which interprets by declared type. An out-of-range `addr.card` throws.
      * @param {CardAddr} [addr]
      * @returns {string}
      */
@@ -337,11 +345,9 @@ export class Document {
         }
     }
     /**
-     * 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.
+     * A single composable card by index, so reading one need not materialize
+     * every card via [`cards`](Self::cards). An out-of-range `index` throws
+     * `edit::index_out_of_range`.
      * @param {number} index
      * @returns {Card}
      */
@@ -361,13 +367,37 @@ export class Document {
         }
     }
     /**
-     * Number of composable cards (excludes the main card). O(1).
+     * Number of composable cards, excluding the main card.
      * @returns {number}
      */
     get cardCount() {
         const ret = wasm.document_cardCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * The composable card's own path, `cards.<kind>[index]`: the root
+     * [`pathFor`](Self::path_for) extends, for anchoring the card rather than
+     * one of its fields. Total on the index axis; out of range renders
+     * `cards[index]`.
+     * @param {number} index
+     * @returns {string}
+     */
+    cardPath(index) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_cardPath(retptr, this.__wbg_ptr, index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * @returns {Card[]}
      */
@@ -394,9 +424,8 @@ export class Document {
         return Document.__wrap(ret);
     }
     /**
-     * Storage version this build writes via [`toJson`](Document::to_json).
-     * Tracks the `Document` model version (not the running crate version):
-     * the tag advances only when the wire format changes, not on every release.
+     * Storage version this build writes via [`toJson`](Document::to_json). The
+     * tag advances only when the wire format changes, not on every release.
      * @returns {string}
      */
     static currentStorageVersion() {
@@ -416,8 +445,7 @@ export class Document {
         }
     }
     /**
-     * Structural equality (parse-time `warnings` excluded). Use to debounce
-     * upstream prop updates instead of re-parsing on every keystroke.
+     * Structural equality, excluding parse-time `warnings`.
      * @param {Document} other
      * @returns {boolean}
      */
@@ -427,9 +455,8 @@ export class Document {
         return ret !== 0;
     }
     /**
-     * Render a Diagnostic as the canonical pretty-printed text (core's
-     * `Diagnostic::fmt_pretty`). Single source of truth so a Diagnostic looks
-     * identical no matter which consumer surfaces it.
+     * Render a Diagnostic as the canonical pretty-printed text, so it looks
+     * identical whichever consumer surfaces it.
      * @param {Diagnostic} diag
      * @returns {string}
      */
@@ -450,11 +477,8 @@ export class Document {
         }
     }
     /**
-     * Authoring-format rules for the card-yaml markdown surface. The canonical
-     * text is core's (`quillmark_core::document::FORMAT_RULES`), re-exposed
-     * here for JS consumers so it matches any other surface that draws from the
-     * same source. Read once at startup and cache; the value never changes
-     * between calls.
+     * Authoring-format rules for the card-yaml markdown surface, re-exposed from
+     * core. Constant across calls; read once and cache.
      * @returns {string}
      */
     static formatRules() {
@@ -474,10 +498,8 @@ export class Document {
         }
     }
     /**
-     * Reconstruct a `Document` from a versioned storage DTO string produced
-     * by [`toJson`](Document::to_json). Unknown `schema` tags are rejected.
-     * The result carries no parse-time warnings (`.warnings` is always empty).
-     *
+     * Reconstruct a `Document` from a versioned storage DTO string produced by
+     * [`toJson`](Document::to_json). The result carries no parse-time warnings.
      * Throws if `json` is not a valid storage DTO (malformed JSON, unknown
      * `schema`, missing fields, or unparseable quill reference).
      * @param {string} json
@@ -524,9 +546,9 @@ export class Document {
     }
     /**
      * 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.
+     * `undefined` when the card carries none: the `$ext` read that avoids
+     * serializing the whole card. Throws on a present `field` or an
+     * out-of-range card.
      * @param {CardAddr} [addr]
      * @returns {Record<string, unknown> | undefined}
      */
@@ -547,9 +569,8 @@ export class Document {
     }
     /**
      * 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.
+     * = main), or `undefined`. Throws on a present `field` or an out-of-range
+     * card.
      * @param {CardAddr} addr
      * @param {string} ns
      * @returns {unknown}
@@ -572,25 +593,20 @@ export class Document {
         }
     }
     /**
-     * Read the **verbatim stored value** at `addr`: the raw payload value of a
-     * field, or the **body content** when `addr.field` is absent. A bare
-     * string is `Addr` shorthand for `{ field }`. Reads are total over the field
-     * axis: an absent field is `undefined`; only an out-of-range `addr.card`
-     * throws `edit::index_out_of_range`. Needs no schema, so it lives on
-     * `Document`: the read echo of the verbatim `store*` write, distinct from
-     * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
-     * markdown projection use [`bodyMarkdown`](Self::get_markdown) (body) or
-     * `reader.get` (a field's declared type).
+     * Read the **verbatim stored value** at `addr`: a field's raw payload value,
+     * or the body content when `addr.field` is absent. A bare string is `Addr`
+     * shorthand for `{ field }`. Needs no schema: the read echo of the verbatim
+     * `store*` write, distinct from the interpreted
+     * [`reader.get`](Self::reader_get). Reads are total over the field axis — an
+     * absent field is `undefined` — and only an out-of-range `addr.card` throws
+     * `edit::index_out_of_range`.
      *
-     * **A content field at rest has one stored form per codec**: a `richtext`
-     * field holds the canonical content object, a `plaintext` field its literal
-     * string. A document that came through the bound door (`quill.parse` /
-     * `quill.conform`) is at rest, so this read no longer depends on which lane
-     * built it. A document that came through the transport door
-     * (`Document.fromMarkdown`, a legacy stored row) may rest as authored until
-     * it is conformed, and this read reports what is there. For the `Content`
-     * either way, use the schema-plane `reader.getContent`, which decodes
-     * through the codec the field's declared type names.
+     * A content field at rest has one stored form per codec: a `richtext` field
+     * holds the canonical content object, a `plaintext` field its literal
+     * string. A document from the bound door (`quill.parse` / `quill.conform`)
+     * is at rest; one from the transport door may rest as authored until it is
+     * conformed, and this read reports what is there. For the `Content` either
+     * way use `reader.getContent`.
      * @param {Addr | string} addr
      * @returns {unknown}
      */
@@ -610,12 +626,10 @@ export class Document {
         }
     }
     /**
-     * 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.
+     * Insert a card: `at` absent appends, a number inserts at that index (in
+     * `0..=cards.length`). Accepts any `CardInput`, including a card read back
+     * out of a document. Throws if `card.kind` is not a valid kind name, or if
+     * `at` is out of range.
      * @param {CardInput} card
      * @param {number} [at]
      */
@@ -634,9 +648,8 @@ export class Document {
     }
     /**
      * 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.
+     * shorthand for `{ field }`. `false` for an absent field and for a body
+     * address; only an out-of-range `addr.card` throws.
      * @param {Addr | string} addr
      * @returns {boolean}
      */
@@ -656,15 +669,14 @@ export class Document {
         }
     }
     /**
-     * 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.
+     * Replace this document's contents **in place** from a versioned storage DTO
+     * string: the mutating twin of [`fromJson`](Document::from_json). Parse-time
+     * `warnings` are cleared. Throws on an invalid DTO, leaving the document
+     * unchanged.
      *
      * 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.
+     * backend-memory clone, then write the state back into the caller's
+     * canonical document, without the caller re-binding its variable.
      * @param {string} json
      */
     loadJson(json) {
@@ -683,8 +695,7 @@ export class Document {
         }
     }
     /**
-     * The document's main (entry) card. Allocates and serializes on each
-     * call: cache locally if read in a hot loop.
+     * The document's main (entry) card. Allocates and serializes on each call.
      * @returns {Card}
      */
     get main() {
@@ -704,17 +715,12 @@ export class Document {
     }
     /**
      * Build a fresh `Card` from a kind and a flat field map: the ergonomic
-     * constructor for `insertCard`. `fields` is an optional
-     * `Record<string, unknown>` (each entry becomes a card field, in
-     * insertion order); `body` defaults to `""`.
+     * constructor for `insertCard`, which also takes any `Card` object
+     * directly. Each `fields` entry becomes a card field in insertion order;
+     * `body` defaults to `""`.
      *
-     * Sugar, not a required step: `insertCard` takes any `Card` object, and
-     * `removeCard` returns one, so a card round-trips without passing through
-     * here.
-     *
-     * Checks only what a detached card can decide alone: field-name grammar
-     * and value depth. Kind validity is positional (`main` is right for the
-     * root, reserved for a composable card) so `insertCard` is its gate, and
+     * Checks only what a detached card can decide alone: field-name grammar and
+     * value depth. Kind validity is positional, so `insertCard` is its gate and
      * any kind string is accepted here.
      * @param {string} kind
      * @param {Record<string, unknown>} [fields]
@@ -759,12 +765,11 @@ export class Document {
         }
     }
     /**
-     * `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)`.
+     * A blank document: a main card carrying only `$quill`, an empty body, and
+     * no composable cards. Absent fields resolve at render time (`default`, else
+     * the field's blank), so nothing the caller did not set reaches the output.
+     * For an example-filled starter use `Quill.seedDocument()`. Throws on an
+     * invalid quill reference.
      * @param {string} quill_ref
      */
     constructor(quill_ref) {
@@ -787,15 +792,11 @@ export class Document {
         }
     }
     /**
-     * **Overwrite** the content value at `addr`: **value semantics**, content
-     * only. Stores exactly `rt` (a canonical `Content` content object); the
-     * identity anchors of any previous value are gone. The bottom rung of the
-     * content lane's ladder by anchor fate: `overwrite` destroys,
-     * [`revise`](Document::revise) rebases,
-     * [`applyChange`](Document::apply_change) preserves. An absent `addr.field`
-     * targets the body, an absent `addr.card` the main card. Cold-importing
-     * markdown is spelled `overwrite(addr, importMarkdown(md))` at the call
-     * site, where the anchor loss is visible.
+     * **Overwrite** the content value at `addr` with exactly `rt`: value
+     * semantics, so the identity anchors of any previous value are gone. By
+     * anchor fate `overwrite` destroys, [`revise`](Document::revise) rebases,
+     * and [`applyChange`](Document::apply_change) preserves. An absent
+     * `addr.field` targets the body, an absent `addr.card` the main card.
      *
      * Throws on an out-of-range card, a malformed field name, or an `rt` that is
      * not a canonical content object.
@@ -815,6 +816,47 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * `addr`'s canonical `DocPath` string, the anchor `Diagnostic.path` carries:
+     * `pathFor()` is `main.body`, `pathFor("intro")` `main.intro`,
+     * `pathFor({card: 2})` `cards.<kind>[2].body`.
+     *
+     * The kind is the card's stored `$kind` verbatim, not `validate`'s
+     * declared-kind filter, since a `Document` holds a `$quill` reference and no
+     * schema. That is the one edge where this path and a `validate` diagnostic
+     * path differ for the same card.
+     *
+     * **Total on the index axis**, unlike the `Addr` reads, which throw there:
+     * an out-of-range `{card: 7, field: "from"}` renders `cards[7].from`, which
+     * parses back and resolves to nothing rather than mis-targeting. Only a
+     * malformed address throws.
+     * @param {Addr | string} addr
+     * @returns {string}
+     */
+    pathFor(addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_pathFor(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);
+            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);
+        }
+    }
     /**
      * @returns {string}
      */
@@ -835,11 +877,9 @@ export class Document {
         }
     }
     /**
-     * The canonical `$quill` reference grammar as author-facing text. Core is
-     * the single source of truth: drive schema `describe` and validation
-     * messages from this instead of re-stating the rule; it matches the
-     * `hint` on `parse::invalid_quill_reference`. Cache it; the value never
-     * changes.
+     * The canonical `$quill` reference grammar as author-facing text: the same
+     * text the `parse::invalid_quill_reference` hint carries. Drive validation
+     * messages from this instead of re-stating the rule.
      * @returns {string}
      */
     static quillRefHint() {
@@ -878,10 +918,9 @@ export class Document {
         }
     }
     /**
-     * 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.
+     * Remove the `$ext` map on the card `addr` targets entirely, returning the
+     * previous map or `undefined`. Discards every namespace at once; prefer
+     * `removeExtNamespace`. Throws on a present `field` or an out-of-range card.
      * @param {CardAddr} [addr]
      * @returns {Record<string, unknown> | undefined}
      */
@@ -928,9 +967,8 @@ export class Document {
     }
     /**
      * 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.
+     * bare string is `Addr` shorthand for `{ field }`. A body address throws, as
+     * does an out-of-range card or a malformed name.
      * @param {Addr | string} addr
      * @returns {any}
      */
@@ -950,9 +988,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. `$seed` is main-only, so this takes no address.
+     * Remove `cardKind` from the main card's `$seed` map, returning its overlay
+     * or `undefined`; drops `$seed` entirely once empty. Sibling kinds survive.
      * @param {string} card_kind
      * @returns {any}
      */
@@ -974,12 +1011,12 @@ export class Document {
         }
     }
     /**
-     * **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.
+     * **Revise** the richtext value at `addr` from a markdown string: the
+     * default write path. Imports the markdown, diffs it against the current
+     * value, rebases surviving identity anchors, and returns the text `Delta` 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-content field value, or an over-nested markdown input.
@@ -1005,11 +1042,9 @@ export class Document {
         }
     }
     /**
-     * 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.
+     * The main card's `$seed[kind]` overlay object, or `undefined`. Feeds
+     * `quill.seedCard(kind, overlay)` without serializing the whole main card,
+     * and keeps `seedCard` pure: the quill never reads the document.
      * @param {string} kind
      * @returns {Record<string, unknown> | undefined}
      */
@@ -1072,15 +1107,11 @@ export class Document {
         }
     }
     /**
-     * Read the storage version tag from a raw storage DTO string without a
-     * full parse, or `undefined`. Returns unknown future versions as-is:
-     * useful to distinguish "build too old" from "payload corrupt" when
-     * `fromJson` throws.
-     *
-     * The storage version, not a field schema ([`schema`](Quill::schema) is the
-     * quill's field declarations). The JSON key is spelled `"schema"`: it is
-     * the DTO's serde tag, and retagging it would break the version dispatch
-     * it drives.
+     * Read the storage version tag from a raw storage DTO string without a full
+     * parse, or `undefined`. Unknown future versions come back as-is, which
+     * distinguishes "build too old" from "payload corrupt" when `fromJson`
+     * throws. This is the storage version, not a field schema, though the JSON
+     * key is spelled `"schema"`: that is the DTO's serde tag.
      * @param {string} json
      * @returns {string | undefined}
      */
@@ -1103,11 +1134,10 @@ export class Document {
         }
     }
     /**
-     * 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.
+     * Replace the opaque `$ext` map on the card `addr` targets (absent `card` =
+     * main). `value` must be a plain object. `$ext` carries out-of-band consumer
+     * state and never reaches the rendered output. Throws on a present `field`
+     * or an out-of-range card.
      * @param {CardAddr} addr
      * @param {any} value
      */
@@ -1126,9 +1156,8 @@ export class Document {
     }
     /**
      * 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.
+     * sibling namespaces: the recommended `$ext` write. Throws on a present
+     * `field` or an out-of-range card.
      * @param {CardAddr} addr
      * @param {string} ns
      * @param {any} value
@@ -1149,14 +1178,12 @@ export class Document {
         }
     }
     /**
-     * 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` / `overwrite` / `writer.reviseBody`. Throws on
-     * an out-of-range card or a malformed name.
+     * Store a field verbatim at `addr`, deferring coercion to render; the typed
+     * write is [`commitField`](Document::commit_field). A bare string is `Addr`
+     * shorthand for `{ field }`; `{ card: 2, field: "qty" }` targets a
+     * composable card. Clears any `!must_fill` marker. A body address throws:
+     * write a body with `revise` / `overwrite`. Throws on an out-of-range card
+     * or a malformed name.
      * @param {Addr | string} addr
      * @param {any} value
      */
@@ -1174,14 +1201,11 @@ export class Document {
         }
     }
     /**
-     * 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.
+     * Store several fields verbatim and atomically on the card `addr` targets.
+     * `addr` is a **card address** (`{ card }`, absent = main) and comes first
+     * because `card` is itself a legal field name; a present `field` throws.
+     * Nothing is applied on error, and 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
      */
@@ -1199,10 +1223,8 @@ export class Document {
         }
     }
     /**
-     * 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).
+     * Store a field verbatim at `addr` and mark it `!must_fill`. A body address
+     * throws; same validation as [`storeField`](Document::store_field).
      * @param {Addr | string} addr
      * @param {any} value
      */
@@ -1221,10 +1243,9 @@ export class Document {
     }
     /**
      * 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.
+     * under `cardKind`, preserving sibling kinds; `$seed` is main-only, so this
+     * takes no address. Sets the starting values new cards of that kind spawn
+     * with. Throws if `overlay` cannot be serialized or nests too deep.
      * @param {string} card_kind
      * @param {any} overlay
      */
@@ -1244,14 +1265,10 @@ export class Document {
         }
     }
     /**
-     * Serialize this document to a versioned storage DTO string.
-     *
-     * Prefer this over `toMarkdown` for persistence across restarts or crate
-     * upgrades: the wire format is frozen per `schema` version. Parse-time
-     * `warnings` are excluded from the DTO.
-     *
-     * Output is **byte-deterministic** within a `schema` version: equal
-     * documents produce byte-equal output, safe for content-hash use cases.
+     * Serialize this document to a versioned storage DTO string. Prefer it over
+     * `toMarkdown` for persistence: the wire format is frozen per `schema`
+     * version and the output is byte-deterministic within one, so equal
+     * documents hash equal. Parse-time `warnings` are excluded.
      * @returns {string}
      */
     toJson() {
@@ -1292,11 +1309,9 @@ export class Document {
         }
     }
     /**
-     * Like [`fromJson`](Document::from_json) but returns `undefined` instead
-     * of throwing when `json` is not a valid storage DTO: use to
-     * discriminate format without exceptions as control flow.
-     * `undefined` means "not a storage DTO"; `fromMarkdown` still throws on
-     * genuinely malformed markdown.
+     * Like [`fromJson`](Document::from_json) but returns `undefined` instead of
+     * throwing when `json` is not a valid storage DTO, to discriminate format
+     * without exceptions as control flow.
      * @param {string} json
      * @returns {Document | undefined}
      */
@@ -1308,9 +1323,9 @@ export class Document {
     }
     /**
      * The non-fatal diagnostics of the load that produced this document: parse
-     * warnings, plus the `conform::*` warnings when it came through
-     * `quill.parse`. Session state, not document value: `equals` and the
-     * storage DTO exclude it, and `fromJson` / `loadJson` clear it.
+     * warnings, plus `conform::*` warnings when it came through `quill.parse`.
+     * Session state, not document value: `equals` and the storage DTO exclude
+     * it, and `fromJson` / `loadJson` clear it.
      * @returns {Diagnostic[]}
      */
     get warnings() {
@@ -1332,17 +1347,14 @@ export class Document {
 if (Symbol.dispose) Document.prototype[Symbol.dispose] = Document.prototype.free;
 
 /**
- * Live render session: reads (`render`, `paint`, `pageSize`, `regions`,
- * `fieldAt`, `positionAt`, `locate`) serve the current compile. `apply(doc)`
- * recompiles a whole document in place, transactionally (on throw every read
- * keeps serving the last-good compile). Geometry reads reflect the current
- * compile; anchoring a caret across edits is the editor's job: re-read
- * geometry after each committed `apply`.
+ * Live render session: every read serves the current compile. `apply(doc)`
+ * recompiles a whole document in place, transactionally — on throw the reads
+ * keep serving the last-good compile. Geometry is per-compile, so re-read it
+ * after each committed `apply`.
  *
- * **Empty documents.** A zero-page document yields a valid session
- * (`pageCount === 0`); `paint(ctx, 0)` or `pageSize(0)` throws with
- * `"page index 0 out of range (pageCount=0)"`. Branch on `pageCount === 0`
- * rather than catching the error.
+ * A zero-page document yields a valid session (`pageCount === 0`) whose
+ * `paint(ctx, 0)` and `pageSize(0)` throw; branch on `pageCount === 0` rather
+ * than catching.
  */
 export class LiveSession {
     static __wrap(ptr) {
@@ -1383,15 +1395,12 @@ export class LiveSession {
         }
     }
     /**
-     * The schema field whose content is under a point on `page`, the
-     * forward (click → field) direction: hit-test a click against the
-     * compiled document and get back the `DocPath` field address to focus in
-     * the editor, or `undefined` off any field's ink. `x`/`y` are PDF points
-     * with a **bottom-left** origin, the same space as `FieldRegion.rect`,
-     * from a canvas click, invert the overlay transform documented on
-     * `FieldRegion`: `x = clickPx.x / renderScale`,
-     * `y = pageHeightPt - clickPx.y / renderScale`. Unlike `regions()`,
-     * *every* placement answers, not just the first.
+     * The schema field whose content is under a point on `page`: the `DocPath`
+     * address to focus in the editor, or `undefined` off any field's ink.
+     * `x`/`y` are PDF points with a **bottom-left** origin, the same space as
+     * `FieldRegion.rect`, so from a canvas click use
+     * `x = clickPx.x / renderScale`, `y = pageHeightPt - clickPx.y / renderScale`.
+     * Unlike `regions()`, *every* placement answers, not just the first.
      * @param {number} page
      * @param {number} x
      * @param {number} y
@@ -1414,15 +1423,11 @@ export class LiveSession {
         }
     }
     /**
-     * The whole-field highlight boxes for `field`: one union rect per page,
-     * over the field's `span`-bearing content segments. The convenience that
-     * owns the union `regions()` leaves derived: it keeps `regions()` the
-     * low-level disjoint truth and folds the span-filter + per-page
-     * union here, so a "highlight the focused field" consumer stops
-     * reimplementing it. **Content only**: a field placed solely as a scalar
-     * reference or a bound widget carries no `span` and returns `[]`; its box
-     * is a single `regions()` rect. Reflects the current compile, like
-     * `regions()`.
+     * The whole-field highlight boxes for `field`: one union rect per page over
+     * the field's `span`-bearing content segments, the union `regions()` leaves
+     * derived. **Content only**: a field placed solely as a scalar reference or
+     * a bound widget carries no `span` and returns `[]`, its box being a single
+     * `regions()` rect. Reflects the current compile.
      * @param {string} field
      * @returns {FieldRegion[]}
      */
@@ -1444,11 +1449,10 @@ export class LiveSession {
         }
     }
     /**
-     * A content position → **caret rect**, the reverse of `positionAt`: given
-     * a field and a USV offset into its `Content`, return the box (in the
-     * same bottom-left PDF-point space as `FieldRegion.rect`) to draw a caret
-     * at, its `span` collapsed to `[pos, pos]`; `undefined` when the field
-     * places no tracked content or the offset maps to no drawn glyph.
+     * A content position → **caret rect**, the reverse of `positionAt`: the box
+     * to draw a caret at, in the same bottom-left PDF-point space as
+     * `FieldRegion.rect`, its `span` collapsed to `[pos, pos]`. `undefined` when
+     * the field places no tracked content or the offset maps to no drawn glyph.
      * @param {string} field
      * @param {number} pos
      * @returns {FieldRegion | undefined}
@@ -1491,17 +1495,16 @@ export class LiveSession {
      * Paint `page` into a `CanvasRenderingContext2D` or
      * `OffscreenCanvasRenderingContext2D`. The painter owns
      * `canvas.width`/`height` (no `clearRect` needed); consumers own
-     * `canvas.style.*`. If `layoutScale * densityScale` exceeds 16384 px
-     * per side, `densityScale` is clamped: `PaintResult.clamped` reports it and
-     * `PaintResult.effectiveDensityScale` carries the density actually applied.
+     * `canvas.style.*`. If `layoutScale * densityScale` exceeds 16384 px per
+     * side, `densityScale` is clamped and `PaintResult` reports it.
      *
      * `put_image_data` writes the whole backing store, bypassing the 2D
-     * context's transform, `globalAlpha`, and clip: the painter owns the entire
-     * canvas, so each visible page needs its own `<canvas>`; you cannot composite
-     * two pages, a sub-rect, or a context transform through this call.
+     * context's transform, `globalAlpha`, and clip, so each visible page needs
+     * its own `<canvas>`: no compositing, sub-rect, or transform reaches through
+     * this call.
      *
-     * Throws if the backend has no canvas painter, `page` is out of range,
-     * `ctx` is the wrong type, or either scale is non-finite or `<= 0`.
+     * Throws if the backend has no canvas painter, `page` is out of range, `ctx`
+     * is the wrong type, or either scale is non-finite or `<= 0`.
      * @param {CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D} ctx
      * @param {number} page
      * @param {PaintOptions | undefined} opts
@@ -1523,14 +1526,11 @@ export class LiveSession {
         }
     }
     /**
-     * A point → **content position**, the fine-grained click direction:
-     * hit-test a point and get back the field *and* a USV offset into its
-     * `Content` (for placing a caret or mapping a selection into the content
-     * model), or `undefined` off all content ink. `x`/`y` are PDF points,
-     * bottom-left origin: the same space as `fieldAt`. The offset is
-     * cluster-exact and degrades to the containing segment's start on
-     * origin-less ink (list markers, a code fence's interior). See
-     * `ContentHit`.
+     * A point → **content position**: the field *and* a USV offset into its
+     * `Content`, for placing a caret or mapping a selection into the content
+     * model, or `undefined` off all content ink. `x`/`y` are PDF points,
+     * bottom-left origin, as in `fieldAt`. The offset is cluster-exact and
+     * degrades to the containing segment's start on origin-less ink.
      * @param {number} page
      * @param {number} x
      * @param {number} y
@@ -1543,13 +1543,10 @@ export class LiveSession {
     /**
      * Schema-field geometry for this compiled session: each content field's
      * **first placement** (one region per page it touches) plus widget and
-     * scalar-reference-site regions, keyed on the canonical `DocPath` address
-     * (`parseDocPath`-routable; the session resolves the backend's plate-space
-     * per-kind ordinal to it); a field may still appear more than once (group
-     * by `field`, see `FieldRegion`). A session-level query: no render, no byte
-     * artifact. An interactive preview reads it to scroll to / highlight the
-     * focused field over a `paint`-ed canvas; the click direction is `fieldAt`.
-     * Empty for backends that place no schema fields.
+     * scalar-reference-site regions, keyed on the canonical `DocPath` address. A
+     * field may appear more than once, so group by `field` (see `FieldRegion`).
+     * A session-level query: no render, no byte artifact. The click direction is
+     * `fieldAt`. Empty for backends that place no schema fields.
      * @returns {FieldRegion[]}
      */
     regions() {
@@ -1587,9 +1584,7 @@ export class LiveSession {
         }
     }
     /**
-     * `true` iff `paint` and `pageSize` will succeed for this session. Derived
-     * from the session's canvas seam, so it reflects exactly what `paint` will
-     * do: no separately captured flag.
+     * `true` iff `paint` and `pageSize` will succeed for this session.
      * @returns {boolean}
      */
     get supportsCanvas() {
@@ -1597,16 +1592,14 @@ export class LiveSession {
         return ret !== 0;
     }
     /**
-     * Recompile the session against `doc`: the edit verb of a live preview.
-     * The document is compiled through the same schema pipeline as `open`
-     * (same quill), then swapped in transactionally: on throw every read
-     * (`render`, `paint`, `pageSize`, `regions`, `fieldAt`) keeps serving the last-good
-     * compile, and the session recovers on the next successful `update`. On
-     * success reads serve the new compile; repaint `dirtyPages ∩ visible`.
+     * Recompile the session against `doc`: the edit verb of a live preview. The
+     * document compiles through the same pipeline as `open`, then swaps in
+     * transactionally — on throw every read keeps serving the last-good compile
+     * and the session recovers on the next successful `update`. On success,
+     * repaint `dirtyPages ∩ visible`.
      *
-     * Distinct from the content lane's [`applyChange`](Document::apply_change),
-     * which splices ops into a document: this one recompiles a whole document
-     * the caller already mutated.
+     * Distinct from [`applyChange`](Document::apply_change), which splices ops
+     * into a document; this recompiles a document the caller already mutated.
      * @param {Document} doc
      * @returns {ChangeSet}
      */
@@ -1627,10 +1620,9 @@ export class LiveSession {
         }
     }
     /**
-     * Non-fatal diagnostics of the session's **current compile** (e.g. Typst
-     * font fallback): set at open and refreshed by each committed `apply`;
-     * a failed apply keeps the last-good compile's warnings. Also appended
-     * to `RenderResult.warnings` on each `render()` call.
+     * Non-fatal diagnostics of the session's **current compile**, refreshed by
+     * each committed `apply`; a failed apply keeps the last-good compile's.
+     * Also appended to `RenderResult.warnings` on each `render()`.
      * @returns {Diagnostic[]}
      */
     get warnings() {
@@ -1670,9 +1662,8 @@ export class Quill {
         wasm.__wbg_quill_free(ptr, 0);
     }
     /**
-     * The *declared* backend identifier (`config.backend`, e.g. `"typst"`).
-     * Intent, not a resolved capability: capability (`supportedFormats` /
-     * `supportsCanvas`) is read from the engine.
+     * The *declared* backend identifier (e.g. `"typst"`): intent, not a
+     * resolved capability. Capability is read from the engine.
      * @returns {string}
      */
     get backendId() {
@@ -1712,19 +1703,15 @@ export class Quill {
     }
     /**
      * Land `doc`'s declared content fields at their canonical rest **in
-     * place**, returning the `conform::*` diagnostics for the values that would
-     * not commit (an empty array when everything rested).
-     *
-     * The read-repair verb: a document that arrived through the transport door
-     * (`fromMarkdown`, `fromJson`, a stored row) converges here, and is then
-     * eligible for rewrite under its current schema tag. Idempotent, and a
-     * no-op on an already-canonical document: an equal value is not rewritten,
-     * so YAML comments and stored bytes survive.
+     * place**, returning the `conform::*` diagnostics for values that would not
+     * commit. The read-repair verb for a document that arrived through the
+     * transport door (`fromMarkdown`, `fromJson`, a stored row).
      *
-     * A `!must_fill` marker anywhere in a field's value skips that field (the
-     * marker is the state), and a value the strict write refuses stays as
-     * authored with a diagnostic. Throws when `doc` declares a different
-     * `$quill`, before any mutation.
+     * Idempotent: an equal value is not rewritten, so YAML comments and stored
+     * bytes survive. A `!must_fill` marker anywhere in a field's value skips
+     * that field, and a value the strict write refuses stays as authored with a
+     * diagnostic. Throws when `doc` declares a different `$quill`, before any
+     * mutation.
      * @param {Document} doc
      * @returns {Diagnostic[]}
      */
@@ -1745,13 +1732,9 @@ export class Quill {
         }
     }
     /**
-     * Build a quill from a file tree. Pure: no backend, no engine; the
-     * declared backend is resolved later, at render time.
-     *
-     * Accepts either a `Map<string, Uint8Array>` or a plain object
-     * (`Record<string, Uint8Array>`). Plain objects are walked via
-     * `Object.entries` at the boundary; the Rust side sees a single
-     * canonical shape.
+     * Build a quill from a file tree. Pure: the declared backend is resolved
+     * later, at render time. Accepts a `Map<string, Uint8Array>` or a plain
+     * object.
      * @param {Map<string, Uint8Array>} tree
      * @returns {Quill}
      */
@@ -1772,9 +1755,8 @@ export class Quill {
     }
     /**
      * Identity snapshot of the `quill:` section of `Quill.yaml` plus any extra
-     * `quill:` keys. Pure config: the backend's output formats are a
-     * resolved-backend capability read from the engine
-     * (`Quillmark.supportedFormats`), not part of this snapshot.
+     * `quill:` keys. Pure config: output formats are a resolved-backend
+     * capability read from `Quillmark.supportedFormats`, not part of this.
      * @returns {QuillMetadata}
      */
     get metadata() {
@@ -1793,18 +1775,16 @@ export class Quill {
         }
     }
     /**
-     * Parse `markdown` and conform it against this quill: the **primary
-     * ingestion path**, and the bound twin of the schema-free
-     * `Document.fromMarkdown`. The returned document rests at its canonical
-     * form (a `richtext` field as a content object, a `plaintext` field as its
-     * literal string), so `getStored` answers "content object or string?" by the
-     * field's declared codec rather than by how the document was built.
+     * Parse `markdown` and conform it against this quill: the primary ingestion
+     * path, and the bound twin of the schema-free `Document.fromMarkdown`. The
+     * returned document rests at its canonical form (a `richtext` field as a
+     * content object, a `plaintext` field as its literal string), so `getStored`
+     * answers by the field's declared codec, not by how the document was built.
      *
      * Parse warnings and the `conform::*` diagnostics both land on
      * `doc.warnings`. Throws on a parse failure, or when `markdown` declares a
-     * `$quill` this quill does not answer to: nothing conforms under the wrong
-     * schema. To open a document whose `$quill` is stale, use the transport
-     * door (`Document.fromMarkdown`, `setQuillRef`, then `quill.conform`).
+     * `$quill` this quill does not answer to. To open a document whose `$quill`
+     * is stale, use `Document.fromMarkdown`, `setQuillRef`, then `quill.conform`.
      * @param {string} markdown
      * @returns {Document}
      */
@@ -1826,15 +1806,11 @@ export class Quill {
         }
     }
     /**
-     * The resolved-value view of `doc` against this quill's schema: for every
-     * declared field the value the render projection would use and the
-     * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
-     * one call. The card body is a `body` sibling on its card (row `name`
-     * `"body"`), never a row in `fields`: `null` when the kind enables no body.
-     *
-     * Value and provenance only: completeness and errors stay `validate`'s
-     * (a consumer merges it with its own diagnostic producers regardless), and
-     * schema guidance reads from `Quill.schema`.
+     * The resolved-value view of `doc`: for every declared field, the value the
+     * render projection would use and the `FieldSource` rung it came from
+     * (`"authored" | "default" | "blank"`). The card body is a `body` sibling on
+     * its card, never a row in `fields`, and `null` when the kind enables no
+     * body. Value and provenance only; completeness stays `validate`'s.
      * @param {Document} doc
      * @returns {Resolved}
      */
@@ -1855,11 +1831,9 @@ export class Quill {
         }
     }
     /**
-     * Document schema for the quill: the user-fillable fields plus their
-     * `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.
+     * Document schema for the quill: the user-fillable fields plus their `ui`
+     * hints. Key order in `fields`/`properties` is declaration order, the
+     * ordering contract.
      * @returns {QuillSchema}
      */
     get schema() {
@@ -1879,15 +1853,13 @@ export class Quill {
     }
     /**
      * Seed a starter composable `Card` of the given kind (carries `$kind`),
-     * 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.insertCard`.
+     * layering an optional per-kind seed `overlay` over the schema-example base
+     * (`overlay › example › absent`). `undefined` when `cardKind` is not
+     * declared in this quill's schema.
      *
      * 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.
+     * for the bare schema seed.
      * @param {string} card_kind
      * @param {Record<string, unknown> | undefined} overlay
      * @returns {Card | undefined}
@@ -1910,12 +1882,10 @@ export class Quill {
         }
     }
     /**
-     * Seed a starter `Document` from the schema, the main card plus one
-     * instance of each composable card kind, each committing its fields'
-     * `example:` values and leaving every other field absent (interpolated at
-     * render: `default:`, else type-empty zero). Illustration-first: a field
-     * with both an `example` and a `default` renders its example. See
-     * `prose/canon/SCHEMAS.md` § "Document seeding".
+     * Seed a starter `Document` from the schema: the main card plus one instance
+     * of each composable card kind, each committing its fields' `example:`
+     * values and leaving every other field absent (interpolated at render as
+     * `default:`, else the field's blank). A field with both renders its example.
      * @returns {Document}
      */
     seedDocument() {
@@ -1924,9 +1894,7 @@ export class Quill {
     }
     /**
      * Seed a starter main `Card` (carries `$quill`) from the schema: the
-     * `$kind: main` card of [`seedDocument`](Self::seed_document) in
-     * isolation, committing each field's `example:` value. Returns the same
-     * `Card` shape as the `Document.main` getter.
+     * `$kind: main` card of [`seedDocument`](Self::seed_document) alone.
      * @returns {Card}
      */
     seedMain() {
@@ -1945,16 +1913,13 @@ export class Quill {
         }
     }
     /**
-     * Flatten this quill back into its canonical file tree: the inverse of
-     * [`fromTree`](Self::from_tree). Round-trips: `Quill.fromTree(q.toTree())`
-     * reproduces an equivalent quill.
+     * Flatten this quill back into its canonical file tree, the inverse of
+     * [`fromTree`](Self::from_tree). Keys are `"/"`-joined relative paths.
      *
      * This is how a quill crosses a WASM linear-memory boundary as data: a
-     * `Quill` built in one build (e.g. the Typst-less `@quillmark/wasm/core`)
-     * cannot be passed to an engine in another (separate linear memories), so
+     * `Quill` built in one build cannot be passed to an engine in another, so
      * `@quillmark/wasm/runtime` re-feeds this tree to the backend build's
-     * `Quill.fromTree` on demand. Keys are `"/"`-joined relative paths,
-     * matching what `fromTree` accepts.
+     * `Quill.fromTree` on demand.
      * @returns {Map<string, Uint8Array>}
      */
     toTree() {
@@ -1963,14 +1928,9 @@ export class Quill {
     }
     /**
      * Validate `doc` against this quill's schema, returning every diagnostic
-     * (an empty array when the document is valid).
-     *
-     * Forwards the canonical `validation::*` diagnostics (same `code`,
-     * `path`, and `hint` the engine emits) including the non-fatal
-     * `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).
+     * (empty when the document is valid). Forwards the canonical
+     * `validation::*` diagnostics the engine emits, including the non-fatal
+     * `validation::must_fill` warning per `!must_fill` marker left behind.
      * @param {Document} doc
      * @returns {Diagnostic[]}
      */
@@ -2064,9 +2024,9 @@ export class Quillmark {
         }
     }
     /**
-     * The output formats `quill`'s backend can emit. Static capability:
-     * resolves the backend but compiles nothing. Throws `engine::backend_not_found`
-     * if no registered backend matches the quill's declared backend.
+     * The output formats `quill`'s backend can emit; resolves the backend but
+     * compiles nothing. Throws `engine::backend_not_found` when no registered
+     * backend matches the quill's declared one.
      * @param {Quill} quill
      * @returns {OutputFormat[]}
      */
@@ -2087,11 +2047,9 @@ export class Quillmark {
         }
     }
     /**
-     * Pre-session hint: `true` iff `quill`'s backend can paint sessions to a
-     * canvas, derived from the backend's output formats; `false` when the
-     * backend is unsupported. Use as a cheap precondition probe before mounting
-     * a canvas-based preview UI; the authoritative answer is the session's
-     * `supportsCanvas` getter once `open()` has been called.
+     * Whether `quill`'s backend can paint sessions to a canvas; `false` when the
+     * backend is unsupported. A cheap probe before mounting a preview UI. The
+     * authoritative answer is the session's `supportsCanvas` getter.
      * @param {Quill} quill
      * @returns {boolean}
      */
@@ -2104,8 +2062,7 @@ export class Quillmark {
 if (Symbol.dispose) Quillmark.prototype[Symbol.dispose] = Quillmark.prototype.free;
 
 /**
- * Export a canonical `Content` content to its markdown projection: the pure
- * on-demand codec behind `exportMarkdown(card.body)`. Throws if `rt` is not a
+ * Export canonical `Content` to its markdown projection. Throws if `rt` is not
  * canonical content.
  * @param {Content} rt
  * @returns {string}
@@ -2137,10 +2094,8 @@ export function exportMarkdown(rt) {
 
 /**
  * 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").
+ * string: the inverse of `parseDocPath`. Throws on a segment array the
+ * deserializer rejects, and on an empty one.
  * @param {DocPathSeg[]} segs
  * @returns {string}
  */
@@ -2170,10 +2125,9 @@ export function formatDocPath(segs) {
 }
 
 /**
- * Import a markdown string to a canonical `Content` content: the pure,
- * document-free codec. Pair with `overwrite(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.
+ * Import a markdown string to canonical `Content`: the pure, document-free
+ * codec. `overwrite(addr, importMarkdown(md))` spells the cold, anchor-losing
+ * write; prefer `revise` for edit semantics. Throws on an over-nested input.
  * @param {string} markdown
  * @returns {Content}
  */
@@ -2197,10 +2151,9 @@ export function importMarkdown(markdown) {
 
 /**
  * Map a base content position (a USV index into `Content.text`, not a UTF-16
- * offset) through a `delta` to its new USV position: the pure position-mapping
- * codec an editor bridge composes to hold a caret stable across a `revise`.
- * `assoc` decides the side of a same-position insertion (`"after"` moves past
- * it). Throws on a malformed `delta`.
+ * offset) through a `delta` to its new position, holding 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
@@ -2223,11 +2176,10 @@ export function mapPos(delta, pos, assoc) {
 }
 
 /**
- * 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.
+ * Parse a canonical document-model `Diagnostic.path` (`cards.<kind>[<i>].<field>`,
+ * `main.body`, `recipients[0].name`) into structured [`DocPathSeg`] segments, so
+ * a consumer routes on segments instead of regexing the string. Throws on a
+ * malformed path.
  * @param {string} path
  * @returns {DocPathSeg[]}
  */
@@ -2250,12 +2202,10 @@ export function parseDocPath(path) {
 }
 
 /**
- * Rebase `markdown` onto a `base` content, the pure, document-free twin of
- * `revise`: cold-import + `diff_import`, returning the new `content` and the
- * text `delta` (its offsets USV indices into `Content.text`, surviving anchors
- * rebased). Use it to compute a revise without a document in hand; `revise(addr,
- * md)` fuses this with the store for atomicity. Throws on an over-nested
- * markdown input or a non-content `base`.
+ * Rebase `markdown` onto a `base` content: the document-free twin of `revise`,
+ * returning the new `content` and the text `delta` (offsets are USV indices into
+ * `Content.text`, surviving anchors rebased). Throws on an over-nested markdown
+ * input or a non-content `base`.
  * @param {Content} base
  * @param {string} markdown
  * @returns {{ content: Content; delta: Delta }}
@@ -2279,13 +2229,9 @@ export function rebase(base, markdown) {
 }
 
 /**
- * Runs at instantiation (the wasm-bindgen start section): installs the panic
- * hook, so a Rust panic reaches the console as a stack trace rather than
- * `unreachable`.
- *
- * Not the package's `init`. That name belongs to the hand-written runtime,
- * which owns instantiation itself (`runtime/runtime.js`); this runs as part of
- * the instantiation it awaits.
+ * Runs at instantiation, so a Rust panic reaches the console as a stack trace
+ * rather than `unreachable`. Not the package's `init` — that name belongs to
+ * the hand-written runtime, which owns instantiation itself.
  */
 export function start() {
     wasm.start();