@quillmark/wasm 0.115.0 → 0.117.0

package/core/wasm.d.ts

@@ -13,13 +13,6 @@ export type PayloadItem =
     type: "field";
     key: string;
     value: unknown;
-    fill?: boolean;
-    /**
-     * Paths to `!must_fill` markers nested *inside* `value` (the `value`
-     * projection itself is fill-free). Absent when the field has no nested
-     * placeholders. Preserved across `insertCard`.
-     */
-    nestedFills?: PathStep[][];
 }
 | { type: "comment"; text: string; inline?: boolean };
 
@@ -27,9 +20,9 @@ export type PayloadItem =
  * A single card block, as read back from a document. Every `Card` is a valid
  * `CardInput`, so a card read from one document pushes straight into another.
  *
- * `$` system entries are hoisted to named fields: `kind` (the `$kind`, empty
- * string when none), `quill` (`$quill` `name@version`, main card only), `ext`
- * (`$ext`), and `seed` (the `$seed` per-kind overlay map, main card only).
+ * `$` system entries are hoisted to named fields: `kind` (the `$kind`),
+ * `quill` (`$quill` `name@version`, main card only), `ext` (`$ext`), and
+ * `seed` (the `$seed` per-kind overlay map, main card only).
  * `payloadItems` carries user fields and comments in order.
  */
 export interface Card {
@@ -357,11 +350,11 @@ export interface ResolvedMain {
 
 /**
  * One composable card's resolved rows in declaration order, with its authored
- * `kind` (`null` for an unknown-kind card), its document-array `index`, and its
+ * `kind` (an undeclared one included), its document-array `index`, and its
  * body row: `null` when the kind enables no body.
  */
 export interface ResolvedCard {
-    kind: string | null;
+    kind: string;
     index: number;
     fields: ResolvedField[];
     body: ResolvedField | null;
@@ -369,7 +362,7 @@ export interface ResolvedCard {
 
 /**
  * The resolved-value view (`Quill.resolve`): the main card and every composable
- * card. Value and provenance only; completeness stays `Quill.validate`'s.
+ * card. Value and provenance only; diagnostics stay `Quill.validate`'s.
  */
 export interface Resolved {
     main: ResolvedMain;
@@ -381,7 +374,6 @@ export interface Resolved {
 /** UI layout hints for a single field. Display order is not a hint: key order
  * in the schema's `fields`/`properties` objects is the ordering contract. */
 export interface QuillFieldUi {
-    title?: string;
     group?: string;
     compact?: boolean;
     multiline?: boolean;
@@ -405,50 +397,35 @@ export interface QuillGroupUi {
 
 /** UI layout hints for a card (main or named card kind). */
 export interface QuillCardUi {
-    title?: string;
     /** The groups a field's `ui.group` may reference, keyed by group id. Key
      * order is the display-order contract, as with `fields`. Absent when the
      * card declares no groups. */
     groups?: Record<string, QuillGroupUi>;
 }
 
-/** A block construct a body can hold. `paragraph` is the floor and cannot be
- * declined, so it is absent. */
-export type QuillBlockConstruct =
-| "heading"
-| "rule"
-| "code"
-| "list"
-| "quote"
-| "table"
-| "image";
-
 /** Body namespace for a card (main or named card kind). */
 export interface QuillCardBody {
     /** When false, consumers must not accept or store body content for this card kind. Defaults to true. */
     enabled?: boolean;
-    /** Example body content embedded verbatim in the blueprint body region. Fallback is "Write <card> body here." */
-    example?: string;
-    /** Block constructs this quill's plate does not typeset in this body;
-     * absent or empty declines nothing. A body that holds one anyway draws a
-     * non-fatal `plate::unsupported_construct` warning. Nothing verifies the
-     * claim: absence from this list is not a promise the plate typesets it. */
-    unsupported?: QuillBlockConstruct[];
 }
 
+export type QuillFieldType = "string" | "number" | "integer" | "boolean" | "array" | "object" | "date" | "datetime" | "richtext" | "plaintext" | "enum" | "matrix";
+
 /** Schema entry for a single field declared in a quill's `Quill.yaml`.
  *
- * One declaration, and no `required` key. `default` and `example` say what the
- * cell holds, and `default`'s absence is the obligation: a field nobody
- * declared a value for carries a `!must_fill` marker in the blueprint and warns
- * `validation::must_fill` while the document leaves it unauthored. Neither
- * gates render: an absent field blank-fills.
+ * `default` is the value an unanswered cell renders. An absent field without a
+ * `default` blank-fills.
  */
 export interface QuillFieldSchema {
-    type: "string" | "number" | "integer" | "boolean" | "array" | "object" | "date" | "datetime" | "richtext" | "plaintext" | "enum" | "matrix";
+    /** A trailing `?` marks the cell optional: unanswered, it renders `none`
+     *  rather than its type's blank, and it never carries a `default`. A
+     *  consumer offers a way back to unanswered (`removeField`) on such a cell. */
+    type: QuillFieldType | `${Exclude<QuillFieldType, "object" | "matrix">}?`;
+    /** The field's label, a literal. Absent, the consumer humanizes the key
+     *  (`memo_for` → "Memo For"). Never present on an array's `items`. */
+    title?: string;
     description?: string;
     default?: unknown;
-    example?: unknown;
     /** The closed set of allowed values. Required on `type: "enum"`, and valid
      *  nowhere else. */
     values?: string[];
@@ -477,6 +454,9 @@ export interface QuillFieldSchema {
 
 /** Schema entry for the main card or a named card kind. */
 export interface QuillCardSchema {
+    /** The kind's label, a literal. Absent, the consumer humanizes the kind
+     *  name. An instance takes its label from its own values. */
+    title?: string;
     description?: string;
     fields: Record<string, QuillFieldSchema>;
     ui?: QuillCardUi;
@@ -558,11 +538,6 @@ export class Document {
      * building `markOps` need not predict it.
      */
     applyChange(addr: Addr | string, bundle: ChangeBundle): void;
-    /**
-     * 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.
-     */
-    static blueprintInstruction(quill_name: string): string;
     /**
      * 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
@@ -596,11 +571,6 @@ export class Document {
      * Structural equality, excluding parse-time `warnings`.
      */
     equals(other: Document): boolean;
-    /**
-     * Authoring-format rules for the card-yaml markdown surface, re-exposed from
-     * core. Constant across calls; read once and cache.
-     */
-    static formatRules(): string;
     /**
      * Parse markdown into a typed Document. Throws on parse errors.
      */
@@ -646,12 +616,6 @@ export class Document {
      * `at` is out of range.
      */
     insertCard(card: CardInput, at?: number): void;
-    /**
-     * 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.
-     */
-    isFill(addr: Addr | string): boolean;
     /**
      * Replace this document's contents **in place** from a versioned storage DTO
      * string: the mutating twin of [`fromStored`](Document::from_stored).
@@ -660,6 +624,11 @@ export class Document {
      * variable.
      */
     loadStored(json: string): void;
+    /**
+     * The Quillmark Markdown rules, re-exposed from core. Constant across
+     * calls; read once and cache.
+     */
+    static markdownRules(): string;
     /**
      * Move the card at `from` to position `to`. `from == to` is a no-op.
      */
@@ -668,8 +637,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.
      */
     constructor(quill_ref: string);
     /**
@@ -766,7 +735,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.
      */
@@ -779,11 +748,6 @@ export class Document {
      * one entry per offending field. Throws on an out-of-range card.
      */
     storeFields(addr: CardAddr, fields: Record<string, unknown>): void;
-    /**
-     * Store a field verbatim at `addr` and mark it `!must_fill`. A body address
-     * throws; same validation as [`storeField`](Document::store_field).
-     */
-    storeFill(addr: Addr | string, value: any): void;
     /**
      * 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
@@ -833,8 +797,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.
      */
@@ -847,6 +810,15 @@ export class Quill {
      * reached by spelling the reference.
      */
     emptyDocument(): Document;
+    /**
+     * The quill's example document, `undefined` when the quill has no
+     * `example.md` at its root: a filled-in page whose values are made up to show the
+     * quill in use, never kept. It comes back pinned to this quill's
+     * `name@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.
+     */
+    exampleDocument(): Document | undefined;
     /**
      * 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
@@ -868,9 +840,9 @@ export class Quill {
     parse(markdown: string): Document;
     /**
      * 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
@@ -879,9 +851,8 @@ export class Quill {
     seedCard(card_kind: string, overlay: Record<string, unknown> | undefined): Card | undefined;
     /**
      * 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).
      */
     seedDocument(): Document;
     /**
@@ -902,8 +873,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.
      */
     validate(doc: Document): Diagnostic[];
     /**
@@ -965,6 +935,22 @@ export function formatDocPath(segs: DocPathSeg[]): string;
  */
 export function importMarkdown(markdown: string): Content;
 
+/**
+ * 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.
+ */
+export function isInline(content: Content): boolean;
+
+/**
+ * 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.
+ */
+export function isPlain(content: Content): boolean;
+
 /**
  * Where `bundle`'s text-moving channels (`delta`, then `islandOps`, then
  * `lineOps`) leave `content`'s marks: the final-text coordinates the bundle's
@@ -1030,7 +1016,6 @@ export interface InitOutput {
     readonly document__readerGetContentAt: (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_blueprintInstruction: (a: number, b: number, c: number) => void;
     readonly document_bodyMarkdown: (a: number, b: number, c: number) => void;
     readonly document_card: (a: number, b: number, c: number) => void;
     readonly document_cardCount: (a: number) => number;
@@ -1039,15 +1024,14 @@ export interface InitOutput {
     readonly document_clone: (a: number) => number;
     readonly document_currentStorageVersion: (a: number) => void;
     readonly document_equals: (a: number, b: number) => number;
-    readonly document_formatRules: (a: number) => void;
     readonly document_fromMarkdown: (a: number, b: number, c: number) => void;
     readonly document_fromStored: (a: number, b: number, c: number) => void;
     readonly document_getExt: (a: number, b: number, c: number) => void;
     readonly document_getStored: (a: number, b: number, c: number) => void;
     readonly document_insertCard: (a: number, b: number, c: number, d: number) => void;
-    readonly document_isFill: (a: number, b: number, c: number) => void;
     readonly document_loadStored: (a: number, b: number, c: number, d: number) => void;
     readonly document_main: (a: number, b: number) => void;
+    readonly document_markdownRules: (a: number) => void;
     readonly document_moveCard: (a: number, b: number, c: number, d: number) => void;
     readonly document_new: (a: number, b: number, c: number) => void;
     readonly document_overwrite: (a: number, b: number, c: number, d: number) => void;
@@ -1065,7 +1049,6 @@ export interface InitOutput {
     readonly document_storeExt: (a: number, b: number, c: number, d: number) => void;
     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_storeFill: (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_toMarkdown: (a: number, b: number) => void;
     readonly document_toStored: (a: number, b: number) => void;
@@ -1074,14 +1057,17 @@ export interface InitOutput {
     readonly formatDiagnostic: (a: number, b: number) => void;
     readonly formatDocPath: (a: number, b: number) => void;
     readonly importMarkdown: (a: number, b: number, c: number) => void;
+    readonly isInline: (a: number, b: number) => void;
+    readonly isPlain: (a: number, b: number) => void;
     readonly mapMarks: (a: number, b: number, c: number) => void;
     readonly mapPos: (a: number, b: number, c: number, d: number) => void;
     readonly parseDocPath: (a: number, b: number, c: number) => void;
-    readonly quill__resolve: (a: number, b: number, c: number) => void;
+    readonly quill__resolve: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly quill_backendId: (a: number, b: number) => void;
     readonly quill_blueprint: (a: number, b: number) => void;
     readonly quill_conform: (a: number, b: number, c: number) => void;
     readonly quill_emptyDocument: (a: number) => number;
+    readonly quill_exampleDocument: (a: number, b: number) => void;
     readonly quill_fromTree: (a: number, b: number) => void;
     readonly quill_metadata: (a: number, b: number) => void;
     readonly quill_parse: (a: number, b: number, c: number, d: number) => void;

package/core/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
@@ -1207,15 +1142,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);
@@ -1274,8 +1212,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
@@ -1309,6 +1246,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
@@ -1406,9 +1367,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
@@ -1436,9 +1397,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() {
@@ -1482,8 +1442,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[]}
      */
@@ -1653,6 +1612,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
@@ -1898,6 +1905,18 @@ function __wbg_get_imports() {
             const ret = Array.from(getObject(arg0));
             return addHeapObject(ret);
         },
+        __wbg_getDate_8e7807f062ade36a: function(arg0) {
+            const ret = getObject(arg0).getDate();
+            return ret;
+        },
+        __wbg_getFullYear_0cfd5a75cf3d5856: function(arg0) {
+            const ret = getObject(arg0).getFullYear();
+            return ret;
+        },
+        __wbg_getMonth_01ce17d889ed7e5e: function(arg0) {
+            const ret = getObject(arg0).getMonth();
+            return ret;
+        },
         __wbg_get_6cf5a4d4d8ad3c5a: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
@@ -1978,6 +1997,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).length;
             return ret;
         },
+        __wbg_new_0_35540e542ba689d2: function() {
+            const ret = new Date();
+            return addHeapObject(ret);
+        },
         __wbg_new_1da3429bc3c4541c: function(arg0) {
             const ret = new Uint8Array(getObject(arg0));
             return addHeapObject(ret);