@quillmark/wasm 0.119.0 → 0.120.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 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. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.119.0",
+  "version": "0.120.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. */

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[]>}