@edge-base/react-native 0.2.5 → 0.2.7

package/dist/index.d.ts

@@ -431,100 +431,6 @@ declare class DatabaseLiveClient implements IDatabaseLiveSubscriber {
     private handleContextChange;
 }
 
-interface ParticipantMapLike<TParticipant> extends Iterable<TParticipant> {
-    values(): IterableIterator<TParticipant>;
-    on(event: 'participantJoined', handler: (participant: TParticipant) => void): void;
-    on(event: 'participantLeft', handler: (participant: TParticipant) => void): void;
-    on(event: 'participantsCleared', handler: () => void): void;
-    on(event: 'participantsUpdate', handler: () => void): void;
-    off(event: 'participantJoined', handler: (participant: TParticipant) => void): void;
-    off(event: 'participantLeft', handler: (participant: TParticipant) => void): void;
-    off(event: 'participantsCleared', handler: () => void): void;
-    off(event: 'participantsUpdate', handler: () => void): void;
-}
-type ParticipantEventHandlers = {
-    audioUpdate: (payload: {
-        audioEnabled: boolean;
-        audioTrack: MediaStreamTrack;
-    }) => void;
-    videoUpdate: (payload: {
-        videoEnabled: boolean;
-        videoTrack: MediaStreamTrack;
-    }) => void;
-    screenShareUpdate: (payload: {
-        screenShareEnabled: boolean;
-        screenShareTracks: {
-            audio?: MediaStreamTrack;
-            video?: MediaStreamTrack;
-        };
-    }) => void;
-};
-interface RoomCloudflareKitParticipant {
-    id: string;
-    customParticipantId?: string;
-    userId?: string;
-    audioTrack?: MediaStreamTrack;
-    audioEnabled?: boolean;
-    videoTrack?: MediaStreamTrack;
-    videoEnabled?: boolean;
-    screenShareTracks?: {
-        audio?: MediaStreamTrack;
-        video?: MediaStreamTrack;
-    };
-    screenShareEnabled?: boolean;
-    on<TEvent extends keyof ParticipantEventHandlers>(event: TEvent, handler: ParticipantEventHandlers[TEvent]): void;
-    off<TEvent extends keyof ParticipantEventHandlers>(event: TEvent, handler: ParticipantEventHandlers[TEvent]): void;
-}
-interface RoomCloudflareKitSelf {
-    id: string;
-    audioTrack?: MediaStreamTrack;
-    videoTrack?: MediaStreamTrack;
-    screenShareTracks?: {
-        audio?: MediaStreamTrack;
-        video?: MediaStreamTrack;
-    };
-    enableAudio(customTrack?: MediaStreamTrack): Promise<void>;
-    enableVideo(customTrack?: MediaStreamTrack): Promise<void>;
-    enableScreenShare(): Promise<void>;
-    disableAudio(): Promise<void>;
-    disableVideo(): Promise<void>;
-    disableScreenShare(): Promise<void>;
-    getDeviceById(deviceId: string, kind: string): Promise<unknown>;
-    setDevice(device: unknown): Promise<void>;
-}
-interface RoomCloudflareKitClient {
-    join?(): Promise<void>;
-    leave?(state?: unknown): Promise<void>;
-    joinRoom?(): Promise<void>;
-    leaveRoom?(state?: unknown): Promise<void>;
-    readonly participants: {
-        active?: ParticipantMapLike<RoomCloudflareKitParticipant>;
-        joined?: ParticipantMapLike<RoomCloudflareKitParticipant>;
-    };
-    readonly self: RoomCloudflareKitSelf;
-}
-interface RoomCloudflareKitClientFactory {
-    init(options: {
-        authToken: string;
-        defaults: {
-            audio: boolean;
-            video: boolean;
-        };
-    }): Promise<RoomCloudflareKitClient>;
-}
-interface RoomCloudflareMediaTransportOptions {
-    autoSubscribe?: boolean;
-    mediaDevices?: Pick<MediaDevices, 'getUserMedia' | 'getDisplayMedia' | 'enumerateDevices'>;
-    clientFactory?: RoomCloudflareKitClientFactory;
-}
-
-interface RoomP2PMediaTransportOptions {
-    rtcConfiguration?: RTCConfiguration;
-    peerConnectionFactory?: (configuration: RTCConfiguration) => RTCPeerConnection;
-    mediaDevices?: Pick<MediaDevices, 'getUserMedia' | 'getDisplayMedia'>;
-    signalPrefix?: string;
-}
-
 /**
  * RoomClient v2 — Client-side room connection for real-time multiplayer state.
  *
@@ -547,6 +453,14 @@ interface RoomOptions {
     sendTimeout?: number;
     /** Timeout for WebSocket connection establishment in ms (default: 15000) */
     connectionTimeout?: number;
