@eleven-am/pondsocket 0.1.191 → 0.1.192

package/abstracts/redisClient.js

@@ -33,7 +33,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _RedisClient_instances, _RedisClient_heartbeatInterval, _RedisClient_cleanupInterval, _RedisClient_instanceTtl, _RedisClient_redisClient, _RedisClient_pubClient, _RedisClient_subClient, _RedisClient_instanceId, _RedisClient_assignsPublisher, _RedisClient_presencePublisher, _RedisClient_userLeavesPublisher, _RedisClient_channelMessagePublisher, _RedisClient_stateSyncPublisher, _RedisClient_heartbeatTimer, _RedisClient_cleanupTimer, _RedisClient_presence_changes_channel_get, _RedisClient_assigns_changes_channel_get, _RedisClient_channel_messages_channel_get, _RedisClient_user_leaves_channel_get, _RedisClient_handleErrors, _RedisClient_getPresenceCacheChannel, _RedisClient_getAssignsCacheChannel, _RedisClient_publishPresenceChange, _RedisClient_publishAssignsChange, _RedisClient_publishChannelMessage, _RedisClient_publishUserLeave, _RedisClient_registerInstance, _RedisClient_unregisterInstance, _RedisClient_unsubscribeFromChannels, _RedisClient_subscribeToChannels, _RedisClient_startHeartbeat, _RedisClient_startPeriodicCleanup, _RedisClient_performConsistencyCheck, _RedisClient_handleRedisMessage, _RedisClient_publishCacheMessage, _RedisClient_emitStateSyncEvent, _RedisClient_subscribeToCacheChanges, _RedisClient_subscribeToChannelMessages, _RedisClient_subscribeToUserLeaves, _RedisClient_subscribeToStateSync, _RedisClient_handleExit, _RedisClient_deleteKeysByPattern, _RedisClient_generateCache;
+var _RedisClient_instances, _RedisClient_heartbeatInterval, _RedisClient_cleanupInterval, _RedisClient_instanceTtl, _RedisClient_redisClient, _RedisClient_pubClient, _RedisClient_subClient, _RedisClient_instanceId, _RedisClient_assignsPublisher, _RedisClient_presencePublisher, _RedisClient_userLeavesPublisher, _RedisClient_channelMessagePublisher, _RedisClient_stateSyncPublisher, _RedisClient_heartbeatTimer, _RedisClient_cleanupTimer, _RedisClient_presence_changes_channel_get, _RedisClient_assigns_changes_channel_get, _RedisClient_channel_messages_channel_get, _RedisClient_user_leaves_channel_get, _RedisClient_handleErrors, _RedisClient_registerInstance, _RedisClient_unregisterInstance, _RedisClient_cleanupDisconnectedClients, _RedisClient_getAllInstanceIds, _RedisClient_startPeriodicCleanup, _RedisClient_startHeartbeat, _RedisClient_performHeartbeat, _RedisClient_unsubscribeFromChannels, _RedisClient_subscribeToChannels, _RedisClient_handleRedisMessage, _RedisClient_getPresenceCacheChannel, _RedisClient_getAssignsCacheChannel, _RedisClient_subscribeToCacheChanges, _RedisClient_subscribeToChannelMessages, _RedisClient_subscribeToUserLeaves, _RedisClient_subscribeToStateSync, _RedisClient_publishPresenceChange, _RedisClient_publishAssignsChange, _RedisClient_publishChannelMessage, _RedisClient_publishUserLeave, _RedisClient_publishCacheMessage, _RedisClient_emitStateSyncEvent, _RedisClient_generateCache, _RedisClient_handleExit;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -97,12 +97,10 @@ class RedisClient {
     }
     shutdown() {
         return __awaiter(this, void 0, void 0, function* () {
-            const batchSize = 1000;
             clearInterval(__classPrivateFieldGet(this, _RedisClient_heartbeatTimer, "f"));
             clearInterval(__classPrivateFieldGet(this, _RedisClient_cleanupTimer, "f"));
             yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_unsubscribeFromChannels).call(this);
             yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_unregisterInstance).call(this);
-            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_deleteKeysByPattern).call(this, `*_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:*`, batchSize);
         });
     }
 }
