@automerge/subduction 0.7.0-alpha.1 → 0.8.1

package/dist/wasm_bindgen/bundler/subduction_wasm_bg.js

@@ -1,53 +1,115 @@
 import { tryIntoJsSedimentreeIdsArray } from './snippets/sedimentree_wasm-68c0499598a3382c/inline2.js';
 
 /**
- * A transport-erased authenticated connection.
+ * An authenticated HTTP long-poll transport.
  *
- * Wraps an [`Authenticated<JsConnection>`] and is the common type
+ * This wrapper proves that the transport has completed the Subduction handshake
+ * and the peer identity has been cryptographically verified.
+ *
+ * Obtain via [`SubductionLongPoll::tryConnect`] or [`SubductionLongPoll::tryDiscover`].
+ */
+export class AuthenticatedLongPoll {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AuthenticatedLongPoll.prototype);
+        obj.__wbg_ptr = ptr;
+        AuthenticatedLongPollFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AuthenticatedLongPollFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_authenticatedlongpoll_free(ptr, 0);
+    }
+    /**
+     * The verified peer identity.
+     * @returns {PeerId}
+     */
+    get peerId() {
+        const ret = wasm.authenticatedlongpoll_peerId(this.__wbg_ptr);
+        return PeerId.__wrap(ret);
+    }
+    /**
+     * The session ID assigned by the server.
+     * @returns {string}
+     */
+    get sessionId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const 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;
+
+/**
+ * A transport-erased authenticated transport.
+ *
+ * Wraps an [`Authenticated<MessageTransport<JsTransport>>`] and is the common type
  * accepted by [`addConnection`](crate::subduction::WasmSubduction::add_connection).
  *
  * # Construction
  *
- * There are three ways to obtain an `AuthenticatedConnection`:
+ * There are three ways to obtain an `AuthenticatedTransport`:
  *
- * 1. **Custom transport** — implement [`HandshakeConnection`](handshake::JsHandshakeConnection)
- *    (extends `Connection` with `sendBytes`/`recvBytes`) and call [`setup`](Self::setup):
+ * 1. **Custom transport** — implement the `Transport` interface
+ *    (`sendBytes`/`recvBytes`/`disconnect`) and call [`setup`](Self::setup):
  *
  *    ```js
- *    const auth = await AuthenticatedConnection.setup(myConn, signer, peerId);
+ *    const auth = await AuthenticatedTransport.setup(myTransport, signer, peerId);
  *    ```
  *
  * 2. **From WebSocket** — authenticate via [`SubductionWebSocket`] then convert:
  *
  *    ```js
  *    const wsAuth = await SubductionWebSocket.tryConnect(url, signer, peerId, timeout);
- *    const auth = wsAuth.toConnection();
+ *    const auth = wsAuth.toTransport();
  *    ```
  *
  * 3. **From HTTP long-poll** — same pattern via [`SubductionLongPoll`]:
  *
  *    ```js
  *    const lpAuth = await SubductionLongPoll.tryConnect(url, signer, peerId, timeout);
- *    const auth = lpAuth.toConnection();
+ *    const auth = lpAuth.toTransport();
  *    ```
  */
-export class AuthenticatedConnection {
+export class AuthenticatedTransport {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(AuthenticatedConnection.prototype);
+        const obj = Object.create(AuthenticatedTransport.prototype);
         obj.__wbg_ptr = ptr;
-        AuthenticatedConnectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        AuthenticatedTransportFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        AuthenticatedConnectionFinalization.unregister(this);
+        AuthenticatedTransportFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_authenticatedconnection_free(ptr, 0);
+        wasm.__wbg_authenticatedtransport_free(ptr, 0);
     }
     /**
      * Accept an incoming handshake over a custom transport (responder side).
@@ -57,20 +119,20 @@ export class AuthenticatedConnection {
      *
      * # Arguments
      *
-     * * `connection` - A `HandshakeConnection` (extends `Connection`)
+     * * `transport` - A `Transport` implementing `sendBytes`/`recvBytes`/`disconnect`
      * * `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 {HandshakeConnection} connection
+     * @param {Transport} transport
      * @param {any} signer
      * @param {number | null} [max_drift_seconds]
-     * @returns {Promise<AuthenticatedConnection>}
+     * @returns {Promise<AuthenticatedTransport>}
      */
-    static accept(connection, signer, max_drift_seconds) {
-        const ret = wasm.authenticatedconnection_accept(connection, signer, isLikeNone(max_drift_seconds) ? 0x100000001 : (max_drift_seconds) >>> 0);
+    static accept(transport, signer, max_drift_seconds) {
+        const ret = wasm.authenticatedtransport_accept(transport, signer, isLikeNone(max_drift_seconds) ? 0x100000001 : (max_drift_seconds) >>> 0);
         return ret;
     }
     /**
@@ -78,103 +140,71 @@ export class AuthenticatedConnection {
      * @returns {PeerId}
      */
     get peerId() {
-        const ret = wasm.authenticatedconnection_peerId(this.__wbg_ptr);
+        const ret = wasm.authenticatedtransport_peerId(this.__wbg_ptr);
         return PeerId.__wrap(ret);
     }
     /**
      * Run the Subduction handshake over a custom transport, producing an
-     * authenticated connection.
+     * authenticated transport.
      *
-     * The `connection` object must implement both `HandshakeConnection`
-     * (for the handshake phase) and `Connection` (for post-handshake
-     * communication). The same object is used for both phases.
+     * The `transport` object must implement the `Transport` interface
+     * (`sendBytes`/`recvBytes`/`disconnect`).
+     * The same object is used for both the handshake phase and post-handshake
+     * communication.
      *
      * # Arguments
      *
-     * * `connection` - A `HandshakeConnection` (extends `Connection`)
+     * * `transport` - A `Transport` implementing `sendBytes`/`recvBytes`/`disconnect`
      * * `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 {HandshakeConnection} connection
+     * @param {Transport} transport
      * @param {any} signer
      * @param {PeerId} expected_peer_id
-     * @returns {Promise<AuthenticatedConnection>}
+     * @returns {Promise<AuthenticatedTransport>}
      */
-    static setup(connection, signer, expected_peer_id) {
+    static setup(transport, signer, expected_peer_id) {
         _assertClass(expected_peer_id, PeerId);
-        const ret = wasm.authenticatedconnection_setup(connection, signer, expected_peer_id.__wbg_ptr);
+        const ret = wasm.authenticatedtransport_setup(transport, signer, expected_peer_id.__wbg_ptr);
         return ret;
     }
-}
-if (Symbol.dispose) AuthenticatedConnection.prototype[Symbol.dispose] = AuthenticatedConnection.prototype.free;
-
-/**
- * An authenticated HTTP long-poll connection.
- *
- * This wrapper proves that the connection has completed the Subduction handshake
- * and the peer identity has been cryptographically verified.
- *
- * Obtain via [`SubductionLongPoll::tryConnect`] or [`SubductionLongPoll::tryDiscover`].
- */
-export class AuthenticatedLongPoll {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(AuthenticatedLongPoll.prototype);
-        obj.__wbg_ptr = ptr;
-        AuthenticatedLongPollFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        AuthenticatedLongPollFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_authenticatedlongpoll_free(ptr, 0);
-    }
-    /**
-     * The verified peer identity.
-     * @returns {PeerId}
-     */
-    get peerId() {
-        const ret = wasm.authenticatedlongpoll_peerId(this.__wbg_ptr);
-        return PeerId.__wrap(ret);
-    }
-    /**
-     * The session ID assigned by the server.
-     * @returns {string}
-     */
-    get sessionId() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const 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 [`AuthenticatedConnection`](super::WasmAuthenticatedConnection).
-     * @returns {AuthenticatedConnection}
+     * 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`
+     * * `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]
+     * @returns {Promise<AuthenticatedTransport>}
      */
-    toConnection() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.authenticatedlongpoll_toConnection(ptr);
-        return AuthenticatedConnection.__wrap(ret);
+    static setupDiscover(transport, signer, 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.authenticatedtransport_setupDiscover(transport, signer, ptr0, len0);
+        return ret;
     }
 }
