@quillmark/wasm 0.112.0 → 0.114.0

package/{backends/typst → render}/wasm_bg.wasm.d.ts

@@ -22,18 +22,15 @@ export const document_cards: (a: number, b: number) => void;
 export const document_clone: (a: number) => number;
 export const document_currentStorageVersion: (a: number) => void;
 export const document_equals: (a: number, b: number) => number;
-export const document_formatDiagnostic: (a: number, b: number) => void;
 export const document_formatRules: (a: number) => void;
-export const document_fromJson: (a: number, b: number, c: number) => void;
 export const document_fromMarkdown: (a: number, b: number, c: number) => void;
+export const document_fromStored: (a: number, b: number, c: number) => void;
 export const document_getExt: (a: number, b: number, c: number) => void;
-export const document_getExtNamespace: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document_getStored: (a: number, b: number, c: number) => void;
 export const document_insertCard: (a: number, b: number, c: number, d: number) => void;
 export const document_isFill: (a: number, b: number, c: number) => void;
-export const document_loadJson: (a: number, b: number, c: number, d: number) => void;
+export const document_loadStored: (a: number, b: number, c: number, d: number) => void;
 export const document_main: (a: number, b: number) => void;
-export const document_makeCard: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const document_moveCard: (a: number, b: number, c: number, d: number) => void;
 export const document_new: (a: number, b: number, c: number) => void;
 export const document_overwrite: (a: number, b: number, c: number, d: number) => void;
@@ -42,61 +39,57 @@ export const document_quillRef: (a: number, b: number) => void;
 export const document_quillRefHint: (a: number) => void;
 export const document_removeCard: (a: number, b: number, c: number) => void;
 export const document_removeExt: (a: number, b: number, c: number) => void;
-export const document_removeExtNamespace: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document_removeField: (a: number, b: number, c: number) => void;
 export const document_removeSeedOverlay: (a: number, b: number, c: number, d: number) => void;
 export const document_revise: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document_seedOverlay: (a: number, b: number, c: number, d: number) => void;
-export const document_setCardKind: (a: number, b: number, c: number, d: number, e: number) => void;
 export const document_setQuillRef: (a: number, b: number, c: number, d: number) => void;
 export const document_storageVersionOf: (a: number, b: number, c: number) => void;
 export const document_storeExt: (a: number, b: number, c: number, d: number) => void;
-export const document_storeExtNamespace: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const document_storeField: (a: number, b: number, c: number, d: number) => void;
 export const document_storeFields: (a: number, b: number, c: number, d: number) => void;
 export const document_storeFill: (a: number, b: number, c: number, d: number) => void;
 export const document_storeSeedOverlay: (a: number, b: number, c: number, d: number, e: number) => void;
-export const document_toJson: (a: number, b: number) => void;
 export const document_toMarkdown: (a: number, b: number) => void;
-export const document_tryFromJson: (a: number, b: number) => number;
+export const document_toStored: (a: number, b: number) => void;
 export const document_warnings: (a: number, b: number) => void;
 export const exportMarkdown: (a: number, b: number) => void;
+export const formatDiagnostic: (a: number, b: number) => void;
 export const formatDocPath: (a: number, b: number) => void;
 export const importMarkdown: (a: number, b: number, c: number) => void;
 export const livesession_backendId: (a: number, b: number) => void;
 export const livesession_fieldAt: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const livesession_fieldBoxes: (a: number, b: number, c: number, d: number) => void;
-export const livesession_locate: (a: number, b: number, c: number, d: number) => number;
+export const livesession_locate: (a: number, b: number, c: number, d: number, e: number) => void;
 export const livesession_pageCount: (a: number) => number;
 export const livesession_pageSize: (a: number, b: number, c: number) => void;
 export const livesession_paint: (a: number, b: number, c: number, d: number, e: number) => void;
-export const livesession_positionAt: (a: number, b: number, c: number, d: number, e: number) => number;
+export const livesession_positionAt: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const livesession_regions: (a: number, b: number) => void;
 export const livesession_render: (a: number, b: number, c: number) => void;
