@eleven-am/pondsocket 0.1.213 → 0.1.215

package/engines/endpointEngine.d.ts

@@ -0,0 +1,34 @@
+import { ChannelEvent, PondPath } from '@eleven-am/pondsocket-common';
+import { WebSocket } from 'ws';
+import { AuthorizationHandler, SocketCache } from '../abstracts/types';
+import { IDistributedBackend } from '../types';
+import { PondChannel } from '../wrappers/pondChannel';
+export declare class EndpointEngine {
+    #private;
+    readonly path: string;
+    constructor(path: string, backend: IDistributedBackend | null, maxMessageSize?: number);
+    /**
+     * Creates a new channel on a specified path
+     */
+    createChannel<Path extends string>(path: PondPath<Path>, handler: AuthorizationHandler<Path>): PondChannel;
+    /**
+     * Gets all connected clients
+     */
+    getClients(): SocketCache[];
+    /**
+     * Gets a specific user by client ID
+     */
+    getUser(clientId: string): SocketCache;
+    /**
+     * Manages a new WebSocket connection
+     */
+    manageSocket(cache: SocketCache): void;
+    /**
+     * Sends a message to a WebSocket
+     */
+    sendMessage(socket: WebSocket, message: ChannelEvent): void;
+    /**
+     * Closes one or more client connections
+     */
+    closeConnection(clientIds: string | string[]): void;
+}

package/engines/endpointEngine.js

@@ -10,10 +10,11 @@ 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 _EndpointEngine_instances, _EndpointEngine_sockets, _EndpointEngine_backend, _EndpointEngine_middleware, _EndpointEngine_lobbyEngines, _EndpointEngine_handleSocketClose, _EndpointEngine_handleMessage, _EndpointEngine_joinChannel, _EndpointEngine_leaveChannel, _EndpointEngine_retrieveChannel, _EndpointEngine_buildError, _EndpointEngine_broadcastMessage, _EndpointEngine_readMessage;
+var _EndpointEngine_instances, _EndpointEngine_sockets, _EndpointEngine_backend, _EndpointEngine_middleware, _EndpointEngine_lobbyEngines, _EndpointEngine_maxMessageSize, _EndpointEngine_handleSocketClose, _EndpointEngine_handleMessage, _EndpointEngine_joinChannel, _EndpointEngine_leaveChannel, _EndpointEngine_retrieveChannel, _EndpointEngine_buildError, _EndpointEngine_broadcastMessage, _EndpointEngine_readMessage;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EndpointEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const ws_1 = require("ws");
 const lobbyEngine_1 = require("./lobbyEngine");
 const middleware_1 = require("../abstracts/middleware");
 const joinContext_1 = require("../contexts/joinContext");
