@automerge/subduction 0.7.0-alpha.1 → 0.8.1

package/dist/index.d.ts

@@ -1,23 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
 
-export interface Connection {
-    disconnect(): Promise<void>;
-    send(message: Message): Promise<void>;
-    recv(): Promise<Message>;
-    nextRequestId(): Promise<RequestId>;
-    call(request: BatchSyncRequest, timeoutMs: number | null): Promise<BatchSyncResponse>;
-}
-
-
-
-export interface HandshakeConnection extends Connection {
-    sendBytes(bytes: Uint8Array): Promise<void>;
-    recvBytes(): Promise<Uint8Array>;
-}
-
-
-
 export interface SedimentreeStorage {
     saveSedimentreeId(sedimentreeId: SedimentreeId): Promise<void>;
     deleteSedimentreeId(sedimentreeId: SedimentreeId): Promise<void>;
@@ -42,38 +25,72 @@ export interface SedimentreeStorage {
 
 
 
+export interface Transport {
+    sendBytes(bytes: Uint8Array): Promise<void>;
+    recvBytes(): Promise<Uint8Array>;
+    disconnect(): Promise<void>;
+}
+
+
+
+/**
+ * An authenticated HTTP long-poll transport.
+ *
+ * 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 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Convert to a transport-erased [`AuthenticatedTransport`](super::WasmAuthenticatedTransport).
+     */
+    toTransport(): AuthenticatedTransport;
+    /**
+     * The verified peer identity.
+     */
+    readonly peerId: PeerId;
+    /**
+     * The session ID assigned by the server.
+     */
+    readonly sessionId: string;
+}
+
 /**
- * A transport-erased authenticated connection.
+ * A transport-erased authenticated transport.
  *
- * Wraps an [`Authenticated<JsConnection>`] and is the common type
+ * 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 {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
@@ -85,7 +102,7 @@ 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)
      *
@@ -93,18 +110,19 @@ export class AuthenticatedConnection {
      *
      * Returns a [`HandshakeError`](WasmHandshakeError) if the handshake fails.
      */
-    static accept(connection: HandshakeConnection, signer: any, max_drift_seconds?: number | null): Promise<AuthenticatedConnection>;
+    static accept(transport: Transport, signer: any, max_drift_seconds?: number | null): Promise<AuthenticatedTransport>;
     /**
      * 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)
      *
@@ -112,41 +130,35 @@ export class AuthenticatedConnection {
      *
      * Returns a [`HandshakeError`](WasmHandshakeError) if the handshake fails.
      */
-    static setup(connection: HandshakeConnection, signer: any, expected_peer_id: PeerId): Promise<AuthenticatedConnection>;
+    static setup(transport: Transport, signer: any, expected_peer_id: PeerId): Promise<AuthenticatedTransport>;
     /**
-     * The verified peer identity.
-     */
-    readonly peerId: PeerId;
-}
-
-/**
- * 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 {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    /**
-     * Convert to a transport-erased [`AuthenticatedConnection`](super::WasmAuthenticatedConnection).
+     * 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.
      */
-    toConnection(): AuthenticatedConnection;
+    static setupDiscover(transport: Transport, signer: any, service_name?: string | null): Promise<AuthenticatedTransport>;
     /**
      * The verified peer identity.
      */
     readonly peerId: PeerId;
-    /**
-     * The session ID assigned by the server.
-     */
-    readonly sessionId: string;
 }
 
 /**
- * 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.
@@ -159,9 +171,9 @@ export class AuthenticatedWebSocket {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Convert to a transport-erased [`AuthenticatedConnection`](super::WasmAuthenticatedConnection).
+     * Convert to a transport-erased [`AuthenticatedTransport`](super::WasmAuthenticatedTransport).
      */
-    toConnection(): AuthenticatedConnection;
+    toTransport(): AuthenticatedTransport;
     /**
      * The verified peer identity.
      */
@@ -270,32 +282,6 @@ export class CommitWithBlob {
     readonly signed: SignedLooseCommit;
 }
 
-/**
- * A pair of a connection and an error that occurred during a call.
- */
-export class ConnErrorPair {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    /**
-     * The connection that encountered the error.
-     */
-    readonly conn: Connection;
-    /**
-     * The error that occurred during the call.
-     */
-    readonly err: Error;
-}
-
-/**
- * A Wasm wrapper around the Rust `ConnectionId` type.
- */
-export class ConnectionId {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-}
-
 /**
  * A JavaScript wrapper around `Depth`.
  */