-export const livesession_supportsCanvas: (a: number) => number;
 export const livesession_update: (a: number, b: number, c: number) => void;
 export const livesession_warnings: (a: number, b: number) => void;
 export const mapMarks: (a: number, b: number, c: number) => void;
 export const mapPos: (a: number, b: number, c: number, d: number) => void;
 export const parseDocPath: (a: number, b: number, c: number) => void;
+export const quill__resolve: (a: number, b: number, c: number) => void;
 export const quill_backendId: (a: number, b: number) => void;
 export const quill_blueprint: (a: number, b: number) => void;
 export const quill_conform: (a: number, b: number, c: number) => void;
 export const quill_fromTree: (a: number, b: number) => void;
 export const quill_metadata: (a: number, b: number) => void;
 export const quill_parse: (a: number, b: number, c: number, d: number) => void;
-export const quill_resolve: (a: number, b: number, c: number) => void;
 export const quill_schema: (a: number, b: number) => void;
 export const quill_seedCard: (a: number, b: number, c: number, d: number, e: number) => void;
 export const quill_seedDocument: (a: number) => number;
 export const quill_seedMain: (a: number, b: number) => void;
 export const quill_toTree: (a: number) => number;
 export const quill_validate: (a: number, b: number, c: number) => void;
+export const quill_warnings: (a: number, b: number) => void;
 export const quillmark_new: () => number;
 export const quillmark_open: (a: number, b: number, c: number, d: number) => void;
 export const quillmark_render: (a: number, b: number, c: number, d: number, e: number) => void;
 export const quillmark_supportedFormats: (a: number, b: number, c: number) => void;
-export const quillmark_supportsCanvas: (a: number, b: number) => number;
 export const rebase: (a: number, b: number, c: number, d: number) => void;
 export const start: () => void;
 export const __wbindgen_export: (a: number, b: number) => number;

package/runtime/runtime.d.ts

@@ -1,9 +1,5 @@
-// @quillmark/wasm/runtime: canonical consumer API.
-//
-// The render-side types are defined HERE as the backend-neutral render contract,
-// not sourced from any one private backend build; `runtime.types.test-d.ts`
-// asserts they stay mutually assignable with the Typst backend's generated
-// declarations.
+// The canonical consumer API, and the package's sole export: `@quillmark/wasm`
+// resolves here.
 //
 // The `Quill`/`Document` `init` resolves to ARE the core build's classes, never
 // wrappers. Two copies of this package are two WASM linear memories and two