@@ -21,17 +22,19 @@ const httpError_1 = require("../errors/httpError");
 const matcher_1 = require("../matcher/matcher");
 const pondChannel_1 = require("../wrappers/pondChannel");
 class EndpointEngine {
-    constructor(path, backend) {
+    constructor(path, backend, maxMessageSize = 1024 * 1024) {
         _EndpointEngine_instances.add(this);
         this.path = path;
         _EndpointEngine_sockets.set(this, void 0);
         _EndpointEngine_backend.set(this, void 0);
         _EndpointEngine_middleware.set(this, void 0);
         _EndpointEngine_lobbyEngines.set(this, void 0);
+        _EndpointEngine_maxMessageSize.set(this, void 0);
         __classPrivateFieldSet(this, _EndpointEngine_sockets, new Map(), "f");
         __classPrivateFieldSet(this, _EndpointEngine_lobbyEngines, new Map(), "f");
         __classPrivateFieldSet(this, _EndpointEngine_middleware, new middleware_1.Middleware(), "f");
         __classPrivateFieldSet(this, _EndpointEngine_backend, backend || null, "f");
+        __classPrivateFieldSet(this, _EndpointEngine_maxMessageSize, maxMessageSize, "f");
     }
     /**
      * Creates a new channel on a specified path
@@ -79,7 +82,7 @@ class EndpointEngine {
         __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").set(cache.clientId, cache);
         cache.socket.on('message', (message) => __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_readMessage).call(this, cache, message));
         cache.socket.on('close', () => __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_handleSocketClose).call(this, cache));
-        cache.socket.on('error', () => __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_handleSocketClose).call(this, cache));
+        cache.socket.on('error', () => { });
         const event = {
             event: pondsocket_common_1.Events.CONNECTION,
             action: pondsocket_common_1.ServerActions.CONNECT,
@@ -93,7 +96,9 @@ class EndpointEngine {
      * Sends a message to a WebSocket
      */
     sendMessage(socket, message) {
-        socket.send(JSON.stringify(message));
+        if (socket.readyState === ws_1.WebSocket.OPEN) {
+            socket.send(JSON.stringify(message));
+        }
     }
     /**
      * Closes one or more client connections
@@ -109,13 +114,13 @@ class EndpointEngine {
     }
 }
 exports.EndpointEngine = EndpointEngine;
-_EndpointEngine_sockets = new WeakMap(), _EndpointEngine_backend = new WeakMap(), _EndpointEngine_middleware = new WeakMap(), _EndpointEngine_lobbyEngines = new WeakMap(), _EndpointEngine_instances = new WeakSet(), _EndpointEngine_handleSocketClose = function _EndpointEngine_handleSocketClose(cache) {
+_EndpointEngine_sockets = new WeakMap(), _EndpointEngine_backend = new WeakMap(), _EndpointEngine_middleware = new WeakMap(), _EndpointEngine_lobbyEngines = new WeakMap(), _EndpointEngine_maxMessageSize = new WeakMap(), _EndpointEngine_instances = new WeakSet(), _EndpointEngine_handleSocketClose = function _EndpointEngine_handleSocketClose(cache) {
     try {
         __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").delete(cache.clientId);
         cache.subscriptions.forEach((unsubscribe) => unsubscribe());
     }
-    catch (e) {
-        // no-op
+    catch (_a) {
+        void 0;
     }
 }, _EndpointEngine_handleMessage = function _EndpointEngine_handleMessage(cache, message) {
     switch (message.action) {
@@ -181,6 +186,9 @@ _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_backend = new WeakMap()
     engine.broadcastMessage(socket.clientId, message);
 }, _EndpointEngine_readMessage = function _EndpointEngine_readMessage(cache, message) {
     try {
+        if (message.length > __classPrivateFieldGet(this, _EndpointEngine_maxMessageSize, "f")) {
+            throw new httpError_1.HttpError(413, `Message size ${message.length} exceeds maximum allowed size of ${__classPrivateFieldGet(this, _EndpointEngine_maxMessageSize, "f")} bytes`);
+        }
         const data = JSON.parse(message);
         const result = pondsocket_common_1.clientMessageSchema.parse(data);
         __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_handleMessage).call(this, cache, result);

package/engines/lobbyEngine.d.ts

@@ -0,0 +1,54 @@
+import { Event, PondPath } from '@eleven-am/pondsocket-common';
+import { ChannelEngine } from './channelEngine';
+import { EndpointEngine } from './endpointEngine';
+import { Middleware } from '../abstracts/middleware';
+import { BroadcastEvent, EventHandler, LeaveCallback, OutgoingEventHandler } from '../abstracts/types';
+import { OutgoingContext } from '../contexts/outgoingContext';
+import { IDistributedBackend } from '../types';
+import { Channel } from '../wrappers/channel';
+export declare class LobbyEngine {
+    #private;
+    parent: EndpointEngine;
+    leaveCallback: LeaveCallback | undefined;
+    readonly middleware: Middleware<BroadcastEvent, ChannelEngine>;
+    readonly outgoing: Middleware<OutgoingContext<string>, Event>;
+    constructor(parent: EndpointEngine, backend: IDistributedBackend | null);
+    /**
+     * Sets the callback for when users leave channels
+     */
+    onLeave(callback: LeaveCallback): void;
+    /**
+     * Attaches a handler for a specific event pattern
+     */
+    onEvent<Event extends string>(event: PondPath<Event>, handler: EventHandler<Event>): void;
+    /**
+     * Attaches a handler for outgoing events
+     */
+    handleOutgoingEvent<Event extends string>(event: PondPath<Event>, handler: OutgoingEventHandler<Event>): void;
+    /**
+     * Processes an outgoing event, applying middleware and returning a new event
+     * @param event - The channel event to process
+     * @param engine - The channel engine handling the event
+     * @param userId - The ID of the user sending the event
+     * @returns A new ChannelEvent or undefined if blocked
+     */
+    processOutgoingEvents(event: Event, engine: ChannelEngine, userId: string): Promise<Event | undefined>;
+    /**
+     * Gets or creates a channel by name
+     */
+    getOrCreateChannel(channelName: string): ChannelEngine;
+    /**
+     * Gets a channel by name
+     * @throws HttpError if a channel not found
+     */
+    getChannel(channelName: string): ChannelEngine;
+    /**
+     * Creates a Channel wrapper from a ChannelEngine
+     * Used by the channel engine for the leave callback
+     */
+    wrapChannel(engine: ChannelEngine): Channel;
+    /**
+     * Broadcasts an event to all users in a channel
+     */
+    deleteChannel(channelName: string): void;
+}

package/engines/lobbyEngine.js

@@ -73,7 +73,7 @@ class LobbyEngine {
             if (payload === undefined || payload === null) {
                 return;
             }
-            context.transform(Object.assign(Object.assign({}, chEvent), { payload }));
+            context.transform(payload);
             return next();
         }));
     }

