@automerge/subduction 0.10.0 → 0.10.2

package/dist/cjs/web-bindings.cjs

@@ -0,0 +1,4800 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// subduction_wasm/dist/wasm_bindgen/web/subduction_wasm.js
+var subduction_wasm_exports = {};
+__export(subduction_wasm_exports, {
+  AuthenticatedLongPoll: () => AuthenticatedLongPoll,
+  AuthenticatedTransport: () => AuthenticatedTransport,
+  AuthenticatedWebSocket: () => AuthenticatedWebSocket,
+  BatchSyncRequest: () => BatchSyncRequest,
+  BatchSyncResponse: () => BatchSyncResponse,
+  BlobMeta: () => BlobMeta,
+  CallError: () => CallError,
+  CommitWithBlob: () => CommitWithBlob,
+  Depth: () => Depth,
+  Digest: () => Digest,
+  Fragment: () => Fragment,
+  FragmentRequested: () => FragmentRequested,
+  FragmentWithBlob: () => FragmentWithBlob,
+  FragmentsArray: () => FragmentsArray,
+  HashMetric: () => HashMetric,
+  LooseCommit: () => LooseCommit,
+  MemorySigner: () => MemorySigner,
+  MemoryStorage: () => MemoryStorage,
+  MessagePortTransport: () => MessagePortTransport,
+  Nonce: () => Nonce,
+  PeerBatchSyncResult: () => PeerBatchSyncResult,
+  PeerId: () => PeerId,
+  PeerResultMap: () => PeerResultMap,
+  RequestId: () => RequestId,
+  Sedimentree: () => Sedimentree,
+  SedimentreeId: () => SedimentreeId,
+  SedimentreeIdsArray: () => SedimentreeIdsArray,
+  SignedFragment: () => SignedFragment,
+  SignedLooseCommit: () => SignedLooseCommit,
+  Subduction: () => Subduction,
+  SubductionHttpLongPoll: () => SubductionHttpLongPoll,
+  SubductionLongPoll: () => SubductionLongPoll,
+  SubductionWebSocket: () => SubductionWebSocket,
+  SyncMessage: () => SyncMessage,
+  SyncStats: () => SyncStats,
+  Topic: () => Topic,
+  WebCryptoSigner: () => WebCryptoSigner,
+  __wbg_set_wasm: () => __wbg_set_wasm,
+  default: () => __wbg_init,
+  initSync: () => initSync,
+  makeMessagePortTransport: () => makeMessagePortTransport,
+  start: () => start
+});
+module.exports = __toCommonJS(subduction_wasm_exports);
+
+// subduction_wasm/dist/wasm_bindgen/web/snippets/sedimentree_wasm-c507f5285f2927a0/inline2.js
+function tryIntoJsSedimentreeIdsArray(xs) {
+  return xs;
+}
+
+// subduction_wasm/dist/wasm_bindgen/web/snippets/subduction_wasm-ec51bcf335db35bd/inline0.js
+var inline0_exports = {};
+__export(inline0_exports, {
+  makeOpenEphemeralPolicy: () => makeOpenEphemeralPolicy
+});
+function makeOpenEphemeralPolicy() {
+  return {
+    authorizeSubscribe() {
+      return Promise.resolve();
+    },
+    authorizePublish() {
+      return Promise.resolve();
+    },
+    filterAuthorizedSubscribers(_topic, peers) {
+      return Promise.resolve(peers);
+    }
+  };
+}
+
+// subduction_wasm/dist/wasm_bindgen/web/snippets/subduction_wasm-ec51bcf335db35bd/inline1.js
+var inline1_exports = {};
+__export(inline1_exports, {
+  makeOpenPolicy: () => makeOpenPolicy
+});
+function makeOpenPolicy() {
+  return {
+    authorizeConnect() {
+      return Promise.resolve();
+    },
+    authorizeFetch() {
+      return Promise.resolve();
+    },
+    authorizePut() {
+      return Promise.resolve();
+    },
+    filterAuthorizedFetch(_peer, ids) {
+      return Promise.resolve(ids);
+    }
+  };
+}
+
+// subduction_wasm/dist/wasm_bindgen/web/subduction_wasm.js
+var import_meta = {};
+var AuthenticatedLongPoll = 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 ret = wasm.authenticatedlongpoll_sessionId(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * Convert to a transport-erased [`AuthenticatedTransport`](super::WasmAuthenticatedTransport).
+   * @returns {AuthenticatedTransport}
+   */
+  toTransport() {
+    const ptr = this.__destroy_into_raw();
+    const ret = wasm.authenticatedlongpoll_toTransport(ptr);
+    return AuthenticatedTransport.__wrap(ret);
+  }
+};
+if (Symbol.dispose) AuthenticatedLongPoll.prototype[Symbol.dispose] = AuthenticatedLongPoll.prototype.free;
+var AuthenticatedTransport = class _AuthenticatedTransport {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_AuthenticatedTransport.prototype);
+    obj.__wbg_ptr = ptr;
+    AuthenticatedTransportFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    AuthenticatedTransportFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_authenticatedtransport_free(ptr, 0);
+  }
+  /**
+   * Accept an incoming handshake over a custom transport (responder side).
+   *
+   * This is the counterpart to [`setup`](Self::setup). The initiator calls
+   * `setup`, and the responder calls `accept` over the same underlying channel.
+   *
+   * # Arguments
+   *
+   * * `transport` - A `Transport` implementing `sendBytes`/`recvBytes`/`disconnect`/`onDisconnect`
+   * * `signer` - The responder's signer for authentication
+   * * `max_drift_seconds` - Maximum acceptable clock drift in seconds (default: 600)
+   *
+   * # Errors
+   *
+   * Returns a [`HandshakeError`](WasmHandshakeError) if the handshake fails.
+   * @param {Transport} transport
+   * @param {any} signer
+   * @param {number | null} [max_drift_seconds]
+   * @param {Function | null} [on_disconnect]
+   * @returns {Promise<AuthenticatedTransport>}
+   */
+  static accept(transport, signer, max_drift_seconds, on_disconnect) {
+    const ret = wasm.authenticatedtransport_accept(transport, signer, isLikeNone(max_drift_seconds) ? 4294967297 : max_drift_seconds >>> 0, isLikeNone(on_disconnect) ? 0 : addToExternrefTable0(on_disconnect));
+    return ret;
+  }
+  /**
+   * The verified peer identity.
+   * @returns {PeerId}
+   */
+  get peerId() {
+    const ret = wasm.authenticatedtransport_peerId(this.__wbg_ptr);
+    return PeerId.__wrap(ret);
+  }
+  /**
+   * Run the Subduction handshake over a custom transport, producing an
+   * authenticated transport.
+   *
+   * The `transport` object must implement the `Transport` interface
+   * (`sendBytes`/`recvBytes`/`disconnect`/`onDisconnect`).
+   * The same object is used for both the handshake phase and post-handshake
+   * communication.
+   *
+   * # Arguments
+   *
+   * * `transport` - A `Transport` implementing `sendBytes`/`recvBytes`/`disconnect`/`onDisconnect`
+   * * `signer` - The client's signer for authentication
+   * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+   *
+   * # Errors
+   *
+   * Returns a [`HandshakeError`](WasmHandshakeError) if the handshake fails.
+   * @param {Transport} transport
+   * @param {any} signer
+   * @param {PeerId} expected_peer_id
+   * @param {Function | null} [on_disconnect]
+   * @returns {Promise<AuthenticatedTransport>}
+   */
+  static setup(transport, signer, expected_peer_id, on_disconnect) {
+    _assertClass(expected_peer_id, PeerId);
+    const ret = wasm.authenticatedtransport_setup(transport, signer, expected_peer_id.__wbg_ptr, isLikeNone(on_disconnect) ? 0 : addToExternrefTable0(on_disconnect));
+    return ret;
+  }
+  /**
+   * Run the Subduction handshake over a custom transport using discovery
+   * mode, producing an authenticated transport.
+   *
+   * Unlike [`setup`](Self::setup) which requires a known peer ID,
+   * this method discovers the peer's identity during the handshake
+   * using a shared service name.
+   *
+   * # Arguments
+   *
+   * * `transport` - A `Transport` implementing `sendBytes`/`recvBytes`/`disconnect`/`onDisconnect`
+   * * `signer` - The client's signer for authentication
+   * * `service_name` - Shared service name for discovery.
+   *   Defaults to [`DEFAULT_LOCAL_SERVICE_NAME`] (`"subduction:local"`) if omitted.
+   *
+   * # Errors
+   *
+   * Returns a [`HandshakeError`](WasmHandshakeError) if the handshake fails.
+   * @param {Transport} transport
+   * @param {any} signer
+   * @param {string | null} [service_name]
+   * @param {Function | null} [on_disconnect]
+   * @returns {Promise<AuthenticatedTransport>}
+   */
+  static setupDiscover(transport, signer, service_name, on_disconnect) {
+    var ptr0 = isLikeNone(service_name) ? 0 : passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.authenticatedtransport_setupDiscover(transport, signer, ptr0, len0, isLikeNone(on_disconnect) ? 0 : addToExternrefTable0(on_disconnect));
+    return ret;
+  }
+};
+if (Symbol.dispose) AuthenticatedTransport.prototype[Symbol.dispose] = AuthenticatedTransport.prototype.free;
+var AuthenticatedWebSocket = 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);
+  }
+  /**
+   * Convert to a transport-erased [`AuthenticatedTransport`](super::WasmAuthenticatedTransport).
+   * @returns {AuthenticatedTransport}
+   */
+  toTransport() {
+    const ptr = this.__destroy_into_raw();
+    const ret = wasm.authenticatedwebsocket_toTransport(ptr);
+    return AuthenticatedTransport.__wrap(ret);
+  }
+};
+if (Symbol.dispose) AuthenticatedWebSocket.prototype[Symbol.dispose] = AuthenticatedWebSocket.prototype.free;
+var BatchSyncRequest = 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;
+var BatchSyncResponse = 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;
+var BlobMeta = 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;
+var CallError = class {
+  __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;
+var CommitWithBlob = 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 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, 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;
+var Depth = 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___wasm_refgen_toWasmDepth(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) {
+    const ret = wasm.depth_new(js_value);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    DepthFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * 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;
+var Digest = 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) {
+    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.digest_fromBase58(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _Digest.__wrap(ret[0]);
+  }
+  /**
+   * 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) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.digest_fromBytes(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _Digest.__wrap(ret[0]);
+  }
+  /**
+   * 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) {
+    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.digest_fromHexString(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _Digest.__wrap(ret[0]);
+  }
+  /**
+   * 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) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.digest_new(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    DigestFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Returns the byte representation of the digest.
+   * @returns {Uint8Array}
+   */
+  toBytes() {
+    const ret = wasm.digest_toBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Returns the hexadecimal string representation of the digest.
+   * @returns {string}
+   */
+  toHexString() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.digest_toHexString(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+    }
+  }
+};
+if (Symbol.dispose) Digest.prototype[Symbol.dispose] = Digest.prototype.free;
+var Fragment = 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() {
+    const ret = wasm.fragment_boundary(this.__wbg_ptr);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 4, 4);
+    return v1;
+  }
+  /**
+   * 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;
+var FragmentRequested = 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;
+var FragmentWithBlob = 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.fragmentwithblob_blob(this.__wbg_ptr);
+    return 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.fragmentwithblob_new(ptr0, 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;
+var FragmentsArray = 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;
+var HashMetric = class {
+  __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 : addToExternrefTable0(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;
+var LooseCommit = 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() {
+    const ret = wasm.loosecommit_parents(this.__wbg_ptr);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 4, 4);
+    return v1;
+  }
+};
+if (Symbol.dispose) LooseCommit.prototype[Symbol.dispose] = LooseCommit.prototype.free;
+var MemorySigner = class _MemorySigner {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_MemorySigner.prototype);
+    obj.__wbg_ptr = ptr;
+    MemorySignerFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    MemorySignerFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_memorysigner_free(ptr, 0);
+  }
+  /**
+   * Create a signer from raw 32-byte Ed25519 secret key bytes.
+   *
+   * # Errors
+   *
+   * Returns an error if `bytes` is not exactly 32 bytes.
+   * @param {Uint8Array} bytes
+   * @returns {MemorySigner}
+   */
+  static fromBytes(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.memorysigner_fromBytes(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _MemorySigner.__wrap(ret[0]);
+  }
+  /**
+   * Create a new signer with a randomly generated Ed25519 key.
+   *
+   * # Panics
+   *
+   * Panics if the system random number generator fails.
+   * @returns {MemorySigner}
+   */
+  static generate() {
+    const ret = wasm.memorysigner_generate();
+    return _MemorySigner.__wrap(ret);
+  }
+  /**
+   * Create a new signer with a randomly generated Ed25519 key.
+   *
+   * This is the JS constructor (`new MemorySigner()`), equivalent to
+   * [`generate`](Self::generate).
+   *
+   * # Panics
+   *
+   * Panics if the system random number generator fails.
+   */
+  constructor() {
+    const ret = wasm.memorysigner_new();
+    this.__wbg_ptr = ret >>> 0;
+    MemorySignerFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Get the peer ID derived from this signer's verifying key.
+   * @returns {PeerId}
+   */
+  peerId() {
+    const ret = wasm.memorysigner_peerId(this.__wbg_ptr);
+    return PeerId.__wrap(ret);
+  }
+  /**
+   * Sign a message and return the 64-byte Ed25519 signature as a `Uint8Array`.
+   *
+   * This fulfils the `Signer.sign(message)` interface contract.
+   * Returns a `Promise<Uint8Array>` for consistency with the async signer interface.
+   * @param {Uint8Array} message
+   * @returns {Promise<Uint8Array>}
+   */
+  sign(message) {
+    const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.memorysigner_sign(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+  /**
+   * Get the 32-byte Ed25519 verifying (public) key as a `Uint8Array`.
+   *
+   * This fulfils the `Signer.verifyingKey()` interface contract.
+   * @returns {Uint8Array}
+   */
+  verifyingKey() {
+    const ret = wasm.memorysigner_verifyingKey(this.__wbg_ptr);
+    return ret;
+  }
+};
+if (Symbol.dispose) MemorySigner.prototype[Symbol.dispose] = MemorySigner.prototype.free;
+var MemoryStorage = class {
+  __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 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 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 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 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 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 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 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 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 ret;
+  }
+  /**
+   * Load all sedimentree IDs.
+   * @returns {Promise<any>}
+   */
+  loadAllSedimentreeIds() {
+    const ret = wasm.memorystorage_loadAllSedimentreeIds(this.__wbg_ptr);
+    return 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 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 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 commits and fragments in a single batch.
+   * @param {SedimentreeId} sedimentree_id
+   * @param {Array<any>} commits
+   * @param {Array<any>} fragments
+   * @returns {Promise<any>}
+   */
+  saveBatchAll(sedimentree_id, commits, fragments) {
+    _assertClass(sedimentree_id, SedimentreeId);
+    const ret = wasm.memorystorage_saveBatchAll(this.__wbg_ptr, sedimentree_id.__wbg_ptr, commits, fragments);
+    return ret;
+  }
+  /**
+   * 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) {
+    _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, blob);
+    return ret;
+  }
+  /**
+   * 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) {
+    _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, blob);
+    return ret;
+  }
+  /**
+   * 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 ret;
+  }
+};
+if (Symbol.dispose) MemoryStorage.prototype[Symbol.dispose] = MemoryStorage.prototype.free;
+var MessagePortTransport = class _MessagePortTransport {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_MessagePortTransport.prototype);
+    obj.__wbg_ptr = ptr;
+    MessagePortTransportFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    MessagePortTransportFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_messageporttransport_free(ptr, 0);
+  }
+  /**
+   * Disconnect (close the port) and fire the `onDisconnect` callback if registered.
+   * @returns {Promise<any>}
+   */
+  disconnect() {
+    const ret = wasm.messageporttransport_disconnect(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Create a new connection wrapping the given `MessagePort`.
+   * @param {any} port
+   */
+  constructor(port) {
+    const ret = wasm.messageporttransport_new(port);
+    this.__wbg_ptr = ret >>> 0;
+    MessagePortTransportFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Register a callback to be invoked when the transport disconnects.
+   *
+   * Part of the [`Transport`](super::JsTransport) interface contract.
+   * Typically called by internal wiring rather than directly by user code.
+   * @param {Function} callback
+   */
+  onDisconnect(callback) {
+    wasm.messageporttransport_onDisconnect(this.__wbg_ptr, callback);
+  }
+  /**
+   * Receive raw bytes (for the handshake phase).
+   * @returns {Promise<any>}
+   */
+  recvBytes() {
+    const ret = wasm.messageporttransport_recvBytes(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Send raw bytes (for the handshake phase).
+   * @param {Uint8Array} bytes
+   * @returns {Promise<any>}
+   */
+  sendBytes(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.messageporttransport_sendBytes(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+};
+if (Symbol.dispose) MessagePortTransport.prototype[Symbol.dispose] = MessagePortTransport.prototype.free;
+var Nonce = 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() {
+    const ret = wasm.nonce_bytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * 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) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nonce_new(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    NonceFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * 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;
+var PeerBatchSyncResult = 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);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Errors that occurred during the batch sync.
+   * @returns {Error[]}
+   */
+  get transportErrors() {
+    const ret = wasm.peerbatchsyncresult_transportErrors(this.__wbg_ptr);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 4, 4);
+    return v1;
+  }
+};
+if (Symbol.dispose) PeerBatchSyncResult.prototype[Symbol.dispose] = PeerBatchSyncResult.prototype.free;
+var PeerId = 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) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.peerid_new(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    PeerIdFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Returns the byte representation of the `PeerId`.
+   * @returns {Uint8Array}
+   */
+  toBytes() {
+    const ret = wasm.peerid_toBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Returns the string representation of the `PeerId`.
+   * @returns {string}
+   */
+  toString() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.peerid_toString(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+    }
+  }
+};
+if (Symbol.dispose) PeerId.prototype[Symbol.dispose] = PeerId.prototype.free;
+var PeerResultMap = 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() {
+    const ret = wasm.peerresultmap_entries(this.__wbg_ptr);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 4, 4);
+    return v1;
+  }
+  /**
+   * 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 ? void 0 : PeerBatchSyncResult.__wrap(ret);
+  }
+};
+if (Symbol.dispose) PeerResultMap.prototype[Symbol.dispose] = PeerResultMap.prototype.free;
+var RequestId = 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;
+var Sedimentree = 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;
+var SedimentreeId = 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.sedimentreeid___wasm_refgen_toWasmSedimentreeId(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) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sedimentreeid_fromBytes(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _SedimentreeId.__wrap(ret[0]);
+  }
+  /**
+   * Returns the raw bytes of this ID.
+   * @returns {Uint8Array}
+   */
+  toBytes() {
+    const ret = wasm.sedimentreeid_toBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Returns the string representation of the ID.
+   * @returns {string}
+   */
+  toString() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.sedimentreeid_toString(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+    }
+  }
+};
+if (Symbol.dispose) SedimentreeId.prototype[Symbol.dispose] = SedimentreeId.prototype.free;
+var SedimentreeIdsArray = 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;
+var SignedFragment = 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;
+  }
+  static __unwrap(jsValue) {
+    if (!(jsValue instanceof _SignedFragment)) {
+      return 0;
+    }
+    return jsValue.__destroy_into_raw();
+  }
+  __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 ret;
+  }
+  /**
+   * Get the unsigned payload without re-verifying the signature.
+   *
+   * # Errors
+   *
+   * Returns an error if the payload cannot be decoded.
+   * @returns {Fragment}
+   */
+  get payload() {
+    const ret = wasm.signedfragment_payload(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return Fragment.__wrap(ret[0]);
+  }
+  /**
+   * 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) {
+    const ret = wasm.signedfragment_tryDecode(bytes);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _SignedFragment.__wrap(ret[0]);
+  }
+};
+if (Symbol.dispose) SignedFragment.prototype[Symbol.dispose] = SignedFragment.prototype.free;
+var SignedLooseCommit = 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;
+  }
+  static __unwrap(jsValue) {
+    if (!(jsValue instanceof _SignedLooseCommit)) {
+      return 0;
+    }
+    return jsValue.__destroy_into_raw();
+  }
+  __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 ret;
+  }
+  /**
+   * Get the unsigned payload without re-verifying the signature.
+   *
+   * # Errors
+   *
+   * Returns an error if the payload cannot be decoded.
+   * @returns {LooseCommit}
+   */
+  get payload() {
+    const ret = wasm.signedloosecommit_payload(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return LooseCommit.__wrap(ret[0]);
+  }
+  /**
+   * 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) {
+    const ret = wasm.signedloosecommit_tryDecode(bytes);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _SignedLooseCommit.__wrap(ret[0]);
+  }
+};
+if (Symbol.dispose) SignedLooseCommit.prototype[Symbol.dispose] = SignedLooseCommit.prototype.free;
+var Subduction = 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);
+  }
+  /**
+   * Accept a connection from a peer over any [`Transport`](JsTransport).
+   *
+   * Performs the responder side of the handshake, then adds the authenticated
+   * connection. This is the counterpart to [`connectTransport`](Self::connect_transport).
+   *
+   * # Arguments
+   *
+   * * `transport` - Any JS object with `sendBytes`/`recvBytes`/`disconnect`
+   * * `service_name` - Shared service name for discovery
+   *
+   * # Errors
+   *
+   * Returns an error if the handshake or connection fails.
+   * @param {Transport} transport
+   * @param {string} service_name
+   * @returns {Promise<PeerId>}
+   */
+  acceptTransport(transport, service_name) {
+    const ptr0 = passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.subduction_acceptTransport(this.__wbg_ptr, transport, ptr0, len0);
+    return ret;
+  }
+  /**
+   * 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, blob);
+    return ret;
+  }
+  /**
+   * Onboard an authenticated transport: add it and sync all sedimentrees.
+   *
+   * Accepts an [`AuthenticatedTransport`](WasmAuthenticatedTransport),
+   * obtained via [`AuthenticatedTransport.setup`](WasmAuthenticatedTransport::setup),
+   * [`AuthenticatedWebSocket.toTransport`], or [`AuthenticatedLongPoll.toTransport`].
+   *
+   * Returns `true` if this is a new peer, `false` if already connected.
+   *
+   * Add an authenticated transport to tracking.
+   *
+   * This does not perform any synchronization. To sync after adding,
+   * call [`fullSyncWithPeer`](Self::full_sync_with_peer).
+   *
+   * Returns `true` if this is a new peer, `false` if already connected.
+   *
+   * # Errors
+   *
+   * Returns an error if the connection is rejected by the policy.
+   * @param {AuthenticatedTransport} transport
+   * @returns {Promise<boolean>}
+   */
+  addConnection(transport) {
+    _assertClass(transport, AuthenticatedTransport);
+    const ret = wasm.subduction_addConnection(this.__wbg_ptr, transport.__wbg_ptr);
+    return 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, blob);
+    return 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 ret;
+  }
+  /**
+   * Connect to a peer via WebSocket and add the connection.
+   *
+   * This performs the cryptographic handshake, verifies the server's identity,
+   * and adds the authenticated connection for syncing.
+   *
+   * Returns the verified peer ID on success.
+   *
+   * # Arguments
+   *
+   * * `address` - The WebSocket URL to connect to
+   * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+   *
+   * # Errors
+   *
+   * Returns an error if connection, handshake, or adding the connection fails.
+   * @param {URL} address
+   * @param {PeerId} expected_peer_id
+   * @returns {Promise<PeerId>}
+   */
+  connect(address, expected_peer_id) {
+    _assertClass(expected_peer_id, PeerId);
+    const ret = wasm.subduction_connect(this.__wbg_ptr, address, expected_peer_id.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Connect to a peer via WebSocket using discovery mode and add the connection.
+   *
+   * Returns the discovered and verified peer ID on success.
+   *
+   * # Arguments
+   *
+   * * `address` - The WebSocket URL to connect to
+   * * `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 adding the connection fails.
+   * @param {URL} address
+   * @param {string | null} [service_name]
+   * @returns {Promise<PeerId>}
+   */
+  connectDiscover(address, 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, address, ptr0, len0);
+    return 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`)
+   * * `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 adding the connection fails.
+   * @param {string} base_url
+   * @param {string | null} [service_name]
+   * @returns {Promise<PeerId>}
+   */
+  connectDiscoverLongPoll(base_url, 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, ptr1, len1);
+    return ret;
+  }
+  /**
+   * Connect to a peer via HTTP long-poll and add the connection.
+   *
+   * Returns the verified peer ID on success.
+   *
+   * # Arguments
+   *
+   * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
+   * * `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 adding the connection fails.
+   * @param {string} base_url
+   * @param {PeerId} expected_peer_id
+   * @returns {Promise<PeerId>}
+   */
+  connectLongPoll(base_url, expected_peer_id) {
+    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, expected_peer_id.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Connect to a peer over any [`Transport`](JsTransport) using discovery mode.
+   *
+   * Performs a discovery handshake, then adds the authenticated connection.
+   * The peer's identity is discovered during the handshake.
+   *
+   * # Arguments
+   *
+   * * `transport` - Any JS object with `sendBytes`/`recvBytes`/`disconnect`
+   * * `service_name` - Shared service name for discovery
+   *
+   * # Errors
+   *
+   * Returns an error if the handshake or connection fails.
+   * @param {Transport} transport
+   * @param {string} service_name
+   * @returns {Promise<PeerId>}
+   */
+  connectTransport(transport, service_name) {
+    const ptr0 = passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.subduction_connectTransport(this.__wbg_ptr, transport, ptr0, len0);
+    return 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 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 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 ret;
+  }
+  /**
+   * Sync all known Sedimentree IDs with all connected peers.
+   * @param {bigint | null} [timeout_milliseconds]
+   * @returns {Promise<PeerBatchSyncResult>}
+   */
+  fullSyncWithAllPeers(timeout_milliseconds) {
+    const ret = wasm.subduction_fullSyncWithAllPeers(this.__wbg_ptr, !isLikeNone(timeout_milliseconds), isLikeNone(timeout_milliseconds) ? BigInt(0) : timeout_milliseconds);
+    return ret;
+  }
+  /**
+   * Sync all known Sedimentree IDs with a single peer.
+   *
+   * # Arguments
+   *
+   * * `peer_id` - The peer to sync with
+   * * `subscribe` - Whether to subscribe to future updates (default: `true`)
+   * * `timeout_milliseconds` - Per-call timeout in milliseconds
+   * @param {PeerId} peer_id
+   * @param {boolean | null} [subscribe]
+   * @param {bigint | null} [timeout_milliseconds]
+   * @returns {Promise<PeerBatchSyncResult>}
+   */
+  fullSyncWithPeer(peer_id, subscribe, timeout_milliseconds) {
+    _assertClass(peer_id, PeerId);
+    const ret = wasm.subduction_fullSyncWithPeer(this.__wbg_ptr, peer_id.__wbg_ptr, isLikeNone(subscribe) ? 16777215 : subscribe ? 1 : 0, !isLikeNone(timeout_milliseconds), isLikeNone(timeout_milliseconds) ? BigInt(0) : timeout_milliseconds);
+    return 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 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 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 ret;
+  }
+  /**
+   * Get the peer IDs of all connected peers.
+   * @returns {Promise<PeerId[]>}
+   */
+  getConnectedPeerIds() {
+    const ret = wasm.subduction_getConnectedPeerIds(this.__wbg_ptr);
+    return 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 ret;
+  }
+  /**
+   * Hydrate a [`Subduction`] instance from external storage.
+   *
+   * Loads all sedimentree data from storage and reconstructs the in-memory
+   * state before initializing the sync engine.
+   *
+   * # 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)
+   * * `policy` - Optional connection/storage authorization policy.
+   *   Defaults to allow-all.
+   * * `ephemeral_policy` - Optional ephemeral message authorization policy.
+   *   Defaults to allow-all.
+   *
+   * # Panics
+   *
+   * Panics if `hash_metric_override` is `Some` but the underlying JS value
+   * cannot be cast to a `Function`.
+   *
+   * # 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]
+   * @param {Policy | null} [policy]
+   * @param {EphemeralPolicy | null} [ephemeral_policy]
+   * @param {Function | null} [on_remote_heads]
+   * @param {Function | null} [on_ephemeral]
+   * @returns {Promise<Subduction>}
+   */
+  static hydrate(signer, storage, service_name, hash_metric_override, max_pending_blob_requests, policy, ephemeral_policy, on_remote_heads, on_ephemeral) {
+    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(signer, storage, ptr0, len0, isLikeNone(hash_metric_override) ? 0 : addToExternrefTable0(hash_metric_override), isLikeNone(max_pending_blob_requests) ? 4294967297 : max_pending_blob_requests >>> 0, isLikeNone(policy) ? 0 : addToExternrefTable0(policy), isLikeNone(ephemeral_policy) ? 0 : addToExternrefTable0(ephemeral_policy), isLikeNone(on_remote_heads) ? 0 : addToExternrefTable0(on_remote_heads), isLikeNone(on_ephemeral) ? 0 : addToExternrefTable0(on_ephemeral));
+    return ret;
+  }
+  /**
+   * Link two local [`Subduction`](WasmSubduction) instances over a
+   * [`MessageChannel`](web_sys::MessageChannel).
+   *
+   * Creates a `MessageChannel`, performs a discovery handshake between
+   * the two instances, and adds the connections to both. This is the
+   * simplest way to sync two local instances.
+   *
+   * # Errors
+   *
+   * Returns an error if the handshake or connection fails.
+   * @param {Subduction} a
+   * @param {Subduction} b
+   * @returns {Promise<void>}
+   */
+  static link(a, b) {
+    _assertClass(a, _Subduction);
+    _assertClass(b, _Subduction);
+    const ret = wasm.subduction_link(a.__wbg_ptr, b.__wbg_ptr);
+    return 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)
+   * * `policy` - Optional connection/storage authorization policy.
+   *   Defaults to allow-all.
+   * * `ephemeral_policy` - Optional ephemeral message authorization policy.
+   *   Defaults to allow-all.
+   *
+   * # Panics
+   *
+   * Panics if `hash_metric_override` is `Some` but the underlying JS value
+   * cannot be cast to a `Function`.
+   * @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]
+   * @param {Policy | null} [policy]
+   * @param {EphemeralPolicy | null} [ephemeral_policy]
+   * @param {Function | null} [on_remote_heads]
+   * @param {Function | null} [on_ephemeral]
+   */
+  constructor(signer, storage, service_name, hash_metric_override, max_pending_blob_requests, policy, ephemeral_policy, on_remote_heads, on_ephemeral) {
+    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(signer, storage, ptr0, len0, isLikeNone(hash_metric_override) ? 0 : addToExternrefTable0(hash_metric_override), isLikeNone(max_pending_blob_requests) ? 4294967297 : max_pending_blob_requests >>> 0, isLikeNone(policy) ? 0 : addToExternrefTable0(policy), isLikeNone(ephemeral_policy) ? 0 : addToExternrefTable0(ephemeral_policy), isLikeNone(on_remote_heads) ? 0 : addToExternrefTable0(on_remote_heads), isLikeNone(on_ephemeral) ? 0 : addToExternrefTable0(on_ephemeral));
+    this.__wbg_ptr = ret >>> 0;
+    SubductionFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Publish an ephemeral message to all subscribers of a topic.
+   *
+   * The payload is opaque bytes — encoding is the caller's responsibility.
+   * Messages are fire-and-forget; delivery is best-effort.
+   *
+   * # Panics
+   *
+   * Panics if the platform's random number generator fails.
+   * @param {Topic} topic
+   * @param {Uint8Array} payload
+   * @returns {Promise<void>}
+   */
+  publishEphemeral(topic, payload) {
+    _assertClass(topic, Topic);
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.subduction_publishEphemeral(this.__wbg_ptr, topic.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+  /**
+   * 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 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 ret;
+  }
+  /**
+   * Get all known Sedimentree IDs
+   * @returns {Promise<SedimentreeId[]>}
+   */
+  sedimentreeIds() {
+    const ret = wasm.subduction_sedimentreeIds(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Get the backing storage.
+   * @returns {any}
+   */
+  get storage() {
+    const ret = wasm.subduction_storage(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Subscribe to ephemeral messages for the given topics
+   * from all connected peers.
+   * @param {Topic[]} topics
+   * @returns {Promise<void>}
+   */
+  subscribeEphemeral(topics) {
+    const ptr0 = passArrayJsValueToWasm0(topics, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.subduction_subscribeEphemeral(this.__wbg_ptr, ptr0, len0);
+    return 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>}
+   */
+  syncWithAllPeers(id, subscribe, timeout_milliseconds) {
+    _assertClass(id, SedimentreeId);
+    const ret = wasm.subduction_syncWithAllPeers(this.__wbg_ptr, id.__wbg_ptr, subscribe, !isLikeNone(timeout_milliseconds), isLikeNone(timeout_milliseconds) ? BigInt(0) : timeout_milliseconds);
+    return 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 ret;
+  }
+  /**
+   * Unsubscribe from ephemeral messages for the given topics
+   * from all connected peers.
+   * @param {Topic[]} topics
+   * @returns {Promise<void>}
+   */
+  unsubscribeEphemeral(topics) {
+    const ptr0 = passArrayJsValueToWasm0(topics, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.subduction_unsubscribeEphemeral(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+};
+if (Symbol.dispose) Subduction.prototype[Symbol.dispose] = Subduction.prototype.free;
+var SubductionHttpLongPoll = class _SubductionHttpLongPoll {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_SubductionHttpLongPoll.prototype);
+    obj.__wbg_ptr = ptr;
+    SubductionHttpLongPollFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SubductionHttpLongPollFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_subductionhttplongpoll_free(ptr, 0);
+  }
+  /**
+   * Disconnect from the peer gracefully.
+   *
+   * Fires the `onDisconnect` callback if one is registered.
+   *
+   * # Errors
+   *
+   * Returns an error if the disconnect fails.
+   * @returns {Promise<void>}
+   */
+  disconnect() {
+    const ret = wasm.subductionhttplongpoll_disconnect(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Register a callback to be invoked when the transport disconnects.
+   *
+   * Part of the [`Transport`](super::JsTransport) interface contract.
+   * Typically called by internal wiring rather than directly by user code.
+   * @param {Function} callback
+   */
+  onDisconnect(callback) {
+    wasm.subductionhttplongpoll_onDisconnect(this.__wbg_ptr, callback);
+  }
+  /**
+   * Receive the next message frame as raw bytes.
+   *
+   * # Errors
+   *
+   * Returns an error if the inbound channel is closed.
+   * @returns {Promise<Uint8Array>}
+   */
+  recvBytes() {
+    const ret = wasm.subductionhttplongpoll_recvBytes(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Send raw bytes over the transport.
+   *
+   * # Errors
+   *
+   * Returns an error if the outbound channel is closed.
+   * @param {Uint8Array} bytes
+   * @returns {Promise<void>}
+   */
+  sendBytes(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.subductionhttplongpoll_sendBytes(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+};
+if (Symbol.dispose) SubductionHttpLongPoll.prototype[Symbol.dispose] = SubductionHttpLongPoll.prototype.free;
+var SubductionLongPoll = class {
+  __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)
+   * * `on_disconnect` - Optional callback invoked with the peer's [`PeerId`] when the connection closes
+   *
+   * # Errors
+   *
+   * Returns [`LongPollTransportError`] if connection or handshake fails.
+   * @param {string} base_url
+   * @param {any} signer
+   * @param {PeerId} expected_peer_id
+   * @param {Function | null} [on_disconnect]
+   * @returns {Promise<AuthenticatedLongPoll>}
+   */
+  static tryConnect(base_url, signer, expected_peer_id, on_disconnect) {
+    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, signer, expected_peer_id.__wbg_ptr, isLikeNone(on_disconnect) ? 0 : addToExternrefTable0(on_disconnect));
+    return 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
+   * * `service_name` - The service name for discovery. If omitted, the base URL is used.
+   *
+   * # Errors
+   *
+   * Returns [`LongPollTransportError`] if connection or handshake fails.
+   * @param {string} base_url
+   * @param {any} signer
+   * @param {string | null} [service_name]
+   * @param {Function | null} [on_disconnect]
+   * @returns {Promise<AuthenticatedLongPoll>}
+   */
+  static tryDiscover(base_url, signer, service_name, on_disconnect) {
+    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, signer, ptr1, len1, isLikeNone(on_disconnect) ? 0 : addToExternrefTable0(on_disconnect));
+    return ret;
+  }
+};
+if (Symbol.dispose) SubductionLongPoll.prototype[Symbol.dispose] = SubductionLongPoll.prototype.free;
+var SubductionWebSocket = 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);
+  }
+  /**
+   * Disconnect from the peer gracefully.
+   * @returns {Promise<void>}
+   */
+  disconnect() {
+    const ret = wasm.subductionwebsocket_disconnect(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Register a callback to be invoked when the WebSocket closes.
+   *
+   * Part of the [`Transport`](super::JsTransport) interface contract.
+   * Typically called by internal wiring (factory methods like `tryConnect`
+   * and `tryDiscover`) rather than directly by user code.
+   *
+   * The callback is fired from the browser WebSocket's `onclose` handler.
+   * @param {Function} callback
+   */
+  onDisconnect(callback) {
+    wasm.subductionwebsocket_onDisconnect(this.__wbg_ptr, callback);
+  }
+  /**
+   * Receive the next message frame as raw bytes.
+   *
+   * # Errors
+   *
+   * Returns [`ReadFromClosedChannel`] if the channel has been closed.
+   * @returns {Promise<Uint8Array>}
+   */
+  recvBytes() {
+    const ret = wasm.subductionwebsocket_recvBytes(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Send raw bytes over the WebSocket.
+   *
+   * # Errors
+   *
+   * Returns [`WasmSendError`] if the bytes could not be sent.
+   * @param {Uint8Array} bytes
+   * @returns {Promise<void>}
+   */
+  sendBytes(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.subductionwebsocket_sendBytes(this.__wbg_ptr, ptr0, len0);
+    return 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)
+   * * `on_disconnect` - Optional callback invoked with the peer's [`PeerId`] when the connection closes
+   *
+   * # 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 {Function | null} [on_disconnect]
+   * @returns {Promise<AuthenticatedWebSocket>}
+   */
+  static setup(ws, signer, expected_peer_id, on_disconnect) {
+    _assertClass(expected_peer_id, PeerId);
+    const ret = wasm.subductionwebsocket_setup(ws, signer, expected_peer_id.__wbg_ptr, isLikeNone(on_disconnect) ? 0 : addToExternrefTable0(on_disconnect));
+    return 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)
+   * * `on_disconnect` - Optional callback invoked with the peer's [`PeerId`] when the connection closes
+   *
+   * # 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 {Function | null} [on_disconnect]
+   * @returns {Promise<AuthenticatedWebSocket>}
+   */
+  static tryConnect(address, signer, expected_peer_id, on_disconnect) {
+    _assertClass(expected_peer_id, PeerId);
+    const ret = wasm.subductionwebsocket_tryConnect(address, signer, expected_peer_id.__wbg_ptr, isLikeNone(on_disconnect) ? 0 : addToExternrefTable0(on_disconnect));
+    return 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
+   * * `service_name` - The service name for discovery (e.g., `localhost:8080`).
+   *   If omitted, the host is extracted from the URL.
+   * * `on_disconnect` - Optional callback invoked with the peer's [`PeerId`] when the connection closes
+   *
+   * # 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 {string | null} [service_name]
+   * @param {Function | null} [on_disconnect]
+   * @returns {Promise<AuthenticatedWebSocket>}
+   */
+  static tryDiscover(address, signer, service_name, on_disconnect) {
+    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(address, signer, ptr0, len0, isLikeNone(on_disconnect) ? 0 : addToExternrefTable0(on_disconnect));
+    return ret;
+  }
+};
+if (Symbol.dispose) SubductionWebSocket.prototype[Symbol.dispose] = SubductionWebSocket.prototype.free;
+var SyncMessage = class _SyncMessage {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_SyncMessage.prototype);
+    obj.__wbg_ptr = ptr;
+    SyncMessageFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SyncMessageFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_syncmessage_free(ptr, 0);
+  }
+  /**
+   * Upcasts; to the JS-import type for [`WasmMessage`].
+   * @returns {SyncMessage}
+   */
+  __wasm_refgen_toWasmMessage() {
+    const ret = wasm.syncmessage___wasm_refgen_toWasmMessage(this.__wbg_ptr);
+    return _SyncMessage.__wrap(ret);
+  }
+  /**
+   * Create a [`SyncMessage::BatchSyncRequest`] message.
+   * @param {BatchSyncRequest} request
+   * @returns {SyncMessage}
+   */
+  static batchSyncRequest(request) {
+    _assertClass(request, BatchSyncRequest);
+    const ret = wasm.syncmessage_batchSyncRequest(request.__wbg_ptr);
+    return _SyncMessage.__wrap(ret);
+  }
+  /**
+   * Create a [`SyncMessage::BatchSyncResponse`] message.
+   * @param {BatchSyncResponse} response
+   * @returns {SyncMessage}
+   */
+  static batchSyncResponse(response) {
+    _assertClass(response, BatchSyncResponse);
+    const ret = wasm.syncmessage_batchSyncResponse(response.__wbg_ptr);
+    return _SyncMessage.__wrap(ret);
+  }
+  /**
+   * The [`Blob`] for commit or fragment messages, if applicable.
+   * @returns {Uint8Array | undefined}
+   */
+  get blob() {
+    const ret = wasm.syncmessage_blob(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * The [`Blob`]s for a [`SyncMessage::BlobsResponse`], if applicable.
+   * @returns {Uint8Array[] | undefined}
+   */
+  get blobs() {
+    const ret = wasm.syncmessage_blobs(this.__wbg_ptr);
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_export5(ret[0], ret[1] * 4, 4);
+    }
+    return v1;
+  }
+  /**
+   * Create a [`SyncMessage::BlobsRequest`] message.
+   * @param {SedimentreeId} id
+   * @param {Digest[]} digests
+   * @returns {SyncMessage}
+   */
+  static blobsRequest(id, digests) {
+    _assertClass(id, SedimentreeId);
+    const ptr0 = passArrayJsValueToWasm0(digests, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.syncmessage_blobsRequest(id.__wbg_ptr, ptr0, len0);
+    return _SyncMessage.__wrap(ret);
+  }
+  /**
+   * Create a [`SyncMessage::BlobsResponse`] message.
+   * @param {SedimentreeId} id
+   * @param {Uint8Array[]} blobs
+   * @returns {SyncMessage}
+   */
+  static blobsResponse(id, blobs) {
+    _assertClass(id, SedimentreeId);
+    const ptr0 = passArrayJsValueToWasm0(blobs, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.syncmessage_blobsResponse(id.__wbg_ptr, ptr0, len0);
+    return _SyncMessage.__wrap(ret);
+  }
+  /**
+   * The [`LooseCommit`] for a [`SyncMessage::LooseCommit`], if applicable.
+   *
+   * Decodes the signed payload to extract the underlying commit.
+   * @returns {LooseCommit | undefined}
+   */
+  get commit() {
+    const ret = wasm.syncmessage_commit(this.__wbg_ptr);
+    return ret === 0 ? void 0 : LooseCommit.__wrap(ret);
+  }
+  /**
+   * The requested [`Digest`]s for a [`SyncMessage::BlobsRequest`], if applicable.
+   * @returns {Digest[] | undefined}
+   */
+  get digests() {
+    const ret = wasm.syncmessage_digests(this.__wbg_ptr);
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_export5(ret[0], ret[1] * 4, 4);
+    }
+    return v1;
+  }
+  /**
+   * The [`Fragment`] for a [`SyncMessage::Fragment`], if applicable.
+   *
+   * Decodes the signed payload to extract the underlying fragment.
+   * @returns {Fragment | undefined}
+   */
+  get fragment() {
+    const ret = wasm.syncmessage_fragment(this.__wbg_ptr);
+    return ret === 0 ? void 0 : Fragment.__wrap(ret);
+  }
+  /**
+   * Deserialize a message from bytes.
+   *
+   * # Errors
+   *
+   * Returns a [`JsMessageDeserializationError`] if deserialization fails.
+   * @param {Uint8Array} bytes
+   * @returns {SyncMessage}
+   */
+  static fromBytes(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.syncmessage_fromBytes(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _SyncMessage.__wrap(ret[0]);
+  }
+  /**
+   * The [`BatchSyncRequest`] for a [`SyncMessage::BatchSyncRequest`], if applicable.
+   * @returns {BatchSyncRequest | undefined}
+   */
+  get request() {
+    const ret = wasm.syncmessage_request(this.__wbg_ptr);
+    return ret === 0 ? void 0 : BatchSyncRequest.__wrap(ret);
+  }
+  /**
+   * The [`BatchSyncResponse`] for a [`SyncMessage::BatchSyncResponse`], if applicable.
+   * @returns {BatchSyncResponse | undefined}
+   */
+  get response() {
+    const ret = wasm.syncmessage_response(this.__wbg_ptr);
+    return ret === 0 ? void 0 : BatchSyncResponse.__wrap(ret);
+  }
+  /**
+   * The [`SedimentreeId`] associated with this message, if any.
+   * @returns {SedimentreeId | undefined}
+   */
+  get sedimentreeId() {
+    const ret = wasm.syncmessage_sedimentreeId(this.__wbg_ptr);
+    return ret === 0 ? void 0 : SedimentreeId.__wrap(ret);
+  }
+  /**
+   * Serialize the message to bytes.
+   * @returns {Uint8Array}
+   */
+  toBytes() {
+    const ret = wasm.syncmessage_toBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * The message variant name.
+   * @returns {string}
+   */
+  get type() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.syncmessage_type(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+    }
+  }
+};
+if (Symbol.dispose) SyncMessage.prototype[Symbol.dispose] = SyncMessage.prototype.free;
+var SyncStats = 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 commits or fragments were transferred.
+   *
+   * Note: `remoteHeads` may still be non-empty (heads metadata is not
+   * considered "data" for this check).
+   * @returns {boolean}
+   */
+  get isEmpty() {
+    const ret = wasm.syncstats_isEmpty(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   * The remote peer's heads for this sedimentree.
+   * @returns {Digest[]}
+   */
+  get remoteHeads() {
+    const ret = wasm.syncstats_remoteHeads(this.__wbg_ptr);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 4, 4);
+    return v1;
+  }
+  /**
+   * 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;
+var Topic = class _Topic {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_Topic.prototype);
+    obj.__wbg_ptr = ptr;
+    TopicFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  static __unwrap(jsValue) {
+    if (!(jsValue instanceof _Topic)) {
+      return 0;
+    }
+    return jsValue.__destroy_into_raw();
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    TopicFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_topic_free(ptr, 0);
+  }
+  /**
+   * Create a topic from a 32-byte array.
+   *
+   * # Errors
+   *
+   * Returns an error if the provided byte array is not exactly 32 bytes.
+   * @param {Uint8Array} bytes
+   * @returns {Topic}
+   */
+  static fromBytes(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.topic_fromBytes(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return _Topic.__wrap(ret[0]);
+  }
+  /**
+   * Returns the raw 32 bytes of this topic.
+   * @returns {Uint8Array}
+   */
+  toBytes() {
+    const ret = wasm.topic_toBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_export5(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Returns a shortened hex prefix representation (first 4 bytes + `…`).
+   * @returns {string}
+   */
+  toString() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.topic_toString(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+    }
+  }
+};
+if (Symbol.dispose) Topic.prototype[Symbol.dispose] = Topic.prototype.free;
+var WebCryptoSigner = 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 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 ret;
+  }
+  /**
+   * Get the 32-byte Ed25519 verifying (public) key.
+   * @returns {Uint8Array}
+   */
+  verifyingKey() {
+    const ret = wasm.webcryptosigner_verifyingKey(this.__wbg_ptr);
+    return ret;
+  }
+};
+if (Symbol.dispose) WebCryptoSigner.prototype[Symbol.dispose] = WebCryptoSigner.prototype.free;
+function makeMessagePortTransport(port) {
+  const ret = wasm.makeMessagePortTransport(port);
+  return MessagePortTransport.__wrap(ret);
+}
+function start() {
+  wasm.start();
+}
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg___wasm_refgen_toWasmCommitWithBlob_bcab5aaed3558280: function(arg0) {
+      const ret = arg0.__wasm_refgen_toWasmCommitWithBlob();
+      _assertClass(ret, CommitWithBlob);
+      var ptr1 = ret.__destroy_into_raw();
+      return ptr1;
+    },
+    __wbg___wasm_refgen_toWasmDepth_5124f666e343ff0c: function(arg0) {
+      const ret = arg0.__wasm_refgen_toWasmDepth();
+      _assertClass(ret, Depth);
+      var ptr1 = ret.__destroy_into_raw();
+      return ptr1;
+    },
+    __wbg___wasm_refgen_toWasmDigest_476b24805f220005: function(arg0) {
+      const ret = arg0.__wasm_refgen_toWasmDigest();
+      _assertClass(ret, Digest);
+      var ptr1 = ret.__destroy_into_raw();
+      return ptr1;
+    },
+    __wbg___wasm_refgen_toWasmFragmentWithBlob_ed713e5c5f4cc52e: function(arg0) {
+      const ret = arg0.__wasm_refgen_toWasmFragmentWithBlob();
+      _assertClass(ret, FragmentWithBlob);
+      var ptr1 = ret.__destroy_into_raw();
+      return ptr1;
+    },
+    __wbg___wasm_refgen_toWasmFragment_10dd1ff9b3934840: function(arg0) {
+      const ret = arg0.__wasm_refgen_toWasmFragment();
+      _assertClass(ret, Fragment);
+      var ptr1 = ret.__destroy_into_raw();
+      return ptr1;
+    },
+    __wbg___wasm_refgen_toWasmLooseCommit_f36ad6a9389cee03: function(arg0) {
+      const ret = arg0.__wasm_refgen_toWasmLooseCommit();
+      _assertClass(ret, LooseCommit);
+      var ptr1 = ret.__destroy_into_raw();
+      return ptr1;
+    },
+    __wbg___wbindgen_debug_string_5398f5bb970e0daa: function(arg0, arg1) {
+      const ret = debugString(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_3c846841762788c1: function(arg0) {
+      const ret = typeof arg0 === "function";
+      return ret;
+    },
+    __wbg___wbindgen_is_null_0b605fc6b167c56f: function(arg0) {
+      const ret = arg0 === null;
+      return ret;
+    },
+    __wbg___wbindgen_is_object_781bc9f159099513: function(arg0) {
+      const val = arg0;
+      const ret = typeof val === "object" && val !== null;
+      return ret;
+    },
+    __wbg___wbindgen_is_string_7ef6b97b02428fae: function(arg0) {
+      const ret = typeof arg0 === "string";
+      return ret;
+    },
+    __wbg___wbindgen_is_undefined_52709e72fb9f179c: function(arg0) {
+      const ret = arg0 === void 0;
+      return ret;
+    },
+    __wbg___wbindgen_jsval_eq_ee31bfad3e536463: function(arg0, arg1) {
+      const ret = arg0 === arg1;
+      return ret;
+    },
+    __wbg___wbindgen_number_get_34bb9d9dcfa21373: function(arg0, arg1) {
+      const obj = arg1;
+      const ret = typeof obj === "number" ? obj : void 0;
+      getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    },
+    __wbg___wbindgen_string_get_395e606bd0ee4427: function(arg0, arg1) {
+      const obj = arg1;
+      const ret = typeof obj === "string" ? obj : void 0;
+      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);
+    },
+    __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbg__wbg_cb_unref_6b5b6b8576d35cb1: function(arg0) {
+      arg0._wbg_cb_unref();
+    },
+    __wbg_arrayBuffer_eb8e9ca620af2a19: function() {
+      return handleError(function(arg0) {
+        const ret = arg0.arrayBuffer();
+        return ret;
+      }, arguments);
+    },
+    __wbg_authenticatedlongpoll_new: function(arg0) {
+      const ret = AuthenticatedLongPoll.__wrap(arg0);
+      return ret;
+    },
+    __wbg_authenticatedtransport_new: function(arg0) {
+      const ret = AuthenticatedTransport.__wrap(arg0);
+      return ret;
+    },
+    __wbg_authenticatedwebsocket_new: function(arg0) {
+      const ret = AuthenticatedWebSocket.__wrap(arg0);
+      return ret;
+    },
+    __wbg_authorizeConnect_8e2609308bbbbcfd: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = arg0.authorizeConnect(PeerId.__wrap(arg1));
+        return ret;
+      }, arguments);
+    },
+    __wbg_authorizeFetch_b7bcc4e437112c73: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.authorizeFetch(PeerId.__wrap(arg1), SedimentreeId.__wrap(arg2));
+        return ret;
+      }, arguments);
+    },
+    __wbg_authorizePublish_7e546fc3d8103532: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.authorizePublish(PeerId.__wrap(arg1), Topic.__wrap(arg2));
+        return ret;
+      }, arguments);
+    },
+    __wbg_authorizePut_ba5a5e36c9e9bbfa: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        const ret = arg0.authorizePut(PeerId.__wrap(arg1), PeerId.__wrap(arg2), SedimentreeId.__wrap(arg3));
+        return ret;
+      }, arguments);
+    },
+    __wbg_authorizeSubscribe_34f5ba6f23bab853: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.authorizeSubscribe(PeerId.__wrap(arg1), Topic.__wrap(arg2));
+        return ret;
+      }, arguments);
+    },
+    __wbg_buffer_60b8043cd926067d: function(arg0) {
+      const ret = arg0.buffer;
+      return ret;
+    },
+    __wbg_call_2d781c1f4d5c0ef8: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_e133b57c9155d22c: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_f858478a02f9600f: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+        const ret = arg0.call(arg1, arg2, arg3, arg4);
+        return ret;
+      }, arguments);
+    },
+    __wbg_close_af26905c832a88cb: function() {
+      return handleError(function(arg0) {
+        arg0.close();
+      }, arguments);
+    },
+    __wbg_close_cbf870bdad0aad99: function(arg0) {
+      arg0.close();
+    },
+    __wbg_close_f85b3643ad9ed8d4: function(arg0) {
+      arg0.close();
+    },
+    __wbg_commitwithblob_new: function(arg0) {
+      const ret = CommitWithBlob.__wrap(arg0);
+      return ret;
+    },
+    __wbg_contains_ef4bfb7fa5a241b7: function(arg0, arg1, arg2) {
+      const ret = arg0.contains(getStringFromWasm0(arg1, arg2));
+      return ret;
+    },
+    __wbg_createObjectStore_92a8aebcc6f9d7e3: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.createObjectStore(getStringFromWasm0(arg1, arg2));
+        return ret;
+      }, arguments);
+    },
+    __wbg_crypto_38df2bab126b63dc: function(arg0) {
+      const ret = arg0.crypto;
+      return ret;
+    },
+    __wbg_data_a3d9ff9cdd801002: function(arg0) {
+      const ret = arg0.data;
+      return ret;
+    },
+    __wbg_deleteAllCommits_026a63e00bba2a2c: function(arg0, arg1) {
+      const ret = arg0.deleteAllCommits(arg1);
+      return ret;
+    },
+    __wbg_deleteAllFragments_857ddb74b3342f83: function(arg0, arg1) {
+      const ret = arg0.deleteAllFragments(arg1);
+      return ret;
+    },
+    __wbg_digest_new: function(arg0) {
+      const ret = Digest.__wrap(arg0);
+      return ret;
+    },
+    __wbg_digest_unwrap: function(arg0) {
+      const ret = Digest.__unwrap(arg0);
+      return ret;
+    },
+    __wbg_disconnect_91312bb506e834b1: function(arg0) {
+      const ret = arg0.disconnect();
+      return ret;
+    },
+    __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+      let deferred0_0;
+      let deferred0_1;
+      try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+      } finally {
+        wasm.__wbindgen_export5(deferred0_0, deferred0_1, 1);
+      }
+    },
+    __wbg_exportKey_c43b919dba5a1db2: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        const ret = arg0.exportKey(getStringFromWasm0(arg1, arg2), arg3);
+        return ret;
+      }, arguments);
+    },
+    __wbg_fetch_5550a88cf343aaa9: function(arg0, arg1) {
+      const ret = arg0.fetch(arg1);
+      return ret;
+    },
+    __wbg_fetch_f8a611684c3b5fe5: function(arg0, arg1) {
+      const ret = arg0.fetch(arg1);
+      return ret;
+    },
+    __wbg_filterAuthorizedFetch_a647f13dc33948f1: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
+        wasm.__wbindgen_export5(arg2, arg3 * 4, 4);
+        const ret = arg0.filterAuthorizedFetch(PeerId.__wrap(arg1), v0);
+        return ret;
+      }, arguments);
+    },
+    __wbg_filterAuthorizedSubscribers_34bdeaaac0eb31a5: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        var v0 = getArrayJsValueFromWasm0(arg2, arg3).slice();
+        wasm.__wbindgen_export5(arg2, arg3 * 4, 4);
+        const ret = arg0.filterAuthorizedSubscribers(Topic.__wrap(arg1), v0);
+        return ret;
+      }, arguments);
+    },
+    __wbg_fragment_new: function(arg0) {
+      const ret = Fragment.__wrap(arg0);
+      return ret;
+    },
+    __wbg_fragmentrequested_new: function(arg0) {
+      const ret = FragmentRequested.__wrap(arg0);
+      return ret;
+    },
+    __wbg_fragmentwithblob_new: function(arg0) {
+      const ret = FragmentWithBlob.__wrap(arg0);
+      return ret;
+    },
+    __wbg_from_4bdf88943703fd48: function(arg0) {
+      const ret = Array.from(arg0);
+      return ret;
+    },
+    __wbg_generateKey_2b6cf71e7c9ad526: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        const ret = arg0.generateKey(arg1, arg2 !== 0, arg3);
+        return ret;
+      }, arguments);
+    },
+    __wbg_getRandomValues_c44a50d8cfdaebeb: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.getRandomValues(arg1);
+      }, arguments);
+    },
+    __wbg_get_3ef1eba1850ade27: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_get_6ac8c8119f577720: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = arg0.get(arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_get_a867a94064ecd263: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        const ret = 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_get_a8ee5c45dabc1b3b: function(arg0, arg1) {
+      const ret = arg0[arg1 >>> 0];
+      return ret;
+    },
+    __wbg_get_unchecked_329cfe50afab7352: function(arg0, arg1) {
+      const ret = arg0[arg1 >>> 0];
+      return ret;
+    },
+    __wbg_has_926ef2ff40b308cf: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = Reflect.has(arg0, arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_headers_eb2234545f9ff993: function(arg0) {
+      const ret = arg0.headers;
+      return ret;
+    },
+    __wbg_host_5b3ec3e9d4d1fc78: function(arg0, arg1) {
+      const ret = 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_da367531ce807a58: function(arg0, arg1) {
+      const ret = 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_397406e38b080c57: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+        const ret = arg0.importKey(getStringFromWasm0(arg1, arg2), arg3, arg4, arg5 !== 0, arg6);
+        return ret;
+      }, arguments);
+    },
+    __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof ArrayBuffer;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Crypto_5c2a4c15287b0332: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Crypto;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_IdbDatabase_5f436cc89cc07f14: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof IDBDatabase;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_IdbFactory_efcffbfd9020e4ac: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof IDBFactory;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_IdbOpenDbRequest_10c2576001eb6613: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof IDBOpenDBRequest;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Promise_7c3bdd7805c2c6e6: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Promise;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Response_9b4d9fd451e051b1: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Response;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Uint8Array_740438561a5b956d: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Uint8Array;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Window_23e677d2c6843922: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Window;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_WorkerGlobalScope_de6976d00cb213c6: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof WorkerGlobalScope;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_isArray_33b91feb269ff46e: function(arg0) {
+      const ret = Array.isArray(arg0);
+      return ret;
+    },
+    __wbg_isSafeInteger_ecd6a7f9c3e053cd: function(arg0) {
+      const ret = Number.isSafeInteger(arg0);
+      return ret;
+    },
+    __wbg_length_b3416cf66a5452c8: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_length_ea16607d7b61445b: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_loadAllCommits_c18e977eb552890c: function(arg0, arg1) {
+      const ret = arg0.loadAllCommits(arg1);
+      return ret;
+    },
+    __wbg_loadAllFragments_499f304a483c7f7f: function(arg0, arg1) {
+      const ret = arg0.loadAllFragments(arg1);
+      return ret;
+    },
+    __wbg_loadAllSedimentreeIds_da48711155f73930: function(arg0) {
+      const ret = arg0.loadAllSedimentreeIds();
+      return ret;
+    },
+    __wbg_loosecommit_new: function(arg0) {
+      const ret = LooseCommit.__wrap(arg0);
+      return ret;
+    },
+    __wbg_messageporttransport_new: function(arg0) {
+      const ret = MessagePortTransport.__wrap(arg0);
+      return ret;
+    },
+    __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+      const ret = arg0.msCrypto;
+      return ret;
+    },
+    __wbg_new_0837727332ac86ba: function() {
+      return handleError(function() {
+        const ret = new Headers();
+        return ret;
+      }, arguments);
+    },
+    __wbg_new_227d7c05414eb861: function() {
+      const ret = new Error();
+      return ret;
+    },
+    __wbg_new_5f486cdf45a04d78: function(arg0) {
+      const ret = new Uint8Array(arg0);
+      return ret;
+    },
+    __wbg_new_a70fbab9066b301f: function() {
+      const ret = new Array();
+      return ret;
+    },
+    __wbg_new_ab79df5bd7c26067: function() {
+      const ret = new Object();
+      return ret;
+    },
+    __wbg_new_d098e265629cd10f: function(arg0, arg1) {
+      try {
+        var state0 = { a: arg0, b: arg1 };
+        var cb0 = (arg02, arg12) => {
+          const a = state0.a;
+          state0.a = 0;
+          try {
+            return __wasm_bindgen_func_elem_1652_195(a, state0.b, arg02, arg12);
+          } finally {
+            state0.a = a;
+          }
+        };
+        const ret = new Promise(cb0);
+        return ret;
+      } finally {
+        state0.a = state0.b = 0;
+      }
+    },
+    __wbg_new_d15cb560a6a0e5f0: function(arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_new_dd50bcc3f60ba434: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
+        return ret;
+      }, arguments);
+    },
+    __wbg_new_f7708ba82c4c12f6: function() {
+      return handleError(function() {
+        const ret = new MessageChannel();
+        return ret;
+      }, arguments);
+    },
+    __wbg_new_from_slice_22da9388ac046e50: function(arg0, arg1) {
+      const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_new_typed_aaaeaf29cf802876: function(arg0, arg1) {
+      try {
+        var state0 = { a: arg0, b: arg1 };
+        var cb0 = (arg02, arg12) => {
+          const a = state0.a;
+          state0.a = 0;
+          try {
+            return __wasm_bindgen_func_elem_1652_196(a, state0.b, arg02, arg12);
+          } finally {
+            state0.a = a;
+          }
+        };
+        const ret = new Promise(cb0);
+        return ret;
+      } finally {
+        state0.a = state0.b = 0;
+      }
+    },
+    __wbg_new_typed_bccac67128ed885a: function() {
+      const ret = new Array();
+      return ret;
+    },
+    __wbg_new_with_length_3259a525196bd8cc: function(arg0) {
+      const ret = new Array(arg0 >>> 0);
+      return ret;
+    },
+    __wbg_new_with_length_825018a1616e9e55: function(arg0) {
+      const ret = new Uint8Array(arg0 >>> 0);
+      return ret;
+    },
+    __wbg_new_with_str_and_init_b4b54d1a819bc724: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_node_84ea875411254db1: function(arg0) {
+      const ret = arg0.node;
+      return ret;
+    },
+    __wbg_now_16f0c993d5dd6c27: function() {
+      const ret = Date.now();
+      return ret;
+    },
+    __wbg_objectStoreNames_564985d2e9ae7523: function(arg0) {
+      const ret = arg0.objectStoreNames;
+      return ret;
+    },
+    __wbg_objectStore_f314ab152a5c7bd0: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.objectStore(getStringFromWasm0(arg1, arg2));
+        return ret;
+      }, arguments);
+    },
+    __wbg_of_8bf7ed3eca00ea43: function(arg0) {
+      const ret = Array.of(arg0);
+      return ret;
+    },
+    __wbg_of_d6376e3774c51f89: function(arg0, arg1) {
+      const ret = Array.of(arg0, arg1);
+      return ret;
+    },
+    __wbg_onDisconnect_a24437def131c941: function(arg0, arg1) {
+      arg0.onDisconnect(arg1);
+    },
+    __wbg_open_e7a9d3d6344572f6: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        const ret = arg0.open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+        return ret;
+      }, arguments);
+    },
+    __wbg_peerbatchsyncresult_new: function(arg0) {
+      const ret = PeerBatchSyncResult.__wrap(arg0);
+      return ret;
+    },
+    __wbg_peerid_new: function(arg0) {
+      const ret = PeerId.__wrap(arg0);
+      return ret;
+    },
+    __wbg_peerresultmap_new: function(arg0) {
+      const ret = PeerResultMap.__wrap(arg0);
+      return ret;
+    },
+    __wbg_port1_869a7ef90538dbdf: function(arg0) {
+      const ret = arg0.port1;
+      return ret;
+    },
+    __wbg_port2_947a51b8ba00adc9: function(arg0) {
+      const ret = arg0.port2;
+      return ret;
+    },
+    __wbg_postMessage_fb1c205fdbbf796d: function(arg0, arg1) {
+      arg0.postMessage(arg1);
+    },
+    __wbg_process_44c7a14e11e9f69e: function(arg0) {
+      const ret = arg0.process;
+      return ret;
+    },
+    __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
+      Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    },
+    __wbg_push_e87b0e732085a946: function(arg0, arg1) {
+      const ret = arg0.push(arg1);
+      return ret;
+    },
+    __wbg_put_f1673d719f93ce22: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.put(arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_queueMicrotask_0c399741342fb10f: function(arg0) {
+      const ret = arg0.queueMicrotask;
+      return ret;
+    },
+    __wbg_queueMicrotask_a082d78ce798393e: function(arg0) {
+      queueMicrotask(arg0);
+    },
+    __wbg_randomFillSync_6c25eac9869eb53c: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.randomFillSync(arg1);
+      }, arguments);
+    },
+    __wbg_readyState_1f1e7f1bdf9f4d42: function(arg0) {
+      const ret = arg0.readyState;
+      return ret;
+    },
+    __wbg_recvBytes_e13f381294da16db: function(arg0) {
+      const ret = arg0.recvBytes();
+      return ret;
+    },
+    __wbg_require_b4edbdcf3e2a1ef0: function() {
+      return handleError(function() {
+        const ret = module.require;
+        return ret;
+      }, arguments);
+    },
+    __wbg_resolve_ae8d83246e5bcc12: function(arg0) {
+      const ret = Promise.resolve(arg0);
+      return ret;
+    },
+    __wbg_result_c5baa2d3d690a01a: function() {
+      return handleError(function(arg0) {
+        const ret = arg0.result;
+        return ret;
+      }, arguments);
+    },
+    __wbg_saveBatchAll_7c5c5f486aefa571: function(arg0, arg1, arg2, arg3) {
+      const ret = arg0.saveBatchAll(arg1, arg2, arg3);
+      return ret;
+    },
+    __wbg_saveCommit_fb38edd913837eb2: function(arg0, arg1, arg2, arg3, arg4) {
+      const ret = arg0.saveCommit(arg1, arg2, arg3, arg4);
+      return ret;
+    },
+    __wbg_saveFragment_8682cc697a38dbad: function(arg0, arg1, arg2, arg3, arg4) {
+      const ret = arg0.saveFragment(arg1, arg2, arg3, arg4);
+      return ret;
+    },
+    __wbg_saveSedimentreeId_ec8145842e87e53b: function(arg0, arg1) {
+      const ret = arg0.saveSedimentreeId(arg1);
+      return ret;
+    },
+    __wbg_sedimentreeid_new: function(arg0) {
+      const ret = SedimentreeId.__wrap(arg0);
+      return ret;
+    },
+    __wbg_sedimentreeid_unwrap: function(arg0) {
+      const ret = SedimentreeId.__unwrap(arg0);
+      return ret;
+    },
+    __wbg_sendBytes_9a00cdaf7c891eff: function(arg0, arg1) {
+      const ret = arg0.sendBytes(arg1);
+      return ret;
+    },
+    __wbg_send_d31a693c975dea74: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        arg0.send(getArrayU8FromWasm0(arg1, arg2));
+      }, arguments);
+    },
+    __wbg_setTimeout_43db2c2050a4d3d2: function(arg0, arg1) {
+      const ret = setTimeout(arg0, arg1);
+      return ret;
+    },
+    __wbg_set_282384002438957f: function(arg0, arg1, arg2) {
+      arg0[arg1 >>> 0] = arg2;
+    },
+    __wbg_set_7eaa4f96924fd6b3: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = Reflect.set(arg0, arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_set_binaryType_3dcf8281ec100a8f: function(arg0, arg1) {
+      arg0.binaryType = __wbindgen_enum_BinaryType[arg1];
+    },
+    __wbg_set_body_a3d856b097dfda04: function(arg0, arg1) {
+      arg0.body = arg1;
+    },
+    __wbg_set_e09648bea3f1af1e: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+        arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+      }, arguments);
+    },
+    __wbg_set_headers_3c8fecc693b75327: function(arg0, arg1) {
+      arg0.headers = arg1;
+    },
+    __wbg_set_method_8c015e8bcafd7be1: function(arg0, arg1, arg2) {
+      arg0.method = getStringFromWasm0(arg1, arg2);
+    },
+    __wbg_set_mode_5a87f2c809cf37c2: function(arg0, arg1) {
+      arg0.mode = __wbindgen_enum_RequestMode[arg1];
+    },
+    __wbg_set_name_7ef37fe858379aaf: function(arg0, arg1, arg2) {
+      arg0.name = getStringFromWasm0(arg1, arg2);
+    },
+    __wbg_set_onclose_8da801226bdd7a7b: function(arg0, arg1) {
+      arg0.onclose = arg1;
+    },
+    __wbg_set_onerror_8a268cb237177bba: function(arg0, arg1) {
+      arg0.onerror = arg1;
+    },
+    __wbg_set_onerror_901ca711f94a5bbb: function(arg0, arg1) {
+      arg0.onerror = arg1;
+    },
+    __wbg_set_onmessage_284248c97c42cb93: function(arg0, arg1) {
+      arg0.onmessage = arg1;
+    },
+    __wbg_set_onmessage_6f80ab771bf151aa: function(arg0, arg1) {
+      arg0.onmessage = arg1;
+    },
+    __wbg_set_onopen_34e3e24cf9337ddd: function(arg0, arg1) {
+      arg0.onopen = arg1;
+    },
+    __wbg_set_onsuccess_fca94ded107b64af: function(arg0, arg1) {
+      arg0.onsuccess = arg1;
+    },
+    __wbg_set_onupgradeneeded_860ce42184f987e7: function(arg0, arg1) {
+      arg0.onupgradeneeded = arg1;
+    },
+    __wbg_sign_a34d057afd14c54d: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+        const ret = arg0.sign(arg1, arg2, getArrayU8FromWasm0(arg3, arg4));
+        return ret;
+      }, arguments);
+    },
+    __wbg_sign_e6fa76bd4ef9c75a: function(arg0, arg1) {
+      const ret = arg0.sign(arg1);
+      return ret;
+    },
+    __wbg_signedfragment_new: function(arg0) {
+      const ret = SignedFragment.__wrap(arg0);
+      return ret;
+    },
+    __wbg_signedfragment_unwrap: function(arg0) {
+      const ret = SignedFragment.__unwrap(arg0);
+      return ret;
+    },
+    __wbg_signedloosecommit_new: function(arg0) {
+      const ret = SignedLooseCommit.__wrap(arg0);
+      return ret;
+    },
+    __wbg_signedloosecommit_unwrap: function(arg0) {
+      const ret = SignedLooseCommit.__unwrap(arg0);
+      return ret;
+    },
+    __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+      const ret = arg1.stack;
+      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_start_f837ba2bac4733b5: function(arg0) {
+      arg0.start();
+    },
+    __wbg_static_accessor_GLOBAL_8adb955bd33fac2f: function() {
+      const ret = typeof global === "undefined" ? null : global;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_GLOBAL_THIS_ad356e0db91c7913: function() {
+      const ret = typeof globalThis === "undefined" ? null : globalThis;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_SELF_f207c857566db248: function() {
+      const ret = typeof self === "undefined" ? null : self;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_WINDOW_bb9f1ba69d61b386: function() {
+      const ret = typeof window === "undefined" ? null : window;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_status_318629ab93a22955: function(arg0) {
+      const ret = arg0.status;
+      return ret;
+    },
+    __wbg_subarray_a068d24e39478a8a: function(arg0, arg1, arg2) {
+      const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+      return ret;
+    },
+    __wbg_subduction_new: function(arg0) {
+      const ret = Subduction.__wrap(arg0);
+      return ret;
+    },
+    __wbg_subductionhttplongpoll_new: function(arg0) {
+      const ret = SubductionHttpLongPoll.__wrap(arg0);
+      return ret;
+    },
+    __wbg_subductionwebsocket_new: function(arg0) {
+      const ret = SubductionWebSocket.__wrap(arg0);
+      return ret;
+    },
+    __wbg_subtle_c060fa3eb5c6248d: function(arg0) {
+      const ret = arg0.subtle;
+      return ret;
+    },
+    __wbg_target_7bc90f314634b37b: function(arg0) {
+      const ret = arg0.target;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_then_098abe61755d12f6: function(arg0, arg1) {
+      const ret = arg0.then(arg1);
+      return ret;
+    },
+    __wbg_then_9e335f6dd892bc11: function(arg0, arg1, arg2) {
+      const ret = arg0.then(arg1, arg2);
+      return ret;
+    },
+    __wbg_topic_new: function(arg0) {
+      const ret = Topic.__wrap(arg0);
+      return ret;
+    },
+    __wbg_topic_unwrap: function(arg0) {
+      const ret = Topic.__unwrap(arg0);
+      return ret;
+    },
+    __wbg_transaction_1309b463c399d2b3: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        const ret = arg0.transaction(getStringFromWasm0(arg1, arg2), __wbindgen_enum_IdbTransactionMode[arg3]);
+        return ret;
+      }, arguments);
+    },
+    __wbg_transaction_2237af0233efbdf3: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.transaction(getStringFromWasm0(arg1, arg2));
+        return ret;
+      }, arguments);
+    },
+    __wbg_tryIntoJsSedimentreeIdsArray_b07d2438a6f2a3b9: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = tryIntoJsSedimentreeIdsArray(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_28c38fc6525caed5: function(arg0) {
+      const ret = arg0.verifyingKey();
+      return ret;
+    },
+    __wbg_versions_276b2795b1c6a219: function(arg0) {
+      const ret = arg0.versions;
+      return ret;
+    },
+    __wbg_webcryptosigner_new: function(arg0) {
+      const ret = WebCryptoSigner.__wrap(arg0);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+      const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_287, __wasm_bindgen_func_elem_639);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+      const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_287, __wasm_bindgen_func_elem_639_1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+      const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_287, __wasm_bindgen_func_elem_639_2);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+      const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_287, __wasm_bindgen_func_elem_639_3);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+      const ret = makeClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_287, __wasm_bindgen_func_elem_638);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000006: function(arg0, arg1) {
+      const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_287, __wasm_bindgen_func_elem_1652);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000007: function(arg0) {
+      const ret = arg0;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+      const ret = getArrayU8FromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000009: function(arg0, arg1) {
+      const ret = getStringFromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_000000000000000a: function(arg0, arg1) {
+      var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+      wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
+      const ret = v0;
+      return ret;
+    },
+    __wbindgen_cast_000000000000000b: function(arg0, arg1) {
+      var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+      wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
+      const ret = v0;
+      return ret;
+    },
+    __wbindgen_cast_000000000000000c: function(arg0, arg1) {
+      var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+      wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
+      const ret = v0;
+      return ret;
+    },
+    __wbindgen_cast_000000000000000d: function(arg0, arg1) {
+      var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+      wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
+      const ret = v0;
+      return ret;
+    },
+    __wbindgen_cast_000000000000000e: function(arg0, arg1) {
+      var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+      wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
+      const ret = v0;
+      return ret;
+    },
+    __wbindgen_init_externref_table: function() {
+      const table = wasm.__wbindgen_externrefs;
+      const offset = table.grow(4);
+      table.set(0, void 0);
+      table.set(offset + 0, void 0);
+      table.set(offset + 1, null);
+      table.set(offset + 2, true);
+      table.set(offset + 3, false);
+    }
+  };
+  return {
+    __proto__: null,
+    "./subduction_wasm_bg.js": import0,
+    "./snippets/subduction_wasm-ec51bcf335db35bd/inline0.js": inline0_exports,
+    "./snippets/subduction_wasm-ec51bcf335db35bd/inline1.js": inline1_exports
+  };
+}
+function __wasm_bindgen_func_elem_638(arg0, arg1) {
+  wasm.__wasm_bindgen_func_elem_638(arg0, arg1);
+}
+function __wasm_bindgen_func_elem_639(arg0, arg1, arg2) {
+  wasm.__wasm_bindgen_func_elem_639(arg0, arg1, arg2);
+}
+function __wasm_bindgen_func_elem_639_1(arg0, arg1, arg2) {
+  wasm.__wasm_bindgen_func_elem_639_1(arg0, arg1, arg2);
+}
+function __wasm_bindgen_func_elem_639_2(arg0, arg1, arg2) {
+  wasm.__wasm_bindgen_func_elem_639_2(arg0, arg1, arg2);
+}
+function __wasm_bindgen_func_elem_639_3(arg0, arg1, arg2) {
+  wasm.__wasm_bindgen_func_elem_639_3(arg0, arg1, arg2);
+}
+function __wasm_bindgen_func_elem_1652(arg0, arg1, arg2) {
+  const ret = wasm.__wasm_bindgen_func_elem_1652(arg0, arg1, arg2);
+  if (ret[1]) {
+    throw takeFromExternrefTable0(ret[0]);
+  }
+}
+function __wasm_bindgen_func_elem_1652_195(arg0, arg1, arg2, arg3) {
+  wasm.__wasm_bindgen_func_elem_1652_195(arg0, arg1, arg2, arg3);
+}
+function __wasm_bindgen_func_elem_1652_196(arg0, arg1, arg2, arg3) {
+  wasm.__wasm_bindgen_func_elem_1652_196(arg0, arg1, arg2, arg3);
+}
+var __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
+var __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
+var __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+var MemorySignerFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_memorysigner_free(ptr >>> 0, 1));
+var MemoryStorageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_memorystorage_free(ptr >>> 0, 1));
+var PeerBatchSyncResultFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_peerbatchsyncresult_free(ptr >>> 0, 1));
+var AuthenticatedLongPollFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_authenticatedlongpoll_free(ptr >>> 0, 1));
+var AuthenticatedTransportFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_authenticatedtransport_free(ptr >>> 0, 1));
+var AuthenticatedWebSocketFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_authenticatedwebsocket_free(ptr >>> 0, 1));
+var BatchSyncRequestFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_batchsyncrequest_free(ptr >>> 0, 1));
+var BatchSyncResponseFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_batchsyncresponse_free(ptr >>> 0, 1));
+var BlobMetaFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_blobmeta_free(ptr >>> 0, 1));
+var CallErrorFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_callerror_free(ptr >>> 0, 1));
+var CommitWithBlobFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_commitwithblob_free(ptr >>> 0, 1));
+var DepthFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_depth_free(ptr >>> 0, 1));
+var DigestFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_digest_free(ptr >>> 0, 1));
+var FragmentFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_fragment_free(ptr >>> 0, 1));
+var FragmentRequestedFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_fragmentrequested_free(ptr >>> 0, 1));
+var FragmentWithBlobFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_fragmentwithblob_free(ptr >>> 0, 1));
+var FragmentsArrayFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_fragmentsarray_free(ptr >>> 0, 1));
+var HashMetricFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_hashmetric_free(ptr >>> 0, 1));
+var SubductionHttpLongPollFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_subductionhttplongpoll_free(ptr >>> 0, 1));
+var SubductionLongPollFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_subductionlongpoll_free(ptr >>> 0, 1));
+var LooseCommitFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_loosecommit_free(ptr >>> 0, 1));
+var SyncMessageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_syncmessage_free(ptr >>> 0, 1));
+var MessagePortTransportFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_messageporttransport_free(ptr >>> 0, 1));
+var NonceFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_nonce_free(ptr >>> 0, 1));
+var PeerIdFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_peerid_free(ptr >>> 0, 1));
+var PeerResultMapFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_peerresultmap_free(ptr >>> 0, 1));
+var RequestIdFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_requestid_free(ptr >>> 0, 1));
+var SedimentreeFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_sedimentree_free(ptr >>> 0, 1));
+var SedimentreeIdFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_sedimentreeid_free(ptr >>> 0, 1));
+var SedimentreeIdsArrayFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_sedimentreeidsarray_free(ptr >>> 0, 1));
+var SignedFragmentFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_signedfragment_free(ptr >>> 0, 1));
+var SignedLooseCommitFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_signedloosecommit_free(ptr >>> 0, 1));
+var SubductionFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_subduction_free(ptr >>> 0, 1));
+var SyncStatsFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_syncstats_free(ptr >>> 0, 1));
+var TopicFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_topic_free(ptr >>> 0, 1));
+var SubductionWebSocketFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_subductionwebsocket_free(ptr >>> 0, 1));
+var WebCryptoSignerFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_webcryptosigner_free(ptr >>> 0, 1));
+function addToExternrefTable0(obj) {
+  const idx = wasm.__wbindgen_export4();
+  wasm.__wbindgen_externrefs.set(idx, obj);
+  return idx;
+}
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+var CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((state) => state.dtor(state.a, state.b));
+function debugString(val) {
+  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";
+    }
+  }
+  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;
+  }
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}
+${val.stack}`;
+  }
+  return className;
+}
+function getArrayJsValueFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  const mem = getDataViewMemory0();
+  const result = [];
+  for (let i = ptr; i < ptr + 4 * len; i += 4) {
+    result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+  }
+  wasm.__wbindgen_export6(ptr, len);
+  return result;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_export3(idx);
+  }
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function makeClosure(arg0, arg1, dtor, f) {
+  const state = { a: arg0, b: arg1, cnt: 1, dtor };
+  const real = (...args) => {
+    state.cnt++;
+    try {
+      return f(state.a, state.b, ...args);
+    } finally {
+      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 makeMutClosure(arg0, arg1, dtor, f) {
+  const state = { a: arg0, b: arg1, cnt: 1, dtor };
+  const real = (...args) => {
+    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;
+  for (let i = 0; i < array.length; i++) {
+    const add = addToExternrefTable0(array[i]);
+    getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+  }
+  WASM_VECTOR_LEN = array.length;
+  return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  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 > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__wbindgen_export7(idx);
+  return value;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var 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));
+}
+var 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
+    };
+  };
+}
+var WASM_VECTOR_LEN = 0;
+var wasmModule;
+var wasm;
+function __wbg_finalize_init(instance, module2) {
+  wasm = instance.exports;
+  wasmModule = module2;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+async function __wbg_load(module2, imports) {
+  if (typeof Response === "function" && module2 instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module2, imports);
+      } catch (e) {
+        const validResponse = module2.ok && expectedResponseType(module2.type);
+        if (validResponse && module2.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 module2.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module2, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module: module2 };
+    } else {
+      return instance;
+    }
+  }
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+function initSync(module2) {
+  if (wasm !== void 0) return wasm;
+  if (module2 !== void 0) {
+    if (Object.getPrototypeOf(module2) === Object.prototype) {
+      ({ module: module2 } = module2);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  if (!(module2 instanceof WebAssembly.Module)) {
+    module2 = new WebAssembly.Module(module2);
+  }
+  const instance = new WebAssembly.Instance(module2, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (module_or_path !== void 0) {
+    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 === void 0) {
+    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: module2 } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+function __wbg_set_wasm(val) {
+  wasm = val;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticatedLongPoll,
+  AuthenticatedTransport,
+  AuthenticatedWebSocket,
+  BatchSyncRequest,
+  BatchSyncResponse,
+  BlobMeta,
+  CallError,
+  CommitWithBlob,
+  Depth,
+  Digest,
+  Fragment,
+  FragmentRequested,
+  FragmentWithBlob,
+  FragmentsArray,
+  HashMetric,
+  LooseCommit,
+  MemorySigner,
+  MemoryStorage,
+  MessagePortTransport,
+  Nonce,
+  PeerBatchSyncResult,
+  PeerId,
+  PeerResultMap,
+  RequestId,
+  Sedimentree,
+  SedimentreeId,
+  SedimentreeIdsArray,
+  SignedFragment,
+  SignedLooseCommit,
+  Subduction,
+  SubductionHttpLongPoll,
+  SubductionLongPoll,
+  SubductionWebSocket,
+  SyncMessage,
+  SyncStats,
+  Topic,
+  WebCryptoSigner,
+  __wbg_set_wasm,
+  initSync,
+  makeMessagePortTransport,
+  start
+});