@@ -26,7 +22,8 @@ import type {
 	mapPos,
 	mapMarks,
 	parseDocPath,
-	formatDocPath
+	formatDocPath,
+	formatDiagnostic
 } from '../core/wasm.js';
 
 /**
@@ -46,6 +43,7 @@ export interface CoreSurface {
 	mapMarks: typeof mapMarks;
 	parseDocPath: typeof parseDocPath;
 	formatDocPath: typeof formatDocPath;
+	formatDiagnostic: typeof formatDiagnostic;
 }
 
 /**
@@ -110,29 +108,24 @@ export type {
 	QuillFieldUi,
 	QuillCardUi,
 	QuillGroupUi,
+	QuillMatrixGroup,
 	QuillMetadata
 } from '../core/wasm.js';
 
 // Content edit vocabulary: the op-grained content model `Document`'s methods
 // speak (`applyChange(addr, bundle)`, `overwrite(addr, rt)`, `revise(…) => Delta`).
-// Declared in the core build; re-exported here so the single public entry point
-// names every type its own re-exported surface already references: `Card.body`
-// is a `Content`, `PayloadItem.nestedFills` a `PathStep[][]`, `CardInput.body` a
-// `Content | string`: rather than forcing consumers to derive them structurally
-// off the `Document` handle. The content write path (a ProseMirror↔content codec)
-// must name all of them; they are its correctness core, not edge types.
-// `ContentLineKind` is the shared half of `ContentLine` and `setKind`, so lifting
-// a line's kind whole (destructure off `containers`/`continues`, spread the rest
-// into the op) is the version-proof spelling of building a `setKind`. Naming it
-// is what makes that spelling type-check without a cast. The alternative, an
-// arm-by-arm switch, means guessing at the open arm's shape and re-editing on
-// every arm added.
+// `ContentLineKind` is the shared half of `ContentLine` and `setKind`, and
+// `ContentMarkKind` of `ContentMark` and a mark op's `add` / `remove`: lifting a
+// read value's kind whole — destructure off the envelope, spread the rest into
+// the op — is the version-proof spelling of the op, and naming the type is what
+// makes that spelling type-check without a cast.
 export type {
 	Content,
 	ContentLine,
 	ContentLineKind,
 	ContentContainer,
 	ContentMark,
+	ContentMarkKind,
 	ContentIsland,
 	TableProps,
 	ImageProps,
@@ -150,13 +143,9 @@ export type {
 	DocPathSeg
 } from '../core/wasm.js';
 
-// The resolved-value view: the return shape of `quill.resolve(doc)`. Value
-// + source rung per declared field (the body is a `body` sibling on its card,
-// never a row in `fields`); diagnostics stay `quill.validate`, guidance stays
-// `quill.schema`.
-// Declared in the core build's generated `.d.ts` via a
-// `typescript_custom_section`; re-exported here so the single public entry
-// point names them.
+// The schema-bound whole-document read on `quill.reader(doc)`: the resolved
+// view (`reader.resolve()`, value + source rung per declared field, the body a
+// `body` sibling on its card and never a row in `fields`).
 export type {
 	FieldSource,
 	ResolvedField,
@@ -165,8 +154,6 @@ export type {
 	Resolved
 } from '../core/wasm.js';
 
-// ── Error contract ──────────────────────────────────────────────────────────
-
 /**
  * The error every fallible method in this package throws: parse
  * (`Document.fromMarkdown`), document mutation, validation
@@ -193,97 +180,12 @@ export interface QuillmarkError extends Error {
  */
 export declare function isQuillmarkError(e: unknown): e is QuillmarkError;
 
-// `ContentIsland.type`, `ContentMark.type`, `ContentLine.kind`, and
-// `ContentContainer.container` are open sets: each union has a residual
-// `{ …: string; … }` arm, so a bare discriminant check never narrows the payload
-// (TS keeps the residual arm live, since a `string` can equal the literal).
-// These guards are the checked narrowing path for the pinned arms; only the
-// payload-carrying arms get one, since the rest narrow to nothing.
-
-import type {
-	ContentIsland,
-	TableProps,
-	ImageProps,
-	ContentMark,
-	ContentLine,
-	ContentContainer
-} from '../core/wasm.js';
+import type { ContentContainer } from '../core/wasm.js';
 
