@quillmark/wasm 0.130.0 → 0.132.0

package/render/wasm.d.ts

@@ -80,8 +80,7 @@ export type ContentLineKind =
 | { kind: "para" }
 | { kind: "heading"; attrs: { level: number } }
 | { kind: "code"; attrs?: { lang?: string } }
-| { kind: "rule" }
-| { kind: "term" };
+| { kind: "rule" };
 
 /** An ancestor block a line nests inside, outermost first. Closed like
  * `ContentLine.kind`.
@@ -110,14 +109,7 @@ export type ContentContainer =
     attrs: { ordered: boolean; start: number; ordinal: number; checked?: boolean };
     instance?: number;
 }
-| { container: "quote"; instance?: number }
-| { container: "description"; instance?: number }
-| { container: "element"; attrs: ElementAttrs; instance?: number };
-
-/** A carrier element's name and attributes, one bag: `$name` is the part of
- * its `qm-<name>` tag after the prefix, and every other key an attribute as
- * written. */
-export type ElementAttrs = { $name: string; [attr: string]: string };
+| { container: "quote"; instance?: number };
 
 /** A mark over char range `[start, end)` into `Content.text`. `type` is a
  * closed set, so `type === "link"` narrows `attrs` to `{ url: string }` with no
@@ -132,7 +124,8 @@ export type ContentMark = { start: number; end: number } & ContentMarkKind;
 export type ContentMarkKind =
 | { type: "strong" | "emph" | "underline" | "strike" | "code" }
 | { type: "link"; attrs: { url: string } }
-| { type: "anchor"; attrs: { id: string } };
+| { type: "anchor"; attrs: { id: string } }
+| { type: "font_family"; attrs: { name: string } };
 
 /** A cell in a `TableProps`. `marks` rides the prose `ContentMark` shape, but
  * each mark's `start`/`end` are USV offsets into this cell's `text`, not into
@@ -144,12 +137,17 @@ export interface TableCell {
     align?: "left" | "center" | "right";
     /** The cell's vertical alignment; absent is the quill's. */
     valign?: "top" | "middle" | "bottom";
+    /** The columns the cell spans, from 2; absent is one. Each cell it covers
+     * holds its slot as an empty placeholder. */
+    colspan?: number;
+    /** The rows the cell spans, from 2; absent is one. */
+    rowspan?: number;
 }
 
