@eleven-am/pondsocket 0.1.199 → 0.1.201

package/contexts/joinContext.js

@@ -0,0 +1,156 @@
+"use strict";
+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");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _JoinContext_instances, _JoinContext_options, _JoinContext_user, _JoinContext_newAssigns, _JoinContext_executed, _JoinContext_accepted, _JoinContext_sendMessage, _JoinContext_directMessage, _JoinContext_performChecks;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinContext = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const baseContext_1 = require("./baseContext");
+const httpError_1 = require("../errors/httpError");
+/**
+ * JoinContext combines the functionality of JoinRequest and JoinResponse
+ * to provide a unified interface for handling join events in a channel.
+ */
+class JoinContext extends baseContext_1.BaseContext {
+    constructor(options, engine, user) {
+        super(engine, options.params, engine.name, options.joinParams, user.clientId);
+        _JoinContext_instances.add(this);
+        _JoinContext_options.set(this, void 0);
+        _JoinContext_user.set(this, void 0);
+        _JoinContext_newAssigns.set(this, void 0);
+        _JoinContext_executed.set(this, void 0);
+        _JoinContext_accepted.set(this, void 0);
+        __classPrivateFieldSet(this, _JoinContext_options, options, "f");
+        __classPrivateFieldSet(this, _JoinContext_user, user, "f");
+        __classPrivateFieldSet(this, _JoinContext_executed, false, "f");
+        __classPrivateFieldSet(this, _JoinContext_accepted, false, "f");
+        __classPrivateFieldSet(this, _JoinContext_newAssigns, Object.assign({}, user.assigns), "f");
+    }
+    /**
+     * The user who sent the request
+     */
+    get user() {
+        return {
+            id: __classPrivateFieldGet(this, _JoinContext_options, "f").clientId,
+            assigns: __classPrivateFieldGet(this, _JoinContext_options, "f").assigns,
+            presence: {},
+        };
+    }
+    /**
+     * The join parameters
+     */
+    get joinParams() {
+        return __classPrivateFieldGet(this, _JoinContext_options, "f").joinParams;
+    }
+    /**
+     * Whether the request has been handled
+     */
+    get hasResponded() {
+        return __classPrivateFieldGet(this, _JoinContext_executed, "f");
+    }
+    /**
+     * Accepts the join request
+     */
+    accept() {
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_performChecks).call(this);
+        const onMessage = this.engine.parent.parent.sendMessage.bind(this.engine.parent.parent, __classPrivateFieldGet(this, _JoinContext_user, "f").socket);
+        const subscription = this.engine.addUser(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, __classPrivateFieldGet(this, _JoinContext_newAssigns, "f"), onMessage);
+        __classPrivateFieldGet(this, _JoinContext_user, "f").subscriptions.add(subscription);
+        __classPrivateFieldSet(this, _JoinContext_accepted, true, "f");
+        return this;
+    }
+    /**
+     * Declines the join request
+     */
+    decline(message, errorCode) {
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_performChecks).call(this);
+        const errorMessage = {
+            event: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
+            payload: {
+                message: message || 'Unauthorized connection',
+                code: errorCode || 401,
+            },
+            channelName: this.engine.name,
+            action: pondsocket_common_1.ServerActions.ERROR,
+            requestId: __classPrivateFieldGet(this, _JoinContext_user, "f").requestId,
+        };
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_directMessage).call(this, errorMessage);
+        return this;
+    }
+    /**
+     * Assigns data to the user
+     */
+    assign(assigns) {
+        if (__classPrivateFieldGet(this, _JoinContext_accepted, "f")) {
+            this.engine.updateAssigns(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, assigns);
+        }
+        else {
+            __classPrivateFieldSet(this, _JoinContext_newAssigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _JoinContext_newAssigns, "f")), assigns), "f");
+        }
+        return this;
+    }
+    /**
+     * Sends a direct reply to the user
+     */
+    reply(event, payload) {
+        const message = {
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: this.engine.name,
+            requestId: __classPrivateFieldGet(this, _JoinContext_user, "f").requestId,
+            payload,
+            event,
+        };
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_directMessage).call(this, message);
+        return this;
+    }
+    /**
+     * Broadcasts a message to specific users
+     */
+    broadcastTo(event, payload, userIds) {
+        const ids = Array.isArray(userIds) ? userIds : [userIds];
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_sendMessage).call(this, ids, event, payload);
+        return this;
+    }
+    /**
+     * Broadcasts a message to all users in the channel
+     */
+    broadcast(event, payload) {
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_USERS, event, payload);
+        return this;
+    }
+    /**
+     * Broadcasts a message to all users except the sender
+     */
+    broadcastFrom(event, payload) {
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, event, payload);
+        return this;
+    }
+    /**
+     * Tracks the user's presence
+     */
+    trackPresence(presence) {
+        this.engine.trackPresence(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, presence);
+        return this;
+    }
+}
+exports.JoinContext = JoinContext;
+_JoinContext_options = new WeakMap(), _JoinContext_user = new WeakMap(), _JoinContext_newAssigns = new WeakMap(), _JoinContext_executed = new WeakMap(), _JoinContext_accepted = new WeakMap(), _JoinContext_instances = new WeakSet(), _JoinContext_sendMessage = function _JoinContext_sendMessage(recipient, event, payload) {
+    this.engine.sendMessage(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, recipient, pondsocket_common_1.ServerActions.BROADCAST, event, payload, __classPrivateFieldGet(this, _JoinContext_user, "f").requestId);
+}, _JoinContext_directMessage = function _JoinContext_directMessage(event) {
+    this.engine.parent.parent.sendMessage(__classPrivateFieldGet(this, _JoinContext_user, "f").socket, event);
+}, _JoinContext_performChecks = function _JoinContext_performChecks() {
+    if (__classPrivateFieldGet(this, _JoinContext_executed, "f")) {
+        const message = `Request to join channel ${this.engine.name} rejected: Request already executed`;
+        throw new httpError_1.HttpError(403, message);
+    }
+    __classPrivateFieldSet(this, _JoinContext_executed, true, "f");
+};

