@automerge/subduction 0.7.0-alpha.1 → 0.8.1

package/dist/wasm_bindgen/web/subduction_wasm.js

@@ -2,53 +2,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).
@@ -58,20 +120,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;
     }
     /**
@@ -79,103 +141,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.
@@ -210,13 +240,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;
@@ -461,63 +491,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`.
  */
@@ -1361,366 +1334,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();
@@ -1750,16 +1485,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}
@@ -1776,6 +1501,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;
 
@@ -2274,6 +2009,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.
      *
@@ -2296,15 +2055,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).
@@ -2314,12 +2073,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;
     }
     /**
@@ -2379,19 +2138,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;
     }
     /**
@@ -2409,14 +2166,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;
     }
     /**
@@ -2434,16 +2190,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;
     }
     /**
@@ -2462,14 +2217,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;
     }
     /**
@@ -2634,6 +2412,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.
      *
@@ -2758,7 +2557,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.
  */
@@ -2785,18 +2650,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;
     }
     /**
@@ -2806,120 +2670,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) {
@@ -2939,22 +2717,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>}
@@ -2964,46 +2726,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;
     }
     /**
@@ -3025,12 +2771,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;
     }
     /**
@@ -3041,8 +2786,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:
@@ -3051,12 +2794,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;
     }
     /**
@@ -3081,19 +2823,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.
  *
@@ -3262,13 +3203,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);
 }
 
 /**
@@ -3286,12 +3227,6 @@ export function start() {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___wasm_refgen_toWasmBatchSyncResponse_d314d3b3e09c54af: function(arg0) {
-            const ret = arg0.__wasm_refgen_toWasmBatchSyncResponse();
-            _assertClass(ret, BatchSyncResponse);
-            var ptr1 = ret.__destroy_into_raw();
-            return ptr1;
-        },
         __wbg___wasm_refgen_toWasmCommitWithBlob_dd531ffcf07010df: function(arg0) {
             const ret = arg0.__wasm_refgen_toWasmCommitWithBlob();
             _assertClass(ret, CommitWithBlob);
@@ -3328,18 +3263,6 @@ function __wbg_get_imports() {
             var ptr1 = ret.__destroy_into_raw();
             return ptr1;
         },
-        __wbg___wasm_refgen_toWasmMessage_03bf79fea85775dc: function(arg0) {
-            const ret = arg0.__wasm_refgen_toWasmMessage();
-            _assertClass(ret, Message);
-            var ptr1 = ret.__destroy_into_raw();
-            return ptr1;
-        },
-        __wbg___wasm_refgen_toWasmRequestId_659561cf5c639011: function(arg0) {
-            const ret = arg0.__wasm_refgen_toWasmRequestId();
-            _assertClass(ret, RequestId);
-            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);
@@ -3388,42 +3311,27 @@ function __wbg_get_imports() {
             const ret = arg0.arrayBuffer();
             return ret;
         }, arguments); },
-        __wbg_authenticatedconnection_new: function(arg0) {
-            const ret = AuthenticatedConnection.__wrap(arg0);
-            return ret;
-        },
         __wbg_authenticatedlongpoll_new: function(arg0) {
             const ret = AuthenticatedLongPoll.__wrap(arg0);
             return ret;
         },
-        __wbg_authenticatedwebsocket_new: function(arg0) {
-            const ret = AuthenticatedWebSocket.__wrap(arg0);
+        __wbg_authenticatedtransport_new: function(arg0) {
+            const ret = AuthenticatedTransport.__wrap(arg0);
             return ret;
         },
-        __wbg_batchsyncresponse_new: function(arg0) {
-            const ret = BatchSyncResponse.__wrap(arg0);
+        __wbg_authenticatedwebsocket_new: function(arg0) {
+            const ret = AuthenticatedWebSocket.__wrap(arg0);
             return ret;
         },
         __wbg_buffer_60b8043cd926067d: function(arg0) {
             const ret = arg0.buffer;
             return ret;
         },
-        __wbg_call_15d4cdb7fcc8c67d: function(arg0, arg1, arg2, arg3) {
-            const ret = arg0.call(BatchSyncRequest.__wrap(arg1), arg2 === 0 ? undefined : arg3);
-            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_clearTimeout_b47e5bf918898b2b: function(arg0) {
-            clearTimeout(arg0);
-        },
-        __wbg_close_83c08a226256ebab: function(arg0) {
+        __wbg_close_9b95bf80abb12681: function(arg0) {
             arg0.close();
         },
         __wbg_close_cbf870bdad0aad99: function(arg0) {
@@ -3433,10 +3341,6 @@ function __wbg_get_imports() {
             const ret = CommitWithBlob.__wrap(arg0);
             return ret;
         },
-        __wbg_connerrorpair_new: function(arg0) {
-            const ret = ConnErrorPair.__wrap(arg0);
-            return ret;
-        },
         __wbg_contains_ef4bfb7fa5a241b7: function(arg0, arg1, arg2) {
             const ret = arg0.contains(getStringFromWasm0(arg1, arg2));
             return ret;
@@ -3469,7 +3373,7 @@ function __wbg_get_imports() {
             const ret = Digest.__unwrap(arg0);
             return ret;
         },
-        __wbg_disconnect_56f1bb3ba450fd5d: function(arg0) {
+        __wbg_disconnect_285027c2ec32acf6: function(arg0) {
             const ret = arg0.disconnect();
             return ret;
         },
@@ -3692,8 +3596,8 @@ function __wbg_get_imports() {
             const ret = LooseCommit.__wrap(arg0);
             return ret;
         },
-        __wbg_message_new: function(arg0) {
-            const ret = Message.__wrap(arg0);
+        __wbg_messageporttransport_new: function(arg0) {
+            const ret = MessagePortTransport.__wrap(arg0);
             return ret;
         },
         __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
@@ -3727,7 +3631,7 @@ function __wbg_get_imports() {
                     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;
                     }
@@ -3746,6 +3650,10 @@ function __wbg_get_imports() {
             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;
@@ -3757,7 +3665,7 @@ function __wbg_get_imports() {
                     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;
                     }
@@ -3776,10 +3684,6 @@ function __wbg_get_imports() {
             const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
             return ret;
         }, arguments); },
-        __wbg_nextRequestId_dd2f74cf9aba6ad5: function(arg0) {
-            const ret = arg0.nextRequestId();
-            return ret;
-        },
         __wbg_node_84ea875411254db1: function(arg0) {
             const ret = arg0.node;
             return ret;
@@ -3804,10 +3708,6 @@ function __wbg_get_imports() {
             const ret = Array.of(arg0, arg1);
             return ret;
         },
-        __wbg_onmessage_8ab5822ce277f116: function(arg0) {
-            const ret = arg0.onmessage;
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
         __wbg_open_e7a9d3d6344572f6: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = arg0.open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
             return ret;
@@ -3824,7 +3724,15 @@ function __wbg_get_imports() {
             const ret = PeerResultMap.__wrap(arg0);
             return ret;
         },
-        __wbg_postMessage_7b7c2f81e97ad513: function(arg0, arg1) {
+        __wbg_port1_869a7ef90538dbdf: function(arg0) {
+            const ret = arg0.port1;
+            return ret;
+        },
+        __wbg_port2_947a51b8ba00adc9: function(arg0) {
+            const ret = arg0.port2;
+            return ret;
+        },
+        __wbg_postMessage_1acd85b7323d11a6: function(arg0, arg1) {
             arg0.postMessage(arg1);
         },
         __wbg_process_44c7a14e11e9f69e: function(arg0) {
@@ -3856,22 +3764,10 @@ function __wbg_get_imports() {
             const ret = arg0.readyState;
             return ret;
         },
-        __wbg_recvBytes_74810cb3b96b1b52: function(arg0) {
+        __wbg_recvBytes_35ad4c7c108ff4dd: function(arg0) {
             const ret = arg0.recvBytes();
             return ret;
         },
-        __wbg_recv_347c2a4b277359e4: function(arg0) {
-            const ret = arg0.recv();
-            return ret;
-        },
-        __wbg_reject_452b6409a2fde3cd: function(arg0) {
-            const ret = Promise.reject(arg0);
-            return ret;
-        },
-        __wbg_requestid_new: function(arg0) {
-            const ret = RequestId.__wrap(arg0);
-            return ret;
-        },
         __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
             const ret = module.require;
             return ret;
@@ -3904,18 +3800,14 @@ function __wbg_get_imports() {
             const ret = SedimentreeId.__unwrap(arg0);
             return ret;
         },
-        __wbg_sendBytes_1443021028c26f11: function(arg0, arg1) {
+        __wbg_sendBytes_c3a40be4ec4bfd25: 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_send_ef8a4b8f5144f8bf: function(arg0, arg1) {
-            const ret = arg0.send(Message.__wrap(arg1));
-            return ret;
-        },
-        __wbg_setTimeout_44f7c6b8fbfaf279: function(arg0, arg1) {
+        __wbg_setTimeout_5e8107dbc66751b5: function(arg0, arg1) {
             const ret = setTimeout(arg0, arg1);
             return ret;
         },
@@ -3953,10 +3845,10 @@ function __wbg_get_imports() {
         __wbg_set_onerror_901ca711f94a5bbb: function(arg0, arg1) {
             arg0.onerror = arg1;
         },
-        __wbg_set_onmessage_6f80ab771bf151aa: function(arg0, arg1) {
+        __wbg_set_onmessage_3b92dfded4487295: function(arg0, arg1) {
             arg0.onmessage = arg1;
         },
-        __wbg_set_onmessage_8f399489f2e56d62: function(arg0, arg1) {
+        __wbg_set_onmessage_6f80ab771bf151aa: function(arg0, arg1) {
             arg0.onmessage = arg1;
         },
         __wbg_set_onopen_34e3e24cf9337ddd: function(arg0, arg1) {
@@ -3968,14 +3860,14 @@ function __wbg_get_imports() {
         __wbg_set_onupgradeneeded_860ce42184f987e7: function(arg0, arg1) {
             arg0.onupgradeneeded = arg1;
         },
+        __wbg_sign_23c468db7fe0ee83: function(arg0, arg1) {
+            const ret = arg0.sign(arg1);
+            return ret;
+        },
         __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_b6a174bd584137fc: function(arg0, arg1) {
-            const ret = arg0.sign(arg1);
-            return ret;
-        },
         __wbg_signedfragment_new: function(arg0) {
             const ret = SignedFragment.__wrap(arg0);
             return ret;
@@ -3991,6 +3883,9 @@ function __wbg_get_imports() {
             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);
@@ -4019,8 +3914,8 @@ function __wbg_get_imports() {
             const ret = Subduction.__wrap(arg0);
             return ret;
         },
-        __wbg_subductionlongpollconnection_new: function(arg0) {
-            const ret = SubductionLongPollConnection.__wrap(arg0);
+        __wbg_subductionhttplongpoll_new: function(arg0) {
+            const ret = SubductionHttpLongPoll.__wrap(arg0);
             return ret;
         },
         __wbg_subductionwebsocket_new: function(arg0) {
@@ -4058,7 +3953,7 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         }, arguments); },
-        __wbg_verifyingKey_8bc97ecebbb22709: function(arg0) {
+        __wbg_verifyingKey_e2a30e05511820c4: function(arg0) {
             const ret = arg0.verifyingKey();
             return ret;
         },
@@ -4071,79 +3966,74 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(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;
         },
         __wbindgen_cast_0000000000000002: function(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;
         },
         __wbindgen_cast_0000000000000003: function(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;
         },
         __wbindgen_cast_0000000000000004: function(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;
         },
         __wbindgen_cast_0000000000000005: function(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;
-        },
-        __wbindgen_cast_0000000000000006: function(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;
         },
-        __wbindgen_cast_0000000000000007: function(arg0) {
+        __wbindgen_cast_0000000000000006: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000009: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_000000000000000a: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000009: function(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;
         },
-        __wbindgen_cast_000000000000000b: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000a: function(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;
         },
-        __wbindgen_cast_000000000000000c: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000b: function(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;
         },
-        __wbindgen_cast_000000000000000d: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000c: function(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;
         },
-        __wbindgen_cast_000000000000000e: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000d: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_export5(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("Uint8Array")) -> Externref`.
@@ -4166,39 +4056,35 @@ function __wbg_get_imports() {
     };
 }
 
-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);
 }
 
 
@@ -4209,9 +4095,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));
@@ -4221,12 +4104,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));
@@ -4245,9 +4128,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));
@@ -4269,21 +4149,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));