@@ -119,53 +117,14 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
     __classPrivateFieldGet(this, _RedisClient_redisClient, "f").on('error', (err) => console.error('Redis client error:', err));
     __classPrivateFieldGet(this, _RedisClient_pubClient, "f").on('error', (err) => console.error('Redis pub client error:', err));
     __classPrivateFieldGet(this, _RedisClient_subClient, "f").on('error', (err) => console.error('Redis sub client error:', err));
-}, _RedisClient_getPresenceCacheChannel = function _RedisClient_getPresenceCacheChannel(endpointId, channelId) {
-    return `presence_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:${endpointId}:${channelId}`;
-}, _RedisClient_getAssignsCacheChannel = function _RedisClient_getAssignsCacheChannel(endpointId, channelId) {
-    return `assigns_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:${endpointId}:${channelId}`;
-}, _RedisClient_publishPresenceChange = function _RedisClient_publishPresenceChange(endpointId, channelId, userId, state) {
-    const message = {
-        userId,
-        channelId,
-        endpointId,
-        state,
-    };
-    const key = __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_presence_changes_channel_get);
-    const cacheKey = __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getPresenceCacheChannel).call(this, message.endpointId, message.channelId);
-    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishCacheMessage).call(this, key, cacheKey, message);
-}, _RedisClient_publishAssignsChange = function _RedisClient_publishAssignsChange(endpointId, channelId, userId, state) {
-    const message = {
-        userId,
-        channelId,
-        endpointId,
-        state,
-    };
-    const key = __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_assigns_changes_channel_get);
-    const cacheKey = __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getAssignsCacheChannel).call(this, message.endpointId, message.channelId);
-    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishCacheMessage).call(this, key, cacheKey, message);
-}, _RedisClient_publishChannelMessage = function _RedisClient_publishChannelMessage(endpointId, channelId, message) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const messageData = JSON.stringify({
-            endpointId,
-            channelId,
-            message,
-        });
-        yield __classPrivateFieldGet(this, _RedisClient_pubClient, "f").publish(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_channel_messages_channel_get), messageData);
-    });
-}, _RedisClient_publishUserLeave = function _RedisClient_publishUserLeave(endpointId, channelId, userId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const message = JSON.stringify({
-            endpointId,
-            channelId,
-            userId,
-        });
-        yield __classPrivateFieldGet(this, _RedisClient_pubClient, "f").publish(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get), message);
-    });
 }, _RedisClient_registerInstance = function _RedisClient_registerInstance() {
     return __awaiter(this, void 0, void 0, function* () {
         const multi = __classPrivateFieldGet(this, _RedisClient_redisClient, "f").multi();
-        multi.sadd('distributed_instances', __classPrivateFieldGet(this, _RedisClient_instanceId, "f"));
-        multi.set(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, Date.now().toString(), 'EX', __classPrivateFieldGet(this, _RedisClient_instanceTtl, "f"));
+        const now = Date.now().toString();
+        multi
+            .sadd('distributed_instances', __classPrivateFieldGet(this, _RedisClient_instanceId, "f"))
+            .set(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, now, 'EX', __classPrivateFieldGet(this, _RedisClient_instanceTtl, "f"))
+            .hset(`instance_metadata:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, 'last_seen', now);
         try {
             yield multi.exec();
         }
@@ -174,73 +133,233 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
         }
     });
 }, _RedisClient_unregisterInstance = function _RedisClient_unregisterInstance() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const multi = __classPrivateFieldGet(this, _RedisClient_redisClient, "f").multi();
-        multi.srem('distributed_instances', __classPrivateFieldGet(this, _RedisClient_instanceId, "f"));
-        multi.del(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`);
+    return __awaiter(this, arguments, void 0, function* (instanceId = __classPrivateFieldGet(this, _RedisClient_instanceId, "f")) {
+        const script = `
+            -- Remove instance registration
+            redis.call('SREM', 'distributed_instances', ARGV[1])
+            redis.call('DEL', 'heartbeat:' .. ARGV[1])
+            redis.call('DEL', 'instance_metadata:' .. ARGV[1])
+            
+            -- Delete all cache keys in one SCAN operation
+            local cursor = '0'
+            repeat
+                local result = redis.call('SCAN', cursor, 'MATCH', '{presence_cache,assigns_cache}:' .. ARGV[1] .. ':*', 'COUNT', 100)
+                cursor = result[1]
+                local keys = result[2]
+                if #keys > 0 then
+                    redis.call('DEL', unpack(keys))
+                end
+            until cursor == '0'
+            
+            return 1
+        `;
         try {
-            yield multi.exec();
+            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0, instanceId);
         }
         catch (_a) {
             // no-op as we're shutting down
         }
     });
-}, _RedisClient_unsubscribeFromChannels = function _RedisClient_unsubscribeFromChannels() {
+}, _RedisClient_cleanupDisconnectedClients = function _RedisClient_cleanupDisconnectedClients() {
     return __awaiter(this, void 0, void 0, function* () {
-        yield __classPrivateFieldGet(this, _RedisClient_subClient, "f").unsubscribe(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_presence_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_assigns_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_channel_messages_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get));
-    });
-}, _RedisClient_subscribeToChannels = function _RedisClient_subscribeToChannels() {
-    return new Promise((resolve, reject) => {
-        __classPrivateFieldGet(this, _RedisClient_subClient, "f").subscribe(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_presence_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_assigns_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_channel_messages_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get), (err) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve();
+        const script = `
+            -- Helper function to check if instance is alive
+            local function is_instance_alive(instance_id)
+                local heartbeat = redis.call('GET', 'heartbeat:' .. instance_id)
+                local in_set = redis.call('SISMEMBER', 'distributed_instances', instance_id)
+                return heartbeat and in_set == 1
+            end
+    
+            -- Get array of instance IDs passed as argument
+            local instance_ids = cjson.decode(ARGV[1])
+            
+            -- Track affected channels and keys to delete
+            local affected_channels = {}
+            local keys_to_delete = {}
+            local batch_size = 100
+            
+            -- Process each instance
+            for _, instance_id in ipairs(instance_ids) do
+                -- If instance is not alive, clean it up
+                if not is_instance_alive(instance_id) then
+                    -- Queue instance metadata keys for deletion
+                    table.insert(keys_to_delete, 'heartbeat:' .. instance_id)
+                    table.insert(keys_to_delete, 'instance_metadata:' .. instance_id)
+                    
+                    -- Remove from distributed_instances
+                    redis.call('SREM', 'distributed_instances', instance_id)
+                    
+                    -- Find and process all cache keys for this instance
+                    local cache_cursor = '0'
+                    repeat
+                        local result = redis.call('SCAN', cache_cursor, 'MATCH', '*_cache:' .. instance_id .. ':*', 'COUNT', batch_size)
+                        cache_cursor = result[1]
+                        
+                        for _, key in ipairs(result[2]) do
+                            -- Extract channel info before deletion
+                            local _, _, endpoint_id, channel_id = string.match(key, '_cache:[^:]+:([^:]+):([^:]+)')
+                            if endpoint_id and channel_id then
+                                affected_channels[endpoint_id .. ":" .. channel_id] = true
+                            end
+                            
+                            -- Add to deletion batch
+                            table.insert(keys_to_delete, key)
+                            
+                            -- If batch is full, process it
+                            if #keys_to_delete >= batch_size then
+                                redis.call('DEL', unpack(keys_to_delete))
+                                keys_to_delete = {}
+                            end
+                        end
+                    until cache_cursor == '0'
+                end
+            end
+            
+            -- Delete any remaining keys
+            if #keys_to_delete > 0 then
+                redis.call('DEL', unpack(keys_to_delete))
+            end
+            
+            -- Convert affected_channels to array
+            local channels = {}
+            for pair in pairs(affected_channels) do
+                table.insert(channels, pair)
+            end
+            
+            return channels
+        `;
+        try {
+            // Get all instance IDs first
+            const instanceIds = yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getAllInstanceIds).call(this);
+            // Run cleanup script with the instance IDs
+            const affectedChannels = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0, JSON.stringify(instanceIds));
+            // Process affected channels
+            if (affectedChannels.length > 0) {
+                const promises = affectedChannels.map((pair) => {
+                    const [endpointId, channelId] = pair.split(':');
+                    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpointId, channelId);
+                });
+                yield Promise.all(promises);
             }
-        });
-        __classPrivateFieldGet(this, _RedisClient_subClient, "f").on('message', __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleRedisMessage).bind(this));
+        }
+        catch (error) {
+            console.error('Error cleaning up disconnected clients:', error);
+        }
     });
