playsocketjs 1.0.7 → 1.0.9

package/dist/playsocket-client.js

@@ -9,6 +9,7 @@ const TIMEOUT_MS = 5000; // 5 second timeout for operations
 class PlaySocket {
     // Core properties
     #id; // Unique client ID
+    #sessionToken; // Unique session token
     #endpoint;
     #socket; // WebSocket connection
     #initialized = false; // Initialization status
@@ -16,8 +17,7 @@ class PlaySocket {
 
     // Room properties
     #storage = {}; // Shared storage object
-    #storageTimestamps = {}; // Tracks update timestamps per key
-    #isHost = false; // Whether this client is host
+    #storageTimestamps = {}; // Tracks update timestamps per key to ensure that not-yet synced updates don't get overwritten
     #roomHost;
     #roomId; // ID of the host (client only)
     #connectionCount = 0;
@@ -29,10 +29,14 @@ class PlaySocket {
     // Async server operations
     #pendingJoin;
     #pendingHost;
-    #pendingInit;
+    #pendingRegistration;
+    #pendingConnect;
+    #pendingReconnect;
 
     // Timeouts or intervals
     #reconnectTimeout;
+    #reconnectCount = 0;
+    #isReconnecting = false;
 
     /**
      * Create a new PlaySocket instance
@@ -72,7 +76,7 @@ class PlaySocket {
      */
     onEvent(event, callback) {
         const validEvents = [
-            "status", "error", "instanceDestroyed", "storageUpdated", "hostMigrated", "clientConnected", "clientDisconnected",
+            "status", "error", "instanceDestroyed", "storageUpdated", "hostMigrated", "clientConnected", "clientDisconnected"
         ];
         if (!validEvents.includes(event)) return console.warn(WARNING_PREFIX + `Invalid event type "${event}".`);
         if (!this.#callbacks.has(event)) this.#callbacks.set(event, []);
@@ -99,40 +103,48 @@ class PlaySocket {
      * @returns {Promise} Resolves when connection is established
      */
     async init() {
-        if (this.#initialized) return Promise.reject(new Error("Already initialized."));
-        if (!this.#endpoint) return Promise.reject(new Error("No websocket endpoint provided."));
+        if (this.#initialized) return Promise.reject(new Error("Already initialized"));
+        if (!this.#endpoint) return Promise.reject(new Error("No websocket endpoint provided"));
         this.#triggerEvent("status", "Initializing...");
 
-        return Promise.race([
-            this.#connect(),
-            this.#createTimeout("Initialization")
-        ]);
-    }
-
-
-    /**
-     * Connect to the WS server and register
-     * @returns {Promise} Resolves when user is registered on the WS server
-     * @private 
-     */
-    async #connect() {
-        return new Promise((resolve, reject) => {
-            this.#socket = new WebSocket(this.#endpoint);
-            this.#setupSocketHandlers(); // Message & close events
+        // Connect to WS server
+        await this.#connect();
 
-            // Resolve or reject depending on answer to registration msg
-            this.#pendingInit = { resolve, reject };
+        // Register with server
+        await Promise.race([
+            new Promise(async (resolve, reject) => {
+                this.#pendingRegistration = { resolve, reject }; // Resolve or reject depending on answer to registration msg
 
-            // Register with server
-            this.#socket.onopen = () => {
-                this.#initialized = true;
+                // Register with server
                 this.#sendToServer({
                     type: 'register',
                     id: this.#id,
                     customData: this.#customData || undefined,
                     clientTime: Date.now()
                 });
-            };
+            }),
+            this.#createTimeout("Registration")
+        ]).finally(() => {
+            this.#pendingRegistration = null;
+        });
+    }
+
+    /**
+     * Connect to the WS server and
+     * @returns {Promise} Resolves when the connection was established
+     * @private 
+     */
+    async #connect() {
+        return Promise.race([
+            new Promise((resolve, reject) => {
+                this.#pendingConnect = { reject };
+                this.#socket = new WebSocket(this.#endpoint);
+                this.#setupSocketHandlers(); // Message & close events
+                this.#socket.onopen = resolve;
+            }),
+            this.#createTimeout("Connection attempt")
+        ]).finally(() => {
+            this.#pendingConnect = null;
         });
     }
 
@@ -147,25 +159,53 @@ class PlaySocket {
                 if (!message.type) return;
 
                 switch (message.type) {
-                    case 'connection_accepted':
+                    case 'join_accepted':
                         // Connected to room
                         if (this.#pendingJoin) {
                             this.#storage = message.storage;
                             this.#storageTimestamps = message.storageTimestamps;
-                            this.#connectionCount = message.participantCount - 1;
+                            this.#connectionCount = message.participantCount - 1; // Counted without the user themselves
+                            this.#roomHost = message.host;
                             this.#triggerEvent("status", `Connected to room.`);
                             this.#triggerEvent("storageUpdated", { ...this.#storage });
                             this.#pendingJoin.resolve();
-                            this.#pendingJoin = null;
                         }
                         break;
 
-                    case 'connection_rejected':
+                    case 'join_rejected':
                         // Connection to room failed
                         if (this.#pendingJoin) {
-                            this.#triggerEvent("status", "Connection rejected: " + message.reason || 'Unknown reason');
-                            this.#pendingJoin.reject(new Error("Connection rejected: " + message.reason || 'Unknown reason'));
-                            this.#pendingJoin = null;
+                            this.#triggerEvent("status", "Connection rejected: " + message.reason);
+                            this.#pendingJoin.reject(new Error("Connection rejected: " + message.reason));
+                        }
+                        break;
+
+                    case 'reconnected':
+                        // Successfully reconnected
+                        if (this.#pendingReconnect) {
+                            this.#isReconnecting = false;
+                            this.#reconnectCount = 0;
+                            if (message.roomData) {
+                                this.#storage = message.roomData.storage;
+                                this.#storageTimestamps = message.roomData.storageTimestamps;
+                                this.#connectionCount = message.roomData.participantCount - 1; // Counted without the user themselves
+                                this.#setHost(message.roomData.host);
+                                this.#triggerEvent("storageUpdated", { ...this.#storage });
+                            } else {
+                                if (this.#roomId) {
+                                    this.#triggerEvent("error", "Reconnected, but room no longer exists.");
+                                    return this.destroy();
+                                }
+                            }
+                            this.#triggerEvent("status", "Reconnected.");
+                            this.#pendingReconnect.resolve();
+                        }
+                        break;
+
+                    case 'reconnection_failed':
+                        if (this.#pendingReconnect) {
+                            this.#triggerEvent("status", `Reconnection failed: ${message.reason}`);
+                            this.#pendingReconnect.reject(new Error("Reconnection failed: " + message.reason));
                         }
                         break;
 
@@ -174,34 +214,32 @@ class PlaySocket {
                             this.#pendingHost.resolve(this.#roomId);
                             this.#triggerEvent("status", `Room created${this.#pendingHost.maxSize ? ` with max size ${this.#pendingHost.maxSize}.` : '.'}`);
                             this.#triggerEvent("storageUpdated", { ...this.#storage });
-                            this.#pendingHost = null;
                         }
                         break;
 
                     case 'room_creation_failed':
                         if (this.#pendingHost) {
-                            this.#pendingHost.reject(new Error("Failed to create room: " + message.reason || 'Unknown reason'));
-                            this.#triggerEvent("error", "Failed to create room: " + message.reason || 'Unknown reason');
-                            this.#pendingHost = null;
+                            this.#pendingHost.reject(new Error("Failed to create room: " + message.reason));
+                            this.#triggerEvent("error", "Failed to create room: " + message.reason);
                         }
                         break;
 
                     case 'id_taken':
-                        if (this.#pendingInit) {
-                            this.#pendingInit.reject(new Error("This id is already in use."));
+                        if (this.#pendingRegistration) {
+                            this.#pendingRegistration.reject(new Error("This id is already in use"));
                             this.#triggerEvent("error", "This id is taken.");
-                            this.#pendingInit = null;
                         }
                         break;
 
                     case 'registered':
-                        if (this.#pendingInit) {
+                        if (this.#pendingRegistration) {
                             const roundTripTime = Date.now() - message.clientTime;
                             const serverTimeAtClientNow = message.serverTime + (roundTripTime / 2);
                             this.#serverTimeOffset = serverTimeAtClientNow - Date.now();
-                            this.#pendingInit.resolve();
+                            this.#sessionToken = message.sessionToken;
+                            this.#initialized = true;
+                            this.#pendingRegistration.resolve();
                             this.#triggerEvent("status", "Connected to server.");
-                            this.#pendingInit = null;
                         }
                         break;
 
@@ -216,22 +254,27 @@ class PlaySocket {
                         }
                         break;
 
+                    case 'storage_operation':
+                        if (message.key) {
+                            const updatedArray = this.#handleArrayUpdate(message.key, message.operation, message.value, message.updateValue);
+                            if (JSON.stringify(this.#storage[message.key]) !== JSON.stringify(updatedArray)) {
+                                this.#storage[message.key] = updatedArray;
+                                this.#storageTimestamps[message.key] = message.timestamp;
+                                this.#triggerEvent("storageUpdated", { ...this.#storage });
+                            }
+                        }
+                        break;
+
                     case 'client_disconnected':
-                        this.#isHost = this.#id == message.updatedHost;
                         this.#connectionCount = message.participantCount - 1; // Counted without the user themselves
-
-                        // If host has changed...
-                        if (this.#roomHost != message.updatedHost) {
-                            this.#roomHost = message.updatedHost;
-                            this.#triggerEvent("hostMigrated", this.#roomHost);
-                        }
+                        this.#setHost(message.host);
 
                         this.#triggerEvent("clientDisconnected", message.client);
                         this.#triggerEvent("status", `Client ${message.client} disconnected.`);
                         break;
 
                     case 'client_connected':
-                        this.#connectionCount = message.participantCount - 1;
+                        this.#connectionCount = message.participantCount - 1; // Counted without the user themselves
                         this.#triggerEvent("clientConnected", message.client);
                         this.#triggerEvent("status", `Client ${message.client} connected.`);
                         break;
@@ -244,37 +287,69 @@ class PlaySocket {
         // Handle socket errors
         this.#socket.onerror = () => {
             this.#triggerEvent("error", "WebSocket error.");
-            if (this.#pendingInit) this.#pendingInit.reject(new Error("WebSocket error."));
+            if (this.#pendingConnect) this.#pendingConnect.reject(new Error("WebSocket error"));
         };
 
         // Handle socket close & attempt reconnect
         this.#socket.onclose = () => {
-            if (!this.#initialized) return;
-            this.#triggerEvent("status", "Disconnected from server.");
-
-            this.#reconnectTimeout = setTimeout(async () => {
-                try {
-                    await this.#connect(); // Will set status to connected if successful
-
-                    // Rejoin room if needed
-                    if (this.#roomId) {
-                        this.#triggerEvent("status", "Rejoining room...");
-                        await this.joinRoom(this.#roomId); // If this fails, it will be caught by the outer catch
-                    }
-                } catch (error) {
-                    this.#triggerEvent("error", "WebSocket connection permanently closed: " + error);
-                    this.destroy();
-                }
-            }, 1000);
+            if (!this.#initialized || this.#isReconnecting) return;
+            this.#triggerEvent("status", "Disconnected.");
+            this.#reconnectCount = 0;
+            this.#attemptReconnect();
         };
     };
 
+    /**
+     * Attempt to reconnect with a fixed number of retries
+     * @private
+     */
+    async #attemptReconnect() {
+        if (this.#reconnectCount++ >= 3) {
+            this.#triggerEvent("error", "Disconnected from server.");
+            return this.destroy();
+        }
+
+        this.#triggerEvent("status", `Attempting to reconnect... (${this.#reconnectCount})`);
+        this.#isReconnecting = true;
+        try {
+            await this.#connect();
+            await Promise.race([
+                new Promise(async (resolve, reject) => {
+                    this.#pendingReconnect = { resolve, reject };
+                    this.#sendToServer({
+                        type: 'reconnect',
+                        id: this.#id,
+                        sessionToken: this.#sessionToken
+                    });
+                }),
+                this.#createTimeout("Reconnection request")
+            ]).finally(() => {
+                this.#pendingReconnect = null;
+            });
+        } catch (error) {
+            this.#triggerEvent("status", "Reconnection failed: " + error.message);
+            this.#reconnectTimeout = setTimeout(() => this.#attemptReconnect(), 500);
+        }
+    }
+
+    /**
+     * Update the host in case a new one was chosen
+     * @param {string} hostId - Client id of new host
+     * @private
+     */
+    #setHost(hostId) {
+        if (this.#roomHost != hostId) {
+            this.#roomHost = hostId;
+            this.#triggerEvent("hostMigrated", hostId);
+        }
+    }
+
     /**
      * Send a message to the server
      * @private
      */
     #sendToServer(data) {
-        if (!this.#initialized || !this.#socket || this.#socket.readyState !== WebSocket.OPEN) {
+        if (!this.#socket || this.#socket.readyState !== WebSocket.OPEN) {
             return console.error(ERROR_PREFIX + "Cannot send message - not connected.");
         }
         try {
@@ -299,7 +374,6 @@ class PlaySocket {
 
         return Promise.race([
             new Promise((resolve, reject) => {
-                this.#isHost = true;
                 this.#storage = initialStorage;
                 this.#roomId = this.#id; // Create room with your own ID as the room ID to mimic p2p
                 this.#roomHost = this.#id;
@@ -313,7 +387,9 @@ class PlaySocket {
                 });
             }),
             this.#createTimeout("Room creation")
-        ]);
+        ]).finally(() => {
+            this.#pendingHost = null;
+        });
     }
 
     /**
@@ -329,9 +405,7 @@ class PlaySocket {
 
         return Promise.race([
             new Promise((resolve, reject) => {
-                this.#isHost = false;
                 this.#roomId = roomId;
-                this.#roomHost = roomId;
                 this.#pendingJoin = { resolve, reject };
 
                 // Send connection request
@@ -342,7 +416,9 @@ class PlaySocket {
                 });
             }),
             this.#createTimeout("Room join")
-        ]);
+        ]).finally(() => {
+            this.#pendingJoin = null;
+        });
     }
 
     /**
@@ -374,15 +450,17 @@ class PlaySocket {
     updateStorageArray(key, operation, value, updateValue) {
         const updatedArray = this.#handleArrayUpdate(key, operation, value, updateValue);
         if (JSON.stringify(this.#storage[key]) === JSON.stringify(updatedArray)) return; // Prevent updates without changes
+        const timestamp = this.#getTimestamp();
         this.#sendToServer({
             type: 'room_storage_array_update',
             key,
             operation,
             value,
-            updateValue
+            updateValue,
+            timestamp
         });
         this.#storage[key] = updatedArray;
-        this.#storageTimestamps[key] = this.#getTimestamp();
+        this.#storageTimestamps[key] = timestamp;
         this.#triggerEvent("storageUpdated", { ...this.#storage });
     }
 
@@ -427,6 +505,8 @@ class PlaySocket {
         this.#initialized = false; // Set this immediately to prevent automatic reconnection
 
         if (this.#socket) {
+            // Signal to the server that it can immediately disconnect this user
+            if (this.#socket.readyState === WebSocket.OPEN) this.#sendToServer({ type: 'disconnect' });
             this.#socket.close();
             this.#socket = null;
 
@@ -436,19 +516,21 @@ class PlaySocket {
         }
 
         // Reset state
-        this.#isHost = false;
+        clearTimeout(this.#reconnectTimeout);
         this.#roomHost = null;
         this.#storage = {};
         this.#storageTimestamps = {};
+        this.#serverTimeOffset = 0;
         this.#roomId = null;
         this.#connectionCount = 0;
-        clearTimeout(this.#reconnectTimeout);
+        this.#isReconnecting = false;
+        this.#reconnectCount = 0;
     }
 
     // Public getters
     get connectionCount() { return this.#connectionCount; }
     get getStorage() { return { ...this.#storage }; }
-    get isHost() { return this.#isHost; }
+    get isHost() { return this.#id == this.#roomHost; }
     get id() { return this.#id; }
 }
 

package/dist/playsocket-server.js

@@ -27,8 +27,10 @@ function requireServer () {
 	    #rooms = {};
 	    #clientRooms = new Map(); // ClientId -> RoomId
 	    #rateLimits = new Map(); // Rate limiting storage
-	    #callbacks = new Map();
+	    #callbacks = new Map(); // Event -> [callback functions]
 	    #heartbeatInterval;
+	    #pendingDisconnects = new Map(); // ClientId -> {timeout, roomId}
+	    #clientTokens = new Map(); // ClientId -> Token
 
 	    /**
 	     * Create a new PlaySocketServer instance
@@ -98,10 +100,45 @@ function requireServer () {
 	                    }
 	                    ws.clientId = data.id; // Adds the provided id to the ws object as clientId
 	                    this.#clients.set(data.id, ws);
-	                    ws.send(JSON.stringify({ type: 'registered', serverTime: Date.now(), clientTime: data.clientTime }));
+	                    const sessionToken = this.#generateSessionToken();
+	                    this.#clientTokens.set(data.id, sessionToken); // Token is used when reconnecting to prevent impersonation attacks
+	                    ws.send(JSON.stringify({ type: 'registered', sessionToken, serverTime: Date.now(), clientTime: data.clientTime }));
 	                    this.#triggerEvent("clientRegistered", data.id, data.customData);
 	                    break;
 
+	                case 'reconnect':
+	                    // If user is pending disconnect, respond (otherwise it's too late)
+	                    const pd = this.#pendingDisconnects.get(data.id);
+	                    if (pd && data.sessionToken) {
+	                        if (data.sessionToken !== this.#clientTokens.get(data.id)) {
+	                            ws.send(JSON.stringify({ type: 'reconnection_failed', reason: "Session token does not match" }));
+	                            return;
+	                        }
+	                        clearTimeout(pd.timeout);
+	                        this.#pendingDisconnects.delete(data.id);
+
+	                        // Re-assign old client id to the new ws connection
+	                        ws.clientId = data.id;
+	                        this.#clients.set(data.id, ws);
+
+	                        // If they were in a room, provide updated room data
+	                        let roomData;
+	                        const formerRoom = this.#rooms[this.#clientRooms.get(data.id)];
+	                        if (formerRoom) {
+	                            roomData = {
+	                                storage: formerRoom.storage,
+	                                storageTimestamps: formerRoom.storageTimestamps,
+	                                participantCount: formerRoom.participants.length,
+	                                host: formerRoom.participants[0]
+	                            };
+	                        }
+
+	                        ws.send(JSON.stringify({ type: 'reconnected', roomData }));
+	                    } else {
+	                        ws.send(JSON.stringify({ type: 'reconnection_failed', reason: "Client unknown to server" }));
+	                    }
+	                    break;
+
 	                case 'create_room':
 	                    if (!ws.clientId) return;
 	                    const newRoomId = ws.clientId;
@@ -126,7 +163,7 @@ function requireServer () {
 	                    break;
 
 	                case 'join_room':
-	                    if (!data.roomId) return;
+	                    if (!data.roomId || !ws.clientId) return;
 	                    const roomId = data.roomId;
 	                    const room = this.#rooms[roomId];
 
@@ -134,7 +171,7 @@ function requireServer () {
 	                        (room.maxSize && room.participants.length >= room.maxSize) ||
 	                        this.#clientRooms.get(ws.clientId)) {
 	                        ws.send(JSON.stringify({
-	                            type: 'connection_rejected',
+	                            type: 'join_rejected',
 	                            reason: !room ? 'Room not found' :
 	                                room.maxSize && room.participants.length >= room.maxSize ? 'Room full' :
 	                                    'Already in a room'
@@ -147,10 +184,11 @@ function requireServer () {
 
 	                    // Notify joiner with initial storage
 	                    ws.send(JSON.stringify({
-	                        type: 'connection_accepted',
+	                        type: 'join_accepted',
 	                        storage: room.storage,
 	                        storageTimestamps: room.storageTimestamps,
-	                        participantCount: room.participants.length
+	                        participantCount: room.participants.length,
+	                        host: room.participants[0]
 	                    }));
 
 	                    // Notify existing participants
@@ -176,7 +214,7 @@ function requireServer () {
 	                        if (data.timestamp > existingTimestamp && JSON.stringify(updateRoom.storage[data.key]) !== JSON.stringify(data.value)) {
 	                            updateRoom.storage[data.key] = data.value;
 	                            updateRoom.storageTimestamps[data.key] = data.timestamp;
-	                            this.#syncRoomStorageKey(updateRoomId, data.key, data.timestamp);
+	                            this.#syncRoomStorageKey(updateRoomId, ws.clientId, data.key, data.timestamp);
 	                        }
 	                    }
 	                    break;
@@ -185,20 +223,36 @@ function requireServer () {
 	                    const arrayRoomId = this.#clientRooms.get(ws.clientId);
 	                    const arrayRoom = arrayRoomId ? this.#rooms[arrayRoomId] : null;
 	                    if (arrayRoom && data.key) {
+	                        // No timestamp check for array operations as they are designed to work unordered
 	                        const updatedArray = this.#arrayUpdate(arrayRoom.storage, data.key, data.operation, data.value, data.updateValue);
 	                        if (JSON.stringify(arrayRoom.storage[data.key]) !== JSON.stringify(updatedArray)) {
 	                            arrayRoom.storage[data.key] = updatedArray;
-	                            arrayRoom.storageTimestamps[data.key] = Date.now(); // New date to ensure that they are applied regardless of age (they don't overwrite – they transform)
-	                            this.#syncRoomStorageKey(arrayRoomId, data.key, Date.now());
+	                            arrayRoom.storageTimestamps[data.key] = data.timestamp;
+	                            this.#syncRoomStorageOperation(arrayRoomId, ws.clientId, data.key, data.operation, data.value, data.updateValue, data.timestamp);
 	                        }
 	                    }
 	                    break;
+
+	                case 'disconnect':
+	                    // Client signals to server that it will will willfully disconnect soon
+	                    ws.willfulDisconnect = true;
+	                    break;
 	            }
 	        } catch (error) {
 	            console.error('Error processing message:', error);
 	        }
 	    }
 
+	    /**
+	     * Generate a random token to prevent malicious reconnect attempts
+	     * @returns {string} - Token
+	     */
+	    #generateSessionToken() {
+	        let token = '';
+	        for (let i = 0; i < 16; i++) token += Math.floor(Math.random() * 16).toString(16);
+	        return token;
+	    }
+
 	    /**
 	     * Check rate limit using token bucket algorithm
 	     * @private
@@ -228,13 +282,18 @@ function requireServer () {
 	    }
 
 	    /**
-	     * Sync storage key to all clients in room
+	     * Sync storage key with all clients in room
 	     * @private
+	     * @param {string} roomId 
+	     * @param {string} requesterId - Client id of whom initiated the operation
+	     * @param {string} key 
+	     * @param {number} timestamp - In milliseconds
 	     */
-	    #syncRoomStorageKey(roomId, key, timestamp) {
+	    #syncRoomStorageKey(roomId, requesterId, key, timestamp) {
 	        const room = this.#rooms[roomId];
 	        if (!room) return;
 	        room.participants.forEach(p => {
+	            if (p == requesterId) return; // Don't sync with the requester
 	            const client = this.#clients.get(p);
 	            if (client) {
 	                client.send(JSON.stringify({
@@ -247,6 +306,36 @@ function requireServer () {
 	        });
 	    }
 
+	    /**
+	     * Sync storage operations with all clients in room
+	     * @private
+	     * @param {string} roomId 
+	     * @param {string} requesterId - Client id of whom initiated the operation
+	     * @param {string} key 
+	     * @param {string} operation 
+	     * @param {*} value 
+	     * @param {*} updateValue 
+	     * @param {number} timestamp - In milliseconds
+	     */
+	    #syncRoomStorageOperation(roomId, requesterId, key, operation, value, updateValue, timestamp) {
+	        const room = this.#rooms[roomId];
+	        if (!room) return;
+	        room.participants.forEach(p => {
+	            if (p == requesterId) return; // Don't send the operation to the requester
+	            const client = this.#clients.get(p);
+	            if (client) {
+	                client.send(JSON.stringify({
+	                    type: 'storage_operation',
+	                    key,
+	                    operation,
+	                    value,
+	                    updateValue,
+	                    timestamp
+	                }));
+	            }
+	        });
+	    }
+
 	    /**
 	     * Handle array operations
 	     * @private
@@ -284,34 +373,50 @@ function requireServer () {
 	     */
 	    #handleDisconnection(ws) {
 	        if (!ws.clientId) return;
+	        this.#clients.delete(ws.clientId); // Immediately remove from active clients (otherwise, server would try to message this client)
 
-	        this.#clients.delete(ws.clientId);
-	        this.#rateLimits.delete(ws.clientId);
+	        if (ws.willfulDisconnect) {
+	            this.#disconnectClient(ws); // Immediate disconnection
+	        } else {
+	            // Pending complete disconnection with 2s grace period to allow for reconnections
+	            this.#pendingDisconnects.set(ws.clientId, {
+	                timeout: setTimeout(() => {
+	                    this.#disconnectClient(ws);
+	                }, 2000)
+	            });
+	        }
+	    }
 
+	    /**
+	     * Disconnect a client
+	     * @private
+	     * @param {Object} ws 
+	     */
+	    #disconnectClient(ws) {
+	        this.#pendingDisconnects.delete(ws.clientId);
+	        this.#rateLimits.delete(ws.clientId);
+	        this.#clientTokens.delete(ws.clientId);
 	        const roomId = this.#clientRooms.get(ws.clientId);
-	        const room = roomId ? this.#rooms[roomId] : null;
+	        const room = this.#rooms[roomId];
 
 	        if (room) {
-	            room.participants = room.participants?.filter(p => p !== ws.clientId);
+	            room.participants = room.participants.filter(p => p !== ws.clientId); // Remove client from room
 	            this.#clientRooms.delete(ws.clientId);
 
-	            // Notify remaining participants
-	            room.participants?.forEach(p => {
-	                const client = this.#clients.get(p);
-	                if (client) {
-	                    try {
-	                        client.send(JSON.stringify({
-	                            type: 'client_disconnected',
-	                            updatedHost: room.participants?.[0],
-	                            client: ws.clientId,
-	                            participantCount: room.participants?.length
-	                        }));
-	                    } catch (error) {
-	                        console.error(`Error notifying client of disconnection:`, error);
-	                    }
-	                }
-	            });
-	            if (room.participants?.length === 0) delete this.#rooms[roomId]; // Delete room if now empty
+	            if (room.participants?.length === 0) {
+	                delete this.#rooms[roomId]; // Delete room if now empty
+	            } else {
+	                // Notify remaining participants
+	                room.participants.forEach(p => {
+	                    const client = this.#clients.get(p);
+	                    if (client) client.send(JSON.stringify({
+	                        type: 'client_disconnected',
+	                        client: ws.clientId,
+	                        host: room.participants[0],
+	                        participantCount: room.participants.length
+	                    }));
+	                });
+	            }
 	        }
 
 	        this.#triggerEvent("clientDisconnected", ws.clientId);
@@ -354,6 +459,9 @@ function requireServer () {
 	                console.log('PlaySocket server stopped');
 	            });
 	        }
+	        this.#pendingDisconnects.forEach((data) => {
+	            clearTimeout(data.timeout);
+	        });
 	    }
 
 	    get getRooms() { return { ...this.#rooms } }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playsocketjs",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "WebSocket wrapper for creating simple multiplayer systems with ease.",
   "module": "dist/playsocket-client.js",
   "exports": {