@quillmark/wasm 0.88.0 → 0.90.0

package/{bundler → backends/typst}/wasm_bg.js

@@ -229,8 +229,8 @@ export class Document {
      * insertion order); `body` defaults to `""`. Kind validity is checked by
      * `pushCard` / `insertCard`, not here.
      * @param {string} kind
-     * @param {Record<string, unknown>} fields
-     * @param {string | null} [body]
+     * @param {Record<string, unknown>} [fields]
+     * @param {string} [body]
      * @returns {Card}
      */
     static makeCard(kind, fields, body) {
@@ -798,7 +798,9 @@ export class Quill {
         wasm.__wbg_quill_free(ptr, 0);
     }
     /**
-     * The resolved backend identifier (e.g. `"typst"`).
+     * The *declared* backend identifier (`config.backend`, e.g. `"typst"`).
+     * Intent, not a resolved capability — capability (`supportedFormats` /
+     * `supportsCanvas`) is read from the engine.
      * @returns {string}
      */
     get backendId() {
@@ -837,54 +839,41 @@ export class Quill {
         }
     }
     /**
-     * Identity snapshot of the `quill:` section of `Quill.yaml`, plus
-     * `supportedFormats` and any extra `quill:` keys.
-     * @returns {QuillMetadata}
-     */
-    get metadata() {
-        const ret = wasm.quill_metadata(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-     * @param {Document} doc
-     * @returns {RenderSession}
+     * Build a quill from a file tree. Pure — no backend, no engine; the
+     * declared backend is resolved later, at render time.
+     *
+     * Accepts either a `Map<string, Uint8Array>` or a plain object
+     * (`Record<string, Uint8Array>`). Plain objects are walked via
+     * `Object.entries` at the boundary; the Rust side sees a single
+     * canonical shape.
+     * @param {Map<string, Uint8Array>} tree
+     * @returns {Quill}
      */
-    open(doc) {
+    static fromTree(tree) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(doc, Document);
-            wasm.quill_open(retptr, this.__wbg_ptr, doc.__wbg_ptr);
+            wasm.quill_fromTree(retptr, addHeapObject(tree));
             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 RenderSession.__wrap(r0);
+            return Quill.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * @param {Document} doc
-     * @param {RenderOptions | null} [opts]
-     * @returns {RenderResult}
+     * Identity snapshot of the `quill:` section of `Quill.yaml` plus any extra
+     * `quill:` keys. Pure config — the backend's output formats are a
+     * resolved-backend capability read from the engine
+     * (`Quillmark.supportedFormats`), not part of this snapshot.
+     * @returns {QuillMetadata}
      */
-    render(doc, opts) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(doc, Document);
-            wasm.quill_render(retptr, this.__wbg_ptr, doc.__wbg_ptr, isLikeNone(opts) ? 0 : addHeapObject(opts));
-            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);
-        }
+    get metadata() {
+        const ret = wasm.quill_metadata(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
      * Document schema for the quill: the user-fillable fields plus their
@@ -937,14 +926,21 @@ export class Quill {
         return takeObject(ret);
     }
     /**
-     * `true` iff `RenderSession.paint` and `RenderSession.pageSize` will
-     * succeed for sessions opened by this quill. Use as a precondition
-     * probe before mounting a canvas-based preview UI.
-     * @returns {boolean}
+     * Flatten this quill back into its canonical file tree — the inverse of
+     * [`fromTree`](Self::from_tree). Round-trips: `Quill.fromTree(q.toTree())`
+     * reproduces an equivalent quill.
+     *
+     * This is how a quill crosses a WASM linear-memory boundary as data: a
+     * `Quill` built in one build (e.g. the Typst-less `@quillmark/wasm/core`)
+     * cannot be passed to an engine in another (separate linear memories), so
+     * `@quillmark/wasm/runtime` re-feeds this tree to the backend build's
+     * `Quill.fromTree` on demand. Keys are `"/"`-joined relative paths,
+     * matching what `fromTree` accepts.
+     * @returns {Map<string, Uint8Array>}
      */
-    get supportsCanvas() {
-        const ret = wasm.quill_supportsCanvas(this.__wbg_ptr);
-        return ret !== 0;
+    toTree() {
+        const ret = wasm.quill_toTree(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
      * Validate `doc` against this quill's schema, returning every diagnostic
@@ -978,6 +974,10 @@ export class Quill {
 }
 if (Symbol.dispose) Quill.prototype[Symbol.dispose] = Quill.prototype.free;
 
+/**
+ * Render engine: a backend registry and render dispatcher. Render build only —
+ * the core build constructs and validates quills without it.
+ */
 export class Quillmark {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -996,30 +996,89 @@ export class Quillmark {
         return this;
     }
     /**
-     * Load a quill from a file tree and attach the appropriate backend.
-     *
-     * Accepts either a `Map<string, Uint8Array>` or a plain object
-     * (`Record<string, Uint8Array>`). Plain objects are walked via
-     * `Object.entries` at the boundary; the Rust side sees a single
-     * canonical shape.
-     * @param {Map<string, Uint8Array>} tree
-     * @returns {Quill}
+     * Open an iterative render session for `doc` against `quill`'s backend.
+     * @param {Quill} quill
+     * @param {Document} doc
+     * @returns {RenderSession}
      */
-    quill(tree) {
+    open(quill, doc) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quillmark_quill(retptr, this.__wbg_ptr, addHeapObject(tree));
+            _assertClass(quill, Quill);
+            _assertClass(doc, Document);
+            wasm.quillmark_open(retptr, this.__wbg_ptr, quill.__wbg_ptr, doc.__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 Quill.__wrap(r0);
+            return RenderSession.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Render `doc` against `quill` in one shot. Convenience over `open` +
+     * `RenderSession.render`: an unset `output_format` falls back to the
+     * backend's first supported format.
+     * @param {Quill} quill
+     * @param {Document} doc
+     * @param {RenderOptions | null} [opts]
+     * @returns {RenderResult}
+     */
+    render(quill, doc, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            _assertClass(doc, Document);
+            wasm.quillmark_render(retptr, this.__wbg_ptr, quill.__wbg_ptr, doc.__wbg_ptr, isLikeNone(opts) ? 0 : addHeapObject(opts));
+            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);
+        }
+    }
+    /**
+     * The output formats `quill`'s backend can emit. Static capability —
+     * resolves the backend but compiles nothing. Throws `UnsupportedBackend`
+     * if no registered backend matches the quill's declared backend.
+     * @param {Quill} quill
+     * @returns {OutputFormat[]}
+     */
+    supportedFormats(quill) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            wasm.quillmark_supportedFormats(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);
+        }
+    }
+    /**
+     * `true` iff `quill`'s backend can paint sessions to a canvas. Asked of
+     * the real backend; `false` when the backend is unsupported or non-canvas.
+     * Use as a precondition probe before mounting a canvas-based preview UI.
+     * @param {Quill} quill
+     * @returns {boolean}
+     */
+    supportsCanvas(quill) {
+        _assertClass(quill, Quill);
+        const ret = wasm.quillmark_supportsCanvas(this.__wbg_ptr, quill.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 if (Symbol.dispose) Quillmark.prototype[Symbol.dispose] = Quillmark.prototype.free;
 
@@ -1146,7 +1205,8 @@ export class RenderSession {
         }
     }
     /**
-     * `true` iff `paint` and `pageSize` will succeed for this session.
+     * `true` iff `paint` and `pageSize` will succeed for this session. The
+     * backend's canvas capability, captured at open time.
      * @returns {boolean}
      */
     get supportsCanvas() {
@@ -1455,6 +1515,10 @@ export function __wbg_new_aa8d0fa9762c29bd() {
     const ret = new Object();
     return addHeapObject(ret);
 }
+export function __wbg_new_from_slice_b5ea43e23f6008c0(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+}
 export function __wbg_new_with_u8_clamped_array_and_sh_fe957411824b5158() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0, arg3 >>> 0);
     return addHeapObject(ret);

package/{bundler → backends/typst}/wasm_bg.wasm.d.ts

@@ -48,17 +48,19 @@ export const document_warnings: (a: number) => number;
 export const init: () => void;
 export const quill_backendId: (a: number, b: number) => void;
 export const quill_blueprint: (a: number, b: number) => void;
+export const quill_fromTree: (a: number, b: 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_schema: (a: number) => number;
 export const quill_seedCard: (a: number, b: number, c: number) => number;
 export const quill_seedDocument: (a: number) => number;
 export const quill_seedMain: (a: number) => number;
-export const quill_supportsCanvas: (a: number) => number;
+export const quill_toTree: (a: number) => number;
 export const quill_validate: (a: number, b: number, c: number) => void;
 export const quillmark_new: () => number;
-export const quillmark_quill: (a: number, b: number, c: number) => void;
+export const quillmark_open: (a: number, b: number, c: number, d: number) => void;
+export const quillmark_render: (a: number, b: number, c: number, d: number, e: number) => void;
+export const quillmark_supportedFormats: (a: number, b: number, c: number) => void;
+export const quillmark_supportsCanvas: (a: number, b: number) => number;
 export const rendersession_backendId: (a: number, b: number) => void;
 export const rendersession_pageCount: (a: number) => number;
 export const rendersession_pageSize: (a: number, b: number, c: number) => void;