-/** Narrow a {@link ContentIsland} to the pinned `table` arm (`props: TableProps`). */
-export declare function isTableIsland(
-	island: ContentIsland
-): island is ContentIsland & { type: 'table'; props: TableProps };
-
-/** Narrow a {@link ContentIsland} to the pinned `image` arm (`props: ImageProps`). */
-export declare function isImageIsland(
-	island: ContentIsland
-): island is ContentIsland & { type: 'image'; props: ImageProps };
-
-/** Narrow a {@link ContentMark} to the `link` arm (carries `attrs.url`). */
-export declare function isLinkMark(
-	mark: ContentMark
-): mark is ContentMark & { type: 'link'; attrs: { url: string } };
-
-/** Narrow a {@link ContentMark} to the `anchor` arm (carries `attrs.id`). */
-export declare function isAnchorMark(
-	mark: ContentMark
-): mark is ContentMark & { type: 'anchor'; attrs: { id: string } };
-
-/** Narrow a {@link ContentLine} to the `heading` arm (carries `attrs.level`). */
-export declare function isHeadingLine(
-	line: ContentLine
-): line is ContentLine & { kind: 'heading'; attrs: { level: number } };
-
-/** Narrow a {@link ContentLine} to the `code` arm (carries `attrs.lang`). */
-export declare function isCodeLine(
-	line: ContentLine
-): line is ContentLine & { kind: 'code'; attrs?: { lang?: string } };
-
-/** Narrow a {@link ContentContainer} to the `list_item` arm (carries its shape). */
-export declare function isListItemContainer(
-	container: ContentContainer
-): container is ContentContainer & {
-	container: 'list_item';
-	attrs: { ordered: boolean; start: number; ordinal: number };
-	instance: number;
-};
-
-// The guards above answer "is this arm X". These four answer "is this a value
-// this build knows?", the question a read-modify-write consumer must ask: an
-// edit restates every line's kind and containers, so a construct the consumer
-// cannot hold is gone on write-back unless carried inertly, and enumerating the
-// built-in names by hand re-couples to a closed set.
-//
-// They classify unknown TAGS, not unknown payloads on known tags: a future
-// `kind: "footnote"` carrying an `attrs.ref` loses `ref` at any consumer that
-// predates it, with or without these. The spelling needs no classifying: a
-// payload rides `attrs` whether or not this build knows the name.
-
-/** True when this build does not know `line.kind`: the open arm, carrying opaque `attrs`. */
-export declare function isUnknownLine(
-	line: ContentLine
-): line is ContentLine & { kind: string; attrs: unknown };
-
-/** True when this build does not know `container.container`. See {@link isUnknownLine}. */
-export declare function isUnknownContainer(
-	container: ContentContainer
-): container is ContentContainer & { container: string; attrs: unknown };
-
-/** True when this build does not know `mark.type`. See {@link isUnknownLine}. */
-export declare function isUnknownMark(
-	mark: ContentMark
-): mark is ContentMark & { type: string; attrs: unknown };
-
-/** True when this build does not know `island.type` (its payload rides `props`, not `attrs`). */
-export declare function isUnknownIsland(
-	island: ContentIsland
-): island is ContentIsland & { type: string; props: unknown };
-
-// `ContentContainer.instance` is required, so a checker reports an omission; it
-// cannot report a `0` stamped on every run, which is the same write. Adjacent
-// runs of one shape sharing a value arrive welded, and nothing reports that
-// either: the flat `containers` form cannot tell it from one container spanning
-// two paragraphs. This carries the rule a codec would otherwise re-derive.
+// `ContentIsland.type`, `ContentMark.type`, `ContentLine.kind`,
+// `ContentContainer.container` and an island's `loss` are closed sets, so a
+// bare discriminant check narrows the payload on its own:
+// `line.kind === 'heading'` reaches `line.attrs.level`, with no guard to call.
 
 /**
  * Stamp `instance` across one parent's blocks at one depth, in document order,
@@ -296,8 +198,9 @@ export declare function isUnknownIsland(
  * `instance` held.
  *
  * The `instance` it stamps is canonical, so a document reads back the value it
- * was written. `ordinal` stays the caller's, and a write is renumbered to a
- * gapless index within its run.
+ * was written — a `0` as an absent key, which decodes to the same value.
+ * `ordinal` stays the caller's, and a write is renumbered to a gapless index
+ * within its run.
  *
  * Which fields decide a weld is coarser than equality for a list: CommonMark
  * reads only a list's first number, so `1. a` beside `3. b` welds despite the
@@ -316,8 +219,8 @@ export declare function assignInstances(
 
 // The backend-neutral render contract, defined here rather than re-exported from
 // one private backend because no single backend owns the canonical API's types.
-// Every backend build must satisfy these shapes; `runtime.types.test-d.ts` keeps
-// them from diverging from the generated `pkg/backends/typst/wasm.d.ts`.
+// The render build must satisfy these shapes; `runtime.types.test-d.ts` keeps
+// them from diverging from the generated `pkg/render/wasm.d.ts`.
 
 import type { Quill, Document, Card } from '../core/wasm.js';
 import type { Diagnostic } from '../core/wasm.js';
@@ -332,9 +235,14 @@ export interface Artifact {
 /** Options for one render. */
 export interface RenderOptions {
 	format?: OutputFormat;
+	/**
+	 * Pixels per inch for raster formats (PNG); ignored by PDF and SVG.
+	 * Defaults to 144. Must be finite, above 0, and small enough to keep every
+	 * rendered page under 268435456 pixels — anything else throws
+	 * `backend::invalid_raster_scale`.
+	 */
 	ppi?: number;
 	pages?: number[];
-	producer?: string;
 	/**
 	 * Populate {@link RenderResult.regions} with schema-field geometry, for
 	 * consumers without a live session. Defaults to `false`.
@@ -379,26 +287,17 @@ export interface ContentHit {
  * direction use {@link LiveSession.fieldAt}, which resolves a point on *any*
  * placement, not just the first one surfaced here.
  *
- * COORDINATE TRANSFORM. `rect` is in PDF points with a **bottom-left** origin.
- *
- * For an **HTML/CSS overlay** on a `width:100%` canvas, position hotspots as
- * percentages of the page, so they track the displayed size across DPI and pane
- * resize for free; only the Y axis flips:
- *
- * ```js
- * const [x0, y0, x1, y1] = region.rect;            // PDF pt, bottom-left origin
- * const left   = (x0 / pageWidthPt) * 100;         // % of page (from PageSize.widthPt)
- * const top    = (1 - y1 / pageHeightPt) * 100;    // %: flip Y (from PageSize.heightPt)
- * const width  = ((x1 - x0) / pageWidthPt) * 100;
- * const height = ((y1 - y0) / pageHeightPt) * 100;
- * ```
- *
- * For painting **into a raster** at `renderScale` (= `layoutScale × densityScale`),
- * use the device-pixel form instead:
+ * COORDINATE TRANSFORM. `rect` is in PDF points with a **bottom-left** origin
+ * where a canvas or CSS overlay is top-left, so only the Y axis flips, off `y1`
+ * — the rect's *upper* edge — and never off `y0`:
  *
  * ```js
- * const left   = x0 * renderScale;
- * const top    = (pageHeightPt - y1) * renderScale;  // flip Y
+ * const [x0, y0, x1, y1] = region.rect;
+ * // Into a raster painted at renderScale (= layoutScale × densityScale):
+ * const left = x0 * renderScale, top = (pageHeightPt - y1) * renderScale;
+ * // Or, for an HTML overlay on a width:100% canvas, as % of the page, which
+ * // tracks the displayed size across DPI and pane resize with no scale to thread:
+ * const leftPct = (x0 / pageWidthPt) * 100, topPct = (1 - y1 / pageHeightPt) * 100;
  * ```
  */
 export interface FieldRegion {
@@ -429,7 +328,6 @@ export interface RenderResult {
 	artifacts: Artifact[];
 	warnings: Diagnostic[];
 	outputFormat: OutputFormat;
-	renderTimeMs: number;
 	/**
 	 * Schema-field geometry, populated only when {@link RenderOptions.regions}
 	 * asked for it. Page indices are document-space even under a `pages` subset.
@@ -448,7 +346,13 @@ export interface PageSize {
 
 /** Inputs to `paint`. */
 export interface PaintOptions {
+	/** How big the page is on screen, in CSS px per point. Default 1. */
 	layoutScale?: number;
+	/**
+	 * How sharp it is: `window.devicePixelRatio`, in-app zoom and
+	 * `visualViewport.scale` folded into one number. Default 1, because the
+	 * painter cannot see any of them (SSR, tests, off-screen).
+	 */
 	densityScale?: number;
 }
 
@@ -482,25 +386,24 @@ export interface ChangeSet {
 
 /**
  * A backend registry entry. `load` is the lazy thunk returning the
- * dynamically-imported backend build module; `formats`/`canvas` are the required
- * static capability manifest, which is what makes `Engine.supportedFormats` and
- * `Engine.supportsCanvas` free: they answer from it without loading a backend
- * binary or cloning a quill. A malformed descriptor throws at `new Engine(...)`.
+ * dynamically-imported backend build module; `formats` is the required static
+ * capability manifest, which is what makes `Engine.supportedFormats` free: it
+ * answers from it without loading a backend binary or cloning a quill. A
+ * malformed descriptor throws at `new Engine(...)`.
  */
 export interface BackendDescriptor {
 	load: () => Promise<unknown>;
 	formats: OutputFormat[];
-	canvas: boolean;
 }
 
 export interface EngineOptions {
 	/**
 	 * Extra or overriding backend descriptors, merged over the built-ins. Keys are
 	 * backend ids (as declared by `Quill.yaml`'s `backend:` and reported by
-	 * `Quill.backendId`). Each value is a `BackendDescriptor`: `formats`/`canvas`
-	 * are required, so capability probes are ALWAYS free (no binary load, no quill
+	 * `Quill.backendId`). Each value is a `BackendDescriptor`: `formats` is
+	 * required, so the format probe is ALWAYS free (no binary load, no quill
 	 * clone). Malformed entries throw at construction. The default registry maps
-	 * `"typst"` to the bundled Typst build.
+	 * `"typst"` and `"acroform"` to the bundled render build.
 	 */
 	backends?: Record<string, BackendDescriptor>;
 }
@@ -510,6 +413,10 @@ export interface EngineOptions {
  * `quill.backendId`, lazily loads that backend build, clones the quill and
  * document into the backend's WASM memory on demand, renders, and frees the
  * clones. The cross-memory crossing is invisible to callers.
+ *
+ * A `quill.backendId` outside the registry rejects with
+ * `engine::backend_not_found`, the capability probes included. The diagnostic's
+ * `hint` names the registered ids.
  */
 export declare class Engine {
 	constructor(options?: EngineOptions);
@@ -518,6 +425,12 @@ export declare class Engine {
 	 * Render `doc` against `quill` in one shot. Both handles are read
 	 * synchronously before the first await, so the caller may `free()` them as
 	 * soon as this call returns.
+	 *
+	 * This is the surface that merges the two warning halves:
+	 * {@link RenderResult.warnings} carries `doc.warnings` (parse, `conform::*`,
+	 * `plate::unsupported_construct`) ahead of the compile's own. A
+	 * {@link LiveSession} outlives the document it opened from, so
+	 * {@link LiveSession.render} carries the compile half alone.
 	 */
 	render(quill: Quill, doc: Document, options?: RenderOptions): Promise<RenderResult>;
 
@@ -535,17 +448,6 @@ export declare class Engine {
 	 * backend binary or cloning the quill. Async for API stability.
 	 */
 	supportedFormats(quill: Quill): Promise<OutputFormat[]>;
-
-	/**
-	 * Whether `quill`'s backend can paint sessions to a canvas: a pre-session
-	 * estimate, not a fact about any particular compile, answered from the
-	 * descriptor's `canvas` manifest like `supportedFormats`. A specific compile
-	 * can still refuse to paint (a 0-page document, say), so this can answer
-	 * `true` while the resulting {@link LiveSession.supportsCanvas} answers
-	 * `false`. Gate mounting a canvas UI on this, and the `paint` call itself on
-	 * the session's getter.
-	 */
-	supportsCanvas(quill: Quill): Promise<boolean>;
 }
 
 /**
@@ -553,23 +455,19 @@ export declare class Engine {
  *
  * CANVAS PAINT IS COMPLETE: {@link LiveSession.paint} writes a whole page
  * raster, every piece of page content already visible in the painted pixels,
- * with no compositing required by the caller — pdfform pre-flattens bound field
- * values into the page content to satisfy this. {@link LiveSession.regions}
+ * with no compositing required by the caller — acroform bakes each bound field
+ * value into the widget's appearance stream to satisfy this. {@link LiveSession.regions}
  * carries schema-field geometry for overlays drawn on top; it is never needed to
  * complete the picture.
+ *
+ * A compile with no pages throws from {@link LiveSession.pageSize} and
+ * {@link LiveSession.paint}, naming the page index and the `pageCount` that
+ * excludes it. Every backend paints, so that is the only refusal either owes.
  */
 export declare class LiveSession {
 	private constructor();
 	readonly pageCount: number;
 	readonly backendId: string;
-	/**
-	 * `true` iff `paint`/`pageSize` will succeed for THIS compile: the
-	 * authoritative answer, which can be `false` even where
-	 * {@link Engine.supportsCanvas} answered `true` for the same `quill` (a
-	 * canvas-capable backend compiled to a 0-page document has nothing to paint).
-	 * Re-check it after `open()` rather than relying on the engine hint.
-	 */
-	readonly supportsCanvas: boolean;
 	readonly warnings: Diagnostic[];
 	/**
 	 * Recompile the session against `doc`: the edit verb of a live preview.
@@ -659,8 +557,6 @@ export declare class LiveSession {
 	free(): void;
 }
 
-// ── Typed writer: the schema-bound front door ───────────────────────────────
-
 // `quill.writer(doc)` is patched onto the re-exported `Quill` prototype (the
 // class is re-exported verbatim, so the method is declared by merging into the
 // core module's `Quill` rather than redeclaring the class).
@@ -673,13 +569,14 @@ declare module '../core/wasm.js' {
 		 */
 		writer(doc: Document): DocumentWriter;
 		/**
-		 * Bind this quill's schema to `doc` for interpreted reads: the read twin of
+		 * Bind this quill's schema to `doc` for schema-bound reads: the read twin of
 		 * {@link Quill.writer}, mirroring core's `quill.reader(&doc)`. Each field is
-		 * read by its declared type (a richtext field to markdown, every other type
-		 * verbatim) with schema authority, so a name the schema does not declare
-		 * throws rather than reading back `undefined`. Holds both handles by
-		 * reference and owns neither (nothing to `free()`); ephemeral by convention:
-		 * bind, read, discard.
+		 * read in the values form (every content leaf as its codec's text, every
+		 * other value as stored) with schema authority, so a name the schema does
+		 * not declare throws rather than reading back `undefined`; the render
+		 * view reads through `resolve()`. Holds both handles by reference and
+		 * owns neither (nothing
+		 * to `free()`); ephemeral by convention: bind, read, discard.
 		 */
 		reader(doc: Document): DocumentReader;
 	}
@@ -824,6 +721,10 @@ export declare class DocumentReader {
 	 * schema's `items` / `properties` / `variants`, so the element's storage
 	 * form is not the caller's business. The empty path is {@link getContent}.
 	 *
+	 * The `Content` is a write input, so this is the read a round-trip takes:
+	 * an anchor and an island `id` have no markdown projection, and survive an
+	 * edit only by riding this read back through `writer.set` of the field.
+	 *
 	 * `undefined` for an absent field and for a path that names nothing in the
 	 * stored value: a repeater's row index goes stale between derive and read,
 	 * so absence there is a read, not a fault. Throws `UnknownField` for an
@@ -834,6 +735,14 @@ export declare class DocumentReader {
 	getContentAt(addr: Addr | string, path: PathStep[]): Content | undefined;
 	/** The main body's markdown: the quill-free body read. Equals `get({})`. */
 	bodyMarkdown(): string;
+	/**
+	 * The resolved-value view: for every declared field, the value the render
+	 * projection would use and the rung it came from (`authored` / `default` /
+	 * `blank`). The one read that blank-fills and coerces; {@link get} reports
+	 * what the document carries. Value and provenance only; completeness stays
+	 * `quill.validate`'s.
+	 */
+	resolve(): Resolved;
 	/**
 	 * A {@link CardReader} for the composable card at `index`. Index validity is
 	 * checked lazily at read time, so an out-of-range index does not throw here.