@quillmark/wasm 0.115.0 → 0.117.0

package/render/wasm.js

@@ -294,30 +294,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * A blueprint's fill obligation for the given `quillName`, re-exposed from
-     * core. Carries no tool name: pair it with your own next-step directive.
-     * @param {string} quill_name
-     * @returns {string}
-     */
-    static blueprintInstruction(quill_name) {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(quill_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_blueprintInstruction(retptr, ptr0, len0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
-        }
-    }
     /**
      * The **body** markdown projection: an on-demand, lossy export (content-only
      * marks do not survive markdown). A body's type is a format fact, not a
@@ -454,27 +430,6 @@ export class Document {
         const ret = wasm.document_equals(this.__wbg_ptr, other.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Authoring-format rules for the card-yaml markdown surface, re-exposed from
-     * core. Constant across calls; read once and cache.
-     * @returns {string}
-     */
-    static formatRules() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_formatRules(retptr);
-            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);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
-        }
-    }
     /**
      * Parse markdown into a typed Document. Throws on parse errors.
      * @param {string} markdown
@@ -602,28 +557,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * Whether the field at `addr` is marked `!must_fill`. A bare string is `Addr`
-     * shorthand for `{ field }`. `false` for an absent field and for a body
-     * address; only an out-of-range `addr.card` throws.
-     * @param {Addr | string} addr
-     * @returns {boolean}
-     */
-    isFill(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_isFill(retptr, this.__wbg_ptr, addHeapObject(addr));
-            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;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
     /**
      * Replace this document's contents **in place** from a versioned storage DTO
      * string: the mutating twin of [`fromStored`](Document::from_stored).
@@ -666,6 +599,27 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * The Quillmark Markdown rules, re-exposed from core. Constant across
+     * calls; read once and cache.
+     * @returns {string}
+     */
+    static markdownRules() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_markdownRules(retptr);
+            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);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Move the card at `from` to position `to`. `from == to` is a no-op.
      * @param {number} from
