@quillmark/wasm 0.66.2 → 0.68.0

package/README.md

@@ -79,12 +79,78 @@ O(1) getter for the number of composable cards (excluding the main card).
 Use this to validate indices before calling card mutators (`removeCard`,
 `updateCardField`, etc.) without allocating the full `cards` array.
 
+### `quill.render(parsed, opts?)` vs. `quill.open(parsed)`
+
+Use **`Quill.render`** for one-shot exports (PDF/SVG/PNG) — compiles, emits
+artifacts, done. Use **`RenderSession`** (returned by `Quill.open`) for
+reactive previews where you'll paint or re-emit pages multiple times: the
+session retains the compiled snapshot so subsequent `paint` / `render`
+calls skip recompilation. Don't open a session per export.
+
 ### `quill.render(parsed, opts?)`
 Render with a pre-parsed `Document`.
 
 ### `quill.open(parsed)` + `session.render(opts?)`
 Open once, render all or selected pages (`opts.pages`).
 
+The session also exposes `pageCount`, `backendId`, `supportsCanvas`,
+`warnings` (snapshot of session-level diagnostics attached at `open` time),
+`pageSize(page)`, and `paint(ctx, page, opts?)` for canvas previews. See
+below.
+
+A document that compiles to zero pages still produces a valid session
+(`pageCount === 0`); `paint(ctx, 0)` and `pageSize(0)` then throw
+`page index 0 out of range (pageCount=0)`. Branch on `pageCount === 0` to
+render a "no pages to preview" UI without relying on the throw.
+
+### Canvas Preview (Typst only)
+
+`session.paint(ctx, page, opts?)` rasterizes a page directly into a
+`CanvasRenderingContext2D` (main thread) or
+`OffscreenCanvasRenderingContext2D` (Worker), skipping PNG/SVG byte
+round-trips.
+
+The painter owns `canvas.width` / `canvas.height` — it sizes the backing
+store itself. Consumers own `canvas.style.*` (or the layout system that
+sets them) and read `layoutWidth` / `layoutHeight` from the returned
+`PaintResult`.
+
+```ts
+const result = session.paint(canvas.getContext("2d"), 0, {
+  layoutScale: 1,                            // layout px per Typst pt
+  densityScale: window.devicePixelRatio,     // backing-store density
+});
+
+canvas.style.width  = `${result.layoutWidth}px`;
+canvas.style.height = `${result.layoutHeight}px`;
+```
+
+- `layoutScale` (default 1) sets the canvas's display-box size:
+  `layoutWidth = widthPt * layoutScale`. For on-screen canvases this is
+  CSS pixels per Typst point. Defaults to 1 (one CSS pixel per pt).
+- `densityScale` (default 1) is the backing-store density multiplier.
+  Fold `window.devicePixelRatio`, in-app zoom, and `visualViewport.scale`
+  (pinch-zoom) into a single value here. Pass `devicePixelRatio` for
+  crisp output on high-DPI displays.
+- The effective rasterization scale is `layoutScale * densityScale`. If
+  that would exceed the safe maximum (16384 px per side), `densityScale`
+  is clamped proportionally; compare `result.pixelWidth` against
+  `Math.round(result.layoutWidth * densityScale)` to detect.
+- `paint` is always a full repaint — setting the backing-store width /
+  height clears it. No `clearRect` required.
+- `pageCount` and `pageSize(page)` are stable for the session's
+  lifetime (immutable snapshot) — cache them.
+- Worker support: pass an `OffscreenCanvasRenderingContext2D` and the
+  same call signature works. `layoutWidth` / `layoutHeight` are
+  informational in that mode (no CSS layout box); fold everything into
+  `densityScale`. Loading the WASM module inside a Worker is the host's
+  responsibility.
+- Backend support: gated by `supportsCanvas`. Probe upfront with
+  `quill.supportsCanvas` (or `session.supportsCanvas`) before mounting a
+  canvas-based UI; the throw on `paint` / `pageSize` remains the
+  enforcement contract and includes the resolved `backendId` for
+  debugging.
+
 ### Errors
 
 Every method that can fail throws a JS `Error` with `.diagnostics` attached:
@@ -118,6 +184,22 @@ without manual `.free()` discipline. `.free()` is still emitted as an eager
 teardown hook for callers that want deterministic release. Requires
 Node 14.6+ / current evergreen browsers (all supported targets).
 
+For environments where `using` (the [explicit resource management][erm]
+proposal) hasn't landed, use an explicit `try` / `finally`:
+
+```ts
+const session = quill.open(doc);
+try {
+  for (let p = 0; p < session.pageCount; p++) {
+    session.paint(ctx, p);
+  }
+} finally {
+  session.free();
+}
+```
+
+[erm]: https://github.com/tc39/proposal-explicit-resource-management
+
 ## Notes
 
 - Parsed markdown requires top-level `QUILL` in frontmatter. Empty input

package/bundler/wasm.d.ts

