@afterrealism/dendri-client 2.3.7

package/dist/store-RTivRmUW.d.cts

@@ -0,0 +1,1378 @@
+import { EventEmitter, ValidEventTypes } from 'eventemitter3';
+
+interface EventsWithError<ErrorType extends string> {
+    error: (error: DendriError<`${ErrorType}`>) => void;
+}
+declare class EventEmitterWithError<ErrorType extends string, Events extends EventsWithError<ErrorType>> extends EventEmitter<Events, never> {
+    /**
+     * Emits a typed error message.
+     *
+     * @internal
+     */
+    emitError(type: ErrorType, err: string | Error, retryable?: boolean): void;
+}
+/**
+ * A DendriError is emitted whenever an error occurs.
+ * It always has a `.type`, which can be used to identify the error.
+ */
+declare class DendriError<T extends string> extends Error {
+    type: T;
+    /** Whether the operation that caused this error can be retried. */
+    retryable: boolean;
+    /** Structured context about the error. */
+    details?: Record<string, unknown>;
+    /**
+     * @internal
+     */
+    constructor(type: T, err: Error | string);
+    /** Set the retryable flag (fluent API). */
+    setRetryable(retryable: boolean): this;
+    /** Set structured details (fluent API). */
+    setDetails(details: Record<string, unknown>): this;
+}
+
+declare enum ConnectionType {
+    Data = "data",
+    Media = "media"
+}
+declare enum DendriErrorType {
+    /**
+     * The client's browser does not support some or all WebRTC features that you are trying to use.
+     */
+    BrowserIncompatible = "browser-incompatible",
+    /**
+     * You've already disconnected this peer from the server and can no longer make any new connections on it.
+     */
+    Disconnected = "disconnected",
+    /**
+     * The ID passed into the Peer constructor contains illegal characters.
+     */
+    InvalidID = "invalid-id",
+    /**
+     * The API key passed into the Peer constructor contains illegal characters or is not in the system (cloud server only).
+     */
+    InvalidKey = "invalid-key",
+    /**
+     * Lost or cannot establish a connection to the signalling server.
+     */
+    Network = "network",
+    /**
+     * The peer you're trying to connect to does not exist.
+     */
+    PeerUnavailable = "peer-unavailable",
+    /**
+     * Dendri is being used securely, but the cloud server does not support SSL. Use a custom DendriServer.
+     */
+    SslUnavailable = "ssl-unavailable",
+    /**
+     * Unable to reach the server.
+     */
+    ServerError = "server-error",
+    /**
+     * An error from the underlying socket.
+     */
+    SocketError = "socket-error",
+    /**
+     * The underlying socket closed unexpectedly.
+     */
+    SocketClosed = "socket-closed",
+    /**
+     * The ID passed into the Peer constructor is already taken.
+     *
+     * :::caution
+     * This error is not fatal if your peer has open peer-to-peer connections.
+     * This can happen if you attempt to {@apilink Dendri.reconnect} a peer that has been disconnected from the server,
+     * but its old ID has now been taken.
+     * :::
+     */
+    UnavailableID = "unavailable-id",
+    /**
+     * Native WebRTC errors.
+     */
+    WebRTC = "webrtc"
+}
+declare enum BaseConnectionErrorType {
+    NegotiationFailed = "negotiation-failed",
+    ConnectionClosed = "connection-closed"
+}
+declare enum DataConnectionErrorType {
+    NotOpenYet = "not-open-yet",
+    MessageTooBig = "message-too-big",
+    /** @deprecated Use {@link MessageTooBig} instead */
+    MessageToBig = "message-too-big"
+}
+declare enum SerializationType {
+    Binary = "binary",
+    BinaryUTF8 = "binary-utf8",
+    JSON = "json",
+    None = "raw"
+}
+declare enum SocketEventType {
+    Message = "message",
+    Disconnected = "disconnected",
+    Error = "error",
+    Close = "close",
+    Reconnected = "reconnected",
+    ReconnectAttempt = "reconnect-attempt"
+}
+declare enum ServerMessageType {
+    Heartbeat = "HEARTBEAT",
+    Candidate = "CANDIDATE",
+    Offer = "OFFER",
+    Answer = "ANSWER",
+    Open = "OPEN",// The connection to the server is open.
+    Error = "ERROR",// Server error.
+    IdTaken = "ID-TAKEN",// The selected ID is taken.
+    InvalidKey = "INVALID-KEY",// The given API key cannot be found.
+    Leave = "LEAVE",// Another peer has closed its connection to this peer.
+    Expire = "EXPIRE",// The offer sent to a peer has expired without response.
+    Data = "DATA",// Relayed data message via WebSocket.
+    Ack = "ACK",// Server acknowledgement with sequence number.
+    RoomJoin = "ROOM-JOIN",// A peer joined a room.
+    RoomLeave = "ROOM-LEAVE",// A peer left a room.
+    RoomPeers = "ROOM-PEERS",// List of peers in a room.
+    HostMigrate = "HOST-MIGRATE",// Host migration notification.
+    PresenceUpdate = "PRESENCE-UPDATE",// Presence data broadcast.
+    KeyExchange = "KEY-EXCHANGE"
+}
+declare enum TransportMode {
+    WebRTC = "webrtc",
+    WebSocketRelay = "ws-relay",
+    Reconnecting = "reconnecting"
+}
+declare enum ConnectionState {
+    /** Initial state, not yet connected */
+    Initialized = "initialized",
+    /** Attempting to connect to signaling server */
+    Connecting = "connecting",
+    /** Connected and ready */
+    Connected = "connected",
+    /** Temporarily disconnected, will auto-reconnect */
+    Disconnected = "disconnected",
+    /** Extended offline, slower retry schedule */
+    Suspended = "suspended",
+    /** Explicitly closed by user */
+    Closed = "closed",
+    /** Unrecoverable error */
+    Failed = "failed"
+}
+declare enum ConnectionQuality {
+    Excellent = "excellent",
+    Good = "good",
+    Poor = "poor",
+    Unknown = "unknown"
+}
+
+interface ServerMessage {
+    type: ServerMessageType;
+    payload: any;
+    src: string;
+    /** Server-assigned sequence number for reliable ordering / replay. */
+    seq?: number;
+    /** Room name associated with this message. */
+    room?: string;
+    /** Server-assigned timestamp (epoch ms). */
+    timestamp?: number;
+    /** ACK identifier for delivery confirmation. */
+    ackId?: string;
+    /** Optional topic for data multiplexing / filtering. */
+    topic?: string;
+}
+
+interface BaseConnectionEvents<ErrorType extends string = BaseConnectionErrorType> extends EventsWithError<ErrorType> {
+    /**
+     * Emitted when either you or the remote peer closes the connection.
+     *
+     * ```ts
+     * connection.on('close', () => { ... });
+     * ```
+     */
+    close: () => void;
+    /**
+     * ```ts
+     * connection.on('error', (error) => { ... });
+     * ```
+     */
+    error: (error: DendriError<`${ErrorType}`>) => void;
+    iceStateChanged: (state: RTCIceConnectionState) => void;
+}
+declare abstract class BaseConnection<SubClassEvents extends ValidEventTypes, ErrorType extends string = never> extends EventEmitterWithError<ErrorType | BaseConnectionErrorType, SubClassEvents & BaseConnectionEvents<BaseConnectionErrorType | ErrorType>> {
+    /**
+     * The ID of the peer on the other end of this connection.
+     */
+    readonly peer: string;
+    provider: Dendri | null;
+    readonly options: any;
+    protected _open: boolean;
+    /**
+     * Any type of metadata associated with the connection,
+     * passed in by whoever initiated the connection.
+     */
+    readonly metadata: any;
+    connectionId: string;
+    peerConnection: RTCPeerConnection | null;
+    dataChannel: RTCDataChannel | null;
+    abstract get type(): ConnectionType;
+    /**
+     * The optional label passed in or assigned by Dendri when the connection was initiated.
+     */
+    label: string;
+    /**
+     * Whether the media connection is active (e.g. your call has been answered).
+     * You can check this if you want to set a maximum wait time for a one-sided call.
+     */
+    get open(): boolean;
+    protected constructor(
+    /**
+     * The ID of the peer on the other end of this connection.
+     */
+    peer: string, provider: Dendri | null, options: any);
+    abstract close(): void;
+    /**
+     * @internal
+     */
+    abstract handleMessage(message: ServerMessage): void;
+    /**
+     * Called by the Negotiator when the DataChannel is ready.
+     * @internal
+     * */
+    abstract _initializeDataChannel(dc: RTCDataChannel): void;
+}
+
+interface DataConnectionEvents extends EventsWithError<DataConnectionErrorType | BaseConnectionErrorType>, BaseConnectionEvents<DataConnectionErrorType | BaseConnectionErrorType> {
+    /**
+     * Emitted when data is received from the remote peer.
+     */
+    data: (data: unknown) => void;
+    /**
+     * Emitted when the connection is established and ready-to-use.
+     */
+    open: () => void;
+}
+/**
+ * Wraps a DataChannel between two Peers.
+ */
+declare abstract class DataConnection extends BaseConnection<DataConnectionEvents, DataConnectionErrorType> {
+    protected static readonly ID_PREFIX = "dc_";
+    protected static readonly MAX_BUFFERED_AMOUNT: number;
+    private _negotiator;
+    abstract readonly serialization: string;
+    readonly reliable: boolean;
+    get type(): ConnectionType;
+    constructor(peerId: string, provider: Dendri, options: any);
+    /** Called by the Negotiator when the DataChannel is ready. */
+    _initializeDataChannel(dc: RTCDataChannel): void;
+    /**
+     * Exposed functionality for users.
+     */
+    private _flushCloseTimeout;
+    /** Allows user to close connection. */
+    close(options?: {
+        flush?: boolean;
+    }): void;
+    protected abstract _send(data: any, chunked: boolean): void | Promise<void>;
+    /** Allows user to send data. */
+    send(data: any, chunked?: boolean): void | Promise<void>;
+    handleMessage(message: ServerMessage): Promise<void>;
+}
+
+/**
+ * ACK-based message delivery confirmation manager.
+ *
+ * Tracks outgoing messages that expect an acknowledgement and resolves/rejects
+ * the corresponding promise when the ACK arrives or the timeout fires.
+ */
+declare class AckManager {
+    private readonly _pending;
+    private _counter;
+    /** Generate a unique ack ID. */
+    nextId(): string;
+    /**
+     * Register a pending ACK with timeout. When `peerId` is supplied, the
+     * ACK can be rejected early by {@link rejectAllForPeer} when that peer
+     * disconnects, so callers don't wait out the full timeout after the
+     * transport layer already knows the target is gone.
+     */
+    waitForAck(ackId: string, timeoutMs?: number, peerId?: string): Promise<void>;
+    /** Handle an incoming ACK message. Returns true if the ackId was pending. */
+    handleAck(ackId: string): boolean;
+    /**
+     * Reject every pending ACK whose `peerId` matches. Called from the
+     * close path of a per-peer connection so broadcastWithAck promises
+     * resolve with a clear error immediately instead of stalling until
+     * the timeout.
+     */
+    rejectAllForPeer(peerId: string): number;
+    /** Clean up all pending ACKs (e.g. on disconnect). */
+    clear(): void;
+    /** Number of ACKs currently awaiting confirmation. */
+    get pendingCount(): number;
+}
+
+interface AnswerOption {
+    /**
+     * Function which runs before create answer to modify sdp answer message.
+     */
+    sdpTransform?: (sdp: string) => string;
+}
+interface DendriOption {
+    key?: string;
+    host?: string;
+    port?: number;
+    path?: string;
+    secure?: boolean;
+    token?: string;
+    config?: RTCConfiguration;
+    debug?: number;
+    referrerPolicy?: ReferrerPolicy;
+    /** Auto-fetch TURN credentials from the signaling server's GET /turn endpoint. */
+    fetchTurnCredentials?: boolean;
+    /** Optional JWT for authenticated connections. */
+    jwt?: string;
+    /** Enable WebSocket relay fallback when WebRTC is unavailable. */
+    enableRelay?: boolean;
+    /** Optional function to validate connection metadata before accepting. */
+    validateMetadata?: (metadata: unknown) => boolean;
+    /** Signaling transport: 'websocket' (default), 'sse', 'polling', or 'auto' (tries WS then SSE then polling) */
+    signalingTransport?: "websocket" | "sse" | "polling" | "auto";
+}
+interface DendriConnectOption {
+    /**
+     * A unique label by which you want to identify this data connection.
+     * If left unspecified, a label will be generated at random.
+     *
+     * Can be accessed with {@apilink DataConnection.label}
+     */
+    label?: string;
+    /**
+     * Metadata associated with the connection, passed in by whoever initiated the connection.
+     *
+     * Can be accessed with {@apilink DataConnection.metadata}.
+     * Can be any serializable type.
+     */
+    metadata?: any;
+    serialization?: string;
+    reliable?: boolean;
+}
+interface HybridConnectionOption {
+    /** Milliseconds before falling back to WebSocket relay (default 10000). */
+    iceTimeout?: number;
+    /** Periodically retry WebRTC when on relay (default true). */
+    autoUpgrade?: boolean;
+    /** Milliseconds between upgrade attempts (default 60000). */
+    upgradeInterval?: number;
+    /** Max consecutive upgrade failures before stopping (default 5). */
+    maxUpgradeAttempts?: number;
+    /** Poll getStats() for connection quality metrics (default false). */
+    enableMetrics?: boolean;
+    /** Encrypt relay (WebSocket) messages with ECDH + AES-256-GCM (default true). */
+    encryptRelay?: boolean;
+}
+interface CallOption {
+    /**
+     * Metadata associated with the connection, passed in by whoever initiated the connection.
+     *
+     * Can be accessed with {@apilink MediaConnection.metadata}.
+     * Can be any serializable type.
+     */
+    metadata?: any;
+    /**
+     * Function which runs before create offer to modify sdp offer message.
+     */
+    sdpTransform?: (sdp: string) => string;
+}
+
+/** Options accepted by {@link HybridConnection.send}. */
+interface HybridSendOptions {
+    /** When set, the message is tagged with this topic string. */
+    readonly topic?: string;
+}
+interface HybridConnectionEvents {
+    open: () => void;
+    data: (data: unknown) => void;
+    close: () => void;
+    error: (err: Error) => void;
+    transportChanged: (mode: TransportMode) => void;
+    qualityChanged: (quality: ConnectionQuality) => void;
+}
+/**
+ * Wraps both a WebRTC DataConnection and a WebSocket relay,
+ * switching transparently between them.
+ *
+ * - Attempts WebRTC first; falls back to WS relay on ICE timeout.
+ * - Periodically retries WebRTC upgrade when on relay.
+ * - Emits `transportChanged` whenever the active transport switches.
+ */
+declare class HybridConnection extends EventEmitter<HybridConnectionEvents> {
+    readonly peer: string;
+    private readonly _provider;
+    private readonly _options;
+    private _dataConnection;
+    private _mode;
+    private _iceTimer;
+    private _upgradeTimer;
+    private _upgradeAttempts;
+    private _open;
+    private _closed;
+    private readonly _ackManager;
+    private readonly _topics;
+    private readonly _encryption;
+    private readonly _encryptRelay;
+    private _keyExchangeSent;
+    private _pendingRelayQueue;
+    private _expectedSeq;
+    private _reorderBuffer;
+    private readonly _reorderTimeout;
+    private _reorderTimers;
+    constructor(peer: string, provider: Dendri, options?: HybridConnectionOption);
+    get mode(): TransportMode;
+    get open(): boolean;
+    /** Start connection: try WebRTC first, fall back to WS relay on timeout. */
+    start(): void;
+    /** Send data through the best available transport, optionally tagged with a topic. */
+    send(data: unknown, options?: HybridSendOptions): void;
+    /**
+     * Send data with delivery confirmation (at-least-once guarantee).
+     * Resolves when the remote peer ACKs, rejects on timeout.
+     */
+    sendWithAck(data: unknown, timeoutMs?: number): Promise<void>;
+    /**
+     * @internal
+     * Expose the AckManager so the Dendri instance can route incoming ACKs.
+     */
+    get ackManager(): AckManager;
+    /**
+     * Subscribe to messages on a specific topic.
+     * Returns an unsubscribe function.
+     */
+    subscribe(topic: string, handler: (data: unknown, peerId: string) => void): () => void;
+    /**
+     * Subscribe to all incoming data regardless of topic.
+     * Returns an unsubscribe function.
+     */
+    onData(handler: (data: unknown, peerId: string) => void): () => void;
+    /**
+     * Handle a DATA message received via WebSocket relay.
+     * Called by Dendri._handleMessage when routing relay data.
+     *
+     * @param payload - The message payload.
+     * @param seq - Optional server-assigned sequence number for ordering.
+     */
+    handleRelayData(payload: unknown, seq?: number): void;
+    /** Close connection and clean up all resources. */
+    close(): void;
+    /**
+     * Initiate the ECDH key exchange by generating a key pair and sending
+     * the public key to the remote peer via signaling.
+     */
+    initiateKeyExchange(): void;
+    /**
+     * Handle an incoming KEY_EXCHANGE message from the remote peer.
+     * Derives the shared secret and sends our public key back if we haven't yet.
+     */
+    handleKeyExchange(payload: {
+        publicKey: JsonWebKey;
+    }): void;
+    /**
+     * Send a payload via WebSocket relay, encrypting it if encryption is ready.
+     * If encryption is enabled but not yet ready, the message is queued.
+     */
+    private _sendRelay;
+    /** Flush messages that were queued while waiting for key exchange. */
+    private _flushPendingRelayQueue;
+    /**
+     * Enforce ordered delivery for sequenced relay messages.
+     * Messages without a seq or when not in relay mode are delivered immediately.
+     */
+    private _deliverInOrder;
+    /** Flush consecutive messages from the reorder buffer. */
+    private _flushReorderBuffer;
+    /**
+     * Force-flush the reorder buffer when a timeout fires.
+     * Skips past any gaps by advancing _expectedSeq to the lowest buffered
+     * sequence, then delivers all consecutive messages from there.
+     */
+    private _forceFlushReorderBuffer;
+    /**
+     * Route an incoming payload through the TopicManager (if applicable)
+     * and emit the generic `data` event.
+     *
+     * If the payload is a topic envelope, the inner data is extracted and
+     * dispatched to topic-specific handlers. The raw `data` event always fires
+     * with the unwrapped payload so legacy listeners still work.
+     */
+    private _dispatchIncoming;
+    /** Attempt a WebRTC connection with ICE timeout. */
+    private _attemptWebRTC;
+    /** Switch to WebSocket relay and optionally schedule periodic upgrade attempts. */
+    private _fallbackToRelay;
+    /** Update the transport mode and emit if changed. */
+    private _setMode;
+    private _clearIceTimer;
+    private _clearUpgradeTimer;
+    /**
+     * Periodically retry WebRTC when on relay.
+     * Respects `autoUpgrade`, `upgradeInterval`, and `maxUpgradeAttempts` options.
+     */
+    private _scheduleUpgrade;
+}
+
+declare enum LogLevel {
+    /**
+     * Prints no logs.
+     */
+    Disabled = 0,
+    /**
+     * Prints only errors.
+     */
+    Errors = 1,
+    /**
+     * Prints errors and warnings.
+     */
+    Warnings = 2,
+    /**
+     * Prints all logs.
+     */
+    All = 3
+}
+
+interface MediaConnectionEvents extends BaseConnectionEvents<never> {
+    /**
+     * Emitted when a connection to the Dendri server is established.
+     *
+     * ```ts
+     * mediaConnection.on('stream', (stream) => { ... });
+     * ```
+     */
+    stream: (stream: MediaStream) => void;
+    /**
+     * Emitted when the auxiliary data channel is established.
+     * After this event, hanging up will close the connection cleanly on the remote peer.
+     * @beta
+     */
+    willCloseOnRemote: () => void;
+}
+/**
+ * Wraps WebRTC's media streams.
+ * To get one, use {@apilink Dendri.call} or listen for the {@apilink DendriEvents | `call`} event.
+ */
+declare class MediaConnection extends BaseConnection<MediaConnectionEvents> {
+    private static readonly ID_PREFIX;
+    readonly label: string;
+    private _negotiator;
+    private _localStream;
+    private _remoteStream;
+    /**
+     * For media connections, this is always 'media'.
+     */
+    get type(): ConnectionType;
+    get localStream(): MediaStream | null | undefined;
+    get remoteStream(): MediaStream | null;
+    constructor(peerId: string, provider: Dendri, options: any);
+    /** Called by the Negotiator when the DataChannel is ready. */
+    _initializeDataChannel(dc: RTCDataChannel): void;
+    addStream(remoteStream: MediaStream): void;
+    /**
+     * @internal
+     */
+    handleMessage(message: ServerMessage): void;
+    /**
+     * When receiving a {@apilink DendriEvents | `call`} event on a peer, you can call
+     * `answer` on the media connection provided by the callback to accept the call
+     * and optionally send your own media stream.
+
+     *
+     * @param stream A WebRTC media stream.
+     * @param options
+     * @returns
+     */
+    answer(stream?: MediaStream, options?: AnswerOption): void;
+    /**
+     * Exposed functionality for users.
+     */
+    /**
+     * Closes the media connection.
+     */
+    close(): void;
+}
+
+/**
+ * Events emitted by all signaling transports.
+ */
+interface TransportEvents {
+    [SocketEventType.Message]: (data: any) => void;
+    [SocketEventType.Disconnected]: () => void;
+    [SocketEventType.Error]: (error: string) => void;
+    [SocketEventType.Reconnected]: () => void;
+    [SocketEventType.ReconnectAttempt]: (attempt: number) => void;
+}
+/**
+ * Abstract signaling transport. WebSocket, SSE+POST, and Long Polling
+ * all implement this interface so the Dendri class is transport-agnostic.
+ */
+declare abstract class SignalingTransport extends EventEmitter<TransportEvents> {
+    abstract start(id: string, token: string): void;
+    abstract send(data: any): void;
+    abstract close(): void;
+    abstract get reconnectAttempt(): number;
+}
+
+declare class DendriOptions implements DendriOption {
+    /**
+     * Prints log messages depending on the debug level passed in.
+     */
+    debug?: LogLevel;
+    /**
+     * Server host for your Dendri signaling server.
+     * Also accepts `'/'` to signify relative hostname.
+     */
+    host: string;
+    /**
+     * Server port. Defaults to `443`.
+     */
+    port?: number;
+    /**
+     * The path where your self-hosted Dendri server is running. Defaults to `'/'`
+     */
+    path?: string;
+    /**
+     * API key for the Dendri server.
+     * This is not used anymore.
+     * @deprecated
+     */
+    key?: string;
+    token?: string;
+    /**
+     * Configuration hash passed to RTCPeerConnection.
+     * This hash contains any custom ICE/TURN server configuration.
+     *
+     * Defaults to {@apilink util.defaultConfig}
+     */
+    config?: any;
+    /**
+     * Set to true `true` if you're using TLS.
+     * :::danger
+     * If possible *always use TLS*
+     * :::
+     */
+    secure?: boolean;
+    pingInterval?: number;
+    referrerPolicy?: ReferrerPolicy;
+    logFunction?: (logLevel: LogLevel, ...rest: any[]) => void;
+    serializers?: SerializerMapping;
+    /** Auto-fetch TURN credentials from the signaling server's GET /turn endpoint. */
+    fetchTurnCredentials?: boolean;
+    /** Optional JWT for authenticated connections. */
+    jwt?: string;
+    /** Enable WebSocket relay fallback when WebRTC is unavailable. */
+    enableRelay?: boolean;
+    /** Optional function to validate connection metadata before accepting. */
+    validateMetadata?: (metadata: unknown) => boolean;
+    /** Signaling transport: 'websocket' (default), 'sse', 'polling', or 'auto' (tries WS then SSE then polling) */
+    signalingTransport?: "websocket" | "sse" | "polling" | "auto";
+}
+
+interface SerializerMapping {
+    [key: string]: new (peerId: string, provider: Dendri, options: any) => DataConnection;
+}
+interface DendriEvents {
+    /**
+     * Emitted when a connection to the Dendri server is established.
+     *
+     * You may use the peer before this is emitted, but messages to the server will be queued. <code>id</code> is the brokering ID of the peer (which was either provided in the constructor or assigned by the server).<span class='tip'>You should not wait for this event before connecting to other peers if connection speed is important.</span>
+     */
+    open: (id: string) => void;
+    /**
+     * Emitted when a new data connection is established from a remote peer.
+     */
+    connection: (dataConnection: DataConnection) => void;
+    /**
+     * Emitted when a remote peer attempts to call you.
+     */
+    call: (mediaConnection: MediaConnection) => void;
+    /**
+     * Emitted when the peer is destroyed and can no longer accept or create any new connections.
+     */
+    close: () => void;
+    /**
+     * Emitted when the peer is disconnected from the signalling server
+     */
+    disconnected: (currentId: string) => void;
+    /**
+     * Errors on the peer are almost always fatal and will destroy the peer.
+     *
+     * Errors from the underlying socket and PeerConnections are forwarded here.
+     */
+    error: (error: DendriError<`${DendriErrorType}`>) => void;
+    /**
+     * Emitted when the server sends a ROOM_PEERS message with the current
+     * list of peers in a room.
+     */
+    roomPeers: (room: string, peers: string[]) => void;
+    /**
+     * Emitted when the connection state machine transitions to a new state.
+     */
+    connectionStateChanged: (state: ConnectionState, previousState: ConnectionState) => void;
+    /**
+     * Emitted when a PRESENCE_UPDATE message is received from the server.
+     */
+    presenceUpdate: (peerId: string, room: string, data: unknown) => void;
+    /**
+     * Emitted when the underlying signaling socket finishes a successful
+     * reconnection. Consumers (e.g. Room) should re-send server-side
+     * state (joinRoom, presence) so it survives server-side state loss
+     * such as a Durable Object hibernation + wake-up cycle.
+     */
+    reconnected: () => void;
+}
+/**
+ * A peer who can initiate connections with other peers.
+ */
+declare class Dendri extends EventEmitterWithError<DendriErrorType, DendriEvents> {
+    private static readonly DEFAULT_KEY;
+    protected readonly _serializers: SerializerMapping;
+    private readonly _options;
+    private readonly _api;
+    private readonly _socket;
+    private _id;
+    private _lastServerId;
+    private _connectionState;
+    /** Number of consecutive reconnection failures that triggers the Suspended state. */
+    private static readonly SUSPEND_THRESHOLD;
+    private readonly _connections;
+    private readonly _lostMessages;
+    private readonly _lostMessageGeneration;
+    private readonly _hybridConnections;
+    /**
+     * The brokering ID of this peer
+     *
+     * If no ID was specified in {@apilink Dendri | the constructor},
+     * this will be `undefined` until the {@apilink DendriEvents | `open`} event is emitted.
+     */
+    get id(): string | null;
+    get options(): DendriOptions;
+    /**
+     * The current connection state of this peer.
+     */
+    get connectionState(): ConnectionState;
+    get open(): boolean;
+    /**
+     * @internal
+     */
+    get socket(): SignalingTransport;
+    /**
+     * A hash of all connections associated with this peer, keyed by the remote peer's ID.
+     * @deprecated
+     * Return type will change from Object to Map<string,[]>
+     */
+    get connections(): Object;
+    /**
+     * true if this peer and all of its connections can no longer be used.
+     */
+    get destroyed(): boolean;
+    /**
+     * false if there is an active connection to the Dendri server.
+     *
+     * Also returns true for terminal states (Closed/Failed) to preserve
+     * backward compatibility: the original boolean was set during
+     * disconnect() and never cleared by destroy().
+     */
+    get disconnected(): boolean;
+    /**
+     * A peer can connect to other peers and listen for connections.
+     */
+    constructor(options: DendriOptions);
+    /**
+     * A peer can connect to other peers and listen for connections.
+     * @param id Other peers can connect to this peer using the provided ID.
+     *     If no ID is given, one will be generated by the brokering server.
+     * The ID must start and end with an alphanumeric character (lower or upper case character or a digit). In the middle of the ID spaces, dashes (-) and underscores (_) are allowed. Use {@apilink DendriOptions.metadata } to send identifying information.
+     * @param options for specifying details about Dendri server
+     */
+    constructor(id: string, options?: DendriOptions);
+    /**
+     * Transition to a new connection state. Invalid transitions are logged and ignored.
+     */
+    private _setState;
+    private static _isValidTransition;
+    private _createServerConnection;
+    /** Initialize a connection with the server. */
+    private _initialize;
+    /** Handles messages from the server. */
+    private _handleMessage;
+    private static readonly MAX_LOST_MESSAGES;
+    private static readonly LOST_MESSAGE_TTL;
+    /** Stores messages without a set up connection, to be claimed later. */
+    private _storeMessage;
+    /**
+     * Retrieve messages from lost message store
+     * @internal
+     */
+    _getMessages(connectionId: string): ServerMessage[];
+    /**
+     * Connects to the remote peer specified by id and returns a data connection.
+     * @param peer The brokering ID of the remote peer (their {@apilink Dendri.id}).
+     * @param options for specifying details about the data connection
+     */
+    connect(peer: string, options?: DendriConnectOption): DataConnection | undefined;
+    /**
+     * Calls the remote peer specified by id and returns a media connection.
+     * @param peer The brokering ID of the remote peer (their peer.id).
+     * @param stream The caller's media stream
+     * @param options Metadata associated with the connection, passed in by whoever initiated the connection.
+     */
+    call(peer: string, stream: MediaStream, options?: CallOption): MediaConnection | undefined;
+    /**
+     * Create a hybrid connection that uses WebRTC when possible
+     * and transparently falls back to WebSocket relay.
+     *
+     * @param peer The brokering ID of the remote peer.
+     * @param options HybridConnection-specific options (ICE timeout, upgrade behaviour, etc.)
+     */
+    connectHybrid(peer: string, options?: HybridConnectionOption): HybridConnection | undefined;
+    /**
+     * Join a room on the signaling server.
+     * The server will respond with a ROOM_PEERS message listing current members.
+     */
+    joinRoom(roomName: string): void;
+    /**
+     * Leave a room on the signaling server.
+     */
+    leaveRoom(roomName: string): void;
+    /** Auto-fetch TURN credentials when the option is enabled. */
+    private _fetchTurnIfEnabled;
+    /** Add a data/media connection to this peer. */
+    private _addConnection;
+    _removeConnection(connection: DataConnection | MediaConnection): void;
+    /** Retrieve a data/media connection for this peer. */
+    getConnection(peerId: string, connectionId: string): null | DataConnection | MediaConnection;
+    /** Error types that indicate an unrecoverable problem. */
+    private static readonly FATAL_ERROR_TYPES;
+    private _delayedAbort;
+    /**
+     * Emits an error message and destroys the Dendri instance.
+     * The Dendri instance is not destroyed if it's in a disconnected state, in which case
+     * it retains its disconnected state and its existing connections.
+     */
+    private _abort;
+    /**
+     * Destroys the Dendri instance: closes all active connections as well as the connection
+     * to the server.
+     *
+     * :::caution
+     * This cannot be undone; the respective peer object will no longer be able
+     * to create or receive any connections, its ID will be forfeited on the server,
+     * and all of its data and media connections will be closed.
+     * :::
+     */
+    destroy(): void;
+    /** Internal destroy that transitions to the given terminal state. */
+    private _destroyWithState;
+    /** Disconnects every connection on this peer. */
+    private _cleanup;
+    /** Closes all connections to this peer. */
+    private _cleanupPeer;
+    /**
+     * Disconnects the Dendri instance's connection to the Dendri server. Does not close any
+     *  active connections.
+     * Warning: The peer can no longer create or accept connections after being
+     *  disconnected. It also cannot reconnect to the server.
+     */
+    disconnect(): void;
+    /** Attempts to reconnect with the same ID.
+     *
+     * Only {@apilink Dendri.disconnect | disconnected peers} can be reconnected.
+     * Destroyed peers cannot be reconnected.
+     * If the connection fails (as an example, if the peer's old ID is now taken),
+     * the peer's existing connections will not close, but any associated errors events will fire.
+     */
+    reconnect(): void;
+    /**
+     * Get a list of available peer IDs. If you're running your own server, you'll
+     * want to set allow_discovery: true in the Dendri server options.
+     */
+    listAllPeers(cb?: (_: any[]) => void): void;
+    /** Returns a snapshot of the current connection state for debugging. */
+    diagnostics(): {
+        peerId: string | null;
+        connectionState: ConnectionState;
+        serverConnected: boolean;
+        connections: Array<{
+            peerId: string;
+            type: string;
+            open: boolean;
+        }>;
+        hybridConnections: Array<{
+            peerId: string;
+            mode: TransportMode;
+            open: boolean;
+        }>;
+        socket: {
+            connected: boolean;
+            autoReconnect: boolean;
+            reconnectAttempt: number;
+            lastSeq: number;
+        };
+        pendingMessages: number;
+    };
+}
+
+interface PresenceEvents<T> {
+    update: (peerId: string, data: T) => void;
+    join: (peerId: string, data: T) => void;
+    leave: (peerId: string) => void;
+    sync: (presences: ReadonlyMap<string, T>) => void;
+}
+/**
+ * Manages per-peer presence state for a room.
+ *
+ * Each peer can set arbitrary typed state that is broadcast to all room
+ * members. Incoming updates are stored and exposed via getters; lifecycle
+ * events (join, update, leave, sync) are emitted for subscribers.
+ */
+declare class PresenceManager<T = Record<string, unknown>> extends EventEmitter<PresenceEvents<T>> {
+    private readonly _presences;
+    private _myPresence;
+    private _myPeerId;
+    /** Set (or merge) my own presence data. */
+    setMyPresence(data: Partial<T>): void;
+    /** Get a specific peer's presence. */
+    getPresence(peerId: string): T | undefined;
+    /** Get all presences excluding this peer. */
+    getOthers(): Map<string, T>;
+    /** Get all presences (including self). */
+    getAll(): Map<string, T>;
+    /** Handle an incoming presence update from a remote peer. */
+    handleUpdate(peerId: string, data: T): void;
+    /** Handle a peer leaving — remove their presence. */
+    handleLeave(peerId: string): void;
+    /** Set this peer's ID (called by Room on join). */
+    setMyPeerId(id: string): void;
+    /** Clear all presences and local state. */
+    clear(): void;
+    /** The local peer's current presence, or null if not yet set. */
+    get myPresence(): T | null;
+    /** Number of tracked presences (including self if set). */
+    get size(): number;
+}
+
+/**
+ * RPC (Remote Procedure Call) layer for request-response patterns over P2P connections.
+ *
+ * Inspired by LiveKit's `performRpc`/`registerRpcMethod`, this module enables
+ * peers to expose named methods that other peers can call and await results.
+ *
+ * Usage (via Room):
+ *   // Responder
+ *   room.registerRpcMethod("greet", (payload) => `Hello, ${payload}!`);
+ *
+ *   // Caller
+ *   const result = await room.performRpc("greet", "world");
+ *   // result === "Hello, world!"
+ */
+interface RpcRequest {
+    readonly __rpc: true;
+    readonly id: string;
+    readonly method: string;
+    readonly payload: unknown;
+    readonly sender: string;
+}
+interface RpcResponse {
+    readonly __rpc_response: true;
+    readonly id: string;
+    readonly result?: unknown;
+    readonly error?: {
+        readonly code: number;
+        readonly message: string;
+    };
+}
+type RpcHandler = (payload: unknown, sender: string) => unknown | Promise<unknown>;
+/** Standard RPC error codes (inspired by LiveKit). */
+declare enum RpcErrorCode {
+    APPLICATION_ERROR = 1500,
+    CONNECTION_TIMEOUT = 1501,
+    RESPONSE_TIMEOUT = 1502,
+    RECIPIENT_DISCONNECTED = 1503,
+    RESPONSE_PAYLOAD_TOO_LARGE = 1504,
+    METHOD_NOT_FOUND = 1505
+}
+declare class RpcError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+declare class RpcManager {
+    private readonly _handlers;
+    private readonly _pending;
+    private _counter;
+    /** Register a method handler. Returns an unregister function. */
+    registerMethod(name: string, handler: RpcHandler): () => void;
+    /** Perform an RPC call -- returns a promise that resolves with the response. */
+    performRpc(method: string, payload: unknown, sendFn: (data: RpcRequest) => void, options?: {
+        readonly timeout?: number;
+    }): Promise<unknown>;
+    /** Handle an incoming RPC request -- execute handler and return response. */
+    handleRequest(request: RpcRequest): Promise<RpcResponse>;
+    /** Handle an incoming RPC response -- resolve the pending promise. */
+    handleResponse(response: RpcResponse): boolean;
+    /** Clear all pending RPCs, rejecting them with CONNECTION_TIMEOUT. */
+    clear(): void;
+    /** Number of RPCs currently awaiting a response. */
+    get pendingCount(): number;
+    /** Names of all registered RPC methods. */
+    get registeredMethods(): string[];
+}
+/** Type guard for RPC request messages. */
+declare function isRpcRequest(data: unknown): data is RpcRequest;
+/** Type guard for RPC response messages. */
+declare function isRpcResponse(data: unknown): data is RpcResponse;
+
+/**
+ * High-level Room abstraction for star-topology P2P rooms with host migration.
+ *
+ * Usage pattern:
+ *   const room = new Room("my-room");
+ *   room.join({ host: "localhost", port: 9000, secure: false, path: "/" });
+ *   room.on("joined", (peerId, isHost) => { ... });
+ *   room.on("data", (peerId, data) => { ... });
+ *   room.broadcast({ cursor: [10, 20] });
+ *
+ * The Room class is opt-in. Existing Dendri usage patterns are unaffected.
+ */
+
+interface RoomEvents {
+    /** Fired when this peer has successfully joined the room. */
+    joined: (peerId: string, isHost: boolean) => void;
+    /** Fired when a remote peer joins the room. */
+    peerJoined: (peerId: string) => void;
+    /** Fired when a remote peer leaves the room. */
+    peerLeft: (peerId: string) => void;
+    /** Fired when data is received from any peer. */
+    data: (peerId: string, data: unknown) => void;
+    /** Fired when the host changes (either via initial join or migration). */
+    hostChanged: (newHostId: string) => void;
+    /** Fired on errors. */
+    error: (err: Error) => void;
+}
+interface RoomOptions {
+    /** Milliseconds to wait for a new host to become reachable (default 10000). */
+    readonly migrationTimeout?: number;
+}
+/**
+ * A Room manages the lifecycle of a star-topology P2P room:
+ * - First peer to join becomes the host (claims the room ID as its peer ID).
+ * - Subsequent peers connect to the host.
+ * - If the host disconnects, the remaining peer with the lowest alphabetical ID
+ *   takes over as host (deterministic election).
+ */
+declare class Room extends EventEmitter<RoomEvents> {
+    private _peer;
+    private _isHost;
+    private _hostId;
+    private readonly _connections;
+    private readonly _knownPeers;
+    private readonly _topics;
+    private readonly _ackManager;
+    private readonly _rpc;
+    private readonly _presence;
+    private readonly _roomId;
+    private readonly _migrationTimeout;
+    private _dendriOptions;
+    private _DendriCtor;
+    private _migrationTimer;
+    private _roomJoinInterval;
+    private _joined;
+    constructor(roomId: string, options?: RoomOptions);
+    /** Whether this peer is the current host. */
+    get isHost(): boolean;
+    /** The peer ID of the current host, or null if not yet joined. */
+    get hostId(): string | null;
+    /** All known peer IDs in the room (excluding self). */
+    get peers(): string[];
+    /** Number of known peers (excluding self). */
+    get peerCount(): number;
+    /** The local peer's ID, or null if not joined. */
+    get peerId(): string | null;
+    /**
+     * Join the room. Tries to become host first (claims roomId as peer ID).
+     * If the ID is already taken, joins as a client.
+     *
+     * @param DendriCtor - The Dendri constructor to use for creating peer instances.
+     * @param dendriOptions - Options forwarded to the Dendri constructor.
+     */
+    join(DendriCtor: new (id: string, opts?: DendriOptions) => Dendri, dendriOptions: DendriOptions): void;
+    /**
+     * Send data to all peers in the room, optionally tagged with a topic.
+     * Tries WebRTC first; falls back to signaling server DATA relay when
+     * no WebRTC connections are open (e.g. behind a VPN).
+     */
+    broadcast(data: unknown, options?: {
+        readonly topic?: string;
+    }): void;
+    /**
+     * Broadcast a binary payload tagged with a topic. Wraps bytes in a
+     * base64 topic envelope so they survive both WebRTC fanout and the
+     * JSON-only signaling-relay fallback. Receivers see a Uint8Array.
+     */
+    broadcastBinary(bytes: Uint8Array, options: {
+        readonly topic: string;
+    }): void;
+    /**
+     * Broadcast data with delivery confirmation (at-least-once guarantee).
+     * Resolves when all currently connected peers have ACKed.
+     */
+    broadcastWithAck(data: unknown, timeoutMs?: number): Promise<void>;
+    /**
+     * Subscribe to messages on a specific topic.
+     * Returns an unsubscribe function.
+     */
+    subscribe(topic: string, handler: (data: unknown, peerId: string) => void): () => void;
+    /**
+     * Subscribe to all incoming data regardless of topic.
+     * Returns an unsubscribe function.
+     */
+    onData(handler: (data: unknown, peerId: string) => void): () => void;
+    /**
+     * Register an RPC method that other peers can call.
+     * Returns an unregister function.
+     */
+    registerRpcMethod(name: string, handler: RpcHandler): () => void;
+    /**
+     * Call an RPC method on a remote peer (or broadcast to all).
+     *
+     * When `peerId` is specified the request is sent only to that peer.
+     * Otherwise it is broadcast to every connected peer (useful when any
+     * peer may handle the method).
+     */
+    performRpc(method: string, payload: unknown, options?: {
+        readonly timeout?: number;
+        readonly peerId?: string;
+    }): Promise<unknown>;
+    /**
+     * Set my presence data -- automatically broadcast to all room peers
+     * via the signaling server's PRESENCE_UPDATE message.
+     */
+    setPresence<P extends Record<string, unknown>>(data: P): void;
+    /** Get all other peers' presence data. */
+    getOthers(): Map<string, unknown>;
+    /** Get a specific peer's presence data. */
+    getPresence(peerId: string): unknown;
+    /** Get the presence manager for direct event listening. */
+    get presence(): PresenceManager;
+    /**
+     * Leave the room and clean up all connections.
+     */
+    leave(): void;
+    private _tryBecomeHost;
+    /**
+     * Wire up all listeners and register with the server-side room.
+     * Used by every entry path (_tryBecomeHost, _joinAsClient, _becomeHost)
+     * so the three can't drift out of sync. This is the single source of
+     * truth for "a peer has just entered the room".
+     */
+    private _postJoinSetup;
+    private readonly _onSignalingReconnected;
+    private _setupHostListeners;
+    private _joinAsClient;
+    /**
+     * Called when the client detects the host has disconnected.
+     * Elects a new host deterministically (lowest alphabetical peer ID).
+     */
+    private _handleHostDisconnect;
+    /**
+     * This peer won the election. Tear down the old peer and create a new
+     * one using the room ID so other peers can find us.
+     */
+    private _becomeHost;
+    /**
+     * Another peer won the election. Wait for it to claim the room ID,
+     * then connect.
+     */
+    private _connectToNewHost;
+    private _retryConnect;
+    private _handleIncomingData;
+    private _isAckRequest;
+    private _isAckResponse;
+    private _isRoomProtocol;
+    private _handleRoomProtocol;
+    /**
+     * Hook up the underlying Dendri peer's presenceUpdate event so incoming
+     * server-side presence broadcasts are routed to the PresenceManager.
+     */
+    private _setupPresenceListener;
+    /**
+     * Listen for relay DATA messages from the signaling server (room fan-out).
+     * This is the fallback path when WebRTC connections can't be established
+     * (e.g. behind a VPN or restrictive firewall).
+     */
+    private _setupRelayDataListener;
+    /**
+     * Listen for ROOM-PEERS messages from the signaling server and merge them
+     * into `_knownPeers`. This ensures the peer count stays accurate even when
+     * WebRTC connections fail (e.g. behind a VPN or restrictive firewall).
+     *
+     * WebRTC-connected peers are always trusted. Peers that only appear in the
+     * signaling list are added as "signaling-only" so the UI reflects the
+     * correct room membership.
+     */
+    private _setupSignalingPeerTracking;
+    /**
+     * Send data directly to a specific peer.
+     * If host: send via the direct connection.
+     * If client: send via the host connection (host relays).
+     */
+    private _sendToPeer;
+    private _clearMigrationTimer;
+    /**
+     * Periodically re-send ROOM-JOIN to the signaling server so room
+     * membership survives server-side state loss (e.g. DO hibernation).
+     */
+    private _startRoomJoinHeartbeat;
+    private _stopRoomJoinHeartbeat;
+}
+
+/**
+ * Framework-agnostic reactive store factory for Dendri Room.
+ *
+ * Works with any UI framework. Provides a subscribe-based reactivity model
+ * (similar to Svelte stores or Zustand) that can be consumed by:
+ *
+ * - **Svelte 5**: Wrap getters in `$derived` or read in `$effect`
+ * - **React**: Use `useSyncExternalStore` with `store.subscribe`
+ * - **Vue**: Use `watchEffect` over store getters
+ * - **Vanilla JS**: Call `store.subscribe` directly
+ *
+ * @example
+ * ```ts
+ * import { Dendri } from "dendri";
+ * import { createDendriStore } from "dendri/store";
+ *
+ * const store = createDendriStore({
+ *   DendriCtor: Dendri,
+ *   dendriOptions: { host: "localhost", port: 9000, secure: false, path: "/" },
+ * });
+ *
+ * store.join("my-room");
+ * store.subscribe(() => console.log("peers:", store.peers));
+ * ```
+ */
+
+/** Options passed to {@link createDendriStore} in advanced form. */
+interface DendriStoreOptions {
+    /**
+     * The Dendri constructor to use for creating peer instances. When
+     * omitted the default {@link Dendri} class is used. Overriding is
+     * useful for injecting a mock in tests.
+     */
+    readonly DendriCtor?: new (id: string, opts?: DendriOptions) => Dendri;
+    /** Options forwarded to the Dendri constructor on each join. */
+    readonly dendriOptions?: DendriOptions;
+    /** Optional Room-level options (e.g. migration timeout). */
+    readonly roomOptions?: RoomOptions;
+}
+/**
+ * `createDendriStore` accepts either the advanced {@link DendriStoreOptions}
+ * shape or a flat {@link DendriOptions} object. Pass an explicit signaling
+ * server host so open-source/self-hosted apps connect to their own server.
+ */
+type CreateDendriStoreInput = DendriStoreOptions | DendriOptions;
+/** Snapshot of the store's reactive state at a given point in time. */
+interface DendriStoreSnapshot {
+    readonly connectionState: ConnectionState;
+    readonly isHost: boolean;
+    readonly myPeerId: string | null;
+    readonly hostId: string | null;
+    readonly peers: readonly string[];
+    readonly peerCount: number;
+    readonly presences: ReadonlyMap<string, unknown>;
+}
+/** Listener callback for store state changes. */
+type StoreListener = () => void;
+/**
+ * A framework-agnostic reactive wrapper around a Dendri {@link Room}.
+ *
+ * State is accessed via getters. External frameworks react to changes
+ * by subscribing with {@link DendriStore.subscribe}.
+ */
+interface DendriStore {
+    /** Current connection lifecycle state. */
+    readonly connectionState: ConnectionState;
+    /** Whether this peer is the current room host. */
+    readonly isHost: boolean;
+    /** The local peer's ID, or `null` before joining. */
+    readonly myPeerId: string | null;
+    /** The current host's peer ID, or `null` before joining. */
+    readonly hostId: string | null;
+    /** All known remote peer IDs in the room. */
+    readonly peers: readonly string[];
+    /** Number of known remote peers. */
+    readonly peerCount: number;
+    /** Map of remote peer presences. */
+    readonly presences: ReadonlyMap<string, unknown>;
+    /** Join a room by ID. Creates a new Room internally. */
+    join(roomId: string): void;
+    /** Leave the current room and clean up. */
+    leave(): void;
+    /** Broadcast data to all room peers, optionally on a topic. */
+    broadcast(data: unknown, options?: {
+        readonly topic?: string;
+    }): void;
+    /** Broadcast a binary payload tagged with a topic. Receivers see a Uint8Array. */
+    broadcastBinary(bytes: Uint8Array, options: {
+        readonly topic: string;
+    }): void;
+    /** Broadcast with delivery confirmation. */
+    broadcastWithAck(data: unknown, timeout?: number): Promise<void>;
+    /** Set this peer's presence data. */
+    setPresence(data: Record<string, unknown>): void;
+    /** Register a callback for when a remote peer joins. Returns unsubscribe fn. */
+    onPeerJoin(handler: (peerId: string) => void): () => void;
+    /** Register a callback for when a remote peer leaves. Returns unsubscribe fn. */
+    onPeerLeave(handler: (peerId: string) => void): () => void;
+    /** Register a callback for all incoming data. Returns unsubscribe fn. */
+    onData(handler: (data: unknown, peerId: string) => void): () => void;
+    /** Register a callback for presence updates. Returns unsubscribe fn. */
+    onPresenceUpdate(handler: PresenceEvents<Record<string, unknown>>["update"]): () => void;
+    /** Register a callback for host changes. Returns unsubscribe fn. */
+    onHostChanged(handler: (hostId: string) => void): () => void;
+    /**
+     * Subscribe to state changes. The listener is called whenever reactive
+     * state changes. Returns an unsubscribe function.
+     *
+     * Compatible with React's `useSyncExternalStore`, Svelte's `$effect`,
+     * and any callback-based reactivity system.
+     */
+    subscribe: {
+        (topic: string, handler: (data: unknown, peerId: string) => void): () => void;
+        (listener: StoreListener): () => void;
+    };
+    /**
+     * Get an immutable snapshot of the current state.
+     * Compatible with React's `useSyncExternalStore` (getSnapshot).
+     */
+    getSnapshot(): DendriStoreSnapshot;
+    /** Leave the room and remove all listeners. */
+    destroy(): void;
+}
+/**
+ * Create a framework-agnostic reactive store wrapping a Dendri Room.
+ *
+ * Accepts three calling shapes:
+ *
+ * ```ts
+ * // 1. Flat DendriOptions (passthrough to the Dendri constructor)
+ * const store = createDendriStore({ host: "localhost", port: 9000, secure: false });
+ *
+ * // 2. Advanced — inject a custom Dendri class (for tests / mocks)
+ * const store = createDendriStore({
+ *   DendriCtor: MyDendri,
+ *   dendriOptions: { secure: true },
+ *   roomOptions: { migrationTimeout: 5000 },
+ * });
+ * ```
+ *
+ * @param input - Configuration containing an explicit signaling server host.
+ * @returns A {@link DendriStore} instance.
+ */
+declare function createDendriStore(input?: CreateDendriStoreInput): DendriStore;
+
+export { AckManager as A, BaseConnectionErrorType as B, type CallOption as C, Dendri as D, type RpcResponse as E, SerializationType as F, ServerMessageType as G, HybridConnection as H, SocketEventType as I, type StoreListener as J, TransportMode as K, LogLevel as L, MediaConnection as M, createDendriStore as N, isRpcRequest as O, type PresenceEvents as P, isRpcResponse as Q, Room as R, type SerializerMapping as S, type TransportEvents as T, type CreateDendriStoreInput as U, DataConnection as a, SignalingTransport as b, type AnswerOption as c, ConnectionQuality as d, ConnectionState as e, ConnectionType as f, DataConnectionErrorType as g, type DendriConnectOption as h, DendriError as i, DendriErrorType as j, type DendriEvents as k, type DendriOption as l, DendriOptions as m, type DendriStore as n, type DendriStoreOptions as o, type DendriStoreSnapshot as p, type HybridConnectionOption as q, type HybridSendOptions as r, PresenceManager as s, type RoomEvents as t, type RoomOptions as u, RpcError as v, RpcErrorCode as w, type RpcHandler as x, RpcManager as y, type RpcRequest as z };