@quillmark/wasm 0.103.0 → 0.104.0

package/CHANGELOG.md

@@ -1,5 +1,125 @@
 # Changelog
 
+## v0.104.0 - 2026-08-13
+
+- feat(core,wasm): a quill declares, per body, the block constructs its plate
+  does not typeset (`main.body.unsupported`, `card_kinds.<k>.body.unsupported`;
+  names from `heading`, `rule`, `code`, `list`, `quote`, `table`, `image`).
+  A body holding one anyway draws the non-fatal `plate::unsupported_construct`,
+  a fifth warning family, on the pre-render walk `Quill::parse` runs beside
+  `conform`: one diagnostic per (body, construct) carrying the count in `args`
+  and the body's path, so occurrences collapse rather than scatter. The
+  declaration also rides `QuillConfig::schema()` to the editor, which is the
+  half a render-time warning could not serve: it answers before the gesture.
+  Nothing verifies a declaration — a plate that drops an undeclared construct
+  stays as silent as before. `usaf_memo` declares `rule`; empty everywhere
+  else, so no existing quill's schema or warnings change.
+- fix(fixtures): `usaf_memo`'s `render-body` drained its heading buffer in the
+  three shapes that used to discard it. A heading with nothing after it (the
+  buffer died with the loop, taking a list item's bullet with it), a heading
+  whose next element opened a *different* list item (its text was delivered
+  into that item), and a heading following a heading (the assignment overwrote
+  the earlier one) each lost their text with nothing in the render to say so.
+  The run-in style is unchanged where it was right: a heading joins the next
+  block of its own item, or the next paragraph at top level.
+- fix(content)!: `to_markdown` writes `***` for a thematic break, not `---`.
+  `- ` + `---` is four dashes separated by spaces, which re-imports as a
+  top-level break, so a rule as a bullet item's first block lost its item on
+  every markdown round-trip. The canonical spelling is now the one with the
+  fewest other readings (`---` is also a setext underline and the root-block
+  front-matter opener). Exported markdown changes for documents holding a
+  rule; the content model, wire data and rendered output do not.
+- refactor(core,pdfform,cli,wasm)!: the `enum:` modifier on `type: string`
+  retires. `type: enum` with a `values:` list is the one spelling of a finite
+  string domain; `enum:` on any type is now `quill::field_parse_error`, whose
+  message names the replacement — it is the only diagnostic a quill written
+  against the modifier ever received, since the deprecation shipped in 0.94
+  with no warning code behind it. `QuillConfig::schema()` re-emits every
+  domain as `values:`, so a consumer reading `enum:` off the schema echo (the
+  wasm `QuillFieldSchema.enum`, dropped here) reads `values:` instead. The
+  `usaf_memo` and `sample_form` fixtures migrate; wire data and rendered
+  output are unchanged, the projections being domain-keyed already.
+- fix(core): `build_transform_schema` keys a field's finite domain on the
+  domain itself rather than the `Enum` token, joining the render floor, the
+  pdfform widget kind and the blueprint annotation. Under the retired
+  spelling every `usaf_memo` enum — `classification`, `format`, `action` —
+  projected as a bare `{"type":"string"}`, so a consumer building a
+  JSON-Schema validator from the transform schema accepted
+  `classification: "banana"` while pdfform drew the six-option dropdown for
+  the same field and `QuillConfig` rejected the value at coercion (#1237)
+- fix(core)!: geometry addresses parse segment-wise, so `locate` and
+  `fieldBoxes` answer for an address deeper than one segment. The translation
+  boundary folded a plate address's whole tail into one `Field`, so
+  `references.0` minted `main.references.0` — a string that reparses as a field
+  literally named `0`, and that the reverse direction refused outright. Both
+  spellings returned `None`, leaving caret placement and whole-field highlight
+  dead for **every** `array<richtext>` element (the flagship memo's
+  `references` among them) and for every nested key a pdfform widget binds
+  (`address.city`). `region.rs` now reads and renders a plate tail one segment
+  at a time: an all-digit segment is an array index, `$body` the body terminal,
+  anything else a field or map key.
+- change(wasm, python)!: `RenderedRegion.field`, `FieldRegion.field` and
+  `ContentHit.field` spell an array element bracketed — `main.references.0`
+  becomes `main.references[0]` — on `regions()`, `fieldAt`, `positionAt` and
+  `RenderResult.regions`. This is the spelling schema validation already emits,
+  so a `Diagnostic.path` and the geometry address for one place are now the same
+  string. A consumer finding an address's children by prefix (`startsWith(`${field}.`)`)
+  needs the `[` opener too, and any heuristic reading a trailing all-digit field
+  name as a lost index is dead.
+- feat(wasm): `doc.pathFor(addr)` mints an `Addr` as the canonical `DocPath`
+  string `Diagnostic.path` carries and `session.locate` / `session.fieldBoxes`
+  take; `doc.cardPath(i)` is the card's own root. `Document` computed the
+  kind-qualified root for every addressed write and did not hand it out, so a
+  consumer building a path restated the kind lookup, the `Addr` defaults and the
+  range guard — and a wrong-kind path is compared as a string, matching nothing
+  and drawing no highlight without throwing. Both are quill-free (the stored
+  `$kind` verbatim) and total on the index axis: a path is an anchor, not a
+  read, so a per-keystroke call needs no `try` (#1225)
+- change(wasm)!: `@quillmark/wasm` declares `engines: { node: ">=24" }`, the
+  tier CI builds and tests the bindings on and the one both devcontainers hand a
+  contributor. Nothing in the package requires it at runtime, so a Node 22
+  install fails `engines` checking without failing at import.
+- docs: `docs/migrations/0.103-to-0.104.md` carries the four breaks — the
+  retired `enum:` modifier, the bracketed index spelling, the `***` thematic
+  break and the Node floor — with the prefix-match, trailing-digit and stored
+  -markdown shapes a consumer has to fix, and the two additive surfaces
+  (`pathFor` / `cardPath`, and the `plate::unsupported_construct` family a
+  code-routing consumer gains an arm for).
+- test(core): three characterization tests pin the render floor's two
+  type-domain edges (a defaultless enum, top-level and nested in a typed
+  dictionary) and an authored empty `date` beside an empty `string`, so the
+  coercion difference between the two is one test's diff. Every shipped quill
+  declares a `default:` on every enum and none authors an empty `date`, so the
+  fixture suite reached neither path. A fourth carries a `!must_fill` tag on two
+  example-seeded cells through seed → store → load → conform. Refs #1234
+
+<!-- seed: commits since v0.103.0, confirm the entries above cover them, then delete this comment
+- Carry the thematic-break and unsupported-construct work into the guide
+- Dense-prose pass over the new comments and docs
+- Let a quill declare the constructs its plate does not typeset
+- Drain the memo's heading buffer instead of dropping it
+- Canonicalize a thematic break to `***`
+- Close the 0.104 release gaps: the migration guide, and four changelog entries
+- Retire the enum: modifier; project a field's domain by capability
+- Pin the render floor's two type-domain edges and the seeded fill tag
+- Raise the Node floor to 24
+- dense-prose pass over the added prose
+- docs: dense-prose pass on the text-type sections
+- docs: give the text-type choice a decision procedure
+- docs: state the backend seam's scope and reserve its namespaces
+- docs: drop the private intra-doc link from pathFor
+- fix(core): state the unspellable-tail conditions instead of linking a private fn
+- chore(wasm): density pass, and gate a core-build dead function
+- docs: dense-prose pass over the geometry-address translation
+- docs: dense-prose pass over the pathFor / cardPath prose
+- test(wasm): execute the static-export exemption instead of listing it
+- feat(wasm): mint a DocPath from an Addr (#1225)
+- fix(core)!: parse geometry addresses segment-wise (#1223)
+- docs: carry the 0.103 CLI break, and the init gate into the quickstart (#1222)
+- SCHEMAS.md: a declared type change rewrites stored values (#1221)
+-->
+
+
 ## v0.103.0 - 2026-08-09
 
 - docs: `docs/integration/operations.md`, carrying what the other integration
@@ -50,32 +170,6 @@
   documents and stored blobs are unaffected. See
   `docs/migrations/0.102-to-0.103.md`
 
-<!-- seed: commits since v0.102.0, confirm the entries above cover them, then delete this comment
-- ci: tag the merge commit, and serialize a release against itself
-- ci: drop the tagger GitHub App from the release workflows
-- Cut SECURITY.md, and operations.md down to what only it can say
-- Drop the audit gate; keep the reachability finding in ci.yml's note
-- Fix two wrong claims, a dead property, and the stdout bug the review found
-- dense-prose pass over the added prose, and read the fixture once
-- Close four production-readiness gaps: audit gate, ops docs, CLI tests, PDF fuzzing
-- Drop the README's claim about the deleted sentinel patch
-- dense-prose pass: cut the restatement the change introduced
-- docs: the 0.102 → 0.103 step, and correct the surface it describes
-- The gate is the only door to the core surface
-- docs(migration): a span guide for 0.92 → 0.102
-- Cut over-specified style rules; author preference wins
-- dense-prose: remove the em-dash ban
-- dense-prose: drop the line-budget clause
-- dense-prose: wrong is worse than missing; relax em-dash ban
-- docs: dense-prose pass over the conform-scope and date-grammar prose
-- docs: migration guides are era-stamped, not immutable
-- docs(migrations): give the datetime split its corpus audit step
-- docs: scope conform to content fields, state the date corpus precondition
-- Tighten the failure-delivery prose
-- Deliver init's conflict as a rejection, not a synchronous throw
--->
-
-
 ## v0.102.0 - 2026-08-04
 
 The pre-1.0 vocabulary reset. Verbs, diagnostic codes, and two words that meant

package/README.md

@@ -604,11 +604,11 @@ call returns: `try { return engine.render(quill, doc); } finally
 { doc.free(); }`: is safe even on the first render, while the backend
 binary is still loading.
 
-The package floor is Node 22+ (`engines: { node: ">=22" }`) and current
+The package floor is Node 24+ (`engines: { node: ">=24" }`) and current
 evergreen browsers; `--weak-refs` itself only needs Node 14.6+. The `using`
-sugar ([explicit resource management][erm]) needs Node 24 and is optional.
-Where it hasn't landed, an explicit `try` / `finally` runs on the Node 22
-floor:
+sugar ([explicit resource management][erm]) is on that floor and optional;
+an explicit `try` / `finally` is the equivalent, and the form that also runs
+in a browser that hasn't shipped it:
 
 ```ts
 const session = await engine.open(quill, doc);

package/backends/pdfform/wasm.d.ts

@@ -181,6 +181,11 @@ export type ContentIsland = {
  * (`doc.storeField("qty", 3)`, `doc.revise("intro", md)`) the one coercion
  * rule. A bare number is *not* an addr (`{ card: 2 }` is the self-documenting
  * spelling), so no third navigation idiom re-fragments the surface.
+ *
+ * `doc.pathFor(addr)` mints the address as its canonical `DocPath` string, the
+ * anchor `Diagnostic.path` carries and `session.locate` / `session.fieldBoxes`
+ * take: a card path is kind-qualified, so building one by hand needs the card's
+ * `$kind`, and a wrong-kind path matches nothing silently.
  */
 export interface Addr {
     card?: number;
@@ -479,12 +484,32 @@ export interface QuillCardUi {
     groups?: Record<string, QuillGroupUi>;
 }
 
+/** A block construct a body can hold. `paragraph` is absent on purpose: it is
+ * the floor and cannot be declined. */
+export type QuillBlockConstruct =
+| "heading"
+| "rule"
+| "code"
+| "list"
+| "quote"
+| "table"
+| "image";
+
 /** Body namespace for a card (main or named card kind). */
 export interface QuillCardBody {
     /** When false, consumers must not accept or store body content for this card kind. Defaults to true. */
     enabled?: boolean;
     /** Example body content embedded verbatim in the blueprint body region. Fallback is "Write <card> body here." */
     example?: string;
+    /** Block constructs this quill's plate does not typeset in this body.
+     *
+     * Absent or empty means it declines nothing, which is the default. An
+     * editor reads this to decline a gesture before the author makes it; a body
+     * that holds one anyway draws a non-fatal `plate::unsupported_construct`
+     * warning carrying the construct and a count. It is the quill's claim about
+     * its own plate, and nothing verifies it: a construct absent from this list
+     * is not a promise that the plate typesets it. */
+    unsupported?: QuillBlockConstruct[];
 }
 
 /** Schema entry for a single field declared in a quill's `Quill.yaml`.
@@ -501,11 +526,8 @@ export interface QuillFieldSchema {
     description?: string;
     default?: unknown;
     example?: unknown;
-    /** Closed value domain. On `type: "enum"` declared as `values`; the
-     *  deprecated `enum` modifier on `type: "string"` is accepted for one
-     *  release. Both round-trip through this field. */
-    enum?: string[];
-    /** Required on `type: "enum"`: the closed set of allowed string values. */
+    /** Required on `type: "enum"`, and valid nowhere else: the closed set of
+     *  allowed string values. */
     values?: string[];
     ui?: QuillFieldUi;
     properties?: Record<string, QuillFieldSchema>;
@@ -752,7 +774,7 @@ export interface Location {
 }
 
 /**
- * What a committed `LiveSession.apply` changed. `dirtyPages` lists the pages
+ * What a committed `LiveSession.update` changed. `dirtyPages` lists the pages
  * whose rendered content differs from the previous compile, including pages
  * the edit added; removed pages are implied by `pageCount`. A preview
  * repaints `dirty ∩ visible` and nothing else.
@@ -812,6 +834,13 @@ export class Document {
      * verbs.
      */
     card(index: number): Card;
+    /**
+     * The composable card's own path, `cards.<kind>[index]`: the whole-card
+     * root [`pathFor`](Self::path_for) extends, for a consumer anchoring the
+     * card rather than one of its fields. Total on the index axis for the same
+     * reason, out of range renders `cards[index]`.
+     */
+    cardPath(index: number): string;
     clone(): Document;
     /**
      * Storage version this build writes via [`toJson`](Document::to_json).
@@ -959,6 +988,29 @@ export class Document {
      * not a canonical content object.
      */
     overwrite(addr: Addr | string, rt: Content): void;
+    /**
+     * `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`. A consumer holding an
+     * `Addr` mints one without restating the kind lookup, the `Addr` defaults
+     * or the range guard.
+     *
+     * The kind is the card's stored `$kind` verbatim, the quill-free rule the
+     * addressed mutators anchor with and the geometry translation uses, not
+     * `validate`'s declared-kind filter: 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 (`getStored`,
+     * `isFill`, `bodyMarkdown`), which throw there: a path is an anchor, not
+     * a read. An out-of-range `{card: 7, field: "from"}` extends the
+     * unknown-kind root `edit::index_out_of_range` anchors at, rendering
+     * `cards[7].from`, which parses back and resolves to nothing rather than
+     * mis-targeting. So a per-keystroke call needs no `try`; a caller wanting
+     * a drop-it guard has [`cardCount`](Self::card_count). Only a malformed
+     * address throws.
+     */
+    pathFor(addr: Addr | string): string;
     /**
      * The canonical `$quill` reference grammar as author-facing text. Core is
      * the single source of truth: drive schema `describe` and validation
@@ -1513,6 +1565,7 @@ export interface InitOutput {
     readonly document_bodyMarkdown: (a: number, b: number, c: number) => void;
     readonly document_card: (a: number, b: number, c: number) => void;
     readonly document_cardCount: (a: number) => number;
+    readonly document_cardPath: (a: number, b: number, c: number) => void;
     readonly document_cards: (a: number, b: number) => void;
     readonly document_clone: (a: number) => number;
     readonly document_currentStorageVersion: (a: number) => void;
@@ -1532,6 +1585,7 @@ export interface InitOutput {
     readonly document_moveCard: (a: number, b: number, c: number, d: number) => void;
     readonly document_new: (a: number, b: number, c: number) => void;
     readonly document_overwrite: (a: number, b: number, c: number, d: number) => void;
+    readonly document_pathFor: (a: number, b: number, c: number) => void;
     readonly document_quillRef: (a: number, b: number) => void;
     readonly document_quillRefHint: (a: number) => void;
     readonly document_removeCard: (a: number, b: number, c: number) => void;

package/backends/pdfform/wasm.js

@@ -368,6 +368,30 @@ export class Document {
         const ret = wasm.document_cardCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * The composable card's own path, `cards.<kind>[index]`: the whole-card
+     * root [`pathFor`](Self::path_for) extends, for a consumer anchoring the
+     * card rather than one of its fields. Total on the index axis for the same
+     * reason, 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[]}
      */
@@ -815,6 +839,54 @@ 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`. A consumer holding an
+     * `Addr` mints one without restating the kind lookup, the `Addr` defaults
+     * or the range guard.
+     *
+     * The kind is the card's stored `$kind` verbatim, the quill-free rule the
+     * addressed mutators anchor with and the geometry translation uses, not
+     * `validate`'s declared-kind filter: 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 (`getStored`,
+     * `isFill`, `bodyMarkdown`), which throw there: a path is an anchor, not
+     * a read. An out-of-range `{card: 7, field: "from"}` extends the
+     * unknown-kind root `edit::index_out_of_range` anchors at, rendering
+     * `cards[7].from`, which parses back and resolves to nothing rather than
+     * mis-targeting. So a per-keystroke call needs no `try`; a caller wanting
+     * a drop-it guard has [`cardCount`](Self::card_count). 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}
      */

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

@@ -16,6 +16,7 @@ export const document_blueprintInstruction: (a: number, b: number, c: number) =>
 export const document_bodyMarkdown: (a: number, b: number, c: number) => void;
 export const document_card: (a: number, b: number, c: number) => void;
 export const document_cardCount: (a: number) => number;
+export const document_cardPath: (a: number, b: number, c: number) => void;
 export const document_cards: (a: number, b: number) => void;
 export const document_clone: (a: number) => number;
 export const document_currentStorageVersion: (a: number) => void;
@@ -35,6 +36,7 @@ export const document_makeCard: (a: number, b: number, c: number, d: number, e:
 export const document_moveCard: (a: number, b: number, c: number, d: number) => void;
 export const document_new: (a: number, b: number, c: number) => void;
 export const document_overwrite: (a: number, b: number, c: number, d: number) => void;
+export const document_pathFor: (a: number, b: number, c: number) => void;
 export const document_quillRef: (a: number, b: number) => void;
 export const document_quillRefHint: (a: number) => void;
 export const document_removeCard: (a: number, b: number, c: number) => void;

package/backends/typst/wasm.d.ts

@@ -181,6 +181,11 @@ export type ContentIsland = {
  * (`doc.storeField("qty", 3)`, `doc.revise("intro", md)`) the one coercion
  * rule. A bare number is *not* an addr (`{ card: 2 }` is the self-documenting
  * spelling), so no third navigation idiom re-fragments the surface.
+ *
+ * `doc.pathFor(addr)` mints the address as its canonical `DocPath` string, the
+ * anchor `Diagnostic.path` carries and `session.locate` / `session.fieldBoxes`
+ * take: a card path is kind-qualified, so building one by hand needs the card's
+ * `$kind`, and a wrong-kind path matches nothing silently.
  */
 export interface Addr {
     card?: number;
@@ -479,12 +484,32 @@ export interface QuillCardUi {
     groups?: Record<string, QuillGroupUi>;
 }
 
+/** A block construct a body can hold. `paragraph` is absent on purpose: it is
+ * the floor and cannot be declined. */
+export type QuillBlockConstruct =
+| "heading"
+| "rule"
+| "code"
+| "list"
+| "quote"
+| "table"
+| "image";
+
 /** Body namespace for a card (main or named card kind). */
 export interface QuillCardBody {
     /** When false, consumers must not accept or store body content for this card kind. Defaults to true. */
     enabled?: boolean;
     /** Example body content embedded verbatim in the blueprint body region. Fallback is "Write <card> body here." */
     example?: string;
+    /** Block constructs this quill's plate does not typeset in this body.
+     *
+     * Absent or empty means it declines nothing, which is the default. An
+     * editor reads this to decline a gesture before the author makes it; a body
+     * that holds one anyway draws a non-fatal `plate::unsupported_construct`
+     * warning carrying the construct and a count. It is the quill's claim about
+     * its own plate, and nothing verifies it: a construct absent from this list
+     * is not a promise that the plate typesets it. */
+    unsupported?: QuillBlockConstruct[];
 }
 
 /** Schema entry for a single field declared in a quill's `Quill.yaml`.
@@ -501,11 +526,8 @@ export interface QuillFieldSchema {
     description?: string;
     default?: unknown;
     example?: unknown;
-    /** Closed value domain. On `type: "enum"` declared as `values`; the
-     *  deprecated `enum` modifier on `type: "string"` is accepted for one
-     *  release. Both round-trip through this field. */
-    enum?: string[];
-    /** Required on `type: "enum"`: the closed set of allowed string values. */
+    /** Required on `type: "enum"`, and valid nowhere else: the closed set of
+     *  allowed string values. */
     values?: string[];
     ui?: QuillFieldUi;
     properties?: Record<string, QuillFieldSchema>;
@@ -752,7 +774,7 @@ export interface Location {
 }
 
 /**
- * What a committed `LiveSession.apply` changed. `dirtyPages` lists the pages
+ * What a committed `LiveSession.update` changed. `dirtyPages` lists the pages
  * whose rendered content differs from the previous compile, including pages
  * the edit added; removed pages are implied by `pageCount`. A preview
  * repaints `dirty ∩ visible` and nothing else.
@@ -812,6 +834,13 @@ export class Document {
      * verbs.
      */
     card(index: number): Card;
+    /**
+     * The composable card's own path, `cards.<kind>[index]`: the whole-card
+     * root [`pathFor`](Self::path_for) extends, for a consumer anchoring the
+     * card rather than one of its fields. Total on the index axis for the same
+     * reason, out of range renders `cards[index]`.
+     */
+    cardPath(index: number): string;
     clone(): Document;
     /**
      * Storage version this build writes via [`toJson`](Document::to_json).
@@ -959,6 +988,29 @@ export class Document {
      * not a canonical content object.
      */
     overwrite(addr: Addr | string, rt: Content): void;
+    /**
+     * `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`. A consumer holding an
+     * `Addr` mints one without restating the kind lookup, the `Addr` defaults
+     * or the range guard.
+     *
+     * The kind is the card's stored `$kind` verbatim, the quill-free rule the
+     * addressed mutators anchor with and the geometry translation uses, not
+     * `validate`'s declared-kind filter: 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 (`getStored`,
+     * `isFill`, `bodyMarkdown`), which throw there: a path is an anchor, not
+     * a read. An out-of-range `{card: 7, field: "from"}` extends the
+     * unknown-kind root `edit::index_out_of_range` anchors at, rendering
+     * `cards[7].from`, which parses back and resolves to nothing rather than
+     * mis-targeting. So a per-keystroke call needs no `try`; a caller wanting
+     * a drop-it guard has [`cardCount`](Self::card_count). Only a malformed
+     * address throws.
+     */
+    pathFor(addr: Addr | string): string;
     /**
      * The canonical `$quill` reference grammar as author-facing text. Core is
      * the single source of truth: drive schema `describe` and validation
@@ -1513,6 +1565,7 @@ export interface InitOutput {
     readonly document_bodyMarkdown: (a: number, b: number, c: number) => void;
     readonly document_card: (a: number, b: number, c: number) => void;
     readonly document_cardCount: (a: number) => number;
+    readonly document_cardPath: (a: number, b: number, c: number) => void;
     readonly document_cards: (a: number, b: number) => void;
     readonly document_clone: (a: number) => number;
     readonly document_currentStorageVersion: (a: number) => void;
@@ -1532,6 +1585,7 @@ export interface InitOutput {
     readonly document_moveCard: (a: number, b: number, c: number, d: number) => void;
     readonly document_new: (a: number, b: number, c: number) => void;
     readonly document_overwrite: (a: number, b: number, c: number, d: number) => void;
+    readonly document_pathFor: (a: number, b: number, c: number) => void;
     readonly document_quillRef: (a: number, b: number) => void;
     readonly document_quillRefHint: (a: number) => void;
     readonly document_removeCard: (a: number, b: number, c: number) => void;

package/backends/typst/wasm.js

@@ -368,6 +368,30 @@ export class Document {
         const ret = wasm.document_cardCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * The composable card's own path, `cards.<kind>[index]`: the whole-card
+     * root [`pathFor`](Self::path_for) extends, for a consumer anchoring the
+     * card rather than one of its fields. Total on the index axis for the same
+     * reason, 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[]}
      */
@@ -815,6 +839,54 @@ 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`. A consumer holding an
+     * `Addr` mints one without restating the kind lookup, the `Addr` defaults
+     * or the range guard.
+     *
+     * The kind is the card's stored `$kind` verbatim, the quill-free rule the
+     * addressed mutators anchor with and the geometry translation uses, not
+     * `validate`'s declared-kind filter: 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 (`getStored`,
+     * `isFill`, `bodyMarkdown`), which throw there: a path is an anchor, not
+     * a read. An out-of-range `{card: 7, field: "from"}` extends the
+     * unknown-kind root `edit::index_out_of_range` anchors at, rendering
+     * `cards[7].from`, which parses back and resolves to nothing rather than
+     * mis-targeting. So a per-keystroke call needs no `try`; a caller wanting
+     * a drop-it guard has [`cardCount`](Self::card_count). 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}
      */

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

@@ -16,6 +16,7 @@ export const document_blueprintInstruction: (a: number, b: number, c: number) =>
 export const document_bodyMarkdown: (a: number, b: number, c: number) => void;
 export const document_card: (a: number, b: number, c: number) => void;
 export const document_cardCount: (a: number) => number;
+export const document_cardPath: (a: number, b: number, c: number) => void;
 export const document_cards: (a: number, b: number) => void;
 export const document_clone: (a: number) => number;
 export const document_currentStorageVersion: (a: number) => void;
@@ -35,6 +36,7 @@ export const document_makeCard: (a: number, b: number, c: number, d: number, e:
 export const document_moveCard: (a: number, b: number, c: number, d: number) => void;
 export const document_new: (a: number, b: number, c: number) => void;
 export const document_overwrite: (a: number, b: number, c: number, d: number) => void;
+export const document_pathFor: (a: number, b: number, c: number) => void;
 export const document_quillRef: (a: number, b: number) => void;
 export const document_quillRefHint: (a: number) => void;
 export const document_removeCard: (a: number, b: number, c: number) => void;

package/core/wasm.d.ts

@@ -181,6 +181,11 @@ export type ContentIsland = {
  * (`doc.storeField("qty", 3)`, `doc.revise("intro", md)`) the one coercion
  * rule. A bare number is *not* an addr (`{ card: 2 }` is the self-documenting
  * spelling), so no third navigation idiom re-fragments the surface.
+ *
+ * `doc.pathFor(addr)` mints the address as its canonical `DocPath` string, the
+ * anchor `Diagnostic.path` carries and `session.locate` / `session.fieldBoxes`
+ * take: a card path is kind-qualified, so building one by hand needs the card's
+ * `$kind`, and a wrong-kind path matches nothing silently.
  */
 export interface Addr {
     card?: number;
@@ -394,12 +399,32 @@ export interface QuillCardUi {
     groups?: Record<string, QuillGroupUi>;
 }
 
+/** A block construct a body can hold. `paragraph` is absent on purpose: it is
+ * the floor and cannot be declined. */
+export type QuillBlockConstruct =
+| "heading"
+| "rule"
+| "code"
+| "list"
+| "quote"
+| "table"
+| "image";
+
 /** Body namespace for a card (main or named card kind). */
 export interface QuillCardBody {
     /** When false, consumers must not accept or store body content for this card kind. Defaults to true. */
     enabled?: boolean;
     /** Example body content embedded verbatim in the blueprint body region. Fallback is "Write <card> body here." */
     example?: string;
+    /** Block constructs this quill's plate does not typeset in this body.
+     *
+     * Absent or empty means it declines nothing, which is the default. An
+     * editor reads this to decline a gesture before the author makes it; a body
+     * that holds one anyway draws a non-fatal `plate::unsupported_construct`
+     * warning carrying the construct and a count. It is the quill's claim about
+     * its own plate, and nothing verifies it: a construct absent from this list
+     * is not a promise that the plate typesets it. */
+    unsupported?: QuillBlockConstruct[];
 }
 
 /** Schema entry for a single field declared in a quill's `Quill.yaml`.
@@ -416,11 +441,8 @@ export interface QuillFieldSchema {
     description?: string;
     default?: unknown;
     example?: unknown;
-    /** Closed value domain. On `type: "enum"` declared as `values`; the
-     *  deprecated `enum` modifier on `type: "string"` is accepted for one
-     *  release. Both round-trip through this field. */
-    enum?: string[];
-    /** Required on `type: "enum"`: the closed set of allowed string values. */
+    /** Required on `type: "enum"`, and valid nowhere else: the closed set of
+     *  allowed string values. */
     values?: string[];
     ui?: QuillFieldUi;
     properties?: Record<string, QuillFieldSchema>;
@@ -560,6 +582,13 @@ export class Document {
      * verbs.
      */
     card(index: number): Card;
+    /**
+     * The composable card's own path, `cards.<kind>[index]`: the whole-card
+     * root [`pathFor`](Self::path_for) extends, for a consumer anchoring the
+     * card rather than one of its fields. Total on the index axis for the same
+     * reason, out of range renders `cards[index]`.
+     */
+    cardPath(index: number): string;
     clone(): Document;
     /**
      * Storage version this build writes via [`toJson`](Document::to_json).
@@ -707,6 +736,29 @@ export class Document {
      * not a canonical content object.
      */
     overwrite(addr: Addr | string, rt: Content): void;
+    /**
+     * `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`. A consumer holding an
+     * `Addr` mints one without restating the kind lookup, the `Addr` defaults
+     * or the range guard.
+     *
+     * The kind is the card's stored `$kind` verbatim, the quill-free rule the
+     * addressed mutators anchor with and the geometry translation uses, not
+     * `validate`'s declared-kind filter: 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 (`getStored`,
+     * `isFill`, `bodyMarkdown`), which throw there: a path is an anchor, not
+     * a read. An out-of-range `{card: 7, field: "from"}` extends the
+     * unknown-kind root `edit::index_out_of_range` anchors at, rendering
+     * `cards[7].from`, which parses back and resolves to nothing rather than
+     * mis-targeting. So a per-keystroke call needs no `try`; a caller wanting
+     * a drop-it guard has [`cardCount`](Self::card_count). Only a malformed
+     * address throws.
+     */
+    pathFor(addr: Addr | string): string;
     /**
      * The canonical `$quill` reference grammar as author-facing text. Core is
      * the single source of truth: drive schema `describe` and validation
@@ -1097,6 +1149,7 @@ export interface InitOutput {
     readonly document_bodyMarkdown: (a: number, b: number, c: number) => void;
     readonly document_card: (a: number, b: number, c: number) => void;
     readonly document_cardCount: (a: number) => number;
+    readonly document_cardPath: (a: number, b: number, c: number) => void;
     readonly document_cards: (a: number, b: number) => void;
     readonly document_clone: (a: number) => number;
     readonly document_currentStorageVersion: (a: number) => void;
@@ -1116,6 +1169,7 @@ export interface InitOutput {
     readonly document_moveCard: (a: number, b: number, c: number, d: number) => void;
     readonly document_new: (a: number, b: number, c: number) => void;
     readonly document_overwrite: (a: number, b: number, c: number, d: number) => void;
+    readonly document_pathFor: (a: number, b: number, c: number) => void;
     readonly document_quillRef: (a: number, b: number) => void;
     readonly document_quillRefHint: (a: number) => void;
     readonly document_removeCard: (a: number, b: number, c: number) => void;

package/core/wasm.js

@@ -368,6 +368,30 @@ export class Document {
         const ret = wasm.document_cardCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * The composable card's own path, `cards.<kind>[index]`: the whole-card
+     * root [`pathFor`](Self::path_for) extends, for a consumer anchoring the
+     * card rather than one of its fields. Total on the index axis for the same
+     * reason, 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[]}
      */
@@ -815,6 +839,54 @@ 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`. A consumer holding an
+     * `Addr` mints one without restating the kind lookup, the `Addr` defaults
+     * or the range guard.
+     *
+     * The kind is the card's stored `$kind` verbatim, the quill-free rule the
+     * addressed mutators anchor with and the geometry translation uses, not
+     * `validate`'s declared-kind filter: 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 (`getStored`,
+     * `isFill`, `bodyMarkdown`), which throw there: a path is an anchor, not
+     * a read. An out-of-range `{card: 7, field: "from"}` extends the
+     * unknown-kind root `edit::index_out_of_range` anchors at, rendering
+     * `cards[7].from`, which parses back and resolves to nothing rather than
+     * mis-targeting. So a per-keystroke call needs no `try`; a caller wanting
+     * a drop-it guard has [`cardCount`](Self::card_count). 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}
      */

package/core/wasm_bg.wasm.d.ts

@@ -14,6 +14,7 @@ export const document_blueprintInstruction: (a: number, b: number, c: number) =>
 export const document_bodyMarkdown: (a: number, b: number, c: number) => void;
 export const document_card: (a: number, b: number, c: number) => void;
 export const document_cardCount: (a: number) => number;
+export const document_cardPath: (a: number, b: number, c: number) => void;
 export const document_cards: (a: number, b: number) => void;
 export const document_clone: (a: number) => number;
 export const document_currentStorageVersion: (a: number) => void;
@@ -33,6 +34,7 @@ export const document_makeCard: (a: number, b: number, c: number, d: number, e:
 export const document_moveCard: (a: number, b: number, c: number, d: number) => void;
 export const document_new: (a: number, b: number, c: number) => void;
 export const document_overwrite: (a: number, b: number, c: number, d: number) => void;
+export const document_pathFor: (a: number, b: number, c: number) => void;
 export const document_quillRef: (a: number, b: number) => void;
 export const document_quillRefHint: (a: number) => void;
 export const document_removeCard: (a: number, b: number, c: number) => void;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.103.0",
+  "version": "0.104.0",
   "description": "WebAssembly bindings for Quillmark, a schema-driven document engine",
   "type": "module",
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "repository": {
     "type": "git",

package/runtime/runtime.d.ts

@@ -398,7 +398,10 @@ export interface FieldRegion {
 	 * 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).
+	 * card's kind is unknown). Nested addresses spell out in full, an array
+	 * element bracketed and a key dotted — `main.references[0]`,
+	 * `cards.<kind>[<i>].addr.city` — the same spelling `Diagnostic.path` uses,
+	 * so the two join on string equality.
 	 */
 	field: string;
 	/** 0-based page index. */

package/runtime/runtime.js

@@ -90,19 +90,25 @@ import { parseDocPath, formatDocPath } from '../core/wasm.js';
 // so there is no subpath around the gate either.
 //
 // The gate is the shape the lazy-backend idiom (§ DEFAULT_BACKENDS) takes when
-// the surface it guards cannot be async: `Quill.fromTree` and `seedDocument`
-// are sync and static, so there is nowhere to hide an await except in front.
+// the surface it guards cannot be async: `Quill.fromTree` and
+// `quill.seedDocument` return synchronously, so there is nowhere to hide an
+// await except in front.
 //
-// WHAT STAYS STATIC is what needs no instance. `MAIN_CARD_ADDR`, the open-set
-// guards and `isQuillmarkError` are pure JS over plain objects; gating them
-// would cost a consumer of one an await it has no use for.
+// WHAT STAYS A STATIC EXPORT is what needs no instance. `MAIN_CARD_ADDR`, the
+// open-set guards and `isQuillmarkError` are pure JS over plain objects; gating
+// them would cost a consumer of one an await it has no use for.
 //
-// The classes stay static too, and are gated by their ARGUMENTS. Every `Engine`
-// verb takes a `Quill` first (`#backendOf` is the single reader), and the
-// writer/reader constructors take both handles, so a caller who has not awaited
-// cannot produce an argument to call them with. `new Engine()` alone touches no
-// wasm: it validates a descriptor map. Holding them out of the gate keeps them
-// tree-shakable, so the editor path drops the dispatcher it never calls.
+// `Engine`, `LiveSession` and the four writer/reader classes stay static too,
+// gated by their ARGUMENTS rather than by the door. Every `Engine` verb takes a
+// `Quill` first (`#backendOf` is the single reader) and the writer/reader
+// constructors take both handles, so a caller who has not awaited cannot
+// produce an argument to call them with. The two constructors taking no handle
+// reach no wasm: `new Engine()` validates a descriptor map, and a `LiveSession`
+// forwards to the backend session `engine.open` is the sole source of. None of
+// the six carries a static method, the one member shape an argument cannot
+// gate. `gate.test.js` is the executable guard, driving the whole static
+// surface before `init`. Holding them out of the gate keeps them tree-shakable,
+// so the editor path drops the dispatcher it never calls.
 //
 // FAILURE DELIVERY follows the FUNCTION kind, not the failure kind: a sync verb
 // throws, a promise-returning verb rejects, and nothing does both. A
@@ -510,9 +516,10 @@ export function isListItemContainer(container) {
 // A predicate rather than an exported name list, because the known tables below
 // are upstream's business. They are pinned against the Rust source
 // (`Content::RESERVED_*` and `KnownIslandType`) by the
-// `known_open_set_names_are_pinned` drift-guard test in
-// `crates/content/src/model.rs`: adding a built-in means editing there, here, and
-// the TS unions in `crates/bindings/wasm/src/engine.rs` in one commit.
+// `js_known_name_tables_match_the_rust_open_sets` drift-guard test in
+// `crates/bindings/wasm/tests/known_names_drift.rs`: adding a built-in means
+// editing there, here, and the TS unions in `crates/bindings/wasm/src/engine.rs`
+// in one commit.
 //
 // These classify unknown *tags*, not unknown *payloads on known tags*. A future
 // `kind: "footnote"` with a sibling `ref` loses `ref` at a consumer that predates