-}, _RedisClient_startHeartbeat = function _RedisClient_startHeartbeat() {
-    __classPrivateFieldSet(this, _RedisClient_heartbeatTimer, setInterval(() => __awaiter(this, void 0, void 0, function* () {
+}, _RedisClient_getAllInstanceIds = function _RedisClient_getAllInstanceIds() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const script = `
+            local instance_ids = {}
+            local seen = {}  -- For deduplication
+            
+            -- 1. Get instances from distributed_instances set
+            local registered = redis.call('SMEMBERS', 'distributed_instances')
+            for _, id in ipairs(registered) do
+                if not seen[id] then
+                    seen[id] = true
+                    table.insert(instance_ids, id)
+                end
+            end
+            
+            -- 2. Get instances from heartbeat keys
+            local cursor = '0'
+            repeat
+                local result = redis.call('SCAN', cursor, 'MATCH', 'heartbeat:*', 'COUNT', 100)
+                cursor = result[1]
+                local keys = result[2]
+                
+                for _, key in ipairs(keys) do
+                    local id = string.match(key, 'heartbeat:([^:]+)')
+                    if id and not seen[id] then
+                        seen[id] = true
+                        table.insert(instance_ids, id)
+                    end
+                end
+            until cursor == '0'
+            
+            -- 3. Get instances from metadata keys
+            cursor = '0'
+            repeat
+                local result = redis.call('SCAN', cursor, 'MATCH', 'instance_metadata:*', 'COUNT', 100)
+                cursor = result[1]
+                local keys = result[2]
+                
+                for _, key in ipairs(keys) do
+                    local id = string.match(key, 'instance_metadata:([^:]+)')
+                    if id and not seen[id] then
+                        seen[id] = true
+                        table.insert(instance_ids, id)
+                    end
+                end
+            until cursor == '0'
+            
+            -- 4. Get instances from cache keys
+            cursor = '0'
+            repeat
+                local result = redis.call('SCAN', cursor, 'MATCH', '*_cache:*', 'COUNT', 100)
+                cursor = result[1]
+                local keys = result[2]
+                
+                for _, key in ipairs(keys) do
+                    local id = string.match(key, '_cache:([^:]+)')
+                    if id and not seen[id] then
+                        seen[id] = true
+                        table.insert(instance_ids, id)
+                    end
+                end
+            until cursor == '0'
+            
+            return instance_ids
+        `;
+        let response = [];
         try {
-            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").set(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, Date.now().toString(), 'EX', __classPrivateFieldGet(this, _RedisClient_instanceTtl, "f"));
+            response = (yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0));
         }
         catch (error) {
-            throw new redisError_1.RedisError('Error setting heartbeat');
+            console.error('Error getting all instance IDs:', error);
         }
-    }), __classPrivateFieldGet(this, _RedisClient_heartbeatInterval, "f")), "f");
+        return response;
+    });
 }, _RedisClient_startPeriodicCleanup = function _RedisClient_startPeriodicCleanup() {
     __classPrivateFieldSet(this, _RedisClient_cleanupTimer, setInterval(() => __awaiter(this, void 0, void 0, function* () {
         try {
-            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_performConsistencyCheck).call(this);
+            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_cleanupDisconnectedClients).call(this);
         }
         catch (error) {
-            throw new redisError_1.RedisError('Error performing consistency check');
+            console.error('Error in periodic cleanup:', error);
         }
     }), __classPrivateFieldGet(this, _RedisClient_cleanupInterval, "f")), "f");