package/contexts/outgoingContext.js

@@ -0,0 +1,59 @@
+"use strict";
+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");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _OutgoingContext_payload, _OutgoingContext_isBlocked;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutgoingContext = void 0;
+const baseContext_1 = require("./baseContext");
+class OutgoingContext extends baseContext_1.BaseContext {
+    constructor(event, params, engine, userid) {
+        super(engine, params, event.event, event.payload, userid);
+        _OutgoingContext_payload.set(this, void 0);
+        _OutgoingContext_isBlocked.set(this, void 0);
+        __classPrivateFieldSet(this, _OutgoingContext_payload, event.payload, "f");
+        __classPrivateFieldSet(this, _OutgoingContext_isBlocked, false, "f");
+    }
+    get payload() {
+        return __classPrivateFieldGet(this, _OutgoingContext_payload, "f");
+    }
+    /**
+     * Blocks the outgoing context, preventing further processing of the event.
+     */
+    block() {
+        __classPrivateFieldSet(this, _OutgoingContext_isBlocked, true, "f");
+        return this;
+    }
+    /**
+     * Checks if the outgoing context is blocked.
+     * @returns {boolean} - True if blocked, false otherwise.
+     */
+    isBlocked() {
+        return __classPrivateFieldGet(this, _OutgoingContext_isBlocked, "f");
+    }
+    /**
+     * Transforms the outgoing context with a new payload.
+     * @param payload - The new payload to set for the context.
+     */
+    transform(payload) {
+        __classPrivateFieldSet(this, _OutgoingContext_payload, payload, "f");
+        return this;
+    }
+    /**
+     * Updates the parameters of the outgoing context.
+     * @param params - The new parameters to set for the context.
+     */
+    updateParams(params) {
+        super.updateParams(params);
+    }
+}
+exports.OutgoingContext = OutgoingContext;
+_OutgoingContext_payload = new WeakMap(), _OutgoingContext_isBlocked = new WeakMap();

package/engines/channelEngine.js

