@edge-base/web 0.1.5 → 0.2.1

package/dist/room.js

@@ -1,6 +1,8 @@
-import { EdgeBaseError } from '@edge-base/core';
+import { EdgeBaseError, createSubscription } from '@edge-base/core';
 import { refreshAccessToken } from './auth-refresh.js';
-import { RoomRealtimeMediaTransport, } from './room-realtime-media.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']);
 function deepSet(obj, path, value) {
@@ -89,6 +91,34 @@ export class RoomClient {
     waitingForAuth = false;
     joinRequested = false;
     unsubAuthState = null;
+    browserNetworkListenersAttached = false;
+    browserOfflineHandler = () => {
+        if (this.intentionallyLeft || !this.joinRequested) {
+            return;
+        }
+        if (this.connectionState === 'connected') {
+            this.setConnectionState('reconnecting');
+        }
+        if (isSocketOpenOrConnecting(this.ws)) {
+            try {
+                this.ws?.close();
+            }
+            catch {
+                // Socket may already be closing.
+            }
+        }
+    };
+    browserOnlineHandler = () => {
+        if (this.intentionallyLeft
+            || !this.joinRequested
+            || this.connectingPromise
+            || isSocketOpenOrConnecting(this.ws)) {
+            return;
+        }
+        if (this.connectionState === 'reconnecting' || this.connectionState === 'disconnected') {
+            this.ensureConnection().catch(() => { });
+        }
+    };
     // ─── Pending send() requests (requestId → { resolve, reject, timeout }) ───
     pendingRequests = new Map();
     pendingSignalRequests = new Map();
@@ -132,6 +162,21 @@ export class RoomClient {
     };
     members = {
         list: () => cloneValue(this._members),
+        current: () => {
+            const connectionId = this.currentConnectionId;
+            if (connectionId) {
+                const byConnection = this._members.find((member) => member.connectionId === connectionId);
+                if (byConnection) {
+                    return cloneValue(byConnection);
+                }
+            }
+            const userId = this.currentUserId;
+            if (!userId) {
+                return null;
+            }
+            const member = this._members.find((entry) => entry.userId === userId) ?? null;
+            return member ? cloneValue(member) : null;
+        },
         onSync: (handler) => this.onMembersSync(handler),
         onJoin: (handler) => this.onMemberJoin(handler),
         onLeave: (handler) => this.onMemberLeave(handler),
@@ -166,13 +211,20 @@ export class RoomClient {
         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),
+        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),
@@ -195,10 +247,12 @@ export class RoomClient {
             maxReconnectAttempts: options?.maxReconnectAttempts ?? 10,
             reconnectBaseDelay: options?.reconnectBaseDelay ?? 1000,
             sendTimeout: options?.sendTimeout ?? 10000,
+            connectionTimeout: options?.connectionTimeout ?? 15000,
         };
         this.unsubAuthState = this.tokenManager.onAuthStateChange((user) => {
             this.handleAuthStateChange(user);
         });
+        this.attachBrowserNetworkListeners();
     }
     // ─── State Accessors ───
     /** Get current shared state (read-only snapshot) */
@@ -229,12 +283,15 @@ export class RoomClient {
         }
         return res.json();
     }
-    async requestRealtimeMedia(path, method, payload) {
+    async requestCloudflareRealtimeKitMedia(path, method, payload) {
+        return this.requestRoomMedia('cloudflare_realtimekit', path, method, payload);
+    }
+    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/realtime/${path}`);
+        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(), {
@@ -247,7 +304,7 @@ export class RoomClient {
         });
         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}`);
+            throw new EdgeBaseError(response.status, (typeof data.message === 'string' && data.message) || `Room media request failed: ${response.statusText}`);
         }
         return data;
     }
