@eleven-am/pondsocket 0.1.176 → 0.1.178

package/abstracts/redisClient.js

@@ -33,16 +33,19 @@ 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_redisClient, _RedisClient_pubClient, _RedisClient_subClient, _RedisClient_instanceId, _RedisClient_assignsPublisher, _RedisClient_presencePublisher, _RedisClient_userLeavesPublisher, _RedisClient_channelMessagePublisher, _RedisClient_ttlRefreshInterval, _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_sendHeartbeat, _RedisClient_startTTLRefresh, _RedisClient_registerInstance, _RedisClient_unregisterInstance, _RedisClient_unsubscribeFromChannels, _RedisClient_subscribeToChannels, _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_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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const ioredis_1 = __importDefault(require("ioredis"));
+const redisError_1 = require("../errors/redisError");
 class RedisClient {
-    constructor(redisOptions) {
+    constructor(config) {
+        var _a, _b, _c;
         _RedisClient_instances.add(this);
-        this.TTL_REFRESH_INTERVAL = 30 * 1000;
-        this.INSTANCE_TTL = 90;
+        _RedisClient_heartbeatInterval.set(this, void 0);
+        _RedisClient_cleanupInterval.set(this, void 0);
+        _RedisClient_instanceTtl.set(this, void 0);
         _RedisClient_redisClient.set(this, void 0);
         _RedisClient_pubClient.set(this, void 0);
         _RedisClient_subClient.set(this, void 0);
@@ -51,10 +54,14 @@ class RedisClient {
         _RedisClient_presencePublisher.set(this, void 0);
         _RedisClient_userLeavesPublisher.set(this, void 0);
         _RedisClient_channelMessagePublisher.set(this, void 0);
-        _RedisClient_ttlRefreshInterval.set(this, void 0);
-        __classPrivateFieldSet(this, _RedisClient_redisClient, new ioredis_1.default(redisOptions), "f");
-        __classPrivateFieldSet(this, _RedisClient_pubClient, new ioredis_1.default(redisOptions), "f");
-        __classPrivateFieldSet(this, _RedisClient_subClient, new ioredis_1.default(redisOptions), "f");
+        _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");
+        __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");
         __classPrivateFieldSet(this, _RedisClient_assignsPublisher, new pondsocket_common_1.Subject(), "f");
         __classPrivateFieldSet(this, _RedisClient_presencePublisher, new pondsocket_common_1.Subject(), "f");
         __classPrivateFieldSet(this, _RedisClient_userLeavesPublisher, new pondsocket_common_1.Subject(), "f");
@@ -79,8 +86,9 @@ class RedisClient {
     initialize() {
         return __awaiter(this, void 0, void 0, function* () {
             __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleErrors).call(this);
-            __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_startTTLRefresh).call(this);
             yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_registerInstance).call(this);
+            __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_startHeartbeat).call(this);
+            __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_startPeriodicCleanup).call(this);
             yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToChannels).call(this);
             process.on('SIGINT', __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleExit).bind(this));
             process.on('SIGTERM', __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleExit).bind(this));
@@ -88,7 +96,8 @@ class RedisClient {
     }
     shutdown() {
         return __awaiter(this, void 0, void 0, function* () {
-            clearInterval(__classPrivateFieldGet(this, _RedisClient_ttlRefreshInterval, "f"));
+            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_cleanup).call(this);
@@ -96,7 +105,7 @@ class RedisClient {
     }
 }
 exports.RedisClient = RedisClient;
-_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_ttlRefreshInterval = 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_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';
@@ -118,9 +127,9 @@ _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap()
     __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:${endpointId}:${channelId}`;
+    return `presence_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:${endpointId}:${channelId}`;
 }, _RedisClient_getAssignsCacheChannel = function _RedisClient_getAssignsCacheChannel(endpointId, channelId) {
-    return `assigns_cache:${endpointId}:${channelId}`;
+    return `assigns_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:${endpointId}:${channelId}`;
 }, _RedisClient_publishPresenceChange = function _RedisClient_publishPresenceChange(endpointId, channelId, userId, state) {
     const message = {
         userId,
@@ -160,33 +169,31 @@ _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap()
         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) {
-    const cacheKey = __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getPresenceCacheChannel).call(this, endpointId, channelId);
-    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_readCachedData).call(this, cacheKey);
+    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_readCachedData).call(this, endpointId, channelId, 'presence_cache:*');
 }, _RedisClient_getAssignsCache = function _RedisClient_getAssignsCache(endpointId, channelId) {
-    const cacheKey = __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getAssignsCacheChannel).call(this, endpointId, channelId);
-    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_readCachedData).call(this, cacheKey);
-}, _RedisClient_sendHeartbeat = function _RedisClient_sendHeartbeat() {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").expire(`instance:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, this.INSTANCE_TTL);
-    });
-}, _RedisClient_startTTLRefresh = function _RedisClient_startTTLRefresh() {
-    __classPrivateFieldSet(this, _RedisClient_ttlRefreshInterval, setInterval(() => __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_sendHeartbeat).call(this), this.TTL_REFRESH_INTERVAL), "f");
+    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();
-        multi.sadd('distributed_instances:', __classPrivateFieldGet(this, _RedisClient_instanceId, "f"));
-        multi.setex(`instance:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, this.INSTANCE_TTL, '1');
-        yield multi.exec();
+        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();
+        }
+        catch (error) {
+            throw new redisError_1.RedisError('Error registering instance');
+        }
     });
 }, _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(`instance:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`);
-        multi.scard('distributed_instances');
-        const results = yield multi.exec();
-        if (results && results[2] && results[2][1] === 0) {
-            // No more instances, clean up
+        multi.del(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`);
+        try {
+            yield multi.exec();
+        }
+        catch (_a) {
+            // no-op as we're shutting down
         }
     });
 }, _RedisClient_unsubscribeFromChannels = function _RedisClient_unsubscribeFromChannels() {
@@ -205,6 +212,51 @@ _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap()
         });
         __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');
