@trylimbo/sdk-verifier-wasm 0.2.25-canary.37 → 0.2.25

package/gen/wasm/trylimbo_sdk_verifier.js

@@ -39,25 +39,26 @@ export class AssetVerifier {
      *
      * # Errors
      *
-     * Throws on a malformed `source`, a repository (or engine) failure, or a validation
+     * Throws on a malformed `input`, a repository (or binder) failure, or a validation
      * failure.
-     * @param {RangeSource} source
+     * @param {RangeSource} input
      * @param {Recovery | null} [recovery]
-     * @returns {Promise<Verification>}
+     * @returns {Promise<AssetVerification>}
      */
-    verify(source, recovery) {
-        const ret = wasm.assetverifier_verify(this.__wbg_ptr, source, isLikeNone(recovery) ? 0 : addToExternrefTable0(recovery));
+    verify(input, recovery) {
+        const ret = wasm.assetverifier_verify(this.__wbg_ptr, input, isLikeNone(recovery) ? 0 : addToExternrefTable0(recovery));
         return ret;
     }
 }
 if (Symbol.dispose) AssetVerifier.prototype[Symbol.dispose] = AssetVerifier.prototype.free;
 
 /**
- * A `RangeSource` over a `Blob`: a `File` off an `<input>`, a
+ * A [`RangeSource`](crate::wasm::RangeInput) over a `Blob`: a `File` off an `<input>`, a
  * `Response.blob()`, a handle from the file system access API.
  *
- * It holds no bytes at all. The SDK reads one slice at a time, so an asset larger than the tab's
- * memory verifies at the disk's speed rather than the heap's.
+ * The only source here that holds nothing. The SDK reads one slice at a time, so an asset larger
+ * than the tab's memory verifies at the disk's speed rather than the heap's, and neither ceiling
+ * the other two carry applies.
  *
  * # Worker only
  *
@@ -122,6 +123,148 @@ export class BlobSource {
 }
 if (Symbol.dispose) BlobSource.prototype[Symbol.dispose] = BlobSource.prototype.free;
 
+/**
+ * A [`RangeSource`](crate::wasm::RangeInput) over bytes the caller already holds, read in place.
+ *
+ * [`MemorySource`] without the copy: the array stays on the JS side and only the window the SDK
+ * asks for crosses, so nothing is resident here and linear memory's 4 GiB ceiling never applies to
+ * the asset.
+ */
+export class BytesSource {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BytesSourceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bytessource_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.bytessource_length(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} data
+     */
+    constructor(data) {
+        const ret = wasm.bytessource_new(data);
+        this.__wbg_ptr = ret;
+        BytesSourceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} offset
+     * @param {number} length
+     * @returns {Uint8Array}
+     */
+    readAt(offset, length) {
+        const ret = wasm.bytessource_readAt(this.__wbg_ptr, offset, length);
+        return ret;
+    }
+}
+if (Symbol.dispose) BytesSource.prototype[Symbol.dispose] = BytesSource.prototype.free;
+
+/**
+ * @returns {string}
+ */
+export function C2PA_TRUST_LIST() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.C2PA_TRUST_LIST();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @returns {string}
+ */
+export function C2PA_TSA_TRUST_LIST() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.C2PA_TSA_TRUST_LIST();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @returns {string}
+ */
+export function DEV_CA() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.DEV_CA();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * A binder contributing a binding you already hold (e.g. an out-of-band video ISCC):
+ * `new HeldBinder(binding)`, the spelling the native lane uses. A verify takes it as data,
+ * `{ kind: "held", binding }`, in `recovery.binders`.
+ */
+export class HeldBinder {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HeldBinderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_heldbinder_free(ptr, 0);
+    }
+    /**
+     * Hand back the held binding; reads nothing.
+     *
+     * # Errors
+     *
+     * Throws when the source cannot be opened.
+     * @param {RangeSource} content
+     * @param {DeriveOptions} options
+     * @returns {Promise<SoftBinding | undefined>}
+     */
+    derive(content, options) {
+        const ret = wasm.heldbinder_derive(this.__wbg_ptr, content, options);
+        return ret;
+    }
+    /**
+     * # Errors
+     *
+     * Throws `SdkError.invalid` on a binding with an empty algorithm or value.
+     * @param {SoftBinding} binding
+     */
+    constructor(binding) {
+        const ret = wasm.heldbinder_new(binding);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        HeldBinderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) HeldBinder.prototype[Symbol.dispose] = HeldBinder.prototype.free;
+
 export class IntoUnderlyingByteSource {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -234,9 +377,57 @@ export class IntoUnderlyingSource {
 if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
 
 /**
- * A `RangeSource` over bytes the caller already holds, read in place: the array stays on the JS
- * side and only the window the SDK asks for crosses, so nothing is resident here and linear
- * memory's 4 GiB ceiling never applies to the asset.
+ * The SDK's local ISCC Image-Code binder, for a standalone `derive`: `new IsccBinder()`, the
+ * spelling the native lane uses. A verify takes it as data, `{ kind: "iscc" }`, in
+ * `recovery.binders`, because a class cannot cross into a worker.
+ *
+ * Vendor watermark detection is repository-side in this SDK: configured detectors participate in
+ * `verify` through `byContent`, while a held binder covers values already available to the caller.
+ */
+export class IsccBinder {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IsccBinderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_isccbinder_free(ptr, 0);
+    }
+    /**
+     * Derive the asset's ISCC standalone; `undefined` when the format yields none.
+     *
+     * # Errors
+     *
+     * Throws on malformed or unreadable input.
+     * @param {RangeSource} content
+     * @param {DeriveOptions} options
+     * @returns {Promise<SoftBinding | undefined>}
+     */
+    derive(content, options) {
+        const ret = wasm.isccbinder_derive(this.__wbg_ptr, content, options);
+        return ret;
+    }
+    constructor() {
+        const ret = wasm.isccbinder_new();
+        this.__wbg_ptr = ret;
+        IsccBinderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) IsccBinder.prototype[Symbol.dispose] = IsccBinder.prototype.free;
+
+/**
+ * An in-memory [`RangeSource`](crate::wasm::RangeInput), for a caller that already holds the whole
+ * asset as bytes.
+ *
+ * # Size ceiling
+ *
+ * The constructor copies the bytes into wasm linear memory, which is 32-bit addressed, so the
+ * asset and everything else the module allocates share a 4 GiB ceiling (a browser tab reaches its
+ * own memory limit well before that). [`BytesSource`] takes the same bytes without the copy, and
+ * [`BlobSource`] holds nothing at all.
  */
 export class MemorySource {
     __destroy_into_raw() {
@@ -260,7 +451,9 @@ export class MemorySource {
      * @param {Uint8Array} data
      */
     constructor(data) {
-        const ret = wasm.memorysource_new(data);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.memorysource_new(ptr0, len0);
         this.__wbg_ptr = ret;
         MemorySourceFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -299,8 +492,8 @@ export class StreamSession {
         wasm.__wbg_streamsession_free(ptr, 0);
     }
     /**
-     * This stream's id and everything its init segments have registered, as CBOR for another
-     * node to `StreamVerifier.resume` from.
+     * Everything this stream's init segments have registered, as CBOR for another node to
+     * `StreamVerifier.resume` from.
      *
      * The one piece of stream state that leaves the SDK, and only because a clustered
      * verifier needs it: the init URL is overwritten on rotation, so a node joining during
@@ -329,11 +522,11 @@ export class StreamSession {
      *
      * Throws an `SdkError` on parse or signature failure, or when a media segment arrives
      * before any init was processed for the stream.
-     * @param {RangeSource} source
+     * @param {RangeSource} data
      * @returns {Promise<SegmentValidation>}
      */
-    validate(source) {
-        const ret = wasm.streamsession_validate(this.__wbg_ptr, source);
+    validate(data) {
+        const ret = wasm.streamsession_validate(this.__wbg_ptr, data);
         return ret;
     }
 }
@@ -373,37 +566,39 @@ export class StreamVerifier {
         return StreamVerifier.__wrap(ret[0]);
     }
     /**
-     * Open the stream `id` for validation, handing back a `StreamSession` to feed segments to.
+     * Open `stream_id` for validation, handing back a `StreamSession` to feed segments to.
      *
      * No I/O: the handle carries the id so it cannot be mistyped or confused with another
      * stream's, and classification still happens per segment. Opening one id twice hands
      * back the same live session, so a component that remounts keeps the state its earlier
      * handle accumulated.
-     * @param {string} id
+     * @param {string} stream_id
      * @returns {StreamSession}
      */
-    open(id) {
-        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    open(stream_id) {
+        const ptr0 = passStringToWasm0(stream_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.streamverifier_open(this.__wbg_ptr, ptr0, len0);
         return StreamSession.__wrap(ret);
     }
     /**
-     * Open the stream another node exported, its state merged into whatever this one holds
-     * for that stream already.
+     * Open `stream_id` on the state another node exported, merged into whatever this one
+     * holds for that id already.
      *
      * # Errors
      *
-     * Throws an `SdkError` with a field violation at `state` when it is not a value
-     * `StreamSession.export` produced (`state.malformed`), or one of another export version
-     * (`state.version`).
+     * Throws an `SdkError` (`STREAM_INVALID`) when `state` is not a value
+     * `StreamSession.export` produced, or carries a version this SDK no longer reads.
+     * @param {string} stream_id
      * @param {Uint8Array} state
      * @returns {StreamSession}
      */
-    resume(state) {
-        const ptr0 = passArray8ToWasm0(state, wasm.__wbindgen_malloc);
+    resume(stream_id, state) {
+        const ptr0 = passStringToWasm0(stream_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.streamverifier_resume(this.__wbg_ptr, ptr0, len0);
+        const ptr1 = passArray8ToWasm0(state, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.streamverifier_resume(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -412,142 +607,6 @@ export class StreamVerifier {
 }
 if (Symbol.dispose) StreamVerifier.prototype[Symbol.dispose] = StreamVerifier.prototype.free;
 
-/**
- * One `verify` result held with the stores it read: `report` is the data, and `resource` reads a
- * thumbnail from credential `credential` (its position in `report.credentials`) by the
- * `identifier` of a resource reference in its manifest. A class rather than a field of the
- * report because a store cannot be serialized, and one handle per verify is what a worker can
- * proxy (a class nested in the report cannot cross a thread).
- */
-export class Verification {
-    static __wrap(ptr) {
-        const obj = Object.create(Verification.prototype);
-        obj.__wbg_ptr = ptr;
-        VerificationFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        VerificationFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_verification_free(ptr, 0);
-    }
-    /**
-     * The report: credentials, recovery, golden flow and verdict.
-     * @returns {AssetVerification}
-     */
-    get report() {
-        const ret = wasm.verification_report(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * The bytes of one resource credential `credential` holds, or `undefined`.
-     *
-     * # Errors
-     *
-     * Throws `READER_INVALID` when the store holds the resource but cannot produce it, and
-     * `undefined` for a `credential` out of range.
-     * @param {number} credential
-     * @param {string} uri
-     * @returns {Uint8Array | undefined}
-     */
-    resource(credential, uri) {
-        const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.verification_resource(this.__wbg_ptr, credential, ptr0, len0);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        let v2;
-        if (ret[0] !== 0) {
-            v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        }
-        return v2;
-    }
-}
-if (Symbol.dispose) Verification.prototype[Symbol.dispose] = Verification.prototype.free;
-
-/**
- * The bundled C2PA Conformance Program signing-CA trust list (a release snapshot). Trusted by
- * default with `trust.c2pa`; read it to pin or extend your own list.
- * @returns {string}
- */
-export function c2paTrustList() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-        const ret = wasm.c2paTrustList();
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-}
-
-/**
- * The bundled C2PA time-stamping-authority trust list (a release snapshot).
- * @returns {string}
- */
-export function c2paTsaTrustList() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-        const ret = wasm.c2paTsaTrustList();
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-}
-
-/**
- * The values this SDK computes for `alg` over `source`, `[]` when it finds none. `format` is
- * the asset's media type; omitted, the bytes name it.
- *
- * # Errors
- *
- * Throws on an algorithm this SDK computes no value of, a `format` that is no media type or that
- * the bytes contradict, an unreadable source, or no trustworthy answer.
- * @param {string} alg
- * @param {RangeSource} source
- * @param {string | null} [format]
- * @returns {Promise<Block[]>}
- */
-export function computeSoftBinding(alg, source, format) {
-    const ptr0 = passStringToWasm0(alg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(format) ? 0 : passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.computeSoftBinding(ptr0, len0, source, ptr1, len1);
-    return ret;
-}
-
-/**
- * PEM trust anchor for the Limbo Integrity development signing environment, **development
- * only**, no security guarantees: put it in `trust.anchors` for a development build, never in a
- * release.
- * @returns {string}
- */
-export function devCa() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-        const ret = wasm.devCa();
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-}
-
 export function init_panic_hook() {
     wasm.init_panic_hook();
 }
@@ -571,12 +630,21 @@ export function parse(manifest) {
     const ptr0 = passArray8ToWasm0(manifest, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.parse(ptr0, len0);
-    return ret;
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
  * The bytes of one resource in a detached manifest store, or `undefined` when it holds none
- * under `uri`: the `identifier` on a resource reference the parsed store carries.
+ * under `uri`.
+ *
+ * `uri` is the `identifier` on a resource reference the store carries, so walking the chain in
+ * the parsed store is what produces it: any manifest's claim thumbnail, including a non-active
+ * one, and any ingredient's. Render it with the `format` beside that identifier. A `uri` naming a
+ * manifest rather than a resource answers that manifest's own JUMBF, so pass what a reference
+ * states, never a bare label.
  *
  * # Errors
  *
@@ -584,7 +652,7 @@ export function parse(manifest) {
  * holds the resource but cannot produce it.
  * @param {Uint8Array} manifest
  * @param {string} uri
- * @returns {Promise<Uint8Array | undefined>}
+ * @returns {Uint8Array | undefined}
  */
 export function resource(manifest, uri) {
     const ptr0 = passArray8ToWasm0(manifest, wasm.__wbindgen_malloc);
@@ -592,7 +660,39 @@ export function resource(manifest, uri) {
     const ptr1 = passStringToWasm0(uri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
     const ret = wasm.resource(ptr0, len0, ptr1, len1);
-    return ret;
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    let v3;
+    if (ret[0] !== 0) {
+        v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v3;
+}
+
+/**
+ * Every thumbnail the store references, by the `identifier` it references them under: each
+ * manifest's claim thumbnail and each ingredient's, whichever manifest carries them.
+ *
+ * One parse for the whole set, where `resource` pays one per call, so a chain view asks once
+ * instead of once per tile. Render each one as the `format` beside its identifier. A reference
+ * the store cannot produce is left out rather than failing the set.
+ *
+ * # Errors
+ *
+ * Throws `READER_INVALID` when the bytes are not a manifest store c2pa can parse.
+ * @param {Uint8Array} manifest
+ * @returns {Record<string, Uint8Array>}
+ */
+export function thumbnails(manifest) {
+    const ptr0 = passArray8ToWasm0(manifest, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.thumbnails(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 function __wbg_get_imports() {
     const import0 = {
@@ -689,14 +789,6 @@ function __wbg_get_imports() {
         __wbg_abort_eee9248a6d680839: function(arg0, arg1) {
             arg0.abort(arg1);
         },
-        __wbg_aborted_2b7b403d16663f24: function(arg0) {
-            const ret = arg0.aborted;
-            return ret;
-        },
-        __wbg_any_a57fdb241e47190d: function(arg0) {
-            const ret = AbortSignal.any(arg0);
-            return ret;
-        },
         __wbg_append_01c74e5c6b58aa64: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
@@ -1020,10 +1112,6 @@ function __wbg_get_imports() {
             const ret = arg0.now();
             return ret;
         },
-        __wbg_of_5f1b88183ddb5d94: function(arg0, arg1) {
-            const ret = Array.of(arg0, arg1);
-            return ret;
-        },
         __wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
@@ -1077,6 +1165,10 @@ function __wbg_get_imports() {
         __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
+        __wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
         __wbg_set_8a16b38e4805b298: function(arg0, arg1, arg2) {
             arg0[arg1 >>> 0] = arg2;
         },
@@ -1156,10 +1248,6 @@ function __wbg_get_imports() {
             const ret = arg0.then(arg1);
             return ret;
         },
-        __wbg_timeout_c971ded6d319fad2: function(arg0) {
-            const ret = AbortSignal.timeout(arg0 >>> 0);
-            return ret;
-        },
         __wbg_url_abdb8fb08377f8c0: function(arg0, arg1) {
             const ret = arg1.url;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -1171,27 +1259,23 @@ function __wbg_get_imports() {
             const ret = arg0.value;
             return ret;
         },
-        __wbg_verification_new: function(arg0) {
-            const ret = Verification.__wrap(arg0);
-            return ret;
-        },
         __wbg_view_21f1d4a4f175dfa9: function(arg0) {
             const ret = arg0.view;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2185, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2054, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hfa954cb356c7e7e1);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 5888, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3951, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hedf60f9cb8ab20c3);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 3433, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hbf782ef36cea6846);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 2728, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hcc9f2329e90526d5);
             return ret;
         },
         __wbindgen_cast_0000000000000004: function(arg0) {
@@ -1219,20 +1303,6 @@ function __wbg_get_imports() {
             const ret = BigInt.asUintN(64, arg0);
             return ret;
         },
-        __wbindgen_cast_0000000000000009: function(arg0, arg1) {
-            var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
-            wasm.__wbindgen_free(arg0, arg1 * 4, 4);
-            // Cast intrinsic for `Vector(NamedExternref("Block")) -> Externref`.
-            const ret = v0;
-            return ret;
-        },
-        __wbindgen_cast_000000000000000a: function(arg0, arg1) {
-            var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
-            wasm.__wbindgen_free(arg0, arg1 * 1, 1);
-            // Cast intrinsic for `Vector(U8) -> Externref`.
-            const ret = v0;
-            return ret;
-        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -1249,8 +1319,8 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__hbf782ef36cea6846(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hbf782ef36cea6846(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__hcc9f2329e90526d5(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hcc9f2329e90526d5(arg0, arg1);
 }
 
 function wasm_bindgen__convert__closures_____invoke__hedf60f9cb8ab20c3(arg0, arg1, arg2) {
@@ -1285,6 +1355,12 @@ const AssetVerifierFinalization = (typeof FinalizationRegistry === 'undefined')
 const BlobSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_blobsource_free(ptr, 1));
+const BytesSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bytessource_free(ptr, 1));
+const HeldBinderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_heldbinder_free(ptr, 1));
 const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr, 1));
@@ -1294,6 +1370,9 @@ const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefin
 const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr, 1));
+const IsccBinderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_isccbinder_free(ptr, 1));
 const MemorySourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_memorysource_free(ptr, 1));
@@ -1303,9 +1382,6 @@ const StreamSessionFinalization = (typeof FinalizationRegistry === 'undefined')
 const StreamVerifierFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_streamverifier_free(ptr, 1));
-const VerificationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_verification_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -1382,17 +1458,6 @@ function debugString(val) {
     return className;
 }
 
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
-    }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
-}
-
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);