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

package/gen/wasm/worker-thread.js

@@ -37,23 +37,24 @@ var AssetVerifier = 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) {
-		return wasm.assetverifier_verify(this.__wbg_ptr, source, isLikeNone(recovery) ? 0 : addToExternrefTable0(recovery));
+	verify(input, recovery) {
+		return wasm.assetverifier_verify(this.__wbg_ptr, input, isLikeNone(recovery) ? 0 : addToExternrefTable0(recovery));
 	}
 };
 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
 *
@@ -112,6 +113,138 @@ 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;
@@ -215,9 +348,55 @@ var IntoUnderlyingSource = class {
 };
 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.
+*/
+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.
 */
 var MemorySource = class {
 	__destroy_into_raw() {
@@ -240,7 +419,9 @@ var MemorySource = class {
 	* @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;
@@ -277,8 +458,8 @@ var StreamSession = 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
@@ -305,11 +486,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} source
+	* @param {RangeSource} data
 	* @returns {Promise<SegmentValidation>}
 	*/
-	validate(source) {
-		return wasm.streamsession_validate(this.__wbg_ptr, source);
+	validate(data) {
+		return wasm.streamsession_validate(this.__wbg_ptr, data);
 	}
 };
 if (Symbol.dispose) StreamSession.prototype[Symbol.dispose] = StreamSession.prototype.free;
@@ -345,137 +526,45 @@ var StreamVerifier = 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]);
 		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.
 *
@@ -493,11 +582,19 @@ function devCa() {
 function parse(manifest) {
 	const ptr0 = passArray8ToWasm0(manifest, wasm.__wbindgen_malloc);
 	const len0 = WASM_VECTOR_LEN;
-	return wasm.parse(ptr0, len0);
+	const ret = wasm.parse(ptr0, len0);
+	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
 *
@@ -505,14 +602,42 @@ function parse(manifest) {
 * holds the resource but cannot produce it.
 * @param {Uint8Array} manifest
 * @param {string} uri
-* @returns {Promise<Uint8Array | undefined>}
+* @returns {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;
-	return wasm.resource(ptr0, len0, ptr1, len1);
+	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]);
 }
 function __wbg_get_imports() {
 	return {
@@ -599,12 +724,6 @@ 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));
@@ -912,9 +1031,6 @@ 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));
@@ -968,6 +1084,11 @@ 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;
 			},
@@ -1043,9 +1164,6 @@ 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);
@@ -1056,9 +1174,6 @@ 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);
@@ -1070,7 +1185,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__hbf782ef36cea6846);
+				return makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hcc9f2329e90526d5);
 			},
 			__wbindgen_cast_0000000000000004: function(arg0) {
 				return arg0;
@@ -1087,16 +1202,6 @@ 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);
@@ -1109,8 +1214,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) {
 	wasm.wasm_bindgen__convert__closures_____invoke__hedf60f9cb8ab20c3(arg0, arg1, arg2);
@@ -1150,6 +1255,14 @@ 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: () => {}
@@ -1162,6 +1275,10 @@ 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: () => {}
@@ -1174,10 +1291,6 @@ 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);
@@ -1221,14 +1334,6 @@ 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);
@@ -1407,7 +1512,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 MemorySource(asset instanceof Uint8Array ? asset : new Uint8Array(asset));
+	return asset instanceof Blob ? new BlobSource(asset) : new BytesSource(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
@@ -1417,6 +1522,13 @@ 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.
 *
@@ -1437,23 +1549,10 @@ 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. */
-	async verify(asset, recovery) {
-		return proxy(new VerificationHandle(await this.inner.verify(source(asset), recovery)));
+	verify(asset, recovery) {
+		return this.inner.verify(source(asset), recovery);
 	}
 };
 /** One stream being validated. Dropping the handle releases the session it accumulated. */
@@ -1466,11 +1565,11 @@ var StreamSessionHandle = class extends Handle {
 	}
 };
 var StreamVerifierHandle = class extends Handle {
-	open(id) {
-		return proxy(new StreamSessionHandle(this.inner.open(id)));
+	open(streamId) {
+		return proxy(new StreamSessionHandle(this.inner.open(streamId)));
 	}
-	resume(state) {
-		return proxy(new StreamSessionHandle(this.inner.resume(state)));
+	resume(streamId, state) {
+		return proxy(new StreamSessionHandle(this.inner.resume(streamId, state)));
 	}
 };
 let ready;
@@ -1486,13 +1585,12 @@ const sdk = {
 	},
 	AssetVerifier: proxy({ create: (options) => proxy(new AssetVerifierHandle(AssetVerifier.create(options))) }),
 	StreamVerifier: proxy({ create: (options) => proxy(new StreamVerifierHandle(StreamVerifier.create(options))) }),
+	Binder: proxy({ 
 	/**
-	* 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 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.
 	*/
-	computeSoftBinding(alg, asset, format) {
-		return computeSoftBinding(alg, source(asset), format);
-	},
+derive: (spec, content, options) => binder(spec).derive(source(content), options) }),
 	/**
 	* 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.
@@ -1507,11 +1605,20 @@ const sdk = {
 	async resource(manifest, uri) {
 		return resource(await bytes(manifest), uri);
 	},
-	devCa,
+	/**
+	* 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,
 	close() {
 		setTimeout(() => self.close(), 0);
 	}
 };
 expose(sdk);
 //#endregion
-export { AssetVerifierHandle, Handle, StreamSessionHandle, StreamVerifierHandle, VerificationHandle };
+export { AssetVerifierHandle, Handle, StreamSessionHandle, StreamVerifierHandle };