@@ -642,104 +628,16 @@ export class MemoryStorage {
 }
 
 /**
- * Wasm wrapper for [`Message`].
- */
-export class Message {
-    private constructor();
-    free(): void;
-    [Symbol.dispose](): void;
-    /**
-     * Upcasts; to the JS-import type for [`WasmMessage`].
-     */
-    __wasm_refgen_toWasmMessage(): Message;
-    /**
-     * Create a [`Message::BatchSyncRequest`] message.
-     */
-    static batchSyncRequest(request: BatchSyncRequest): Message;
-    /**
-     * Create a [`Message::BatchSyncResponse`] message.
-     */
-    static batchSyncResponse(response: BatchSyncResponse): Message;
-    /**
-     * Create a [`Message::BlobsRequest`] message.
-     */
-    static blobsRequest(id: SedimentreeId, digests: Digest[]): Message;
-    /**
-     * Create a [`Message::BlobsResponse`] message.
-     */
-    static blobsResponse(id: SedimentreeId, blobs: Uint8Array[]): Message;
-    /**
-     * Deserialize a message from bytes.
-     *
-     * # Errors
-     *
-     * Returns a [`JsMessageDeserializationError`] if deserialization fails.
-     */
-    static fromBytes(bytes: Uint8Array): Message;
-    /**
-     * Serialize the message to bytes.
-     */
-    toBytes(): Uint8Array;
-    /**
-     * The [`Blob`] for commit or fragment messages, if applicable.
-     */
-    readonly blob: Uint8Array | undefined;
-    /**
-     * The [`Blob`]s for a [`Message::BlobsResponse`], if applicable.
-     */
-    readonly blobs: Uint8Array[] | undefined;
-    /**
-     * The [`LooseCommit`] for a [`Message::LooseCommit`], if applicable.
-     *
-     * Decodes the signed payload to extract the underlying commit.
-     */
-    readonly commit: LooseCommit | undefined;
-    /**
-     * The requested [`Digest`]s for a [`Message::BlobsRequest`], if applicable.
-     */
-    readonly digests: Digest[] | undefined;
-    /**
-     * The [`Fragment`] for a [`Message::Fragment`], if applicable.
-     *
-     * Decodes the signed payload to extract the underlying fragment.
-     */
-    readonly fragment: Fragment | undefined;
-    /**
-     * The [`BatchSyncRequest`] for a [`Message::BatchSyncRequest`], if applicable.
-     */
-    readonly request: BatchSyncRequest | undefined;
-    /**
-     * The [`BatchSyncResponse`] for a [`Message::BatchSyncResponse`], if applicable.
-     */
-    readonly response: BatchSyncResponse | undefined;
-    /**
-     * The [`SedimentreeId`] associated with this message, if any.
-     */
-    readonly sedimentreeId: SedimentreeId | undefined;
-    /**
-     * The message variant name.
-     */
-    readonly type: string;
-}
-
-/**
- * A [`HandshakeConnection`] backed by a `MessagePort` (or any object with
+ * A `Transport` 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.
+ * 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 MessagePortConnection {
+export class MessagePortTransport {
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * Not supported on `MessagePort` connections.
-     */
-    call(_request: any, _timeout_ms?: number | null): Promise<any>;
     /**
      * Disconnect (close the port).
      */