-if (Symbol.dispose) AuthenticatedLongPoll.prototype[Symbol.dispose] = AuthenticatedLongPoll.prototype.free;
+if (Symbol.dispose) AuthenticatedTransport.prototype[Symbol.dispose] = AuthenticatedTransport.prototype.free;
 
 /**
- * An authenticated WebSocket connection.
+ * An authenticated WebSocket transport.
  *
  * This wrapper proves that the connection has completed the Subduction handshake
  * and the peer identity has been cryptographically verified.
@@ -209,13 +239,13 @@ export class AuthenticatedWebSocket {
         return PeerId.__wrap(ret);
     }
     /**
-     * Convert to a transport-erased [`AuthenticatedConnection`](super::WasmAuthenticatedConnection).
-     * @returns {AuthenticatedConnection}
+     * Convert to a transport-erased [`AuthenticatedTransport`](super::WasmAuthenticatedTransport).
+     * @returns {AuthenticatedTransport}
      */
-    toConnection() {
+    toTransport() {
         const ptr = this.__destroy_into_raw();
-        const ret = wasm.authenticatedwebsocket_toConnection(ptr);
-        return AuthenticatedConnection.__wrap(ret);
+        const ret = wasm.authenticatedwebsocket_toTransport(ptr);
+        return AuthenticatedTransport.__wrap(ret);
     }
 }
 if (Symbol.dispose) AuthenticatedWebSocket.prototype[Symbol.dispose] = AuthenticatedWebSocket.prototype.free;
@@ -460,63 +490,6 @@ export class CommitWithBlob {
 }
 if (Symbol.dispose) CommitWithBlob.prototype[Symbol.dispose] = CommitWithBlob.prototype.free;
 
-/**
- * A pair of a connection and an error that occurred during a call.
- */
-export class ConnErrorPair {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(ConnErrorPair.prototype);
-        obj.__wbg_ptr = ptr;
-        ConnErrorPairFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ConnErrorPairFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_connerrorpair_free(ptr, 0);
-    }
-    /**
-     * The connection that encountered the error.
-     * @returns {Connection}
-     */
-    get conn() {
-        const ret = wasm.connerrorpair_conn(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * The error that occurred during the call.
-     * @returns {Error}
-     */
-    get err() {
-        const ret = wasm.connerrorpair_err(this.__wbg_ptr);
-        return ret;
-    }
-}
-if (Symbol.dispose) ConnErrorPair.prototype[Symbol.dispose] = ConnErrorPair.prototype.free;
-
-/**
- * A Wasm wrapper around the Rust `ConnectionId` type.
- */
-export class ConnectionId {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ConnectionIdFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_connectionid_free(ptr, 0);
-    }
-}
-if (Symbol.dispose) ConnectionId.prototype[Symbol.dispose] = ConnectionId.prototype.free;
-
 /**
  * A JavaScript wrapper around `Depth`.
  */