@@ -30,22 +30,31 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var _ChannelEngine_instances, _ChannelEngine_presenceEngine, _ChannelEngine_assignsCache, _ChannelEngine_userSubscriptions, _ChannelEngine_publisher, _ChannelEngine_name, _ChannelEngine_buildSubscriber, _ChannelEngine_getOrCreatePresenceEngine, _ChannelEngine_getUsersFromRecipients;
+var _ChannelEngine_instances, _ChannelEngine_endpointId, _ChannelEngine_backend, _ChannelEngine_presenceEngine, _ChannelEngine_assignsCache, _ChannelEngine_userSubscriptions, _ChannelEngine_publisher, _ChannelEngine_distributedSubscription, _ChannelEngine_name, _ChannelEngine_buildSubscriber, _ChannelEngine_getOrCreatePresenceEngine, _ChannelEngine_getUsersFromRecipients, _ChannelEngine_setupDistributedSubscription, _ChannelEngine_handleDistributedMessage, _ChannelEngine_requestChannelState, _ChannelEngine_handleStateRequest, _ChannelEngine_handleStateResponse, _ChannelEngine_handleRemoteUserJoined, _ChannelEngine_handleRemoteUserLeft, _ChannelEngine_handleRemoteMessage, _ChannelEngine_handleRemotePresenceUpdate, _ChannelEngine_handleRemotePresenceRemoved, _ChannelEngine_handleRemoteAssignsUpdate, _ChannelEngine_handleRemoteAssignsRemoved, _ChannelEngine_handleRemoteEvictUser, _ChannelEngine_broadcastToNodes;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const presenceEngine_1 = require("./presenceEngine");
+const types_1 = require("../abstracts/types");
 const httpError_1 = require("../errors/httpError");
 class ChannelEngine {
-    constructor(parent, name) {
+    constructor(parent, name, backend = null) {
         _ChannelEngine_instances.add(this);
         this.parent = parent;
+        _ChannelEngine_endpointId.set(this, void 0);
+        _ChannelEngine_backend.set(this, void 0);
         _ChannelEngine_presenceEngine.set(this, null);
         _ChannelEngine_assignsCache.set(this, new Map());
         _ChannelEngine_userSubscriptions.set(this, new Map());
         _ChannelEngine_publisher.set(this, new pondsocket_common_1.Subject());
+        _ChannelEngine_distributedSubscription.set(this, null);
         _ChannelEngine_name.set(this, void 0);
         __classPrivateFieldSet(this, _ChannelEngine_name, name, "f");
+        __classPrivateFieldSet(this, _ChannelEngine_backend, backend, "f");
+        __classPrivateFieldSet(this, _ChannelEngine_endpointId, parent.parent.path, "f");
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_setupDistributedSubscription).call(this);
+        }
     }
     get name() {
         return __classPrivateFieldGet(this, _ChannelEngine_name, "f");
@@ -65,10 +74,22 @@ class ChannelEngine {
             const message = `ChannelEngine: User with id ${userId} already exists in channel ${this.name}`;
             throw new httpError_1.HttpError(400, message);
         }
-        // Store user assigns
+        const isFirstUser = this.users.size === 0;
         __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(userId, assigns);
-        // Subscribe user to messages
         __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_buildSubscriber).call(this, userId, onMessage);
+        if (isFirstUser && __classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_requestChannelState).call(this);
+        }
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.USER_JOINED,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                presence: {},
+                assigns,
+            });
+        }
         // Send acknowledgment
         this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [userId], pondsocket_common_1.ServerActions.SYSTEM, pondsocket_common_1.Events.ACKNOWLEDGE, {});
         // Return unsubscribe function
@@ -91,15 +112,31 @@ class ChannelEngine {
         };
         const recipients = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, recipient, sender);
         const internalEvent = Object.assign(Object.assign({}, channelEvent), { recipients });
+        // Publish locally
         __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").publish(internalEvent);