+        }
+    }), __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);
+        }
+        catch (error) {
+            throw new redisError_1.RedisError('Error performing consistency check');
+        }
+    }), __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;
+    });
 }, _RedisClient_handleRedisMessage = function _RedisClient_handleRedisMessage(channel, message) {
     const data = JSON.parse(message);
     switch (channel) {
@@ -234,16 +286,47 @@ _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap()
         }
         yield __classPrivateFieldGet(this, _RedisClient_pubClient, "f").publish(key, messageData);
     });
-}, _RedisClient_readCachedData = function _RedisClient_readCachedData(cacheKey) {
+}, _RedisClient_readCachedData = function _RedisClient_readCachedData(endpointId, channelId, cacheKey) {
     return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const data = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").hgetall(cacheKey);
-            return new Map(Object.entries(data).map(([key, value]) => [key, JSON.parse(value)]));
-        }
-        catch (error) {
-            console.error(error);
-            return new Map();
-        }
+        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;
     });
 }, _RedisClient_subscribeToCacheChanges = function _RedisClient_subscribeToCacheChanges(endpoint, channel, presence, callback) {
     const subject = presence ? __classPrivateFieldGet(this, _RedisClient_presencePublisher, "f") : __classPrivateFieldGet(this, _RedisClient_assignsPublisher, "f");

package/errors/httpError.js

@@ -6,6 +6,39 @@ class HttpError extends Error {
         super(message);
         this.statusCode = statusCode;
         this.name = 'HttpError';
+        this.statusText = HttpError.getStatusText(statusCode);
+    }
+    static getStatusText(statusCode) {
+        switch (statusCode) {
+            case 400:
+                return 'Bad Request';
+            case 401:
+                return 'Unauthorized';
+            case 403:
+                return 'Forbidden';
+            case 404:
+                return 'Not Found';
+            case 405:
+                return 'Method Not Allowed';
+            case 406:
+                return 'Not Acceptable';
+            case 409:
+                return 'Conflict';
+            case 429:
+                return 'Too Many Requests';
+            case 500:
+                return 'Internal Server Error';
+            case 501:
+                return 'Not Implemented';
+            case 502:
+                return 'Bad Gateway';
+            case 503:
+                return 'Service Unavailable';
+            case 504:
+                return 'Gateway Timeout';
+            default:
+                return 'Unknown Error';
+        }
     }
 }
 exports.HttpError = HttpError;

package/errors/redisError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisError = void 0;
+class RedisError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RedisError';
+    }
+}
+exports.RedisError = RedisError;

package/index.js

@@ -1,4 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisError = void 0;
 const server_1 = require("./server/server");
+var redisError_1 = require("./errors/redisError");
+Object.defineProperty(exports, "RedisError", { enumerable: true, get: function () { return redisError_1.RedisError; } });
 exports.default = server_1.PondSocket;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.176",
+  "version": "0.1.178",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",

package/types.d.ts

@@ -23,6 +23,9 @@ export interface RedisOptions {
     db?: number;
     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> {
@@ -472,3 +475,7 @@ export declare class EventResponse<EventType extends PondEventMap = PondEventMap
      */
     evictUser(reason: string, userId?: string): EventResponse;
 }
+
+export declare class RedisError extends Error {
+    constructor(message: string);
+}

package/wrappers/pondChannel.js

@@ -10,12 +10,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _PondChannel_lobby;
+var _PondChannel_instances, _PondChannel_lobby, _PondChannel_getChannel;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondChannel = void 0;
 const channel_1 = require("./channel");
 class PondChannel {
     constructor(lobby) {
+        _PondChannel_instances.add(this);
         _PondChannel_lobby.set(this, void 0);
         __classPrivateFieldSet(this, _PondChannel_lobby, lobby, "f");
     }
@@ -28,21 +29,28 @@ class PondChannel {
         return this;
     }
     getChannel(channelName) {
-        const channel = __classPrivateFieldGet(this, _PondChannel_lobby, "f").getChannel(channelName);
-        return new channel_1.Channel(channel);
+        try {
+            return __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName);
+        }
+        catch (_a) {
+            return null;
+        }
     }
     broadcast(channelName, event, payload) {
-        this.getChannel(channelName).broadcast(event, payload);
+        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcast(event, payload);
         return this;
     }
     broadcastFrom(channelName, userId, event, payload) {
-        this.getChannel(channelName).broadcastFrom(userId, event, payload);
+        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcastFrom(userId, event, payload);
         return this;
     }
     broadcastTo(channelName, userIds, event, payload) {
-        this.getChannel(channelName).broadcastTo(userIds, event, payload);
+        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcastTo(userIds, event, payload);
         return this;
     }
 }
 exports.PondChannel = PondChannel;
-_PondChannel_lobby = new WeakMap();
+_PondChannel_lobby = new WeakMap(), _PondChannel_instances = new WeakSet(), _PondChannel_getChannel = function _PondChannel_getChannel(channelName) {
+    const channel = __classPrivateFieldGet(this, _PondChannel_lobby, "f").getChannel(channelName);
+    return new channel_1.Channel(channel);
+};