@docmentis/udoc-wasm 0.0.0-stage → 0.8.1

package/dist/wasm/udoc.js

@@ -0,0 +1,4600 @@
+/* @ts-self-types="./udoc.d.ts" */
+
+/**
+ * A font specimen returned by
+ * [`renderFontPreview`](WasmSession::render_font_preview): a PNG whose **alpha
+ * is the glyph coverage** (the color is flat black and carries nothing), plus
+ * the CSS box to draw it in.
+ *
+ * The host wraps the bytes in a `Blob`, points a CSS `mask-image` at the object
+ * URL, and gives the element `background: currentColor` — the specimen then
+ * inherits the theme's text color, and a light/dark switch needs no redraw. The
+ * PNG is rendered at the device pixel ratio behind [`width`](Self::width) ×
+ * [`height`](Self::height), so a mask sized to that box is sharp on a retina
+ * display.
+ */
+export class FontPreviewImage {
+    static __wrap(ptr) {
+        const obj = Object.create(FontPreviewImage.prototype);
+        obj.__wbg_ptr = ptr;
+        FontPreviewImageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FontPreviewImageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fontpreviewimage_free(ptr, 0);
+    }
+    /**
+     * The transparent bleed baked into **every side**, in CSS px.
+     *
+     * The raster's left edge sits one of these left of where the pen started,
+     * because the box is grown all round to hold ink that overhangs the
+     * advances (an italic's ascender, a script face's tail). A host laying the
+     * specimen beside ordinary text at the same em offsets by `-bleed`, which
+     * puts the two pen origins in the same place.
+     * @returns {number}
+     */
+    get bleed() {
+        const ret = wasm.fontpreviewimage_bleed(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The specimen's height in **CSS px** — the box, not the PNG's pixels.
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.fontpreviewimage_height(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Take the PNG bytes, leaving the image empty — call once. Moving avoids
+     * cloning the buffer before it crosses the wasm boundary as a
+     * `Uint8Array`.
+     * @returns {Uint8Array}
+     */
+    takePng() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fontpreviewimage_takePng(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The specimen's width in **CSS px** — the box, not the PNG's pixels.
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.fontpreviewimage_width(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) FontPreviewImage.prototype[Symbol.dispose] = FontPreviewImage.prototype.free;
+
+/**
+ * A rasterized page image returned by
+ * [`renderPageToRgba`](WasmSession::render_page_to_rgba): premultiplied RGBA8
+ * bytes (`width * height * 4`, row-major, Y-down, tightly packed) plus the
+ * pixel dimensions the renderer chose. The host reads `width`/`height`, pulls
+ * the pixels once via [`takeData`](PageImage::take_data) (which moves them out
+ * — call once), wraps them in an `ImageData`, and `createImageBitmap`s it.
+ */
+export class PageImage {
+    static __wrap(ptr) {
+        const obj = Object.create(PageImage.prototype);
+        obj.__wbg_ptr = ptr;
+        PageImageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PageImageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pageimage_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.pageimage_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Take the premultiplied RGBA8 pixels, leaving the image empty — call
+     * once. Moving avoids cloning the (sizable) buffer before it crosses the
+     * wasm boundary as a `Uint8Array`.
+     * @returns {Uint8Array}
+     */
+    takeData() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pageimage_takeData(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.pageimage_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) PageImage.prototype[Symbol.dispose] = PageImage.prototype.free;
+
+/**
+ * The wasm-facing session host: owns the document [`UDocSession`] and its
+ * canvas, and forwards the worker's resize/scroll/zoom intents. See the
+ * module docs.
+ */
+export class WasmSession {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmSession.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSessionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsession_free(ptr, 0);
+    }
+    /**
+     * Follow `destination` — an outline item's or a link's: a named one
+     * resolves through the document's named destinations, the target page
+     * composes ahead, and the view lands as its view asks (§12.3.2, Table 149),
+     * each zoom set once for that page — the point a view lands, by
+     * `alignment` (`"top"`, the spec's own landing, `"center"`, `"bottom"` or
+     * `"nearest"`). Returns the view it landed by — a named
+     * destination's, resolved — so the host can tell whether the zoom was set;
+     * `undefined` for a name the document doesn't define or a page no longer
+     * in it. The resulting zoom and scroll ride back in the next
+     * [`view_state`](Self::view_state); the repaint happens on the next
+     * [`render_frame`](Self::render_frame).
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF,
+     * `destination` isn't a `Destination`, or `alignment` isn't one of the
+     * four names.
+     * @param {Destination} destination
+     * @param {ScrollAlignment} alignment
+     * @returns {DestinationView | undefined}
+     */
+    __portable_goToDestination(destination, alignment) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___portable_goToDestination(retptr, this.__wbg_ptr, addBorrowedObject(destination), addBorrowedObject(alignment));
+            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);
+            heap[stack_pointer++] = undefined;
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Run a hide action: hide each of `targets` — a hide action's `/T` — or
+     * show it where `hide` is `false`. Which annotations hide actions have
+     * hidden or shown is session state, held over their own flags as a
+     * layer's is; the composed pages recompose and repaint. Returns whether
+     * any annotation changed.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, or `targets`
+     * isn't a list of hide targets.
+     * @param {ActionHideTarget[]} targets
+     * @param {boolean} hide
+     * @returns {boolean}
+     */
+    __portable_hideAnnotations(targets, hide) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(targets, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession___portable_hideAnnotations(retptr, this.__wbg_ptr, ptr0, len0, hide);
+            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 r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serialize the annotation `annotation` on the model **page** `page` —
+     * both 32-char hex keys — or `undefined` when the page's annotations part
+     * doesn't list it. Loaded on first read, whether or not the page has
+     * composed — hence `&mut self`. The value a host builds an
+     * `UpdateAnnotations` command from: it reads an annotation here, changes
+     * what it edits, and sends the annotation back. A dump: the annotation
+     * whole, its appearance's artwork included.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, a key is not
+     * valid, the page's annotations part or the annotation fails to load, or
+     * serialization fails.
+     * @param {string} page
+     * @param {string} annotation
+     * @returns {Annotation | undefined}
+     */
+    __portable_model__page__annotation_dump(page, annotation) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(page, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(annotation, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.wasmsession___portable_model__page__annotation_dump(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            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 rich contents of the annotation `annotation` on the model **page**
+     * `page` — both 32-char hex keys — as XHTML (`Annotation::rich_contents`):
+     * its `/RC` as the file wrote it or an edit set it, else its `/Contents`
+     * a paragraph a line. `undefined` when the page's annotations part doesn't
+     * list it, or it isn't loaded. What a host's comment popup shows, and
+     * edits into a `SetAnnotationRichContents` command.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, or a key is
+     * not valid.
+     * @param {string} page
+     * @param {string} annotation
+     * @returns {string | undefined}
+     */
+    __portable_model__page__annotation_richContents(page, annotation) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(page, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(annotation, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.wasmsession___portable_model__page__annotation_richContents(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            let v3;
+            if (r0 !== 0) {
+                v3 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serialize the annotations part of the model **page** named by `id` (its
+     * 32-char hex key) — its `PageAnnotationList`: the ids of its annotations, in
+     * paint order — or `undefined` for a page not in the document. The part is
+     * reached through the page's `Page::annotations`, the page and the part
+     * loaded on first read, whether or not the page has composed — hence
+     * `&mut self` — so a host can list a document's comments without composing
+     * its pages, reading each through
+     * [`annotation(id).dump`](Self::__portable_model__page__annotation_dump).
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, `id` is not a
+     * valid key, the part fails to load, or serialization fails.
+     * @param {string} id
+     * @returns {PageAnnotationList | undefined}
+     */
+    __portable_model__page_annotations_dump(id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession___portable_model__page_annotations_dump(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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serialize the portable document's **interactive form** — the catalog's
+     * `/AcroForm`: its terminal fields, each with its name, its type, its
+     * value and its widgets' ids — as JSON. Loaded on first read, hence
+     * `&mut self`; a document with no form gives one with no fields. A dump:
+     * the whole part, which a host reads to find the field a widget belongs
+     * to, and fills in with a `FillAcroFormFields` command.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, the form
+     * fails to load, or serialization fails.
+     * @returns {AcroForm}
+     */
+    __portable_model_acroForm_dump() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___portable_model_acroForm_dump(retptr, this.__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);
+        }
+    }
+    /**
+     * Serialize the portable document's **font list** — every font it has,
+     * each with its id, `/BaseFont`, type, and whether it is embedded, a subset
+     * or one of the standard 14 — as JSON. Walked on first read, hence
+     * `&mut self`; a font an edit added is in it too. A dump: the whole list,
+     * which a host reads to find the font a free text's `/DA` names before
+     * adding one with an `AddStandardFont` command.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, the font list
+     * fails to load, or serialization fails.
+     * @returns {FontInfoList}
+     */
+    __portable_model_fontInfoList_dump() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___portable_model_fontInfoList_dump(retptr, this.__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);
+        }
+    }
+    /**
+     * Serialize the portable document's **optional content properties** —
+     * the catalog's `/OCProperties`: every group (its id, and the name a layers
+     * panel labels it with) and the configurations, the default one's `order`
+     * being the tree the panel shows. Loaded on
+     * first read, hence `&mut self`; a document with no layers gives no groups.
+     * A dump: the whole part.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, the
+     * properties fail to load, or serialization fails.
+     * @returns {OptionalContentProperties}
+     */
+    __portable_model_optionalContentProperties_dump() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___portable_model_optionalContentProperties_dump(retptr, this.__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);
+        }
+    }
+    /**
+     * Serialize the portable document's **outline** — its bookmarks, the
+     * catalog's `/Outlines` — as JSON: every item with its title, action or
+     * destination, colour, style, open state and children. The part is loaded
+     * on first read, hence `&mut self`; a document with no outline gives one
+     * with no items. A dump: the whole tree.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, the outline
+     * fails to load, or serialization fails.
+     * @returns {Outline}
+     */
+    __portable_model_outline_dump() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___portable_model_outline_dump(retptr, this.__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);
+        }
+    }
+    /**
+     * Serialize the portable document's whole **catalog** — each page's id,
+     * media box, rotation and annotations part — as JSON. One entry per page,
+     * so it grows with the document: a dump for looking inside, where a lookup
+     * is [`portable.model.root.pageIdByIndex`](Self::__portable_model_root_pageIdByIndex)
+     * / [`pageIndexById`](Self::__portable_model_root_pageIndexById).
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, or
+     * serialization fails.
+     * @returns {Catalog}
+     */
+    __portable_model_root_dump() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___portable_model_root_dump(retptr, this.__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);
+        }
+    }
+    /**
+     * The id (hex key) of the page at `index`, or `undefined` past the last
+     * page — how the host turns the page index it works in into the id an
+     * id-addressed command or selection takes.
+     *
+     * # Errors
+     * Returns a JS error if no document is open or it isn't a PDF.
+     * @param {number} index
+     * @returns {string | undefined}
+     */
+    __portable_model_root_pageIdByIndex(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___portable_model_root_pageIdByIndex(retptr, this.__wbg_ptr, index);
+            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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The ids (hex keys) of the portable document's pages, in page order — the
+     * page list.
+     *
+     * # Errors
+     * Returns a JS error if no document is open or it isn't a PDF.
+     * @returns {string[]}
+     */
+    __portable_model_root_pageIds() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___portable_model_root_pageIds(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The index of the page named by `id` (its hex key), or `undefined` for a
+     * page not in the document — the reverse of
+     * [`portable.model.root.pageIdByIndex`](Self::__portable_model_root_pageIdByIndex).
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, or `id` is not
+     * a valid key.
+     * @param {string} id
+     * @returns {number | undefined}
+     */
+    __portable_model_root_pageIndexById(id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession___portable_model_root_pageIndexById(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getFloat64(retptr + 8 * 0, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            return r0 === Number.MAX_SAFE_INTEGER ? undefined : r0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The document's `/PageMode` — how it asks to be shown when it opens: the
+     * outline, the thumbnails, full screen, … — or `undefined` when the file
+     * gives none, which reads as `UseNone`.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, or
+     * serialization fails.
+     * @returns {PageMode | undefined}
+     */
+    __portable_model_root_pageMode() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___portable_model_root_pageMode(retptr, this.__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);
+        }
+    }
+    /**
+     * The ids (hex keys) of the optional content groups that are **OFF** now;
+     * every other group is ON. Starts from the default configuration when the
+     * document opens and changes with
+     * [`portable.setOptionalContentGroupOn`](Self::__portable_setOptionalContentGroupOn).
+     *
+     * # Errors
+     * Returns a JS error if no document is open or it isn't a PDF.
+     * @returns {string[]}
+     */
+    __portable_optionalContentOff() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___portable_optionalContentOff(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Switch the optional content group `id` (its hex key) ON or OFF, as a
+     * layers panel does: a locked group doesn't switch, and turning one ON
+     * turns the others of its radio groups OFF. The composed pages recompose
+     * and repaint. Returns whether any group changed.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a PDF, or `id` is
+     * not a valid key.
+     * @param {string} id
+     * @param {boolean} on
+     * @returns {boolean}
+     */
+    __portable_setOptionalContentGroupOn(id, on) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession___portable_setOptionalContentGroupOn(retptr, this.__wbg_ptr, ptr0, len0, on);
+            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 r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The elements of page `index` on the current plane that play media, each
+     * with its box in page-local points — what the host lays its players over.
+     * Empty for a page not composed, or one that plays nothing.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a presentation, or
+     * serialization fails.
+     * @param {number} index
+     * @returns {ComposedShapeMedia[]}
+     */
+    __presentation_layout__page_media(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___presentation_layout__page_media(retptr, this.__wbg_ptr, index);
+            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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The bytes of the media file `id` (a 32-char hex key) — the audio or
+     * video a player plays, as an element's `media.data` names it. Loaded on
+     * first read, the one part alone, hence `&mut self`.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a presentation, the
+     * key is not valid, or the part fails to load.
+     * @param {string} id
+     * @returns {Uint8Array}
+     */
+    __presentation_model__mediaData_bytes(id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession___presentation_model__mediaData_bytes(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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The content type of the media file `id` (a 32-char hex key), as the
+     * package declared it — `video/mp4`, `audio/mp4`, … — which the host
+     * hands its player with [the bytes](Self::__presentation_model__mediaData_bytes).
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a presentation, the
+     * key is not valid, or the part fails to load.
+     * @param {string} id
+     * @returns {string}
+     */
+    __presentation_model__mediaData_contentType(id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession___presentation_model__mediaData_contentType(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);
+            }
+            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);
+        }
+    }
+    /**
+     * Every slide master, in `p:sldMasterIdLst` order, as a
+     * [`SlideMasterSummary`] — the roster the New-Slide picker enumerates.
+     * Ensures every slide master (loading it to learn its slide layouts), so
+     * the picker offers unused slide layouts too, and every slide layout, for
+     * its name — the ones the picker then renders a thumbnail of anyway —
+     * hence `&mut self`.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a presentation, or
+     * serialization fails.
+     * @returns {SlideMasterSummary[]}
+     */
+    __presentation_model_slideMasters_summary() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___presentation_model_slideMasters_summary(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Load the sheet at tab position `plane` without showing it, so
+     * [`planeTabColor`](Self::plane_tab_color) can read its tab's colour —
+     * what the host's background walk over the sheets calls, one sheet a call.
+     * Returns whether the sheet is loaded: `false` past the last sheet, or for
+     * one that failed to load.
+     *
+     * # Errors
+     * Returns a JS error if no document is open or it isn't a spreadsheet.
+     * @param {number} plane
+     * @returns {boolean}
+     */
+    __spreadsheet_loadSheet(plane) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___spreadsheet_loadSheet(retptr, this.__wbg_ptr, plane);
+            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 r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The id (hex key) of the sheet at tab position `index`, or `undefined`
+     * past the last sheet — how the host turns the plane it works in (a plane
+     * is a sheet, in tab order) into the id an id-addressed command takes.
+     *
+     * # Errors
+     * Returns a JS error if no document is open or it isn't a spreadsheet.
+     * @param {number} index
+     * @returns {string | undefined}
+     */
+    __spreadsheet_model_root_sheetIdByIndex(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession___spreadsheet_model_root_sheetIdByIndex(retptr, this.__wbg_ptr, index);
+            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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Follow a link to bookmark `name` (`w:hyperlink@w:anchor`): the view
+     * lands on the bookmark's start, the point placed by `alignment`
+     * (`"top"`, `"center"`, `"bottom"` or `"nearest"`) — or on the document's
+     * start where no bookmark has the name, which is where ECMA-376 §17.16.22
+     * has such a link go. The resulting scroll rides back in the next
+     * [`view_state`](Self::view_state); the repaint happens on the next
+     * [`render_frame`](Self::render_frame).
+     *
+     * # Errors
+     * Returns a JS error if no document is open, it isn't a word-processing
+     * document, `alignment` isn't one of the four names, or laying the
+     * document out to the bookmark fails.
+     * @param {string} name
+     * @param {ScrollAlignment} alignment
+     */
+    __wordprocessing_goToBookmark(name, alignment) {
+        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.wasmsession___wordprocessing_goToBookmark(retptr, this.__wbg_ptr, ptr0, len0, addBorrowedObject(alignment));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Attach the (already transferred) `OffscreenCanvas` this session paints
+     * into — the browser viewport path. A headless host never calls this.
+     *
+     * # Errors
+     * Returns a JS error if a 2D context can't be obtained.
+     * @param {OffscreenCanvas} canvas
+     */
+    attach(canvas) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_attach(retptr, this.__wbg_ptr, addHeapObject(canvas));
+            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);
+        }
+    }
+    /**
+     * Unlock the document that [`needsPassword`](Self::needs_password) with
+     * `password` — its user or its owner password. Returns `true` once it is
+     * open, the host then pulling the layout as after [`open`](Self::open),
+     * and `false` when `password` is rejected, the document waiting for
+     * another.
+     *
+     * Not a second open: the document was opened, and this session's permit
+     * spent, by [`open`](Self::open).
+     *
+     * # Errors
+     * Returns a JS error if no document is open, its encryption is one this
+     * build can't unlock, or it fails to open once unlocked.
+     * @param {string} password
+     * @returns {boolean}
+     */
+    authenticate(password) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(password, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_authenticate(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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The brand decal's CSS-px rect as `[x, y, width, height]`, or empty before
+     * a viewport is known. Screen-fixed (bottom-right), so it changes only with
+     * the viewport size, density, or [inset](Self::set_branding_inset) — the
+     * host places a click target over it for the attribution link. The same box
+     * [`render_frame`](Self::render_frame) paints the mark into.
+     * @returns {Float64Array}
+     */
+    brandingRect() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_brandingRect(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Whether a [`redo`](Self::redo) would do anything (see
+     * [`canUndo`](Self::can_undo)).
+     * @returns {boolean}
+     */
+    canRedo() {
+        const ret = wasm.wasmsession_canRedo(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether an [`undo`](Self::undo) would do anything — the host's cue to
+     * enable/disable its undo control. `false` when no document is open or the
+     * doc type has no undo stack. The worker re-reads this after every edit and
+     * pushes it to the host (see the `history` report).
+     * @returns {boolean}
+     */
+    canUndo() {
+        const ret = wasm.wasmsession_canUndo(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Stop drawing the page border — what a host does when the pages touch,
+     * where the frame would only rule a line between them. Remembered across
+     * [`open`](Self::open) like the color, and applied to the current document
+     * immediately; the next [`render_frame`](Self::render_frame) repaints
+     * without it. [`setPageBorderColor`](Self::set_page_border_color) draws it
+     * again.
+     */
+    clearPageBorder() {
+        wasm.wasmsession_clearPageBorder(this.__wbg_ptr);
+    }
+    /**
+     * Delete this peer's pointer — the pointer left the view, or sharing it
+     * stopped. Returns the blob carrying the deletion, as
+     * [`setPointer`](Self::set_pointer) does.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or serialization fails.
+     * @returns {Uint8Array}
+     */
+    clearPointer() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_clearPointer(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Clear the selection, returning the (empty) geometry.
+     *
+     * # Errors
+     * Returns a JS error only if the new geometry can't be serialized — never
+     * in practice for these plain page-anchored boxes.
+     * @returns {SelectionGeometry}
+     */
+    clearSelection() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_clearSelection(retptr, this.__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);
+        }
+    }
+    /**
+     * Release the open document — its model, composed layout, editor, and
+     * viewer all go with it — keeping the canvas attached.
+     *
+     * This does **not** free the session for another document: its permit was
+     * spent on the document being released, so [`open`](Self::open) stays
+     * refused afterwards. Closing is how a host clears the screen while
+     * keeping the canvas it transferred; the next file needs a new session.
+     *
+     * Clears the canvas on the way out: the painted pixels belong to the
+     * document being released, and [`renderFrame`](Self::render_frame) has
+     * nothing to draw without a session, so without this the closed document
+     * would stay on screen.
+     */
+    close() {
+        wasm.wasmsession_close(this.__wbg_ptr);
+    }
+    /**
+     * Settle order `id` with the binaries fetched for it — **`[]` means "I have
+     * nothing"**, and either way that this order is finished.
+     *
+     * A 404, a css2 response with no covering block, and giving up after three
+     * retries are the same event: those characters are recorded as unavailable
+     * from that vendor and the next layout tries the next one down the chain. To
+     * retry instead, simply don't call this until you have stopped trying — the
+     * order stays open and the document renders in the stand-in meanwhile.
+     *
+     * Returns whether `id` named a live order; `false` for a stale one (a
+     * doc-type switch rebuilt the session while the fetch was out), which is
+     * exactly when there is nothing to re-render.
+     * @param {bigint} id
+     * @param {Uint8Array[]} binaries
+     * @returns {boolean}
+     */
+    completeFontRequest(id, binaries) {
+        const ptr0 = passArrayJsValueToWasm0(binaries, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsession_completeFontRequest(this.__wbg_ptr, id, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * How many pages have been composed so far. Grows as composition advances
+     * (see [`updateLayout`](Self::update_layout)) and changes on a
+     * page-inserting or -deleting edit, so the host re-pulls it after either.
+     * It is the document's page count once `updateLayout` reports complete.
+     * `0` when no document is open or the doc type has no pagination. The
+     * companion content extent rides the per-frame
+     * [`viewState`](Self::view_state) (indices 3–4).
+     * @returns {number}
+     */
+    composedPageCount() {
+        const ret = wasm.wasmsession_composedPageCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * The camera as `[a, b, c, d, e, f]` (PDF/SVG order): content space
+     * (document points) → **CSS px** under the current scroll/zoom.
+     * Composed with [`pageToContent`](Self::page_to_content) it projects a
+     * page- (or, with a node's local transform, node-) anchored HTML
+     * overlay onto the canvas; its inverse maps a pointer back to content
+     * space. The viewer's own camera lands in device px; this divides the
+     * dpr back out so the DOM-facing contract stays CSS px. Empty when no
+     * document is open.
+     * @returns {Float64Array}
+     */
+    contentToViewport() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_contentToViewport(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The current selection as a [`UDocFragment`] for the system clipboard — the
+     * host writes its JSON as our own custom flavor and projects the other
+     * flavors from it (see [`plainText`](Self::plain_text) for `text/plain`),
+     * then hands it back to [`paste`](Self::paste). A pure read: no CRDT write,
+     * not undoable. `undefined` when no document is open or nothing copyable is
+     * selected, so the host leaves the clipboard untouched.
+     *
+     * [`UDocFragment`]: docmentis_udoc_facade::UDocFragment
+     * @returns {UDocFragment | undefined}
+     */
+    copy() {
+        const ret = wasm.wasmsession_copy(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The current plane — the active sheet of a spreadsheet (0-based); `0`
+     * for a single-plane doc type, and `0` when no document is open.
+     * @returns {number}
+     */
+    currentPlane() {
+        const ret = wasm.wasmsession_currentPlane(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Which doc type is open (`"portable"`, `"presentation"`, …), or
+     * `undefined` when nothing is — the tag a host puts on a
+     * [`UDocSelectionEdit`], and its cue for a doc-type-appropriate default
+     * fit (fit-width for paged text, fit-page for slides and images).
+     * @returns {UDocType | undefined}
+     */
+    docType() {
+        const ret = wasm.wasmsession_docType(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * What this session was granted, for the host's own UI. Advisory: the
+     * entitlements are enforced at the calls they guard, so a host that
+     * ignores this is refused rather than obeyed.
+     *
+     * # Errors
+     * If the value can't be serialized.
+     * @returns {Entitlements}
+     */
+    entitlements() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_entitlements(retptr, this.__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);
+        }
+    }
+    /**
+     * Execute one edit, given as a [`UDocCommand`] object — the single
+     * edit seam every document mutation crosses, replacing the old per-verb
+     * wall. Page ops address by index, object/content ops by id (see the
+     * command's own docs); the host builds the command, e.g.
+     * `{"portable":{"insertPage":{"index":0}}}`. Relayouts, so the host's
+     * follow-up [`composedPageCount`](Self::composed_page_count) /
+     * [`viewState`](Self::view_state) pulls see the edit.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to the feature the
+     * command needs, no document is open, the JSON isn't a valid command, it
+     * doesn't match the open doc type, or the edit fails.
+     * @param {UDocCommand} command
+     */
+    execute(command) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_execute(retptr, this.__wbg_ptr, addBorrowedObject(command));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Apply a selection-relative edit to the current selection — a doc-type-tagged
+     * [`UDocSelectionEdit`] (`{"portable":{"object":{"edit":"deleteObjects"}}}`), the ribbon/canvas
+     * edit tagged with the open format. The editor binds it to the live
+     * selection's ids and the matching command (a portable object command, a
+     * presentation shape command, …). The typed twin of [`execute`](Self::execute)
+     * / [`setSelection`](Self::set_selection): the caller emits the format-blind
+     * inner edit and the boundary tags it, replacing the old worker-side
+     * `runOnSelection`. A committing edit (one undo step); relayouts like
+     * [`execute`](Self::execute), and the worker re-posts the selection after.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to the feature the
+     * edit needs, no document is open, the payload isn't a valid edit for the
+     * open doc type, or the bound command fails.
+     *
+     * [`UDocSelectionEdit`]: docmentis_udoc_facade::UDocSelectionEdit
+     * @param {UDocSelectionEdit} edit
+     */
+    executeOnSelection(edit) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_executeOnSelection(retptr, this.__wbg_ptr, addBorrowedObject(edit));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Export page `page_index` on `plane` as `format` — `{ png: { scale } }`
+     * (1.0 == 1 output pixel per document point, i.e. 72 DPI) — and return the
+     * encoded bytes. `plane` is `0` for a single-plane doc type and a
+     * presentation's slide plane; `1..` addresses a slide-master's layout plane.
+     *
+     * The encoded counterpart to
+     * [`render_page_to_rgba`](Self::render_page_to_rgba): it hands back a
+     * ready-to-write file rather than raw pixels a JS host must encode, so a
+     * Node backend needs no PNG encoder of its own. Like it, a CPU render into
+     * a fresh pixmap, independent of any attached viewport canvas. Plane-leading
+     * and required, matching the facade session's
+     * `export_page_to_bytes(plane, page_index, ..)`.
+     *
+     * # Errors
+     * Returns a JS error if `format` isn't a format this build knows, no
+     * document is open, the page index is out of the composed range,
+     * rasterization / encoding fails, or exporting to `format` isn't built yet.
+     * @param {number} plane
+     * @param {number} page_index
+     * @param {PageExportFormat} format
+     * @returns {Uint8Array}
+     */
+    exportPageToBytes(plane, page_index, format) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_exportPageToBytes(retptr, this.__wbg_ptr, plane, page_index, addBorrowedObject(format));
+            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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Export the whole open document as `format` — a rendering of its
+     * laid-out pages, fixed and one-way.
+     *
+     * # Errors
+     * Returns a JS error if `format` isn't a format this build knows, no
+     * document is open, or — until PDF export is built — always.
+     * @param {ExportFormat} format
+     * @returns {Uint8Array}
+     */
+    exportToBytes(format) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_exportToBytes(retptr, this.__wbg_ptr, addBorrowedObject(format));
+            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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Every font family available to the open document, sorted by name, with its
+     * faces grouped under it — the whole picker dropdown, so a row renders with
+     * bold and italic enabled or greyed out. `[]` when no document is open or the
+     * doc type has no text font registry (PDF composes its own embedded font
+     * programs; an image carries no text). A pure read.
+     *
+     * Carries each family's faces, for a picker that greys out bold and italic
+     * per family; [`fontFamilySummaries`](Self::font_family_summaries) is the
+     * same list without them, and is what a picker that only lists families
+     * should read.
+     *
+     * Availability is all the host gets: a family still downloading is listed
+     * like any other, since picking it shapes in a stand-in at once and re-shapes
+     * when its binary lands.
+     *
+     * # Errors
+     *
+     * If the family list can't be serialized.
+     * @returns {FontFamily[]}
+     */
+    fontFamilies() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_fontFamilies(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Every font family available, sorted by name, with its `sourceType` and
+     * **without** its faces — the picker's list. `[]` when no document is open
+     * or the doc type has no text font registry.
+     *
+     * The same families [`fontFamilies`](Self::font_families) reports, and the
+     * read to prefer whenever the faces aren't wanted. A picker draws a row per
+     * family and needs two things: what to call it, and which vendor it comes
+     * from — the latter deciding whether the browser can load the family into
+     * its own text stack (`Local` / `Url` / `Google`) or the row has to go
+     * through [`renderFontPreview`](Self::render_font_preview). At ~1800
+     * families the faces are three quarters of the payload, and the
+     * `FontEntryId`s in them are process-local, so they cross for nothing.
+     *
+     * # Errors
+     *
+     * If the list can't be serialized.
+     * @returns {FontFamilySummary[]}
+     */
+    fontFamilySummaries() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_fontFamilySummaries(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The phase breakdown (ms) of the most recent painted frame — the host
+     * reads this after a painted [`render_frame`](Self::render_frame) while the
+     * perf toggle is on. All zero when timing is off.
+     *
+     * # Errors
+     * Returns a JS error only if the timings can't be serialized — never in
+     * practice for this plain four-`f64` struct.
+     * @returns {FrameTimings}
+     */
+    frameTimings() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_frameTimings(retptr, this.__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);
+        }
+    }
+    /**
+     * Whether the open document came from a udoc package rather than a file
+     * imported here — which `sourceFormat` alone can't tell, since a package
+     * reports the format it recorded. `false` when nothing is open.
+     * @returns {boolean}
+     */
+    fromPackage() {
+        const ret = wasm.wasmsession_fromPackage(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Scroll so page `index` (0-based) is brought to the top of the viewport —
+     * the "go to page N" intent behind the page-number control. Composes the
+     * target page first (the stack composes lazily), so a far jump arranges
+     * it before the camera moves; in spread mode it shows the page's spread. The resulting clamped scroll and centered page ride back to the
+     * host in the next [`view_state`](Self::view_state). A no-op when no
+     * document is open. The repaint happens on the next
+     * [`render_frame`](Self::render_frame).
+     * @param {number} index
+     */
+    goToPage(index) {
+        wasm.wasmsession_goToPage(this.__wbg_ptr, index);
+    }
+    /**
+     * Switch the current plane — the active sheet of a multi-sheet
+     * spreadsheet (0-based). Resets the view to the new sheet's top; its
+     * content lands on the next [`render_frame`](Self::render_frame). A no-op
+     * when no document is open or for a single-plane doc type (its only plane
+     * is `0`). Read [`planeCount`](Self::plane_count) for the bound and
+     * [`currentPlane`](Self::current_plane) for the active one.
+     * @param {number} plane
+     */
+    goToPlane(plane) {
+        wasm.wasmsession_goToPlane(this.__wbg_ptr, plane);
+    }
+    /**
+     * Bring the rect `x0`, `y0`, `x1`, `y1` — page-local document points, as
+     * an annotation's rect is — on page `index` (0-based) into view as
+     * `alignment` (`"top"`, `"center"`, `"bottom"` or `"nearest"`) says,
+     * keeping the zoom — `"top"` is a PDF `/XYZ` destination's landing: what
+     * choosing a comment or stepping to a search match does. Composes the
+     * target page first, as [`goToPage`](Self::go_to_page) does. The resulting
+     * scroll rides back in the next [`view_state`](Self::view_state). A no-op
+     * when no document is open.
+     *
+     * # Errors
+     *
+     * If `alignment` is not one of the four names.
+     * @param {number} index
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {ScrollAlignment} alignment
+     */
+    goToRect(index, x0, y0, x1, y1, alignment) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_goToRect(retptr, this.__wbg_ptr, index, x0, y0, x1, y1, addBorrowedObject(alignment));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * The viewer's guide chrome — a spreadsheet's row/column headers or a paged
+     * ruler — as a resolved render list for the host to draw in the DOM. The
+     * viewer projects it in its own **device px** (origin at the content pane's
+     * top-left); this boundary divides by the dpr into the CSS px the DOM bands
+     * draw in, so the host contract stays CSS px throughout. `undefined` with no
+     * open document or a doc type with no chrome. Pull on each viewport change,
+     * beside [`viewState`](Self::view_state) — and after a selection change that
+     * moves the ruler's "0" (which rides the text frame a caret edits).
+     * @returns {Guide | undefined}
+     */
+    guide() {
+        const ret = wasm.wasmsession_guide(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Pick at CSS-px point `(css_x, css_y)`: the whole hit as a [`UDocHit`] JSON
+     * string (e.g. `{"portable":{"page":"7-0","object":"7-3","text":{"run":0,"boundary":2}}}`,
+     * or `"none"`) — the one read behind the host's hover cursor (an I-beam when
+     * the hit carries `text`) and click routing. Returned as JSON the same way
+     * [`selection`](Self::selection) returns `UDocSelection`, so a doc-tagged hit
+     * needs no bespoke boundary type; the host parses it against the generated
+     * `UDocHit` type. The host calls it **latest-wins** on pointer move (one in
+     * flight, coalesced), so there is no cached set to invalidate as the
+     * document, layout, or a co-editor changes it: the answer is always the live
+     * engine's, and the same query a click routes on, so the cursor can never
+     * disagree with what a click does. `"none"` with no document open.
+     * @param {number} css_x
+     * @param {number} css_y
+     * @returns {UDocHit}
+     */
+    hitTest(css_x, css_y) {
+        const ret = wasm.wasmsession_hitTest(this.__wbg_ptr, css_x, css_y);
+        return takeObject(ret);
+    }
+    /**
+     * Insert the image file `bytes` as a picture on the current page, centred
+     * and scaled down to fit, and select it — one undo step, relayouting like
+     * [`execute`](Self::execute). `contentType` is the file's MIME type
+     * (`image/png`, …); an empty one is read from the bytes' own signature.
+     * The image is an opaque part: its bytes never enter the CRDT, and reach a
+     * peer through [`opaquePartsSince`](Self::opaque_parts_since).
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to editing, no
+     * document is open, it isn't a presentation, no codec reads the bytes, or
+     * the edit fails.
+     * @param {Uint8Array} bytes
+     * @param {string} content_type
+     */
+    insertImage(bytes, content_type) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(content_type, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.wasmsession_insertImage(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            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);
+        }
+    }
+    /**
+     * Mark the whole visible window dirty (e.g. after an edit).
+     */
+    invalidate() {
+        wasm.wasmsession_invalidate(this.__wbg_ptr);
+    }
+    /**
+     * Mark a layout-space (document-points) region dirty.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    invalidateRect(x, y, width, height) {
+        wasm.wasmsession_invalidateRect(this.__wbg_ptr, x, y, width, height);
+    }
+    /**
+     * The families that are **loaded** — parsed and in hand this moment — a
+     * subset of [`fontFamilySummaries`](Self::font_family_summaries), in the
+     * same order.
+     *
+     * The set the document has actually *used*: fonts materialize lazily, so a
+     * family arrives here when something resolves to it, whether it was bundled
+     * all along or just finished downloading. A bundled family nothing has
+     * touched is not in it — it would apply instantly, but it isn't loaded.
+     *
+     * It grows as a document composes and as fonts are picked, so re-read it
+     * rather than caching it:
+     * [`fontFamilySummaries`](Self::font_family_summaries) stays put, this does
+     * not. A hint for ordering a picker, never a gate —
+     * resolution is total, and any family in the full list can be chosen.
+     * @returns {string[]}
+     */
+    loadedFontFamilyNames() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_loadedFontFamilyNames(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;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Create each part a peer's [`opaquePartsSince`](Self::opaque_parts_since)
+     * carries, to pass on in turn. A part arrives before
+     * [`mergePatch`](Self::merge_patch) takes the patch that names it, so
+     * nothing relayouts.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or the data is malformed.
+     * @param {Uint8Array} data
+     */
+    mergeOpaqueParts(data) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_mergeOpaqueParts(retptr, this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * Merge a peer's [`snapshot`](Self::snapshot) or [`patchSince`](Self::patch_since)
+     * blob and relayout (like the page-edit methods), so the host's follow-up
+     * pulls see the merged state.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or the merge fails.
+     * @param {Uint8Array} data
+     */
+    mergePatch(data) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_mergePatch(retptr, this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * Merge a peer's [`presence`](Self::presence) blob — last-write-wins,
+     * idempotent, and repaint-free (peer selections render as host-side
+     * overlay, not document pixels). The host re-pulls
+     * [`peerSelectionGeometry`](Self::peer_selection_geometry) after.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or the data is malformed.
+     * @param {Uint8Array} data
+     */
+    mergePresence(data) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_mergePresence(retptr, this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * Mint one fresh, CRDT-safe id (its `replica-counter` key) for a host
+     * building a new object: the host stamps it into the object's `id`, then
+     * inserts the object with an `InsertObjects` command through
+     * [`execute`](Self::execute) and selects it by that id with
+     * [`setSelection`](Self::set_selection). Id allocation is the editor's, so
+     * a drawn/pasted id can't collide; the host requests one id per node it
+     * creates. `undefined` when no document is open or the doc type mints no
+     * ids.
+     * @returns {string | undefined}
+     */
+    mintId() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_mintId(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Move the text caret per a keyboard `movement` (arrows / Home / End),
+     * extending the selection instead of collapsing when `extend` (Shift).
+     * Presence only — not a command, not undoable. Returns the refreshed
+     * selection geometry, like [`select`](Self::select).
+     *
+     * # Errors
+     * Returns a JS error if the [`TextCaretMove`] JSON can't be decoded, or
+     * (never in practice) if the resulting geometry can't be serialized.
+     * @param {TextCaretMove} movement
+     * @param {boolean} extend
+     * @returns {SelectionGeometry}
+     */
+    moveTextCaret(movement, extend) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_moveTextCaret(retptr, this.__wbg_ptr, addBorrowedObject(movement), extend);
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Whether the document opened needs a password before it can be read — a
+     * PDF encrypted with a user password. Until
+     * [`authenticate`](Self::authenticate) unlocks it, the session answers as
+     * with no document open, except for [`docType`](Self::doc_type) and
+     * [`sourceFormat`](Self::source_format).
+     * @returns {boolean}
+     */
+    needsPassword() {
+        const ret = wasm.wasmsession_needsPassword(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * The content of every opaque part — an inserted picture's image — a
+     * peer lacks. `peer` is that peer's
+     * [`versionVector`](Self::version_vector). Send it ahead of the
+     * [`patchSince`](Self::patch_since) that names them, so the far side has
+     * each part first; empty when there is none to send.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or a part's content can't be encoded.
+     * @param {Uint8Array} peer
+     * @returns {Uint8Array}
+     */
+    opaquePartsSince(peer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(peer, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_opaquePartsSince(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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Open a document from raw bytes. The host then pulls the initial layout
+     * ([`composedPageCount`](Self::composed_page_count) + the
+     * [`viewState`](Self::view_state) extent) and the
+     * [`docType`](Self::doc_type).
+     *
+     * `format` is for bytes detection gets wrong: given, it skips detection
+     * outright; absent, the format is detected, and a `.udoc` zip opens as a
+     * package.
+     *
+     * One document per session: the permit this session was started with is
+     * spent on this open, so a second call is refused and the host starts a
+     * new session for the next file.
+     *
+     * A document that [`needsPassword`](Self::needs_password) — an encrypted
+     * PDF — opens without its pages: the host asks for the password and hands
+     * it to [`authenticate`](Self::authenticate), as often as it takes, then
+     * pulls the layout.
+     *
+     * `delimiter` splits a CSV's fields — one ASCII character, `";"`, `"|"`, …
+     * Absent, it is a comma, or a semicolon where the first record is split by
+     * more of them. No other format takes one.
+     *
+     * # Errors
+     * Returns a JS error if `format` isn't a format this build opens,
+     * `delimiter` isn't one ASCII character or is given for a format that
+     * takes none, a document was already opened here, the format can't be
+     * detected, or parsing fails.
+     * @param {Uint8Array} bytes
+     * @param {FileFormat | null} [format]
+     * @param {string | null} [delimiter]
+     */
+    open(bytes, format, delimiter) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(delimiter) ? 0 : passStringToWasm0(delimiter, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.wasmsession_open(retptr, this.__wbg_ptr, ptr0, len0, isLikeNone(format) ? 0 : addHeapObject(format), ptr1, len1);
+            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);
+        }
+    }
+    /**
+     * Open the package a server keeps at `url` — its package resource,
+     * `…/documents/{documentId}/package` — fetching each part through `fetch`
+     * the first time the document needs it. The host then pulls the initial
+     * layout as after [`open`](Self::open).
+     *
+     * `fetch` is the host's: it fetches a URL synchronously and returns its
+     * bytes, or throws when the request fails. The session holds it for as
+     * long as the document is open, since every page composed later may reach
+     * a part not yet fetched. It blocks the engine's thread while it waits, so
+     * this is for a session running off the host's main thread.
+     *
+     * One document per session, as for [`open`](Self::open): this spends the
+     * session's permit.
+     *
+     * # Errors
+     * Returns a JS error if a document was already opened here, a fetch fails,
+     * or the package can't be read.
+     * @param {string} url
+     * @param {(url: string) => Uint8Array} fetch
+     */
+    openRemote(url, fetch) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_openRemote(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(fetch));
+            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);
+        }
+    }
+    /**
+     * The size (document points) of page `page_index` on `plane` —
+     * doc-type-agnostic, so the host's thumbnail strip can shape and scale a
+     * preview of any open document's page (slide, PDF page, image frame),
+     * including a slide layout or master on its own plane. `plane` is `0` for a
+     * single-plane doc type and a presentation's slide plane; `1..` addresses a
+     * slide-master's layout plane. Composes the page if needed (hence `&mut`),
+     * like the render below. Plane-leading and required, matching the facade
+     * session's `page_metrics(plane, page_index)`.
+     *
+     * # Errors
+     * Returns a JS error if no document is open or the page index is out of
+     * the composed range.
+     * @param {number} plane
+     * @param {number} page_index
+     * @returns {Size}
+     */
+    pageSize(plane, page_index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_pageSize(retptr, this.__wbg_ptr, plane, page_index);
+            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 arrangement transform for page `index` as `[a, b, c, d, e, f]`: the
+     * page's page-local space (origin top-left, `(0, 0, width, height)` in
+     * points) → content space. Composed under
+     * [`contentToViewport`](Self::content_to_viewport) — and, for a node
+     * within the page, prepended with that node's local transform — it places
+     * an overlay anchored in page coordinates. Empty when `index` isn't
+     * arranged or no document is open.
+     * @param {number} index
+     * @returns {Float64Array}
+     */
+    pageToContent(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_pageToContent(retptr, this.__wbg_ptr, index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The on-screen pages projected to viewport (CSS px) space, as a flat
+     * buffer with stride 6: `[index, x, y, width, height, rotation, …]`. The
+     * per-frame payload an HTML overlay layer positions page chrome from — a
+     * corner button from a page's rect, an inter-page divider from the gap
+     * between two consecutive rects. `rotation` is the page's quarter turn
+     * clockwise (`0`/`1`/`2`/`3` = 0°/90°/180°/270°) — what an overlay
+     * projecting page-anchored geometry needs to orient itself on a rotated
+     * page, since the rect alone is axis-aligned. Only the pages currently
+     * within the viewport are emitted, so the buffer stays small regardless of
+     * document length. Empty when no document is open.
+     * @returns {Float64Array}
+     */
+    pageViewRects() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_pageViewRects(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The viewport box the last [`render_frame`](Self::render_frame) repainted,
+     * as `[x, y, width, height]` in **CSS px** — the dirty window the
+     * compositor settled on, after the scroll-blit and any full-repaint
+     * promotion. Empty when that frame painted nothing, so a host that wants to
+     * keep the box on screen through the idle frames that follow holds the last
+     * non-empty one itself.
+     *
+     * A developer diagnostic: the host outlines it over the canvas to see how
+     * much of the surface each frame costs. Costs nothing to report —
+     * `render_frame` hands the window back either way.
+     * @returns {Float64Array}
+     */
+    paintedArea() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_paintedArea(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Paste a [`UDocFragment`] into the open document — a doc-type-tagged fragment
+     * the host read back off the system clipboard. The fragment's objects are
+     * re-inserted with fresh ids onto the selection's page (else the current page)
+     * and become the selection. A committing edit (one undo step); relayouts like
+     * [`execute`](Self::execute), and the worker re-posts the selection after.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to editing, no
+     * document is open, the payload isn't a valid fragment, its doc type
+     * doesn't match the open document, or the paste fails.
+     *
+     * [`UDocFragment`]: docmentis_udoc_facade::UDocFragment
+     * @param {UDocFragment} fragment
+     */
+    paste(fragment) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_paste(retptr, this.__wbg_ptr, addBorrowedObject(fragment));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Serialize only the ops a peer lacks — the delta-sync export. `peer` is a
+     * peer's [`versionVector`](Self::version_vector); feed the result to that
+     * peer's [`mergePatch`](Self::merge_patch).
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or serialization fails.
+     * @param {Uint8Array} peer
+     * @returns {Uint8Array}
+     */
+    patchSince(peer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(peer, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_patchSince(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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Every remote peer's pointer on the plane shown — what the host draws as
+     * collaborator pointers. Each is a [`PeerPointer`]: the peer (id + name,
+     * the same color seed as its selection) and the page its pointer rests on
+     * with the point in that page's local space, placed like a selection box.
+     * Re-pulled whenever presence changes or the plane does; scroll and zoom
+     * never require a re-pull. Empty when no document is open or no peer
+     * shares a pointer.
+     *
+     * # Errors
+     * Returns a JS error only if the pointers can't be serialized — never in
+     * practice for these plain page-anchored points.
+     * @returns {PeerPointer[]}
+     */
+    peerPointers() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_peerPointers(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Every remote peer's selection projected against the local layout —
+     * what the host renders as collaborator selection overlays, beside its
+     * own [`selectionGeometry`](Self::selection_geometry). Each peer rides
+     * with its replica as a 16-hex string (a stable color seed). Re-pulled
+     * whenever presence, the document, or the layout changes; scroll and
+     * zoom never require a re-pull. Empty when no document is open or no
+     * peer has presence. Each entry is a [`PeerSelectionGeometry`] — the peer
+     * (id + name) and its role-grouped geometry, faithful like the local user's.
+     *
+     * [`PeerSelectionGeometry`]: docmentis_udoc_core::viewer::PeerSelectionGeometry
+     *
+     * # Errors
+     * Returns a JS error only if the geometry can't be serialized — never in
+     * practice for these plain page-anchored boxes.
+     * @returns {PeerSelectionGeometry[]}
+     */
+    peerSelectionGeometry() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_peerSelectionGeometry(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The remote peers present on the presence channel — each one's id (a
+     * 16-hex string, the same color seed as its selection) and the name it
+     * advertised — the roster a host lists them by. A peer is present once it
+     * has any presence: a name, a selection or a pointer. Re-pulled whenever
+     * presence changes. Empty when no document is open or no peer is present.
+     *
+     * # Errors
+     * Returns a JS error only if the peers can't be serialized — never in
+     * practice for these plain records.
+     * @returns {Peer[]}
+     */
+    peers() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_peers(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * A copied [`UDocFragment`] projected to plain text — the `text/plain`
+     * clipboard flavor beside our own format, so a paste into any other app gets
+     * readable text, not our JSON. Empty when the fragment carries no text (a
+     * pure shape / image copy), so the host writes only our flavor. Pairs with
+     * [`copy`](Self::copy): the host copies, then projects each flavor it writes
+     * (a future `html` joins here).
+     *
+     * # Errors
+     * Returns a JS error if the payload isn't a valid fragment.
+     *
+     * [`UDocFragment`]: docmentis_udoc_facade::UDocFragment
+     * @param {UDocFragment} fragment
+     * @returns {string}
+     */
+    plainText(fragment) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_plainText(retptr, this.__wbg_ptr, addBorrowedObject(fragment));
+            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 ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * How many planes the document has — the sheet count for a spreadsheet,
+     * `1` for a single-plane doc type, `0` when nothing is open. The bound the
+     * host's sheet tabs and [`goToPlane`](Self::go_to_plane) page
+     * through (reflected once the first [`render_frame`](Self::render_frame)
+     * has reconciled).
+     * @returns {number}
+     */
+    planeCount() {
+        const ret = wasm.wasmsession_planeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Whether plane `plane` is a spreadsheet's chartsheet — a chart, with no
+     * grid and so no row and column headers. `false` for a worksheet, a sheet
+     * not loaded yet (see `spreadsheet.loadSheet`), a plane out of range, a doc
+     * type with no sheets, or when nothing is open.
+     * @param {number} plane
+     * @returns {boolean}
+     */
+    planeIsChartsheet(plane) {
+        const ret = wasm.wasmsession_planeIsChartsheet(this.__wbg_ptr, plane);
+        return ret !== 0;
+    }
+    /**
+     * Whether plane `plane` is a spreadsheet's very hidden sheet —
+     * `state="veryHidden"`, which shows no tab. `false` for any other sheet, a
+     * plane out of range, a doc type with no sheets, or when nothing is open.
+     * @param {number} plane
+     * @returns {boolean}
+     */
+    planeIsVeryHidden(plane) {
+        const ret = wasm.wasmsession_planeIsVeryHidden(this.__wbg_ptr, plane);
+        return ret !== 0;
+    }
+    /**
+     * The display name of plane `plane` — a spreadsheet's sheet-tab label
+     * (the `<sheet name>` from `workbook.xml`), or `undefined` for a plane out
+     * of range, a doc type without named planes, or when nothing is open. The
+     * label the host's sheet tabs show; read [`planeCount`](Self::plane_count)
+     * for the bound.
+     * @param {number} plane
+     * @returns {string | undefined}
+     */
+    planeName(plane) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_planeName(retptr, this.__wbg_ptr, plane);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The colour of plane `plane`'s tab — a spreadsheet's sheet-tab colour
+     * (`<sheetPr><tabColor>`) as Excel draws it — or `undefined` for a tab in
+     * no colour, a sheet not loaded yet (see `spreadsheet.loadSheet`), a plane
+     * out of range, a doc type without tabs, or when nothing is open.
+     * @param {number} plane
+     * @returns {PaintSRgbColor | undefined}
+     */
+    planeTabColor(plane) {
+        const ret = wasm.wasmsession_planeTabColor(this.__wbg_ptr, plane);
+        return takeObject(ret);
+    }
+    /**
+     * Serialize the session's presence (its selection) for sync with a peer
+     * — the transient channel beside [`snapshot`](Self::snapshot): no
+     * history, no undo, never part of a save. Feed it to a peer's
+     * [`mergePresence`](Self::merge_presence).
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or serialization fails.
+     * @returns {Uint8Array}
+     */
+    presence() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_presence(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Redo the last undone edit. Relayouts like the page-edit methods.
+     *
+     * # Errors
+     * Returns a JS error if no document is open or the redo fails.
+     */
+    redo() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_redo(retptr, this.__wbg_ptr);
+            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);
+        }
+    }
+    /**
+     * Re-shape the composed pages against the fonts that have landed, and report
+     * whether there was anything composed to re-shape — repaint if `true`.
+     *
+     * Separate from [`completeFontRequest`](Self::complete_font_request) so a
+     * batch of completions costs one recompose rather than one each: this is the
+     * expensive half of the cycle (a full invalidate plus a recompose of the
+     * composed prefix).
+     * @returns {boolean}
+     */
+    refreshFonts() {
+        const ret = wasm.wasmsession_refreshFonts(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Keep this peer present: stamp its own presence entries anew, so peers
+     * keep them past the presence timeout, and drop the entries of peers that
+     * vanished without leaving. A joined host calls it on a period well inside
+     * the timeout, and on each join before it sends
+     * [`presence`](Self::presence); the host re-pulls the peers after.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration.
+     */
+    refreshPresence() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_refreshPresence(retptr, this.__wbg_ptr);
+            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);
+        }
+    }
+    /**
+     * Register host-supplied font bytes — an OS font, an upload, anything the
+     * host already holds.
+     *
+     * Just the bytes: the font names itself, and every face of a collection is
+     * registered under the family it declares.
+     *
+     * Host state: it applies to documents opened **after** this call, since a
+     * session's font system is built when the document is. Register at startup,
+     * before the first [`open`](Self::open). The bytes are copied once, here,
+     * and shared with every session thereafter.
+     * @param {Uint8Array} bytes
+     */
+    registerLocalFont(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmsession_registerLocalFont(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Register fonts the host will fetch by URL when they are asked for —
+     * `[{ descriptor: { family, bold, italic }, url, scripts? }]`.
+     *
+     * `scripts` is an optional list of Unicode script names (`"Latin"`,
+     * `"Greek"`) used only as a prefilter, to avoid ordering a font for a script
+     * it can't serve. Omit it when unsure: unconstrained means "always try",
+     * and guessing narrow is the one error that loses a font permanently.
+     * Host state, like [`registerLocalFont`](Self::register_local_font).
+     *
+     * # Errors
+     *
+     * If `fonts` isn't a list of that shape.
+     * @param {UrlFont[]} fonts
+     */
+    registerUrlFonts(fonts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(fonts, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_registerUrlFonts(retptr, this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * Draw `text` in one family's own face as a PNG **alpha mask** — the picker
+     * row for a family the browser can't load itself, which is any family whose
+     * `sourceType` is `Embedded`, `OfficeCompatible` or `AdobeStandard`.
+     *
+     * Opaque black on transparent: the host uses it as a CSS `mask-image` over
+     * `currentColor`, so the specimen takes the theme's text color and one
+     * raster serves light and dark.
+     *
+     * The family's **own** face or nothing — `undefined` when no document is
+     * open, the doc type has no text font registry, the family has no face here
+     * yet, or nothing shaped. A row that gets `undefined` keeps its plain name,
+     * which beats labelling one face with another's name. A pure read: drawing
+     * a specimen does not load the family, so browsing the picker leaves
+     * [`loadedFontFamilyNames`](Self::loaded_font_family_names) alone.
+     *
+     * `size` is the em in **CSS px** and the returned `width` / `height` are
+     * the CSS box to give the element; the PNG itself is rendered at the
+     * device pixel ratio behind that box, so it stays sharp on a retina display
+     * without the host doing any scaling arithmetic. `bleed` is the transparent
+     * margin baked into every side — offset the element by `-bleed` to line the
+     * specimen up with ordinary text at the same em.
+     *
+     * # Errors
+     *
+     * If rasterization or PNG encoding fails.
+     * @param {string} family
+     * @param {boolean} bold
+     * @param {boolean} italic
+     * @param {string} text
+     * @param {number} size
+     * @returns {FontPreviewImage | undefined}
+     */
+    renderFontPreview(family, bold, italic, text, size) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(family, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.wasmsession_renderFontPreview(retptr, this.__wbg_ptr, ptr0, len0, bold, italic, ptr1, len1, size);
+            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 r0 === 0 ? undefined : FontPreviewImage.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Paint the pending dirty area. Safe to call every frame; a no-op when
+     * nothing is dirty. Returns true if it painted.
+     *
+     * Applies any deferred backing-store resize first, so the clear and the
+     * full repaint it triggers happen together in this frame.
+     *
+     * # Errors
+     * Returns a JS error if rasterization or a canvas draw fails.
+     * @returns {boolean}
+     */
+    renderFrame() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_renderFrame(retptr, this.__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 r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Rasterize page `page_index` on `plane` to premultiplied RGBA8 at `scale`
+     * (1.0 == 1 output pixel per document point, i.e. 72 DPI) for an
+     * off-viewport preview — the thumbnail strip, or a slide-layout / master
+     * preview off a non-current plane. `plane` is `0` for a single-plane doc
+     * type and a presentation's slide plane; `1..` addresses a slide-master's
+     * layout plane. A CPU render into a fresh pixmap, wholly independent of the
+     * live OffscreenCanvas/compositor, so it never disturbs the painted frame;
+     * it does run synchronously on the worker thread, so the host throttles it
+     * against viewport painting (renders only while the camera is settled).
+     * Returns the pixels plus the dimensions the renderer chose (the host sizes
+     * its `ImageData` to them). Plane-leading and required, matching the facade
+     * session's `render_page_to_pixmap(plane, page_index, ..)`. `ephemeral`
+     * draws the ephemeral annotations — shown, never saved — which a print
+     * leaves out.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, the page index is out of the
+     * composed range, or rasterization fails.
+     * @param {number} plane
+     * @param {number} page_index
+     * @param {number} scale
+     * @param {boolean} ephemeral
+     * @returns {PageImage}
+     */
+    renderPageToRgba(plane, page_index, scale, ephemeral) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_renderPageToRgba(retptr, this.__wbg_ptr, plane, page_index, scale, ephemeral);
+            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 PageImage.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Raise a font request for text the document doesn't have yet — the font
+     * picker's seam. `undefined` when there is nothing to fetch.
+     *
+     * Applying a family the document has never used lays the text out in a
+     * stand-in, raises the request then, and reflows when it lands: the text
+     * changes twice for one click. Ask here first and it changes once:
+     *
+     * ```js
+     * let request;
+     * while ((request = session.requestFont(family, bold, italic, session.selectedText()))) {
+     *   session.completeFontRequest(BigInt(request.id), await fetchBinaries(request));
+     * }
+     * session.executeOnSelection(theFontChange);   // composes once, in the real font
+     * ```
+     *
+     * The request is the same shape and settles the same way as one from
+     * [`takeFontRequests`](Self::take_font_requests), because it is the same
+     * thing — but it goes straight to in-flight, so that call never hands it
+     * out and **no [`refreshFonts`](Self::refresh_fonts) follows**: nothing
+     * composed is waiting on it, and your own edit is what composes.
+     *
+     * Ask again after settling: the next call names the next vendor down the
+     * chain, and `undefined` ends the loop — the family is here, or nobody has
+     * it. Either way, apply the change.
+     *
+     * # Errors
+     *
+     * If the request can't be serialized.
+     * @param {string} family
+     * @param {boolean} bold
+     * @param {boolean} italic
+     * @param {string} characters
+     * @returns {FontRequest | undefined}
+     */
+    requestFont(family, bold, italic, characters) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(family, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(characters, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.wasmsession_requestFont(retptr, this.__wbg_ptr, ptr0, len0, bold, italic, ptr1, len1);
+            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 viewport size (CSS px) or device-pixel ratio changed: record the
+     * new logical viewport and queue the backing-store resize for the next
+     * frame. The actual `set_width` (which clears the backing) is deferred to
+     * [`render_frame`](Self::render_frame) so it lands in the same rAF frame
+     * as the repaint — no blank flash, and on the vsync cadence.
+     * @param {number} css_width
+     * @param {number} css_height
+     * @param {number} dpr
+     */
+    resize(css_width, css_height, dpr) {
+        wasm.wasmsession_resize(this.__wbg_ptr, css_width, css_height, dpr);
+    }
+    /**
+     * Save the open document as `format`, faithfully — the bytes reopen as
+     * the same document. `format` is one of the open doc type's own (a PDF
+     * saves to `"pdf"`, a presentation to `"pptx"`); rendering it into any
+     * other is an [export](Self::export_to_bytes).
+     *
+     * `strategy` is how much of the file the session was opened from, the
+     * original, the saved bytes keep. A `"delta"` or `"incremental"` save
+     * writes over it, which a session opened with `openRemote` doesn't hold.
+     * Absent, it is the one keeping the most of it that `format` saves by: a
+     * PDF's `"incremental"`, a CSV's, a TSV's, a PSV's or an image's
+     * `"rewrite"`, any other's `"delta"`.
+     *
+     * `delimiter` splits a CSV's fields, one ASCII character; absent, the
+     * one the document was opened with, else a comma. No other format takes
+     * one.
+     *
+     * # Errors
+     * Returns a JS error if `format` or `strategy` isn't one this build knows,
+     * `delimiter` isn't one ASCII character or is given for a format that
+     * takes none, no document is open, `format` isn't one of its doc type's, `format`
+     * never saves by `strategy`, the session holds no original for a strategy
+     * that writes over it, saving that way isn't built yet, or serializing
+     * fails.
+     * @param {FileFormat} format
+     * @param {SaveStrategy | null} [strategy]
+     * @param {string | null} [delimiter]
+     * @returns {Uint8Array}
+     */
+    saveToBytes(format, strategy, delimiter) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            var ptr0 = isLikeNone(delimiter) ? 0 : passStringToWasm0(delimiter, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_saveToBytes(retptr, this.__wbg_ptr, addBorrowedObject(format), isLikeNone(strategy) ? 0 : addHeapObject(strategy), 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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Save the open document as a udoc package — the bytes of a `.udoc` zip,
+     * the one package backend in wasm — recording the format it came from, so
+     * a reopen can still save back to it.
+     *
+     * `version` makes it a checkpoint, baseline `v<version>`: the package
+     * keeps the edit log a reopen replays. Absent, the package is a flat
+     * baseline — the whole document and no log.
+     *
+     * # Errors
+     * Returns a JS error if no document is open or serializing fails.
+     * @param {number | null} [version]
+     * @returns {Uint8Array}
+     */
+    saveToPackage(version) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_saveToPackage(retptr, this.__wbg_ptr, isLikeNone(version) ? Number.MAX_SAFE_INTEGER : (version) >>> 0);
+            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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The next batch of `query`'s matches, as a [`SearchBatch`]: at most
+     * [`MAX_MATCHES`](SearchBatch::MAX_MATCHES), each with its page, its
+     * highlight quads (page-local points) and its context, plus `next` — the
+     * [`SearchContinuation`] to hand back as `from` for the batch after, `null`
+     * when the search is done. `scope` is a [`UDocSearchScope`] for the open
+     * doc type, or `undefined` for the whole document; `from` is `undefined`
+     * for the first batch. Stateless: nothing is kept between calls. A page
+     * not laid out yet is laid out first, so the host re-pulls the layout
+     * after, as after [`updateLayout`](Self::update_layout).
+     *
+     * # Errors
+     * Returns a JS error if no document is open, a payload isn't valid, the
+     * scope's doc type doesn't match the open document's, or a part the search
+     * reads fails to load.
+     * @param {string} query
+     * @param {SearchOptions} options
+     * @param {UDocSearchScope | null} [scope]
+     * @param {SearchContinuation | null} [from]
+     * @returns {SearchBatch}
+     */
+    search(query, options, scope, from) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_search(retptr, this.__wbg_ptr, ptr0, len0, addBorrowedObject(options), isLikeNone(scope) ? 0 : addHeapObject(scope), isLikeNone(from) ? 0 : addHeapObject(from));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * The [`UDocSelection`] naming the text of a match — the separate step
+     * from a [`SearchMatch`](docmentis_udoc_core::engine::SearchMatch) to a
+     * selection, taking the match's `location`. Hand the result to
+     * [`setSelection`](Self::set_selection) to select it. `undefined` when no
+     * document is open or nothing at `location` can be selected.
+     *
+     * # Errors
+     * Returns a JS error if `location` isn't a valid [`SearchMatchLocation`].
+     * @param {SearchMatchLocation} location
+     * @returns {UDocSelection | undefined}
+     */
+    searchMatchSelection(location) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_searchMatchSelection(retptr, this.__wbg_ptr, addBorrowedObject(location));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Set an **object** selection from a pointer gesture (CSS px) — a click
+     * picks the topmost object, a drag sweeps a marquee. The host routes here
+     * when a [`hitTest`](Self::hit_test) says the anchor is over an object or
+     * bare canvas. `mode` is the engine's [`SelectMode`] (how the pick combines
+     * with the current selection); `enclose` is the marquee's window rule
+     * (`true` fully-contained only, `false` any-overlap). Unlike text and cells,
+     * the object domain takes these two directly — it has no options struct.
+     * Returns the new selection's geometry.
+     *
+     * # Errors
+     * Returns a JS error if the [`SelectMode`] JSON can't be decoded, or (never
+     * in practice) if the resulting geometry can't be serialized.
+     * @param {number} anchor_css_x
+     * @param {number} anchor_css_y
+     * @param {number} focus_css_x
+     * @param {number} focus_css_y
+     * @param {SelectMode} mode
+     * @param {boolean} enclose
+     * @returns {SelectionGeometry}
+     */
+    selectObjects(anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, mode, enclose) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectObjects(retptr, this.__wbg_ptr, anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, addBorrowedObject(mode), enclose);
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Select the whole sheet — a press on the header corner box. Returns the new
+     * selection's geometry. A no-op on a non-spreadsheet document.
+     *
+     * # Errors
+     * Returns a JS error only if the new geometry can't be serialized — never
+     * in practice for these plain page-anchored boxes.
+     * @returns {SelectionGeometry}
+     */
+    selectSheet() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectSheet(retptr, this.__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);
+        }
+    }
+    /**
+     * Set a **cell** selection from a pointer gesture (CSS px) — a block on the
+     * active sheet of a spreadsheet. `options` ([`GridCellSelectOptions`] —
+     * `extend`) is optional. Returns the new selection's geometry.
+     *
+     * # Errors
+     * Returns a JS error if the [`GridCellSelectOptions`] JSON can't be decoded, or
+     * (never in practice) if the resulting geometry can't be serialized.
+     * @param {number} anchor_css_x
+     * @param {number} anchor_css_y
+     * @param {number} focus_css_x
+     * @param {number} focus_css_y
+     * @param {GridCellSelectOptions} options
+     * @returns {SelectionGeometry}
+     */
+    selectSheetCells(anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectSheetCells(retptr, this.__wbg_ptr, anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, addBorrowedObject(options));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Select whole **columns** from a header gesture (CSS px) — a press / drag on
+     * the top header band. The x resolves the column run (the y is ignored);
+     * `options` ([`GridCellSelectOptions`] — `extend`) is optional. Returns the new
+     * selection's geometry. A no-op on a non-spreadsheet document.
+     *
+     * # Errors
+     * Returns a JS error if the [`GridCellSelectOptions`] JSON can't be decoded, or
+     * (never in practice) if the resulting geometry can't be serialized.
+     * @param {number} anchor_css_x
+     * @param {number} anchor_css_y
+     * @param {number} focus_css_x
+     * @param {number} focus_css_y
+     * @param {GridCellSelectOptions} options
+     * @returns {SelectionGeometry}
+     */
+    selectSheetColumns(anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectSheetColumns(retptr, this.__wbg_ptr, anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, addBorrowedObject(options));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Select whole **rows** from a header gesture (CSS px) — a press / drag on the
+     * left header band. The y resolves the row run (the x is ignored). Returns the
+     * new selection's geometry. A no-op on a non-spreadsheet document.
+     *
+     * # Errors
+     * Returns a JS error if the [`GridCellSelectOptions`] JSON can't be decoded, or
+     * (never in practice) if the resulting geometry can't be serialized.
+     * @param {number} anchor_css_x
+     * @param {number} anchor_css_y
+     * @param {number} focus_css_x
+     * @param {number} focus_css_y
+     * @param {GridCellSelectOptions} options
+     * @returns {SelectionGeometry}
+     */
+    selectSheetRows(anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectSheetRows(retptr, this.__wbg_ptr, anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, addBorrowedObject(options));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Select the whole table the current selection sits in — Select ▸ Table.
+     * A no-op when the selection is not inside one.
+     *
+     * # Errors
+     * Returns a JS error if the resulting geometry can't be serialized.
+     * @returns {SelectionGeometry}
+     */
+    selectTable() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectTable(retptr, this.__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);
+        }
+    }
+    /**
+     * Set a **table cell** selection from a pointer gesture (CSS px) — a block
+     * inside one graphic frame's table on the current slide. A click collapses
+     * to the cell under it, a drag spans to the focus's cell, and
+     * `options` ([`TableSelectOptions`] — `extend`) Shift-extends from what is
+     * already picked in that table. Returns the new selection's geometry.
+     *
+     * Routed here when [`hitTest`](Self::hit_test) says the anchor is over a
+     * table cell *and* the gesture means cells rather than text — the same hit
+     * that would otherwise open a caret. A no-op on a doc type without tables.
+     *
+     * # Errors
+     * Returns a JS error if the [`TableSelectOptions`] JSON can't be decoded,
+     * or (never in practice) if the resulting geometry can't be serialized.
+     * @param {number} anchor_css_x
+     * @param {number} anchor_css_y
+     * @param {number} focus_css_x
+     * @param {number} focus_css_y
+     * @param {TableSelectOptions} options
+     * @returns {SelectionGeometry}
+     */
+    selectTableCells(anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectTableCells(retptr, this.__wbg_ptr, anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, addBorrowedObject(options));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Widen the current table selection to its whole **columns** — Select ▸
+     * Column, the twin of [`selectTableRows`](Self::select_table_rows).
+     *
+     * # Errors
+     * Returns a JS error if the resulting geometry can't be serialized.
+     * @returns {SelectionGeometry}
+     */
+    selectTableColumns() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectTableColumns(retptr, this.__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);
+        }
+    }
+    /**
+     * Widen the current table selection to its whole **rows** — the Select ▸ Row
+     * context-menu command. Takes no point: a table has no row header to press,
+     * so it acts on whatever is already picked (a caret in a cell widens to its
+     * row). Returns the new selection's geometry.
+     *
+     * # Errors
+     * Returns a JS error if the resulting geometry can't be serialized.
+     * @returns {SelectionGeometry}
+     */
+    selectTableRows() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectTableRows(retptr, this.__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);
+        }
+    }
+    /**
+     * Set a **text** selection from a pointer gesture between two viewport-space
+     * points (CSS px) — a caret / range in the open doc's text. The host routes
+     * here after a [`hitTest`](Self::hit_test) says the anchor is over text.
+     * `options` ([`TextSelectOptions`] — `granularity`, `extend`, `global`) is
+     * optional per field (`{}` is a plain click). Returns the new selection's
+     * geometry (see [`selectionGeometry`](Self::selection_geometry)).
+     *
+     * # Errors
+     * Returns a JS error if the [`TextSelectOptions`] JSON can't be decoded, or
+     * (never in practice) if the resulting geometry can't be serialized.
+     * @param {number} anchor_css_x
+     * @param {number} anchor_css_y
+     * @param {number} focus_css_x
+     * @param {number} focus_css_y
+     * @param {TextSelectOptions} options
+     * @returns {SelectionGeometry}
+     */
+    selectText(anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectText(retptr, this.__wbg_ptr, anchor_css_x, anchor_css_y, focus_css_x, focus_css_y, addBorrowedObject(options));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * The plain text of the current selection — the characters a font about to
+     * be applied will have to render, for [`requestFont`](Self::request_font).
+     *
+     * Empty for a caret, a doc type without copy, or nothing selected, which is
+     * a useful answer in its own right: no text on screen is about to change,
+     * so there is nothing to fetch ahead.
+     * @returns {string}
+     */
+    selectedText() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectedText(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);
+        }
+    }
+    /**
+     * The current selection as its JSON wire form (see [`UDocSelection`]) — the
+     * read that lets a host fold the live selection into an id-addressed edit
+     * command (transform / delete) or mirror it in its own UI. `undefined` when
+     * no document is open. The host `JSON.parse`s it and reads the ids out of
+     * the per-doc-type shape (e.g. `.Portable.Objects`).
+     *
+     * [`UDocSelection`]: docmentis_udoc_facade::UDocSelection
+     * @returns {UDocSelection | undefined}
+     */
+    selection() {
+        const ret = wasm.wasmsession_selection(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The engine's verdict on which selection commands are live for the current
+     * selection — the host's input for enabling/disabling the selection-gated
+     * toolbar controls (Delete, Arrange ▸ z-order / group / ungroup). Re-pulled
+     * on the same cadence as [`selectionGeometry`](Self::selection_geometry) (a
+     * selection change or an edit). All-`false` with no document open.
+     *
+     * # Errors
+     * Returns a JS error only if the capabilities can't be serialized — never
+     * in practice for this plain `{ count, allowed }` struct.
+     * @returns {UDocSelectionCapabilities}
+     */
+    selectionCapabilities() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectionCapabilities(retptr, this.__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);
+        }
+    }
+    /**
+     * The current selection projected to page-anchored rectangles
+     * (page-local document points). Camera-independent — the host re-pulls
+     * it after a selection change or an edit (an edit can move or delete
+     * selected objects), then projects it against the per-frame page view
+     * rects; scroll and zoom never require a re-pull. Empty when nothing is
+     * selected or no document is open.
+     *
+     * # Errors
+     * Returns a JS error only if the geometry can't be serialized — never in
+     * practice for these plain page-anchored boxes.
+     * @returns {SelectionGeometry}
+     */
+    selectionGeometry() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_selectionGeometry(retptr, this.__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);
+        }
+    }
+    /**
+     * Where geometry handle `index` of
+     * [`selectionGeometry`](Self::selection_geometry)'s `handles` would land if
+     * it were dragged at `(to_x, to_y)` — a point in that handle's **own local
+     * space** (document points, the space the streamed handle's `point` is
+     * already in), not CSS pixels: the host un-projects the pointer through the
+     * handle's own transform before asking, exactly as it does to commit the
+     * drag.
+     *
+     * A handle travels the track its geometry describes and stops at the ends
+     * of its range, so drawing the grip under the raw cursor puts it where the
+     * shape never will. This hands back the position the committed drag will
+     * produce and writes nothing, so a host can call it latest-wins (one in
+     * flight, coalesced) on every pointer move and draw the answer.
+     * `undefined` when the selection offers no such handle, or no document is
+     * open.
+     * @param {number} index
+     * @param {number} to_x
+     * @param {number} to_y
+     * @returns {SelectionHandle | undefined}
+     */
+    selectionHandlePreview(index, to_x, to_y) {
+        const ret = wasm.wasmsession_selectionHandlePreview(this.__wbg_ptr, index, to_x, to_y);
+        return takeObject(ret);
+    }
+    /**
+     * The current values of the selection's editable properties, as a
+     * [`UDocSelectionProperties`] JSON string (e.g.
+     * `{"portable":{"nonstrokingStyle":{"value":{"brush":{"solid":…},…}},"strokingStyle":"absent"}}`).
+     * Returned
+     * as JSON the same way [`selection`](Self::selection) returns `UDocSelection`,
+     * so each doc type's native paint / text vocabulary stays faithful — the host
+     * parses it against the generated `UDocSelectionProperties` type and the
+     * (doc-type-aware) UI decides how to present it. Re-pulled on the same cadence
+     * as [`selectionCapabilities`](Self::selection_capabilities). `None` with no
+     * document open.
+     *
+     * [`UDocSelectionProperties`]: docmentis_udoc_facade::UDocSelectionProperties
+     * @returns {UDocSelectionProperties | undefined}
+     */
+    selectionProperties() {
+        const ret = wasm.wasmsession_selectionProperties(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Set the viewport backdrop — the color filled in the gaps around and
+     * between pages — from 8-bit sRGB components. Remembered across
+     * [`open`](Self::open) (a fresh document otherwise resets it) and applied
+     * to the current document immediately, forcing a full repaint on the next
+     * [`render_frame`](Self::render_frame).
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     */
+    setBackdropColor(r, g, b) {
+        wasm.wasmsession_setBackdropColor(this.__wbg_ptr, r, g, b);
+    }
+    /**
+     * Set how far, in CSS px, the brand decal sits in from the viewport's
+     * bottom and right edges — the thickness of chrome the host lays over
+     * them, such as scrollbars floating over the canvas. `0` (the default)
+     * tucks it flush into the corner. Clamped to `0..=24`, so no inset can
+     * push the decal off the surface; `NaN` counts as `0`. Re-projects the
+     * decal onto the current document; the host re-reads
+     * [`branding_rect`](Self::branding_rect).
+     * @param {number} css_px
+     */
+    setBrandingInset(css_px) {
+        wasm.wasmsession_setBrandingInset(this.__wbg_ptr, css_px);
+    }
+    /**
+     * Turn canvas fonts on with the host's own text stack, or off with
+     * `undefined`.
+     *
+     * On, a family no vendor offers — not the document, not the host, not the
+     * Google catalog — is drawn by `canvas_text` when the viewer's machine has it
+     * installed, before resolution gives the family up for a substitute. The
+     * same document then renders differently on machines with different
+     * fonts, which is why it is off unless a host turns it on. Host state,
+     * like [`registerLocalFont`](Self::register_local_font).
+     * @param {CanvasText | null} [canvas_text]
+     */
+    setCanvasText(canvas_text) {
+        wasm.wasmsession_setCanvasText(this.__wbg_ptr, isLikeNone(canvas_text) ? 0 : addHeapObject(canvas_text));
+    }
+    /**
+     * Set how many CSS px make a physical inch on the host's screen: `96`,
+     * the CSS inch — `72` for a spreadsheet, whose 100% is Mac Excel's —
+     * unless the host calibrated it, so 100% shows a page at its real size, a
+     * Letter page as wide as the paper beside the screen.
+     * The viewer's dpi becomes `dpi × dpr`; the zoom stays, so the next frame
+     * shows the same zoom at the new size.
+     * @param {number} dpi
+     */
+    setDpi(dpi) {
+        wasm.wasmsession_setDpi(this.__wbg_ptr, dpi);
+    }
+    /**
+     * Set the fit: its `mode` is `"none"`, `"width"`, `"height"`, `"both"`
+     * (contain) or `"either"` (cover); its `zoomCap` caps the derived zoom
+     * (`null` uncapped, `1.0` to never enlarge past natural size). The viewer
+     * derives the zoom to fit the current spread and re-derives it on resize;
+     * while a fit is active the per-frame zoom in [`set_view`](Self::set_view)
+     * is ignored. The derived zoom rides back to the host in
+     * [`view_state`](Self::view_state)'s `scale`.
+     *
+     * # Errors
+     * Returns a `JsValue` error if `fit` is not a [`Fit`].
+     * @param {Fit} fit
+     */
+    setFit(fit) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_setFit(retptr, this.__wbg_ptr, addBorrowedObject(fit));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Toggle formatting marks — `¶` at each paragraph mark, a dot in each
+     * space, an arrow in each tab and `↵` at each line break — drawn over
+     * composed text in the space it already holds, so showing them never
+     * reflows. On while an editor's user asks for them, never in an export.
+     * Remembered across [`open`](Self::open) like the backdrop and applied to
+     * the current document immediately, forcing a repaint on the next
+     * [`render_frame`](Self::render_frame). PDF text ignores it; a
+     * spreadsheet's cells compose through the same text engine as a slide's
+     * and a page's, so they show marks too.
+     * @param {boolean} on
+     */
+    setFormattingMarks(on) {
+        wasm.wasmsession_setFormattingMarks(this.__wbg_ptr, on);
+    }
+    /**
+     * Set the host's Google font catalog —
+     * `[{ name, variants: [[bold, italic], …], subsets: ["latin", …] }]` —
+     * replacing the one set before.
+     *
+     * There is no compiled-in family list: the host owns the catalog, because it
+     * already owns the css2 protocol that fetches from it. An empty catalog *is*
+     * Google disabled, so `[]` turns off a catalog set earlier. `subsets` feeds
+     * only the script prefilter — the host's fulfiller picks what to actually
+     * download from the live `unicode-range`s. Host state, like
+     * [`registerLocalFont`](Self::register_local_font).
+     *
+     * # Errors
+     *
+     * If `families` isn't a list of that shape.
+     * @param {GoogleFontFamily[]} families
+     */
+    setGoogleFontFamilies(families) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(families, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmsession_setGoogleFontFamilies(retptr, this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * Set how the layout groups pages into spreads: `"singlePage"`,
+     * `"doublePage"`, `"doublePageOddRight"` or `"doublePageOddLeft"`.
+     * Remembered across [`open`](Self::open) like the spacing, and applied to
+     * the current document immediately; the re-stack and repaint happen on the
+     * next [`render_frame`](Self::render_frame).
+     *
+     * # Errors
+     * Returns a `JsValue` error if `mode` is not one of the four names.
+     * @param {LayoutMode} mode
+     */
+    setLayoutMode(mode) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_setLayoutMode(retptr, this.__wbg_ptr, addBorrowedObject(mode));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Set whether content overflowing the page bounds is drawn. When set, an
+     * object that runs off the page stays visible within the spread (the
+     * viewport in spread mode, or the page plus half the inter-page gap in
+     * continuous); otherwise content is clipped to the page. Remembered across
+     * [`open`](Self::open) like the scroll mode, and applied to the current
+     * document immediately — only the clip changes, so the repaint happens on
+     * the next [`render_frame`](Self::render_frame).
+     * @param {boolean} visible
+     */
+    setOverflowVisible(visible) {
+        wasm.wasmsession_setOverflowVisible(this.__wbg_ptr, visible);
+    }
+    /**
+     * Set the page-border color — the 1-device-pixel frame drawn just outside
+     * each page (typically the theme's outline, so the host recolors it per
+     * theme) — from 8-bit sRGB components. Remembered across
+     * [`open`](Self::open) (a fresh document otherwise draws none) and applied
+     * to the current document immediately; the next
+     * [`render_frame`](Self::render_frame) reconciles and repaints it.
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     */
+    setPageBorderColor(r, g, b) {
+        wasm.wasmsession_setPageBorderColor(this.__wbg_ptr, r, g, b);
+    }
+    /**
+     * Turn every page `quarter_turns` quarter turns clockwise (`0`–`3`) on top
+     * of its own rotation — a view setting, never a document edit. Remembered
+     * across [`open`](Self::open) like the spacing, and applied to the current
+     * document immediately; the re-stack and repaint happen on the next
+     * [`render_frame`](Self::render_frame).
+     *
+     * # Errors
+     * Returns a `JsValue` error if `quarter_turns` is past three.
+     * @param {number} quarter_turns
+     */
+    setPageRotation(quarter_turns) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_setPageRotation(retptr, this.__wbg_ptr, quarter_turns);
+            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);
+        }
+    }
+    /**
+     * Turn the developer performance counter's per-frame timing on or off.
+     * While on, [`render_frame`](Self::render_frame) splits each painted frame
+     * into reconcile / record / rasterize / composite, readable via
+     * [`frame_timings`](Self::frame_timings); while off, the frame path is
+     * untimed and pays nothing. Sticky across [`open`](Self::open) — it lives
+     * on the persistent canvas, not the per-document session.
+     * @param {boolean} enabled
+     */
+    setPerf(enabled) {
+        wasm.wasmsession_setPerf(this.__wbg_ptr, enabled);
+    }
+    /**
+     * Toggle empty-placeholder authoring chrome — the dashed frame and
+     * "Click to add …" prompt an empty presentation placeholder shows while it
+     * is being edited. On for an editor, off for a reading view / export (an
+     * empty placeholder then renders blank, as `PowerPoint`'s slideshow does).
+     * Remembered across [`open`](Self::open) like the backdrop and applied to
+     * the current document immediately, forcing a repaint on the next
+     * [`render_frame`](Self::render_frame). Doc types without placeholders
+     * (only presentations have them) ignore it.
+     * @param {boolean} on
+     */
+    setPlaceholderPrompts(on) {
+        wasm.wasmsession_setPlaceholderPrompts(this.__wbg_ptr, on);
+    }
+    /**
+     * Set where this peer's pointer rests from the viewport point (CSS px)
+     * it is at — the page under it and the point in that page's local space —
+     * or delete it when the point is off every page. Presence only. Returns
+     * the blob carrying that one entry, to send as a presence a peer
+     * [merges](Self::merge_presence): a pointer set on every move travels
+     * alone.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or serialization fails.
+     * @param {number} css_x
+     * @param {number} css_y
+     * @returns {Uint8Array}
+     */
+    setPointer(css_x, css_y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_setPointer(retptr, this.__wbg_ptr, css_x, css_y);
+            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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Switch the scroll mode: `"spread"` (one spread at a time) or
+     * `"continuous"` (the scrolling stack default). Remembered across
+     * [`open`](Self::open) like the backdrop and spacing, and applied to the
+     * current document immediately — keeping the page you were on in view. The
+     * repaint happens on the next [`render_frame`](Self::render_frame).
+     *
+     * # Errors
+     * Returns a `JsValue` error if `mode` is not one of the two names.
+     * @param {ScrollMode} mode
+     */
+    setScrollMode(mode) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_setScrollMode(retptr, this.__wbg_ptr, addBorrowedObject(mode));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Set the scrollbar size, in CSS px — the thickness of the strip the camera
+     * keeps clear along the right edge while the vertical bar shows and along
+     * the bottom while the horizontal one does, for the host to draw the bar
+     * in ([`viewState`](Self::view_state) says which show). A fit measures the
+     * viewport less one strip on each axis, so the zoom never follows the bars.
+     * `0` (the default) keeps no strip, for bars that float over the content;
+     * negative or `NaN` counts as `0`. Remembered across [`open`](Self::open)
+     * like the spacing, re-stretched on a dpr change, and applied to the
+     * current document immediately.
+     * @param {number} css_px
+     */
+    setScrollbarSize(css_px) {
+        wasm.wasmsession_setScrollbarSize(this.__wbg_ptr, css_px);
+    }
+    /**
+     * Replace the selection from its JSON wire form — externally tagged by doc
+     * type, e.g. `{"portable":{"objects":["7-0"]}}` or `{"portable":"none"}`
+     * (see [`UDocSelection`]). Presence only: not a command, not undoable.
+     * This is the agnostic seam that replaces the per-doc-type select verbs —
+     * the host builds the JSON (stamping the object ids it minted or read back
+     * from [`selection`](Self::selection)) and gets the new selection geometry.
+     * A `None` selection clears.
+     *
+     * # Errors
+     * Returns a JS error if no document is open, the JSON is malformed, or its
+     * doc type doesn't match the open document.
+     *
+     * [`UDocSelection`]: docmentis_udoc_facade::UDocSelection
+     * @param {UDocSelection} selection
+     * @returns {SelectionGeometry}
+     */
+    setSelection(selection) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_setSelection(retptr, this.__wbg_ptr, addBorrowedObject(selection));
+            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);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Set the page arrangement's spacing — the `content_padding` on each edge of
+     * the content block and the `page_gap` between adjacent pages, across a
+     * spread and down from one spread to the next. The gaps are in document
+     * points (page-fixed: they scale with zoom and read as part of the paper).
+     * Each padding edge is a
+     * `ViewLength` — screen-fixed pixels (`px`, sized for screen chrome) or
+     * document points (`pt`). The host sends both in its own CSS units; this
+     * boundary multiplies the `px` edges by the dpr into the viewer's device px
+     * (the `pt` edges and the gap are page units and pass through). The CSS-px
+     * padding is remembered across [`open`](Self::open) like the backdrop and
+     * applied to the current document immediately, keeping the page at the
+     * viewport's top edge anchored. A dpr change re-stretches the `px` edges
+     * automatically ([`resize`](Self::resize) re-applies), so the host sets the
+     * spacing once and never re-sends it.
+     *
+     * # Errors
+     * Returns a JS error if the [`ContentPadding`] or [`PageGap`] JSON can't be
+     * decoded.
+     * @param {ContentPadding} content_padding
+     * @param {PageGap} page_gap
+     */
+    setSpacing(content_padding, page_gap) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_setSpacing(retptr, this.__wbg_ptr, addBorrowedObject(content_padding), addBorrowedObject(page_gap));
+            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);
+            heap[stack_pointer++] = undefined;
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Set the local user's info (currently a display name) shown on this peer's
+     * selection to others. Sticky like the backdrop: remembered and re-applied
+     * to every document opened later (a fresh session's presence starts
+     * nameless), so it survives a re-open. Rides the presence channel with the
+     * selection — the host re-broadcasts [`presence`](Self::presence) so peers
+     * pick it up.
+     * @param {string} name
+     */
+    setUserInfo(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmsession_setUserInfo(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Scroll and/or zoom changed. The viewer clamps scroll and, in fit
+     * modes, derives zoom; the actual blit/repaint happens once per frame
+     * in [`Self::render_frame`].
+     * @param {number} scroll_x
+     * @param {number} scroll_y
+     * @param {number} zoom
+     */
+    setView(scroll_x, scroll_y, zoom) {
+        wasm.wasmsession_setView(this.__wbg_ptr, scroll_x, scroll_y, zoom);
+    }
+    /**
+     * Serialize the session's full CRDT state for a fresh peer — an opaque blob
+     * to hand another session's [`mergePatch`](Self::merge_patch). For delta sync, use
+     * [`versionVector`](Self::version_vector) + [`patchSince`](Self::patch_since)
+     * instead; this ships the whole document.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or serialization fails.
+     * @returns {Uint8Array}
+     */
+    snapshot() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_snapshot(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The file format the open document came from (`"pdf"`, `"pptx"`,
+     * `"png"`, …) — what saving it back means — or `undefined` when nothing is
+     * open or a package recorded none.
+     * @returns {FileFormat | undefined}
+     */
+    sourceFormat() {
+        const ret = wasm.wasmsession_sourceFormat(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Take the outstanding font orders —
+     * `[{ id, family, bold, italic, vendor, characters }]`, `[]` when there is
+     * nothing to fetch.
+     *
+     * **The host does the fetching.** Each order names a font and the characters
+     * wanted from it; `vendor` is either `"google"` (ask css2, read the
+     * `unicode-range`s, download the blocks that hold those characters) or
+     * `{ url: { url } }`. Fetch them however you like — in parallel, with
+     * whatever retry policy — then settle each with
+     * [`completeFontRequest`](Self::complete_font_request) and call
+     * [`refreshFonts`](Self::refresh_fonts) once for the batch.
+     *
+     * Nothing here blocks or waits: an order is out until it is settled, and the
+     * document keeps rendering in a stand-in throughout.
+     *
+     * # Errors
+     *
+     * If the order list can't be serialized.
+     * @returns {FontRequest[]}
+     */
+    takeFontRequests() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_takeFontRequests(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The current slide's resolved theme color palette as a JSON string — the
+     * mapped scheme slots (`bg1`/`tx1`/accents/links) a host renders as "Theme
+     * Colors", each a `#rrggbb` device-sRGB hex. `undefined` when no document is
+     * open or the doc type carries no theme (only presentations do). The host
+     * `JSON.parse`s it into `{ name, text1, background1, … }` (camelCase keys)
+     * and drives its color picker with the resolved swatches. Per slide, not
+     * per document (a multi-master deck re-themes per slide); loads that slide's
+     * theme chain on demand, hence `&mut self`.
+     * @returns {string | undefined}
+     */
+    themePalette() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_themePalette(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Undo the last edit. Relayouts like the page-edit methods, so the host's
+     * follow-up pulls see the reverted state.
+     *
+     * # Errors
+     * Returns a JS error if no document is open or the undo fails.
+     */
+    undo() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_undo(retptr, this.__wbg_ptr);
+            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);
+        }
+    }
+    /**
+     * Compose ahead through page index `page_limit`, growing the composed
+     * prefix, and return whether the document is now **fully composed**. The
+     * idle compose-ahead seam: the host calls it from `requestIdleCallback`
+     * with a rising limit (e.g. `composedPageCount + 1` to advance one page)
+     * until it returns `true` — at which point
+     * [`composedPageCount`](Self::composed_page_count) is the document's page
+     * count. There is no total to ask for up front: a page is known only once
+     * composed.
+     *
+     * Best-effort, like every viewer-side compose: a page that fails to
+     * compose is left out (it paints as a placeholder) and reported as *not*
+     * complete rather than thrown, so one bad page can't abort the pump. A
+     * host that needs the failure — a batch export — drives the native
+     * `UDocSession::update_layout`, which returns it. Since a stalled page
+     * keeps `false` coming back, pair the flag with a no-progress guard on
+     * `composedPageCount`.
+     *
+     * # Errors
+     * Returns a JS error if no document is open.
+     * @param {number} page_limit
+     * @returns {boolean}
+     */
+    updateLayout(page_limit) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_updateLayout(retptr, this.__wbg_ptr, page_limit);
+            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 r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The session's version vector — the opaque handshake token to hand another
+     * session's [`patchSince`](Self::patch_since) so it can send back only the
+     * ops this session lacks.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or serialization fails.
+     * @returns {Uint8Array}
+     */
+    versionVector() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_versionVector(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The authoritative view state as `[scale, scrollX, scrollY,
+     * contentWidth, contentHeight, currentPage, usedWidth, usedHeight,
+     * scrollbarX, scrollbarY]`: the CSS px per document point under the current
+     * zoom (`zoom × dpi / 72`), the scroll/extent in document points after the
+     * viewer's clamping/anchoring, the 0-based index of the page the viewport is
+     * centered on (`-1` when no page is arranged), the **used** content size the
+     * scrollbar is drawn from (the scrollable extent for most doc types; a
+     * spreadsheet's used data range, which is smaller than its scrollable grid),
+     * and whether the horizontal / vertical scrollbar shows (`1` / `0`) — the
+     * bars the frame kept a strip clear for. Streamed to the main thread beside
+     * [`pageViewRects`](Self::page_view_rects) each painted frame: with
+     * screen-fixed (px) spacing the content extent — and, across a re-arrangement,
+     * the scroll — depend on zoom in ways the host can't derive, so it adopts
+     * these instead. The guide chrome rides its own structured pull
+     * ([`guide`](Self::guide)). Empty when no document is open.
+     * @returns {Float64Array}
+     */
+    viewState() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_viewState(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Leave the presence channel: the blob deleting this peer's entries for
+     * every peer that [merges](Self::merge_presence) it, with every peer's
+     * entries forgotten here. A host leaving a collaboration sends it before
+     * it goes, and re-pulls the peers after.
+     *
+     * # Errors
+     * Returns a JS error if the session is not entitled to collaboration, no
+     * document is open, or serialization fails.
+     * @returns {Uint8Array}
+     */
+    withdrawPresence() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmsession_withdrawPresence(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Zoom to an explicit magnification keeping the content point under the
+     * viewport point (`x`, `y`, **CSS px**) pinned on screen — cursor-anchored
+     * zoom (the wheel and the zoom controls). Multiplied by the dpr into the
+     * viewer's device px here, like every pointer intent. Unlike
+     * [`set_view`](Self::set_view) the engine owns the resulting scroll, so it's
+     * exact at any step; it rides back in the next
+     * [`view_state`](Self::view_state). Clears any active fit. A no-op when no
+     * document is open.
+     * @param {number} zoom
+     * @param {number} css_x
+     * @param {number} css_y
+     */
+    zoomAtPoint(zoom, css_x, css_y) {
+        wasm.wasmsession_zoomAtPoint(this.__wbg_ptr, zoom, css_x, css_y);
+    }
+    /**
+     * Fit a viewport-space rectangle (`x`, `y`, `width`, `height` in **CSS px**)
+     * to the viewport and centre it — the marquee zoom. Multiplied by the dpr
+     * into the viewer's device px here. The engine derives the zoom and resolves
+     * the scroll after re-arranging, so it stays correct across the screen-fixed
+     * spacing a host can't account for. The result rides back in the next
+     * [`view_state`](Self::view_state). A no-op when no document is open or for a
+     * doc type without a paginated view.
+     * @param {number} css_x
+     * @param {number} css_y
+     * @param {number} css_width
+     * @param {number} css_height
+     */
+    zoomToRect(css_x, css_y, css_width, css_height) {
+        wasm.wasmsession_zoomToRect(this.__wbg_ptr, css_x, css_y, css_width, css_height);
+    }
+}
+if (Symbol.dispose) WasmSession.prototype[Symbol.dispose] = WasmSession.prototype.free;
+
+/**
+ * Start a licensed or permitted session — the module's only constructor.
+ *
+ * Validates the license offline; a valid one's features are the session's, and
+ * this returns without touching the network. Otherwise the session is free
+ * tier: this mints a nonce, asks the permit server for a permit, and verifies
+ * the one it gets back, all inside wasm — and the features that permit grants
+ * are the session's.
+ *
+ * Being a free function, it borrows no session across its `await`, so the
+ * host's frame loop and message pump keep running while the permit is in
+ * flight.
+ *
+ * # Errors
+ * A `UDocError` describing the refusal — its `code` `invalidLicense`,
+ * `permitRefused` or `cannotVerify`, the variant's fields its `detail` — and the
+ * same refusal on the console with the specifics; or, for a `config` that
+ * won't decode, an `invalidRequest` one. A supplied key that does not validate is a
+ * refusal like any other: it does **not** fall back to metered free usage,
+ * because a customer whose key broke should be told, not quietly metered until
+ * they hit a cap.
+ * @param {SessionConfig} config
+ * @returns {Promise<WasmSession>}
+ */
+export function startSession(config) {
+    const ret = wasm.startSession(addHeapObject(config));
+    return takeObject(ret);
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_is_function_754e9f305ff6029e: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_object_56732c2bc353f41d: function(arg0) {
+            const val = getObject(arg0);
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_c236cabd84a4d769: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_67b456be8673d3d7: function(arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_9bb1761122181af2: function(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);
+        },
+        __wbg___wbindgen_string_get_72bdf95d3ae505b1: function(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);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg__wbg_cb_unref_61db23ac97f16c31: function(arg0) {
+            getObject(arg0)._wbg_cb_unref();
+        },
+        __wbg_assign_671cc7293104db6d: function(arg0, arg1) {
+            const ret = Object.assign(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_beginPath_13add782681be0f7: function(arg0) {
+            getObject(arg0).beginPath();
+        },
+        __wbg_call_9c758de292015997: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_clearRect_3e4ce26e687ec49f: function(arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).clearRect(arg1, arg2, arg3, arg4);
+        },
+        __wbg_clip_5f059eebddcbe6ae: function(arg0) {
+            getObject(arg0).clip();
+        },
+        __wbg_covers_ccd7618eb4a0c3da: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).covers(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+            return ret;
+        }, arguments); },
+        __wbg_crypto_38df2bab126b63dc: function(arg0) {
+            const ret = getObject(arg0).crypto;
+            return addHeapObject(ret);
+        },
+        __wbg_drawImage_c3d17f387dd48be1: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).drawImage(getObject(arg1), arg2, arg3);
+        }, arguments); },
+        __wbg_error_78ff5b3a29b770e0: function(arg0) {
+            console.error(getObject(arg0));
+        },
+        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_fetch_8e5a5301575dfbb6: function() { return handleError(function (arg0) {
+            const ret = fetch(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_fillRect_515c1159951ba081: function(arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).fillRect(arg1, arg2, arg3, arg4);
+        },
+        __wbg_getContext_7d3a8f461c828713: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).getRandomValues(getObject(arg1));
+        }, arguments); },
+        __wbg_getTime_00b3f7db575e4ef5: function(arg0) {
+            const ret = getObject(arg0).getTime();
+            return ret;
+        },
+        __wbg_getTimezoneOffset_08e2892156231088: function(arg0) {
+            const ret = getObject(arg0).getTimezoneOffset();
+            return ret;
+        },
+        __wbg_get_de6a0f7d4d18a304: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_unchecked_33f6e5c9e2f2d6b2: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_height_6664d43063375ca4: function(arg0) {
+            const ret = getObject(arg0).height;
+            return ret;
+        },
+        __wbg_instanceof_OffscreenCanvasRenderingContext2d_2649509607c20f77: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof OffscreenCanvasRenderingContext2D;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Response_cb984bd66d7bd408: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Response;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_86f30649f63ef9c2: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_WorkerGlobalScope_fe1d59aa8cd22e9a: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof WorkerGlobalScope;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_length_4a591ecaa01354d9: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_66f1a4b2e9026940: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_measure_472c24e52a63dff8: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).measure(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+            return ret;
+        }, arguments); },
+        __wbg_metrics_4e3e3c9e1e0cac37: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).metrics(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+            const ret = getObject(arg0).msCrypto;
+            return addHeapObject(ret);
+        },
+        __wbg_new_0_445c13a750296eb6: function() {
+            const ret = new Date();
+            return addHeapObject(ret);
+        },
+        __wbg_new_227d7c05414eb861: function() {
+            const ret = new Error();
+            return addHeapObject(ret);
+        },
+        __wbg_new_3b242422c588a8f3: function() { return handleError(function (arg0, arg1) {
+            const ret = new OffscreenCanvas(arg0 >>> 0, arg1 >>> 0);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_50bb5ebeecef71a8: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_6d75fd236f920a62: function(arg0) {
+            const ret = new Date(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_new_ce1ab61c1c2b300d: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
+        __wbg_new_d90091b82fdf5b91: function() {
+            const ret = new Array();
+            return addHeapObject(ret);
+        },
+        __wbg_new_e436d06bc8e77460: function() { return handleError(function () {
+            const ret = new Headers();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_typed_bf31d18f92484486: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return __wasm_bindgen_func_elem_68499(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_new_with_length_36a4998e27b014c5: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_new_with_str_and_init_bcd02b79a793d27f: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_with_u8_clamped_array_and_sh_e3609225f4ad3a74: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0, arg3 >>> 0);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_node_84ea875411254db1: function(arg0) {
+            const ret = getObject(arg0).node;
+            return addHeapObject(ret);
+        },
+        __wbg_now_190933fa139cc119: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_now_f462ca322babb89f: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_now_f565250295e2d180: function(arg0) {
+            const ret = getObject(arg0).now();
+            return ret;
+        },
+        __wbg_parse_03863847d06c4e89: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_performance_6712214a47b62987: function(arg0) {
+            const ret = getObject(arg0).performance;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_process_44c7a14e11e9f69e: function(arg0) {
+            const ret = getObject(arg0).process;
+            return addHeapObject(ret);
+        },
+        __wbg_prototypesetcall_3249fc62a0fafa30: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_push_a6822215aa43e71c: function(arg0, arg1) {
+            const ret = getObject(arg0).push(getObject(arg1));
+            return ret;
+        },
+        __wbg_putImageData_18be978638bb8a18: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
+        }, arguments); },
+        __wbg_queueMicrotask_35c611f4a14830b2: function(arg0) {
+            queueMicrotask(getObject(arg0));
+        },
+        __wbg_queueMicrotask_404ed0a58e0b63cc: function(arg0) {
+            const ret = getObject(arg0).queueMicrotask;
+            return addHeapObject(ret);
+        },
+        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).randomFillSync(takeObject(arg1));
+        }, arguments); },
+        __wbg_rasterize_52a5149dd7613d64: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+            const ret = getObject(arg0).rasterize(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), getArrayF64FromWasm0(arg5, arg6), arg7 === 0 ? undefined : arg8);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_rect_cfd51c6824c010ab: function(arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).rect(arg1, arg2, arg3, arg4);
+        },
+        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
+            const ret = module.require;
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_resolve_25a7e548d5881dca: function(arg0) {
+            const ret = Promise.resolve(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_restore_e6b5ec8b57c26465: function(arg0) {
+            getObject(arg0).restore();
+        },
+        __wbg_save_5b28126dc816c631: function(arg0) {
+            getObject(arg0).save();
+        },
+        __wbg_set_25ef40a9aeff260d: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_set_6e30c9374c26414c: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
+        __wbg_set_body_36614c7e61546809: function(arg0, arg1) {
+            getObject(arg0).body = getObject(arg1);
+        },
+        __wbg_set_fillStyle_73054f7e9d1c5cbe: function(arg0, arg1, arg2) {
+            getObject(arg0).fillStyle = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_headers_7c1e39ece7826bec: function(arg0, arg1) {
+            getObject(arg0).headers = getObject(arg1);
+        },
+        __wbg_set_method_7a6811dec7a4feff: function(arg0, arg1, arg2) {
+            getObject(arg0).method = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_name_3c3fc49c8f747e56: function(arg0, arg1, arg2) {
+            getObject(arg0).name = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+            const ret = getObject(arg1).stack;
+            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);
+        },
+        __wbg_static_accessor_GLOBAL_9d53f2689e622ca1: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_a1a35cec07001a8a: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_SELF_4c59f6c7ea29a144: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_WINDOW_e70ae9f2eb052253: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_stringify_8286df6dcc591521: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_subarray_4aa221f6a4f5ab22: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_text_a17febec76d36501: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).text();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_then_18f476d590e58992: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_then_ac7b025999b52837: function(arg0, arg1) {
+            const ret = getObject(arg0).then(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_toISOString_d485be0388a74494: function(arg0) {
+            const ret = getObject(arg0).toISOString();
+            return addHeapObject(ret);
+        },
+        __wbg_versions_276b2795b1c6a219: function(arg0) {
+            const ret = getObject(arg0).versions;
+            return addHeapObject(ret);
+        },
+        __wbg_wasmsession_new: function(arg0) {
+            const ret = WasmSession.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_width_440db126d7331632: function(arg0) {
+            const ret = getObject(arg0).width;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 15189, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_68497);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_clone_ref: function(arg0) {
+            const ret = getObject(arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./udoc_bg.js": import0,
+    };
+}
+
+function __wasm_bindgen_func_elem_68497(arg0, arg1, arg2) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.__wasm_bindgen_func_elem_68497(retptr, arg0, arg1, addHeapObject(arg2));
+        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);
+    }
+}
+
+function __wasm_bindgen_func_elem_68499(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_68499(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+const FontPreviewImageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fontpreviewimage_free(ptr, 1));
+const PageImageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pageimage_free(ptr, 1));
+const WasmSessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsession_free(ptr, 1));
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_export5(state.a, state.b));
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+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);
+}
+
+function getClampedArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ClampedArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedUint8ClampedArrayMemory0 = null;
+function getUint8ClampedArrayMemory0() {
+    if (cachedUint8ClampedArrayMemory0 === null || cachedUint8ClampedArrayMemory0.byteLength === 0) {
+        cachedUint8ClampedArrayMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
+    }
+    return cachedUint8ClampedArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export3(addHeapObject(e));
+    }
+}
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_export5(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let stack_pointer = 1024;
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    cachedUint8ClampedArrayMemory0 = null;
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('udoc_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };