@eleven-am/pondsocket 0.1.217 → 0.1.219

package/{server → dist/server}/server.js

@@ -1,4 +1,13 @@
 "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");
@@ -10,7 +19,7 @@ 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 _PondSocket_instances, _PondSocket_server, _PondSocket_exclusiveServer, _PondSocket_socketServer, _PondSocket_backend, _PondSocket_middleware, _PondSocket_maxMessageSize, _PondSocket_heartbeatMs, _PondSocket_heartbeatTimer, _PondSocket_backendReady, _PondSocket_handleUpgrade, _PondSocket_manageHeartbeat, _PondSocket_init, _PondSocket_getCookies;
+var _PondSocket_instances, _PondSocket_server, _PondSocket_exclusiveServer, _PondSocket_socketServer, _PondSocket_backend, _PondSocket_middleware, _PondSocket_maxMessageSize, _PondSocket_heartbeatMs, _PondSocket_closeHttpServerOnShutdown, _PondSocket_upgradeHandler, _PondSocket_heartbeatTimer, _PondSocket_backendReady, _PondSocket_backendError, _PondSocket_serverError, _PondSocket_shutdownPromise, _PondSocket_shutdown, _PondSocket_handleUpgrade, _PondSocket_manageHeartbeat, _PondSocket_init, _PondSocket_getCookies;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocket = void 0;
 const http_1 = require("http");
@@ -22,7 +31,7 @@ const endpointEngine_1 = require("../engines/endpointEngine");
 const matcher_1 = require("../matcher/matcher");
 const endpoint_1 = require("../wrappers/endpoint");
 class PondSocket {
-    constructor({ server, socketServer, exclusiveServer = true, distributedBackend, maxMessageSize = 1024 * 1024, heartbeatInterval = 30000, } = {}) {
+    constructor({ server, socketServer, closeHttpServerOnShutdown = true, exclusiveServer = true, distributedBackend, maxMessageSize = 1024 * 1024, heartbeatInterval = 30000, } = {}) {
         _PondSocket_instances.add(this);
         _PondSocket_server.set(this, void 0);
         _PondSocket_exclusiveServer.set(this, void 0);
@@ -31,15 +40,22 @@ class PondSocket {
         _PondSocket_middleware.set(this, void 0);
         _PondSocket_maxMessageSize.set(this, void 0);
         _PondSocket_heartbeatMs.set(this, void 0);
+        _PondSocket_closeHttpServerOnShutdown.set(this, void 0);
+        _PondSocket_upgradeHandler.set(this, void 0);
         _PondSocket_heartbeatTimer.set(this, null);
         _PondSocket_backendReady.set(this, null);
+        _PondSocket_backendError.set(this, null);
+        _PondSocket_serverError.set(this, null);
+        _PondSocket_shutdownPromise.set(this, null);
         __classPrivateFieldSet(this, _PondSocket_middleware, new middleware_1.Middleware(), "f");
         __classPrivateFieldSet(this, _PondSocket_exclusiveServer, exclusiveServer, "f");
         __classPrivateFieldSet(this, _PondSocket_server, server !== null && server !== void 0 ? server : new http_1.Server(), "f");
         __classPrivateFieldSet(this, _PondSocket_backend, distributedBackend !== null && distributedBackend !== void 0 ? distributedBackend : null, "f");
         __classPrivateFieldSet(this, _PondSocket_maxMessageSize, maxMessageSize, "f");
         __classPrivateFieldSet(this, _PondSocket_heartbeatMs, heartbeatInterval, "f");
+        __classPrivateFieldSet(this, _PondSocket_closeHttpServerOnShutdown, closeHttpServerOnShutdown, "f");
         __classPrivateFieldSet(this, _PondSocket_socketServer, socketServer !== null && socketServer !== void 0 ? socketServer : new ws_1.WebSocketServer({ noServer: true }), "f");
+        __classPrivateFieldSet(this, _PondSocket_upgradeHandler, __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_handleUpgrade).bind(this), "f");
         __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_init).call(this);
     }
     /**
@@ -52,34 +68,35 @@ class PondSocket {
      * Close the server
      */
     close(callback, timeout = 5000) {
-        var _a, _b;
-        if (__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f")) {
-            clearInterval(__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f"));
-            __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, null, "f");
+        this.closeAsync(timeout)
+            .then(() => callback === null || callback === void 0 ? void 0 : callback())
+            .catch((error) => callback === null || callback === void 0 ? void 0 : callback(error instanceof Error ? error : new Error(String(error))));
+        return __classPrivateFieldGet(this, _PondSocket_server, "f");
+    }
+    closeAsync(timeout = 5000) {
+        if (__classPrivateFieldGet(this, _PondSocket_shutdownPromise, "f")) {
+            return __classPrivateFieldGet(this, _PondSocket_shutdownPromise, "f");
         }
-        __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
-            if (socket.readyState === ws_1.WebSocket.OPEN) {
-                socket.close(1001, 'Server shutting down');
+        __classPrivateFieldSet(this, _PondSocket_shutdownPromise, __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_shutdown).call(this, timeout), "f");
+        return __classPrivateFieldGet(this, _PondSocket_shutdownPromise, "f");
+    }
+    ready() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield ((_a = __classPrivateFieldGet(this, _PondSocket_backendReady, "f")) !== null && _a !== void 0 ? _a : Promise.resolve());
+            if (__classPrivateFieldGet(this, _PondSocket_backendError, "f")) {
+                throw __classPrivateFieldGet(this, _PondSocket_backendError, "f");
             }
         });