@@ -269,15 +326,7 @@ export class RoomClient {
         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'));
+        this.rejectAllPendingRequests(new EdgeBaseError(499, 'Room left'));
         if (this.ws) {
             const socket = this.ws;
             this.sendRaw({ type: 'leave' });
@@ -299,6 +348,36 @@ export class RoomClient {
         this.reconnectInfo = null;
         this.setConnectionState('disconnected');
     }
+    /**
+     * Destroy the RoomClient and release all resources.
+     * Calls leave() if still connected, unsubscribes from auth state changes,
+     * and clears all handler arrays to allow garbage collection.
+     */
+    destroy() {
+        this.leave();
+        this.detachBrowserNetworkListeners();
+        this.unsubAuthState?.();
+        this.unsubAuthState = null;
+        // Clear all handler arrays to break references
+        this.sharedStateHandlers.length = 0;
+        this.playerStateHandlers.length = 0;
+        this.messageHandlers.clear();
+        this.allMessageHandlers.length = 0;
+        this.errorHandlers.length = 0;
+        this.kickedHandlers.length = 0;
+        this.memberSyncHandlers.length = 0;
+        this.memberJoinHandlers.length = 0;
+        this.memberLeaveHandlers.length = 0;
+        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;
+    }
     // ─── Actions ───
     /**
      * Send an action to the server.
@@ -331,33 +410,29 @@ export class RoomClient {
      * Subscribe to shared state changes.
      * Called on full sync and on each shared_delta.
      *
-     * @returns Subscription with unsubscribe()
+     * @returns Subscription (callable & .unsubscribe())
      */
     onSharedState(handler) {
         this.sharedStateHandlers.push(handler);
-        return {
-            unsubscribe: () => {
-                const idx = this.sharedStateHandlers.indexOf(handler);
-                if (idx >= 0)
-                    this.sharedStateHandlers.splice(idx, 1);
-            },
-        };
+        return createSubscription(() => {
+            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()
+     * @returns Subscription (callable & .unsubscribe())
      */
     onPlayerState(handler) {
         this.playerStateHandlers.push(handler);
-        return {
-            unsubscribe: () => {
-                const idx = this.playerStateHandlers.indexOf(handler);
-                if (idx >= 0)
-                    this.playerStateHandlers.splice(idx, 1);
-            },
-        };
+        return createSubscription(() => {
+            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().
@@ -365,186 +440,154 @@ export class RoomClient {
      * @example
      * room.onMessage('game_over', (data) => { console.log(data.winner); });
      *
-     * @returns Subscription with unsubscribe()
+     * @returns Subscription (callable & .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);
-                }
-            },
-        };
+        return createSubscription(() => {
+            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()
+     * @returns Subscription (callable & .unsubscribe())
      */
     onAnyMessage(handler) {
         this.allMessageHandlers.push(handler);
-        return {
-            unsubscribe: () => {
-                const idx = this.allMessageHandlers.indexOf(handler);
-                if (idx >= 0)
-                    this.allMessageHandlers.splice(idx, 1);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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);
-            },
-        };
+        return createSubscription(() => {
+            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) {
@@ -651,29 +694,53 @@ export class RoomClient {
             const wsUrl = this.buildWsUrl();
             const ws = new WebSocket(wsUrl);
             this.ws = ws;
+            let settled = false;
+            const connectionTimer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    try {
+                        ws.close();
+                    }
+                    catch (_) { /* ignore */ }
+                    this.ws = null;
+                    reject(new EdgeBaseError(408, `Room WebSocket connection timed out after ${this.options.connectionTimeout}ms. Is the server running?`));
+                }
+            }, this.options.connectionTimeout);
             ws.onopen = () => {
+                clearTimeout(connectionTimer);
                 this.connected = true;
                 this.reconnectAttempts = 0;
                 this.startHeartbeat();
                 this.authenticate()
                     .then(() => {
-                    this.waitingForAuth = false;
-                    resolve();
+                    if (!settled) {
+                        settled = true;
+                        this.waitingForAuth = false;
+                        resolve();
+                    }
                 })
                     .catch((error) => {
-                    this.handleAuthenticationFailure(error);
-                    reject(error);
+                    if (!settled) {
+                        settled = true;
+                        this.handleAuthenticationFailure(error);
+                        reject(error);
+                    }
                 });
             };
             ws.onmessage = (event) => {
                 this.handleMessage(event.data);
             };
             ws.onclose = (event) => {
+                clearTimeout(connectionTimer);
                 this.connected = false;
                 this.authenticated = false;
                 this.joined = false;
                 this.ws = null;
                 this.stopHeartbeat();
+                // Reject pending requests immediately so callers don't hang until timeout
+                if (!this.intentionallyLeft) {
+                    this.rejectAllPendingRequests(new EdgeBaseError(499, 'WebSocket connection lost'));
+                }
                 if (event.code === 4004 && this.connectionState !== 'kicked') {
                     this.handleKicked();
                 }
@@ -688,7 +755,11 @@ export class RoomClient {
                 }
             };
             ws.onerror = () => {
-                reject(new EdgeBaseError(500, 'Room WebSocket connection error'));
+                clearTimeout(connectionTimer);
+                if (!settled) {
+                    settled = true;
+                    reject(new EdgeBaseError(500, 'Room WebSocket connection error'));
+                }
             };
         });
     }
@@ -1008,7 +1079,7 @@ export class RoomClient {
         this.upsertMember(member);
         this.syncMediaMemberInfo(member);
         const requestId = msg.requestId;
-        if (requestId && member.memberId === this.currentUserId) {
+        if (requestId) {
             const pending = this.pendingMemberStateRequests.get(requestId);
             if (pending) {
                 clearTimeout(pending.timeout);
@@ -1191,6 +1262,8 @@ export class RoomClient {
         this.waitingForAuth = this.joinRequested;
         this.reconnectInfo = null;
         this.setConnectionState('auth_lost');
+        // Reject pending requests — auth is gone, server won't respond
+        this.rejectAllPendingRequests(new EdgeBaseError(401, 'Auth state lost'));
         if (this.ws) {
             const socket = this.ws;
             this.sendRaw({ type: 'leave' });
@@ -1447,6 +1520,18 @@ export class RoomClient {
             [kind]: next,
         };
     }
+    /** Reject all 5 pending request maps at once. */
+    rejectAllPendingRequests(error) {
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+        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) {
             clearTimeout(pending.timeout);
@@ -1475,9 +1560,41 @@ export class RoomClient {
         const wsUrl = httpUrl.replace(/^http/, 'ws');
         return `${wsUrl}/api/room?namespace=${encodeURIComponent(this.namespace)}&id=${encodeURIComponent(this.roomId)}`;
     }
+    attachBrowserNetworkListeners() {
+        if (this.browserNetworkListenersAttached) {
+            return;
+        }
+        const eventTarget = typeof globalThis !== 'undefined'
+            && typeof globalThis.addEventListener === 'function'
+            ? globalThis
+            : null;
+        if (!eventTarget) {
+            return;
+        }
+        eventTarget.addEventListener('offline', this.browserOfflineHandler);
+        eventTarget.addEventListener('online', this.browserOnlineHandler);
+        this.browserNetworkListenersAttached = true;
+    }
+    detachBrowserNetworkListeners() {
+        if (!this.browserNetworkListenersAttached) {
+            return;
+        }
+        const eventTarget = typeof globalThis !== 'undefined'
+            && typeof globalThis.removeEventListener === 'function'
+            ? globalThis
+            : null;
+        if (!eventTarget) {
+            return;
+        }
+        eventTarget.removeEventListener('offline', this.browserOfflineHandler);
+        eventTarget.removeEventListener('online', this.browserOnlineHandler);
+        this.browserNetworkListenersAttached = false;
+    }
     scheduleReconnect() {
         const attempt = this.reconnectAttempts + 1;
-        const delay = this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
+        const baseDelay = this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
+        const jitter = Math.random() * baseDelay * 0.25;
+        const delay = baseDelay + jitter;
         this.reconnectAttempts++;
         this.reconnectInfo = { attempt };
         this.setConnectionState('reconnecting');