@quillmark/wasm 0.95.1 → 0.96.0

package/backends/pdfform/wasm_bg.js

@@ -29,7 +29,7 @@ export class Document {
      * 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 `[EditError::UnknownField]` per undeclared name; an invalid
+     * including an `edit::unknown_field` per undeclared name; an invalid
      * kind or body, or an out-of-range position, throws a single-entry bundle
      * keyed `$kind` / `$body`.
      * @param {Quill} quill
@@ -72,12 +72,12 @@ export class Document {
      * address throws — a body has no field schema; write it with `writer.setBody`
      * / `revise`. A field declared in the schema is strict-committed (a mismatch
      * throws now, not at render); a name the schema does not declare throws
-     * `[EditError::UnknownField]` rather than falling to the opaque store — on
+     * `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 `[EditError::FieldConform]` /
-     * `[EditError::FieldRichtextDecode]` / `[EditError::FieldRichtextNotInline]`
-     * on a typed mismatch, `[EditError::InvalidFieldName]` on a malformed name,
-     * and `[EditError::IndexOutOfRange]` on an out-of-range card.
+     * opaque storage. Also throws `edit::field_conform` /
+     * `edit::field_richtext_decode` / `edit::field_richtext_not_inline`
+     * on a typed mismatch, `edit::invalid_field_name` on a malformed name,
+     * and `edit::index_out_of_range` on an out-of-range card.
      *
      * The `quill` handle is passed per call because a `Document` carries only a
      * `$quill` reference, not the resolved schema.
@@ -107,7 +107,7 @@ export class Document {
      * 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 `[EditError::UnknownField]` for any name the schema does not
+     * including an `edit::unknown_field` for any name the schema does not
      * declare, so a whole-form submit sees every typo in one pass. Throws on an
      * out-of-range card.
      * @param {Quill} quill
@@ -129,32 +129,34 @@ export class Document {
         }
     }
     /**
-     * Revise the richtext field at `addr` from markdown, typed *and*
-     * anchor-preserving — the ABI under `writer.reviseField`. Resolves the
-     * field's schema from `quill` (main card, or the addressed card's `$kind`)
-     * and defers to [`TypedWriter::revise_field`](quillmark_core::TypedWriter::revise_field):
-     * surviving anchors rebase (as [`revise`](Self::revise)), then the diffed
-     * result is schema-conformed, so a `richtext(inline)` field rejects a
-     * multi-block result with `[EditError::FieldRichtextNotInline]`. Returns the
-     * text [`Delta`].
+     * Interpreted read at `addr`, resolving the field's declared `type` from
+     * `quill` — the stable ABI under the runtime `reader.get` / `reader.card(i).get`.
+     * The schema-plane twin of the quill-free [`get`](Self::get): a `richtext`
+     * field returns its markdown projection, every other declared type its
+     * canonical value verbatim, so a consumer holding the quill reads by field
+     * meaning rather than by wire shape.
      *
-     * `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 `[EditError::UnknownField]`. Throws
-     * on an out-of-range card. Hidden from the `.d.ts`; the visible verb is
-     * `writer.reviseField` in the runtime layer.
+     * A bare string is `Addr` shorthand for `{ field }`; `{ card, field }`
+     * targets a composable card (its `$kind` resolves the schema). Returns
+     * `undefined` for an **absent** field. An absent `addr.field` reads the body
+     * markdown — quill-free, mirroring [`getMarkdown`](Self::get_markdown), since
+     * a body's type is a format fact, not a schema fact. A name the schema does
+     * not declare throws `edit::unknown_field` (the authority `getMarkdown`
+     * lacks — there an unknown name reads back `undefined`); a `richtext` field
+     * holding a value that does not decode throws `edit::field_richtext_decode`;
+     * an out-of-range `addr.card` throws.
+     *
+     * The `quill` handle is passed per call because a `Document` carries only a
+     * `$quill` reference, not the resolved schema.
      * @param {Quill} quill
      * @param {Addr | string} addr
-     * @param {string} markdown
-     * @returns {Delta}
+     * @returns {unknown}
      */
-    _reviseField(quill, addr, markdown) {
+    _readerGet(quill, addr) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(quill, Quill);
-            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document__reviseField(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), ptr0, len0);
+            wasm.document__readerGet(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -167,34 +169,32 @@ export class Document {
         }
     }
     /**
-     * Interpreted read at `addr`, resolving the field's declared `type` from
-     * `quill` — the stable ABI under the runtime `view.get` / `view.card(i).get`.
-     * The schema-plane twin of the quill-free [`get`](Self::get): a `richtext`
-     * field returns its markdown projection, every other declared type its
-     * canonical value verbatim, so a consumer holding the quill reads by field
-     * meaning rather than by wire shape.
-     *
-     * A bare string is `Addr` shorthand for `{ field }`; `{ card, field }`
-     * targets a composable card (its `$kind` resolves the schema). Returns
-     * `undefined` for an **absent** field. An absent `addr.field` reads the body
-     * markdown — quill-free, mirroring [`getMarkdown`](Self::get_markdown), since
-     * a body's type is a format fact, not a schema fact. A name the schema does
-     * not declare throws `[EditError::UnknownField]` (the authority `getMarkdown`
-     * lacks — there an unknown name reads back `undefined`); a `richtext` field
-     * holding a value that does not decode throws `[EditError::FieldRichtextDecode]`;
-     * an out-of-range `addr.card` throws.
+     * Revise the richtext field at `addr` from markdown, typed *and*
+     * anchor-preserving — the ABI under `writer.reviseField`. Resolves the
+     * field's schema from `quill` (main card, or the addressed card's `$kind`)
+     * and defers to [`TypedWriter::revise_field`](quillmark_core::TypedWriter::revise_field):
+     * surviving anchors rebase (as [`revise`](Self::revise)), then the diffed
+     * result is schema-conformed, so a `richtext(inline)` field rejects a
+     * multi-block result with `edit::field_richtext_not_inline`. Returns the
+     * text [`Delta`].
      *
-     * The `quill` handle is passed per call because a `Document` carries only a
-     * `$quill` reference, not the resolved schema.
+     * `addr` must name a field (a bare string is `{ field }`); a body address
+     * throws (a body carries no field schema — use [`revise`](Self::revise)). A
+     * name the schema does not declare throws `edit::unknown_field`. Throws
+     * on an out-of-range card. Hidden from the `.d.ts`; the visible verb is
+     * `writer.reviseField` in the runtime layer.
      * @param {Quill} quill
      * @param {Addr | string} addr
-     * @returns {unknown}
+     * @param {string} markdown
+     * @returns {Delta}
      */
-    _viewGet(quill, addr) {
+    _reviseField(quill, addr, markdown) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(quill, Quill);
-            wasm.document__viewGet(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr));
+            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document__reviseField(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -261,7 +261,7 @@ 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 `[EditError::IndexOutOfRange]`, matching the card write
+     * `index` throws `edit::index_out_of_range`, matching the card write
      * verbs.
      * @param {number} index
      * @returns {Card}
@@ -463,7 +463,7 @@ export class Document {
      * 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
-     * `[EditError::IndexOutOfRange]`. Reads need no schema, so they live on
+     * `edit::index_out_of_range`. Reads need no schema, so they live on
      * `Document`, not the typed writer; for the markdown projection of a
      * richtext value use [`getMarkdown`](Self::get_markdown).
      * @param {Addr | string} addr
@@ -541,7 +541,7 @@ export class Document {
      *
      * `addr` is an optional **card address** (`{ card }`, absent = main). A
      * present `field` throws — a field's markdown is read through the
-     * schema-plane `quill.view(doc).get(field)`, which interprets by declared
+     * schema-plane `quill.reader(doc).get(field)`, which interprets by declared
      * type (#978). An out-of-range `addr.card` throws.
      * @param {CardAddr} [addr]
      * @returns {string}
@@ -1344,8 +1344,8 @@ 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 field address to focus in the
-     * editor, or `undefined` off any field's ink. `x`/`y` are PDF points
+     * 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`,
@@ -1502,11 +1502,12 @@ 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 quill schema field path; 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`.
+     * 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.
      * @returns {FieldRegion[]}
      */
@@ -1686,6 +1687,34 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * The resolved-value view of `doc` against this quill's schema — for every
+     * declared field the value the render projection would use and the
+     * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
+     * one call. The card body rides the `fields` map under the `$body` key.
+     *
+     * Value and provenance only: completeness and errors stay `validate`'s
+     * (a consumer merges it with its own diagnostic producers regardless), and
+     * schema guidance reads from `Quill.schema`.
+     * @param {Document} doc
+     * @returns {Resolved}
+     */
+    resolve(doc) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(doc, Document);
+            wasm.quill_resolve(retptr, this.__wbg_ptr, doc.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Document schema for the quill: the user-fillable fields plus their
      * `ui` hints (title / group / compact / multiline). The single
@@ -1967,6 +1996,40 @@ 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").
+ * @param {DocPathSeg[]} segs
+ * @returns {string}
+ */
+export function formatDocPath(segs) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.formatDocPath(retptr, addHeapObject(segs));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr1 = r0;
+        var len1 = r1;
+        if (r3) {
+            ptr1 = 0; len1 = 0;
+            throw takeObject(r2);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Import a markdown string to a canonical `Content` content — the pure,
  * document-free codec. Pair with `install(addr, importMarkdown(md))` to spell
@@ -2026,6 +2089,33 @@ 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.
+ * @param {string} path
+ * @returns {DocPathSeg[]}
+ */
+export function parseDocPath(path) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.parseDocPath(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Rebase `markdown` onto a `base` content — the pure, document-free twin of
  * `revise`: cold-import + `diff_import`, returning the new `content` and the

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

@@ -8,8 +8,8 @@ export const __wbg_quillmark_free: (a: number, b: number) => void;
 export const document__addCard: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
 export const document__commitField: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document__commitFields: (a: number, b: number, c: number, d: number, e: number) => void;
+export const document__readerGet: (a: number, b: number, c: number, d: number) => void;
 export const document__reviseField: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-export const document__viewGet: (a: number, b: number, c: number, d: number) => void;
 export const document_applyChange: (a: number, b: number, c: number, d: number) => void;
 export const document_blueprintInstruction: (a: number, b: number, c: number) => void;
 export const document_card: (a: number, b: number, c: number) => void;
@@ -58,6 +58,7 @@ export const document_toMarkdown: (a: number, b: number) => void;
 export const document_tryFromJson: (a: number, b: number) => number;
 export const document_warnings: (a: number, b: number) => void;
 export const exportMarkdown: (a: number, b: number) => void;
+export const formatDocPath: (a: number, b: number) => void;
 export const importMarkdown: (a: number, b: number, c: number) => void;
 export const init: () => void;
 export const livesession_apply: (a: number, b: number, c: number) => void;
@@ -74,10 +75,12 @@ export const livesession_render: (a: number, b: number, c: number) => void;
 export const livesession_supportsCanvas: (a: number) => number;
 export const livesession_warnings: (a: number, b: number) => void;
 export const mapPos: (a: number, b: number, c: number, d: number) => void;
+export const parseDocPath: (a: number, b: number, c: number) => void;
 export const quill_backendId: (a: number, b: number) => void;
 export const quill_blueprint: (a: number, b: number) => void;
 export const quill_fromTree: (a: number, b: number) => void;
 export const quill_metadata: (a: number, b: number) => void;
+export const quill_resolve: (a: number, b: number, c: number) => void;
 export const quill_schema: (a: number, b: number) => void;
 export const quill_seedCard: (a: number, b: number, c: number, d: number, e: number) => void;
 export const quill_seedDocument: (a: number) => number;

package/backends/typst/wasm.d.ts

@@ -110,14 +110,44 @@ export type ContentMark = { start: number; end: number } & (
 | { type: string; attrs: unknown }
 );
 
-/** A structured object (table, figure, …) occupying one island slot in `Content.text`. */
-export interface ContentIsland {
+/** A cell in a `TableProps` — its plain `text` plus the `marks` over it. `marks`
+ * rides the same wire shape as prose `ContentMark`, but each mark's `start`/`end`
+ * are USV offsets into this cell's `text` (`0..text.length`), not into
+ * `Content.text`. */
+export interface TableCell {
+    text: string;
+    marks: ContentMark[];
+}
+
+/** `props` of a `type: "table"` island: a pipe table normalized to one column
+ * count that `header`, every row of `rows`, and `aligns` all share. */
+export interface TableProps {
+    header: TableCell[];
+    rows: TableCell[][];
+    /** Per-column alignment, one entry per column. */
+    aligns: ("none" | "left" | "center" | "right")[];
+}
+
+/** `props` of a `type: "image"` island. */
+export interface ImageProps {
+    url: string;
+    alt: string;
+}
+
+/** A structured object occupying one island slot in `Content.text`. `type` is an
+ * open set: the engine pins `props` as `TableProps` for `table` and `ImageProps`
+ * for `image`; an island of any other type round-trips with opaque `props`. Like
+ * `ContentMark`, the open `type` arm means a discriminant check does not itself
+ * narrow `props` — key off `type` and read `props` as the matching shape. */
+export type ContentIsland = {
     id: string;
-    type: string;
-    props: unknown;
     /** How faithfully the markdown projection can carry this island. */
     loss: "lossless" | "degraded" | "unrepresentable";
-}
+} & (
+| { type: "table"; props: TableProps }
+| { type: "image"; props: ImageProps }
+| { type: string; props: unknown }
+);
 
 /**
  * A write address — one navigation concept for the whole `Document` surface. An
@@ -203,6 +233,21 @@ export interface ChangeBundle {
 
 
 
+/**
+ * One segment of a parsed `Diagnostic.path` (see `parseDocPath`). The head
+ * carries the document-model root — `main` (only before `body`), a `card`
+ * (`kind: null` is the unknown-kind `cards[i]` form), or a `field`; the tail is
+ * `field` / `index` / a terminal `body`.
+ */
+export type DocPathSeg =
+| { seg: "main" }
+| { seg: "card"; kind: string | null; index: number }
+| { seg: "field"; name: string }
+| { seg: "index"; index: number }
+| { seg: "body" };
+
+
+
 /**
  * Page dimensions in points (1 pt = 1/72 inch). Typst measures in Typst
  * points; pdfform measures in PDF points — the same unit.
@@ -288,6 +333,55 @@ export interface PaintResult {
 
 
 
+/** The commitment-ladder rung that produced a `ResolvedField.value`. */
+export type FieldSource = "authored" | "default" | "zero";
+
+/**
+ * One resolved row: its `name`, the value the render projection would use, and
+ * the `FieldSource` rung it came from. Rows are an ordered array — declaration
+ * order is structural, not object-key order. The card body is a `body` sibling
+ * on its card, never a row in `fields`. Diagnostics stay `Quill.validate`'s;
+ * schema guidance (`example:`, labels) reads from `Quill.schema`.
+ */
+export interface ResolvedField {
+    name: string;
+    value: unknown;
+    source: FieldSource;
+}
+
+/**
+ * The main card's resolved rows in declaration order, plus its body row —
+ * `null` when the main enables no body.
+ */
+export interface ResolvedMain {
+    fields: ResolvedField[];
+    body: ResolvedField | null;
+}
+
+/**
+ * One composable card's resolved rows in declaration order, with its authored
+ * `kind` (`null` for an unknown-kind card), its document-array `index`, and its
+ * body row — `null` when the kind enables no body.
+ */
+export interface ResolvedCard {
+    kind: string | null;
+    index: number;
+    fields: ResolvedField[];
+    body: ResolvedField | null;
+}
+
+/**
+ * The resolved-value view (`Quill.resolve`): the main card and every
+ * composable card. Value and provenance only — completeness and errors stay
+ * `Quill.validate`.
+ */
+export interface Resolved {
+    main: ResolvedMain;
+    cards: ResolvedCard[];
+}
+
+
+
 /** UI layout hints for a single field. Field display order is not a hint:
  * key order in the schema's `fields`/`properties` objects is declaration
  * order, the ordering contract. */
@@ -298,9 +392,23 @@ export interface QuillFieldUi {
     multiline?: boolean;
 }
 
+/** One entry in a card's `ui.groups` registry: a display-label override for the
+ * group id (the map key). An empty object carries no override — the consumer
+ * derives the label from the id (`memo_for` → "Memo For"), as it does a field
+ * label from its key. */
+export interface QuillGroupUi {
+    title?: string;
+}
+
 /** UI layout hints for a card (main or named card kind). */
 export interface QuillCardUi {
     title?: string;
+    /** The card's group registry: the ordered table of contents naming every
+     * group a field's `ui.group` may reference. The map key is the group id, and
+     * key order is declaration order — the display-order contract, the same one
+     * `fields` key order carries. Absent when the card declares no groups (or
+     * uses the deprecated implicit-group form). */
+    groups?: Record<string, QuillGroupUi>;
 }
 
 /** Body namespace for a card (main or named card kind). */
@@ -467,7 +575,7 @@ 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 `[EditError::IndexOutOfRange]`, matching the card write
+     * `index` throws `edit::index_out_of_range`, matching the card write
      * verbs.
      */
     card(index: number): Card;
@@ -523,7 +631,7 @@ export class Document {
      * 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
-     * `[EditError::IndexOutOfRange]`. Reads need no schema, so they live on
+     * `edit::index_out_of_range`. Reads need no schema, so they live on
      * `Document`, not the typed writer; for the markdown projection of a
      * richtext value use [`getMarkdown`](Self::get_markdown).
      */
@@ -550,7 +658,7 @@ export class Document {
      *
      * `addr` is an optional **card address** (`{ card }`, absent = main). A
      * present `field` throws — a field's markdown is read through the
-     * schema-plane `quill.view(doc).get(field)`, which interprets by declared
+     * schema-plane `quill.reader(doc).get(field)`, which interprets by declared
      * type (#978). An out-of-range `addr.card` throws.
      */
     getMarkdown(addr?: CardAddr): string;
@@ -808,8 +916,8 @@ 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 field address to focus in the
-     * editor, or `undefined` off any field's ink. `x`/`y` are PDF points
+     * 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`,
@@ -873,11 +981,12 @@ 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 quill schema field path; 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`.
+     * 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.
      */
     regions(): FieldRegion[];
@@ -916,6 +1025,17 @@ export class Quill {
      * canonical shape.
      */
     static fromTree(tree: Map<string, Uint8Array>): Quill;
+    /**
+     * The resolved-value view of `doc` against this quill's schema — for every
+     * declared field the value the render projection would use and the
+     * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
+     * one call. The card body rides the `fields` map under the `$body` key.
+     *
+     * 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`.
+     */
+    resolve(doc: Document): Resolved;
     /**
      * Seed a starter composable `Card` of the given kind (carries `$kind`),
      * layering an optional per-kind seed `overlay` over the schema-example
@@ -1035,6 +1155,15 @@ export class Quillmark {
  */
 export function exportMarkdown(rt: Content): string;
 
+/**
+ * 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").
+ */
+export function formatDocPath(segs: DocPathSeg[]): string;
+
 /**
  * Import a markdown string to a canonical `Content` content — the pure,
  * document-free codec. Pair with `install(addr, importMarkdown(md))` to spell
@@ -1056,6 +1185,15 @@ export function init(): void;
  */
 export function mapPos(delta: Delta, pos: number, assoc: Assoc): number;
 
+/**
+ * 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.
+ */
+export function parseDocPath(path: string): DocPathSeg[];
+
 /**
  * Rebase `markdown` onto a `base` content — the pure, document-free twin of
  * `revise`: cold-import + `diff_import`, returning the new `content` and the

package/backends/typst/wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./wasm_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    Document, LiveSession, Quill, Quillmark, exportMarkdown, importMarkdown, init, mapPos, rebase
+    Document, LiveSession, Quill, Quillmark, exportMarkdown, formatDocPath, importMarkdown, init, mapPos, parseDocPath, rebase
 } from "./wasm_bg.js";