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

package/gen/wasm/worker-thread.js

@@ -37,24 +37,23 @@ var AssetVerifier = 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) {
-		return wasm.assetverifier_verify(this.__wbg_ptr, input, isLikeNone(recovery) ? 0 : addToExternrefTable0(recovery));
+	verify(source, recovery) {
+		return wasm.assetverifier_verify(this.__wbg_ptr, source, isLikeNone(recovery) ? 0 : addToExternrefTable0(recovery));
 	}
 };
 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
 *
@@ -113,138 +112,6 @@ var BlobSource = class {
 	}
 };
 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.
-*/
-var BytesSource = class {
-	__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() {
-		return wasm.bytessource_length(this.__wbg_ptr);
-	}
-	/**
-	* @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) {
-		return wasm.bytessource_readAt(this.__wbg_ptr, offset, length);
-	}
-};
-if (Symbol.dispose) BytesSource.prototype[Symbol.dispose] = BytesSource.prototype.free;
-/**
-* @returns {string}
-*/
-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}
-*/
-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}
-*/
-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`.
-*/
-var HeldBinder = class {
-	__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) {
-		return wasm.heldbinder_derive(this.__wbg_ptr, content, options);
-	}
-	/**
-	* # 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;
 var IntoUnderlyingByteSource = class {
 	__destroy_into_raw() {
 		const ptr = this.__wbg_ptr;
@@ -348,55 +215,9 @@ var IntoUnderlyingSource = class {
 };
 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.
-*/
-var IsccBinder = class {
-	__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) {
-		return wasm.isccbinder_derive(this.__wbg_ptr, content, options);
-	}
-	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.
 */
 var MemorySource = class {
 	__destroy_into_raw() {
@@ -419,9 +240,7 @@ var MemorySource = class {
 	* @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;
@@ -458,8 +277,8 @@ var StreamSession = 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
@@ -486,11 +305,11 @@ var StreamSession = 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) {
-		return wasm.streamsession_validate(this.__wbg_ptr, data);
+	validate(source) {
+		return wasm.streamsession_validate(this.__wbg_ptr, source);
 	}
 };
 if (Symbol.dispose) StreamSession.prototype[Symbol.dispose] = StreamSession.prototype.free;
@@ -526,45 +345,137 @@ var StreamVerifier = 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]);
 		return StreamSession.__wrap(ret[0]);
 	}
 };
 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).
+*/
+var Verification = 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() {
+		return wasm.verification_report(this.__wbg_ptr);
+	}
+	/**
+	* 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 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[]>}
+*/
+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;
+	return wasm.computeSoftBinding(ptr0, len0, source, ptr1, len1);
+}
+/**
+* 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}
+*/
+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);
+	}
+}
+/**
 * Parse a detached C2PA manifest store: a `.c2pa` sidecar, or the bytes a repository serves for a
 * manifest id.
 *
@@ -582,19 +493,11 @@ if (Symbol.dispose) StreamVerifier.prototype[Symbol.dispose] = StreamVerifier.pr
 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 wasm.parse(ptr0, len0);
 }
 /**
 * 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
 *
@@ -602,42 +505,14 @@ function parse(manifest) {
 * holds the resource but cannot produce it.
 * @param {Uint8Array} manifest
 * @param {string} uri
-* @returns {Uint8Array | undefined}
+* @returns {Promise<Uint8Array | undefined>}
 */
 function resource(manifest, uri) {
 	const ptr0 = passArray8ToWasm0(manifest, wasm.__wbindgen_malloc);
 	const len0 = WASM_VECTOR_LEN;
 	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>}
-*/
-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 wasm.resource(ptr0, len0, ptr1, len1);
 }
 function __wbg_get_imports() {
 	return {
@@ -724,6 +599,12 @@ function __wbg_get_imports() {
 			__wbg_abort_eee9248a6d680839: function(arg0, arg1) {
 				arg0.abort(arg1);
 			},
+			__wbg_aborted_2b7b403d16663f24: function(arg0) {
+				return arg0.aborted;
+			},
+			__wbg_any_a57fdb241e47190d: function(arg0) {
+				return AbortSignal.any(arg0);
+			},
 			__wbg_append_01c74e5c6b58aa64: function() {
 				return handleError(function(arg0, arg1, arg2, arg3, arg4) {
 					arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
@@ -1031,6 +912,9 @@ function __wbg_get_imports() {
 			__wbg_now_e7c6795a7f81e10f: function(arg0) {
 				return arg0.now();
 			},
+			__wbg_of_5f1b88183ddb5d94: function(arg0, arg1) {
+				return Array.of(arg0, arg1);
+			},
 			__wbg_parse_1c0d8a8656d7e016: function() {
 				return handleError(function(arg0, arg1) {
 					return JSON.parse(getStringFromWasm0(arg0, arg1));
@@ -1084,11 +968,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) {
-					return Reflect.set(arg0, arg1, arg2);
-				}, arguments);
-			},
 			__wbg_set_8a16b38e4805b298: function(arg0, arg1, arg2) {
 				arg0[arg1 >>> 0] = arg2;
 			},
@@ -1164,6 +1043,9 @@ function __wbg_get_imports() {
 			__wbg_then_6ec10ae38b3e92f7: function(arg0, arg1) {
 				return arg0.then(arg1);
 			},
+			__wbg_timeout_c971ded6d319fad2: function(arg0) {
+				return AbortSignal.timeout(arg0 >>> 0);
+			},
 			__wbg_url_abdb8fb08377f8c0: function(arg0, arg1) {
 				const ret = arg1.url;
 				const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -1174,6 +1056,9 @@ function __wbg_get_imports() {
 			__wbg_value_a5d5488a9589444a: function(arg0) {
 				return arg0.value;
 			},
+			__wbg_verification_new: function(arg0) {
+				return Verification.__wrap(arg0);
+			},
 			__wbg_view_21f1d4a4f175dfa9: function(arg0) {
 				const ret = arg0.view;
 				return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1185,7 +1070,7 @@ function __wbg_get_imports() {
 				return makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hedf60f9cb8ab20c3);
 			},
 			__wbindgen_cast_0000000000000003: function(arg0, arg1) {
-				return makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hcc9f2329e90526d5);
+				return makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hbf782ef36cea6846);
 			},
 			__wbindgen_cast_0000000000000004: function(arg0) {
 				return arg0;
@@ -1202,6 +1087,16 @@ function __wbg_get_imports() {
 			__wbindgen_cast_0000000000000008: function(arg0) {
 				return BigInt.asUintN(64, arg0);
 			},
+			__wbindgen_cast_0000000000000009: function(arg0, arg1) {
+				var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+				wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+				return v0;
+			},
+			__wbindgen_cast_000000000000000a: function(arg0, arg1) {
+				var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
+				wasm.__wbindgen_free(arg0, arg1 * 1, 1);
+				return v0;
+			},
 			__wbindgen_init_externref_table: function() {
 				const table = wasm.__wbindgen_externrefs;
 				const offset = table.grow(4);
@@ -1214,8 +1109,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) {
 	wasm.wasm_bindgen__convert__closures_____invoke__hedf60f9cb8ab20c3(arg0, arg1, arg2);
@@ -1255,14 +1150,6 @@ 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: () => {}
@@ -1275,10 +1162,6 @@ const IntoUnderlyingSourceFinalization = typeof FinalizationRegistry === "undefi
 	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: () => {}
@@ -1291,6 +1174,10 @@ 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();
 	wasm.__wbindgen_externrefs.set(idx, obj);
@@ -1334,6 +1221,14 @@ function debugString(val) {
 	if (val instanceof Error) return `${val.name}: ${val.message}\n${val.stack}`;
 	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);
@@ -1512,7 +1407,7 @@ async function __wbg_init(module_or_path) {
 * a slice and a local file. Choosing the store is all that is left here.
 */
 function source(asset) {
-	return asset instanceof Blob ? new BlobSource(asset) : new BytesSource(asset instanceof Uint8Array ? asset : new Uint8Array(asset));
+	return asset instanceof Blob ? new BlobSource(asset) : new MemorySource(asset instanceof Uint8Array ? asset : new Uint8Array(asset));
 }
 /**
 * The caller's asset as the bytes a manifest read takes. A `Blob` is read here rather than in the
@@ -1522,13 +1417,6 @@ async function bytes(asset) {
 	if (asset instanceof Blob) return new Uint8Array(await asset.arrayBuffer());
 	return asset instanceof Uint8Array ? asset : new Uint8Array(asset);
 }
-function binder(spec) {
-	switch (spec.kind) {
-		case "iscc": return new IsccBinder();
-		case "held": return new HeldBinder(spec.binding);
-		default: throw new TypeError(`unknown binder: ${JSON.stringify(spec)}`);
-	}
-}
 /**
 * A wasm object held in this thread on the caller's behalf.
 *
@@ -1549,10 +1437,23 @@ var Handle = class {
 		this.inner.free();
 	}
 };
+/**
+* One verify result. A wasm class cannot cross the thread, so the report and the stores behind it
+* stay here and the caller holds this: `report()` is the data, `resource()` reads a thumbnail from
+* a credential by its position in `report().credentials`.
+*/
+var VerificationHandle = class extends Handle {
+	report() {
+		return this.inner.report;
+	}
+	resource(credential, uri) {
+		return this.inner.resource(credential, uri);
+	}
+};
 var AssetVerifierHandle = class extends Handle {
 	/** `recovery` is what this verify may do to recover a manifest, as the direct import takes it. */
-	verify(asset, recovery) {
-		return this.inner.verify(source(asset), recovery);
+	async verify(asset, recovery) {
+		return proxy(new VerificationHandle(await this.inner.verify(source(asset), recovery)));
 	}
 };
 /** One stream being validated. Dropping the handle releases the session it accumulated. */
@@ -1565,11 +1466,11 @@ var StreamSessionHandle = class extends Handle {
 	}
 };
 var StreamVerifierHandle = class extends Handle {
-	open(streamId) {
-		return proxy(new StreamSessionHandle(this.inner.open(streamId)));
+	open(id) {
+		return proxy(new StreamSessionHandle(this.inner.open(id)));
 	}
-	resume(streamId, state) {
-		return proxy(new StreamSessionHandle(this.inner.resume(streamId, state)));
+	resume(state) {
+		return proxy(new StreamSessionHandle(this.inner.resume(state)));
 	}
 };
 let ready;
@@ -1585,12 +1486,13 @@ const sdk = {
 	},
 	AssetVerifier: proxy({ create: (options) => proxy(new AssetVerifierHandle(AssetVerifier.create(options))) }),
 	StreamVerifier: proxy({ create: (options) => proxy(new StreamVerifierHandle(StreamVerifier.create(options))) }),
-	Binder: proxy({ 
 	/**
-	* Derive one binder's binding standalone. The binder is built, used and dropped here, so there
-	* is no handle to keep: what the caller wants back is the binding.
+	* The values this SDK computes for `alg` over the asset, `[]` when it finds none. `format` is the
+	* asset's media type; omitted, the bytes name it.
 	*/
-derive: (spec, content, options) => binder(spec).derive(source(content), options) }),
+	computeSoftBinding(alg, asset, format) {
+		return computeSoftBinding(alg, source(asset), format);
+	},
 	/**
 	* Read a detached manifest store. Contents, not a verdict: with no asset there is no hard binding
 	* to check, so the store's validation fields state nothing this established.
@@ -1605,20 +1507,11 @@ derive: (spec, content, options) => binder(spec).derive(source(content), options
 	async resource(manifest, uri) {
 		return resource(await bytes(manifest), uri);
 	},
-	/**
-	* Every thumbnail the store references, by the identifier it references them under. One parse
-	* and one thread hop for the whole set, where `resource` pays both per call.
-	*/
-	async thumbnails(manifest) {
-		return thumbnails(await bytes(manifest));
-	},
-	C2PA_TRUST_LIST,
-	C2PA_TSA_TRUST_LIST,
-	DEV_CA,
+	devCa,
 	close() {
 		setTimeout(() => self.close(), 0);
 	}
 };
 expose(sdk);
 //#endregion
-export { AssetVerifierHandle, Handle, StreamSessionHandle, StreamVerifierHandle };
+export { AssetVerifierHandle, Handle, StreamSessionHandle, StreamVerifierHandle, VerificationHandle };