+        // If distributed and this is a user message, broadcast to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f") && action === pondsocket_common_1.ServerActions.BROADCAST && sender !== pondsocket_common_1.SystemSender.CHANNEL) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.USER_MESSAGE,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                fromUserId: sender,
+                event,
+                payload,
+                requestId,
+                recipients,
+            });
+        }
     }
     /**
      * Broadcasts a message from a user
+     * @param userId - The ID of the user sending the message
+     * @param message - The message to broadcast
      */
     broadcastMessage(userId, message) {
         if (!this.users.has(userId)) {
-            const message = `ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`;
-            throw new httpError_1.HttpError(404, message);
+            const messageText = `ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`;
+            throw new httpError_1.HttpError(404, messageText);
         }
         const responseEvent = Object.assign(Object.assign({}, message), { sender: userId, action: pondsocket_common_1.ServerActions.BROADCAST });
         this.parent.middleware.run(responseEvent, this, (error) => {
@@ -111,24 +148,58 @@ class ChannelEngine {
     }
     /**
      * Tracks a user's presence
+     * @param userId - The ID of the user
+     * @param presence - The presence data to track
      */
     trackPresence(userId, presence) {
         const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
         presenceEngine.trackPresence(userId, presence);
+        // Broadcast presence update to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.PRESENCE_UPDATE,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                presence,
+            });
+        }
     }
     /**
      * Updates a user's presence
+     * @param userId - The ID of the user
+     * @param presence - The presence data to update
      */
     updatePresence(userId, presence) {
         const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
         presenceEngine.updatePresence(userId, presence);
+        // Broadcast presence update to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.PRESENCE_UPDATE,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                presence,
+            });
+        }
     }
     /**
      * Removes a user's presence
+     * @param userId - The ID of the user to remove presence for
      */
     removePresence(userId) {
         if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
             __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(userId);
+            // Broadcast presence removal to other nodes
+            if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+                __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                    type: types_1.DistributedMessageType.PRESENCE_REMOVED,
+                    endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                    channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                    userId,
+                });
+            }
         }
     }
     /**
@@ -137,6 +208,16 @@ class ChannelEngine {
     upsertPresence(userId, presence) {
         const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
         presenceEngine.upsertPresence(userId, presence);
+        // Broadcast presence update to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.PRESENCE_UPDATE,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                presence,
+            });
+        }
     }
     /**
      * Updates a user's assigns
@@ -146,7 +227,18 @@ class ChannelEngine {
             throw new httpError_1.HttpError(404, `User with id ${userId} does not exist in channel ${this.name}`);
         }
         const currentAssigns = __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").get(userId) || {};
-        __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(userId, Object.assign(Object.assign({}, currentAssigns), assigns));
+        const newAssigns = Object.assign(Object.assign({}, currentAssigns), assigns);
+        __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(userId, newAssigns);
+        // Broadcast assigns update to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.ASSIGNS_UPDATE,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                assigns: newAssigns,
+            });
+        }
     }
     /**
      * Kicks a user from the channel
@@ -156,6 +248,16 @@ class ChannelEngine {
             message: reason,
             code: 403,
         });
+        // Broadcast eviction to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.EVICT_USER,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                reason,
+            });
+        }
         this.removeUser(userId);
         this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, 'kicked', {
             userId,
@@ -211,19 +313,26 @@ class ChannelEngine {
                 unsubscribe();
                 __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").delete(userId);
             }
-            // Trigger leave callback if defined
+            // Broadcast user left to other nodes
+            if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+                __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                    type: types_1.DistributedMessageType.USER_LEFT,
+                    endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                    channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                    userId,
+                });
+            }
             if (this.parent.leaveCallback) {
                 this.parent.leaveCallback({
                     user: userData,
                     channel: this.parent.wrapChannel(this),
                 });
             }
-            // If no users left, close the channel
             if (this.users.size === 0) {
                 this.close();
             }
         }
-        catch (error) {
+        catch (_a) {
             // Ignore cleanup errors
         }
     }
@@ -248,31 +357,30 @@ class ChannelEngine {
      * Closes the channel and cleans up resources
      */
     close() {
-        // Clear all user subscriptions
         __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").forEach((unsubscribe) => unsubscribe());
         __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").clear();
-        // Clear assigns
         __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").clear();
-        // Close presence engine if exists
         if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
             __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").close();
             __classPrivateFieldSet(this, _ChannelEngine_presenceEngine, null, "f");
         }
