@quillmark/wasm 0.112.0 → 0.113.0

package/{backends/pdfform → render}/wasm.d.ts

@@ -17,7 +17,7 @@ export type PayloadItem =
     /**
      * 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` / `makeCard`.
+     * placeholders. Preserved across `insertCard`.
      */
     nestedFills?: PathStep[][];
 }
@@ -72,11 +72,10 @@ export interface Content {
     islands: ContentIsland[];
 }
 
-/** One `\n`-separated segment of `Content.text`, in order. `kind` is an open set:
- * an unknown role round-trips with opaque `attrs` and renders as a paragraph.
- * Every role spells its payload in `attrs`, known or not, so promoting one moves
- * no bytes. The open arm blocks discriminant narrowing, so read
- * `attrs.level`/`attrs.lang` behind a check of the arm you want. */
+/** One `\n`-separated segment of `Content.text`, in order. `kind` is a closed
+ * set: a role outside it is refused wherever content is decoded. Every role
+ * spells its payload in `attrs`, so `kind === "heading"` narrows `attrs` to
+ * `{ level: number }` with no guard. */
 export type ContentLine = {
     containers: ContentContainer[];
     /** A within-block hard line break rather than a new block. Omitted (false) in the common case. */
@@ -89,57 +88,50 @@ export type ContentLineKind =
 | { kind: "heading"; attrs: { level: number } }
 | { kind: "code"; attrs?: { lang?: string } }
 | { kind: "island" }
-| { kind: "rule" }
-| { kind: string; attrs?: unknown };
+| { kind: "rule" };
 
-/** An ancestor block a line nests inside, outermost first. Open like
- * `ContentLine.kind`: an unrecognized container round-trips with opaque `attrs`
- * and renders transparently (its lines sit at the enclosing level).
+/** An ancestor block a line nests inside, outermost first. Closed like
+ * `ContentLine.kind`.
  *
  * Two adjacent lines sit in the same container iff their whole path matches, so
  * `instance` is what tells one container from an adjacent sibling of identical
  * shape — two consecutive quotes, two consecutive lists — which contiguity
  * alone reads as one.
  *
- * **A writer owes a distinct value per adjacent sibling run**, not merely a
- * value. Runs of one shape sharing one arrive as one: a second list's items come
- * back as continuation paragraphs of the first, markers gone. The field is
- * required, so a checker reports the omission; it cannot report a `0` stamped on
- * both, which is the same write. A codec flattening a tree takes them from
- * `assignInstances` in `@quillmark/wasm/runtime` rather than by hand. Any
- * distinct pair works; a write is canonicalized to `0`/`1`.
+ * **A writer owes a distinct value per adjacent sibling run.** Runs of one shape
+ * sharing one arrive as one: a second list's items come back as continuation
+ * paragraphs of the first, markers gone. Nothing reports that — an omitted field
+ * and a `0` stamped on both are the same write — so a codec flattening a tree
+ * takes them from `assignInstances` in `@quillmark/wasm` rather than by hand.
+ * Any distinct pair works; a write is canonicalized to `0`/`1`.
  *
- * Reading is not the mirror of writing. Every read spells the field, the `0` on
- * a container with nothing to be told apart from included. A read also carries a
- * discriminator on pairs no writer had to spell: `1.` beside a list starting at
- * `3` differs by `start`, so those runs arrive apart with nothing written, and
- * the canonical form spends one anyway because Markdown reads only a list's
- * first number.
- *
- * Content parsed from a stored document is the one shape that arrives without
- * it — storage omits a zero — and needs a cast. */
+ * Absent is `0`, and a read omits it there, so a container with nothing adjacent
+ * to be told apart from carries no key. A read does spell one on pairs no writer
+ * had to: `1.` beside a list starting at `3` differs by `start`, so those runs
+ * arrive apart with nothing written, and the canonical form spends a
+ * discriminator anyway because Markdown reads only a list's first number. */
 export type ContentContainer =
 | {
     container: "list_item";
     attrs: { ordered: boolean; start: number; ordinal: number };
-    instance: number;
+    instance?: number;
 }
-| { container: "quote"; instance: number }
-| { container: string; attrs?: unknown; instance: number };
+| { container: "quote"; instance?: number };
 
-/** A mark over char range `[start, end)` into `Content.text`. The open `type`
- * arm blocks discriminant narrowing, so read a payload-carrying arm behind its
- * guard: `isLinkMark` (`attrs.url`) / `isAnchorMark` (`attrs.id`), from
- * `@quillmark/wasm/runtime`. An `anchor`'s `id` is a caller-supplied opaque
+/** 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
+ * guard. An `anchor`'s `id` is a caller-supplied opaque
  * handle, unique per `Content` and invariant while the mark lives (positions
  * rebase, the id never does); it has no markdown projection and survives only
  * through the edit lane. */
-export type ContentMark = { start: number; end: number } & (
+export type ContentMark = { start: number; end: number } & ContentMarkKind;
+
+/** A mark's type with its payload, shared by `ContentMark` and a `MarkOp`'s
+ * `add` / `remove`. */
+export type ContentMarkKind =
 | { type: "strong" | "emph" | "underline" | "strike" | "code" }
 | { type: "link"; attrs: { url: string } }
-| { type: "anchor"; attrs: { id: string } }
-| { type: string; attrs?: unknown }
-);
+| { type: "anchor"; attrs: { id: string } };
 
 /** A cell in a `TableProps`. `marks` rides the prose `ContentMark` shape, but
  * each mark's `start`/`end` are USV offsets into this cell's `text`, not into
@@ -158,28 +150,25 @@ export interface TableProps {
     aligns: ("none" | "left" | "center" | "right")[];
 }
 
-/** `props` of a `type: "image"` island. */
+/** `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. */
 export interface ImageProps {
     url: string;
     alt: string;
 }
 
-/** How faithfully the markdown projection can carry an island. Open: an unknown
- * class round-trips verbatim and reads as `unrepresentable`. */
-export type ContentLossClass = "lossless" | "degraded" | "unrepresentable" | (string & {});
+/** How faithfully the markdown projection can carry an island. */
+export type ContentLossClass = "lossless" | "degraded" | "unrepresentable";
 
-/** A structured object occupying one island slot in `Content.text`. `type` is an
- * open set: `props` is `TableProps` for `table` and `ImageProps` for `image`,
- * and any other type round-trips with opaque `props`. The open arm blocks
- * narrowing, so read `props` behind the `isTableIsland` / `isImageIsland`
- * guards (from `@quillmark/wasm/runtime`). */
+/** A structured object occupying one island slot in `Content.text`. `type` is a
+ * closed set, so `type === "table"` narrows `props` to `TableProps`. */
 export type ContentIsland = {
     id: string;
     loss: ContentLossClass;
 } & (
 | { type: "table"; props: TableProps }
 | { type: "image"; props: ImageProps }
-| { type: string; props: unknown }
 );
 
 /**
@@ -219,6 +208,10 @@ export interface CardAddr {
  * A text-splice change set over the USV content (CodeMirror `ChangeSet`
  * semantics), returned by `revise` and by the `rebase` codec. Map a stored
  * position through it with `mapPos`.
+ *
+ * Applying one admits an `insert` string rather than storing it verbatim: `\r`
+ * and the Unicode bidi controls drop, and a line separator — VT, FF, NEL,
+ * U+2028, U+2029 — becomes a space. Nothing reports the substitution.
  */
 export interface Delta {
     ops: ({ retain: number } | { insert: string } | { delete: number })[];
@@ -229,24 +222,25 @@ export type Assoc = "before" | "after";
 
 /**
  * A mark edit in final-text coordinates (post-delta, post-line-op). `add` /
- * `remove` carry the `ContentMark` vocabulary; `removeAnchor` drops one identity
- * anchor by id. An `add` of an `anchor` requires a non-empty `id` not already
- * live in the field; a collision or the empty id throws.
+ * `remove` are a `ContentMark` under an op, so a held mark spreads in whole;
+ * `removeAnchor` drops one identity anchor by id. An `add` of an `anchor`
+ * requires a non-empty `id` not already live in the field; a collision or the
+ * empty id throws.
  */
 export type MarkOp =
-| ({ op: "add" | "remove"; start: number; end: number } & (
-| { type: "strong" | "emph" | "underline" | "strike" | "code" }
-| { type: "link"; url: string }
-| { type: "anchor"; id: string }
-| { type: string; attrs: unknown }
-))
+| ({ op: "add" | "remove" } & ContentMark)
 | { op: "removeAnchor"; id: string };
 
 /**
  * A line/block edit. `split`/`join` splice `\n` in post-`delta`,
  * post-`islandOps` coordinates; `setKind`/`setContainers`/`setContinues` touch
  * metadata. `setContinues` sets or clears a line's within-block hard-break flag
- * (`ContentLine.continues`); `continues: true` on line 0 is rejected.
+ * (`ContentLine.continues`); `continues: true` lands as `false` on line 0, which
+ * nothing precedes, on a line whose containers differ from the line above, and
+ * on one following a heading, island or rule, each a block of one line.
+ * `setKind` lands a kind the line's text contradicts — `island` or `rule` over
+ * prose, `code` over a slot — as `para`, which is what re-importing the line's
+ * own markdown yields. Read the content back to see where an op settled.
  */
 export type LineOp =
 | { op: "split"; at: number }
@@ -277,11 +271,19 @@ export type LineOp =
  * A `set` stores the `loss` it is given; nothing re-derives the class from the
  * new `props`.
  *
- * An island is *inline* (a slot inside a paragraph) unless its line says
- * otherwise. A **block** island is one bundle of all three channels, in the
- * order they apply: `delta` inserts the `\n` that opens the line, `islandOps`
- * inserts the slot, `lineOps` tags the line `{ op: "setKind", kind: "island" }`.
- * `{ op: "split" }` cannot open that line, since line ops run after island ops.
+ * An island is *inline* (a slot inside a paragraph) or a **block** (that slot
+ * alone on a line under `kind: "island"`), and for a slot alone on a line the
+ * type settles which: markdown writes a `table` as a block and an image inline,
+ * so the line's `kind` is read off the type and a `setKind` spelling it
+ * otherwise does not survive. Landing a block island is one bundle of all three
+ * channels, in the order they apply: `delta` inserts the `\n` that opens the
+ * line, `islandOps` inserts the slot, `lineOps` tags the line
+ * `{ op: "setKind", kind: "island" }`. `{ op: "split" }` cannot open that line,
+ * since line ops run after island ops.
+ *
+ * A `table` has no inline placement: markdown writes it as a block, so an
+ * `insert` whose `at` is not an empty line throws, as does a `set` retyping an
+ * inline island into one.
  */
 export type IslandOp =
 | ({ op: "set" } & ContentIsland)
@@ -575,15 +577,9 @@ export interface ContentHit {
 }
 
 /**
- * A schema field address plus its geometry on the page, for scrolling to or
- * highlighting a field; use `LiveSession.fieldAt` for the click direction.
- *
- * `field` is **not** unique: content fields surface one region per segment
- * (paragraph, heading, whole code fence) and per page each touches, a scalar
- * referenced at several plate sites surfaces each site, and tracked content
- * plus a `field:`-bound widget yields both. Group by `field`. The whole-field
- * highlight is the union of a page's `span`-bearing rects, so inter-paragraph
- * whitespace stays uncovered; `LiveSession.fieldBoxes(field)` owns that union.
+ * A schema field address plus its geometry on the page. `field` is **not**
+ * unique, and the whole-field highlight is a union `LiveSession.fieldBoxes`
+ * owns: the consumer's copy of this contract is `runtime/runtime.d.ts`.
  */
 export interface FieldRegion {
     /**
@@ -608,8 +604,36 @@ export interface FieldRegion {
 }
 
 /**
- * Diagnostic message (error or warning)
+ * How precisely a `ContentHit.pos` resolved. Never sub-cluster: `cluster` is
+ * the finest this API offers, `segment` the floor it degrades to.
+ */
+export type HitGranularity = "cluster" | "segment";
+
+/**
+ * Output formats supported by backends. Gated behind the engine surface so
+ * tsify omits it from the core bundle, which has no rendering surface.
+ */
+export type OutputFormat = "pdf" | "svg" | "png";
+
+/**
+ * What a committed `LiveSession.update` changed. `dirtyPages` lists pages whose
+ * content differs from the previous compile, including pages the edit added;
+ * removed pages are implied by `pageCount`.
  */
+export interface ChangeSet {
+    pageCount: number;
+    dirtyPages: number[];
+}
+
+export interface Artifact {
+    format: OutputFormat;
+    /**
+     * `serde_bytes` so the boundary emits a real `Uint8Array`, not `number[]`.
+     */
+    bytes: Uint8Array;
+    mimeType: string;
+}
+
 export interface Diagnostic {
     severity: Severity;
     code?: string;
@@ -629,18 +653,14 @@ export interface Diagnostic {
      * `skip_serializing_if`, so an omitted field would be declared required.
      */
     args?: Record<string, unknown>;
-    sourceChain?: string[];
 }
 
-/**
- * How precisely a `ContentHit.pos` resolved. Never sub-cluster: `cluster` is
- * the finest this API offers, `segment` the floor it degrades to.
- */
-export type HitGranularity = "cluster" | "segment";
+export interface Location {
+    file: string;
+    line: number;
+    column: number;
+}
 
-/**
- * Options for rendering.
- */
 export interface RenderOptions {
     format?: OutputFormat;
     /**
@@ -649,14 +669,10 @@ export interface RenderOptions {
     ppi?: number;
     /**
      * 0-based page indices to render; `undefined` renders all pages. An index
-     * `>= pageCount` throws `typst::page_index_out_of_bounds`. Not supported
-     * for PDF output: throws `typst::pdf_page_selection_not_supported`.
+     * `>= pageCount` throws `backend::page_index_out_of_bounds`. Not supported
+     * for PDF output: throws `backend::page_selection_not_supported`.
      */
     pages?: number[];
-    /**
-     * PDF `/Info` `/Producer` override; defaults to `Quillmark <version>`.
-     */
-    producer?: string;
     /**
      * Populate `RenderResult.regions` with schema-field geometry, for consumers
      * without a live session. Defaults to `false`. Page indices are
@@ -665,32 +681,10 @@ export interface RenderOptions {
     regions?: boolean;
 }
 
-/**
- * Output formats supported by backends. Gated behind the engine surface so
- * tsify omits it from the core bundle, which has no rendering surface.
- */
-export type OutputFormat = "pdf" | "svg" | "png";
-
-/**
- * Rendered artifact (PDF, SVG, etc.).
- */
-export interface Artifact {
-    format: OutputFormat;
-    /**
-     * `serde_bytes` so the boundary emits a real `Uint8Array`, not `number[]`.
-     */
-    bytes: Uint8Array;
-    mimeType: string;
-}
-
-/**
- * Result of a render operation.
- */
 export interface RenderResult {
     artifacts: Artifact[];
     warnings: Diagnostic[];
     outputFormat: OutputFormat;
-    renderTimeMs: number;
     /**
      * Schema-field geometry, populated only when `RenderOptions.regions` asked
      * for it. Page indices are document-space even under a `pages` subset.
@@ -698,31 +692,9 @@ export interface RenderResult {
     regions: FieldRegion[];
 }
 
-/**
- * Source location for errors and warnings
- */
-export interface Location {
-    file: string;
-    line: number;
-    column: number;
-}
-
-/**
- * What a committed `LiveSession.update` changed. `dirtyPages` lists pages whose
- * content differs from the previous compile, including pages the edit added;
- * removed pages are implied by `pageCount`.
- */
-export interface ChangeSet {
-    pageCount: number;
-    dirtyPages: number[];
-}
-
 export type Severity = "error" | "warning";
 
 
-/**
- * Typed in-memory Quillmark document.
- */
 export class Document {
     free(): void;
     [Symbol.dispose](): void;
@@ -744,8 +716,8 @@ export class Document {
      */
     applyChange(addr: Addr | string, bundle: ChangeBundle): void;
     /**
-     * Authoring-ergonomics header introducing a blueprint to an LLM/MCP consumer
-     * for the given `quillName`, re-exposed from core.
+     * 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;
     /**
@@ -758,12 +730,6 @@ export class Document {
      * which interprets by declared type. An out-of-range `addr.card` throws.
      */
     bodyMarkdown(addr?: CardAddr): string;
-    /**
-     * A single composable card by index, so reading one need not materialize
-     * every card via [`cards`](Self::cards). An out-of-range `index` throws
-     * `edit::index_out_of_range`.
-     */
-    card(index: number): Card;
     /**
      * The composable card's own path, `cards.<kind>[index]`: the root
      * [`pathFor`](Self::path_for) extends, for anchoring the card rather than
@@ -771,9 +737,15 @@ export class Document {
      * `cards[index]`.
      */
     cardPath(index: number): string;
+    /**
+     * A single composable card by index, so reading one need not materialize
+     * every card via [`cards`](Self::cards). An out-of-range `index` throws
+     * `edit::index_out_of_range`.
+     */
+    card(index: number): Card;
     clone(): Document;
     /**
-     * Storage version this build writes via [`toJson`](Document::to_json). The
+     * Storage version this build writes via [`toStored`](Document::to_stored). The
      * tag advances only when the wire format changes, not on every release.
      */
     static currentStorageVersion(): string;
@@ -781,27 +753,22 @@ export class Document {
      * Structural equality, excluding parse-time `warnings`.
      */
     equals(other: Document): boolean;
-    /**
-     * Render a Diagnostic as the canonical pretty-printed text, so it looks
-     * identical whichever consumer surfaces it.
-     */
-    static formatDiagnostic(diag: Diagnostic): string;
     /**
      * 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.
+     */
+    static fromMarkdown(markdown: string): Document;
     /**
      * Reconstruct a `Document` from a versioned storage DTO string produced by
-     * [`toJson`](Document::to_json). The result carries no parse-time warnings.
+     * [`toStored`](Document::to_stored). The result carries no parse-time warnings.
      * 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. Throws on parse errors.
-     */
-    static fromMarkdown(markdown: string): Document;
+    static fromStored(json: string): Document;
     /**
      * The whole `$ext` map at `addr` (a card address, absent `card` = main), or
      * `undefined` when the card carries none: the `$ext` read that avoids
@@ -809,12 +776,6 @@ export class Document {
      * out-of-range card.
      */
     getExt(addr?: CardAddr): Record<string, unknown> | undefined;
-    /**
-     * The value stored under `$ext[ns]` at `addr` (a card address, absent `card`
-     * = main), or `undefined`. Throws on a present `field` or an out-of-range
-     * card.
-     */
-    getExtNamespace(addr: CardAddr, ns: string): unknown;
     /**
      * Read the **verbatim stored value** at `addr`: a field's raw payload value,
      * or the body content when `addr.field` is absent. A bare string is `Addr`
@@ -831,9 +792,8 @@ export class Document {
      * conformed, and this read reports what is there. For the `Content` either
      * way use `reader.getContent`.
      *
-     * The body arm is typed `Content` and answers in the seam form, spelling
-     * every `ContentContainer.instance`. A field arm echoes the stored bytes,
-     * which omit a zero: verbatim is the contract, and is why it is `unknown`.
+     * The body arm is typed `Content`; a field arm echoes the stored bytes
+     * unread, which is the contract and why it is `unknown`.
      */
     getStored(addr: Addr | string): unknown;
     /**
@@ -851,26 +811,12 @@ export class Document {
     isFill(addr: Addr | string): boolean;
     /**
      * Replace this document's contents **in place** from a versioned storage DTO
-     * string: the mutating twin of [`fromJson`](Document::from_json). Parse-time
-     * `warnings` are cleared. Throws on an invalid DTO, leaving the document
-     * unchanged.
-     *
-     * The cross-WASM-memory `Document` bridge: mutate a document on a
-     * backend-memory clone, then write the state back into the caller's
-     * canonical document, without the caller re-binding its variable.
-     */
-    loadJson(json: string): void;
-    /**
-     * Build a fresh `Card` from a kind and a flat field map: the ergonomic
-     * constructor for `insertCard`, which also takes any `Card` object
-     * directly. Each `fields` entry becomes a card field in insertion order;
-     * `body` defaults to `""`.
-     *
-     * Checks only what a detached card can decide alone: field-name grammar and
-     * value depth. Kind validity is positional, so `insertCard` is its gate and
-     * any kind string is accepted here.
+     * string: the mutating twin of [`fromStored`](Document::from_stored).
+     * Parse-time `warnings` are cleared. Throws on an invalid DTO, leaving the
+     * document unchanged. A caller holding the document need not re-bind its
+     * variable.
      */
-    static makeCard(kind: string, fields?: Record<string, unknown>, body?: string): Card;
+    loadStored(json: string): void;
     /**
      * Move the card at `from` to position `to`. `from == to` is a no-op.
      */
@@ -919,17 +865,10 @@ export class Document {
     removeCard(index: number): Card | undefined;
     /**
      * Remove the `$ext` map on the card `addr` targets entirely, returning the
-     * previous map or `undefined`. Discards every namespace at once; prefer
-     * `removeExtNamespace`. Throws on a present `field` or an out-of-range card.
+     * previous map or `undefined`. Discards every namespace at once. Throws on
+     * a present `field` or an out-of-range card.
      */
     removeExt(addr?: CardAddr): Record<string, unknown> | undefined;
-    /**
-     * Remove `$ext[ns]` on the card `addr` targets, returning its value or
-     * `undefined`; drops `$ext` once empty. `addr` is a card address (absent =
-     * main). Preserves sibling namespaces. Throws on a present `field` or an
-     * out-of-range card.
-     */
-    removeExtNamespace(addr: CardAddr, ns: string): any;
     /**
      * Remove a field at `addr`, returning the removed value or `undefined`. A
      * bare string is `Addr` shorthand for `{ field }`. A body address throws, as
@@ -959,12 +898,6 @@ export class Document {
      * and keeps `seedCard` pure: the quill never reads the document.
      */
     seedOverlay(kind: string): Record<string, unknown> | undefined;
-    /**
-     * 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.
-     */
-    setCardKind(index: number, new_kind: string): void;
     /**
      * Replace the QUILL reference string. Throws if `ref_str` is invalid.
      */
@@ -972,7 +905,7 @@ export class Document {
     /**
      * Read the storage version tag from a raw storage DTO string without a full
      * parse, or `undefined`. Unknown future versions come back as-is, which
-     * distinguishes "build too old" from "payload corrupt" when `fromJson`
+     * distinguishes "build too old" from "payload corrupt" when `fromStored`
      * throws. This is the storage version, not a field schema, though the JSON
      * key is spelled `"schema"`: that is the DTO's serde tag.
      */
@@ -980,16 +913,12 @@ export class Document {
     /**
      * Replace the opaque `$ext` map on the card `addr` targets (absent `card` =
      * main). `value` must be a plain object. `$ext` carries out-of-band consumer
-     * state and never reaches the rendered output. Throws on a present `field`
-     * or an out-of-range card.
+     * state and never reaches the rendered output. The whole map is the write,
+     * so a consumer holding one namespace merges the rest:
+     * `{...doc.getExt(addr), [ns]: v}`. Throws on a present `field` or an
+     * out-of-range card.
      */
     storeExt(addr: CardAddr, value: any): void;
-    /**
-     * Merge `value` into `$ext[ns]` on the card `addr` targets, preserving
-     * sibling namespaces: the recommended `$ext` write. Throws on a present
-     * `field` or an out-of-range card.
-     */
-    storeExtNamespace(addr: CardAddr, ns: string, value: any): void;
     /**
      * Store a field verbatim at `addr`, deferring coercion to render; the typed
      * write is [`commitField`](Document::commit_field). A bare string is `Addr`
@@ -1019,24 +948,18 @@ export class Document {
      * with. Throws if `overlay` cannot be serialized or nests too deep.
      */
     storeSeedOverlay(card_kind: string, overlay: any): void;
-    /**
-     * Serialize this document to a versioned storage DTO string. Prefer it over
-     * `toMarkdown` for persistence: the wire format is frozen per `schema`
-     * version and the output is byte-deterministic within one, so equal
-     * documents hash equal. Parse-time `warnings` are excluded.
-     */
-    toJson(): string;
     /**
      * Emit canonical Quillmark Markdown. Round-trip safe: re-parsing the
      * result produces a `Document` equal to `self` by value and by type.
      */
     toMarkdown(): string;
     /**
-     * Like [`fromJson`](Document::from_json) but returns `undefined` instead of
-     * throwing when `json` is not a valid storage DTO, to discriminate format
-     * without exceptions as control flow.
+     * Serialize this document to a versioned storage DTO string. Prefer it over
+     * `toMarkdown` for persistence: the wire format is frozen per `schema`
+     * version and the output is byte-deterministic within one, so equal
+     * documents hash equal. Parse-time `warnings` are excluded.
      */
-    static tryFromJson(json: string): Document | undefined;
+    toStored(): string;
     /**
      * Number of composable cards, excluding the main card.
      */
@@ -1051,20 +974,20 @@ 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 `fromJson` / `loadJson` clear it.
+     * it, and `fromStored` / `loadStored` clear it.
      */
     readonly warnings: Diagnostic[];
 }
 
 /**
- * Live render session: every read serves the current compile. `apply(doc)`
+ * Live render session: every read serves the current compile. `update(doc)`
  * recompiles a whole document in place, transactionally — on throw the reads
  * keep serving the last-good compile. Geometry is per-compile, so re-read it
- * after each committed `apply`.
+ * after each committed `update`.
  *
  * A zero-page document yields a valid session (`pageCount === 0`) whose
- * `paint(ctx, 0)` and `pageSize(0)` throw; branch on `pageCount === 0` rather
- * than catching.
+ * `paint(ctx, 0)` and `pageSize(0)` throw as any out-of-range page does; branch
+ * on `pageCount === 0` rather than catching.
  */
 export class LiveSession {
     private constructor();
@@ -1101,8 +1024,8 @@ export class LiveSession {
      */
     locate(field: string, pos: number): FieldRegion | undefined;
     /**
-     * Page dimensions in points (1 pt = 1/72 inch).
-     * Throws if the backend has no canvas painter or `page` is out of range.
+     * Page dimensions in points (1 pt = 1/72 inch). Throws if `page` is out of
+     * range, which a zero-page compile makes true of every index.
      */
     pageSize(page: number): PageSize;
     /**
@@ -1117,8 +1040,9 @@ export class LiveSession {
      * its own `<canvas>`: no compositing, sub-rect, or transform reaches through
      * this call.
      *
-     * 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`.
+     * 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`).
      */
     paint(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, page: number, opts: PaintOptions | undefined): PaintResult;
     /**
@@ -1159,13 +1083,9 @@ export class LiveSession {
      */
     readonly backendId: string;
     readonly pageCount: number;
-    /**
-     * `true` iff `paint` and `pageSize` will succeed for this session.
-     */
-    readonly supportsCanvas: boolean;
     /**
      * Non-fatal diagnostics of the session's **current compile**, refreshed by
-     * each committed `apply`; a failed apply keeps the last-good compile's.
+     * each committed `update`; a failed `update` keeps the last-good compile's.
      * Also appended to `RenderResult.warnings` on each `render()`.
      */
     readonly warnings: Diagnostic[];
@@ -1179,7 +1099,7 @@ export class Quill {
      * Land `doc`'s declared content fields at their canonical rest **in
      * place**, returning the `conform::*` diagnostics for values that would not
      * commit. The read-repair verb for a document that arrived through the
-     * transport door (`fromMarkdown`, `fromJson`, a stored row).
+     * 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
@@ -1207,14 +1127,6 @@ export class Quill {
      * is stale, use `Document.fromMarkdown`, `setQuillRef`, then `quill.conform`.
      */
     parse(markdown: string): Document;
-    /**
-     * The resolved-value view of `doc`: for every declared field, the value the
-     * render projection would use and the `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.
-     */
-    resolve(doc: Document): Resolved;
     /**
      * Seed a starter composable `Card` of the given kind (carries `$kind`),
      * layering an optional per-kind seed `overlay` over the schema-example base
@@ -1244,8 +1156,8 @@ export class Quill {
      *
      * This is how a quill crosses a WASM linear-memory boundary as data: a
      * `Quill` built in one build cannot be passed to an engine in another, so
-     * `@quillmark/wasm/runtime` re-feeds this tree to the backend build's
-     * `Quill.fromTree` on demand.
+     * the `@quillmark/wasm` runtime layer re-feeds this tree to the backend
+     * build's `Quill.fromTree` on demand.
      */
     toTree(): Map<string, Uint8Array>;
     /**
@@ -1262,9 +1174,9 @@ export class Quill {
     readonly backendId: string;
     readonly blueprint: string;
     /**
-     * Identity snapshot of the `quill:` section of `Quill.yaml` plus any extra
-     * `quill:` keys. Pure config: output formats are a resolved-backend
-     * capability read from `Quillmark.supportedFormats`, not part of this.
+     * Identity snapshot of the `quill:` section of `Quill.yaml`. Pure config:
+     * output formats are a resolved-backend capability read from
+     * `Quillmark.supportedFormats`, not part of this.
      */
     readonly metadata: QuillMetadata;
     /**
@@ -1273,6 +1185,12 @@ export class Quill {
      * ordering contract.
      */
     readonly schema: QuillSchema;
+    /**
+     * The advisory diagnostics of the load that produced this quill: what is
+     * wrong with it short of refusing it. A quill that loads clean answers
+     * `[]`.
+     */
+    readonly warnings: Diagnostic[];
 }
 
 /**
@@ -1299,12 +1217,6 @@ export class Quillmark {
      * backend matches the quill's declared one.
      */
     supportedFormats(quill: Quill): OutputFormat[];
-    /**
-     * Whether `quill`'s backend can paint sessions to a canvas; `false` when the
-     * backend is unsupported. A cheap probe before mounting a preview UI. The
-     * authoritative answer is the session's `supportsCanvas` getter.
-     */
-    supportsCanvas(quill: Quill): boolean;
 }
 
 /**
@@ -1403,18 +1315,15 @@ 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_formatDiagnostic: (a: number, b: number) => void;
     readonly document_formatRules: (a: number) => void;
-    readonly document_fromJson: (a: number, b: number, c: 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_getExtNamespace: (a: number, b: number, c: number, d: number, e: 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_loadJson: (a: number, b: number, c: number, d: number) => void;
+    readonly document_loadStored: (a: number, b: number, c: number, d: number) => void;
     readonly document_main: (a: number, b: number) => void;
-    readonly document_makeCard: (a: number, b: number, c: number, d: number, e: number, f: 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;
@@ -1423,23 +1332,19 @@ export interface InitOutput {
     readonly document_quillRefHint: (a: number) => void;
     readonly document_removeCard: (a: number, b: number, c: number) => void;
     readonly document_removeExt: (a: number, b: number, c: number) => void;
-    readonly document_removeExtNamespace: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly document_removeField: (a: number, b: number, c: number) => void;
     readonly document_removeSeedOverlay: (a: number, b: number, c: number, d: number) => void;
     readonly document_revise: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly document_seedOverlay: (a: number, b: number, c: number, d: number) => void;
-    readonly document_setCardKind: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly document_setQuillRef: (a: number, b: number, c: number, d: number) => void;
     readonly document_storageVersionOf: (a: number, b: number, c: number) => void;
     readonly document_storeExt: (a: number, b: number, c: number, d: number) => void;
-    readonly document_storeExtNamespace: (a: number, b: number, c: number, d: number, e: number, f: 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_toJson: (a: number, b: number) => void;
     readonly document_toMarkdown: (a: number, b: number) => void;
-    readonly document_tryFromJson: (a: number, b: number) => number;
+    readonly document_toStored: (a: number, b: number) => void;
     readonly document_warnings: (a: number, b: number) => void;
     readonly exportMarkdown: (a: number, b: number) => void;
     readonly formatDocPath: (a: number, b: number) => void;
@@ -1447,37 +1352,36 @@ export interface InitOutput {
     readonly livesession_backendId: (a: number, b: number) => void;
     readonly livesession_fieldAt: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly livesession_fieldBoxes: (a: number, b: number, c: number, d: number) => void;
-    readonly livesession_locate: (a: number, b: number, c: number, d: number) => number;
+    readonly livesession_locate: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly livesession_pageCount: (a: number) => number;
     readonly livesession_pageSize: (a: number, b: number, c: number) => void;
     readonly livesession_paint: (a: number, b: number, c: number, d: number, e: number) => void;
-    readonly livesession_positionAt: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly livesession_positionAt: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly livesession_regions: (a: number, b: number) => void;
     readonly livesession_render: (a: number, b: number, c: number) => void;
-    readonly livesession_supportsCanvas: (a: number) => number;
     readonly livesession_update: (a: number, b: number, c: number) => void;
     readonly livesession_warnings: (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_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_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;
-    readonly quill_resolve: (a: number, b: number, c: number) => void;
     readonly quill_schema: (a: number, b: number) => void;
     readonly quill_seedCard: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly quill_seedDocument: (a: number) => number;
     readonly quill_seedMain: (a: number, b: number) => void;
     readonly quill_toTree: (a: number) => number;
     readonly quill_validate: (a: number, b: number, c: number) => void;
+    readonly quill_warnings: (a: number, b: number) => void;
     readonly quillmark_new: () => number;
     readonly quillmark_open: (a: number, b: number, c: number, d: number) => void;
     readonly quillmark_render: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly quillmark_supportedFormats: (a: number, b: number, c: number) => void;
-    readonly quillmark_supportsCanvas: (a: number, b: number) => number;
     readonly rebase: (a: number, b: number, c: number, d: number) => void;
     readonly start: () => void;
     readonly __wbindgen_export: (a: number, b: number) => number;