@eleven-am/pondsocket 0.1.178 → 0.1.180

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_heartbeatTimer, _RedisClient_cleanupTimer, _RedisClient_presence_changes_channel_get, _RedisClient_assigns_changes_channel_get, _RedisClient_channel_messages_channel_get, _RedisClient_user_leaves_channel_get, _RedisClient_cleanup, _RedisClient_handleErrors, _RedisClient_getPresenceCacheChannel, _RedisClient_getAssignsCacheChannel, _RedisClient_publishPresenceChange, _RedisClient_publishAssignsChange, _RedisClient_publishChannelMessage, _RedisClient_publishUserLeave, _RedisClient_getPresenceCache, _RedisClient_getAssignsCache, _RedisClient_registerInstance, _RedisClient_unregisterInstance, _RedisClient_unsubscribeFromChannels, _RedisClient_subscribeToChannels, _RedisClient_startHeartbeat, _RedisClient_startPeriodicCleanup, _RedisClient_performConsistencyCheck, _RedisClient_getActiveInstances, _RedisClient_handleRedisMessage, _RedisClient_publishCacheMessage, _RedisClient_readCachedData, _RedisClient_subscribeToCacheChanges, _RedisClient_subscribeToChannelMessages, _RedisClient_subscribeToUserLeaves, _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_presence_changes_channel_get, _RedisClient_assigns_changes_channel_get, _RedisClient_channel_messages_channel_get, _RedisClient_user_leaves_channel_get, _RedisClient_cleanup, _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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -54,6 +54,7 @@ class RedisClient {
         _RedisClient_presencePublisher.set(this, void 0);
         _RedisClient_userLeavesPublisher.set(this, void 0);
         _RedisClient_channelMessagePublisher.set(this, void 0);
+        _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");
@@ -66,13 +67,12 @@ class RedisClient {
         __classPrivateFieldSet(this, _RedisClient_presencePublisher, new pondsocket_common_1.Subject(), "f");
         __classPrivateFieldSet(this, _RedisClient_userLeavesPublisher, new pondsocket_common_1.Subject(), "f");
         __classPrivateFieldSet(this, _RedisClient_channelMessagePublisher, new pondsocket_common_1.Subject(), "f");
+        __classPrivateFieldSet(this, _RedisClient_stateSyncPublisher, new pondsocket_common_1.Subject(), "f");
         __classPrivateFieldSet(this, _RedisClient_instanceId, (0, pondsocket_common_1.uuid)(), "f");
     }
     buildClient(endpointId) {
         return (channelId) => ({
             channelId,
-            getPresenceCache: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getPresenceCache).bind(this, endpointId, channelId),
-            getAssignsCache: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getAssignsCache).bind(this, endpointId, channelId),
             publishPresenceChange: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishPresenceChange).bind(this, endpointId, channelId),
             publishAssignsChange: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishAssignsChange).bind(this, endpointId, channelId),
             publishChannelMessage: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishChannelMessage).bind(this, endpointId, channelId),
@@ -81,6 +81,7 @@ class RedisClient {
             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 +106,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_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_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';
@@ -168,10 +169,6 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
         });
         yield __classPrivateFieldGet(this, _RedisClient_pubClient, "f").publish(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get), message);
     });
-}, _RedisClient_getPresenceCache = function _RedisClient_getPresenceCache(endpointId, channelId) {
-    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_readCachedData).call(this, endpointId, channelId, 'presence_cache:*');
-}, _RedisClient_getAssignsCache = function _RedisClient_getAssignsCache(endpointId, channelId) {
-    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_readCachedData).call(this, endpointId, channelId, 'assigns_cache:*');
 }, _RedisClient_registerInstance = function _RedisClient_registerInstance() {
     return __awaiter(this, void 0, void 0, function* () {
         const multi = __classPrivateFieldGet(this, _RedisClient_redisClient, "f").multi();
@@ -232,30 +229,44 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
     }), __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_instances, "m", _RedisClient_getActiveInstances).call(this);