@@ -748,22 +646,10 @@ export class MessagePortConnection {
      * Create a new connection wrapping the given `MessagePort`.
      */
     constructor(port: any);
-    /**
-     * Not supported on `MessagePort` connections.
-     */
-    nextRequestId(): Promise<any>;
-    /**
-     * Receive the next message.
-     */
-    recv(): Promise<any>;
     /**
      * Receive raw bytes (for the handshake phase).
      */
     recvBytes(): Promise<any>;
-    /**
-     * Send a structured message (post-handshake).
-     */
-    send(message: any): Promise<any>;
     /**
      * Send raw bytes (for the handshake phase).
      */
@@ -805,10 +691,6 @@ export class PeerBatchSyncResult {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * List of connection errors that occurred during the batch sync.
-     */
-    readonly connErrors: ConnErrorPair[];
     /**
      * Statistics about the sync operation.
      */
@@ -817,6 +699,10 @@ export class PeerBatchSyncResult {
      * Whether the batch sync was successful with at least one connection.
      */
     readonly success: boolean;
+    /**
+     * Errors that occurred during the batch sync.
+     */
+    readonly transportErrors: Error[];
 }
 
 /**
@@ -1011,6 +897,22 @@ export class SignedLooseCommit {
 export class Subduction {
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * 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.
+     */
+    acceptTransport(transport: Transport, service_name: string): Promise<PeerId>;
     /**
      * Add a commit with its associated blob to the storage.
      *
@@ -1023,15 +925,15 @@ export class Subduction {
      */
     addCommit(id: SedimentreeId, parents: Digest[], blob: Uint8Array): Promise<FragmentRequested | undefined>;
     /**
-     * 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).
@@ -1042,7 +944,7 @@ export class Subduction {
      *
      * Returns an error if the connection is rejected by the policy.
      */
-    addConnection(conn: AuthenticatedConnection): Promise<boolean>;
+    addConnection(transport: AuthenticatedTransport): Promise<boolean>;
     /**
      * Add a fragment with its associated blob to the storage.
      *
@@ -1074,13 +976,12 @@ 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.
      */
-    connect(address: URL, expected_peer_id: PeerId, timeout_milliseconds: number): Promise<PeerId>;
+    connect(address: URL, expected_peer_id: PeerId): Promise<PeerId>;
     /**
      * Connect to a peer via WebSocket using discovery mode and add the connection.
      *
@@ -1096,7 +997,7 @@ export class Subduction {
      *
      * Returns an error if connection, handshake, or adding the connection fails.
      */
-    connectDiscover(address: URL, timeout_milliseconds?: number | null, service_name?: string | null): Promise<PeerId>;
+    connectDiscover(address: URL, service_name?: string | null): Promise<PeerId>;
     /**
      * Connect to a peer via HTTP long-poll using discovery mode.
      *
@@ -1112,7 +1013,7 @@ export class Subduction {
      *
      * Returns an error if connection, handshake, or adding the connection fails.
      */
-    connectDiscoverLongPoll(base_url: string, timeout_milliseconds?: number | null, service_name?: string | null): Promise<PeerId>;
+    connectDiscoverLongPoll(base_url: string, service_name?: string | null): Promise<PeerId>;
     /**
      * Connect to a peer via HTTP long-poll and add the connection.
      *
@@ -1128,7 +1029,23 @@ export class Subduction {
      *
      * Returns an error if connection, handshake, or adding the connection fails.
      */
-    connectLongPoll(base_url: string, expected_peer_id: PeerId, timeout_milliseconds?: number | null): Promise<PeerId>;
+    connectLongPoll(base_url: string, expected_peer_id: PeerId): Promise<PeerId>;
+    /**
+     * 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.
+     */
+    connectTransport(transport: Transport, service_name: string): Promise<PeerId>;
     /**
      * Disconnect from all peers.
      *
@@ -1220,6 +1137,19 @@ export class Subduction {
      * Returns [`WasmHydrationError`] if hydration fails.
      */
     static hydrate(signer: any, storage: SedimentreeStorage, service_name?: string | null, hash_metric_override?: (digest: Digest) => Depth | null, max_pending_blob_requests?: number | null): Promise<Subduction>;
+    /**
+     * 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.
+     */
+    static link(a: Subduction, b: Subduction): Promise<void>;
     /**
      * Create a new [`Subduction`] instance.
      *
@@ -1290,136 +1220,113 @@ export class Subduction {
 }
 
 /**
- * HTTP long-poll connection factory for browser/worker environments.
- *
- * Analogous to [`SubductionWebSocket`] but uses HTTP long-poll instead of WebSocket.
+ * 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 SubductionLongPoll {
+export class SubductionHttpLongPoll {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Connect to a server with a known peer ID.
-     *
-     * # Arguments
-     *
-     * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
-     * * `signer` - The client's signer for authentication
-     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
-     * * `timeout_milliseconds` - Request timeout in milliseconds (default: 30000)
+     * Disconnect from the peer gracefully.
      *
      * # Errors
      *
-     * Returns [`LongPollConnectionError`] if connection or handshake fails.
+     * Returns an error if the disconnect fails.
      */
-    static tryConnect(base_url: string, signer: any, expected_peer_id: PeerId, timeout_milliseconds?: number | null): Promise<AuthenticatedLongPoll>;
+    disconnect(): Promise<void>;
     /**
-     * Connect to a server using discovery mode.
+     * Receive the next message frame as raw bytes.
      *
-     * # Arguments
+     * # Errors
      *
-     * * `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.
+     * Returns an error if the inbound channel is closed.
+     */
+    recvBytes(): Promise<Uint8Array>;
+    /**
+     * Send raw bytes over the transport.
      *
      * # Errors
      *
-     * Returns [`LongPollConnectionError`] if connection or handshake fails.
+     * Returns an error if the outbound channel is closed.
      */
-    static tryDiscover(base_url: string, signer: any, timeout_milliseconds?: number | null, service_name?: string | null): Promise<AuthenticatedLongPoll>;
+    sendBytes(bytes: Uint8Array): Promise<void>;
 }
 
 /**
- * JS-facing wrapper around [`WasmLongPollConnection`] that exposes the
- * [`Connection`](super::JsConnection) interface so it can be used as a
- * duck-typed `JsConnection` from JavaScript.
+ * HTTP long-poll transport factory for browser/worker environments.
+ *
+ * Analogous to [`SubductionWebSocket`] but uses HTTP long-poll instead of WebSocket.
  */
-export class SubductionLongPollConnection {
+export class SubductionLongPoll {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Make a synchronous call to the peer.
+     * Connect to a server with a known peer ID.
      *
-     * # Errors
+     * # Arguments
      *
-     * Returns an error if the call fails or times out.
-     */
-    call(request: BatchSyncRequest, timeout_ms?: number | null): Promise<BatchSyncResponse>;
-    /**
-     * Disconnect from the peer gracefully.
+     * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
+     * * `signer` - The client's signer for authentication
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     * * `timeout_milliseconds` - Request timeout in milliseconds (default: 30000)
      *
      * # Errors
      *
-     * Returns [`WasmLongPollConnError`] if the disconnect fails.
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Get the next request ID.
+     * Returns [`LongPollTransportError`] if connection or handshake fails.
      */
-    nextRequestId(): Promise<RequestId>;
+    static tryConnect(base_url: string, signer: any, expected_peer_id: PeerId): Promise<AuthenticatedLongPoll>;
     /**
-     * Receive a message.
+     * Connect to a server using discovery mode.
      *
-     * # Errors
+     * # Arguments
      *
-     * Returns an error if the inbound channel is closed.
-     */
-    recv(): Promise<Message>;
-    /**
-     * Send a message.
+     * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
+     * * `signer` - The client's signer for authentication
+     * * `service_name` - The service name for discovery. If omitted, the base URL is used.
      *
      * # Errors
      *
-     * Returns an error if the outbound channel is closed.
+     * Returns [`LongPollTransportError`] if connection or handshake fails.
      */
-    send(message: Message): Promise<void>;
+    static tryDiscover(base_url: string, signer: any, service_name?: string | null): Promise<AuthenticatedLongPoll>;
 }
 
 /**
- * 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 {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * Make a synchronous call to the peer.
-     *
-     * # Errors
-     *
-     * Returns [`WasmCallError`] if the call fails or times out.
-     */
-    call(request: BatchSyncRequest, timeout_ms?: number | null): Promise<BatchSyncResponse>;
     /**
      * Disconnect from the peer gracefully.
      */
     disconnect(): Promise<void>;
     /**
-     * Get the next request ID.
-     */
-    nextRequestId(): Promise<RequestId>;
-    /**
-     * Get the peer ID of the remote peer.
-     */
-    peerId(): PeerId;
-    /**
-     * Receive a message.
+     * Receive the next message frame as raw bytes.
      *
      * # Errors
      *
      * Returns [`ReadFromClosedChannel`] if the channel has been closed.
      */
-    recv(): Promise<Message>;
+    recvBytes(): Promise<Uint8Array>;
     /**
-     * Send a message.
+     * Send raw bytes over the WebSocket.
      *
      * # Errors
      *
-     * Returns [`WasmSendError`] if the message could not be sent over the WebSocket.
+     * Returns [`WasmSendError`] if the bytes could not be sent.
      */
-    send(wasm_message: Message): Promise<void>;
+    sendBytes(bytes: Uint8Array): Promise<void>;
     /**
      * Authenticate an existing WebSocket via handshake.
      *
@@ -1437,7 +1344,7 @@ export class SubductionWebSocket {
      *
      * Returns an error if the handshake fails (signature invalid, wrong peer, etc.)
      */
-    static setup(ws: WebSocket, signer: any, expected_peer_id: PeerId, timeout_milliseconds: number): Promise<AuthenticatedWebSocket>;
+    static setup(ws: WebSocket, signer: any, expected_peer_id: PeerId): Promise<AuthenticatedWebSocket>;
     /**
      * Connect to a WebSocket server with mutual authentication via handshake.
      *
@@ -1446,15 +1353,13 @@ 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:
      * - The WebSocket connection could not be established
      * - The handshake fails (signature invalid, wrong server, clock drift, etc.)
      */
-    static tryConnect(address: URL, signer: any, expected_peer_id: PeerId, timeout_milliseconds: number): Promise<AuthenticatedWebSocket>;
+    static tryConnect(address: URL, signer: any, expected_peer_id: PeerId): Promise<AuthenticatedWebSocket>;
     /**
      * Connect to a WebSocket server using discovery mode.
      *
@@ -1476,7 +1381,88 @@ export class SubductionWebSocket {
      * - The WebSocket connection could not be established
      * - The handshake fails (signature invalid, clock drift, etc.)
      */
-    static tryDiscover(address: URL, signer: any, timeout_milliseconds?: number | null, service_name?: string | null): Promise<AuthenticatedWebSocket>;
+    static tryDiscover(address: URL, signer: any, service_name?: string | null): Promise<AuthenticatedWebSocket>;
+}
+
+/**
+ * Wasm wrapper for [`SyncMessage`].
+ */
+export class SyncMessage {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmMessage`].
+     */
+    __wasm_refgen_toWasmMessage(): SyncMessage;
+    /**
+     * Create a [`SyncMessage::BatchSyncRequest`] message.
+     */
+    static batchSyncRequest(request: BatchSyncRequest): SyncMessage;
+    /**
+     * Create a [`SyncMessage::BatchSyncResponse`] message.
+     */
+    static batchSyncResponse(response: BatchSyncResponse): SyncMessage;
+    /**
+     * Create a [`SyncMessage::BlobsRequest`] message.
+     */
+    static blobsRequest(id: SedimentreeId, digests: Digest[]): SyncMessage;
+    /**
+     * Create a [`SyncMessage::BlobsResponse`] message.
+     */
+    static blobsResponse(id: SedimentreeId, blobs: Uint8Array[]): SyncMessage;
+    /**
+     * Deserialize a message from bytes.
+     *
+     * # Errors
+     *
+     * Returns a [`JsMessageDeserializationError`] if deserialization fails.
+     */
+    static fromBytes(bytes: Uint8Array): SyncMessage;
+    /**
+     * Serialize the message to bytes.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * The [`Blob`] for commit or fragment messages, if applicable.
+     */
+    readonly blob: Uint8Array | undefined;
+    /**
+     * The [`Blob`]s for a [`SyncMessage::BlobsResponse`], if applicable.
+     */
+    readonly blobs: Uint8Array[] | undefined;
+    /**
+     * The [`LooseCommit`] for a [`SyncMessage::LooseCommit`], if applicable.
+     *
+     * Decodes the signed payload to extract the underlying commit.
+     */
+    readonly commit: LooseCommit | undefined;
+    /**
+     * The requested [`Digest`]s for a [`SyncMessage::BlobsRequest`], if applicable.
+     */
+    readonly digests: Digest[] | undefined;
+    /**
+     * The [`Fragment`] for a [`SyncMessage::Fragment`], if applicable.
+     *
+     * Decodes the signed payload to extract the underlying fragment.
+     */
+    readonly fragment: Fragment | undefined;
+    /**
+     * The [`BatchSyncRequest`] for a [`SyncMessage::BatchSyncRequest`], if applicable.
+     */
+    readonly request: BatchSyncRequest | undefined;
+    /**
+     * The [`BatchSyncResponse`] for a [`SyncMessage::BatchSyncResponse`], if applicable.
+     */
+    readonly response: BatchSyncResponse | undefined;
+    /**
+     * The [`SedimentreeId`] associated with this message, if any.
+     */
+    readonly sedimentreeId: SedimentreeId | undefined;
+    /**
+     * The message variant name.
+     */
+    readonly type: string;
 }
 
 /**
@@ -1570,9 +1556,9 @@ export class WebCryptoSigner {
 }
 
 /**
- * Convenience factory — equivalent to `new MessagePortConnection(port)`.
+ * Convenience factory — equivalent to `new MessagePortTransport(port)`.
  */
-export function makeMessagePortConnection(port: any): MessagePortConnection;
+export function makeMessagePortTransport(port: any): MessagePortTransport;
 
 /**
  * Entry point called when the Wasm module is instantiated.