-        // Close publisher
+        if (__classPrivateFieldGet(this, _ChannelEngine_distributedSubscription, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_distributedSubscription, "f").call(this);
+            __classPrivateFieldSet(this, _ChannelEngine_distributedSubscription, null, "f");
+        }
         __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").close();
-        // Remove the channel from the parent
         this.parent.deleteChannel(this.name);
     }
 }
 exports.ChannelEngine = ChannelEngine;
-_ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new WeakMap(), _ChannelEngine_userSubscriptions = new WeakMap(), _ChannelEngine_publisher = new WeakMap(), _ChannelEngine_name = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_buildSubscriber = function _ChannelEngine_buildSubscriber(userId, onMessage) {
+_ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(), _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new WeakMap(), _ChannelEngine_userSubscriptions = new WeakMap(), _ChannelEngine_publisher = new WeakMap(), _ChannelEngine_distributedSubscription = new WeakMap(), _ChannelEngine_name = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_buildSubscriber = function _ChannelEngine_buildSubscriber(userId, onMessage) {
     const subscription = __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").subscribe((_a) => __awaiter(this, void 0, void 0, function* () {
         var { recipients } = _a, event = __rest(_a, ["recipients"]);
         if (recipients.includes(userId)) {
-            if (event.action === pondsocket_common_1.ServerActions.SYSTEM) {
+            if (event.action === pondsocket_common_1.ServerActions.PRESENCE) {
                 return onMessage(event);
             }
-            const newEvent = yield this.parent.manageOutgoingEvents(event, userId, this);
+            const newEvent = yield this.parent.processOutgoingEvents(event, this, userId);
             if (newEvent) {
                 onMessage(newEvent);
             }
@@ -282,7 +390,6 @@ _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new
 }, _ChannelEngine_getOrCreatePresenceEngine = function _ChannelEngine_getOrCreatePresenceEngine() {
     if (!__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
         __classPrivateFieldSet(this, _ChannelEngine_presenceEngine, new presenceEngine_1.PresenceEngine(this.name), "f");
-        // Subscribe to presence events and publish them through the channel publisher
         __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").subscribe((event) => {
             __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").publish(event);
         });
@@ -315,4 +422,163 @@ _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new
             break;
     }
     return users;
+}, _ChannelEngine_setupDistributedSubscription = function _ChannelEngine_setupDistributedSubscription() {
+    if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+        return;
+    }
+    __classPrivateFieldSet(this, _ChannelEngine_distributedSubscription, __classPrivateFieldGet(this, _ChannelEngine_backend, "f").subscribe(__classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"), __classPrivateFieldGet(this, _ChannelEngine_name, "f"), (message) => {
+        __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleDistributedMessage).call(this, message);
+    }), "f");
+}, _ChannelEngine_handleDistributedMessage = function _ChannelEngine_handleDistributedMessage(message) {
+    switch (message.type) {
+        case types_1.DistributedMessageType.STATE_REQUEST:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleStateRequest).call(this, message);
+            break;
+        case types_1.DistributedMessageType.STATE_RESPONSE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleStateResponse).call(this, message);
+            break;
+        case types_1.DistributedMessageType.USER_JOINED:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteUserJoined).call(this, message);
+            break;
+        case types_1.DistributedMessageType.USER_LEFT:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteUserLeft).call(this, message);
+            break;
+        case types_1.DistributedMessageType.USER_MESSAGE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteMessage).call(this, message);
+            break;
+        case types_1.DistributedMessageType.PRESENCE_UPDATE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemotePresenceUpdate).call(this, message);
+            break;
+        case types_1.DistributedMessageType.PRESENCE_REMOVED:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemotePresenceRemoved).call(this, message);
+            break;
+        case types_1.DistributedMessageType.ASSIGNS_UPDATE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteAssignsUpdate).call(this, message);
+            break;
+        case types_1.DistributedMessageType.ASSIGNS_REMOVED:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteAssignsRemoved).call(this, message);
+            break;
+        case types_1.DistributedMessageType.EVICT_USER:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteEvictUser).call(this, message);
+            break;
+        default:
+            break;
+    }
+}, _ChannelEngine_requestChannelState = function _ChannelEngine_requestChannelState() {
+    if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+        type: types_1.DistributedMessageType.STATE_REQUEST,
+        endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+        channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+        fromNode: 'current-node',
+    });
+}, _ChannelEngine_handleStateRequest = function _ChannelEngine_handleStateRequest(_message) {
+    if (this.users.size === 0) {
+        return;
+    }
+    const users = Array.from(__classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").entries()).map(([id, assigns]) => {
+        var _a;
+        return ({
+            id,
+            assigns,
+            presence: ((_a = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) === null || _a === void 0 ? void 0 : _a.getPresence(id)) || {},
+        });
+    });
+    __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+        type: types_1.DistributedMessageType.STATE_RESPONSE,
+        endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+        channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+        users,
+    });
+}, _ChannelEngine_handleStateResponse = function _ChannelEngine_handleStateResponse(message) {
+    if (!message.users) {
+        return;
+    }
+    message.users.forEach((user) => {
+        if (!this.users.has(user.id)) {
+            __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(user.id, user.assigns);
+            if (user.presence && Object.keys(user.presence).length > 0) {
+                const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
+                presenceEngine.trackPresence(user.id, user.presence);
+            }
+        }
+    });
+}, _ChannelEngine_handleRemoteUserJoined = function _ChannelEngine_handleRemoteUserJoined(message) {
+    if (this.users.has(message.userId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(message.userId, message.assigns);
+    if (message.presence && Object.keys(message.presence).length > 0) {
+        const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
+        presenceEngine.trackPresence(message.userId, message.presence);
+    }
+}, _ChannelEngine_handleRemoteUserLeft = function _ChannelEngine_handleRemoteUserLeft(message) {
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").delete(message.userId);
+    if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+        __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(message.userId);
+    }
+}, _ChannelEngine_handleRemoteMessage = function _ChannelEngine_handleRemoteMessage(message) {
+    const localRecipients = message.recipients.filter((userId) => this.users.has(userId));
+    if (localRecipients.length === 0) {
+        return;
+    }
+    const internalEvent = {
+        channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+        requestId: message.requestId,
+        action: pondsocket_common_1.ServerActions.BROADCAST,
+        event: message.event,
+        payload: message.payload,
+        recipients: localRecipients,
+    };
+    __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").publish(internalEvent);
+}, _ChannelEngine_handleRemotePresenceUpdate = function _ChannelEngine_handleRemotePresenceUpdate(message) {
+    if (!this.users.has(message.userId)) {
+        return;
+    }
+    const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
+    presenceEngine.upsertPresence(message.userId, message.presence);
+}, _ChannelEngine_handleRemotePresenceRemoved = function _ChannelEngine_handleRemotePresenceRemoved(message) {
+    if (!this.users.has(message.userId)) {
+        return;
+    }
+    if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+        __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(message.userId);
+    }
+}, _ChannelEngine_handleRemoteAssignsUpdate = function _ChannelEngine_handleRemoteAssignsUpdate(message) {
+    if (!this.users.has(message.userId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(message.userId, message.assigns);
+}, _ChannelEngine_handleRemoteAssignsRemoved = function _ChannelEngine_handleRemoteAssignsRemoved(message) {
+    if (!this.users.has(message.userId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(message.userId, {});
+}, _ChannelEngine_handleRemoteEvictUser = function _ChannelEngine_handleRemoteEvictUser(message) {
+    if (!this.users.has(message.userId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").delete(message.userId);
+    if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+        __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(message.userId);
+    }
+    const unsubscribe = __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").get(message.userId);
+    if (unsubscribe) {
+        unsubscribe();
+        __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").delete(message.userId);
+    }
+}, _ChannelEngine_broadcastToNodes = function _ChannelEngine_broadcastToNodes(message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            return;
+        }
+        try {
+            yield __classPrivateFieldGet(this, _ChannelEngine_backend, "f").broadcast(__classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"), __classPrivateFieldGet(this, _ChannelEngine_name, "f"), message);
+        }
+        catch (_a) {
+            // Silently ignore broadcast errors to prevent cascading failures
+        }
+    });
 };