@automerge/subduction 0.10.0 → 0.10.1

package/dist/index.d.ts

@@ -0,0 +1,1706 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Connection and storage authorization policy.
+ *
+ * Throwing (or returning a rejected promise) denies the operation.
+ * Resolving allows it.
+ */
+export interface Policy {
+    authorizeConnect(peerId: PeerId): Promise<void>;
+    authorizeFetch(peerId: PeerId, sedimentreeId: SedimentreeId): Promise<void>;
+    authorizePut(requestor: PeerId, author: PeerId, sedimentreeId: SedimentreeId): Promise<void>;
+    filterAuthorizedFetch(peerId: PeerId, ids: SedimentreeId[]): Promise<SedimentreeId[]>;
+}
+
+
+
+/**
+ * Ephemeral message authorization policy.
+ *
+ * Throwing (or returning a rejected promise) denies the operation.
+ * Resolving allows it.
+ */
+export interface EphemeralPolicy {
+    authorizeSubscribe(peerId: PeerId, topic: Topic): Promise<void>;
+    authorizePublish(peerId: PeerId, topic: Topic): Promise<void>;
+    filterAuthorizedSubscribers(topic: Topic, peers: PeerId[]): Promise<PeerId[]>;
+}
+
+
+
+export interface SedimentreeStorage {
+    saveSedimentreeId(sedimentreeId: SedimentreeId): Promise<void>;
+    deleteSedimentreeId(sedimentreeId: SedimentreeId): Promise<void>;
+    loadAllSedimentreeIds(): Promise<SedimentreeId[]>;
+
+    // Compound storage for commits (signed data + blob stored together)
+    saveCommit(sedimentreeId: SedimentreeId, digest: Digest, signedCommit: SignedLooseCommit, blob: Uint8Array): Promise<void>;
+    loadCommit(sedimentreeId: SedimentreeId, digest: Digest): Promise<CommitWithBlob | null>;
+    listCommitDigests(sedimentreeId: SedimentreeId): Promise<Digest[]>;
+    loadAllCommits(sedimentreeId: SedimentreeId): Promise<CommitWithBlob[]>;
+    deleteCommit(sedimentreeId: SedimentreeId, digest: Digest): Promise<void>;
+    deleteAllCommits(sedimentreeId: SedimentreeId): Promise<void>;
+
+    // Compound storage for fragments (signed data + blob stored together)
+    saveFragment(sedimentreeId: SedimentreeId, digest: Digest, signedFragment: SignedFragment, blob: Uint8Array): Promise<void>;
+    loadFragment(sedimentreeId: SedimentreeId, digest: Digest): Promise<FragmentWithBlob | null>;
+    listFragmentDigests(sedimentreeId: SedimentreeId): Promise<Digest[]>;
+    loadAllFragments(sedimentreeId: SedimentreeId): Promise<FragmentWithBlob[]>;
+    deleteFragment(sedimentreeId: SedimentreeId, digest: Digest): Promise<void>;
+    deleteAllFragments(sedimentreeId: SedimentreeId): Promise<void>;
+
+    // Batch save: write all commits + fragments in a single storage transaction.
+    saveBatchAll(sedimentreeId: SedimentreeId, commits: Array<{digest: Digest, signedCommit: SignedLooseCommit, blob: Uint8Array}>, fragments: Array<{digest: Digest, signedFragment: SignedFragment, blob: Uint8Array}>): Promise<number>;
+}
+
+
+
+export interface Transport {
+    sendBytes(bytes: Uint8Array): Promise<void>;
+    recvBytes(): Promise<Uint8Array>;
+    disconnect(): Promise<void>;
+    onDisconnect(callback: () => void): 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 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 `AuthenticatedTransport`:
+ *
+ * 1. **Custom transport** — implement the `Transport` interface
+ *    (`sendBytes`/`recvBytes`/`disconnect`/`onDisconnect`) and call
+ *    [`setup`](Self::setup):
+ *
+ *    ```js
+ *    const auth = await AuthenticatedTransport.setup(myTransport, signer, peerId, (peerId) => {
+ *        console.log(`${peerId} disconnected`);
+ *    });
+ *    ```
+ *
+ * 2. **From WebSocket** — authenticate via [`SubductionWebSocket`] then convert:
+ *
+ *    ```js
+ *    const wsAuth = await SubductionWebSocket.tryConnect(url, signer, peerId, (peerId) => {
+ *        console.log(`${peerId} disconnected`);
+ *    });
+ *    const auth = wsAuth.toTransport();
+ *    ```
+ *
+ * 3. **From HTTP long-poll** — same pattern via [`SubductionLongPoll`]:
+ *
+ *    ```js
+ *    const lpAuth = await SubductionLongPoll.tryConnect(url, signer, peerId, (peerId) => {
+ *        console.log(`${peerId} disconnected`);
+ *    });
+ *    const auth = lpAuth.toTransport();
+ *    ```
+ */
+export class AuthenticatedTransport {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Accept an incoming handshake over a custom transport (responder side).
+     *
+     * This is the counterpart to [`setup`](Self::setup). The initiator calls
+     * `setup`, and the responder calls `accept` over the same underlying channel.
+     *
+     * # Arguments
+     *
+     * * `transport` - A `Transport` implementing `sendBytes`/`recvBytes`/`disconnect`/`onDisconnect`
+     * * `signer` - The responder's signer for authentication
+     * * `max_drift_seconds` - Maximum acceptable clock drift in seconds (default: 600)
+     *
+     * # Errors
+     *
+     * Returns a [`HandshakeError`](WasmHandshakeError) if the handshake fails.
+     */
+    static accept(transport: Transport, signer: any, max_drift_seconds?: number | null, on_disconnect?: Function | null): Promise<AuthenticatedTransport>;
+    /**
+     * Run the Subduction handshake over a custom transport, producing an
+     * authenticated transport.
+     *
+     * The `transport` object must implement the `Transport` interface
+     * (`sendBytes`/`recvBytes`/`disconnect`/`onDisconnect`).
+     * The same object is used for both the handshake phase and post-handshake
+     * communication.
+     *
+     * # Arguments
+     *
+     * * `transport` - A `Transport` implementing `sendBytes`/`recvBytes`/`disconnect`/`onDisconnect`
+     * * `signer` - The client's signer for authentication
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     *
+     * # Errors
+     *
+     * Returns a [`HandshakeError`](WasmHandshakeError) if the handshake fails.
+     */
+    static setup(transport: Transport, signer: any, expected_peer_id: PeerId, on_disconnect?: Function | null): Promise<AuthenticatedTransport>;
+    /**
+     * Run the Subduction handshake over a custom transport using discovery
+     * mode, producing an authenticated transport.
+     *
+     * Unlike [`setup`](Self::setup) which requires a known peer ID,
+     * this method discovers the peer's identity during the handshake
+     * using a shared service name.
+     *
+     * # Arguments
+     *
+     * * `transport` - A `Transport` implementing `sendBytes`/`recvBytes`/`disconnect`/`onDisconnect`
+     * * `signer` - The client's signer for authentication
+     * * `service_name` - Shared service name for discovery.
+     *   Defaults to [`DEFAULT_LOCAL_SERVICE_NAME`] (`"subduction:local"`) if omitted.
+     *
+     * # Errors
+     *
+     * Returns a [`HandshakeError`](WasmHandshakeError) if the handshake fails.
+     */
+    static setupDiscover(transport: Transport, signer: any, service_name?: string | null, on_disconnect?: Function | null): Promise<AuthenticatedTransport>;
+    /**
+     * The verified peer identity.
+     */
+    readonly peerId: PeerId;
+}
+
+/**
+ * An authenticated WebSocket transport.
+ *
+ * This wrapper proves that the connection has completed the Subduction handshake
+ * and the peer identity has been cryptographically verified.
+ *
+ * Obtain via [`SubductionWebSocket::setup`], [`SubductionWebSocket::tryConnect`],
+ * or [`SubductionWebSocket::tryDiscover`].
+ */
+export class AuthenticatedWebSocket {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Convert to a transport-erased [`AuthenticatedTransport`](super::WasmAuthenticatedTransport).
+     */
+    toTransport(): AuthenticatedTransport;
+    /**
+     * The verified peer identity.
+     */
+    readonly peerId: PeerId;
+}
+
+/**
+ * Wasm wrapper for [`BatchSyncRequest`].
+ */
+export class BatchSyncRequest {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The sedimentree ID this request corresponds to.
+     */
+    id(): SedimentreeId;
+    /**
+     * The request ID for this request.
+     */
+    request_id(): RequestId;
+    /**
+     * Whether this request subscribes to future updates.
+     */
+    subscribe(): boolean;
+}
+
+/**
+ * Wasm wrapper for [`BatchSyncResponse`].
+ */
+export class BatchSyncResponse {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmBatchSyncResponse`].
+     */
+    __wasm_refgen_toWasmBatchSyncResponse(): BatchSyncResponse;
+    /**
+     * The sedimentree ID this response corresponds to.
+     */
+    id(): SedimentreeId;
+    /**
+     * The request ID this response corresponds to.
+     */
+    request_id(): RequestId;
+}
+
+/**
+ * A Wasm wrapper around the [`BlobMeta`] type.
+ */
+export class BlobMeta {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get the digest of the blob.
+     */
+    digest(): Digest;
+    /**
+     * Create a `BlobMeta` from a digest and size.
+     *
+     * This is useful for deserialization when the original blob is not available.
+     * Since this is manual, the caller must ensure the digest and size are correct.
+     */
+    static fromDigestSize(digest: Digest, size_bytes: bigint): BlobMeta;
+    /**
+     * Create a new `BlobMeta` from the given blob contents.
+     */
+    constructor(blob: Uint8Array);
+    /**
+     * Get the size of the blob in bytes.
+     */
+    readonly sizeBytes: bigint;
+}
+
+/**
+ * Wasm wrapper for call errors.
+ */
+export class CallError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+}
+
+/**
+ * A commit stored with its associated blob.
+ */
+export class CommitWithBlob {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmCommitWithBlob`].
+     */
+    __wasm_refgen_toWasmCommitWithBlob(): CommitWithBlob;
+    /**
+     * Create a new commit with blob.
+     */
+    constructor(signed: SignedLooseCommit, blob: Uint8Array);
+    /**
+     * Get the blob.
+     */
+    readonly blob: Uint8Array;
+    /**
+     * Get the signed commit.
+     */
+    readonly signed: SignedLooseCommit;
+}
+
+/**
+ * A JavaScript wrapper around `Depth`.
+ */
+export class Depth {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Internal method for a hack crossing the JS boundary.
+     */
+    __subduction_castToDepth(): Depth;
+    /**
+     * Upcasts; to the JS-import type for [`WasmDepth`].
+     */
+    __wasm_refgen_toWasmDepth(): Depth;
+    /**
+     * Creates a new `WasmDepth` from a JavaScript value.
+     *
+     * # Errors
+     *
+     * Returns a `NotU32Error` if the JS value is not safely coercible to `u32`.
+     */
+    constructor(js_value: any);
+    /**
+     * The depth value as an integer.
+     */
+    readonly value: number;
+}
+
+/**
+ * A wrapper around digest bytes for use in JavaScript via wasm-bindgen.
+ *
+ * Since JavaScript doesn't have Rust's type system, this stores raw bytes
+ * and converts to/from typed `Digest<T>` at the Rust boundary.
+ */
+export class Digest {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmDigest`].
+     */
+    __wasm_refgen_toWasmDigest(): Digest;
+    /**
+     * Creates a new digest from its Base58 string representation.
+     *
+     * # Errors
+     *
+     * Returns a `WasmInvalidDigest` error if the string cannot be decoded or is not a valid digest.
+     */
+    static fromBase58(s: string): Digest;
+    /**
+     * Creates a new digest from its byte representation.
+     *
+     * # Errors
+     *
+     * Returns a `WasmValue` error if the byte slice is not a valid digest.
+     */
+    static fromBytes(bytes: Uint8Array): Digest;
+    /**
+     * Creates a new digest from its hexadecimal string representation.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmInvalidDigest`] if the string is not a valid digest.
+     */
+    static fromHexString(s: string): Digest;
+    /**
+     * Creates a new digest from its byte representation.
+     *
+     * # Errors
+     *
+     * Returns a `WasmValue` error if the byte slice is not a valid digest.
+     */
+    constructor(bytes: Uint8Array);
+    /**
+     * Returns the byte representation of the digest.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Returns the hexadecimal string representation of the digest.
+     */
+    toHexString(): string;
+}
+
+/**
+ * A data fragment used in the Sedimentree system.
+ */
+export class Fragment {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmFragment`].
+     */
+    __wasm_refgen_toWasmFragment(): Fragment;
+    /**
+     * Create a new fragment from the given sedimentree ID, head, boundary, checkpoints, and blob metadata.
+     */
+    constructor(sedimentree_id: SedimentreeId, head: Digest, boundary: Digest[], checkpoints: Digest[], blob_meta: BlobMeta);
+    /**
+     * Get the blob metadata of the fragment.
+     */
+    readonly blobMeta: BlobMeta;
+    /**
+     * Get the boundary digests of the fragment.
+     */
+    readonly boundary: Digest[];
+    /**
+     * Get the head digest of the fragment.
+     */
+    readonly head: Digest;
+}
+
+/**
+ * A request for a specific fragment in the Sedimentree system.
+ */
+export class FragmentRequested {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new fragment request from the given digest.
+     */
+    constructor(digest: Digest, depth: Depth);
+    /**
+     * Get the depth of the requested fragment.
+     */
+    readonly depth: Depth;
+    /**
+     * Get the digest of the requested fragment.
+     */
+    readonly head: Digest;
+}
+
+/**
+ * A fragment stored with its associated blob.
+ */
+export class FragmentWithBlob {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmFragmentWithBlob`].
+     */
+    __wasm_refgen_toWasmFragmentWithBlob(): FragmentWithBlob;
+    /**
+     * Create a new fragment with blob.
+     */
+    constructor(signed: SignedFragment, blob: Uint8Array);
+    /**
+     * Get the blob.
+     */
+    readonly blob: Uint8Array;
+    /**
+     * Get the signed fragment.
+     */
+    readonly signed: SignedFragment;
+}
+
+export class FragmentsArray {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmFragmentsArray`].
+     */
+    __wasm_refgen_toWasmFragmentsArray(): FragmentsArray;
+}
+
+/**
+ * An overridable hash metric.
+ */
+export class HashMetric {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new `WasmHashMetric` with an optional JavaScript function.
+     *
+     * Defaults to counting leading zero bytes if no function is provided.
+     */
+    constructor(func?: Function | null);
+}
+
+/**
+ * A Wasm wrapper around the [`LooseCommit`] type.
+ */
+export class LooseCommit {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmLooseCommit`].
+     */
+    __wasm_refgen_toWasmLooseCommit(): LooseCommit;
+    /**
+     * Create a new `LooseCommit` from the given sedimentree ID, parents, and blob metadata.
+     */
+    constructor(sedimentree_id: SedimentreeId, parents: Digest[], blob_meta: BlobMeta);
+    /**
+     * Get the blob metadata of the commit.
+     */
+    readonly blobMeta: BlobMeta;
+    /**
+     * Get the digest of the commit.
+     */
+    readonly digest: Digest;
+    /**
+     * Get the parent digests of the commit.
+     */
+    readonly parents: Digest[];
+}
+
+/**
+ * An in-memory Ed25519 signer exposed to JavaScript.
+ *
+ * Implements the `Signer` interface (`sign` / `verifyingKey`) so it can be
+ * passed anywhere a [`JsSigner`](crate::signer::JsSigner) is expected.
+ *
+ * # Example
+ *
+ * ```javascript
+ * import { MemorySigner } from "@automerge/subduction";
+ *
+ * const signer = MemorySigner.generate();
+ * console.log("Peer ID:", signer.peerId().toString());
+ * ```
+ */
+export class MemorySigner {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a signer from raw 32-byte Ed25519 secret key bytes.
+     *
+     * # Errors
+     *
+     * Returns an error if `bytes` is not exactly 32 bytes.
+     */
+    static fromBytes(bytes: Uint8Array): MemorySigner;
+    /**
+     * Create a new signer with a randomly generated Ed25519 key.
+     *
+     * # Panics
+     *
+     * Panics if the system random number generator fails.
+     */
+    static generate(): MemorySigner;
+    /**
+     * Create a new signer with a randomly generated Ed25519 key.
+     *
+     * This is the JS constructor (`new MemorySigner()`), equivalent to
+     * [`generate`](Self::generate).
+     *
+     * # Panics
+     *
+     * Panics if the system random number generator fails.
+     */
+    constructor();
+    /**
+     * Get the peer ID derived from this signer's verifying key.
+     */
+    peerId(): PeerId;
+    /**
+     * Sign a message and return the 64-byte Ed25519 signature as a `Uint8Array`.
+     *
+     * This fulfils the `Signer.sign(message)` interface contract.
+     * Returns a `Promise<Uint8Array>` for consistency with the async signer interface.
+     */
+    sign(message: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get the 32-byte Ed25519 verifying (public) key as a `Uint8Array`.
+     *
+     * This fulfils the `Signer.verifyingKey()` interface contract.
+     */
+    verifyingKey(): Uint8Array;
+}
+
+/**
+ * An in-memory storage implementation for use in tests and development.
+ *
+ * This wraps the core `MemoryStorage` and exposes it via the `SedimentreeStorage` interface.
+ */
+export class MemoryStorage {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Delete all commits for a sedimentree.
+     */
+    deleteAllCommits(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * Delete all fragments for a sedimentree.
+     */
+    deleteAllFragments(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * Delete a commit by digest.
+     */
+    deleteCommit(sedimentree_id: SedimentreeId, digest: Digest): Promise<any>;
+    /**
+     * Delete a fragment by digest.
+     */
+    deleteFragment(sedimentree_id: SedimentreeId, digest: Digest): Promise<any>;
+    /**
+     * Delete a sedimentree ID.
+     */
+    deleteSedimentreeId(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * List all commit digests for a sedimentree.
+     */
+    listCommitDigests(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * List all fragment digests for a sedimentree.
+     */
+    listFragmentDigests(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * Load all commits for a sedimentree, returning `CommitWithBlob[]`.
+     */
+    loadAllCommits(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * Load all fragments for a sedimentree, returning `FragmentWithBlob[]`.
+     */
+    loadAllFragments(sedimentree_id: SedimentreeId): Promise<any>;
+    /**
+     * Load all sedimentree IDs.
+     */
+    loadAllSedimentreeIds(): Promise<any>;
+    /**
+     * Load a commit by digest, returning `CommitWithBlob` or null.
+     */
+    loadCommit(sedimentree_id: SedimentreeId, digest: Digest): Promise<any>;
+    /**
+     * Load a fragment by digest, returning `FragmentWithBlob` or null.
+     */
+    loadFragment(sedimentree_id: SedimentreeId, digest: Digest): Promise<any>;
+    /**
+     * Create a new in-memory storage instance.
+     */
+    constructor();
+    /**
+     * Save a commit with its blob.
+     */
+    saveCommit(sedimentree_id: SedimentreeId, _digest: Digest, signed_commit: SignedLooseCommit, blob: Uint8Array): Promise<any>;
+    /**
+     * Save a fragment with its blob.
+     */
+    saveFragment(sedimentree_id: SedimentreeId, _digest: Digest, signed_fragment: SignedFragment, blob: Uint8Array): Promise<any>;
+    /**
+     * Save a sedimentree ID.
+     */
+    saveSedimentreeId(sedimentree_id: SedimentreeId): Promise<any>;
+}
+
+/**
+ * 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 MessagePortTransport {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Disconnect (close the port) and fire the `onDisconnect` callback if registered.
+     */
+    disconnect(): Promise<any>;
+    /**
+     * Create a new connection wrapping the given `MessagePort`.
+     */
+    constructor(port: any);
+    /**
+     * Register a callback to be invoked when the transport disconnects.
+     *
+     * Part of the [`Transport`](super::JsTransport) interface contract.
+     * Typically called by internal wiring rather than directly by user code.
+     */
+    onDisconnect(callback: Function): void;
+    /**
+     * Receive raw bytes (for the handshake phase).
+     */
+    recvBytes(): Promise<any>;
+    /**
+     * Send raw bytes (for the handshake phase).
+     */
+    sendBytes(bytes: Uint8Array): Promise<any>;
+}
+
+/**
+ * A 64-bit nonce represented as big-endian bytes.
+ */
+export class Nonce {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new [`WasmNonce`] from exactly 8 big-endian bytes.
+     *
+     * # Errors
+     *
+     * Returns [`WasmNonceError`] if the input is not exactly 8 bytes.
+     */
+    constructor(bytes: Uint8Array);
+    /**
+     * Generate a random nonce.
+     *
+     * # Panics
+     *
+     * Panics if the system random number generator fails.
+     */
+    static random(): Nonce;
+    /**
+     * Get the nonce as big-endian bytes.
+     */
+    readonly bytes: Uint8Array;
+}
+
+/**
+ * Result of a peer batch sync request.
+ */
+export class PeerBatchSyncResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Statistics about the sync operation.
+     */
+    readonly stats: SyncStats;
+    /**
+     * Whether the batch sync was successful with at least one connection.
+     */
+    readonly success: boolean;
+    /**
+     * Errors that occurred during the batch sync.
+     */
+    readonly transportErrors: Error[];
+}
+
+/**
+ * A JavaScript-compatible wrapper around the Rust `PeerId` type.
+ */
+export class PeerId {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Creates a new `WasmPeerId` from a `PeerId`.
+     *
+     * # Errors
+     *
+     * Returns a `WasmInvalidPeerId` if the provided byte slice is not exactly 32 bytes long.
+     */
+    constructor(bytes: Uint8Array);
+    /**
+     * Returns the byte representation of the `PeerId`.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Returns the string representation of the `PeerId`.
+     */
+    toString(): string;
+}
+
+/**
+ * Map of peer IDs to their batch sync results.
+ */
+export class PeerResultMap {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get all entries in the peer result map.
+     */
+    entries(): PeerBatchSyncResult[];
+    /**
+     * Get the result for a specific peer ID.
+     */
+    getResult(peer_id: PeerId): PeerBatchSyncResult | undefined;
+}
+
+/**
+ * Wasm wrapper for [`RequestId`].
+ */
+export class RequestId {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmRequestId`].
+     */
+    __wasm_refgen_toWasmRequestId(): RequestId;
+    /**
+     * Create a new [`RequestId`] from a requestor peer ID and nonce.
+     */
+    constructor(requestor: PeerId, nonce: Nonce);
+    /**
+     * The request nonce.
+     */
+    readonly nonce: Nonce;
+    /**
+     * The peer ID of the requestor.
+     */
+    readonly requestor: PeerId;
+}
+
+/**
+ * The main Sedimentree data structure.
+ */
+export class Sedimentree {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create an empty Sedimentree.
+     */
+    static empty(): Sedimentree;
+    /**
+     * Create a new Sedimentree from fragments and loose commits.
+     */
+    constructor(fragments: Fragment[], commits: LooseCommit[]);
+}
+
+/**
+ * A Wasm wrapper around the [`SedimentreeId`] type.
+ */
+export class SedimentreeId {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmSedimentreeId`].
+     */
+    __wasm_refgen_toWasmSedimentreeId(): SedimentreeId;
+    /**
+     * Create an ID from a byte array.
+     *
+     * # Errors
+     *
+     * Returns `Not32Bytes` if the provided byte array is not exactly 32 bytes long.
+     */
+    static fromBytes(bytes: Uint8Array): SedimentreeId;
+    /**
+     * Returns the raw bytes of this ID.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Returns the string representation of the ID.
+     */
+    toString(): string;
+}
+
+export class SedimentreeIdsArray {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmSedimentreeIdsArray`].
+     */
+    __wasm_refgen_toWasmSedimentreeIdsArray(): SedimentreeIdsArray;
+}
+
+/**
+ * A Wasm wrapper around `Signed<Fragment>`.
+ */
+export class SignedFragment {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmSignedFragment`].
+     */
+    __wasm_refgen_toWasmSignedFragment(): SignedFragment;
+    /**
+     * Encode this signed fragment to raw bytes.
+     */
+    encode(): Uint8Array;
+    /**
+     * Decode a `SignedFragment` from raw bytes.
+     *
+     * # Errors
+     *
+     * Returns an error if the bytes are not a valid signed fragment.
+     */
+    static tryDecode(bytes: Uint8Array): SignedFragment;
+    /**
+     * Get the unsigned payload without re-verifying the signature.
+     *
+     * # Errors
+     *
+     * Returns an error if the payload cannot be decoded.
+     */
+    readonly payload: Fragment;
+}
+
+/**
+ * A Wasm wrapper around `Signed<LooseCommit>`.
+ */
+export class SignedLooseCommit {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Upcasts; to the JS-import type for [`WasmSignedLooseCommit`].
+     */
+    __wasm_refgen_toWasmSignedLooseCommit(): SignedLooseCommit;
+    /**
+     * Encode this signed loose commit to raw bytes.
+     */
+    encode(): Uint8Array;
+    /**
+     * Decode a `SignedLooseCommit` from raw bytes.
+     *
+     * # Errors
+     *
+     * Returns an error if the bytes are not a valid signed loose commit.
+     */
+    static tryDecode(bytes: Uint8Array): SignedLooseCommit;
+    /**
+     * Get the unsigned payload without re-verifying the signature.
+     *
+     * # Errors
+     *
+     * Returns an error if the payload cannot be decoded.
+     */
+    readonly payload: LooseCommit;
+}
+
+/**
+ * Wasm bindings for [`Subduction`](subduction_core::Subduction)
+ */
+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.
+     *
+     * The commit metadata (including `BlobMeta`) is computed internally from
+     * the provided blob, ensuring consistency by construction.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmWriteError`] if storage, networking, or policy fail.
+     */
+    addCommit(id: SedimentreeId, parents: Digest[], blob: Uint8Array): Promise<FragmentRequested | undefined>;
+    /**
+     * Onboard an authenticated transport: add it and sync all sedimentrees.
+     *
+     * Accepts an [`AuthenticatedTransport`](WasmAuthenticatedTransport),
+     * obtained via [`AuthenticatedTransport.setup`](WasmAuthenticatedTransport::setup),
+     * [`AuthenticatedWebSocket.toTransport`], or [`AuthenticatedLongPoll.toTransport`].
+     *
+     * Returns `true` if this is a new peer, `false` if already connected.
+     *
+     * Add an authenticated transport to tracking.
+     *
+     * This does not perform any synchronization. To sync after adding,
+     * call [`fullSyncWithPeer`](Self::full_sync_with_peer).
+     *
+     * Returns `true` if this is a new peer, `false` if already connected.
+     *
+     * # Errors
+     *
+     * Returns an error if the connection is rejected by the policy.
+     */
+    addConnection(transport: AuthenticatedTransport): Promise<boolean>;
+    /**
+     * Add a fragment with its associated blob to the storage.
+     *
+     * The fragment metadata (including `BlobMeta`) is computed internally from
+     * the provided blob, ensuring consistency by construction.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmWriteError`] if storage, networking, or policy fail.
+     */
+    addFragment(id: SedimentreeId, head: Digest, boundary: Digest[], checkpoints: Digest[], blob: Uint8Array): Promise<void>;
+    /**
+     * Add a Sedimentree.
+     *
+     * # Errors
+     *
+     * Returns [`WasmWriteError`] if there is a problem with storage, networking, or policy.
+     */
+    addSedimentree(id: SedimentreeId, sedimentree: Sedimentree, blobs: Uint8Array[]): Promise<void>;
+    /**
+     * Connect to a peer via WebSocket and add the connection.
+     *
+     * This performs the cryptographic handshake, verifies the server's identity,
+     * and adds the authenticated connection for syncing.
+     *
+     * Returns the verified peer ID on success.
+     *
+     * # Arguments
+     *
+     * * `address` - The WebSocket URL to connect to
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     *
+     * # Errors
+     *
+     * Returns an error if connection, handshake, or adding the connection fails.
+     */
+    connect(address: URL, expected_peer_id: PeerId): Promise<PeerId>;
+    /**
+     * Connect to a peer via WebSocket using discovery mode and add the connection.
+     *
+     * Returns the discovered and verified peer ID on success.
+     *
+     * # Arguments
+     *
+     * * `address` - The WebSocket URL to connect to
+     * * `timeout_milliseconds` - Request timeout in milliseconds (defaults to 30000)
+     * * `service_name` - The service name for discovery (defaults to URL host)
+     *
+     * # Errors
+     *
+     * Returns an error if connection, handshake, or adding the connection fails.
+     */
+    connectDiscover(address: URL, service_name?: string | null): Promise<PeerId>;
+    /**
+     * Connect to a peer via HTTP long-poll using discovery mode.
+     *
+     * Returns the discovered and verified peer ID on success.
+     *
+     * # Arguments
+     *
+     * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
+     * * `timeout_milliseconds` - Request timeout in milliseconds (default: 30000)
+     * * `service_name` - The service name for discovery (defaults to `base_url`)
+     *
+     * # Errors
+     *
+     * Returns an error if connection, handshake, or adding the connection fails.
+     */
+    connectDiscoverLongPoll(base_url: string, service_name?: string | null): Promise<PeerId>;
+    /**
+     * Connect to a peer via HTTP long-poll and add the connection.
+     *
+     * Returns the verified peer ID on success.
+     *
+     * # Arguments
+     *
+     * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     * * `timeout_milliseconds` - Request timeout in milliseconds (default: 30000)
+     *
+     * # Errors
+     *
+     * Returns an error if connection, handshake, or adding the connection fails.
+     */
+    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.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmDisconnectionError`] if disconnection was not graceful.
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Disconnect from a peer by its ID.
+     *
+     * # Errors
+     *
+     * Returns a `WasmDisconnectionError` if disconnection fails.
+     */
+    disconnectFromPeer(peer_id: PeerId): Promise<boolean>;
+    /**
+     * Fetch blobs by their digests, with an optional timeout in milliseconds.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmIoError`] if storage or networking fail.
+     */
+    fetchBlobs(id: SedimentreeId, timeout_milliseconds?: bigint | null): Promise<Uint8Array[] | undefined>;
+    /**
+     * Sync all known Sedimentree IDs with all connected peers.
+     */
+    fullSyncWithAllPeers(timeout_milliseconds?: bigint | null): Promise<PeerBatchSyncResult>;
+    /**
+     * Sync all known Sedimentree IDs with a single peer.
+     *
+     * # Arguments
+     *
+     * * `peer_id` - The peer to sync with
+     * * `subscribe` - Whether to subscribe to future updates (default: `true`)
+     * * `timeout_milliseconds` - Per-call timeout in milliseconds
+     */
+    fullSyncWithPeer(peer_id: PeerId, subscribe?: boolean | null, timeout_milliseconds?: bigint | null): Promise<PeerBatchSyncResult>;
+    /**
+     * Get a local blob by its digest.
+     *
+     * # Errors
+     *
+     * Returns a [`JsStorageError`] if JS storage fails.
+     */
+    getBlob(id: SedimentreeId, digest: Digest): Promise<Uint8Array | undefined>;
+    /**
+     * Get all local blobs for a given Sedimentree ID.
+     *
+     * # Errors
+     *
+     * Returns a [`JsStorageError`] if JS storage fails.
+     */
+    getBlobs(id: SedimentreeId): Promise<Uint8Array[]>;
+    /**
+     * Get all commits for a given Sedimentree ID
+     */
+    getCommits(id: SedimentreeId): Promise<LooseCommit[] | undefined>;
+    /**
+     * Get the peer IDs of all connected peers.
+     */
+    getConnectedPeerIds(): Promise<PeerId[]>;
+    /**
+     * Get all fragments for a given Sedimentree ID
+     */
+    getFragments(id: SedimentreeId): Promise<Fragment[] | undefined>;
+    /**
+     * Hydrate a [`Subduction`] instance from external storage.
+     *
+     * Loads all sedimentree data from storage and reconstructs the in-memory
+     * state before initializing the sync engine.
+     *
+     * # Arguments
+     *
+     * * `signer` - The cryptographic signer for this node's identity
+     * * `storage` - Storage backend for persisting data
+     * * `service_name` - Optional service identifier for discovery mode (e.g., `sync.example.com`).
+     *   When set, clients can connect without knowing the server's peer ID.
+     * * `hash_metric_override` - Optional custom depth metric function
+     * * `max_pending_blob_requests` - Optional maximum number of pending blob requests (default: 10,000)
+     * * `policy` - Optional connection/storage authorization policy.
+     *   Defaults to allow-all.
+     * * `ephemeral_policy` - Optional ephemeral message authorization policy.
+     *   Defaults to allow-all.
+     *
+     * # Panics
+     *
+     * Panics if `hash_metric_override` is `Some` but the underlying JS value
+     * cannot be cast to a `Function`.
+     *
+     * # Errors
+     *
+     * Returns [`WasmHydrationError`] if hydration fails.
+     */
+    static hydrate(signer: any, storage: SedimentreeStorage, service_name?: string | null, hash_metric_override?: (digest: Digest) => Depth | null, max_pending_blob_requests?: number | null, policy?: Policy | null, ephemeral_policy?: EphemeralPolicy | null, on_remote_heads?: Function | null, on_ephemeral?: Function | 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.
+     *
+     * # Arguments
+     *
+     * * `signer` - The cryptographic signer for this node's identity
+     * * `storage` - Storage backend for persisting data
+     * * `service_name` - Optional service identifier for discovery mode (e.g., `sync.example.com`).
+     *   When set, clients can connect without knowing the server's peer ID.
+     * * `hash_metric_override` - Optional custom depth metric function
+     * * `max_pending_blob_requests` - Optional maximum number of pending blob requests (default: 10,000)
+     * * `policy` - Optional connection/storage authorization policy.
+     *   Defaults to allow-all.
+     * * `ephemeral_policy` - Optional ephemeral message authorization policy.
+     *   Defaults to allow-all.
+     *
+     * # Panics
+     *
+     * Panics if `hash_metric_override` is `Some` but the underlying JS value
+     * cannot be cast to a `Function`.
+     */
+    constructor(signer: any, storage: SedimentreeStorage, service_name?: string | null, hash_metric_override?: (digest: Digest) => Depth | null, max_pending_blob_requests?: number | null, policy?: Policy | null, ephemeral_policy?: EphemeralPolicy | null, on_remote_heads?: Function | null, on_ephemeral?: Function | null);
+    /**
+     * Publish an ephemeral message to all subscribers of a topic.
+     *
+     * The payload is opaque bytes — encoding is the caller's responsibility.
+     * Messages are fire-and-forget; delivery is best-effort.
+     *
+     * # Panics
+     *
+     * Panics if the platform's random number generator fails.
+     */
+    publishEphemeral(topic: Topic, payload: Uint8Array): Promise<void>;
+    /**
+     * Remove a Sedimentree and all associated data.
+     *
+     * # Errors
+     *
+     * Returns a [`WasmIoError`] if storage or networking fail.
+     */
+    removeSedimentree(id: SedimentreeId): Promise<void>;
+    /**
+     * Request blobs by their digests from connected peers for a specific sedimentree.
+     */
+    requestBlobs(id: SedimentreeId, digests: Digest[]): Promise<void>;
+    /**
+     * Get all known Sedimentree IDs
+     */
+    sedimentreeIds(): Promise<SedimentreeId[]>;
+    /**
+     * Subscribe to ephemeral messages for the given topics
+     * from all connected peers.
+     */
+    subscribeEphemeral(topics: Topic[]): Promise<void>;
+    /**
+     * Request batch sync for a given Sedimentree ID from all connected peers.
+     *
+     * # Arguments
+     *
+     * * `id` - The sedimentree ID to sync
+     * * `subscribe` - Whether to subscribe for incremental updates
+     * * `timeout_milliseconds` - Optional timeout in milliseconds
+     *
+     * # Errors
+     *
+     * Returns a [`WasmIoError`] if storage or networking fail.
+     */
+    syncWithAllPeers(id: SedimentreeId, subscribe: boolean, timeout_milliseconds?: bigint | null): Promise<PeerResultMap>;
+    /**
+     * Request batch sync for a given Sedimentree ID from a specific peer.
+     *
+     * # Arguments
+     *
+     * * `to_ask` - The peer ID to sync with
+     * * `id` - The sedimentree ID to sync
+     * * `subscribe` - Whether to subscribe for incremental updates
+     * * `timeout_milliseconds` - Optional timeout in milliseconds
+     *
+     * # Errors
+     *
+     * Returns a [`WasmIoError`] if storage or networking fail.
+     */
+    syncWithPeer(to_ask: PeerId, id: SedimentreeId, subscribe: boolean, timeout_milliseconds?: bigint | null): Promise<PeerBatchSyncResult>;
+    /**
+     * Unsubscribe from ephemeral messages for the given topics
+     * from all connected peers.
+     */
+    unsubscribeEphemeral(topics: Topic[]): Promise<void>;
+    /**
+     * Get the backing storage.
+     */
+    readonly storage: any;
+}
+
+/**
+ * JS-facing wrapper around [`HttpLongPollTransport`] that exposes the
+ * byte-oriented [`Transport`](super::JsTransport) interface
+ * (`sendBytes`/`recvBytes`/`disconnect`/`onDisconnect`) so it can be used as a
+ * duck-typed `JsTransport` from JavaScript.
+ */
+export class SubductionHttpLongPoll {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Disconnect from the peer gracefully.
+     *
+     * Fires the `onDisconnect` callback if one is registered.
+     *
+     * # Errors
+     *
+     * Returns an error if the disconnect fails.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Register a callback to be invoked when the transport disconnects.
+     *
+     * Part of the [`Transport`](super::JsTransport) interface contract.
+     * Typically called by internal wiring rather than directly by user code.
+     */
+    onDisconnect(callback: Function): void;
+    /**
+     * Receive the next message frame as raw bytes.
+     *
+     * # Errors
+     *
+     * Returns an error if the inbound channel is closed.
+     */
+    recvBytes(): Promise<Uint8Array>;
+    /**
+     * Send raw bytes over the transport.
+     *
+     * # Errors
+     *
+     * Returns an error if the outbound channel is closed.
+     */
+    sendBytes(bytes: Uint8Array): Promise<void>;
+}
+
+/**
+ * HTTP long-poll transport factory for browser/worker environments.
+ *
+ * Analogous to [`SubductionWebSocket`] but uses HTTP long-poll instead of WebSocket.
+ */
+export class SubductionLongPoll {
+    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)
+     * * `on_disconnect` - Optional callback invoked with the peer's [`PeerId`] when the connection closes
+     *
+     * # Errors
+     *
+     * Returns [`LongPollTransportError`] if connection or handshake fails.
+     */
+    static tryConnect(base_url: string, signer: any, expected_peer_id: PeerId, on_disconnect?: Function | null): Promise<AuthenticatedLongPoll>;
+    /**
+     * Connect to a server using discovery mode.
+     *
+     * # Arguments
+     *
+     * * `base_url` - The server's HTTP base URL (e.g., `http://localhost:8080`)
+     * * `signer` - The client's signer for authentication
+     * * `service_name` - The service name for discovery. If omitted, the base URL is used.
+     *
+     * # Errors
+     *
+     * Returns [`LongPollTransportError`] if connection or handshake fails.
+     */
+    static tryDiscover(base_url: string, signer: any, service_name?: string | null, on_disconnect?: Function | null): Promise<AuthenticatedLongPoll>;
+}
+
+/**
+ * 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;
+    /**
+     * Disconnect from the peer gracefully.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Register a callback to be invoked when the WebSocket closes.
+     *
+     * Part of the [`Transport`](super::JsTransport) interface contract.
+     * Typically called by internal wiring (factory methods like `tryConnect`
+     * and `tryDiscover`) rather than directly by user code.
+     *
+     * The callback is fired from the browser WebSocket's `onclose` handler.
+     */
+    onDisconnect(callback: Function): void;
+    /**
+     * Receive the next message frame as raw bytes.
+     *
+     * # Errors
+     *
+     * Returns [`ReadFromClosedChannel`] if the channel has been closed.
+     */
+    recvBytes(): Promise<Uint8Array>;
+    /**
+     * Send raw bytes over the WebSocket.
+     *
+     * # Errors
+     *
+     * Returns [`WasmSendError`] if the bytes could not be sent.
+     */
+    sendBytes(bytes: Uint8Array): Promise<void>;
+    /**
+     * Authenticate an existing WebSocket via handshake.
+     *
+     * This performs the Subduction handshake protocol over the provided WebSocket
+     * to establish mutual identity. The WebSocket can be in CONNECTING or OPEN state.
+     *
+     * # Arguments
+     *
+     * * `ws` - An existing WebSocket (CONNECTING or OPEN)
+     * * `signer` - The client's signer for authentication
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     * * `on_disconnect` - Optional callback invoked with the peer's [`PeerId`] when the connection closes
+     *
+     * # Errors
+     *
+     * Returns an error if the handshake fails (signature invalid, wrong peer, etc.)
+     */
+    static setup(ws: WebSocket, signer: any, expected_peer_id: PeerId, on_disconnect?: Function | null): Promise<AuthenticatedWebSocket>;
+    /**
+     * Connect to a WebSocket server with mutual authentication via handshake.
+     *
+     * # Arguments
+     *
+     * * `address` - The WebSocket URL to connect to
+     * * `signer` - The client's signer for authentication
+     * * `expected_peer_id` - The expected server peer ID (verified during handshake)
+     * * `on_disconnect` - Optional callback invoked with the peer's [`PeerId`] when the connection closes
+     *
+     * # Errors
+     *
+     * Returns an error if:
+     * - The WebSocket connection could not be established
+     * - The handshake fails (signature invalid, wrong server, clock drift, etc.)
+     */
+    static tryConnect(address: URL, signer: any, expected_peer_id: PeerId, on_disconnect?: Function | null): Promise<AuthenticatedWebSocket>;
+    /**
+     * Connect to a WebSocket server using discovery mode.
+     *
+     * This method performs a cryptographic handshake using a service name
+     * instead of a known peer ID. The server's peer ID is discovered during
+     * the handshake and returned.
+     *
+     * # Arguments
+     *
+     * * `address` - The WebSocket URL to connect to
+     * * `signer` - The client's signer for authentication
+     * * `service_name` - The service name for discovery (e.g., `localhost:8080`).
+     *   If omitted, the host is extracted from the URL.
+     * * `on_disconnect` - Optional callback invoked with the peer's [`PeerId`] when the connection closes
+     *
+     * # Errors
+     *
+     * Returns an error if:
+     * - The WebSocket connection could not be established
+     * - The handshake fails (signature invalid, clock drift, etc.)
+     */
+    static tryDiscover(address: URL, signer: any, service_name?: string | null, on_disconnect?: Function | 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;
+}
+
+/**
+ * Statistics from a sync operation.
+ *
+ * The "sent" counts reflect items that were _successfully_ sent over the wire,
+ * not just items that were requested.
+ */
+export class SyncStats {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of commits received from the peer.
+     */
+    readonly commitsReceived: number;
+    /**
+     * Number of commits successfully sent to the peer.
+     */
+    readonly commitsSent: number;
+    /**
+     * Number of fragments received from the peer.
+     */
+    readonly fragmentsReceived: number;
+    /**
+     * Number of fragments successfully sent to the peer.
+     */
+    readonly fragmentsSent: number;
+    /**
+     * Returns true if no commits or fragments were transferred.
+     *
+     * Note: `remoteHeads` may still be non-empty (heads metadata is not
+     * considered "data" for this check).
+     */
+    readonly isEmpty: boolean;
+    /**
+     * The remote peer's heads for this sedimentree.
+     */
+    readonly remoteHeads: Digest[];
+    /**
+     * Total items received (commits + fragments).
+     */
+    readonly totalReceived: number;
+    /**
+     * Total items sent (commits + fragments).
+     */
+    readonly totalSent: number;
+}
+
+/**
+ * A Wasm wrapper around the ephemeral [`Topic`] type.
+ *
+ * Topics are opaque 32-byte identifiers for ephemeral pubsub channels.
+ * A [`SedimentreeId`] can be used as a topic, but topics are not
+ * limited to sedimentrees.
+ *
+ * [`SedimentreeId`]: sedimentree_core::id::SedimentreeId
+ */
+export class Topic {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a topic from a 32-byte array.
+     *
+     * # Errors
+     *
+     * Returns an error if the provided byte array is not exactly 32 bytes.
+     */
+    static fromBytes(bytes: Uint8Array): Topic;
+    /**
+     * Returns the raw 32 bytes of this topic.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Returns a shortened hex prefix representation (first 4 bytes + `…`).
+     */
+    toString(): string;
+}
+
+/**
+ * An Ed25519 signer using the browser's `WebCrypto` API.
+ *
+ * This signer generates and stores Ed25519 keys using `crypto.subtle`,
+ * providing secure key generation and signing operations. The key is
+ * persisted to `IndexedDB` so it survives page reloads.
+ *
+ * # Example
+ *
+ * ```javascript
+ * import { WebCryptoSigner } from "@anthropic/subduction";
+ *
+ * const signer = await WebCryptoSigner.setup();
+ * console.log("Peer ID:", signer.peerId().toString());
+ * ```
+ */
+export class WebCryptoSigner {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get the peer ID derived from this signer's verifying key.
+     *
+     * # Panics
+     *
+     * Panics if the stored public key bytes are invalid (should never happen).
+     */
+    peerId(): PeerId;
+    /**
+     * Set up the signer, loading an existing key from `IndexedDB` or generating a new one.
+     *
+     * # Errors
+     *
+     * Returns an error if `WebCrypto` or `IndexedDB` operations fail.
+     */
+    static setup(): Promise<WebCryptoSigner>;
+    /**
+     * Sign a message and return the 64-byte Ed25519 signature.
+     *
+     * # Errors
+     *
+     * Returns an error if `WebCrypto` signing fails.
+     */
+    sign(message: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get the 32-byte Ed25519 verifying (public) key.
+     */
+    verifyingKey(): Uint8Array;
+}
+
+/**
+ * Convenience factory — equivalent to `new MessagePortTransport(port)`.
+ */
+export function makeMessagePortTransport(port: any): MessagePortTransport;
+
+/**
+ * Entry point called when the Wasm module is instantiated.
+ *
+ * Only compiled when the `standalone` feature is active. Downstream cdylib
+ * crates that define their own `#[wasm_bindgen(start)]` should depend on
+ * `subduction_wasm` with `default-features = false` and call
+ * [`set_panic_hook`] from their own start function.
+ */
+export function start(): void;