@@ -688,8 +642,8 @@ export class Document {
      * A blank document: a main card carrying only `$quill`, an empty body, and
      * no composable cards. Absent fields resolve at render time (`default`, else
      * the field's blank), so nothing the caller did not set reaches the output.
-     * For an example-filled starter use `Quill.seedDocument()`. Throws on an
-     * invalid quill reference.
+     * For one instance of every card kind use `Quill.seedDocument()`. Throws on
+     * an invalid quill reference.
      * @param {string} quill_ref
      */
     constructor(quill_ref) {
@@ -1032,7 +986,7 @@ export class Document {
      * Store a field verbatim at `addr`, deferring coercion to render; the typed
      * write is [`commitField`](Document::commit_field). A bare string is `Addr`
      * shorthand for `{ field }`; `{ card: 2, field: "qty" }` targets a
-     * composable card. Clears any `!must_fill` marker. A body address throws:
+     * composable card. A body address throws:
      * write a body with `revise` / `overwrite`. Throws on an out-of-range card
      * or a malformed name.
      * @param {Addr | string} addr
@@ -1073,25 +1027,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * Store a field verbatim at `addr` and mark it `!must_fill`. A body address
-     * throws; same validation as [`storeField`](Document::store_field).
-     * @param {Addr | string} addr
-     * @param {any} value
-     */
-    storeFill(addr, value) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_storeFill(retptr, this.__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);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
     /**
      * Merge a card-kind's seed `overlay` into the **main** card's `$seed` map
      * under `cardKind`, preserving sibling kinds; `$seed` is main-only, so this
@@ -1235,15 +1170,17 @@ export class LiveSession {
      * 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.
      * `x`/`y` are PDF points with a **bottom-left** origin, the same space as
-     * `FieldRegion.rect`, so from a canvas click use
-     * `x = clickPx.x / renderScale`, `y = pageHeightPt - clickPx.y / renderScale`.
+     * `FieldRegion.rect`. A pointer event reports CSS pixels, so divide by the
+     * CSS px per point the page is shown at, `k = canvas.clientWidth /
+     * pageWidthPt`, not by `paint`'s `scale`, which carries `devicePixelRatio`:
+     * `x = e.offsetX / k`, `y = pageHeightPt - e.offsetY / k`.
      * Unlike `regions()`, *every* placement answers, not just the first.
      *
      * `tolPt` is how far off the ink a click still counts, in the same points,
      * and defaults to `0` — exact. Convert the pointer slack a surface wants
-     * from CSS pixels at the scale it drew the page (`slackPx / renderScale`),
-     * so it stays the same size under the cursor as the page zooms. The
-     * nearest placement answers, so raising it only fills a miss.
+     * from CSS pixels by the same `k` (`slackPx / k`), so it stays the same
+     * size under the cursor as the page zooms. The nearest placement answers,
+     * so raising it only fills a miss.
      * @param {number} page
      * @param {number} x
      * @param {number} y
@@ -1348,35 +1285,31 @@ export class LiveSession {
     }
     /**
      * Paint `page` into a `CanvasRenderingContext2D` or
-     * `OffscreenCanvasRenderingContext2D`. The painter owns
-     * `canvas.width`/`height` (no `clearRect` needed); consumers own
-     * `canvas.style.*`. If `layoutScale * densityScale` exceeds 16384 px per
-     * side, `densityScale` is clamped and `PaintResult` reports it.
+     * `OffscreenCanvasRenderingContext2D` at `scale` backing-store pixels per
+     * point, reduced where it must be to keep both sides within
+     * `MAX_RASTER_SIDE` (16384 px). The painter owns `canvas.width`/`height`;
+     * consumers own `canvas.style.*`.
      *
      * `put_image_data` writes the whole backing store, bypassing the 2D
      * context's transform, `globalAlpha`, and clip, so each visible page needs
      * its own `<canvas>`: no compositing, sub-rect, or transform reaches through
      * this call.
      *
-     * Throws if `page` is out of range, `ctx` is the wrong type, either scale is
-     * non-finite or `<= 0`, or the page cannot be rasterized at the resulting
-     * scale (`backend::invalid_raster_scale`).
+     * Throws if `page` is out of range, `ctx` is the wrong type, or `scale` is
+     * not finite and positive (`backend::invalid_raster_scale`).
      * @param {CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D} ctx
      * @param {number} page
-     * @param {PaintOptions | undefined} opts
-     * @returns {PaintResult}
+     * @param {number} scale
      */
-    paint(ctx, page, opts) {
+    paint(ctx, page, scale) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.livesession_paint(retptr, this.__wbg_ptr, addHeapObject(ctx), page, addHeapObject(opts));
+            wasm.livesession_paint(retptr, this.__wbg_ptr, addHeapObject(ctx), page, scale);
             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);
+            if (r1) {
+                throw takeObject(r0);
             }
-            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -1530,15 +1463,18 @@ export class Quill {
      * `FieldSource` rung it came from (`"authored" | "default" | "blank"`). The
      * card body is a `body` sibling on its card, never a row in `fields`, and
      * `null` when the kind enables no body. Value and provenance only;
-     * completeness stays `validate`'s.
+     * diagnostics stay `validate`'s. `today` reads as on `Quillmark.open`.
      * @param {Document} doc
+     * @param {string | null} [today]
      * @returns {Resolved}
      */
-    _resolve(doc) {
+    _resolve(doc, today) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(doc, Document);
-            wasm.quill__resolve(retptr, this.__wbg_ptr, doc.__wbg_ptr);
+            var ptr0 = isLikeNone(today) ? 0 : passStringToWasm0(today, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.quill__resolve(retptr, this.__wbg_ptr, doc.__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);
@@ -1597,8 +1533,7 @@ export class Quill {
      * transport door (`fromMarkdown`, `fromStored`, a stored row).
      *
      * Idempotent: an equal value is not rewritten, so YAML comments and stored
-     * bytes survive. A `!must_fill` marker anywhere in a field's value skips
-     * that field, and a value the strict write refuses stays as authored with a
+     * bytes survive. A value the strict write refuses stays as authored with a
      * diagnostic. Throws when `doc` declares a different `$quill`, before any
      * mutation.
      * @param {Document} doc
@@ -1632,6 +1567,30 @@ export class Quill {
         const ret = wasm.quill_emptyDocument(this.__wbg_ptr);
         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@version` 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.
+     * @returns {Document | undefined}
+     */
+    exampleDocument() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quill_exampleDocument(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 r0 === 0 ? undefined : Document.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Build a quill from a file tree. Pure: the declared backend is resolved
      * later, at render time. Accepts a `Map<string, Uint8Array>` or a plain
@@ -1729,9 +1688,9 @@ export class Quill {
     }
     /**
      * Seed a starter composable `Card` of the given kind (carries `$kind`),
-     * layering an optional per-kind seed `overlay` over the schema-example base
-     * (`overlay › example › absent`). `undefined` when `cardKind` is not
-     * declared in this quill's schema.
+     * committing an optional per-kind seed `overlay`'s fields and `$body`
+     * (`overlay › absent`, body `overlay › empty`). `undefined` when
+     * `cardKind` is not declared in this quill's schema.
      *
      * Pass `document.seedOverlay(cardKind)` as `overlay` so a card added to a
      * template-derived document inherits its curated starting values; omit it
@@ -1759,9 +1718,8 @@ export class Quill {
     }
     /**
      * Seed a starter `Document` from the schema: the main card plus one instance
-     * of each composable card kind, each committing its fields' `example:`
-     * values and leaving every other field absent (interpolated at render as
-     * `default:`, else the field's blank). A field with both renders its example.
+     * of each composable card kind, each body empty and every field absent
+     * (interpolated at render as `default:`, else the field's blank).
      * @returns {Document}
      */
     seedDocument() {
@@ -1805,8 +1763,7 @@ export class Quill {
     /**
      * Validate `doc` against this quill's schema, returning every diagnostic
      * (empty when the document is valid). Forwards the canonical
-     * `validation::*` diagnostics the engine emits, including the non-fatal
-     * `validation::must_fill` warning per `!must_fill` marker left behind.
+     * `validation::*` diagnostics the engine emits.
      * @param {Document} doc
      * @returns {Diagnostic[]}
      */
@@ -1872,17 +1829,21 @@ export class Quillmark {
         return this;
     }
     /**
-     * Open a live render session for `doc` against `quill`'s backend.
+     * Open a live render session for `doc` against `quill`'s backend, on the
+     * render date `today` (`YYYY-MM-DD`, default the local date).
      * @param {Quill} quill
      * @param {Document} doc
+     * @param {string | null} [today]
      * @returns {LiveSession}
      */
-    open(quill, doc) {
+    open(quill, doc, today) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(quill, Quill);
             _assertClass(doc, Document);
-            wasm.quillmark_open(retptr, this.__wbg_ptr, quill.__wbg_ptr, doc.__wbg_ptr);
+            var ptr0 = isLikeNone(today) ? 0 : passStringToWasm0(today, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.quillmark_open(retptr, this.__wbg_ptr, quill.__wbg_ptr, doc.__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);
@@ -1895,20 +1856,24 @@ export class Quillmark {
         }
     }
     /**
-     * Render `doc` against `quill` in one shot. Convenience over `open` +
-     * `LiveSession.render`: an unset `output_format` falls back to the
-     * backend's first supported format.
+     * 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`.
      * @param {Quill} quill
      * @param {Document} doc
      * @param {RenderOptions | null} [opts]
+     * @param {string | null} [today]
      * @returns {RenderResult}
      */
-    render(quill, doc, opts) {
+    render(quill, doc, opts, today) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(quill, Quill);
             _assertClass(doc, Document);
-            wasm.quillmark_render(retptr, this.__wbg_ptr, quill.__wbg_ptr, doc.__wbg_ptr, isLikeNone(opts) ? 0 : addHeapObject(opts));
+            var ptr0 = isLikeNone(today) ? 0 : passStringToWasm0(today, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.quillmark_render(retptr, this.__wbg_ptr, quill.__wbg_ptr, doc.__wbg_ptr, isLikeNone(opts) ? 0 : addHeapObject(opts), 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);
@@ -2072,6 +2037,54 @@ export function importMarkdown(markdown) {
     }
 }
 
+/**
+ * Whether `content` satisfies the `inline` constraint of `richtext` and
+ * `plaintext`: one `Para` line, in no container, with no islands. Judged on
+ * the normalized content, which is what a write stores. Throws if `content` is
+ * not canonical content.
+ * @param {Content} content
+ * @returns {boolean}
+ */
+export function isInline(content) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.isInline(retptr, addHeapObject(content));
+        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;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Whether `content` satisfies the `plaintext` constraint: no marks, no
+ * islands, every line a `Para` in no container. Judged on the normalized
+ * content, which is what a write stores. Throws if `content` is not canonical
+ * content.
+ * @param {Content} content
+ * @returns {boolean}
+ */
+export function isPlain(content) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.isPlain(retptr, addHeapObject(content));
+        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;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Where `bundle`'s text-moving channels (`delta`, then `islandOps`, then
  * `lineOps`) leave `content`'s marks: the final-text coordinates the bundle's
@@ -2325,20 +2338,16 @@ function __wbg_get_imports() {
             const ret = Array.from(getObject(arg0));
             return addHeapObject(ret);
         },
-        __wbg_getTime_65922ba0b59d55a7: function(arg0) {
-            const ret = getObject(arg0).getTime();
+        __wbg_getDate_8e7807f062ade36a: function(arg0) {
+            const ret = getObject(arg0).getDate();
             return ret;
         },
-        __wbg_getUTCDate_b061d7dd93ea65ec: function(arg0) {
-            const ret = getObject(arg0).getUTCDate();
+        __wbg_getFullYear_0cfd5a75cf3d5856: function(arg0) {
+            const ret = getObject(arg0).getFullYear();
             return ret;
         },
-        __wbg_getUTCFullYear_4f3d4172a60a56ec: function(arg0) {
-            const ret = getObject(arg0).getUTCFullYear();
-            return ret;
-        },
-        __wbg_getUTCMonth_0c3985a29f63aeb1: function(arg0) {
-            const ret = getObject(arg0).getUTCMonth();
+        __wbg_getMonth_01ce17d889ed7e5e: function(arg0) {
+            const ret = getObject(arg0).getMonth();
             return ret;
         },
         __wbg_get_6cf5a4d4d8ad3c5a: function() { return handleError(function (arg0, arg1) {
@@ -2445,10 +2454,6 @@ function __wbg_get_imports() {
             const ret = new Date();
             return addHeapObject(ret);
         },
-        __wbg_new_180f1022bb6ee517: function(arg0) {
-            const ret = new Date(getObject(arg0));
-            return addHeapObject(ret);
-        },
         __wbg_new_1da3429bc3c4541c: function(arg0) {
             const ret = new Uint8Array(getObject(arg0));
             return addHeapObject(ret);

package/render/wasm_bg.wasm.d.ts

@@ -13,7 +13,6 @@ export const document__readerGetContent: (a: number, b: number, c: number, d: nu
 export const document__readerGetContentAt: (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_blueprintInstruction: (a: number, b: number, c: number) => void;
 export const document_bodyMarkdown: (a: number, b: number, c: number) => void;
 export const document_card: (a: number, b: number, c: number) => void;
 export const document_cardCount: (a: number) => number;
@@ -22,15 +21,14 @@ export const document_cards: (a: number, b: number) => void;
 export const document_clone: (a: number) => number;
 export const document_currentStorageVersion: (a: number) => void;
 export const document_equals: (a: number, b: number) => number;
-export const document_formatRules: (a: number) => void;
 export const document_fromMarkdown: (a: number, b: number, c: number) => void;
 export const document_fromStored: (a: number, b: number, c: number) => void;
 export const document_getExt: (a: number, b: number, c: number) => void;
 export const document_getStored: (a: number, b: number, c: number) => void;
 export const document_insertCard: (a: number, b: number, c: number, d: number) => void;
-export const document_isFill: (a: number, b: number, c: number) => void;
 export const document_loadStored: (a: number, b: number, c: number, d: number) => void;
 export const document_main: (a: number, b: number) => void;
+export const document_markdownRules: (a: number) => void;
 export const document_moveCard: (a: number, b: number, c: number, d: number) => void;
 export const document_new: (a: number, b: number, c: number) => void;
 export const document_overwrite: (a: number, b: number, c: number, d: number) => void;
@@ -48,7 +46,6 @@ export const document_storageVersionOf: (a: number, b: number, c: number) => voi
 export const document_storeExt: (a: number, b: number, c: number, d: number) => void;
 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_storeFill: (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_toMarkdown: (a: number, b: number) => void;
 export const document_toStored: (a: number, b: number) => void;
@@ -57,6 +54,8 @@ export const exportMarkdown: (a: number, b: number) => void;
 export const formatDiagnostic: (a: number, b: number) => void;
 export const formatDocPath: (a: number, b: number) => void;
 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_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;
@@ -72,11 +71,12 @@ 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 parseDocPath: (a: number, b: number, c: number) => void;
-export const quill__resolve: (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_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_fromTree: (a: number, b: number) => void;
 export const quill_metadata: (a: number, b: number) => void;
 export const quill_parse: (a: number, b: number, c: number, d: number) => void;
@@ -88,8 +88,8 @@ export const quill_toTree: (a: number) => number;
 export const quill_validate: (a: number, b: number, c: number) => void;
 export const quill_warnings: (a: number, b: number) => void;
 export const quillmark_new: () => number;
-export const quillmark_open: (a: number, b: number, c: number, d: number) => void;
-export const quillmark_render: (a: number, b: number, c: number, d: number, e: number) => void;
+export const quillmark_open: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const quillmark_render: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const quillmark_supportedFormats: (a: number, b: number, c: number) => void;
 export const rebase: (a: number, b: number, c: number, d: number) => void;
 export const start: () => void;