@freqhole/midden 0.1.31 → 0.2.1

package/midden_bg.js

@@ -11,7 +11,6 @@
  */
 export class BiStream {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(BiStream.prototype);
         obj.__wbg_ptr = ptr;
         BiStreamFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -147,7 +146,7 @@ export class BiStream {
      * race the QUIC flush -- the peer's `read_to_end` then errors with
      * "connection lost" mid-payload because the in-flight frames are
      * torn down with the connection. matters most for large payloads
-     * (e.g. base64-encoded blob bodies in `proxy_response`).
+     * (e.g. base64-encoded blob bodies in `api_response`).
      * @param {Uint8Array} data
      * @returns {Promise<void>}
      */
@@ -160,12 +159,120 @@ export class BiStream {
 }
 if (Symbol.dispose) BiStream.prototype[Symbol.dispose] = BiStream.prototype.free;
 
+/**
+ * incremental blake3 hasher for streaming uploads — feed fixed-size chunks
+ * via update() and read the final hex hash from finalize(). lets JS hash a
+ * File while streaming it (file.stream() reader loop) instead of holding
+ * the whole payload in memory for a one-shot hash_blake3().
+ */
+export class Blake3Hasher {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Blake3HasherFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_blake3hasher_free(ptr, 0);
+    }
+    /**
+     * finish and return the hash as a 64-char hex string. the hasher can
+     * keep absorbing after this (blake3 finalize is non-destructive), but
+     * callers should treat the session as done.
+     * @returns {string}
+     */
+    finalize() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.blake3hasher_finalize(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    constructor() {
+        const ret = wasm.blake3hasher_new();
+        this.__wbg_ptr = ret;
+        Blake3HasherFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * absorb the next chunk of data.
+     * @param {Uint8Array} chunk
+     */
+    update(chunk) {
+        const ptr0 = passArray8ToWasm0(chunk, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.blake3hasher_update(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) Blake3Hasher.prototype[Symbol.dispose] = Blake3Hasher.prototype.free;
+
+/**
+ * cooperative cancellation for in-flight downloads (pause/cancel from JS).
+ * the download loops select on `cancelled()` between progress events —
+ * cancellation takes effect at the next event boundary, and the partial
+ * data stays in the store, so a later download of the same hash resumes
+ * from the persisted bitfield (only missing ranges transfer).
+ */
+export class CancelToken {
+    static __wrap(ptr) {
+        const obj = Object.create(CancelToken.prototype);
+        obj.__wbg_ptr = ptr;
+        CancelTokenFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CancelTokenFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_canceltoken_free(ptr, 0);
+    }
+    /**
+     * request cancellation. idempotent.
+     */
+    cancel() {
+        wasm.canceltoken_cancel(this.__wbg_ptr);
+    }
+    /**
+     * return a new CancelToken sharing the same cancellation state.
+     * needed because passing a wasm class by value consumes the JS handle —
+     * callers keep the original and pass a clone into download calls.
+     * @returns {CancelToken}
+     */
+    clone_token() {
+        const ret = wasm.canceltoken_clone_token(this.__wbg_ptr);
+        return CancelToken.__wrap(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    is_cancelled() {
+        const ret = wasm.canceltoken_is_cancelled(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.canceltoken_new();
+        this.__wbg_ptr = ret;
+        CancelTokenFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) CancelToken.prototype[Symbol.dispose] = CancelToken.prototype.free;
+
 /**
  * result from fetching the server hello image from a peer
  */
 export class HelloImageResult {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(HelloImageResult.prototype);
         obj.__wbg_ptr = ptr;
         HelloImageResultFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -203,6 +310,65 @@ export class HelloImageResult {
 }
 if (Symbol.dispose) HelloImageResult.prototype[Symbol.dispose] = HelloImageResult.prototype.free;
 
+/**
+ * chunked import session — the streaming counterpart to import_blob.
+ *
+ * created via MiddenNode::start_import(). JS feeds fixed-size chunks with
+ * push() (backpressured: the promise resolves only once the chunk is
+ * queued), then finish() completes the import and returns the blake3 hash.
+ * the wasm boundary never sees the whole payload at once; the store's
+ * ImportByteStream machinery computes the bao tree incrementally.
+ *
+ * the finished blob is pinned in the node's active_tags (same as
+ * import_blob) until release_blob() is called.
+ */
+export class ImportSession {
+    static __wrap(ptr) {
+        const obj = Object.create(ImportSession.prototype);
+        obj.__wbg_ptr = ptr;
+        ImportSessionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ImportSessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_importsession_free(ptr, 0);
+    }
+    /**
+     * abort the import. any partially-imported data is left to GC.
+     */
+    abort() {
+        wasm.importsession_abort(this.__wbg_ptr);
+    }
+    /**
+     * signal end-of-stream, wait for the import to complete, pin the
+     * resulting blob, and return its blake3 hash as a hex string.
+     * @returns {Promise<string>}
+     */
+    finish() {
+        const ret = wasm.importsession_finish(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * queue the next chunk. resolves once the chunk has been accepted by
+     * the import stream (bounded channel — this is the backpressure point).
+     * @param {Uint8Array} chunk
+     * @returns {Promise<void>}
+     */
+    push(chunk) {
+        const ptr0 = passArray8ToWasm0(chunk, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.importsession_push(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) ImportSession.prototype[Symbol.dispose] = ImportSession.prototype.free;
+
 export class IntoUnderlyingByteSource {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -318,12 +484,11 @@ if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderly
  * browser P2P node for freqhole federation
  *
  * supports two protocols:
- * - freqhole/1: API proxying and small blob streaming
+ * - freqhole/1: API requests and small blob streaming
  * - iroh-blobs: verified streaming for audio files
  */
 export class MiddenNode {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(MiddenNode.prototype);
         obj.__wbg_ptr = ptr;
         MiddenNodeFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -363,6 +528,40 @@ export class MiddenNode {
         const ret = wasm.middennode_active_blob_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * send an API request to a peer
+     * peer_addr can be plain node_id or full endpoint JSON with relay/IP hints
+     * @param {string} peer_addr
+     * @param {string} method
+     * @param {string} path
+     * @param {string | null} [body]
+     * @returns {Promise<any>}
+     */
+    api_request(peer_addr, method, path, body) {
+        const ptr0 = passStringToWasm0(peer_addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(body) ? 0 : passStringToWasm0(body, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm.middennode_api_request(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        return ret;
+    }
+    /**
+     * PROTOTYPE: remove a hash's restriction, returning it to the default
+     * (served to anyone) state.
+     * @param {string} blake3_hash
+     */
+    clear_blob_restriction(blake3_hash) {
+        const ptr0 = passStringToWasm0(blake3_hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.middennode_clear_blob_restriction(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * compute blake3 hash for a blob on demand
      *
@@ -384,39 +583,70 @@ export class MiddenNode {
         return ret;
     }
     /**
-     * create a new node with random identity
-     * waits for relay connection before returning
+     * create a new node with random identity, an in-memory blob store, and
+     * the default ALPN set. waits for relay connection before returning.
+     *
+     * deprecated: use `create_with_options` instead.
+     *
+     * `connect_timeout_ms` is an optional per-dial timeout for `open_bi`
+     * (defaults to 10s when omitted/undefined).
+     * @param {number | null} [connect_timeout_ms]
      * @returns {Promise<MiddenNode>}
      */
-    static create() {
-        const ret = wasm.middennode_create();
+    static create(connect_timeout_ms) {
+        const ret = wasm.middennode_create(isLikeNone(connect_timeout_ms) ? Number.MAX_SAFE_INTEGER : (connect_timeout_ms) >>> 0);
         return ret;
     }
     /**
      * create a node from existing secret key bytes (for persistence)
-     * key_bytes must be exactly 32 bytes
+     * key_bytes must be exactly 32 bytes.
+     *
+     * deprecated: use `create_with_options` instead.
+     *
+     * `connect_timeout_ms` is an optional per-dial timeout for `open_bi`
+     * (defaults to 10s when omitted/undefined).
      * @param {Uint8Array} key_bytes
+     * @param {number | null} [connect_timeout_ms]
      * @returns {Promise<MiddenNode>}
      */
-    static create_from_key(key_bytes) {
+    static create_from_key(key_bytes, connect_timeout_ms) {
         const ptr0 = passArray8ToWasm0(key_bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.middennode_create_from_key(ptr0, len0);
+        const ret = wasm.middennode_create_from_key(ptr0, len0, isLikeNone(connect_timeout_ms) ? Number.MAX_SAFE_INTEGER : (connect_timeout_ms) >>> 0);
         return ret;
     }
     /**
      * create a node from existing secret key with additional ALPN protocols.
      *
+     * deprecated: use `create_with_options` instead.
+     *
      * `extra_alpns` is a JS array of strings (e.g. ["iroh/automerge-repo/1"]).
-     * the node always registers "freqhole/1" plus whatever extra ALPNs are given.
+     * the node always registers the default ALPN set plus whatever extra ALPNs are given.
+     *
+     * `connect_timeout_ms` is an optional per-dial timeout for `open_bi`
+     * (defaults to 10s when omitted/undefined).
      * @param {Uint8Array} key_bytes
      * @param {Array<any>} extra_alpns
+     * @param {number | null} [connect_timeout_ms]
      * @returns {Promise<MiddenNode>}
      */
-    static create_with_alpns(key_bytes, extra_alpns) {
+    static create_with_alpns(key_bytes, extra_alpns, connect_timeout_ms) {
         const ptr0 = passArray8ToWasm0(key_bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.middennode_create_with_alpns(ptr0, len0, extra_alpns);
+        const ret = wasm.middennode_create_with_alpns(ptr0, len0, extra_alpns, isLikeNone(connect_timeout_ms) ? Number.MAX_SAFE_INTEGER : (connect_timeout_ms) >>> 0);
+        return ret;
+    }
+    /**
+     * create a node from an options bag. this is the single canonical
+     * constructor — `create`/`create_from_key`/`create_with_alpns` below
+     * are deprecated wrappers kept for existing callers (spume, playlistz).
+     * @param {MiddenNodeOptions} options
+     * @returns {Promise<MiddenNode>}
+     */
+    static create_with_options(options) {
+        _assertClass(options, MiddenNodeOptions);
+        var ptr0 = options.__destroy_into_raw();
+        const ret = wasm.middennode_create_with_options(ptr0);
         return ret;
     }
     /**
@@ -460,6 +690,25 @@ export class MiddenNode {
         const ret = wasm.middennode_download_verified_by_id(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
+    /**
+     * full pipeline from blob_id with progress reporting.
+     *
+     * computes blake3 on demand, then uses verified download with progress.
+     * returns [data: Uint8Array, blake3: string].
+     * @param {string} peer_addr
+     * @param {string} blob_id
+     * @param {number} total_size
+     * @param {Function} on_progress
+     * @returns {Promise<Array<any>>}
+     */
+    download_verified_by_id_progress(peer_addr, blob_id, total_size, on_progress) {
+        const ptr0 = passStringToWasm0(peer_addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(blob_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.middennode_download_verified_by_id_progress(this.__wbg_ptr, ptr0, len0, ptr1, len1, total_size, on_progress);
+        return ret;
+    }
     /**
      * download a verified blob and stream chunks to JS via callback
      *
@@ -484,33 +733,46 @@ export class MiddenNode {
      * @param {number} total_size
      * @param {Function} on_chunk
      * @param {Function} on_progress
+     * @param {CancelToken | null} [cancel]
      * @returns {Promise<number>}
      */
-    download_verified_streaming(peer_addr, blake3_hash, total_size, on_chunk, on_progress) {
+    download_verified_streaming(peer_addr, blake3_hash, total_size, on_chunk, on_progress, cancel) {
         const ptr0 = passStringToWasm0(peer_addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(blake3_hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.middennode_download_verified_streaming(this.__wbg_ptr, ptr0, len0, ptr1, len1, total_size, on_chunk, on_progress);
+        let ptr2 = 0;
+        if (!isLikeNone(cancel)) {
+            _assertClass(cancel, CancelToken);
+            ptr2 = cancel.__destroy_into_raw();
+        }
+        const ret = wasm.middennode_download_verified_streaming(this.__wbg_ptr, ptr0, len0, ptr1, len1, total_size, on_chunk, on_progress, ptr2);
         return ret;
     }
     /**
      * streaming download with auto ensure+retry. first attempts the streaming
      * download; if the verified download fails (blob not in peer's store), calls
-     * ensure_blob to load it, then retries.
+     * ensure_blob to load it, then retries. a deliberate cancellation is NOT
+     * retried — it propagates immediately with the "download cancelled" message.
      * @param {string} peer_addr
      * @param {string} blake3_hash
      * @param {number} total_size
      * @param {Function} on_chunk
      * @param {Function} on_progress
+     * @param {CancelToken | null} [cancel]
      * @returns {Promise<number>}
      */
-    download_verified_streaming_with_ensure(peer_addr, blake3_hash, total_size, on_chunk, on_progress) {
+    download_verified_streaming_with_ensure(peer_addr, blake3_hash, total_size, on_chunk, on_progress, cancel) {
         const ptr0 = passStringToWasm0(peer_addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(blake3_hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.middennode_download_verified_streaming_with_ensure(this.__wbg_ptr, ptr0, len0, ptr1, len1, total_size, on_chunk, on_progress);
+        let ptr2 = 0;
+        if (!isLikeNone(cancel)) {
+            _assertClass(cancel, CancelToken);
+            ptr2 = cancel.__destroy_into_raw();
+        }
+        const ret = wasm.middennode_download_verified_streaming_with_ensure(this.__wbg_ptr, ptr0, len0, ptr1, len1, total_size, on_chunk, on_progress, ptr2);
         return ret;
     }
     /**
@@ -530,6 +792,71 @@ export class MiddenNode {
         const ret = wasm.middennode_download_verified_with_ensure(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
+    /**
+     * download with ensure + retry and progress reporting.
+     *
+     * tries download first; if blob not in peer's FsStore, calls ensure_blob
+     * then retries. progress callback receives fraction (0.0 to 1.0).
+     * `cancel`: optional cooperative cancellation (pause) — a deliberate
+     * cancellation is NOT retried, it propagates immediately.
+     *
+     * NOTE: any failure on the first attempt triggers this same
+     * ensure-then-retry fallback, not just the "blob not in FsStore yet"
+     * case the fallback was designed for. for a large blob, the first
+     * attempt can stream a substantial fraction of the bytes (driving
+     * `on_progress` most/all of the way to 1.0) before failing late, so the
+     * caller-visible symptom is a full 0->100% progress cycle that silently
+     * restarts from 0 for a second full cycle. logging the first attempt's
+     * error and explicitly resetting progress to 0 here makes this restart
+     * visible/diagnosable instead of looking like a silent glitch.
+     * @param {string} peer_addr
+     * @param {string} blake3_hash
+     * @param {number} total_size
+     * @param {Function} on_progress
+     * @param {CancelToken | null} [cancel]
+     * @returns {Promise<Uint8Array>}
+     */
+    download_verified_with_ensure_progress(peer_addr, blake3_hash, total_size, on_progress, cancel) {
+        const ptr0 = passStringToWasm0(peer_addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(blake3_hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        let ptr2 = 0;
+        if (!isLikeNone(cancel)) {
+            _assertClass(cancel, CancelToken);
+            ptr2 = cancel.__destroy_into_raw();
+        }
+        const ret = wasm.middennode_download_verified_with_ensure_progress(this.__wbg_ptr, ptr0, len0, ptr1, len1, total_size, on_progress, ptr2);
+        return ret;
+    }
+    /**
+     * download a blob with progress reporting via JS callback
+     *
+     * same as download_verified but calls on_progress(fraction) where
+     * fraction is bytes_received / total_size (0.0 to 1.0).
+     * total_size should come from the caller's known size field.
+     * `cancel`: optional cooperative cancellation (pause) — see
+     * download_verified_streaming for the semantics.
+     * @param {string} peer_addr
+     * @param {string} blake3_hash
+     * @param {number} total_size
+     * @param {Function} on_progress
+     * @param {CancelToken | null} [cancel]
+     * @returns {Promise<Uint8Array>}
+     */
+    download_verified_with_progress(peer_addr, blake3_hash, total_size, on_progress, cancel) {
+        const ptr0 = passStringToWasm0(peer_addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(blake3_hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        let ptr2 = 0;
+        if (!isLikeNone(cancel)) {
+            _assertClass(cancel, CancelToken);
+            ptr2 = cancel.__destroy_into_raw();
+        }
+        const ret = wasm.middennode_download_verified_with_progress(this.__wbg_ptr, ptr0, len0, ptr1, len1, total_size, on_progress, ptr2);
+        return ret;
+    }
     /**
      * ensure a blob is loaded into the peer's FsStore by blake3 hash
      *
@@ -563,7 +890,7 @@ export class MiddenNode {
         return ret;
     }
     /**
-     * check whether a blob with the given blake3 hash is currently held in the MemStore
+     * check whether a blob with the given blake3 hash is currently held in the store
      * via an active TempTag. avoids expensive OPFS read + bao recomputation when the
      * blob is already loaded.
      * @param {string} blake3_hash
@@ -575,6 +902,20 @@ export class MiddenNode {
         const ret = wasm.middennode_has_active_blob(this.__wbg_ptr, ptr0, len0);
         return ret !== 0;
     }
+    /**
+     * check whether a COMPLETE blob with this hash exists in the blob store
+     * itself — with the persistent opfs store this is true across reloads,
+     * even when no TempTag pins it. lets serving paths skip re-imports
+     * entirely.
+     * @param {string} blake3_hash
+     * @returns {Promise<boolean>}
+     */
+    has_complete_blob(blake3_hash) {
+        const ptr0 = passStringToWasm0(blake3_hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.middennode_has_complete_blob(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * import a blob from its pre-computed bao-encoded bytes, skipping the
      * expensive bao tree computation. `blake3_hash` is the 64-char hex hash,
@@ -600,7 +941,7 @@ export class MiddenNode {
      * import raw bytes into the iroh-blobs store, returning the blake3 hash.
      * this makes the blob available for verified download by peers.
      * the blob stays in the store as long as its TempTag is held in active_tags.
-     * call release_blob() to allow GC, or it will be evicted when the map exceeds 3 entries.
+     * call release_blob() to allow GC.
      * @param {Uint8Array} data
      * @returns {Promise<string>}
      */
@@ -625,6 +966,34 @@ export class MiddenNode {
         const ret = wasm.middennode_import_blob_and_export_bao(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * get our full endpoint address as JSON (node_id + relay url + any direct addrs).
+     *
+     * after `online()` has resolved this includes the home relay url, which is
+     * enough for a remote peer to dial us directly via the relay without doing
+     * a pkarr/DNS discovery lookup first. pass the returned string straight to
+     * `open_bi`/`connect` on the other side - `parse_peer_addr` accepts this
+     * same JSON shape. avoids the discovery propagation race on fresh boots.
+     * @returns {string}
+     */
+    node_addr() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.middennode_node_addr(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * get our node_id (iroh public key)
      * @returns {string}
@@ -645,7 +1014,7 @@ export class MiddenNode {
      * open a bidirectional stream to a peer on a specific ALPN.
      *
      * `peer_addr` can be a plain node_id hex string or a full endpoint
-     * address JSON (same format as proxy_request). `alpn` is the protocol
+     * address JSON (same format as api_request). `alpn` is the protocol
      * to negotiate (e.g. "iroh/automerge-repo/1").
      *
      * returns a BiStream for length-delimited message exchange.
@@ -661,6 +1030,20 @@ export class MiddenNode {
         const ret = wasm.middennode_open_bi(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
+    /**
+     * pin a hash so gc won't sweep it (e.g. a paused partial download).
+     * idempotent. pair with unprotect_blob when the partial is resumed to
+     * completion or discarded.
+     * @param {string} blake3_hash
+     */
+    protect_blob(blake3_hash) {
+        const ptr0 = passStringToWasm0(blake3_hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.middennode_protect_blob(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * dispatch a typed admin command to a peer over the freqhole-admin/1 ALPN.
      *
@@ -683,27 +1066,6 @@ export class MiddenNode {
         const ret = wasm.middennode_proxy_admin(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
         return ret;
     }
-    /**
-     * send an API request to a peer
-     * peer_addr can be plain node_id or full endpoint JSON with relay/IP hints
-     * @param {string} peer_addr
-     * @param {string} method
-     * @param {string} path
-     * @param {string | null} [body]
-     * @returns {Promise<any>}
-     */
-    proxy_request(peer_addr, method, path, body) {
-        const ptr0 = passStringToWasm0(peer_addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        var ptr3 = isLikeNone(body) ? 0 : passStringToWasm0(body, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len3 = WASM_VECTOR_LEN;
-        const ret = wasm.middennode_proxy_request(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
-        return ret;
-    }
     /**
      * release a blob's TempTag, allowing the store to garbage-collect it.
      * blake3_hash should be the 64-char hex string returned by import_blob.
@@ -717,6 +1079,27 @@ export class MiddenNode {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * PROTOTYPE: restrict a blob (by blake3 hex hash) so only the given
+     * peer node ids may fetch it over the `iroh-blobs/*` ALPN. a hash with
+     * no restriction registered is served to anyone (today's default
+     * behavior, unchanged) — calling this is what opts a specific hash
+     * into gating.
+     *
+     * this is a stopgap/demo hook, not the real canvas-ACL integration: it
+     * has to be called explicitly, from JS, with an already-resolved list
+     * of allowed peer node ids for this one hash.
+     * @param {string} blake3_hash
+     * @param {Array<any>} peer_node_ids
+     */
+    restrict_blob_to_peers(blake3_hash, peer_node_ids) {
+        const ptr0 = passStringToWasm0(blake3_hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.middennode_restrict_blob_to_peers(this.__wbg_ptr, ptr0, len0, peer_node_ids);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * get the secret key bytes for persistence (32 bytes)
      * store this in IndexedDB to maintain the same identity across sessions
@@ -746,6 +1129,16 @@ export class MiddenNode {
     start_blob_server() {
         wasm.middennode_start_blob_server(this.__wbg_ptr);
     }
+    /**
+     * begin a chunked import — the streaming counterpart to import_blob for
+     * payloads that shouldn't be materialized as one contiguous &[u8] across
+     * the wasm boundary. see ImportSession for the push/finish protocol.
+     * @returns {ImportSession}
+     */
+    start_import() {
+        const ret = wasm.middennode_start_import(this.__wbg_ptr);
+        return ImportSession.__wrap(ret);
+    }
     /**
      * connect to a freqhole radio broadcaster.
      *
@@ -775,9 +1168,128 @@ export class MiddenNode {
         const ret = wasm.middennode_tune_radio(this.__wbg_ptr, ptr0, len0, ptr1, len1, on_hello, on_meta, on_chunk);
         return ret;
     }
+    /**
+     * remove a gc pin added by protect_blob (or by a cancelled download).
+     * @param {string} blake3_hash
+     */
+    unprotect_blob(blake3_hash) {
+        const ptr0 = passStringToWasm0(blake3_hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.middennode_unprotect_blob(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
 }
 if (Symbol.dispose) MiddenNode.prototype[Symbol.dispose] = MiddenNode.prototype.free;
 
+/**
+ * options bag for `MiddenNode::create_with_options`, the single canonical
+ * constructor. build one, set whichever fields are needed, and pass it in:
+ *
+ * ```js
+ * const opts = new MiddenNodeOptions();
+ * opts.opfs_store_dir = "midden-blob-store";
+ * opts.connect_timeout_ms = 5000;
+ * const node = await MiddenNode.create_with_options(opts);
+ * ```
+ *
+ * `create`/`create_from_key`/`create_with_alpns` remain as deprecated
+ * wrappers over this constructor for existing callers (spume, playlistz).
+ */
+export class MiddenNodeOptions {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MiddenNodeOptionsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_middennodeoptions_free(ptr, 0);
+    }
+    /**
+     * per-dial timeout (ms) for `open_bi`/`connect` (defaults to 10s).
+     * @returns {number | undefined}
+     */
+    get connect_timeout_ms() {
+        const ret = wasm.middennodeoptions_get_connect_timeout_ms(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * additional ALPN protocols to register beyond the default set.
+     * @returns {string[] | undefined}
+     */
+    get extra_alpns() {
+        const ret = wasm.middennodeoptions_get_extra_alpns(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
+    /**
+     * when given, blobs persist in an OPFS-backed store under this
+     * directory (worker context required); otherwise (or when OPFS is
+     * unavailable) an in-memory store is used.
+     * @returns {string | undefined}
+     */
+    get opfs_store_dir() {
+        const ret = wasm.middennodeoptions_get_opfs_store_dir(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * the node's secret key (32 raw bytes). omit (or pass null/undefined)
+     * to generate a random identity.
+     * @returns {Uint8Array | undefined}
+     */
+    get secret_key() {
+        const ret = wasm.middennodeoptions_get_secret_key(this.__wbg_ptr);
+        return ret;
+    }
+    constructor() {
+        const ret = wasm.middennodeoptions_new();
+        this.__wbg_ptr = ret;
+        MiddenNodeOptionsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number | null} [ms]
+     */
+    set connect_timeout_ms(ms) {
+        wasm.middennodeoptions_set_connect_timeout_ms(this.__wbg_ptr, isLikeNone(ms) ? Number.MAX_SAFE_INTEGER : (ms) >>> 0);
+    }
+    /**
+     * @param {string[] | null} [alpns]
+     */
+    set extra_alpns(alpns) {
+        var ptr0 = isLikeNone(alpns) ? 0 : passArrayJsValueToWasm0(alpns, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.middennodeoptions_set_extra_alpns(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string | null} [dir]
+     */
+    set opfs_store_dir(dir) {
+        var ptr0 = isLikeNone(dir) ? 0 : passStringToWasm0(dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.middennodeoptions_set_opfs_store_dir(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {Uint8Array | null} [key]
+     */
+    set secret_key(key) {
+        wasm.middennodeoptions_set_secret_key(this.__wbg_ptr, isLikeNone(key) ? 0 : addToExternrefTable0(key));
+    }
+}
+if (Symbol.dispose) MiddenNodeOptions.prototype[Symbol.dispose] = MiddenNodeOptions.prototype.free;
+
 /**
  * handle returned to JS for a tuned-in radio session. dropping the handle
  * (or calling `leave()`) closes the iroh connection, which tears down both
@@ -785,7 +1297,6 @@ if (Symbol.dispose) MiddenNode.prototype[Symbol.dispose] = MiddenNode.prototype.
  */
 export class RadioHandle {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(RadioHandle.prototype);
         obj.__wbg_ptr = ptr;
         RadioHandleFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -831,10 +1342,33 @@ export function hash_blake3(data) {
     }
 }
 
+/**
+ * opfs store selftest — runs the full import/export round trip against
+ * real OPFS through the real iroh-blobs api. worker context required
+ * (sync access handles). wasm-only debug helper, used for manual
+ * debugging from the blob worker, not from automated tests.
+ * @returns {Promise<string>}
+ */
+export function opfs_store_selftest() {
+    const ret = wasm.opfs_store_selftest();
+    return ret;
+}
+
+/**
+ * persistence selftest: blobs + tags survive a store shutdown/reopen over
+ * the same OPFS directory. worker context required. wasm-only debug
+ * helper, used for manual debugging from the blob worker.
+ * @returns {Promise<string>}
+ */
+export function opfs_store_selftest_persistence() {
+    const ret = wasm.opfs_store_selftest_persistence();
+    return ret;
+}
+
 export function start() {
     wasm.start();
 }
-export function __wbg_Error_83742b46f01ce22d(arg0, arg1) {
+export function __wbg_Error_92b29b0548f8b746(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return ret;
 }
@@ -845,36 +1379,36 @@ export function __wbg_String_8564e559799eccda(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_boolean_get_c0f3f60bac5a78d1(arg0) {
+export function __wbg___wbindgen_boolean_get_fa956cfa2d1bd751(arg0) {
     const v = arg0;
     const ret = typeof(v) === 'boolean' ? v : undefined;
     return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
 }
-export function __wbg___wbindgen_debug_string_5398f5bb970e0daa(arg0, arg1) {
+export function __wbg___wbindgen_debug_string_c25d447a39f5578f(arg0, arg1) {
     const ret = debugString(arg1);
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_is_function_3c846841762788c1(arg0) {
+export function __wbg___wbindgen_is_function_1ff95bcc5517c252(arg0) {
     const ret = typeof(arg0) === 'function';
     return ret;
 }
-export function __wbg___wbindgen_is_object_781bc9f159099513(arg0) {
+export function __wbg___wbindgen_is_object_a27215656b807791(arg0) {
     const val = arg0;
     const ret = typeof(val) === 'object' && val !== null;
     return ret;
 }
-export function __wbg___wbindgen_is_string_7ef6b97b02428fae(arg0) {
+export function __wbg___wbindgen_is_string_ea5e6cc2e4141dfe(arg0) {
     const ret = typeof(arg0) === 'string';
     return ret;
 }
-export function __wbg___wbindgen_is_undefined_52709e72fb9f179c(arg0) {
+export function __wbg___wbindgen_is_undefined_c05833b95a3cf397(arg0) {
     const ret = arg0 === undefined;
     return ret;
 }
-export function __wbg___wbindgen_string_get_395e606bd0ee4427(arg0, arg1) {
+export function __wbg___wbindgen_string_get_b0ca35b86a603356(arg0, arg1) {
     const obj = arg1;
     const ret = typeof(obj) === 'string' ? obj : undefined;
     var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -882,25 +1416,25 @@ export function __wbg___wbindgen_string_get_395e606bd0ee4427(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_throw_6ddd609b62940d55(arg0, arg1) {
+export function __wbg___wbindgen_throw_344f42d3211c4765(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg__wbg_cb_unref_6b5b6b8576d35cb1(arg0) {
+export function __wbg__wbg_cb_unref_fffb441def202758(arg0) {
     arg0._wbg_cb_unref();
 }
-export function __wbg_abort_5ef96933660780b7(arg0) {
+export function __wbg_abort_8bae0f33e7833997(arg0) {
     arg0.abort();
 }
-export function __wbg_abort_6479c2d794ebf2ee(arg0, arg1) {
+export function __wbg_abort_eee9248a6d680839(arg0, arg1) {
     arg0.abort(arg1);
 }
-export function __wbg_addEventListener_3f4b57aea6662d2e() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_addEventListener_c33b246adf950d7c() { return handleError(function (arg0, arg1, arg2, arg3) {
     arg0.addEventListener(getStringFromWasm0(arg1, arg2), arg3);
 }, arguments); }
-export function __wbg_append_608dfb635ee8998f() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_append_01c74e5c6b58aa64() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments); }
-export function __wbg_arrayBuffer_eb8e9ca620af2a19() { return handleError(function (arg0) {
+export function __wbg_arrayBuffer_3b637f0fa65c5351() { return handleError(function (arg0) {
     const ret = arg0.arrayBuffer();
     return ret;
 }, arguments); }
@@ -908,75 +1442,86 @@ export function __wbg_bistream_new(arg0) {
     const ret = BiStream.__wrap(arg0);
     return ret;
 }
-export function __wbg_body_ac1dad652946e6da(arg0) {
+export function __wbg_body_18c9f2ac15ead4b2(arg0) {
     const ret = arg0.body;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 }
-export function __wbg_buffer_60b8043cd926067d(arg0) {
+export function __wbg_buffer_54b87055582c8a81(arg0) {
     const ret = arg0.buffer;
     return ret;
 }
-export function __wbg_byobRequest_6342e5f2b232c0f9(arg0) {
+export function __wbg_byobRequest_06b654bb15590436(arg0) {
     const ret = arg0.byobRequest;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 }
-export function __wbg_byteLength_607b856aa6c5a508(arg0) {
+export function __wbg_byteLength_41862ca4020b9c43(arg0) {
     const ret = arg0.byteLength;
     return ret;
 }
-export function __wbg_byteOffset_b26b63681c83856c(arg0) {
+export function __wbg_byteOffset_d42e18c4441f628b(arg0) {
     const ret = arg0.byteOffset;
     return ret;
 }
-export function __wbg_call_2d781c1f4d5c0ef8() { return handleError(function (arg0, arg1, arg2) {
-    const ret = arg0.call(arg1, arg2);
+export function __wbg_call_44b7209e1e252e6a() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    const ret = arg0.call(arg1, arg2, arg3, arg4);
     return ret;
 }, arguments); }
-export function __wbg_call_dcc2662fa17a72cf() { return handleError(function (arg0, arg1, arg2, arg3) {
-    const ret = arg0.call(arg1, arg2, arg3);
+export function __wbg_call_8a2dd23819f8a60a() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
     return ret;
 }, arguments); }
-export function __wbg_call_f858478a02f9600f() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-    const ret = arg0.call(arg1, arg2, arg3, arg4);
+export function __wbg_call_a6e5c5dce5018821() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
     return ret;
 }, arguments); }
-export function __wbg_cancel_79b3bea07a1028e7(arg0) {
+export function __wbg_call_e3b662382210db98() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.call(arg1, arg2, arg3);
+    return ret;
+}, arguments); }
+export function __wbg_cancel_3983a93e24cc66b3(arg0) {
     const ret = arg0.cancel();
     return ret;
 }
-export function __wbg_catch_d7ed0375ab6532a5(arg0, arg1) {
+export function __wbg_catch_c1a60df4c30d76d3(arg0, arg1) {
     const ret = arg0.catch(arg1);
     return ret;
 }
-export function __wbg_clearTimeout_2256f1e7b94ef517(arg0) {
+export function __wbg_clearTimeout_333bba87532ab9d3(arg0) {
     const ret = clearTimeout(arg0);
     return ret;
 }
 export function __wbg_clearTimeout_47a40e3be01ed7a3() { return handleError(function (arg0, arg1) {
     arg0.clearTimeout(arg1);
 }, arguments); }
-export function __wbg_close_690d36108c557337() { return handleError(function (arg0) {
+export function __wbg_close_249a23304523681b() { return handleError(function (arg0) {
     arg0.close();
 }, arguments); }
-export function __wbg_close_737b4b1fbc658540() { return handleError(function (arg0) {
+export function __wbg_close_72d318d9c16e83ef() { return handleError(function (arg0) {
     arg0.close();
 }, arguments); }
-export function __wbg_close_af26905c832a88cb() { return handleError(function (arg0) {
+export function __wbg_close_c65ca0257e895318() { return handleError(function (arg0) {
     arg0.close();
 }, arguments); }
-export function __wbg_code_aea376e2d265a64f(arg0) {
+export function __wbg_close_d00f4cb641f9db10(arg0) {
+    arg0.close();
+}
+export function __wbg_code_1fc52b4142a112ac(arg0) {
     const ret = arg0.code;
     return ret;
 }
-export function __wbg_code_bc4dde4d67926010(arg0) {
+export function __wbg_code_cb4327cfc515673b(arg0) {
     const ret = arg0.code;
     return ret;
 }
+export function __wbg_createSyncAccessHandle_0caafebe31e4f2d9(arg0) {
+    const ret = arg0.createSyncAccessHandle();
+    return ret;
+}
 export function __wbg_crypto_38df2bab126b63dc(arg0) {
     const ret = arg0.crypto;
     return ret;
 }
-export function __wbg_data_a3d9ff9cdd801002(arg0) {
+export function __wbg_data_328de4280640da92(arg0) {
     const ret = arg0.data;
     return ret;
 }
@@ -985,14 +1530,14 @@ export function __wbg_debug_eaef3b49d572d680(arg0, arg1) {
     wasm.__wbindgen_free(arg0, arg1 * 4, 4);
     console.debug(...v0);
 }
-export function __wbg_done_08ce71ee07e3bd17(arg0) {
+export function __wbg_done_89b2b13e91a60321(arg0) {
     const ret = arg0.done;
     return ret;
 }
-export function __wbg_enqueue_ec3552838b4b7fbf() { return handleError(function (arg0, arg1) {
+export function __wbg_enqueue_6d83b4c6281bafd6() { return handleError(function (arg0, arg1) {
     arg0.enqueue(arg1);
 }, arguments); }
-export function __wbg_entries_5b8fe91cea59610e(arg0) {
+export function __wbg_entries_900cefd6f70eb290(arg0) {
     const ret = arg0.entries();
     return ret;
 }
@@ -1012,45 +1557,64 @@ export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }
-export function __wbg_fetch_43b2f110608a59ff(arg0) {
+export function __wbg_fetch_074561c3e313c86f(arg0) {
     const ret = fetch(arg0);
     return ret;
 }
-export function __wbg_fetch_5550a88cf343aaa9(arg0, arg1) {
+export function __wbg_fetch_b5951fc96f52f786(arg0, arg1) {
     const ret = arg0.fetch(arg1);
     return ret;
 }
-export function __wbg_getRandomValues_76dfc69825c9c552() { return handleError(function (arg0, arg1) {
-    globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+export function __wbg_flush_a4bd8d4e05ad23f6() { return handleError(function (arg0) {
+    arg0.flush();
 }, arguments); }
+export function __wbg_getDirectoryHandle_cf175faf1a75a384(arg0, arg1, arg2, arg3) {
+    const ret = arg0.getDirectoryHandle(getStringFromWasm0(arg1, arg2), arg3);
+    return ret;
+}
+export function __wbg_getDirectory_389283588dfb8117(arg0) {
+    const ret = arg0.getDirectory();
+    return ret;
+}
+export function __wbg_getFileHandle_72de55ab3ca9ad57(arg0, arg1, arg2, arg3) {
+    const ret = arg0.getFileHandle(getStringFromWasm0(arg1, arg2), arg3);
+    return ret;
+}
 export function __wbg_getRandomValues_c44a50d8cfdaebeb() { return handleError(function (arg0, arg1) {
     arg0.getRandomValues(arg1);
 }, arguments); }
+export function __wbg_getRandomValues_cc7f052a444bb2ce() { return handleError(function (arg0, arg1) {
+    globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+}, arguments); }
 export function __wbg_getReader_9facd4f899beac89() { return handleError(function (arg0) {
     const ret = arg0.getReader();
     return ret;
 }, arguments); }
-export function __wbg_get_3ef1eba1850ade27() { return handleError(function (arg0, arg1) {
-    const ret = Reflect.get(arg0, arg1);
+export function __wbg_getSize_29187e13478442fb() { return handleError(function (arg0) {
+    const ret = arg0.getSize();
     return ret;
 }, arguments); }
-export function __wbg_get_a8ee5c45dabc1b3b(arg0, arg1) {
+export function __wbg_get_507a50627bffa49b(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
 }
-export function __wbg_get_done_d0ab690f8df5501f(arg0) {
+export function __wbg_get_78f252d074a84d0b() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
+export function __wbg_get_done_670108eb06ecbe46(arg0) {
     const ret = arg0.done;
     return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
 }
-export function __wbg_get_value_548ae6adf5a174e4(arg0) {
+export function __wbg_get_value_f465f5be30aa0963(arg0) {
     const ret = arg0.value;
     return ret;
 }
-export function __wbg_has_926ef2ff40b308cf() { return handleError(function (arg0, arg1) {
+export function __wbg_has_8374cf06984d8bfc() { return handleError(function (arg0, arg1) {
     const ret = Reflect.has(arg0, arg1);
     return ret;
 }, arguments); }
-export function __wbg_headers_eb2234545f9ff993(arg0) {
+export function __wbg_headers_cf9c80f30e2a4eff(arg0) {
     const ret = arg0.headers;
     return ret;
 }
@@ -1058,7 +1622,7 @@ export function __wbg_helloimageresult_new(arg0) {
     const ret = HelloImageResult.__wrap(arg0);
     return ret;
 }
-export function __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6(arg0) {
+export function __wbg_instanceof_ArrayBuffer_4480b9e0068a8adb(arg0) {
     let result;
     try {
         result = arg0 instanceof ArrayBuffer;
@@ -1068,7 +1632,7 @@ export function __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6(arg0) {
     const ret = result;
     return ret;
 }
-export function __wbg_instanceof_Blob_c91af000f11c2d0b(arg0) {
+export function __wbg_instanceof_Blob_c6523f92a32c8695(arg0) {
     let result;
     try {
         result = arg0 instanceof Blob;
@@ -1078,7 +1642,37 @@ export function __wbg_instanceof_Blob_c91af000f11c2d0b(arg0) {
     const ret = result;
     return ret;
 }
-export function __wbg_instanceof_Response_9b4d9fd451e051b1(arg0) {
+export function __wbg_instanceof_FileSystemDirectoryHandle_c9ab7c5cdb7a7c30(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof FileSystemDirectoryHandle;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_FileSystemFileHandle_68e80b30532d5f04(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof FileSystemFileHandle;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_FileSystemSyncAccessHandle_db0b7504516129c1(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof FileSystemSyncAccessHandle;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Response_c8b64b2256f01bec(arg0) {
     let result;
     try {
         result = arg0 instanceof Response;
@@ -1088,15 +1682,35 @@ export function __wbg_instanceof_Response_9b4d9fd451e051b1(arg0) {
     const ret = result;
     return ret;
 }
-export function __wbg_isArray_33b91feb269ff46e(arg0) {
+export function __wbg_instanceof_Window_05ba1ee4f6781663(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Window;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_WorkerGlobalScope_8ec07b5e040a41c3(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof WorkerGlobalScope;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_isArray_0677c962b281d01a(arg0) {
     const ret = Array.isArray(arg0);
     return ret;
 }
-export function __wbg_length_b3416cf66a5452c8(arg0) {
+export function __wbg_length_1f0964f4a5e2c6d8(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_ea16607d7b61445b(arg0) {
+export function __wbg_length_370319915dc99107(arg0) {
     const ret = arg0.length;
     return ret;
 }
@@ -1105,7 +1719,7 @@ export function __wbg_log_7a0760e115750083(arg0, arg1) {
     wasm.__wbindgen_free(arg0, arg1 * 4, 4);
     console.log(...v0);
 }
-export function __wbg_message_e959edc81e4b6cb7(arg0, arg1) {
+export function __wbg_message_fb0e6e7854e6ea7a(arg0, arg1) {
     const ret = arg1.message;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -1120,7 +1734,15 @@ export function __wbg_msCrypto_bd5a034af96bcba6(arg0) {
     const ret = arg0.msCrypto;
     return ret;
 }
-export function __wbg_new_0837727332ac86ba() { return handleError(function () {
+export function __wbg_navigator_51379c10a84aeec9(arg0) {
+    const ret = arg0.navigator;
+    return ret;
+}
+export function __wbg_navigator_99621db14b3f1099(arg0) {
+    const ret = arg0.navigator;
+    return ret;
+}
+export function __wbg_new_0d809930cd1354c6() { return handleError(function () {
     const ret = new Headers();
     return ret;
 }, arguments); }
@@ -1128,46 +1750,46 @@ export function __wbg_new_227d7c05414eb861() {
     const ret = new Error();
     return ret;
 }
-export function __wbg_new_49d5571bd3f0c4d4() {
-    const ret = new Map();
-    return ret;
-}
-export function __wbg_new_5f486cdf45a04d78(arg0) {
-    const ret = new Uint8Array(arg0);
-    return ret;
-}
-export function __wbg_new_a70fbab9066b301f() {
+export function __wbg_new_32b398fb48b6d94a() {
     const ret = new Array();
     return ret;
 }
-export function __wbg_new_ab79df5bd7c26067() {
-    const ret = new Object();
-    return ret;
-}
-export function __wbg_new_c518c60af666645b() { return handleError(function () {
+export function __wbg_new_4339b2a2675a03e3() { return handleError(function () {
     const ret = new AbortController();
     return ret;
 }, arguments); }
-export function __wbg_new_d15cb560a6a0e5f0(arg0, arg1) {
+export function __wbg_new_7796ffc7ed656783() {
+    const ret = new Map();
+    return ret;
+}
+export function __wbg_new_b667d279fd5aa943(arg0, arg1) {
     const ret = new Error(getStringFromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_dd50bcc3f60ba434() { return handleError(function (arg0, arg1) {
+export function __wbg_new_bf8729ffe10e9ee7() { return handleError(function (arg0, arg1) {
     const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
     return ret;
 }, arguments); }
-export function __wbg_new_from_slice_22da9388ac046e50(arg0, arg1) {
+export function __wbg_new_cd45aabdf6073e84(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+}
+export function __wbg_new_da52cf8fe3429cb2() {
+    const ret = new Object();
+    return ret;
+}
+export function __wbg_new_from_slice_77cdfb7977362f3c(arg0, arg1) {
     const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_typed_aaaeaf29cf802876(arg0, arg1) {
+export function __wbg_new_typed_1824d93f294193e5(arg0, arg1) {
     try {
         var state0 = {a: arg0, b: arg1};
         var cb0 = (arg0, arg1) => {
             const a = state0.a;
             state0.a = 0;
             try {
-                return wasm_bindgen__convert__closures_____invoke__h357561f53ac5f508(a, state0.b, arg0, arg1);
+                return wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___js_sys_4d6744c9ee3fc402___Function_fn_wasm_bindgen_eec8db4f48ed3396___JsValue_____wasm_bindgen_eec8db4f48ed3396___sys__Undefined___js_sys_4d6744c9ee3fc402___Function_fn_wasm_bindgen_eec8db4f48ed3396___JsValue_____wasm_bindgen_eec8db4f48ed3396___sys__Undefined_______true_(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -1175,26 +1797,26 @@ export function __wbg_new_typed_aaaeaf29cf802876(arg0, arg1) {
         const ret = new Promise(cb0);
         return ret;
     } finally {
-        state0.a = state0.b = 0;
+        state0.a = 0;
     }
 }
-export function __wbg_new_with_byte_offset_and_length_b2ec5bf7b2f35743(arg0, arg1, arg2) {
+export function __wbg_new_with_byte_offset_and_length_54c7724ee3ec7d82(arg0, arg1, arg2) {
     const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
     return ret;
 }
-export function __wbg_new_with_length_825018a1616e9e55(arg0) {
+export function __wbg_new_with_length_e6785c33c8e4cce8(arg0) {
     const ret = new Uint8Array(arg0 >>> 0);
     return ret;
 }
-export function __wbg_new_with_str_and_init_b4b54d1a819bc724() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_new_with_str_and_init_d95cbe11ce28e65e() { return handleError(function (arg0, arg1, arg2) {
     const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
 }, arguments); }
-export function __wbg_new_with_str_sequence_82c04ad794ead10e() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_new_with_str_sequence_2de2f569c29910ad() { return handleError(function (arg0, arg1, arg2) {
     const ret = new WebSocket(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
 }, arguments); }
-export function __wbg_next_11b99ee6237339e3() { return handleError(function (arg0) {
+export function __wbg_next_71f2aa1cb3d1e37e() { return handleError(function (arg0) {
     const ret = arg0.next();
     return ret;
 }, arguments); }
@@ -1202,7 +1824,7 @@ export function __wbg_node_84ea875411254db1(arg0) {
     const ret = arg0.node;
     return ret;
 }
-export function __wbg_now_16f0c993d5dd6c27() {
+export function __wbg_now_86c0d4ba3fa605b8() {
     const ret = Date.now();
     return ret;
 }
@@ -1218,25 +1840,25 @@ export function __wbg_process_44c7a14e11e9f69e(arg0) {
     const ret = arg0.process;
     return ret;
 }
-export function __wbg_protocol_1ac9e6bde227a312(arg0, arg1) {
+export function __wbg_protocol_14b3b1c4bf71cd4a(arg0, arg1) {
     const ret = arg1.protocol;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_prototypesetcall_d62e5099504357e6(arg0, arg1, arg2) {
+export function __wbg_prototypesetcall_4770620bbe4688a0(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
 }
-export function __wbg_push_e87b0e732085a946(arg0, arg1) {
+export function __wbg_push_d2ae3af0c1217ae6(arg0, arg1) {
     const ret = arg0.push(arg1);
     return ret;
 }
-export function __wbg_queueMicrotask_0c399741342fb10f(arg0) {
+export function __wbg_queueMicrotask_0ab5b2d2393e99b9(arg0) {
     const ret = arg0.queueMicrotask;
     return ret;
 }
-export function __wbg_queueMicrotask_a082d78ce798393e(arg0) {
+export function __wbg_queueMicrotask_6a09b7bc46549209(arg0) {
     queueMicrotask(arg0);
 }
 export function __wbg_radiohandle_new(arg0) {
@@ -1246,109 +1868,130 @@ export function __wbg_radiohandle_new(arg0) {
 export function __wbg_randomFillSync_6c25eac9869eb53c() { return handleError(function (arg0, arg1) {
     arg0.randomFillSync(arg1);
 }, arguments); }
-export function __wbg_read_7f593a961a7f80ed(arg0) {
+export function __wbg_random_039a7d5d06e0d333() {
+    const ret = Math.random();
+    return ret;
+}
+export function __wbg_read_27d98fb08886b1fc() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.read(getArrayU8FromWasm0(arg1, arg2), arg3);
+    return ret;
+}, arguments); }
+export function __wbg_read_8afa15f12a160ef8(arg0) {
     const ret = arg0.read();
     return ret;
 }
-export function __wbg_readyState_1f1e7f1bdf9f4d42(arg0) {
+export function __wbg_readyState_50bc38c2a9e83db6(arg0) {
     const ret = arg0.readyState;
     return ret;
 }
-export function __wbg_reason_cbcb9911796c4714(arg0, arg1) {
+export function __wbg_reason_5dc8e429d537d6a9(arg0, arg1) {
     const ret = arg1.reason;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_releaseLock_ef7766a5da654ff8(arg0) {
+export function __wbg_releaseLock_5b92874cad775644(arg0) {
     arg0.releaseLock();
 }
-export function __wbg_removeEventListener_c15bc311b6a5d11f() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_removeEntry_e38219fa4a98cfb3(arg0, arg1, arg2) {
+    const ret = arg0.removeEntry(getStringFromWasm0(arg1, arg2));
+    return ret;
+}
+export function __wbg_removeEventListener_eb8291c80ca9056d() { return handleError(function (arg0, arg1, arg2, arg3) {
     arg0.removeEventListener(getStringFromWasm0(arg1, arg2), arg3);
 }, arguments); }
 export function __wbg_require_b4edbdcf3e2a1ef0() { return handleError(function () {
     const ret = module.require;
     return ret;
 }, arguments); }
-export function __wbg_resolve_ae8d83246e5bcc12(arg0) {
+export function __wbg_resolve_2191a4dfe481c25b(arg0) {
     const ret = Promise.resolve(arg0);
     return ret;
 }
-export function __wbg_respond_e286ee502e7cf7e4() { return handleError(function (arg0, arg1) {
+export function __wbg_respond_510e32df8aeb6817() { return handleError(function (arg0, arg1) {
     arg0.respond(arg1 >>> 0);
 }, arguments); }
-export function __wbg_send_4a1dc66e8653e5ed() { return handleError(function (arg0, arg1, arg2) {
-    arg0.send(getStringFromWasm0(arg1, arg2));
-}, arguments); }
-export function __wbg_send_d31a693c975dea74() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_send_a321b376d40ec867() { return handleError(function (arg0, arg1, arg2) {
     arg0.send(getArrayU8FromWasm0(arg1, arg2));
 }, arguments); }
+export function __wbg_send_df98dd5ede9b3f4d() { return handleError(function (arg0, arg1, arg2) {
+    arg0.send(getStringFromWasm0(arg1, arg2));
+}, arguments); }
+export function __wbg_setTimeout_3a808dd861dd3c12(arg0, arg1) {
+    const ret = setTimeout(arg0, arg1);
+    return ret;
+}
 export function __wbg_setTimeout_6613a51400c1bf9f() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.setTimeout(arg1, arg2);
     return ret;
 }, arguments); }
-export function __wbg_setTimeout_b188b3bcc8977c7d(arg0, arg1) {
-    const ret = setTimeout(arg0, arg1);
-    return ret;
+export function __wbg_set_4d7dd76f3dae2926(arg0, arg1, arg2) {
+    arg0.set(getArrayU8FromWasm0(arg1, arg2));
 }
-export function __wbg_set_282384002438957f(arg0, arg1, arg2) {
-    arg0[arg1 >>> 0] = arg2;
+export function __wbg_set_575dd786d51585f8(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
 }
 export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
     arg0[arg1] = arg2;
 }
-export function __wbg_set_7eaa4f96924fd6b3() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_set_8535240470bf2500() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.set(arg0, arg1, arg2);
     return ret;
 }, arguments); }
-export function __wbg_set_8c0b3ffcf05d61c2(arg0, arg1, arg2) {
-    arg0.set(getArrayU8FromWasm0(arg1, arg2));
+export function __wbg_set_8a16b38e4805b298(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
 }
-export function __wbg_set_bf7251625df30a02(arg0, arg1, arg2) {
-    const ret = arg0.set(arg1, arg2);
-    return ret;
+export function __wbg_set_at_674f6538cd77adef(arg0, arg1) {
+    arg0.at = arg1;
 }
-export function __wbg_set_binaryType_3dcf8281ec100a8f(arg0, arg1) {
+export function __wbg_set_binaryType_a37b086c78ca7c29(arg0, arg1) {
     arg0.binaryType = __wbindgen_enum_BinaryType[arg1];
 }
-export function __wbg_set_body_a3d856b097dfda04(arg0, arg1) {
+export function __wbg_set_body_029f2d171e0a005f(arg0, arg1) {
     arg0.body = arg1;
 }
-export function __wbg_set_cache_ec7e430c6056ebda(arg0, arg1) {
+export function __wbg_set_cache_b4a740b195c051f4(arg0, arg1) {
     arg0.cache = __wbindgen_enum_RequestCache[arg1];
 }
-export function __wbg_set_credentials_ed63183445882c65(arg0, arg1) {
+export function __wbg_set_create_a807a6e9ac628698(arg0, arg1) {
+    arg0.create = arg1 !== 0;
+}
+export function __wbg_set_create_fa1dfa475fac91e9(arg0, arg1) {
+    arg0.create = arg1 !== 0;
+}
+export function __wbg_set_credentials_bb34a40189e3b43b(arg0, arg1) {
     arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
 }
-export function __wbg_set_handle_event_d54649fda219fb74(arg0, arg1) {
+export function __wbg_set_handle_event_dd6bc370a8cb4486(arg0, arg1) {
     arg0.handleEvent = arg1;
 }
-export function __wbg_set_headers_3c8fecc693b75327(arg0, arg1) {
+export function __wbg_set_headers_9c61d123c3ee1f10(arg0, arg1) {
     arg0.headers = arg1;
 }
-export function __wbg_set_method_8c015e8bcafd7be1(arg0, arg1, arg2) {
+export function __wbg_set_method_5532d59b92d76467(arg0, arg1, arg2) {
     arg0.method = getStringFromWasm0(arg1, arg2);
 }
-export function __wbg_set_mode_5a87f2c809cf37c2(arg0, arg1) {
+export function __wbg_set_mode_66c79886ad78fc05(arg0, arg1) {
     arg0.mode = __wbindgen_enum_RequestMode[arg1];
 }
-export function __wbg_set_onclose_8da801226bdd7a7b(arg0, arg1) {
+export function __wbg_set_onclose_f706475385ecce07(arg0, arg1) {
     arg0.onclose = arg1;
 }
-export function __wbg_set_onerror_901ca711f94a5bbb(arg0, arg1) {
+export function __wbg_set_onerror_9f5773fd31512333(arg0, arg1) {
     arg0.onerror = arg1;
 }
-export function __wbg_set_onmessage_6f80ab771bf151aa(arg0, arg1) {
+export function __wbg_set_onmessage_836d2f72130b4706(arg0, arg1) {
     arg0.onmessage = arg1;
 }
-export function __wbg_set_onopen_34e3e24cf9337ddd(arg0, arg1) {
+export function __wbg_set_onopen_4f65470ae522a61a(arg0, arg1) {
     arg0.onopen = arg1;
 }
-export function __wbg_set_signal_0cebecb698f25d21(arg0, arg1) {
+export function __wbg_set_signal_c4ef8faddb4c1446(arg0, arg1) {
     arg0.signal = arg1;
 }
-export function __wbg_signal_166e1da31adcac18(arg0) {
+export function __wbg_signal_dad7cb35193abd31(arg0) {
     const ret = arg0.signal;
     return ret;
 }
@@ -1359,53 +2002,64 @@ export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_static_accessor_GLOBAL_8adb955bd33fac2f() {
+export function __wbg_static_accessor_GLOBAL_4ef717fb391d88b7() {
     const ret = typeof global === 'undefined' ? null : global;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 }
-export function __wbg_static_accessor_GLOBAL_THIS_ad356e0db91c7913() {
+export function __wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4() {
     const ret = typeof globalThis === 'undefined' ? null : globalThis;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 }
-export function __wbg_static_accessor_SELF_f207c857566db248() {
+export function __wbg_static_accessor_SELF_146583524fe1469b() {
     const ret = typeof self === 'undefined' ? null : self;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 }
-export function __wbg_static_accessor_WINDOW_bb9f1ba69d61b386() {
+export function __wbg_static_accessor_WINDOW_f2829a2234d7819e() {
     const ret = typeof window === 'undefined' ? null : window;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 }
-export function __wbg_status_318629ab93a22955(arg0) {
+export function __wbg_status_c45b3b9b3033184a(arg0) {
     const ret = arg0.status;
     return ret;
 }
-export function __wbg_subarray_a068d24e39478a8a(arg0, arg1, arg2) {
-    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+export function __wbg_storage_3c893ad40b9e831e(arg0) {
+    const ret = arg0.storage;
     return ret;
 }
-export function __wbg_then_098abe61755d12f6(arg0, arg1) {
-    const ret = arg0.then(arg1);
+export function __wbg_storage_756400487605531a(arg0) {
+    const ret = arg0.storage;
+    return ret;
+}
+export function __wbg_subarray_3ed232c8a6baee09(arg0, arg1, arg2) {
+    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
     return ret;
 }
-export function __wbg_then_9e335f6dd892bc11(arg0, arg1, arg2) {
+export function __wbg_then_16d107c451e9905d(arg0, arg1, arg2) {
     const ret = arg0.then(arg1, arg2);
     return ret;
 }
-export function __wbg_url_778f9516ea867e17(arg0, arg1) {
+export function __wbg_then_6ec10ae38b3e92f7(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+}
+export function __wbg_truncate_98a6032d23095328() { return handleError(function (arg0, arg1) {
+    arg0.truncate(arg1);
+}, arguments); }
+export function __wbg_url_a410c0bec2fb1b2c(arg0, arg1) {
     const ret = arg1.url;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_url_7fefc1820fba4e0c(arg0, arg1) {
+export function __wbg_url_abdb8fb08377f8c0(arg0, arg1) {
     const ret = arg1.url;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_value_21fc78aab0322612(arg0) {
+export function __wbg_value_a5d5488a9589444a(arg0) {
     const ret = arg0.value;
     return ret;
 }
@@ -1413,7 +2067,7 @@ export function __wbg_versions_276b2795b1c6a219(arg0) {
     const ret = arg0.versions;
     return ret;
 }
-export function __wbg_view_f68a712e7315f8b2(arg0) {
+export function __wbg_view_21f1d4a4f175dfa9(arg0) {
     const ret = arg0.view;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 }
@@ -1422,71 +2076,70 @@ export function __wbg_warn_3a37cdd7216f1479(arg0, arg1) {
     wasm.__wbindgen_free(arg0, arg1 * 4, 4);
     console.warn(...v0);
 }
-export function __wbg_wasClean_69f68dc4ed2d2cc7(arg0) {
+export function __wbg_wasClean_3c7aa2335da09e74(arg0) {
     const ret = arg0.wasClean;
     return ret;
 }
+export function __wbg_write_e557b5312ec23477() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.write(getArrayU8FromWasm0(arg1, arg2), arg3);
+    return ret;
+}, arguments); }
 export function __wbindgen_cast_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 3029, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 3030, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hb183e556614092ca, wasm_bindgen__convert__closures_____invoke__hbe731298a115c9e4);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3530, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___wasm_bindgen_eec8db4f48ed3396___JsValue______true_);
     return ret;
 }
 export function __wbindgen_cast_0000000000000002(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 3185, function: Function { arguments: [], shim_idx: 3186, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h85ae81daf1218992, wasm_bindgen__convert__closures_____invoke__hc6f3654ebee0b80e);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 5576, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___wasm_bindgen_eec8db4f48ed3396___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_eec8db4f48ed3396___JsError___true_);
     return ret;
 }
 export function __wbindgen_cast_0000000000000003(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 3209, function: Function { arguments: [Externref], shim_idx: 3210, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h9c0e6de874b60dbc, wasm_bindgen__convert__closures_____invoke__hd1f261354767d15e);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2808, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___web_sys_a9844cda14584e26___features__gen_CloseEvent__CloseEvent______true_);
     return ret;
 }
 export function __wbindgen_cast_0000000000000004(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 3254, function: Function { arguments: [], shim_idx: 3255, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h23a1c12cd048d3cb, wasm_bindgen__convert__closures_____invoke__hfa08fd7116a7315b);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 4161, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___web_sys_a9844cda14584e26___features__gen_MessageEvent__MessageEvent______true_);
     return ret;
 }
 export function __wbindgen_cast_0000000000000005(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 3307, function: Function { arguments: [], shim_idx: 3308, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
-    const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hea58ba9208361aba, wasm_bindgen__convert__closures_____invoke__he25ef9f974db7a85);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 3449, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke_______true_);
     return ret;
 }
 export function __wbindgen_cast_0000000000000006(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 3728, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 3729, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__he82de21879ef6972, wasm_bindgen__convert__closures_____invoke__heb521225421210b0);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 3703, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+    const ret = makeClosure(arg0, arg1, wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke_______true__1_);
     return ret;
 }
 export function __wbindgen_cast_0000000000000007(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 5061, function: Function { arguments: [], shim_idx: 5062, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hc498dc21c6574762, wasm_bindgen__convert__closures_____invoke__he2934cb51e5b7bf4);
-    return ret;
-}
-export function __wbindgen_cast_0000000000000008(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 5070, function: Function { arguments: [Externref], shim_idx: 5071, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hb75a498ac0db6fe5, wasm_bindgen__convert__closures_____invoke__h190e8892b208884b);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 5540, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke_______true__2_);
     return ret;
 }
-export function __wbindgen_cast_0000000000000009(arg0) {
+export function __wbindgen_cast_0000000000000008(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;
     return ret;
 }
-export function __wbindgen_cast_000000000000000a(arg0) {
+export function __wbindgen_cast_0000000000000009(arg0) {
     // Cast intrinsic for `I64 -> Externref`.
     const ret = arg0;
     return ret;
 }
-export function __wbindgen_cast_000000000000000b(arg0, arg1) {
+export function __wbindgen_cast_000000000000000a(arg0, arg1) {
     // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
     const ret = getArrayU8FromWasm0(arg0, arg1);
     return ret;
 }
-export function __wbindgen_cast_000000000000000c(arg0, arg1) {
+export function __wbindgen_cast_000000000000000b(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 }
-export function __wbindgen_cast_000000000000000d(arg0) {
+export function __wbindgen_cast_000000000000000c(arg0) {
     // Cast intrinsic for `U64 -> Externref`.
     const ret = BigInt.asUintN(64, arg0);
     return ret;
@@ -1500,43 +2153,39 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
-function wasm_bindgen__convert__closures_____invoke__hc6f3654ebee0b80e(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hc6f3654ebee0b80e(arg0, arg1);
+function wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke_______true_(arg0, arg1) {
+    wasm.wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke_______true_(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__hfa08fd7116a7315b(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hfa08fd7116a7315b(arg0, arg1);
+function wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke_______true__1_(arg0, arg1) {
+    wasm.wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke_______true__1_(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__he25ef9f974db7a85(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__he25ef9f974db7a85(arg0, arg1);
+function wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke_______true__2_(arg0, arg1) {
+    wasm.wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke_______true__2_(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__he2934cb51e5b7bf4(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__he2934cb51e5b7bf4(arg0, arg1);
+function wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___wasm_bindgen_eec8db4f48ed3396___JsValue______true_(arg0, arg1, arg2) {
+    wasm.wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___wasm_bindgen_eec8db4f48ed3396___JsValue______true_(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__hbe731298a115c9e4(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hbe731298a115c9e4(arg0, arg1, arg2);
+function wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___web_sys_a9844cda14584e26___features__gen_CloseEvent__CloseEvent______true_(arg0, arg1, arg2) {
+    wasm.wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___web_sys_a9844cda14584e26___features__gen_CloseEvent__CloseEvent______true_(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__hd1f261354767d15e(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hd1f261354767d15e(arg0, arg1, arg2);
+function wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___web_sys_a9844cda14584e26___features__gen_MessageEvent__MessageEvent______true_(arg0, arg1, arg2) {
+    wasm.wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___web_sys_a9844cda14584e26___features__gen_MessageEvent__MessageEvent______true_(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__heb521225421210b0(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__heb521225421210b0(arg0, arg1, arg2);
-}
-
-function wasm_bindgen__convert__closures_____invoke__h190e8892b208884b(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h190e8892b208884b(arg0, arg1, arg2);
+function wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___wasm_bindgen_eec8db4f48ed3396___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_eec8db4f48ed3396___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___wasm_bindgen_eec8db4f48ed3396___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_eec8db4f48ed3396___JsError___true_(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h357561f53ac5f508(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h357561f53ac5f508(arg0, arg1, arg2, arg3);
+function wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___js_sys_4d6744c9ee3fc402___Function_fn_wasm_bindgen_eec8db4f48ed3396___JsValue_____wasm_bindgen_eec8db4f48ed3396___sys__Undefined___js_sys_4d6744c9ee3fc402___Function_fn_wasm_bindgen_eec8db4f48ed3396___JsValue_____wasm_bindgen_eec8db4f48ed3396___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_eec8db4f48ed3396___convert__closures_____invoke___js_sys_4d6744c9ee3fc402___Function_fn_wasm_bindgen_eec8db4f48ed3396___JsValue_____wasm_bindgen_eec8db4f48ed3396___sys__Undefined___js_sys_4d6744c9ee3fc402___Function_fn_wasm_bindgen_eec8db4f48ed3396___JsValue_____wasm_bindgen_eec8db4f48ed3396___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
 }
 
 
@@ -1555,25 +2204,37 @@ const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
 const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
 const BiStreamFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_bistream_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_bistream_free(ptr, 1));
+const Blake3HasherFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_blake3hasher_free(ptr, 1));
+const CancelTokenFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_canceltoken_free(ptr, 1));
 const HelloImageResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_helloimageresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_helloimageresult_free(ptr, 1));
+const ImportSessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_importsession_free(ptr, 1));
 const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr, 1));
 const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr, 1));
 const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr, 1));
 const MiddenNodeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_middennode_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_middennode_free(ptr, 1));
+const MiddenNodeOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_middennodeoptions_free(ptr, 1));
 const RadioHandleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_radiohandle_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_radiohandle_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -1581,9 +2242,15 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+    : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
 
 function debugString(val) {
     // primitive types
@@ -1675,8 +2342,7 @@ function getDataViewMemory0() {
 }
 
 function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
+    return decodeText(ptr >>> 0, len);
 }
 
 let cachedUint8ArrayMemory0 = null;
@@ -1700,8 +2366,8 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-function makeClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+function makeClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
     const real = (...args) => {
 
         // First up with a closure we increment the internal reference
@@ -1716,7 +2382,7 @@ function makeClosure(arg0, arg1, dtor, f) {
     };
     real._wbg_cb_unref = () => {
         if (--state.cnt === 0) {
-            state.dtor(state.a, state.b);
+            wasm.__wbindgen_destroy_closure(state.a, state.b);
             state.a = 0;
             CLOSURE_DTORS.unregister(state);
         }
@@ -1725,8 +2391,8 @@ function makeClosure(arg0, arg1, dtor, f) {
     return real;
 }
 
-function makeMutClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+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
@@ -1744,7 +2410,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     };
     real._wbg_cb_unref = () => {
         if (--state.cnt === 0) {
-            state.dtor(state.a, state.b);
+            wasm.__wbindgen_destroy_closure(state.a, state.b);
             state.a = 0;
             CLOSURE_DTORS.unregister(state);
         }
@@ -1760,6 +2426,16 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);