-        const allKeys = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").keys('*_cache:*');
-        for (const key of allKeys) {
-            const [_, instanceId] = key.split(':');
-            if (!activeInstances.has(instanceId)) {
-                yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").del(key);
-            }
-        }
-    });
-}, _RedisClient_getActiveInstances = function _RedisClient_getActiveInstances() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const instances = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").smembers('distributed_instances');
-        const activeInstances = new Set();
-        for (const instanceId of instances) {
-            const lastHeartbeat = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").get(`heartbeat:${instanceId}`);
-            if (lastHeartbeat && Date.now() - parseInt(lastHeartbeat, 10) < __classPrivateFieldGet(this, _RedisClient_instanceTtl, "f") * 1000) {
-                activeInstances.add(instanceId);
-            }
-            else {
-                yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").srem('distributed_instances', instanceId);
-                yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").del(`heartbeat:${instanceId}`);
-            }
-        }
-        return activeInstances;
+        const consistencyCheckScript = `
+            local active_instances = redis.call('SMEMBERS', 'distributed_instances')
+            local all_keys = redis.call('KEYS', '*_cache:*')
+            local inactive_keys = {}
+            local unique_pairs = {}
+            
+            for _, key in ipairs(all_keys) do
+                local parts = {}
+                for part in string.gmatch(key, '[^:]+') do
+                    table.insert(parts, part)
+                end
+                local instance_id, endpoint_id, channel_id = parts[2], parts[3], parts[4]
+                
+                if not (active_instances[instance_id]) then
+                    table.insert(inactive_keys, key)
+                    local pair = endpoint_id .. ':' .. channel_id
+                    unique_pairs[pair] = true
+                end
+            end
+            
+            if #inactive_keys > 0 then
+                redis.call('DEL', unpack(inactive_keys))
+            end
+            
+            local unique_pairs_list = {}
+            for pair in pairs(unique_pairs) do
+                table.insert(unique_pairs_list, pair)
+            end
+            
+            return unique_pairs_list
+        `;
+        const [response] = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(consistencyCheckScript, 0);
+        const uniquePairs = Array.isArray(response) ? response : [response];
+        const promises = uniquePairs.map((pair) => {
+            const [endpointId, channelId] = pair.split(':');
+            return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpointId, channelId);
+        });
+        yield Promise.all(promises);
     });
 }, _RedisClient_handleRedisMessage = function _RedisClient_handleRedisMessage(channel, message) {
     const data = JSON.parse(message);
@@ -277,56 +288,58 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
     }
 }, _RedisClient_publishCacheMessage = function _RedisClient_publishCacheMessage(key, cacheKey, message) {
     return __awaiter(this, void 0, void 0, function* () {
+        const script = `
+            local messageData = ARGV[1]
+            local userId = ARGV[2]
+            local state = ARGV[3]
+            
+            if state ~= '' then
+                redis.call('HSET', KEYS[1], userId, state)
+            else
+                redis.call('HDEL', KEYS[1], userId)
+            end
+            
+            redis.call('PUBLISH', KEYS[2], messageData)
+            
+            return 1
+        `;
         const messageData = JSON.stringify(message);
-        if (message.state) {
-            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").hset(cacheKey, message.userId, JSON.stringify(message.state));
-        }
-        else {
-            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").hdel(cacheKey, message.userId);
-        }
-        yield __classPrivateFieldGet(this, _RedisClient_pubClient, "f").publish(key, messageData);
+        const state = message.state ? JSON.stringify(message.state) : '';
+        yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 2, cacheKey, key, messageData, message.userId, state);
     });
