@quillmark/wasm 0.55.0 → 0.58.2-rc.4

package/bundler/wasm_bg.js

@@ -1,135 +1,160 @@
-export class CompiledDocument {
+/**
+ * Typed in-memory Quillmark document.
+ *
+ * Created via `Document.fromMarkdown(markdown)`. Exposes:
+ * - `quillRef` (string)
+ * - `frontmatter` (JS object/Record)
+ * - `body` (string)
+ * - `cards` (array of Card objects)
+ * - `warnings` (array of Diagnostic objects)
+ *
+ * `toMarkdown()` emits canonical Quillmark Markdown that round-trips back to
+ * an equal `Document` by value and by type.
+ */
+export class Document {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(CompiledDocument.prototype);
+        const obj = Object.create(Document.prototype);
         obj.__wbg_ptr = ptr;
-        CompiledDocumentFinalization.register(obj, obj.__wbg_ptr, obj);
+        DocumentFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        CompiledDocumentFinalization.unregister(this);
+        DocumentFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_compileddocument_free(ptr, 0);
+        wasm.__wbg_document_free(ptr, 0);
     }
     /**
-     * Number of pages in this compiled document.
-     * @returns {number}
+     * Global Markdown body between frontmatter and the first card.
+     *
+     * Trailing newlines are stripped — those are structural separators in
+     * the Markdown wire format, not content the consumer wrote.
+     *
+     * Empty string when no body is present.
+     * @returns {string}
      */
-    get pageCount() {
-        const ret = wasm.compileddocument_pageCount(this.__wbg_ptr);
-        return ret >>> 0;
+    get body() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_body(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
     }
     /**
-     * Render selected pages. `pages = null/undefined` renders all pages.
-     * @param {Uint32Array | null | undefined} pages
-     * @param {RenderPagesOptions} opts
-     * @returns {RenderResult}
+     * Ordered list of card blocks as JS objects with `tag`, `fields`, and `body`.
+     * @returns {any}
      */
-    renderPages(pages, opts) {
+    get cards() {
+        const ret = wasm.document_cards(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Parse markdown into a typed Document.
+     *
+     * Returns the document with any parse-time warnings accessible via `.warnings`.
+     * Throws on parse errors.
+     * @param {string} markdown
+     * @returns {Document}
+     */
+    static fromMarkdown(markdown) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            var ptr0 = isLikeNone(pages) ? 0 : passArray32ToWasm0(pages, wasm.__wbindgen_export);
-            var len0 = WASM_VECTOR_LEN;
-            wasm.compileddocument_renderPages(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(opts));
+            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_fromMarkdown(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 takeObject(r0);
+            return Document.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-}
-if (Symbol.dispose) CompiledDocument.prototype[Symbol.dispose] = CompiledDocument.prototype.free;
-
-/**
- * Quillmark WASM Engine
- *
- * Create once, register Quills, render markdown. That's it.
- */
-export class Quillmark {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        QuillmarkFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_quillmark_free(ptr, 0);
+    /**
+     * Typed YAML frontmatter fields as a JS object (no QUILL, BODY, or CARDS keys).
+     * @returns {any}
+     */
+    get frontmatter() {
+        const ret = wasm.document_frontmatter(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-     * Compile a parsed document into an opaque compiled document handle.
-     * @param {ParsedDocument} parsed
-     * @param {CompileOptions | null} [opts]
-     * @returns {CompiledDocument}
+     * Insert a card at the given index.
+     *
+     * `index` must be in `0..=cards.length`. Out-of-range throws an `Error`.
+     *
+     * Mutators never modify `warnings`.
+     * @param {number} index
+     * @param {any} card
      */
-    compile(parsed, opts) {
+    insertCard(index, card) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quillmark_compile(retptr, this.__wbg_ptr, addHeapObject(parsed), isLikeNone(opts) ? 0 : addHeapObject(opts));
+            wasm.document_insertCard(retptr, this.__wbg_ptr, index, addHeapObject(card));
             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);
+            if (r1) {
+                throw takeObject(r0);
             }
-            return CompiledDocument.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Compile markdown to JSON data without rendering artifacts.
+     * Move the card at `from` to position `to`.
      *
-     * This exposes the intermediate data structure that would be passed to the backend.
-     * Useful for debugging and validation.
-     * @param {string} markdown
-     * @returns {any}
+     * `from == to` is a no-op. Both indices must be in `0..cards.length`.
+     * Out-of-range throws an `Error`.
+     *
+     * Mutators never modify `warnings`.
+     * @param {number} from
+     * @param {number} to
      */
-    compileData(markdown) {
+    moveCard(from, to) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.quillmark_compileData(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.document_moveCard(retptr, this.__wbg_ptr, from, to);
             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);
+            if (r1) {
+                throw takeObject(r0);
             }
-            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Perform a dry run validation without backend compilation.
+     * Append a card to the end of the card list.
      *
-     * Executes parsing, schema validation, and template composition to
-     * surface input errors quickly. Returns successfully on valid input,
-     * or throws an error with diagnostic payload on failure.
+     * `card` must be a JS object with a `tag` string field and optional
+     * `fields` (object) and `body` (string).
      *
-     * The quill name is read from the markdown's required QUILL tag.
+     * Throws an `Error` if `card.tag` is not a valid tag name.
      *
-     * This is useful for fast feedback loops in LLM-driven document generation.
-     * @param {string} markdown
+     * Mutators never modify `warnings`.
+     * @param {any} card
      */
-    dryRun(markdown) {
+    pushCard(card) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.quillmark_dryRun(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.document_pushCard(retptr, this.__wbg_ptr, addHeapObject(card));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -140,126 +165,286 @@ export class Quillmark {
         }
     }
     /**
-     * Get shallow information about a registered Quill
+     * The QUILL reference string (e.g. `"usaf_memo@0.1"`).
+     * @returns {string}
+     */
+    get quillRef() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_quillRef(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Remove the card at `index` and return it, or `undefined` if out of range.
+     *
+     * Mutators never modify `warnings`.
+     * @param {number} index
+     * @returns {any}
+     */
+    removeCard(index) {
+        const ret = wasm.document_removeCard(this.__wbg_ptr, index);
+        return takeObject(ret);
+    }
+    /**
+     * Remove a frontmatter field, returning the removed value or `undefined`.
+     *
+     * Mutators never modify `warnings`.
+     * @param {string} name
+     * @returns {any}
+     */
+    removeField(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.document_removeField(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Replace the global Markdown body.
+     *
+     * Mutators never modify `warnings`.
+     * @param {string} body
+     */
+    replaceBody(body) {
+        const ptr0 = passStringToWasm0(body, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.document_replaceBody(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Set a frontmatter field.
      *
-     * This returns metadata, backend info, field schemas, and supported formats
-     * that consumers need to configure render options for the next step.
+     * Throws an `Error` whose message includes the `EditError` variant name and
+     * details if `name` is reserved (`BODY`, `CARDS`, `QUILL`, `CARD`) or does
+     * not match `[a-z_][a-z0-9_]*`.
+     *
+     * Mutators never modify `warnings`.
      * @param {string} name
-     * @returns {QuillInfo}
+     * @param {any} value
      */
-    getQuillInfo(name) {
+    setField(name, value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.quillmark_getQuillInfo(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.document_setField(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(value));
             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);
+            if (r1) {
+                throw takeObject(r0);
             }
-            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Get the public YAML schema contract for a registered quill.
-     * @param {string} name
-     * @returns {string}
+     * Replace the QUILL reference string.
+     *
+     * Throws if `ref_str` is not a valid `QuillReference`.
+     *
+     * Mutators never modify `warnings`.
+     * @param {string} ref_str
      */
-    getQuillSchema(name) {
-        let deferred3_0;
-        let deferred3_1;
+    setQuillRef(ref_str) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(ref_str, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.quillmark_getQuillSchema(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.document_setQuillRef(retptr, this.__wbg_ptr, 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);
-            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-            var ptr2 = r0;
-            var len2 = r1;
-            if (r3) {
-                ptr2 = 0; len2 = 0;
-                throw takeObject(r2);
+            if (r1) {
+                throw takeObject(r0);
             }
-            deferred3_0 = ptr2;
-            deferred3_1 = len2;
-            return getStringFromWasm0(ptr2, len2);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
         }
     }
     /**
-     * List registered Quills with their exact versions
+     * Emit canonical Quillmark Markdown.
      *
-     * Returns strings in the format "name@version" (e.g. "resume-template@2.1.0")
-     * @returns {string[]}
+     * Returns the document serialised as a Quillmark Markdown string.
+     * The output is type-fidelity round-trip safe: re-parsing the result
+     * produces a `Document` equal to `self` by value and by type.
+     * @returns {string}
      */
-    listQuills() {
+    toMarkdown() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quillmark_listQuills(retptr, this.__wbg_ptr);
+            wasm.document_toMarkdown(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 4, 4);
-            return v1;
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * JavaScript constructor: `new Quillmark()`
+     * Replace the body of the card at `index`.
+     *
+     * Throws if `index` is out of range.
+     *
+     * Mutators never modify `warnings`.
+     * @param {number} index
+     * @param {string} body
      */
-    constructor() {
-        const ret = wasm.quillmark_new();
-        this.__wbg_ptr = ret >>> 0;
-        QuillmarkFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    updateCardBody(index, body) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(body, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_updateCardBody(retptr, this.__wbg_ptr, index, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Parse markdown into a ParsedDocument
+     * Update a field on the card at `index`.
      *
-     * This is the first step in the workflow. The returned ParsedDocument contains
-     * the parsed YAML frontmatter fields and the quill_ref from QUILL.
-     * @param {string} markdown
-     * @returns {ParsedDocument}
+     * Convenience method: equivalent to `doc.card_mut(index)?.set_field(name, value)`.
+     *
+     * Throws if `index` is out of range, `name` is reserved or invalid, or
+     * `value` cannot be serialized.
+     *
+     * Mutators never modify `warnings`.
+     * @param {number} index
+     * @param {string} name
+     * @param {any} value
      */
-    static parseMarkdown(markdown) {
+    updateCardField(index, name, value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.quillmark_parseMarkdown(retptr, ptr0, len0);
+            wasm.document_updateCardField(retptr, this.__wbg_ptr, index, ptr0, len0, addHeapObject(value));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Non-fatal parse-time warnings as a JS array of Diagnostic objects.
+     * @returns {any}
+     */
+    get warnings() {
+        const ret = wasm.document_warnings(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) Document.prototype[Symbol.dispose] = Document.prototype.free;
+
+/**
+ * Opaque, shareable Quill handle.
+ */
+export class Quill {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Quill.prototype);
+        obj.__wbg_ptr = ptr;
+        QuillFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QuillFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_quill_free(ptr, 0);
+    }
+    /**
+     * The resolved backend identifier (e.g. `"typst"`).
+     * @returns {string}
+     */
+    get backendId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quill_backendId(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Open an iterative render session for page-selective rendering.
+     * @param {Document} doc
+     * @returns {RenderSession}
+     */
+    open(doc) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(doc, Document);
+            var ptr0 = doc.__destroy_into_raw();
+            wasm.quill_open(retptr, this.__wbg_ptr, ptr0);
             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);
+            return RenderSession.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Register a Quill template bundle
+     * Project a document through this quill's schema.
      *
-     * Accepts either a JSON string or a JsValue object representing the Quill file tree.
-     * Validation happens automatically on registration.
-     * @param {any} quill_json
-     * @returns {QuillInfo}
+     * Returns a plain JS object (not a class) that is immediately
+     * `JSON.stringify`-able. The shape mirrors [`FormProjection`]:
+     *
+     * ```json
+     * {
+     *   "main":  { "schema": {...}, "values": { "field": {...} } },
+     *   "cards": [ ... ],
+     *   "diagnostics": [ ... ]
+     * }
+     * ```
+     *
+     * **Snapshot semantics.** This is a read-only snapshot of the document
+     * at call time. Subsequent edits to `doc` require calling `projectForm`
+     * again.
+     *
+     * [`FormProjection`]: quillmark::form::FormProjection
+     * @param {Document} doc
+     * @returns {any}
      */
-    registerQuill(quill_json) {
+    projectForm(doc) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quillmark_registerQuill(retptr, this.__wbg_ptr, addHeapObject(quill_json));
+            _assertClass(doc, Document);
+            wasm.quill_projectForm(retptr, this.__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);
@@ -272,17 +457,17 @@ export class Quillmark {
         }
     }
     /**
-     * Render a ParsedDocument to final artifacts (PDF, SVG, TXT)
-     *
-     * Uses the Quill specified in the ParsedDocument's quill_ref field.
-     * @param {ParsedDocument} parsed
-     * @param {RenderOptions} opts
+     * Render a document to final artifacts.
+     * @param {Document} doc
+     * @param {RenderOptions | null} [opts]
      * @returns {RenderResult}
      */
-    render(parsed, opts) {
+    render(doc, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quillmark_render(retptr, this.__wbg_ptr, addHeapObject(parsed), addHeapObject(opts));
+            _assertClass(doc, Document);
+            var ptr0 = doc.__destroy_into_raw();
+            wasm.quill_render(retptr, this.__wbg_ptr, ptr0, 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);
@@ -294,49 +479,127 @@ export class Quillmark {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+}
+if (Symbol.dispose) Quill.prototype[Symbol.dispose] = Quill.prototype.free;
+
+/**
+ * Quillmark WASM Engine
+ */
+export class Quillmark {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QuillmarkFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_quillmark_free(ptr, 0);
+    }
     /**
-     * Resolve a Quill reference to a registered Quill, or null if not available
-     *
-     * Accepts a quill reference string like "resume-template", "resume-template@2",
-     * or "resume-template@2.1.0". Returns QuillInfo if the engine can resolve it
-     * locally, or null if an external fetch is needed.
-     * @param {string} quill_ref
-     * @returns {any}
+     * JavaScript constructor: `new Quillmark()`
      */
-    resolveQuill(quill_ref) {
-        const ptr0 = passStringToWasm0(quill_ref, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.quillmark_resolveQuill(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
+    constructor() {
+        const ret = wasm.quillmark_new();
+        this.__wbg_ptr = ret >>> 0;
+        QuillmarkFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Unregister a Quill by name or specific version
+     * Load a quill from a file tree and attach the appropriate backend.
      *
-     * If a base name is provided (e.g., "my-quill"), all versions of that quill are freed.
-     * If a versioned name is provided (e.g., "my-quill@2.1.0"), only that specific version is freed.
-     * Returns true if something was unregistered, false if not found.
-     * @param {string} name_or_ref
-     * @returns {boolean}
+     * The tree must be a `Map<string, Uint8Array>`.
+     * @param {any} tree
+     * @returns {Quill}
      */
-    unregisterQuill(name_or_ref) {
-        const ptr0 = passStringToWasm0(name_or_ref, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.quillmark_unregisterQuill(this.__wbg_ptr, ptr0, len0);
-        return ret !== 0;
+    quill(tree) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quillmark_quill(retptr, this.__wbg_ptr, 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 Quill.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
 }
 if (Symbol.dispose) Quillmark.prototype[Symbol.dispose] = Quillmark.prototype.free;
 
+export class RenderSession {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RenderSession.prototype);
+        obj.__wbg_ptr = ptr;
+        RenderSessionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RenderSessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rendersession_free(ptr, 0);
+    }
+    /**
+     * Number of pages in this render session.
+     * @returns {number}
+     */
+    get pageCount() {
+        const ret = wasm.rendersession_pageCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Render all or selected pages from this session.
+     * @param {RenderOptions | null} [opts]
+     * @returns {RenderResult}
+     */
+    render(opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_render(retptr, this.__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);
+        }
+    }
+}
+if (Symbol.dispose) RenderSession.prototype[Symbol.dispose] = RenderSession.prototype.free;
+
 /**
  * Initialize the WASM module with panic hooks for better error messages
  */
 export function init() {
     wasm.init();
 }
-export function __wbg_Error_2e59b1b37a9a34c3(arg0, arg1) {
+export function __wbg_Error_960c155d3d49e4c2(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
 }
+export function __wbg_Number_32bf70a599af1d4b(arg0) {
+    const ret = Number(getObject(arg0));
+    return ret;
+}
+export function __wbg_String_8564e559799eccda(arg0, arg1) {
+    const ret = String(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
 export function __wbg_String_b51de6b05a10845b(arg0, arg1) {
     const ret = String(getObject(arg1));
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -344,64 +607,64 @@ export function __wbg_String_b51de6b05a10845b(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_bigint_get_as_i64_2c5082002e4826e2(arg0, arg1) {
+export function __wbg___wbindgen_bigint_get_as_i64_3d3aba5d616c6a51(arg0, arg1) {
     const v = getObject(arg1);
     const ret = typeof(v) === 'bigint' ? v : undefined;
     getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
 }
-export function __wbg___wbindgen_boolean_get_a86c216575a75c30(arg0) {
+export function __wbg___wbindgen_boolean_get_6ea149f0a8dcc5ff(arg0) {
     const v = getObject(arg0);
     const ret = typeof(v) === 'boolean' ? v : undefined;
     return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
 }
-export function __wbg___wbindgen_debug_string_dd5d2d07ce9e6c57(arg0, arg1) {
+export function __wbg___wbindgen_debug_string_ab4b34d23d6778bd(arg0, arg1) {
     const ret = debugString(getObject(arg1));
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
     const len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_in_4bd7a57e54337366(arg0, arg1) {
+export function __wbg___wbindgen_in_a5d8b22e52b24dd1(arg0, arg1) {
     const ret = getObject(arg0) in getObject(arg1);
     return ret;
 }
-export function __wbg___wbindgen_is_bigint_6c98f7e945dacdde(arg0) {
+export function __wbg___wbindgen_is_bigint_ec25c7f91b4d9e93(arg0) {
     const ret = typeof(getObject(arg0)) === 'bigint';
     return ret;
 }
-export function __wbg___wbindgen_is_function_49868bde5eb1e745(arg0) {
+export function __wbg___wbindgen_is_function_3baa9db1a987f47d(arg0) {
     const ret = typeof(getObject(arg0)) === 'function';
     return ret;
 }
-export function __wbg___wbindgen_is_object_40c5a80572e8f9d3(arg0) {
+export function __wbg___wbindgen_is_object_63322ec0cd6ea4ef(arg0) {
     const val = getObject(arg0);
     const ret = typeof(val) === 'object' && val !== null;
     return ret;
 }
-export function __wbg___wbindgen_is_string_b29b5c5a8065ba1a(arg0) {
+export function __wbg___wbindgen_is_string_6df3bf7ef1164ed3(arg0) {
     const ret = typeof(getObject(arg0)) === 'string';
     return ret;
 }
-export function __wbg___wbindgen_is_undefined_c0cca72b82b86f4d(arg0) {
+export function __wbg___wbindgen_is_undefined_29a43b4d42920abd(arg0) {
     const ret = getObject(arg0) === undefined;
     return ret;
 }
-export function __wbg___wbindgen_jsval_eq_7d430e744a913d26(arg0, arg1) {
+export function __wbg___wbindgen_jsval_eq_d3465d8a07697228(arg0, arg1) {
     const ret = getObject(arg0) === getObject(arg1);
     return ret;
 }
-export function __wbg___wbindgen_jsval_loose_eq_3a72ae764d46d944(arg0, arg1) {
+export function __wbg___wbindgen_jsval_loose_eq_cac3565e89b4134c(arg0, arg1) {
     const ret = getObject(arg0) == getObject(arg1);
     return ret;
 }
-export function __wbg___wbindgen_number_get_7579aab02a8a620c(arg0, arg1) {
+export function __wbg___wbindgen_number_get_c7f42aed0525c451(arg0, arg1) {
     const obj = getObject(arg1);
     const ret = typeof(obj) === 'number' ? obj : undefined;
     getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
 }
-export function __wbg___wbindgen_string_get_914df97fcfa788f2(arg0, arg1) {
+export function __wbg___wbindgen_string_get_7ed5322991caaec5(arg0, arg1) {
     const obj = getObject(arg1);
     const ret = typeof(obj) === 'string' ? obj : undefined;
     var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -409,18 +672,22 @@ export function __wbg___wbindgen_string_get_914df97fcfa788f2(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_throw_81fc77679af83bc6(arg0, arg1) {
+export function __wbg___wbindgen_throw_6b64449b9b9ed33c(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_call_7f2987183bb62793() { return handleError(function (arg0, arg1) {
+export function __wbg_call_14b169f759b26747() { return handleError(function (arg0, arg1) {
     const ret = getObject(arg0).call(getObject(arg1));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_done_547d467e97529006(arg0) {
+export function __wbg_done_9158f7cc8751ba32(arg0) {
     const ret = getObject(arg0).done;
     return ret;
 }
-export function __wbg_entries_616b1a459b85be0b(arg0) {
+export function __wbg_entries_2bf997cf82353e47(arg0) {
+    const ret = getObject(arg0).entries();
+    return addHeapObject(ret);
+}
+export function __wbg_entries_e0b73aa8571ddb56(arg0) {
     const ret = Object.entries(getObject(arg0));
     return addHeapObject(ret);
 }
@@ -435,42 +702,50 @@ export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
         wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
     }
 }
+export function __wbg_from_0dbf29f09e7fb200(arg0) {
+    const ret = Array.from(getObject(arg0));
+    return addHeapObject(ret);
+}
 export function __wbg_getRandomValues_3f44b700395062e5() { return handleError(function (arg0, arg1) {
     globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
 }, arguments); }
-export function __wbg_getTime_f6ac312467f7cf09(arg0) {
+export function __wbg_getTime_da7c55f52b71e8c6(arg0) {
     const ret = getObject(arg0).getTime();
     return ret;
 }
-export function __wbg_getUTCDate_9b73619d33527a0e(arg0) {
+export function __wbg_getUTCDate_5cd8b68e971333f7(arg0) {
     const ret = getObject(arg0).getUTCDate();
     return ret;
 }
-export function __wbg_getUTCFullYear_1c80c08b216993d4(arg0) {
+export function __wbg_getUTCFullYear_f3b3950a0ccb9165(arg0) {
     const ret = getObject(arg0).getUTCFullYear();
     return ret;
 }
-export function __wbg_getUTCMonth_ea2d5842542c5998(arg0) {
+export function __wbg_getUTCMonth_62fa72a7522ef806(arg0) {
     const ret = getObject(arg0).getUTCMonth();
     return ret;
 }
-export function __wbg_get_4848e350b40afc16(arg0, arg1) {
-    const ret = getObject(arg0)[arg1 >>> 0];
-    return addHeapObject(ret);
-}
-export function __wbg_get_ed0642c4b9d31ddf() { return handleError(function (arg0, arg1) {
+export function __wbg_get_1affdbdd5573b16a() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(getObject(arg0), getObject(arg1));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_get_unchecked_7d7babe32e9e6a54(arg0, arg1) {
+export function __wbg_get_8360291721e2339f(arg0, arg1) {
     const ret = getObject(arg0)[arg1 >>> 0];
     return addHeapObject(ret);
 }
+export function __wbg_get_unchecked_17f53dad852b9588(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+}
+export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
+    const ret = getObject(arg0)[getObject(arg1)];
+    return addHeapObject(ret);
+}
 export function __wbg_get_with_ref_key_f64427178466f623(arg0, arg1) {
     const ret = getObject(arg0)[getObject(arg1)];
     return addHeapObject(ret);
 }
-export function __wbg_instanceof_ArrayBuffer_ff7c1337a5e3b33a(arg0) {
+export function __wbg_instanceof_ArrayBuffer_7c8433c6ed14ffe3(arg0) {
     let result;
     try {
         result = getObject(arg0) instanceof ArrayBuffer;
@@ -480,7 +755,17 @@ export function __wbg_instanceof_ArrayBuffer_ff7c1337a5e3b33a(arg0) {
     const ret = result;
     return ret;
 }
-export function __wbg_instanceof_Uint8Array_4b8da683deb25d72(arg0) {
+export function __wbg_instanceof_Map_1b76fd4635be43eb(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof Map;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Uint8Array_152ba1f289edcf3f(arg0) {
     let result;
     try {
         result = getObject(arg0) instanceof Uint8Array;
@@ -490,86 +775,90 @@ export function __wbg_instanceof_Uint8Array_4b8da683deb25d72(arg0) {
     const ret = result;
     return ret;
 }
-export function __wbg_isArray_db61795ad004c139(arg0) {
+export function __wbg_isArray_c3109d14ffc06469(arg0) {
     const ret = Array.isArray(getObject(arg0));
     return ret;
 }
-export function __wbg_isSafeInteger_ea83862ba994770c(arg0) {
+export function __wbg_isSafeInteger_4fc213d1989d6d2a(arg0) {
     const ret = Number.isSafeInteger(getObject(arg0));
     return ret;
 }
-export function __wbg_iterator_de403ef31815a3e6() {
+export function __wbg_iterator_013bc09ec998c2a7() {
     const ret = Symbol.iterator;
     return addHeapObject(ret);
 }
-export function __wbg_length_0c32cb8543c8e4c8(arg0) {
+export function __wbg_length_3d4ecd04bd8d22f1(arg0) {
     const ret = getObject(arg0).length;
     return ret;
 }
-export function __wbg_length_6e821edde497a532(arg0) {
+export function __wbg_length_9f1775224cf1d815(arg0) {
     const ret = getObject(arg0).length;
     return ret;
 }
-export function __wbg_new_0_bfa2ef4bc447daa2() {
+export function __wbg_new_0_4d657201ced14de3() {
     const ret = new Date();
     return addHeapObject(ret);
 }
-export function __wbg_new_0f6d2ddfe083319b(arg0) {
-    const ret = new Date(getObject(arg0));
+export function __wbg_new_0c7403db6e782f19(arg0) {
+    const ret = new Uint8Array(getObject(arg0));
     return addHeapObject(ret);
 }
 export function __wbg_new_227d7c05414eb861() {
     const ret = new Error();
     return addHeapObject(ret);
 }
-export function __wbg_new_4f9fafbb3909af72() {
-    const ret = new Object();
-    return addHeapObject(ret);
-}
-export function __wbg_new_99cabae501c0a8a0() {
+export function __wbg_new_34d45cc8e36aaead() {
     const ret = new Map();
     return addHeapObject(ret);
 }
-export function __wbg_new_a560378ea1240b14(arg0) {
-    const ret = new Uint8Array(getObject(arg0));
+export function __wbg_new_5e360d2ff7b9e1c3(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
 }
-export function __wbg_new_f3c9df4f38f3f798() {
+export function __wbg_new_682678e2f47e32bc() {
     const ret = new Array();
     return addHeapObject(ret);
 }
-export function __wbg_next_01132ed6134b8ef5(arg0) {
-    const ret = getObject(arg0).next;
+export function __wbg_new_7913666fe5070684(arg0) {
+    const ret = new Date(getObject(arg0));
     return addHeapObject(ret);
 }
-export function __wbg_next_b3713ec761a9dbfd() { return handleError(function (arg0) {
+export function __wbg_new_aa8d0fa9762c29bd() {
+    const ret = new Object();
+    return addHeapObject(ret);
+}
+export function __wbg_next_0340c4ae324393c3() { return handleError(function (arg0) {
     const ret = getObject(arg0).next();
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_now_88621c9c9a4f3ffc() {
+export function __wbg_next_7646edaa39458ef7(arg0) {
+    const ret = getObject(arg0).next;
+    return addHeapObject(ret);
+}
+export function __wbg_now_a9b7df1cbee90986() {
     const ret = Date.now();
     return ret;
 }
-export function __wbg_parse_545d11396395fbbd() { return handleError(function (arg0, arg1) {
-    const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
-    return addHeapObject(ret);
-}, arguments); }
-export function __wbg_prototypesetcall_3e05eb9545565046(arg0, arg1, arg2) {
+export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 }
-export function __wbg_set_08463b1df38a7e29(arg0, arg1, arg2) {
-    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
-    return addHeapObject(ret);
+export function __wbg_set_022bee52d0b05b19() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+    return ret;
+}, arguments); }
+export function __wbg_set_3bf1de9fab0cd644(arg0, arg1, arg2) {
+    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
 }
 export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
     getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
 }
-export function __wbg_set_6c60b2e8ad0e9383(arg0, arg1, arg2) {
-    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
-}
 export function __wbg_set_f071dbb3bd088e0e(arg0, arg1, arg2) {
     getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
 }
+export function __wbg_set_fde2cec06c23692b(arg0, arg1, arg2) {
+    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+}
 export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     const ret = getObject(arg1).stack;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -577,11 +866,7 @@ export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_stringify_a2c39d991e1bf91d() { return handleError(function (arg0) {
-    const ret = JSON.stringify(getObject(arg0));
-    return addHeapObject(ret);
-}, arguments); }
-export function __wbg_value_7f6052747ccf940f(arg0) {
+export function __wbg_value_ee3a06f4579184fa(arg0) {
     const ret = getObject(arg0).value;
     return addHeapObject(ret);
 }
@@ -612,12 +897,18 @@ export function __wbindgen_object_clone_ref(arg0) {
 export function __wbindgen_object_drop_ref(arg0) {
     takeObject(arg0);
 }
-const CompiledDocumentFinalization = (typeof FinalizationRegistry === 'undefined')
+const DocumentFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_compileddocument_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_document_free(ptr >>> 0, 1));
+const QuillFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_quill_free(ptr >>> 0, 1));
 const QuillmarkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_quillmark_free(ptr >>> 0, 1));
+const RenderSessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rendersession_free(ptr >>> 0, 1));
 
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);
@@ -628,6 +919,12 @@ function addHeapObject(obj) {
     return idx;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -699,16 +996,6 @@ function dropObject(idx) {
     heap_next = idx;
 }
 
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(takeObject(mem.getUint32(i, true)));
-    }
-    return result;
-}
-
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -727,14 +1014,6 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
-let cachedUint32ArrayMemory0 = null;
-function getUint32ArrayMemory0() {
-    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
-        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
-    }
-    return cachedUint32ArrayMemory0;
-}
-
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -762,13 +1041,6 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-function passArray32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getUint32ArrayMemory0().set(arg, ptr / 4);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);