-        const forceClose = setTimeout(() => {
-            __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
-                if (socket.readyState !== ws_1.WebSocket.CLOSED) {
-                    socket.terminate();
-                }
-            });
-            __classPrivateFieldGet(this, _PondSocket_socketServer, "f").close();
-        }, timeout);
-        __classPrivateFieldGet(this, _PondSocket_socketServer, "f").close(() => {
-            clearTimeout(forceClose);
-        });
-        __classPrivateFieldSet(this, _PondSocket_backendReady, (_b = (_a = __classPrivateFieldGet(this, _PondSocket_backendReady, "f")) === null || _a === void 0 ? void 0 : _a.catch(() => { }).then(() => { var _a; return (_a = __classPrivateFieldGet(this, _PondSocket_backend, "f")) === null || _a === void 0 ? void 0 : _a.cleanup(); }).catch(() => { })) !== null && _b !== void 0 ? _b : null, "f");
-        return __classPrivateFieldGet(this, _PondSocket_server, "f").close(callback);
     }
-    /**
-     * Create a new endpoint
-     */
-    createEndpoint(path, handler) {
+    isHealthy() {
+        return __classPrivateFieldGet(this, _PondSocket_backendError, "f") === null && __classPrivateFieldGet(this, _PondSocket_serverError, "f") === null && __classPrivateFieldGet(this, _PondSocket_shutdownPromise, "f") === null;
+    }
+    createEndpoint(pathOrDefinition, handler) {
+        const path = (0, pondsocket_common_1.isPondEndpointDefinition)(pathOrDefinition) ? pathOrDefinition.path : pathOrDefinition;
+        if (typeof path === 'string') {
+            (0, pondsocket_common_1.compilePondRoute)(path);
+        }
         const endpoint = new endpointEngine_1.EndpointEngine(String(path), __classPrivateFieldGet(this, _PondSocket_backend, "f"), __classPrivateFieldGet(this, _PondSocket_maxMessageSize, "f"));
         __classPrivateFieldGet(this, _PondSocket_middleware, "f").use((req, params, next) => {
             const event = (0, matcher_1.parseAddress)(path, req.address);
@@ -93,13 +110,67 @@ class PondSocket {
                 webSocketServer: __classPrivateFieldGet(this, _PondSocket_socketServer, "f"),
             };
             const context = new connectionContext_1.ConnectionContext(request, newParams);
-            return Promise.resolve(handler(context, next)).then(() => undefined);
+            let delegated = false;
+            const delegate = (error) => {
+                delegated = true;
+                return next(error);
+            };
+            return Promise.resolve(handler(context, delegate)).then(() => {
+                if (!delegated && !context.hasResponded) {
+                    context.decline('Connection handler completed without accepting or declining the request', 500);
+                }
+            });
         });
         return new endpoint_1.Endpoint(endpoint);
     }
 }
 exports.PondSocket = PondSocket;
