@quillmark/wasm 0.131.0 → 0.133.0

package/core/wasm.js

@@ -444,8 +444,9 @@ export class Document {
      * The newest storage version this build writes via
      * [`toStored`](Document::to_stored): a document spelling a font mark, a
      * `table` element, a merged table cell or a table head 0.130 cannot draw
-     * carries it, every other the tag before it, which a 0.130 build reads. The tag advances only when the wire format changes, not on
-     * every release.
+     * carries it, every other the tag before it, which a 0.130 build reads.
+     * The tag advances only when the wire format changes, not on every
+     * release.
      * @returns {string}
      */
     static currentStorageVersion() {
@@ -713,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
@@ -903,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
@@ -1238,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;
@@ -1310,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}
      */
@@ -1319,25 +1358,63 @@ 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);
+        }
+    }
+    /**
+     * 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
+     * throws one `quill::bundle_*` diagnostic.
+     * @param {Uint8Array} bytes
+     * @returns {Quill}
+     */
+    static fromBundle(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.quill_fromBundle(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 Quill.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -1498,6 +1575,53 @@ 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.
+     * @returns {Uint8Array}
+     */
+    toBundle() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quill_toBundle(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Flatten this quill back into its canonical file tree, the inverse of
      * [`fromTree`](Self::from_tree). Keys are `"/"`-joined relative paths.
@@ -1799,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
@@ -2329,6 +2477,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/core/wasm_bg.wasm.d.ts

@@ -39,6 +39,7 @@ export const document_removeExt: (a: number, b: number, c: number) => void;
 export const document_removeField: (a: number, b: number, c: number) => void;
 export const document_removeSeedOverlay: (a: number, b: number, c: number, d: number) => void;
 export const document_revise: (a: number, b: number, c: number, d: number, e: number) => void;
+export const document_reviseContent: (a: number, b: number, c: number, d: number) => void;
 export const document_seedOverlay: (a: number, b: number, c: number, d: number) => void;
 export const document_setQuillRef: (a: number, b: number, c: number, d: number) => void;
 export const document_storageVersionOf: (a: number, b: number, c: number) => void;
@@ -58,13 +59,16 @@ export const isInline: (a: number, b: number) => void;
 export const isPlain: (a: number, b: number) => void;
 export const mapMarks: (a: number, b: number, c: number) => void;
 export const mapPos: (a: number, b: number, c: number, d: number) => void;
+export const normalize: (a: number, b: number) => void;
 export const parseDocPath: (a: number, b: number, c: number) => void;
 export const quill__resolve: (a: number, b: number, c: number, d: number, e: number) => void;
+export const quill_authoringSchema: (a: number, b: number) => void;
 export const quill_backendId: (a: number, b: number) => void;
-export const quill_blueprint: (a: number, b: number) => void;
 export const quill_conform: (a: number, b: number, c: number) => void;
 export const quill_emptyDocument: (a: number) => number;
-export const quill_exampleDocument: (a: number, b: number) => void;
+export const quill_exampleDocument: (a: number) => number;
+export const quill_fromAuthoring: (a: number, b: number, c: number) => void;
+export const quill_fromBundle: (a: number, b: number, c: number) => void;
 export const quill_fromTree: (a: number, b: number) => void;
 export const quill_metadata: (a: number, b: number) => void;
 export const quill_parse: (a: number, b: number, c: number, d: number) => void;
@@ -72,6 +76,8 @@ 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;
 export const quill_seedMain: (a: number, b: number) => void;
+export const quill_toAuthoring: (a: number, b: number, c: number) => void;
+export const quill_toBundle: (a: number, b: number) => void;
 export const quill_toTree: (a: number) => number;
 export const quill_validate: (a: number, b: number, c: number) => void;
 export const quill_warnings: (a: number, b: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.131.0",
+  "version": "0.133.0",
   "description": "WebAssembly bindings for Quillmark, a schema-driven document framework",
   "type": "module",
   "license": "Apache-2.0",

package/render/wasm.d.ts

@@ -80,8 +80,7 @@ export type ContentLineKind =
 | { kind: "para" }
 | { kind: "heading"; attrs: { level: number } }
 | { kind: "code"; attrs?: { lang?: string } }
-| { kind: "rule" }
-| { kind: "term" };
+| { kind: "rule" };
 
 /** An ancestor block a line nests inside, outermost first. Closed like
  * `ContentLine.kind`.
@@ -110,14 +109,7 @@ export type ContentContainer =
     attrs: { ordered: boolean; start: number; ordinal: number; checked?: boolean };
     instance?: number;
 }
-| { container: "quote"; instance?: number }
-| { container: "description"; instance?: number }
-| { container: "element"; attrs: ElementAttrs; instance?: number };
-
-/** A carrier element's name and attributes, one bag: `$name` is the part of
- * its `qm-<name>` tag after the prefix, and every other key an attribute as
- * written. */
-export type ElementAttrs = { $name: string; [attr: string]: string };
+| { container: "quote"; instance?: number };
 
 /** A mark over char range `[start, end)` into `Content.text`. `type` is a
  * closed set, so `type === "link"` narrows `attrs` to `{ url: string }` with no
@@ -251,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;
@@ -365,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)
@@ -532,6 +527,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";
@@ -539,7 +539,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`
@@ -551,6 +552,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[];
@@ -615,6 +617,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
@@ -774,6 +796,11 @@ export interface RenderOptions {
      * document-space even when `pages` selects a subset.
      */
     regions?: boolean;
+    /**
+     * The PDF document title, over the plate's own and then the quill's
+     * `description`. A blank title counts as absent; ignored for PNG and SVG.
+     */
+    title?: string;
 }
 
 export interface RenderResult {
@@ -838,8 +865,9 @@ export class Document {
      * The newest storage version this build writes via
      * [`toStored`](Document::to_stored): a document spelling a font mark, a
      * `table` element, a merged table cell or a table head 0.130 cannot draw
-     * carries it, every other the tag before it, which a 0.130 build reads. The tag advances only when the wire format changes, not on
-     * every release.
+     * carries it, every other the tag before it, which a 0.130 build reads.
+     * The tag advances only when the wire format changes, not on every
+     * release.
      */
     static currentStorageVersion(): string;
     /**
@@ -920,8 +948,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
@@ -968,6 +997,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
@@ -1255,19 +1301,34 @@ 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
+     * throws one `quill::bundle_*` diagnostic.
+     */
+    static fromBundle(bytes: Uint8Array): Quill;
     /**
      * Build a quill from a file tree. Pure: the declared backend is resolved
      * later, at render time. Accepts a `Map<string, Uint8Array>` or a plain
@@ -1310,6 +1371,18 @@ 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.
+     */
+    toBundle(): Uint8Array;
     /**
      * Flatten this quill back into its canonical file tree, the inverse of
      * [`fromTree`](Self::from_tree). Keys are `"/"`-joined relative paths.
@@ -1327,12 +1400,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
@@ -1432,6 +1511,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
@@ -1500,6 +1587,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;
@@ -1537,13 +1625,16 @@ export interface InitOutput {
     readonly livesession_warnings: (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;
     readonly quill_parse: (a: number, b: number, c: number, d: number) => void;
@@ -1551,6 +1642,8 @@ 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;
     readonly quill_warnings: (a: number, b: number) => void;