@automerge/subduction 0.4.2-alpha.0

package/dist/wasm_bindgen/web/subduction_wasm.js

@@ -0,0 +1,4386 @@
+/* @ts-self-types="./subduction_wasm.d.ts" */
+import { tryIntoJsSedimentreeIdsArray } from './snippets/sedimentree_wasm-02bbe03284226492/inline2.js';
+
+/**
+ * An authenticated HTTP long-poll connection.
+ *
+ * This wrapper proves that the connection has completed the Subduction handshake
+ * and the peer identity has been cryptographically verified.
+ *
+ * Obtain via [`SubductionLongPoll::tryConnect`] or [`SubductionLongPoll::tryDiscover`].
+ */
+export class AuthenticatedLongPoll {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AuthenticatedLongPoll.prototype);
+        obj.__wbg_ptr = ptr;
+        AuthenticatedLongPollFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AuthenticatedLongPollFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_authenticatedlongpoll_free(ptr, 0);
+    }
+    /**
+     * The verified peer identity.
+     * @returns {PeerId}
+     */
+    get peerId() {
+        const ret = wasm.authenticatedlongpoll_peerId(this.__wbg_ptr);
+        return PeerId.__wrap(ret);
+    }
+    /**
+     * The session ID assigned by the server.
+     * @returns {string}
+     */
+    get sessionId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.authenticatedlongpoll_sessionId(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) AuthenticatedLongPoll.prototype[Symbol.dispose] = AuthenticatedLongPoll.prototype.free;
+
+/**
+ * An authenticated WebSocket connection.
+ *
+ * This wrapper proves that the connection has completed the Subduction handshake
+ * and the peer identity has been cryptographically verified.
+ *
+ * Obtain via [`SubductionWebSocket::setup`], [`SubductionWebSocket::tryConnect`],
+ * or [`SubductionWebSocket::tryDiscover`].
+ */
+export class AuthenticatedWebSocket {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AuthenticatedWebSocket.prototype);
+        obj.__wbg_ptr = ptr;
+        AuthenticatedWebSocketFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AuthenticatedWebSocketFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_authenticatedwebsocket_free(ptr, 0);
+    }
+    /**
+     * The verified peer identity.
+     * @returns {PeerId}
+     */
+    get peerId() {
+        const ret = wasm.authenticatedwebsocket_peerId(this.__wbg_ptr);
+        return PeerId.__wrap(ret);
+    }
+}
+if (Symbol.dispose) AuthenticatedWebSocket.prototype[Symbol.dispose] = AuthenticatedWebSocket.prototype.free;
+
+/**
+ * Wasm wrapper for [`BatchSyncRequest`].
+ */
+export class BatchSyncRequest {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(BatchSyncRequest.prototype);
+        obj.__wbg_ptr = ptr;
+        BatchSyncRequestFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BatchSyncRequestFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_batchsyncrequest_free(ptr, 0);
+    }
+    /**
+     * The sedimentree ID this request corresponds to.
+     * @returns {SedimentreeId}
+     */
+    id() {
+        const ret = wasm.batchsyncrequest_id(this.__wbg_ptr);
+        return SedimentreeId.__wrap(ret);
+    }
+    /**
+     * The request ID for this request.
+     * @returns {RequestId}
+     */
+    request_id() {
+        const ret = wasm.batchsyncrequest_request_id(this.__wbg_ptr);
+        return RequestId.__wrap(ret);
+    }
+    /**
+     * Whether this request subscribes to future updates.
+     * @returns {boolean}
+     */
+    subscribe() {
+        const ret = wasm.batchsyncrequest_subscribe(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) BatchSyncRequest.prototype[Symbol.dispose] = BatchSyncRequest.prototype.free;
+
+/**
+ * Wasm wrapper for [`BatchSyncResponse`].
+ */
+export class BatchSyncResponse {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(BatchSyncResponse.prototype);
+        obj.__wbg_ptr = ptr;
+        BatchSyncResponseFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BatchSyncResponseFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_batchsyncresponse_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmBatchSyncResponse`].
+     * @returns {BatchSyncResponse}
+     */
+    __wasm_refgen_toWasmBatchSyncResponse() {
+        const ret = wasm.batchsyncresponse___wasm_refgen_toWasmBatchSyncResponse(this.__wbg_ptr);
+        return BatchSyncResponse.__wrap(ret);
+    }
+    /**
+     * The sedimentree ID this response corresponds to.
+     * @returns {SedimentreeId}
+     */
+    id() {
+        const ret = wasm.batchsyncresponse_id(this.__wbg_ptr);
+        return SedimentreeId.__wrap(ret);
+    }
+    /**
+     * The request ID this response corresponds to.
+     * @returns {RequestId}
+     */
+    request_id() {
+        const ret = wasm.batchsyncresponse_request_id(this.__wbg_ptr);
+        return RequestId.__wrap(ret);
+    }
+}
+if (Symbol.dispose) BatchSyncResponse.prototype[Symbol.dispose] = BatchSyncResponse.prototype.free;
+
+/**
+ * A Wasm wrapper around the [`BlobMeta`] type.
+ */
+export class BlobMeta {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(BlobMeta.prototype);
+        obj.__wbg_ptr = ptr;
+        BlobMetaFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BlobMetaFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_blobmeta_free(ptr, 0);
+    }
+    /**
+     * Get the digest of the blob.
+     * @returns {Digest}
+     */
+    digest() {
+        const ret = wasm.blobmeta_digest(this.__wbg_ptr);
+        return Digest.__wrap(ret);
+    }
+    /**
+     * Create a `BlobMeta` from a digest and size.
+     *
+     * This is useful for deserialization when the original blob is not available.
+     * Since this is manual, the caller must ensure the digest and size are correct.
+     * @param {Digest} digest
+     * @param {bigint} size_bytes
+     * @returns {BlobMeta}
+     */
+    static fromDigestSize(digest, size_bytes) {
+        _assertClass(digest, Digest);
+        const ret = wasm.blobmeta_fromDigestSize(digest.__wbg_ptr, size_bytes);
+        return BlobMeta.__wrap(ret);
+    }
+    /**
+     * Create a new `BlobMeta` from the given blob contents.
+     * @param {Uint8Array} blob
+     */
+    constructor(blob) {
+        const ptr0 = passArray8ToWasm0(blob, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.blobmeta_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        BlobMetaFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the size of the blob in bytes.
+     * @returns {bigint}
+     */
+    get sizeBytes() {
+        const ret = wasm.blobmeta_sizeBytes(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+}
+if (Symbol.dispose) BlobMeta.prototype[Symbol.dispose] = BlobMeta.prototype.free;
+
+/**
+ * Wasm wrapper for call errors from the unified transport.
+ */
+export class CallError {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CallErrorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_callerror_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) CallError.prototype[Symbol.dispose] = CallError.prototype.free;
+
+/**
+ * A commit stored with its associated blob.
+ */
+export class CommitWithBlob {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CommitWithBlob.prototype);
+        obj.__wbg_ptr = ptr;
+        CommitWithBlobFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CommitWithBlobFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_commitwithblob_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmCommitWithBlob`].
+     * @returns {CommitWithBlob}
+     */
+    __wasm_refgen_toWasmCommitWithBlob() {
+        const ret = wasm.commitwithblob___wasm_refgen_toWasmCommitWithBlob(this.__wbg_ptr);
+        return CommitWithBlob.__wrap(ret);
+    }
+    /**
+     * Get the blob.
+     * @returns {Uint8Array}
+     */
+    get blob() {
+        const ret = wasm.commitwithblob_blob(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Create a new commit with blob.
+     * @param {SignedLooseCommit} signed
+     * @param {Uint8Array} blob
+     */
+    constructor(signed, blob) {
+        _assertClass(signed, SignedLooseCommit);
+        var ptr0 = signed.__destroy_into_raw();
+        const ret = wasm.commitwithblob_new(ptr0, addHeapObject(blob));
+        this.__wbg_ptr = ret >>> 0;
+        CommitWithBlobFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the signed commit.
+     * @returns {SignedLooseCommit}
+     */
+    get signed() {
+        const ret = wasm.commitwithblob_signed(this.__wbg_ptr);
+        return SignedLooseCommit.__wrap(ret);
+    }
+}
+if (Symbol.dispose) CommitWithBlob.prototype[Symbol.dispose] = CommitWithBlob.prototype.free;
+
+/**
+ * A pair of a connection and an error that occurred during a call.
+ */
+export class ConnErrorPair {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ConnErrorPair.prototype);
+        obj.__wbg_ptr = ptr;
+        ConnErrorPairFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ConnErrorPairFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_connerrorpair_free(ptr, 0);
+    }
+    /**
+     * The connection that encountered the error.
+     * @returns {Connection}
+     */
+    get conn() {
+        const ret = wasm.connerrorpair_conn(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The error that occurred during the call.
+     * @returns {Error}
+     */
+    get err() {
+        const ret = wasm.connerrorpair_err(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) ConnErrorPair.prototype[Symbol.dispose] = ConnErrorPair.prototype.free;
+
+/**
+ * A Wasm wrapper around the Rust `ConnectionId` type.
+ */
+export class ConnectionId {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ConnectionIdFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_connectionid_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) ConnectionId.prototype[Symbol.dispose] = ConnectionId.prototype.free;
+
+/**
+ * A JavaScript wrapper around `Depth`.
+ */
+export class Depth {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Depth.prototype);
+        obj.__wbg_ptr = ptr;
+        DepthFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DepthFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_depth_free(ptr, 0);
+    }
+    /**
+     * Internal method for a hack crossing the JS boundary.
+     * @returns {Depth}
+     */
+    __subduction_castToDepth() {
+        const ret = wasm.depth___subduction_castToDepth(this.__wbg_ptr);
+        return Depth.__wrap(ret);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmDepth`].
+     * @returns {Depth}
+     */
+    __wasm_refgen_toWasmDepth() {
+        const ret = wasm.depth___subduction_castToDepth(this.__wbg_ptr);
+        return Depth.__wrap(ret);
+    }
+    /**
+     * Creates a new `WasmDepth` from a JavaScript value.
+     *
+     * # Errors
+     *
+     * Returns a `NotU32Error` if the JS value is not safely coercible to `u32`.
+     * @param {any} js_value
+     */
+    constructor(js_value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.depth_new(retptr, addBorrowedObject(js_value));
+            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);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            DepthFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * The depth value as an integer.
+     * @returns {number}
+     */
+    get value() {
+        const ret = wasm.depth_value(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Depth.prototype[Symbol.dispose] = Depth.prototype.free;
+
+/**
+ * A wrapper around digest bytes for use in JavaScript via wasm-bindgen.
+ *
+ * Since JavaScript doesn't have Rust's type system, this stores raw bytes
+ * and converts to/from typed `Digest<T>` at the Rust boundary.
+ */
+export class Digest {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Digest.prototype);
+        obj.__wbg_ptr = ptr;
+        DigestFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof Digest)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DigestFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_digest_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmDigest`].
+     * @returns {Digest}
+     */
+    __wasm_refgen_toWasmDigest() {
+        const ret = wasm.digest___wasm_refgen_toWasmDigest(this.__wbg_ptr);
+        return Digest.__wrap(ret);
+    }
+    /**
+     * Creates a new digest from its Base58 string representation.
+     *
+     * # Errors
+     *
+     * Returns a `WasmInvalidDigest` error if the string cannot be decoded or is not a valid digest.
+     * @param {string} s
+     * @returns {Digest}
+     */
+    static fromBase58(s) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.digest_fromBase58(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 Digest.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Creates a new digest from its byte representation.
+     *
+     * # Errors
+     *
+     * Returns a `WasmValue` error if the byte slice is not a valid digest.
+     * @param {Uint8Array} bytes
+     * @returns {Digest}
+     */
+    static fromBytes(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.digest_fromBytes(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 Digest.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Creates a new digest from its hexadecimal string representation.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmInvalidDigest`] if the string is not a valid digest.
+     * @param {string} s
+     * @returns {Digest}
+     */
+    static fromHexString(s) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.digest_fromHexString(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 Digest.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Creates a new digest from its byte representation.
+     *
+     * # Errors
+     *
+     * Returns a `WasmValue` error if the byte slice is not a valid digest.
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.digest_new(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);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            DigestFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the byte representation of the digest.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.digest_toBytes(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 the hexadecimal string representation of the digest.
+     * @returns {string}
+     */
+    toHexString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.digest_toHexString(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) Digest.prototype[Symbol.dispose] = Digest.prototype.free;
+
+/**
+ * A data fragment used in the Sedimentree system.
+ */
+export class Fragment {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Fragment.prototype);
+        obj.__wbg_ptr = ptr;
+        FragmentFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FragmentFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fragment_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmFragment`].
+     * @returns {Fragment}
+     */
+    __wasm_refgen_toWasmFragment() {
+        const ret = wasm.fragment___wasm_refgen_toWasmFragment(this.__wbg_ptr);
+        return Fragment.__wrap(ret);
+    }
+    /**
+     * Get the blob metadata of the fragment.
+     * @returns {BlobMeta}
+     */
+    get blobMeta() {
+        const ret = wasm.fragment_blobMeta(this.__wbg_ptr);
+        return BlobMeta.__wrap(ret);
+    }
+    /**
+     * Get the boundary digests of the fragment.
+     * @returns {Digest[]}
+     */
+    get boundary() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fragment_boundary(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the head digest of the fragment.
+     * @returns {Digest}
+     */
+    get head() {
+        const ret = wasm.fragment_head(this.__wbg_ptr);
+        return Digest.__wrap(ret);
+    }
+    /**
+     * Create a new fragment from the given sedimentree ID, head, boundary, checkpoints, and blob metadata.
+     * @param {SedimentreeId} sedimentree_id
+     * @param {Digest} head
+     * @param {Digest[]} boundary
+     * @param {Digest[]} checkpoints
+     * @param {BlobMeta} blob_meta
+     */
+    constructor(sedimentree_id, head, boundary, checkpoints, blob_meta) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        var ptr0 = sedimentree_id.__destroy_into_raw();
+        _assertClass(head, Digest);
+        var ptr1 = head.__destroy_into_raw();
+        const ptr2 = passArrayJsValueToWasm0(boundary, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArrayJsValueToWasm0(checkpoints, wasm.__wbindgen_export);
+        const len3 = WASM_VECTOR_LEN;
+        _assertClass(blob_meta, BlobMeta);
+        var ptr4 = blob_meta.__destroy_into_raw();
+        const ret = wasm.fragment_new(ptr0, ptr1, ptr2, len2, ptr3, len3, ptr4);
+        this.__wbg_ptr = ret >>> 0;
+        FragmentFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) Fragment.prototype[Symbol.dispose] = Fragment.prototype.free;
+
+/**
+ * A request for a specific fragment in the Sedimentree system.
+ */
+export class FragmentRequested {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(FragmentRequested.prototype);
+        obj.__wbg_ptr = ptr;
+        FragmentRequestedFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FragmentRequestedFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fragmentrequested_free(ptr, 0);
+    }
+    /**
+     * Get the depth of the requested fragment.
+     * @returns {Depth}
+     */
+    get depth() {
+        const ret = wasm.fragmentrequested_depth(this.__wbg_ptr);
+        return Depth.__wrap(ret);
+    }
+    /**
+     * Get the digest of the requested fragment.
+     * @returns {Digest}
+     */
+    get head() {
+        const ret = wasm.fragmentrequested_head(this.__wbg_ptr);
+        return Digest.__wrap(ret);
+    }
+    /**
+     * Create a new fragment request from the given digest.
+     * @param {Digest} digest
+     * @param {Depth} depth
+     */
+    constructor(digest, depth) {
+        _assertClass(digest, Digest);
+        _assertClass(depth, Depth);
+        const ret = wasm.fragmentrequested_new(digest.__wbg_ptr, depth.__wbg_ptr);
+        this.__wbg_ptr = ret >>> 0;
+        FragmentRequestedFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) FragmentRequested.prototype[Symbol.dispose] = FragmentRequested.prototype.free;
+
+/**
+ * A fragment stored with its associated blob.
+ */
+export class FragmentWithBlob {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(FragmentWithBlob.prototype);
+        obj.__wbg_ptr = ptr;
+        FragmentWithBlobFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FragmentWithBlobFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fragmentwithblob_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmFragmentWithBlob`].
+     * @returns {FragmentWithBlob}
+     */
+    __wasm_refgen_toWasmFragmentWithBlob() {
+        const ret = wasm.fragmentwithblob___wasm_refgen_toWasmFragmentWithBlob(this.__wbg_ptr);
+        return FragmentWithBlob.__wrap(ret);
+    }
+    /**
+     * Get the blob.
+     * @returns {Uint8Array}
+     */
+    get blob() {
+        const ret = wasm.commitwithblob_blob(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Create a new fragment with blob.
+     * @param {SignedFragment} signed
+     * @param {Uint8Array} blob
+     */
+    constructor(signed, blob) {
+        _assertClass(signed, SignedFragment);
+        var ptr0 = signed.__destroy_into_raw();
+        const ret = wasm.commitwithblob_new(ptr0, addHeapObject(blob));
+        this.__wbg_ptr = ret >>> 0;
+        FragmentWithBlobFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the signed fragment.
+     * @returns {SignedFragment}
+     */
+    get signed() {
+        const ret = wasm.fragmentwithblob_signed(this.__wbg_ptr);
+        return SignedFragment.__wrap(ret);
+    }
+}
+if (Symbol.dispose) FragmentWithBlob.prototype[Symbol.dispose] = FragmentWithBlob.prototype.free;
+
+export class FragmentsArray {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(FragmentsArray.prototype);
+        obj.__wbg_ptr = ptr;
+        FragmentsArrayFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FragmentsArrayFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fragmentsarray_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmFragmentsArray`].
+     * @returns {FragmentsArray}
+     */
+    __wasm_refgen_toWasmFragmentsArray() {
+        const ret = wasm.fragmentsarray___wasm_refgen_toWasmFragmentsArray(this.__wbg_ptr);
+        return FragmentsArray.__wrap(ret);
+    }
+}
+if (Symbol.dispose) FragmentsArray.prototype[Symbol.dispose] = FragmentsArray.prototype.free;
+
+/**
+ * An overridable hash metric.
+ */
+export class HashMetric {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HashMetricFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_hashmetric_free(ptr, 0);
+    }
+    /**
+     * Create a new `WasmHashMetric` with an optional JavaScript function.
+     *
+     * Defaults to counting leading zero bytes if no function is provided.
+     * @param {Function | null} [func]
+     */
+    constructor(func) {
+        const ret = wasm.hashmetric_new(isLikeNone(func) ? 0 : addHeapObject(func));
+        this.__wbg_ptr = ret >>> 0;
+        HashMetricFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) HashMetric.prototype[Symbol.dispose] = HashMetric.prototype.free;
+
+/**
+ * A Wasm wrapper around the [`LooseCommit`] type.
+ */
+export class LooseCommit {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(LooseCommit.prototype);
+        obj.__wbg_ptr = ptr;
+        LooseCommitFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LooseCommitFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_loosecommit_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmLooseCommit`].
+     * @returns {LooseCommit}
+     */
+    __wasm_refgen_toWasmLooseCommit() {
+        const ret = wasm.loosecommit___wasm_refgen_toWasmLooseCommit(this.__wbg_ptr);
+        return LooseCommit.__wrap(ret);
+    }
+    /**
+     * Get the blob metadata of the commit.
+     * @returns {BlobMeta}
+     */
+    get blobMeta() {
+        const ret = wasm.loosecommit_blobMeta(this.__wbg_ptr);
+        return BlobMeta.__wrap(ret);
+    }
+    /**
+     * Get the digest of the commit.
+     * @returns {Digest}
+     */
+    get digest() {
+        const ret = wasm.loosecommit_digest(this.__wbg_ptr);
+        return Digest.__wrap(ret);
+    }
+    /**
+     * Create a new `LooseCommit` from the given sedimentree ID, parents, and blob metadata.
+     * @param {SedimentreeId} sedimentree_id
+     * @param {Digest[]} parents
+     * @param {BlobMeta} blob_meta
+     */
+    constructor(sedimentree_id, parents, blob_meta) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        var ptr0 = sedimentree_id.__destroy_into_raw();
+        const ptr1 = passArrayJsValueToWasm0(parents, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        _assertClass(blob_meta, BlobMeta);
+        const ret = wasm.loosecommit_new(ptr0, ptr1, len1, blob_meta.__wbg_ptr);
+        this.__wbg_ptr = ret >>> 0;
+        LooseCommitFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the parent digests of the commit.
+     * @returns {Digest[]}
+     */
+    get parents() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.loosecommit_parents(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) LooseCommit.prototype[Symbol.dispose] = LooseCommit.prototype.free;
+
+/**
+ * An in-memory storage implementation for use in tests and development.
+ *
+ * This wraps the core `MemoryStorage` and exposes it via the `SedimentreeStorage` interface.
+ */
+export class MemoryStorage {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MemoryStorageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_memorystorage_free(ptr, 0);
+    }
+    /**
+     * Delete all commits for a sedimentree.
+     * @param {SedimentreeId} sedimentree_id
+     * @returns {Promise<any>}
+     */
+    deleteAllCommits(sedimentree_id) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        const ret = wasm.memorystorage_deleteAllCommits(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Delete all fragments for a sedimentree.
+     * @param {SedimentreeId} sedimentree_id
+     * @returns {Promise<any>}
+     */
+    deleteAllFragments(sedimentree_id) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        const ret = wasm.memorystorage_deleteAllFragments(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Delete a commit by digest.
+     * @param {SedimentreeId} sedimentree_id
+     * @param {Digest} digest
+     * @returns {Promise<any>}
+     */
+    deleteCommit(sedimentree_id, digest) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        _assertClass(digest, Digest);
+        const ret = wasm.memorystorage_deleteCommit(this.__wbg_ptr, sedimentree_id.__wbg_ptr, digest.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Delete a fragment by digest.
+     * @param {SedimentreeId} sedimentree_id
+     * @param {Digest} digest
+     * @returns {Promise<any>}
+     */
+    deleteFragment(sedimentree_id, digest) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        _assertClass(digest, Digest);
+        const ret = wasm.memorystorage_deleteFragment(this.__wbg_ptr, sedimentree_id.__wbg_ptr, digest.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Delete a sedimentree ID.
+     * @param {SedimentreeId} sedimentree_id
+     * @returns {Promise<any>}
+     */
+    deleteSedimentreeId(sedimentree_id) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        const ret = wasm.memorystorage_deleteSedimentreeId(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * List all commit digests for a sedimentree.
+     * @param {SedimentreeId} sedimentree_id
+     * @returns {Promise<any>}
+     */
+    listCommitDigests(sedimentree_id) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        const ret = wasm.memorystorage_listCommitDigests(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * List all fragment digests for a sedimentree.
+     * @param {SedimentreeId} sedimentree_id
+     * @returns {Promise<any>}
+     */
+    listFragmentDigests(sedimentree_id) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        const ret = wasm.memorystorage_listFragmentDigests(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Load all commits for a sedimentree, returning `CommitWithBlob[]`.
+     * @param {SedimentreeId} sedimentree_id
+     * @returns {Promise<any>}
+     */
+    loadAllCommits(sedimentree_id) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        const ret = wasm.memorystorage_loadAllCommits(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Load all fragments for a sedimentree, returning `FragmentWithBlob[]`.
+     * @param {SedimentreeId} sedimentree_id
+     * @returns {Promise<any>}
+     */
+    loadAllFragments(sedimentree_id) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        const ret = wasm.memorystorage_loadAllFragments(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Load all sedimentree IDs.
+     * @returns {Promise<any>}
+     */
+    loadAllSedimentreeIds() {
+        const ret = wasm.memorystorage_loadAllSedimentreeIds(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Load a commit by digest, returning `CommitWithBlob` or null.
+     * @param {SedimentreeId} sedimentree_id
+     * @param {Digest} digest
+     * @returns {Promise<any>}
+     */
+    loadCommit(sedimentree_id, digest) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        _assertClass(digest, Digest);
+        const ret = wasm.memorystorage_loadCommit(this.__wbg_ptr, sedimentree_id.__wbg_ptr, digest.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Load a fragment by digest, returning `FragmentWithBlob` or null.
+     * @param {SedimentreeId} sedimentree_id
+     * @param {Digest} digest
+     * @returns {Promise<any>}
+     */
+    loadFragment(sedimentree_id, digest) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        _assertClass(digest, Digest);
+        const ret = wasm.memorystorage_loadFragment(this.__wbg_ptr, sedimentree_id.__wbg_ptr, digest.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Create a new in-memory storage instance.
+     */
+    constructor() {
+        const ret = wasm.memorystorage_new();
+        this.__wbg_ptr = ret >>> 0;
+        MemoryStorageFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Save a commit with its blob.
+     * @param {SedimentreeId} sedimentree_id
+     * @param {Digest} _digest
+     * @param {SignedLooseCommit} signed_commit
+     * @param {Uint8Array} blob
+     * @returns {Promise<any>}
+     */
+    saveCommit(sedimentree_id, _digest, signed_commit, blob) {
+        try {
+            _assertClass(sedimentree_id, SedimentreeId);
+            _assertClass(_digest, Digest);
+            _assertClass(signed_commit, SignedLooseCommit);
+            const ret = wasm.memorystorage_saveCommit(this.__wbg_ptr, sedimentree_id.__wbg_ptr, _digest.__wbg_ptr, signed_commit.__wbg_ptr, addBorrowedObject(blob));
+            return takeObject(ret);
+        } finally {
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Save a fragment with its blob.
+     * @param {SedimentreeId} sedimentree_id
+     * @param {Digest} _digest
+     * @param {SignedFragment} signed_fragment
+     * @param {Uint8Array} blob
+     * @returns {Promise<any>}
+     */
+    saveFragment(sedimentree_id, _digest, signed_fragment, blob) {
+        try {
+            _assertClass(sedimentree_id, SedimentreeId);
+            _assertClass(_digest, Digest);
+            _assertClass(signed_fragment, SignedFragment);
+            const ret = wasm.memorystorage_saveFragment(this.__wbg_ptr, sedimentree_id.__wbg_ptr, _digest.__wbg_ptr, signed_fragment.__wbg_ptr, addBorrowedObject(blob));
+            return takeObject(ret);
+        } finally {
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Save a sedimentree ID.
+     * @param {SedimentreeId} sedimentree_id
+     * @returns {Promise<any>}
+     */
+    saveSedimentreeId(sedimentree_id) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        const ret = wasm.memorystorage_saveSedimentreeId(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) MemoryStorage.prototype[Symbol.dispose] = MemoryStorage.prototype.free;
+
+/**
+ * Wasm wrapper for [`Message`].
+ */
+export class Message {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Message.prototype);
+        obj.__wbg_ptr = ptr;
+        MessageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MessageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_message_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmMessage`].
+     * @returns {Message}
+     */
+    __wasm_refgen_toWasmMessage() {
+        const ret = wasm.message___wasm_refgen_toWasmMessage(this.__wbg_ptr);
+        return Message.__wrap(ret);
+    }
+    /**
+     * Create a [`Message::BatchSyncRequest`] message.
+     * @param {BatchSyncRequest} request
+     * @returns {Message}
+     */
+    static batchSyncRequest(request) {
+        _assertClass(request, BatchSyncRequest);
+        const ret = wasm.message_batchSyncRequest(request.__wbg_ptr);
+        return Message.__wrap(ret);
+    }
+    /**
+     * Create a [`Message::BatchSyncResponse`] message.
+     * @param {BatchSyncResponse} response
+     * @returns {Message}
+     */
+    static batchSyncResponse(response) {
+        _assertClass(response, BatchSyncResponse);
+        const ret = wasm.message_batchSyncResponse(response.__wbg_ptr);
+        return Message.__wrap(ret);
+    }
+    /**
+     * The [`Blob`] for commit or fragment messages, if applicable.
+     * @returns {Uint8Array | undefined}
+     */
+    get blob() {
+        const ret = wasm.message_blob(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The [`Blob`]s for a [`Message::BlobsResponse`], if applicable.
+     * @returns {Uint8Array[] | undefined}
+     */
+    get blobs() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.message_blobs(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 = getArrayJsValueFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Create a [`Message::BlobsRequest`] message.
+     * @param {SedimentreeId} id
+     * @param {Digest[]} digests
+     * @returns {Message}
+     */
+    static blobsRequest(id, digests) {
+        _assertClass(id, SedimentreeId);
+        const ptr0 = passArrayJsValueToWasm0(digests, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.message_blobsRequest(id.__wbg_ptr, ptr0, len0);
+        return Message.__wrap(ret);
+    }
+    /**
+     * Create a [`Message::BlobsResponse`] message.
+     * @param {SedimentreeId} id
+     * @param {Uint8Array[]} blobs
+     * @returns {Message}
+     */
+    static blobsResponse(id, blobs) {
+        _assertClass(id, SedimentreeId);
+        const ptr0 = passArrayJsValueToWasm0(blobs, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.message_blobsResponse(id.__wbg_ptr, ptr0, len0);
+        return Message.__wrap(ret);
+    }
+    /**
+     * The [`LooseCommit`] for a [`Message::LooseCommit`], if applicable.
+     *
+     * Decodes the signed payload to extract the underlying commit.
+     * @returns {LooseCommit | undefined}
+     */
+    get commit() {
+        const ret = wasm.message_commit(this.__wbg_ptr);
+        return ret === 0 ? undefined : LooseCommit.__wrap(ret);
+    }
+    /**
+     * The requested [`Digest`]s for a [`Message::BlobsRequest`], if applicable.
+     * @returns {Digest[] | undefined}
+     */
+    get digests() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.message_digests(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 = getArrayJsValueFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The [`Fragment`] for a [`Message::Fragment`], if applicable.
+     *
+     * Decodes the signed payload to extract the underlying fragment.
+     * @returns {Fragment | undefined}
+     */
+    get fragment() {
+        const ret = wasm.message_fragment(this.__wbg_ptr);
+        return ret === 0 ? undefined : Fragment.__wrap(ret);
+    }
+    /**
+     * Deserialize a message from bytes.
+     *
+     * # Errors
+     *
+     * Returns a [`JsMessageDeserializationError`] if deserialization fails.
+     * @param {Uint8Array} bytes
+     * @returns {Message}
+     */
+    static fromBytes(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.message_fromBytes(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 Message.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The [`BatchSyncRequest`] for a [`Message::BatchSyncRequest`], if applicable.
+     * @returns {BatchSyncRequest | undefined}
+     */
+    get request() {
+        const ret = wasm.message_request(this.__wbg_ptr);
+        return ret === 0 ? undefined : BatchSyncRequest.__wrap(ret);
+    }
+    /**
+     * The [`BatchSyncResponse`] for a [`Message::BatchSyncResponse`], if applicable.
+     * @returns {BatchSyncResponse | undefined}
+     */
+    get response() {
+        const ret = wasm.message_response(this.__wbg_ptr);
+        return ret === 0 ? undefined : BatchSyncResponse.__wrap(ret);
+    }
+    /**
+     * The [`SedimentreeId`] associated with this message, if any.
+     * @returns {SedimentreeId | undefined}
+     */
+    get sedimentreeId() {
+        const ret = wasm.message_sedimentreeId(this.__wbg_ptr);
+        return ret === 0 ? undefined : SedimentreeId.__wrap(ret);
+    }
+    /**
+     * Serialize the message to bytes.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.message_toBytes(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);
+        }
+    }
+    /**
+     * The message variant name.
+     * @returns {string}
+     */
+    get type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.message_type(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) Message.prototype[Symbol.dispose] = Message.prototype.free;
+
+/**
+ * A 64-bit nonce represented as big-endian bytes.
+ */
+export class Nonce {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Nonce.prototype);
+        obj.__wbg_ptr = ptr;
+        NonceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NonceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_nonce_free(ptr, 0);
+    }
+    /**
+     * Get the nonce as big-endian bytes.
+     * @returns {Uint8Array}
+     */
+    get bytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.nonce_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);
+        }
+    }
+    /**
+     * Create a new [`WasmNonce`] from exactly 8 big-endian bytes.
+     *
+     * # Errors
+     *
+     * Returns [`WasmNonceError`] if the input is not exactly 8 bytes.
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.nonce_new(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);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            NonceFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Generate a random nonce.
+     *
+     * # Panics
+     *
+     * Panics if the system random number generator fails.
+     * @returns {Nonce}
+     */
+    static random() {
+        const ret = wasm.nonce_random();
+        return Nonce.__wrap(ret);
+    }
+}
+if (Symbol.dispose) Nonce.prototype[Symbol.dispose] = Nonce.prototype.free;
+
+/**
+ * Result of a peer batch sync request.
+ */
+export class PeerBatchSyncResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PeerBatchSyncResult.prototype);
+        obj.__wbg_ptr = ptr;
+        PeerBatchSyncResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PeerBatchSyncResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_peerbatchsyncresult_free(ptr, 0);
+    }
+    /**
+     * List of connection errors that occurred during the batch sync.
+     * @returns {ConnErrorPair[]}
+     */
+    get connErrors() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.peerbatchsyncresult_connErrors(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Statistics about the sync operation.
+     * @returns {SyncStats}
+     */
+    get stats() {
+        const ret = wasm.peerbatchsyncresult_stats(this.__wbg_ptr);
+        return SyncStats.__wrap(ret);
+    }
+    /**
+     * Whether the batch sync was successful with at least one connection.
+     * @returns {boolean}
+     */
+    get success() {
+        const ret = wasm.peerbatchsyncresult_success(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) PeerBatchSyncResult.prototype[Symbol.dispose] = PeerBatchSyncResult.prototype.free;
+
+/**
+ * A JavaScript-compatible wrapper around the Rust `PeerId` type.
+ */
+export class PeerId {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PeerId.prototype);
+        obj.__wbg_ptr = ptr;
+        PeerIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PeerIdFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_peerid_free(ptr, 0);
+    }
+    /**
+     * Creates a new `WasmPeerId` from a `PeerId`.
+     *
+     * # Errors
+     *
+     * Returns a `WasmInvalidPeerId` if the provided byte slice is not exactly 32 bytes long.
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.peerid_new(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);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            PeerIdFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the byte representation of the `PeerId`.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.peerid_toBytes(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 the string representation of the `PeerId`.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.peerid_toString(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) PeerId.prototype[Symbol.dispose] = PeerId.prototype.free;
+
+/**
+ * Map of peer IDs to their batch sync results.
+ */
+export class PeerResultMap {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PeerResultMap.prototype);
+        obj.__wbg_ptr = ptr;
+        PeerResultMapFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PeerResultMapFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_peerresultmap_free(ptr, 0);
+    }
+    /**
+     * Get all entries in the peer result map.
+     * @returns {PeerBatchSyncResult[]}
+     */
+    entries() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.peerresultmap_entries(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the result for a specific peer ID.
+     * @param {PeerId} peer_id
+     * @returns {PeerBatchSyncResult | undefined}
+     */
+    getResult(peer_id) {
+        _assertClass(peer_id, PeerId);
+        const ret = wasm.peerresultmap_getResult(this.__wbg_ptr, peer_id.__wbg_ptr);
+        return ret === 0 ? undefined : PeerBatchSyncResult.__wrap(ret);
+    }
+}
+if (Symbol.dispose) PeerResultMap.prototype[Symbol.dispose] = PeerResultMap.prototype.free;
+
+/**
+ * Wasm wrapper for [`RequestId`].
+ */
+export class RequestId {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RequestId.prototype);
+        obj.__wbg_ptr = ptr;
+        RequestIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RequestIdFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_requestid_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmRequestId`].
+     * @returns {RequestId}
+     */
+    __wasm_refgen_toWasmRequestId() {
+        const ret = wasm.requestid___wasm_refgen_toWasmRequestId(this.__wbg_ptr);
+        return RequestId.__wrap(ret);
+    }
+    /**
+     * Create a new [`RequestId`] from a requestor peer ID and nonce.
+     * @param {PeerId} requestor
+     * @param {Nonce} nonce
+     */
+    constructor(requestor, nonce) {
+        _assertClass(requestor, PeerId);
+        _assertClass(nonce, Nonce);
+        const ret = wasm.requestid_new(requestor.__wbg_ptr, nonce.__wbg_ptr);
+        this.__wbg_ptr = ret >>> 0;
+        RequestIdFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * The request nonce.
+     * @returns {Nonce}
+     */
+    get nonce() {
+        const ret = wasm.requestid_nonce(this.__wbg_ptr);
+        return Nonce.__wrap(ret);
+    }
+    /**
+     * The peer ID of the requestor.
+     * @returns {PeerId}
+     */
+    get requestor() {
+        const ret = wasm.requestid_requestor(this.__wbg_ptr);
+        return PeerId.__wrap(ret);
+    }
+}
+if (Symbol.dispose) RequestId.prototype[Symbol.dispose] = RequestId.prototype.free;
+
+/**
+ * The main Sedimentree data structure.
+ */
+export class Sedimentree {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Sedimentree.prototype);
+        obj.__wbg_ptr = ptr;
+        SedimentreeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SedimentreeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sedimentree_free(ptr, 0);
+    }
+    /**
+     * Create an empty Sedimentree.
+     * @returns {Sedimentree}
+     */
+    static empty() {
+        const ret = wasm.sedimentree_empty();
+        return Sedimentree.__wrap(ret);
+    }
+    /**
+     * Create a new Sedimentree from fragments and loose commits.
+     * @param {Fragment[]} fragments
+     * @param {LooseCommit[]} commits
+     */
+    constructor(fragments, commits) {
+        const ptr0 = passArrayJsValueToWasm0(fragments, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(commits, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.sedimentree_new(ptr0, len0, ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        SedimentreeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) Sedimentree.prototype[Symbol.dispose] = Sedimentree.prototype.free;
+
+/**
+ * A Wasm wrapper around the [`SedimentreeId`] type.
+ */
+export class SedimentreeId {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SedimentreeId.prototype);
+        obj.__wbg_ptr = ptr;
+        SedimentreeIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof SedimentreeId)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SedimentreeIdFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sedimentreeid_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmSedimentreeId`].
+     * @returns {SedimentreeId}
+     */
+    __wasm_refgen_toWasmSedimentreeId() {
+        const ret = wasm.digest___wasm_refgen_toWasmDigest(this.__wbg_ptr);
+        return SedimentreeId.__wrap(ret);
+    }
+    /**
+     * Create an ID from a byte array.
+     *
+     * # Errors
+     *
+     * Returns `Not32Bytes` if the provided byte array is not exactly 32 bytes long.
+     * @param {Uint8Array} bytes
+     * @returns {SedimentreeId}
+     */
+    static fromBytes(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.sedimentreeid_fromBytes(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 SedimentreeId.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the raw bytes of this ID.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.digest_toBytes(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 the string representation of the ID.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.sedimentreeid_toString(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) SedimentreeId.prototype[Symbol.dispose] = SedimentreeId.prototype.free;
+
+export class SedimentreeIdsArray {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SedimentreeIdsArray.prototype);
+        obj.__wbg_ptr = ptr;
+        SedimentreeIdsArrayFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SedimentreeIdsArrayFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sedimentreeidsarray_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmSedimentreeIdsArray`].
+     * @returns {SedimentreeIdsArray}
+     */
+    __wasm_refgen_toWasmSedimentreeIdsArray() {
+        const ret = wasm.sedimentreeidsarray___wasm_refgen_toWasmSedimentreeIdsArray(this.__wbg_ptr);
+        return SedimentreeIdsArray.__wrap(ret);
+    }
+}
+if (Symbol.dispose) SedimentreeIdsArray.prototype[Symbol.dispose] = SedimentreeIdsArray.prototype.free;
+
+/**
+ * A Wasm wrapper around `Signed<Fragment>`.
+ */
+export class SignedFragment {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SignedFragment.prototype);
+        obj.__wbg_ptr = ptr;
+        SignedFragmentFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignedFragmentFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signedfragment_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmSignedFragment`].
+     * @returns {SignedFragment}
+     */
+    __wasm_refgen_toWasmSignedFragment() {
+        const ret = wasm.signedfragment___wasm_refgen_toWasmSignedFragment(this.__wbg_ptr);
+        return SignedFragment.__wrap(ret);
+    }
+    /**
+     * Encode this signed fragment to raw bytes.
+     * @returns {Uint8Array}
+     */
+    encode() {
+        const ret = wasm.signedfragment_encode(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the unsigned payload without re-verifying the signature.
+     *
+     * # Errors
+     *
+     * Returns an error if the payload cannot be decoded.
+     * @returns {Fragment}
+     */
+    get payload() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.signedfragment_payload(retptr, this.__wbg_ptr);
+            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 Fragment.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Decode a `SignedFragment` from raw bytes.
+     *
+     * # Errors
+     *
+     * Returns an error if the bytes are not a valid signed fragment.
+     * @param {Uint8Array} bytes
+     * @returns {SignedFragment}
+     */
+    static tryDecode(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.signedfragment_tryDecode(retptr, addBorrowedObject(bytes));
+            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 SignedFragment.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+}
+if (Symbol.dispose) SignedFragment.prototype[Symbol.dispose] = SignedFragment.prototype.free;
+
+/**
+ * A Wasm wrapper around `Signed<LooseCommit>`.
+ */
+export class SignedLooseCommit {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SignedLooseCommit.prototype);
+        obj.__wbg_ptr = ptr;
+        SignedLooseCommitFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignedLooseCommitFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signedloosecommit_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmSignedLooseCommit`].
+     * @returns {SignedLooseCommit}
+     */
+    __wasm_refgen_toWasmSignedLooseCommit() {
+        const ret = wasm.signedloosecommit___wasm_refgen_toWasmSignedLooseCommit(this.__wbg_ptr);
+        return SignedLooseCommit.__wrap(ret);
+    }
+    /**
+     * Encode this signed loose commit to raw bytes.
+     * @returns {Uint8Array}
+     */
+    encode() {
+        const ret = wasm.signedloosecommit_encode(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the unsigned payload without re-verifying the signature.
+     *
+     * # Errors
+     *
+     * Returns an error if the payload cannot be decoded.
+     * @returns {LooseCommit}
+     */
+    get payload() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.signedloosecommit_payload(retptr, this.__wbg_ptr);
+            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 LooseCommit.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Decode a `SignedLooseCommit` from raw bytes.
+     *
+     * # Errors
+     *
+     * Returns an error if the bytes are not a valid signed loose commit.
+     * @param {Uint8Array} bytes
+     * @returns {SignedLooseCommit}
+     */
+    static tryDecode(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.signedloosecommit_tryDecode(retptr, addBorrowedObject(bytes));
+            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 SignedLooseCommit.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+}
+if (Symbol.dispose) SignedLooseCommit.prototype[Symbol.dispose] = SignedLooseCommit.prototype.free;
+
+/**
+ * Wasm bindings for [`Subduction`](subduction_core::Subduction)
+ */
+export class Subduction {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Subduction.prototype);
+        obj.__wbg_ptr = ptr;
+        SubductionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SubductionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_subduction_free(ptr, 0);
+    }
+    /**
+     * Add a commit with its associated blob to the storage.
+     *
+     * The commit metadata (including `BlobMeta`) is computed internally from
+     * the provided blob, ensuring consistency by construction.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmWriteError`] if storage, networking, or policy fail.
+     * @param {SedimentreeId} id
+     * @param {Digest[]} parents
+     * @param {Uint8Array} blob
+     * @returns {Promise<FragmentRequested | undefined>}
+     */
+    addCommit(id, parents, blob) {
+        _assertClass(id, SedimentreeId);
+        const ptr0 = passArrayJsValueToWasm0(parents, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.subduction_addCommit(this.__wbg_ptr, id.__wbg_ptr, ptr0, len0, addHeapObject(blob));
+        return takeObject(ret);
+    }
+    /**
+     * Add a fragment with its associated blob to the storage.
+     *
+     * The fragment metadata (including `BlobMeta`) is computed internally from
+     * the provided blob, ensuring consistency by construction.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmWriteError`] if storage, networking, or policy fail.
+     * @param {SedimentreeId} id
+     * @param {Digest} head
+     * @param {Digest[]} boundary
+     * @param {Digest[]} checkpoints
+     * @param {Uint8Array} blob
+     * @returns {Promise<void>}
+     */
+    addFragment(id, head, boundary, checkpoints, blob) {
+        _assertClass(id, SedimentreeId);
+        _assertClass(head, Digest);
+        const ptr0 = passArrayJsValueToWasm0(boundary, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(checkpoints, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.subduction_addFragment(this.__wbg_ptr, id.__wbg_ptr, head.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(blob));
+        return takeObject(ret);
+    }
+    /**
+     * Add a Sedimentree.
+     *
+     * # Errors
+     *
+     * Returns [`WasmWriteError`] if there is a problem with storage, networking, or policy.
+     * @param {SedimentreeId} id
+     * @param {Sedimentree} sedimentree
+     * @param {Uint8Array[]} blobs
+     * @returns {Promise<void>}
+     */
+    addSedimentree(id, sedimentree, blobs) {
+        _assertClass(id, SedimentreeId);
+        _assertClass(sedimentree, Sedimentree);
+        const ptr0 = passArrayJsValueToWasm0(blobs, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.subduction_addSedimentree(this.__wbg_ptr, id.__wbg_ptr, sedimentree.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Attach an authenticated WebSocket connection and sync all sedimentrees.
+     *
+     * The connection must have been authenticated via [`SubductionWebSocket::setup`],
+     * [`SubductionWebSocket::tryConnect`], or [`SubductionWebSocket::tryDiscover`].
+     *
+     * Returns `true` if this is a new peer, `false` if already connected.
+     *
+     * # Errors
+     *
+     * Returns an error if registration or sync fails.
+     * @param {AuthenticatedWebSocket} conn
+     * @returns {Promise<boolean>}
+     */
+    attach(conn) {
+        _assertClass(conn, AuthenticatedWebSocket);
+        const ret = wasm.subduction_attach(this.__wbg_ptr, conn.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Connect to a peer via WebSocket and register the connection.
+     *
+     * This performs the cryptographic handshake, verifies the server's identity,
+     * and registers the authenticated connection for syncing.
+     *
+     * Returns the verified peer ID on success.
+     *
+     * # Arguments
+     *
+     * * `address` - The WebSocket URL to connect to
+     * * `signer` - The client's signer for authentication
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     * * `timeout_milliseconds` - Request timeout in milliseconds
+     *
+     * # Errors
+     *
+     * Returns an error if connection, handshake, or registration fails.
+     * @param {URL} address
+     * @param {any} signer
+     * @param {PeerId} expected_peer_id
+     * @param {number} timeout_milliseconds
+     * @returns {Promise<PeerId>}
+     */
+    connect(address, signer, expected_peer_id, timeout_milliseconds) {
+        _assertClass(expected_peer_id, PeerId);
+        const ret = wasm.subduction_connect(this.__wbg_ptr, addHeapObject(address), addHeapObject(signer), expected_peer_id.__wbg_ptr, timeout_milliseconds);
+        return takeObject(ret);
+    }
+    /**
+     * Connect to a peer via WebSocket using discovery mode and register the connection.
+     *
+     * Returns the discovered and verified peer ID on success.
+     *
+     * # Arguments
+     *
+     * * `address` - The WebSocket URL to connect to
+     * * `signer` - The client's signer for authentication
+     * * `timeout_milliseconds` - Request timeout in milliseconds (defaults to 30000)
+     * * `service_name` - The service name for discovery (defaults to URL host)
+     *
+     * # Errors
+     *
+     * Returns an error if connection, handshake, or registration fails.
+     * @param {URL} address
+     * @param {any} signer
+     * @param {number | null} [timeout_milliseconds]
+     * @param {string | null} [service_name]
+     * @returns {Promise<PeerId>}
+     */
+    connectDiscover(address, signer, timeout_milliseconds, service_name) {
+        var ptr0 = isLikeNone(service_name) ? 0 : passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.subduction_connectDiscover(this.__wbg_ptr, addHeapObject(address), addHeapObject(signer), isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Connect to a peer via HTTP long-poll using discovery mode.
+     *
+     * Returns the discovered and verified peer ID on success.
+     *
+     * # Arguments
+     *
+     * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
+     * * `signer` - The client's signer for authentication
+     * * `timeout_milliseconds` - Request timeout in milliseconds (default: 30000)
+     * * `service_name` - The service name for discovery (defaults to `base_url`)
+     *
+     * # Errors
+     *
+     * Returns an error if connection, handshake, or registration fails.
+     * @param {string} base_url
+     * @param {any} signer
+     * @param {number | null} [timeout_milliseconds]
+     * @param {string | null} [service_name]
+     * @returns {Promise<PeerId>}
+     */
+    connectDiscoverLongPoll(base_url, signer, timeout_milliseconds, service_name) {
+        const ptr0 = passStringToWasm0(base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(service_name) ? 0 : passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.subduction_connectDiscoverLongPoll(this.__wbg_ptr, ptr0, len0, addHeapObject(signer), isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+     * Connect to a peer via HTTP long-poll and register the connection.
+     *
+     * Returns the verified peer ID on success.
+     *
+     * # Arguments
+     *
+     * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
+     * * `signer` - The client's signer for authentication
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     * * `timeout_milliseconds` - Request timeout in milliseconds (default: 30000)
+     *
+     * # Errors
+     *
+     * Returns an error if connection, handshake, or registration fails.
+     * @param {string} base_url
+     * @param {any} signer
+     * @param {PeerId} expected_peer_id
+     * @param {number | null} [timeout_milliseconds]
+     * @returns {Promise<PeerId>}
+     */
+    connectLongPoll(base_url, signer, expected_peer_id, timeout_milliseconds) {
+        const ptr0 = passStringToWasm0(base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(expected_peer_id, PeerId);
+        const ret = wasm.subduction_connectLongPoll(this.__wbg_ptr, ptr0, len0, addHeapObject(signer), expected_peer_id.__wbg_ptr, isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0);
+        return takeObject(ret);
+    }
+    /**
+     * Disconnect from all peers.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmDisconnectionError`] if disconnection was not graceful.
+     * @returns {Promise<void>}
+     */
+    disconnectAll() {
+        const ret = wasm.subduction_disconnectAll(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Disconnect from a peer by its ID.
+     *
+     * # Errors
+     *
+     * Returns a `WasmDisconnectionError` if disconnection fails.
+     * @param {PeerId} peer_id
+     * @returns {Promise<boolean>}
+     */
+    disconnectFromPeer(peer_id) {
+        _assertClass(peer_id, PeerId);
+        const ret = wasm.subduction_disconnectFromPeer(this.__wbg_ptr, peer_id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Fetch blobs by their digests, with an optional timeout in milliseconds.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmIoError`] if storage or networking fail.
+     * @param {SedimentreeId} id
+     * @param {bigint | null} [timeout_milliseconds]
+     * @returns {Promise<Uint8Array[] | undefined>}
+     */
+    fetchBlobs(id, timeout_milliseconds) {
+        _assertClass(id, SedimentreeId);
+        const ret = wasm.subduction_fetchBlobs(this.__wbg_ptr, id.__wbg_ptr, !isLikeNone(timeout_milliseconds), isLikeNone(timeout_milliseconds) ? BigInt(0) : timeout_milliseconds);
+        return takeObject(ret);
+    }
+    /**
+     * Request batch sync for all known Sedimentree IDs from all connected peers.
+     * @param {bigint | null} [timeout_milliseconds]
+     * @returns {Promise<PeerBatchSyncResult>}
+     */
+    fullSync(timeout_milliseconds) {
+        const ret = wasm.subduction_fullSync(this.__wbg_ptr, !isLikeNone(timeout_milliseconds), isLikeNone(timeout_milliseconds) ? BigInt(0) : timeout_milliseconds);
+        return takeObject(ret);
+    }
+    /**
+     * Get a local blob by its digest.
+     *
+     * # Errors
+     *
+     * Returns a [`JsStorageError`] if JS storage fails.
+     * @param {SedimentreeId} id
+     * @param {Digest} digest
+     * @returns {Promise<Uint8Array | undefined>}
+     */
+    getBlob(id, digest) {
+        _assertClass(id, SedimentreeId);
+        _assertClass(digest, Digest);
+        const ret = wasm.subduction_getBlob(this.__wbg_ptr, id.__wbg_ptr, digest.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get all local blobs for a given Sedimentree ID.
+     *
+     * # Errors
+     *
+     * Returns a [`JsStorageError`] if JS storage fails.
+     * @param {SedimentreeId} id
+     * @returns {Promise<Uint8Array[]>}
+     */
+    getBlobs(id) {
+        _assertClass(id, SedimentreeId);
+        const ret = wasm.subduction_getBlobs(this.__wbg_ptr, id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get all commits for a given Sedimentree ID
+     * @param {SedimentreeId} id
+     * @returns {Promise<LooseCommit[] | undefined>}
+     */
+    getCommits(id) {
+        _assertClass(id, SedimentreeId);
+        const ret = wasm.subduction_getCommits(this.__wbg_ptr, id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the peer IDs of all connected peers.
+     * @returns {Promise<PeerId[]>}
+     */
+    getConnectedPeerIds() {
+        const ret = wasm.subduction_getConnectedPeerIds(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get all fragments for a given Sedimentree ID
+     * @param {SedimentreeId} id
+     * @returns {Promise<Fragment[] | undefined>}
+     */
+    getFragments(id) {
+        _assertClass(id, SedimentreeId);
+        const ret = wasm.subduction_getFragments(this.__wbg_ptr, id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Hydrate a [`Subduction`] instance from external storage.
+     *
+     * # Arguments
+     *
+     * * `signer` - The cryptographic signer for this node's identity
+     * * `storage` - Storage backend for persisting data
+     * * `service_name` - Optional service identifier for discovery mode (e.g., `sync.example.com`).
+     *   When set, clients can connect without knowing the server's peer ID.
+     * * `hash_metric_override` - Optional custom depth metric function
+     * * `max_pending_blob_requests` - Optional maximum number of pending blob requests (default: 10,000)
+     *
+     * # Errors
+     *
+     * Returns [`WasmHydrationError`] if hydration fails.
+     * @param {any} signer
+     * @param {SedimentreeStorage} storage
+     * @param {string | null} [service_name]
+     * @param {(digest: Digest) => Depth | null} [hash_metric_override]
+     * @param {number | null} [max_pending_blob_requests]
+     * @returns {Promise<Subduction>}
+     */
+    static hydrate(signer, storage, service_name, hash_metric_override, max_pending_blob_requests) {
+        var ptr0 = isLikeNone(service_name) ? 0 : passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.subduction_hydrate(addHeapObject(signer), addHeapObject(storage), ptr0, len0, isLikeNone(hash_metric_override) ? 0 : addHeapObject(hash_metric_override), isLikeNone(max_pending_blob_requests) ? 0x100000001 : (max_pending_blob_requests) >>> 0);
+        return takeObject(ret);
+    }
+    /**
+     * Create a new [`Subduction`] instance.
+     *
+     * # Arguments
+     *
+     * * `signer` - The cryptographic signer for this node's identity
+     * * `storage` - Storage backend for persisting data
+     * * `service_name` - Optional service identifier for discovery mode (e.g., `sync.example.com`).
+     *   When set, clients can connect without knowing the server's peer ID.
+     * * `hash_metric_override` - Optional custom depth metric function
+     * * `max_pending_blob_requests` - Optional maximum number of pending blob requests (default: 10,000)
+     * @param {any} signer
+     * @param {SedimentreeStorage} storage
+     * @param {string | null} [service_name]
+     * @param {(digest: Digest) => Depth | null} [hash_metric_override]
+     * @param {number | null} [max_pending_blob_requests]
+     */
+    constructor(signer, storage, service_name, hash_metric_override, max_pending_blob_requests) {
+        var ptr0 = isLikeNone(service_name) ? 0 : passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.subduction_new(addHeapObject(signer), addHeapObject(storage), ptr0, len0, isLikeNone(hash_metric_override) ? 0 : addHeapObject(hash_metric_override), isLikeNone(max_pending_blob_requests) ? 0x100000001 : (max_pending_blob_requests) >>> 0);
+        this.__wbg_ptr = ret >>> 0;
+        SubductionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Remove a Sedimentree and all associated data.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmIoError`] if storage or networking fail.
+     * @param {SedimentreeId} id
+     * @returns {Promise<void>}
+     */
+    removeSedimentree(id) {
+        _assertClass(id, SedimentreeId);
+        const ret = wasm.subduction_removeSedimentree(this.__wbg_ptr, id.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Request blobs by their digests from connected peers for a specific sedimentree.
+     * @param {SedimentreeId} id
+     * @param {Digest[]} digests
+     * @returns {Promise<void>}
+     */
+    requestBlobs(id, digests) {
+        _assertClass(id, SedimentreeId);
+        const ptr0 = passArrayJsValueToWasm0(digests, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.subduction_requestBlobs(this.__wbg_ptr, id.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Get all known Sedimentree IDs
+     * @returns {Promise<SedimentreeId[]>}
+     */
+    sedimentreeIds() {
+        const ret = wasm.subduction_sedimentreeIds(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the backing storage.
+     * @returns {any}
+     */
+    get storage() {
+        const ret = wasm.subduction_storage(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Request batch sync for a given Sedimentree ID from all connected peers.
+     *
+     * # Arguments
+     *
+     * * `id` - The sedimentree ID to sync
+     * * `subscribe` - Whether to subscribe for incremental updates
+     * * `timeout_milliseconds` - Optional timeout in milliseconds
+     *
+     * # Errors
+     *
+     * Returns a [`WasmIoError`] if storage or networking fail.
+     * @param {SedimentreeId} id
+     * @param {boolean} subscribe
+     * @param {bigint | null} [timeout_milliseconds]
+     * @returns {Promise<PeerResultMap>}
+     */
+    syncAll(id, subscribe, timeout_milliseconds) {
+        _assertClass(id, SedimentreeId);
+        const ret = wasm.subduction_syncAll(this.__wbg_ptr, id.__wbg_ptr, subscribe, !isLikeNone(timeout_milliseconds), isLikeNone(timeout_milliseconds) ? BigInt(0) : timeout_milliseconds);
+        return takeObject(ret);
+    }
+    /**
+     * Request batch sync for a given Sedimentree ID from a specific peer.
+     *
+     * # Arguments
+     *
+     * * `to_ask` - The peer ID to sync with
+     * * `id` - The sedimentree ID to sync
+     * * `subscribe` - Whether to subscribe for incremental updates
+     * * `timeout_milliseconds` - Optional timeout in milliseconds
+     *
+     * # Errors
+     *
+     * Returns a [`WasmIoError`] if storage or networking fail.
+     * @param {PeerId} to_ask
+     * @param {SedimentreeId} id
+     * @param {boolean} subscribe
+     * @param {bigint | null} [timeout_milliseconds]
+     * @returns {Promise<PeerBatchSyncResult>}
+     */
+    syncWithPeer(to_ask, id, subscribe, timeout_milliseconds) {
+        _assertClass(to_ask, PeerId);
+        _assertClass(id, SedimentreeId);
+        const ret = wasm.subduction_syncWithPeer(this.__wbg_ptr, to_ask.__wbg_ptr, id.__wbg_ptr, subscribe, !isLikeNone(timeout_milliseconds), isLikeNone(timeout_milliseconds) ? BigInt(0) : timeout_milliseconds);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) Subduction.prototype[Symbol.dispose] = Subduction.prototype.free;
+
+/**
+ * HTTP long-poll connection factory for browser/worker environments.
+ *
+ * Analogous to [`SubductionWebSocket`] but uses HTTP long-poll instead of WebSocket.
+ */
+export class SubductionLongPoll {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SubductionLongPollFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_subductionlongpoll_free(ptr, 0);
+    }
+    /**
+     * Connect to a server with a known peer ID.
+     *
+     * # Arguments
+     *
+     * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
+     * * `signer` - The client's signer for authentication
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     * * `timeout_milliseconds` - Request timeout in milliseconds (default: 30000)
+     *
+     * # Errors
+     *
+     * Returns [`LongPollConnectionError`] if connection or handshake fails.
+     * @param {string} base_url
+     * @param {any} signer
+     * @param {PeerId} expected_peer_id
+     * @param {number | null} [timeout_milliseconds]
+     * @returns {Promise<AuthenticatedLongPoll>}
+     */
+    static tryConnect(base_url, signer, expected_peer_id, timeout_milliseconds) {
+        const ptr0 = passStringToWasm0(base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(expected_peer_id, PeerId);
+        const ret = wasm.subductionlongpoll_tryConnect(ptr0, len0, addHeapObject(signer), expected_peer_id.__wbg_ptr, isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0);
+        return takeObject(ret);
+    }
+    /**
+     * Connect to a server using discovery mode.
+     *
+     * # Arguments
+     *
+     * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
+     * * `signer` - The client's signer for authentication
+     * * `timeout_milliseconds` - Request timeout in milliseconds (default: 30000)
+     * * `service_name` - The service name for discovery. If omitted, the base URL is used.
+     *
+     * # Errors
+     *
+     * Returns [`LongPollConnectionError`] if connection or handshake fails.
+     * @param {string} base_url
+     * @param {any} signer
+     * @param {number | null} [timeout_milliseconds]
+     * @param {string | null} [service_name]
+     * @returns {Promise<AuthenticatedLongPoll>}
+     */
+    static tryDiscover(base_url, signer, timeout_milliseconds, service_name) {
+        const ptr0 = passStringToWasm0(base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(service_name) ? 0 : passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.subductionlongpoll_tryDiscover(ptr0, len0, addHeapObject(signer), isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0, ptr1, len1);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) SubductionLongPoll.prototype[Symbol.dispose] = SubductionLongPoll.prototype.free;
+
+/**
+ * JS-facing wrapper around [`WasmLongPollConnection`] that exposes the
+ * [`Connection`](super::JsConnection) interface so it can be used as a
+ * duck-typed `JsConnection` from JavaScript.
+ */
+export class SubductionLongPollConnection {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SubductionLongPollConnection.prototype);
+        obj.__wbg_ptr = ptr;
+        SubductionLongPollConnectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SubductionLongPollConnectionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_subductionlongpollconnection_free(ptr, 0);
+    }
+    /**
+     * Make a synchronous call to the peer.
+     *
+     * # Errors
+     *
+     * Returns an error if the call fails or times out.
+     * @param {BatchSyncRequest} request
+     * @param {number | null} [timeout_ms]
+     * @returns {Promise<BatchSyncResponse>}
+     */
+    call(request, timeout_ms) {
+        _assertClass(request, BatchSyncRequest);
+        var ptr0 = request.__destroy_into_raw();
+        const ret = wasm.subductionlongpollconnection_call(this.__wbg_ptr, ptr0, !isLikeNone(timeout_ms), isLikeNone(timeout_ms) ? 0 : timeout_ms);
+        return takeObject(ret);
+    }
+    /**
+     * Disconnect from the peer gracefully.
+     *
+     * # Errors
+     *
+     * Returns [`WasmLongPollConnError`] if the disconnect fails.
+     * @returns {Promise<void>}
+     */
+    disconnect() {
+        const ret = wasm.subductionlongpollconnection_disconnect(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the next request ID.
+     * @returns {Promise<RequestId>}
+     */
+    nextRequestId() {
+        const ret = wasm.subductionlongpollconnection_nextRequestId(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the peer ID of the remote peer.
+     * @returns {PeerId}
+     */
+    peerId() {
+        const ret = wasm.subductionlongpollconnection_peerId(this.__wbg_ptr);
+        return PeerId.__wrap(ret);
+    }
+    /**
+     * Receive a message.
+     *
+     * # Errors
+     *
+     * Returns an error if the inbound channel is closed.
+     * @returns {Promise<Message>}
+     */
+    recv() {
+        const ret = wasm.subductionlongpollconnection_recv(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Send a message.
+     *
+     * # Errors
+     *
+     * Returns an error if the outbound channel is closed.
+     * @param {Message} message
+     * @returns {Promise<void>}
+     */
+    send(message) {
+        _assertClass(message, Message);
+        var ptr0 = message.__destroy_into_raw();
+        const ret = wasm.subductionlongpollconnection_send(this.__wbg_ptr, ptr0);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) SubductionLongPollConnection.prototype[Symbol.dispose] = SubductionLongPollConnection.prototype.free;
+
+/**
+ * A WebSocket connection with internal wiring for [`Subduction`] message handling.
+ */
+export class SubductionWebSocket {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SubductionWebSocket.prototype);
+        obj.__wbg_ptr = ptr;
+        SubductionWebSocketFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SubductionWebSocketFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_subductionwebsocket_free(ptr, 0);
+    }
+    /**
+     * Make a synchronous call to the peer.
+     *
+     * # Errors
+     *
+     * Returns [`WasmCallError`] if the call fails or times out.
+     * @param {BatchSyncRequest} request
+     * @param {number | null} [timeout_ms]
+     * @returns {Promise<BatchSyncResponse>}
+     */
+    call(request, timeout_ms) {
+        _assertClass(request, BatchSyncRequest);
+        var ptr0 = request.__destroy_into_raw();
+        const ret = wasm.subductionwebsocket_call(this.__wbg_ptr, ptr0, !isLikeNone(timeout_ms), isLikeNone(timeout_ms) ? 0 : timeout_ms);
+        return takeObject(ret);
+    }
+    /**
+     * Disconnect from the peer gracefully.
+     * @returns {Promise<void>}
+     */
+    disconnect() {
+        const ret = wasm.subductionwebsocket_disconnect(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the next request ID.
+     * @returns {Promise<RequestId>}
+     */
+    nextRequestId() {
+        const ret = wasm.subductionwebsocket_nextRequestId(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the peer ID of the remote peer.
+     * @returns {PeerId}
+     */
+    peerId() {
+        const ret = wasm.authenticatedwebsocket_peerId(this.__wbg_ptr);
+        return PeerId.__wrap(ret);
+    }
+    /**
+     * Receive a message.
+     *
+     * # Errors
+     *
+     * Returns [`ReadFromClosedChannel`] if the channel has been closed.
+     * @returns {Promise<Message>}
+     */
+    recv() {
+        const ret = wasm.subductionwebsocket_recv(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Send a message.
+     *
+     * # Errors
+     *
+     * Returns [`WasmSendError`] if the message could not be sent over the WebSocket.
+     * @param {Message} wasm_message
+     * @returns {Promise<void>}
+     */
+    send(wasm_message) {
+        _assertClass(wasm_message, Message);
+        var ptr0 = wasm_message.__destroy_into_raw();
+        const ret = wasm.subductionwebsocket_send(this.__wbg_ptr, ptr0);
+        return takeObject(ret);
+    }
+    /**
+     * Authenticate an existing WebSocket via handshake.
+     *
+     * This performs the Subduction handshake protocol over the provided WebSocket
+     * to establish mutual identity. The WebSocket can be in CONNECTING or OPEN state.
+     *
+     * # Arguments
+     *
+     * * `ws` - An existing WebSocket (CONNECTING or OPEN)
+     * * `signer` - The client's signer for authentication
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     * * `timeout_milliseconds` - Request timeout in milliseconds
+     *
+     * # Errors
+     *
+     * Returns an error if the handshake fails (signature invalid, wrong peer, etc.)
+     * @param {WebSocket} ws
+     * @param {any} signer
+     * @param {PeerId} expected_peer_id
+     * @param {number} timeout_milliseconds
+     * @returns {Promise<AuthenticatedWebSocket>}
+     */
+    static setup(ws, signer, expected_peer_id, timeout_milliseconds) {
+        _assertClass(expected_peer_id, PeerId);
+        const ret = wasm.subductionwebsocket_setup(addHeapObject(ws), addHeapObject(signer), expected_peer_id.__wbg_ptr, timeout_milliseconds);
+        return takeObject(ret);
+    }
+    /**
+     * Connect to a WebSocket server with mutual authentication via handshake.
+     *
+     * # Arguments
+     *
+     * * `address` - The WebSocket URL to connect to
+     * * `signer` - The client's signer for authentication
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     * * `timeout_milliseconds` - Request timeout in milliseconds
+     *
+     * # Errors
+     *
+     * Returns an error if:
+     * - The WebSocket connection could not be established
+     * - The handshake fails (signature invalid, wrong server, clock drift, etc.)
+     * @param {URL} address
+     * @param {any} signer
+     * @param {PeerId} expected_peer_id
+     * @param {number} timeout_milliseconds
+     * @returns {Promise<AuthenticatedWebSocket>}
+     */
+    static tryConnect(address, signer, expected_peer_id, timeout_milliseconds) {
+        _assertClass(expected_peer_id, PeerId);
+        const ret = wasm.subductionwebsocket_tryConnect(addHeapObject(address), addHeapObject(signer), expected_peer_id.__wbg_ptr, timeout_milliseconds);
+        return takeObject(ret);
+    }
+    /**
+     * Connect to a WebSocket server using discovery mode.
+     *
+     * This method performs a cryptographic handshake using a service name
+     * instead of a known peer ID. The server's peer ID is discovered during
+     * the handshake and returned.
+     *
+     * # Arguments
+     *
+     * * `address` - The WebSocket URL to connect to
+     * * `signer` - The client's signer for authentication
+     * * `timeout_milliseconds` - Request timeout in milliseconds. Defaults to 30000 (30s).
+     * * `service_name` - The service name for discovery (e.g., `localhost:8080`).
+     *   If omitted, the host is extracted from the URL.
+     *
+     * # Errors
+     *
+     * Returns an error if:
+     * - The WebSocket connection could not be established
+     * - The handshake fails (signature invalid, clock drift, etc.)
+     * @param {URL} address
+     * @param {any} signer
+     * @param {number | null} [timeout_milliseconds]
+     * @param {string | null} [service_name]
+     * @returns {Promise<AuthenticatedWebSocket>}
+     */
+    static tryDiscover(address, signer, timeout_milliseconds, service_name) {
+        var ptr0 = isLikeNone(service_name) ? 0 : passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.subductionwebsocket_tryDiscover(addHeapObject(address), addHeapObject(signer), isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0, ptr0, len0);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) SubductionWebSocket.prototype[Symbol.dispose] = SubductionWebSocket.prototype.free;
+
+/**
+ * Statistics from a sync operation.
+ *
+ * The "sent" counts reflect items that were _successfully_ sent over the wire,
+ * not just items that were requested.
+ */
+export class SyncStats {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SyncStats.prototype);
+        obj.__wbg_ptr = ptr;
+        SyncStatsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SyncStatsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_syncstats_free(ptr, 0);
+    }
+    /**
+     * Number of commits received from the peer.
+     * @returns {number}
+     */
+    get commitsReceived() {
+        const ret = wasm.syncstats_commitsReceived(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of commits successfully sent to the peer.
+     * @returns {number}
+     */
+    get commitsSent() {
+        const ret = wasm.syncstats_commitsSent(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of fragments received from the peer.
+     * @returns {number}
+     */
+    get fragmentsReceived() {
+        const ret = wasm.syncstats_fragmentsReceived(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of fragments successfully sent to the peer.
+     * @returns {number}
+     */
+    get fragmentsSent() {
+        const ret = wasm.syncstats_fragmentsSent(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns true if no data was exchanged.
+     * @returns {boolean}
+     */
+    get isEmpty() {
+        const ret = wasm.syncstats_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Total items received (commits + fragments).
+     * @returns {number}
+     */
+    get totalReceived() {
+        const ret = wasm.syncstats_totalReceived(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Total items sent (commits + fragments).
+     * @returns {number}
+     */
+    get totalSent() {
+        const ret = wasm.syncstats_totalSent(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) SyncStats.prototype[Symbol.dispose] = SyncStats.prototype.free;
+
+/**
+ * An Ed25519 signer using the browser's `WebCrypto` API.
+ *
+ * This signer generates and stores Ed25519 keys using `crypto.subtle`,
+ * providing secure key generation and signing operations. The key is
+ * persisted to `IndexedDB` so it survives page reloads.
+ *
+ * # Example
+ *
+ * ```javascript
+ * import { WebCryptoSigner } from "@anthropic/subduction";
+ *
+ * const signer = await WebCryptoSigner.setup();
+ * console.log("Peer ID:", signer.peerId().toString());
+ * ```
+ */
+export class WebCryptoSigner {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WebCryptoSigner.prototype);
+        obj.__wbg_ptr = ptr;
+        WebCryptoSignerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WebCryptoSignerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_webcryptosigner_free(ptr, 0);
+    }
+    /**
+     * Get the peer ID derived from this signer's verifying key.
+     *
+     * # Panics
+     *
+     * Panics if the stored public key bytes are invalid (should never happen).
+     * @returns {PeerId}
+     */
+    peerId() {
+        const ret = wasm.webcryptosigner_peerId(this.__wbg_ptr);
+        return PeerId.__wrap(ret);
+    }
+    /**
+     * Set up the signer, loading an existing key from `IndexedDB` or generating a new one.
+     *
+     * # Errors
+     *
+     * Returns an error if `WebCrypto` or `IndexedDB` operations fail.
+     * @returns {Promise<WebCryptoSigner>}
+     */
+    static setup() {
+        const ret = wasm.webcryptosigner_setup();
+        return takeObject(ret);
+    }
+    /**
+     * Sign a message and return the 64-byte Ed25519 signature.
+     *
+     * # Errors
+     *
+     * Returns an error if `WebCrypto` signing fails.
+     * @param {Uint8Array} message
+     * @returns {Promise<Uint8Array>}
+     */
+    sign(message) {
+        const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webcryptosigner_sign(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Get the 32-byte Ed25519 verifying (public) key.
+     * @returns {Uint8Array}
+     */
+    verifyingKey() {
+        const ret = wasm.webcryptosigner_verifyingKey(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) WebCryptoSigner.prototype[Symbol.dispose] = WebCryptoSigner.prototype.free;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wasm_refgen_toWasmCommitWithBlob_da516f4613a39b57: function(arg0) {
+            const ret = getObject(arg0).__wasm_refgen_toWasmCommitWithBlob();
+            _assertClass(ret, CommitWithBlob);
+            var ptr1 = ret.__destroy_into_raw();
+            return ptr1;
+        },
+        __wbg___wasm_refgen_toWasmDepth_ee4cad395c825171: function(arg0) {
+            const ret = getObject(arg0).__wasm_refgen_toWasmDepth();
+            _assertClass(ret, Depth);
+            var ptr1 = ret.__destroy_into_raw();
+            return ptr1;
+        },
+        __wbg___wasm_refgen_toWasmDigest_66d1df4db7cdd9a2: function(arg0) {
+            const ret = getObject(arg0).__wasm_refgen_toWasmDigest();
+            _assertClass(ret, Digest);
+            var ptr1 = ret.__destroy_into_raw();
+            return ptr1;
+        },
+        __wbg___wasm_refgen_toWasmFragmentWithBlob_5563b8007297efa7: function(arg0) {
+            const ret = getObject(arg0).__wasm_refgen_toWasmFragmentWithBlob();
+            _assertClass(ret, FragmentWithBlob);
+            var ptr1 = ret.__destroy_into_raw();
+            return ptr1;
+        },
+        __wbg___wasm_refgen_toWasmFragment_02267ee4c333bd43: function(arg0) {
+            const ret = getObject(arg0).__wasm_refgen_toWasmFragment();
+            _assertClass(ret, Fragment);
+            var ptr1 = ret.__destroy_into_raw();
+            return ptr1;
+        },
+        __wbg___wasm_refgen_toWasmLooseCommit_899ec4675da39a86: function(arg0) {
+            const ret = getObject(arg0).__wasm_refgen_toWasmLooseCommit();
+            _assertClass(ret, LooseCommit);
+            var ptr1 = ret.__destroy_into_raw();
+            return ptr1;
+        },
+        __wbg___wbindgen_debug_string_ddde1867f49c2442: function(arg0, arg1) {
+            const ret = debugString(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_is_function_d633e708baf0d146: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_null_a2a19127c13e7126: function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_4b3de556756ee8a8: function(arg0) {
+            const val = getObject(arg0);
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_7debe47dc1e045c2: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_c18285b9fc34cb7d: function(arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_5854912275df1894: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_throw_39bc967c0e5a9b58: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg__wbg_cb_unref_b6d832240a919168: function(arg0) {
+            getObject(arg0)._wbg_cb_unref();
+        },
+        __wbg_arrayBuffer_8fd4b7df096647f9: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).arrayBuffer();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_authenticatedlongpoll_new: function(arg0) {
+            const ret = AuthenticatedLongPoll.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_authenticatedwebsocket_new: function(arg0) {
+            const ret = AuthenticatedWebSocket.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_batchsyncresponse_new: function(arg0) {
+            const ret = BatchSyncResponse.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_call_08ad0d89caa7cb79: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_73af281463ec8b58: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).call(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_c974f0bf2231552e: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_close_88d72cf512fed8bc: function(arg0) {
+            getObject(arg0).close();
+        },
+        __wbg_commitwithblob_new: function(arg0) {
+            const ret = CommitWithBlob.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_connerrorpair_new: function(arg0) {
+            const ret = ConnErrorPair.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_contains_412524090060514f: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
+            return ret;
+        },
+        __wbg_createObjectStore_bfd875621f13f126: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_crypto_38df2bab126b63dc: function(arg0) {
+            const ret = getObject(arg0).crypto;
+            return addHeapObject(ret);
+        },
+        __wbg_data_826b7d645a40043f: function(arg0) {
+            const ret = getObject(arg0).data;
+            return addHeapObject(ret);
+        },
+        __wbg_deleteAllCommits_08122bac302f379f: function(arg0, arg1) {
+            const ret = getObject(arg0).deleteAllCommits(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_deleteAllFragments_442f1f1ee9cff06a: function(arg0, arg1) {
+            const ret = getObject(arg0).deleteAllFragments(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_digest_new: function(arg0) {
+            const ret = Digest.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_digest_unwrap: function(arg0) {
+            const ret = Digest.__unwrap(getObject(arg0));
+            return ret;
+        },
+        __wbg_exportKey_d8f8486549147648: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).exportKey(getStringFromWasm0(arg1, arg2), getObject(arg3));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_fetch_3c1f541fa62e562d: function(arg0, arg1) {
+            const ret = getObject(arg0).fetch(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_fetch_59df3bdc0a4c0e4b: function(arg0, arg1) {
+            const ret = getObject(arg0).fetch(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_fragment_new: function(arg0) {
+            const ret = Fragment.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_fragmentrequested_new: function(arg0) {
+            const ret = FragmentRequested.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_fragmentwithblob_new: function(arg0) {
+            const ret = FragmentWithBlob.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_from_d7e888a2e9063b32: function(arg0) {
+            const ret = Array.from(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_generateKey_3ad334ccb45181f1: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).generateKey(getObject(arg1), arg2 !== 0, getObject(arg3));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).getRandomValues(getObject(arg1));
+        }, arguments); },
+        __wbg_get_18349afdb36339a9: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_791b26b41a7de3d5: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).get(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_f09c3a16f8848381: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_get_fc68a746a75a3e9d: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg1).get(getStringFromWasm0(arg2, arg3));
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_headers_028b9b1c907f9362: function(arg0) {
+            const ret = getObject(arg0).headers;
+            return addHeapObject(ret);
+        },
+        __wbg_host_f6433f5f5f3a3eb4: function(arg0, arg1) {
+            const ret = getObject(arg1).host;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_href_72623bc1de5c4cb5: function(arg0, arg1) {
+            const ret = getObject(arg1).href;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_importKey_ac1d2e02c862b89b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            const ret = getObject(arg0).importKey(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4), arg5 !== 0, getObject(arg6));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_instanceof_ArrayBuffer_15859862b80b732d: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Crypto_31bafd3455a3b508: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Crypto;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_IdbDatabase_9f1f490b74b465ba: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof IDBDatabase;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_IdbFactory_f448efd6949878d4: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof IDBFactory;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_IdbOpenDbRequest_bc707ea112c6f917: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof IDBOpenDBRequest;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_JsDepth_4051ca2508d01961: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof JsDepth;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Promise_44e4f673e91c710d: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Promise;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Response_8ec0057b1e5c71bf: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Response;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Window_4aba49e4d1a12365: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Window;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_WorkerGlobalScope_12b79fbd44254705: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof WorkerGlobalScope;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isSafeInteger_10e4151eb694e42a: function(arg0) {
+            const ret = Number.isSafeInteger(getObject(arg0));
+            return ret;
+        },
+        __wbg_is_1ad0660d6042ae31: function(arg0, arg1) {
+            const ret = Object.is(getObject(arg0), getObject(arg1));
+            return ret;
+        },
+        __wbg_length_5855c1f289dfffc1: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_a31e05262e09b7f8: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_loadAllCommits_dfccdd45918469a3: function(arg0, arg1) {
+            const ret = getObject(arg0).loadAllCommits(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_loadAllFragments_d70484307b61371a: function(arg0, arg1) {
+            const ret = getObject(arg0).loadAllFragments(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_loadAllSedimentreeIds_38e22f908df2c6d1: function(arg0) {
+            const ret = getObject(arg0).loadAllSedimentreeIds();
+            return addHeapObject(ret);
+        },
+        __wbg_loosecommit_new: function(arg0) {
+            const ret = LooseCommit.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_message_new: function(arg0) {
+            const ret = Message.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+            const ret = getObject(arg0).msCrypto;
+            return addHeapObject(ret);
+        },
+        __wbg_new_0765f05b3e3b4625: function() { return handleError(function () {
+            const ret = new Headers();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_09959f7b4c92c246: function(arg0) {
+            const ret = new Uint8Array(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_new_1213b57bccbdbb66: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_79ce7968119cfd96: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return __wasm_bindgen_func_elem_5956(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = state0.b = 0;
+            }
+        },
+        __wbg_new_cbee8c0d5c479eac: function() {
+            const ret = new Array();
+            return addHeapObject(ret);
+        },
+        __wbg_new_ed69e637b553a997: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
+        __wbg_new_fc4d5b17b0f1a4cb: function() { return handleError(function (arg0, arg1) {
+            const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_from_slice_d7e202fdbee3c396: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_typed_8258a0d8488ef2a2: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return __wasm_bindgen_func_elem_5956(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = state0.b = 0;
+            }
+        },
+        __wbg_new_with_length_c8449d782396d344: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_new_with_str_and_init_5fdb105df3907de1: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_node_84ea875411254db1: function(arg0) {
+            const ret = getObject(arg0).node;
+            return addHeapObject(ret);
+        },
+        __wbg_now_edd718b3004d8631: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_objectStoreNames_3645b6da2d1f3852: function(arg0) {
+            const ret = getObject(arg0).objectStoreNames;
+            return addHeapObject(ret);
+        },
+        __wbg_objectStore_3a6b969b917c6262: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_of_25a3bcb86f9d51ab: function(arg0) {
+            const ret = Array.of(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_of_d3b315af6d5ecc2a: function(arg0, arg1) {
+            const ret = Array.of(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_onmessage_d350391ecfb5652a: function(arg0) {
+            const ret = getObject(arg0).onmessage;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_open_9badd3c8846fbf11: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_peerbatchsyncresult_new: function(arg0) {
+            const ret = PeerBatchSyncResult.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_peerid_new: function(arg0) {
+            const ret = PeerId.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_peerresultmap_new: function(arg0) {
+            const ret = PeerResultMap.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_process_44c7a14e11e9f69e: function(arg0) {
+            const ret = getObject(arg0).process;
+            return addHeapObject(ret);
+        },
+        __wbg_prototypesetcall_f034d444741426c3: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_push_a6f9488ffd3fae3b: function(arg0, arg1) {
+            const ret = getObject(arg0).push(getObject(arg1));
+            return ret;
+        },
+        __wbg_put_d86a6833e14a4c3b: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_queueMicrotask_2c8dfd1056f24fdc: function(arg0) {
+            const ret = getObject(arg0).queueMicrotask;
+            return addHeapObject(ret);
+        },
+        __wbg_queueMicrotask_8985ad63815852e7: function(arg0) {
+            queueMicrotask(getObject(arg0));
+        },
+        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).randomFillSync(takeObject(arg1));
+        }, arguments); },
+        __wbg_readyState_66d6203f2fbfd533: function(arg0) {
+            const ret = getObject(arg0).readyState;
+            return ret;
+        },
+        __wbg_requestid_new: function(arg0) {
+            const ret = RequestId.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
+            const ret = module.require;
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_resolve_5d61e0d10c14730a: function(arg0) {
+            const ret = Promise.resolve(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_result_aaba1e6bbc5d42c8: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).result;
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_saveCommit_d7a8daf852b67448: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).saveCommit(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
+            return addHeapObject(ret);
+        },
+        __wbg_saveFragment_386a96a2400bfc01: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).saveFragment(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
+            return addHeapObject(ret);
+        },
+        __wbg_saveSedimentreeId_e9bc6683117677fb: function(arg0, arg1) {
+            const ret = getObject(arg0).saveSedimentreeId(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_sedimentreeid_new: function(arg0) {
+            const ret = SedimentreeId.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_sedimentreeid_unwrap: function(arg0) {
+            const ret = SedimentreeId.__unwrap(getObject(arg0));
+            return ret;
+        },
+        __wbg_send_b7d2dc9c231d3eb3: function() { return handleError(function (arg0, arg1, arg2) {
+            getObject(arg0).send(getArrayU8FromWasm0(arg1, arg2));
+        }, arguments); },
+        __wbg_set_77cf5fbc40154bdb: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_set_bad5c505cc70b5f8: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
+        __wbg_set_binaryType_ee9186e9e9c98376: function(arg0, arg1) {
+            getObject(arg0).binaryType = __wbindgen_enum_BinaryType[arg1];
+        },
+        __wbg_set_body_cced363f7703790d: function(arg0, arg1) {
+            getObject(arg0).body = getObject(arg1);
+        },
+        __wbg_set_headers_9144e2163352af57: function(arg0, arg1) {
+            getObject(arg0).headers = getObject(arg1);
+        },
+        __wbg_set_method_c1be4686b152fe29: function(arg0, arg1, arg2) {
+            getObject(arg0).method = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_mode_13fad253f291265c: function(arg0, arg1) {
+            getObject(arg0).mode = __wbindgen_enum_RequestMode[arg1];
+        },
+        __wbg_set_name_1965d19c3010e94a: function(arg0, arg1, arg2) {
+            getObject(arg0).name = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_onclose_9e7a850dd4c00263: function(arg0, arg1) {
+            getObject(arg0).onclose = getObject(arg1);
+        },
+        __wbg_set_onerror_00bcdee7bf806a30: function(arg0, arg1) {
+            getObject(arg0).onerror = getObject(arg1);
+        },
+        __wbg_set_onerror_8b43a0b08de76f6d: function(arg0, arg1) {
+            getObject(arg0).onerror = getObject(arg1);
+        },
+        __wbg_set_onmessage_3579a04e3b06c86a: function(arg0, arg1) {
+            getObject(arg0).onmessage = getObject(arg1);
+        },
+        __wbg_set_onopen_60d5c65fa1d328c9: function(arg0, arg1) {
+            getObject(arg0).onopen = getObject(arg1);
+        },
+        __wbg_set_onsuccess_76214f5146684855: function(arg0, arg1) {
+            getObject(arg0).onsuccess = getObject(arg1);
+        },
+        __wbg_set_onupgradeneeded_74f1c8e9dbd2b70c: function(arg0, arg1) {
+            getObject(arg0).onupgradeneeded = getObject(arg1);
+        },
+        __wbg_sign_39441a404dcdb16a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).sign(getObject(arg1), getObject(arg2), getArrayU8FromWasm0(arg3, arg4));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_sign_af285df6f98c87a6: function(arg0, arg1) {
+            const ret = getObject(arg0).sign(takeObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_signedfragment_new: function(arg0) {
+            const ret = SignedFragment.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_signedloosecommit_new: function(arg0) {
+            const ret = SignedLooseCommit.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_14325d8cca34bb77: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_GLOBAL_f3a1e69f9c5a7e8e: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_SELF_50cdb5b517789aca: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_WINDOW_d6c4126e4c244380: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_status_acf2080bc55aa324: function(arg0) {
+            const ret = getObject(arg0).status;
+            return ret;
+        },
+        __wbg_subarray_7ad5f01d4a9c1c4d: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_subduction_new: function(arg0) {
+            const ret = Subduction.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_subductionlongpollconnection_new: function(arg0) {
+            const ret = SubductionLongPollConnection.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_subductionwebsocket_new: function(arg0) {
+            const ret = SubductionWebSocket.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_subtle_27cb8bee5d13f00f: function(arg0) {
+            const ret = getObject(arg0).subtle;
+            return addHeapObject(ret);
+        },
+        __wbg_target_adcfd1353c3de078: function(arg0) {
+            const ret = getObject(arg0).target;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_then_d4163530723f56f4: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_then_f1c954fe00733701: function(arg0, arg1) {
+            const ret = getObject(arg0).then(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_transaction_8555c5d00a94c767: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2), __wbindgen_enum_IdbTransactionMode[arg3]);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_transaction_f90e157c0cdb0001: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_tryIntoJsSedimentreeIdsArray_f012c6bad5612aef: function() { return handleError(function (arg0, arg1) {
+            const ret = tryIntoJsSedimentreeIdsArray(getObject(arg1));
+            const ptr1 = passArrayJsValueToWasm0(ret, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_verifyingKey_aab82f75b82f977c: function(arg0) {
+            const ret = getObject(arg0).verifyingKey();
+            return addHeapObject(ret);
+        },
+        __wbg_versions_276b2795b1c6a219: function(arg0) {
+            const ret = getObject(arg0).versions;
+            return addHeapObject(ret);
+        },
+        __wbg_webcryptosigner_new: function(arg0) {
+            const ret = WebCryptoSigner.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [NamedExternref("Event")], shim_idx: 3, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_187, __wasm_bindgen_func_elem_898);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 3, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_187, __wasm_bindgen_func_elem_898);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 3, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_187, __wasm_bindgen_func_elem_898);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [], shim_idx: 2, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_187, __wasm_bindgen_func_elem_897);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 551, function: Function { arguments: [Externref], shim_idx: 657, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3965, __wasm_bindgen_func_elem_5951);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000006: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000009: function(arg0, arg1) {
+            var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+            wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
+            // Cast intrinsic for `Vector(NamedExternref("Fragment")) -> Externref`.
+            const ret = v0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_000000000000000a: function(arg0, arg1) {
+            var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+            wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
+            // Cast intrinsic for `Vector(NamedExternref("LooseCommit")) -> Externref`.
+            const ret = v0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_000000000000000b: function(arg0, arg1) {
+            var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+            wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
+            // Cast intrinsic for `Vector(NamedExternref("PeerId")) -> Externref`.
+            const ret = v0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_000000000000000c: function(arg0, arg1) {
+            var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+            wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
+            // Cast intrinsic for `Vector(NamedExternref("SedimentreeId")) -> Externref`.
+            const ret = v0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_000000000000000d: function(arg0, arg1) {
+            var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+            wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
+            // Cast intrinsic for `Vector(NamedExternref("Uint8Array")) -> Externref`.
+            const ret = v0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_clone_ref: function(arg0) {
+            const ret = getObject(arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./subduction_wasm_bg.js": import0,
+    };
+}
+
+function __wasm_bindgen_func_elem_897(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_897(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_898(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_898(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_5951(arg0, arg1, arg2) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.__wasm_bindgen_func_elem_5951(retptr, arg0, arg1, addHeapObject(arg2));
+        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);
+    }
+}
+
+function __wasm_bindgen_func_elem_5956(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_5956(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+
+const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
+
+
+const __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
+
+
+const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+const AuthenticatedLongPollFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_authenticatedlongpoll_free(ptr >>> 0, 1));
+const AuthenticatedWebSocketFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_authenticatedwebsocket_free(ptr >>> 0, 1));
+const BatchSyncRequestFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_batchsyncrequest_free(ptr >>> 0, 1));
+const BatchSyncResponseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_batchsyncresponse_free(ptr >>> 0, 1));
+const BlobMetaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_blobmeta_free(ptr >>> 0, 1));
+const CallErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_callerror_free(ptr >>> 0, 1));
+const CommitWithBlobFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_commitwithblob_free(ptr >>> 0, 1));
+const ConnErrorPairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_connerrorpair_free(ptr >>> 0, 1));
+const ConnectionIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_connectionid_free(ptr >>> 0, 1));
+const DepthFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_depth_free(ptr >>> 0, 1));
+const DigestFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_digest_free(ptr >>> 0, 1));
+const FragmentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fragment_free(ptr >>> 0, 1));
+const FragmentRequestedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fragmentrequested_free(ptr >>> 0, 1));
+const FragmentWithBlobFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fragmentwithblob_free(ptr >>> 0, 1));
+const FragmentsArrayFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fragmentsarray_free(ptr >>> 0, 1));
+const HashMetricFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_hashmetric_free(ptr >>> 0, 1));
+const LooseCommitFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_loosecommit_free(ptr >>> 0, 1));
+const MemoryStorageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_memorystorage_free(ptr >>> 0, 1));
+const MessageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_message_free(ptr >>> 0, 1));
+const NonceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_nonce_free(ptr >>> 0, 1));
+const PeerBatchSyncResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_peerbatchsyncresult_free(ptr >>> 0, 1));
+const PeerIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_peerid_free(ptr >>> 0, 1));
+const PeerResultMapFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_peerresultmap_free(ptr >>> 0, 1));
+const RequestIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_requestid_free(ptr >>> 0, 1));
+const SedimentreeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sedimentree_free(ptr >>> 0, 1));
+const SedimentreeIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sedimentreeid_free(ptr >>> 0, 1));
+const SedimentreeIdsArrayFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sedimentreeidsarray_free(ptr >>> 0, 1));
+const SignedFragmentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signedfragment_free(ptr >>> 0, 1));
+const SignedLooseCommitFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signedloosecommit_free(ptr >>> 0, 1));
+const SubductionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_subduction_free(ptr >>> 0, 1));
+const SubductionLongPollFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_subductionlongpoll_free(ptr >>> 0, 1));
+const SubductionLongPollConnectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_subductionlongpollconnection_free(ptr >>> 0, 1));
+const SubductionWebSocketFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_subductionwebsocket_free(ptr >>> 0, 1));
+const SyncStatsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_syncstats_free(ptr >>> 0, 1));
+const WebCryptoSignerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_webcryptosigner_free(ptr >>> 0, 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 _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+
+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) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, 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_export3(addHeapObject(e));
+    }
+}
+
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+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 passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.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;
+}
+
+let stack_pointer = 128;
+
+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 wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new /* @vite-ignore */ URL('subduction_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };