@quillmark/wasm 0.131.0 → 0.133.0

package/CHANGELOG.md

@@ -1,5 +1,127 @@
 # 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
+holding a `qm-*` element or a definition list loads as what it held, and every
+Typst PDF now carries a title.
+
+### Quill bundles
+
+- feat(core): **a quill reads and writes as one `.quill` bundle**, its file
+  tree as one zip: `Quill.yaml` at the archive root, `/` paths with no `..`,
+  stored or deflated entries, and a budget of 2048 entries, 32 MiB a file and
+  64 MiB in all, counted off the central directory before anything inflates.
+  [`prose/references/quill-bundle.md`](prose/references/quill-bundle.md)
+  specifies the format. `Quill::from_bundle` and `Quill::to_bundle` sit beside
+  `from_tree`, and a refused bundle fails as `quill::bundle_invalid`,
+  `quill::bundle_unsupported`, `quill::bundle_path` or
+  `quill::bundle_too_large`. An archive listing one path as both a file and a
+  directory is refused.
+- feat(bindings): **every surface reads and writes a bundle**: WASM
+  `Quill.fromBundle(bytes)` and `quill.toBundle()` in both builds, Python
+  `Quill.from_bundle(bytes)` and `quill.to_bundle()`. `quill_from_path` reads a
+  file named `*.quill` as a bundle, so `Quill.from_path` and every CLI command
+  taking a quill path take one; `workspace` refuses a file. `quillmark pack
+  <QUILL_PATH> [-o FILE]` writes one, by default `<name>@<version>.quill`.
+
+### Content
+
+- feat(content)!: **a `qm-<name>` element and a definition list are no longer
+  content.** A `qm-*` tag other than `qm-span` and `qm-anchor` drops, its open
+  tag warning `parse::dropped_construct` under its name, and what it wrapped
+  imports as written. A definition list reads as the paragraph CommonMark
+  reads. A stored `element` or `description` container or `term` line loads as
+  what it held and saves without it, under the tag it would take anyway; the
+  authored lanes refuse either container. The Typst helper's `elements`
+  registry, `_qm-element` and `typst::unregistered_element` are gone, so a
+  plate calling `qm.elements.update(..)` fails to compile until the call goes.
+
+### Rendering
+
+- feat(typst)!: **every Typst PDF carries a title**, in `/Info /Title` and XMP
+  `dc:title`: the render's new `title` option, else the plate's
+  `set document(title: ..)`, else the quill's `description`, trimmed.
+  `RenderOptions` gains `title`, the WASM and Python render options carry it,
+  and `quillmark render` takes `--title`.
+- fix(typst): **a table cell breaks inside an email address or dotted name**,
+  such as `Michael.Marshall@us.af.mil`, where one wider than its column ran
+  into the next cell. The address still copies out of the PDF whole.
+
 ## v0.131.0 - 2026-10-26
 
 Upgrade path: [0.130 → 0.131](docs/migrations/0.130-to-0.131.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;
@@ -383,7 +392,7 @@ the local date): what a `today` date field and a plate's `datetime.today()`
 render as. A session keeps the date it opened with, so a preview left open past
 midnight renders yesterday's until it is reopened.
 
-`opts` takes `format`, `ppi`, `pages` and `regions`, on `engine.render` and
+`opts` takes `format`, `ppi`, `pages`, `regions` and `title`, on `engine.render` and
 `session.render` alike. Any other key throws rather than reading as absent,
 `today` included, so `engine.render(quill, doc, { today })` rejects instead of
 rendering the local date. The date goes last:
@@ -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.131.0 (https://github.com/borb-sh/quillmark)
-- quillmark-typst 0.131.0 (https://github.com/borb-sh/quillmark)
-- quillmark-cli 0.131.0 (https://github.com/borb-sh/quillmark)
-- quillmark-python 0.131.0
-- quillmark-content 0.131.0 (https://github.com/borb-sh/quillmark)
-- quillmark-core 0.131.0 (https://github.com/borb-sh/quillmark)
-- quillmark 0.131.0 (https://github.com/borb-sh/quillmark)
-- quillmark-pdf 0.131.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.131.0 (https://github.com/borb-sh/quillmark)
-- quillmark-fixtures 0.131.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

@@ -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)
@@ -508,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";
@@ -515,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`
@@ -527,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[];
@@ -591,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
@@ -687,8 +709,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;
     /**
@@ -769,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
@@ -817,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
@@ -943,19 +984,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
@@ -998,6 +1054,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.
@@ -1015,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
@@ -1120,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
@@ -1186,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;
@@ -1205,13 +1288,16 @@ 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;
     readonly quill_parse: (a: number, b: number, c: number, d: number) => void;
@@ -1219,6 +1305,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;