package/engines/presenceEngine.d.ts

@@ -0,0 +1,15 @@
+import { PondPresence } from '@eleven-am/pondsocket-common';
+import { InternalChannelEvent } from '../abstracts/types';
+export type PublishCallback = (event: InternalChannelEvent) => void;
+export declare class PresenceEngine {
+    #private;
+    constructor(channelId: string, publish: PublishCallback);
+    get presenceCount(): number;
+    trackPresence(userId: string, data: PondPresence): void;
+    updatePresence(userId: string, data: PondPresence): void;
+    removePresence(userId: string): void;
+    upsertPresence(userId: string, data: PondPresence): void;
+    getPresence(userId: string): PondPresence | null;
+    getAllPresence(): Map<string, PondPresence>;
+    close(): void;
+}

package/engines/presenceEngine.js

@@ -10,102 +10,49 @@ 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 _PresenceEngine_instances, _PresenceEngine_presenceCache, _PresenceEngine_publisher, _PresenceEngine_channelId, _PresenceEngine_processPresenceAction;
+var _PresenceEngine_instances, _PresenceEngine_presenceCache, _PresenceEngine_publish, _PresenceEngine_channelId, _PresenceEngine_processPresenceAction;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PresenceEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
-/**
- * Manages user presence for a channel
- */
 class PresenceEngine {
-    /**
-     * Creates a new Presence manager
-     * @param channelId - The ID of the channel this presence belongs to
-     */
-    constructor(channelId) {
+    constructor(channelId, publish) {
         _PresenceEngine_instances.add(this);
         _PresenceEngine_presenceCache.set(this, new Map());
-        _PresenceEngine_publisher.set(this, new pondsocket_common_1.Subject());
+        _PresenceEngine_publish.set(this, void 0);
         _PresenceEngine_channelId.set(this, void 0);
         __classPrivateFieldSet(this, _PresenceEngine_channelId, channelId, "f");
+        __classPrivateFieldSet(this, _PresenceEngine_publish, publish, "f");
     }
-    /**
-     * Gets the number of users with presence data
-     */
     get presenceCount() {
         return __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").size;
     }
-    /**
-     * Track a new user's presence
-     * @param userId - The ID of the user
-     * @param data - The presence data
-     * @returns The generated presence event
-     */
     trackPresence(userId, data) {
         return __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_processPresenceAction).call(this, pondsocket_common_1.PresenceEventTypes.JOIN, userId, data);
     }
-    /**
-     * Update an existing user's presence
-     * @param userId - The ID of the user
-     * @param data - The updated presence data
-     * @returns The generated presence event
-     */
     updatePresence(userId, data) {
         return __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_processPresenceAction).call(this, pondsocket_common_1.PresenceEventTypes.UPDATE, userId, data);
     }