+    /** Heartbeat ping interval in ms (default: 8000) */
+    heartbeatIntervalMs?: number;
+    /** Consider the room socket stale if no pong is observed within this window. */
+    heartbeatStaleTimeoutMs?: number;
+    /** Grace period before reacting to browser network type changes. */
+    networkRecoveryGraceMs?: number;
+    /** Time to wait for recovery before surfacing a session reset recommendation. */
+    disconnectResetTimeoutMs?: number;
 }
 
 type SharedStateHandler = (state: Record<string, unknown>, changes: Record<string, unknown>) => void;
@@ -577,99 +491,37 @@ interface RoomMember {
 interface RoomReconnectInfo {
     attempt: number;
 }
-type RoomMediaKind = 'audio' | 'video' | 'screen';
-interface RoomMediaTrack {
-    kind: RoomMediaKind;
-    trackId?: string;
-    deviceId?: string;
-    muted: boolean;
-    publishedAt?: number;
-    adminDisabled?: boolean;
-    providerSessionId?: string;
-}
-interface RoomMemberMediaKindState {
-    published: boolean;
-    muted: boolean;
-    trackId?: string;
-    deviceId?: string;
-    publishedAt?: number;
-    adminDisabled?: boolean;
-    providerSessionId?: string;
-}
-interface RoomMemberMediaState {
-    audio?: RoomMemberMediaKindState;
-    video?: RoomMemberMediaKindState;
-    screen?: RoomMemberMediaKindState;
-}
-interface RoomMediaMember {
-    member: RoomMember;
-    state: RoomMemberMediaState;
-    tracks: RoomMediaTrack[];
+interface RoomRecoveryFailureInfo {
+    state: RoomConnectionState;
+    timeoutMs: number;
 }
-interface RoomMediaDeviceChange {
-    kind: RoomMediaKind;
-    deviceId: string;
-}
-interface RoomCloudflareRealtimeKitCreateSessionRequest {
-    connectionId?: string;
-    customParticipantId?: string;
-    name?: string;
-    picture?: string;
-}
-interface RoomCloudflareRealtimeKitCreateSessionResponse {
-    sessionId: string;
-    meetingId: string;
-    participantId: string;
-    authToken: string;
-    presetName: string;
-    connectionId?: string;
-    reused?: boolean;
-}
-interface RoomMediaTransportConnectPayload {
-    connectionId?: string;
-    customParticipantId?: string;
-    name?: string;
-    picture?: string;
-}
-interface RoomMediaRemoteTrackEvent {
-    kind: RoomMediaKind;
-    track: MediaStreamTrack;
-    stream?: MediaStream;
-    trackName?: string;
-    providerSessionId?: string;
-    participantId?: string;
-    customParticipantId?: string;
-    userId?: string;
-}
-interface RoomMediaTransport {
-    connect(payload?: RoomMediaTransportConnectPayload): Promise<string>;
-    enableAudio(constraints?: MediaTrackConstraints | boolean): Promise<MediaStreamTrack>;
-    enableVideo(constraints?: MediaTrackConstraints | boolean): Promise<MediaStreamTrack>;
-    startScreenShare(constraints?: unknown): Promise<MediaStreamTrack>;
-    disableAudio(): Promise<void>;
-    disableVideo(): Promise<void>;
-    stopScreenShare(): Promise<void>;
-    setMuted(kind: Extract<RoomMediaKind, 'audio' | 'video'>, muted: boolean): Promise<void>;
-    switchDevices(payload: {
-        audioInputId?: string;
-        videoInputId?: string;
-        screenInputId?: string;
-    }): Promise<void>;
-    onRemoteTrack(handler: (event: RoomMediaRemoteTrackEvent) => void): Subscription;
-    getSessionId(): string | null;
-    getPeerConnection(): RTCPeerConnection | null;
-    destroy(): void;
-}
-type RoomMediaTransportProvider = 'cloudflare_realtimekit' | 'p2p';
-interface RoomCloudflareRealtimeKitTransportFactoryOptions {
-    provider?: 'cloudflare_realtimekit';
-    cloudflareRealtimeKit?: RoomCloudflareMediaTransportOptions;
+interface RoomConnectDiagnostic {
+    ok: boolean;
+    type: string;
+    category: string;
+    message: string;
+    namespace?: string;
+    roomId?: string;
+    runtime?: string;
+    pendingCount?: number;
+    maxPending?: number;
+}
+interface RoomSummary {
+    namespace: string;
+    roomId: string;
+    metadata: Record<string, unknown>;
+    occupancy: {
+        activeMembers: number;
+        activeConnections: number;
+    };
+    updatedAt: string;
 }
-interface RoomP2PTransportFactoryOptions {
-    provider: 'p2p';
-    p2p?: RoomP2PMediaTransportOptions;
+interface RoomSummaryCollection {
+    namespace: string;
+    items: RoomSummary[];
+    deniedIds: string[];
+    updatedAt: string;
 }
-type RoomMediaTransportOptions = RoomCloudflareRealtimeKitTransportFactoryOptions | RoomP2PTransportFactoryOptions;
 declare class RoomClient {
     private baseUrl;
     private tokenManager;
@@ -683,7 +535,7 @@ declare class RoomClient {
     private _playerState;
     private _playerVersion;
     private _members;
-    private _mediaMembers;
+    private lastLocalMemberState;
     private ws;
     private reconnectAttempts;
     private connected;
@@ -695,15 +547,19 @@ declare class RoomClient {
     private reconnectInfo;
     private connectingPromise;
     private heartbeatTimer;
+    private lastHeartbeatAckAt;
+    private disconnectResetTimer;
     private intentionallyLeft;
     private waitingForAuth;
     private joinRequested;
     private unsubAuthState;
+    private browserNetworkListenersAttached;
+    private readonly browserOfflineHandler;
+    private readonly browserOnlineHandler;
     private pendingRequests;
     private pendingSignalRequests;
     private pendingAdminRequests;
     private pendingMemberStateRequests;
-    private pendingMediaRequests;
     private sharedStateHandlers;
     private playerStateHandlers;
     private messageHandlers;
@@ -711,16 +567,14 @@ declare class RoomClient {
     private errorHandlers;
     private kickedHandlers;
     private memberSyncHandlers;
+    private memberSnapshotHandlers;
     private memberJoinHandlers;
     private memberLeaveHandlers;
     private memberStateHandlers;
     private signalHandlers;
     private anySignalHandlers;
-    private mediaTrackHandlers;
-    private mediaTrackRemovedHandlers;
-    private mediaStateHandlers;
-    private mediaDeviceHandlers;
     private reconnectHandlers;
+    private recoveryFailureHandlers;
     private connectionStateHandlers;
     readonly state: {
         getShared: () => Record<string, unknown>;
@@ -731,6 +585,7 @@ declare class RoomClient {
     };
     readonly meta: {
         get: () => Promise<Record<string, unknown>>;
+        summary: () => Promise<RoomSummary>;
     };
     readonly signals: {
         send: (event: string, payload?: unknown, options?: {
@@ -743,7 +598,9 @@ declare class RoomClient {
     readonly members: {
         list: () => RoomMember[];
         current: () => RoomMember | null;
+        awaitCurrent: (timeoutMs?: number) => Promise<RoomMember | null>;
         onSync: (handler: (members: RoomMember[]) => void) => Subscription;
+        onSnapshot: (handler: (members: RoomMember[]) => void) => Subscription;
         onJoin: (handler: (member: RoomMember) => void) => Subscription;
         onLeave: (handler: (member: RoomMember, reason: RoomMemberLeaveReason) => void) => Subscription;
         setState: (state: Record<string, unknown>) => Promise<void>;
@@ -752,81 +609,49 @@ declare class RoomClient {
     };
     readonly admin: {
         kick: (memberId: string) => Promise<void>;
-        mute: (memberId: string) => Promise<void>;
         block: (memberId: string) => Promise<void>;
         setRole: (memberId: string, role: string) => Promise<void>;
-        disableVideo: (memberId: string) => Promise<void>;
-        stopScreenShare: (memberId: string) => Promise<void>;
-    };
-    readonly media: {
-        list: () => RoomMediaMember[];
-        audio: {
-            enable: (payload?: {
-                trackId?: string;
-                deviceId?: string;
-            }) => Promise<void>;
-            disable: () => Promise<void>;
-            setMuted: (muted: boolean) => Promise<void>;
-        };
-        video: {
-            enable: (payload?: {
-                trackId?: string;
-                deviceId?: string;
-            }) => Promise<void>;
-            disable: () => Promise<void>;
-            setMuted: (muted: boolean) => Promise<void>;
-        };
-        screen: {
-            start: (payload?: {
-                trackId?: string;
-                deviceId?: string;
-            }) => Promise<void>;
-            stop: () => Promise<void>;
-        };
-        devices: {
-            switch: (payload: {
-                audioInputId?: string;
-                videoInputId?: string;
-                screenInputId?: string;
-            }) => Promise<void>;
-        };
-        cloudflareRealtimeKit: {
-            createSession: (payload?: RoomCloudflareRealtimeKitCreateSessionRequest) => Promise<RoomCloudflareRealtimeKitCreateSessionResponse>;
-        };
-        transport: (options?: RoomMediaTransportOptions) => RoomMediaTransport;
-        onTrack: (handler: (track: RoomMediaTrack, member: RoomMember) => void) => Subscription;
-        onTrackRemoved: (handler: (track: RoomMediaTrack, member: RoomMember) => void) => Subscription;
-        onStateChange: (handler: (member: RoomMember, state: RoomMemberMediaState) => void) => Subscription;
-        onDeviceChange: (handler: (member: RoomMember, change: RoomMediaDeviceChange) => void) => Subscription;
     };
     readonly session: {
         onError: (handler: ErrorHandler) => Subscription;
         onKicked: (handler: KickedHandler) => Subscription;
         onReconnect: (handler: (info: RoomReconnectInfo) => void) => Subscription;
         onConnectionStateChange: (handler: (state: RoomConnectionState) => void) => Subscription;
+        onRecoveryFailure: (handler: (info: RoomRecoveryFailureInfo) => void) => Subscription;
+        getDebugSnapshot: () => unknown;
     };
     constructor(baseUrl: string, namespace: string, roomId: string, tokenManager: TokenManager, options?: RoomOptions);
     /** Get current shared state (read-only snapshot) */
     getSharedState(): Record<string, unknown>;
     /** Get current player state (read-only snapshot) */
     getPlayerState(): Record<string, unknown>;
+    private waitForCurrentMember;
     /**
      * Get room metadata without joining (HTTP GET).
      * Returns developer-defined metadata set by room.setMetadata() on the server.
      */
     getMetadata(): Promise<Record<string, unknown>>;
-    private requestCloudflareRealtimeKitMedia;
-    private requestRoomMedia;
+    getSummary(): Promise<RoomSummary>;
+    checkConnection(): Promise<RoomConnectDiagnostic>;
     /**
      * Static: Get room metadata without creating a RoomClient instance.
      * Useful for lobby screens where you need room info before joining.
      */
     static getMetadata(baseUrl: string, namespace: string, roomId: string): Promise<Record<string, unknown>>;
+    static getSummary(baseUrl: string, namespace: string, roomId: string): Promise<RoomSummary>;
+    static getSummaries(baseUrl: string, namespace: string, roomIds: string[]): Promise<RoomSummaryCollection>;
+    static checkConnection(baseUrl: string, namespace: string, roomId: string): Promise<RoomConnectDiagnostic>;
+    private static requestPublicRoomResource;
     /** Connect to the room, authenticate, and join */
     join(): Promise<void>;
     /** Leave the room and disconnect. Cleans up all pending requests. */
     leave(): void;
-    /** Destroy the room client, cleaning up all listeners and the auth subscription. */
+    private assertConnected;
+    /**
+     * Destroy the RoomClient and release all resources.
+     * Calls leave() if still connected, unsubscribes from auth state changes,
+     * and clears all handler arrays to allow garbage collection.
+     */
     destroy(): void;
     /**
      * Send an action to the server.
@@ -872,22 +697,18 @@ declare class RoomClient {
     private onSignal;
     private onAnySignal;
     private onMembersSync;
+    private onMemberSnapshot;
     private onMemberJoin;
     private onMemberLeave;
     private onMemberStateChange;
     private onReconnect;
+    private onRecoveryFailure;
     private onConnectionStateChange;
-    private onMediaTrack;
-    private onMediaTrackRemoved;
-    private onMediaStateChange;
-    private onMediaDeviceChange;
     private sendSignal;
     private sendMemberState;
     private clearMemberState;
     private sendMemberStateRequest;
     private sendAdmin;
-    private sendMedia;
-    private switchMediaDevices;
     private establishConnection;
     private ensureConnection;
     private authenticate;
@@ -903,17 +724,10 @@ declare class RoomClient {
     private handleSignalSent;
     private handleSignalError;
     private handleMembersSync;
-    private handleMediaSync;
     private handleMemberJoinFrame;
     private handleMemberLeaveFrame;
     private handleMemberStateFrame;
     private handleMemberStateError;
-    private handleMediaTrackFrame;
-    private handleMediaTrackRemovedFrame;
-    private handleMediaStateFrame;
-    private handleMediaDeviceFrame;
-    private handleMediaResult;
-    private handleMediaError;
     private handleAdminResult;
     private handleAdminError;
     private handleKicked;
@@ -921,34 +735,32 @@ declare class RoomClient {
     private refreshAuth;
     private handleAuthStateChange;
     private handleAuthenticationFailure;
+    private shouldTreatErrorAsAuthLoss;
+    private hasPendingRequests;
+    private handleRoomAuthStateLoss;
     private normalizeMembers;
-    private normalizeMediaMembers;
     private normalizeMember;
     private normalizeState;
-    private normalizeMediaMember;
-    private normalizeMediaState;
-    private normalizeMediaKindState;
-    private normalizeMediaTracks;
-    private normalizeMediaTrack;
-    private normalizeMediaKind;
     private normalizeSignalMeta;
     private normalizeLeaveReason;
+    private getDebugSnapshot;
     private upsertMember;
     private removeMember;
-    private syncMediaMemberInfo;
-    private ensureMediaMember;
-    private removeMediaMember;
-    private upsertMediaTrack;
-    private removeMediaTrack;
-    private mergeMediaState;
+    /** Reject all 5 pending request maps at once. */
     private rejectAllPendingRequests;
     private rejectPendingVoidRequests;
+    private shouldScheduleDisconnectReset;
+    private clearDisconnectResetTimer;
+    private scheduleDisconnectReset;
     private setConnectionState;
     private sendRaw;
     private buildWsUrl;
+    private attachBrowserNetworkListeners;
+    private detachBrowserNetworkListeners;
     private scheduleReconnect;
     private startHeartbeat;
     private stopHeartbeat;
+    private getReconnectMemberState;
 }
 
 /**
@@ -1410,4 +1222,4 @@ declare function useTurnstile({ baseUrl, action, }: UseTurnstileOptions): UseTur
  */
 declare function isPlatformWeb(): boolean;
 
-export { type AppStateAdapter, type AsyncStorageAdapter, AuthClient, type AuthResult, type AuthStateChangeHandler, ClientAnalytics, ClientEdgeBase, DatabaseLiveClient, type DatabaseLiveClientAdapter, type DatabaseLiveOptions, type FilterEntry, type FilterOperator, type JuneClientOptions, LifecycleManager, type LinkingAdapter, type PasskeysAuthOptions, PushClient, type PushMessage, type PushMessageHandler, type PushPermissionProvider, type PushPermissionStatus, type PushPlatform, type PushTokenProvider, RoomClient, type RoomCloudflareRealtimeKitCreateSessionRequest, type RoomCloudflareRealtimeKitCreateSessionResponse, type RoomCloudflareRealtimeKitTransportFactoryOptions, type RoomConnectionState, type RoomMediaDeviceChange, type RoomMediaKind, type RoomMediaMember, type RoomMediaRemoteTrackEvent, type RoomMediaTrack, type RoomMediaTransport, type RoomMediaTransportConnectPayload, type RoomMediaTransportOptions, type RoomMediaTransportProvider, type RoomMember, type RoomMemberLeaveReason, type RoomMemberMediaKindState, type RoomMemberMediaState, type RoomOptions, type RoomP2PTransportFactoryOptions, type RoomReconnectInfo, type RoomSignalMeta, type Session, type SignInOptions, type SignUpOptions, TokenManager, type TokenPair, type TokenUser, TurnstileWebView, type TurnstileWebViewProps, type UpdateProfileOptions, type UseLifecycleOptions, type UseTurnstileOptions, type UseTurnstileResult, createClient, isPlatformWeb, matchesFilter, useLifecycle, useTurnstile };
+export { type AppStateAdapter, type AsyncStorageAdapter, AuthClient, type AuthResult, type AuthStateChangeHandler, ClientAnalytics, ClientEdgeBase, DatabaseLiveClient, type DatabaseLiveClientAdapter, type DatabaseLiveOptions, type FilterEntry, type FilterOperator, type JuneClientOptions, LifecycleManager, type LinkingAdapter, type PasskeysAuthOptions, PushClient, type PushMessage, type PushMessageHandler, type PushPermissionProvider, type PushPermissionStatus, type PushPlatform, type PushTokenProvider, RoomClient, type RoomConnectDiagnostic, type RoomConnectionState, type RoomMember, type RoomMemberLeaveReason, type RoomOptions, type RoomReconnectInfo, type RoomRecoveryFailureInfo, type RoomSignalMeta, type RoomSummary, type RoomSummaryCollection, type Session, type SignInOptions, type SignUpOptions, TokenManager, type TokenPair, type TokenUser, TurnstileWebView, type TurnstileWebViewProps, type UpdateProfileOptions, type UseLifecycleOptions, type UseTurnstileOptions, type UseTurnstileResult, createClient, isPlatformWeb, matchesFilter, useLifecycle, useTurnstile };