@quillmark/wasm 0.130.0 → 0.131.0

package/CHANGELOG.md

@@ -1,5 +1,109 @@
 # Changelog
 
+## v0.131.0 - 2026-10-26
+
+Upgrade path: [0.130 → 0.131](docs/migrations/0.130-to-0.131.md). A row
+holding a font mark, an element named `table`, a merged cell or a table `head`
+0.130 cannot draw saves under `quillmark/document@0.131.0`, which a 0.130
+build refuses, so deploy every reader before a writer saves one.
+
+### Storage
+
+- fix(core): **a row holding an element named `table`, a table cell spanning
+  more than one column or row, or a table `head` a 0.130 build cannot draw
+  saves under `quillmark/document@0.131.0`**, as a row holding a `font_family`
+  mark does: a 0.130 build refused the element as corrupt and drew the rest
+  wrong under `@0.129.0`. The check reads each body and each field and `$seed`
+  value that decodes as content, and no longer reads `$ext`, so host data
+  shaped like a font mark keeps `@0.129.0`.
+
+### Content
+
+- feat(content)!: **a table writes as a GFM pipe table when pipes hold all of
+  it, and as an HTML table when it holds column widths, a placement, a cell's
+  alignment, a merged cell or other than one header row**, whichever spelling
+  the markdown used. An HTML block opening `<table>` imports as a table: the
+  subset is `table`, `thead`, `tbody`, `tfoot`, `tr`, `th` and `td`, with
+  `widths`, `aligns` and `align` on `<table>` and `colspan`, `rowspan`, `align`
+  and `valign` on a cell, whose content is inline markdown. A span stores as a
+  cell's `colspan` and `rowspan`, each cell it covers an empty placeholder, and
+  the header rows as the table's `head`, a count `headless: true` normalizes
+  to `head: 0`. What an HTML table cannot hold warns
+  `parse::dropped_construct` as `table`, `table:row`, `table:text` or
+  `<tag>[<attr>]`. Markdown after a `</table>` in its HTML block reads as
+  markdown of its own. An HTML table is as wide as its widest row, a `<th>`
+  row opening its `tbody` is a header row, and `border`, `class`, `scope` and
+  `style` drop silently. The Typst backend draws a span through
+  `table.cell(colspan:, rowspan:)` and every header row in `table.header`.
+- feat(content)!: **`qm-table` and `qm-cell` no longer spell a table's
+  layout**: `qm-table` is an ordinary element name, and a `qm-cell` pair in a
+  cell drops, warning `qm-cell`, so markdown written with either loses its
+  table layout; rewrite such a table as HTML.
+- fix(content): **a table's `head: 0` keeps `headless: true` beside it**, so a
+  0.130 reader draws no header row on a table 0.131 saved, and a richtext
+  field holding a 0.130 `headless: true` table reads as content, exporting as
+  a table where it wrote its YAML tree. A cell a span covers keeps its `align`
+  and `valign`, drawn again once the span shrinks, and a cell holding a mark,
+  a comment anchor included, is no placeholder a span covers. A 0.130 row
+  holding `headless: true` or a cell span rewrites once when saved, under the
+  same tag unless a span still covers more than one slot, which saves under
+  `@0.131.0`.
+- fix(content)!: **a body formatting mark spanning a line break loads as one
+  mark per line**, cut at each `\n`, the form markdown export writes, so a
+  mark over a hard break round-trips through markdown and a `MarkOp::Add`
+  across lines reads back split. A stored row holding such a
+  mark saves to new bytes on its first load. A table cell's or footnote's
+  marks still span its `<br>`.
+- fix(content)!: **`link` is keyed like `font_family`**: overlapping links
+  settle to one url per character, the later-starting one winning, and a
+  `MarkOp::Add` of a link over a link replaces its url there, so
+  `MarkKind::is_keyed` holds for `Link`. Keyed marks settle before the cut at
+  line breaks, so a later-starting family keeps its whole range across one.
+- fix(content)!: **a table's grid is capped at `MAX_TABLE_CELLS` (100 000)
+  slots, and a markdown import's tables share the cap**: import drops the rows
+  past it, warning `table:size`, and the stored lanes refuse such a table as
+  `Invariant::TableTooLarge` before padding it, where a few bytes could
+  allocate millions of cells.
+- fix(content): **a code span in an HTML table's cell never reaches past a
+  subset tag**, so a stray backtick is the cell's text rather than merging
+  cells, rows or the prose after the table, and a code mark over a subset tag
+  exports the tag as escaped text.
+
+### Fonts
+
+- feat!: **a run of richtext sets a font family, spelled in markdown as an
+  inline `<qm-span family="…">` pair** and stored as a `font_family` mark, one
+  family per character, so export writes nested pairs back side by side. A
+  row holding a `font_family` mark saves as `quillmark/document@0.131.0`,
+  which a 0.130 build refuses; `currentStorageVersion()` /
+  `current_storage_version()` return that tag. `MarkKind` gains
+  `FontFamily { name }`, `StoredDocument` gains `V0_131_0`, and the WASM
+  `ContentMark` gains `font_family`. A `qm-span` tag line, which 0.130 read as
+  an element named `span`, drops and warns `qm-span`.
+- feat!: **an engine takes a host font library**: `Engine::with_fonts`, the
+  `fonts` option of `new Engine(..)`, `Engine(fonts=..)` and `--font` on
+  `quillmark render` and `quillmark workspace`. A file other than `.ttf`,
+  `.otf`, `.ttc` or `.otc` fails as `engine::font_unsupported`, one holding no
+  face Typst reads as `engine::font_unreadable`. A library face sets only text
+  a font mark sets, and a family the library lacks keeps the surrounding font
+  and warns `typst::unknown_font_family`. `TypstBackend` is a struct holding
+  the library, built with `TypstBackend::default()` or
+  `TypstBackend::new(Arc<FontLibrary>)`, `quillmark_typst::workspace::workspace`
+  takes a `&FontLibrary` third, and `Engine::font_faces`,
+  `engine.fontFaces(quill)` and `Engine.font_faces(quill)` list the faces,
+  sharing the library's bytes rather than copying them. The WASM engine copies
+  its `fonts` when built and parses them once, so a refused font rejects every
+  verb that loads the render build with the same error. A plate naming a
+  library family never reaches its face.
+
+### Fixes
+
+- fix(acroform): a `richtext` array element holding no text binds as an empty
+  line, so a blank line between groups reaches the widget.
+- fix(core): a list item with nothing after its marker ends at the blank line
+  below it, so a card fence inside a code block below such an item stays
+  code.
+
 ## v0.130.0 - 2026-10-22
 
 Upgrade path: [0.129 → 0.130](docs/migrations/0.129-to-0.130.md). A stored row

