@eleven-am/pondsocket 0.1.191 → 0.1.193

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_stateSyncInterval, _RedisClient_ttlBuffer, _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_startPeriodicCleanup, _RedisClient_startHeartbeat, _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_getActiveInstances, _RedisClient_getCachedInstances, _RedisClient_generateCache, _RedisClient_handleExit;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -41,7 +41,7 @@ const ioredis_1 = __importDefault(require("ioredis"));
 const redisError_1 = require("../errors/redisError");
 class RedisClient {
     constructor(config) {
-        var _a, _b, _c;
+        var _a;
         _RedisClient_instances.add(this);
         _RedisClient_heartbeatInterval.set(this, void 0);
         _RedisClient_cleanupInterval.set(this, void 0);
@@ -57,9 +57,14 @@ class RedisClient {
         _RedisClient_stateSyncPublisher.set(this, void 0);
         _RedisClient_heartbeatTimer.set(this, void 0);
         _RedisClient_cleanupTimer.set(this, void 0);
-        __classPrivateFieldSet(this, _RedisClient_instanceTtl, (_a = config.instanceTtl) !== null && _a !== void 0 ? _a : 90, "f");
-        __classPrivateFieldSet(this, _RedisClient_heartbeatInterval, (_b = config.heartbeatInterval) !== null && _b !== void 0 ? _b : 10 * 1000, "f");
-        __classPrivateFieldSet(this, _RedisClient_cleanupInterval, (_c = config.cleanupInterval) !== null && _c !== void 0 ? _c : 60 * 1000, "f");
+        _RedisClient_stateSyncInterval.set(this, void 0);
+        _RedisClient_ttlBuffer.set(this, 5);
+        const baseTtl = (_a = config.instanceTtl) !== null && _a !== void 0 ? _a : 90;
+        const milliseconds = baseTtl * 1000;
+        __classPrivateFieldSet(this, _RedisClient_stateSyncInterval, milliseconds, "f");
+        __classPrivateFieldSet(this, _RedisClient_cleanupInterval, milliseconds * 2, "f");
+        __classPrivateFieldSet(this, _RedisClient_heartbeatInterval, milliseconds / 3, "f");
+        __classPrivateFieldSet(this, _RedisClient_instanceTtl, baseTtl + __classPrivateFieldGet(this, _RedisClient_ttlBuffer, "f"), "f");
         __classPrivateFieldSet(this, _RedisClient_redisClient, new ioredis_1.default(config), "f");
         __classPrivateFieldSet(this, _RedisClient_pubClient, new ioredis_1.default(config), "f");
         __classPrivateFieldSet(this, _RedisClient_subClient, new ioredis_1.default(config), "f");
@@ -97,17 +102,15 @@ 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);
         });
     }
 }
 exports.RedisClient = RedisClient;
-_RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = new WeakMap(), _RedisClient_instanceTtl = new WeakMap(), _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap(), _RedisClient_subClient = new WeakMap(), _RedisClient_instanceId = new WeakMap(), _RedisClient_assignsPublisher = new WeakMap(), _RedisClient_presencePublisher = new WeakMap(), _RedisClient_userLeavesPublisher = new WeakMap(), _RedisClient_channelMessagePublisher = new WeakMap(), _RedisClient_stateSyncPublisher = new WeakMap(), _RedisClient_heartbeatTimer = new WeakMap(), _RedisClient_cleanupTimer = new WeakMap(), _RedisClient_instances = new WeakSet(), _RedisClient_presence_changes_channel_get = function _RedisClient_presence_changes_channel_get() {
+_RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = new WeakMap(), _RedisClient_instanceTtl = new WeakMap(), _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap(), _RedisClient_subClient = new WeakMap(), _RedisClient_instanceId = new WeakMap(), _RedisClient_assignsPublisher = new WeakMap(), _RedisClient_presencePublisher = new WeakMap(), _RedisClient_userLeavesPublisher = new WeakMap(), _RedisClient_channelMessagePublisher = new WeakMap(), _RedisClient_stateSyncPublisher = new WeakMap(), _RedisClient_heartbeatTimer = new WeakMap(), _RedisClient_cleanupTimer = new WeakMap(), _RedisClient_stateSyncInterval = new WeakMap(), _RedisClient_ttlBuffer = new WeakMap(), _RedisClient_instances = new WeakSet(), _RedisClient_presence_changes_channel_get = function _RedisClient_presence_changes_channel_get() {
     return 'presence_changes';
 }, _RedisClient_assigns_changes_channel_get = function _RedisClient_assigns_changes_channel_get() {
     return 'assigns_changes';
@@ -119,128 +122,146 @@ _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"));
         try {
-            yield multi.exec();
+            const now = Date.now().toString();
+            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").set(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, now, 'EX', __classPrivateFieldGet(this, _RedisClient_instanceTtl, "f"));
         }
         catch (error) {
-            throw new redisError_1.RedisError('Error registering instance');
+            throw new redisError_1.RedisError(`Error registering instance: ${error}`);
         }
     });
 }, _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 = `
+            -- Delete heartbeat
+            redis.call('DEL', 'heartbeat:' .. ARGV[1])
+            
+            -- Delete all cache keys in one SCAN operation
+            local cursor = '0'
+            repeat
+                local result = redis.call('SCAN', cursor, 'MATCH', '*_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);
+        const script = `
+            -- Array of instance IDs that have cache data but no heartbeat
+            local dead_instances = cjson.decode(ARGV[1])
+            local affected_channels = {}
+            local keys_to_delete = {}
+            local batch_size = 100
+            
+            -- Process each dead instance
+            for _, instance_id in ipairs(dead_instances) do
+                -- 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
+            
+            -- 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 {
+            const [activeInstances, cachedInstances] = yield Promise.all([
+                __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getActiveInstances).call(this),
+                __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getCachedInstances).call(this),
+            ]);
+            const deadInstances = cachedInstances.filter((id) => !activeInstances.includes(id));
+            if (deadInstances.length === 0) {
+                return;
             }
