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

package/gen/wasm/trylimbo_sdk_verifier.js

@@ -39,26 +39,25 @@ export class AssetVerifier {
      *
      * # Errors
      *
-     * Throws on a malformed `input`, a repository (or binder) failure, or a validation
+     * Throws on a malformed `source`, a repository (or engine) failure, or a validation
      * failure.
-     * @param {RangeSource} input
+     * @param {RangeSource} source
      * @param {Recovery | null} [recovery]
-     * @returns {Promise<AssetVerification>}
+     * @returns {Promise<Verification>}
      */
-    verify(input, recovery) {
-        const ret = wasm.assetverifier_verify(this.__wbg_ptr, input, isLikeNone(recovery) ? 0 : addToExternrefTable0(recovery));
+    verify(source, recovery) {
+        const ret = wasm.assetverifier_verify(this.__wbg_ptr, source, isLikeNone(recovery) ? 0 : addToExternrefTable0(recovery));
         return ret;
     }
 }
 if (Symbol.dispose) AssetVerifier.prototype[Symbol.dispose] = AssetVerifier.prototype.free;
 
 /**
- * A [`RangeSource`](crate::wasm::RangeInput) over a `Blob`: a `File` off an `<input>`, a
+ * A `RangeSource` over a `Blob`: a `File` off an `<input>`, a
  * `Response.blob()`, a handle from the file system access API.
  *
- * 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.
+ * 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.
  *
  * # Worker only
  *
@@ -123,148 +122,6 @@ 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;
@@ -377,57 +234,9 @@ export class IntoUnderlyingSource {
 if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
 
 /**
- * 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.
+ * 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.
  */
 export class MemorySource {
     __destroy_into_raw() {
@@ -451,9 +260,7 @@ export class MemorySource {
      * @param {Uint8Array} data
      */
     constructor(data) {
-        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.memorysource_new(ptr0, len0);
+        const ret = wasm.memorysource_new(data);
         this.__wbg_ptr = ret;
         MemorySourceFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -492,8 +299,8 @@ export class StreamSession {
         wasm.__wbg_streamsession_free(ptr, 0);
     }
     /**
-     * Everything this stream's init segments have registered, as CBOR for another node to
-     * `StreamVerifier.resume` from.
+     * This stream's id and everything its 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
@@ -522,11 +329,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} data
+     * @param {RangeSource} source
      * @returns {Promise<SegmentValidation>}
      */
-    validate(data) {
-        const ret = wasm.streamsession_validate(this.__wbg_ptr, data);
+    validate(source) {
+        const ret = wasm.streamsession_validate(this.__wbg_ptr, source);
         return ret;
     }
 }
@@ -566,39 +373,37 @@ export class StreamVerifier {
         return StreamVerifier.__wrap(ret[0]);
     }
     /**
-     * Open `stream_id` for validation, handing back a `StreamSession` to feed segments to.
+     * Open the 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} stream_id
+     * @param {string} id
      * @returns {StreamSession}
      */
-    open(stream_id) {
-        const ptr0 = passStringToWasm0(stream_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    open(id) {
+        const ptr0 = passStringToWasm0(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 `stream_id` on the state another node exported, merged into whatever this one
-     * holds for that id already.
+     * Open the stream another node exported, its state merged into whatever this one holds
+     * for that stream already.
      *
      * # Errors
      *
-     * 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
+     * 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`).
      * @param {Uint8Array} state
      * @returns {StreamSession}
      */
-    resume(stream_id, state) {
-        const ptr0 = passStringToWasm0(stream_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    resume(state) {
+        const ptr0 = passArray8ToWasm0(state, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(state, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.streamverifier_resume(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.streamverifier_resume(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -607,6 +412,142 @@ 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();
 }
@@ -630,21 +571,12 @@ export function parse(manifest) {
     const ptr0 = passArray8ToWasm0(manifest, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.parse(ptr0, len0);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+    return ret;
 }
 
 /**
  * The bytes of one resource in a detached manifest store, or `undefined` when it holds none
- * 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.
+ * under `uri`: the `identifier` on a resource reference the parsed store carries.
  *
  * # Errors
  *
@@ -652,7 +584,7 @@ export function parse(manifest) {
  * holds the resource but cannot produce it.
  * @param {Uint8Array} manifest
  * @param {string} uri
- * @returns {Uint8Array | undefined}
+ * @returns {Promise<Uint8Array | undefined>}
  */
 export function resource(manifest, uri) {
     const ptr0 = passArray8ToWasm0(manifest, wasm.__wbindgen_malloc);
@@ -660,39 +592,7 @@ 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);
-    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]);
+    return ret;
 }
 function __wbg_get_imports() {
     const import0 = {
@@ -789,6 +689,14 @@ 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); },
@@ -1112,6 +1020,10 @@ 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;
@@ -1165,10 +1077,6 @@ 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;
         },
@@ -1248,6 +1156,10 @@ 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);
@@ -1259,23 +1171,27 @@ 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: 2054, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // 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`.
             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: 3951, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 5888, 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: 2728, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hcc9f2329e90526d5);
+            // 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);
             return ret;
         },
         __wbindgen_cast_0000000000000004: function(arg0) {
@@ -1303,6 +1219,20 @@ 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);
@@ -1319,8 +1249,8 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__hcc9f2329e90526d5(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hcc9f2329e90526d5(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__hbf782ef36cea6846(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hbf782ef36cea6846(arg0, arg1);
 }
 
 function wasm_bindgen__convert__closures_____invoke__hedf60f9cb8ab20c3(arg0, arg1, arg2) {
@@ -1355,12 +1285,6 @@ 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));
@@ -1370,9 +1294,6 @@ 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));
@@ -1382,6 +1303,9 @@ 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();
@@ -1458,6 +1382,17 @@ 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);