-_PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_backend = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_maxMessageSize = new WeakMap(), _PondSocket_heartbeatMs = new WeakMap(), _PondSocket_heartbeatTimer = new WeakMap(), _PondSocket_backendReady = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_handleUpgrade = function _PondSocket_handleUpgrade(req, socket, head) {
+_PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_backend = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_maxMessageSize = new WeakMap(), _PondSocket_heartbeatMs = new WeakMap(), _PondSocket_closeHttpServerOnShutdown = new WeakMap(), _PondSocket_upgradeHandler = new WeakMap(), _PondSocket_heartbeatTimer = new WeakMap(), _PondSocket_backendReady = new WeakMap(), _PondSocket_backendError = new WeakMap(), _PondSocket_serverError = new WeakMap(), _PondSocket_shutdownPromise = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_shutdown = function _PondSocket_shutdown(timeout) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f")) {
+            clearInterval(__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f"));
+            __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, null, "f");
+        }
+        __classPrivateFieldGet(this, _PondSocket_server, "f").off('upgrade', __classPrivateFieldGet(this, _PondSocket_upgradeHandler, "f"));
+        __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
+            if (socket.readyState === ws_1.WebSocket.OPEN) {
+                socket.close(1001, 'Server shutting down');
+            }
+        });
+        const closeSockets = new Promise((resolve) => {
+            var _a;
+            const forceClose = setTimeout(() => {
+                __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
+                    if (socket.readyState !== ws_1.WebSocket.CLOSED) {
+                        socket.terminate();
+                    }
+                });
+                resolve();
+            }, timeout);
+            (_a = forceClose.unref) === null || _a === void 0 ? void 0 : _a.call(forceClose);
+            try {
+                __classPrivateFieldGet(this, _PondSocket_socketServer, "f").close(() => {
+                    clearTimeout(forceClose);
+                    resolve();
+                });
+            }
+            catch (_b) {
+                clearTimeout(forceClose);
+                resolve();
+            }
+        });
+        const cleanupBackend = ((_a = __classPrivateFieldGet(this, _PondSocket_backendReady, "f")) !== null && _a !== void 0 ? _a : Promise.resolve())
+            .catch(() => { })
+            .then(() => { var _a; return (_a = __classPrivateFieldGet(this, _PondSocket_backend, "f")) === null || _a === void 0 ? void 0 : _a.cleanup(); });
+        const closeHttpServer = __classPrivateFieldGet(this, _PondSocket_closeHttpServerOnShutdown, "f") && __classPrivateFieldGet(this, _PondSocket_server, "f").listening
+            ? new Promise((resolve, reject) => {
+                __classPrivateFieldGet(this, _PondSocket_server, "f").close((error) => error ? reject(error) : resolve());
+            })
+            : Promise.resolve();
+        yield Promise.all([closeSockets, cleanupBackend, closeHttpServer]);
+    });
+}, _PondSocket_handleUpgrade = function _PondSocket_handleUpgrade(req, socket, head) {
     const clientId = (0, pondsocket_common_1.uuid)();
     const request = {
         id: clientId,
@@ -125,12 +196,13 @@ _PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(),
         }
     });
 }, _PondSocket_manageHeartbeat = function _PondSocket_manageHeartbeat() {
+    var _a;
     __classPrivateFieldGet(this, _PondSocket_socketServer, "f").on('connection', (socket) => {
         socket.on('pong', () => {
             socket.isAlive = true;
         });
     });
-    return setInterval(() => {
+    const timer = setInterval(() => {
         __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
             if (socket.isAlive === false) {
                 return socket.terminate();
@@ -139,18 +211,20 @@ _PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(),
             socket.ping();
         });
     }, __classPrivateFieldGet(this, _PondSocket_heartbeatMs, "f"));
+    (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+    return timer;
 }, _PondSocket_init = function _PondSocket_init() {
     var _a, _b;
     __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_manageHeartbeat).call(this), "f");
     __classPrivateFieldSet(this, _PondSocket_backendReady, (_b = (_a = __classPrivateFieldGet(this, _PondSocket_backend, "f")) === null || _a === void 0 ? void 0 : _a.initialize().catch((error) => {
-        __classPrivateFieldGet(this, _PondSocket_server, "f").emit('error', error);
+        __classPrivateFieldSet(this, _PondSocket_backendError, error instanceof Error ? error : new Error(String(error)), "f");
     })) !== null && _b !== void 0 ? _b : null, "f");
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('error', (error) => {
+        __classPrivateFieldSet(this, _PondSocket_serverError, error, "f");
         if (__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f")) {
             clearInterval(__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f"));
             __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, null, "f");
         }
-        throw new Error(error.message);
     });
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('close', () => {
         if (__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f")) {
@@ -158,7 +232,7 @@ _PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(),
             __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, null, "f");
         }
     });