-            else {
-                resolve();
+            const affectedChannels = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0, JSON.stringify(deadInstances));
+            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));
-    });
-}, _RedisClient_startHeartbeat = function _RedisClient_startHeartbeat() {
-    __classPrivateFieldSet(this, _RedisClient_heartbeatTimer, setInterval(() => __awaiter(this, void 0, void 0, function* () {
-        try {
-            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").set(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, Date.now().toString(), 'EX', __classPrivateFieldGet(this, _RedisClient_instanceTtl, "f"));
         }
         catch (error) {
-            throw new redisError_1.RedisError('Error setting heartbeat');
+            console.error('Error cleaning up disconnected clients:', error);
         }
-    }), __classPrivateFieldGet(this, _RedisClient_heartbeatInterval, "f")), "f");
+    });
 }, _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_registerInstance).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_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 +281,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_stateSyncInterval, "f"));
+    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 = `
@@ -284,71 +380,112 @@ _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 = `
-            local active_instances = redis.call('SMEMBERS', 'distributed_instances')
+            local instances = ARGV[1]
             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]
+            -- Parse instance IDs array
+            local instance_ids = cjson.decode(instances)
+            
+            for _, instance in ipairs(instance_ids) do
+                local presence_key = 'presence_cache:' .. instance .. ':' .. ARGV[2] .. ':' .. ARGV[3]
+                local assigns_key = 'assigns_cache:' .. instance .. ':' .. ARGV[2] .. ':' .. ARGV[3]
                 
+                -- Get all presence data for this instance and channel
                 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]
+                    presence_data[presence[i]] = presence[i + 1]
                 end
                 
+                -- Get all assigns data for this instance and channel
+                local assigns = redis.call('HGETALL', assigns_key)
                 for i = 1, #assigns, 2 do
-                    assigns_data[assigns[i]] = assigns[i+1]
+                    assigns_data[assigns[i]] = assigns[i + 1]
                 end
             end
             
             return {cjson.encode(presence_data), cjson.encode(assigns_data)}
         `;
-        const [presenceData, assignsData] = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0, endpointId, channelId);
-        const event = {
-            endpointId,
-            channelId,
-            initialFetch,
-            presence: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_generateCache).call(this, presenceData),
-            assigns: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_generateCache).call(this, assignsData),
-        };
-        __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);
+        try {
+            // Get active instances
+            const activeInstances = yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getActiveInstances).call(this);
+            // Get the data using our active instances
+            const [presenceData, assignsData] = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0, JSON.stringify(activeInstances), endpointId, channelId);
+            const event = {
+                endpointId,
+                channelId,
+                initialFetch,
+                presence: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_generateCache).call(this, presenceData),
+                assigns: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_generateCache).call(this, assignsData),
+            };
+            __classPrivateFieldGet(this, _RedisClient_stateSyncPublisher, "f").publish(event);
         }
-    });
-}, _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);
+        catch (error) {
+            console.error('Error emitting state sync event:', error);
         }
     });
-}, _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_getActiveInstances = function _RedisClient_getActiveInstances() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const script = `
+            local active_instances = {}
+            
+            local cursor = '0'
+            repeat
+                local result = redis.call('SCAN', cursor, 'MATCH', 'heartbeat:*', 'COUNT', 100)
+                cursor = result[1]
+                
+                for _, key in ipairs(result[2]) do
+                    local id = string.match(key, 'heartbeat:([^:]+)')
+                    if id then
+                        table.insert(active_instances, id)
+                    end
+                end
+            until cursor == '0'
+            
+            return active_instances
+        `;
+        try {
+            return yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0);
+        }
+        catch (error) {
+            console.error('Error getting active instances:', error);
+            return [];
         }
     });
-}, _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);
+}, _RedisClient_getCachedInstances = function _RedisClient_getCachedInstances() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const script = `
+            local seen = {}
+            local cached_instances = {}
+            
+            local cursor = '0'
+            repeat
+                local result = redis.call('SCAN', cursor, 'MATCH', '*_cache:*', 'COUNT', 100)
+                cursor = result[1]
+                
+                for _, key in ipairs(result[2]) do
+                    local id = string.match(key, '_cache:([^:]+)')
+                    if id and not seen[id] then
+                        seen[id] = true
+                        table.insert(cached_instances, id)
+                    end
+                end
+            until cursor == '0'
+            
+            return cached_instances
+        `;
+        try {
+            return yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0);
+        }
+        catch (error) {
+            console.error('Error getting cached instances:', error);
+            return [];
         }
     });
-    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 +496,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.193",
   "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-jest": "^29.2.6",
+    "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": [