@quillmark/wasm 0.123.1 → 0.124.0

package/core/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() {
@@ -1441,8 +1499,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[]}
@@ -1557,7 +1615,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
@@ -1589,11 +1647,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 {
@@ -1726,7 +1786,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
@@ -1752,12 +1812,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 {
@@ -1918,10 +1979,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);
@@ -1952,6 +2009,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 {
@@ -1992,6 +2059,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);
@@ -2032,6 +2103,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/core/wasm_bg.wasm.d.ts

@@ -9,6 +9,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;
@@ -45,6 +46,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/package.json

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

package/render/wasm.d.ts

@@ -105,10 +105,17 @@ export type ContentLineKind =
 export type ContentContainer =
 | {
     container: "list_item";
-    attrs: { ordered: boolean; start: number; ordinal: number };
+    /** `checked` is present on a task item: `true` ticked, `false` open. */
+    attrs: { ordered: boolean; start: number; ordinal: number; checked?: boolean };
     instance?: number;
 }
-| { container: "quote"; instance?: number };
+| { container: "quote"; 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 };
 
 /** 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
@@ -131,20 +138,33 @@ export type ContentMarkKind =
 export interface TableCell {
     text: string;
     marks: ContentMark[];
+    /** The cell's horizontal alignment; absent is its column's. */
+    align?: "left" | "center" | "right";
+    /** The cell's vertical alignment; absent is the quill's. */
+    valign?: "top" | "middle" | "bottom";
 }
 
 /** `props` of a `type: "table"` island: a pipe table normalized to one column
- * count that `header`, every row of `rows`, and `aligns` all share. */
+ * count that `header`, every row of `rows`, `aligns` and `widths` all share.
+ * A layout key at its default is absent. */
 export interface TableProps {
     header: TableCell[];
     rows: TableCell[][];
     /** Per-column alignment, one entry per column. */
     aligns: ("none" | "left" | "center" | "right")[];
+    /** Per-column relative weights; `null` is an auto-fit column. Absent when
+     * every column is auto-fit. A weight is an integer from 1 to
+     * `Number.MAX_SAFE_INTEGER`; any other entry drops the key. */
+    widths?: (number | null)[];
+    /** The table's placement; absent is the quill's. */
+    align?: "left" | "center" | "right";
+    /** `true` draws `header` as the first body row; absent is a header row. */
+    headless?: true;
 }
 
 /** `props` of a `type: "image"` island. Stores and round-trips; no backend
  * typesets one, and a render that holds one warns `backend::declined_construct`,
- * because what `url` names is undecided. */
+ * because no backend resolves `url`. */
 export interface ImageProps {
     url: string;
     alt: string;
@@ -205,6 +225,51 @@ export interface Delta {
     ops: ({ retain: number } | { insert: string } | { delete: number })[];
 }
 
+/**
+ * The receipt of a markdown revise (`revise`, `writer.reviseBody`,
+ * `writer.reviseField`): the text `delta`, and one `parse::dropped_construct`
+ * warning per construct the import dropped, anchored at the revised address.
+ */
+export interface Revised {
+    delta: Delta;
+    warnings: Diagnostic[];
+}
+
+/**
+ * The receipt of `writer.reviseDocument`. `droppedAnchors` names every prose
+ * anchor the write did not carry, at its path in the stored document; a table
+ * cell's anchors drop unnamed. `warnings` are the parse's, then each revised
+ * content field's `parse::dropped_construct`, then the writer's `conform::*`.
+ * A field that lands rather than revises, on an inserted card or over no stored
+ * content, reports no drop.
+ */
+export interface DocumentRevised {
+    droppedAnchors: { path: string; id: string }[];
+    warnings: Diagnostic[];
+}
+
+/**
+ * The read `toAnnotatedMarkdown` returns: `toMarkdown`'s markdown with a
+ * read-only `<qm-anchor ref="…"></qm-anchor>` at each prose anchor's
+ * start its line can hold, and every prose anchor of every body and content
+ * field, spelled or not; a table cell's anchors are neither. Each names the
+ * `path` of its body or field and the text of the `line` its start sits on,
+ * island slots removed.
+ */
+export interface AnnotatedMarkdown {
+    markdown: string;
+    anchors: { id: string; path: string; line: string }[];
+}
+
+/**
+ * A markdown import (`importMarkdown`): the canonical `content`, and one
+ * `parse::dropped_construct` warning per construct it dropped, with no `path`.
+ */
+export interface Imported {
+    content: Content;
+    warnings: Diagnostic[];
+}
+
 /** Which side of a same-position insertion `mapPos` lands a point on. */
 export type Assoc = "before" | "after";
 
@@ -596,8 +661,8 @@ export interface Diagnostic {
     message: string;
     location?: Location;
     /**
-     * Document-model path anchor (e.g. `"cards.indorsement[0].signature_block"`),
-     * set on schema validation diagnostics and `undefined` otherwise.
+     * Document-model path anchor (e.g. `"cards.indorsement[0].signature_block"`)
+     * where the diagnostic has a document address, `undefined` otherwise.
      */
     path?: string;
     hint?: string;
@@ -828,15 +893,17 @@ 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.
      */
-    revise(addr: Addr | string, markdown: string): Delta;
+    revise(addr: Addr | string, markdown: string): Revised;
     /**
      * The main card's `$seed[kind]` overlay object, or `undefined`. Feeds
      * `quill.seedCard(kind, overlay)` without serializing the whole main card,
@@ -889,8 +956,18 @@ export class Document {
      */
     storeSeedOverlay(card_kind: string, overlay: any): void;
     /**
-     * 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.
+     */
+    toAnnotatedMarkdown(): AnnotatedMarkdown;
+    /**
+     * 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.
      */
     toMarkdown(): string;
     /**
@@ -914,7 +991,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.
      */
     readonly warnings: Diagnostic[];
 }
@@ -1119,8 +1196,8 @@ export class Quill {
      */
     toTree(): Map<string, Uint8Array>;
     /**
-     * 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.
      */
     validate(doc: Document): Diagnostic[];
@@ -1165,9 +1242,11 @@ export class Quillmark {
     open(quill: Quill, doc: Document, today?: string | null): LiveSession;
     /**
      * 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`.
      */
     render(quill: Quill, doc: Document, opts?: RenderOptions | null, today?: string | null): RenderResult;
     /**
@@ -1198,18 +1277,20 @@ export function exportMarkdown(rt: Content): string;
 export function formatDiagnostic(diagnostic: Diagnostic): string;
 
 /**
- * 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.
  */
 export function formatDocPath(segs: DocPathSeg[]): string;
 
 /**
- * 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.
  */
-export function importMarkdown(markdown: string): Content;
+export function importMarkdown(markdown: string): Imported;
 
 /**
  * Whether `content` satisfies the `inline` constraint of `richtext` and
@@ -1257,7 +1338,7 @@ export function mapPos(delta: Delta, pos: number, assoc: Assoc): number;
 
 /**
  * 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.
  */
@@ -1265,11 +1346,12 @@ export function parseDocPath(path: string): DocPathSeg[];
 
 /**
  * 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`.
  */
-export function rebase(base: Content, markdown: string): { content: Content; delta: Delta };
+export function rebase(base: Content, markdown: string): { content: Content; delta: Delta; warnings: Diagnostic[] };
 
 /**
  * Runs at instantiation, so a Rust panic reaches the console as a stack trace
@@ -1292,6 +1374,7 @@ export interface InitOutput {
     readonly document__readerGet: (a: number, b: number, c: number, d: number) => void;
     readonly document__readerGetContent: (a: number, b: number, c: number, d: number) => void;
     readonly document__readerGetContentAt: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document__reviseDocument: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly document__reviseField: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly document_applyChange: (a: number, b: number, c: number, d: number) => void;
     readonly document_bodyMarkdown: (a: number, b: number, c: number) => void;
@@ -1328,6 +1411,7 @@ export interface InitOutput {
     readonly document_storeField: (a: number, b: number, c: number, d: number) => void;
     readonly document_storeFields: (a: number, b: number, c: number, d: number) => void;
     readonly document_storeSeedOverlay: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document_toAnnotatedMarkdown: (a: number, b: number) => void;
     readonly document_toMarkdown: (a: number, b: number) => void;
     readonly document_toStored: (a: number, b: number) => void;
     readonly document_warnings: (a: number, b: number) => void;