-}, _RedisClient_performConsistencyCheck = function _RedisClient_performConsistencyCheck() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const activeInstances = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").smembers('distributed_instances');
-        const allKeys = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").keys('*_cache:*');
-        const activeSet = new Set(activeInstances);
-        const inactiveKeys = [];
-        const uniquePairs = new Set();
-        for (const key of allKeys) {
-            const [, instanceId, endpointId, channelId] = key.split(':');
-            if (!activeSet.has(instanceId)) {
-                inactiveKeys.push(key);
-                uniquePairs.add(`${endpointId}:${channelId}`);
-            }
+}, _RedisClient_startHeartbeat = function _RedisClient_startHeartbeat() {
+    __classPrivateFieldSet(this, _RedisClient_heartbeatTimer, setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_performHeartbeat).call(this);
         }
-        if (inactiveKeys.length > 0) {
-            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").del(...inactiveKeys);
+        catch (error) {
+            console.error('Error performing heartbeat:', error);
         }
-        const promises = Array.from(uniquePairs).map((pair) => {
-            const [endpointId, channelId] = pair.split(':');
-            return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpointId, channelId);
+    }), __classPrivateFieldGet(this, _RedisClient_heartbeatInterval, "f")), "f");
+}, _RedisClient_performHeartbeat = function _RedisClient_performHeartbeat() {
+    const now = Date.now().toString();
+    const multi = __classPrivateFieldGet(this, _RedisClient_redisClient, "f").multi();
+    multi
+        .set(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, now, 'EX', __classPrivateFieldGet(this, _RedisClient_instanceTtl, "f"))
+        .hset(`instance_metadata:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, 'last_seen', now);
+    return multi.exec();
+}, _RedisClient_unsubscribeFromChannels = function _RedisClient_unsubscribeFromChannels() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield __classPrivateFieldGet(this, _RedisClient_subClient, "f").unsubscribe(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_presence_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_assigns_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_channel_messages_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get));
+    });
+}, _RedisClient_subscribeToChannels = function _RedisClient_subscribeToChannels() {
+    return new Promise((resolve, reject) => {
+        __classPrivateFieldGet(this, _RedisClient_subClient, "f").subscribe(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_presence_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_assigns_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_channel_messages_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get), (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
         });
-        yield Promise.all(promises);
+        __classPrivateFieldGet(this, _RedisClient_subClient, "f").on('message', __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleRedisMessage).bind(this));
     });
 }, _RedisClient_handleRedisMessage = function _RedisClient_handleRedisMessage(channel, message) {
     const data = JSON.parse(message);
@@ -260,6 +379,81 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
         default:
             throw new Error(`Unknown channel: ${channel}`);
     }
+}, _RedisClient_getPresenceCacheChannel = function _RedisClient_getPresenceCacheChannel(endpointId, channelId) {
+    return `presence_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:${endpointId}:${channelId}`;
+}, _RedisClient_getAssignsCacheChannel = function _RedisClient_getAssignsCacheChannel(endpointId, channelId) {
+    return `assigns_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:${endpointId}:${channelId}`;
+}, _RedisClient_subscribeToCacheChanges = function _RedisClient_subscribeToCacheChanges(endpoint, channel, presence, callback) {
+    const subject = presence ? __classPrivateFieldGet(this, _RedisClient_presencePublisher, "f") : __classPrivateFieldGet(this, _RedisClient_assignsPublisher, "f");
+    return subject.subscribe((_a) => {
+        var { endpointId, channelId } = _a, data = __rest(_a, ["endpointId", "channelId"]);
+        if (endpointId === endpoint && channelId === channel) {
+            return callback(data);
+        }
+    });
+}, _RedisClient_subscribeToChannelMessages = function _RedisClient_subscribeToChannelMessages(endpoint, channel, callback) {
+    return __classPrivateFieldGet(this, _RedisClient_channelMessagePublisher, "f").subscribe(({ endpointId, channelId, message }) => {
+        if (endpointId === endpoint && channelId === channel) {
+            return callback(message);
+        }
+    });
+}, _RedisClient_subscribeToUserLeaves = function _RedisClient_subscribeToUserLeaves(endpoint, channel, callback) {
+    return __classPrivateFieldGet(this, _RedisClient_userLeavesPublisher, "f").subscribe(({ endpointId, channelId, userId }) => {
+        if (endpointId === endpoint && channelId === channel) {
+            return callback(userId);
+        }
+    });
+}, _RedisClient_subscribeToStateSync = function _RedisClient_subscribeToStateSync(endpoint, channel, callback) {
+    const interval = setInterval(() => __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpoint, channel), __classPrivateFieldGet(this, _RedisClient_heartbeatInterval, "f") * 10);
+    const subscription = __classPrivateFieldGet(this, _RedisClient_stateSyncPublisher, "f").subscribe((_a) => {
+        var { endpointId, channelId } = _a, data = __rest(_a, ["endpointId", "channelId"]);
+        if (endpointId === endpoint && channelId === channel) {
+            return callback(data);
+        }
+    });
+    void __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpoint, channel, true);
+    return () => {
+        clearInterval(interval);
+        subscription();
+    };
+}, _RedisClient_publishPresenceChange = function _RedisClient_publishPresenceChange(endpointId, channelId, userId, state) {
+    const message = {
+        userId,
+        channelId,
+        endpointId,
+        state,
+    };
+    const key = __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_presence_changes_channel_get);
+    const cacheKey = __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getPresenceCacheChannel).call(this, message.endpointId, message.channelId);
+    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishCacheMessage).call(this, key, cacheKey, message);
+}, _RedisClient_publishAssignsChange = function _RedisClient_publishAssignsChange(endpointId, channelId, userId, state) {
+    const message = {
+        userId,
+        channelId,
+        endpointId,
+        state,
+    };
+    const key = __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_assigns_changes_channel_get);
+    const cacheKey = __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getAssignsCacheChannel).call(this, message.endpointId, message.channelId);
+    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishCacheMessage).call(this, key, cacheKey, message);
+}, _RedisClient_publishChannelMessage = function _RedisClient_publishChannelMessage(endpointId, channelId, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const messageData = JSON.stringify({
+            endpointId,
+            channelId,
+            message,
+        });
+        yield __classPrivateFieldGet(this, _RedisClient_pubClient, "f").publish(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_channel_messages_channel_get), messageData);
+    });
+}, _RedisClient_publishUserLeave = function _RedisClient_publishUserLeave(endpointId, channelId, userId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const message = JSON.stringify({
+            endpointId,
+            channelId,
+            userId,
+        });
+        yield __classPrivateFieldGet(this, _RedisClient_pubClient, "f").publish(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get), message);
+    });
 }, _RedisClient_publishCacheMessage = function _RedisClient_publishCacheMessage(key, cacheKey, message) {
     return __awaiter(this, void 0, void 0, function* () {
         const script = `
@@ -269,6 +463,8 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
             
             if state ~= '' then
                 redis.call('HSET', KEYS[1], userId, state)
+                -- Set TTL on cache key
+                redis.call('EXPIRE', KEYS[1], ${__classPrivateFieldGet(this, _RedisClient_instanceTtl, "f")})
             else
                 redis.call('HDEL', KEYS[1], userId)
             end
@@ -284,23 +480,45 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
 }, _RedisClient_emitStateSyncEvent = function _RedisClient_emitStateSyncEvent(endpointId_1, channelId_1) {
     return __awaiter(this, arguments, void 0, function* (endpointId, channelId, initialFetch = false) {
         const script = `
+            -- Helper function to check if an instance is truly alive
+            -- Returns true only if:
+            -- 1. Instance has a valid heartbeat AND
+            -- 2. Instance is in the distributed_instances set
+            local function is_instance_alive(instance_id)
+                -- Both checks in one atomic operation
+                local exists = redis.call('EXISTS', 'heartbeat:' .. instance_id)
+                if exists == 0 then
+                    return false
+                end
+                
+                local is_registered = redis.call('SISMEMBER', 'distributed_instances', instance_id)
+                return is_registered == 1
+            end
+    
+            -- Get all registered instances
             local active_instances = redis.call('SMEMBERS', 'distributed_instances')
             local presence_data = {}
             local assigns_data = {}
             
             for _, instance in ipairs(active_instances) do
-                local presence_key = 'presence_cache:' .. instance .. ':' .. ARGV[1] .. ':' .. ARGV[2]
-                local assigns_key = 'assigns_cache:' .. instance .. ':' .. ARGV[1] .. ':' .. ARGV[2]
-                
-                local presence = redis.call('HGETALL', presence_key)
-                local assigns = redis.call('HGETALL', assigns_key)
-                
-                for i = 1, #presence, 2 do
-                    presence_data[presence[i]] = presence[i+1]
-                end
-                
-                for i = 1, #assigns, 2 do
-                    assigns_data[assigns[i]] = assigns[i+1]
+                -- Only process data from instances that are truly alive
+                if is_instance_alive(instance) then
+                    local presence_key = 'presence_cache:' .. instance .. ':' .. ARGV[1] .. ':' .. ARGV[2]
+                    local assigns_key = 'assigns_cache:' .. instance .. ':' .. ARGV[1] .. ':' .. ARGV[2]
+                    
+                    -- Fetch data atomically for this instance
+                    local presence = redis.call('HGETALL', presence_key)
+                    local assigns = redis.call('HGETALL', assigns_key)
+                    
+                    -- Process presence data
+                    for i = 1, #presence, 2 do
+                        presence_data[presence[i]] = presence[i+1]
+                    end
+                    
+                    -- Process assigns data
+                    for i = 1, #assigns, 2 do
+                        assigns_data[assigns[i]] = assigns[i+1]
+                    end
                 end
             end
             
@@ -316,39 +534,10 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
         };
         __classPrivateFieldGet(this, _RedisClient_stateSyncPublisher, "f").publish(event);
     });
-}, _RedisClient_subscribeToCacheChanges = function _RedisClient_subscribeToCacheChanges(endpoint, channel, presence, callback) {
-    const subject = presence ? __classPrivateFieldGet(this, _RedisClient_presencePublisher, "f") : __classPrivateFieldGet(this, _RedisClient_assignsPublisher, "f");
-    return subject.subscribe((_a) => {
-        var { endpointId, channelId } = _a, data = __rest(_a, ["endpointId", "channelId"]);
-        if (endpointId === endpoint && channelId === channel) {
-            return callback(data);
-        }
-    });
-}, _RedisClient_subscribeToChannelMessages = function _RedisClient_subscribeToChannelMessages(endpoint, channel, callback) {
-    return __classPrivateFieldGet(this, _RedisClient_channelMessagePublisher, "f").subscribe(({ endpointId, channelId, message }) => {
-        if (endpointId === endpoint && channelId === channel) {
-            return callback(message);
-        }
-    });
-}, _RedisClient_subscribeToUserLeaves = function _RedisClient_subscribeToUserLeaves(endpoint, channel, callback) {
-    return __classPrivateFieldGet(this, _RedisClient_userLeavesPublisher, "f").subscribe(({ endpointId, channelId, userId }) => {
-        if (endpointId === endpoint && channelId === channel) {
-            return callback(userId);
-        }
-    });
-}, _RedisClient_subscribeToStateSync = function _RedisClient_subscribeToStateSync(endpoint, channel, callback) {
-    const interval = setInterval(() => __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpoint, channel), __classPrivateFieldGet(this, _RedisClient_heartbeatInterval, "f") * 10);
-    const subscription = __classPrivateFieldGet(this, _RedisClient_stateSyncPublisher, "f").subscribe((_a) => {
-        var { endpointId, channelId } = _a, data = __rest(_a, ["endpointId", "channelId"]);
-        if (endpointId === endpoint && channelId === channel) {
-            return callback(data);
-        }
-    });
-    void __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpoint, channel, true);
-    return () => {
-        clearInterval(interval);
-        subscription();
-    };
+}, _RedisClient_generateCache = function _RedisClient_generateCache(data) {
+    const first = Object.entries(JSON.parse(data));
+    const second = first.map(([key, value]) => [key, JSON.parse(String(value))]);
+    return new Map(second);
 }, _RedisClient_handleExit = function _RedisClient_handleExit() {
     return __awaiter(this, void 0, void 0, function* () {
         try {
@@ -359,19 +548,4 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
             process.exit(1);
         }
     });
-}, _RedisClient_deleteKeysByPattern = function _RedisClient_deleteKeysByPattern(pattern, batchSize) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let cursor = '0';
-        do {
-            const [newCursor, keys] = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").scan(cursor, 'MATCH', pattern, 'COUNT', batchSize);
-            cursor = newCursor;
-            if (keys.length > 0) {
-                yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").del(...keys);
-            }
-        } while (cursor !== '0');
-    });
-}, _RedisClient_generateCache = function _RedisClient_generateCache(data) {
-    const first = Object.entries(JSON.parse(data));
-    const second = first.map(([key, value]) => [key, JSON.parse(String(value))]);
-    return new Map(second);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.191",
+  "version": "0.1.192",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -35,32 +35,36 @@
   },
   "dependencies": {
     "@eleven-am/pondsocket-common": "^0.0.26",
-    "ioredis": "^5.4.2",
-    "ws": "^8.18.0"
+    "ioredis": "^5.5.0",
+    "ws": "^8.18.1"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin-ts": "^2.10.1",
+    "@eslint/compat": "^1.2.7",
+    "@eslint/eslintrc": "^3.3.0",
+    "@eslint/js": "^9.21.0",
+    "@stylistic/eslint-plugin-ts": "^4.0.1",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.8.7",
-    "@types/ws": "^8.5.13",
-    "@typescript-eslint/eslint-plugin": "^8.11.0",
-    "@typescript-eslint/parser": "^8.11.0",
-    "eslint": "^8.57.1",
-    "eslint-config-prettier": "^9.1.0",
+    "@types/node": "^22.13.5",
+    "@types/ws": "^8.5.14",
+    "@typescript-eslint/eslint-plugin": "^8.24.1",
+    "@typescript-eslint/parser": "^8.24.1",
+    "eslint": "^9.21.0",
+    "eslint-config-prettier": "^10.0.1",
     "eslint-import-resolver-node": "^0.3.9",
-    "eslint-plugin-file-progress": "^1.5.0",
+    "eslint-plugin-file-progress": "^3.0.1",
     "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-prettier": "^5.2.3",
+    "globals": "^16.0.0",
     "jest": "^29.7.0",
-    "nodemon": "^3.1.7",
-    "prettier": "^3.3.3",
+    "nodemon": "^3.1.9",
+    "prettier": "^3.5.2",
     "source-map-support": "^0.5.21",
     "supertest": "^7.0.0",
     "ts-jest": "^29.2.5",
-    "ts-loader": "^9.5.1",
+    "ts-loader": "^9.5.2",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.6.3"
+    "typescript": "^5.7.3"
   },
   "jest": {
     "moduleFileExtensions": [