@eleven-am/pondsocket 0.1.217 → 0.1.219

package/{engines → dist/engines}/channelEngine.js

@@ -30,7 +30,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var _ChannelEngine_instances, _ChannelEngine_endpointId, _ChannelEngine_backend, _ChannelEngine_nodeId, _ChannelEngine_presenceEngine, _ChannelEngine_assignsCache, _ChannelEngine_userSubscriptions, _ChannelEngine_publisher, _ChannelEngine_distributedSubscription, _ChannelEngine_heartbeatSubscription, _ChannelEngine_nodeLastSeen, _ChannelEngine_nodeUsers, _ChannelEngine_staleNodeTimer, _ChannelEngine_name, _ChannelEngine_closed, _ChannelEngine_distributedReady, _ChannelEngine_safeRemovePresence, _ChannelEngine_buildSubscriber, _ChannelEngine_getOrCreatePresenceEngine, _ChannelEngine_getUsersFromRecipients, _ChannelEngine_setupDistributedSubscription, _ChannelEngine_afterDistributedReady, _ChannelEngine_handleDistributedMessage, _ChannelEngine_requestChannelState, _ChannelEngine_handleStateRequest, _ChannelEngine_handleStateResponse, _ChannelEngine_handleRemoteUserJoined, _ChannelEngine_handleRemoteUserLeft, _ChannelEngine_handleRemoteMessage, _ChannelEngine_handleRemotePresenceUpdate, _ChannelEngine_handleRemotePresenceRemoved, _ChannelEngine_handleRemoteAssignsUpdate, _ChannelEngine_handleRemoteEvictUser, _ChannelEngine_setupHeartbeatTracking, _ChannelEngine_cleanupStaleNodes, _ChannelEngine_trackNodeUser, _ChannelEngine_untrackNodeUser, _ChannelEngine_broadcastToNodes;
+var _ChannelEngine_instances, _ChannelEngine_endpointId, _ChannelEngine_backend, _ChannelEngine_nodeId, _ChannelEngine_presenceEngine, _ChannelEngine_assignsCache, _ChannelEngine_userSubscriptions, _ChannelEngine_publisher, _ChannelEngine_distributedSubscription, _ChannelEngine_heartbeatSubscription, _ChannelEngine_nodeLastSeen, _ChannelEngine_nodeUsers, _ChannelEngine_pendingUserGets, _ChannelEngine_staleNodeTimer, _ChannelEngine_name, _ChannelEngine_closed, _ChannelEngine_distributedReady, _ChannelEngine_safeRemovePresence, _ChannelEngine_buildSubscriber, _ChannelEngine_getOrCreatePresenceEngine, _ChannelEngine_getUsersFromRecipients, _ChannelEngine_setupDistributedSubscription, _ChannelEngine_afterDistributedReady, _ChannelEngine_handleDistributedMessage, _ChannelEngine_requestChannelState, _ChannelEngine_handleStateRequest, _ChannelEngine_handleStateResponse, _ChannelEngine_handleRemoteUserJoined, _ChannelEngine_handleRemoteUserLeft, _ChannelEngine_handleRemoteMessage, _ChannelEngine_handleRemotePresenceUpdate, _ChannelEngine_handleRemotePresenceRemoved, _ChannelEngine_handleRemoteAssignsUpdate, _ChannelEngine_handleRemoteEvictUser, _ChannelEngine_handleRemoteUserRemove, _ChannelEngine_handleRemoteUserGetRequest, _ChannelEngine_handleRemoteUserGetResponse, _ChannelEngine_setupHeartbeatTracking, _ChannelEngine_cleanupStaleNodes, _ChannelEngine_trackNodeUser, _ChannelEngine_untrackNodeUser, _ChannelEngine_broadcastToNodes;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -59,6 +59,7 @@ class ChannelEngine {
         _ChannelEngine_heartbeatSubscription.set(this, null);
         _ChannelEngine_nodeLastSeen.set(this, new Map());
         _ChannelEngine_nodeUsers.set(this, new Map());
+        _ChannelEngine_pendingUserGets.set(this, new Map());
         _ChannelEngine_staleNodeTimer.set(this, null);
         _ChannelEngine_name.set(this, void 0);
         _ChannelEngine_closed.set(this, false);
@@ -78,7 +79,7 @@ class ChannelEngine {
     get users() {
         return new Set(__classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").keys());
     }
-    addUser(userId, assigns, onMessage) {
+    addUser(userId, assigns, onMessage, requestId = (0, pondsocket_common_1.uuid)()) {
         if (this.users.has(userId)) {
             const message = `ChannelEngine: User with id ${userId} already exists in channel ${this.name}`;
             throw new httpError_1.HttpError(400, message);
@@ -86,7 +87,7 @@ class ChannelEngine {
         const isFirstUser = this.users.size === 0;
         onMessage({
             channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
-            requestId: (0, pondsocket_common_1.uuid)(),
+            requestId,
             action: pondsocket_common_1.ServerActions.SYSTEM,
             event: pondsocket_common_1.Events.ACKNOWLEDGE,
             payload: {},
@@ -222,6 +223,38 @@ class ChannelEngine {
         });
         this.removeUser(userId, true);
     }
+    requestUserRemoval(userId) {
+        __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+            type: types_1.DistributedMessageType.USER_REMOVE,
+            endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+            channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+            userId,
+        });
+    }
+    getUserAcrossNodes(userId, timeoutMs = 5000) {
+        if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            return Promise.resolve(null);
+        }
+        const requestId = (0, pondsocket_common_1.uuid)();
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").delete(requestId);
+                resolve(null);
+            }, timeoutMs);
+            __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").set(requestId, {
+                resolve,
+                timer,
+            });
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.USER_GET_REQUEST,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                requestId,
+                fromNode: __classPrivateFieldGet(this, _ChannelEngine_nodeId, "f"),
+            });
+        });
+    }
     getAssigns() {
         return mapToObject(__classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f"));
     }
@@ -238,9 +271,15 @@ class ChannelEngine {
         this.close();
     }
     removeUser(userId, skipDistributedBroadcast = false) {
+        let userData;
+        try {
+            userData = this.getUserData(userId);
+        }
+        catch (_a) {
+            return;
+        }
+        const unsubscribe = __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").get(userId);
         try {
-            const userData = this.getUserData(userId);
-            const unsubscribe = __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").get(userId);
             __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").delete(userId);
             __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_safeRemovePresence).call(this, userId);
             if (unsubscribe) {
@@ -255,19 +294,25 @@ class ChannelEngine {
                     userId,
                 });
             }
-            if (this.parent.leaveCallback) {
-                this.parent.leaveCallback({
+        }
+        catch (_) {
+            void 0;
+        }
+        if (this.users.size === 0) {
+            this.close();
+        }
+        if (this.parent.leaveCallback) {
+            try {
+                const result = this.parent.leaveCallback({
                     user: userData,
                     channel: this.parent.wrapChannel(this),
                 });
+                void Promise.resolve(result).catch(() => { });
             }
-            if (this.users.size === 0) {
-                this.close();
+            catch (_) {
+                void 0;
             }
         }
-        catch (_) {
-            void 0;
-        }
     }
     getUserData(userId) {
         var _a;
@@ -304,6 +349,8 @@ class ChannelEngine {
             clearInterval(__classPrivateFieldGet(this, _ChannelEngine_staleNodeTimer, "f"));
             __classPrivateFieldSet(this, _ChannelEngine_staleNodeTimer, null, "f");
         }
+        __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").forEach((pending) => clearTimeout(pending.timer));
+        __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").clear();
         __classPrivateFieldGet(this, _ChannelEngine_nodeLastSeen, "f").clear();
         __classPrivateFieldGet(this, _ChannelEngine_nodeUsers, "f").clear();
         __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").close();
@@ -311,7 +358,7 @@ class ChannelEngine {
     }
 }
 exports.ChannelEngine = ChannelEngine;
-_ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(), _ChannelEngine_nodeId = new WeakMap(), _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new WeakMap(), _ChannelEngine_userSubscriptions = new WeakMap(), _ChannelEngine_publisher = new WeakMap(), _ChannelEngine_distributedSubscription = new WeakMap(), _ChannelEngine_heartbeatSubscription = new WeakMap(), _ChannelEngine_nodeLastSeen = new WeakMap(), _ChannelEngine_nodeUsers = new WeakMap(), _ChannelEngine_staleNodeTimer = new WeakMap(), _ChannelEngine_name = new WeakMap(), _ChannelEngine_closed = new WeakMap(), _ChannelEngine_distributedReady = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_safeRemovePresence = function _ChannelEngine_safeRemovePresence(userId) {
+_ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(), _ChannelEngine_nodeId = new WeakMap(), _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new WeakMap(), _ChannelEngine_userSubscriptions = new WeakMap(), _ChannelEngine_publisher = new WeakMap(), _ChannelEngine_distributedSubscription = new WeakMap(), _ChannelEngine_heartbeatSubscription = new WeakMap(), _ChannelEngine_nodeLastSeen = new WeakMap(), _ChannelEngine_nodeUsers = new WeakMap(), _ChannelEngine_pendingUserGets = new WeakMap(), _ChannelEngine_staleNodeTimer = new WeakMap(), _ChannelEngine_name = new WeakMap(), _ChannelEngine_closed = new WeakMap(), _ChannelEngine_distributedReady = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_safeRemovePresence = function _ChannelEngine_safeRemovePresence(userId) {
     if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
         try {
             __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(userId);
@@ -421,6 +468,15 @@ _ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(
         case types_1.DistributedMessageType.EVICT_USER:
             __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteEvictUser).call(this, message);
             break;
+        case types_1.DistributedMessageType.USER_REMOVE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteUserRemove).call(this, message);
+            break;
+        case types_1.DistributedMessageType.USER_GET_REQUEST:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteUserGetRequest).call(this, message);
+            break;
+        case types_1.DistributedMessageType.USER_GET_RESPONSE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteUserGetResponse).call(this, message);
+            break;
         case types_1.DistributedMessageType.NODE_HEARTBEAT:
             break;
         default:
@@ -545,6 +601,40 @@ _ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(
         unsubscribe();
         __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").delete(message.userId);
     }
+}, _ChannelEngine_handleRemoteUserRemove = function _ChannelEngine_handleRemoteUserRemove(message) {
+    if (__classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").has(message.userId)) {
+        this.removeUser(message.userId);
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").delete(message.userId);
+    __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_safeRemovePresence).call(this, message.userId);
+    __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_untrackNodeUser).call(this, message.sourceNodeId, message.userId);
+}, _ChannelEngine_handleRemoteUserGetRequest = function _ChannelEngine_handleRemoteUserGetRequest(message) {
+    var _a;
+    if (!__classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").has(message.userId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+        type: types_1.DistributedMessageType.USER_GET_RESPONSE,
+        endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+        channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+        userId: message.userId,
+        requestId: message.requestId,
+        assigns: __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").get(message.userId) || {},
+        presence: ((_a = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) === null || _a === void 0 ? void 0 : _a.getPresence(message.userId)) || {},
+    });
+}, _ChannelEngine_handleRemoteUserGetResponse = function _ChannelEngine_handleRemoteUserGetResponse(message) {
+    const pending = __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").get(message.requestId);
+    if (!pending) {
+        return;
+    }
+    clearTimeout(pending.timer);
+    __classPrivateFieldGet(this, _ChannelEngine_pendingUserGets, "f").delete(message.requestId);
+    pending.resolve({
+        id: message.userId,
+        assigns: message.assigns || {},
+        presence: message.presence || {},
+    });
 }, _ChannelEngine_setupHeartbeatTracking = function _ChannelEngine_setupHeartbeatTracking() {
     if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
         return;

package/{engines → dist/engines}/endpointEngine.d.ts

@@ -1,4 +1,4 @@
-import { ChannelEvent, AnyPondSchema, PondPath } from '@eleven-am/pondsocket-common';
+import { ChannelEvent, AnyPondChannelDefinition, AnyPondSchema, PathOf, PondPath, SchemaOf } from '@eleven-am/pondsocket-common';
 import { WebSocket } from 'ws';
 import { AuthorizationHandler, SocketCache } from '../abstracts/types';
 import { IDistributedBackend } from '../types';
@@ -10,6 +10,7 @@ export declare class EndpointEngine {
     /**
      * Creates a new channel on a specified path
      */
+    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>;
     /**
      * Gets all connected clients

package/{engines → dist/engines}/endpointEngine.js

@@ -36,10 +36,14 @@ class EndpointEngine {
         __classPrivateFieldSet(this, _EndpointEngine_backend, backend || null, "f");
         __classPrivateFieldSet(this, _EndpointEngine_maxMessageSize, maxMessageSize, "f");
     }
-    /**
-     * Creates a new channel on a specified path
-     */
-    createChannel(path, handler) {
+    createChannel(pathOrDefinition, handler) {
+        const path = (0, pondsocket_common_1.isPondChannelDefinition)(pathOrDefinition) ? pathOrDefinition.path : pathOrDefinition;
+        if (typeof path === 'string') {
+            (0, pondsocket_common_1.compilePondRoute)(path);
+        }
+        if (__classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f").has(path)) {
+            throw new httpError_1.HttpError(409, `GatewayEngine: Channel pattern ${String(path)} is already registered`);
+        }
         const lobbyEngine = new lobbyEngine_1.LobbyEngine(this, __classPrivateFieldGet(this, _EndpointEngine_backend, "f"));
         __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => {
             const event = (0, matcher_1.parseAddress)(path, user.channelName);
@@ -52,7 +56,16 @@ class EndpointEngine {
                 };
                 const channel = lobbyEngine.getOrCreateChannel(user.channelName);
                 const context = new joinContext_1.JoinContext(options, channel, user);
-                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('Join handler completed without accepting or declining the request', 500);
+                    }
+                });
             }
             next();
         });
