@quillmark/wasm 0.132.0 → 0.133.0

package/CHANGELOG.md

@@ -1,5 +1,79 @@
 # Changelog
 
+## v0.133.0 - 2026-10-29
+
+Upgrade path: [0.132 → 0.133](docs/migrations/0.132-to-0.133.md). The
+blueprint is retired: a model writes the JSON authoring document, so a prompt
+built from `quill.blueprint` moves to `quill.authoringSchema`. A root
+`example.md` is an ordinary file: a quill's example is what its `Quill.yaml`
+declares, so move each value onto its field before upgrading.
+
+### LLM authoring
+
+- feat(core,cli,wasm,python)!: **LLMs author documents as JSON; the blueprint
+  is retired.** The authoring document is the values form lifted to the whole
+  document, `{fields, body, cards: [{kind, fields, body}]}`, every rich-text
+  field and body a Markdown string and `null` absent.
+  `QuillConfig::authoring_schema()` is its JSON Schema, built by
+  `build_transform_schema` under the new `SchemaCodec::Text`: every cell admits
+  `null`, every declared object refuses an undeclared key, a variant-bearing enum is a `oneOf` per world, and each slot carries
+  its `title`, `description`, `default` and `examples`.
+  `Quill::to_authoring` exports a document, a field stored as `null` absent, and `Quill::from_authoring` imports
+  and conforms one, refusing a malformed shape with `authoring::invalid_shape`,
+  its RFC 6901 pointer in `args.pointer`. Export never fails: an undecodable
+  or string-held content leaf passes as stored, so every export validates
+  against the schema and imports back unchanged.
+  WASM `authoringSchema` / `toAuthoring` / `fromAuthoring`, Python
+  `authoring_schema` / `to_authoring` / `from_authoring`, and
+  `quillmark schema --authoring` expose them. `QuillConfig::blueprint()`,
+  `quill.blueprint`, `quillmark blueprint` and `print_blueprint` are deleted;
+  `quillmark validate` renders the empty and seeded documents.
+  `build_transform_schema` takes a `SchemaCodec`. The blueprint's load rules go
+  with it: a multi-line `description:` and an enum member holding `>`, `;` or
+  `|` load, and `quill::description_multiline` and
+  `quill::format_literal_reserved_char` are deleted. (#2331)
+
+### Examples
+
+- feat(core)!: **`example:` and a body's `description` and `example` join the
+  quill schema.** A slot at any depth declares at most one `example:`, a value
+  of its type checked at load as `default:` is, under
+  `quill::example_{type_mismatch,not_in_enum,format_violation,held_stored,on_namespace,over_max,over_length}`
+  and `quill::richtext_example_import`. It answers no cell. A body's `description` is text for the writer and its
+  `example` markdown that imports without a drop; either beside
+  `enabled: false` is `quill::invalid_body`. `schema()` carries them,
+  `FieldSchema` and `BodyCardSchema` gain the fields, and WASM types them as
+  `QuillFieldSchema.example` and `QuillCardBody.{description,example}`. (#2329)
+- feat(core,cli,wasm,python)!: **the example document is derived.**
+  `Quill::example_document()` returns `Option<Document>`: the seeded document
+  with every declared `example:` committed and each kind's `body.example` as
+  its body, `None` where the quill declares none. A root `example.md` is an
+  ordinary file: `EXAMPLE_FILE` and `quill::example_reference` are deleted,
+  WASM `exampleDocument()` and Python `example_document()` no longer throw, and
+  `quillmark validate` validates and renders the derived document, warning
+  `cli::example_file_ignored` while a root `example.md` remains. The
+  fixture quills declare the values their `example.md` held. (#2329)
+
+### Content
+
+- feat(content,core,wasm): **`reviseContent` revises a body or field to a
+  content and keeps its prose anchors.** WASM `doc.reviseContent(addr, rt)`,
+  over core's `Card::revise_body_content` / `revise_field_content` and the
+  content crate's `delta::carry_anchors`, diffs a content built elsewhere
+  against the stored value, carries each prose anchor whose id `rt` does not
+  hold, and returns the `Revised` receipt with its text `delta`. `rt`'s own
+  anchors and island ids land as they are.
+- feat(content)!: **normalizing content moves no text.** A table's slot
+  sharing its line with prose is canonical: `Content::normalize` leaves the
+  line as given, where it inserted a `\n` on each side, and `to_markdown`
+  breaks it instead. `overwrite`, `reviseContent` and
+  `serial::from_authored_value` take the shape where they threw `block island
+  in a line's prose`, an `IslandOp::Set` on such a table lands, and a stored
+  row holding it loads as stored under the same tag. Typst sets the table as a
+  block where its slot sits, closing a heading around it, and a hard break
+  after a line the slot ends clears. WASM gains `normalize(content)`, the form
+  `overwrite` stores. (#2330)
+
 ## v0.132.0 - 2026-10-27
 
 Upgrade path: [0.131 → 0.132](docs/migrations/0.131-to-0.132.md). A row

package/README.md

@@ -240,8 +240,17 @@ values from the `Document` payload: there is no separate form-view projection.
 `quill.validate(doc)` scores it without invoking the backend.
 
 `quill.exampleDocument()` returns the quill's example, a filled-in page whose
-values are made up, pinned to the quill's `name@MAJOR.MINOR`; `undefined`
-when the quill has no `example.md` at its root.
+values are made up: the seeded document with each `example` the schema
+declares committed, a field's as its value and a body's as the body;
+`undefined` when the quill declares none.
+
+An LLM writes a document as JSON: `quill.authoringSchema` is its JSON Schema,
+`quill.fromAuthoring(reply)` builds and conforms the `Document` (the JSON twin of
+`quill.parse`), and `quill.toAuthoring(doc)` exports any document back, every
+rich-text field and body a Markdown string. A shape error throws
+`authoring::invalid_shape` at its JSON path; a value of the wrong type lands
+with a `conform::*` warning and `quill.validate(doc)` reports it at its
+document path.
 
 `quill.seedDocument()` returns a starter document: one card per kind, each
 carrying the kind's `seed` from `Quill.yaml` and no other field;
@@ -452,10 +461,9 @@ if (cssPxPerPt > 0) {                        // 0 while the canvas has no layout
 
 A field declares no `required` key: nothing is required.
 
-**`default:`** — what an unanswered field renders. With one, `quill.blueprint`
-renders that value under a type-only `# <type>` annotation and the render path
-uses it when the document omits the field. Without one, the blueprint leaves the
-cell empty and an absent field blank-fills.
+**`default:`** — what an unanswered field renders. With one, the render path
+uses it when the document omits the field, and `quill.authoringSchema` carries
+it as the field's `default`. Without one, an absent field blank-fills.
 
 An unanswered field draws no diagnostic. Partial documents are accepted, and
 `engine.render(quill, doc)` throws only for malformed input.

package/THIRD_PARTY_LICENSES.md

@@ -2153,14 +2153,14 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH RE
 
 ## Apache License 2.0
 
-- quillmark-acroform 0.132.0 (https://github.com/borb-sh/quillmark)
-- quillmark-typst 0.132.0 (https://github.com/borb-sh/quillmark)
-- quillmark-cli 0.132.0 (https://github.com/borb-sh/quillmark)
-- quillmark-python 0.132.0
-- quillmark-content 0.132.0 (https://github.com/borb-sh/quillmark)
-- quillmark-core 0.132.0 (https://github.com/borb-sh/quillmark)
-- quillmark 0.132.0 (https://github.com/borb-sh/quillmark)
-- quillmark-pdf 0.132.0 (https://github.com/borb-sh/quillmark)
+- quillmark-acroform 0.133.0 (https://github.com/borb-sh/quillmark)
+- quillmark-typst 0.133.0 (https://github.com/borb-sh/quillmark)
+- quillmark-cli 0.133.0 (https://github.com/borb-sh/quillmark)
+- quillmark-python 0.133.0
+- quillmark-content 0.133.0 (https://github.com/borb-sh/quillmark)
+- quillmark-core 0.133.0 (https://github.com/borb-sh/quillmark)
+- quillmark 0.133.0 (https://github.com/borb-sh/quillmark)
+- quillmark-pdf 0.133.0 (https://github.com/borb-sh/quillmark)
 - ciborium-io 0.2.2 (https://github.com/enarx/ciborium)
 - ciborium-ll 0.2.2 (https://github.com/enarx/ciborium)
 - ciborium 0.2.2 (https://github.com/enarx/ciborium)
@@ -4523,7 +4523,7 @@ limitations under the License.
 - js-sys 0.3.106 (https://github.com/wasm-bindgen/wasm-bindgen/tree/master/crates/js-sys)
 - lock_api 0.4.14 (https://github.com/Amanieu/parking_lot)
 - log 0.4.29 (https://github.com/rust-lang/log)
-- num-bigint 0.4.6 (https://github.com/rust-num/num-bigint)
+- num-bigint 0.4.8 (https://github.com/rust-num/num-bigint)
 - num-integer 0.1.46 (https://github.com/rust-num/num-integer)
 - num-traits 0.2.19 (https://github.com/rust-num/num-traits)
 - once_cell 1.21.4 (https://github.com/matklad/once_cell)
@@ -4537,7 +4537,7 @@ limitations under the License.
 - proc-macro-hack 0.5.20+deprecated (https://github.com/dtolnay/proc-macro-hack)
 - rayon-core 1.13.0 (https://github.com/rayon-rs/rayon)
 - rayon 1.12.0 (https://github.com/rayon-rs/rayon)
-- regex-automata 0.4.14 (https://github.com/rust-lang/regex)
+- regex-automata 0.4.18 (https://github.com/rust-lang/regex)
 - regex-syntax 0.8.10 (https://github.com/rust-lang/regex)
 - regex 1.12.3 (https://github.com/rust-lang/regex)
 - roxmltree 0.20.0 (https://github.com/RazrFalcon/roxmltree)
@@ -6248,8 +6248,8 @@ limitations under the License.
 
 ## Apache License 2.0
 
-- quillmark-wasm 0.132.0 (https://github.com/borb-sh/quillmark)
-- quillmark-fixtures 0.132.0
+- quillmark-wasm 0.133.0 (https://github.com/borb-sh/quillmark)
+- quillmark-fixtures 0.133.0
 - arraydeque 0.5.1 (https://github.com/andylokandy/arraydeque)
 - codex 0.3.0 (https://github.com/typst/codex)
 - color 0.3.3 (https://github.com/linebender/color)
@@ -7624,7 +7624,7 @@ SOFTWARE.
 ## MIT License
 
 - unsafe-libyaml 0.2.11 (https://github.com/dtolnay/unsafe-libyaml)
-- zmij 1.0.21 (https://github.com/dtolnay/zmij)
+- zmij 1.0.23 (https://github.com/dtolnay/zmij)
 
 ~~~~text
 Permission is hereby granted, free of charge, to any

package/core/wasm.d.ts

@@ -243,9 +243,10 @@ export interface Delta {
 }
 
 /**
- * The receipt of a markdown revise (`revise`, `writer.reviseBody`,
+ * The receipt of a revise (`revise`, `reviseContent`, `writer.reviseBody`,
  * `writer.reviseField`): the text `delta`, and one `parse::dropped_construct`
- * warning per construct the import dropped, anchored at the revised address.
+ * warning per construct a markdown import dropped, anchored at the revised
+ * address. `reviseContent` imports nothing, so its `warnings` is empty.
  */
 export interface Revised {
     delta: Delta;
@@ -357,7 +358,9 @@ export type LineOp =
  *
  * A `table` has no inline placement: markdown writes it as a block, so an
  * `insert` whose `at` is not an empty line throws, as does a `set` retyping an
- * inline island into one.
+ * inline island into one. A table already sharing its line, as a `join` or an
+ * `overwrite` of merged edits leaves one, stays there and takes its `set`;
+ * markdown writes it on a line of its own.
  */
 export type IslandOp =
 | ({ op: "set" } & ContentIsland)
@@ -500,6 +503,11 @@ export interface QuillCardUi {
 export interface QuillCardBody {
     /** When false, consumers must not accept or store body content for this card kind. Defaults to true. */
     enabled?: boolean;
+    /** What the body holds, for the writer. Never beside `enabled: false`. */
+    description?: string;
+    /** A made-up body in markdown, which `exampleDocument()` commits. Never
+     *  beside `enabled: false`. */
+    example?: string;
 }
 
 export type QuillFieldType = "number" | "integer" | "boolean" | "array" | "object" | "date" | "datetime" | "text" | "richtext" | "enum" | "matrix";
@@ -507,7 +515,8 @@ export type QuillFieldType = "number" | "integer" | "boolean" | "array" | "objec
 /** Schema entry for a single field declared in a quill's `Quill.yaml`.
  *
  * `default` is the value an unanswered cell renders. An absent field without a
- * `default` blank-fills.
+ * `default` blank-fills. `example` is a made-up value of the same type, which
+ * answers no cell: `exampleDocument()` commits it.
  */
 export interface QuillFieldSchema {
     /** A trailing `?` marks the cell optional: unanswered, it renders `none`
@@ -519,6 +528,7 @@ export interface QuillFieldSchema {
     title?: string;
     description?: string;
     default?: unknown;
+    example?: unknown;
     /** The closed set of allowed values. Required on `type: "enum"`, and valid
      *  nowhere else. */
     values?: string[];
@@ -583,6 +593,26 @@ export interface QuillSchema {
     card_kinds?: Record<string, QuillCardSchema>;
 }
 
+/**
+ * One card of an `AuthoringDocument`: its kind, its fields in the values form,
+ * and its body as Markdown. `null` anywhere a value goes is absent.
+ */
+export interface AuthoringCard {
+    kind: string;
+    fields?: Record<string, unknown> | null;
+    body?: string | null;
+}
+
+/**
+ * The JSON a model reads and writes, described by `Quill.authoringSchema`:
+ * the main card's fields and body, and the composable cards in order.
+ */
+export interface AuthoringDocument {
+    fields?: Record<string, unknown> | null;
+    body?: string | null;
+    cards?: AuthoringCard[] | null;
+}
+
 /**
  * Identity snapshot mirroring the `quill:` section of `Quill.yaml`. The schema
  * lives on `Quill.schema`; output formats are a resolved-backend capability read
@@ -762,8 +792,9 @@ export class Document {
     /**
      * **Overwrite** the content value at `addr` with exactly `rt`: value
      * semantics, so the identity anchors of any previous value are gone. By
-     * anchor fate `overwrite` destroys, [`revise`](Document::revise) rebases,
-     * and [`applyChange`](Document::apply_change) preserves. An absent
+     * anchor fate `overwrite` destroys, [`revise`](Document::revise) and
+     * [`reviseContent`](Document::revise_content) rebase, and
+     * [`applyChange`](Document::apply_change) preserves. An absent
      * `addr.field` targets the body, an absent `addr.card` the main card.
      *
      * Throws on an out-of-range card, a malformed field name, or an `rt` that is
@@ -810,6 +841,23 @@ export class Document {
      * or `undefined`; drops `$seed` entirely once empty. Sibling kinds survive.
      */
     removeSeedOverlay(card_kind: string): any;
+    /**
+     * **Revise** the richtext value at `addr` to `rt`, keeping each stored prose
+     * anchor whose id `rt` does not hold: the content twin of
+     * [`revise`](Document::revise), for a value built elsewhere such as a
+     * merge's projection. Diffs `rt` against the current value, carries those
+     * anchors through the diff, and returns the
+     * `Revised` receipt, whose `delta` an editor bridge maps its own positions
+     * through and whose `warnings` is empty. `rt`'s own anchors and island ids
+     * land as they are. An absent `addr.field` targets the body, an absent
+     * `addr.card` the main card; an absent field diffs from empty. Richtext
+     * only: a `text` field takes `overwrite`.
+     *
+     * Throws on an out-of-range card, a malformed field name, a present
+     * non-content field value, or an `rt` that is not a canonical content
+     * object.
+     */
+    reviseContent(addr: Addr | string, rt: Content): Revised;
     /**
      * **Revise** the richtext value at `addr` from a markdown string: the
      * default write path. Imports the markdown, diffs it against the current
@@ -936,19 +984,28 @@ export class Quill {
      * The empty document: a main card carrying this quill's `$quill` and
      * `$kind: main`, no field committed, no composable card, no body. The
      * type-minimal valid input, and the document a plate is bound to render
-     * (the quill authoring contract). `new Document(ref)` is the same document
+     * (the plate contract). `new Document(ref)` is the same document
      * reached by spelling the reference.
      */
     emptyDocument(): Document;
     /**
-     * The quill's example document, `undefined` when the quill has no
-     * `example.md` at its root: a filled-in page whose values are made up to show the
-     * quill in use, never kept. It comes back pinned to this quill's
-     * `name@MAJOR.MINOR` and conformed as `parse` conforms, its parse and
-     * `conform::*` warnings on `doc.warnings`. Throws when the file does not
-     * parse or its `$quill` is not this quill's bare name.
+     * The quill's example document, `undefined` when no slot or body declares
+     * an example: the seeded document with every declared `example` committed
+     * as its cell's value and each kind's `body.example` as its body. A
+     * filled-in page whose values are made up to show the quill in use, never
+     * kept.
      */
     exampleDocument(): Document | undefined;
+    /**
+     * A document from an authoring document, conformed against this quill:
+     * the JSON twin of `parse`. A `null` is absent; the document carries this
+     * quill's `$quill`. A value the schema refuses lands with a `conform::*`
+     * warning on `doc.warnings`, and `validate` reports the rest at document
+     * paths. Throws, with every error found, on a value that is not the
+     * authoring document's shape (`authoring::invalid_shape`) or a name or
+     * kind no card can store (`edit::*`).
+     */
+    fromAuthoring(value: AuthoringDocument): Document;
     /**
      * Read a `.quill` bundle, the zip archive holding one quill's file tree.
      * Pure, as [`fromTree`](Self::from_tree) is. A bundle outside the format
@@ -997,6 +1054,13 @@ export class Quill {
      * `$kind: main` card of [`seedDocument`](Self::seed_document) alone.
      */
     seedMain(): Card;
+    /**
+     * `doc` as an authoring document: every field in the values form (each
+     * content leaf its codec's text), every body as Markdown, each card
+     * `{kind, fields, body}`. Sparse: an absent or `null` field stays absent. A
+     * content leaf that decodes under neither encoding exports as stored.
+     */
+    toAuthoring(doc: Document): AuthoringDocument;
     /**
      * This quill's file tree as a `.quill` bundle, the bytes
      * [`fromBundle`](Self::from_bundle) reads.
@@ -1019,12 +1083,18 @@ export class Quill {
      * backend's `backend::declined_construct`.
      */
     validate(doc: Document): Diagnostic[];
+    /**
+     * JSON Schema (draft 2020-12) of the quill's authoring document: the
+     * shape `fromAuthoring` takes and `toAuthoring` returns, every content
+     * leaf a Markdown or literal string, each card kind under `$defs`
+     * selected by `kind`.
+     */
+    readonly authoringSchema: Record<string, unknown>;
     /**
      * The *declared* backend identifier (e.g. `"typst"`): intent, not a
      * resolved capability. Capability is read from the engine.
      */
     readonly backendId: string;
-    readonly blueprint: string;
     /**
      * Identity snapshot of the `quill:` section of `Quill.yaml`. Pure config:
      * output formats are a resolved-backend capability read from
@@ -1124,6 +1194,14 @@ export function mapMarks(content: Content, bundle: ChangeBundle): ContentMark[];
  */
 export function mapPos(delta: Delta, pos: number, assoc: Assoc): number;
 
+/**
+ * The canonical form of `rt`: the content `overwrite` stores from it, read
+ * without a document. Normalizing rewrites structure, never the text, so the
+ * answer's `text` is `rt.text`. Throws where `overwrite` would, with the same
+ * error under this verb's name.
+ */
+export function normalize(rt: Content): Content;
+
 /**
  * Parse a canonical document-model `Diagnostic.path` (`cards.<kind>[<i>].<field>`,
  * `main.body`, `recipients[0].name`) into structured `DocPathSeg` segments, so
@@ -1190,6 +1268,7 @@ export interface InitOutput {
     readonly document_removeField: (a: number, b: number, c: number) => void;
     readonly document_removeSeedOverlay: (a: number, b: number, c: number, d: number) => void;
     readonly document_revise: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document_reviseContent: (a: number, b: number, c: number, d: number) => void;
     readonly document_seedOverlay: (a: number, b: number, c: number, d: number) => void;
     readonly document_setQuillRef: (a: number, b: number, c: number, d: number) => void;
     readonly document_storageVersionOf: (a: number, b: number, c: number) => void;
@@ -1209,13 +1288,15 @@ export interface InitOutput {
     readonly isPlain: (a: number, b: number) => void;
     readonly mapMarks: (a: number, b: number, c: number) => void;
     readonly mapPos: (a: number, b: number, c: number, d: number) => void;
+    readonly normalize: (a: number, b: number) => void;
     readonly parseDocPath: (a: number, b: number, c: number) => void;
     readonly quill__resolve: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly quill_authoringSchema: (a: number, b: number) => void;
     readonly quill_backendId: (a: number, b: number) => void;
-    readonly quill_blueprint: (a: number, b: number) => void;
     readonly quill_conform: (a: number, b: number, c: number) => void;
     readonly quill_emptyDocument: (a: number) => number;
-    readonly quill_exampleDocument: (a: number, b: number) => void;
+    readonly quill_exampleDocument: (a: number) => number;
+    readonly quill_fromAuthoring: (a: number, b: number, c: number) => void;
     readonly quill_fromBundle: (a: number, b: number, c: number) => void;
     readonly quill_fromTree: (a: number, b: number) => void;
     readonly quill_metadata: (a: number, b: number) => void;
@@ -1224,6 +1305,7 @@ export interface InitOutput {
     readonly quill_seedCard: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly quill_seedDocument: (a: number) => number;
     readonly quill_seedMain: (a: number, b: number) => void;
+    readonly quill_toAuthoring: (a: number, b: number, c: number) => void;
     readonly quill_toBundle: (a: number, b: number) => void;
     readonly quill_toTree: (a: number) => number;
     readonly quill_validate: (a: number, b: number, c: number) => void;

package/core/wasm.js

@@ -714,8 +714,9 @@ export class Document {
     /**
      * **Overwrite** the content value at `addr` with exactly `rt`: value
      * semantics, so the identity anchors of any previous value are gone. By
-     * anchor fate `overwrite` destroys, [`revise`](Document::revise) rebases,
-     * and [`applyChange`](Document::apply_change) preserves. An absent
+     * anchor fate `overwrite` destroys, [`revise`](Document::revise) and
+     * [`reviseContent`](Document::revise_content) rebase, and
+     * [`applyChange`](Document::apply_change) preserves. An absent
      * `addr.field` targets the body, an absent `addr.card` the main card.
      *
      * Throws on an out-of-range card, a malformed field name, or an `rt` that is
@@ -904,6 +905,40 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * **Revise** the richtext value at `addr` to `rt`, keeping each stored prose
+     * anchor whose id `rt` does not hold: the content twin of
+     * [`revise`](Document::revise), for a value built elsewhere such as a
+     * merge's projection. Diffs `rt` against the current value, carries those
+     * anchors through the diff, and returns the
+     * `Revised` receipt, whose `delta` an editor bridge maps its own positions
+     * through and whose `warnings` is empty. `rt`'s own anchors and island ids
+     * land as they are. An absent `addr.field` targets the body, an absent
+     * `addr.card` the main card; an absent field diffs from empty. Richtext
+     * only: a `text` field takes `overwrite`.
+     *
+     * Throws on an out-of-range card, a malformed field name, a present
+     * non-content field value, or an `rt` that is not a canonical content
+     * object.
+     * @param {Addr | string} addr
+     * @param {Content} rt
+     * @returns {Revised}
+     */
+    reviseContent(addr, rt) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_reviseContent(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(rt));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * **Revise** the richtext value at `addr` from a markdown string: the
      * default write path. Imports the markdown, diffs it against the current
@@ -1239,35 +1274,38 @@ export class Quill {
         }
     }
     /**
-     * The *declared* backend identifier (e.g. `"typst"`): intent, not a
-     * resolved capability. Capability is read from the engine.
-     * @returns {string}
+     * JSON Schema (draft 2020-12) of the quill's authoring document: the
+     * shape `fromAuthoring` takes and `toAuthoring` returns, every content
+     * leaf a Markdown or literal string, each card kind under `$defs`
+     * selected by `kind`.
+     * @returns {Record<string, unknown>}
      */
-    get backendId() {
-        let deferred1_0;
-        let deferred1_1;
+    get authoringSchema() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_backendId(retptr, this.__wbg_ptr);
+            wasm.quill_authoringSchema(retptr, this.__wbg_ptr);
             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);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
     /**
+     * The *declared* backend identifier (e.g. `"typst"`): intent, not a
+     * resolved capability. Capability is read from the engine.
      * @returns {string}
      */
-    get blueprint() {
+    get backendId() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_blueprint(retptr, this.__wbg_ptr);
+            wasm.quill_backendId(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -1311,7 +1349,7 @@ export class Quill {
      * The empty document: a main card carrying this quill's `$quill` and
      * `$kind: main`, no field committed, no composable card, no body. The
      * type-minimal valid input, and the document a plate is bound to render
-     * (the quill authoring contract). `new Document(ref)` is the same document
+     * (the plate contract). `new Document(ref)` is the same document
      * reached by spelling the reference.
      * @returns {Document}
      */
@@ -1320,25 +1358,39 @@ export class Quill {
         return Document.__wrap(ret);
     }
     /**
-     * The quill's example document, `undefined` when the quill has no
-     * `example.md` at its root: a filled-in page whose values are made up to show the
-     * quill in use, never kept. It comes back pinned to this quill's
-     * `name@MAJOR.MINOR` and conformed as `parse` conforms, its parse and
-     * `conform::*` warnings on `doc.warnings`. Throws when the file does not
-     * parse or its `$quill` is not this quill's bare name.
+     * The quill's example document, `undefined` when no slot or body declares
+     * an example: the seeded document with every declared `example` committed
+     * as its cell's value and each kind's `body.example` as its body. A
+     * filled-in page whose values are made up to show the quill in use, never
+     * kept.
      * @returns {Document | undefined}
      */
     exampleDocument() {
+        const ret = wasm.quill_exampleDocument(this.__wbg_ptr);
+        return ret === 0 ? undefined : Document.__wrap(ret);
+    }
+    /**
+     * A document from an authoring document, conformed against this quill:
+     * the JSON twin of `parse`. A `null` is absent; the document carries this
+     * quill's `$quill`. A value the schema refuses lands with a `conform::*`
+     * warning on `doc.warnings`, and `validate` reports the rest at document
+     * paths. Throws, with every error found, on a value that is not the
+     * authoring document's shape (`authoring::invalid_shape`) or a name or
+     * kind no card can store (`edit::*`).
+     * @param {AuthoringDocument} value
+     * @returns {Document}
+     */
+    fromAuthoring(value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_exampleDocument(retptr, this.__wbg_ptr);
+            wasm.quill_fromAuthoring(retptr, this.__wbg_ptr, addHeapObject(value));
             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 r0 === 0 ? undefined : Document.__wrap(r0);
+            return Document.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -1523,6 +1575,30 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * `doc` as an authoring document: every field in the values form (each
+     * content leaf its codec's text), every body as Markdown, each card
+     * `{kind, fields, body}`. Sparse: an absent or `null` field stays absent. A
+     * content leaf that decodes under neither encoding exports as stored.
+     * @param {Document} doc
+     * @returns {AuthoringDocument}
+     */
+    toAuthoring(doc) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(doc, Document);
+            wasm.quill_toAuthoring(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);
+        }
+    }
     /**
      * This quill's file tree as a `.quill` bundle, the bytes
      * [`fromBundle`](Self::from_bundle) reads.
@@ -1847,6 +1923,30 @@ export function mapPos(delta, pos, assoc) {
     }
 }
 
+/**
+ * The canonical form of `rt`: the content `overwrite` stores from it, read
+ * without a document. Normalizing rewrites structure, never the text, so the
+ * answer's `text` is `rt.text`. Throws where `overwrite` would, with the same
+ * error under this verb's name.
+ * @param {Content} rt
+ * @returns {Content}
+ */
+export function normalize(rt) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.normalize(retptr, addHeapObject(rt));
+        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);
+    }
+}
+
 /**
  * Parse a canonical document-model `Diagnostic.path` (`cards.<kind>[<i>].<field>`,
  * `main.body`, `recipients[0].name`) into structured `DocPathSeg` segments, so