@quillmark/wasm 0.95.1 → 0.96.0

package/core/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}
@@ -1371,6 +1371,34 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * The resolved-value view of `doc` against this quill's schema — for every
+     * declared field the value the render projection would use and the
+     * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
+     * one call. The card body rides the `fields` map under the `$body` key.
+     *
+     * Value and provenance only: completeness and errors stay `validate`'s
+     * (a consumer merges it with its own diagnostic producers regardless), and
+     * schema guidance reads from `Quill.schema`.
+     * @param {Document} doc
+     * @returns {Resolved}
+     */
+    resolve(doc) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(doc, Document);
+            wasm.quill_resolve(retptr, this.__wbg_ptr, doc.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Document schema for the quill: the user-fillable fields plus their
      * `ui` hints (title / group / compact / multiline). The single
@@ -1542,6 +1570,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
@@ -1601,6 +1663,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/core/wasm_bg.wasm.d.ts

@@ -6,8 +6,8 @@ export const __wbg_quill_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;
@@ -56,13 +56,16 @@ 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 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.95.1",
+  "version": "0.96.0",
   "description": "WebAssembly bindings for Quillmark, a schema-driven document engine",
   "type": "module",
   "license": "MIT OR Apache-2.0",

package/runtime/runtime.d.ts

@@ -16,6 +16,9 @@
 export { Quill, Document, init } from '../core/wasm.js';
 // The document-free content codec, re-exported from the core build.
 export { importMarkdown, exportMarkdown, rebase, mapPos } from '../core/wasm.js';
+// The document-model path parser/serializer — route on `Diagnostic.path`
+// segments instead of regexing the string.
+export { parseDocPath, formatDocPath } from '../core/wasm.js';
 
 import type { CardAddr } from '../core/wasm.js';
 
@@ -42,6 +45,7 @@ export type {
 	QuillCardBody,
 	QuillFieldUi,
 	QuillCardUi,
+	QuillGroupUi,
 	QuillMetadata
 } from '../core/wasm.js';
 
@@ -59,6 +63,9 @@ export type {
 	ContentContainer,
 	ContentMark,
 	ContentIsland,
+	TableProps,
+	ImageProps,
+	TableCell,
 	CardInput,
 	PathStep,
 	Addr,
@@ -67,7 +74,22 @@ export type {
 	Assoc,
 	LineOp,
 	MarkOp,
-	ChangeBundle
+	ChangeBundle,
+	DocPathSeg
+} from '../core/wasm.js';
+
+// The resolved-value view — the return shape of `quill.resolve(doc)`. Value
+// + source rung per declared field (the body rides the fields map under
+// `$body`); diagnostics stay `quill.validate`, guidance stays `quill.schema`.
+// Declared in the core build's generated `.d.ts` via a
+// `typescript_custom_section`; re-exported here so the single public entry
+// point names them.
+export type {
+	FieldSource,
+	ResolvedField,
+	ResolvedMain,
+	ResolvedCard,
+	Resolved
 } from '../core/wasm.js';
 
 // ── Error contract ──────────────────────────────────────────────────────────
@@ -148,6 +170,10 @@ export type HitGranularity = 'cluster' | 'segment';
 
 /** A click resolved to a field and USV offset into its Content. */
 export interface ContentHit {
+	/**
+	 * The field's canonical `DocPath` address (`parseDocPath`-routable) — the same
+	 * address {@link LiveSession.fieldAt} returns for that point.
+	 */
 	field: string;
 	pos: number;
 	/**
@@ -158,8 +184,8 @@ export interface ContentHit {
 }
 
 /**
- * A rendered field region: the quill schema field address (`field`) plus its
- * geometry (`rect`) on the page. Emitted by backends that place schema fields
+ * A rendered field region: the canonical `DocPath` field address (`field`) plus
+ * its geometry (`rect`) on the page. Emitted by backends that place schema fields
  * (`pdfform` AcroForm widgets; Typst form-fields and span-tracked content —
  * richtext bodies, `richtext[]` elements, card content fields, direct scalar
  * references). Only fields with a schema address produce a region — a
@@ -195,7 +221,12 @@ export interface ContentHit {
  * ```
  */
 export interface FieldRegion {
-	/** Quill schema field path (e.g. `"signature_block"`), not a backend widget name. */
+	/**
+	 * The field's canonical `DocPath` address (`parseDocPath`-routable), not a
+	 * backend widget name: `main.signature_block` for a main field,
+	 * `cards.<kind>[<i>].signature_block` for a card field (`cards[<i>].…` when the
+	 * card's kind is unknown).
+	 */
 	field: string;
 	/** 0-based page index. */
 	page: number;
@@ -390,11 +421,11 @@ export declare class LiveSession {
 	apply(doc: Document): ChangeSet;
 	render(options?: RenderOptions): RenderResult;
 	/**
-	 * Schema-field geometry for this compiled session, keyed on quill schema
-	 * field path. A session-level query: no render, no byte artifact. Read it
-	 * to scroll to / highlight the focused field over a `paint`-ed canvas;
-	 * the click direction is {@link fieldAt}. Empty for backends that place
-	 * no schema fields.
+	 * Schema-field geometry for this compiled session, keyed on the canonical
+	 * `DocPath` address (`parseDocPath`-routable). A session-level query: no
+	 * render, no byte artifact. Read it to scroll to / highlight the focused
+	 * field over a `paint`-ed canvas; the click direction is {@link fieldAt}.
+	 * Empty for backends that place no schema fields.
 	 *
 	 * `field` is **not** unique: a content field surfaces its **first
 	 * placement** as one {@link FieldRegion} per page that placement touches
@@ -407,9 +438,10 @@ export declare class LiveSession {
 	 */
 	regions(): FieldRegion[];
 	/**
-	 * The whole-field highlight boxes for `field` — one union rect per page,
-	 * over the field's `span`-bearing content segments (the "highlight the
-	 * focused field" quantity). Owns the union {@link regions} leaves derived
+	 * The whole-field highlight boxes for `field` (a canonical `DocPath` address,
+	 * as {@link regions} keys) — one union rect per page, over the field's
+	 * `span`-bearing content segments (the "highlight the focused field"
+	 * quantity). Owns the union {@link regions} leaves derived
 	 * (span-filter + per-page union), keeping `regions()` the low-level disjoint
 	 * truth, so a consumer stops reimplementing it. **Content only** — a field
 	 * placed solely as a scalar reference or a bound widget carries no `span`
@@ -420,10 +452,11 @@ export declare 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 with a
-	 * **bottom-left** origin, the same space as {@link FieldRegion.rect} —
-	 * from a canvas click, invert the overlay transform documented there:
+	 * document and get back the canonical `DocPath` field address
+	 * (`parseDocPath`-routable) 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 {@link FieldRegion.rect} — from a canvas click, invert the
+	 * overlay transform documented there:
 	 * `x = clickPx.x / renderScale`,
 	 * `y = pageHeightPt - clickPx.y / renderScale`. Unlike {@link regions},
 	 * *every* placement answers, not just the first.
@@ -434,7 +467,10 @@ export declare class LiveSession {
 	 * space as {@link fieldAt}; `undefined` off all content ink.
 	 */
 	positionAt(page: number, x: number, y: number): ContentHit | undefined;
-	/** Content position → caret rect — reverse of {@link positionAt}. */
+	/**
+	 * Content position → caret rect — reverse of {@link positionAt}. `field` is a
+	 * canonical `DocPath` address (`parseDocPath`-routable), as {@link regions} keys.
+	 */
 	locate(field: string, pos: number): FieldRegion | undefined;
 	/** Page geometry in points (1/72″). Report-only; the painter sizes the canvas. */
 	pageSize(page: number): PageSize;
@@ -483,14 +519,14 @@ declare module '../core/wasm.js' {
 		writer(doc: Document): DocumentWriter;
 		/**
 		 * Bind this quill's schema to `doc` for interpreted reads — the read twin of
-		 * {@link Quill.writer}, mirroring core's `quill.view(&doc)`. Each field is
+		 * {@link Quill.writer}, mirroring core's `quill.reader(&doc)`. Each field is
 		 * read by its declared type (a richtext field to markdown, every other type
 		 * verbatim) with schema authority, so a name the schema does not declare
 		 * throws rather than reading back `undefined`. Holds both handles by
 		 * reference and owns neither (nothing to `free()`); ephemeral by convention —
 		 * bind, read, discard.
 		 */
-		view(doc: Document): DocumentView;
+		reader(doc: Document): DocumentReader;
 	}
 }
 
@@ -588,7 +624,7 @@ export declare class CardWriter {
 
 /**
  * A `Document` bound to its `Quill` for interpreted reads — the schema-plane read
- * view, constructed via {@link Quill.view} and the read twin of
+ * surface, constructed via {@link Quill.reader} and the read twin of
  * {@link DocumentWriter}. One `get` reads each field by its declared type: a
  * richtext field to its markdown projection, a plaintext field to its literal
  * text, every other type its canonical value verbatim. Holds both handles by
@@ -601,7 +637,7 @@ export declare class CardWriter {
  * body-only `Document.getMarkdown`. The body read stays quill-free (a body's type
  * is a format fact) and never throws.
  */
-export declare class DocumentView {
+export declare class DocumentReader {
 	constructor(quill: Quill, doc: Document);
 	/** The bound document — the instance passed in. */
 	readonly document: Document;
@@ -617,20 +653,20 @@ export declare class DocumentView {
 	/** The main body's markdown — the quill-free body read. Equals `get({})`. */
 	getBody(): string;
 	/**
-	 * A {@link CardView} for the composable card at `index`. Index validity is
+	 * A {@link CardReader} for the composable card at `index`. Index validity is
 	 * checked lazily at read time, so this never throws. The cursor is ephemeral —
 	 * a `removeCard`/`addCard` between binding and reading silently retargets it.
 	 */
-	card(index: number): CardView;
+	card(index: number): CardReader;
 }
 
 /**
  * A composable card bound to its `Quill` for interpreted reads, from
- * {@link DocumentView.card}. Same verbs as {@link DocumentView}, reading the card
+ * {@link DocumentReader.card}. Same verbs as {@link DocumentReader}, reading the card
  * at its bound index; each read throws `IndexOutOfRange` if that index is out of
  * range.
  */
-export declare class CardView {
+export declare class CardReader {
 	constructor(quill: Quill, doc: Document, index: number);
 	/** The bound card index. */
 	readonly index: number;
@@ -645,6 +681,6 @@ export declare class CardView {
 	 * `IndexOutOfRange` for a bad index.
 	 */
 	get(name: string): unknown;
-	/** This card's body markdown — the card twin of {@link DocumentView.getBody}. */
+	/** This card's body markdown — the card twin of {@link DocumentReader.getBody}. */
 	getBody(): string;
 }

package/runtime/runtime.js

@@ -63,6 +63,10 @@ export { Quill, Document, init };
 // projection), `importMarkdown`, and the position-mapping pair (`rebase`,
 // `mapPos`).
 export { importMarkdown, exportMarkdown, rebase, mapPos } from '../core/wasm.js';
+// The document-model path parser/serializer: `parseDocPath(str) => DocPathSeg[]`
+// and its inverse `formatDocPath`, so a consumer routes on `Diagnostic.path`
+// segments instead of reverse-engineering the grammar.
+export { parseDocPath, formatDocPath } from '../core/wasm.js';
 
 // ── The main-card address ───────────────────────────────────────────────────
 /**
@@ -749,11 +753,11 @@ Quill.prototype.writer = function writer(doc) {
 	return new DocumentWriter(this, doc);
 };
 
-// ── Typed-reader sugar: the schema-plane read view ──────────────────────────
+// ── Typed-reader sugar: the schema-plane read surface ──────────────────────────
 // The read twin of the writer above. The transport `Document.get` is schema-free
 // — a `Document` cannot say which fields are richtext, so an unknown field name
 // reads back `undefined` rather than as the typo it is. Binding the quill's
-// schema (`_viewGet` takes the handle, like the `commit*` verbs) lets one `get`
+// schema (`_readerGet` takes the handle, like the `commit*` verbs) lets one `get`
 // interpret by declared type: a richtext field to markdown, a plaintext field to
 // its literal text, every other type verbatim, and an unknown name throws
 // `UnknownField`. A field's markdown lives here, not on the body-only
@@ -762,11 +766,11 @@ Quill.prototype.writer = function writer(doc) {
 
 /**
  * A {@link Document} bound to its {@link Quill} for typed reads — the JS twin of
- * Rust's `quill.view(&doc)` and the read counterpart of {@link DocumentWriter}.
+ * Rust's `quill.reader(&doc)` and the read counterpart of {@link DocumentWriter}.
  * Reads target the main card; use {@link card} for a composable card. Holds both
  * handles by reference and owns neither, so there is nothing to `free()`.
  */
-export class DocumentView {
+export class DocumentReader {
 	#quill;
 	#doc;
 	/**
@@ -792,7 +796,7 @@ export class DocumentView {
 	 * @returns {unknown}
 	 */
 	get(addr) {
-		return this.#doc._viewGet(this.#quill, addr);
+		return this.#doc._readerGet(this.#quill, addr);
 	}
 	/**
 	 * The main body's markdown — the quill-free body read (a body's type is a
@@ -800,28 +804,28 @@ export class DocumentView {
 	 * @returns {string}
 	 */
 	getBody() {
-		return this.#doc._viewGet(this.#quill, {});
+		return this.#doc._readerGet(this.#quill, {});
 	}
 	/**
-	 * A {@link CardView} bound to the composable card at `index`. Index validity
+	 * A {@link CardReader} bound to the composable card at `index`. Index validity
 	 * is checked lazily by the underlying read (it throws `IndexOutOfRange` at read
 	 * time), so constructing one never throws. Ephemeral like the writer cursor —
 	 * it holds `index`, not the card, so a `removeCard`/`addCard` between binding
 	 * and reading silently retargets it.
 	 * @param {number} index
-	 * @returns {CardView}
+	 * @returns {CardReader}
 	 */
 	card(index) {
-		return new CardView(this.#quill, this.#doc, index);
+		return new CardReader(this.#quill, this.#doc, index);
 	}
 }
 
 /**
  * A single composable card bound to its {@link Quill} for typed reads, from
- * {@link DocumentView.card}. Same `get` / `getBody` verbs as
- * {@link DocumentView}, reading the card at its bound index.
+ * {@link DocumentReader.card}. Same `get` / `getBody` verbs as
+ * {@link DocumentReader}, reading the card at its bound index.
  */
-export class CardView {
+export class CardReader {
 	#quill;
 	#doc;
 	#index;
@@ -855,30 +859,30 @@ export class CardView {
 	 * @returns {unknown}
 	 */
 	get(name) {
-		return this.#doc._viewGet(this.#quill, { card: this.#index, field: name });
+		return this.#doc._readerGet(this.#quill, { card: this.#index, field: name });
 	}
 	/**
-	 * This card's body markdown — the card twin of {@link DocumentView.getBody}.
+	 * This card's body markdown — the card twin of {@link DocumentReader.getBody}.
 	 * @returns {string}
 	 */
 	getBody() {
-		return this.#doc._viewGet(this.#quill, { card: this.#index });
+		return this.#doc._readerGet(this.#quill, { card: this.#index });
 	}
 }
 
-// ── `quill.view(doc)` — the schema-plane read front door ─────────────────────
+// ── `quill.reader(doc)` — the schema-plane read front door ─────────────────────
 // The read twin of `quill.writer(doc)`, patched onto the same re-exported `Quill`
 // prototype (the `Quill === CoreQuill` identity invariant holds — this only adds
-// a method constructing the pure-JS view, which owns no WASM handle).
+// a method constructing the pure-JS reader, which owns no WASM handle).
 /**
- * A {@link DocumentView} binding this quill's schema to `doc` for interpreted
- * reads — the read front door, mirroring core's `quill.view(&doc)`. The returned
- * view holds both handles by reference and owns neither, so there is nothing to
+ * A {@link DocumentReader} binding this quill's schema to `doc` for interpreted
+ * reads — the read front door, mirroring core's `quill.reader(&doc)`. The returned
+ * reader holds both handles by reference and owns neither, so there is nothing to
  * `free()`. Ephemeral by convention: bind, read, discard.
  * @this {Quill}
  * @param {Document} doc the document to read, held by reference (not owned)
- * @returns {DocumentView}
+ * @returns {DocumentReader}
  */
-Quill.prototype.view = function view(doc) {
-	return new DocumentView(this, doc);
+Quill.prototype.reader = function reader(doc) {
+	return new DocumentReader(this, doc);
 };