-    /**
-     * Remove a user's presence
-     * @param userId - The ID of the user
-     * @returns The generated presence event
-     */
     removePresence(userId) {
         return __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_processPresenceAction).call(this, pondsocket_common_1.PresenceEventTypes.LEAVE, userId, null);
     }
-    /**
-     * Add or update a user's presence
-     * @param userId - The ID of the user
-     * @param data - The presence data
-     * @returns The generated presence event
-     */
     upsertPresence(userId, data) {
         if (__classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").has(userId)) {
             return this.updatePresence(userId, data);
         }
         return this.trackPresence(userId, data);
     }
-    /**
-     * Get a specific user's presence
-     * @param userId - The ID of the user
-     * @returns The user's presence data or null if not found
-     */
     getPresence(userId) {
         return __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").get(userId) || null;
     }
-    /**
-     * Get presence data for all users
-     * @returns A copy of all presence data
-     */
     getAllPresence() {
         return new Map(__classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f"));
     }
-    /**
-     * Subscribe to presence events
-     * @param callback - The callback to invoke when presence changes
-     * @returns A function to unsubscribe
-     */
-    subscribe(callback) {
-        return __classPrivateFieldGet(this, _PresenceEngine_publisher, "f").subscribe(callback);
-    }
-    /**
-     * Clear all presence data and close the publisher
-     */
     close() {
         __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").clear();
-        __classPrivateFieldGet(this, _PresenceEngine_publisher, "f").close();
     }
 }
 exports.PresenceEngine = PresenceEngine;
-_PresenceEngine_presenceCache = new WeakMap(), _PresenceEngine_publisher = new WeakMap(), _PresenceEngine_channelId = new WeakMap(), _PresenceEngine_instances = new WeakSet(), _PresenceEngine_processPresenceAction = function _PresenceEngine_processPresenceAction(action, userId, data) {
+_PresenceEngine_presenceCache = new WeakMap(), _PresenceEngine_publish = new WeakMap(), _PresenceEngine_channelId = new WeakMap(), _PresenceEngine_instances = new WeakSet(), _PresenceEngine_processPresenceAction = function _PresenceEngine_processPresenceAction(action, userId, data) {
     if (action === pondsocket_common_1.PresenceEventTypes.JOIN && __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").has(userId)) {
         throw new Error(`User with id ${userId} already exists in the presence cache`);
     }
@@ -135,5 +82,5 @@ _PresenceEngine_presenceCache = new WeakMap(), _PresenceEngine_publisher = new W
             presence: total,
         },
     };
-    __classPrivateFieldGet(this, _PresenceEngine_publisher, "f").publish(internalEvent);
+    __classPrivateFieldGet(this, _PresenceEngine_publish, "f").call(this, internalEvent);
 };

package/errors/httpError.d.ts

@@ -0,0 +1,6 @@
+export declare class HttpError extends Error {
+    readonly statusCode: number;
+    readonly statusText: string;
+    constructor(statusCode: number, message: string);
+    static getStatusText(statusCode: number): "Bad Request" | "Unauthorized" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Conflict" | "Payload Too Large" | "Too Many Requests" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "Unknown Error";
+}

package/errors/httpError.js

