@quillmark/wasm 0.112.0 → 0.113.0

package/core/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)
@@ -499,9 +501,6 @@ export interface QuillMetadata {
 }
 
 
-/**
- * Diagnostic message (error or warning)
- */
 export interface Diagnostic {
     severity: Severity;
     code?: string;
@@ -521,12 +520,8 @@ export interface Diagnostic {
      * `skip_serializing_if`, so an omitted field would be declared required.
      */
     args?: Record<string, unknown>;
-    sourceChain?: string[];
 }
 
-/**
- * Source location for errors and warnings
- */
 export interface Location {
     file: string;
     line: number;
@@ -536,9 +531,6 @@ export interface Location {
 export type Severity = "error" | "warning";
 
 
-/**
- * Typed in-memory Quillmark document.
- */
 export class Document {
     free(): void;
     [Symbol.dispose](): void;
@@ -560,8 +552,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;
     /**
@@ -574,12 +566,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
@@ -587,9 +573,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;
@@ -597,27 +589,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
@@ -625,12 +612,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`
@@ -647,9 +628,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;
     /**
@@ -667,26 +647,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.
      */
@@ -735,17 +701,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
@@ -775,12 +734,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.
      */
@@ -788,7 +741,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.
      */
@@ -796,16 +749,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`
@@ -835,24 +784,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.
      */
@@ -867,7 +810,7 @@ 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[];
 }
@@ -880,7 +823,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
@@ -908,14 +851,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
@@ -945,8 +880,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>;
     /**
@@ -963,9 +898,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;
     /**
@@ -974,6 +909,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[];
 }
 
 /**
@@ -1070,18 +1011,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;
@@ -1090,23 +1028,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;
@@ -1114,19 +1048,20 @@ export interface InitOutput {
     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 rebase: (a: number, b: number, c: number, d: number) => void;
     readonly start: () => void;
     readonly __wbindgen_export: (a: number, b: number) => number;