@afterrealism/dendri-client 2.3.7

package/dist/dendri.d.cts

@@ -0,0 +1,340 @@
+import * as BinaryPack from 'peerjs-js-binarypack';
+import { D as Dendri, S as SerializerMapping, a as DataConnection, b as SignalingTransport } from './store-RTivRmUW.cjs';
+export { A as AckManager, c as AnswerOption, B as BaseConnectionErrorType, C as CallOption, d as ConnectionQuality, e as ConnectionState, f as ConnectionType, g as DataConnectionErrorType, h as DendriConnectOption, i as DendriError, j as DendriErrorType, k as DendriEvents, l as DendriOption, m as DendriOptions, n as DendriStore, o as DendriStoreOptions, p as DendriStoreSnapshot, H as HybridConnection, q as HybridConnectionOption, r as HybridSendOptions, L as LogLevel, M as MediaConnection, P as PresenceEvents, s as PresenceManager, R as Room, t as RoomEvents, u as RoomOptions, v as RpcError, w as RpcErrorCode, x as RpcHandler, y as RpcManager, z as RpcRequest, E as RpcResponse, F as SerializationType, G as ServerMessageType, I as SocketEventType, J as StoreListener, T as TransportEvents, K as TransportMode, N as createDendriStore, O as isRpcRequest, Q as isRpcResponse } from './store-RTivRmUW.cjs';
+import 'eventemitter3';
+
+declare class BinaryPackChunker {
+    readonly chunkedMTU = 16300;
+    private _dataCount;
+    chunk: (blob: ArrayBuffer) => {
+        __peerData: number;
+        n: number;
+        total: number;
+        data: ArrayBuffer;
+    }[];
+}
+
+interface UtilSupportsObj {
+    /**
+     * The current browser.
+     * This property can be useful in determining whether two peers can connect.
+     *
+     * ```ts
+     * if (util.browser === 'firefox') {
+     *  // OK to peer with Firefox peers.
+     * }
+     * ```
+     *
+     * `util.browser` can currently have the values
+     * `'firefox', 'chrome', 'safari', 'edge', 'Not a supported browser.', 'Not a browser.' (unknown WebRTC-compatible agent).
+     */
+    browser: boolean;
+    webRTC: boolean;
+    /**
+     * True if the current browser supports media streams and PeerConnection.
+     */
+    audioVideo: boolean;
+    /**
+     * True if the current browser supports DataChannel and PeerConnection.
+     */
+    data: boolean;
+    binaryBlob: boolean;
+    /**
+     * True if the current browser supports reliable DataChannels.
+     */
+    reliable: boolean;
+}
+declare class Util extends BinaryPackChunker {
+    noop(): void;
+    readonly CLOUD_HOST = "signal.dendri.dev";
+    readonly CLOUD_PORT = 443;
+    readonly chunkedBrowsers: {
+        Chrome: number;
+        chrome: number;
+    };
+    readonly defaultConfig: RTCConfiguration;
+    readonly browser: string;
+    readonly browserVersion: number;
+    get isSafari(): boolean;
+    get isIOS(): boolean;
+    pack: typeof BinaryPack.pack;
+    unpack: typeof BinaryPack.unpack;
+    /**
+     * A hash of WebRTC features mapped to booleans that correspond to whether the feature is supported by the current browser.
+     *
+     * :::caution
+     * Only the properties documented here are guaranteed to be present on `util.supports`
+     * :::
+     */
+    readonly supports: UtilSupportsObj;
+    validateId: (id: string) => boolean;
+    randomToken: () => string;
+    blobToArrayBuffer(blob: Blob, cb: (arg: ArrayBuffer | null) => void): FileReader;
+    binaryStringToArrayBuffer(binary: string): ArrayBuffer | SharedArrayBuffer;
+    isSecure(): boolean;
+}
+/**
+ * Provides a variety of helpful utilities.
+ *
+ * :::caution
+ * Only the utilities documented here are guaranteed to be present on `util`.
+ * Undocumented utilities can be removed without warning.
+ * We don't consider these to be breaking changes.
+ * :::
+ */
+declare const util: Util;
+
+/**
+ * @experimental
+ */
+declare class MsgPackDendri extends Dendri {
+    _serializers: SerializerMapping;
+}
+
+declare abstract class BufferedConnection extends DataConnection {
+    private _buffer;
+    private _bufferSize;
+    private _buffering;
+    private _bufferTimer;
+    private _messageHandler;
+    get bufferSize(): number;
+    _initializeDataChannel(dc: RTCDataChannel): void;
+    protected abstract _handleDataMessage(e: MessageEvent): void;
+    protected _bufferedSend(msg: ArrayBuffer): void;
+    private _trySend;
+    private _tryBuffer;
+    close(options?: {
+        flush?: boolean;
+    }): void;
+}
+
+declare abstract class StreamConnection extends DataConnection {
+    private _CHUNK_SIZE;
+    private _splitStream;
+    private _rawSendStream;
+    protected writer: WritableStreamDefaultWriter<Uint8Array<ArrayBufferLike>>;
+    private _readStreamMessageHandler;
+    private _readStreamController;
+    protected _rawReadStream: ReadableStream<ArrayBuffer>;
+    protected constructor(peerId: string, provider: Dendri, options: any);
+    _initializeDataChannel(dc: RTCDataChannel): void;
+    close(options?: {
+        flush?: boolean;
+    }): void;
+}
+
+declare class MsgPack extends StreamConnection {
+    readonly serialization = "MsgPack";
+    private _encoder;
+    constructor(peerId: string, provider: Dendri, options: any);
+    protected _send(data: unknown): Promise<void>;
+}
+
+/**
+ * E2E encryption for relay messages using ECDH + AES-256-GCM.
+ * Uses the Web Crypto API -- available in all modern browsers and Node.js 18+.
+ */
+/** Encrypted payload structure sent over the relay. */
+interface EncryptedPayload {
+    readonly iv: string;
+    readonly ciphertext: string;
+}
+declare class RelayEncryption {
+    private _keyPair;
+    private _sharedKey;
+    private _ready;
+    get ready(): boolean;
+    /** Generate ECDH key pair and return the public key as JWK. */
+    generateKeyPair(): Promise<JsonWebKey>;
+    /** Derive shared AES-256-GCM key from remote peer's public key. */
+    deriveSharedKey(remotePublicKeyJwk: JsonWebKey): Promise<void>;
+    /** Encrypt a message for relay. */
+    encrypt(data: string): Promise<EncryptedPayload>;
+    /** Decrypt a message from relay. */
+    decrypt(encrypted: EncryptedPayload): Promise<string>;
+    /** Reset encryption state. */
+    clear(): void;
+}
+
+/**
+ * Host migration utilities for star topology rooms.
+ *
+ * When the host disconnects, the peer with the lowest alphabetical ID
+ * among all remaining peers becomes the new host. This is deterministic:
+ * every peer arrives at the same answer independently.
+ */
+interface HostMigrationOptions {
+    readonly roomId: string;
+    readonly myPeerId: string;
+    readonly knownPeers: readonly string[];
+    readonly onBecomeHost: () => void;
+    readonly onNewHost: (hostId: string) => void;
+    readonly migrationTimeout?: number;
+}
+/**
+ * Elect a new host from the given set of peer IDs.
+ * Deterministic: the lowest alphabetical ID always wins.
+ *
+ * @param myPeerId - The local peer's ID.
+ * @param peerIds  - All other known peer IDs (excluding the departed host).
+ * @returns The peer ID that should become the new host.
+ */
+declare function electNewHost(myPeerId: string, peerIds: readonly string[]): string;
+
+/**
+ * HTTP Long Polling transport — works through any network that allows HTTPS.
+ * Client->Server: POST
+ * Server->Client: GET (held open until data available or timeout)
+ */
+declare class PollingTransport extends SignalingTransport {
+    private _connected;
+    private _disconnected;
+    private _id?;
+    private _token?;
+    private _messagesQueue;
+    private _polling;
+    private _autoReconnect;
+    private _reconnectAttempt;
+    private _reconnectTimer?;
+    private _heartbeatTimer?;
+    private _lastSeq;
+    private _baseUrl;
+    private readonly _pingInterval;
+    private _abortController?;
+    /** Backoff schedule base delays in milliseconds. */
+    private static readonly BACKOFF_SCHEDULE;
+    /** Random jitter range in milliseconds (applied as +/-). */
+    private static readonly BACKOFF_JITTER;
+    constructor(secure: boolean, host: string, port: number, path: string, _key: string, pingInterval?: number, _jwt?: string);
+    get reconnectAttempt(): number;
+    start(id: string, token: string): void;
+    private _startPolling;
+    send(data: any): void;
+    private _postMessage;
+    close(): void;
+    /** Compute the backoff delay (with jitter) for the current attempt. */
+    private _getReconnectDelay;
+    private _scheduleReconnect;
+    private _startHeartbeat;
+    private _sendQueuedMessages;
+    private _cleanup;
+}
+
+/**
+ * Server-side API client for dendri signal server.
+ * Use this from your backend to manage peers and rooms programmatically.
+ */
+declare class DendriServerAPI {
+    private readonly _baseUrl;
+    private readonly _key;
+    constructor(options: {
+        url: string;
+        key?: string;
+    });
+    /** Get server health and stats */
+    getHealth(): Promise<{
+        status: string;
+        clients: number;
+        rooms: number;
+        uptime_ms: number;
+        relay_enabled: boolean;
+    }>;
+    /** List all connected peer IDs */
+    listPeers(room?: string): Promise<string[]>;
+    /** Generate a new peer ID */
+    generatePeerId(): Promise<string>;
+    /** Get TURN credentials */
+    getTurnCredentials(): Promise<{
+        iceServers: RTCIceServer[];
+    }>;
+    /** Get analytics metadata */
+    getAnalytics(): Promise<{
+        dataset: string;
+        events_tracked: string[];
+    }>;
+}
+
+/**
+ * SSE + POST transport for environments where WebSocket is blocked.
+ * Server->Client: Server-Sent Events (fetch-based, supports custom headers)
+ * Client->Server: HTTP POST requests
+ */
+declare class SSETransport extends SignalingTransport {
+    private _connected;
+    private _disconnected;
+    private _id?;
+    private _token?;
+    private _messagesQueue;
+    private _abortController?;
+    private _autoReconnect;
+    private _reconnectAttempt;
+    private _reconnectTimer?;
+    private _heartbeatTimer?;
+    private _lastSeq;
+    private _baseUrl;
+    private _jwt?;
+    private readonly _pingInterval;
+    /** Backoff schedule base delays in milliseconds. */
+    private static readonly BACKOFF_SCHEDULE;
+    /** Random jitter range in milliseconds (applied as +/-). */
+    private static readonly BACKOFF_JITTER;
+    constructor(secure: boolean, host: string, port: number, path: string, _key: string, pingInterval?: number, jwt?: string);
+    get reconnectAttempt(): number;
+    start(id: string, token: string): void;
+    private _connectSSE;
+    send(data: any): void;
+    private _postMessage;
+    close(): void;
+    private _handleDisconnect;
+    /** Compute the backoff delay (with jitter) for the current attempt. */
+    private _getReconnectDelay;
+    private _scheduleReconnect;
+    private _startHeartbeat;
+    private _sendQueuedMessages;
+    private _cleanup;
+}
+
+/**
+ * Callback signature for topic message handlers.
+ * @param data  The payload received on this topic.
+ * @param peerId  The ID of the peer that sent the message.
+ */
+type TopicHandler = (data: unknown, peerId: string) => void;
+/**
+ * Marker interface for messages that carry topic metadata.
+ * When a topic is specified the original payload is wrapped in this envelope
+ * so the receiver can extract and route it.
+ */
+interface TopicEnvelope {
+    readonly __topic: string;
+    readonly __data: unknown;
+    /** If true, `__data` is base64-encoded bytes — receivers must decode before use. */
+    readonly __binary?: boolean;
+}
+/** Type-guard: does `value` look like a topic-wrapped envelope? */
+declare function isTopicEnvelope(value: unknown): value is TopicEnvelope;
+/**
+ * Manages per-topic subscriptions and dispatches incoming messages
+ * to the matching handlers.
+ *
+ * Designed for use inside Room and HybridConnection so that
+ * callers can filter messages by topic without manual switching logic.
+ */
+declare class TopicManager {
+    private readonly _handlers;
+    private readonly _globalHandlers;
+    /** Subscribe to a specific topic. Returns an unsubscribe function. */
+    subscribe(topic: string, handler: TopicHandler): () => void;
+    /** Subscribe to ALL topics (including un-topiced messages). Returns an unsubscribe function. */
+    subscribeAll(handler: TopicHandler): () => void;
+    /**
+     * Dispatch a message to the appropriate handlers.
+     *
+     * @returns `true` if at least one handler was invoked, `false` otherwise.
+     */
+    dispatch(topic: string | undefined, data: unknown, peerId: string): boolean;
+    /** Remove all subscriptions. */
+    clear(): void;
+}
+
+export { BufferedConnection, DataConnection, Dendri, DendriServerAPI, type EncryptedPayload, type HostMigrationOptions, MsgPack, MsgPackDendri, PollingTransport, RelayEncryption, SSETransport, SerializerMapping, SignalingTransport, StreamConnection, type TopicEnvelope, type TopicHandler, TopicManager, Util, type UtilSupportsObj, Dendri as default, electNewHost, isTopicEnvelope, util };