-}, _RedisClient_readCachedData = function _RedisClient_readCachedData(endpointId, channelId, cacheKey) {
+}, _RedisClient_emitStateSyncEvent = function _RedisClient_emitStateSyncEvent(endpointId, channelId) {
     return __awaiter(this, void 0, void 0, function* () {
-        const response = new Map();
-        const activeInstances = new Set(yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").smembers('distributed_instances'));
-        let cursor = '0';
-        do {
-            const [nextCursor, keys] = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").scan(cursor, 'MATCH', cacheKey, 'COUNT', '100');
-            cursor = nextCursor;
-            const pipeline = __classPrivateFieldGet(this, _RedisClient_redisClient, "f").pipeline();
-            keys.forEach((key) => {
-                const [_, instanceId, keyEndpointId, keyChannelId] = key.split(':');
-                if (keyEndpointId === endpointId && keyChannelId === channelId) {
-                    if (activeInstances.has(instanceId)) {
-                        pipeline.hgetall(key);
-                    }
-                    else {
-                        pipeline.del(key);
-                    }
-                }
-            });
-            const results = yield pipeline.exec();
-            if (results) {
-                results.forEach(([error, data]) => {
-                    if (!error && data && typeof data === 'object') {
-                        Object.entries(data)
-                            .forEach(([userId, value]) => {
-                            try {
-                                const parsedData = JSON.parse(value);
-                                if (typeof parsedData === 'object' && parsedData !== null) {
-                                    response.set(userId, parsedData);
-                                }
-                            }
-                            catch (e) {
-                                throw new redisError_1.RedisError('Error parsing cached data');
-                            }
-                        });
-                    }
-                });
-            }
-        } while (cursor !== '0');
-        return response;
+        const script = `
+            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]
+                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,
+            presence: new Map(Object.entries(JSON.parse(presenceData))),
+            assigns: new Map(Object.entries(JSON.parse(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");
@@ -348,6 +361,19 @@ _RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = n
             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);
+    return () => {
+        clearInterval(interval);
+        subscription();
+    };
 }, _RedisClient_handleExit = function _RedisClient_handleExit() {
     return __awaiter(this, void 0, void 0, function* () {
         try {

package/engines/endpointEngine.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -45,7 +36,7 @@ class EndpointEngine {
     }
     createChannel(path, handler) {
         const pondChannel = new lobbyEngine_1.LobbyEngine(this);
-        __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => __awaiter(this, void 0, void 0, function* () {
+        __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => {
             const event = (0, matcher_1.parseAddress)(path, user.channelName);
             if (event) {
                 const options = {
@@ -54,13 +45,13 @@ class EndpointEngine {
                     params: event,
                     joinParams,
                 };
-                const channel = yield pondChannel.getOrCreateChannel(user.channelName);
+                const channel = pondChannel.getOrCreateChannel(user.channelName);
                 const request = new joinRequest_1.JoinRequest(options, channel);
                 const response = new joinResponse_1.JoinResponse(user, channel);
                 return handler(request, response, next);
             }
             next();
-        }));
+        });
         __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f").set(path, pondChannel);
         return new pondChannel_1.PondChannel(pondChannel);
     }

package/engines/lobbyEngine.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -69,11 +60,9 @@ exports.LobbyEngine = LobbyEngine;
 _LobbyEngine_channels = new WeakMap(), _LobbyEngine_instances = new WeakSet(), _LobbyEngine_getChannel = function _LobbyEngine_getChannel(channelName) {
     return __classPrivateFieldGet(this, _LobbyEngine_channels, "f").get(channelName) || null;
 }, _LobbyEngine_createChannel = function _LobbyEngine_createChannel(channelName) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const onManagerClose = __classPrivateFieldGet(this, _LobbyEngine_channels, "f").delete.bind(__classPrivateFieldGet(this, _LobbyEngine_channels, "f"), channelName);
-        const manager = yield this.parent.createManager(channelName, onManagerClose);
-        const channel = new channelEngine_1.ChannelEngine(this, channelName, manager);
-        __classPrivateFieldGet(this, _LobbyEngine_channels, "f").set(channelName, channel);
-        return channel;
-    });
+    const onManagerClose = __classPrivateFieldGet(this, _LobbyEngine_channels, "f").delete.bind(__classPrivateFieldGet(this, _LobbyEngine_channels, "f"), channelName);
+    const manager = this.parent.createManager(channelName, onManagerClose);
+    const channel = new channelEngine_1.ChannelEngine(this, channelName, manager);
+    __classPrivateFieldGet(this, _LobbyEngine_channels, "f").set(channelName, channel);
+    return channel;
 };

package/managers/distributedManager.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -66,44 +57,42 @@ class DistributedManager extends manager_1.Manager {
         __classPrivateFieldGet(this, _DistributedManager_client, "f").publishChannelMessage(message);
     }
     initialize(unsubscribe) {
-        const _super = Object.create(null, {
-            initialize: { get: () => super.initialize }
+        super.initialize(unsubscribe);
+        const leaveSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToUserLeaves((userId) => {
+            var _a;
+            (_a = this.userSubscriptions.get(userId)) === null || _a === void 0 ? void 0 : _a();
+            this.userSubscriptions.delete(userId);
+        });
+        const presenceSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToPresenceChanges(({ userId, state }) => {
+            if (state) {
+                this.presenceCache.set(userId, state);
+            }
+            else {
+                this.presenceCache.delete(userId);
+            }
+        });
+        const assignSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToAssignsChanges(({ userId, state }) => {
+            if (state) {
+                this.assignsCache.set(userId, state);
+            }
+            else {
+                this.assignsCache.delete(userId);
+            }
+        });
+        const messageSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToChannelMessages((message) => {
+            this.publisher.publish(message);
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.initialize.call(this, unsubscribe);
-            this.presenceCache = yield __classPrivateFieldGet(this, _DistributedManager_client, "f").getPresenceCache();
-            this.assignsCache = yield __classPrivateFieldGet(this, _DistributedManager_client, "f").getAssignsCache();
-            const leaveSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToUserLeaves((userId) => {
-                var _a;
-                (_a = this.userSubscriptions.get(userId)) === null || _a === void 0 ? void 0 : _a();
-                this.userSubscriptions.delete(userId);
-            });
-            const presenceSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToPresenceChanges(({ userId, state }) => {
-                if (state) {
-                    this.presenceCache.set(userId, state);
-                }
-                else {
-                    this.presenceCache.delete(userId);
-                }
-            });
-            const assignSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToAssignsChanges(({ userId, state }) => {
-                if (state) {
-                    this.assignsCache.set(userId, state);
-                }
-                else {
-                    this.assignsCache.delete(userId);
-                }
-            });
-            const messageSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToChannelMessages((message) => {
-                this.publisher.publish(message);
-            });
-            __classPrivateFieldSet(this, _DistributedManager_subscriptions, () => {
-                leaveSubscription();
-                presenceSubscription();
-                assignSubscription();
-                messageSubscription();
-            }, "f");
+        const stateSyncSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToStateSync((state) => {
+            this.assignsCache = new Map(state.assigns);
+            this.presenceCache = new Map(state.presence);
         });
+        __classPrivateFieldSet(this, _DistributedManager_subscriptions, () => {
+            leaveSubscription();
+            presenceSubscription();
+            assignSubscription();
+            messageSubscription();
+            stateSyncSubscription();
+        }, "f");
     }
     close() {
         var _a;

package/managers/manager.js

@@ -52,7 +52,6 @@ class Manager {
     }
     initialize(unsubscribe) {
         __classPrivateFieldSet(this, _Manager_onClose, unsubscribe, "f");
-        return Promise.resolve();
     }
     getPresence(userId) {
         return this.presenceCache.get(userId) || null;

package/managers/managerFactory.js

@@ -1,31 +1,20 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManagerFactory = void 0;
 const distributedManager_1 = require("./distributedManager");
 const localManager_1 = require("./localManager");
 class ManagerFactory {
     static create(channelId, clientFactory, onClose) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let manager;
-            if (clientFactory) {
-                const client = clientFactory(channelId);
-                manager = new distributedManager_1.DistributedManager(client);
-            }
-            else {
-                manager = new localManager_1.LocalManager(channelId);
-            }
-            yield manager.initialize(onClose);
-            return manager;
-        });
+        let manager;
+        if (clientFactory) {
+            const client = clientFactory(channelId);
+            manager = new distributedManager_1.DistributedManager(client);
+        }
+        else {
+            manager = new localManager_1.LocalManager(channelId);
+        }
+        manager.initialize(onClose);
+        return manager;
     }
 }
 exports.ManagerFactory = ManagerFactory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.178",
+  "version": "0.1.180",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -49,7 +49,7 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-import-resolver-node": "^0.3.9",
     "eslint-plugin-file-progress": "^1.5.0",
-    "eslint-plugin-import": "^2.30.0",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-prettier": "^5.2.1",
     "jest": "^29.7.0",
     "nodemon": "^3.1.7",