@quillmark/wasm 0.132.0 → 0.133.0

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,15 @@ 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;
@@ -73,6 +76,7 @@ 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.132.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

@@ -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)
@@ -524,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";
@@ -531,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`
@@ -543,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[];
@@ -607,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
@@ -918,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
@@ -966,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
@@ -1253,19 +1301,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
@@ -1314,6 +1371,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.
@@ -1336,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
@@ -1441,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
@@ -1509,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;
@@ -1546,13 +1625,15 @@ 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;
@@ -1561,6 +1642,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/render/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
@@ -1728,35 +1763,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;
@@ -1800,7 +1838,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}
      */
@@ -1809,25 +1847,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);
         }
@@ -2012,6 +2064,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.
@@ -2336,6 +2412,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

package/render/wasm_bg.wasm.d.ts

@@ -41,6 +41,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;
@@ -78,13 +79,15 @@ export const livesession_update: (a: number, b: number, c: number) => void;
 export const livesession_warnings: (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;
@@ -93,6 +96,7 @@ 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;

package/runtime/runtime.d.ts

@@ -18,6 +18,7 @@ import type {
 	Document as CoreDocument,
 	importMarkdown,
 	exportMarkdown,
+	normalize,
 	rebase,
 	mapPos,
 	mapMarks,
@@ -40,6 +41,7 @@ export interface CoreSurface {
 	Document: typeof CoreDocument;
 	importMarkdown: typeof importMarkdown;
 	exportMarkdown: typeof exportMarkdown;
+	normalize: typeof normalize;
 	rebase: typeof rebase;
 	mapPos: typeof mapPos;
 	mapMarks: typeof mapMarks;
@@ -113,7 +115,9 @@ export type {
 	QuillFieldUi,
 	QuillCardUi,
 	QuillGroupUi,
-	QuillMetadata
+	QuillMetadata,
+	AuthoringDocument,
+	AuthoringCard
 } from '../core/wasm.js';
 
 // Content edit vocabulary: the op-grained content model `Document`'s methods

package/runtime/runtime.js

@@ -19,7 +19,7 @@ import initCore, { Quill, Document } from '../core/wasm.js';
 // itself), a `node:fs` read under Node, whose `fetch` rejects `file:` URLs.
 // Resolution-time, so `node:fs` never enters a browser graph.
 import { toModuleSource } from '#quillmark-env';
-import { importMarkdown, exportMarkdown, rebase, mapPos, mapMarks } from '../core/wasm.js';
+import { importMarkdown, exportMarkdown, normalize, rebase, mapPos, mapMarks } from '../core/wasm.js';
 import { isInline, isPlain } from '../core/wasm.js';
 import { parseDocPath, formatDocPath, formatDiagnostic } from '../core/wasm.js';
 
@@ -47,6 +47,7 @@ const CORE_SURFACE = Object.freeze({
 	Document,
 	importMarkdown,
 	exportMarkdown,
+	normalize,
 	rebase,
 	mapPos,
 	mapMarks,
@@ -278,7 +279,7 @@ const HANDLE_KINDS = {
 	},
 	Document: {
 		code: 'runtime::not_a_document',
-		hint: 'Pass a Document built by Document.fromMarkdown / fromStored or quill.seedDocument / emptyDocument. A Document from another copy of @quillmark/wasm is refused too — each copy is its own WASM linear memory and its own class — so run `npm ls @quillmark/wasm` and dedupe to one.'
+		hint: 'Pass a Document built by Document.fromMarkdown / fromStored or quill.seedDocument / emptyDocument / fromAuthoring. A Document from another copy of @quillmark/wasm is refused too — each copy is its own WASM linear memory and its own class — so run `npm ls @quillmark/wasm` and dedupe to one.'
 	}
 };