-/** `props` of a `type: "table"` island: a pipe table normalized to one column
- * count that `header`, every row of `rows`, `aligns` and `widths` all share.
- * A layout key at its default is absent; one holding a value outside its type
- * stays as written and reads as absent. */
+/** `props` of a `type: "table"` island: a rectangular grid normalized to one
+ * column count that `header`, every row of `rows`, `aligns` and `widths` all
+ * share. A layout key at its default is absent; one holding a value outside
+ * its type stays as written and reads as absent. */
 export interface TableProps {
     header: TableCell[];
     rows: TableCell[][];
@@ -161,8 +159,9 @@ export interface TableProps {
     widths?: (number | null)[];
     /** The table's placement; absent is the quill's. */
     align?: "left" | "center" | "right";
-    /** `true` draws `header` as the first body row; absent is a header row. */
-    headless?: true;
+    /** How many rows from the top of `header` then `rows` are header rows;
+     * `0` draws `header` as the first body row, and absent is one. */
+    head?: number;
 }
 
 /** `props` of a `type: "image"` island. Stores and round-trips; no backend
@@ -300,7 +299,9 @@ export type Assoc = "before" | "after";
 /**
  * A mark edit in final-text coordinates (post-delta, post-line-op). `add` /
  * `remove` are a `ContentMark` under an op, so a held mark spreads in whole;
- * `removeAnchor` drops one identity anchor by id. An `add` of an `anchor`
+ * `removeAnchor` drops one identity anchor by id. An `add` of a `link` or a
+ * `font_family` replaces the one under its range, and a mark added across a
+ * line break reads back as one mark per line. An `add` of an `anchor`
  * requires a non-empty `id` not already live in the field; a collision or the
  * empty id throws.
  */
@@ -471,6 +472,19 @@ export interface Resolved {
 
 
 
+/** One face a session sets text in, with what an editor needs for an
+ * `@font-face` rule: the family, the CSS weight and style, and the font file.
+ * `index` is the face's place in `data` where the file is a collection. */
+export interface FontFace {
+    family: string;
+    weight: number;
+    style: "normal" | "italic" | "oblique";
+    index: number;
+    data: Uint8Array;
+}
+
+
+
 /** UI layout hints for a single field. Display order is not a hint: key order
  * in the schema's `fields`/`properties` objects is the ordering contract. */
 export interface QuillFieldUi {
@@ -752,6 +766,11 @@ export interface RenderOptions {
      * document-space even when `pages` selects a subset.
      */
     regions?: boolean;
+    /**
+     * The PDF document title, over the plate's own and then the quill's
+     * `description`. A blank title counts as absent; ignored for PNG and SVG.
+     */
+    title?: string;
 }
 
 export interface RenderResult {
@@ -813,8 +832,12 @@ export class Document {
     card(index: number): Card;
     clone(): Document;
     /**
-     * Storage version this build writes via [`toStored`](Document::to_stored). The
-     * tag advances only when the wire format changes, not on every release.
+     * The newest storage version this build writes via
+     * [`toStored`](Document::to_stored): a document spelling a font mark, a
+     * `table` element, a merged table cell or a table head 0.130 cannot draw
+     * carries it, every other the tag before it, which a 0.130 build reads.
+     * The tag advances only when the wire format changes, not on every
+     * release.
      */
     static currentStorageVersion(): string;
     /**
@@ -1056,7 +1079,18 @@ export class Document {
 export class Engine {
     free(): void;
     [Symbol.dispose](): void;
-    constructor();
+    /**
+     * The text faces a `font_family` mark may set in a session of `quill`:
+     * the host library's, in library order.
+     */
+    fontFaces(quill: Quill): FontFace[];
+    /**
+     * An engine whose sessions also set text in `fonts`, the host's font
+     * library: each a `.ttf`, `.otf`, `.ttc` or `.otc` file, parsed once
+     * here. A file in another format throws `engine::font_unsupported`, and
+     * one holding no readable face `engine::font_unreadable`.
+     */
+    constructor(fonts: Uint8Array[] | undefined);
     /**
      * Open a live render session for `doc` against `quill`'s backend, on the
      * render date `today` (`YYYY-MM-DD`, default the local date).
@@ -1232,6 +1266,12 @@ export class Quill {
      * parse or its `$quill` is not this quill's bare name.
      */
     exampleDocument(): Document | undefined;
+    /**
+     * Read a `.quill` bundle, the zip archive holding one quill's file tree.
+     * Pure, as [`fromTree`](Self::from_tree) is. A bundle outside the format
+     * throws one `quill::bundle_*` diagnostic.
+     */
+    static fromBundle(bytes: Uint8Array): Quill;
     /**
      * Build a quill from a file tree. Pure: the declared backend is resolved
      * later, at render time. Accepts a `Map<string, Uint8Array>` or a plain
@@ -1274,6 +1314,11 @@ export class Quill {
      * `$kind: main` card of [`seedDocument`](Self::seed_document) alone.
      */
     seedMain(): Card;
+    /**
+     * This quill's file tree as a `.quill` bundle, the bytes
+     * [`fromBundle`](Self::from_bundle) reads.
+     */
+    toBundle(): Uint8Array;
     /**
      * Flatten this quill back into its canonical file tree, the inverse of
      * [`fromTree`](Self::from_tree). Keys are `"/"`-joined relative paths.
@@ -1475,7 +1520,8 @@ export interface InitOutput {
     readonly document_toMarkdown: (a: number, b: number) => void;
     readonly document_toStored: (a: number, b: number) => void;
     readonly document_warnings: (a: number, b: number) => void;
-    readonly engine_new: () => number;
+    readonly engine_fontFaces: (a: number, b: number, c: number) => void;
+    readonly engine_new: (a: number, b: number) => void;
     readonly engine_open: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly engine_render: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly engine_supportedFormats: (a: number, b: number, c: number) => void;
@@ -1507,6 +1553,7 @@ export interface InitOutput {
     readonly quill_conform: (a: number, b: number, c: number) => void;
     readonly quill_emptyDocument: (a: number) => number;
     readonly quill_exampleDocument: (a: number, b: number) => void;
+    readonly quill_fromBundle: (a: number, b: number, c: number) => void;
     readonly quill_fromTree: (a: number, b: number) => void;
     readonly quill_metadata: (a: number, b: number) => void;
     readonly quill_parse: (a: number, b: number, c: number, d: number) => void;
@@ -1514,6 +1561,7 @@ export interface InitOutput {
     readonly quill_seedCard: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly quill_seedDocument: (a: number) => number;
     readonly quill_seedMain: (a: number, b: number) => void;
+    readonly quill_toBundle: (a: number, b: number) => void;
     readonly quill_toTree: (a: number) => number;
     readonly quill_validate: (a: number, b: number, c: number) => void;
     readonly quill_warnings: (a: number, b: number) => void;

package/render/wasm.js

@@ -441,8 +441,12 @@ export class Document {
         return Document.__wrap(ret);
     }
     /**
-     * Storage version this build writes via [`toStored`](Document::to_stored). The
-     * tag advances only when the wire format changes, not on every release.
+     * The newest storage version this build writes via
+     * [`toStored`](Document::to_stored): a document spelling a font mark, a
+     * `table` element, a merged table cell or a table head 0.130 cannot draw
+     * carries it, every other the tag before it, which a 0.130 build reads.
+     * The tag advances only when the wire format changes, not on every
+     * release.
      * @returns {string}
      */
     static currentStorageVersion() {
@@ -1203,11 +1207,51 @@ export class Engine {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_engine_free(ptr, 0);
     }
-    constructor() {
-        const ret = wasm.engine_new();
-        this.__wbg_ptr = ret;
-        EngineFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * The text faces a `font_family` mark may set in a session of `quill`:
+     * the host library's, in library order.
+     * @param {Quill} quill
+     * @returns {FontFace[]}
+     */
+    fontFaces(quill) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            wasm.engine_fontFaces(retptr, this.__wbg_ptr, quill.__wbg_ptr);
+            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);
+        }
+    }
+    /**
+     * An engine whose sessions also set text in `fonts`, the host's font
+     * library: each a `.ttf`, `.otf`, `.ttc` or `.otc` file, parsed once
+     * here. A file in another format throws `engine::font_unsupported`, and
+     * one holding no readable face `engine::font_unreadable`.
+     * @param {Uint8Array[] | undefined} fonts
+     */
+    constructor(fonts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.engine_new(retptr, addHeapObject(fonts));
+            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);
+            }
+            this.__wbg_ptr = r0;
+            EngineFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * Open a live render session for `doc` against `quill`'s backend, on the
@@ -1788,6 +1832,30 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Read a `.quill` bundle, the zip archive holding one quill's file tree.
+     * Pure, as [`fromTree`](Self::from_tree) is. A bundle outside the format
+     * throws one `quill::bundle_*` diagnostic.
+     * @param {Uint8Array} bytes
+     * @returns {Quill}
+     */
+    static fromBundle(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.quill_fromBundle(retptr, ptr0, len0);
+            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 Quill.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Build a quill from a file tree. Pure: the declared backend is resolved
      * later, at render time. Accepts a `Map<string, Uint8Array>` or a plain
@@ -1944,6 +2012,29 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * This quill's file tree as a `.quill` bundle, the bytes
+     * [`fromBundle`](Self::from_bundle) reads.
+     * @returns {Uint8Array}
+     */
+    toBundle() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quill_toBundle(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Flatten this quill back into its canonical file tree, the inverse of
      * [`fromTree`](Self::from_tree). Keys are `"/"`-joined relative paths.
@@ -2452,6 +2543,9 @@ function __wbg_get_imports() {
             const ret = Reflect.getPrototypeOf(getObject(arg0));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_getRandomValues_436a51d0629d84e1: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
         __wbg_get_658f6698067d9515: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
@@ -2603,6 +2697,10 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
+        __wbg_push_2baf45db356cf468: function(arg0, arg1) {
+            const ret = getObject(arg0).push(getObject(arg1));
+            return ret;
+        },
         __wbg_putImageData_11570c06086c9e05: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
         }, arguments); },
@@ -2849,6 +2947,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/render/wasm_bg.wasm.d.ts

@@ -52,7 +52,8 @@ export const document_toAnnotatedMarkdown: (a: number, b: number) => void;
 export const document_toMarkdown: (a: number, b: number) => void;
 export const document_toStored: (a: number, b: number) => void;
 export const document_warnings: (a: number, b: number) => void;
-export const engine_new: () => number;
+export const engine_fontFaces: (a: number, b: number, c: number) => void;
+export const engine_new: (a: number, b: number) => void;
 export const engine_open: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const engine_render: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const engine_supportedFormats: (a: number, b: number, c: number) => void;
@@ -84,6 +85,7 @@ export const quill_blueprint: (a: number, b: number) => void;
 export const quill_conform: (a: number, b: number, c: number) => void;
 export const quill_emptyDocument: (a: number) => number;
 export const quill_exampleDocument: (a: number, b: number) => void;
+export const quill_fromBundle: (a: number, b: number, c: number) => void;
 export const quill_fromTree: (a: number, b: number) => void;
 export const quill_metadata: (a: number, b: number) => void;
 export const quill_parse: (a: number, b: number, c: number, d: number) => void;
@@ -91,6 +93,7 @@ export const quill_schema: (a: number, b: number) => void;
 export const quill_seedCard: (a: number, b: number, c: number, d: number, e: number) => void;
 export const quill_seedDocument: (a: number) => number;
 export const quill_seedMain: (a: number, b: number) => void;
+export const quill_toBundle: (a: number, b: number) => void;
 export const quill_toTree: (a: number) => number;
 export const quill_validate: (a: number, b: number, c: number) => void;
 export const quill_warnings: (a: number, b: number) => void;

package/runtime/runtime.d.ts

@@ -267,6 +267,12 @@ export interface RenderOptions {
 	 * consumers without a live session. Defaults to `false`.
 	 */
 	regions?: boolean;
+	/**
+	 * The PDF document title, over the plate's own `set document(title: ..)`
+	 * and then the quill's `description`. A blank title counts as absent;
+	 * ignored by PNG and SVG.
+	 */
+	title?: string;
 }
 
 /**
@@ -415,6 +421,31 @@ export interface EngineOptions {
 	 * `"typst"` and `"acroform"` to the bundled render build.
 	 */
 	backends?: Record<string, BackendDescriptor>;
+
+	/**
+	 * The host's font library: each a `.ttf`, `.otf`, `.ttc` or `.otc` file,
+	 * whose faces set only text a `font_family` mark sets. The bytes are
+	 * copied at construction, cross into the render build once, when it loads,
+	 * and are parsed there once. A file it refuses rejects every verb that
+	 * needs that build, the first and each later one, with the same error:
+	 * `engine::font_unsupported` for another format, `engine::font_unreadable`
+	 * for a file holding no readable face. A value that is not an array of
+	 * `Uint8Array` throws at construction.
+	 */
+	fonts?: Uint8Array[];
+}
+
+/**
+ * One face a session sets text in, with what an editor needs for an
+ * `@font-face` rule: the family, the CSS weight and style, and the font file.
+ * `index` is the face's place in `data` where the file is a collection.
+ */
+export interface FontFace {
+	family: string;
+	weight: number;
+	style: 'normal' | 'italic' | 'oblique';
+	index: number;
+	data: Uint8Array;
 }
 
 /**
@@ -485,6 +516,15 @@ export declare class Engine {
 	 * backend binary or cloning the quill. Async for API stability.
 	 */
 	supportedFormats(quill: Quill): Promise<OutputFormat[]>;
+
+	/**
+	 * The text faces a `font_family` mark may set in a session of `quill`: the
+	 * host library's, in the order of `fonts`. A quill's own fonts and the
+	 * embedded fallback set its plate, never a mark. Loads the backend and
+	 * clones the quill as `open` does; a backend that reads no fonts answers
+	 * `[]`.
+	 */
+	fontFaces(quill: Quill): Promise<FontFace[]>;
 }
 
 /**

package/runtime/runtime.js

@@ -331,10 +331,9 @@ function requireLocalQuill(quill, method) {
 // `runtime.test.js` § "container run boundaries" stamps a pair and re-imports
 // it, where `Content::normalize` re-mints against the Rust predicate. A tag the
 // table omits welds with nothing, so `tests/known_names_drift.rs` pins that
-// every container has an entry. An entry of `'*'` welds on the whole bag: an
-// element's attributes are open, its name among them.
+// every container has an entry.
 
-const WELD_KEYS = { list_item: ['ordered'], quote: [], description: [], element: '*' };
+const WELD_KEYS = { list_item: ['ordered'], quote: [] };
 
 /**
  * @param {import('../core/wasm.js').ContentContainer} a
@@ -347,20 +346,7 @@ function weldsWith(a, b) {
 	// `hasOwn`, so a tag colliding with an `Object.prototype` member answers
 	// `false` rather than reaching a function.
 	if (!Object.hasOwn(WELD_KEYS, a.container)) return false;
-	const keys = WELD_KEYS[a.container];
-	if (keys === '*') return sameBag(a.attrs, b.attrs);
-	return keys.every((k) => a.attrs?.[k] === b.attrs?.[k]);
-}
-
-/**
- * @param {Record<string, unknown> | undefined} a
- * @param {Record<string, unknown> | undefined} b
- * @returns {boolean}
- */
-function sameBag(a, b) {
-	const [x, y] = [a ?? {}, b ?? {}];
-	const keys = Object.keys(x);
-	return keys.length === Object.keys(y).length && keys.every((k) => Object.hasOwn(y, k) && x[k] === y[k]);
+	return WELD_KEYS[a.container].every((k) => a.attrs?.[k] === b.attrs?.[k]);
 }
 
 /**
@@ -470,10 +456,22 @@ export class Engine {
 	 */
 	/** load → Promise<build module>, memoized so each build loads once. */
 	#modules = new Map();
-	/** load → that build's engine instance (the WASM backend registry). */
+	/**
+	 * load → `{ engine }`, that build's engine instance (the WASM backend
+	 * registry), or `{ refused }`, the error its construction threw. A refusal
+	 * is the font library's, which every retry would parse and refuse again.
+	 */
 	#engines = new Map();
 	/** backendId → descriptor `{ load, formats }`. */
 	#loaders;
+	/**
+	 * The host's font library, copied at construction and handed to each
+	 * build's engine as it loads; `null` once every build has had it.
+	 * @type {Uint8Array[] | null}
+	 */
+	#fonts;
+	/** How many distinct builds the loaders name. */
+	#builds;
 	/**
 	 * load → WeakMap<canonical Quill, build-memory clone>, caching the
 	 * expensive materialization. WeakMap so dropping the canonical quill makes
@@ -486,10 +484,15 @@ export class Engine {
 	 * `load` must resolve to a READY module: a registrant shipping its own
 	 * `--target web` build instantiates inside the thunk, and more than one
 	 * `Engine` may call it, so memoize (the built-ins do, at module scope).
-	 * @param {{ backends?: Record<string, { load: () => Promise<unknown>, formats: string[] }> }} [options]
+	 * @param {{ backends?: Record<string, { load: () => Promise<unknown>, formats: string[] }>, fonts?: Uint8Array[] }} [options]
 	 */
 	constructor(options) {
-		rejectUnknownKeys(options, ['backends'], 'Engine options');
+		rejectUnknownKeys(options, ['backends', 'fonts'], 'Engine options');
+		const fonts = options?.fonts ?? [];
+		if (!Array.isArray(fonts) || !fonts.every((font) => font instanceof Uint8Array)) {
+			throw new Error('Engine: `fonts` must be an array of Uint8Array.');
+		}
+		this.#fonts = fonts.map((font) => font.slice());
 		const merged = { ...DEFAULT_BACKENDS, ...(options?.backends ?? {}) };
 		/** @type {Record<string, { load: () => Promise<unknown>, formats: string[] }>} */
 		const loaders = {};
@@ -497,6 +500,7 @@ export class Engine {
 			loaders[id] = validateBackend(id, entry);
 		}
 		this.#loaders = loaders;
+		this.#builds = new Set(Object.values(loaders).map((descriptor) => descriptor.load)).size;
 	}
 
 	/**
@@ -554,12 +558,18 @@ export class Engine {
 		}
 		const mod = await modPromise;
 
-		let engine = this.#engines.get(load);
-		if (!engine) {
-			engine = new mod.Engine();
-			this.#engines.set(load, engine);
+		let built = this.#engines.get(load);
+		if (!built) {
+			try {
+				built = { engine: new mod.Engine(this.#fonts) };
+			} catch (refused) {
+				built = { refused };
+			}
+			this.#engines.set(load, built);
+			if (this.#engines.size === this.#builds) this.#fonts = null;
 		}
-		return { mod, engine };
+		if ('refused' in built) throw built.refused;
+		return { mod, engine: built.engine };
 	}
 
 	/**
@@ -630,7 +640,7 @@ export class Engine {
 	/**
 	 * @param {Quill} quill
 	 * @param {Document} doc
-	 * @param {object} [options] render options (`{ format, ppi, pages, regions }`)
+	 * @param {object} [options] render options (`{ format, ppi, pages, regions, title }`)
 	 * @param {string} [today] the render date, `YYYY-MM-DD`
 	 * @returns {Promise<import('./runtime.js').RenderResult>}
 	 */
@@ -658,6 +668,36 @@ export class Engine {
 		);
 	}
 
