@eleven-am/pondsocket 0.1.192 → 0.1.194

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_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;
+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");
@@ -73,15 +78,15 @@ class RedisClient {
     buildClient(endpointId) {
         return (channelId) => ({
             channelId,
-            publishPresenceChange: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishPresenceChange).bind(this, endpointId, channelId),
+            publishUserLeave: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishUserLeave).bind(this, endpointId, channelId),
+            subscribeToStateSync: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToStateSync).bind(this, endpointId, channelId),
             publishAssignsChange: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishAssignsChange).bind(this, endpointId, channelId),
+            publishPresenceChange: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishPresenceChange).bind(this, endpointId, channelId),
             publishChannelMessage: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishChannelMessage).bind(this, endpointId, channelId),
-            publishUserLeave: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishUserLeave).bind(this, endpointId, channelId),
             subscribeToUserLeaves: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToUserLeaves).bind(this, endpointId, channelId),
+            subscribeToChannelMessages: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToChannelMessages).bind(this, endpointId, channelId),
             subscribeToPresenceChanges: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToCacheChanges).bind(this, endpointId, channelId, true),
             subscribeToAssignsChanges: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToCacheChanges).bind(this, endpointId, channelId, false),
-            subscribeToChannelMessages: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToChannelMessages).bind(this, endpointId, channelId),
-            subscribeToStateSync: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToStateSync).bind(this, endpointId, channelId),
         });
     }
     initialize() {
@@ -105,7 +110,7 @@ class RedisClient {
     }
 }
 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,31 +124,24 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
     __classPrivateFieldGet(this, _RedisClient_subClient, "f").on('error', (err) => console.error('Redis sub client error:', err));
 }, _RedisClient_registerInstance = function _RedisClient_registerInstance() {
     return __awaiter(this, void 0, void 0, function* () {
-        const multi = __classPrivateFieldGet(this, _RedisClient_redisClient, "f").multi();
-        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();
+            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, arguments, void 0, function* (instanceId = __classPrivateFieldGet(this, _RedisClient_instanceId, "f")) {
         const script = `
-            -- Remove instance registration
-            redis.call('SREM', 'distributed_instances', ARGV[1])
+            -- Delete heartbeat
             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)
+                local result = redis.call('SCAN', cursor, 'MATCH', '*_cache:' .. ARGV[1] .. ':*', 'COUNT', 100)
                 cursor = result[1]
                 local keys = result[2]
                 if #keys > 0 then
@@ -163,56 +161,37 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
 }, _RedisClient_cleanupDisconnectedClients = function _RedisClient_cleanupDisconnectedClients() {
     return __awaiter(this, void 0, void 0, function* () {
         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
+            -- 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 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)
+            -- 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]
                     
-                    -- 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
                         
-                        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
+                        -- 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
-                    until cache_cursor == '0'
-                end
+                    end
+                until cache_cursor == '0'
             end
             
             -- Delete any remaining keys
@@ -229,11 +208,15 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
             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
+            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;
+            }
+            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(':');
@@ -246,80 +229,6 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
             console.error('Error cleaning up disconnected clients:', error);
         }
     });
-}, _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 {
-            response = (yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0));
-        }
-        catch (error) {
-            console.error('Error getting all instance IDs:', error);
-        }
-        return response;
-    });
 }, _RedisClient_startPeriodicCleanup = function _RedisClient_startPeriodicCleanup() {
     __classPrivateFieldSet(this, _RedisClient_cleanupTimer, setInterval(() => __awaiter(this, void 0, void 0, function* () {
         try {
@@ -332,19 +241,12 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
 }, _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);
+            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_registerInstance).call(this);
         }
         catch (error) {
             console.error('Error performing heartbeat:', error);
         }
     }), __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));
@@ -404,7 +306,7 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
         }
     });
 }, _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 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) {
@@ -463,8 +365,6 @@ _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
@@ -480,59 +380,107 @@ _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
+            local instances = ARGV[1]
+            local presence_data = {}
+            local assigns_data = {}
+            
+            -- 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)
+                for i = 1, #presence, 2 do
+                    presence_data[presence[i]] = presence[i + 1]
                 end
                 
-                local is_registered = redis.call('SISMEMBER', 'distributed_instances', instance_id)
-                return is_registered == 1
+                -- 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]
+                end
             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
-                -- 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]
+            return {cjson.encode(presence_data), cjson.encode(assigns_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);
+        }
+        catch (error) {
+            console.error('Error emitting state sync event:', error);
+        }
+    });
+}, _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
-                    
-                    -- Process assigns data
-                    for i = 1, #assigns, 2 do
-                        assigns_data[assigns[i]] = assigns[i+1]
+                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_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
-            end
+            until cursor == '0'
             
-            return {cjson.encode(presence_data), cjson.encode(assigns_data)}
+            return cached_instances
         `;
-        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);
+        try {
+            return yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0);
+        }
+        catch (error) {
+            console.error('Error getting cached instances:', error);
+            return [];
+        }
     });
 }, _RedisClient_generateCache = function _RedisClient_generateCache(data) {
     const first = Object.entries(JSON.parse(data));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.192",
+  "version": "0.1.194",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -60,7 +60,7 @@
     "prettier": "^3.5.2",
     "source-map-support": "^0.5.21",
     "supertest": "^7.0.0",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.2.6",
     "ts-loader": "^9.5.2",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",

package/types.d.ts

@@ -24,8 +24,6 @@ export interface RedisOptions {
     username?: string;
     password?: string;
     instanceTtl?: number;
-    heartbeatInterval?: number;
-    cleanupInterval?: number;
 }
 
 export interface LeaveEvent<EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {