@quillmark/wasm 0.123.1 → 0.125.0

package/render/wasm.js

@@ -26,11 +26,14 @@ export class Document {
      * leaves the document untouched. Field errors throw the same per-field
      * bundle as [`commitFields`](Self::commit_fields); an invalid kind or body,
      * or a bad position, throws a single-entry bundle keyed `$kind` / `$body`.
+     * Returns the fields' `parse::dropped_construct` warnings, then the body
+     * import's, anchored under the placed card.
      * @param {Quill} quill
      * @param {string} kind
      * @param {Record<string, unknown>} [fields]
      * @param {string} [body]
      * @param {number} [at]
+     * @returns {Diagnostic[]}
      */
     _addCard(quill, kind, fields, body, at) {
         try {
@@ -43,9 +46,11 @@ export class Document {
             wasm.document__addCard(retptr, this.__wbg_ptr, quill.__wbg_ptr, ptr0, len0, isLikeNone(fields) ? 0 : addHeapObject(fields), ptr1, len1, isLikeNone(at) ? Number.MAX_SAFE_INTEGER : (at) >>> 0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -68,9 +73,13 @@ export class Document {
      *
      * The `quill` handle is passed per call because a `Document` carries only a
      * `$quill` reference, not the resolved schema.
+     *
+     * Returns a `parse::dropped_construct` warning per construct a `richtext`
+     * markdown string in the value dropped, at the string's path.
      * @param {Quill} quill
      * @param {Addr | string} addr
      * @param {any} value
+     * @returns {Diagnostic[]}
      */
     _commitField(quill, addr, value) {
         try {
@@ -79,9 +88,11 @@ export class Document {
             wasm.document__commitField(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), addHeapObject(value));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -93,10 +104,12 @@ export class Document {
      * diagnostic contract as [`storeFields`](Document::store_fields) — nothing
      * applied on error, one `diagnostics` entry per offending field, including
      * `edit::unknown_field` for undeclared names. Throws on an out-of-range
-     * card.
+     * card. Returns [`commitField`](Document::commit_field)'s warnings for
+     * every field, in batch order.
      * @param {Quill} quill
      * @param {CardAddr} addr
      * @param {Record<string, unknown>} fields
+     * @returns {Diagnostic[]}
      */
     _commitFields(quill, addr, fields) {
         try {
@@ -105,9 +118,11 @@ export class Document {
             wasm.document__commitFields(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), addHeapObject(fields));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -228,14 +243,40 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * The ABI under `writer.reviseDocument`: a whole-document revise, then
+     * conform against `quill`. Throws when `markdown` declares a `$quill` this quill
+     * does not answer to, before any mutation.
+     * @param {Quill} quill
+     * @param {string} markdown
+     * @returns {DocumentRevised}
+     */
+    _reviseDocument(quill, markdown) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document__reviseDocument(retptr, this.__wbg_ptr, quill.__wbg_ptr, 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 takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Revise the content field at `addr` from authored text, typed *and*
      * anchor-preserving: the ABI under `writer.reviseField`. Surviving anchors
      * rebase as in [`revise`](Self::revise), then the diffed result is
      * schema-conformed, so a `richtext(inline)` field rejects a multi-block
-     * result with `edit::field_not_inline`. Returns the text `Delta`. The codec
-     * is the declared type's: `richtext` diffs markdown, `plaintext` literal
-     * text.
+     * result with `edit::field_not_inline`. Returns the `Revised` receipt, its
+     * warnings anchored at the field. The codec is the declared type's:
+     * `richtext` diffs markdown, `plaintext` literal text, which drops nothing.
      *
      * `addr` must name a field; a body address throws, since a body carries no
      * field schema (use [`revise`](Self::revise)). An undeclared name throws
@@ -243,7 +284,7 @@ export class Document {
      * @param {Quill} quill
      * @param {Addr | string} addr
      * @param {string} text
-     * @returns {Delta}
+     * @returns {Revised}
      */
     _reviseField(quill, addr, text) {
         try {
@@ -861,16 +902,18 @@ export class Document {
     /**
      * **Revise** the richtext value at `addr` from a markdown string: the
      * default write path. Imports the markdown, diffs it against the current
-     * value, rebases surviving identity anchors, and returns the text `Delta` an
-     * editor bridge maps its own positions through (`mapPos`). An absent
-     * `addr.field` targets the body, an absent `addr.card` the main card; an
-     * absent field cold-imports from empty.
+     * value, rebases surviving identity anchors, and returns the `Revised`
+     * receipt: the text `delta` an editor bridge maps its own positions through
+     * (`mapPos`), and a `parse::dropped_construct` warning per construct the
+     * import dropped, its `path` the address written. An absent `addr.field`
+     * targets the body, an absent `addr.card` the main card; an absent field
+     * cold-imports from empty.
      *
      * Throws on an out-of-range card, a malformed field name, a present
      * non-content field value, or an over-nested markdown input.
      * @param {Addr | string} addr
      * @param {string} markdown
-     * @returns {Delta}
+     * @returns {Revised}
      */
     revise(addr, markdown) {
         try {
@@ -1051,8 +1094,33 @@ export class Document {
         }
     }
     /**
-     * Emit canonical Quillmark Markdown. Round-trip safe: re-parsing the
-     * result produces a `Document` equal to `self` by value and by type.
+     * `toMarkdown` with each prose anchor of every body and content field
+     * spelled read-only at its start where its line can hold the tag, and
+     * listed with its field's path and line either way. An import drops every
+     * tag, so `writer.reviseDocument` with the markdown keeps the anchors it keeps
+     * with `toMarkdown`'s.
+     * @returns {AnnotatedMarkdown}
+     */
+    toAnnotatedMarkdown() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_toAnnotatedMarkdown(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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Emit canonical Quillmark Markdown. Re-parsing the result produces a
+     * `Document` equal to `self` by value and by type, but for content: a body
+     * or content field holds what its markdown spells, so its anchors drop and
+     * its island ids re-mint. `toStored` keeps both.
      * @returns {string}
      */
     toMarkdown() {
@@ -1098,7 +1166,7 @@ export class Document {
      * The non-fatal diagnostics of the load that produced this document: parse
      * warnings, plus `conform::*` warnings when it came through `quill.parse`.
      * Session state, not document value: `equals` and the storage DTO exclude
-     * it, and `fromStored` / `loadStored` clear it.
+     * it, and `fromStored` / `loadStored` / `writer.reviseDocument` clear it.
      * @returns {Diagnostic[]}
      */
     get warnings() {
@@ -1166,6 +1234,28 @@ export class LiveSession {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Each address the current compile fills that a reader could want to
+     * click, and the `DocPath` of the region reaching it: the address itself,
+     * the nearest enclosing one a region carries (a row claim reaching its
+     * cells), or `undefined` where no click does. Reflects the current compile.
+     * @returns {FieldCoverage[]}
+     */
+    coverage() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.livesession_coverage(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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * The schema field whose content is under a point on `page`: the `DocPath`
      * address to focus in the editor, or `undefined` off any field's ink.
@@ -1206,9 +1296,9 @@ export class LiveSession {
     /**
      * The whole-field highlight boxes for `field`: one union rect per page over
      * the field's `span`-bearing content segments, the union `regions()` leaves
-     * derived. **Content only**: a field placed solely as a scalar reference or
-     * a bound widget carries no `span` and returns `[]`, its box being a single
-     * `regions()` rect. Reflects the current compile.
+     * derived. **Content only**: a field placed solely as a scalar's ink, a
+     * claim or a bound widget carries no `span` and returns `[]`, its box being
+     * a single `regions()` rect. Reflects the current compile.
      * @param {string} field
      * @returns {FieldRegion[]}
      */
@@ -1347,9 +1437,9 @@ export class LiveSession {
         }
     }
     /**
-     * Schema-field geometry for this compiled session: each content field's
-     * **first placement** (one region per page it touches) plus widget and
-     * scalar-reference-site regions, keyed on the canonical `DocPath` address. A
+     * Schema-field geometry for this compiled session: each piece of generated
+     * ink's **first placement** (one region per page it touches) plus claim and
+     * widget regions, keyed on the canonical `DocPath` address. A
      * field may appear more than once, so group by `field` (see `FieldRegion`).
      * A session-level query: no render, no byte artifact. The click direction is
      * `fieldAt`. Empty for backends that place no schema fields.
@@ -1763,9 +1853,10 @@ export class Quill {
         return takeObject(ret);
     }
     /**
-     * Validate `doc` against this quill's schema, returning every diagnostic
-     * (empty when the document is valid). Forwards the canonical
-     * `validation::*` diagnostics the engine emits.
+     * Validate `doc` against this quill's schema, returning every diagnostic:
+     * an error blocks a render, a warning does not. Forwards the engine's
+     * `validation::*`, a markdown string's `parse::dropped_construct` and the
+     * backend's `backend::declined_construct`.
      * @param {Document} doc
      * @returns {Diagnostic[]}
      */
@@ -1859,9 +1950,10 @@ export class Quillmark {
     }
     /**
      * Render `doc` against `quill` in one shot: `open` + `LiveSession.render`,
-     * with `doc.warnings`, then every `quill.validate` warning, ahead of the
-     * compile's in `warnings`. An unset `output_format` falls back to the
-     * backend's first supported format. `today` reads as on `open`.
+     * with every `quill.validate` warning in `warnings`, a decline among the
+     * compile's and the rest ahead of them; the load's stay on `doc.warnings`.
+     * An unset `output_format` falls back to the backend's first supported
+     * format. `today` reads as on `open`.
      * @param {Quill} quill
      * @param {Document} doc
      * @param {RenderOptions | null} [opts]
@@ -1983,7 +2075,7 @@ export function formatDiagnostic(diagnostic) {
 }
 
 /**
- * Serialize structured [`DocPathSeg`] segments back to the canonical path
+ * Serialize structured `DocPathSeg` segments back to the canonical path
  * string: the inverse of `parseDocPath`. Throws on a segment array the
  * deserializer rejects, and on an empty one.
  * @param {DocPathSeg[]} segs
@@ -2015,11 +2107,13 @@ export function formatDocPath(segs) {
 }
 
 /**
- * Import a markdown string to canonical `Content`: the pure, document-free
- * codec. `overwrite(addr, importMarkdown(md))` spells the cold, anchor-losing
- * write; prefer `revise` for edit semantics. Throws on an over-nested input.
+ * Import a markdown string: the pure, document-free codec. Returns the
+ * canonical `content` and a `parse::dropped_construct` warning per construct
+ * the import dropped, with no `path`. `overwrite(addr, importMarkdown(md).content)`
+ * spells the cold, anchor-losing write; prefer `revise` for edit semantics.
+ * Throws on an over-nested input.
  * @param {string} markdown
- * @returns {Content}
+ * @returns {Imported}
  */
 export function importMarkdown(markdown) {
     try {
@@ -2152,7 +2246,7 @@ export function mapPos(delta, pos, assoc) {
 
 /**
  * Parse a canonical document-model `Diagnostic.path` (`cards.<kind>[<i>].<field>`,
- * `main.body`, `recipients[0].name`) into structured [`DocPathSeg`] segments, so
+ * `main.body`, `recipients[0].name`) into structured `DocPathSeg` segments, so
  * a consumer routes on segments instead of regexing the string. Throws on a
  * malformed path.
  * @param {string} path
@@ -2178,12 +2272,13 @@ export function parseDocPath(path) {
 
 /**
  * Rebase `markdown` onto a `base` content: the document-free twin of `revise`,
- * returning the new `content` and the text `delta` (offsets are USV indices into
- * `Content.text`, surviving anchors rebased). Throws on an over-nested markdown
- * input or a non-content `base`.
+ * returning the new `content`, the text `delta` (offsets are USV indices into
+ * `Content.text`, surviving anchors rebased), and the import's
+ * `parse::dropped_construct` warnings, with no `path`. Throws on an
+ * over-nested markdown input or a non-content `base`.
  * @param {Content} base
  * @param {string} markdown
- * @returns {{ content: Content; delta: Delta }}
+ * @returns {{ content: Content; delta: Delta; warnings: Diagnostic[] }}
  */
 export function rebase(base, markdown) {
     try {
@@ -2352,10 +2447,6 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).getMonth();
             return ret;
         },
-        __wbg_getOwnPropertyNames_f8299644de14134c: function(arg0) {
-            const ret = Object.getOwnPropertyNames(getObject(arg0));
-            return addHeapObject(ret);
-        },
         __wbg_getPrototypeOf_4e7d85b5bf38d546: function() { return handleError(function (arg0) {
             const ret = Reflect.getPrototypeOf(getObject(arg0));
             return addHeapObject(ret);
@@ -2396,6 +2487,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Error_80a725f81f2e102d: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Map_b2611749102d7ba3: function(arg0) {
             let result;
             try {
@@ -2446,6 +2547,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).length;
             return ret;
         },
+        __wbg_message_5f8387f0c32b90a7: function(arg0) {
+            const ret = getObject(arg0).message;
+            return addHeapObject(ret);
+        },
         __wbg_new_0_72d020f0c63443d4: function() {
             const ret = new Date();
             return addHeapObject(ret);
@@ -2490,6 +2595,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).next();
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_ownKeys_7f46b96dc7311fe8: function() { return handleError(function (arg0) {
+            const ret = Reflect.ownKeys(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },

package/render/wasm_bg.wasm.d.ts

@@ -11,6 +11,7 @@ export const document__commitFields: (a: number, b: number, c: number, d: number
 export const document__readerGet: (a: number, b: number, c: number, d: number) => void;
 export const document__readerGetContent: (a: number, b: number, c: number, d: number) => void;
 export const document__readerGetContentAt: (a: number, b: number, c: number, d: number, e: number) => void;
+export const document__reviseDocument: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document__reviseField: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const document_applyChange: (a: number, b: number, c: number, d: number) => void;
 export const document_bodyMarkdown: (a: number, b: number, c: number) => void;
@@ -47,6 +48,7 @@ export const document_storeExt: (a: number, b: number, c: number, d: number) =>
 export const document_storeField: (a: number, b: number, c: number, d: number) => void;
 export const document_storeFields: (a: number, b: number, c: number, d: number) => void;
 export const document_storeSeedOverlay: (a: number, b: number, c: number, d: number, e: number) => void;
+export const document_toAnnotatedMarkdown: (a: number, b: number) => void;
 export const document_toMarkdown: (a: number, b: number) => void;
 export const document_toStored: (a: number, b: number) => void;
 export const document_warnings: (a: number, b: number) => void;
@@ -57,6 +59,7 @@ export const importMarkdown: (a: number, b: number, c: number) => void;
 export const isInline: (a: number, b: number) => void;
 export const isPlain: (a: number, b: number) => void;
 export const livesession_backendId: (a: number, b: number) => void;
+export const livesession_coverage: (a: number, b: number) => void;
 export const livesession_fieldAt: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const livesession_fieldBoxes: (a: number, b: number, c: number, d: number) => void;
 export const livesession_locate: (a: number, b: number, c: number, d: number, e: number) => void;

package/runtime/runtime.d.ts

@@ -117,7 +117,7 @@ export type {
 } from '../core/wasm.js';
 
 // Content edit vocabulary: the op-grained content model `Document`'s methods
-// speak (`applyChange(addr, bundle)`, `overwrite(addr, rt)`, `revise(…) => Delta`).
+// speak (`applyChange(addr, bundle)`, `overwrite(addr, rt)`, `revise(…) => Revised`).
 // `ContentLineKind` is the shared half of `ContentLine` and `setKind`, and
 // `ContentMarkKind` of `ContentMark` and a mark op's `add` / `remove`: lifting a
 // read value's kind whole — destructure off the envelope, spread the rest into
@@ -139,6 +139,11 @@ export type {
 	Addr,
 	CardAddr,
 	Delta,
+	Revised,
+	DocumentRevised,
+	AnnotatedMarkdown,
+	DocumentAnchor,
+	Imported,
 	Assoc,
 	IslandOp,
 	LineOp,
@@ -328,14 +333,30 @@ export interface FieldRegion {
 	rect: [number, number, number, number];
 	/**
 	 * The content slice this box covers: USV `[start, end)` into the field's
-	 * `Content` for content ink (one segment), absent for a scalar reference
-	 * site or widget. Consumers key segment highlights on it;
+	 * `Content` for content ink (one segment), absent for a scalar's or a
+	 * date's ink, a claim or a widget. Consumers key segment highlights on it;
 	 * {@link LiveSession.fieldBoxes} unions same-page segments for the
 	 * whole-field box.
 	 */
 	span?: [number, number];
 }
 
+/**
+ * One address a compiled document fills, and the region address a click
+ * reaches it through. A report, not a gate: a field a quill never prints is
+ * legitimately unreachable.
+ */
+export interface FieldCoverage {
+	/** The field's canonical `DocPath` address, as {@link FieldRegion.field}. */
+	field: string;
+	/**
+	 * The `DocPath` of the region reaching `field`: `field` itself, or the
+	 * nearest enclosing address a region carries (a row claim reaching its
+	 * cells, a whole array its elements). Absent where no click reaches it.
+	 */
+	coveredBy?: string;
+}
+
 /** Result of one render. */
 export interface RenderResult {
 	artifacts: Artifact[];
@@ -410,11 +431,12 @@ export declare class Engine {
 	 * synchronously before the first await, so the caller may `free()` them as
 	 * soon as this call returns.
 	 *
-	 * {@link RenderResult.warnings} carries the whole pipeline's, in order:
-	 * `doc.warnings` (parse and `conform::*`), every `quill.validate(doc)`
-	 * warning, then the compile's own. A {@link LiveSession} outlives the
-	 * document it opened from, so {@link LiveSession.render} carries the
-	 * compile's alone: read `doc.warnings` and `quill.validate(doc)` beside it.
+	 * {@link RenderResult.warnings} carries every `quill.validate(doc)` warning
+	 * but `backend::declined_construct`, then the compile's own, a decline among
+	 * them. The load's (parse
+	 * and `conform::*`) stay on `doc.warnings`, and a revise's on its receipt.
+	 * A {@link LiveSession} carries the compile's alone: read
+	 * `quill.validate(doc)` beside it.
 	 *
 	 * `today` reads as on {@link open}. An `options` key outside
 	 * {@link RenderOptions} rejects, `today` among them.
@@ -489,22 +511,27 @@ export declare class LiveSession {
 	 * Empty for backends that place no schema fields.
 	 *
 	 * `field` is **not** unique: a content field surfaces its **first placement**
-	 * as one {@link FieldRegion} per page that placement touches, a scalar
-	 * referenced at several plate sites surfaces each site, and tracked content
-	 * plus a `field:`-bound widget yields both, widget first. Group by `field`.
-	 * Later placements of one content value are not enumerated; {@link fieldAt}
-	 * still resolves clicks on them.
+	 * as one {@link FieldRegion} per page that placement touches, each claim on
+	 * a field surfaces its own, and tracked content plus a `field:`-bound widget
+	 * yields both, widget first. Group by `field`. Later placements of one value
+	 * are not enumerated; {@link fieldAt} still resolves clicks on them.
 	 */
 	regions(): FieldRegion[];
 	/**
 	 * The whole-field highlight boxes for `field` (a canonical `DocPath` address,
 	 * as {@link regions} keys): one union rect per page over the field's
 	 * `span`-bearing content segments, the union {@link regions} leaves derived.
-	 * **Content only**: a field placed solely as a scalar reference or a bound
-	 * widget carries no `span` and returns `[]`, its box being a single
+	 * **Content only**: a field placed solely as a scalar's ink, a claim or a
+	 * bound widget carries no `span` and returns `[]`, its box being a single
 	 * {@link regions} rect. Reflects the current compile.
 	 */
 	fieldBoxes(field: string): FieldRegion[];
+	/**
+	 * Every address the current compile fills that a reader could want to
+	 * click — each non-blank declared leaf, every roster member held or not —
+	 * with the region reaching it. Reflects the current compile.
+	 */
+	coverage(): FieldCoverage[];
 	/**
 	 * The schema field whose content is under a point on `page`: the canonical
 	 * `DocPath` address to focus in the editor, or `undefined` off any field's
@@ -591,7 +618,7 @@ declare module '../core/wasm.js' {
 	}
 }
 
-import type { Addr, Content, Delta, PathStep, Resolved } from '../core/wasm.js';
+import type { Addr, Content, DocumentRevised, PathStep, Resolved, Revised } from '../core/wasm.js';
 
 /**
  * A `Document` bound to its `Quill` for typed writes, from {@link Quill.writer}.
@@ -611,40 +638,57 @@ export declare class DocumentWriter {
 	readonly document: Document;
 	/**
 	 * Typed-commit one main-card field (strict coerce, mismatch throws now).
-	 * Throws `UnknownField` for a name the schema does not declare.
+	 * Throws `UnknownField` for a name the schema does not declare. Returns a
+	 * `parse::dropped_construct` warning per construct a `richtext` markdown
+	 * string in the value dropped, at the string's path.
 	 */
-	set(name: string, value: unknown): void;
+	set(name: string, value: unknown): Diagnostic[];
 	/**
 	 * Typed-commit several main-card fields atomically: nothing is applied on
 	 * error (throws a {@link QuillmarkError} carrying one diagnostic per
 	 * offending field, including an `UnknownField` for each undeclared name).
+	 * Returns `set`'s warnings for every field, in batch order.
 	 */
-	setAll(fields: Record<string, unknown>): void;
+	setAll(fields: Record<string, unknown>): Diagnostic[];
 	/**
-	 * Revise the main body from markdown; anchors rebase. Returns the text
-	 * `Delta`: a body carries no field schema to type against, so this is the
-	 * content lane's `revise` reached through the writer.
+	 * Revise the main body from markdown; anchors rebase. Returns the
+	 * `Revised` receipt, its warnings at `main.body`: a body carries no field
+	 * schema to type against, so this is the content lane's `revise` reached
+	 * through the writer.
 	 */
-	reviseBody(markdown: string): Delta;
+	reviseBody(markdown: string): Revised;
 	/**
 	 * Revise the content main-card field `name` from authored text: typed *and*
 	 * anchor-preserving. Surviving anchors rebase, then the diffed result is
 	 * schema-conformed (`richtext(inline)` rejects a multi-block result). Throws
-	 * `UnknownField` for a name the schema does not declare. Returns the `Delta`.
+	 * `UnknownField` for a name the schema does not declare. Returns the
+	 * `Revised` receipt, its warnings at the field.
 	 *
 	 * The codec comes from the declared type: `richtext` diffs markdown, while
 	 * `plaintext` diffs the literal text and never imports markdown, so a
 	 * byte-identical revise of a value carrying escapes is a byte no-op.
 	 */
-	reviseField(name: string, text: string): Delta;
+	reviseField(name: string, text: string): Revised;
+	/**
+	 * Replace the bound document with `markdown`, then conform it. Composable
+	 * cards align to the stored ones by `$kind` and text similarity, an aligned
+	 * card's body and stored content fields revise, their anchors rebasing as
+	 * {@link reviseBody}'s do, and every declared content field lands at rest.
+	 * Returns the `DocumentRevised` receipt, its `warnings` ending with the
+	 * `conform::*` ones, and clears `doc.warnings`. Throws when `markdown`
+	 * declares a `$quill` this quill does not answer to, or does not parse,
+	 * leaving the document unchanged.
+	 */
+	reviseDocument(markdown: string): DocumentRevised;
 	/**
 	 * Build a composable card of `kind`, typed-commit `fields` onto it, set its
 	 * body from optional markdown, and place it. `at` omitted appends, a number
 	 * inserts at that index. Transactional: a rejected field (throwing a per-field
 	 * diagnostic bundle) or an invalid kind, body, or position leaves the document
-	 * untouched.
+	 * untouched. Returns the fields' `parse::dropped_construct` warnings, then
+	 * the body import's, anchored under the placed card.
 	 */
-	addCard(kind: string, fields?: Record<string, unknown>, body?: string, at?: number): void;
+	addCard(kind: string, fields?: Record<string, unknown>, body?: string, at?: number): Diagnostic[];
 	/** Remove the composable card at `index`, returning it (or `undefined`). */
 	removeCard(index: number): Card | undefined;
 	/**
@@ -672,15 +716,18 @@ export declare class CardWriter {
 	 * index.
 	 */
 	readonly kind: string;
-	set(name: string, value: unknown): void;
-	setAll(fields: Record<string, unknown>): void;
-	/** Revise this card's body from markdown (edit semantics), returning the text `Delta`. */
-	reviseBody(markdown: string): Delta;
+	set(name: string, value: unknown): Diagnostic[];
+	setAll(fields: Record<string, unknown>): Diagnostic[];
+	/**
+	 * Revise this card's body from markdown (edit semantics), returning the
+	 * `Revised` receipt, its warnings at the card's body.
+	 */
+	reviseBody(markdown: string): Revised;
 	/**
 	 * The card twin of {@link DocumentWriter.reviseField}. Throws `UnknownField`
 	 * for an undeclared name and `IndexOutOfRange` for a bad bound index.
 	 */
-	reviseField(name: string, text: string): Delta;
+	reviseField(name: string, text: string): Revised;
 }
 
 /**