+	/**
+	 * Run `fn` against `quill`'s build-memory clone, `quill` snapshotted before
+	 * the first await as `#withClones` snapshots it.
+	 * @param {string} method the caller's name, for the rejection message
+	 * @param {Quill} quill
+	 * @param {(ctx: { engine: any, quill: any }) => any} fn
+	 */
+	async #withQuill(method, quill, fn) {
+		const backendId = this.#backendOf(quill, method);
+		const quillTree = this.#quillClones.get(this.#descriptorFor(backendId).load)?.has(quill)
+			? null
+			: quill.toTree();
+		const { mod, engine } = await this.#resolveBackend(backendId);
+		try {
+			return fn({ engine, quill: this.#cachedQuillClone(mod, backendId, quill, quillTree) });
+		} catch (err) {
+			throw backendTrap(err);
+		}
+	}
+
+	/**
+	 * @param {Quill} quill
+	 * @returns {Promise<import('./runtime.d.ts').FontFace[]>}
+	 */
+	async fontFaces(quill) {
+		return this.#withQuill('engine.fontFaces(quill)', quill, ({ engine, quill: q }) =>
+			typeof engine.fontFaces === 'function' ? engine.fontFaces(q) : []
+		);
+	}
+
 	/**
 	 * @param {Quill} quill
 	 * @returns {Promise<void>}