@officialunofficial/kit-wasm 0.0.0-init → 0.7.1

package/kit_wasm_bg.js

@@ -0,0 +1,2977 @@
+export class AttestKeyPairJs {
+    static __wrap(ptr) {
+        const obj = Object.create(AttestKeyPairJs.prototype);
+        obj.__wbg_ptr = ptr;
+        AttestKeyPairJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AttestKeyPairJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_attestkeypairjs_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get algo() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.attestkeypairjs_algo(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get keyid() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.attestkeypairjs_keyid(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get pubkey_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.attestkeypairjs_pubkey_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get seed_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.attestkeypairjs_seed_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) AttestKeyPairJs.prototype[Symbol.dispose] = AttestKeyPairJs.prototype.free;
+
+export class AttestationJs {
+    static __wrap(ptr) {
+        const obj = Object.create(AttestationJs.prototype);
+        obj.__wbg_ptr = ptr;
+        AttestationJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AttestationJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_attestationjs_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get attestation_id_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.attestationjs_attestation_id_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get envelope_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.attestationjs_envelope_json(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get keyid() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.attestationjs_keyid(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) AttestationJs.prototype[Symbol.dispose] = AttestationJs.prototype.free;
+
+export class BaoEncoded {
+    static __wrap(ptr) {
+        const obj = Object.create(BaoEncoded.prototype);
+        obj.__wbg_ptr = ptr;
+        BaoEncodedFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BaoEncodedFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_baoencoded_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get hash_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.baoencoded_hash_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get outboard() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.baoencoded_outboard(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) BaoEncoded.prototype[Symbol.dispose] = BaoEncoded.prototype.free;
+
+export class BaoVerify {
+    static __wrap(ptr) {
+        const obj = Object.create(BaoVerify.prototype);
+        obj.__wbg_ptr = ptr;
+        BaoVerifyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BaoVerifyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_baoverify_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array | undefined}
+     */
+    get bytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.baoverify_bytes(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getArrayU8FromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get error() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.baoverify_error(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1);
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    get ok() {
+        const ret = wasm.baoverify_ok(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) BaoVerify.prototype[Symbol.dispose] = BaoVerify.prototype.free;
+
+/**
+ * One `FastCDC` chunk boundary plus its BLAKE3.
+ */
+export class ChunkInfo {
+    static __wrap(ptr) {
+        const obj = Object.create(ChunkInfo.prototype);
+        obj.__wbg_ptr = ptr;
+        ChunkInfoFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChunkInfoFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chunkinfo_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get hash_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.chunkinfo_hash_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get len() {
+        const ret = wasm.chunkinfo_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get offset() {
+        const ret = wasm.chunkinfo_offset(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ChunkInfo.prototype[Symbol.dispose] = ChunkInfo.prototype.free;
+
+export class ChunkedBlobJs {
+    static __wrap(ptr) {
+        const obj = Object.create(ChunkedBlobJs.prototype);
+        obj.__wbg_ptr = ptr;
+        ChunkedBlobJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChunkedBlobJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chunkedblobjs_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get bytes_len() {
+        const ret = wasm.chunkedblobjs_bytes_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} i
+     * @returns {ChunkInfo | undefined}
+     */
+    chunk(i) {
+        const ret = wasm.chunkedblobjs_chunk(this.__wbg_ptr, i);
+        return ret === 0 ? undefined : ChunkInfo.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get chunk_count() {
+        const ret = wasm.chunkedblobjs_chunk_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {string}
+     */
+    get root_hash_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.chunkedblobjs_root_hash_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) ChunkedBlobJs.prototype[Symbol.dispose] = ChunkedBlobJs.prototype.free;
+
+export class ChunkerResult {
+    static __wrap(ptr) {
+        const obj = Object.create(ChunkerResult.prototype);
+        obj.__wbg_ptr = ptr;
+        ChunkerResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChunkerResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chunkerresult_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get avg() {
+        const ret = wasm.chunkerresult_avg(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} i
+     * @returns {ChunkInfo | undefined}
+     */
+    chunk(i) {
+        const ret = wasm.chunkerresult_chunk(this.__wbg_ptr, i);
+        return ret === 0 ? undefined : ChunkInfo.__wrap(ret);
+    }
+    /**
+     * Number of chunks. The `chunk(i)` getter returns each one by index,
+     * which is cheaper than materialising a JS array of opaque handles
+     * when the web caller only wants a few.
+     * @returns {number}
+     */
+    get chunk_count() {
+        const ret = wasm.chunkerresult_chunk_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get max() {
+        const ret = wasm.chunkerresult_max(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get min() {
+        const ret = wasm.chunkerresult_min(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ChunkerResult.prototype[Symbol.dispose] = ChunkerResult.prototype.free;
+
+/**
+ * Decoded display fields of a commit object — what [`commit_decode`]
+ * returns for the multiplayer log to walk + render the room's `main`
+ * chain. `parents` are 64-hex object ids (parent 0 first); `signer_hex`
+ * is the 64-hex Ed25519 signer/author pubkey; `timestamp` is unix
+ * seconds; `tree_hex` is the 64-hex tree object id; `signature_hex` is
+ * the 128-hex Ed25519 signature.
+ */
+export class CommitInfoJs {
+    static __wrap(ptr) {
+        const obj = Object.create(CommitInfoJs.prototype);
+        obj.__wbg_ptr = ptr;
+        CommitInfoJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CommitInfoJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_commitinfojs_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.commitinfojs_message(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {number} i
+     * @returns {string | undefined}
+     */
+    parent(i) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.commitinfojs_parent(retptr, this.__wbg_ptr, i);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1);
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Number of parents; pair with [`CommitInfoJs::parent`] to read each
+     * 64-hex id by index, matching the `*_count` + indexed-getter shape
+     * used by the streaming result structs.
+     * @returns {number}
+     */
+    get parent_count() {
+        const ret = wasm.commitinfojs_parent_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * 128-hex Ed25519 signature over the commit's signing bytes.
+     * @returns {string}
+     */
+    get signature_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.commitinfojs_signature_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get signer_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.commitinfojs_signer_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {bigint}
+     */
+    get timestamp() {
+        const ret = wasm.commitinfojs_timestamp(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * 64-hex id of the tree this commit snapshots.
+     * @returns {string}
+     */
+    get tree_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.commitinfojs_tree_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) CommitInfoJs.prototype[Symbol.dispose] = CommitInfoJs.prototype.free;
+
+/**
+ * One entry in the delta summary. `offset` is populated only for `copy` ops.
+ */
+export class DeltaOp {
+    static __wrap(ptr) {
+        const obj = Object.create(DeltaOp.prototype);
+        obj.__wbg_ptr = ptr;
+        DeltaOpFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DeltaOpFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_deltaop_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get kind() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.deltaop_kind(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get len() {
+        const ret = wasm.deltaop_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get offset() {
+        const ret = wasm.deltaop_offset(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+}
+if (Symbol.dispose) DeltaOp.prototype[Symbol.dispose] = DeltaOp.prototype.free;
+
+export class DeltaSummary {
+    static __wrap(ptr) {
+        const obj = Object.create(DeltaSummary.prototype);
+        obj.__wbg_ptr = ptr;
+        DeltaSummaryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DeltaSummaryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_deltasummary_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get bytes_on_wire() {
+        const ret = wasm.deltasummary_bytes_on_wire(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get full_size() {
+        const ret = wasm.deltasummary_full_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} i
+     * @returns {DeltaOp | undefined}
+     */
+    op(i) {
+        const ret = wasm.deltasummary_op(this.__wbg_ptr, i);
+        return ret === 0 ? undefined : DeltaOp.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get op_count() {
+        const ret = wasm.deltasummary_op_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DeltaSummary.prototype[Symbol.dispose] = DeltaSummary.prototype.free;
+
+export class EncodedCommit {
+    static __wrap(ptr) {
+        const obj = Object.create(EncodedCommit.prototype);
+        obj.__wbg_ptr = ptr;
+        EncodedCommitFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EncodedCommitFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_encodedcommit_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get bytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.encodedcommit_bytes(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get hash_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.encodedcommit_hash_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get signature_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.encodedcommit_signature_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) EncodedCommit.prototype[Symbol.dispose] = EncodedCommit.prototype.free;
+
+export class EncodedObject {
+    static __wrap(ptr) {
+        const obj = Object.create(EncodedObject.prototype);
+        obj.__wbg_ptr = ptr;
+        EncodedObjectFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EncodedObjectFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_encodedobject_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get bytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.encodedobject_bytes(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get hash_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.encodedobject_hash_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) EncodedObject.prototype[Symbol.dispose] = EncodedObject.prototype.free;
+
+export class KeyPairJs {
+    static __wrap(ptr) {
+        const obj = Object.create(KeyPairJs.prototype);
+        obj.__wbg_ptr = ptr;
+        KeyPairJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KeyPairJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_keypairjs_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get pubkey_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.keypairjs_pubkey_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get seed_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.keypairjs_seed_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) KeyPairJs.prototype[Symbol.dispose] = KeyPairJs.prototype.free;
+
+/**
+ * Decoded display fields of a remix object — the remix counterpart of
+ * [`CommitInfoJs`]. Carries the same commit-shaped fields plus the
+ * remix-only `sources` (read via `source_count` + the `source(i)`
+ * indexed getter), each a [`RemixSourceJs`] naming an upstream commit
+ * the fork derives from. `parents` are 64-hex object ids (parent 0
+ * first); `signer_hex` is the 64-hex Ed25519 signer pubkey; `timestamp`
+ * is unix seconds; `tree_hex` is the 64-hex tree id; `signature_hex` is
+ * the 128-hex Ed25519 signature.
+ */
+export class RemixInfoJs {
+    static __wrap(ptr) {
+        const obj = Object.create(RemixInfoJs.prototype);
+        obj.__wbg_ptr = ptr;
+        RemixInfoJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RemixInfoJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_remixinfojs_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.remixinfojs_message(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {number} i
+     * @returns {string | undefined}
+     */
+    parent(i) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.remixinfojs_parent(retptr, this.__wbg_ptr, i);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1);
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Number of parents; pair with [`RemixInfoJs::parent`] to read each
+     * 64-hex id by index.
+     * @returns {number}
+     */
+    get parent_count() {
+        const ret = wasm.remixinfojs_parent_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * 128-hex Ed25519 signature over the remix's signing bytes.
+     * @returns {string}
+     */
+    get signature_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.remixinfojs_signature_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get signer_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.remixinfojs_signer_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {number} i
+     * @returns {RemixSourceJs | undefined}
+     */
+    source(i) {
+        const ret = wasm.remixinfojs_source(this.__wbg_ptr, i);
+        return ret === 0 ? undefined : RemixSourceJs.__wrap(ret);
+    }
+    /**
+     * Number of sources (upstream commits this fork derives from); pair
+     * with [`RemixInfoJs::source`] to read each `{ upstream_id_hex,
+     * commit_hash_hex }` by index.
+     * @returns {number}
+     */
+    get source_count() {
+        const ret = wasm.remixinfojs_source_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get timestamp() {
+        const ret = wasm.remixinfojs_timestamp(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * 64-hex id of the tree this remix snapshots.
+     * @returns {string}
+     */
+    get tree_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.remixinfojs_tree_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) RemixInfoJs.prototype[Symbol.dispose] = RemixInfoJs.prototype.free;
+
+/**
+ * One remix source: a `{ upstream_id_hex, commit_hash_hex }` pair naming
+ * an upstream commit this fork derives from. `upstream_id` is the opaque
+ * caller-chosen 32-byte provenance tag (e.g. the room id); `commit_hash`
+ * is the 64-hex id of the upstream commit being remixed.
+ */
+export class RemixSourceJs {
+    static __wrap(ptr) {
+        const obj = Object.create(RemixSourceJs.prototype);
+        obj.__wbg_ptr = ptr;
+        RemixSourceJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RemixSourceJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_remixsourcejs_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get commit_hash_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.remixsourcejs_commit_hash_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get upstream_id_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.remixsourcejs_upstream_id_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) RemixSourceJs.prototype[Symbol.dispose] = RemixSourceJs.prototype.free;
+
+/**
+ * A verified KDSP span, including its authenticated metadata and plaintext.
+ *
+ * Both getters use the result of one verification. The JSON deliberately
+ * excludes the bytes; callers obtain them through [`VerifiedSpan::bytes`].
+ */
+export class VerifiedSpan {
+    static __wrap(ptr) {
+        const obj = Object.create(VerifiedSpan.prototype);
+        obj.__wbg_ptr = ptr;
+        VerifiedSpanFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VerifiedSpanFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_verifiedspan_free(ptr, 0);
+    }
+    /**
+     * The authenticated content bytes of the requested range.
+     * @returns {Uint8Array}
+     */
+    get bytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.verifiedspan_bytes(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Authenticated span metadata as JSON.
+     * @returns {string}
+     */
+    get json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.verifiedspan_json(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) VerifiedSpan.prototype[Symbol.dispose] = VerifiedSpan.prototype.free;
+
+/**
+ * Build a DSSE-wrapped in-toto v1 attestation over a subject, signed with the chosen algorithm.
+ *
+ * * `subject_bytes` is the subject's serialised bytes — its `blake3` and
+ *   paired `sha256` digest (SPEC-ATTESTATIONS §4.2) are both derived from
+ *   these bytes, so the two can never disagree. For a real commit this is
+ *   the commit's serialised bytes; callers binding a non-commit subject
+ *   (e.g. a derived-key identity binding) pass whatever bytes that
+ *   subject's identifier is itself the hash of.
+ * * `predicate_type` is a URI like `https://example.com/Review/v1`.
+ * * `predicate_jcs` is the predicate body as already-canonical JCS bytes (must start with `{` and end with `}`).
+ * * `seed_hex` is a 32-byte seed. How it's interpreted depends on `algo`:
+ *   * `ed25519`   — raw Ed25519 seed
+ *   * `secp256k1` — raw 32-byte scalar
+ *   * `p256`      — raw 32-byte scalar
+ *
+ * Returns `{ envelope_json, keyid, attestation_id_hex }`. The keyid's prefix reveals which algorithm was used.
+ * @param {Uint8Array} subject_bytes
+ * @param {string} predicate_type
+ * @param {Uint8Array} predicate_jcs
+ * @param {string} seed_hex
+ * @param {string} algo
+ * @returns {AttestationJs}
+ */
+export function attest_build(subject_bytes, predicate_type, predicate_jcs, seed_hex, algo) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(subject_bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(predicate_type, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(predicate_jcs, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(seed_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(algo, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len4 = WASM_VECTOR_LEN;
+        wasm.attest_build(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return AttestationJs.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Derive the pubkey + canonical keyid for the given attestation algorithm from a 32-byte seed. `algo` is one of
+ * `"ed25519" | "secp256k1" | "p256"`. Deterministic: same seed + same algorithm always produces the same pubkey.
+ *
+ * Pubkey encoding depends on the algorithm:
+ *   * `ed25519`   — 32-byte raw pubkey
+ *   * `secp256k1` — 33-byte compressed SEC1 (`0x02`/`0x03` prefix + x)
+ *   * `p256`      — 33-byte compressed SEC1 (same shape)
+ *
+ * `keyid` follows the canonical `<prefix>:<hex-pubkey>` form described in SPEC-ATTESTATIONS §6.3 for ES256K / ES256,
+ * and the legacy `blake3:<hex-of-blake3(pubkey)>` form for Ed25519 (what `RepoKeySigner` emits; verifier accepts).
+ * @param {string} seed_hex
+ * @param {string} algo
+ * @returns {AttestKeyPairJs}
+ */
+export function attest_keypair(seed_hex, algo) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(seed_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(algo, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.attest_keypair(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return AttestKeyPairJs.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Compute the DSSE PAE for an (unsigned) in-toto attestation over a
+ * subject. This is the exact byte string a browser passkey MUST
+ * place in its `WebAuthn` `challenge` so the resulting assertion
+ * verifies under [`verify_webauthn_wrapping`].
+ *
+ * Same `(subject_bytes, predicate_type, predicate_jcs)` inputs as
+ * [`attest_build`], minus the key — the PAE is signer-independent, so a
+ * passkey and a software key over the same statement bind to identical
+ * bytes. Returns the raw PAE; the JS side passes it straight to
+ * `navigator.credentials.get` as a `BufferSource` challenge.
+ *
+ * NOTE: the `WebAuthn` `challenge` here is the *whole* PAE, and platform
+ * authenticators cap challenge size in practice — keep demo predicates
+ * small (see the research note's "challenge sizing" fork).
+ *
+ * # Errors
+ * The statement fails to encode.
+ * @param {Uint8Array} subject_bytes
+ * @param {string} predicate_type
+ * @param {Uint8Array} predicate_jcs
+ * @returns {Uint8Array}
+ */
+export function attest_pae(subject_bytes, predicate_type, predicate_jcs) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(subject_bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(predicate_type, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(predicate_jcs, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.attest_pae(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v4 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v4;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verify a DSSE envelope against a single trust root of the given algorithm.
+ *
+ * * `envelope_json` is the canonical DSSE envelope JSON emitted by [`attest_build`].
+ * * `pubkey_hex` is the public key, hex-encoded:
+ *   * `ed25519`   — 32-byte raw pubkey (64 hex chars)
+ *   * `secp256k1` — 33-byte compressed SEC1 (66 hex chars) or 65-byte uncompressed (130 hex chars)
+ *   * `p256`      — same shape as `secp256k1`
+ * * `algo` selects which trust-root variant the registry dispatches on.
+ *
+ * Returns `true` iff at least one signature in the envelope verifies.
+ * @param {string} envelope_json
+ * @param {string} pubkey_hex
+ * @param {string} algo
+ * @returns {boolean}
+ */
+export function attest_verify(envelope_json, pubkey_hex, algo) {
+    const ptr0 = passStringToWasm0(envelope_json, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(pubkey_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(algo, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.attest_verify(ptr0, len0, ptr1, len1, ptr2, len2);
+    return ret !== 0;
+}
+
+/**
+ * Encode `bytes` in Bao outboard mode and return `{ hash_hex, outboard }`.
+ * Outboard keeps the encoded tree proof separate from the payload so
+ * the demo can stream the original bytes on one track and the proof on
+ * another.
+ * @param {Uint8Array} bytes
+ * @returns {BaoEncoded}
+ */
+export function bao_encode(bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.bao_encode(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return BaoEncoded.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Extract a proof-carrying slice from a Bao outboard encoding. The
+ * returned bytes are in the format `bao::decode::SliceDecoder`
+ * consumes — the original payload plus just enough tree proof to
+ * verify it against the root hash.
+ * @param {Uint8Array} outboard
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @param {number} len
+ * @returns {Uint8Array}
+ */
+export function bao_slice(outboard, bytes, offset, len) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(outboard, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.bao_slice(retptr, ptr0, len0, ptr1, len1, offset, len);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verify a Bao slice against a root hash. On success returns
+ * `{ ok: true, bytes }` with the verified payload. On tamper returns
+ * `{ ok: false, error }` with the error message — a convenience over
+ * throwing, since the demo wants to render both outcomes side-by-side.
+ * @param {string} hash_hex
+ * @param {Uint8Array} slice_bytes
+ * @param {number} offset
+ * @param {number} len
+ * @returns {BaoVerify}
+ */
+export function bao_verify_slice(hash_hex, slice_bytes, offset, len) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(hash_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(slice_bytes, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.bao_verify_slice(retptr, ptr0, len0, ptr1, len1, offset, len);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return BaoVerify.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * BLAKE3 of arbitrary bytes, as 64-char lowercase hex. This is the
+ * object id kit uses for every stored object.
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+export function blake3_hex(data) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.blake3_hex(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Bao outboard over the **canonical blob bytes** of `content`.
+ *
+ * `hash_hex` equals the blob object id (`object_id(blob_encode(content).bytes)`).
+ * Distinct from [`crate::bao_encode`], which hashes raw file bytes.
+ *
+ * # Errors
+ *
+ * Content larger than 16 MiB, or a serialize failure.
+ * @param {Uint8Array} content
+ * @returns {BaoEncoded}
+ */
+export function blob_bao_encode(content) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.blob_bao_encode(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return BaoEncoded.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Extract a Bao slice over canonical blob bytes at a **content** offset.
+ *
+ * The +10 shift onto the canonical blob (6-byte prologue + 4-byte
+ * length) happens inside. Distinct from [`crate::bao_slice`].
+ *
+ * # Errors
+ *
+ * Oversize content, serialize failure, or a slice-extract error.
+ * @param {Uint8Array} outboard
+ * @param {Uint8Array} content
+ * @param {number} content_offset
+ * @param {number} len
+ * @returns {Uint8Array}
+ */
+export function blob_bao_slice(outboard, content, content_offset, len) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(outboard, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(content, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.blob_bao_slice(retptr, ptr0, len0, ptr1, len1, content_offset, len);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verify a Bao slice against a blob id at a **content** offset.
+ *
+ * Delegates to [`kit_core::verify::verify_blob_slice`]. Tamper returns
+ * `{ ok: false, error }` rather than throwing, matching [`crate::bao_verify_slice`].
+ *
+ * # Errors
+ *
+ * Malformed `blob_id_hex`.
+ * @param {string} blob_id_hex
+ * @param {Uint8Array} slice
+ * @param {number} content_offset
+ * @param {number} len
+ * @returns {BaoVerify}
+ */
+export function blob_bao_verify_slice(blob_id_hex, slice, content_offset, len) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(blob_id_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(slice, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.blob_bao_verify_slice(retptr, ptr0, len0, ptr1, len1, content_offset, len);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return BaoVerify.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Decode a canonical blob into its uninterpreted file bytes.
+ *
+ * # Errors
+ * Invalid encoding, a non-blob object, or input larger than 16 MiB.
+ * @param {Uint8Array} bytes
+ * @returns {Uint8Array}
+ */
+export function blob_decode(bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.blob_decode(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Serialize a blob object and return `{ bytes, hash_hex }`.
+ *
+ * The returned `bytes` are the canonical on-disk v1 object bytes
+ * (see `docs/specs/SPEC-OBJECTS.md`); `hash_hex` is the object's content id
+ * (via `id_from_object`) — for a non-merkelized `Blob`, BLAKE3 of those bytes.
+ * @param {Uint8Array} data
+ * @returns {EncodedObject}
+ */
+export function blob_encode(data) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.blob_encode(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return EncodedObject.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Run the frozen v1 `FastCDC` chunker over `bytes` and return
+ * `{ chunks: [{ offset, len, hash_hex }], avg, min, max }`.
+ *
+ * Each `hash_hex` is BLAKE3 of the chunk payload — handy for colouring
+ * chips in the web demo when an edit shifts boundaries.
+ * @param {Uint8Array} bytes
+ * @returns {ChunkerResult}
+ */
+export function chunk_boundaries(bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chunk_boundaries(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return ChunkerResult.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Decode a canonical `ChunkedBlob` object into JSON
+ * `{ total_size, chunk_size, chunks: [hex] }`.
+ *
+ * Input is capped at 16 MiB, matching [`crate::chunked_blob_encode`]'s
+ * workspace admission limit.
+ *
+ * # Errors
+ *
+ * Oversize input, invalid encoding, or a non-`ChunkedBlob` object.
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function chunked_blob_decode(bytes) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chunked_blob_decode(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Build a `ChunkedBlob` manifest from raw bytes: chunk with `FastCDC` v1 and
+ * return `{ root_hash_hex, chunks: [{ offset, len, hash_hex }], bytes_len }`.
+ *
+ * `root_hash_hex` is the object's content id — the BMT root of the manifest,
+ * whose leaves are the per-chunk **Blob object ids** (built via the shared
+ * `worktree::chunked_blob_from_bytes`), so it equals the id the native store
+ * keys the `ChunkedBlob` under. Each chunk's `hash_hex` is the **raw**
+ * BLAKE3 of the chunk payload — for UI colouring/dedup, distinct from the
+ * manifest leaf. `chunk_size` is `0` (the CDC marker, SPEC-OBJECTS §13.7).
+ * @param {Uint8Array} bytes
+ * @returns {ChunkedBlobJs}
+ */
+export function chunked_blob_encode(bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chunked_blob_encode(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return ChunkedBlobJs.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Decode a commit object's display fields from its raw on-disk bytes.
+ *
+ * Deserializes via the same path [`commit_verify`] uses
+ * (`kit_core::deserialize` → [`Object::Commit`]) and exposes the
+ * fields the multiplayer log needs to walk + render the room's `main`
+ * chain: the [`CommitInfoJs::message`], the parents via
+ * [`CommitInfoJs::parent_count`] / [`CommitInfoJs::parent`]
+ * (64-hex object ids, parent 0 first), the
+ * [`CommitInfoJs::signer_hex`] (the 64-hex Ed25519 signer/author
+ * pubkey), the [`CommitInfoJs::timestamp`] (unix seconds), the
+ * [`CommitInfoJs::tree_hex`] (64-hex tree object id), and the
+ * [`CommitInfoJs::signature_hex`] (128-hex Ed25519 signature) — the
+ * last two power the navigable commit-detail view.
+ *
+ * This function does not verify the signature. The signer, tree and
+ * signature fields are unverified claims. Call [`commit_verify`] to check
+ * them. Input over 16 MiB is rejected.
+ *
+ * # Errors
+ * `commit_bytes` is not a valid serialized object, or it deserializes
+ * to a non-`Commit` object.
+ * @param {Uint8Array} bytes
+ * @returns {CommitInfoJs}
+ */
+export function commit_decode(bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.commit_decode(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return CommitInfoJs.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Build and sign a commit, returning `{ bytes, hash_hex, signature_hex }`.
+ *
+ * `parent_hex` is a comma-separated list of parent commit hashes (empty
+ * string = root commit). `seed_hex` is the 32-byte Ed25519 seed.
+ * @param {string} tree_hash_hex
+ * @param {string} parent_hex
+ * @param {string} message
+ * @param {bigint} timestamp
+ * @param {string} seed_hex
+ * @returns {EncodedCommit}
+ */
+export function commit_encode_and_sign(tree_hash_hex, parent_hex, message, timestamp, seed_hex) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(tree_hash_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(parent_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(message, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(seed_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.commit_encode_and_sign(retptr, ptr0, len0, ptr1, len1, ptr2, len2, timestamp, ptr3, len3);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return EncodedCommit.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verify a commit signature, given the raw on-disk commit bytes.
+ * Returns `true` on pass, `false` on structural or crypto failure.
+ * Input over 16 MiB returns `false`.
+ * @param {Uint8Array} commit_bytes
+ * @returns {boolean}
+ */
+export function commit_verify(commit_bytes) {
+    const ptr0 = passArray8ToWasm0(commit_bytes, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.commit_verify(ptr0, len0);
+    return ret !== 0;
+}
+
+/**
+ * Build a SPEC-DELTA v1 stream of `base -> target` and return a
+ * structural summary: `{ ops, bytes_on_wire, full_size }`.
+ *
+ * `ops` contains one entry per opcode — `{ kind: "copy", offset, len }`
+ * or `{ kind: "insert", len }` — without the insert payloads, so the
+ * whole thing stays cheap to pass across the JS boundary. `bytes_on_wire`
+ * is the total delta stream length; `full_size` is `target.len()` for
+ * easy delta-savings calculation.
+ * @param {Uint8Array} base
+ * @param {Uint8Array} target
+ * @returns {DeltaSummary}
+ */
+export function delta_encode(base, target) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(base, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(target, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.delta_encode(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return DeltaSummary.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Return the verified payload bytes of a disclosure bundle.
+ *
+ * Re-verifies the bundle. Object payload: canonical object bytes. Chunk
+ * payload: the chunk's canonical blob bytes. Range payload: the
+ * disclosed range bytes.
+ *
+ * # Errors
+ *
+ * The same failures as [`verify_disclosure`].
+ * @param {string} commit_id_hex
+ * @param {Uint8Array} bundle
+ * @returns {Uint8Array}
+ */
+export function disclosure_payload_bytes(commit_id_hex, bundle) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(commit_id_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bundle, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.disclosure_payload_bytes(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Derive the 32-byte Ed25519 public key from a 32-byte seed.
+ *
+ * Pure function: same seed → same pubkey. Errors only if `seed` is not
+ * exactly 32 bytes. Internally goes through `kit-core`'s
+ * `KeyPair::from_seed`, which is the same derivation step the commit
+ * signer uses, so a key minted here interoperates 1:1 with on-disk
+ * `.kit/keys/default.key` material.
+ * @param {Uint8Array} seed
+ * @returns {Uint8Array}
+ */
+export function ed25519_pubkey_from_seed(seed) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ed25519_pubkey_from_seed(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Sign `msg` with the Ed25519 secret derived from a 32-byte `seed`.
+ *
+ * Returns the 64-byte signature (`R || s`). Errors only if `seed` is
+ * not exactly 32 bytes — Ed25519 signing itself is infallible once the
+ * key material is the right shape (RFC 8032 is deterministic; no RNG).
+ *
+ * The output is byte-equal to
+ * `ed25519_dalek::SigningKey::from_bytes(seed).sign(msg)`, which is the
+ * same signing path `kit-core::sign::KeyPair` drives for commit
+ * signatures (modulo the BLAKE3-domain wrapper that commits add on
+ * top — those callers should keep using `commit_encode_and_sign`).
+ * @param {Uint8Array} msg
+ * @param {Uint8Array} seed
+ * @returns {Uint8Array}
+ */
+export function ed25519_sign(msg, seed) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(seed, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.ed25519_sign(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verify a raw Ed25519 signature, with strict canonical-encoding checks.
+ *
+ * Returns `true` only if the signature passes the SPEC-SIGNING §1
+ * predicate over `msg`: canonical, non-small-order `A` and `R`, canonical
+ * `s`, and the cofactored equation. This is the same check every other
+ * Ed25519 verifier in kit runs.
+ *
+ * Wrong-length `sig` or `pubkey` return `false` (the JS API matches the
+ * noble shape — boolean out, no exceptions on shape errors).
+ * @param {Uint8Array} sig
+ * @param {Uint8Array} msg
+ * @param {Uint8Array} pubkey
+ * @returns {boolean}
+ */
+export function ed25519_verify(sig, msg, pubkey) {
+    const ptr0 = passArray8ToWasm0(sig, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(msg, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(pubkey, wasm.__wbindgen_export2);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.ed25519_verify(ptr0, len0, ptr1, len1, ptr2, len2);
+    return ret !== 0;
+}
+
+/**
+ * Derive `{ seed_hex, pubkey_hex }` from a 32-byte seed. Deterministic:
+ * the same seed always yields the same public key.
+ * @param {string} seed_hex
+ * @returns {KeyPairJs}
+ */
+export function keypair_from_seed(seed_hex) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(seed_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.keypair_from_seed(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return KeyPairJs.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Generate a fresh Ed25519 keypair from the browser CSPRNG.
+ * @returns {KeyPairJs}
+ */
+export function keypair_generate() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.keypair_generate(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return KeyPairJs.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Return a canonical object's 64-hex content id, including Merkle ids.
+ *
+ * This checks the encoding, not signatures or referenced child objects.
+ * Callers must compare the result with the independently requested id.
+ *
+ * # Errors
+ * Invalid object encoding or input larger than 16 MiB.
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function object_id(bytes) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.object_id(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Read the object-type tag from a serialized object's prologue and
+ * return its spec short name: `"commit" | "remix" | "tree" | "blob" |
+ * "chunked_blob" | "delta" | "tag"`.
+ *
+ * Lets the browser route a fetched object to the right decoder
+ * (`commit_decode` vs `remix_decode`) without guessing or trial-decoding.
+ * Goes through `kit_core::deserialize` so the answer reflects a fully
+ * well-formed object, then reports `ObjectType::name`.
+ *
+ * # Errors
+ * `bytes` is not a valid serialized object (bad prologue / truncated /
+ * unknown type tag), or longer than 16 MiB.
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function object_kind(bytes) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.object_kind(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Decode a remix object's display fields from its raw on-disk bytes.
+ *
+ * The remix counterpart of [`commit_decode`]: deserializes via
+ * `kit_core::deserialize` → [`Object::Remix`] and exposes the same
+ * commit-shaped fields (`message`, `signer_hex`, `timestamp`,
+ * `tree_hex`, `signature_hex`, `parents`) plus the remix-only
+ * `sources` — each a `{ upstream_id_hex, commit_hash_hex }`
+ * read by `source_count` + the `source(i)` indexed getter. The web
+ * browser uses the sources to render the "fork of …" badge whose
+ * `commit_hash` links to the upstream commit's detail.
+ *
+ * This function does not verify the signature. The signer, tree and
+ * signature fields are unverified claims. Input over 16 MiB is rejected.
+ *
+ * # Errors
+ * `bytes` is not a valid serialized object, or it deserializes to a
+ * non-`Remix` object.
+ * @param {Uint8Array} bytes
+ * @returns {RemixInfoJs}
+ */
+export function remix_decode(bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.remix_decode(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return RemixInfoJs.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Build and sign a remix (fork/derivation), returning
+ * `{ bytes, hash_hex, signature_hex }` like [`commit_encode_and_sign`].
+ *
+ * A `Remix` is the first-class fork object: it snapshots a `tree_hash`,
+ * names zero or more `parents` (prior remixes/commits in the fork's own
+ * history), and — crucially — records one or more `sources`, each a
+ * `RemixSource { upstream_id, commit_hash }` pointing at the upstream
+ * commit(s) this fork derives from.
+ *
+ * Inputs mirror the commit variant, plus `sources_json`:
+ * * `tree_hash_hex` — 64-hex tree object id this remix snapshots.
+ * * `parent_hex` — comma-separated parent ids (empty = root remix).
+ * * `sources_json` — JSON array of `{ "upstream_id_hex", "commit_hash_hex" }`
+ *   objects, each 64-hex. The upstream commits being forked/remixed.
+ * * `message` / `timestamp` — same as a commit.
+ * * `seed_hex` — the 32-byte Ed25519 seed.
+ *
+ * `sources` are sorted here by `(upstream_id, commit_hash)` and checked
+ * for duplicates, satisfying the strict-ascending order kit-core's
+ * `read_remix` enforces at decode time (see `Remix::sources_sorted`).
+ * At least one source is required — a remix with no source is not a fork.
+ *
+ * # Errors
+ * Any hex field is malformed, `sources_json` does not parse, `sources`
+ * is empty or contains a duplicate `(upstream_id, commit_hash)` pair, or
+ * signing-bytes construction fails.
+ * @param {string} tree_hash_hex
+ * @param {string} parent_hex
+ * @param {string} sources_json
+ * @param {string} message
+ * @param {bigint} timestamp
+ * @param {string} seed_hex
+ * @returns {EncodedCommit}
+ */
+export function remix_encode_and_sign(tree_hash_hex, parent_hex, sources_json, message, timestamp, seed_hex) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(tree_hash_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(parent_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(sources_json, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(message, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(seed_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len4 = WASM_VECTOR_LEN;
+        wasm.remix_encode_and_sign(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, timestamp, ptr4, len4);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return EncodedCommit.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verify a canonical remix's signature. Returns false for invalid encoding,
+ * wrong object kind, signature failure, or input larger than 16 MiB.
+ * @param {Uint8Array} bytes
+ * @returns {boolean}
+ */
+export function remix_verify(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.remix_verify(ptr0, len0);
+    return ret !== 0;
+}
+
+/**
+ * Sign arbitrary bytes under kit's commit signing domain. Exposed for
+ * the signing demo — real kit commits go through `commit_encode_and_sign`.
+ * @param {string} seed_hex
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function sign_bytes_commit_domain(seed_hex, bytes) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(seed_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.sign_bytes_commit_domain(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Decode a canonical tree into JSON `[name, mode, hash_hex]` triples.
+ * Modes match [`tree_encode`]: `blob`, `tree`, `symlink`, and `exec`.
+ *
+ * # Errors
+ * Invalid encoding, a non-tree object, input larger than 16 MiB, or a
+ * non-UTF-8 entry name (which cannot round-trip through the JSON API).
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function tree_decode(bytes) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.tree_decode(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Build a tree object from a JSON array of `[name, mode, hash_hex]`
+ * triples and return its serialized bytes + hash. `mode` is one of
+ * `"blob" | "tree" | "symlink" | "exec"`.
+ * @param {string} entries_json
+ * @returns {EncodedObject}
+ */
+export function tree_encode(entries_json) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(entries_json, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.tree_encode(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return EncodedObject.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verify a signature made by [`sign_bytes_commit_domain`].
+ * @param {string} pubkey_hex
+ * @param {Uint8Array} bytes
+ * @param {string} sig_hex
+ * @returns {boolean}
+ */
+export function verify_bytes_commit_domain(pubkey_hex, bytes, sig_hex) {
+    const ptr0 = passStringToWasm0(pubkey_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(sig_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.verify_bytes_commit_domain(ptr0, len0, ptr1, len1, ptr2, len2);
+    return ret !== 0;
+}
+
+/**
+ * Verify a single chunk inclusion proof against a `ChunkedBlob` id.
+ *
+ * `position` is the BMT position (chunk index + 1). Position 0 is the
+ * metadata leaf and is never a valid chunk proof. Returns `Ok(false)`
+ * on [`MerkleError::VerificationFailed`]; `Err` on malformed input.
+ *
+ * # Errors
+ *
+ * Malformed hex or proof bytes, or any merkle error other than
+ * [`MerkleError::VerificationFailed`].
+ * @param {string} chunked_id_hex
+ * @param {string} chunk_id_hex
+ * @param {number} position
+ * @param {Uint8Array} proof
+ * @returns {boolean}
+ */
+export function verify_chunk(chunked_id_hex, chunk_id_hex, position, proof) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(chunked_id_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(chunk_id_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(proof, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.verify_chunk(retptr, ptr0, len0, ptr1, len1, position, ptr2, len2);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0 !== 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verify a closure manifest plus concatenated packs against a trusted root.
+ *
+ * The manifest is a locator, never a trust anchor: `expected_root_hex`
+ * must match the manifest root. Pack framing matches
+ * [`verify_closure_packs`].
+ *
+ * # Errors
+ *
+ * Malformed hex, oversize input, or any [`verify::VerifyError`].
+ * @param {string} expected_root_hex
+ * @param {Uint8Array} manifest
+ * @param {Uint8Array} packs
+ * @param {string} pack_lengths_json
+ * @returns {string}
+ */
+export function verify_closure_manifest(expected_root_hex, manifest, packs, pack_lengths_json) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(expected_root_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(manifest, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(packs, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(pack_lengths_json, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.verify_closure_manifest(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr5 = r0;
+        var len5 = r1;
+        if (r3) {
+            ptr5 = 0; len5 = 0;
+            throw takeObject(r2);
+        }
+        deferred6_0 = ptr5;
+        deferred6_1 = len5;
+        return getStringFromWasm0(ptr5, len5);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred6_0, deferred6_1, 1);
+    }
+}
+
+/**
+ * Verify concatenated raw-only closure packs against a trusted root.
+ *
+ * `mode` is `"snapshot"` or `"history"`. `packs` is the concatenation of
+ * each pack's bytes; `pack_lengths_json` is a JSON array of those
+ * lengths in the same order, e.g. `"[1024,2048]"`. Each pack and the
+ * concatenated buffer are capped at 1 GiB.
+ *
+ * Returns JSON `{ root, mode, verified, complete, unreferenced_checked,
+ * missing, corrupt, unreferenced }`.
+ *
+ * # Errors
+ *
+ * Malformed hex or mode, oversize or mis-sliced packs, or any
+ * [`verify::VerifyError`].
+ * @param {string} root_hex
+ * @param {string} mode
+ * @param {Uint8Array} packs
+ * @param {string} pack_lengths_json
+ * @returns {string}
+ */
+export function verify_closure_packs(root_hex, mode, packs, pack_lengths_json) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(root_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(mode, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(packs, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(pack_lengths_json, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.verify_closure_packs(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr5 = r0;
+        var len5 = r1;
+        if (r3) {
+            ptr5 = 0; len5 = 0;
+            throw takeObject(r2);
+        }
+        deferred6_0 = ptr5;
+        deferred6_1 = len5;
+        return getStringFromWasm0(ptr5, len5);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred6_0, deferred6_1, 1);
+    }
+}
+
+/**
+ * Verify a disclosure bundle against a trusted commit id.
+ *
+ * Returns JSON `{ commit_id, tree_hash, path, leaf_id, signer,
+ * signature_valid, payload, step_inner_roots, chunk_inner_root }`
+ * **without** payload bytes. Call
+ * [`disclosure_payload_bytes`] for the verified bytes. Both functions
+ * re-verify; a caller that wants both should call this first and treat a
+ * failure of either as a failure.
+ *
+ * `path` entries are `{ name }` (UTF-8 or `null`), `{ name_hex }`, and
+ * `{ mode }` (`blob` / `tree` / `symlink` / `exec`). Payload `kind` is
+ * `object`, `chunk`, or `range`. Bundles larger than 64 MiB
+ * ([`MAX_BUNDLE_BYTES`]) are rejected before decode.
+ *
+ * # Errors
+ *
+ * Malformed hex, an oversize bundle, or any [`verify::VerifyError`].
+ * @param {string} commit_id_hex
+ * @param {Uint8Array} bundle
+ * @returns {string}
+ */
+export function verify_disclosure(commit_id_hex, bundle) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(commit_id_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bundle, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.verify_disclosure(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Verify a KDSP v1 span container against a trusted commit id.
+ *
+ * The JSON contains `commit_id`, `tree_hash`, `path`, `leaf_id`, `signer`,
+ * `signature_valid`, `offset`, `bytes_len`, `bytes_blake3`, `first`, `last`,
+ * `span_start`, and `chunk_inner_root`. A `path` entry has `name` (UTF-8 or
+ * `null`), `name_hex`, and `mode`. The bytes are returned by the getter of
+ * the same [`VerifiedSpan`] and are never reverified. Input is capped at
+ * 64 MiB. Every error starts with a SPEC-DISCLOSURE §8.2 reason label,
+ * except a malformed `commit_id_hex`, which is not a §8.2 condition and
+ * starts with `invalid_input:`.
+ *
+ * # Errors
+ *
+ * Invalid commit hex, an oversized container, malformed framing, or a
+ * failed cryptographic or span check.
+ * @param {string} commit_id_hex
+ * @param {Uint8Array} bundle
+ * @returns {VerifiedSpan}
+ */
+export function verify_disclosure_span(commit_id_hex, bundle) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(commit_id_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bundle, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.verify_disclosure_span(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return VerifiedSpan.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verify a single tree-entry inclusion proof against a tree object id.
+ *
+ * `entry_json` is `{ "name" | "name_hex", "mode", "object_hash" }`.
+ * `mode` matches [`crate::tree_encode`]: `blob` / `tree` / `symlink` /
+ * `exec`. `object_hash` is 64-char lowercase hex. Returns `Ok(false)`
+ * when the proof does not fold to `tree_id_hex`
+ * ([`MerkleError::VerificationFailed`]); `Err` on malformed input.
+ *
+ * # Errors
+ *
+ * Malformed hex, JSON, or proof bytes, or any merkle error other than
+ * [`MerkleError::VerificationFailed`].
+ * @param {string} tree_id_hex
+ * @param {string} entry_json
+ * @param {number} position
+ * @param {Uint8Array} proof
+ * @returns {boolean}
+ */
+export function verify_tree_entry(tree_id_hex, entry_json, position, proof) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(tree_id_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(entry_json, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(proof, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.verify_tree_entry(retptr, ptr0, len0, ptr1, len1, position, ptr2, len2);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0 !== 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Verify a browser passkey (`WebAuthn` / P-256) assertion against a DSSE
+ * PAE — cryptographic checks only, no ceremony policy.
+ *
+ * Thin wrapper over `kit_attest::verify_webauthn_wrapping`. Checks the
+ * `type == "webauthn.get"`, `challenge == base64url-nopad(pae)`, the
+ * `authenticatorData` shape, and the P-256 signature over
+ * `authenticatorData || SHA-256(clientDataJSON)`. It does NOT bind the
+ * RP ID or origin — use [`verify_webauthn_wrapping_with_policy`] for
+ * that (which is what a real demo should do, pinning the RP ID to the
+ * site so the green check proves origin binding, not just a signature).
+ *
+ * * `pae` — the bytes from [`attest_pae`].
+ * * `authenticator_data` / `client_data_json` — raw bytes from the
+ *   browser assertion (`response.authenticatorData` /
+ *   `response.clientDataJSON`), passed as a `Uint8Array`.
+ * * `pubkey_hex` — SEC1 P-256 public key, 33-byte compressed (66 hex)
+ *   or 65-byte uncompressed (130 hex).
+ * * `signature` — 64-byte compact `r || s` (DER must be converted and
+ *   low-S-normalised JS-side first).
+ *
+ * Returns `Ok(())` when the assertion verifies. On failure the `Err`
+ * carries the typed reason (challenge mismatch, signature failed, …) so
+ * the demo can show *why* — more instructive than a bare boolean.
+ *
+ * # Errors
+ * `pubkey_hex` is not valid hex, or any `WebAuthn` verification failure.
+ * @param {Uint8Array} pae
+ * @param {Uint8Array} authenticator_data
+ * @param {Uint8Array} client_data_json
+ * @param {string} pubkey_hex
+ * @param {Uint8Array} signature
+ */
+export function verify_webauthn_wrapping(pae, authenticator_data, client_data_json, pubkey_hex, signature) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(pae, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(authenticator_data, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(client_data_json, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(pubkey_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray8ToWasm0(signature, wasm.__wbindgen_export2);
+        const len4 = WASM_VECTOR_LEN;
+        wasm.verify_webauthn_wrapping(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        if (r1) {
+            throw takeObject(r0);
+        }
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Policy-aware counterpart of [`verify_webauthn_wrapping`].
+ *
+ * Same cryptographic checks, plus the ceremony policy parsed from
+ * `policy_json` — an empty string (or `"{}"`) is fully permissive.
+ * Recognised keys (all optional):
+ *
+ * ```json
+ * {
+ *   "expected_rp_id": "kit.storage",
+ *   "allowed_origins": ["https://kit.storage"],
+ *   "require_user_presence": true,
+ *   "require_user_verification": false,
+ *   "allow_cross_origin": false,
+ *   "previous_sign_count": 0
+ * }
+ * ```
+ *
+ * Defaults match `WebAuthnPolicy::permissive` (no RP-ID/origin binding,
+ * UP/UV off, cross-origin allowed, counter unenforced) — only keys
+ * present in `policy_json` tighten the check.
+ *
+ * # Errors
+ * Malformed `policy_json`, `pubkey_hex` is not valid hex, or any
+ * `WebAuthn` verification failure.
+ * @param {Uint8Array} pae
+ * @param {Uint8Array} authenticator_data
+ * @param {Uint8Array} client_data_json
+ * @param {string} pubkey_hex
+ * @param {Uint8Array} signature
+ * @param {string} policy_json
+ */
+export function verify_webauthn_wrapping_with_policy(pae, authenticator_data, client_data_json, pubkey_hex, signature, policy_json) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(pae, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(authenticator_data, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(client_data_json, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(pubkey_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray8ToWasm0(signature, wasm.__wbindgen_export2);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passStringToWasm0(policy_json, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len5 = WASM_VECTOR_LEN;
+        wasm.verify_webauthn_wrapping_with_policy(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        if (r1) {
+            throw takeObject(r0);
+        }
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Wrap a BMT inner root with the kit type domain, producing the object id.
+ *
+ * `kind` is `"tree"` or `"chunked_blob"`. For a commonware BMT verifier
+ * that checked the inner root, this is the remaining step before
+ * comparing to an kit id.
+ *
+ * # Errors
+ *
+ * Unknown `kind` or malformed hex.
+ * @param {string} kind
+ * @param {string} inner_root_hex
+ * @returns {string}
+ */
+export function wrap_object_id(kind, inner_root_hex) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(inner_root_hex, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wrap_object_id(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+    }
+}
+export function __wbg_Error_30c8987f7c2ed4e2(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+}
+export function __wbg___wbindgen_throw_41e9ee4f547fc59a(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_getRandomValues_436a51d0629d84e1() { return handleError(function (arg0, arg1) {
+    globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+}, arguments); }
+export function __wbindgen_generic_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+}
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+}
+const AttestKeyPairJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_attestkeypairjs_free(ptr, 1));
+const AttestationJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_attestationjs_free(ptr, 1));
+const BaoEncodedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_baoencoded_free(ptr, 1));
+const BaoVerifyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_baoverify_free(ptr, 1));
+const ChunkInfoFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chunkinfo_free(ptr, 1));
+const ChunkedBlobJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chunkedblobjs_free(ptr, 1));
+const ChunkerResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chunkerresult_free(ptr, 1));
+const CommitInfoJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_commitinfojs_free(ptr, 1));
+const DeltaOpFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_deltaop_free(ptr, 1));
+const DeltaSummaryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_deltasummary_free(ptr, 1));
+const EncodedCommitFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encodedcommit_free(ptr, 1));
+const EncodedObjectFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encodedobject_free(ptr, 1));
+const KeyPairJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_keypairjs_free(ptr, 1));
+const RemixInfoJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_remixinfojs_free(ptr, 1));
+const RemixSourceJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_remixsourcejs_free(ptr, 1));
+const VerifiedSpanFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_verifiedspan_free(ptr, 1));
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export(addHeapObject(e));
+    }
+}
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}