@automerge/subduction 0.4.2-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,1344 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export interface Connection {
+    peerId(): PeerId;
+    disconnect(): Promise<void>;
+    send(message: Message): Promise<void>;
+    recv(): Promise<Message>;
+    nextRequestId(): Promise<RequestId>;
+    call(request: BatchSyncRequest, timeoutMs: number | null): Promise<BatchSyncResponse>;
+}
+
+
+
+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>;
+}
+
+
+
+/**
+ * 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;
+    /**
+     * The verified peer identity.
+     */
+    readonly peerId: PeerId;
+    /**
+     * The session ID assigned by the server.
+     */
+    readonly sessionId: string;
+}
+
+/**
+ * An authenticated WebSocket connection.
+ *
+ * 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;
+    /**
+     * 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 from the unified transport.
+ */
+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 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`.
+ */
+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 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>;
+}
+
+/**
+ * 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 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;
+    /**
+     * List of connection errors that occurred during the batch sync.
+     */
+    readonly connErrors: ConnErrorPair[];
+    /**
+     * Statistics about the sync operation.
+     */
+    readonly stats: SyncStats;
+    /**
+     * Whether the batch sync was successful with at least one connection.
+     */
+    readonly success: boolean;
+}
+
+/**
+ * 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;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * Attach an authenticated WebSocket connection and sync all sedimentrees.
+     *
+     * The connection must have been authenticated via [`SubductionWebSocket::setup`],
+     * [`SubductionWebSocket::tryConnect`], or [`SubductionWebSocket::tryDiscover`].
+     *
+     * Returns `true` if this is a new peer, `false` if already connected.
+     *
+     * # Errors
+     *
+     * Returns an error if registration or sync fails.
+     */
+    attach(conn: AuthenticatedWebSocket): Promise<boolean>;
+    /**
+     * Connect to a peer via WebSocket and register the connection.
+     *
+     * This performs the cryptographic handshake, verifies the server's identity,
+     * and registers the authenticated connection for syncing.
+     *
+     * Returns the verified peer ID on success.
+     *
+     * # 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)
+     * * `timeout_milliseconds` - Request timeout in milliseconds
+     *
+     * # Errors
+     *
+     * Returns an error if connection, handshake, or registration fails.
+     */
+    connect(address: URL, signer: any, expected_peer_id: PeerId, timeout_milliseconds: number): Promise<PeerId>;
+    /**
+     * Connect to a peer via WebSocket using discovery mode and register the connection.
+     *
+     * Returns the discovered and verified peer ID on success.
+     *
+     * # Arguments
+     *
+     * * `address` - The WebSocket URL to connect to
+     * * `signer` - The client's signer for authentication
+     * * `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 registration fails.
+     */
+    connectDiscover(address: URL, signer: any, timeout_milliseconds?: number | null, 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`)
+     * * `signer` - The client's signer for authentication
+     * * `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 registration fails.
+     */
+    connectDiscoverLongPoll(base_url: string, signer: any, timeout_milliseconds?: number | null, service_name?: string | null): Promise<PeerId>;
+    /**
+     * Connect to a peer via HTTP long-poll and register the connection.
+     *
+     * Returns the verified peer ID on success.
+     *
+     * # 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)
+     *
+     * # Errors
+     *
+     * Returns an error if connection, handshake, or registration fails.
+     */
+    connectLongPoll(base_url: string, signer: any, expected_peer_id: PeerId, timeout_milliseconds?: number | null): 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>;
+    /**
+     * Request batch sync for all known Sedimentree IDs from all connected peers.
+     */
+    fullSync(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.
+     *
+     * # 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)
+     *
+     * # 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): Promise<Subduction>;
+    /**
+     * 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)
+     */
+    constructor(signer: any, storage: SedimentreeStorage, service_name?: string | null, hash_metric_override?: (digest: Digest) => Depth | null, max_pending_blob_requests?: number | null);
+    /**
+     * 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[]>;
+    /**
+     * 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.
+     */
+    syncAll(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>;
+    /**
+     * Get the backing storage.
+     */
+    readonly storage: any;
+}
+
+/**
+ * HTTP long-poll connection 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)
+     * * `timeout_milliseconds` - Request timeout in milliseconds (default: 30000)
+     *
+     * # Errors
+     *
+     * Returns [`LongPollConnectionError`] if connection or handshake fails.
+     */
+    static tryConnect(base_url: string, signer: any, expected_peer_id: PeerId, timeout_milliseconds?: number | 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
+     * * `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.
+     */
+    static tryDiscover(base_url: string, signer: any, timeout_milliseconds?: number | null, service_name?: string | null): Promise<AuthenticatedLongPoll>;
+}
+
+/**
+ * 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 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Make a synchronous call to the peer.
+     *
+     * # Errors
+     *
+     * Returns an error if the call fails or times out.
+     */
+    call(request: BatchSyncRequest, timeout_ms?: number | null): Promise<BatchSyncResponse>;
+    /**
+     * Disconnect from the peer gracefully.
+     *
+     * # Errors
+     *
+     * Returns [`WasmLongPollConnError`] if the disconnect fails.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get the next request ID.
+     */
+    nextRequestId(): Promise<RequestId>;
+    /**
+     * Get the peer ID of the remote peer.
+     */
+    peerId(): PeerId;
+    /**
+     * Receive a message.
+     *
+     * # Errors
+     *
+     * Returns an error if the inbound channel is closed.
+     */
+    recv(): Promise<Message>;
+    /**
+     * Send a message.
+     *
+     * # Errors
+     *
+     * Returns an error if the outbound channel is closed.
+     */
+    send(message: Message): Promise<void>;
+}
+
+/**
+ * A WebSocket connection with internal wiring for [`Subduction`] message handling.
+ */
+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.
+     *
+     * # Errors
+     *
+     * Returns [`ReadFromClosedChannel`] if the channel has been closed.
+     */
+    recv(): Promise<Message>;
+    /**
+     * Send a message.
+     *
+     * # Errors
+     *
+     * Returns [`WasmSendError`] if the message could not be sent over the WebSocket.
+     */
+    send(wasm_message: Message): 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)
+     * * `timeout_milliseconds` - Request timeout in milliseconds
+     *
+     * # Errors
+     *
+     * 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>;
+    /**
+     * 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)
+     * * `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>;
+    /**
+     * 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
+     * * `timeout_milliseconds` - Request timeout in milliseconds. Defaults to 30000 (30s).
+     * * `service_name` - The service name for discovery (e.g., `localhost:8080`).
+     *   If omitted, the host is extracted from the URL.
+     *
+     * # 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, timeout_milliseconds?: number | null, service_name?: string | null): Promise<AuthenticatedWebSocket>;
+}
+
+/**
+ * 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 data was exchanged.
+     */
+    readonly isEmpty: boolean;
+    /**
+     * Total items received (commits + fragments).
+     */
+    readonly totalReceived: number;
+    /**
+     * Total items sent (commits + fragments).
+     */
+    readonly totalSent: number;
+}
+
+/**
+ * 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;
+}