@quillmark/wasm 0.123.0 → 0.124.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 body import's `parse::dropped_construct` warnings, anchored
+     * at the placed card's body.
      * @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);
         }
@@ -228,14 +233,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 +274,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 +892,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 +1084,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 +1156,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() {
@@ -1763,8 +1821,8 @@ 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
+     * Validate `doc` against this quill's schema, returning every diagnostic:
+     * an error blocks a render, a warning does not. Forwards the canonical
      * `validation::*` diagnostics the engine emits.
      * @param {Document} doc
      * @returns {Diagnostic[]}
@@ -1859,9 +1917,11 @@ 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 but `validation::declined_construct`,
+     * which the compile raises as `backend::declined_construct`, ahead of the
+     * compile's in `warnings`; 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 +2043,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 +2075,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 +2214,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 +2240,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 +2415,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 +2455,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 +2515,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 +2563,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;

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,10 @@ export type {
 	Addr,
 	CardAddr,
 	Delta,
+	Revised,
+	DocumentRevised,
+	AnnotatedMarkdown,
+	Imported,
 	Assoc,
 	IslandOp,
 	LineOp,
@@ -410,11 +414,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 `validation::declined_construct`, which the compile raises as
+	 * `backend::declined_construct`, then the compile's own. 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.
@@ -591,7 +596,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}.
@@ -621,30 +626,44 @@ export declare class DocumentWriter {
 	 */
 	setAll(fields: Record<string, unknown>): void;
 	/**
-	 * 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 body import's `parse::dropped_construct` warnings,
+	 * anchored at the placed card's body.
 	 */
-	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;
 	/**
@@ -674,13 +693,16 @@ export declare class CardWriter {
 	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;
+	/**
+	 * 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;
 }
 
 /**

package/runtime/runtime.js

@@ -162,11 +162,11 @@ function quillmarkError(code, message, hint) {
 }
 
 /**
- * Throw on options that are not a plain object, or on an own key of them
- * outside `known`. The JS twin of the binding's `reject_unknown_keys`, in the
- * uncoded shape it throws: a misspelled optional key would otherwise read as
- * absent, and a read reaches a key up the prototype chain that no own-key walk
- * sees.
+ * Throw on options that are not a plain object, or on a key of them, or of a
+ * null-prototype object they inherit from, outside `known`. The JS twin of the
+ * binding's `reject_unknown_keys`, in the uncoded shape it throws: a misspelled
+ * optional key would otherwise read as absent, and a read reaches a key up the
+ * prototype chain that no own-key walk sees.
  * @param {unknown} options
  * @param {string[]} known
  * @param {string} what the options' name, for the message
@@ -174,8 +174,28 @@ function quillmarkError(code, message, hint) {
  */
 function rejectUnknownKeys(options, known, what) {
 	if (options == null) return;
-	const proto = Object.getPrototypeOf(options);
 	let message;
+	try {
+		message = unknownKeyRefusal(options, known, what);
+	} catch (e) {
+		const cause = e instanceof Error ? e.message : String(e);
+		message = `${what} must be a plain object, not one whose read throws: ${cause}`;
+	}
+	if (message === undefined) return;
+	const err = /** @type {any} */ (new Error(message));
+	err.diagnostics = [{ severity: 'error', message }];
+	throw err;
+}
+
+/**
+ * The refusal `rejectUnknownKeys` throws, if any. A `Proxy` trap may throw.
+ * @param {unknown} options
+ * @param {string[]} known
+ * @param {string} what
+ * @returns {string | undefined}
+ */
+function unknownKeyRefusal(options, known, what) {
+	const proto = Object.getPrototypeOf(options);
 	if (proto !== null && Object.getPrototypeOf(proto) !== null) {
 		const passed =
 			options instanceof Map
@@ -183,15 +203,16 @@ function rejectUnknownKeys(options, known, what) {
 				: typeof options === 'object'
 					? 'one inheriting from another object'
 					: `a ${typeof options}`;
-		message = `${what} must be a plain object, not ${passed}`;
-	} else {
-		const key = Object.getOwnPropertyNames(options).find((k) => !known.includes(k));
-		if (key === undefined) return;
-		message = `${what} have unknown key \`${key}\`; ${what} take only \`${known.join('`, `')}\``;
+		return `${what} must be a plain object, not ${passed}`;
 	}
-	const err = /** @type {any} */ (new Error(message));
-	err.diagnostics = [{ severity: 'error', message }];
-	throw err;
+	const keys = Object.getOwnPropertyNames(options);
+	if (proto !== null) {
+		const builtin = Object.getOwnPropertyNames(Object.prototype);
+		keys.push(...Object.getOwnPropertyNames(proto).filter((k) => !builtin.includes(k)));
+	}
+	const key = keys.find((k) => !known.includes(k));
+	if (key === undefined) return undefined;
+	return `${what} have unknown key \`${key}\`; ${what} take only \`${known.join('`, `')}\``;
 }
 
 // These checks deliver the ERROR, not the rejection, at the seams that cross
@@ -263,9 +284,10 @@ function requireLocalQuill(quill, method) {
 // `runtime.test.js` § "container run boundaries" stamps a pair and re-imports
 // it, where `Content::normalize` re-mints against the Rust predicate. A tag the
 // table omits welds with nothing, so `tests/known_names_drift.rs` pins that
-// every container has an entry.
+// every container has an entry. An entry of `'*'` welds on the whole bag: an
+// element's attributes are open, its name among them.
 
-const WELD_KEYS = { list_item: ['ordered'], quote: [] };
+const WELD_KEYS = { list_item: ['ordered'], quote: [], element: '*' };
 
 /**
  * @param {import('../core/wasm.js').ContentContainer} a
@@ -278,7 +300,20 @@ function weldsWith(a, b) {
 	// `hasOwn`, so a tag colliding with an `Object.prototype` member answers
 	// `false` rather than reaching a function.
 	if (!Object.hasOwn(WELD_KEYS, a.container)) return false;
-	return WELD_KEYS[a.container].every((k) => a.attrs?.[k] === b.attrs?.[k]);
+	const keys = WELD_KEYS[a.container];
+	if (keys === '*') return sameBag(a.attrs, b.attrs);
+	return keys.every((k) => a.attrs?.[k] === b.attrs?.[k]);
+}
+
+/**
+ * @param {Record<string, unknown> | undefined} a
+ * @param {Record<string, unknown> | undefined} b
+ * @returns {boolean}
+ */
+function sameBag(a, b) {
+	const [x, y] = [a ?? {}, b ?? {}];
+	const keys = Object.keys(x);
+	return keys.length === Object.keys(y).length && keys.every((k) => Object.hasOwn(y, k) && x[k] === y[k]);
 }
 
 /**
@@ -510,16 +545,11 @@ export class Engine {
 	 * memory and run `fn` against the backend engine. Only `render`/`open` call
 	 * this, so `doc` is always present.
 	 *
-	 * OWNERSHIP WINDOW: both caller handles are snapshotted (`doc.toStored()` and
-	 * `doc.warnings`, and `quill.toTree()` on a clone-cache miss) BEFORE the first
-	 * await. The backend load below is a real suspension point, so reading the
+	 * OWNERSHIP WINDOW: both caller handles are snapshotted (`doc.toStored()`,
+	 * and `quill.toTree()` on a clone-cache miss) BEFORE the first await. The backend load below is a real suspension point, so reading the
 	 * handles after it would race a caller that `free()`s them as soon as this
 	 * call returns its promise ("null pointer passed to rust").
 	 *
-	 * `docWarnings` rides the context because the storage DTO does not carry
-	 * them: `fromStored` clears the load's warnings, so the backend clone knows
-	 * nothing of them and `render` splices the snapshot back in.
-	 *
 	 * Clone lifetimes differ by design: the `doc` clone is TRANSIENT, freed in
 	 * the `finally` of every call, while the `quill` clone is CACHED and is not
 	 * freed here — a `Quill` instance's contents never change after
@@ -528,13 +558,12 @@ export class Engine {
 	 * @param {string} method the caller's name, for the rejection message
 	 * @param {Quill} quill
 	 * @param {Document} doc
-	 * @param {(ctx: { mod: any, engine: any, quill: any, doc: any, docWarnings: any[] }) => any} fn
+	 * @param {(ctx: { mod: any, engine: any, quill: any, doc: any }) => any} fn
 	 */
 	async #withClones(method, quill, doc, fn) {
 		const backendId = this.#backendOf(quill, method);
 		requireLocalDoc(doc, method);
 		const docJson = doc.toStored();
-		const docWarnings = doc.warnings;
 		const quillTree = this.#quillClones.get(this.#descriptorFor(backendId).load)?.has(quill)
 			? null
 			: quill.toTree();
@@ -546,7 +575,7 @@ export class Engine {
 		let backendDoc = null;
 		try {
 			backendDoc = mod.Document.fromStored(docJson);
-			return fn({ mod, engine, quill: backendQuill, doc: backendDoc, docWarnings });
+			return fn({ mod, engine, quill: backendQuill, doc: backendDoc });
 		} finally {
 			backendDoc?.free();
 		}
@@ -564,11 +593,7 @@ export class Engine {
 			'engine.render(quill, doc)',
 			quill,
 			doc,
-			({ engine, quill: q, doc: d, docWarnings }) => {
-				const result = engine.render(q, d, options ?? undefined, today);
-				result.warnings = docWarnings.concat(result.warnings);
-				return result;
-			}
+			({ engine, quill: q, doc: d }) => engine.render(q, d, options ?? undefined, today)
 		);
 	}
 
@@ -756,7 +781,7 @@ export class DocumentWriter {
 	}
 	/**
 	 * @param {string} markdown
-	 * @returns {import('../core/wasm.js').Delta}
+	 * @returns {import('../core/wasm.js').Revised}
 	 */
 	reviseBody(markdown) {
 		return this.#doc.revise({}, markdown);
@@ -764,17 +789,24 @@ export class DocumentWriter {
 	/**
 	 * @param {string} name
 	 * @param {string} text
-	 * @returns {import('../core/wasm.js').Delta}
+	 * @returns {import('../core/wasm.js').Revised}
 	 */
 	reviseField(name, text) {
 		return this.#doc._reviseField(this.#quill, name, text);
 	}
+	/**
+	 * @param {string} markdown
+	 * @returns {import('../core/wasm.js').DocumentRevised}
+	 */
+	reviseDocument(markdown) {
+		return this.#doc._reviseDocument(this.#quill, markdown);
+	}
 	/**
 	 * @param {string} kind
 	 * @param {Record<string, unknown>} [fields]
 	 * @param {string} [body]
 	 * @param {number} [at] insertion index; appends when omitted
-	 * @returns {void}
+	 * @returns {import('../core/wasm.js').Diagnostic[]}
 	 */
 	addCard(kind, fields, body, at) {
 		return this.#doc._addCard(this.#quill, kind, fields, body, at);
@@ -837,7 +869,7 @@ export class CardWriter {
 	}
 	/**
 	 * @param {string} markdown
-	 * @returns {import('../core/wasm.js').Delta}
+	 * @returns {import('../core/wasm.js').Revised}
 	 */
 	reviseBody(markdown) {
 		return this.#doc.revise({ card: this.#index }, markdown);
@@ -845,7 +877,7 @@ export class CardWriter {
 	/**
 	 * @param {string} name
 	 * @param {string} text
-	 * @returns {import('../core/wasm.js').Delta}
+	 * @returns {import('../core/wasm.js').Revised}
 	 */
 	reviseField(name, text) {
 		return this.#doc._reviseField(this.#quill, { card: this.#index, field: name }, text);