-    __classPrivateFieldGet(this, _PondSocket_server, "f").on('upgrade', __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_handleUpgrade).bind(this));
+    __classPrivateFieldGet(this, _PondSocket_server, "f").on('upgrade', __classPrivateFieldGet(this, _PondSocket_upgradeHandler, "f"));
 }, _PondSocket_getCookies = function _PondSocket_getCookies(headers) {
     const cookieHeader = headers.cookie;
     if (!cookieHeader) {
@@ -173,7 +247,12 @@ _PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(),
         }
         const name = trimmed.slice(0, eqIndex);
         const value = trimmed.slice(eqIndex + 1);
-        cookies[name] = decodeURIComponent(value);
+        try {
+            cookies[name] = decodeURIComponent(value);
+        }
+        catch (_a) {
+            cookies[name] = value;
+        }
         return cookies;
     }, {});
 };

package/{types.d.ts → dist/types.d.ts}

@@ -14,6 +14,7 @@ export interface RedisDistributedBackendOptions {
     onError?: (error: Error) => void;
 }
 export interface PondSocketOptions {
+    closeHttpServerOnShutdown?: boolean;
     server?: HTTPServer;
     socketServer?: WebSocketServer;
     exclusiveServer?: boolean;
@@ -100,20 +101,19 @@ export interface EvictUser extends DistributedMessage {
 export interface UserRemove extends DistributedMessage {
     type: DistributedMessageType.USER_REMOVE;
     userId: string;
-    reason: string;
 }
 export interface UserGetRequest extends DistributedMessage {
     type: DistributedMessageType.USER_GET_REQUEST;
     userId: string;
-    lookupRequestId: string;
+    requestId: string;
+    fromNode: string;
 }
 export interface UserGetResponse extends DistributedMessage {
     type: DistributedMessageType.USER_GET_RESPONSE;
-    lookupRequestId: string;
     userId: string;
-    found: boolean;
-    assigns?: PondAssigns;
-    presence?: PondPresence;
+    requestId: string;
+    assigns: PondAssigns;
+    presence: PondPresence;
 }
 export interface NodeHeartbeat extends DistributedMessage {
     type: DistributedMessageType.NODE_HEARTBEAT;

package/{wrappers → dist/wrappers}/channel.d.ts

@@ -1,4 +1,4 @@
-import { AnyPondSchema, AssignsOf, EventsOf, EventPayload, PresenceOf, UserData, UserAssigns, UserPresences } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, AssignsOf, EventsOf, EventPayload, PresenceOf, RouteParamsArguments, UserData, UserAssigns, UserPresences } from '@eleven-am/pondsocket-common';
 import { ChannelEngine } from '../engines/channelEngine';
 export declare class Channel<Schema extends AnyPondSchema = AnyPondSchema> {
     #private;
@@ -6,7 +6,7 @@ export declare class Channel<Schema extends AnyPondSchema = AnyPondSchema> {
     /**
      * Gets a user's data
      */
-    getUserData(userId: string): UserData<PresenceOf<Schema>, AssignsOf<Schema>> | null;
+    getUserData(userId: string): UserData<PresenceOf<Schema>, AssignsOf<Schema>>;
     /**
      * Gets all presence data
      */
@@ -18,15 +18,15 @@ export declare class Channel<Schema extends AnyPondSchema = AnyPondSchema> {
     /**
      * Broadcasts a message to all users
      */
-    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): this;
     /**
      * Broadcasts a message from a specific user to all others
      */
-    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): this;
     /**
      * Broadcasts a message to specific users
      */
-    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): this;
     /**
      * Kicks a user from the channel
      */
@@ -51,4 +51,12 @@ export declare class Channel<Schema extends AnyPondSchema = AnyPondSchema> {
      * Updates a user's assigns
      */
     updateAssigns(userId: string, assigns: Partial<AssignsOf<Schema>>): this;
+    /**
+     * Resolves a user's data from any node in the distributed cluster
+     */
+    getUserAcrossNodes(userId: string, timeoutMs?: number): Promise<UserData<PresenceOf<Schema>, AssignsOf<Schema>> | null>;
+    /**
+     * Requests removal of a user across all nodes in the distributed cluster
+     */
+    requestUserRemoval(userId: string): this;
 }

package/{wrappers → dist/wrappers}/channel.js

@@ -40,23 +40,26 @@ class Channel {
     /**
      * Broadcasts a message to all users
      */
-    broadcast(event, payload) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+    broadcast(event, payload, ...args) {
+        var _a;
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, (0, pondsocket_common_1.buildPondRoute)(event, (_a = args[0]) !== null && _a !== void 0 ? _a : {}), payload);
         return this;
     }
     /**
      * Broadcasts a message from a specific user to all others
      */
-    broadcastFrom(userId, event, payload) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(userId, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+    broadcastFrom(userId, event, payload, ...args) {
+        var _a;
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(userId, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, (0, pondsocket_common_1.buildPondRoute)(event, (_a = args[0]) !== null && _a !== void 0 ? _a : {}), payload);
         return this;
     }
     /**
      * Broadcasts a message to specific users
      */
-    broadcastTo(userIds, event, payload) {
+    broadcastTo(userIds, event, payload, ...args) {
+        var _a;
         const users = Array.isArray(userIds) ? userIds : [userIds];
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, users, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, users, pondsocket_common_1.ServerActions.BROADCAST, (0, pondsocket_common_1.buildPondRoute)(event, (_a = args[0]) !== null && _a !== void 0 ? _a : {}), payload);
         return this;
     }
     /**
@@ -101,6 +104,19 @@ class Channel {
         __classPrivateFieldGet(this, _Channel_engine, "f").updateAssigns(userId, assigns);
         return this;
     }
+    /**
+     * Resolves a user's data from any node in the distributed cluster
+     */
+    getUserAcrossNodes(userId, timeoutMs) {
+        return __classPrivateFieldGet(this, _Channel_engine, "f").getUserAcrossNodes(userId, timeoutMs);
+    }
+    /**
+     * Requests removal of a user across all nodes in the distributed cluster
+     */
+    requestUserRemoval(userId) {
+        __classPrivateFieldGet(this, _Channel_engine, "f").requestUserRemoval(userId);
+        return this;
+    }
 }
 exports.Channel = Channel;
 _Channel_engine = new WeakMap();

package/{wrappers → dist/wrappers}/endpoint.d.ts

@@ -1,10 +1,12 @@
-import { AnyPondSchema, PondPath } from '@eleven-am/pondsocket-common';
+import { AnyPondChannelDefinition, AnyPondSchema, PathOf, PondPath, SchemaOf } from '@eleven-am/pondsocket-common';
+import { PondChannel } from './pondChannel';
 import { AuthorizationHandler } from '../abstracts/types';
 import { EndpointEngine } from '../engines/endpointEngine';
 export declare class Endpoint {
     #private;
     constructor(engine: EndpointEngine);
-    createChannel<Path extends string, Schema extends AnyPondSchema = AnyPondSchema>(path: PondPath<Path>, handler: AuthorizationHandler<Path, Schema>): import("./pondChannel").PondChannel<Schema>;
+    createChannel<Definition extends AnyPondChannelDefinition>(definition: Definition, handler: AuthorizationHandler<PathOf<Definition>, SchemaOf<Definition>>): PondChannel<SchemaOf<Definition>>;
+    createChannel<Path extends string, Schema extends AnyPondSchema = AnyPondSchema>(path: PondPath<Path>, handler: AuthorizationHandler<Path, Schema>): PondChannel<Schema>;
     closeConnection(clientIds: string | string[]): void;
     getClients(): import("ws").WebSocket[];
 }

package/{wrappers → dist/wrappers}/pondChannel.d.ts

@@ -1,4 +1,4 @@
-import { AnyPondSchema, EventPayload, EventsOf, PondPath } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, EventPayload, EventsOf, PondPath, RouteParamsArguments } from '@eleven-am/pondsocket-common';
 import { Channel } from './channel';
 import { EventHandler, LeaveCallback, OutgoingEventHandler } from '../abstracts/types';
 import { LobbyEngine } from '../engines/lobbyEngine';
@@ -9,7 +9,7 @@ export declare class PondChannel<Schema extends AnyPondSchema = AnyPondSchema> {
     onLeave(callback: LeaveCallback): PondChannel<Schema>;
     handleOutgoingEvent<Event extends Extract<keyof EventsOf<Schema>, string>>(event: PondPath<Event>, handler: OutgoingEventHandler<Event, Schema, Event>): this;
     getChannel(channelName: string): Channel<Schema> | null;
-    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
-    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
-    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): PondChannel<Schema>;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): PondChannel<Schema>;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): PondChannel<Schema>;
 }

