@quillmark/wasm 0.81.0-rc.2 → 0.82.0

package/bundler/wasm.d.ts

@@ -4,10 +4,10 @@
 /**
  * Input shape for `Document.pushCard` and `Document.insertCard`.
  *
- * Only `tag` is required. `fields` defaults to `{}`, `body` to `""`.
+ * Only `kind` is required. `fields` defaults to `{}`, `body` to `""`.
  */
 export interface CardInput {
-    tag: string;
+    kind: string;
     fields?: Record<string, unknown>;
     body?: string;
 }
@@ -131,7 +131,7 @@ export interface QuillCardSchema {
  * Document schema returned by `Quill.schema`. Includes optional `ui` keys.
  *
  * `main.fields.QUILL` and `card_kinds[name].fields.CARD` are required
- * sentinels with `const` values telling consumers what to write.
+ * reserved fields with `const` values telling consumers what to write.
  */
 export interface QuillSchema {
     main: QuillCardSchema;
@@ -183,8 +183,8 @@ export interface FormCard {
  * Schema-aware form view of a document, returned by `Quill.form`.
  *
  * - `main` — the main card viewed through the quill's main schema.
- * - `cards` — composable card blocks, in document order (unknown tags excluded).
- * - `diagnostics` — diagnostics from unknown card tags and validation.
+ * - `cards` — composable card blocks, in document order (unknown kinds excluded).
+ * - `diagnostics` — diagnostics from unknown card kinds and validation.
  */
 export interface Form {
     main: FormCard;
@@ -200,10 +200,8 @@ export interface Artifact {
 }
 
 export interface Card {
-    sentinel: string;
-    tag: string;
-    frontmatter: Record<string, unknown>;
-    frontmatterItems: FrontmatterItem[];
+    kind: string;
+    payloadItems: PayloadItem[];
     body: string;
 }
 
@@ -236,372 +234,176 @@ export interface RenderResult {
     renderTimeMs: number;
 }
 
-export type FrontmatterItem = { kind: "field"; key: string; value: unknown; fill?: boolean } | { kind: "comment"; text: string; inline?: boolean };
-
 export type OutputFormat = "pdf" | "svg" | "txt" | "png";
 
+export type PayloadItem = { type: "field"; key: string; value: unknown; fill?: boolean } | { type: "comment"; text: string; inline?: boolean };
+
 export type Severity = "error" | "warning" | "note";
 
 
 /**
  * Typed in-memory Quillmark document.
- *
- * Created via `Document.fromMarkdown(markdown)`. Exposes:
- * - `quillRef` (string)
- * - `frontmatter` (JS object/Record)
- * - `body` (string)
- * - `cards` (array of Card objects)
- * - `warnings` (array of Diagnostic objects)
- *
- * `toMarkdown()` emits canonical Quillmark Markdown that round-trips back to
- * an equal `Document` by value and by type.
  */
 export class Document {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * Return a fresh `Document` handle with the same parse state.
-     *
-     * Mutations on the returned handle do not affect the original and
-     * vice versa. Parse-time warnings are snapshotted alongside the
-     * document — they describe the original parse, not the edit
-     * history of either handle.
-     */
     clone(): Document;
     /**
      * Schema version this build writes via [`toJson`](Document::to_json).
-     *
-     * Compare a payload's [`schemaVersionOf`](Document::schema_version_of)
-     * against this to detect mismatches before calling
-     * [`fromJson`](Document::from_json).
+     * Tracks the `Document` model version (not the running crate version):
+     * the tag advances only when the wire format changes, not on every release.
      */
     static currentSchemaVersion(): string;
     /**
-     * Structural equality against another `Document`.
-     *
-     * Compares `main` and `cards` by value (matching core's [`PartialEq`]).
-     * Parse-time `warnings` are intentionally excluded — they describe the
-     * source text, not the document's content.
-     *
-     * Use this to debounce upstream prop updates: keep the last parsed
-     * `Document` and compare instead of re-parsing on every keystroke.
+     * Structural equality (parse-time `warnings` excluded). Use to debounce
+     * upstream prop updates instead of re-parsing on every keystroke.
      */
     equals(other: Document): boolean;
     /**
-     * Reconstruct a `Document` from its versioned storage DTO string.
+     * Reconstruct a `Document` from a versioned storage DTO string produced
+     * by [`toJson`](Document::to_json). Unknown `schema` tags are rejected.
+     * The result carries no parse-time warnings (`.warnings` is always empty).
      *
-     * `json` must be a string produced by [`toJson`](Document::to_json) —
-     * the versioned storage DTO. Parsing and schema dispatch happen inside
-     * the module via `serde_json`; the JS `JSON` global is not involved.
-     * Unknown `schema` tags are rejected.
-     *
-     * The reconstructed document carries no parse-time warnings — the DTO
-     * describes content, not source text — so `.warnings` is always empty.
-     *
-     * Throws a JS `Error` if `json` is not a valid storage DTO (malformed
-     * JSON, unknown `schema`, missing fields, or an unparseable quill
-     * reference).
+     * Throws if `json` is not a valid storage DTO (malformed JSON, unknown
+     * `schema`, missing fields, or unparseable quill reference).
      */
     static fromJson(json: string): Document;
     /**
-     * Parse markdown into a typed Document.
-     *
-     * Returns the document with any parse-time warnings accessible via `.warnings`.
-     * Throws on parse errors.
+     * Parse markdown into a typed Document. Throws on parse errors.
      */
     static fromMarkdown(markdown: string): Document;
     /**
-     * Insert a card at the given index.
-     *
-     * `index` must be in `0..=cards.length`. Out-of-range throws an `Error`.
-     *
-     * Mutators never modify `warnings`.
+     * Insert a card at `index` (must be in `0..=cards.length`).
      */
     insertCard(index: number, card: CardInput): void;
     /**
-     * Move the card at `from` to position `to`.
-     *
-     * `from == to` is a no-op. Both indices must be in `0..cards.length`.
-     * Out-of-range throws an `Error`.
-     *
-     * Mutators never modify `warnings`.
+     * Move the card at `from` to position `to`. `from == to` is a no-op.
      */
     moveCard(from: number, to: number): void;
     /**
      * Append a card to the end of the card list.
-     *
-     * `card` must be a JS object with a `tag` string field and optional
-     * `fields` (object) and `body` (string).
-     *
-     * Throws an `Error` if `card.tag` is not a valid tag name.
-     *
-     * Mutators never modify `warnings`.
+     * Throws if `card.kind` is not a valid kind name.
      */
     pushCard(card: CardInput): void;
-    /**
-     * Remove the card at `index` and return it, or `undefined` if out of range.
-     *
-     * Mutators never modify `warnings`.
-     */
     removeCard(index: number): Card | undefined;
     /**
-     * Remove a frontmatter field on the card at `index`, returning the
-     * removed value or `undefined` if the field was absent.
-     *
-     * Throws if `index` is out of range, `name` is reserved, or `name` does
-     * not match `[a-z_][a-z0-9_]*`.
-     *
-     * Mutators never modify `warnings`.
+     * Remove a field on the card at `index`. Returns the removed value or
+     * `undefined`. Throws if `index` is out of range or `name` is invalid.
      */
     removeCardField(index: number, name: string): any;
     /**
-     * Remove a frontmatter field on the main card, returning the removed value or `undefined`.
-     *
-     * Throws an `Error` whose message includes the `EditError` variant name
-     * and details if `name` is reserved (`BODY`, `CARDS`, `QUILL`, `CARD`)
-     * or does not match `[a-z_][a-z0-9_]*`. Absence of an otherwise-valid
-     * name returns `undefined`.
-     *
-     * Mutators never modify `warnings`.
+     * Remove a payload field on the main card, returning the removed value or
+     * `undefined`. Throws if `name` is reserved or does not match
+     * `[a-z_][a-z0-9_]*`.
      */
     removeField(name: string): any;
-    /**
-     * Replace the main card's body (the global Markdown body).
-     *
-     * Mutators never modify `warnings`.
-     */
     replaceBody(body: string): void;
     /**
-     * Read the schema version from a raw storage DTO string without
-     * performing a full parse, or `undefined`.
-     *
-     * Returns the `schema` field as-is — including unknown future versions
-     * that `fromJson` would reject. Use this to distinguish "this build is
-     * too old for the payload" from "the payload is corrupt" when
-     * [`fromJson`](Document::from_json) throws:
-     *
-     * ```js
-     * const v = Document.schemaVersionOf(blob);
-     * if (v === undefined) {
-     *   // not a stored DTO at all — try fromMarkdown
-     * } else if (v !== Document.currentSchemaVersion()) {
-     *   // newer (or older unmigrated) schema — prompt the user to upgrade
-     * } else {
-     *   doc = Document.fromJson(blob);
-     * }
-     * ```
+     * Read the `schema` version tag from a raw storage DTO string without a
+     * full parse, or `undefined`. Returns unknown future versions as-is —
+     * useful to distinguish "build too old" from "payload corrupt" when
+     * `fromJson` throws.
      */
     static schemaVersionOf(json: string): string | undefined;
     /**
-     * Replace the tag of the composable card at `index`.
-     *
-     * Mutates only the sentinel — the card's frontmatter and body are
-     * untouched. Schema-aware migration (clearing orphan fields, applying
-     * new defaults) is the caller's responsibility; `setCardTag` is a
-     * structural primitive.
-     *
-     * Throws if `index` is out of range or if `newTag` does not match
-     * `[a-z_][a-z0-9_]*`.
-     *
-     * Mutators never modify `warnings`.
+     * Replace the kind of the card at `index`. Payload and body are untouched;
+     * schema-aware migration is the caller's responsibility.
+     * Throws if `index` is out of range or `newKind` is invalid.
      */
-    setCardTag(index: number, new_tag: string): void;
+    setCardKind(index: number, new_kind: string): void;
     /**
-     * Update a frontmatter field on the main card.
-     *
-     * Convenience method: equivalent to `doc.mainMut().setField(name, value)`.
-     * Clears any existing `!fill` marker on the field.
+     * Update a payload field on the main card. Clears any existing `!fill` marker.
      *
-     * Throws an `Error` whose message includes the `EditError` variant name and
-     * details if `name` is reserved (`BODY`, `CARDS`, `QUILL`, `CARD`) or does
+     * Throws if `name` is reserved (`BODY`, `CARDS`, `QUILL`, `CARD`) or does
      * not match `[a-z_][a-z0-9_]*`.
-     *
-     * Mutators never modify `warnings`.
      */
     setField(name: string, value: any): void;
     /**
-     * Update a frontmatter field on the main card AND mark it as `!fill`.
-     *
-     * Convenience method: equivalent to `doc.mainMut().setFill(name, value)`.
-     *
+     * Update a payload field on the main card and mark it as `!fill`.
      * Throws on invalid name (see [`setField`](Document::set_field)).
-     *
-     * Mutators never modify `warnings`.
      */
     setFill(name: string, value: any): void;
     /**
-     * Replace the QUILL reference string.
-     *
-     * Throws if `ref_str` is not a valid `QuillReference`.
-     *
-     * Mutators never modify `warnings`.
+     * Replace the QUILL reference string. Throws if `ref_str` is invalid.
      */
     setQuillRef(ref_str: string): void;
     /**
      * Serialize this document to a versioned storage DTO string.
      *
-     * Returns the document as a JSON string carrying a `schema` version
-     * field. The string is produced inside the module via `serde_json` and
-     * round-trips losslessly back to an equal `Document` via
-     * [`fromJson`](Document::from_json) — the JS `JSON` global is not
-     * involved in either direction.
-     *
-     * Use this — not [`toMarkdown`](Document::to_markdown) — to persist a
-     * document across a process restart or crate upgrade; the wire format
-     * is frozen per `schema` version, whereas Markdown syntax evolves.
-     * Parse-time `warnings` are not part of the DTO.
+     * Prefer this over `toMarkdown` for persistence across restarts or crate
+     * upgrades — the wire format is frozen per `schema` version. Parse-time
+     * `warnings` are excluded from the DTO.
      *
-     * The result is standard JSON text, so callers that want to inspect it
-     * may `JSON.parse` it — but treating it as an opaque blob is the
-     * intended use.
+     * Output is **byte-deterministic** within a `schema` version: equal
+     * documents produce byte-equal output, safe for content-hash use cases.
      */
     toJson(): string;
     /**
-     * Emit canonical Quillmark Markdown.
-     *
-     * Returns the document serialised as a Quillmark Markdown string.
-     * The output is type-fidelity round-trip safe: re-parsing the result
-     * produces a `Document` equal to `self` by value and by type.
+     * Emit canonical Quillmark Markdown. Round-trip safe: re-parsing the
+     * result produces a `Document` equal to `self` by value and by type.
      */
     toMarkdown(): string;
     /**
-     * Reconstruct a `Document` from a storage DTO string, or `undefined`.
-     *
-     * Like [`fromJson`](Document::from_json), but returns `undefined`
-     * instead of throwing when `json` is not a valid storage DTO. Use this
-     * to detect format and fall back without exceptions as control flow:
-     *
-     * ```js
-     * const doc = Document.tryFromJson(content) ?? Document.fromMarkdown(content);
-     * ```
-     *
-     * `undefined` only ever means "not a storage DTO" — `fromMarkdown`
-     * still throws on genuinely malformed markdown.
+     * Like [`fromJson`](Document::from_json) but returns `undefined` instead
+     * of throwing when `json` is not a valid storage DTO — use to
+     * discriminate format without exceptions as control flow.
+     * `undefined` means "not a storage DTO"; `fromMarkdown` still throws on
+     * genuinely malformed markdown.
      */
     static tryFromJson(json: string): Document | undefined;
     /**
-     * Replace the body of the card at `index`.
-     *
-     * Throws if `index` is out of range.
-     *
-     * Mutators never modify `warnings`.
+     * Replace the body of the card at `index`. Throws if out of range.
      */
     updateCardBody(index: number, body: string): void;
     /**
      * Update a field on the card at `index`.
-     *
-     * Convenience method: equivalent to `doc.card_mut(index)?.set_field(name, value)`.
-     *
-     * Throws if `index` is out of range, `name` is reserved or invalid, or
-     * `value` cannot be serialized.
-     *
-     * Mutators never modify `warnings`.
+     * Throws if `index` is out of range, `name` is reserved or invalid.
      */
     updateCardField(index: number, name: string, value: any): void;
     /**
-     * Number of composable cards (excludes the main card).
-     *
-     * O(1). Use this to validate indices before calling card mutators
-     * instead of allocating the full `cards` array.
+     * Number of composable cards (excludes the main card). O(1).
      */
     readonly cardCount: number;
-    /**
-     * Ordered list of composable card blocks as typed `Card` objects.
-     */
     readonly cards: Card[];
     /**
-     * The document's main (entry) card.
-     *
-     * Carries the QUILL sentinel, the document-level frontmatter, and the
-     * global body. Frontmatter/body reads and mutations go through this
-     * handle — there are no document-level shortcuts after the rework.
-     *
-     * Allocates and serializes on each call — cache locally if read in a hot loop.
+     * The document's main (entry) card. Allocates and serializes on each
+     * call — cache locally if read in a hot loop.
      */
     readonly main: Card;
-    /**
-     * The QUILL reference string (e.g. `"usaf_memo@0.1"`).
-     */
     readonly quillRef: string;
-    /**
-     * Non-fatal parse-time warnings as an array of typed `Diagnostic` objects.
-     */
     readonly warnings: Diagnostic[];
 }
 
-/**
- * Opaque, shareable Quill handle.
- */
 export class Quill {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * A blank form for a card of the given kind — no document values supplied.
-     *
-     * Returns `null` if `cardKind` is not declared in this quill's schema.
-     * Otherwise returns a plain JS object shaped like a single entry in
-     * [`Form::cards`].
-     *
-     * [`Form::cards`]: quillmark::form::Form::cards
+     * Blank `FormCard` for the given card kind. Returns `null` if `cardKind`
+     * is not declared in this quill's schema.
      */
     blankCard(card_kind: string): FormCard | null;
     /**
-     * A blank form for the main card — no document values supplied.
-     *
-     * Returns a plain JS object with the same shape as one entry in
-     * [`Form::main`]. Every declared field's `source` is `"default"` (when
-     * the schema declares a default) or `"missing"`.
-     *
-     * [`Form::main`]: quillmark::form::Form::main
+     * Blank `FormCard` for the main card with no document values.
+     * Every field's `source` is `"default"` or `"missing"`.
      */
     blankMain(): FormCard;
     /**
-     * The schema-aware form view of `doc`.
-     *
-     * Returns a plain JS object (not a class) that is immediately
-     * `JSON.stringify`-able. The shape mirrors [`Form`]:
-     *
-     * ```json
-     * {
-     *   "main":  { "schema": {...}, "values": { "field": {...} } },
-     *   "cards": [ ... ],
-     *   "diagnostics": [ ... ]
-     * }
-     * ```
-     *
-     * **Snapshot semantics.** This is a read-only snapshot of the document
-     * at call time. Subsequent edits to `doc` require calling `form` again.
-     *
-     * [`Form`]: quillmark::form::Form
+     * The schema-aware form view of `doc`. Read-only snapshot at call time;
+     * subsequent edits to `doc` require calling `form` again.
      */
     form(doc: Document): Form;
-    /**
-     * Open an iterative render session for page-selective rendering.
-     */
     open(doc: Document): RenderSession;
-    /**
-     * Render a document to final artifacts.
-     */
     render(doc: Document, opts?: RenderOptions | null): RenderResult;
     /**
      * The resolved backend identifier (e.g. `"typst"`).
      */
     readonly backendId: string;
-    /**
-     * Auto-generated annotated Markdown blueprint for LLM consumers.
-     */
     readonly blueprint: string;
     /**
      * Identity snapshot of the `quill:` section of `Quill.yaml`, plus
-     * `supportedFormats` and any custom `quill:` keys.
-     *
-     * Consumers that need validation run their own validator against
-     * `metadata.schema`.
-     *
-     * Equivalent by value for the lifetime of the handle; the quill is
-     * immutable once constructed.
+     * `supportedFormats` and any extra `quill:` keys.
      */
     readonly metadata: QuillMetadata;
     /**
@@ -609,25 +411,16 @@ export class Quill {
      */
     readonly schema: QuillSchema;
     /**
-     * Whether this quill's backend supports canvas preview.
-     *
      * `true` iff `RenderSession.paint` and `RenderSession.pageSize` will
-     * succeed for sessions opened by this quill. Use this as a precondition
-     * probe before mounting a canvas-based preview UI; the throw on `paint`
-     * remains the enforcement contract.
+     * succeed for sessions opened by this quill. Use as a precondition
+     * probe before mounting a canvas-based preview UI.
      */
     readonly supportsCanvas: boolean;
 }
 
-/**
- * Quillmark WASM Engine
- */
 export class Quillmark {
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * JavaScript constructor: `new Quillmark()`
-     */
     constructor();
     /**
      * Load a quill from a file tree and attach the appropriate backend.
@@ -641,19 +434,12 @@ export class Quillmark {
 }
 
 /**
- * An iterative render handle backed by an immutable compiled snapshot.
- *
- * Created via [`Quill::open`]. Holds the compiled output so that
- * [`RenderSession::render`], [`RenderSession::paint`], and
- * [`RenderSession::page_size`] can be called repeatedly without
- * recompiling.
+ * Iterative render handle backed by an immutable compiled snapshot.
  *
- * **Empty documents.** A document that compiles to zero pages still
- * produces a valid session (`pageCount === 0`). Iterating
- * `0..pageCount` is then a no-op; calling `paint(ctx, 0)` or
- * `pageSize(0)` throws `"... page index 0 out of range
- * (pageCount=0)"`. Hosts that surface "no pages to preview" UI should
- * branch on `pageCount === 0` rather than on a thrown error.
+ * **Empty documents.** A zero-page document yields a valid session
+ * (`pageCount === 0`); `paint(ctx, 0)` or `pageSize(0)` throws with
+ * `"page index 0 out of range (pageCount=0)"`. Branch on `pageCount === 0`
+ * rather than catching the error.
  */
 export class RenderSession {
     private constructor();
@@ -661,94 +447,33 @@ export class RenderSession {
     [Symbol.dispose](): void;
     /**
      * Page dimensions in Typst points (1 pt = 1/72 inch).
-     *
-     * Report-only: the painter sizes the canvas itself based on
-     * `PaintOptions`. Exposed for consumers that need page geometry
-     * up-front (e.g. to lay out a scrollable list of canvases before
-     * any pixels are rendered).
-     *
-     * Stable for a given `page` across the session's lifetime — the
-     * compiled document is an immutable snapshot, so callers can cache
-     * results.
-     *
-     * Throws if the underlying backend has no canvas painter (i.e. is not
-     * the Typst backend) or if `page` is out of range.
+     * Throws if the backend has no canvas painter or `page` is out of range.
      */
     pageSize(page: number): PageSize;
     /**
-     * Paint `page` into a 2D canvas context.
+     * 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 — detect via `PaintResult.pixelWidth`.
      *
-     * Accepts either a `CanvasRenderingContext2D` (main thread) or an
-     * `OffscreenCanvasRenderingContext2D` (Worker / off-DOM rasterization).
-     * Both dispatch to the same Rust rasterizer; the dispatch happens at
-     * the JS boundary so neither context type is privileged.
-     *
-     * The painter owns `canvas.width` / `canvas.height` and writes them
-     * itself; consumers must not. The painter does not touch
-     * `canvas.style.*` — that's layout, owned by the consumer (see
-     * `PaintResult.layoutWidth` / `layoutHeight`).
-     *
-     * `opts.layoutScale` (default 1.0) is layout-space pixels per Typst
-     * point and determines the canvas's display-box size. `opts.densityScale`
-     * (default 1.0) is the rasterization density multiplier the consumer
-     * folds `window.devicePixelRatio`, in-app zoom, and
-     * `visualViewport.scale` (pinch-zoom) into. The effective
-     * rasterization scale is `layoutScale * densityScale`.
-     *
-     * If `layoutScale * densityScale` would exceed the safe backing-store
-     * maximum (16384 px per side), `densityScale` is clamped
-     * proportionally so the largest dimension fits. The actual
-     * backing-store dimensions are reported in the returned
-     * `PaintResult` — compare against
-     * `round(layoutWidth * densityScale)` to detect clamping.
-     *
-     * Each call resets the backing store (`paint` is always a full
-     * repaint). Consumers do not need to call `clearRect`.
-     *
-     * Throws when:
-     * - the backend does not support canvas preview (message includes the
-     *   resolved `backendId`),
-     * - `page` is out of range,
-     * - `ctx` is neither `CanvasRenderingContext2D` nor
-     *   `OffscreenCanvasRenderingContext2D`,
-     * - `opts.layoutScale` or `opts.densityScale` is non-finite or `<= 0`.
+     * Throws if the backend has no canvas painter, `page` is out of range,
+     * `ctx` is the wrong type, or either scale is non-finite or `<= 0`.
      */
     paint(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, page: number, opts: PaintOptions | undefined): PaintResult;
-    /**
-     * Render all or selected pages from this session.
-     */
     render(opts?: RenderOptions | null): RenderResult;
     /**
      * The backend that produced this session (e.g. `"typst"`).
-     *
-     * Equal to the `backendId` of the [`Quill`] that opened this session
-     * (sessions inherit their quill's backend), so checking either is fine.
      */
     readonly backendId: string;
-    /**
-     * Number of pages in this render session.
-     *
-     * Stable for the lifetime of the session — the underlying compiled
-     * document is an immutable snapshot.
-     */
     readonly pageCount: number;
     /**
-     * Whether this session's backend supports canvas preview.
-     *
-     * `true` iff [`paint`](Self::paint) and [`page_size`](Self::page_size)
-     * will succeed. Equal to `Quill.supportsCanvas` for the quill that
-     * opened this session.
+     * `true` iff `paint` and `pageSize` will succeed for this session.
      */
     readonly supportsCanvas: boolean;
     /**
-     * Session-level warnings attached at `quill.open(...)` time.
-     *
-     * Snapshot of any non-fatal diagnostics emitted while opening the
-     * session (e.g. version compatibility shims). Stable across the
-     * session's lifetime. These are also appended to
-     * [`RenderResult.warnings`] on every `render()` call; the accessor
-     * surfaces them to canvas-preview consumers that don't go through
-     * `render()`.
+     * Non-fatal diagnostics emitted when opening the session. Also appended
+     * to `RenderResult.warnings` on each `render()` call.
      */
     readonly warnings: Diagnostic[];
 }