@quillmark/wasm 0.119.0 → 0.121.0

package/CHANGELOG.md

@@ -1,5 +1,80 @@
 # Changelog
 
+## v0.121.0 - 2026-09-30
+
+Upgrade path: [0.120 → 0.121](docs/migrations/0.120-to-0.121.md).
+
+### Matrix presence
+
+- feat(core,typst,wasm)!: **a matrix member is held by being present in the
+  document**: a mapping is held whatever it carries, `{}` included, and a bare
+  scalar is the tick. A mapping naming no `held` flips from unticked to ticked,
+  with nothing reporting it. `held` is never stored: a member mapping storing
+  it fails validation as `validation::held_stored`, and the render with it, and
+  a `Quill.yaml` `seed:` or `default:` storing it fails to load as
+  `quill::seed_held_stored` / `quill::default_held_stored`. A `held: null` is
+  absent. The strict write rests a held member with no answers as `true`, and
+  the blueprint's `# e.g.` line drops `held: true`. (#2023)
+
+### Matrix plate
+
+- feat(core,typst,acroform)!: **a matrix reaches the plate as the members it
+  holds**, each its columns keyed by id: no member carries `held` or a roster
+  `title`, and an unheld member is absent, so a plate reading `m.held` or
+  `m.title` fails to compile. `roster(dict, key)` in the Typst helper prints the
+  whole vocabulary as `(id, title, held, value, path)` rows, and the dictionary
+  declaring a matrix carries `$path` for it. A member's tick is its own address,
+  `<field>.<member>`: a claim on `<field>.<member>.held` fails the compile, an
+  acroform binding on it fails to load as `acroform::dangling_binding`, and a
+  bare tick the boolean coercion refuses is `validation::type_mismatch` at the
+  member's path. `resolve()` reports the members a matrix holds. A matrix takes
+  a `default:` and `type: matrix?`. The transform schema carries the roster as
+  `quillmark:roster` `[id, title]` pairs, and Rust `QUILLMARK_ORDER_KEY` is
+  `QUILLMARK_ROSTER_KEY`; `FieldSchema::members` is `FieldSchema::member`,
+  beside `added_item`, and `namespace_props` answers `None` for a matrix.
+  (#2023)
+
+### Open matrix
+
+- feat(core,typst,wasm): **`open: true` on a matrix admits items a document
+  adds**, each keyed by a snake_case id and carrying a `title`, taking the
+  roster's columns. The plate and `roster` carry them after the held roster
+  members, sorted by id, and an added item's `title` is a cell with an address.
+  Any other key outside the roster is `validation::enum_violation`, which gains
+  an `open` arg. The transform schema declares the added item as
+  `additionalProperties`, `schema()` emits `open: true` (WASM
+  `QuillFieldSchema.open`), and an acroform quill declaring one fails to load as
+  `quill::open_matrix_unsupported`. `FieldType::Matrix` carries `open: bool`.
+  (#2023)
+
+### Release
+
+- ci(release): **crate publishing retries past a crates.io index backlog**,
+  excluding the crates crates.io already holds at the release version, so a
+  re-run resumes a partial upload. (#2029)
+
+
+## v0.120.0 - 2026-09-30
+
+Upgrade path: [0.119 → 0.120](docs/migrations/0.119-to-0.120.md).
+
+### `Engine.load`
+
+- feat(wasm): **`engine.load(quill)` loads and instantiates a quill's backend
+  build without a document**, cloning no quill. It is the memoized load
+  `render` and `open` await, so a host can start the render build's fetch once
+  the quill resolves and mount its editor on core meanwhile. Awaiting it before
+  `open` makes the session's first compile read the current document. A failed
+  load rejects, `runtime::backend_load_failed` for the built-ins, and the next
+  call retries. (#2027)
+
+### `quill::table_column_not_leaf`
+
+- refactor(core)!: **a `ui.layout: table` column that is not a leaf fails to
+  load as `quill::table_column_not_leaf`**, where it was
+  `quill::table_column_not_flat`. Its trigger and message are unchanged.
+  (#2021)
+
 ## v0.119.0 - 2026-09-30
 
 ### `ui.layout: flat`

package/README.md

@@ -119,8 +119,8 @@ A load failure surfaces as `runtime::init_failed`, whose hint names that line.
 Create the render dispatcher. Routes each quill to its backend by
 `quill.backendId`, lazily loads that backend binary, and renders: cloning the
 quill/document into the backend's memory and freeing the clones internally.
-`render`, `open`, and `supportedFormats` are **async** (the first call may load
-a backend). Pass `{ backends }` to register or override backend descriptors.
+`render`, `open`, `load`, and `supportedFormats` are **async** (the first call
+may load a backend). Pass `{ backends }` to register or override backend descriptors.
 Each entry is a descriptor (`{ [backendId]: { load, formats } }`) where `load`
 is the lazy thunk returning the backend module and `formats` is the
 **required** static capability manifest. A malformed descriptor throws at
@@ -131,6 +131,21 @@ is the lazy thunk returning the backend module and `formats` is the
 manifest: never loading the multi-MB backend binary and never cloning the
 quill. Use it as a non-failing pre-render probe.
 
+**An editor does not wait on the render build.** `open` reads the document
+before it awaits the backend load, so a session opened while the build loads
+compiles the document as it stood at the call. Mount the editor on core, start
+the load, and open once it lands:
+
+```js
+void engine.load(quill);          // start the fetch as soon as the quill resolves
+mountEditor(quill, doc);          // core alone
+await engine.load(quill);         // memoized: the same load
+const session = await engine.open(quill, doc); // one compile, current document
+```
+
+`load` reads only `quill.backendId` and clones nothing. A failed load rejects
+with `runtime::backend_load_failed`, and the next call retries.
+
 ### The two doors: `Document.fromMarkdown` vs `quill.parse` / `quill.conform`
 
 `Document.fromMarkdown` is the quill-free **transport door** (migrations, `$ext`
@@ -451,7 +466,7 @@ try {
 
 **Delivery follows the function, not the failure.** A synchronous method throws;
 a promise-returning one rejects. The promise-returning surface is `init` and the
-three `Engine` verbs (`render`, `open`, `supportedFormats`), so a programming
+four `Engine` verbs (`render`, `open`, `load`, `supportedFormats`), so a programming
 error reached through one of them (a foreign handle, an unregistered backend)
 rejects like any other failure. Nothing here both returns
 a promise and throws, so a `.catch` on a promise-returning call is a whole

package/core/wasm.d.ts

@@ -383,7 +383,7 @@ export interface QuillFieldUi {
     /** The control the field asks for, where the shape admits more than one.
      *  `"table"` is valid only on an `array` whose `items` is an `object`.
      *  Every column is a leaf, a contract refused at load as
-     *  `quill::table_column_not_flat`. `"flat"` is valid only on an `object`
+     *  `quill::table_column_not_leaf`. `"flat"` is valid only on an `object`
      *  that is not an array's element: its properties stand at the depth of the
      *  field list around it, with no frame of their own. Either is a
      *  request: a consumer that cannot draws its own choice for the type. */
@@ -439,9 +439,16 @@ export interface QuillFieldSchema {
     variants?: Record<string, Record<string, QuillFieldSchema>>;
     /** The roster of a `type: "matrix"` field, required there and valid
      *  nowhere else: member id to display title, key order the display order.
-     *  Each member is an object of `held` plus the field's `properties`
-     *  (the columns), addressed as `<field>.<member id>.held`. */
+     *  A member is held by being present in the document, as a mapping of the
+     *  field's `properties` (the columns) or a bare `true`; unticking removes
+     *  it. Its own address `<field>.<member id>` is the tick, and each column
+     *  addresses one step further down. */
     members?: Record<string, string>;
+    /** `true` on a `type: "matrix"` field admitting items a document adds
+     *  beside the roster: each keyed by a snake_case id and carrying a
+     *  `title` string beside the columns, held by being present. Valid only
+     *  on a matrix. */
+    open?: boolean;
     ui?: QuillFieldUi;
     properties?: Record<string, QuillFieldSchema>;
     items?: QuillFieldSchema;

package/package.json

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

package/render/wasm.d.ts

@@ -394,7 +394,7 @@ export interface QuillFieldUi {
     /** The control the field asks for, where the shape admits more than one.
      *  `"table"` is valid only on an `array` whose `items` is an `object`.
      *  Every column is a leaf, a contract refused at load as
-     *  `quill::table_column_not_flat`. `"flat"` is valid only on an `object`
+     *  `quill::table_column_not_leaf`. `"flat"` is valid only on an `object`
      *  that is not an array's element: its properties stand at the depth of the
      *  field list around it, with no frame of their own. Either is a
      *  request: a consumer that cannot draws its own choice for the type. */
@@ -450,9 +450,16 @@ export interface QuillFieldSchema {
     variants?: Record<string, Record<string, QuillFieldSchema>>;
     /** The roster of a `type: "matrix"` field, required there and valid
      *  nowhere else: member id to display title, key order the display order.
-     *  Each member is an object of `held` plus the field's `properties`
-     *  (the columns), addressed as `<field>.<member id>.held`. */
+     *  A member is held by being present in the document, as a mapping of the
+     *  field's `properties` (the columns) or a bare `true`; unticking removes
+     *  it. Its own address `<field>.<member id>` is the tick, and each column
+     *  addresses one step further down. */
     members?: Record<string, string>;
+    /** `true` on a `type: "matrix"` field admitting items a document adds
+     *  beside the roster: each keyed by a snake_case id and carrying a
+     *  `title` string beside the columns, held by being present. Valid only
+     *  on a matrix. */
+    open?: boolean;
     ui?: QuillFieldUi;
     properties?: Record<string, QuillFieldSchema>;
     items?: QuillFieldSchema;

package/runtime/runtime.d.ts

@@ -423,6 +423,19 @@ export declare class Engine {
 	 */
 	open(quill: Quill, doc: Document, today?: string): Promise<LiveSession>;
 
+	/**
+	 * Load and instantiate `quill`'s backend build, reading no document and
+	 * cloning no quill. It is the memoized load `render` and `open` await, so a
+	 * host can start the fetch before it has a document to open. Only
+	 * `quill.backendId` is read, before the first await. A failed load rejects
+	 * (`runtime::backend_load_failed` for the built-ins) and the next call
+	 * retries.
+	 *
+	 * `open` snapshots its document before awaiting this load: await `load`
+	 * first, and the session's first compile is of the current document.
+	 */
+	load(quill: Quill): Promise<void>;
+
 	/**
 	 * Output formats `quill`'s backend can emit. An always-free pre-render probe:
 	 * it answers from the descriptor's `formats` manifest without loading the

package/runtime/runtime.js

@@ -553,6 +553,14 @@ export class Engine {
 		);
 	}
 
+	/**
+	 * @param {Quill} quill
+	 * @returns {Promise<void>}
+	 */
+	async load(quill) {
+		await this.#resolveBackend(this.#backendOf(quill, 'engine.load(quill)'));
+	}
+
 	/**
 	 * @param {Quill} quill
 	 * @returns {Promise<import('./runtime.js').OutputFormat[]>}