@@ -1360,366 +1333,128 @@ export class MemoryStorage {
 if (Symbol.dispose) MemoryStorage.prototype[Symbol.dispose] = MemoryStorage.prototype.free;
 
 /**
- * Wasm wrapper for [`Message`].
+ * A `Transport` backed by a `MessagePort` (or any object with
+ * `postMessage` / `onmessage` / `close`).
+ *
+ * Implements the byte-oriented `Transport` interface (`sendBytes`,
+ * `recvBytes`, `disconnect`) using the port as the underlying channel.
+ * After the handshake, the [`Authenticated`] wrapper provides the sync API.
  */
-export class Message {
+export class MessagePortTransport {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Message.prototype);
+        const obj = Object.create(MessagePortTransport.prototype);
         obj.__wbg_ptr = ptr;
-        MessageFinalization.register(obj, obj.__wbg_ptr, obj);
+        MessagePortTransportFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MessageFinalization.unregister(this);
+        MessagePortTransportFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_message_free(ptr, 0);
+        wasm.__wbg_messageporttransport_free(ptr, 0);
     }
     /**
-     * Upcasts; to the JS-import type for [`WasmMessage`].
-     * @returns {Message}
+     * Disconnect (close the port).
+     * @returns {Promise<any>}
      */
-    __wasm_refgen_toWasmMessage() {
-        const ret = wasm.message___wasm_refgen_toWasmMessage(this.__wbg_ptr);
-        return Message.__wrap(ret);
+    disconnect() {
+        const ret = wasm.messageporttransport_disconnect(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Create a [`Message::BatchSyncRequest`] message.
-     * @param {BatchSyncRequest} request
-     * @returns {Message}
+     * Create a new connection wrapping the given `MessagePort`.
+     * @param {any} port
      */
-    static batchSyncRequest(request) {
-        _assertClass(request, BatchSyncRequest);
-        const ret = wasm.message_batchSyncRequest(request.__wbg_ptr);
-        return Message.__wrap(ret);
+    constructor(port) {
+        const ret = wasm.messageporttransport_new(port);
+        this.__wbg_ptr = ret >>> 0;
+        MessagePortTransportFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Create a [`Message::BatchSyncResponse`] message.
-     * @param {BatchSyncResponse} response
-     * @returns {Message}
+     * Receive raw bytes (for the handshake phase).
+     * @returns {Promise<any>}
      */
-    static batchSyncResponse(response) {
-        _assertClass(response, BatchSyncResponse);
-        const ret = wasm.message_batchSyncResponse(response.__wbg_ptr);
-        return Message.__wrap(ret);
+    recvBytes() {
+        const ret = wasm.messageporttransport_recvBytes(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * The [`Blob`] for commit or fragment messages, if applicable.
-     * @returns {Uint8Array | undefined}
+     * Send raw bytes (for the handshake phase).
+     * @param {Uint8Array} bytes
+     * @returns {Promise<any>}
      */
-    get blob() {
-        const ret = wasm.message_blob(this.__wbg_ptr);
+    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;
+
+/**
+ * A 64-bit nonce represented as big-endian bytes.
+ */
+export class Nonce {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Nonce.prototype);
+        obj.__wbg_ptr = ptr;
+        NonceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NonceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_nonce_free(ptr, 0);
+    }
     /**
-     * The [`Blob`]s for a [`Message::BlobsResponse`], if applicable.
-     * @returns {Uint8Array[] | undefined}
+     * Get the nonce as big-endian bytes.
+     * @returns {Uint8Array}
      */
-    get blobs() {
-        const ret = wasm.message_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);
-        }
+    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 [`Message::BlobsRequest`] message.
-     * @param {SedimentreeId} id
-     * @param {Digest[]} digests
-     * @returns {Message}
+     * Create a new [`WasmNonce`] from exactly 8 big-endian bytes.
+     *
+     * # Errors
+     *
+     * Returns [`WasmNonceError`] if the input is not exactly 8 bytes.
+     * @param {Uint8Array} bytes
      */
-    static blobsRequest(id, digests) {
-        _assertClass(id, SedimentreeId);
-        const ptr0 = passArrayJsValueToWasm0(digests, wasm.__wbindgen_export);
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.message_blobsRequest(id.__wbg_ptr, ptr0, len0);
-        return Message.__wrap(ret);
+        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;
     }
     /**
-     * Create a [`Message::BlobsResponse`] message.
-     * @param {SedimentreeId} id
-     * @param {Uint8Array[]} blobs
-     * @returns {Message}
-     */
-    static blobsResponse(id, blobs) {
-        _assertClass(id, SedimentreeId);
-        const ptr0 = passArrayJsValueToWasm0(blobs, wasm.__wbindgen_export);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.message_blobsResponse(id.__wbg_ptr, ptr0, len0);
-        return Message.__wrap(ret);
-    }
-    /**
-     * The [`LooseCommit`] for a [`Message::LooseCommit`], if applicable.
-     *
-     * Decodes the signed payload to extract the underlying commit.
-     * @returns {LooseCommit | undefined}
-     */
-    get commit() {
-        const ret = wasm.message_commit(this.__wbg_ptr);
-        return ret === 0 ? undefined : LooseCommit.__wrap(ret);
-    }
-    /**
-     * The requested [`Digest`]s for a [`Message::BlobsRequest`], if applicable.
-     * @returns {Digest[] | undefined}
-     */
-    get digests() {
-        const ret = wasm.message_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 [`Message::Fragment`], if applicable.
-     *
-     * Decodes the signed payload to extract the underlying fragment.
-     * @returns {Fragment | undefined}
-     */
-    get fragment() {
-        const ret = wasm.message_fragment(this.__wbg_ptr);
-        return ret === 0 ? undefined : Fragment.__wrap(ret);
-    }
-    /**
-     * Deserialize a message from bytes.
-     *
-     * # Errors
-     *
-     * Returns a [`JsMessageDeserializationError`] if deserialization fails.
-     * @param {Uint8Array} bytes
-     * @returns {Message}
-     */
-    static fromBytes(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.message_fromBytes(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Message.__wrap(ret[0]);
-    }
-    /**
-     * The [`BatchSyncRequest`] for a [`Message::BatchSyncRequest`], if applicable.
-     * @returns {BatchSyncRequest | undefined}
-     */
-    get request() {
-        const ret = wasm.message_request(this.__wbg_ptr);
-        return ret === 0 ? undefined : BatchSyncRequest.__wrap(ret);
-    }
-    /**
-     * The [`BatchSyncResponse`] for a [`Message::BatchSyncResponse`], if applicable.
-     * @returns {BatchSyncResponse | undefined}
-     */
-    get response() {
-        const ret = wasm.message_response(this.__wbg_ptr);
-        return ret === 0 ? undefined : BatchSyncResponse.__wrap(ret);
-    }
-    /**
-     * The [`SedimentreeId`] associated with this message, if any.
-     * @returns {SedimentreeId | undefined}
-     */
-    get sedimentreeId() {
-        const ret = wasm.message_sedimentreeId(this.__wbg_ptr);
-        return ret === 0 ? undefined : SedimentreeId.__wrap(ret);
-    }
-    /**
-     * Serialize the message to bytes.
-     * @returns {Uint8Array}
-     */
-    toBytes() {
-        const ret = wasm.message_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.message_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) Message.prototype[Symbol.dispose] = Message.prototype.free;
-
-/**
- * A [`HandshakeConnection`] backed by a `MessagePort` (or any object with
- * `postMessage` / `onmessage` / `close`).
- *
- * Implements the full `HandshakeConnection` interface (`sendBytes`,
- * `recvBytes`, `send`, `recv`, `disconnect`) using the port for transport.
- *
- * `nextRequestId` and `call` return rejected promises — `MessagePort`
- * connections are used for peer-to-peer handshakes, not RPC-style sync.
- * After the handshake, the [`Authenticated`] wrapper provides the sync API.
- */
-export class MessagePortConnection {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(MessagePortConnection.prototype);
-        obj.__wbg_ptr = ptr;
-        MessagePortConnectionFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        MessagePortConnectionFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_messageportconnection_free(ptr, 0);
-    }
-    /**
-     * Not supported on `MessagePort` connections.
-     * @param {any} _request
-     * @param {number | null} [_timeout_ms]
-     * @returns {Promise<any>}
-     */
-    call(_request, _timeout_ms) {
-        const ret = wasm.messageportconnection_call(this.__wbg_ptr, _request, !isLikeNone(_timeout_ms), isLikeNone(_timeout_ms) ? 0 : _timeout_ms);
-        return ret;
-    }
-    /**
-     * Disconnect (close the port).
-     * @returns {Promise<any>}
-     */
-    disconnect() {
-        const ret = wasm.messageportconnection_disconnect(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Create a new connection wrapping the given `MessagePort`.
-     * @param {any} port
-     */
-    constructor(port) {
-        const ret = wasm.messageportconnection_new(port);
-        this.__wbg_ptr = ret >>> 0;
-        MessagePortConnectionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Not supported on `MessagePort` connections.
-     * @returns {Promise<any>}
-     */
-    nextRequestId() {
-        const ret = wasm.messageportconnection_nextRequestId(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Receive the next message.
-     * @returns {Promise<any>}
-     */
-    recv() {
-        const ret = wasm.messageportconnection_recv(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Receive raw bytes (for the handshake phase).
-     * @returns {Promise<any>}
-     */
-    recvBytes() {
-        const ret = wasm.messageportconnection_recvBytes(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Send a structured message (post-handshake).
-     * @param {any} message
-     * @returns {Promise<any>}
-     */
-    send(message) {
-        const ret = wasm.messageportconnection_send(this.__wbg_ptr, message);
-        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.messageportconnection_sendBytes(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
-}
-if (Symbol.dispose) MessagePortConnection.prototype[Symbol.dispose] = MessagePortConnection.prototype.free;
-
-/**
- * A 64-bit nonce represented as big-endian bytes.
- */
-export class Nonce {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Nonce.prototype);
-        obj.__wbg_ptr = ptr;
-        NonceFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NonceFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_nonce_free(ptr, 0);
-    }
-    /**
-     * Get the nonce as big-endian bytes.
-     * @returns {Uint8Array}
-     */
-    get bytes() {
-        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}
+     * Generate a random nonce.
+     *
+     * # Panics
+     *
+     * Panics if the system random number generator fails.
+     * @returns {Nonce}
      */
     static random() {
         const ret = wasm.nonce_random();
@@ -1749,16 +1484,6 @@ export class PeerBatchSyncResult {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_peerbatchsyncresult_free(ptr, 0);
     }
-    /**
-     * List of connection errors that occurred during the batch sync.
-     * @returns {ConnErrorPair[]}
-     */
-    get connErrors() {
-        const ret = wasm.peerbatchsyncresult_connErrors(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_export5(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
     /**
      * Statistics about the sync operation.
      * @returns {SyncStats}
@@ -1775,6 +1500,16 @@ export class PeerBatchSyncResult {
         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;
 
@@ -2273,6 +2008,30 @@ export class Subduction {
         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.
      *
@@ -2295,15 +2054,15 @@ export class Subduction {
         return ret;
     }
     /**
-     * Onboard an authenticated connection: add it and sync all sedimentrees.
+     * Onboard an authenticated transport: add it and sync all sedimentrees.
      *
-     * Accepts an [`AuthenticatedConnection`](WasmAuthenticatedConnection),
-     * obtained via [`AuthenticatedConnection.setup`](WasmAuthenticatedConnection::setup),
-     * [`AuthenticatedWebSocket.toConnection`], or [`AuthenticatedLongPoll.toConnection`].
+     * 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 connection to tracking.
+     * Add an authenticated transport to tracking.
      *
      * This does not perform any synchronization. To sync after adding,
      * call [`fullSyncWithPeer`](Self::full_sync_with_peer).
@@ -2313,12 +2072,12 @@ export class Subduction {
      * # Errors
      *
      * Returns an error if the connection is rejected by the policy.
-     * @param {AuthenticatedConnection} conn
+     * @param {AuthenticatedTransport} transport
      * @returns {Promise<boolean>}
      */
-    addConnection(conn) {
-        _assertClass(conn, AuthenticatedConnection);
-        const ret = wasm.subduction_addConnection(this.__wbg_ptr, conn.__wbg_ptr);
+    addConnection(transport) {
+        _assertClass(transport, AuthenticatedTransport);
+        const ret = wasm.subduction_addConnection(this.__wbg_ptr, transport.__wbg_ptr);
         return ret;
     }
     /**
@@ -2378,19 +2137,17 @@ export class Subduction {
      *
      * * `address` - The WebSocket URL to connect to
      * * `expected_peer_id` - The expected server peer ID (verified during handshake)
-     * * `timeout_milliseconds` - Request timeout in milliseconds
      *
      * # Errors
      *
      * Returns an error if connection, handshake, or adding the connection fails.
      * @param {URL} address
      * @param {PeerId} expected_peer_id
-     * @param {number} timeout_milliseconds
      * @returns {Promise<PeerId>}
      */
-    connect(address, expected_peer_id, timeout_milliseconds) {
+    connect(address, expected_peer_id) {
         _assertClass(expected_peer_id, PeerId);
-        const ret = wasm.subduction_connect(this.__wbg_ptr, address, expected_peer_id.__wbg_ptr, timeout_milliseconds);
+        const ret = wasm.subduction_connect(this.__wbg_ptr, address, expected_peer_id.__wbg_ptr);
         return ret;
     }
     /**
@@ -2408,14 +2165,13 @@ export class Subduction {
      *
      * Returns an error if connection, handshake, or adding the connection fails.
      * @param {URL} address
-     * @param {number | null} [timeout_milliseconds]
      * @param {string | null} [service_name]
      * @returns {Promise<PeerId>}
      */
-    connectDiscover(address, timeout_milliseconds, service_name) {
+    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, isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0, ptr0, len0);
+        const ret = wasm.subduction_connectDiscover(this.__wbg_ptr, address, ptr0, len0);
         return ret;
     }
     /**
@@ -2433,16 +2189,15 @@ export class Subduction {
      *
      * Returns an error if connection, handshake, or adding the connection fails.
      * @param {string} base_url
-     * @param {number | null} [timeout_milliseconds]
      * @param {string | null} [service_name]
      * @returns {Promise<PeerId>}
      */
-    connectDiscoverLongPoll(base_url, timeout_milliseconds, service_name) {
+    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, isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0, ptr1, len1);
+        const ret = wasm.subduction_connectDiscoverLongPoll(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
     /**
@@ -2461,14 +2216,37 @@ export class Subduction {
      * Returns an error if connection, handshake, or adding the connection fails.
      * @param {string} base_url
      * @param {PeerId} expected_peer_id
-     * @param {number | null} [timeout_milliseconds]
      * @returns {Promise<PeerId>}
      */
-    connectLongPoll(base_url, expected_peer_id, timeout_milliseconds) {
+    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, isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0);
+        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;
     }
     /**
@@ -2633,6 +2411,27 @@ export class Subduction {
         const ret = wasm.subduction_hydrate(signer, storage, ptr0, len0, isLikeNone(hash_metric_override) ? 0 : addToExternrefTable0(hash_metric_override), isLikeNone(max_pending_blob_requests) ? 0x100000001 : (max_pending_blob_requests) >>> 0);
         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.
      *
@@ -2757,7 +2556,73 @@ export class Subduction {
 if (Symbol.dispose) Subduction.prototype[Symbol.dispose] = Subduction.prototype.free;
 
 /**
- * HTTP long-poll connection factory for browser/worker environments.
+ * JS-facing wrapper around [`HttpLongPollTransport`] that exposes the
+ * byte-oriented [`Transport`](super::JsTransport) interface
+ * (`sendBytes`/`recvBytes`/`disconnect`) so it can be used as a
+ * duck-typed `JsTransport` from JavaScript.
+ */
+export 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.
+     *
+     * # Errors
+     *
+     * Returns an error if the disconnect fails.
+     * @returns {Promise<void>}
+     */
+    disconnect() {
+        const ret = wasm.subductionhttplongpoll_disconnect(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * 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;
+
+/**
+ * HTTP long-poll transport factory for browser/worker environments.
  *
  * Analogous to [`SubductionWebSocket`] but uses HTTP long-poll instead of WebSocket.
  */
@@ -2784,18 +2649,17 @@ export class SubductionLongPoll {
      *
      * # Errors
      *
-     * Returns [`LongPollConnectionError`] if connection or handshake fails.
+     * Returns [`LongPollTransportError`] if connection or handshake fails.
      * @param {string} base_url
      * @param {any} signer
      * @param {PeerId} expected_peer_id
-     * @param {number | null} [timeout_milliseconds]
      * @returns {Promise<AuthenticatedLongPoll>}
      */
-    static tryConnect(base_url, signer, expected_peer_id, timeout_milliseconds) {
+    static tryConnect(base_url, signer, 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.subductionlongpoll_tryConnect(ptr0, len0, signer, expected_peer_id.__wbg_ptr, isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0);
+        const ret = wasm.subductionlongpoll_tryConnect(ptr0, len0, signer, expected_peer_id.__wbg_ptr);
         return ret;
     }
     /**
@@ -2805,120 +2669,34 @@ export class SubductionLongPoll {
      *
      * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
      * * `signer` - The client's signer for authentication
-     * * `timeout_milliseconds` - Request timeout in milliseconds (default: 30000)
      * * `service_name` - The service name for discovery. If omitted, the base URL is used.
      *
      * # Errors
      *
-     * Returns [`LongPollConnectionError`] if connection or handshake fails.
+     * Returns [`LongPollTransportError`] if connection or handshake fails.
      * @param {string} base_url
      * @param {any} signer
-     * @param {number | null} [timeout_milliseconds]
      * @param {string | null} [service_name]
      * @returns {Promise<AuthenticatedLongPoll>}
      */
-    static tryDiscover(base_url, signer, timeout_milliseconds, service_name) {
+    static tryDiscover(base_url, signer, service_name) {
         const ptr0 = passStringToWasm0(base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
         var ptr1 = isLikeNone(service_name) ? 0 : passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        var len1 = WASM_VECTOR_LEN;
-        const ret = wasm.subductionlongpoll_tryDiscover(ptr0, len0, signer, isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0, ptr1, len1);
-        return ret;
-    }
-}
-if (Symbol.dispose) SubductionLongPoll.prototype[Symbol.dispose] = SubductionLongPoll.prototype.free;
-
-/**
- * JS-facing wrapper around [`WasmLongPollConnection`] that exposes the
- * [`Connection`](super::JsConnection) interface so it can be used as a
- * duck-typed `JsConnection` from JavaScript.
- */
-export class SubductionLongPollConnection {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(SubductionLongPollConnection.prototype);
-        obj.__wbg_ptr = ptr;
-        SubductionLongPollConnectionFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SubductionLongPollConnectionFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_subductionlongpollconnection_free(ptr, 0);
-    }
-    /**
-     * Make a synchronous call to the peer.
-     *
-     * # Errors
-     *
-     * Returns an error if the call fails or times out.
-     * @param {BatchSyncRequest} request
-     * @param {number | null} [timeout_ms]
-     * @returns {Promise<BatchSyncResponse>}
-     */
-    call(request, timeout_ms) {
-        _assertClass(request, BatchSyncRequest);
-        var ptr0 = request.__destroy_into_raw();
-        const ret = wasm.subductionlongpollconnection_call(this.__wbg_ptr, ptr0, !isLikeNone(timeout_ms), isLikeNone(timeout_ms) ? 0 : timeout_ms);
-        return ret;
-    }
-    /**
-     * Disconnect from the peer gracefully.
-     *
-     * # Errors
-     *
-     * Returns [`WasmLongPollConnError`] if the disconnect fails.
-     * @returns {Promise<void>}
-     */
-    disconnect() {
-        const ret = wasm.subductionlongpollconnection_disconnect(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Get the next request ID.
-     * @returns {Promise<RequestId>}
-     */
-    nextRequestId() {
-        const ret = wasm.subductionlongpollconnection_nextRequestId(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Receive a message.
-     *
-     * # Errors
-     *
-     * Returns an error if the inbound channel is closed.
-     * @returns {Promise<Message>}
-     */
-    recv() {
-        const ret = wasm.subductionlongpollconnection_recv(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Send a message.
-     *
-     * # Errors
-     *
-     * Returns an error if the outbound channel is closed.
-     * @param {Message} message
-     * @returns {Promise<void>}
-     */
-    send(message) {
-        _assertClass(message, Message);
-        var ptr0 = message.__destroy_into_raw();
-        const ret = wasm.subductionlongpollconnection_send(this.__wbg_ptr, ptr0);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.subductionlongpoll_tryDiscover(ptr0, len0, signer, ptr1, len1);
         return ret;
     }
 }
-if (Symbol.dispose) SubductionLongPollConnection.prototype[Symbol.dispose] = SubductionLongPollConnection.prototype.free;
+if (Symbol.dispose) SubductionLongPoll.prototype[Symbol.dispose] = SubductionLongPoll.prototype.free;
 
 /**
- * A WebSocket connection with internal wiring for [`Subduction`] message handling.
+ * A WebSocket transport exposing the byte-oriented `Transport` interface.
+ *
+ * Raw bytes from the WebSocket's `onmessage` handler are buffered in an
+ * `async_channel` and returned via `recvBytes`. No message decoding or
+ * request-response routing happens here — that's handled by
+ * [`MessageTransport`](subduction_core::transport::message::MessageTransport).
  */
 export class SubductionWebSocket {
     static __wrap(ptr) {
@@ -2938,22 +2716,6 @@ export class SubductionWebSocket {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_subductionwebsocket_free(ptr, 0);
     }
-    /**
-     * Make a synchronous call to the peer.
-     *
-     * # Errors
-     *
-     * Returns [`WasmCallError`] if the call fails or times out.
-     * @param {BatchSyncRequest} request
-     * @param {number | null} [timeout_ms]
-     * @returns {Promise<BatchSyncResponse>}
-     */
-    call(request, timeout_ms) {
-        _assertClass(request, BatchSyncRequest);
-        var ptr0 = request.__destroy_into_raw();
-        const ret = wasm.subductionwebsocket_call(this.__wbg_ptr, ptr0, !isLikeNone(timeout_ms), isLikeNone(timeout_ms) ? 0 : timeout_ms);
-        return ret;
-    }
     /**
      * Disconnect from the peer gracefully.
      * @returns {Promise<void>}
@@ -2963,46 +2725,30 @@ export class SubductionWebSocket {
         return ret;
     }
     /**
-     * Get the next request ID.
-     * @returns {Promise<RequestId>}
-     */
-    nextRequestId() {
-        const ret = wasm.subductionwebsocket_nextRequestId(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Get the peer ID of the remote peer.
-     * @returns {PeerId}
-     */
-    peerId() {
-        const ret = wasm.subductionwebsocket_peerId(this.__wbg_ptr);
-        return PeerId.__wrap(ret);
-    }
-    /**
-     * Receive a message.
+     * Receive the next message frame as raw bytes.
      *
      * # Errors
      *
      * Returns [`ReadFromClosedChannel`] if the channel has been closed.
-     * @returns {Promise<Message>}
+     * @returns {Promise<Uint8Array>}
      */
-    recv() {
-        const ret = wasm.subductionwebsocket_recv(this.__wbg_ptr);
+    recvBytes() {
+        const ret = wasm.subductionwebsocket_recvBytes(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Send a message.
+     * Send raw bytes over the WebSocket.
      *
      * # Errors
      *
-     * Returns [`WasmSendError`] if the message could not be sent over the WebSocket.
-     * @param {Message} wasm_message
+     * Returns [`WasmSendError`] if the bytes could not be sent.
+     * @param {Uint8Array} bytes
      * @returns {Promise<void>}
      */
-    send(wasm_message) {
-        _assertClass(wasm_message, Message);
-        var ptr0 = wasm_message.__destroy_into_raw();
-        const ret = wasm.subductionwebsocket_send(this.__wbg_ptr, ptr0);
+    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;
     }
     /**
@@ -3024,12 +2770,11 @@ export class SubductionWebSocket {
      * @param {WebSocket} ws
      * @param {any} signer
      * @param {PeerId} expected_peer_id
-     * @param {number} timeout_milliseconds
      * @returns {Promise<AuthenticatedWebSocket>}
      */
-    static setup(ws, signer, expected_peer_id, timeout_milliseconds) {
+    static setup(ws, signer, expected_peer_id) {
         _assertClass(expected_peer_id, PeerId);
-        const ret = wasm.subductionwebsocket_setup(ws, signer, expected_peer_id.__wbg_ptr, timeout_milliseconds);
+        const ret = wasm.subductionwebsocket_setup(ws, signer, expected_peer_id.__wbg_ptr);
         return ret;
     }
     /**
@@ -3040,8 +2785,6 @@ export class SubductionWebSocket {
      * * `address` - The WebSocket URL to connect to
      * * `signer` - The client's signer for authentication
      * * `expected_peer_id` - The expected server peer ID (verified during handshake)
-     * * `timeout_milliseconds` - Request timeout in milliseconds
-     *
      * # Errors
      *
      * Returns an error if:
@@ -3050,12 +2793,11 @@ export class SubductionWebSocket {
      * @param {URL} address
      * @param {any} signer
      * @param {PeerId} expected_peer_id
-     * @param {number} timeout_milliseconds
      * @returns {Promise<AuthenticatedWebSocket>}
      */
-    static tryConnect(address, signer, expected_peer_id, timeout_milliseconds) {
+    static tryConnect(address, signer, expected_peer_id) {
         _assertClass(expected_peer_id, PeerId);
-        const ret = wasm.subductionwebsocket_tryConnect(address, signer, expected_peer_id.__wbg_ptr, timeout_milliseconds);
+        const ret = wasm.subductionwebsocket_tryConnect(address, signer, expected_peer_id.__wbg_ptr);
         return ret;
     }
     /**
@@ -3080,19 +2822,218 @@ export class SubductionWebSocket {
      * - The handshake fails (signature invalid, clock drift, etc.)
      * @param {URL} address
      * @param {any} signer
-     * @param {number | null} [timeout_milliseconds]
      * @param {string | null} [service_name]
      * @returns {Promise<AuthenticatedWebSocket>}
      */
-    static tryDiscover(address, signer, timeout_milliseconds, service_name) {
+    static tryDiscover(address, signer, service_name) {
         var ptr0 = isLikeNone(service_name) ? 0 : passStringToWasm0(service_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.subductionwebsocket_tryDiscover(address, signer, isLikeNone(timeout_milliseconds) ? 0x100000001 : (timeout_milliseconds) >>> 0, ptr0, len0);
+        const ret = wasm.subductionwebsocket_tryDiscover(address, signer, ptr0, len0);
         return ret;
     }
 }
 if (Symbol.dispose) SubductionWebSocket.prototype[Symbol.dispose] = SubductionWebSocket.prototype.free;
 
+/**
+ * Wasm wrapper for [`SyncMessage`].
+ */
+export 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 ? undefined : 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 ? undefined : 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 ? undefined : 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 ? undefined : 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 ? undefined : 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;
+
 /**
  * Statistics from a sync operation.
  *
@@ -3261,13 +3202,13 @@ export class WebCryptoSigner {
 if (Symbol.dispose) WebCryptoSigner.prototype[Symbol.dispose] = WebCryptoSigner.prototype.free;
 
 /**
- * Convenience factory — equivalent to `new MessagePortConnection(port)`.
+ * Convenience factory — equivalent to `new MessagePortTransport(port)`.
  * @param {any} port
- * @returns {MessagePortConnection}
+ * @returns {MessagePortTransport}
  */
-export function makeMessagePortConnection(port) {
-    const ret = wasm.makeMessagePortConnection(port);
-    return MessagePortConnection.__wrap(ret);
+export function makeMessagePortTransport(port) {
+    const ret = wasm.makeMessagePortTransport(port);
+    return MessagePortTransport.__wrap(ret);
 }
 
 /**
@@ -3281,12 +3222,6 @@ export function makeMessagePortConnection(port) {
 export function start() {
     wasm.start();
 }
-export function __wbg___wasm_refgen_toWasmBatchSyncResponse_d314d3b3e09c54af(arg0) {
-    const ret = arg0.__wasm_refgen_toWasmBatchSyncResponse();
-    _assertClass(ret, BatchSyncResponse);
-    var ptr1 = ret.__destroy_into_raw();
-    return ptr1;
-}
 export function __wbg___wasm_refgen_toWasmCommitWithBlob_dd531ffcf07010df(arg0) {
     const ret = arg0.__wasm_refgen_toWasmCommitWithBlob();
     _assertClass(ret, CommitWithBlob);
@@ -3323,18 +3258,6 @@ export function __wbg___wasm_refgen_toWasmLooseCommit_c9b58ceccbe54e38(arg0) {
     var ptr1 = ret.__destroy_into_raw();
     return ptr1;
 }
-export function __wbg___wasm_refgen_toWasmMessage_03bf79fea85775dc(arg0) {
-    const ret = arg0.__wasm_refgen_toWasmMessage();
-    _assertClass(ret, Message);
-    var ptr1 = ret.__destroy_into_raw();
-    return ptr1;
-}
-export function __wbg___wasm_refgen_toWasmRequestId_659561cf5c639011(arg0) {
-    const ret = arg0.__wasm_refgen_toWasmRequestId();
-    _assertClass(ret, RequestId);
-    var ptr1 = ret.__destroy_into_raw();
-    return ptr1;
-}
 export function __wbg___wbindgen_debug_string_5398f5bb970e0daa(arg0, arg1) {
     const ret = debugString(arg1);
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -3383,42 +3306,27 @@ export function __wbg_arrayBuffer_eb8e9ca620af2a19() { return handleError(functi
     const ret = arg0.arrayBuffer();
     return ret;
 }, arguments); }
-export function __wbg_authenticatedconnection_new(arg0) {
-    const ret = AuthenticatedConnection.__wrap(arg0);
-    return ret;
-}
 export function __wbg_authenticatedlongpoll_new(arg0) {
     const ret = AuthenticatedLongPoll.__wrap(arg0);
     return ret;
 }
-export function __wbg_authenticatedwebsocket_new(arg0) {
-    const ret = AuthenticatedWebSocket.__wrap(arg0);
+export function __wbg_authenticatedtransport_new(arg0) {
+    const ret = AuthenticatedTransport.__wrap(arg0);
     return ret;
 }
-export function __wbg_batchsyncresponse_new(arg0) {
-    const ret = BatchSyncResponse.__wrap(arg0);
+export function __wbg_authenticatedwebsocket_new(arg0) {
+    const ret = AuthenticatedWebSocket.__wrap(arg0);
     return ret;
 }
 export function __wbg_buffer_60b8043cd926067d(arg0) {
     const ret = arg0.buffer;
     return ret;
 }
-export function __wbg_call_15d4cdb7fcc8c67d(arg0, arg1, arg2, arg3) {
-    const ret = arg0.call(BatchSyncRequest.__wrap(arg1), arg2 === 0 ? undefined : arg3);
-    return ret;
-}
 export function __wbg_call_2d781c1f4d5c0ef8() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.call(arg1, arg2);
     return ret;
 }, arguments); }
-export function __wbg_call_e133b57c9155d22c() { return handleError(function (arg0, arg1) {
-    const ret = arg0.call(arg1);
-    return ret;
-}, arguments); }
-export function __wbg_clearTimeout_b47e5bf918898b2b(arg0) {
-    clearTimeout(arg0);
-}
-export function __wbg_close_83c08a226256ebab(arg0) {
+export function __wbg_close_9b95bf80abb12681(arg0) {
     arg0.close();
 }
 export function __wbg_close_cbf870bdad0aad99(arg0) {
@@ -3428,10 +3336,6 @@ export function __wbg_commitwithblob_new(arg0) {
     const ret = CommitWithBlob.__wrap(arg0);
     return ret;
 }
-export function __wbg_connerrorpair_new(arg0) {
-    const ret = ConnErrorPair.__wrap(arg0);
-    return ret;
-}
 export function __wbg_contains_ef4bfb7fa5a241b7(arg0, arg1, arg2) {
     const ret = arg0.contains(getStringFromWasm0(arg1, arg2));
     return ret;
@@ -3464,7 +3368,7 @@ export function __wbg_digest_unwrap(arg0) {
     const ret = Digest.__unwrap(arg0);
     return ret;
 }
-export function __wbg_disconnect_56f1bb3ba450fd5d(arg0) {
+export function __wbg_disconnect_285027c2ec32acf6(arg0) {
     const ret = arg0.disconnect();
     return ret;
 }
@@ -3687,8 +3591,8 @@ export function __wbg_loosecommit_new(arg0) {
     const ret = LooseCommit.__wrap(arg0);
     return ret;
 }
-export function __wbg_message_new(arg0) {
-    const ret = Message.__wrap(arg0);
+export function __wbg_messageporttransport_new(arg0) {
+    const ret = MessagePortTransport.__wrap(arg0);
     return ret;
 }
 export function __wbg_msCrypto_bd5a034af96bcba6(arg0) {
@@ -3722,7 +3626,7 @@ export function __wbg_new_d098e265629cd10f(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wasm_bindgen_func_elem_1447_191(a, state0.b, arg0, arg1);
+                return __wasm_bindgen_func_elem_1476_183(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -3741,6 +3645,10 @@ export function __wbg_new_dd50bcc3f60ba434() { return handleError(function (arg0
     const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
     return ret;
 }, arguments); }
+export function __wbg_new_f7708ba82c4c12f6() { return handleError(function () {
+    const ret = new MessageChannel();
+    return ret;
+}, arguments); }
 export function __wbg_new_from_slice_22da9388ac046e50(arg0, arg1) {
     const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
     return ret;
@@ -3752,7 +3660,7 @@ export function __wbg_new_typed_aaaeaf29cf802876(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wasm_bindgen_func_elem_1447_192(a, state0.b, arg0, arg1);
+                return __wasm_bindgen_func_elem_1476_184(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -3771,10 +3679,6 @@ export function __wbg_new_with_str_and_init_b4b54d1a819bc724() { return handleEr
     const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
 }, arguments); }
-export function __wbg_nextRequestId_dd2f74cf9aba6ad5(arg0) {
-    const ret = arg0.nextRequestId();
-    return ret;
-}
 export function __wbg_node_84ea875411254db1(arg0) {
     const ret = arg0.node;
     return ret;
@@ -3799,10 +3703,6 @@ export function __wbg_of_d6376e3774c51f89(arg0, arg1) {
     const ret = Array.of(arg0, arg1);
     return ret;
 }
-export function __wbg_onmessage_8ab5822ce277f116(arg0) {
-    const ret = arg0.onmessage;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-}
 export function __wbg_open_e7a9d3d6344572f6() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = arg0.open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
     return ret;
@@ -3819,7 +3719,15 @@ export function __wbg_peerresultmap_new(arg0) {
     const ret = PeerResultMap.__wrap(arg0);
     return ret;
 }
-export function __wbg_postMessage_7b7c2f81e97ad513(arg0, arg1) {
+export function __wbg_port1_869a7ef90538dbdf(arg0) {
+    const ret = arg0.port1;
+    return ret;
+}
+export function __wbg_port2_947a51b8ba00adc9(arg0) {
+    const ret = arg0.port2;
+    return ret;
+}
+export function __wbg_postMessage_1acd85b7323d11a6(arg0, arg1) {
     arg0.postMessage(arg1);
 }
 export function __wbg_process_44c7a14e11e9f69e(arg0) {
@@ -3851,22 +3759,10 @@ export function __wbg_readyState_1f1e7f1bdf9f4d42(arg0) {
     const ret = arg0.readyState;
     return ret;
 }
-export function __wbg_recvBytes_74810cb3b96b1b52(arg0) {
+export function __wbg_recvBytes_35ad4c7c108ff4dd(arg0) {
     const ret = arg0.recvBytes();
     return ret;
 }
-export function __wbg_recv_347c2a4b277359e4(arg0) {
-    const ret = arg0.recv();
-    return ret;
-}
-export function __wbg_reject_452b6409a2fde3cd(arg0) {
-    const ret = Promise.reject(arg0);
-    return ret;
-}
-export function __wbg_requestid_new(arg0) {
-    const ret = RequestId.__wrap(arg0);
-    return ret;
-}
 export function __wbg_require_b4edbdcf3e2a1ef0() { return handleError(function () {
     const ret = module.require;
     return ret;
@@ -3899,18 +3795,14 @@ export function __wbg_sedimentreeid_unwrap(arg0) {
     const ret = SedimentreeId.__unwrap(arg0);
     return ret;
 }
-export function __wbg_sendBytes_1443021028c26f11(arg0, arg1) {
+export function __wbg_sendBytes_c3a40be4ec4bfd25(arg0, arg1) {
     const ret = arg0.sendBytes(arg1);
     return ret;
 }
 export function __wbg_send_d31a693c975dea74() { return handleError(function (arg0, arg1, arg2) {
     arg0.send(getArrayU8FromWasm0(arg1, arg2));
 }, arguments); }
-export function __wbg_send_ef8a4b8f5144f8bf(arg0, arg1) {
-    const ret = arg0.send(Message.__wrap(arg1));
-    return ret;
-}
-export function __wbg_setTimeout_44f7c6b8fbfaf279(arg0, arg1) {
+export function __wbg_setTimeout_5e8107dbc66751b5(arg0, arg1) {
     const ret = setTimeout(arg0, arg1);
     return ret;
 }
@@ -3948,10 +3840,10 @@ export function __wbg_set_onerror_8a268cb237177bba(arg0, arg1) {
 export function __wbg_set_onerror_901ca711f94a5bbb(arg0, arg1) {
     arg0.onerror = arg1;
 }
-export function __wbg_set_onmessage_6f80ab771bf151aa(arg0, arg1) {
+export function __wbg_set_onmessage_3b92dfded4487295(arg0, arg1) {
     arg0.onmessage = arg1;
 }
-export function __wbg_set_onmessage_8f399489f2e56d62(arg0, arg1) {
+export function __wbg_set_onmessage_6f80ab771bf151aa(arg0, arg1) {
     arg0.onmessage = arg1;
 }
 export function __wbg_set_onopen_34e3e24cf9337ddd(arg0, arg1) {
@@ -3963,14 +3855,14 @@ export function __wbg_set_onsuccess_fca94ded107b64af(arg0, arg1) {
 export function __wbg_set_onupgradeneeded_860ce42184f987e7(arg0, arg1) {
     arg0.onupgradeneeded = arg1;
 }
+export function __wbg_sign_23c468db7fe0ee83(arg0, arg1) {
+    const ret = arg0.sign(arg1);
+    return ret;
+}
 export function __wbg_sign_a34d057afd14c54d() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     const ret = arg0.sign(arg1, arg2, getArrayU8FromWasm0(arg3, arg4));
     return ret;
 }, arguments); }
-export function __wbg_sign_b6a174bd584137fc(arg0, arg1) {
-    const ret = arg0.sign(arg1);
-    return ret;
-}
 export function __wbg_signedfragment_new(arg0) {
     const ret = SignedFragment.__wrap(arg0);
     return ret;
@@ -3986,6 +3878,9 @@ export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
+export function __wbg_start_f837ba2bac4733b5(arg0) {
+    arg0.start();
+}
 export function __wbg_static_accessor_GLOBAL_8adb955bd33fac2f() {
     const ret = typeof global === 'undefined' ? null : global;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -4014,8 +3909,8 @@ export function __wbg_subduction_new(arg0) {
     const ret = Subduction.__wrap(arg0);
     return ret;
 }
-export function __wbg_subductionlongpollconnection_new(arg0) {
-    const ret = SubductionLongPollConnection.__wrap(arg0);
+export function __wbg_subductionhttplongpoll_new(arg0) {
+    const ret = SubductionHttpLongPoll.__wrap(arg0);
     return ret;
 }
 export function __wbg_subductionwebsocket_new(arg0) {
@@ -4053,7 +3948,7 @@ export function __wbg_tryIntoJsSedimentreeIdsArray_6f2961e02ae84900() { return h
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }, arguments); }
-export function __wbg_verifyingKey_8bc97ecebbb22709(arg0) {
+export function __wbg_verifyingKey_e2a30e05511820c4(arg0) {
     const ret = arg0.verifyingKey();
     return ret;
 }
@@ -4066,79 +3961,74 @@ export function __wbg_webcryptosigner_new(arg0) {
     return ret;
 }
 export function __wbindgen_cast_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 589, function: Function { arguments: [Externref], shim_idx: 700, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_239, __wasm_bindgen_func_elem_1447);
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 10, function: Function { arguments: [Externref], shim_idx: 11, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_255, __wasm_bindgen_func_elem_552);
     return ret;
 }
 export function __wbindgen_cast_0000000000000002(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 7, function: Function { arguments: [Externref], shim_idx: 9, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_239, __wasm_bindgen_func_elem_529);
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 10, function: Function { arguments: [NamedExternref("Event")], shim_idx: 11, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_255, __wasm_bindgen_func_elem_552_1);
     return ret;
 }
 export function __wbindgen_cast_0000000000000003(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 7, function: Function { arguments: [NamedExternref("Event")], shim_idx: 9, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_239, __wasm_bindgen_func_elem_529_2);
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 10, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 11, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_255, __wasm_bindgen_func_elem_552_2);
     return ret;
 }
 export function __wbindgen_cast_0000000000000004(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 7, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 9, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_239, __wasm_bindgen_func_elem_529_3);
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 10, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 11, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_255, __wasm_bindgen_func_elem_552_3);
     return ret;
 }
 export function __wbindgen_cast_0000000000000005(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 7, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 9, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_239, __wasm_bindgen_func_elem_529_4);
-    return ret;
-}
-export function __wbindgen_cast_0000000000000006(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 7, function: Function { arguments: [], shim_idx: 8, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_239, __wasm_bindgen_func_elem_528);
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 609, function: Function { arguments: [Externref], shim_idx: 698, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_255, __wasm_bindgen_func_elem_1476);
     return ret;
 }
-export function __wbindgen_cast_0000000000000007(arg0) {
+export function __wbindgen_cast_0000000000000006(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;
     return ret;
 }
-export function __wbindgen_cast_0000000000000008(arg0, arg1) {
+export function __wbindgen_cast_0000000000000007(arg0, arg1) {
     // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
     const ret = getArrayU8FromWasm0(arg0, arg1);
     return ret;
 }
-export function __wbindgen_cast_0000000000000009(arg0, arg1) {
+export function __wbindgen_cast_0000000000000008(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 }
-export function __wbindgen_cast_000000000000000a(arg0, arg1) {
+export function __wbindgen_cast_0000000000000009(arg0, arg1) {
     var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
     // Cast intrinsic for `Vector(NamedExternref("Fragment")) -> Externref`.
     const ret = v0;
     return ret;
 }
-export function __wbindgen_cast_000000000000000b(arg0, arg1) {
+export function __wbindgen_cast_000000000000000a(arg0, arg1) {
     var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
     // Cast intrinsic for `Vector(NamedExternref("LooseCommit")) -> Externref`.
     const ret = v0;
     return ret;
 }
-export function __wbindgen_cast_000000000000000c(arg0, arg1) {
+export function __wbindgen_cast_000000000000000b(arg0, arg1) {
     var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
     // Cast intrinsic for `Vector(NamedExternref("PeerId")) -> Externref`.
     const ret = v0;
     return ret;
 }
-export function __wbindgen_cast_000000000000000d(arg0, arg1) {
+export function __wbindgen_cast_000000000000000c(arg0, arg1) {
     var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
     // Cast intrinsic for `Vector(NamedExternref("SedimentreeId")) -> Externref`.
     const ret = v0;
     return ret;
 }
-export function __wbindgen_cast_000000000000000e(arg0, arg1) {
+export function __wbindgen_cast_000000000000000d(arg0, arg1) {
     var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
     // Cast intrinsic for `Vector(NamedExternref("Uint8Array")) -> Externref`.
@@ -4154,39 +4044,35 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
-function __wasm_bindgen_func_elem_528(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_528(arg0, arg1);
+function __wasm_bindgen_func_elem_552(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_552(arg0, arg1, arg2);
 }
 
-function __wasm_bindgen_func_elem_529(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_529(arg0, arg1, arg2);
+function __wasm_bindgen_func_elem_552_1(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_552_1(arg0, arg1, arg2);
 }
 
-function __wasm_bindgen_func_elem_529_2(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_529_2(arg0, arg1, arg2);
+function __wasm_bindgen_func_elem_552_2(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_552_2(arg0, arg1, arg2);
 }
 
-function __wasm_bindgen_func_elem_529_3(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_529_3(arg0, arg1, arg2);
+function __wasm_bindgen_func_elem_552_3(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_552_3(arg0, arg1, arg2);
 }
 
-function __wasm_bindgen_func_elem_529_4(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_529_4(arg0, arg1, arg2);
-}
-
-function __wasm_bindgen_func_elem_1447(arg0, arg1, arg2) {
-    const ret = wasm.__wasm_bindgen_func_elem_1447(arg0, arg1, arg2);
+function __wasm_bindgen_func_elem_1476(arg0, arg1, arg2) {
+    const ret = wasm.__wasm_bindgen_func_elem_1476(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function __wasm_bindgen_func_elem_1447_191(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1447_191(arg0, arg1, arg2, arg3);
+function __wasm_bindgen_func_elem_1476_183(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1476_183(arg0, arg1, arg2, arg3);
 }
 
-function __wasm_bindgen_func_elem_1447_192(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1447_192(arg0, arg1, arg2, arg3);
+function __wasm_bindgen_func_elem_1476_184(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1476_184(arg0, arg1, arg2, arg3);
 }
 
 
@@ -4197,9 +4083,6 @@ const __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versioncha
 
 
 const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
-const ConnErrorPairFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_connerrorpair_free(ptr >>> 0, 1));
 const MemorySignerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_memorysigner_free(ptr >>> 0, 1));
@@ -4209,12 +4092,12 @@ const MemoryStorageFinalization = (typeof FinalizationRegistry === 'undefined')
 const PeerBatchSyncResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_peerbatchsyncresult_free(ptr >>> 0, 1));
-const AuthenticatedConnectionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_authenticatedconnection_free(ptr >>> 0, 1));
 const AuthenticatedLongPollFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_authenticatedlongpoll_free(ptr >>> 0, 1));
+const AuthenticatedTransportFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_authenticatedtransport_free(ptr >>> 0, 1));
 const AuthenticatedWebSocketFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_authenticatedwebsocket_free(ptr >>> 0, 1));
@@ -4233,9 +4116,6 @@ const CallErrorFinalization = (typeof FinalizationRegistry === 'undefined')
 const CommitWithBlobFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_commitwithblob_free(ptr >>> 0, 1));
-const ConnectionIdFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_connectionid_free(ptr >>> 0, 1));
 const DepthFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_depth_free(ptr >>> 0, 1));
@@ -4257,21 +4137,21 @@ const FragmentsArrayFinalization = (typeof FinalizationRegistry === 'undefined')
 const HashMetricFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_hashmetric_free(ptr >>> 0, 1));
+const SubductionHttpLongPollFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_subductionhttplongpoll_free(ptr >>> 0, 1));
 const SubductionLongPollFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_subductionlongpoll_free(ptr >>> 0, 1));
-const SubductionLongPollConnectionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_subductionlongpollconnection_free(ptr >>> 0, 1));
 const LooseCommitFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_loosecommit_free(ptr >>> 0, 1));
-const MessageFinalization = (typeof FinalizationRegistry === 'undefined')
+const SyncMessageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_message_free(ptr >>> 0, 1));
-const MessagePortConnectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    : new FinalizationRegistry(ptr => wasm.__wbg_syncmessage_free(ptr >>> 0, 1));
+const MessagePortTransportFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_messageportconnection_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_messageporttransport_free(ptr >>> 0, 1));
 const NonceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_nonce_free(ptr >>> 0, 1));