package/{wrappers → dist/wrappers}/pondChannel.js

@@ -40,16 +40,16 @@ class PondChannel {
             return null;
         }
     }
-    broadcast(channelName, event, payload) {
-        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcast(event, payload);
+    broadcast(channelName, event, payload, ...args) {
+        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcast(event, payload, ...args);
         return this;
     }
-    broadcastFrom(channelName, userId, event, payload) {
-        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcastFrom(userId, event, payload);
+    broadcastFrom(channelName, userId, event, payload, ...args) {
+        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcastFrom(userId, event, payload, ...args);
         return this;
     }
-    broadcastTo(channelName, userIds, event, payload) {
-        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcastTo(userIds, event, payload);
+    broadcastTo(channelName, userIds, event, payload, ...args) {
+        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcastTo(userIds, event, payload, ...args);
         return this;
     }
 }

package/package.json

@@ -1,80 +1,65 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.217",
-  "description": "PondSocket is a fast simple socket server",
+  "version": "0.1.219",
+  "description": "Typed WebSocket and SSE server with presence and distributed messaging.",
   "keywords": [
-    "socket",
-    "server",
-    "ws",
+    "pondsocket",
     "websocket",
-    "pubsub",
-    "presence",
+    "sse",
     "realtime",
-    "realtime server"
+    "presence",
+    "pubsub",
+    "redis"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "test": "jest --coverage --verbose --forceExit --detectOpenHandles --runInBand --bail",
-    "build": "rimraf dist && tsc --project tsconfig.build.json && rm -rf dist/tests",
-    "lint": "eslint --ext .ts src",
-    "lint:fix": "eslint --fix --ext .ts src",
-    "copy": "cp package.json dist && cp README.md dist && cp LICENSE dist",
-    "push": "npm version patch && npm run copy && cd dist && npm publish && cd ..",
-    "pipeline": "npm run lint:fix && npm run lint && npm run test && npm run build && npm run push"
-  },
   "author": "Roy OSSAI",
   "license": "GPL-3.0",
-  "main": "./index.js",
-  "types": "./index.d.ts",
+  "homepage": "https://github.com/eleven-am/pondsocket#readme",
+  "bugs": {
+    "url": "https://github.com/eleven-am/pondsocket/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eleven-am/pondsocket.git",
+    "directory": "javascript/core"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "default": "./index.js"
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./types": {
-      "types": "./index.d.ts",
-      "default": "./index.js"
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Eleven-am/pondSocket.git"
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
   },
-  "dependencies": {
-    "@eleven-am/pondsocket-common": "^0.0.39",
-    "@types/node": "^25.3.3",
-    "@types/ws": "^8.18.1",
-    "redis": "^5.12.1",
-    "ws": "^8.20.1"
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "npm run clean && tsc --project tsconfig.build.json",
+    "test": "jest --coverage --verbose --detectOpenHandles --runInBand --bail",
+    "lint": "eslint src --max-warnings=0",
+    "prepack": "npm run build"
   },
-  "devDependencies": {
-    "@eslint/compat": "^1.4.0",
-    "@eslint/eslintrc": "^3.3.4",
-    "@eslint/js": "^9.39.4",
-    "@stylistic/eslint-plugin-ts": "^4.4.1",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^25.3.3",
+  "dependencies": {
+    "@eleven-am/pondsocket-common": "^0.0.41",
+    "@types/node": "^20.19.43",
     "@types/ws": "^8.18.1",
-    "@typescript-eslint/eslint-plugin": "^8.59.4",
-    "@typescript-eslint/parser": "^8.59.4",
-    "eslint": "^9.39.4",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-import-resolver-node": "^0.3.9",
-    "eslint-plugin-file-progress": "^3.0.2",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.5",
-    "globals": "^16.4.0",
-    "jest": "^30.2.0",
-    "prettier": "^3.8.3",
-    "source-map-support": "^0.5.21",
-    "supertest": "^7.2.2",
-    "ts-jest": "^29.4.11",
-    "ts-loader": "^9.5.7",
-    "ts-node": "^10.9.2",
-    "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.9.3"
+    "redis": "^6.1.0",
+    "ws": "^8.21.0"
   },
   "jest": {
     "moduleFileExtensions": [
@@ -85,7 +70,7 @@
     "rootDir": "src",
     "testRegex": ".*\\.test\\.ts$",
     "transform": {
-      "^.+\\.(t|j)s$": [
+      "^.+\\.ts$": [
         "ts-jest",
         {
           "diagnostics": false
@@ -93,15 +78,14 @@
       ]
     },
     "collectCoverageFrom": [
-      "**/*.(t|j)s",
+      "**/*.ts",
       "!**/*.test.ts",
       "!**/*.d.ts",
       "!**/index.ts",
       "!**/tests/**",
-      "!**/types.d.ts",
       "!**/abstracts/distributor.ts"
     ],
-    "coverageDirectory": "../coverage",
+    "coverageDirectory": "../coverage/core",
     "testEnvironment": "node",
     "moduleNameMapper": {
       "^@eleven-am/pondsocket-common$": "<rootDir>/../../comnon/dist"

package/contexts/outgoingContext.d.ts

@@ -1,28 +0,0 @@
-import { ChannelReceivers, AnyPondSchema, Event, EventParams, EventPayload, EventsOf, PondObject } from '@eleven-am/pondsocket-common';
-import { BaseContext } from './baseContext';
-import { ChannelEngine } from '../engines/channelEngine';
-export declare class OutgoingContext<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, EventName extends Extract<keyof EventsOf<Schema>, string> = Extract<keyof EventsOf<Schema>, string>> extends BaseContext<Path, Schema, EventName, EventPayload<EventsOf<Schema>, EventName>> {
-    #private;
-    constructor(event: Event, params: EventParams<Path>, engine: ChannelEngine, userid: string);
-    get payload(): EventPayload<EventsOf<Schema>, EventName>;
-    /**
-     * Blocks the outgoing context, preventing further processing of the event.
-     */
-    block(): this;
-    /**
-     * Checks if the outgoing context is blocked.
-     * @returns {boolean} - True if blocked, false otherwise.
-     */
-    isBlocked(): boolean;
-    /**
-     * Transforms the outgoing context with a new payload.
-     * @param payload - The new payload to set for the context.
-     */
-    transform(payload: EventPayload<EventsOf<Schema>, EventName>): this;
-    /**
-     * Updates the parameters of the outgoing context.
-     * @param params - The new parameters to set for the context.
-     */
-    updateParams(params: EventParams<Path>): void;
-    protected _sendMessageToRecipients(_recipient: ChannelReceivers, _event: string, _payload: PondObject): void;
-}