@quillmark/wasm 0.92.1 → 0.95.1

package/backends/pdfform/wasm.d.ts

@@ -0,0 +1,1066 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A path to a value nested inside a field `value`: `string` keys and
+ * `number` array indices, e.g. `["addr", "street"]` or `["recipients", 0, "name"]`.
+ */
+export type PathStep = string | number;
+
+/** A field or comment entry in a `Card.payloadItems` list. */
+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` / `makeCard`.
+     */
+    nestedFills?: PathStep[][];
+}
+| { type: "comment"; text: string; inline?: boolean };
+
+/**
+ * A single card block, as read back from a document: returned by
+ * `Document.main` / `Document.cards` / `Document.removeCard` / `Quill.seedCard`
+ * / `Document.makeCard`. To feed a card *into* a document use `CardInput`
+ * (which `insertCard` accepts); 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), optional `quill` (the `$quill` `name@version`, main card
+ * only), optional `id` (`$id`), optional `ext` (`$ext`), and optional `seed`
+ * (the `$seed` per-kind overlay map, main card only). `payloadItems` carries
+ * user fields and comments in order.
+ */
+export interface Card {
+    kind: string;
+    quill?: string;
+    id?: string;
+    ext?: Record<string, unknown>;
+    seed?: Record<string, unknown>;
+    payloadItems: PayloadItem[];
+    /**
+     * The card body as canonical `Content` — the source-of-truth content model.
+     * Always this content shape on read, never a markdown string. For the markdown
+     * projection call the codec `exportMarkdown(card.body)`. Write a body back
+     * with `doc.install(addr, rt)` / `doc.revise(addr, md)`, or via `CardInput.body`.
+     */
+    body: Content;
+}
+
+/**
+ * A card written *into* a document — the input twin of `Card`, accepted by
+ * `Document.insertCard`. Like `Card` but `body` also
+ * takes a markdown `string` (imported to the content, so a markdown / LLM writer
+ * needn't build the `Content` shape), and every field but `kind` is optional —
+ * an absent field defaults (no payload items, an empty body). Write one inline
+ * (`{ kind, body }`) or build it with `Document.makeCard`.
+ */
+export interface CardInput {
+    kind: string;
+    quill?: string;
+    id?: string;
+    ext?: Record<string, unknown>;
+    seed?: Record<string, unknown>;
+    payloadItems?: PayloadItem[];
+    body?: Content | string;
+}
+
+/**
+ * Canonical richtext content — the content model for a card body (and richtext
+ * fields). One text sequence over a single coordinate space (Unicode scalar
+ * values): `text` plus line attributes, anchored `marks`, and embedded
+ * `islands`. Every edit is a splice; markdown is a projection, not the model.
+ * Mirrors `quillmark_content::serial`'s canonical JSON encoding.
+ */
+export interface Content {
+    text: string;
+    lines: ContentLine[];
+    marks: ContentMark[];
+    islands: ContentIsland[];
+}
+
+/** One `\n`-separated segment of `Content.text`, in order. */
+export type ContentLine = {
+    containers: ContentContainer[];
+    /** A within-block hard line break rather than a new block. Omitted (false) in the common case. */
+    continues?: boolean;
+} & (
+| { kind: "para" }
+| { kind: "heading"; level: number }
+| { kind: "code"; lang?: string }
+| { kind: "island" }
+| { kind: "rule" }
+);
+
+/** An ancestor block a line nests inside, outermost first. */
+export type ContentContainer =
+| { container: "list_item"; ordered: boolean; start: number; ordinal: number }
+| { container: "quote" };
+
+/** A mark over char range `[start, end)` into `Content.text`. */
+export type ContentMark = { start: number; end: number } & (
+| { type: "strong" | "emph" | "underline" | "strike" | "code" }
+| { type: "link"; url: string }
+| { type: "anchor"; id: string }
+| { type: string; attrs: unknown }
+);
+
+/** A structured object (table, figure, …) occupying one island slot in `Content.text`. */
+export interface ContentIsland {
+    id: string;
+    type: string;
+    props: unknown;
+    /** How faithfully the markdown projection can carry this island. */
+    loss: "lossless" | "degraded" | "unrepresentable";
+}
+
+/**
+ * A write address — one navigation concept for the whole `Document` surface. An
+ * absent `field` targets the card body; an absent `card` targets the main card.
+ * `{}` is the main-card body; `{ card: 2 }` the body of the composable card at
+ * index 2; `{ field: "intro" }` the main card's `intro` field; `{ card: 2,
+ * field: "intro" }` a card field.
+ *
+ * On the `Addr`-taking verbs a **bare string** is shorthand for `{ field: name }`
+ * — `doc.storeField("qty", 3)`, `doc.revise("intro", md)` — the one coercion
+ * rule. A bare number is *not* an addr (`{ card: 2 }` is the self-documenting
+ * spelling), so no third navigation idiom re-fragments the surface.
+ */
+export interface Addr {
+    card?: number;
+    field?: string;
+}
+
+/**
+ * A card-only address — the axis the card-scoped verbs (`storeFields`,
+ * `storeExt`, `getExt`, `commitFields`, …) take. An absent `card` targets the
+ * main card. A present `field` throws: a card address takes only `card`, and a
+ * would-be nested write is a bug the error names rather than silently ignores.
+ */
+export interface CardAddr {
+    card?: number;
+}
+
+/**
+ * A text-splice change set over the USV content (CodeMirror `ChangeSet`
+ * semantics) — plain, structured-clone-able data. Returned by `revise` and by
+ * the `rebase` codec; map a stored position through it with `mapPos`.
+ */
+export interface Delta {
+    ops: ({ retain: number } | { insert: string } | { delete: number })[];
+}
+
+/** Which side of a same-position insertion `mapPos` lands a point on. */
+export type Assoc = "before" | "after";
+
+/**
+ * A mark edit in final-text coordinates (post-delta, post-line-op). `add` /
+ * `remove` carry the `ContentMark` vocabulary (`{ type, … }`); `removeAnchor`
+ * drops one identity anchor by id.
+ */
+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: "removeAnchor"; id: string };
+
+/**
+ * A line/block edit. `split`/`join` splice `\n`; `setKind`/`setContainers`/
+ * `setContinues` touch metadata. `setContinues` sets/clears a line's within-block
+ * hard-break flag (`ContentLine.continues`) — the op-grained way to lower a
+ * Shift+Enter hard break or a new code-fence interior line; `continues: true` on
+ * line 0 is rejected (nothing precedes it to continue).
+ */
+export type LineOp =
+| { op: "split"; at: number }
+| { op: "join"; line: number }
+| ({ op: "setKind"; line: number } & (
+| { kind: "para" | "island" | "rule" }
+| { kind: "heading"; level: number }
+| { kind: "code"; lang?: string }
+))
+| { op: "setContainers"; line: number; containers: ContentContainer[] }
+| { op: "setContinues"; line: number; continues: boolean };
+
+/**
+ * A committed content edit bundle for `applyChange`: a text `delta` (default no
+ * text change), then `lineOps`, then `markOps` (mark ranges are in post-delta
+ * coordinates). Every field is optional.
+ */
+export interface ChangeBundle {
+    delta?: Delta;
+    lineOps?: LineOp[];
+    markOps?: MarkOp[];
+}
+
+
+
+/**
+ * Page dimensions in points (1 pt = 1/72 inch). Typst measures in Typst
+ * points; pdfform measures in PDF points — the same unit.
+ *
+ * Report-only: the painter sizes the canvas itself based on
+ * `PaintOptions`. `pageSize` is exposed for callers that need page
+ * geometry up-front (e.g. to lay out a scrollable list of canvases
+ * before any pixels are rendered).
+ */
+export interface PageSize {
+    widthPt: number;
+    heightPt: number;
+}
+
+/**
+ * Inputs to `LiveSession.paint`. Both fields are optional and default
+ * to `1`.
+ *
+ * - `layoutScale` — layout-space pixels per point (Typst point / PDF
+ *   point — the same 1/72″ unit). For on-screen
+ *   canvases this is CSS pixels per pt; the page's layout-pixel size is
+ *   `widthPt * layoutScale × heightPt * layoutScale`. The painter
+ *   surfaces these dimensions as `layoutWidth` / `layoutHeight` so
+ *   consumers can drive `canvas.style.*` (or any layout system).
+ * - `densityScale` — backing-store density multiplier. Fold
+ *   `window.devicePixelRatio`, in-app zoom, and `visualViewport.scale`
+ *   (pinch-zoom) into a single value here. Defaults to `1`, which
+ *   produces a non-retina backing store — pass `window.devicePixelRatio`
+ *   for crisp output on high-DPI displays.
+ *
+ * The effective rasterization scale is `layoutScale * densityScale`.
+ * Both must be finite and `> 0`. For `OffscreenCanvasRenderingContext2D`
+ * the two collapse to a single scalar; folding everything into
+ * `densityScale` is the simplest convention.
+ */
+export interface PaintOptions {
+    layoutScale?: number;
+    densityScale?: number;
+}
+
+/**
+ * Returned by `LiveSession.paint`.
+ *
+ * - `layoutWidth` / `layoutHeight` — layout-pixel dimensions of the
+ *   canvas's display box. For on-screen canvases this is CSS pixels:
+ *   set `canvas.style.width = layoutWidth + "px"` and
+ *   `canvas.style.height = layoutHeight + "px"` (or feed these into
+ *   your layout system). Independent of `densityScale`.
+ * - `pixelWidth` / `pixelHeight` — integer backing-store pixel
+ *   dimensions the painter wrote to `canvas.width` / `canvas.height`.
+ *   Equal to `round(layoutWidth * densityScale)` ×
+ *   `round(layoutHeight * densityScale)` *unless* the requested backing
+ *   exceeded the painter's safe maximum (16384 px per side), in which
+ *   case `densityScale` was clamped to fit.
+ * - `clamped` — `true` when that 16384-px clamp fired, so the page is
+ *   painted at fewer device pixels than requested and renders soft at the
+ *   same `canvas.style` size. Reads the clamp off the return value instead
+ *   of the `pixelWidth < round(layoutWidth * densityScale)` derivation.
+ * - `effectiveDensityScale` — the `densityScale` actually applied: the
+ *   requested value unless `clamped`, then reduced proportionally.
+ *   `layoutScale * effectiveDensityScale` is the scale the backing store
+ *   was rasterized at.
+ *
+ * The painter owns `canvas.width` / `canvas.height`; consumers must not
+ * write to them. The painter does **not** touch `canvas.style.*`;
+ * consumers own layout. The write is a whole-backing-store `putImageData`,
+ * which bypasses the 2D context transform, `globalAlpha`, and clip: give
+ * each visible page its own `` — you cannot composite two pages, a
+ * sub-rect, or a context transform through `paint`.
+ *
+ * For `OffscreenCanvasRenderingContext2D` (Worker rasterization, no
+ * DOM), `layoutWidth` / `layoutHeight` are informational — there's no
+ * CSS layout box to apply them to.
+ */
+export interface PaintResult {
+    layoutWidth: number;
+    layoutHeight: number;
+    pixelWidth: number;
+    pixelHeight: number;
+    clamped: boolean;
+    effectiveDensityScale: number;
+}
+
+
+
+/** UI layout hints for a single field. Field display order is not a hint:
+ * key order in the schema's `fields`/`properties` objects is declaration
+ * order, the ordering contract. */
+export interface QuillFieldUi {
+    title?: string;
+    group?: string;
+    compact?: boolean;
+    multiline?: boolean;
+}
+
+/** UI layout hints for a card (main or named card kind). */
+export interface QuillCardUi {
+    title?: string;
+}
+
+/** 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;
+}
+
+/** Schema entry for a single field declared in a quill's `Quill.yaml`.
+ *
+ * A field's *cell* is determined by `default`: a field with a `default`
+ * is **Endorsed** (the rendered value is shippable as-is), while a field
+ * without a `default` is **Unendorsed** (the blueprint carries a
+ * `!must_fill` marker; a marker left in the document yields the non-fatal
+ * `validation::must_fill` warning from validate, and the render path
+ * zero-fills the field). There is no separate `required` axis.
+ */
+export interface QuillFieldSchema {
+    type: "string" | "number" | "integer" | "boolean" | "array" | "object" | "date" | "datetime" | "richtext" | "plaintext" | "enum";
+    description?: string;
+    default?: unknown;
+    example?: unknown;
+    /** Closed value domain. On `type: "enum"` declared as `values`; the
+     *  deprecated `enum` modifier on `type: "string"` is accepted for one
+     *  release. Both round-trip through this field. */
+    enum?: string[];
+    /** Required on `type: "enum"`: the closed set of allowed string values. */
+    values?: string[];
+    ui?: QuillFieldUi;
+    properties?: Record<string, QuillFieldSchema>;
+    items?: QuillFieldSchema;
+    /** Present (and `true`) on a `richtext` or `plaintext` field declared
+     *  `inline` — the single-paragraph, container-free, island-free constraint.
+     *  Core serializes `inline: true` into the schema JSON; absent otherwise. */
+    inline?: boolean;
+}
+
+/** Schema entry for the main card or a named card kind. */
+export interface QuillCardSchema {
+    description?: string;
+    fields: Record<string, QuillFieldSchema>;
+    ui?: QuillCardUi;
+    body?: QuillCardBody;
+}
+
+/**
+ * Document schema returned by `Quill.schema`. Includes optional `ui` keys.
+ *
+ * Describes only the user-fillable fields. The quill reference
+ * (constructed as `${metadata.name}@${metadata.version}`) and card-kind
+ * discriminators are document-level metadata, not schema fields.
+ */
+export interface QuillSchema {
+    main: QuillCardSchema;
+    /** Present only when the quill declares at least one named card kind. */
+    card_kinds?: Record<string, QuillCardSchema>;
+}
+
+/**
+ * Identity snapshot mirroring the `quill:` section of `Quill.yaml`.
+ * The schema lives on `Quill.schema`; the backend's output formats are a
+ * resolved-backend capability read from the engine (`Quillmark.supportedFormats`),
+ * not part of this pure-config snapshot.
+ */
+export interface QuillMetadata {
+    name: string;
+    version: string;
+    backend: string;
+    author: string;
+    description: string;
+}
+
+
+export interface Artifact {
+    format: OutputFormat;
+    bytes: Uint8Array;
+    mimeType: string;
+}
+
+export interface ChangeSet {
+    pageCount: number;
+    dirtyPages: number[];
+}
+
+export interface ContentHit {
+    field: string;
+    pos: number;
+    granularity?: HitGranularity;
+}
+
+export interface Diagnostic {
+    severity: Severity;
+    code?: string;
+    message: string;
+    location?: Location;
+    path?: string;
+    hint?: string;
+    sourceChain?: string[];
+}
+
+export interface FieldRegion {
+    field: string;
+    page: number;
+    rect: [number, number, number, number];
+    span?: [number, number];
+}
+
+export interface Location {
+    file: string;
+    line: number;
+    column: number;
+}
+
+export interface RenderOptions {
+    format?: OutputFormat;
+    ppi?: number;
+    pages?: number[];
+    producer?: string;
+    regions?: boolean;
+}
+
+export interface RenderResult {
+    artifacts: Artifact[];
+    warnings: Diagnostic[];
+    outputFormat: OutputFormat;
+    renderTimeMs: number;
+    regions: FieldRegion[];
+}
+
+export type HitGranularity = "cluster" | "segment";
+
+export type OutputFormat = "pdf" | "svg" | "txt" | "png";
+
+export type Severity = "error" | "warning";
+
+
+/**
+ * Typed in-memory Quillmark document.
+ */
+export class Document {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * **Apply** a committed content edit `bundle` (`{ delta?, lineOps?, markOps? }`)
+     * at `addr` — the editor splice: text delta first, then line ops, then mark
+     * ops (mark ranges in final-text coordinates), each all-or-nothing. An absent
+     * `addr.field` targets the body, an absent `addr.card` the main card.
+     *
+     * Throws on an out-of-range card, a field that is not richtext, a malformed
+     * bundle, or an op that applies out of bounds (the value is unchanged on a
+     * failed apply).
+     */
+    applyChange(addr: Addr | string, bundle: ChangeBundle): void;
+    /**
+     * Authoring-ergonomics header introducing a blueprint to an LLM/MCP
+     * consumer for the given `quillName`. Re-exposes core's canonical text for
+     * JS consumers; any surface that draws from the same core source stays
+     * uniform.
+     */
+    static blueprintInstruction(quill_name: string): string;
+    /**
+     * A single composable card by index — the whole `Card`, the card-indexed
+     * twin of the [`main`](Self::main) getter, so reading one card need not
+     * materialize every card via [`cards`](Self::cards). An out-of-range
+     * `index` throws `[EditError::IndexOutOfRange]`, matching the card write
+     * verbs.
+     */
+    card(index: number): Card;
+    /**
+     * The index of the first composable card whose `$id` equals `id`, or
+     * `undefined` when none carries it. Resolves the canonical durable address
+     * without a hand-rolled scan over [`cards`](Self::cards); `$id` is
+     * non-unique by design, so the first match wins.
+     */
+    cardIndexById(id: string): number | undefined;
+    clone(): Document;
+    /**
+     * Schema version this build writes via [`toJson`](Document::to_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 (parse-time `warnings` excluded). Use to debounce
+     * upstream prop updates instead of re-parsing on every keystroke.
+     */
+    equals(other: Document): boolean;
+    /**
+     * Render a Diagnostic as the canonical pretty-printed text (core's
+     * `Diagnostic::fmt_pretty`). Single source of truth so a Diagnostic looks
+     * identical no matter which consumer surfaces it.
+     */
+    static formatDiagnostic(diag: Diagnostic): string;
+    /**
+     * Authoring-format rules for the card-yaml markdown surface. The canonical
+     * text is core's (`quillmark_core::document::FORMAT_RULES`), re-exposed
+     * here for JS consumers so it matches any other surface that draws from the
+     * same source. Read once at startup and cache; the value never changes
+     * between calls.
+     */
+    static formatRules(): 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).
+     *
+     * 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;
+    /**
+     * Read the value at `addr` — the raw stored payload value of a field (a
+     * content object for a richtext field, a scalar/array/object otherwise), or
+     * the **body content** when `addr.field` is absent. A bare string is `Addr`
+     * shorthand for `{ field }`. Reads are total over the field axis: an absent
+     * field is `undefined`; only an out-of-range `addr.card` throws
+     * `[EditError::IndexOutOfRange]`. Reads need no schema, so they live on
+     * `Document`, not the typed writer; for the markdown projection of a
+     * richtext value use [`getMarkdown`](Self::get_markdown).
+     */
+    get(addr: Addr | string): unknown;
+    /**
+     * The whole `$ext` map at `addr` (a card address, absent `card` = main), or
+     * `undefined` when the card carries none. The fine-grained `$ext` read —
+     * your own state without serializing the whole card. Throws on a present
+     * `field` (a card address takes only `card`) or an 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`. The namespace-scoped `$ext` read — your own slot
+     * without a whole-card serialize, and non-destructive (unlike
+     * `removeExtNamespace`). Throws on a present `field` or an out-of-range card.
+     */
+    getExtNamespace(addr: CardAddr, ns: string): unknown;
+    /**
+     * The **body** markdown projection — the main body, or a composable card's
+     * body (`{ card }`) — the on-demand, lossy export (content-only marks do not
+     * survive markdown). A body's type is a format fact, not a schema fact, so
+     * this read stays quill-free; a body is never absent.
+     *
+     * `addr` is an optional **card address** (`{ card }`, absent = main). A
+     * present `field` throws — a field's markdown is read through the
+     * schema-plane `quill.view(doc).get(field)`, which interprets by declared
+     * type (#978). An out-of-range `addr.card` throws.
+     */
+    getMarkdown(addr?: CardAddr): string;
+    /**
+     * Insert a card — the single insertion verb: `at` absent appends, a number
+     * inserts at that index (must be in `0..=cards.length`). Accepts a
+     * `CardInput` — a card read back (`cards` / `removeCard` / `quill.seedCard`),
+     * a [`makeCard`](Document::make_card) result, or a bare `{ kind, body }`
+     * (every returned `Card` is a valid `CardInput`). Throws if `card.kind` is
+     * not a valid kind name, or if `at` is out of range.
+     */
+    insertCard(card: CardInput, at?: number): void;
+    /**
+     * **Install** a richtext value at `addr` — **value semantics**, content only.
+     * Stores exactly `rt` (a canonical `Content` content object); the identity
+     * anchors of any previous value are gone. An absent `addr.field` targets the
+     * body, an absent `addr.card` the main card. For "here's new markdown," use
+     * [`revise`](Document::revise); the cold-import path is spelled at the call
+     * site as `install(addr, importMarkdown(md))`, so anchor loss is visible in
+     * source.
+     *
+     * Throws on an out-of-range card, a malformed field name, or an `rt` that is
+     * not a canonical content object.
+     */
+    install(addr: Addr | string, rt: Content): void;
+    /**
+     * Whether the field at `addr` is marked `!must_fill`. A bare string is `Addr`
+     * shorthand for `{ field }`. `false` for an absent field (truthful — it isn't
+     * marked) and for a body address (a body is never a fill). 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 the static
+     * [`fromJson`](Document::from_json) constructor. Parse-time `warnings` are
+     * cleared. Throws (leaving the document unchanged) on an invalid DTO.
+     *
+     * The cross-WASM-memory `Document` bridge: mutate a document on a
+     * backend-memory clone, then write the mutated state back into the caller's
+     * canonical document with this — the one way to update a live handle across
+     * the linear-memory seam 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`. `fields` is an optional
+     * `Record<string, unknown>` (each entry becomes a card field, in
+     * insertion order); `body` defaults to `""`. Kind validity is checked by
+     * `insertCard`, not here.
+     */
+    static makeCard(kind: string, fields?: Record<string, unknown>, body?: string): Card;
+    /**
+     * Move the card at `from` to position `to`. `from == to` is a no-op.
+     */
+    moveCard(from: number, to: number): void;
+    /**
+     * `new Document(quillRef)` — a blank document: a main card carrying only
+     * `$quill`, an empty body, and no composable cards. The programmatic
+     * blank canvas: absent fields resolve at render time (`default`, else
+     * type-empty zero), so nothing the caller did not set reaches the
+     * output. For an example-filled starter use `Quill.seedDocument()`.
+     * Throws on an invalid quill reference. Mirrors Python `Document(quill_ref)`.
+     */
+    constructor(quill_ref: string);
+    /**
+     * The canonical `$quill` reference grammar as author-facing text. Core is
+     * the single source of truth: drive schema `describe` and validation
+     * messages from this instead of re-stating the rule — it matches the
+     * `hint` on `parse::invalid_quill_reference`. Cache it; the value never
+     * changes.
+     */
+    static quillRefHint(): string;
+    removeCard(index: number): Card | undefined;
+    /**
+     * Remove the `$ext` map on the card `addr` targets *entirely*, returning the
+     * previous map or `undefined` — a blunt escape hatch that discards every
+     * namespace at once (prefer `removeExtNamespace`). `addr` is a card address
+     * (absent = main). 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 }`. One `remove` verb serves
+     * every write lane. A body address throws; throws on an out-of-range card or
+     * a malformed name.
+     */
+    removeField(addr: Addr | string): any;
+    /**
+     * Remove `cardKind` from the main card's `$seed` map, returning its
+     * overlay or `undefined`; drops `$seed` entirely once empty. Sibling kinds
+     * survive. `$seed` is main-only, so this takes no address.
+     */
+    removeSeedNamespace(card_kind: string): any;
+    /**
+     * **Revise** the richtext value at `addr` from a markdown string — **edit
+     * semantics**, the default write path, returning the text [`Delta`]. Imports
+     * the markdown, diffs it against the current value, rebases surviving
+     * identity anchors, and returns the change an editor bridge maps its own
+     * positions through (`mapPos`). An absent `addr.field` targets the body, an
+     * absent `addr.card` the main card; an absent field cold-imports from empty.
+     *
+     * Throws on an out-of-range card, a malformed field name, a present
+     * non-content field value, or an over-nested markdown input.
+     */
+    revise(addr: Addr | string, markdown: string): Delta;
+    /**
+     * 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;
+    /**
+     * The main card's `$seed` overlay object for `kind` (the `$seed[kind]`
+     * entry), or `undefined` when absent. The cheap read that feeds
+     * `quill.seedCard(kind, overlay)` without serializing the whole main card
+     * via [`main`](Self::main) to fish out one key — and it keeps `seedCard`
+     * pure: the quill still 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.
+     */
+    setQuillRef(ref_str: string): void;
+    /**
+     * Replace the opaque `$ext` map on the card `addr` targets (a card address,
+     * absent `card` = main). `value` must be a plain object. `$ext` carries
+     * out-of-band consumer state and never reaches the rendered output; pass
+     * `{}` for an explicit empty `$ext`. Quill-free and verbatim — an opaque
+     * `store` verb. 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. `addr` is a card
+     * address (absent = main). Quill-free and verbatim — an opaque `store` verb.
+     * 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` — the opaque store (**store** = verbatim,
+     * coercion deferred to render; the typed write is
+     * [`commitField`](Document::commit_field)). A bare string is `Addr`
+     * shorthand for `{ field }`, so `doc.storeField("qty", 3)` reads as written;
+     * `{ card: 2, field: "qty" }` targets a composable card. Clears any
+     * `!must_fill` marker. A body address (no `field`) throws — a body is never
+     * opaque; write it with `revise` / `install` / `writer.setBody`. Throws on
+     * an out-of-range card or a malformed name.
+     */
+    storeField(addr: Addr | string, value: any): void;
+    /**
+     * Store several fields verbatim and atomically on the card `addr` targets —
+     * the opaque store's batch. `addr` is a **card address** (`{ card }`, absent
+     * = main); a present `field` throws. The batch verb takes the address first
+     * and is never shape-overloaded, because `card` is a legal field name:
+     * `storeFields({}, fields)` is the main card, `storeFields({ card: 2 },
+     * fields)` a composable one — never ambiguous with "set field `card`".
+     * Nothing is applied on error; the thrown error's `diagnostics` carry 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` — the opaque
+     * store's fill variant, card-capable (a bare string or `{ field }` for main,
+     * `{ card, field }` for a composable card). 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` lives on the main
+     * card by model, so this takes no address. Sets the starting values new
+     * cards of that kind spawn with. Quill-free and verbatim — an opaque `store`
+     * verb. Throws if `overlay` cannot be serialized or nests too deep.
+     */
+    storeSeedNamespace(card_kind: string, overlay: any): void;
+    /**
+     * Serialize this document to a versioned storage DTO string.
+     *
+     * 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.
+     *
+     * 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. 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 — 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;
+    /**
+     * Number of composable cards (excludes the main card). O(1).
+     */
+    readonly cardCount: number;
+    readonly cards: Card[];
+    /**
+     * The document's main (entry) card. Allocates and serializes on each
+     * call — cache locally if read in a hot loop.
+     */
+    readonly main: Card;
+    readonly quillRef: string;
+    readonly warnings: Diagnostic[];
+}
+
+/**
+ * Live render session: reads (`render`, `paint`, `pageSize`, `regions`,
+ * `fieldAt`, `positionAt`, `locate`) serve the current compile. `apply(doc)`
+ * recompiles a whole document in place, transactionally (on throw every read
+ * keeps serving the last-good compile). Geometry reads reflect the current
+ * compile; anchoring a caret across edits is the editor's job — re-read
+ * geometry after each committed `apply`.
+ *
+ * **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 LiveSession {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Recompile the session against `doc` — the edit verb of a live preview.
+     * The document is compiled through the same schema pipeline as `open`
+     * (same quill), then applied transactionally: on throw every read
+     * (`render`, `paint`, `pageSize`, `regions`, `fieldAt`) keeps serving the last-good
+     * compile, and the session recovers on the next successful `apply`. On
+     * success reads serve the new compile; repaint `dirtyPages ∩ visible`.
+     */
+    apply(doc: Document): ChangeSet;
+    /**
+     * The schema field whose content is under a point on `page` — the
+     * forward (click → field) direction: hit-test a click against the
+     * compiled document and get back the field address to focus in the
+     * editor, or `undefined` off any field's ink. `x`/`y` are PDF points
+     * with a **bottom-left** origin, the same space as `FieldRegion.rect` —
+     * from a canvas click, invert the overlay transform documented on
+     * `FieldRegion`: `x = clickPx.x / renderScale`,
+     * `y = pageHeightPt - clickPx.y / renderScale`. Unlike `regions()`,
+     * *every* placement answers, not just the first.
+     */
+    fieldAt(page: number, x: number, y: number): string | undefined;
+    /**
+     * The whole-field highlight boxes for `field` — one union rect per page,
+     * over the field's `span`-bearing content segments. The convenience that
+     * owns the union `regions()` leaves derived: it keeps `regions()` the
+     * low-level disjoint truth (#829) and folds the span-filter + per-page
+     * union here, so a "highlight the focused field" consumer stops
+     * reimplementing it. **Content only** — a field placed solely as a scalar
+     * reference or a bound widget carries no `span` and returns `[]`; its box
+     * is a single `regions()` rect. Reflects the current compile, like
+     * `regions()`.
+     */
+    fieldBoxes(field: string): FieldRegion[];
+    /**
+     * A content position → **caret rect** — the reverse of `positionAt`: given
+     * a field and a USV offset into its `Content`, return the box (in the
+     * same bottom-left PDF-point space as `FieldRegion.rect`) to draw a caret
+     * at, its `span` collapsed to `[pos, pos]`; `undefined` when the field
+     * places no tracked content or the offset maps to no drawn glyph.
+     */
+    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.
+     */
+    pageSize(page: number): PageSize;
+    /**
+     * 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 — `PaintResult.clamped` reports it and
+     * `PaintResult.effectiveDensityScale` carries the density actually applied.
+     *
+     * `put_image_data` writes the whole backing store, bypassing the 2D
+     * context's transform, `globalAlpha`, and clip: the painter owns the entire
+     * canvas, so each visible page needs its own `` — you cannot composite
+     * two pages, a sub-rect, or a context transform 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`.
+     */
+    paint(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, page: number, opts: PaintOptions | undefined): PaintResult;
+    /**
+     * A point → **content position** — the fine-grained click direction:
+     * hit-test a point and get back the field *and* a USV offset into its
+     * `Content` (for placing a caret or mapping a selection into the content
+     * model), or `undefined` off all content ink. `x`/`y` are PDF points,
+     * bottom-left origin — the same space as `fieldAt`. The offset is
+     * cluster-exact and degrades to the containing segment's start on
+     * origin-less ink (list markers, a code fence's interior). See
+     * `ContentHit`.
+     */
+    positionAt(page: number, x: number, y: number): ContentHit | undefined;
+    /**
+     * Schema-field geometry for this compiled session — each content field's
+     * **first placement** (one region per page it touches) plus widget and
+     * scalar-reference-site regions, keyed on the quill schema field path; a
+     * field may still appear more than once (group by `field`, see
+     * `FieldRegion`). A session-level query: no render, no byte artifact. An
+     * interactive preview reads it to scroll to / highlight the focused
+     * field over a `paint`-ed canvas; the click direction is `fieldAt`.
+     * Empty for backends that place no schema fields.
+     */
+    regions(): FieldRegion[];
+    render(opts?: RenderOptions | null): RenderResult;
+    /**
+     * The backend that produced this session (e.g. `"typst"`).
+     */
+    readonly backendId: string;
+    readonly pageCount: number;
+    /**
+     * `true` iff `paint` and `pageSize` will succeed for this session. Derived
+     * from the session's canvas seam, so it reflects exactly what `paint` will
+     * do — no separately captured flag.
+     */
+    readonly supportsCanvas: boolean;
+    /**
+     * Non-fatal diagnostics of the session's **current compile** (e.g. Typst
+     * font fallback) — set at open and refreshed by each committed `apply`;
+     * a failed apply keeps the last-good compile's warnings. Also appended
+     * to `RenderResult.warnings` on each `render()` call.
+     */
+    readonly warnings: Diagnostic[];
+}
+
+export class Quill {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a quill from a file tree. Pure — no backend, no engine; the
+     * declared backend is resolved later, at render time.
+     *
+     * Accepts either a `Map<string, Uint8Array>` or a plain object
+     * (`Record<string, Uint8Array>`). Plain objects are walked via
+     * `Object.entries` at the boundary; the Rust side sees a single
+     * canonical shape.
+     */
+    static fromTree(tree: Map<string, Uint8Array>): 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`). Returns `undefined` if `cardKind`
+     * is not declared in this quill's schema, else a `Card` that feeds
+     * straight into `Document.insertCard`.
+     *
+     * Pass `document.seedOverlay(cardKind)` as `overlay` so a card added to a
+     * template-derived document inherits its curated starting values; omit it
+     * (or pass `undefined` / `null`) for the bare schema seed. `overlay` is a
+     * plain object — this reads the document, it does not mutate it.
+     */
+    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: `default:`, else type-empty zero). Illustration-first: a field
+     * with both an `example` and a `default` renders its example. See
+     * `prose/canon/SCHEMAS.md` § "Document seeding".
+     */
+    seedDocument(): Document;
+    /**
+     * Seed a starter main `Card` (carries `$quill`) from the schema — the
+     * `$kind: main` card of [`seedDocument`](Self::seed_document) in
+     * isolation, committing each field's `example:` value. Returns the same
+     * `Card` shape as the `Document.main` getter.
+     */
+    seedMain(): Card;
+    /**
+     * Flatten this quill back into its canonical file tree — the inverse of
+     * [`fromTree`](Self::from_tree). Round-trips: `Quill.fromTree(q.toTree())`
+     * reproduces an equivalent quill.
+     *
+     * This is how a quill crosses a WASM linear-memory boundary as data: a
+     * `Quill` built in one build (e.g. the Typst-less `@quillmark/wasm/core`)
+     * cannot be passed to an engine in another (separate linear memories), so
+     * `@quillmark/wasm/runtime` re-feeds this tree to the backend build's
+     * `Quill.fromTree` on demand. Keys are `"/"`-joined relative paths,
+     * matching what `fromTree` accepts.
+     */
+    toTree(): Map<string, Uint8Array>;
+    /**
+     * Validate `doc` against this quill's schema, returning every diagnostic
+     * (an empty array when the document is valid).
+     *
+     * Forwards the canonical `validation::*` diagnostics — same `code`,
+     * `path`, and `hint` the engine emits — including the non-fatal
+     * `validation::must_fill` warning for each `!must_fill` marker left in
+     * the document. Field values, defaults, and order are not part of this
+     * surface: read them from the `Document` payload and `Quill.schema`
+     * (schema key order is display order).
+     */
+    validate(doc: Document): Diagnostic[];
+    /**
+     * The *declared* backend identifier (`config.backend`, e.g. `"typst"`).
+     * Intent, not a resolved capability — capability (`supportedFormats` /
+     * `supportsCanvas`) is read from the engine.
+     */
+    readonly backendId: string;
+    readonly blueprint: string;
+    /**
+     * Identity snapshot of the `quill:` section of `Quill.yaml` plus any extra
+     * `quill:` keys. Pure config — the backend's output formats are a
+     * resolved-backend capability read from the engine
+     * (`Quillmark.supportedFormats`), not part of this snapshot.
+     */
+    readonly metadata: QuillMetadata;
+    /**
+     * Document schema for the quill: the user-fillable fields plus their
+     * `ui` hints (title / group / compact / multiline). The single
+     * field-metadata surface — drives form editors and LLM/MCP consumers
+     * alike. Key order in `fields`/`properties` is declaration order — the
+     * ordering contract. Returns the `QuillSchema` shape.
+     */
+    readonly schema: QuillSchema;
+}
+
+/**
+ * Render engine: a backend registry and render dispatcher. Render build only —
+ * the core build constructs and validates quills without it.
+ */
+export class Quillmark {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor();
+    /**
+     * Open a live render session for `doc` against `quill`'s backend.
+     */
+    open(quill: Quill, doc: Document): LiveSession;
+    /**
+     * Render `doc` against `quill` in one shot. Convenience over `open` +
+     * `LiveSession.render`: an unset `output_format` falls back to the
+     * backend's first supported format.
+     */
+    render(quill: Quill, doc: Document, opts?: RenderOptions | null): RenderResult;
+    /**
+     * The output formats `quill`'s backend can emit. Static capability —
+     * resolves the backend but compiles nothing. Throws `engine::backend_not_found`
+     * if no registered backend matches the quill's declared backend.
+     */
+    supportedFormats(quill: Quill): OutputFormat[];
+    /**
+     * Pre-session hint: `true` iff `quill`'s backend can paint sessions to a
+     * canvas, derived from the backend's output formats; `false` when the
+     * backend is unsupported. Use as a cheap precondition probe before mounting
+     * a canvas-based preview UI; the authoritative answer is the session's
+     * `supportsCanvas` getter once `open()` has been called.
+     */
+    supportsCanvas(quill: Quill): boolean;
+}
+
+/**
+ * Export a canonical `Content` content to its markdown projection — the pure
+ * on-demand codec behind `exportMarkdown(card.body)`. Throws if `rt` is not a
+ * canonical content.
+ */
+export function exportMarkdown(rt: Content): string;
+
+/**
+ * Import a markdown string to a canonical `Content` content — the pure,
+ * document-free codec. Pair with `install(addr, importMarkdown(md))` to spell
+ * the cold (anchor-losing) write at the call site; prefer `revise` for edit
+ * semantics. Throws on an over-nested input.
+ */
+export function importMarkdown(markdown: string): Content;
+
+/**
+ * Initialize the WASM module with panic hooks for better error messages
+ */
+export function init(): void;
+
+/**
+ * Map a base content position through a `delta` to its new position — the pure
+ * position-mapping codec an editor bridge composes to hold a caret stable
+ * across a `revise`. `assoc` decides the side of a same-position insertion
+ * (`"after"` moves past it). Throws on a malformed `delta`.
+ */
+export function mapPos(delta: Delta, pos: number, assoc: Assoc): number;
+
+/**
+ * Rebase `markdown` onto a `base` content — the pure, document-free twin of
+ * `revise`: cold-import + `diff_import`, returning the new `content` and the
+ * text `delta` (surviving anchors rebased). Use it to compute a revise without
+ * a document in hand; `revise(addr, md)` fuses this with the store for
+ * atomicity. Throws on an over-nested markdown input or a non-content `base`.
+ */
+export function rebase(base: Content, markdown: string): { content: Content; delta: Delta };