@quillmark/wasm 0.67.0 → 0.68.0

package/README.md

@@ -79,53 +79,77 @@ 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`, `warnings` (snapshot of
-session-level diagnostics attached at `open` time), `pageSize(page)`, and
-`paint(ctx, page, scale)` for canvas previews. See below.
+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, scale)` rasterizes a page directly into a
-`CanvasRenderingContext2D`, skipping PNG/SVG byte round-trips. Pair with
-`session.pageSize(page)` to size the canvas:
+`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 dpr = window.devicePixelRatio || 1;
-const userZoom = 1;                              // your zoom UI
-const scale = dpr * userZoom;                    // multiplier on 72 ppi
-
-const { widthPt, heightPt } = session.pageSize(0);
-// Reassigning canvas.width/height clears the backing store, which is what
-// you want between pages. If you reuse the same canvas at the same size
-// (e.g. repaint after a zoom that didn't change scale), call
-// ctx.clearRect(0, 0, canvas.width, canvas.height) before paint instead.
-canvas.width  = Math.round(widthPt  * scale);    // device px
-canvas.height = Math.round(heightPt * scale);
-canvas.style.width  = `${widthPt  * userZoom}px`;
-canvas.style.height = `${heightPt * userZoom}px`;
-
-session.paint(canvas.getContext("2d"), 0, scale);
+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`;
 ```
 
-- `scale` is a multiplier on Typst's natural 72 ppi (1 pt → 1 device
-  pixel at `scale = 1`). Always include `devicePixelRatio` for crisp
-  output.
+- `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.
-- Setting `canvas.width` / `canvas.height` clears the backing store; if
-  you reuse a canvas without resizing, call `clearRect` before `paint`.
-- Currently main-thread only: `paint` accepts `CanvasRenderingContext2D`,
-  not `OffscreenCanvasRenderingContext2D`. Worker support is on the
-  follow-up list.
-- Backend support: Typst only. Calling `paint` on a session opened by
-  any other backend throws an error that includes the resolved
-  `backendId`.
+- 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
 
@@ -160,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

