@edge-base/web 0.2.5 → 0.2.7

package/dist/room.js

@@ -1,7 +1,5 @@
-import { EdgeBaseError, createSubscription } from '@edge-base/core';
+import { EdgeBaseError, createSubscription, networkError, parseErrorResponse, } from '@edge-base/core';
 import { refreshAccessToken } from './auth-refresh.js';
-import { RoomCloudflareMediaTransport, } from './room-cloudflare-media.js';
-import { RoomP2PMediaTransport, } from './room-p2p-media.js';
 export { createSubscription };
 // ─── Helpers ───
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
@@ -46,19 +44,21 @@ const WS_OPEN = 1;
 const ROOM_EXPLICIT_LEAVE_CLOSE_CODE = 4005;
 const ROOM_AUTH_STATE_LOST_CLOSE_CODE = 4006;
 const ROOM_EXPLICIT_LEAVE_REASON = 'Client left room';
-const ROOM_EXPLICIT_LEAVE_CLOSE_DELAY_MS = 40;
+const ROOM_HEARTBEAT_INTERVAL_MS = 8000;
+const ROOM_HEARTBEAT_STALE_TIMEOUT_MS = 20_000;
 function isSocketOpenOrConnecting(socket) {
     return !!socket && (socket.readyState === WS_OPEN || socket.readyState === WS_CONNECTING);
 }
 function closeSocketAfterLeave(socket, reason) {
-    globalThis.setTimeout(() => {
-        try {
-            socket.close(ROOM_EXPLICIT_LEAVE_CLOSE_CODE, reason);
-        }
-        catch {
-            // Socket already closed.
-        }
-    }, ROOM_EXPLICIT_LEAVE_CLOSE_DELAY_MS);
+    try {
+        socket.close(ROOM_EXPLICIT_LEAVE_CLOSE_CODE, reason);
+    }
+    catch {
+        // Socket already closed.
+    }
+}
+function getDefaultHeartbeatStaleTimeoutMs(heartbeatIntervalMs) {
+    return Math.max(Math.floor(heartbeatIntervalMs * 2.5), ROOM_HEARTBEAT_STALE_TIMEOUT_MS);
 }
 // ─── RoomClient v2 ───
 export class RoomClient {
@@ -75,7 +75,7 @@ export class RoomClient {
     _playerState = {};
     _playerVersion = 0;
     _members = [];
-    _mediaMembers = [];
+    lastLocalMemberState = null;
     // ─── Connection ───
     ws = null;
     reconnectAttempts = 0;
@@ -88,6 +88,8 @@ export class RoomClient {
     reconnectInfo = null;
     connectingPromise = null;
     heartbeatTimer = null;
+    lastHeartbeatAckAt = Date.now();
+    disconnectResetTimer = null;
     intentionallyLeft = false;
     waitingForAuth = false;
     joinRequested = false;
@@ -125,7 +127,6 @@ export class RoomClient {
     pendingSignalRequests = new Map();
     pendingAdminRequests = new Map();
     pendingMemberStateRequests = new Map();
-    pendingMediaRequests = new Map();
     // ─── Subscriptions ───
     sharedStateHandlers = [];
     playerStateHandlers = [];
@@ -134,16 +135,14 @@ export class RoomClient {
     errorHandlers = [];
     kickedHandlers = [];
     memberSyncHandlers = [];
+    memberSnapshotHandlers = [];
     memberJoinHandlers = [];
     memberLeaveHandlers = [];
     memberStateHandlers = [];
     signalHandlers = new Map();
     anySignalHandlers = [];
-    mediaTrackHandlers = [];
-    mediaTrackRemovedHandlers = [];
-    mediaStateHandlers = [];
-    mediaDeviceHandlers = [];
     reconnectHandlers = [];
+    recoveryFailureHandlers = [];
     connectionStateHandlers = [];
     state = {
         getShared: () => this.getSharedState(),
@@ -154,6 +153,7 @@ export class RoomClient {
     };
     meta = {
         get: () => this.getMetadata(),
+        summary: () => this.getSummary(),
     };
     signals = {
         send: (event, payload, options) => this.sendSignal(event, payload, options),
@@ -162,7 +162,7 @@ export class RoomClient {
         onAny: (handler) => this.onAnySignal(handler),
     };
     members = {
-        list: () => cloneValue(this._members),
+        list: () => this._members.map((member) => cloneValue(member)),
         current: () => {
             const connectionId = this.currentConnectionId;
             if (connectionId) {
@@ -178,7 +178,9 @@ export class RoomClient {
             const member = this._members.find((entry) => entry.userId === userId) ?? null;
             return member ? cloneValue(member) : null;
         },
+        awaitCurrent: (timeoutMs = 10_000) => this.waitForCurrentMember(timeoutMs),
         onSync: (handler) => this.onMembersSync(handler),
+        onSnapshot: (handler) => this.onMemberSnapshot(handler),
         onJoin: (handler) => this.onMemberJoin(handler),
         onLeave: (handler) => this.onMemberLeave(handler),
         setState: (state) => this.sendMemberState(state),
@@ -187,59 +189,16 @@ export class RoomClient {
     };
     admin = {
         kick: (memberId) => this.sendAdmin('kick', memberId),
-        mute: (memberId) => this.sendAdmin('mute', memberId),
         block: (memberId) => this.sendAdmin('block', memberId),
         setRole: (memberId, role) => this.sendAdmin('setRole', memberId, { role }),
-        disableVideo: (memberId) => this.sendAdmin('disableVideo', memberId),
-        stopScreenShare: (memberId) => this.sendAdmin('stopScreenShare', memberId),
-    };
-    media = {
-        list: () => cloneValue(this._mediaMembers),
-        audio: {
-            enable: (payload) => this.sendMedia('publish', 'audio', payload),
-            disable: () => this.sendMedia('unpublish', 'audio'),
-            setMuted: (muted) => this.sendMedia('mute', 'audio', { muted }),
-        },
-        video: {
-            enable: (payload) => this.sendMedia('publish', 'video', payload),
-            disable: () => this.sendMedia('unpublish', 'video'),
-            setMuted: (muted) => this.sendMedia('mute', 'video', { muted }),
-        },
-        screen: {
-            start: (payload) => this.sendMedia('publish', 'screen', payload),
-            stop: () => this.sendMedia('unpublish', 'screen'),
-        },
-        devices: {
-            switch: (payload) => this.switchMediaDevices(payload),
-        },
-        realtime: {
-            iceServers: (payload) => this.requestRealtimeMedia('turn', 'POST', payload),
-        },
-        cloudflareRealtimeKit: {
-            createSession: (payload) => this.requestCloudflareRealtimeKitMedia('session', 'POST', payload),
-        },
-        transport: (options) => {
-            // Infer provider from options: if cloudflareRealtimeKit config is present, use it;
-            // otherwise default to p2p for zero-config local development.
-            const hasCloudflareConfig = options && 'cloudflareRealtimeKit' in options && options.cloudflareRealtimeKit != null;
-            const provider = options?.provider ?? (hasCloudflareConfig ? 'cloudflare_realtimekit' : 'p2p');
-            if (provider === 'p2p') {
-                const p2pOptions = options?.p2p;
-                return new RoomP2PMediaTransport(this, p2pOptions);
-            }
-            const cloudflareOptions = options?.cloudflareRealtimeKit;
-            return new RoomCloudflareMediaTransport(this, cloudflareOptions);
-        },
-        onTrack: (handler) => this.onMediaTrack(handler),
-        onTrackRemoved: (handler) => this.onMediaTrackRemoved(handler),
-        onStateChange: (handler) => this.onMediaStateChange(handler),
-        onDeviceChange: (handler) => this.onMediaDeviceChange(handler),
     };
     session = {
         onError: (handler) => this.onError(handler),
         onKicked: (handler) => this.onKicked(handler),
         onReconnect: (handler) => this.onReconnect(handler),
         onConnectionStateChange: (handler) => this.onConnectionStateChange(handler),
+        onRecoveryFailure: (handler) => this.onRecoveryFailure(handler),
+        getDebugSnapshot: () => this.getDebugSnapshot(),
     };
     constructor(baseUrl, namespace, roomId, tokenManager, options) {
         this.baseUrl = baseUrl;
@@ -252,6 +211,11 @@ export class RoomClient {
             reconnectBaseDelay: options?.reconnectBaseDelay ?? 1000,
             sendTimeout: options?.sendTimeout ?? 10000,
             connectionTimeout: options?.connectionTimeout ?? 15000,
+            heartbeatIntervalMs: options?.heartbeatIntervalMs ?? ROOM_HEARTBEAT_INTERVAL_MS,
+            heartbeatStaleTimeoutMs: options?.heartbeatStaleTimeoutMs
+                ?? getDefaultHeartbeatStaleTimeoutMs(options?.heartbeatIntervalMs ?? ROOM_HEARTBEAT_INTERVAL_MS),
+            networkRecoveryGraceMs: options?.networkRecoveryGraceMs ?? 3500,
+            disconnectResetTimeoutMs: options?.disconnectResetTimeoutMs ?? 8000,
         };
         this.unsubAuthState = this.tokenManager.onAuthStateChange((user) => {
             this.handleAuthStateChange(user);
@@ -267,6 +231,17 @@ export class RoomClient {
     getPlayerState() {
         return cloneRecord(this._playerState);
     }
+    async waitForCurrentMember(timeoutMs = 10_000) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs) {
+            const member = this.members.current();
+            if (member) {
+                return member;
+            }
+            await new Promise((resolve) => globalThis.setTimeout(resolve, 50));
+        }
+        return this.members.current();
+    }
     // ─── Metadata (HTTP, no WebSocket needed) ───
     /**
      * Get room metadata without joining (HTTP GET).
@@ -275,45 +250,91 @@ export class RoomClient {
     async getMetadata() {
         return RoomClient.getMetadata(this.baseUrl, this.namespace, this.roomId);
     }
+    async getSummary() {
+        return RoomClient.getSummary(this.baseUrl, this.namespace, this.roomId);
+    }
+    async checkConnection() {
+        return RoomClient.checkConnection(this.baseUrl, this.namespace, this.roomId);
+    }
     /**
      * Static: Get room metadata without creating a RoomClient instance.
      * Useful for lobby screens where you need room info before joining.
      */
     static async getMetadata(baseUrl, namespace, roomId) {
-        const url = `${baseUrl.replace(/\/$/, '')}/api/room/metadata?namespace=${encodeURIComponent(namespace)}&id=${encodeURIComponent(roomId)}`;
-        const res = await fetch(url);
-        if (!res.ok) {
-            throw new EdgeBaseError(res.status, `Failed to get room metadata: ${res.statusText}`);
-        }
-        return res.json();
+        return RoomClient.requestPublicRoomResource(baseUrl, 'metadata', namespace, roomId, 'Failed to get room metadata');
     }
-    async requestCloudflareRealtimeKitMedia(path, method, payload) {
-        return this.requestRoomMedia('cloudflare_realtimekit', path, method, payload);
+    static async getSummary(baseUrl, namespace, roomId) {
+        return RoomClient.requestPublicRoomResource(baseUrl, 'summary', namespace, roomId, 'Failed to get room summary');
     }
-    async requestRealtimeMedia(path, method, payload) {
-        return this.requestRoomMedia('realtime', path, method, payload);
+    static async getSummaries(baseUrl, namespace, roomIds) {
+        const url = `${baseUrl.replace(/\/$/, '')}/api/room/summaries`;
+        let res;
+        try {
+            res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ namespace, ids: roomIds }),
+            });
+        }
+        catch (error) {
+            throw networkError(`Failed to get room summaries. Could not reach ${baseUrl.replace(/\/$/, '')}. Make sure the EdgeBase server is running and reachable.`, { cause: error });
+        }
+        const data = (await res.json().catch(() => null));
+        if (!res.ok) {
+            const parsed = parseErrorResponse(res.status, data);
+            parsed.message = `Failed to get room summaries: ${parsed.message}`;
+            throw parsed;
+        }
+        return data;
     }
-    async requestRoomMedia(providerPath, path, method, payload) {
-        const token = await this.tokenManager.getAccessToken((refreshToken) => refreshAccessToken(this.baseUrl, refreshToken));
-        if (!token) {
-            throw new EdgeBaseError(401, 'Authentication required');
-        }
-        const url = new URL(`${this.baseUrl.replace(/\/$/, '')}/api/room/media/${providerPath}/${path}`);
-        url.searchParams.set('namespace', this.namespace);
-        url.searchParams.set('id', this.roomId);
-        const response = await fetch(url.toString(), {
-            method,
-            headers: {
-                Authorization: `Bearer ${token}`,
-                'Content-Type': 'application/json',
-            },
-            body: method === 'GET' ? undefined : JSON.stringify(payload ?? {}),
-        });
-        const data = (await response.json().catch(() => ({})));
+    static async checkConnection(baseUrl, namespace, roomId) {
+        const url = `${baseUrl.replace(/\/$/, '')}/api/room/connect-check?namespace=${encodeURIComponent(namespace)}&id=${encodeURIComponent(roomId)}`;
+        let response;
+        try {
+            response = await fetch(url);
+        }
+        catch (error) {
+            throw networkError(`Room connect-check could not reach ${baseUrl.replace(/\/$/, '')}. Make sure the EdgeBase server is running and reachable.`, { cause: error });
+        }
+        const data = (await response.json().catch(() => null));
         if (!response.ok) {
-            throw new EdgeBaseError(response.status, (typeof data.message === 'string' && data.message) || `Room media request failed: ${response.statusText}`);
+            throw parseErrorResponse(response.status, data);
         }
-        return data;
+        if (typeof data?.ok !== 'boolean'
+            || typeof data?.type !== 'string'
+            || typeof data?.category !== 'string'
+            || typeof data?.message !== 'string') {
+            throw new EdgeBaseError(response.status || 500, 'Room connect-check returned an unexpected response. The EdgeBase server and SDK may be out of sync.');
+        }
+        const diagnostic = data;
+        return {
+            ok: diagnostic.ok,
+            type: diagnostic.type,
+            category: diagnostic.category,
+            message: diagnostic.message,
+            namespace: typeof diagnostic.namespace === 'string' ? diagnostic.namespace : undefined,
+            roomId: typeof diagnostic.roomId === 'string' ? diagnostic.roomId : undefined,
+            runtime: typeof diagnostic.runtime === 'string' ? diagnostic.runtime : undefined,
+            pendingCount: typeof diagnostic.pendingCount === 'number' ? diagnostic.pendingCount : undefined,
+            maxPending: typeof diagnostic.maxPending === 'number' ? diagnostic.maxPending : undefined,
+        };
+    }
+    static async requestPublicRoomResource(baseUrl, resource, namespace, roomId, failureMessage) {
+        const url = `${baseUrl.replace(/\/$/, '')}/api/room/${resource}?namespace=${encodeURIComponent(namespace)}&id=${encodeURIComponent(roomId)}`;
+        let res;
+        try {
+            res = await fetch(url);
+        }
+        catch (error) {
+            throw networkError(`${failureMessage}. Could not reach ${baseUrl.replace(/\/$/, '')}. Make sure the EdgeBase server is running and reachable.`, { cause: error });
+        }
+        if (!res.ok) {
+            const data = await res.json().catch(() => null);
+            const parsed = parseErrorResponse(res.status, data);
+            parsed.message = `${failureMessage}: ${parsed.message}`;
+            throw parsed;
+        }
+        return res.json();
     }
     // ─── Connection Lifecycle ───
     /** Connect to the room, authenticate, and join */
@@ -332,6 +353,7 @@ export class RoomClient {
         this.joinRequested = false;
         this.waitingForAuth = false;
         this.stopHeartbeat();
+        this.clearDisconnectResetTimer();
         // Reject all pending send() requests
         this.rejectAllPendingRequests(new EdgeBaseError(499, 'Room left'));
         if (this.ws) {
@@ -349,12 +371,17 @@ export class RoomClient {
         this._playerState = {};
         this._playerVersion = 0;
         this._members = [];
-        this._mediaMembers = [];
+        this.lastLocalMemberState = null;
         this.currentUserId = null;
         this.currentConnectionId = null;
         this.reconnectInfo = null;
         this.setConnectionState('disconnected');
     }
+    assertConnected(action) {
+        if (!this.ws || !this.connected || !this.authenticated) {
+            throw new EdgeBaseError(400, `Room connection required before ${action}. Call room.join() and wait for the connection to finish.`);
+        }
+    }
     /**
      * Destroy the RoomClient and release all resources.
      * Calls leave() if still connected, unsubscribes from auth state changes,
@@ -378,10 +405,6 @@ export class RoomClient {
         this.memberStateHandlers.length = 0;
         this.signalHandlers.clear();
         this.anySignalHandlers.length = 0;
-        this.mediaTrackHandlers.length = 0;
-        this.mediaTrackRemovedHandlers.length = 0;
-        this.mediaStateHandlers.length = 0;
-        this.mediaDeviceHandlers.length = 0;
         this.reconnectHandlers.length = 0;
         this.connectionStateHandlers.length = 0;
     }
@@ -394,9 +417,7 @@ export class RoomClient {
      * const result = await room.send('SET_SCORE', { score: 42 });
      */
     async send(actionType, payload) {
-        if (!this.ws || !this.connected || !this.authenticated) {
-            throw new EdgeBaseError(400, 'Not connected to room');
-        }
+        this.assertConnected(`sending action '${actionType}'`);
         const requestId = generateRequestId();
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
@@ -524,6 +545,14 @@ export class RoomClient {
                 this.memberSyncHandlers.splice(index, 1);
         });
     }
+    onMemberSnapshot(handler) {
+        this.memberSnapshotHandlers.push(handler);
+        return createSubscription(() => {
+            const index = this.memberSnapshotHandlers.indexOf(handler);
+            if (index >= 0)
+                this.memberSnapshotHandlers.splice(index, 1);
+        });
+    }
     onMemberJoin(handler) {
         this.memberJoinHandlers.push(handler);
         return createSubscription(() => {
@@ -556,50 +585,24 @@ export class RoomClient {
                 this.reconnectHandlers.splice(index, 1);
         });
     }
-    onConnectionStateChange(handler) {
-        this.connectionStateHandlers.push(handler);
-        return createSubscription(() => {
-            const index = this.connectionStateHandlers.indexOf(handler);
-            if (index >= 0)
-                this.connectionStateHandlers.splice(index, 1);
-        });
-    }
-    onMediaTrack(handler) {
-        this.mediaTrackHandlers.push(handler);
-        return createSubscription(() => {
-            const index = this.mediaTrackHandlers.indexOf(handler);
-            if (index >= 0)
-                this.mediaTrackHandlers.splice(index, 1);
-        });
-    }
-    onMediaTrackRemoved(handler) {
-        this.mediaTrackRemovedHandlers.push(handler);
-        return createSubscription(() => {
-            const index = this.mediaTrackRemovedHandlers.indexOf(handler);
-            if (index >= 0)
-                this.mediaTrackRemovedHandlers.splice(index, 1);
-        });
-    }
-    onMediaStateChange(handler) {
-        this.mediaStateHandlers.push(handler);
+    onRecoveryFailure(handler) {
+        this.recoveryFailureHandlers.push(handler);
         return createSubscription(() => {
-            const index = this.mediaStateHandlers.indexOf(handler);
+            const index = this.recoveryFailureHandlers.indexOf(handler);
             if (index >= 0)
-                this.mediaStateHandlers.splice(index, 1);
+                this.recoveryFailureHandlers.splice(index, 1);
         });
     }
-    onMediaDeviceChange(handler) {
-        this.mediaDeviceHandlers.push(handler);
+    onConnectionStateChange(handler) {
+        this.connectionStateHandlers.push(handler);
         return createSubscription(() => {
-            const index = this.mediaDeviceHandlers.indexOf(handler);
+            const index = this.connectionStateHandlers.indexOf(handler);
             if (index >= 0)
-                this.mediaDeviceHandlers.splice(index, 1);
+                this.connectionStateHandlers.splice(index, 1);
         });
     }
     async sendSignal(event, payload, options) {
-        if (!this.ws || !this.connected || !this.authenticated) {
-            throw new EdgeBaseError(400, 'Not connected to room');
-        }
+        this.assertConnected(`sending signal '${event}'`);
         const requestId = generateRequestId();
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
@@ -618,34 +621,39 @@ export class RoomClient {
         });
     }
     async sendMemberState(state) {
+        const nextState = {
+            ...(this.lastLocalMemberState ?? {}),
+            ...cloneRecord(state),
+        };
         return this.sendMemberStateRequest({
             type: 'member_state',
             state,
+        }, () => {
+            this.lastLocalMemberState = nextState;
         });
     }
     async clearMemberState() {
+        const clearedState = {};
         return this.sendMemberStateRequest({
             type: 'member_state_clear',
+        }, () => {
+            this.lastLocalMemberState = clearedState;
         });
     }
-    async sendMemberStateRequest(payload) {
-        if (!this.ws || !this.connected || !this.authenticated) {
-            throw new EdgeBaseError(400, 'Not connected to room');
-        }
+    async sendMemberStateRequest(payload, onSuccess) {
+        this.assertConnected('updating member state');
         const requestId = generateRequestId();
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 this.pendingMemberStateRequests.delete(requestId);
                 reject(new EdgeBaseError(408, 'Member state update timed out'));
             }, this.options.sendTimeout);
-            this.pendingMemberStateRequests.set(requestId, { resolve, reject, timeout });
+            this.pendingMemberStateRequests.set(requestId, { resolve, reject, timeout, onSuccess });
             this.sendRaw({ ...payload, requestId });
         });
     }
     async sendAdmin(operation, memberId, payload) {
-        if (!this.ws || !this.connected || !this.authenticated) {
-            throw new EdgeBaseError(400, 'Not connected to room');
-        }
+        this.assertConnected(`running admin operation '${operation}'`);
         const requestId = generateRequestId();
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
@@ -662,39 +670,6 @@ export class RoomClient {
             });
         });
     }
-    async sendMedia(operation, kind, payload) {
-        if (!this.ws || !this.connected || !this.authenticated) {
-            throw new EdgeBaseError(400, 'Not connected to room');
-        }
-        const requestId = generateRequestId();
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.pendingMediaRequests.delete(requestId);
-                reject(new EdgeBaseError(408, `Media operation '${operation}' timed out`));
-            }, this.options.sendTimeout);
-            this.pendingMediaRequests.set(requestId, { resolve, reject, timeout });
-            this.sendRaw({
-                type: 'media',
-                operation,
-                kind,
-                payload: payload ?? {},
-                requestId,
-            });
-        });
-    }
-    async switchMediaDevices(payload) {
-        const operations = [];
-        if (payload.audioInputId) {
-            operations.push(this.sendMedia('device', 'audio', { deviceId: payload.audioInputId }));
-        }
-        if (payload.videoInputId) {
-            operations.push(this.sendMedia('device', 'video', { deviceId: payload.videoInputId }));
-        }
-        if (payload.screenInputId) {
-            operations.push(this.sendMedia('device', 'screen', { deviceId: payload.screenInputId }));
-        }
-        await Promise.all(operations);
-    }
     // ─── Private: Connection ───
     async establishConnection() {
         return new Promise((resolve, reject) => {
@@ -794,11 +769,11 @@ export class RoomClient {
     async authenticate() {
         const token = await this.tokenManager.getAccessToken((refreshToken) => refreshAccessToken(this.baseUrl, refreshToken));
         if (!token) {
-            throw new EdgeBaseError(401, 'No access token available. Sign in first.');
+            throw new EdgeBaseError(401, 'Room authentication requires a signed-in session. Sign in before joining the room.');
         }
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                reject(new EdgeBaseError(401, 'Room auth timeout'));
+                reject(new EdgeBaseError(401, 'Room authentication timed out. Check the server auth response and room connectivity.'));
             }, 10000);
             const originalOnMessage = this.ws?.onmessage;
             if (this.ws) {
@@ -818,6 +793,7 @@ export class RoomClient {
                             lastSharedVersion: this._sharedVersion,
                             lastPlayerState: this._playerState,
                             lastPlayerVersion: this._playerVersion,
+                            lastMemberState: this.getReconnectMemberState(),
                         });
                         this.joined = true;
                         resolve();
@@ -876,9 +852,6 @@ export class RoomClient {
             case 'members_sync':
                 this.handleMembersSync(msg);
                 break;
-            case 'media_sync':
-                this.handleMediaSync(msg);
-                break;
             case 'member_join':
                 this.handleMemberJoinFrame(msg);
                 break;
@@ -891,24 +864,6 @@ export class RoomClient {
             case 'member_state_error':
                 this.handleMemberStateError(msg);
                 break;
-            case 'media_track':
-                this.handleMediaTrackFrame(msg);
-                break;
-            case 'media_track_removed':
-                this.handleMediaTrackRemovedFrame(msg);
-                break;
-            case 'media_state':
-                this.handleMediaStateFrame(msg);
-                break;
-            case 'media_device':
-                this.handleMediaDeviceFrame(msg);
-                break;
-            case 'media_result':
-                this.handleMediaResult(msg);
-                break;
-            case 'media_error':
-                this.handleMediaError(msg);
-                break;
             case 'admin_result':
                 this.handleAdminResult(msg);
                 break;
@@ -923,6 +878,7 @@ export class RoomClient {
                 break;
             case 'pong':
                 // Heartbeat response — no action needed
+                this.lastHeartbeatAckAt = Date.now();
                 break;
         }
     }
@@ -1052,23 +1008,19 @@ export class RoomClient {
     handleMembersSync(msg) {
         const members = this.normalizeMembers(msg.members);
         this._members = members;
-        for (const member of members) {
-            this.syncMediaMemberInfo(member);
-        }
-        const snapshot = cloneValue(this._members);
+        const snapshot = this._members.map((member) => cloneValue(member));
         for (const handler of this.memberSyncHandlers) {
             handler(snapshot);
         }
-    }
-    handleMediaSync(msg) {
-        this._mediaMembers = this.normalizeMediaMembers(msg.members);
+        for (const handler of this.memberSnapshotHandlers) {
+            handler(snapshot);
+        }
     }
     handleMemberJoinFrame(msg) {
         const member = this.normalizeMember(msg.member);
         if (!member)
             return;
         this.upsertMember(member);
-        this.syncMediaMemberInfo(member);
         const snapshot = cloneValue(member);
         for (const handler of this.memberJoinHandlers) {
             handler(snapshot);
@@ -1079,7 +1031,6 @@ export class RoomClient {
         if (!member)
             return;
         this.removeMember(member.memberId);
-        this.removeMediaMember(member.memberId);
         const reason = this.normalizeLeaveReason(msg.reason);
         const snapshot = cloneValue(member);
         for (const handler of this.memberLeaveHandlers) {
@@ -1093,13 +1044,13 @@ export class RoomClient {
             return;
         member.state = state;
         this.upsertMember(member);
-        this.syncMediaMemberInfo(member);
         const requestId = msg.requestId;
         if (requestId) {
             const pending = this.pendingMemberStateRequests.get(requestId);
             if (pending) {
                 clearTimeout(pending.timeout);
                 this.pendingMemberStateRequests.delete(requestId);
+                pending.onSuccess?.();
                 pending.resolve();
             }
         }
@@ -1120,115 +1071,6 @@ export class RoomClient {
         this.pendingMemberStateRequests.delete(requestId);
         pending.reject(new EdgeBaseError(400, msg.message || 'Member state update failed'));
     }
-    handleMediaTrackFrame(msg) {
-        const member = this.normalizeMember(msg.member);
-        const track = this.normalizeMediaTrack(msg.track);
-        if (!member || !track)
-            return;
-        const mediaMember = this.ensureMediaMember(member);
-        this.upsertMediaTrack(mediaMember, track);
-        this.mergeMediaState(mediaMember, track.kind, {
-            published: true,
-            muted: track.muted,
-            trackId: track.trackId,
-            deviceId: track.deviceId,
-            publishedAt: track.publishedAt,
-            adminDisabled: track.adminDisabled,
-            providerSessionId: track.providerSessionId,
-        });
-        const memberSnapshot = cloneValue(mediaMember.member);
-        const trackSnapshot = cloneValue(track);
-        for (const handler of this.mediaTrackHandlers) {
-            handler(trackSnapshot, memberSnapshot);
-        }
-        const stateSnapshot = cloneValue(mediaMember.state);
-        for (const handler of this.mediaStateHandlers) {
-            handler(memberSnapshot, stateSnapshot);
-        }
-    }
-    handleMediaTrackRemovedFrame(msg) {
-        const member = this.normalizeMember(msg.member);
-        const track = this.normalizeMediaTrack(msg.track);
-        if (!member || !track)
-            return;
-        const mediaMember = this.ensureMediaMember(member);
-        this.removeMediaTrack(mediaMember, track);
-        mediaMember.state = {
-            ...mediaMember.state,
-            [track.kind]: {
-                published: false,
-                muted: false,
-                adminDisabled: false,
-                providerSessionId: undefined,
-            },
-        };
-        const memberSnapshot = cloneValue(mediaMember.member);
-        const trackSnapshot = cloneValue(track);
-        for (const handler of this.mediaTrackRemovedHandlers) {
-            handler(trackSnapshot, memberSnapshot);
-        }
-        const stateSnapshot = cloneValue(mediaMember.state);
-        for (const handler of this.mediaStateHandlers) {
-            handler(memberSnapshot, stateSnapshot);
-        }
-    }
-    handleMediaStateFrame(msg) {
-        const member = this.normalizeMember(msg.member);
-        if (!member)
-            return;
-        const mediaMember = this.ensureMediaMember(member);
-        mediaMember.state = this.normalizeMediaState(msg.state);
-        const memberSnapshot = cloneValue(mediaMember.member);
-        const stateSnapshot = cloneValue(mediaMember.state);
-        for (const handler of this.mediaStateHandlers) {
-            handler(memberSnapshot, stateSnapshot);
-        }
-    }
-    handleMediaDeviceFrame(msg) {
-        const member = this.normalizeMember(msg.member);
-        const kind = this.normalizeMediaKind(msg.kind);
-        const deviceId = typeof msg.deviceId === 'string' ? msg.deviceId : '';
-        if (!member || !kind || !deviceId)
-            return;
-        const mediaMember = this.ensureMediaMember(member);
-        this.mergeMediaState(mediaMember, kind, { deviceId });
-        for (const track of mediaMember.tracks) {
-            if (track.kind === kind) {
-                track.deviceId = deviceId;
-            }
-        }
-        const memberSnapshot = cloneValue(mediaMember.member);
-        const change = { kind, deviceId };
-        for (const handler of this.mediaDeviceHandlers) {
-            handler(memberSnapshot, change);
-        }
-        const stateSnapshot = cloneValue(mediaMember.state);
-        for (const handler of this.mediaStateHandlers) {
-            handler(memberSnapshot, stateSnapshot);
-        }
-    }
-    handleMediaResult(msg) {
-        const requestId = msg.requestId;
-        if (!requestId)
-            return;
-        const pending = this.pendingMediaRequests.get(requestId);
-        if (!pending)
-            return;
-        clearTimeout(pending.timeout);
-        this.pendingMediaRequests.delete(requestId);
-        pending.resolve();
-    }
-    handleMediaError(msg) {
-        const requestId = msg.requestId;
-        if (!requestId)
-            return;
-        const pending = this.pendingMediaRequests.get(requestId);
-        if (!pending)
-            return;
-        clearTimeout(pending.timeout);
-        this.pendingMediaRequests.delete(requestId);
-        pending.reject(new EdgeBaseError(400, msg.message || 'Media operation failed'));
-    }
     handleAdminResult(msg) {
         const requestId = msg.requestId;
         if (!requestId)
@@ -1305,7 +1147,6 @@ export class RoomClient {
             this.connected = false;
             this.authenticated = false;
             this.joined = false;
-            this._mediaMembers = [];
             this.currentUserId = null;
             this.currentConnectionId = null;
             try {
@@ -1319,7 +1160,6 @@ export class RoomClient {
         this.connected = false;
         this.authenticated = false;
         this.joined = false;
-        this._mediaMembers = [];
     }
     handleAuthenticationFailure(error) {
         const authError = error instanceof EdgeBaseError
@@ -1355,8 +1195,7 @@ export class RoomClient {
         return this.pendingRequests.size > 0
             || this.pendingSignalRequests.size > 0
             || this.pendingAdminRequests.size > 0
-            || this.pendingMemberStateRequests.size > 0
-            || this.pendingMediaRequests.size > 0;
+            || this.pendingMemberStateRequests.size > 0;
     }
     handleRoomAuthStateLoss(message) {
         const detail = message?.trim();
@@ -1382,14 +1221,6 @@ export class RoomClient {
             .map((member) => this.normalizeMember(member))
             .filter((member) => !!member);
     }
-    normalizeMediaMembers(value) {
-        if (!Array.isArray(value)) {
-            return [];
-        }
-        return value
-            .map((member) => this.normalizeMediaMember(member))
-            .filter((member) => !!member);
-    }
     normalizeMember(value) {
         if (!value || typeof value !== 'object' || Array.isArray(value)) {
             return null;
@@ -1413,84 +1244,6 @@ export class RoomClient {
         }
         return cloneRecord(value);
     }
-    normalizeMediaMember(value) {
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            return null;
-        }
-        const entry = value;
-        const member = this.normalizeMember(entry.member);
-        if (!member) {
-            return null;
-        }
-        return {
-            member,
-            state: this.normalizeMediaState(entry.state),
-            tracks: this.normalizeMediaTracks(entry.tracks),
-        };
-    }
-    normalizeMediaState(value) {
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            return {};
-        }
-        const state = value;
-        return {
-            audio: this.normalizeMediaKindState(state.audio),
-            video: this.normalizeMediaKindState(state.video),
-            screen: this.normalizeMediaKindState(state.screen),
-        };
-    }
-    normalizeMediaKindState(value) {
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            return undefined;
-        }
-        const state = value;
-        return {
-            published: state.published === true,
-            muted: state.muted === true,
-            trackId: typeof state.trackId === 'string' ? state.trackId : undefined,
-            deviceId: typeof state.deviceId === 'string' ? state.deviceId : undefined,
-            publishedAt: typeof state.publishedAt === 'number' ? state.publishedAt : undefined,
-            adminDisabled: state.adminDisabled === true,
-            providerSessionId: typeof state.providerSessionId === 'string' ? state.providerSessionId : undefined,
-        };
-    }
-    normalizeMediaTracks(value) {
-        if (!Array.isArray(value)) {
-            return [];
-        }
-        return value
-            .map((track) => this.normalizeMediaTrack(track))
-            .filter((track) => !!track);
-    }
-    normalizeMediaTrack(value) {
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            return null;
-        }
-        const track = value;
-        const kind = this.normalizeMediaKind(track.kind);
-        if (!kind) {
-            return null;
-        }
-        return {
-            kind,
-            trackId: typeof track.trackId === 'string' ? track.trackId : undefined,
-            deviceId: typeof track.deviceId === 'string' ? track.deviceId : undefined,
-            muted: track.muted === true,
-            publishedAt: typeof track.publishedAt === 'number' ? track.publishedAt : undefined,
-            adminDisabled: track.adminDisabled === true,
-            providerSessionId: typeof track.providerSessionId === 'string' ? track.providerSessionId : undefined,
-        };
-    }
-    normalizeMediaKind(value) {
-        switch (value) {
-            case 'audio':
-            case 'video':
-            case 'screen':
-                return value;
-            default:
-                return null;
-        }
-    }
     normalizeSignalMeta(value) {
         if (!value || typeof value !== 'object' || Array.isArray(value)) {
             return {};
@@ -1516,6 +1269,20 @@ export class RoomClient {
                 return 'leave';
         }
     }
+    getDebugSnapshot() {
+        return {
+            connectionState: this.connectionState,
+            connected: this.connected,
+            authenticated: this.authenticated,
+            joined: this.joined,
+            currentUserId: this.currentUserId,
+            currentConnectionId: this.currentConnectionId,
+            membersCount: this._members.length,
+            reconnectAttempts: this.reconnectAttempts,
+            joinRequested: this.joinRequested,
+            waitingForAuth: this.waitingForAuth,
+        };
+    }
     upsertMember(member) {
         const index = this._members.findIndex((entry) => entry.memberId === member.memberId);
         if (index >= 0) {
@@ -1527,64 +1294,6 @@ export class RoomClient {
     removeMember(memberId) {
         this._members = this._members.filter((member) => member.memberId !== memberId);
     }
-    syncMediaMemberInfo(member) {
-        const mediaMember = this._mediaMembers.find((entry) => entry.member.memberId === member.memberId);
-        if (!mediaMember) {
-            return;
-        }
-        mediaMember.member = cloneValue(member);
-    }
-    ensureMediaMember(member) {
-        const existing = this._mediaMembers.find((entry) => entry.member.memberId === member.memberId);
-        if (existing) {
-            existing.member = cloneValue(member);
-            return existing;
-        }
-        const created = {
-            member: cloneValue(member),
-            state: {},
-            tracks: [],
-        };
-        this._mediaMembers.push(created);
-        return created;
-    }
-    removeMediaMember(memberId) {
-        this._mediaMembers = this._mediaMembers.filter((member) => member.member.memberId !== memberId);
-    }
-    upsertMediaTrack(mediaMember, track) {
-        const index = mediaMember.tracks.findIndex((entry) => entry.kind === track.kind &&
-            entry.trackId === track.trackId);
-        if (index >= 0) {
-            mediaMember.tracks[index] = cloneValue(track);
-            return;
-        }
-        mediaMember.tracks = mediaMember.tracks
-            .filter((entry) => !(entry.kind === track.kind && !track.trackId))
-            .concat(cloneValue(track));
-    }
-    removeMediaTrack(mediaMember, track) {
-        mediaMember.tracks = mediaMember.tracks.filter((entry) => {
-            if (track.trackId) {
-                return !(entry.kind === track.kind && entry.trackId === track.trackId);
-            }
-            return entry.kind !== track.kind;
-        });
-    }
-    mergeMediaState(mediaMember, kind, partial) {
-        const next = {
-            published: partial.published ?? mediaMember.state[kind]?.published ?? false,
-            muted: partial.muted ?? mediaMember.state[kind]?.muted ?? false,
-            trackId: partial.trackId ?? mediaMember.state[kind]?.trackId,
-            deviceId: partial.deviceId ?? mediaMember.state[kind]?.deviceId,
-            publishedAt: partial.publishedAt ?? mediaMember.state[kind]?.publishedAt,
-            adminDisabled: partial.adminDisabled ?? mediaMember.state[kind]?.adminDisabled,
-            providerSessionId: partial.providerSessionId ?? mediaMember.state[kind]?.providerSessionId,
-        };
-        mediaMember.state = {
-            ...mediaMember.state,
-            [kind]: next,
-        };
-    }
     /** Reject all 5 pending request maps at once. */
     rejectAllPendingRequests(error) {
         for (const [, pending] of this.pendingRequests) {
@@ -1595,7 +1304,6 @@ export class RoomClient {
         this.rejectPendingVoidRequests(this.pendingSignalRequests, error);
         this.rejectPendingVoidRequests(this.pendingAdminRequests, error);
         this.rejectPendingVoidRequests(this.pendingMemberStateRequests, error);
-        this.rejectPendingVoidRequests(this.pendingMediaRequests, error);
     }
     rejectPendingVoidRequests(pendingRequests, error) {
         for (const [, pending] of pendingRequests) {
@@ -1604,11 +1312,59 @@ export class RoomClient {
         }
         pendingRequests.clear();
     }
+    shouldScheduleDisconnectReset(next) {
+        if (this.intentionallyLeft || !this.joinRequested) {
+            return false;
+        }
+        return next === 'disconnected';
+    }
+    clearDisconnectResetTimer() {
+        if (this.disconnectResetTimer) {
+            clearTimeout(this.disconnectResetTimer);
+            this.disconnectResetTimer = null;
+        }
+    }
+    scheduleDisconnectReset(stateAtSchedule) {
+        this.clearDisconnectResetTimer();
+        const timeoutMs = this.options.disconnectResetTimeoutMs;
+        if (!(timeoutMs > 0)) {
+            return;
+        }
+        this.disconnectResetTimer = setTimeout(() => {
+            this.disconnectResetTimer = null;
+            if (this.intentionallyLeft || !this.joinRequested) {
+                return;
+            }
+            if (this.connectionState !== stateAtSchedule) {
+                return;
+            }
+            if (this.connectionState === 'connected') {
+                return;
+            }
+            for (const handler of this.recoveryFailureHandlers) {
+                try {
+                    handler({
+                        state: this.connectionState,
+                        timeoutMs,
+                    });
+                }
+                catch {
+                    // Ignore recovery failure handler errors.
+                }
+            }
+        }, timeoutMs);
+    }
     setConnectionState(next) {
         if (this.connectionState === next) {
             return;
         }
         this.connectionState = next;
+        if (this.shouldScheduleDisconnectReset(next)) {
+            this.scheduleDisconnectReset(next);
+        }
+        else {
+            this.clearDisconnectResetTimer();
+        }
         for (const handler of this.connectionStateHandlers) {
             handler(next);
         }
@@ -1675,11 +1431,21 @@ export class RoomClient {
     }
     startHeartbeat() {
         this.stopHeartbeat();
+        this.lastHeartbeatAckAt = Date.now();
         this.heartbeatTimer = setInterval(() => {
             if (this.ws && this.connected) {
+                if (Date.now() - this.lastHeartbeatAckAt > this.options.heartbeatStaleTimeoutMs) {
+                    try {
+                        this.ws.close();
+                    }
+                    catch {
+                        // Socket may already be closing.
+                    }
+                    return;
+                }
                 this.ws.send(JSON.stringify({ type: 'ping' }));
             }
-        }, 30000);
+        }, this.options.heartbeatIntervalMs);
     }
     stopHeartbeat() {
         if (this.heartbeatTimer) {
@@ -1687,5 +1453,11 @@ export class RoomClient {
             this.heartbeatTimer = null;
         }
     }
+    getReconnectMemberState() {
+        if (!this.lastLocalMemberState) {
+            return undefined;
+        }
+        return cloneRecord(this.lastLocalMemberState);
+    }
 }
 //# sourceMappingURL=room.js.map