package/dist/dendri.d.ts

@@ -0,0 +1,340 @@
+import * as BinaryPack from 'peerjs-js-binarypack';
+import { D as Dendri, S as SerializerMapping, a as DataConnection, b as SignalingTransport } from './store-RTivRmUW.js';
+export { A as AckManager, c as AnswerOption, B as BaseConnectionErrorType, C as CallOption, d as ConnectionQuality, e as ConnectionState, f as ConnectionType, g as DataConnectionErrorType, h as DendriConnectOption, i as DendriError, j as DendriErrorType, k as DendriEvents, l as DendriOption, m as DendriOptions, n as DendriStore, o as DendriStoreOptions, p as DendriStoreSnapshot, H as HybridConnection, q as HybridConnectionOption, r as HybridSendOptions, L as LogLevel, M as MediaConnection, P as PresenceEvents, s as PresenceManager, R as Room, t as RoomEvents, u as RoomOptions, v as RpcError, w as RpcErrorCode, x as RpcHandler, y as RpcManager, z as RpcRequest, E as RpcResponse, F as SerializationType, G as ServerMessageType, I as SocketEventType, J as StoreListener, T as TransportEvents, K as TransportMode, N as createDendriStore, O as isRpcRequest, Q as isRpcResponse } from './store-RTivRmUW.js';
+import 'eventemitter3';
+
+declare class BinaryPackChunker {
+    readonly chunkedMTU = 16300;
+    private _dataCount;
+    chunk: (blob: ArrayBuffer) => {
+        __peerData: number;
+        n: number;
+        total: number;
+        data: ArrayBuffer;
+    }[];
+}
+
+interface UtilSupportsObj {
+    /**
+     * The current browser.
+     * This property can be useful in determining whether two peers can connect.
+     *
+     * ```ts
+     * if (util.browser === 'firefox') {
+     *  // OK to peer with Firefox peers.
+     * }
+     * ```
+     *
+     * `util.browser` can currently have the values
+     * `'firefox', 'chrome', 'safari', 'edge', 'Not a supported browser.', 'Not a browser.' (unknown WebRTC-compatible agent).
+     */
+    browser: boolean;
+    webRTC: boolean;
+    /**
+     * True if the current browser supports media streams and PeerConnection.
+     */
+    audioVideo: boolean;
+    /**
+     * True if the current browser supports DataChannel and PeerConnection.
+     */
+    data: boolean;
+    binaryBlob: boolean;
+    /**
+     * True if the current browser supports reliable DataChannels.
+     */
+    reliable: boolean;
+}
+declare class Util extends BinaryPackChunker {
+    noop(): void;
+    readonly CLOUD_HOST = "signal.dendri.dev";
+    readonly CLOUD_PORT = 443;
+    readonly chunkedBrowsers: {
+        Chrome: number;
+        chrome: number;
+    };
+    readonly defaultConfig: RTCConfiguration;
+    readonly browser: string;
+    readonly browserVersion: number;
+    get isSafari(): boolean;
+    get isIOS(): boolean;
+    pack: typeof BinaryPack.pack;
+    unpack: typeof BinaryPack.unpack;
+    /**
+     * A hash of WebRTC features mapped to booleans that correspond to whether the feature is supported by the current browser.
+     *
+     * :::caution
+     * Only the properties documented here are guaranteed to be present on `util.supports`
+     * :::
+     */
+    readonly supports: UtilSupportsObj;
+    validateId: (id: string) => boolean;
+    randomToken: () => string;
+    blobToArrayBuffer(blob: Blob, cb: (arg: ArrayBuffer | null) => void): FileReader;
+    binaryStringToArrayBuffer(binary: string): ArrayBuffer | SharedArrayBuffer;
+    isSecure(): boolean;
+}
+/**
+ * Provides a variety of helpful utilities.
+ *
+ * :::caution
+ * Only the utilities documented here are guaranteed to be present on `util`.
+ * Undocumented utilities can be removed without warning.
+ * We don't consider these to be breaking changes.
+ * :::
+ */
+declare const util: Util;
+
+/**
+ * @experimental
+ */
+declare class MsgPackDendri extends Dendri {
+    _serializers: SerializerMapping;
+}
+
+declare abstract class BufferedConnection extends DataConnection {
+    private _buffer;
+    private _bufferSize;
+    private _buffering;
+    private _bufferTimer;
+    private _messageHandler;
+    get bufferSize(): number;
+    _initializeDataChannel(dc: RTCDataChannel): void;
+    protected abstract _handleDataMessage(e: MessageEvent): void;
+    protected _bufferedSend(msg: ArrayBuffer): void;
+    private _trySend;
+    private _tryBuffer;
+    close(options?: {
+        flush?: boolean;
+    }): void;
+}
+
+declare abstract class StreamConnection extends DataConnection {
+    private _CHUNK_SIZE;
+    private _splitStream;
+    private _rawSendStream;
+    protected writer: WritableStreamDefaultWriter<Uint8Array<ArrayBufferLike>>;
+    private _readStreamMessageHandler;
+    private _readStreamController;
+    protected _rawReadStream: ReadableStream<ArrayBuffer>;
+    protected constructor(peerId: string, provider: Dendri, options: any);
+    _initializeDataChannel(dc: RTCDataChannel): void;
+    close(options?: {
+        flush?: boolean;
+    }): void;
+}
+
+declare class MsgPack extends StreamConnection {
+    readonly serialization = "MsgPack";
+    private _encoder;
+    constructor(peerId: string, provider: Dendri, options: any);
+    protected _send(data: unknown): Promise<void>;
+}
+
+/**
+ * E2E encryption for relay messages using ECDH + AES-256-GCM.
+ * Uses the Web Crypto API -- available in all modern browsers and Node.js 18+.
+ */
+/** Encrypted payload structure sent over the relay. */
+interface EncryptedPayload {
+    readonly iv: string;
+    readonly ciphertext: string;
+}
+declare class RelayEncryption {
+    private _keyPair;
+    private _sharedKey;
+    private _ready;
+    get ready(): boolean;
+    /** Generate ECDH key pair and return the public key as JWK. */
+    generateKeyPair(): Promise<JsonWebKey>;
+    /** Derive shared AES-256-GCM key from remote peer's public key. */
+    deriveSharedKey(remotePublicKeyJwk: JsonWebKey): Promise<void>;
+    /** Encrypt a message for relay. */
+    encrypt(data: string): Promise<EncryptedPayload>;
+    /** Decrypt a message from relay. */
+    decrypt(encrypted: EncryptedPayload): Promise<string>;
+    /** Reset encryption state. */
+    clear(): void;
+}
+
+/**
+ * Host migration utilities for star topology rooms.
+ *
+ * When the host disconnects, the peer with the lowest alphabetical ID
+ * among all remaining peers becomes the new host. This is deterministic:
+ * every peer arrives at the same answer independently.
+ */
+interface HostMigrationOptions {
+    readonly roomId: string;
+    readonly myPeerId: string;
+    readonly knownPeers: readonly string[];
+    readonly onBecomeHost: () => void;
+    readonly onNewHost: (hostId: string) => void;
+    readonly migrationTimeout?: number;
+}
+/**
+ * Elect a new host from the given set of peer IDs.
+ * Deterministic: the lowest alphabetical ID always wins.
+ *
+ * @param myPeerId - The local peer's ID.
+ * @param peerIds  - All other known peer IDs (excluding the departed host).
+ * @returns The peer ID that should become the new host.
+ */
+declare function electNewHost(myPeerId: string, peerIds: readonly string[]): string;
+
+/**
+ * HTTP Long Polling transport — works through any network that allows HTTPS.
+ * Client->Server: POST
+ * Server->Client: GET (held open until data available or timeout)
+ */
+declare class PollingTransport extends SignalingTransport {
+    private _connected;
+    private _disconnected;
+    private _id?;
+    private _token?;
+    private _messagesQueue;
+    private _polling;
+    private _autoReconnect;
+    private _reconnectAttempt;
+    private _reconnectTimer?;
+    private _heartbeatTimer?;
+    private _lastSeq;
+    private _baseUrl;
+    private readonly _pingInterval;
+    private _abortController?;
+    /** Backoff schedule base delays in milliseconds. */
+    private static readonly BACKOFF_SCHEDULE;
+    /** Random jitter range in milliseconds (applied as +/-). */
+    private static readonly BACKOFF_JITTER;
+    constructor(secure: boolean, host: string, port: number, path: string, _key: string, pingInterval?: number, _jwt?: string);
+    get reconnectAttempt(): number;
+    start(id: string, token: string): void;
+    private _startPolling;
+    send(data: any): void;
+    private _postMessage;
+    close(): void;
+    /** Compute the backoff delay (with jitter) for the current attempt. */
+    private _getReconnectDelay;
+    private _scheduleReconnect;
+    private _startHeartbeat;
+    private _sendQueuedMessages;
+    private _cleanup;
+}
+
+/**
+ * Server-side API client for dendri signal server.
+ * Use this from your backend to manage peers and rooms programmatically.
+ */
+declare class DendriServerAPI {
+    private readonly _baseUrl;
+    private readonly _key;
+    constructor(options: {
+        url: string;
+        key?: string;
+    });
+    /** Get server health and stats */
+    getHealth(): Promise<{
+        status: string;
+        clients: number;
+        rooms: number;
+        uptime_ms: number;
+        relay_enabled: boolean;
+    }>;
+    /** List all connected peer IDs */
+    listPeers(room?: string): Promise<string[]>;
+    /** Generate a new peer ID */
+    generatePeerId(): Promise<string>;
+    /** Get TURN credentials */
+    getTurnCredentials(): Promise<{
+        iceServers: RTCIceServer[];
+    }>;
+    /** Get analytics metadata */
+    getAnalytics(): Promise<{
+        dataset: string;
+        events_tracked: string[];
+    }>;
+}
+
+/**
+ * SSE + POST transport for environments where WebSocket is blocked.
+ * Server->Client: Server-Sent Events (fetch-based, supports custom headers)
+ * Client->Server: HTTP POST requests
+ */
+declare class SSETransport extends SignalingTransport {
+    private _connected;
+    private _disconnected;
+    private _id?;
+    private _token?;
+    private _messagesQueue;
+    private _abortController?;
+    private _autoReconnect;
+    private _reconnectAttempt;
+    private _reconnectTimer?;
+    private _heartbeatTimer?;
+    private _lastSeq;
+    private _baseUrl;
+    private _jwt?;
+    private readonly _pingInterval;
+    /** Backoff schedule base delays in milliseconds. */
+    private static readonly BACKOFF_SCHEDULE;
+    /** Random jitter range in milliseconds (applied as +/-). */
+    private static readonly BACKOFF_JITTER;
+    constructor(secure: boolean, host: string, port: number, path: string, _key: string, pingInterval?: number, jwt?: string);
+    get reconnectAttempt(): number;
+    start(id: string, token: string): void;
+    private _connectSSE;
+    send(data: any): void;
+    private _postMessage;
+    close(): void;
+    private _handleDisconnect;
+    /** Compute the backoff delay (with jitter) for the current attempt. */
+    private _getReconnectDelay;
+    private _scheduleReconnect;
+    private _startHeartbeat;
+    private _sendQueuedMessages;
+    private _cleanup;
+}
+
+/**
+ * Callback signature for topic message handlers.
+ * @param data  The payload received on this topic.
+ * @param peerId  The ID of the peer that sent the message.
+ */
+type TopicHandler = (data: unknown, peerId: string) => void;
+/**
+ * Marker interface for messages that carry topic metadata.
+ * When a topic is specified the original payload is wrapped in this envelope
+ * so the receiver can extract and route it.
+ */
+interface TopicEnvelope {
+    readonly __topic: string;
+    readonly __data: unknown;
+    /** If true, `__data` is base64-encoded bytes — receivers must decode before use. */
+    readonly __binary?: boolean;
+}
+/** Type-guard: does `value` look like a topic-wrapped envelope? */
+declare function isTopicEnvelope(value: unknown): value is TopicEnvelope;
+/**
+ * Manages per-topic subscriptions and dispatches incoming messages
+ * to the matching handlers.
+ *
+ * Designed for use inside Room and HybridConnection so that
+ * callers can filter messages by topic without manual switching logic.
+ */
+declare class TopicManager {
+    private readonly _handlers;
+    private readonly _globalHandlers;
+    /** Subscribe to a specific topic. Returns an unsubscribe function. */
+    subscribe(topic: string, handler: TopicHandler): () => void;
+    /** Subscribe to ALL topics (including un-topiced messages). Returns an unsubscribe function. */
+    subscribeAll(handler: TopicHandler): () => void;
+    /**
+     * Dispatch a message to the appropriate handlers.
+     *
+     * @returns `true` if at least one handler was invoked, `false` otherwise.
+     */
+    dispatch(topic: string | undefined, data: unknown, peerId: string): boolean;
+    /** Remove all subscriptions. */
+    clear(): void;
+}
+
+export { BufferedConnection, DataConnection, Dendri, DendriServerAPI, type EncryptedPayload, type HostMigrationOptions, MsgPack, MsgPackDendri, PollingTransport, RelayEncryption, SSETransport, SerializerMapping, SignalingTransport, StreamConnection, type TopicEnvelope, type TopicHandler, TopicManager, Util, type UtilSupportsObj, Dendri as default, electNewHost, isTopicEnvelope, util };