@edge-base/web 0.1.1

package/dist/room.js

@@ -0,0 +1,1506 @@
+import { EdgeBaseError } from '@edge-base/core';
+import { refreshAccessToken } from './auth-refresh.js';
+import { RoomRealtimeMediaTransport, } from './room-realtime-media.js';
+// ─── Helpers ───
+function deepSet(obj, path, value) {
+    const parts = path.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (typeof current[key] !== 'object' || current[key] === null) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const lastKey = parts[parts.length - 1];
+    if (value === null) {
+        delete current[lastKey];
+    }
+    else {
+        current[lastKey] = value;
+    }
+}
+function generateRequestId() {
+    // Use crypto.randomUUID if available, fallback to simple counter
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function cloneValue(value) {
+    if (typeof structuredClone === 'function') {
+        return structuredClone(value);
+    }
+    return JSON.parse(JSON.stringify(value ?? null));
+}
+function cloneRecord(value) {
+    return cloneValue(value);
+}
+const WS_CONNECTING = 0;
+const WS_OPEN = 1;
+const ROOM_EXPLICIT_LEAVE_CLOSE_CODE = 4005;
+const ROOM_EXPLICIT_LEAVE_REASON = 'Client left room';
+const ROOM_EXPLICIT_LEAVE_CLOSE_DELAY_MS = 40;
+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);
+}
+// ─── RoomClient v2 ───
+export class RoomClient {
+    baseUrl;
+    tokenManager;
+    options;
+    /** Room namespace (e.g. 'game', 'chat') */
+    namespace;
+    /** Room instance ID within the namespace */
+    roomId;
+    // ─── State ───
+    _sharedState = {};
+    _sharedVersion = 0;
+    _playerState = {};
+    _playerVersion = 0;
+    _members = [];
+    _mediaMembers = [];
+    // ─── Connection ───
+    ws = null;
+    reconnectAttempts = 0;
+    connected = false;
+    authenticated = false;
+    joined = false;
+    currentUserId = null;
+    currentConnectionId = null;
+    connectionState = 'idle';
+    reconnectInfo = null;
+    connectingPromise = null;
+    heartbeatTimer = null;
+    intentionallyLeft = false;
+    waitingForAuth = false;
+    joinRequested = false;
+    unsubAuthState = null;
+    // ─── Pending send() requests (requestId → { resolve, reject, timeout }) ───
+    pendingRequests = new Map();
+    pendingSignalRequests = new Map();
+    pendingAdminRequests = new Map();
+    pendingMemberStateRequests = new Map();
+    pendingMediaRequests = new Map();
+    // ─── Subscriptions ───
+    sharedStateHandlers = [];
+    playerStateHandlers = [];
+    messageHandlers = new Map(); // messageType → handlers
+    allMessageHandlers = [];
+    errorHandlers = [];
+    kickedHandlers = [];
+    memberSyncHandlers = [];
+    memberJoinHandlers = [];
+    memberLeaveHandlers = [];
+    memberStateHandlers = [];
+    signalHandlers = new Map();
+    anySignalHandlers = [];
+    mediaTrackHandlers = [];
+    mediaTrackRemovedHandlers = [];
+    mediaStateHandlers = [];
+    mediaDeviceHandlers = [];
+    reconnectHandlers = [];
+    connectionStateHandlers = [];
+    state = {
+        getShared: () => this.getSharedState(),
+        getMine: () => this.getPlayerState(),
+        onSharedChange: (handler) => this.onSharedState(handler),
+        onMineChange: (handler) => this.onPlayerState(handler),
+        send: (actionType, payload) => this.send(actionType, payload),
+    };
+    meta = {
+        get: () => this.getMetadata(),
+    };
+    signals = {
+        send: (event, payload, options) => this.sendSignal(event, payload, options),
+        sendTo: (memberId, event, payload) => this.sendSignal(event, payload, { memberId }),
+        on: (event, handler) => this.onSignal(event, handler),
+        onAny: (handler) => this.onAnySignal(handler),
+    };
+    members = {
+        list: () => cloneValue(this._members),
+        onSync: (handler) => this.onMembersSync(handler),
+        onJoin: (handler) => this.onMemberJoin(handler),
+        onLeave: (handler) => this.onMemberLeave(handler),
+        setState: (state) => this.sendMemberState(state),
+        clearState: () => this.clearMemberState(),
+        onStateChange: (handler) => this.onMemberStateChange(handler),
+    };
+    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: {
+            createSession: (payload) => this.requestRealtimeMedia('session', 'POST', payload),
+            getIceServers: (payload) => this.requestRealtimeMedia('turn', 'POST', payload),
+            addTracks: (payload) => this.requestRealtimeMedia('tracks/new', 'POST', payload),
+            renegotiate: (payload) => this.requestRealtimeMedia('renegotiate', 'PUT', payload),
+            closeTracks: (payload) => this.requestRealtimeMedia('tracks/close', 'PUT', payload),
+            transport: (options) => new RoomRealtimeMediaTransport(this, options),
+        },
+        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),
+    };
+    constructor(baseUrl, namespace, roomId, tokenManager, options) {
+        this.baseUrl = baseUrl;
+        this.namespace = namespace;
+        this.roomId = roomId;
+        this.tokenManager = tokenManager;
+        this.options = {
+            autoReconnect: options?.autoReconnect ?? true,
+            maxReconnectAttempts: options?.maxReconnectAttempts ?? 10,
+            reconnectBaseDelay: options?.reconnectBaseDelay ?? 1000,
+            sendTimeout: options?.sendTimeout ?? 10000,
+        };
+        this.unsubAuthState = this.tokenManager.onAuthStateChange((user) => {
+            this.handleAuthStateChange(user);
+        });
+    }
+    // ─── State Accessors ───
+    /** Get current shared state (read-only snapshot) */
+    getSharedState() {
+        return cloneRecord(this._sharedState);
+    }
+    /** Get current player state (read-only snapshot) */
+    getPlayerState() {
+        return cloneRecord(this._playerState);
+    }
+    // ─── Metadata (HTTP, no WebSocket needed) ───
+    /**
+     * Get room metadata without joining (HTTP GET).
+     * Returns developer-defined metadata set by room.setMetadata() on the server.
+     */
+    async getMetadata() {
+        return RoomClient.getMetadata(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();
+    }
+    async requestRealtimeMedia(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/realtime/${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(() => ({})));
+        if (!response.ok) {
+            throw new EdgeBaseError(response.status, (typeof data.message === 'string' && data.message) || `Realtime media request failed: ${response.statusText}`);
+        }
+        return data;
+    }
+    // ─── Connection Lifecycle ───
+    /** Connect to the room, authenticate, and join */
+    async join() {
+        this.intentionallyLeft = false;
+        this.joinRequested = true;
+        if (isSocketOpenOrConnecting(this.ws)) {
+            return this.connectingPromise ?? Promise.resolve();
+        }
+        this.setConnectionState(this.reconnectInfo ? 'reconnecting' : 'connecting');
+        return this.ensureConnection();
+    }
+    /** Leave the room and disconnect. Cleans up all pending requests. */
+    leave() {
+        this.intentionallyLeft = true;
+        this.joinRequested = false;
+        this.waitingForAuth = false;
+        this.stopHeartbeat();
+        // Reject all pending send() requests
+        for (const [reqId, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new EdgeBaseError(499, 'Room left'));
+        }
+        this.pendingRequests.clear();
+        this.rejectPendingVoidRequests(this.pendingSignalRequests, new EdgeBaseError(499, 'Room left'));
+        this.rejectPendingVoidRequests(this.pendingAdminRequests, new EdgeBaseError(499, 'Room left'));
+        this.rejectPendingVoidRequests(this.pendingMemberStateRequests, new EdgeBaseError(499, 'Room left'));
+        this.rejectPendingVoidRequests(this.pendingMediaRequests, new EdgeBaseError(499, 'Room left'));
+        if (this.ws) {
+            const socket = this.ws;
+            this.sendRaw({ type: 'leave' });
+            closeSocketAfterLeave(socket, ROOM_EXPLICIT_LEAVE_REASON);
+            this.ws = null;
+        }
+        this.connected = false;
+        this.authenticated = false;
+        this.joined = false;
+        this.connectingPromise = null;
+        this._sharedState = {};
+        this._sharedVersion = 0;
+        this._playerState = {};
+        this._playerVersion = 0;
+        this._members = [];
+        this._mediaMembers = [];
+        this.currentUserId = null;
+        this.currentConnectionId = null;
+        this.reconnectInfo = null;
+        this.setConnectionState('disconnected');
+    }
+    // ─── Actions ───
+    /**
+     * Send an action to the server.
+     * Returns a Promise that resolves with the action result from the server.
+     *
+     * @example
+     * 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');
+        }
+        const requestId = generateRequestId();
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new EdgeBaseError(408, `Action '${actionType}' timed out`));
+            }, this.options.sendTimeout);
+            this.pendingRequests.set(requestId, { resolve, reject, timeout });
+            this.sendRaw({
+                type: 'send',
+                actionType,
+                payload: payload ?? {},
+                requestId,
+            });
+        });
+    }
+    // ─── Subscriptions (v2 API) ───
+    /**
+     * Subscribe to shared state changes.
+     * Called on full sync and on each shared_delta.
+     *
+     * @returns Subscription with unsubscribe()
+     */
+    onSharedState(handler) {
+        this.sharedStateHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const idx = this.sharedStateHandlers.indexOf(handler);
+                if (idx >= 0)
+                    this.sharedStateHandlers.splice(idx, 1);
+            },
+        };
+    }
+    /**
+     * Subscribe to player state changes.
+     * Called on full sync and on each player_delta.
+     *
+     * @returns Subscription with unsubscribe()
+     */
+    onPlayerState(handler) {
+        this.playerStateHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const idx = this.playerStateHandlers.indexOf(handler);
+                if (idx >= 0)
+                    this.playerStateHandlers.splice(idx, 1);
+            },
+        };
+    }
+    /**
+     * Subscribe to messages of a specific type sent by room.sendMessage().
+     *
+     * @example
+     * room.onMessage('game_over', (data) => { console.log(data.winner); });
+     *
+     * @returns Subscription with unsubscribe()
+     */
+    onMessage(messageType, handler) {
+        if (!this.messageHandlers.has(messageType)) {
+            this.messageHandlers.set(messageType, []);
+        }
+        this.messageHandlers.get(messageType).push(handler);
+        return {
+            unsubscribe: () => {
+                const handlers = this.messageHandlers.get(messageType);
+                if (handlers) {
+                    const idx = handlers.indexOf(handler);
+                    if (idx >= 0)
+                        handlers.splice(idx, 1);
+                }
+            },
+        };
+    }
+    /**
+     * Subscribe to ALL messages regardless of type.
+     *
+     * @returns Subscription with unsubscribe()
+     */
+    onAnyMessage(handler) {
+        this.allMessageHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const idx = this.allMessageHandlers.indexOf(handler);
+                if (idx >= 0)
+                    this.allMessageHandlers.splice(idx, 1);
+            },
+        };
+    }
+    /** Subscribe to errors */
+    onError(handler) {
+        this.errorHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const idx = this.errorHandlers.indexOf(handler);
+                if (idx >= 0)
+                    this.errorHandlers.splice(idx, 1);
+            },
+        };
+    }
+    /** Subscribe to kick events */
+    onKicked(handler) {
+        this.kickedHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const idx = this.kickedHandlers.indexOf(handler);
+                if (idx >= 0)
+                    this.kickedHandlers.splice(idx, 1);
+            },
+        };
+    }
+    onSignal(event, handler) {
+        if (!this.signalHandlers.has(event)) {
+            this.signalHandlers.set(event, []);
+        }
+        this.signalHandlers.get(event).push(handler);
+        return {
+            unsubscribe: () => {
+                const handlers = this.signalHandlers.get(event);
+                if (!handlers)
+                    return;
+                const index = handlers.indexOf(handler);
+                if (index >= 0)
+                    handlers.splice(index, 1);
+            },
+        };
+    }
+    onAnySignal(handler) {
+        this.anySignalHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.anySignalHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.anySignalHandlers.splice(index, 1);
+            },
+        };
+    }
+    onMembersSync(handler) {
+        this.memberSyncHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.memberSyncHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.memberSyncHandlers.splice(index, 1);
+            },
+        };
+    }
+    onMemberJoin(handler) {
+        this.memberJoinHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.memberJoinHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.memberJoinHandlers.splice(index, 1);
+            },
+        };
+    }
+    onMemberLeave(handler) {
+        this.memberLeaveHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.memberLeaveHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.memberLeaveHandlers.splice(index, 1);
+            },
+        };
+    }
+    onMemberStateChange(handler) {
+        this.memberStateHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.memberStateHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.memberStateHandlers.splice(index, 1);
+            },
+        };
+    }
+    onReconnect(handler) {
+        this.reconnectHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.reconnectHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.reconnectHandlers.splice(index, 1);
+            },
+        };
+    }
+    onConnectionStateChange(handler) {
+        this.connectionStateHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.connectionStateHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.connectionStateHandlers.splice(index, 1);
+            },
+        };
+    }
+    onMediaTrack(handler) {
+        this.mediaTrackHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.mediaTrackHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.mediaTrackHandlers.splice(index, 1);
+            },
+        };
+    }
+    onMediaTrackRemoved(handler) {
+        this.mediaTrackRemovedHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.mediaTrackRemovedHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.mediaTrackRemovedHandlers.splice(index, 1);
+            },
+        };
+    }
+    onMediaStateChange(handler) {
+        this.mediaStateHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.mediaStateHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.mediaStateHandlers.splice(index, 1);
+            },
+        };
+    }
+    onMediaDeviceChange(handler) {
+        this.mediaDeviceHandlers.push(handler);
+        return {
+            unsubscribe: () => {
+                const index = this.mediaDeviceHandlers.indexOf(handler);
+                if (index >= 0)
+                    this.mediaDeviceHandlers.splice(index, 1);
+            },
+        };
+    }
+    async sendSignal(event, payload, options) {
+        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.pendingSignalRequests.delete(requestId);
+                reject(new EdgeBaseError(408, `Signal '${event}' timed out`));
+            }, this.options.sendTimeout);
+            this.pendingSignalRequests.set(requestId, { resolve, reject, timeout });
+            this.sendRaw({
+                type: 'signal',
+                event,
+                payload: payload ?? {},
+                includeSelf: options?.includeSelf === true,
+                memberId: options?.memberId,
+                requestId,
+            });
+        });
+    }
+    async sendMemberState(state) {
+        return this.sendMemberStateRequest({
+            type: 'member_state',
+            state,
+        });
+    }
+    async clearMemberState() {
+        return this.sendMemberStateRequest({
+            type: 'member_state_clear',
+        });
+    }
+    async sendMemberStateRequest(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.pendingMemberStateRequests.delete(requestId);
+                reject(new EdgeBaseError(408, 'Member state update timed out'));
+            }, this.options.sendTimeout);
+            this.pendingMemberStateRequests.set(requestId, { resolve, reject, timeout });
+            this.sendRaw({ ...payload, requestId });
+        });
+    }
+    async sendAdmin(operation, memberId, 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.pendingAdminRequests.delete(requestId);
+                reject(new EdgeBaseError(408, `Admin operation '${operation}' timed out`));
+            }, this.options.sendTimeout);
+            this.pendingAdminRequests.set(requestId, { resolve, reject, timeout });
+            this.sendRaw({
+                type: 'admin',
+                operation,
+                memberId,
+                payload: payload ?? {},
+                requestId,
+            });
+        });
+    }
+    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) => {
+            const wsUrl = this.buildWsUrl();
+            const ws = new WebSocket(wsUrl);
+            this.ws = ws;
+            ws.onopen = () => {
+                this.connected = true;
+                this.reconnectAttempts = 0;
+                this.startHeartbeat();
+                this.authenticate()
+                    .then(() => {
+                    this.waitingForAuth = false;
+                    resolve();
+                })
+                    .catch((error) => {
+                    this.handleAuthenticationFailure(error);
+                    reject(error);
+                });
+            };
+            ws.onmessage = (event) => {
+                this.handleMessage(event.data);
+            };
+            ws.onclose = (event) => {
+                this.connected = false;
+                this.authenticated = false;
+                this.joined = false;
+                this.ws = null;
+                this.stopHeartbeat();
+                if (event.code === 4004 && this.connectionState !== 'kicked') {
+                    this.handleKicked();
+                }
+                if (!this.intentionallyLeft &&
+                    !this.waitingForAuth &&
+                    this.options.autoReconnect &&
+                    this.reconnectAttempts < this.options.maxReconnectAttempts) {
+                    this.scheduleReconnect();
+                }
+                else if (!this.intentionallyLeft && this.connectionState !== 'kicked' && this.connectionState !== 'auth_lost') {
+                    this.setConnectionState('disconnected');
+                }
+            };
+            ws.onerror = () => {
+                reject(new EdgeBaseError(500, 'Room WebSocket connection error'));
+            };
+        });
+    }
+    ensureConnection() {
+        if (this.connectingPromise) {
+            return this.connectingPromise;
+        }
+        const nextPromise = this.establishConnection().finally(() => {
+            if (this.connectingPromise === nextPromise) {
+                this.connectingPromise = null;
+            }
+        });
+        this.connectingPromise = nextPromise;
+        return nextPromise;
+    }
+    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.');
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new EdgeBaseError(401, 'Room auth timeout'));
+            }, 10000);
+            const originalOnMessage = this.ws?.onmessage;
+            if (this.ws) {
+                this.ws.onmessage = (event) => {
+                    const msg = JSON.parse(event.data);
+                    if (msg.type === 'auth_success' || msg.type === 'auth_refreshed') {
+                        clearTimeout(timeout);
+                        this.authenticated = true;
+                        this.currentUserId = typeof msg.userId === 'string' ? msg.userId : this.currentUserId;
+                        this.currentConnectionId = typeof msg.connectionId === 'string' ? msg.connectionId : this.currentConnectionId;
+                        if (this.ws)
+                            this.ws.onmessage = originalOnMessage ?? null;
+                        // Send join message with last known state for eviction recovery
+                        this.sendRaw({
+                            type: 'join',
+                            lastSharedState: this._sharedState,
+                            lastSharedVersion: this._sharedVersion,
+                            lastPlayerState: this._playerState,
+                            lastPlayerVersion: this._playerVersion,
+                        });
+                        this.joined = true;
+                        resolve();
+                    }
+                    else if (msg.type === 'error') {
+                        clearTimeout(timeout);
+                        reject(new EdgeBaseError(401, msg.message));
+                    }
+                };
+            }
+            this.sendRaw({ type: 'auth', token });
+        });
+    }
+    // ─── Private: Message Handling ───
+    handleMessage(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        const type = msg.type;
+        switch (type) {
+            case 'auth_success':
+            case 'auth_refreshed':
+                this.handleAuthAck(msg);
+                break;
+            case 'sync':
+                this.handleSync(msg);
+                break;
+            case 'shared_delta':
+                this.handleSharedDelta(msg);
+                break;
+            case 'player_delta':
+                this.handlePlayerDelta(msg);
+                break;
+            case 'action_result':
+                this.handleActionResult(msg);
+                break;
+            case 'action_error':
+                this.handleActionError(msg);
+                break;
+            case 'message':
+                this.handleServerMessage(msg);
+                break;
+            case 'signal':
+                this.handleSignalFrame(msg);
+                break;
+            case 'signal_sent':
+                this.handleSignalSent(msg);
+                break;
+            case 'signal_error':
+                this.handleSignalError(msg);
+                break;
+            case 'members_sync':
+                this.handleMembersSync(msg);
+                break;
+            case 'media_sync':
+                this.handleMediaSync(msg);
+                break;
+            case 'member_join':
+                this.handleMemberJoinFrame(msg);
+                break;
+            case 'member_leave':
+                this.handleMemberLeaveFrame(msg);
+                break;
+            case 'member_state':
+                this.handleMemberStateFrame(msg);
+                break;
+            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;
+            case 'admin_error':
+                this.handleAdminError(msg);
+                break;
+            case 'kicked':
+                this.handleKicked();
+                break;
+            case 'error':
+                this.handleError(msg);
+                break;
+            case 'pong':
+                // Heartbeat response — no action needed
+                break;
+        }
+    }
+    handleSync(msg) {
+        this._sharedState = msg.sharedState;
+        this._sharedVersion = msg.sharedVersion;
+        this._playerState = msg.playerState;
+        this._playerVersion = msg.playerVersion;
+        const reconnectInfo = this.reconnectInfo;
+        this.reconnectInfo = null;
+        this.setConnectionState('connected');
+        // Notify handlers with full state as changes
+        const sharedSnapshot = cloneRecord(this._sharedState);
+        const playerSnapshot = cloneRecord(this._playerState);
+        for (const handler of this.sharedStateHandlers) {
+            handler(sharedSnapshot, cloneRecord(sharedSnapshot));
+        }
+        for (const handler of this.playerStateHandlers) {
+            handler(playerSnapshot, cloneRecord(playerSnapshot));
+        }
+        if (reconnectInfo) {
+            for (const handler of this.reconnectHandlers) {
+                handler(reconnectInfo);
+            }
+        }
+    }
+    handleSharedDelta(msg) {
+        const delta = msg.delta;
+        this._sharedVersion = msg.version;
+        // Apply delta to local state
+        for (const [path, value] of Object.entries(delta)) {
+            deepSet(this._sharedState, path, value);
+        }
+        const sharedSnapshot = cloneRecord(this._sharedState);
+        const deltaSnapshot = cloneRecord(delta);
+        for (const handler of this.sharedStateHandlers) {
+            handler(sharedSnapshot, deltaSnapshot);
+        }
+    }
+    handlePlayerDelta(msg) {
+        const delta = msg.delta;
+        this._playerVersion = msg.version;
+        // Apply delta to local player state
+        for (const [path, value] of Object.entries(delta)) {
+            deepSet(this._playerState, path, value);
+        }
+        const playerSnapshot = cloneRecord(this._playerState);
+        const deltaSnapshot = cloneRecord(delta);
+        for (const handler of this.playerStateHandlers) {
+            handler(playerSnapshot, deltaSnapshot);
+        }
+    }
+    handleActionResult(msg) {
+        const requestId = msg.requestId;
+        const pending = this.pendingRequests.get(requestId);
+        if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(requestId);
+            pending.resolve(msg.result);
+        }
+    }
+    handleActionError(msg) {
+        const requestId = msg.requestId;
+        const pending = this.pendingRequests.get(requestId);
+        if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(requestId);
+            pending.reject(new EdgeBaseError(400, msg.message));
+        }
+    }
+    handleAuthAck(msg) {
+        this.currentUserId = typeof msg.userId === 'string' ? msg.userId : this.currentUserId;
+        this.currentConnectionId =
+            typeof msg.connectionId === 'string' ? msg.connectionId : this.currentConnectionId;
+    }
+    handleServerMessage(msg) {
+        const messageType = msg.messageType;
+        const data = msg.data;
+        // Type-specific handlers
+        const handlers = this.messageHandlers.get(messageType);
+        if (handlers) {
+            for (const handler of handlers)
+                handler(data);
+        }
+        // All-message handlers
+        for (const handler of this.allMessageHandlers) {
+            handler(messageType, data);
+        }
+    }
+    handleSignalFrame(msg) {
+        const event = typeof msg.event === 'string' ? msg.event : '';
+        if (!event)
+            return;
+        const meta = this.normalizeSignalMeta(msg.meta);
+        const payload = msg.payload;
+        const handlers = this.signalHandlers.get(event);
+        if (handlers) {
+            for (const handler of handlers)
+                handler(payload, meta);
+        }
+        for (const handler of this.anySignalHandlers) {
+            handler(event, payload, meta);
+        }
+    }
+    handleSignalSent(msg) {
+        const requestId = msg.requestId;
+        if (!requestId)
+            return;
+        const pending = this.pendingSignalRequests.get(requestId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timeout);
+        this.pendingSignalRequests.delete(requestId);
+        pending.resolve();
+    }
+    handleSignalError(msg) {
+        const requestId = msg.requestId;
+        if (!requestId)
+            return;
+        const pending = this.pendingSignalRequests.get(requestId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timeout);
+        this.pendingSignalRequests.delete(requestId);
+        pending.reject(new EdgeBaseError(400, msg.message || 'Signal failed'));
+    }
+    handleMembersSync(msg) {
+        const members = this.normalizeMembers(msg.members);
+        this._members = members;
+        for (const member of members) {
+            this.syncMediaMemberInfo(member);
+        }
+        const snapshot = cloneValue(this._members);
+        for (const handler of this.memberSyncHandlers) {
+            handler(snapshot);
+        }
+    }
+    handleMediaSync(msg) {
+        this._mediaMembers = this.normalizeMediaMembers(msg.members);
+    }
+    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);
+        }
+    }
+    handleMemberLeaveFrame(msg) {
+        const member = this.normalizeMember(msg.member);
+        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) {
+            handler(snapshot, reason);
+        }
+    }
+    handleMemberStateFrame(msg) {
+        const member = this.normalizeMember(msg.member);
+        const state = this.normalizeState(msg.state);
+        if (!member)
+            return;
+        member.state = state;
+        this.upsertMember(member);
+        this.syncMediaMemberInfo(member);
+        const requestId = msg.requestId;
+        if (requestId && member.memberId === this.currentUserId) {
+            const pending = this.pendingMemberStateRequests.get(requestId);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingMemberStateRequests.delete(requestId);
+                pending.resolve();
+            }
+        }
+        const memberSnapshot = cloneValue(member);
+        const stateSnapshot = cloneRecord(state);
+        for (const handler of this.memberStateHandlers) {
+            handler(memberSnapshot, stateSnapshot);
+        }
+    }
+    handleMemberStateError(msg) {
+        const requestId = msg.requestId;
+        if (!requestId)
+            return;
+        const pending = this.pendingMemberStateRequests.get(requestId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timeout);
+        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);
+        }
+    }
+    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);
+        }
+    }
+    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);
+        }
+    }
+    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)
+            return;
+        const pending = this.pendingAdminRequests.get(requestId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timeout);
+        this.pendingAdminRequests.delete(requestId);
+        pending.resolve();
+    }
+    handleAdminError(msg) {
+        const requestId = msg.requestId;
+        if (!requestId)
+            return;
+        const pending = this.pendingAdminRequests.get(requestId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timeout);
+        this.pendingAdminRequests.delete(requestId);
+        pending.reject(new EdgeBaseError(400, msg.message || 'Admin operation failed'));
+    }
+    handleKicked() {
+        for (const handler of this.kickedHandlers)
+            handler();
+        // Don't auto-reconnect after being kicked
+        this.intentionallyLeft = true;
+        this.reconnectInfo = null;
+        this.setConnectionState('kicked');
+    }
+    handleError(msg) {
+        for (const handler of this.errorHandlers) {
+            handler({ code: msg.code, message: msg.message });
+        }
+    }
+    refreshAuth() {
+        const token = this.tokenManager.currentAccessToken;
+        if (!token || !this.ws || !this.connected)
+            return;
+        this.sendRaw({ type: 'auth', token });
+    }
+    handleAuthStateChange(user) {
+        if (user) {
+            if (this.ws && this.connected && this.authenticated) {
+                this.refreshAuth();
+                return;
+            }
+            this.waitingForAuth = false;
+            if (this.joinRequested
+                && !this.connectingPromise
+                && !isSocketOpenOrConnecting(this.ws)) {
+                this.reconnectAttempts = 0;
+                this.ensureConnection().catch(() => {
+                    // Connection errors are surfaced through the normal socket lifecycle.
+                });
+            }
+            return;
+        }
+        this.waitingForAuth = this.joinRequested;
+        this.reconnectInfo = null;
+        this.setConnectionState('auth_lost');
+        if (this.ws) {
+            const socket = this.ws;
+            this.sendRaw({ type: 'leave' });
+            this.stopHeartbeat();
+            this.ws = null;
+            this.connected = false;
+            this.authenticated = false;
+            this.joined = false;
+            this._mediaMembers = [];
+            this.currentUserId = null;
+            this.currentConnectionId = null;
+            try {
+                closeSocketAfterLeave(socket, 'Signed out');
+            }
+            catch {
+                // Ignore close failures — socket is already unusable.
+            }
+            return;
+        }
+        this.connected = false;
+        this.authenticated = false;
+        this.joined = false;
+        this._mediaMembers = [];
+    }
+    handleAuthenticationFailure(error) {
+        const authError = error instanceof EdgeBaseError
+            ? error
+            : new EdgeBaseError(500, 'Room authentication failed.');
+        this.waitingForAuth = authError.code === 401 && this.joinRequested;
+        this.stopHeartbeat();
+        this.connected = false;
+        this.authenticated = false;
+        this.joined = false;
+        this.connectingPromise = null;
+        if (this.ws) {
+            const socket = this.ws;
+            this.ws = null;
+            try {
+                socket.close(4001, authError.message);
+            }
+            catch {
+                // Ignore close failures — the server will time out stale sockets.
+            }
+        }
+    }
+    normalizeMembers(value) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        return value
+            .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;
+        }
+        const member = value;
+        if (typeof member.memberId !== 'string' || typeof member.userId !== 'string') {
+            return null;
+        }
+        return {
+            memberId: member.memberId,
+            userId: member.userId,
+            connectionId: typeof member.connectionId === 'string' ? member.connectionId : undefined,
+            connectionCount: typeof member.connectionCount === 'number' ? member.connectionCount : undefined,
+            role: typeof member.role === 'string' ? member.role : undefined,
+            state: this.normalizeState(member.state),
+        };
+    }
+    normalizeState(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return {};
+        }
+        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 {};
+        }
+        const meta = value;
+        return {
+            memberId: typeof meta.memberId === 'string' || meta.memberId === null ? meta.memberId : undefined,
+            userId: typeof meta.userId === 'string' || meta.userId === null ? meta.userId : undefined,
+            connectionId: typeof meta.connectionId === 'string' || meta.connectionId === null
+                ? meta.connectionId
+                : undefined,
+            sentAt: typeof meta.sentAt === 'number' ? meta.sentAt : undefined,
+            serverSent: meta.serverSent === true,
+        };
+    }
+    normalizeLeaveReason(value) {
+        switch (value) {
+            case 'leave':
+            case 'timeout':
+            case 'kicked':
+                return value;
+            default:
+                return 'leave';
+        }
+    }
+    upsertMember(member) {
+        const index = this._members.findIndex((entry) => entry.memberId === member.memberId);
+        if (index >= 0) {
+            this._members[index] = cloneValue(member);
+            return;
+        }
+        this._members.push(cloneValue(member));
+    }
+    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,
+        };
+    }
+    rejectPendingVoidRequests(pendingRequests, error) {
+        for (const [, pending] of pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+        }
+        pendingRequests.clear();
+    }
+    setConnectionState(next) {
+        if (this.connectionState === next) {
+            return;
+        }
+        this.connectionState = next;
+        for (const handler of this.connectionStateHandlers) {
+            handler(next);
+        }
+    }
+    // ─── Private: Helpers ───
+    sendRaw(data) {
+        if (this.ws && this.connected) {
+            this.ws.send(JSON.stringify(data));
+            return;
+        }
+    }
+    buildWsUrl() {
+        const httpUrl = this.baseUrl.replace(/\/$/, '');
+        const wsUrl = httpUrl.replace(/^http/, 'ws');
+        return `${wsUrl}/api/room?namespace=${encodeURIComponent(this.namespace)}&id=${encodeURIComponent(this.roomId)}`;
+    }
+    scheduleReconnect() {
+        const attempt = this.reconnectAttempts + 1;
+        const delay = this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
+        this.reconnectAttempts++;
+        this.reconnectInfo = { attempt };
+        this.setConnectionState('reconnecting');
+        setTimeout(() => {
+            if (this.connectingPromise
+                || !this.joinRequested
+                || this.waitingForAuth
+                || isSocketOpenOrConnecting(this.ws)) {
+                return;
+            }
+            this.ensureConnection().catch(() => { });
+        }, Math.min(delay, 30000));
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.ws && this.connected) {
+                this.ws.send(JSON.stringify({ type: 'ping' }));
+            }
+        }, 30000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+}
+//# sourceMappingURL=room.js.map