@@ -17,14 +17,72 @@ export interface CardInput {
 /**
  * Page dimensions in Typst points (1 pt = 1/72 inch).
  *
- * Returned by `RenderSession.pageSize`. Use these to size a canvas backing
- * store (`widthPt * scale × heightPt * scale`) before calling `paint`.
+ * 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;
@@ -368,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;
 }
 
 /**
@@ -391,6 +458,21 @@ 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;
@@ -398,6 +480,11 @@ export class RenderSession {
     /**
      * 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.
@@ -409,33 +496,51 @@ export class RenderSession {
     /**
      * Paint `page` into a 2D canvas context.
      *
-     * `scale` multiplies Typst's natural 72 ppi (1 pt → 1 device pixel at
-     * `scale = 1`). Typical usage:
-     * `scale = (window.devicePixelRatio || 1) * userZoom`.
-     *
-     * The caller must size `ctx.canvas` so that
-     * `canvas.width === round(widthPt * scale)` and `canvas.height ===
-     * round(heightPt * scale)` *before* calling `paint`. Setting
-     * `canvas.width` / `canvas.height` clears the backing store, which is
-     * the recommended way to handle page-to-page transitions; if you
-     * reuse a canvas without resizing, call
-     * `ctx.clearRect(0, 0, canvas.width, canvas.height)` first to avoid
-     * stale pixels showing through transparent regions.
-     *
-     * `paint` writes into the backing store at origin `(0, 0)` and does
-     * not clear outside the rendered region.
-     *
-     * Throws if the backend does not support canvas preview (the message
-     * includes the resolved `backendId` for debugging), or if `page` is
-     * out of range.
-     */
-    paint(ctx: CanvasRenderingContext2D, page: number, scale: number): void;
+     * 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;
     /**
@@ -445,6 +550,14 @@ export class RenderSession {
      * 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.
      *

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;
@@ -759,6 +787,9 @@ export class RenderSession {
     }
     /**
      * 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() {
@@ -791,6 +822,11 @@ export class RenderSession {
     /**
      * 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.
@@ -818,41 +854,58 @@ export class RenderSession {
     /**
      * Paint `page` into a 2D canvas context.
      *
-     * `scale` multiplies Typst's natural 72 ppi (1 pt → 1 device pixel at
-     * `scale = 1`). Typical usage:
-     * `scale = (window.devicePixelRatio || 1) * userZoom`.
+     * 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`.
      *
-     * The caller must size `ctx.canvas` so that
-     * `canvas.width === round(widthPt * scale)` and `canvas.height ===
-     * round(heightPt * scale)` *before* calling `paint`. Setting
-     * `canvas.width` / `canvas.height` clears the backing store, which is
-     * the recommended way to handle page-to-page transitions; if you
-     * reuse a canvas without resizing, call
-     * `ctx.clearRect(0, 0, canvas.width, canvas.height)` first to avoid
-     * stale pixels showing through transparent regions.
+     * 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.
      *
-     * `paint` writes into the backing store at origin `(0, 0)` and does
-     * not clear outside the rendered region.
+     * Each call resets the backing store (`paint` is always a full
+     * repaint). Consumers do not need to call `clearRect`.
      *
-     * Throws if the backend does not support canvas preview (the message
-     * includes the resolved `backendId` for debugging), or if `page` is
-     * out of range.
-     * @param {CanvasRenderingContext2D} ctx
+     * 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 {number} scale
+     * @param {PaintOptions | undefined} opts
+     * @returns {PaintResult}
      */
-    paint(ctx, page, scale) {
+    paint(ctx, page, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.rendersession_paint(retptr, this.__wbg_ptr, addBorrowedObject(ctx), page, scale);
+            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);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            heap[stack_pointer++] = undefined;
         }
     }
     /**
@@ -875,6 +928,18 @@ 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.
      *
@@ -997,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;
@@ -1073,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 {
@@ -1083,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 {
@@ -1167,6 +1260,9 @@ export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, 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;
@@ -1184,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);
@@ -1255,12 +1363,6 @@ function _assertClass(instance, klass) {
     }
 }
 
-function addBorrowedObject(obj) {
-    if (stack_pointer == 1) throw new Error('out of js stack');
-    heap[--stack_pointer] = obj;
-    return stack_pointer;
-}
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -1427,8 +1529,6 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-let stack_pointer = 1024;
-
 function takeObject(idx) {
     const ret = getObject(idx);
     dropObject(idx);

package/bundler/wasm_bg.wasm.d.ts

@@ -35,6 +35,7 @@ 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;
@@ -42,6 +43,7 @@ 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;

package/node-esm/wasm.d.ts

@@ -17,14 +17,72 @@ export interface CardInput {
 /**
  * Page dimensions in Typst points (1 pt = 1/72 inch).
  *
- * Returned by `RenderSession.pageSize`. Use these to size a canvas backing
- * store (`widthPt * scale × heightPt * scale`) before calling `paint`.
+ * 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;
@@ -368,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;
 }
 
 /**
@@ -391,6 +458,21 @@ 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;
@@ -398,6 +480,11 @@ export class RenderSession {
     /**
      * 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.
@@ -409,33 +496,51 @@ export class RenderSession {
     /**
      * Paint `page` into a 2D canvas context.
      *
-     * `scale` multiplies Typst's natural 72 ppi (1 pt → 1 device pixel at
-     * `scale = 1`). Typical usage:
-     * `scale = (window.devicePixelRatio || 1) * userZoom`.
-     *
-     * The caller must size `ctx.canvas` so that
-     * `canvas.width === round(widthPt * scale)` and `canvas.height ===
-     * round(heightPt * scale)` *before* calling `paint`. Setting
-     * `canvas.width` / `canvas.height` clears the backing store, which is
-     * the recommended way to handle page-to-page transitions; if you
-     * reuse a canvas without resizing, call
-     * `ctx.clearRect(0, 0, canvas.width, canvas.height)` first to avoid
-     * stale pixels showing through transparent regions.
-     *
-     * `paint` writes into the backing store at origin `(0, 0)` and does
-     * not clear outside the rendered region.
-     *
-     * Throws if the backend does not support canvas preview (the message
-     * includes the resolved `backendId` for debugging), or if `page` is
-     * out of range.
-     */
-    paint(ctx: CanvasRenderingContext2D, page: number, scale: number): void;
+     * 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;
     /**
@@ -445,6 +550,14 @@ export class RenderSession {
      * 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.
      *

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;
@@ -763,6 +791,9 @@ export class RenderSession {
     }
     /**
      * 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() {
@@ -795,6 +826,11 @@ export class RenderSession {
     /**
      * 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.
@@ -822,41 +858,58 @@ export class RenderSession {
     /**
      * Paint `page` into a 2D canvas context.
      *
-     * `scale` multiplies Typst's natural 72 ppi (1 pt → 1 device pixel at
-     * `scale = 1`). Typical usage:
-     * `scale = (window.devicePixelRatio || 1) * userZoom`.
+     * 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`.
      *
-     * The caller must size `ctx.canvas` so that
-     * `canvas.width === round(widthPt * scale)` and `canvas.height ===
-     * round(heightPt * scale)` *before* calling `paint`. Setting
-     * `canvas.width` / `canvas.height` clears the backing store, which is
-     * the recommended way to handle page-to-page transitions; if you
-     * reuse a canvas without resizing, call
-     * `ctx.clearRect(0, 0, canvas.width, canvas.height)` first to avoid
-     * stale pixels showing through transparent regions.
+     * 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.
      *
-     * `paint` writes into the backing store at origin `(0, 0)` and does
-     * not clear outside the rendered region.
+     * Each call resets the backing store (`paint` is always a full
+     * repaint). Consumers do not need to call `clearRect`.
      *
-     * Throws if the backend does not support canvas preview (the message
-     * includes the resolved `backendId` for debugging), or if `page` is
-     * out of range.
-     * @param {CanvasRenderingContext2D} ctx
+     * 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 {number} scale
+     * @param {PaintOptions | undefined} opts
+     * @returns {PaintResult}
      */
-    paint(ctx, page, scale) {
+    paint(ctx, page, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.rendersession_paint(retptr, this.__wbg_ptr, addBorrowedObject(ctx), page, scale);
+            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);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            heap[stack_pointer++] = undefined;
         }
     }
     /**
@@ -879,6 +932,18 @@ 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.
      *
@@ -1004,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;
@@ -1080,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 {
@@ -1090,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 {
@@ -1174,6 +1267,9 @@ function __wbg_get_imports() {
         __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;
@@ -1191,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);
@@ -1269,12 +1377,6 @@ function _assertClass(instance, klass) {
     }
 }
 
-function addBorrowedObject(obj) {
-    if (stack_pointer == 1) throw new Error('out of js stack');
-    heap[--stack_pointer] = obj;
-    return stack_pointer;
-}
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -1441,8 +1543,6 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-let stack_pointer = 1024;
-
 function takeObject(idx) {
     const ret = getObject(idx);
     dropObject(idx);

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

@@ -35,6 +35,7 @@ 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;
@@ -42,6 +43,7 @@ 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;

package/package.json

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