package/README.md

@@ -182,10 +182,11 @@ const doc = Document.storageVersionOf(content)
   : Document.fromMarkdown(content);
 ```
 
-The `schema` value (`quillmark/document@0.129.0`) is the **model version**,
-not the running crate version. It is a hand-set constant, bumped only when
-the `Document` model itself changes, so every `0.129.x` patch release reads
-and writes that same value.
+The `schema` value (`quillmark/document@0.131.0` for a document holding a font
+mark, `@0.129.0` for any other) is the **model version**, not the running crate
+version. It is a hand-set constant, bumped only when the `Document` model
+itself changes, so every `0.131.x` patch release reads and writes those same
+values.
 
 - **Upgrading is safe.** A newer build reads documents an older build's
   *writer* produced. Each schema version's wire format is frozen and never
@@ -206,19 +207,26 @@ and writes that same value.
   read, newer than the build or retired, rather than guessing at its format.
   Don't feed documents written by a newer build back into an older one.
 
-To detect a version mismatch before parsing, use the static accessors:
+`Document.currentStorageVersion()` is the newest tag this build writes. A
+save writes the oldest tag that holds the row, so a fresh row can carry an
+older tag still read: a row holding no font mark, `table` element, merged
+table cell or table `head` 0.130 cannot draw saves as
+`quillmark/document@0.129.0`. A tag other than `currentStorageVersion()` is
+therefore not a mismatch. Use `storageVersionOf` after `fromStored` throws,
+to tell "a version this build does not read" from "corrupt":
 
 ```ts
