@quillmark/wasm 0.95.1 → 0.97.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 [`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.
      *
-     * `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}
@@ -290,10 +290,10 @@ export class Document {
         return ret >>> 0;
     }
     /**
-     * The index of the first composable card whose `$id` equals `id`, or
-     * `undefined` when none carries it. Resolves the canonical durable address
+     * The index of the composable card whose `$id` equals `id`, or
+     * `undefined` when none carries it. Resolves the durable card handle
      * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
-     * non-unique by design, so the first match wins.
+     * unique per document, so at most one card matches.
      * @param {string} id
      * @returns {number | undefined}
      */
@@ -457,33 +457,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * Read the value at `addr` — the raw stored payload value of a field (a
-     * content object for a richtext field, a scalar/array/object otherwise), or
-     * the **body content** when `addr.field` is absent. A bare string is `Addr`
-     * shorthand for `{ field }`. Reads are total over the field axis: an absent
-     * field is `undefined`; only an out-of-range `addr.card` throws
-     * `[EditError::IndexOutOfRange]`. Reads need no schema, so they live on
-     * `Document`, not the typed writer; for the markdown projection of a
-     * richtext value use [`getMarkdown`](Self::get_markdown).
-     * @param {Addr | string} addr
-     * @returns {unknown}
-     */
-    get(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_get(retptr, this.__wbg_ptr, addHeapObject(addr));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
     /**
      * The whole `$ext` map at `addr` (a card address, absent `card` = main), or
      * `undefined` when the card carries none. The fine-grained `$ext` read —
@@ -541,7 +514,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}
@@ -561,6 +534,35 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Read the **verbatim stored value** at `addr` — the raw payload value of a
+     * field (a content object for a richtext field, a scalar/array/object
+     * otherwise), or the **body content** when `addr.field` is absent. A bare
+     * string is `Addr` shorthand for `{ field }`. Reads are total over the field
+     * axis: an absent field is `undefined`; only an out-of-range `addr.card`
+     * throws `edit::index_out_of_range`. Needs no schema, so it lives on
+     * `Document` — the read echo of the verbatim `store*` write, distinct from
+     * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
+     * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
+     * `reader.get` (a field's declared type).
+     * @param {Addr | string} addr
+     * @returns {unknown}
+     */
+    getStored(addr) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_getStored(retptr, this.__wbg_ptr, addHeapObject(addr));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Insert a card — the single insertion verb: `at` absent appends, a number
      * inserts at that index (must be in `0..=cards.length`). Accepts a
@@ -917,7 +919,7 @@ export class Document {
     }
     /**
      * **Revise** the richtext value at `addr` from a markdown string — **edit
-     * semantics**, the default write path, returning the text [`Delta`]. Imports
+     * semantics**, the default write path, returning the text `Delta`. Imports
      * the markdown, diffs it against the current value, rebases surviving
      * identity anchors, and returns the change an editor bridge maps its own
      * positions through (`mapPos`). An absent `addr.field` targets the body, an
@@ -1344,8 +1346,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 +1504,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 +1689,35 @@ 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 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`.
+     * @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 +1999,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
@@ -2001,10 +2067,11 @@ export function init() {
 }
 
 /**
- * Map a base content position through a `delta` to its new position — the pure
- * position-mapping codec an editor bridge composes to hold a caret stable
- * across a `revise`. `assoc` decides the side of a same-position insertion
- * (`"after"` moves past it). Throws on a malformed `delta`.
+ * Map a base content position — a USV index into `Content.text`, not a UTF-16
+ * offset — through a `delta` to its new USV position: the pure position-mapping
+ * codec an editor bridge composes to hold a caret stable across a `revise`.
+ * `assoc` decides the side of a same-position insertion (`"after"` moves past
+ * it). Throws on a malformed `delta`.
  * @param {Delta} delta
  * @param {number} pos
  * @param {Assoc} assoc
@@ -2026,12 +2093,40 @@ 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
- * text `delta` (surviving anchors rebased). Use it to compute a revise without
- * a document in hand; `revise(addr, md)` fuses this with the store for
- * atomicity. Throws on an over-nested markdown input or a non-content `base`.
+ * text `delta` (its offsets USV indices into `Content.text`, surviving anchors
+ * rebased). Use it to compute a revise without a document in hand; `revise(addr,
+ * md)` fuses this with the store for atomicity. Throws on an over-nested
+ * markdown input or a non-content `base`.
  * @param {Content} base
  * @param {string} markdown
  * @returns {{ content: Content; delta: Delta }}

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

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