@@ -24,6 +24,8 @@ class HttpError extends Error {
                 return 'Not Acceptable';
             case 409:
                 return 'Conflict';
+            case 413:
+                return 'Payload Too Large';
             case 429:
                 return 'Too Many Requests';
             case 500:

package/index.d.ts

@@ -1,5 +1,14 @@
-import { PondSocket } from './types';
-
-export { RedisDistributedBackend } from './types';
-
-export default PondSocket;
+export { PondSocket } from './server/server';
+export { RedisDistributedBackend } from './abstracts/distributor';
+export { Endpoint } from './wrappers/endpoint';
+export { PondChannel } from './wrappers/pondChannel';
+export { Channel } from './wrappers/channel';
+export { ConnectionContext } from './contexts/connectionContext';
+export { BaseContext } from './contexts/baseContext';
+export { JoinContext } from './contexts/joinContext';
+export { EventContext } from './contexts/eventContext';
+export { OutgoingContext } from './contexts/outgoingContext';
+export { HttpError } from './errors/httpError';
+export type { ConnectionHandler, AuthorizationHandler, EventHandler, OutgoingEventHandler, LeaveCallback, LeaveEvent, NextFunction, } from './abstracts/types';
+export * from './types';
+export * from '@eleven-am/pondsocket-common';

package/index.js

@@ -1,7 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisDistributedBackend = void 0;
-const server_1 = require("./server/server");
+exports.HttpError = exports.OutgoingContext = exports.EventContext = exports.JoinContext = exports.BaseContext = exports.ConnectionContext = exports.Channel = exports.PondChannel = exports.Endpoint = exports.RedisDistributedBackend = exports.PondSocket = void 0;
+var server_1 = require("./server/server");
+Object.defineProperty(exports, "PondSocket", { enumerable: true, get: function () { return server_1.PondSocket; } });
 var distributor_1 = require("./abstracts/distributor");
 Object.defineProperty(exports, "RedisDistributedBackend", { enumerable: true, get: function () { return distributor_1.RedisDistributedBackend; } });
-exports.default = server_1.PondSocket;
+var endpoint_1 = require("./wrappers/endpoint");
+Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return endpoint_1.Endpoint; } });
+var pondChannel_1 = require("./wrappers/pondChannel");
+Object.defineProperty(exports, "PondChannel", { enumerable: true, get: function () { return pondChannel_1.PondChannel; } });
+var channel_1 = require("./wrappers/channel");
+Object.defineProperty(exports, "Channel", { enumerable: true, get: function () { return channel_1.Channel; } });
+var connectionContext_1 = require("./contexts/connectionContext");
+Object.defineProperty(exports, "ConnectionContext", { enumerable: true, get: function () { return connectionContext_1.ConnectionContext; } });
+var baseContext_1 = require("./contexts/baseContext");
+Object.defineProperty(exports, "BaseContext", { enumerable: true, get: function () { return baseContext_1.BaseContext; } });
+var joinContext_1 = require("./contexts/joinContext");
+Object.defineProperty(exports, "JoinContext", { enumerable: true, get: function () { return joinContext_1.JoinContext; } });
+var eventContext_1 = require("./contexts/eventContext");
+Object.defineProperty(exports, "EventContext", { enumerable: true, get: function () { return eventContext_1.EventContext; } });
+var outgoingContext_1 = require("./contexts/outgoingContext");
+Object.defineProperty(exports, "OutgoingContext", { enumerable: true, get: function () { return outgoingContext_1.OutgoingContext; } });
+var httpError_1 = require("./errors/httpError");
+Object.defineProperty(exports, "HttpError", { enumerable: true, get: function () { return httpError_1.HttpError; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("@eleven-am/pondsocket-common"), exports);

package/matcher/matcher.d.ts

@@ -0,0 +1,2 @@
+import { EventParams, PondPath } from '@eleven-am/pondsocket-common';
+export declare function parseAddress<Path extends string>(route: PondPath<Path>, address: string): EventParams<Path> | null;

package/matcher/matcher.js

@@ -43,12 +43,12 @@ function getQuery(query) {
     if (!query) {
         return {};
     }
-    const parts = query.split('&');
-    return parts.reduce((params, part) => {
-        const [key, value] = part.split('=');
+    const searchParams = new URLSearchParams(query);
+    const params = {};
+    searchParams.forEach((value, key) => {
         params[key] = value;
-        return params;
-    }, {});
+    });
+    return params;
 }
 function parseAddress(route, address) {
     if (route instanceof RegExp) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.213",
+  "version": "0.1.215",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -17,11 +17,10 @@
   },
   "scripts": {
     "test": "jest --coverage --verbose --forceExit --detectOpenHandles --runInBand --bail",
-    "build": "rimraf dist && tsc && npm run remove",
+    "build": "rimraf dist && tsc --project tsconfig.build.json && rm -rf dist/tests",
     "lint": "eslint --ext .ts src",
     "lint:fix": "eslint --fix --ext .ts src",
-    "remove": "rm -r dist/tests && rm dist/distIndex.js",
-    "copy": "cp src/types.d.ts dist/types.d.ts && cp src/distIndex.ts dist/index.d.ts && cp package.json dist && cp README.md dist && cp LICENSE dist",
+    "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"
   },
@@ -29,37 +28,47 @@
   "license": "GPL-3.0",
   "main": "./index.js",
   "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./types": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Eleven-am/pondSocket.git"
   },
   "dependencies": {
-    "@eleven-am/pondsocket-common": "^0.0.29",
-    "redis": "^5.8.3",
-    "ws": "^8.18.3"
+    "@eleven-am/pondsocket-common": "^0.0.37",
+    "redis": "^5.11.0",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
     "@eslint/compat": "^1.4.0",
-    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/eslintrc": "^3.3.4",
     "@eslint/js": "^9.38.0",
     "@stylistic/eslint-plugin-ts": "^4.4.1",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.8.1",
+    "@types/node": "^25.3.3",
     "@types/ws": "^8.18.1",
-    "@typescript-eslint/eslint-plugin": "^8.46.1",
-    "@typescript-eslint/parser": "^8.46.1",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
     "eslint": "^9.38.0",
     "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.4",
+    "eslint-plugin-prettier": "^5.5.5",
     "globals": "^16.4.0",
     "jest": "^30.2.0",
-    "prettier": "^3.6.2",
+    "prettier": "^3.8.1",
     "source-map-support": "^0.5.21",
-    "supertest": "^7.1.4",
-    "ts-jest": "^29.4.5",
+    "supertest": "^7.2.2",
+    "ts-jest": "^29.4.6",
     "ts-loader": "^9.5.4",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
@@ -74,12 +83,26 @@
     "rootDir": "src",
     "testRegex": ".*\\.test\\.ts$",
     "transform": {
-      "^.+\\.(t|j)s$": "ts-jest"
+      "^.+\\.(t|j)s$": [
+        "ts-jest",
+        {
+          "diagnostics": false
+        }
+      ]
     },
     "collectCoverageFrom": [
-      "**/*.(t|j)s"
+      "**/*.(t|j)s",
+      "!**/*.test.ts",
+      "!**/*.d.ts",
+      "!**/index.ts",
+      "!**/tests/**",
+      "!**/types.d.ts",
+      "!**/abstracts/distributor.ts"
     ],
     "coverageDirectory": "../coverage",
-    "testEnvironment": "node"
+    "testEnvironment": "node",
+    "moduleNameMapper": {
+      "^@eleven-am/pondsocket-common$": "<rootDir>/../../comnon/dist"
+    }
   }
 }

package/server/server.d.ts

@@ -0,0 +1,21 @@
+import { IncomingMessage, Server as HTTPServer } from 'http';
+import { PondPath } from '@eleven-am/pondsocket-common';
+import { ConnectionHandler } from '../abstracts/types';
+import { PondSocketOptions } from '../types';
+import { Endpoint } from '../wrappers/endpoint';
+export declare class PondSocket {
+    #private;
+    constructor({ server, socketServer, exclusiveServer, distributedBackend, maxMessageSize, heartbeatInterval, }?: PondSocketOptions);
+    /**
+     * Start listening for connections
+     */
+    listen(...args: any[]): HTTPServer<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
+    /**
+     * Close the server
+     */
+    close(callback?: (err?: Error) => void, timeout?: number): HTTPServer<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
+    /**
+     * Create a new endpoint
+     */
+    createEndpoint<Path extends string>(path: PondPath<Path>, handler: ConnectionHandler<Path>): Endpoint;
+}