@@ -141,8 +154,9 @@ _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_backend = new WeakMap()
 }, _EndpointEngine_joinChannel = function _EndpointEngine_joinChannel(channel, socket, joinParams, requestId) {
     const cache = Object.assign(Object.assign({}, socket), { requestId, channelName: channel });
     __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").run(cache, joinParams, (error) => {
-        error = error || new httpError_1.HttpError(404, `GatewayEngine: Channel ${channel} does not exist`);
-        throw error;
+        const requestError = error || new httpError_1.HttpError(404, `GatewayEngine: Channel ${channel} does not exist`);
+        const errorType = error ? pondsocket_common_1.ErrorTypes.CHANNEL_ERROR : pondsocket_common_1.ErrorTypes.CHANNEL_NOT_FOUND;
+        this.sendMessage(socket.socket, __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_buildError).call(this, requestError, errorType, channel, requestId));
     });
 }, _EndpointEngine_leaveChannel = function _EndpointEngine_leaveChannel(channel, socket) {
     var _a;
@@ -161,7 +175,7 @@ _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_backend = new WeakMap()
         }
     }
     throw new httpError_1.HttpError(404, `GatewayEngine: Channel ${channel} does not exist`);
-}, _EndpointEngine_buildError = function _EndpointEngine_buildError(error) {
+}, _EndpointEngine_buildError = function _EndpointEngine_buildError(error, errorType = pondsocket_common_1.ErrorTypes.INVALID_MESSAGE, channelName = pondsocket_common_1.SystemSender.ENDPOINT, requestId = (0, pondsocket_common_1.uuid)()) {
     let message;
     let status;
     if (error instanceof httpError_1.HttpError) {
@@ -177,11 +191,15 @@ _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_backend = new WeakMap()
         status = 500;
     }
     const event = {
-        event: pondsocket_common_1.ErrorTypes.INVALID_MESSAGE,
+        event: errorType,
         action: pondsocket_common_1.ServerActions.ERROR,
-        channelName: pondsocket_common_1.SystemSender.ENDPOINT,
-        requestId: (0, pondsocket_common_1.uuid)(),
+        channelName,
+        requestId,
         payload: {
+            code: errorType,
+            message,
+            status,
+            statusCode: status,
             error: {
                 message,
                 status,

package/{engines → dist/engines}/lobbyEngine.js

@@ -22,6 +22,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _LobbyEngine_instances, _LobbyEngine_backend, _LobbyEngine_channels, _LobbyEngine_getChannel, _LobbyEngine_createChannel;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LobbyEngine = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const channelEngine_1 = require("./channelEngine");
 const middleware_1 = require("../abstracts/middleware");
 const eventContext_1 = require("../contexts/eventContext");
@@ -50,6 +51,9 @@ class LobbyEngine {
      * Attaches a handler for a specific event pattern
      */
     onEvent(event, handler) {
+        if (typeof event === 'string') {
+            (0, pondsocket_common_1.compilePondRoute)(event);
+        }
         this.middleware.use((requestEvent, channel, next) => {
             const params = (0, matcher_1.parseAddress)(event, requestEvent.event);
             if (!params) {
@@ -63,18 +67,17 @@ class LobbyEngine {
      * Attaches a handler for outgoing events
      */
     handleOutgoingEvent(event, handler) {
+        if (typeof event === 'string') {
+            (0, pondsocket_common_1.compilePondRoute)(event);
+        }
         this.outgoing.use((context, chEvent, next) => __awaiter(this, void 0, void 0, function* () {
             const params = (0, matcher_1.parseAddress)(event, chEvent.event);
             if (!params || context.isBlocked()) {
                 return next();
             }
-            context.updateParams(params);
-            const payload = yield handler(context, next);
-            if (payload === undefined || payload === null) {
-                return;
-            }
-            context.transform(payload);
-            return next();
+            const typedContext = context;
+            typedContext.updateParams(params);
+            yield handler(typedContext);
         }));
     }
     /**
@@ -88,8 +91,10 @@ class LobbyEngine {
         return __awaiter(this, void 0, void 0, function* () {
             const params = (0, matcher_1.parseAddress)('*', event.event);
             const context = new outgoingContext_1.OutgoingContext(event, params, engine, userId);
-            yield this.outgoing.runAsync(context, event, () => {
-                // no-op
+            yield this.outgoing.runAsync(context, event, (error) => {
+                if (error) {
+                    context.block();
+                }
             });
             if (context.isBlocked()) {
                 return;

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

@@ -8,6 +8,7 @@ export { BaseContext } from './contexts/baseContext';
 export { JoinContext } from './contexts/joinContext';
 export { EventContext } from './contexts/eventContext';
 export { OutgoingContext } from './contexts/outgoingContext';
+export type { OutgoingHandlerContext, OutgoingPayload } from './contexts/outgoingContext';
 export { HttpError } from './errors/httpError';
 export type { ConnectionHandler, AuthorizationHandler, EventHandler, OutgoingEventHandler, LeaveCallback, LeaveEvent, NextFunction, } from './abstracts/types';
 export * from './types';

package/dist/matcher/matcher.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAddress = parseAddress;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+function parseAddress(route, address) {
+    if (route instanceof RegExp) {
+        const match = address.match(route);
+        if (!match) {
+            return null;
+        }
+        return {
+            params: {},
+            query: {},
+        };
+    }
+    return (0, pondsocket_common_1.parsePondRoute)(route, address);
+}

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

@@ -1,21 +1,25 @@
 import { IncomingMessage, Server as HTTPServer } from 'http';
-import { PondPath } from '@eleven-am/pondsocket-common';
+import { PondEndpointDefinition, 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);
+    constructor({ server, socketServer, closeHttpServerOnShutdown, exclusiveServer, distributedBackend, maxMessageSize, heartbeatInterval, }?: PondSocketOptions);
     /**
      * Start listening for connections
      */
-    listen(...args: any[]): HTTPServer<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
+    listen(...args: any[]): HTTPServer<typeof IncomingMessage, typeof import("http").ServerResponse>;
     /**
      * Close the server
      */
-    close(callback?: (err?: Error) => void, timeout?: number): HTTPServer<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
+    close(callback?: (err?: Error) => void, timeout?: number): HTTPServer<typeof IncomingMessage, typeof import("http").ServerResponse>;
+    closeAsync(timeout?: number): Promise<void>;
+    ready(): Promise<void>;
+    isHealthy(): boolean;
     /**
      * Create a new endpoint
      */
+    createEndpoint<Path extends string>(definition: PondEndpointDefinition<Path>, handler: ConnectionHandler<Path>): Endpoint;
     createEndpoint<Path extends string>(path: PondPath<Path>, handler: ConnectionHandler<Path>): Endpoint;
 }