-const v = Document.storageVersionOf(blob); // undefined | string
-if (v && v !== Document.currentStorageVersion()) {
-  // payload is from a build with a different model version
+try {
+  return Document.fromStored(blob);
+} catch (err) {
+  const v = Document.storageVersionOf(blob); // undefined | string
+  // v: a tag this build does not read; undefined: not a stored document
 }
 ```
 
 `storageVersionOf` does not validate the payload: it only reads the
 `schema` field, returning `undefined` for non-JSON, non-objects, or
-payloads that don't carry one. Use it to distinguish "wrong version" from
-"corrupt" when `fromStored` throws.
+payloads that don't carry one.
 
 In short: persist the `toStored` string, resave rows under a retired tag
 before upgrading past it, never downgrade. The full design (including how

package/THIRD_PARTY_LICENSES.md

@@ -2153,14 +2153,14 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH RE
 
 ## Apache License 2.0
 
-- quillmark-acroform 0.130.0 (https://github.com/borb-sh/quillmark)
-- quillmark-typst 0.130.0 (https://github.com/borb-sh/quillmark)
-- quillmark-cli 0.130.0 (https://github.com/borb-sh/quillmark)
-- quillmark-python 0.130.0
-- quillmark-content 0.130.0 (https://github.com/borb-sh/quillmark)
-- quillmark-core 0.130.0 (https://github.com/borb-sh/quillmark)
-- quillmark 0.130.0 (https://github.com/borb-sh/quillmark)
-- quillmark-pdf 0.130.0 (https://github.com/borb-sh/quillmark)
+- quillmark-acroform 0.131.0 (https://github.com/borb-sh/quillmark)
+- quillmark-typst 0.131.0 (https://github.com/borb-sh/quillmark)
+- quillmark-cli 0.131.0 (https://github.com/borb-sh/quillmark)
+- quillmark-python 0.131.0
+- quillmark-content 0.131.0 (https://github.com/borb-sh/quillmark)
+- quillmark-core 0.131.0 (https://github.com/borb-sh/quillmark)
+- quillmark 0.131.0 (https://github.com/borb-sh/quillmark)
+- quillmark-pdf 0.131.0 (https://github.com/borb-sh/quillmark)
 - ciborium-io 0.2.2 (https://github.com/enarx/ciborium)
 - ciborium-ll 0.2.2 (https://github.com/enarx/ciborium)
 - ciborium 0.2.2 (https://github.com/enarx/ciborium)
@@ -2377,6 +2377,11 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH RE
 - clap 4.6.7 (https://github.com/clap-rs/clap)
 - clap_builder 4.6.7 (https://github.com/clap-rs/clap)
 - clap_derive 4.6.7 (https://github.com/clap-rs/clap)
+- serde_spanned 1.1.2 (https://github.com/toml-rs/toml)
+- toml 1.1.8+spec-1.1.0 (https://github.com/toml-rs/toml)
+- toml_datetime 1.1.2+spec-1.1.0 (https://github.com/toml-rs/toml)
+- toml_parser 1.1.5+spec-1.1.0 (https://github.com/toml-rs/toml)
+- toml_writer 1.1.3+spec-1.1.0 (https://github.com/toml-rs/toml)
 
 ~~~~text
                                  Apache License
@@ -2600,15 +2605,10 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH RE
 - once_cell_polyfill 1.70.2 (https://github.com/polyfill-rs/once_cell_polyfill)
 - quick-error 2.0.1 (http://github.com/tailhook/quick-error)
 - serde_spanned 0.6.9 (https://github.com/toml-rs/toml)
-- serde_spanned 1.1.1 (https://github.com/toml-rs/toml)
 - toml 0.8.23 (https://github.com/toml-rs/toml)
-- toml 1.1.6+spec-1.1.0 (https://github.com/toml-rs/toml)
 - toml_datetime 0.6.11 (https://github.com/toml-rs/toml)
-- toml_datetime 1.1.1+spec-1.1.0 (https://github.com/toml-rs/toml)
 - toml_edit 0.22.27 (https://github.com/toml-rs/toml)
-- toml_parser 1.1.3+spec-1.1.0 (https://github.com/toml-rs/toml)
 - toml_write 0.1.2 (https://github.com/toml-rs/toml)
-- toml_writer 1.1.2+spec-1.1.0 (https://github.com/toml-rs/toml)
 
 ~~~~text
                                  Apache License
@@ -4555,7 +4555,7 @@ limitations under the License.
 - unic-langid-macros-impl 0.9.6 (https://github.com/zbraniecki/unic-locale)
 - unic-langid-macros 0.9.6 (https://github.com/zbraniecki/unic-locale)
 - unic-langid 0.9.6 (https://github.com/zbraniecki/unic-locale)
-- unicase 2.9.0 (https://github.com/seanmonstar/unicase)
+- unicase 2.10.0 (https://github.com/seanmonstar/unicase)
 - unicode-bidi-mirroring 0.4.0 (https://github.com/RazrFalcon/unicode-bidi-mirroring)
 - unicode-bidi 0.3.18 (https://github.com/servo/unicode-bidi)
 - unicode-ccc 0.4.0 (https://github.com/RazrFalcon/unicode-ccc)
@@ -5395,6 +5395,7 @@ APPENDIX: How to apply the Apache License to your work.
 
 ## Apache License 2.0
 
+- getrandom 0.4.3 (https://github.com/rust-random/getrandom)
 - rand_chacha 0.3.1 (https://github.com/rust-random/rand)
 
 ~~~~text
@@ -6247,8 +6248,8 @@ limitations under the License.
 
 ## Apache License 2.0
 
-- quillmark-wasm 0.130.0 (https://github.com/borb-sh/quillmark)
-- quillmark-fixtures 0.130.0
+- quillmark-wasm 0.131.0 (https://github.com/borb-sh/quillmark)
+- quillmark-fixtures 0.131.0
 - arraydeque 0.5.1 (https://github.com/andylokandy/arraydeque)
 - codex 0.3.0 (https://github.com/typst/codex)
 - color 0.3.3 (https://github.com/linebender/color)
@@ -6311,7 +6312,7 @@ limitations under the License.
 - serde_core 1.0.229 (https://github.com/serde-rs/serde)
 - serde_derive 1.0.229 (https://github.com/serde-rs/serde)
 - serde_derive_internals 0.29.1 (https://github.com/serde-rs/serde)
-- serde_json 1.0.151 (https://github.com/serde-rs/json)
+- serde_json 1.0.154 (https://github.com/serde-rs/json)
 - serde_path_to_error 0.1.20 (https://github.com/dtolnay/path-to-error)
 - serde_yaml 0.9.34+deprecated (https://github.com/dtolnay/serde-yaml)
 - siphasher 1.0.2 (https://github.com/jedisct1/rust-siphash)

package/core/wasm.d.ts

@@ -132,7 +132,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 +145,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 +167,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 +307,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.
  */
@@ -675,8 +684,11 @@ 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;
     /**

package/core/wasm.js

@@ -441,8 +441,11 @@ 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() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.130.0",
+  "version": "0.131.0",
   "description": "WebAssembly bindings for Quillmark, a schema-driven document framework",
   "type": "module",
   "license": "Apache-2.0",

package/render/wasm.d.ts

@@ -132,7 +132,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 +145,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 +167,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 +307,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 +480,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 {
@@ -813,8 +835,11 @@ 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 +1081,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).
@@ -1475,7 +1511,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;

package/render/wasm.js

@@ -441,8 +441,11 @@ 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 +1206,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
@@ -2452,6 +2495,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 +2649,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); },

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;

package/runtime/runtime.d.ts

@@ -415,6 +415,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 +510,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[]>;
 }
 
 /**