@tonytomo/gosocket-client 0.0.0-stage → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,880 @@
+/**
+ * Clock abstraction for deterministic time testing.
+ *
+ * NOTE: This is the ONLY file in src/ permitted to invoke the platform's
+ * global setTimeout / clearTimeout primitives. All SDK timers must be
+ * scheduled via a Clock instance.
+ */
+interface Timer {
+    stop(): void;
+}
+interface Clock {
+    now(): number;
+    setTimeout(fn: () => void, ms: number): Timer;
+    clearTimeout(t: Timer): void;
+}
+declare class RealClock implements Clock {
+    now(): number;
+    setTimeout(fn: () => void, ms: number): Timer;
+    clearTimeout(t: Timer): void;
+}
+
+/**
+ * Wire protocol types mirroring PROTOCOL.md and Go client/types.go.
+ */
+type ErrorCode = 'UNAUTHORIZED' | 'FORBIDDEN_SCOPE' | 'NOT_ROOM_OWNER' | 'BAD_REQUEST' | 'ROOM_NOT_FOUND' | 'ROOM_ALREADY_EXISTS' | 'ROOM_FULL' | 'INVALID_PASSCODE' | 'PASSCODE_RATE_LIMITED' | 'MAX_ROOMS_REACHED' | 'BINARY_NOT_ALLOWED' | 'CHANNEL_NOT_RELIABLE' | 'CHANNEL_NOT_FOUND' | 'RESERVED_CHANNEL_NAME' | 'CHANNEL_READ_ONLY' | 'RATE_LIMITED' | 'INTERNAL_ERROR';
+interface ChannelConfig {
+    name: string;
+    reliable: boolean;
+    max_rate: number;
+}
+interface ChannelConfigInput {
+    reliable?: boolean;
+    max_rate?: number;
+}
+interface RoomSummary {
+    name: string;
+    members: number;
+    protected: boolean;
+    kind?: string;
+    channels?: string[];
+    channel_configs?: Record<string, ChannelConfig>;
+    max_members?: number;
+    created_at: number;
+    metadata?: unknown;
+}
+type BinaryChannelMap$1 = Record<string, number>;
+interface CapabilityLimits {
+    max_rooms: number;
+    max_members_per_room: number | null;
+    max_message_bytes: number;
+    max_rooms_per_key: number | null;
+    max_channels_per_room: number | null;
+    max_metadata_bytes: number | null;
+    list_rooms_max_limit: number | null;
+    list_rooms_default_limit: number | null;
+}
+interface ListRoomsFeatures {
+    pagination?: boolean;
+    detail_levels?: string[];
+    filters?: string[];
+}
+interface CapabilityFeatures {
+    binary_frames?: boolean;
+    room_kinds?: string[];
+    list_rooms?: ListRoomsFeatures;
+}
+interface Capabilities {
+    limits?: CapabilityLimits;
+    features?: CapabilityFeatures;
+}
+interface CreateRoomRequest {
+    type?: 'create_room';
+    room: string;
+    kind?: 'chat' | 'game' | 'custom' | string;
+    passcode?: string;
+    max_members?: number;
+    ephemeral?: boolean;
+    channels?: Record<string, ChannelConfigInput>;
+    metadata?: unknown;
+}
+interface JoinRoomRequest {
+    type?: 'join_room';
+    room: string;
+    passcode?: string;
+    binary_channels?: BinaryChannelMap$1;
+}
+interface LeaveRoomRequest {
+    type?: 'leave_room';
+    room: string;
+}
+interface DeleteRoomRequest {
+    type?: 'delete_room';
+    room: string;
+}
+interface ListRoomsRequest {
+    type?: 'list_rooms';
+    limit?: number;
+    cursor?: string;
+    filters?: unknown;
+    detail?: string;
+}
+interface PublishRequest$1 {
+    type?: 'publish';
+    room: string;
+    channel?: string;
+    reliable?: boolean;
+    payload?: unknown;
+    include_sender?: boolean;
+}
+interface PingRequest {
+    type?: 'ping';
+}
+type ClientFrame = CreateRoomRequest | JoinRoomRequest | LeaveRoomRequest | DeleteRoomRequest | ListRoomsRequest | PublishRequest$1 | PingRequest;
+interface WelcomeFrame {
+    type: 'welcome';
+    client_id: string;
+    label: string;
+    server_version: string;
+    capabilities?: Capabilities;
+}
+interface RoomCreatedFrame {
+    type: 'room_created';
+    room: string;
+    channels: string[];
+}
+interface RoomJoinedFrame {
+    type: 'room_joined';
+    room: string;
+    channels: string[];
+    members: number;
+}
+interface RoomLeftFrame {
+    type: 'room_left';
+    room: string;
+}
+interface RoomListFrame {
+    type: 'room_list';
+    rooms: RoomSummary[];
+    next_cursor?: string;
+    truncated?: boolean;
+    filters_applied?: unknown;
+    detail?: string;
+}
+interface MessageFrame {
+    type: 'message';
+    room: string;
+    channel: string;
+    from: string;
+    seq: number;
+    ts: number;
+    payload: unknown;
+}
+interface ErrorFrame {
+    type: 'error';
+    code: ErrorCode;
+    message: string;
+    channel?: string;
+    retry_after_ms?: number;
+    room?: string;
+}
+interface PongFrame {
+    type: 'pong';
+}
+type ServerFrame = WelcomeFrame | RoomCreatedFrame | RoomJoinedFrame | RoomLeftFrame | RoomListFrame | MessageFrame | ErrorFrame | PongFrame;
+declare function isErrorFrame(x: unknown): x is ErrorFrame;
+declare function isMessageFrame(x: unknown): x is MessageFrame;
+declare function isWelcomeFrame(x: unknown): x is WelcomeFrame;
+
+interface ChannelPolicy {
+    reliable: boolean;
+    maxRate: number;
+    coalesce: boolean;
+    coalesceDriver?: 'timer' | 'raf';
+    merge?: (prev: unknown, next: unknown) => {
+        value: unknown;
+        skip: boolean;
+    };
+}
+interface PolicyProvider {
+    channelPolicy(room: string, channel: string): ChannelPolicy | undefined;
+}
+type RoomKind = 'chat' | 'game' | 'custom';
+declare function presetsFor(kind: RoomKind, overrides?: Record<string, Partial<ChannelPolicy>>): Record<string, ChannelPolicy>;
+declare function resolvePolicy(room: string, channel: string, provider: PolicyProvider | undefined, overrides: Record<string, ChannelPolicy>): ChannelPolicy;
+
+type BinaryChannelMap = Readonly<Record<string, number>>;
+declare class BinaryMapBuilder {
+    private readonly byChannel;
+    private readonly byId;
+    set(channel: string, id: number): this;
+    autoSet(channel: string): this;
+    build(): BinaryChannelMap;
+}
+declare function validateBinaryMap(map: BinaryChannelMap): void;
+
+type ErrorAction = 'ignore' | 'drop_intent' | 'retry_backoff' | 'reconnect' | 'fatal' | 'app_prompt';
+interface ErrorClassification {
+    action: ErrorAction;
+    retryAfterMs?: number;
+}
+interface ErrorPolicyConfig {
+    overrides?: Partial<Record<ErrorCode, ErrorClassification>>;
+}
+/**
+ * Pure function that maps an ErrorCode and optional ErrorFrame to the SDK's
+ * recommended recovery action based on PROTOCOL.md §4.7.
+ */
+declare function classifyError(code: ErrorCode, frame?: Partial<Pick<ErrorFrame, 'message' | 'channel' | 'retry_after_ms'>>, overrides?: ErrorPolicyConfig['overrides']): ErrorClassification;
+
+interface RttStats {
+    last: number;
+    min: number;
+    max: number;
+    mean: number;
+    samples: number;
+}
+interface RttEvent$1 {
+    sample: number;
+    source: 'heartbeat' | 'on_demand';
+    stats: RttStats;
+}
+declare class RttTracker {
+    private stats;
+    getStats(): RttStats | undefined;
+    recordSample(sampleMs: number): RttStats;
+    reset(): void;
+}
+
+type State = 'idle' | 'connecting' | 'awaiting_welcome' | 'ready' | 'reconnecting' | 'closed';
+interface StateChangeEvent {
+    from: State;
+    to: State;
+}
+interface ConnectedEvent {
+    welcome: WelcomeFrame;
+}
+interface DisconnectedEvent {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+}
+interface ReconnectingEvent {
+    attempt: number;
+    delayMs: number;
+}
+interface ErrorEvent {
+    error: Error;
+    phase: 'connect' | 'runtime';
+}
+interface ErrorClassifiedEvent {
+    code: ErrorCode;
+    message: string;
+    room?: string;
+    channel?: string;
+    action: ErrorAction;
+    retryAfterMs?: number;
+    rawFrame?: ErrorFrame;
+}
+interface FatalEvent {
+    code: 'AUTH_FAILED' | 'POLICY_VIOLATION' | 'CLOSED';
+    message: string;
+}
+interface HeartbeatTimeoutEvent {
+    elapsedMs: number;
+}
+interface RttEvent {
+    sample: number;
+    source: 'heartbeat' | 'on_demand';
+    stats: RttStats;
+}
+interface SessionRestoredEvent {
+    restored: string[];
+    failed: Array<{
+        room: string;
+        code: ErrorCode;
+    }>;
+}
+interface IntentFailedEvent {
+    room: string;
+    code: ErrorCode;
+}
+interface CapabilitiesChangedEvent {
+    previous?: Capabilities;
+    current: Capabilities;
+    previousVersion?: string;
+    currentVersion?: string;
+}
+interface RateLimitedEvent {
+    source: 'local' | 'server';
+    room: string;
+    channel: string;
+    retryAfterMs: number;
+}
+interface ReliableOverflowEvent {
+    room: string;
+    channel: string;
+    depth: number;
+    action: 'dropped' | 'closed';
+}
+interface UnreliableDroppedEvent {
+    room: string;
+    channel: string;
+    depth: number;
+}
+interface CoalescedEvent {
+    room: string;
+    channel: string;
+    merged: boolean;
+    skipped: boolean;
+}
+interface QueuesDiscardedEvent {
+    reliable: number;
+    unreliable: number;
+    coalesced: number;
+}
+interface BackpressureEvent {
+    state: 'high' | 'low';
+    bufferedAmount: number;
+}
+interface PolicyAppliedEvent {
+    room: string;
+    channel: string;
+    policy: ChannelPolicy;
+}
+interface BinaryMessageEvent {
+    room: string;
+    channel: string;
+    payload: Uint8Array;
+}
+interface BinaryUnknownChannelEvent {
+    id: number;
+}
+interface BinaryIdCollisionEvent {
+    id: number;
+    existing: string[];
+    rejected: string[];
+}
+interface BinaryMappingChangedEvent {
+    room: string;
+    map: BinaryChannelMap;
+}
+interface PresenceJoinEvent {
+    room: string;
+    who: string;
+}
+interface PresenceLeaveEvent {
+    room: string;
+    who: string;
+}
+interface PresenceInvalidatedEvent {
+    room: string;
+    reason: string;
+}
+interface RoomDeletedEvent {
+    room: string;
+    who: string;
+}
+interface SequenceGapEvent {
+    room: string;
+    channel: string;
+    prev: number;
+    current: number;
+    missed: number;
+    reliable: boolean;
+}
+interface ProtocolViolationEvent {
+    room: string;
+    reason: string;
+}
+interface EventMap {
+    stateChange: StateChangeEvent;
+    connected: ConnectedEvent;
+    disconnected: DisconnectedEvent;
+    reconnecting: ReconnectingEvent;
+    error: ErrorEvent;
+    errorClassified: ErrorClassifiedEvent;
+    fatal: FatalEvent;
+    heartbeatTimeout: HeartbeatTimeoutEvent;
+    rtt: RttEvent;
+    sessionRestored: SessionRestoredEvent;
+    intentFailed: IntentFailedEvent;
+    capabilitiesChanged: CapabilitiesChangedEvent;
+    message: MessageFrame;
+    rateLimited: RateLimitedEvent;
+    reliableOverflow: ReliableOverflowEvent;
+    unreliableDropped: UnreliableDroppedEvent;
+    coalesced: CoalescedEvent;
+    queuesDiscarded: QueuesDiscardedEvent;
+    backpressure: BackpressureEvent;
+    policyApplied: PolicyAppliedEvent;
+    binaryMessage: BinaryMessageEvent;
+    binaryUnknownChannel: BinaryUnknownChannelEvent;
+    binaryIdCollision: BinaryIdCollisionEvent;
+    binaryMappingChanged: BinaryMappingChangedEvent;
+    presenceJoin: PresenceJoinEvent;
+    presenceLeave: PresenceLeaveEvent;
+    presenceInvalidated: PresenceInvalidatedEvent;
+    roomDeleted: RoomDeletedEvent;
+    sequenceGap: SequenceGapEvent;
+    protocolViolation: ProtocolViolationEvent;
+}
+type EventName = keyof EventMap;
+type EventPayload<E extends EventName> = EventMap[E];
+
+interface HeartbeatConfig {
+    enabled?: boolean;
+    intervalMs?: number;
+    timeoutMs?: number;
+    trackRtt?: boolean;
+}
+
+/**
+ * Structured logger interface and redaction utilities.
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+type Logger = (level: LogLevel, msg: string, fields?: Record<string, unknown>) => void;
+declare function redactUrl(rawUrl: string): string;
+declare function redactString(str: string, secrets: Iterable<string>): string;
+declare function redactValue(value: unknown, secrets: Iterable<string>): unknown;
+
+/**
+ * Reconnection backoff curves and jitter algorithms.
+ */
+type JitterMode = 'full' | 'equal' | 'none';
+interface ReconnectConfig {
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    maxAttempts?: number;
+    jitter?: JitterMode;
+    shouldReconnect?: (ctx: {
+        closeCode: number;
+        firstConnect: boolean;
+    }) => boolean;
+}
+declare function computeReconnectDelay(attempt: number, config?: {
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    jitter?: JitterMode;
+    random?: () => number;
+}): number;
+
+interface RoomIntent {
+    room: string;
+    passcode: string;
+    binaryChannels?: BinaryChannelMap$1;
+}
+type RoomFullPolicy = 'drop' | 'retry';
+interface RestoreConfig {
+    roomFullPolicy?: RoomFullPolicy;
+    restorePerRoomTimeoutMs?: number;
+}
+interface FailedIntent {
+    room: string;
+    code: ErrorCode;
+}
+
+interface Transport {
+    connect(url: string): Promise<void>;
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    readonly readyState: number;
+    bufferedAmount(): number;
+    onopen: (() => void) | null;
+    onmessage: (ev: {
+        data: unknown;
+    }) => void;
+    onclose: (ev: {
+        code: number;
+        reason: string;
+        wasClean: boolean;
+    }) => void;
+    onerror: (ev: unknown) => void;
+}
+declare class BrowserWebSocketTransport implements Transport {
+    private ws;
+    onopen: (() => void) | null;
+    onmessage: (ev: {
+        data: unknown;
+    }) => void;
+    onclose: (ev: {
+        code: number;
+        reason: string;
+        wasClean: boolean;
+    }) => void;
+    onerror: (ev: unknown) => void;
+    bufferedAmount(): number;
+    get readyState(): number;
+    connect(url: string): Promise<void>;
+    private cleanupPreOpen;
+    send(data: string | ArrayBufferLike | Blob): void;
+    close(code?: number, reason?: string): void;
+}
+
+interface BackpressureConfig {
+    enabled?: boolean;
+    highWaterMarkBytes?: number;
+    lowWaterMarkBytes?: number;
+    pollIntervalMs?: number;
+}
+type BackpressureEventCallback = (ev: {
+    state: 'high' | 'low';
+    bufferedAmount: number;
+}) => void;
+declare class BackpressureManager {
+    readonly enabled: boolean;
+    readonly highWaterMarkBytes: number;
+    readonly lowWaterMarkBytes: number;
+    readonly pollIntervalMs: number;
+    private blocked;
+    private pollTimer;
+    private readonly transport;
+    private readonly clock;
+    private readonly onStateChange;
+    private readonly onWakeWriter;
+    constructor(transport: Transport, clock: Clock, config: BackpressureConfig | undefined, onStateChange: BackpressureEventCallback, onWakeWriter: () => void);
+    start(): void;
+    private scheduleNextPoll;
+    stop(): void;
+    isBlocked(): boolean;
+    check(): boolean;
+}
+
+interface OutboundConfig {
+    reliableQueueSize?: number;
+    unreliableQueueSize?: number;
+    reliableOverflow?: 'drop' | 'close';
+    reliableBurst?: number;
+    unreliableBurst?: number;
+    policyProvider?: PolicyProvider;
+    enableClientRateLimit?: boolean;
+}
+interface OutboundFrame {
+    room: string;
+    channel: string;
+    reliable: boolean;
+    wire: string | ArrayBufferLike | Uint8Array;
+    frameType?: 'text' | 'binary';
+    coalesceKey?: string;
+}
+/**
+ * Bounded FIFO queue utilizing a sliding head index to maintain O(1) dequeue
+ * performance without invoking Array.prototype.shift() which incurs O(n) re-indexing.
+ */
+declare class OutboundQueue<T> {
+    private items;
+    private head;
+    readonly capacity: number;
+    constructor(capacity: number);
+    get size(): number;
+    enqueue(item: T): void;
+    dequeue(): T | undefined;
+    dropOldest(): T | undefined;
+    peek(): T | undefined;
+    clear(): number;
+}
+
+interface PresenceState {
+    known: Set<string>;
+    serverCount: number;
+    invalidated: boolean;
+    invalidReason: 'reconnected' | 'reliable presence gap' | '';
+}
+interface PresenceConfig {
+    autoInvalidateOnReliableGap?: boolean;
+}
+declare class PresenceManager {
+    private readonly states;
+    readonly autoInvalidateOnReliableGap: boolean;
+    constructor(config?: PresenceConfig);
+    get(room: string): PresenceState | undefined;
+    init(room: string, members: number): void;
+    remove(room: string): void;
+    clear(): void;
+    invalidateAll(): string[];
+    knownMembers(room: string, selfLabel: string): string[];
+    lastServerMemberCount(room: string): {
+        count: number;
+        ok: boolean;
+    };
+    presenceInvalidated(room: string): boolean;
+    resetPresence(room: string): void;
+}
+
+declare class SdkError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+
+declare const ROOM_NAME_RE: RegExp;
+declare const CHANNEL_NAME_RE: RegExp;
+interface ValidationConfig {
+    enabled?: boolean;
+    maxTextPayloadBytes?: number;
+    maxBinaryPayloadBytes?: number;
+}
+type ValidationField = 'room' | 'channel' | 'payload' | 'binary_payload';
+type ValidationRule = 'name_syntax' | 'reserved_channel' | 'too_large';
+declare class ValidationError extends SdkError {
+    readonly field: ValidationField;
+    readonly rule: ValidationRule;
+    readonly value: string;
+    readonly limit?: number;
+    constructor(field: ValidationField, rule: ValidationRule, value: string, limit?: number);
+}
+declare class BinaryPayloadTooLargeError extends ValidationError {
+    readonly byteLength: number;
+    readonly maxBytes: number;
+    constructor(byteLength: number, maxBytes: number);
+}
+declare function validateRoomName(room: string, config?: ValidationConfig): void;
+declare function validateChannelName(channel: string, config?: ValidationConfig): void;
+declare function validateTextPayloadSize(marshaledLength: number, config?: ValidationConfig): void;
+declare function validateBinaryPayloadSize(byteLength: number, config?: ValidationConfig): void;
+
+type AuthFailureMode = 'heuristic' | 'never-fatal' | 'always-fatal';
+type AuthMode = 'query';
+interface PublishRequest {
+    room: string;
+    channel?: string;
+    payload: unknown;
+    reliable?: boolean;
+    includeSender?: boolean;
+}
+interface ClientConfig {
+    url: string;
+    apiKey: string;
+    authFailureMode?: AuthFailureMode;
+    onAmbiguousAuth?: (closeCode: number, reason: string) => 'fatal' | 'retry';
+    reconnect?: ReconnectConfig;
+    heartbeat?: HeartbeatConfig;
+    restore?: RestoreConfig;
+    outbound?: OutboundConfig;
+    backpressure?: BackpressureConfig;
+    presence?: PresenceConfig;
+    errorPolicy?: ErrorPolicyConfig;
+    validation?: ValidationConfig;
+    maxBinaryPayloadBytes?: number;
+    welcomeTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    logger?: Logger;
+    clock?: Clock;
+    transport?: Transport;
+}
+declare function buildWsUrl(baseUrl: string, apiKey: string): string;
+declare class Client {
+    private readonly config;
+    private readonly clock;
+    private readonly emitter;
+    private readonly logger;
+    private transport;
+    private _state;
+    private _capabilities;
+    private serverVersion;
+    private firstConnectDone;
+    private currentConnWelcomeReceived;
+    private isRestoringSession;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private welcomeTimer;
+    private readonly intents;
+    private readonly waiters;
+    private listRoomsLock;
+    private heartbeatManager;
+    private readonly reliableQueue;
+    private readonly unreliableQueue;
+    private readonly coalesceManager;
+    private readonly backpressureManager;
+    private readonly rateLimiters;
+    private readonly writer;
+    private readonly policyOverrides;
+    private readonly appliedPolicies;
+    private _selfLabel;
+    private readonly binaryOwner;
+    private readonly presenceManager;
+    private readonly seqTracker;
+    private readonly rttTracker;
+    private readonly createdRooms;
+    private pingChain;
+    private pendingConnectResolve;
+    private pendingConnectReject;
+    constructor(config: ClientConfig);
+    get state(): State;
+    get capabilities(): Readonly<Capabilities> | undefined;
+    get selfLabel(): string;
+    knownMembers(room: string): string[];
+    lastServerMemberCount(room: string): {
+        count: number;
+        ok: boolean;
+    };
+    presenceInvalidated(room: string): boolean;
+    resetPresence(room: string): void;
+    lastSeq(room: string, channel: string): {
+        seq: number;
+        ok: boolean;
+    };
+    rttStats(): RttStats | undefined;
+    ping(timeoutMs?: number): Promise<number>;
+    private clearRoomState;
+    private isClosed;
+    on<E extends EventName>(event: E, handler: (payload: EventPayload<E>) => void): () => void;
+    connect(): Promise<WelcomeFrame>;
+    close(): Promise<void>;
+    createRoom(req: CreateRoomRequest): Promise<RoomCreatedFrame>;
+    joinRoomWithBinary(roomOrReq: string | (JoinRoomRequest & {
+        binaryChannels?: BinaryChannelMap;
+    }), passcodeOrNothing?: string, binaryChannelsOrNothing?: BinaryChannelMap): Promise<RoomJoinedFrame>;
+    joinRoom(req: JoinRoomRequest): Promise<RoomJoinedFrame>;
+    leaveRoom(room: string): Promise<RoomLeftFrame>;
+    deleteRoom(room: string): Promise<void>;
+    listRooms(): Promise<RoomListFrame>;
+    send(frame: ClientFrame): void;
+    publish(req: PublishRequest): Promise<void>;
+    publishBinary(roomOrReq: string | {
+        room: string;
+        channel: string;
+        payload: ArrayBuffer | Uint8Array;
+        reliable?: boolean;
+    }, channelOrNothing?: string, payloadOrNothing?: ArrayBuffer | Uint8Array): Promise<void>;
+    setChannelPolicy(room: string, channel: string, policy: ChannelPolicy): void;
+    queueDepth(): {
+        reliable: number;
+        unreliable: number;
+        coalesced: number;
+    };
+    bufferedAmount(): number;
+    __flushNow(): Promise<void>;
+    private getPolicy;
+    private discardOutboundQueues;
+    getRoomIntents(): RoomIntent[];
+    forgetRoom(room: string): void;
+    private transitionState;
+    private initiateConnect;
+    private setupTransportHandlers;
+    private handleIncomingData;
+    private handlePresenceMessage;
+    private handleWelcome;
+    private handleWelcomeTimeout;
+    private handlePreOpenFailure;
+    private handleSocketClose;
+    private classifyAndDispatch;
+    private triggerReconnect;
+    private restoreSession;
+    private sendWithCorrelation;
+    private handleErrorFrame;
+    private failPendingWaiters;
+    private clearTimers;
+    private rejectPendingConnect;
+}
+
+declare class TokenBucket {
+    readonly ratePerSec: number;
+    readonly burst: number;
+    private tokens;
+    private lastRefillMs;
+    private readonly clock;
+    constructor(ratePerSec: number, burst: number, clock: Clock);
+    advanceTo(now: number): void;
+    tryConsume(): boolean;
+    retryAfterMs(now: number): number;
+}
+declare class RateLimiterRegistry {
+    private readonly limiters;
+    private readonly serverBackoffs;
+    private readonly recentRoomByChan;
+    private readonly clock;
+    constructor(clock: Clock);
+    private makeKey;
+    get(room: string, channel: string, ratePerSec: number): TokenBucket;
+    recordPublish(room: string, channel: string): void;
+    getRecentRoom(channel: string): string | undefined;
+    pause(room: string, channel: string, untilMs: number): void;
+    isPaused(room: string, channel: string, now: number): {
+        paused: boolean;
+        retryAfterMs: number;
+    };
+    clearRoom(room: string): void;
+    clearAll(): void;
+}
+
+declare class CapabilityLimitError extends SdkError {
+    readonly limit: 'max_metadata_bytes' | 'max_channels_per_room' | 'max_rooms_per_key';
+    readonly requested: number;
+    readonly allowed: number;
+    constructor(limit: 'max_metadata_bytes' | 'max_channels_per_room' | 'max_rooms_per_key', requested: number, allowed: number);
+}
+declare function checkCapabilityPreflight(capabilities: Capabilities | undefined, req: CreateRoomRequest, ownedRoomsCount: number): void;
+
+declare class AuthError extends SdkError {
+    readonly code: "AUTH_FAILED";
+    constructor(message?: string, options?: ErrorOptions);
+}
+interface ConnectErrorCause {
+    closeCode?: number;
+    reason?: string;
+    [key: string]: unknown;
+}
+declare class ConnectError extends SdkError {
+    readonly cause?: ConnectErrorCause | unknown;
+    constructor(message: string, cause?: ConnectErrorCause | unknown);
+    get closeCode(): number | undefined;
+    get reason(): string | undefined;
+}
+declare class PolicyViolationError extends SdkError {
+    readonly code: "POLICY_VIOLATION";
+    readonly closeCode: number;
+    readonly reason?: string;
+    constructor(message?: string, closeCode?: number, reason?: string);
+}
+declare class RequestTimeoutError extends SdkError {
+    constructor(message?: string);
+}
+declare class ConcurrentRequestError extends SdkError {
+    constructor(message?: string);
+}
+declare class ServerError extends SdkError {
+    readonly code: ErrorCode;
+    readonly channel?: string;
+    readonly retryAfterMs?: number;
+    constructor(code: ErrorCode, message: string, channel?: string, retryAfterMs?: number);
+}
+declare class NotReadyError extends SdkError {
+    constructor(message?: string);
+}
+declare class ChannelNotReliableError extends SdkError {
+    readonly channel: string;
+    constructor(channel: string, message?: string);
+}
+declare class RateLimitedError extends SdkError {
+    readonly retryAfterMs: number;
+    readonly channel: string;
+    readonly source: 'local' | 'server';
+    constructor(retryAfterMs: number, channel: string, source: 'local' | 'server', message?: string);
+}
+type BinaryMapValidationReason = 'out_of_range' | 'reserved_channel' | 'duplicate_id' | 'duplicate_channel';
+declare class BinaryMapValidationError extends SdkError {
+    readonly channel: string;
+    readonly id: number;
+    readonly reason: BinaryMapValidationReason;
+    constructor(channel: string, id: number, reason: BinaryMapValidationReason);
+}
+declare class BinaryMapExhaustedError extends SdkError {
+    constructor(message?: string);
+}
+declare class BinaryIdCollisionError extends SdkError {
+    readonly id: number;
+    readonly existing: string[];
+    readonly rejected: string[];
+    constructor(id: number, existing: string[], rejected: string[]);
+}
+declare class BinaryChannelUnmappedError extends SdkError {
+    readonly room: string;
+    readonly channel: string;
+    constructor(room: string, channel: string);
+}
+
+interface SeqState {
+    last: number;
+    hasBase: boolean;
+}
+interface SequenceGapResult {
+    prev: number;
+    current: number;
+    missed: number;
+    reliable: boolean;
+}
+declare class SeqTracker {
+    private readonly states;
+    private makeKey;
+    lastSeq(room: string, channel: string): {
+        seq: number;
+        ok: boolean;
+    };
+    process(room: string, channel: string, seq: number, reliable: boolean): {
+        gap?: SequenceGapResult;
+    };
+    rebaselineAll(): void;
+    clearRoom(room: string): void;
+    clear(): void;
+}
+
+export { AuthError, type AuthFailureMode, type AuthMode, type BackpressureConfig, type BackpressureEvent, BackpressureManager, type BinaryChannelMap$1 as BinaryChannelMap, BinaryChannelUnmappedError, BinaryIdCollisionError, type BinaryIdCollisionEvent, BinaryMapBuilder, BinaryMapExhaustedError, BinaryMapValidationError, type BinaryMapValidationReason, type BinaryMappingChangedEvent, type BinaryMessageEvent, BinaryPayloadTooLargeError, type BinaryUnknownChannelEvent, BrowserWebSocketTransport, CHANNEL_NAME_RE, type Capabilities, type CapabilitiesChangedEvent, type CapabilityFeatures, CapabilityLimitError, type CapabilityLimits, type ChannelConfig, type ChannelConfigInput, ChannelNotReliableError, type ChannelPolicy, Client, type ClientConfig, type ClientFrame, type Clock, type CoalescedEvent, ConcurrentRequestError, ConnectError, type ConnectErrorCause, type ConnectedEvent, type CreateRoomRequest, type DeleteRoomRequest, type DisconnectedEvent, type ErrorAction, type ErrorClassification, type ErrorClassifiedEvent, type ErrorCode, type ErrorEvent, type ErrorFrame, type ErrorPolicyConfig, type EventMap, type EventName, type EventPayload, type FailedIntent, type FatalEvent, type HeartbeatConfig, type HeartbeatTimeoutEvent, type IntentFailedEvent, type JitterMode, type JoinRoomRequest, type LeaveRoomRequest, type ListRoomsFeatures, type ListRoomsRequest, type LogLevel, type Logger, type MessageFrame, NotReadyError, type OutboundConfig, type OutboundFrame, OutboundQueue, type PingRequest, type PolicyAppliedEvent, type PolicyProvider, PolicyViolationError, type PongFrame, type PresenceConfig, type PresenceInvalidatedEvent, type PresenceJoinEvent, type PresenceLeaveEvent, PresenceManager, type PresenceState, type ProtocolViolationEvent, type PublishRequest, type QueuesDiscardedEvent, ROOM_NAME_RE, RateLimitedError, type RateLimitedEvent, RateLimiterRegistry, RealClock, type ReconnectConfig, type ReconnectingEvent, type ReliableOverflowEvent, RequestTimeoutError, type RestoreConfig, type RoomCreatedFrame, type RoomDeletedEvent, type RoomFullPolicy, type RoomIntent, type RoomJoinedFrame, type RoomKind, type RoomLeftFrame, type RoomListFrame, type RoomSummary, type RttEvent$1 as RttEvent, type RttStats, RttTracker, SdkError, type SeqState, SeqTracker, type SequenceGapEvent, type SequenceGapResult, ServerError, type ServerFrame, type SessionRestoredEvent, type State, type StateChangeEvent, type Timer, TokenBucket, type Transport, type UnreliableDroppedEvent, type ValidationConfig, ValidationError, type ValidationField, type ValidationRule, type WelcomeFrame, type PublishRequest$1 as WirePublishRequest, buildWsUrl, checkCapabilityPreflight, classifyError, computeReconnectDelay, isErrorFrame, isMessageFrame, isWelcomeFrame, presetsFor, redactString, redactUrl, redactValue, resolvePolicy, validateBinaryMap, validateBinaryPayloadSize, validateChannelName, validateRoomName, validateTextPayloadSize };