@@ -13,6 +13,77 @@ export interface CardInput {
 }
 
 
+
+/**
+ * Page dimensions in Typst points (1 pt = 1/72 inch).
+ *
+ * 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 `RenderSession.paint`. Both fields are optional and default
+ * to `1`.
+ *
+ * - `layoutScale` — layout-space pixels per Typst point. 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 `RenderSession.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. Detect clamping via
+ *   `pixelWidth < round(layoutWidth * densityScale)`.
+ *
+ * The painter owns `canvas.width` / `canvas.height`; consumers must not
+ * write to them. The painter does **not** touch `canvas.style.*`;
+ * consumers own layout.
+ *
+ * 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;
+}
+
+
 export interface Artifact {
     format: OutputFormat;
     bytes: Uint8Array;
@@ -355,6 +426,15 @@ export class Quill {
      * immutable once constructed.
      */
     readonly metadata: any;
+    /**
+     * Whether this quill's backend supports canvas preview.
+     *
+     * `true` iff `RenderSession.paint` and `RenderSession.pageSize` will
+     * succeed for sessions opened by this quill. Use this as a precondition
+     * probe before mounting a canvas-based preview UI; the throw on `paint`
+     * remains the enforcement contract.
+     */
+    readonly supportsCanvas: boolean;
 }
 
 /**
@@ -378,18 +458,117 @@ export class Quillmark {
     quill(tree: Map<string, Uint8Array>): Quill;
 }
 
+/**
+ * An iterative render handle backed by an immutable compiled snapshot.
+ *
+ * Created via [`Quill::open`]. Holds the compiled output so that
+ * [`RenderSession::render`], [`RenderSession::paint`], and
+ * [`RenderSession::page_size`] can be called repeatedly without
+ * recompiling.
+ *
+ * **Empty documents.** A document that compiles to zero pages still
+ * produces a valid session (`pageCount === 0`). Iterating
+ * `0..pageCount` is then a no-op; calling `paint(ctx, 0)` or
+ * `pageSize(0)` throws `"... page index 0 out of range
+ * (pageCount=0)"`. Hosts that surface "no pages to preview" UI should
+ * branch on `pageCount === 0` rather than on a thrown error.
+ */
 export class RenderSession {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Page dimensions in Typst points (1 pt = 1/72 inch).
+     *
+     * Report-only: the painter sizes the canvas itself based on
+     * `PaintOptions`. Exposed for consumers that need page geometry
+     * up-front (e.g. to lay out a scrollable list of canvases before
+     * any pixels are rendered).
+     *
+     * Stable for a given `page` across the session's lifetime — the
+     * compiled document is an immutable snapshot, so callers can cache
+     * results.
+     *
+     * Throws if the underlying backend has no canvas painter (i.e. is not
+     * the Typst backend) or if `page` is out of range.
+     */
+    pageSize(page: number): PageSize;
+    /**
+     * Paint `page` into a 2D canvas context.
+     *
+     * Accepts either a `CanvasRenderingContext2D` (main thread) or an
+     * `OffscreenCanvasRenderingContext2D` (Worker / off-DOM rasterization).
+     * Both dispatch to the same Rust rasterizer; the dispatch happens at
+     * the JS boundary so neither context type is privileged.
+     *
+     * The painter owns `canvas.width` / `canvas.height` and writes them
+     * itself; consumers must not. The painter does not touch
+     * `canvas.style.*` — that's layout, owned by the consumer (see
+     * `PaintResult.layoutWidth` / `layoutHeight`).
+     *
+     * `opts.layoutScale` (default 1.0) is layout-space pixels per Typst
+     * point and determines the canvas's display-box size. `opts.densityScale`
+     * (default 1.0) is the rasterization density multiplier the consumer
+     * folds `window.devicePixelRatio`, in-app zoom, and
+     * `visualViewport.scale` (pinch-zoom) into. The effective
+     * rasterization scale is `layoutScale * densityScale`.
+     *
+     * If `layoutScale * densityScale` would exceed the safe backing-store
+     * maximum (16384 px per side), `densityScale` is clamped
+     * proportionally so the largest dimension fits. The actual
+     * backing-store dimensions are reported in the returned
+     * `PaintResult` — compare against
+     * `round(layoutWidth * densityScale)` to detect clamping.
+     *
+     * Each call resets the backing store (`paint` is always a full
+     * repaint). Consumers do not need to call `clearRect`.
+     *
+     * Throws when:
+     * - the backend does not support canvas preview (message includes the
+     *   resolved `backendId`),
+     * - `page` is out of range,
+     * - `ctx` is neither `CanvasRenderingContext2D` nor
+     *   `OffscreenCanvasRenderingContext2D`,
+     * - `opts.layoutScale` or `opts.densityScale` is non-finite or `<= 0`.
+     */
+    paint(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, page: number, opts: PaintOptions | undefined): PaintResult;
     /**
      * Render all or selected pages from this session.
      */
     render(opts?: RenderOptions | null): RenderResult;
+    /**
+     * The backend that produced this session (e.g. `"typst"`).
+     *
+     * Equal to the `backendId` of the [`Quill`] that opened this session
+     * (sessions inherit their quill's backend), so checking either is fine.
+     */
+    readonly backendId: string;
     /**
      * Number of pages in this render session.
+     *
+     * Stable for the lifetime of the session — the underlying compiled
+     * document is an immutable snapshot.
      */
     readonly pageCount: number;
+    /**
+     * Whether this session's backend supports canvas preview.
+     *
+     * `true` iff [`paint`](Self::paint) and [`page_size`](Self::page_size)
+     * will succeed. Equal to `Quill.supportsCanvas` for the quill that
+     * opened this session.
+     */
+    readonly supportsCanvas: boolean;
+    /**
+     * Session-level warnings attached at `quill.open(...)` time.
+     *
+     * Snapshot of any non-fatal diagnostics emitted while opening the
+     * session (e.g. version compatibility shims). Stable across the
+     * session's lifetime. These are also appended to
+     * [`RenderResult.warnings`] on every `render()` call; the accessor
+     * surfaces them to canvas-preview consumers that don't go through
+     * `render()`.
+     */
+    readonly warnings: Diagnostic[];
 }
 
 /**

package/bundler/wasm_bg.js

@@ -685,6 +685,19 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Whether this quill's backend supports canvas preview.
+     *
+     * `true` iff `RenderSession.paint` and `RenderSession.pageSize` will
+     * succeed for sessions opened by this quill. Use this as a precondition
+     * probe before mounting a canvas-based preview UI; the throw on `paint`
+     * remains the enforcement contract.
+     * @returns {boolean}
+     */
+    get supportsCanvas() {
+        const ret = wasm.quill_supportsCanvas(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 if (Symbol.dispose) Quill.prototype[Symbol.dispose] = Quill.prototype.free;
 
@@ -739,6 +752,21 @@ export class Quillmark {
 }
 if (Symbol.dispose) Quillmark.prototype[Symbol.dispose] = Quillmark.prototype.free;
 
+/**
+ * An iterative render handle backed by an immutable compiled snapshot.
+ *
+ * Created via [`Quill::open`]. Holds the compiled output so that
+ * [`RenderSession::render`], [`RenderSession::paint`], and
+ * [`RenderSession::page_size`] can be called repeatedly without
+ * recompiling.
+ *
+ * **Empty documents.** A document that compiles to zero pages still
+ * produces a valid session (`pageCount === 0`). Iterating
+ * `0..pageCount` is then a no-op; calling `paint(ctx, 0)` or
+ * `pageSize(0)` throws `"... page index 0 out of range
+ * (pageCount=0)"`. Hosts that surface "no pages to preview" UI should
+ * branch on `pageCount === 0` rather than on a thrown error.
+ */
 export class RenderSession {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -757,14 +785,129 @@ export class RenderSession {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_rendersession_free(ptr, 0);
     }
+    /**
+     * The backend that produced this session (e.g. `"typst"`).
+     *
+     * Equal to the `backendId` of the [`Quill`] that opened this session
+     * (sessions inherit their quill's backend), so checking either is fine.
+     * @returns {string}
+     */
+    get backendId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_backendId(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Number of pages in this render session.
+     *
+     * Stable for the lifetime of the session — the underlying compiled
+     * document is an immutable snapshot.
      * @returns {number}
      */
     get pageCount() {
         const ret = wasm.rendersession_pageCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Page dimensions in Typst points (1 pt = 1/72 inch).
+     *
+     * Report-only: the painter sizes the canvas itself based on
+     * `PaintOptions`. Exposed for consumers that need page geometry
+     * up-front (e.g. to lay out a scrollable list of canvases before
+     * any pixels are rendered).
+     *
+     * Stable for a given `page` across the session's lifetime — the
+     * compiled document is an immutable snapshot, so callers can cache
+     * results.
+     *
+     * Throws if the underlying backend has no canvas painter (i.e. is not
+     * the Typst backend) or if `page` is out of range.
+     * @param {number} page
+     * @returns {PageSize}
+     */
+    pageSize(page) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_pageSize(retptr, this.__wbg_ptr, page);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Paint `page` into a 2D canvas context.
+     *
+     * Accepts either a `CanvasRenderingContext2D` (main thread) or an
+     * `OffscreenCanvasRenderingContext2D` (Worker / off-DOM rasterization).
+     * Both dispatch to the same Rust rasterizer; the dispatch happens at
+     * the JS boundary so neither context type is privileged.
+     *
+     * The painter owns `canvas.width` / `canvas.height` and writes them
+     * itself; consumers must not. The painter does not touch
+     * `canvas.style.*` — that's layout, owned by the consumer (see
+     * `PaintResult.layoutWidth` / `layoutHeight`).
+     *
+     * `opts.layoutScale` (default 1.0) is layout-space pixels per Typst
+     * point and determines the canvas's display-box size. `opts.densityScale`
+     * (default 1.0) is the rasterization density multiplier the consumer
+     * folds `window.devicePixelRatio`, in-app zoom, and
+     * `visualViewport.scale` (pinch-zoom) into. The effective
+     * rasterization scale is `layoutScale * densityScale`.
+     *
+     * If `layoutScale * densityScale` would exceed the safe backing-store
+     * maximum (16384 px per side), `densityScale` is clamped
+     * proportionally so the largest dimension fits. The actual
+     * backing-store dimensions are reported in the returned
+     * `PaintResult` — compare against
+     * `round(layoutWidth * densityScale)` to detect clamping.
+     *
+     * Each call resets the backing store (`paint` is always a full
+     * repaint). Consumers do not need to call `clearRect`.
+     *
+     * Throws when:
+     * - the backend does not support canvas preview (message includes the
+     *   resolved `backendId`),
+     * - `page` is out of range,
+     * - `ctx` is neither `CanvasRenderingContext2D` nor
+     *   `OffscreenCanvasRenderingContext2D`,
+     * - `opts.layoutScale` or `opts.densityScale` is non-finite or `<= 0`.
+     * @param {CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D} ctx
+     * @param {number} page
+     * @param {PaintOptions | undefined} opts
+     * @returns {PaintResult}
+     */
+    paint(ctx, page, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_paint(retptr, this.__wbg_ptr, addHeapObject(ctx), page, addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Render all or selected pages from this session.
      * @param {RenderOptions | null} [opts]
@@ -785,6 +928,33 @@ export class RenderSession {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Whether this session's backend supports canvas preview.
+     *
+     * `true` iff [`paint`](Self::paint) and [`page_size`](Self::page_size)
+     * will succeed. Equal to `Quill.supportsCanvas` for the quill that
+     * opened this session.
+     * @returns {boolean}
+     */
+    get supportsCanvas() {
+        const ret = wasm.rendersession_supportsCanvas(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Session-level warnings attached at `quill.open(...)` time.
+     *
+     * Snapshot of any non-fatal diagnostics emitted while opening the
+     * session (e.g. version compatibility shims). Stable across the
+     * session's lifetime. These are also appended to
+     * [`RenderResult.warnings`] on every `render()` call; the accessor
+     * surfaces them to canvas-preview consumers that don't go through
+     * `render()`.
+     * @returns {Diagnostic[]}
+     */
+    get warnings() {
+        const ret = wasm.rendersession_warnings(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 if (Symbol.dispose) RenderSession.prototype[Symbol.dispose] = RenderSession.prototype.free;
 
@@ -892,6 +1062,14 @@ export function __wbg_call_14b169f759b26747() { return handleError(function (arg
     const ret = getObject(arg0).call(getObject(arg1));
     return addHeapObject(ret);
 }, arguments); }
+export function __wbg_canvas_2c0c6d263d4c52ad(arg0) {
+    const ret = getObject(arg0).canvas;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+}
+export function __wbg_canvas_374da9f3c5b3dd0e(arg0) {
+    const ret = getObject(arg0).canvas;
+    return addHeapObject(ret);
+}
 export function __wbg_done_9158f7cc8751ba32(arg0) {
     const ret = getObject(arg0).done;
     return ret;
@@ -968,6 +1146,16 @@ export function __wbg_instanceof_ArrayBuffer_7c8433c6ed14ffe3(arg0) {
     const ret = result;
     return ret;
 }
+export function __wbg_instanceof_CanvasRenderingContext2d_24a3fe06e62b98d7(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof CanvasRenderingContext2D;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
 export function __wbg_instanceof_Map_1b76fd4635be43eb(arg0) {
     let result;
     try {
@@ -978,6 +1166,16 @@ export function __wbg_instanceof_Map_1b76fd4635be43eb(arg0) {
     const ret = result;
     return ret;
 }
+export function __wbg_instanceof_OffscreenCanvasRenderingContext2d_285a274020b4f230(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof OffscreenCanvasRenderingContext2D;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
 export function __wbg_instanceof_Uint8Array_152ba1f289edcf3f(arg0) {
     let result;
     try {
@@ -1040,6 +1238,10 @@ export function __wbg_new_aa8d0fa9762c29bd() {
     const ret = new Object();
     return addHeapObject(ret);
 }
+export function __wbg_new_with_u8_clamped_array_and_sh_fe957411824b5158() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0, arg3 >>> 0);
+    return addHeapObject(ret);
+}, arguments); }
 export function __wbg_next_0340c4ae324393c3() { return handleError(function (arg0) {
     const ret = getObject(arg0).next();
     return addHeapObject(ret);
@@ -1055,6 +1257,12 @@ export function __wbg_now_a9b7df1cbee90986() {
 export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 }
+export function __wbg_putImageData_c810e62ea70e761d() { return handleError(function (arg0, arg1, arg2, arg3) {
+    getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
+}, arguments); }
+export function __wbg_putImageData_cb4de9afd58963be() { return handleError(function (arg0, arg1, arg2, arg3) {
+    getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
+}, arguments); }
 export function __wbg_set_022bee52d0b05b19() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
     return ret;
@@ -1072,6 +1280,18 @@ export function __wbg_set_fde2cec06c23692b(arg0, arg1, arg2) {
     const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
     return addHeapObject(ret);
 }
+export function __wbg_set_height_24d07d982f176ac6(arg0, arg1) {
+    getObject(arg0).height = arg1 >>> 0;
+}
+export function __wbg_set_height_be9b2b920bd68401(arg0, arg1) {
+    getObject(arg0).height = arg1 >>> 0;
+}
+export function __wbg_set_width_5cda41d4d06a14dd(arg0, arg1) {
+    getObject(arg0).width = arg1 >>> 0;
+}
+export function __wbg_set_width_adc925bca9c5351a(arg0, arg1) {
+    getObject(arg0).width = arg1 >>> 0;
+}
 export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     const ret = getObject(arg1).stack;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -1219,6 +1439,11 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+function getClampedArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ClampedArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -1240,6 +1465,14 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+let cachedUint8ClampedArrayMemory0 = null;
+function getUint8ClampedArrayMemory0() {
+    if (cachedUint8ClampedArrayMemory0 === null || cachedUint8ClampedArrayMemory0.byteLength === 0) {
+        cachedUint8ClampedArrayMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
+    }
+    return cachedUint8ClampedArrayMemory0;
+}
+
 function getObject(idx) { return heap[idx]; }
 
 function handleError(f, args) {

package/bundler/wasm_bg.wasm.d.ts

@@ -35,10 +35,16 @@ export const quill_form: (a: number, b: number, c: number) => void;
 export const quill_metadata: (a: number) => number;
 export const quill_open: (a: number, b: number, c: number) => void;
 export const quill_render: (a: number, b: number, c: number, d: number) => void;
+export const quill_supportsCanvas: (a: number) => number;
 export const quillmark_new: () => number;
 export const quillmark_quill: (a: number, b: number, c: number) => void;
+export const rendersession_backendId: (a: number, b: number) => void;
 export const rendersession_pageCount: (a: number) => number;
+export const rendersession_pageSize: (a: number, b: number, c: number) => void;
+export const rendersession_paint: (a: number, b: number, c: number, d: number, e: number) => void;
 export const rendersession_render: (a: number, b: number, c: number) => void;
+export const rendersession_supportsCanvas: (a: number) => number;
+export const rendersession_warnings: (a: number) => number;
 export const lut_inverse_interp16: (a: number, b: number, c: number) => number;
 export const qcms_profile_precache_output_transform: (a: number) => void;
 export const qcms_white_point_sRGB: (a: number) => void;

package/node-esm/wasm.d.ts

@@ -13,6 +13,77 @@ export interface CardInput {
 }
 
 
+
+/**
+ * Page dimensions in Typst points (1 pt = 1/72 inch).
+ *
+ * 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 `RenderSession.paint`. Both fields are optional and default
+ * to `1`.
+ *
+ * - `layoutScale` — layout-space pixels per Typst point. 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 `RenderSession.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. Detect clamping via
+ *   `pixelWidth < round(layoutWidth * densityScale)`.
+ *
+ * The painter owns `canvas.width` / `canvas.height`; consumers must not
+ * write to them. The painter does **not** touch `canvas.style.*`;
+ * consumers own layout.
+ *
+ * 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;
+}
+
+
 export interface Artifact {
     format: OutputFormat;
     bytes: Uint8Array;
@@ -355,6 +426,15 @@ export class Quill {
      * immutable once constructed.
      */
     readonly metadata: any;
+    /**
+     * Whether this quill's backend supports canvas preview.
+     *
+     * `true` iff `RenderSession.paint` and `RenderSession.pageSize` will
+     * succeed for sessions opened by this quill. Use this as a precondition
+     * probe before mounting a canvas-based preview UI; the throw on `paint`
+     * remains the enforcement contract.
+     */
+    readonly supportsCanvas: boolean;
 }
 
 /**
@@ -378,18 +458,117 @@ export class Quillmark {
     quill(tree: Map<string, Uint8Array>): Quill;
 }
 
+/**
+ * An iterative render handle backed by an immutable compiled snapshot.
+ *
+ * Created via [`Quill::open`]. Holds the compiled output so that
+ * [`RenderSession::render`], [`RenderSession::paint`], and
+ * [`RenderSession::page_size`] can be called repeatedly without
+ * recompiling.
+ *
+ * **Empty documents.** A document that compiles to zero pages still
+ * produces a valid session (`pageCount === 0`). Iterating
+ * `0..pageCount` is then a no-op; calling `paint(ctx, 0)` or
+ * `pageSize(0)` throws `"... page index 0 out of range
+ * (pageCount=0)"`. Hosts that surface "no pages to preview" UI should
+ * branch on `pageCount === 0` rather than on a thrown error.
+ */
 export class RenderSession {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Page dimensions in Typst points (1 pt = 1/72 inch).
+     *
+     * Report-only: the painter sizes the canvas itself based on
+     * `PaintOptions`. Exposed for consumers that need page geometry
+     * up-front (e.g. to lay out a scrollable list of canvases before
+     * any pixels are rendered).
+     *
+     * Stable for a given `page` across the session's lifetime — the
+     * compiled document is an immutable snapshot, so callers can cache
+     * results.
+     *
+     * Throws if the underlying backend has no canvas painter (i.e. is not
+     * the Typst backend) or if `page` is out of range.
+     */
+    pageSize(page: number): PageSize;
+    /**
+     * Paint `page` into a 2D canvas context.
+     *
+     * Accepts either a `CanvasRenderingContext2D` (main thread) or an
+     * `OffscreenCanvasRenderingContext2D` (Worker / off-DOM rasterization).
+     * Both dispatch to the same Rust rasterizer; the dispatch happens at
+     * the JS boundary so neither context type is privileged.
+     *
+     * The painter owns `canvas.width` / `canvas.height` and writes them
+     * itself; consumers must not. The painter does not touch
+     * `canvas.style.*` — that's layout, owned by the consumer (see
+     * `PaintResult.layoutWidth` / `layoutHeight`).
+     *
+     * `opts.layoutScale` (default 1.0) is layout-space pixels per Typst
+     * point and determines the canvas's display-box size. `opts.densityScale`
+     * (default 1.0) is the rasterization density multiplier the consumer
+     * folds `window.devicePixelRatio`, in-app zoom, and
+     * `visualViewport.scale` (pinch-zoom) into. The effective
+     * rasterization scale is `layoutScale * densityScale`.
+     *
+     * If `layoutScale * densityScale` would exceed the safe backing-store
+     * maximum (16384 px per side), `densityScale` is clamped
+     * proportionally so the largest dimension fits. The actual
+     * backing-store dimensions are reported in the returned
+     * `PaintResult` — compare against
+     * `round(layoutWidth * densityScale)` to detect clamping.
+     *
+     * Each call resets the backing store (`paint` is always a full
+     * repaint). Consumers do not need to call `clearRect`.
+     *
+     * Throws when:
+     * - the backend does not support canvas preview (message includes the
+     *   resolved `backendId`),
+     * - `page` is out of range,
+     * - `ctx` is neither `CanvasRenderingContext2D` nor
+     *   `OffscreenCanvasRenderingContext2D`,
+     * - `opts.layoutScale` or `opts.densityScale` is non-finite or `<= 0`.
+     */
+    paint(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, page: number, opts: PaintOptions | undefined): PaintResult;
     /**
      * Render all or selected pages from this session.
      */
     render(opts?: RenderOptions | null): RenderResult;
+    /**
+     * The backend that produced this session (e.g. `"typst"`).
+     *
+     * Equal to the `backendId` of the [`Quill`] that opened this session
+     * (sessions inherit their quill's backend), so checking either is fine.
+     */
+    readonly backendId: string;
     /**
      * Number of pages in this render session.
+     *
+     * Stable for the lifetime of the session — the underlying compiled
+     * document is an immutable snapshot.
      */
     readonly pageCount: number;
+    /**
+     * Whether this session's backend supports canvas preview.
+     *
+     * `true` iff [`paint`](Self::paint) and [`page_size`](Self::page_size)
+     * will succeed. Equal to `Quill.supportsCanvas` for the quill that
+     * opened this session.
+     */
+    readonly supportsCanvas: boolean;
+    /**
+     * Session-level warnings attached at `quill.open(...)` time.
+     *
+     * Snapshot of any non-fatal diagnostics emitted while opening the
+     * session (e.g. version compatibility shims). Stable across the
+     * session's lifetime. These are also appended to
+     * [`RenderResult.warnings`] on every `render()` call; the accessor
+     * surfaces them to canvas-preview consumers that don't go through
+     * `render()`.
+     */
+    readonly warnings: Diagnostic[];
 }
 
 /**

package/node-esm/wasm.js

@@ -689,6 +689,19 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Whether this quill's backend supports canvas preview.
+     *
+     * `true` iff `RenderSession.paint` and `RenderSession.pageSize` will
+     * succeed for sessions opened by this quill. Use this as a precondition
+     * probe before mounting a canvas-based preview UI; the throw on `paint`
+     * remains the enforcement contract.
+     * @returns {boolean}
+     */
+    get supportsCanvas() {
+        const ret = wasm.quill_supportsCanvas(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 if (Symbol.dispose) Quill.prototype[Symbol.dispose] = Quill.prototype.free;
 
@@ -743,6 +756,21 @@ export class Quillmark {
 }
 if (Symbol.dispose) Quillmark.prototype[Symbol.dispose] = Quillmark.prototype.free;
 
+/**
+ * An iterative render handle backed by an immutable compiled snapshot.
+ *
+ * Created via [`Quill::open`]. Holds the compiled output so that
+ * [`RenderSession::render`], [`RenderSession::paint`], and
+ * [`RenderSession::page_size`] can be called repeatedly without
+ * recompiling.
+ *
+ * **Empty documents.** A document that compiles to zero pages still
+ * produces a valid session (`pageCount === 0`). Iterating
+ * `0..pageCount` is then a no-op; calling `paint(ctx, 0)` or
+ * `pageSize(0)` throws `"... page index 0 out of range
+ * (pageCount=0)"`. Hosts that surface "no pages to preview" UI should
+ * branch on `pageCount === 0` rather than on a thrown error.
+ */
 export class RenderSession {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -761,14 +789,129 @@ export class RenderSession {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_rendersession_free(ptr, 0);
     }
+    /**
+     * The backend that produced this session (e.g. `"typst"`).
+     *
+     * Equal to the `backendId` of the [`Quill`] that opened this session
+     * (sessions inherit their quill's backend), so checking either is fine.
+     * @returns {string}
+     */
+    get backendId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_backendId(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Number of pages in this render session.
+     *
+     * Stable for the lifetime of the session — the underlying compiled
+     * document is an immutable snapshot.
      * @returns {number}
      */
     get pageCount() {
         const ret = wasm.rendersession_pageCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Page dimensions in Typst points (1 pt = 1/72 inch).
+     *
+     * Report-only: the painter sizes the canvas itself based on
+     * `PaintOptions`. Exposed for consumers that need page geometry
+     * up-front (e.g. to lay out a scrollable list of canvases before
+     * any pixels are rendered).
+     *
+     * Stable for a given `page` across the session's lifetime — the
+     * compiled document is an immutable snapshot, so callers can cache
+     * results.
+     *
+     * Throws if the underlying backend has no canvas painter (i.e. is not
+     * the Typst backend) or if `page` is out of range.
+     * @param {number} page
+     * @returns {PageSize}
+     */
+    pageSize(page) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_pageSize(retptr, this.__wbg_ptr, page);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Paint `page` into a 2D canvas context.
+     *
+     * Accepts either a `CanvasRenderingContext2D` (main thread) or an
+     * `OffscreenCanvasRenderingContext2D` (Worker / off-DOM rasterization).
+     * Both dispatch to the same Rust rasterizer; the dispatch happens at
+     * the JS boundary so neither context type is privileged.
+     *
+     * The painter owns `canvas.width` / `canvas.height` and writes them
+     * itself; consumers must not. The painter does not touch
+     * `canvas.style.*` — that's layout, owned by the consumer (see
+     * `PaintResult.layoutWidth` / `layoutHeight`).
+     *
+     * `opts.layoutScale` (default 1.0) is layout-space pixels per Typst
+     * point and determines the canvas's display-box size. `opts.densityScale`
+     * (default 1.0) is the rasterization density multiplier the consumer
+     * folds `window.devicePixelRatio`, in-app zoom, and
+     * `visualViewport.scale` (pinch-zoom) into. The effective
+     * rasterization scale is `layoutScale * densityScale`.
+     *
+     * If `layoutScale * densityScale` would exceed the safe backing-store
+     * maximum (16384 px per side), `densityScale` is clamped
+     * proportionally so the largest dimension fits. The actual
+     * backing-store dimensions are reported in the returned
+     * `PaintResult` — compare against
+     * `round(layoutWidth * densityScale)` to detect clamping.
+     *
+     * Each call resets the backing store (`paint` is always a full
+     * repaint). Consumers do not need to call `clearRect`.
+     *
+     * Throws when:
+     * - the backend does not support canvas preview (message includes the
+     *   resolved `backendId`),
+     * - `page` is out of range,
+     * - `ctx` is neither `CanvasRenderingContext2D` nor
+     *   `OffscreenCanvasRenderingContext2D`,
+     * - `opts.layoutScale` or `opts.densityScale` is non-finite or `<= 0`.
+     * @param {CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D} ctx
+     * @param {number} page
+     * @param {PaintOptions | undefined} opts
+     * @returns {PaintResult}
+     */
+    paint(ctx, page, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_paint(retptr, this.__wbg_ptr, addHeapObject(ctx), page, addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Render all or selected pages from this session.
      * @param {RenderOptions | null} [opts]
@@ -789,6 +932,33 @@ export class RenderSession {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Whether this session's backend supports canvas preview.
+     *
+     * `true` iff [`paint`](Self::paint) and [`page_size`](Self::page_size)
+     * will succeed. Equal to `Quill.supportsCanvas` for the quill that
+     * opened this session.
+     * @returns {boolean}
+     */
+    get supportsCanvas() {
+        const ret = wasm.rendersession_supportsCanvas(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Session-level warnings attached at `quill.open(...)` time.
+     *
+     * Snapshot of any non-fatal diagnostics emitted while opening the
+     * session (e.g. version compatibility shims). Stable across the
+     * session's lifetime. These are also appended to
+     * [`RenderResult.warnings`] on every `render()` call; the accessor
+     * surfaces them to canvas-preview consumers that don't go through
+     * `render()`.
+     * @returns {Diagnostic[]}
+     */
+    get warnings() {
+        const ret = wasm.rendersession_warnings(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 if (Symbol.dispose) RenderSession.prototype[Symbol.dispose] = RenderSession.prototype.free;
 
@@ -899,6 +1069,14 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).call(getObject(arg1));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_canvas_2c0c6d263d4c52ad: function(arg0) {
+            const ret = getObject(arg0).canvas;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_canvas_374da9f3c5b3dd0e: function(arg0) {
+            const ret = getObject(arg0).canvas;
+            return addHeapObject(ret);
+        },
         __wbg_done_9158f7cc8751ba32: function(arg0) {
             const ret = getObject(arg0).done;
             return ret;
@@ -975,6 +1153,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_CanvasRenderingContext2d_24a3fe06e62b98d7: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof CanvasRenderingContext2D;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Map_1b76fd4635be43eb: function(arg0) {
             let result;
             try {
@@ -985,6 +1173,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_OffscreenCanvasRenderingContext2d_285a274020b4f230: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof OffscreenCanvasRenderingContext2D;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Uint8Array_152ba1f289edcf3f: function(arg0) {
             let result;
             try {
@@ -1047,6 +1245,10 @@ function __wbg_get_imports() {
             const ret = new Object();
             return addHeapObject(ret);
         },
+        __wbg_new_with_u8_clamped_array_and_sh_fe957411824b5158: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0, arg3 >>> 0);
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_next_0340c4ae324393c3: function() { return handleError(function (arg0) {
             const ret = getObject(arg0).next();
             return addHeapObject(ret);
@@ -1062,6 +1264,12 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_a6b02eb00b0f4ce2: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
+        __wbg_putImageData_c810e62ea70e761d: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
+        }, arguments); },
+        __wbg_putImageData_cb4de9afd58963be: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
+        }, arguments); },
         __wbg_set_022bee52d0b05b19: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
             return ret;
@@ -1079,6 +1287,18 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         },
+        __wbg_set_height_24d07d982f176ac6: function(arg0, arg1) {
+            getObject(arg0).height = arg1 >>> 0;
+        },
+        __wbg_set_height_be9b2b920bd68401: function(arg0, arg1) {
+            getObject(arg0).height = arg1 >>> 0;
+        },
+        __wbg_set_width_5cda41d4d06a14dd: function(arg0, arg1) {
+            getObject(arg0).width = arg1 >>> 0;
+        },
+        __wbg_set_width_adc925bca9c5351a: function(arg0, arg1) {
+            getObject(arg0).width = arg1 >>> 0;
+        },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = getObject(arg1).stack;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -1233,6 +1453,11 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+function getClampedArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ClampedArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -1254,6 +1479,14 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+let cachedUint8ClampedArrayMemory0 = null;
+function getUint8ClampedArrayMemory0() {
+    if (cachedUint8ClampedArrayMemory0 === null || cachedUint8ClampedArrayMemory0.byteLength === 0) {
+        cachedUint8ClampedArrayMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
+    }
+    return cachedUint8ClampedArrayMemory0;
+}
+
 function getObject(idx) { return heap[idx]; }
 
 function handleError(f, args) {

package/node-esm/wasm_bg.wasm.d.ts

@@ -35,10 +35,16 @@ export const quill_form: (a: number, b: number, c: number) => void;
 export const quill_metadata: (a: number) => number;
 export const quill_open: (a: number, b: number, c: number) => void;
 export const quill_render: (a: number, b: number, c: number, d: number) => void;
+export const quill_supportsCanvas: (a: number) => number;
 export const quillmark_new: () => number;
 export const quillmark_quill: (a: number, b: number, c: number) => void;
+export const rendersession_backendId: (a: number, b: number) => void;
 export const rendersession_pageCount: (a: number) => number;
+export const rendersession_pageSize: (a: number, b: number, c: number) => void;
+export const rendersession_paint: (a: number, b: number, c: number, d: number, e: number) => void;
 export const rendersession_render: (a: number, b: number, c: number) => void;
+export const rendersession_supportsCanvas: (a: number) => number;
+export const rendersession_warnings: (a: number) => number;
 export const lut_inverse_interp16: (a: number, b: number, c: number) => number;
 export const qcms_profile_precache_output_transform: (a: number) => void;
 export const qcms_white_point_sRGB: (a: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.66.2",
+  "version": "0.68.0",
   "description": "WebAssembly bindings for quillmark",
   "type": "module",
   "license": "MIT OR Apache-2.0",