@socket-mesh/server 18.1.5 → 19.1.0

package/dist/broker/exchange.d.ts

@@ -1,4 +1,9 @@
-import { ChannelMap, Channels } from '@socket-mesh/channels';
+import { ChannelMap, Channels, ChannelsOptions } from '@socket-mesh/channels';
+interface ExchangeOptions extends ChannelsOptions {
+    id: string;
+}
 export declare abstract class Exchange<T extends ChannelMap> extends Channels<T> {
     id: string;
+    constructor(options: ExchangeOptions);
 }
+export {};

package/dist/broker/exchange.js

@@ -1,4 +1,8 @@
 import { Channels } from '@socket-mesh/channels';
 export class Exchange extends Channels {
     id;
+    constructor(options) {
+        super(options);
+        this.id = options.id;
+    }
 }

package/dist/broker/simple-exchange.d.ts

@@ -3,7 +3,6 @@ import { Broker } from './broker.js';
 import { Exchange } from './exchange.js';
 export declare class SimpleExchange<T extends ChannelMap> extends Exchange<T> {
     private readonly _broker;
-    readonly id: string;
     constructor(broker: Broker<T>, options?: ChannelsOptions);
     invokePublish<U extends keyof T & string>(channelName: U, data: T[U]): Promise<void>;
     transmit(event: '#publish', packet: PublishOptions): Promise<void>;

package/dist/broker/simple-exchange.js

@@ -1,10 +1,11 @@
 import { Exchange } from './exchange.js';
 export class SimpleExchange extends Exchange {
     _broker;
-    id;
     constructor(broker, options) {
-        super(options);
-        this.id = 'exchange';
+        super({
+            ...(options || {}),
+            id: 'exchange'
+        });
         this._broker = broker;
     }
     async invokePublish(channelName, data) {

package/dist/events/index.d.ts

@@ -1,19 +1,19 @@
 import { ChannelMap, SubscribeEvent, SubscribeFailEvent, SubscribeStateChangeEvent, UnsubscribeEvent } from '@socket-mesh/channels';
-import { ClientSocket, ServerPrivateMap } from '@socket-mesh/client';
-import { AuthenticateEvent, AuthStateChangeEvent, BadAuthTokenEvent, ConnectEvent, ConnectingEvent, DeauthenticateEvent, DisconnectEvent, MessageEvent, PingEvent, PongEvent, PrivateMethodMap, PublicMethodMap, RemoveAuthTokenEvent, RequestEvent, ResponseEvent, CloseEvent as SCloseEvent, ErrorEvent as SErrorEvent, ServiceMap } from '@socket-mesh/core';
+import { ClientPrivateMap, ClientSocket, ServerPrivateMap } from '@socket-mesh/client';
+import { AuthenticateEvent, AuthStateChangeEvent, BadAuthTokenEvent, ConnectEvent, ConnectingEvent, DeauthenticateEvent, DisconnectEvent, MessageEvent, PingEvent, PongEvent, PrivateMethodMap, PublicMethodMap, RemoveAuthTokenEvent, CloseEvent as SCloseEvent, ErrorEvent as SErrorEvent, ServiceMap, TypedRequestEvent, TypedResponseEvent } from '@socket-mesh/core';
 import { IncomingMessage } from 'http';
 import { ServerSocket } from '../server-socket.js';
 export interface CloseEvent {
 }
-export interface ConnectionEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
-    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export interface ConnectionEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> {
+    socket: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
     upgradeReq: IncomingMessage;
 }
 export interface ErrorEvent {
     error: Error;
 }
-export interface HandshakeEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
-    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export interface HandshakeEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> {
+    socket: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
 }
 export interface HeadersEvent {
     headers: string[];
@@ -21,29 +21,29 @@ export interface HeadersEvent {
 }
 export interface ListeningEvent {
 }
-export type ServerEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = CloseEvent | ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | ErrorEvent | HandshakeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | HeadersEvent | ListeningEvent | SocketAuthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketAuthStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketBadAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketCloseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketConnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketConnectingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketDeauthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketDisconnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketErrorEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketMessageEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketPingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketPongEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketRemoveAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | SocketRequestEvent<TService, TIncoming, TPrivateIncoming> | SocketResponseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState> | WarningEvent;
-export interface ServerSocketEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
-    socket: ClientSocket<PublicMethodMap, TChannel, TService, TState, TOutgoing & TPrivateOutgoing, TPrivateIncoming> | ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-}
-export type SocketAuthenticateEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = AuthenticateEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketAuthStateChangeEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = AuthStateChangeEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketBadAuthTokenEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = BadAuthTokenEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketCloseEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = SCloseEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketConnectEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = ConnectEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketConnectingEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = ConnectingEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketDeauthenticateEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = DeauthenticateEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketDisconnectEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = DisconnectEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketErrorEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = SErrorEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketMessageEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = MessageEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketPingEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = PingEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketPongEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = PongEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketRemoveAuthTokenEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = RemoveAuthTokenEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketRequestEvent<TService extends ServiceMap, TIncoming extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap> = RequestEvent<TIncoming & TPrivateIncoming & ServerPrivateMap, TService>;
-export type SocketResponseEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = ResponseEvent<TOutgoing, TPrivateOutgoing, TService> & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketSubscribeEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = SubscribeEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketSubscribeFailEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = SubscribeFailEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketSubscribeStateChangeEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = SubscribeStateChangeEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export type SocketUnsubscribeEvent<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> = UnsubscribeEvent & ServerSocketEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export type ServerEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = CloseEvent | ConnectionEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | ErrorEvent | HandshakeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | HeadersEvent | ListeningEvent | SocketAuthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketAuthStateChangeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketBadAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketCloseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketConnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketConnectingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketDeauthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketDisconnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketErrorEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketMessageEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketPingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketPongEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketRemoveAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | SocketRequestEvent<TIncoming, TService, TPrivateIncoming> | SocketResponseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState> | WarningEvent;
+export interface ServerSocketEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> {
+    socket: ClientSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateOutgoing> | ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+}
+export type SocketAuthenticateEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = AuthenticateEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketAuthStateChangeEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = AuthStateChangeEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketBadAuthTokenEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = BadAuthTokenEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketCloseEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = SCloseEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketConnectEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = ConnectEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketConnectingEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = ConnectingEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketDeauthenticateEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = DeauthenticateEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketDisconnectEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = DisconnectEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketErrorEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = SErrorEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketMessageEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = MessageEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketPingEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = PingEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketPongEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = PongEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketRemoveAuthTokenEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = RemoveAuthTokenEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketRequestEvent<TIncoming extends PublicMethodMap, TService extends ServiceMap, TPrivateIncoming extends PrivateMethodMap> = TypedRequestEvent<TIncoming & TPrivateIncoming & ServerPrivateMap, TService>;
+export type SocketResponseEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = TypedResponseEvent<TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService> & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketSubscribeEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = SubscribeEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketSubscribeFailEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = SubscribeFailEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketSubscribeStateChangeEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = SubscribeStateChangeEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export type SocketUnsubscribeEvent<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> = UnsubscribeEvent & ServerSocketEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
 export interface WarningEvent {
     warning: Error;
 }

package/dist/handlers/authenticate.js

@@ -1,4 +1,6 @@
+import { toError } from '@socket-mesh/core';
 import { AuthTokenError, AuthTokenExpiredError, AuthTokenInvalidError, AuthTokenNotBeforeError, InvalidActionError } from '@socket-mesh/errors';
+import jwt from 'jsonwebtoken';
 const HANDSHAKE_REJECTION_STATUS_CODE = 4008;
 ;
 export async function authenticateHandler({ isRpc, options: signedAuthToken, socket, transport }) {
@@ -40,17 +42,17 @@ export async function processAuthentication(socket, transport, authInfo) {
     return await transport.setAuthorization(authInfo.signedAuthToken, authInfo.authToken);
 }
 function processTokenError(err) {
-    if (err.name === 'TokenExpiredError' && 'expiredAt' in err) {
+    if (err instanceof jwt.TokenExpiredError) {
         return new AuthTokenExpiredError(err.message, err.expiredAt);
     }
-    if (err.name === 'JsonWebTokenError') {
-        return new AuthTokenInvalidError(err.message);
-    }
-    if (err.name === 'NotBeforeError' && 'date' in err) {
+    if (err instanceof jwt.NotBeforeError) {
         // In this case, the token is good; it's just not active yet.
         return new AuthTokenNotBeforeError(err.message, err.date);
     }
-    return new AuthTokenError(err.message);
+    if (err instanceof jwt.JsonWebTokenError) {
+        return new AuthTokenInvalidError(err.message);
+    }
+    return new AuthTokenError(toError(err).message);
 }
 export async function validateAuthToken(auth, authToken, verificationOptions) {
     try {

package/dist/handlers/handshake.js

@@ -1,4 +1,4 @@
-import { wait } from '@socket-mesh/core';
+import { toError, wait } from '@socket-mesh/core';
 import { dehydrateError } from '@socket-mesh/errors';
 import { processAuthentication, validateAuthToken } from './authenticate.js';
 const HANDSHAKE_REJECTION_STATUS_CODE = 4008;
@@ -18,10 +18,11 @@ export async function handshakeHandler({ options, socket, transport }) {
                 });
             }
             catch (err) {
-                if (err.statusCode == null) {
-                    err.statusCode = HANDSHAKE_REJECTION_STATUS_CODE;
+                const error = toError(err);
+                if (!('statusCode' in error)) {
+                    error.statusCode = HANDSHAKE_REJECTION_STATUS_CODE;
                 }
-                throw err;
+                throw error;
             }
         }
     }

package/dist/handlers/publish.d.ts

@@ -1,5 +1,5 @@
 import { PublishOptions } from '@socket-mesh/channels';
 import { ServerRequestHandlerArgs } from './server-request-handler.js';
-export declare function publishHandler({ options, socket, transport }: ServerRequestHandlerArgs<PublishOptions, {}, {
+export declare function publishHandler({ options, socket, transport }: ServerRequestHandlerArgs<PublishOptions, {}, {}, {
     [channel: string]: any;
 }>): Promise<void>;

package/dist/handlers/remove-auth-token.d.ts

@@ -1,4 +1,4 @@
-import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
+import { ClientPrivateMap } from '@socket-mesh/client';
 import { SocketTransport } from '@socket-mesh/core';
 import { ServerSocketState } from '../server-socket-state.js';
-export declare function deauthenticate(transport: SocketTransport<ServerPrivateMap, {}, ClientPrivateMap, {}, ServerSocketState>): Promise<boolean>;
+export declare function deauthenticate(transport: SocketTransport<{}, {}, ServerSocketState, {}, {}, ClientPrivateMap>): Promise<boolean>;

package/dist/handlers/server-request-handler.d.ts

@@ -1,7 +1,6 @@
 import { ChannelMap } from '@socket-mesh/channels';
-import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
 import { PrivateMethodMap, PublicMethodMap, RequestHandlerArgs, ServiceMap } from '@socket-mesh/core';
 import { ServerSocketState } from '../server-socket-state.js';
 import { ServerSocket } from '../server-socket.js';
 import { ServerTransport } from '../server-transport.js';
-export type ServerRequestHandlerArgs<TOptions, TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> = RequestHandlerArgs<TOptions, TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState, ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>, ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
+export type ServerRequestHandlerArgs<TOptions, TIncoming extends PublicMethodMap = any, TOutgoing extends PublicMethodMap = any, TChannel extends ChannelMap = any, TService extends ServiceMap = any, TState extends object = any, TPrivateIncoming extends PrivateMethodMap = any, TPrivateOutgoing extends PrivateMethodMap = any, TServerState extends object = any> = RequestHandlerArgs<TOptions, TState & ServerSocketState, ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>, ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;

package/dist/index.d.ts

@@ -17,7 +17,7 @@ export type { PluginType } from '@socket-mesh/core';
  * @return {AGServer} websocket cluster server
  * @api public
  */
-export declare function attach<TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(server: http.Server, options?: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export declare function attach<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}>(server: http.Server, options?: ServerOptions<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): Server<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
 /**
  * Creates an http.Server exclusively used for WS upgrades.
  *
@@ -27,6 +27,6 @@ export declare function attach<TChannel extends ChannelMap = {}, TService extend
  * @return {AGServer} websocket cluster server
  * @api public
  */
-export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(port: number, options: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-export declare function listen<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}>(port: number, options: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>, fn: () => void): Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+export declare function listen<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}>(): Server<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export declare function listen<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}>(port: number, options: ServerOptions<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): Server<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+export declare function listen<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}>(port: number, options: ServerOptions<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>, fn: () => void): Server<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;

package/dist/plugin/server-plugin.d.ts

@@ -1,33 +1,31 @@
 import { ChannelMap, ChannelOptions } from '@socket-mesh/channels';
-import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
 import { Plugin, PrivateMethodMap, PublicMethodMap, ServiceMap } from '@socket-mesh/core';
 import { IncomingMessage } from 'http';
 import { AuthInfo } from '../handlers/authenticate.js';
-import { ServerSocketState } from '../server-socket-state.js';
 import { ServerSocket } from '../server-socket.js';
 import { ServerTransport } from '../server-transport.js';
-export interface HandshakePluginArgs<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
+export interface HandshakePluginArgs<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> {
     authInfo: AuthInfo;
-    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-    transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    socket: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+    transport: ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
 }
-export interface PublishPluginArgs<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
+export interface PublishPluginArgs<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> {
     channel: string;
     data: any;
-    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-    transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    socket: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+    transport: ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
 }
-export interface ServerPlugin<TIncoming extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> extends Plugin<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
+export interface ServerPlugin<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> extends Plugin<ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>, ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>> {
     onAuthenticate?: (authInfo: AuthInfo) => void;
     onConnection?: (request: IncomingMessage) => Promise<void>;
-    onHandshake?: (options: HandshakePluginArgs<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>) => Promise<void>;
-    onPublishIn?: (options: PublishPluginArgs<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>) => Promise<any>;
-    onPublishOut?: (options: PublishPluginArgs<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>) => Promise<any>;
-    onSubscribe?: (options: SubscribePluginArgs<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>) => Promise<void>;
+    onHandshake?: (options: HandshakePluginArgs<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>) => Promise<void>;
+    onPublishIn?: (options: PublishPluginArgs<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>) => Promise<any>;
+    onPublishOut?: (options: PublishPluginArgs<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>) => Promise<any>;
+    onSubscribe?: (options: SubscribePluginArgs<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>) => Promise<void>;
 }
-export interface SubscribePluginArgs<TChannel extends ChannelMap, TService extends ServiceMap, TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> {
+export interface SubscribePluginArgs<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> {
     channel: string;
     options: ChannelOptions;
-    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-    transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    socket: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+    transport: ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
 }

package/dist/server-options.d.ts

@@ -1,25 +1,31 @@
 import { AuthEngine, AuthOptions } from '@socket-mesh/auth-engine';
 import { ChannelMap } from '@socket-mesh/channels';
-import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
+import { ServerPrivateMap } from '@socket-mesh/client';
 import { CallIdGenerator, HandlerMap, PrivateMethodMap, PublicMethodMap, ServiceMap, StreamCleanupMode } from '@socket-mesh/core';
 import { CodecEngine } from '@socket-mesh/formatter';
 import { ServerOptions as WebSocketServerOptions } from 'ws';
 import { Broker } from './broker/broker.js';
 import { ServerPlugin } from './plugin/server-plugin.js';
-export interface ServerOptions<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> extends WebSocketServerOptions {
+import { ServerSocketState } from './server-socket-state.js';
+import { ServerSocket } from './server-socket.js';
+import { ServerTransport } from './server-transport.js';
+export interface ServerOptions<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}> extends WebSocketServerOptions {
     ackTimeoutMs?: number;
     allowClientPublish?: boolean;
     authEngine?: AuthEngine | AuthOptions;
     brokerEngine?: Broker<TChannel>;
     callIdGenerator?: CallIdGenerator;
     codecEngine?: CodecEngine;
-    handlers?: HandlerMap<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState>;
+    handlers?: HandlerMap<TIncoming & TPrivateIncoming & ServerPrivateMap, TState & ServerSocketState, ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>, ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
     handshakeTimeoutMs?: number;
     isPingTimeoutDisabled?: boolean;
     origins?: string;
     pingIntervalMs?: number;
     pingTimeoutMs?: number;
-    plugins?: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
+    plugins?: ServerPlugin<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>[];
+    serviceHandlers?: {
+        [TServiceName in keyof TService & string]?: HandlerMap<TService[TServiceName], TState & ServerSocketState, ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>, ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    };
     socketChannelLimit?: number;
     socketStreamCleanupMode?: StreamCleanupMode;
     strictHandshake?: boolean;

package/dist/server-socket.d.ts

@@ -1,30 +1,77 @@
 import { ChannelMap } from '@socket-mesh/channels';
 import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
-import { HandlerMap, PrivateMethodMap, PublicMethodMap, ServiceMap, Socket, SocketOptions } from '@socket-mesh/core';
+import { AuthenticateEvent, AuthStateChangeEvent, BadAuthTokenEvent, BaseSocket, BaseSocketOptions, CloseEvent, ConnectEvent, ConnectingEvent, DeauthenticateEvent, DisconnectEvent, ErrorEvent, FunctionReturnType, InvokeMethodOptions, InvokeServiceOptions, MessageEvent, PingEvent, PongEvent, PrivateMethodMap, PublicMethodMap, RemoveAuthTokenEvent, RequestEvent, ResponseEvent, ServiceMap, ServiceMethodName, ServiceName, Socket, TypedRequestEvent, TypedResponseEvent, TypedSocketEvent } from '@socket-mesh/core';
+import { DemuxedConsumableStream, StreamEvent } from '@socket-mesh/stream-demux';
 import { IncomingMessage } from 'http';
 import { WebSocket } from 'ws';
 import { Exchange } from './broker/exchange.js';
 import { ServerPlugin } from './plugin/server-plugin.js';
 import { ServerSocketState } from './server-socket-state.js';
 import { Server } from './server.js';
-export interface ServerSocketOptions<TIncoming extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object, TState extends object> extends SocketOptions<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
-    handlers: HandlerMap<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState>;
+export interface ServerSocketOptions<TIncoming extends PublicMethodMap, TOutgoing extends PublicMethodMap, TChannel extends ChannelMap, TService extends ServiceMap, TState extends object, TPrivateIncoming extends PrivateMethodMap, TPrivateOutgoing extends PrivateMethodMap, TServerState extends object> extends BaseSocketOptions<TState & ServerSocketState> {
     id?: string;
-    plugins?: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
+    plugins?: ServerPlugin<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>[];
     request: IncomingMessage;
-    server: Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    server: Server<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
     service?: string;
     socket: WebSocket;
 }
-export declare class ServerSocket<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> extends Socket<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
+export declare class ServerSocket<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}> extends BaseSocket<TState & ServerSocketState> implements Socket<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TState & ServerSocketState, TService, {}, TPrivateOutgoing & ClientPrivateMap> {
     private _serverTransport;
-    readonly server: Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-    constructor(options: ServerSocketOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
+    readonly server: Server<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+    constructor(options: ServerSocketOptions<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>);
     deauthenticate(rejectOnFailedDelivery?: boolean): Promise<boolean>;
+    emit(event: 'request', data: TypedRequestEvent<TIncoming & TPrivateIncoming & ServerPrivateMap, TService>): void;
+    emit(event: 'response', data: TypedResponseEvent<TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService>): void;
+    emit(event: 'authStateChange', data: AuthStateChangeEvent): void;
+    emit(event: 'authenticate', data: AuthenticateEvent): void;
+    emit(event: 'badAuthToken', data: BadAuthTokenEvent): void;
+    emit(event: 'close', data: CloseEvent): void;
+    emit(event: 'connect', data: ConnectEvent): void;
+    emit(event: 'connectAbort', data: DisconnectEvent): void;
+    emit(event: 'connecting', data: ConnectingEvent): void;
+    emit(event: 'deauthenticate', data: DeauthenticateEvent): void;
+    emit(event: 'disconnect', data: DisconnectEvent): void;
+    emit(event: 'end'): void;
+    emit(event: 'error', data: ErrorEvent): void;
+    emit(event: 'message', data: MessageEvent): void;
+    emit(event: 'ping', data: PingEvent): void;
+    emit(event: 'pong', data: PongEvent): void;
+    emit(event: 'removeAuthToken', data: RemoveAuthTokenEvent): void;
+    emit(event: 'request', data: RequestEvent): void;
+    emit(event: 'response', data: ResponseEvent): void;
     get exchange(): Exchange<TChannel>;
     get id(): string;
+    invoke<TMethod extends keyof TOutgoing & string>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
+    invoke<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: [TServiceName, TMethod, (false | number)?], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
+    invoke<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: InvokeServiceOptions<TService, TServiceName, TMethod>, arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
+    invoke<TMethod extends keyof TOutgoing & string>(options: InvokeMethodOptions<TOutgoing, TMethod>, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
+    invoke<TMethod extends keyof (TPrivateOutgoing & ClientPrivateMap) & string>(method: TMethod, arg: Parameters<(TPrivateOutgoing & ClientPrivateMap)[TMethod]>[0]): Promise<FunctionReturnType<(TPrivateOutgoing & ClientPrivateMap)[TMethod]>>;
+    invoke<TMethod extends keyof (TPrivateOutgoing & ClientPrivateMap) & string>(options: InvokeMethodOptions<(TPrivateOutgoing & ClientPrivateMap), TMethod>, arg?: Parameters<(TPrivateOutgoing & ClientPrivateMap)[TMethod]>[0]): Promise<FunctionReturnType<(TPrivateOutgoing & ClientPrivateMap)[TMethod]>>;
     kickOut(channel: string, message: string): Promise<void[]>;
+    listen(): DemuxedConsumableStream<StreamEvent<TypedSocketEvent<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService>>>;
+    listen(event: 'authStateChange'): DemuxedConsumableStream<AuthStateChangeEvent>;
+    listen(event: 'authenticate'): DemuxedConsumableStream<AuthenticateEvent>;
+    listen(event: 'badAuthToken'): DemuxedConsumableStream<BadAuthTokenEvent>;
+    listen(event: 'close'): DemuxedConsumableStream<CloseEvent>;
+    listen(event: 'connect'): DemuxedConsumableStream<ConnectEvent>;
+    listen(event: 'connectAbort'): DemuxedConsumableStream<DisconnectEvent>;
+    listen(event: 'connecting'): DemuxedConsumableStream<ConnectingEvent>;
+    listen(event: 'deauthenticate'): DemuxedConsumableStream<DeauthenticateEvent>;
+    listen(event: 'disconnect'): DemuxedConsumableStream<DisconnectEvent>;
+    listen(event: 'end'): DemuxedConsumableStream<void>;
+    listen(event: 'error'): DemuxedConsumableStream<ErrorEvent>;
+    listen(event: 'message'): DemuxedConsumableStream<MessageEvent>;
+    listen(event: 'ping'): DemuxedConsumableStream<PingEvent>;
+    listen(event: 'pong'): DemuxedConsumableStream<PongEvent>;
+    listen(event: 'removeAuthToken'): DemuxedConsumableStream<RemoveAuthTokenEvent>;
+    listen(event: 'request'): DemuxedConsumableStream<TypedRequestEvent<TIncoming & TPrivateIncoming & ServerPrivateMap, TService>>;
+    listen(event: 'response'): DemuxedConsumableStream<TypedResponseEvent<TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService>>;
+    listen<U extends TypedSocketEvent<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService>, V = U>(event: string): DemuxedConsumableStream<V>;
     ping(): Promise<void>;
     get service(): string | undefined;
+    transmit<TMethod extends keyof TOutgoing & string>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<void>;
+    transmit<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: [TServiceName, TMethod], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<void>;
+    transmit<TMethod extends keyof (TPrivateOutgoing & ClientPrivateMap) & string>(method: TMethod, arg?: Parameters<(TPrivateOutgoing & ClientPrivateMap)[TMethod]>[0]): Promise<void>;
     get type(): 'server';
 }

package/dist/server-socket.js

@@ -1,6 +1,6 @@
-import { Socket } from '@socket-mesh/core';
+import { BaseSocket, toError } from '@socket-mesh/core';
 import { ServerTransport } from './server-transport.js';
-export class ServerSocket extends Socket {
+export class ServerSocket extends BaseSocket {
     _serverTransport;
     server;
     constructor(options) {
@@ -15,7 +15,8 @@ export class ServerSocket extends Socket {
             try {
                 await this._serverTransport.invoke('#removeAuthToken', undefined)[0];
             }
-            catch (error) {
+            catch (err) {
+                const error = toError(err);
                 this._serverTransport.onError(error);
                 throw error;
             }
@@ -25,18 +26,24 @@ export class ServerSocket extends Socket {
             await this.transmit('#removeAuthToken');
         }
         catch (err) {
-            if (err.name !== 'BadConnectionError') {
+            if (toError(err).name !== 'BadConnectionError') {
                 throw err;
             }
         }
         return result;
     }
+    emit(event, data) {
+        super.emit(event, data);
+    }
     get exchange() {
         return this.server.exchange;
     }
     get id() {
         return this._serverTransport.id;
     }
+    invoke(methodOptions, arg) {
+        return super.invoke(methodOptions, arg);
+    }
     kickOut(channel, message) {
         const channels = channel ? [channel] : Object.keys(this.state.channelSubscriptions || {});
         return Promise.all(channels.map((channelName) => {
@@ -44,12 +51,18 @@ export class ServerSocket extends Socket {
             return this._serverTransport.unsubscribe(channelName);
         }));
     }
+    listen(event) {
+        return super.listen(event ?? '');
+    }
     ping() {
         return this._serverTransport.ping();
     }
     get service() {
         return this._serverTransport.service;
     }
+    transmit(serviceAndMethod, arg) {
+        return super.transmit(serviceAndMethod, arg);
+    }
     get type() {
         return this._serverTransport.type;
     }

package/dist/server-transport.d.ts

@@ -2,37 +2,46 @@ import { AuthToken, SignedAuthToken } from '@socket-mesh/auth';
 import { AuthTokenOptions } from '@socket-mesh/auth-engine';
 import { ChannelMap, PublishOptions } from '@socket-mesh/channels';
 import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
-import { AnyPacket, AnyResponse, InboundMessage, InvokeMethodRequest, InvokeServiceRequest, PrivateMethodMap, PublicMethodMap, ServiceMap, SocketStatus, SocketTransport, TransmitMethodRequest, TransmitServiceRequest } from '@socket-mesh/core';
+import { AnyPacket, AnyRequest, AnyResponse, BaseSocketTransport, FunctionReturnType, InboundMessage, InvokeMethodOptions, InvokeServiceOptions, PrivateMethodMap, PublicMethodMap, ServiceMap, ServiceMethodName, ServiceName, SocketStatus, SocketTransport } from '@socket-mesh/core';
 import { IncomingMessage } from 'http';
 import { Data } from 'ws';
 import { ServerPlugin } from './plugin/server-plugin.js';
 import { ServerSocketState } from './server-socket-state.js';
 import { ServerSocket, ServerSocketOptions } from './server-socket.js';
-export declare class ServerTransport<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> extends SocketTransport<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState & ServerSocketState> {
+export declare class ServerTransport<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}> extends BaseSocketTransport<TState & ServerSocketState> implements SocketTransport<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TState & ServerSocketState, TService, {}, TPrivateOutgoing & ClientPrivateMap> {
     id: string;
-    readonly plugins: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
+    readonly plugins: ServerPlugin<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>[];
     readonly request: IncomingMessage;
     readonly service?: string;
     type: 'server';
-    constructor(options: ServerSocketOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
+    constructor(options: ServerSocketOptions<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>);
     changeToUnauthenticatedState(): Promise<boolean>;
-    protected handleInboudMessage({ packet, timestamp }: InboundMessage<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService>): Promise<void>;
+    protected handleInboudMessage({ packet, timestamp }: InboundMessage): Promise<void>;
+    invoke<TMethod extends keyof TOutgoing & string>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TOutgoing[TMethod]>>, () => void];
+    invoke<TMethod extends keyof TOutgoing & string>(options: InvokeMethodOptions<TOutgoing, TMethod>, arg?: Parameters<TOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TOutgoing[TMethod]>>, () => void];
+    invoke<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: [TServiceName, TMethod, (false | number)?], arg?: Parameters<TService[TServiceName][TMethod]>[0]): [Promise<FunctionReturnType<TService[TServiceName][TMethod]>>, () => void];
+    invoke<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: InvokeServiceOptions<TService, TServiceName, TMethod>, arg?: Parameters<TService[TServiceName][TMethod]>[0]): [Promise<FunctionReturnType<TService[TServiceName][TMethod]>>, () => void];
+    invoke<TMethod extends keyof (TPrivateOutgoing & ClientPrivateMap) & string>(method: TMethod, arg: Parameters<(TPrivateOutgoing & ClientPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(TPrivateOutgoing & ClientPrivateMap)[TMethod]>>, () => void];
+    invoke<TMethod extends keyof (TPrivateOutgoing & ClientPrivateMap) & string>(options: InvokeMethodOptions<(TPrivateOutgoing & ClientPrivateMap), TMethod>, arg?: Parameters<(TPrivateOutgoing & ClientPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(TPrivateOutgoing & ClientPrivateMap)[TMethod]>>, () => void];
     protected onClose(code: number, reason?: Buffer | string): void;
     protected onDisconnect(status: SocketStatus, code: number, reason?: string): void;
     onError(error: Error): void;
-    protected onInvoke<TServiceName extends keyof TService, TServiceMethod extends keyof TService[TServiceName], TMethod extends keyof TOutgoing, TPrivateMethod extends keyof TPrivateOutgoing>(request: InvokeMethodRequest<TOutgoing, TMethod> | InvokeMethodRequest<TPrivateOutgoing, TPrivateMethod> | InvokeServiceRequest<TService, TServiceName, TServiceMethod>): void;
+    protected onInvoke(request: AnyRequest): void;
     protected onMessage(data: Data, isBinary: boolean): void;
     protected onPingPong(): void;
     protected onPublish(options: PublishOptions): Promise<void>;
-    protected onRequest(packet: AnyPacket<TIncoming & TPrivateIncoming & ServerPrivateMap, TService>, timestamp: Date, pluginError?: Error): Promise<boolean>;
-    protected onResponse(response: AnyResponse<TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService>): void;
-    protected onTransmit<TServiceName extends keyof TService, TServiceMethod extends keyof TService[TServiceName], TMethod extends keyof TOutgoing>(request: TransmitMethodRequest<TOutgoing, TMethod> | TransmitServiceRequest<TService, TServiceName, TServiceMethod>): void;
+    protected onRequest(packet: AnyPacket, timestamp: Date, pluginError?: Error): Promise<boolean>;
+    protected onResponse(response: AnyResponse): void;
+    protected onTransmit(request: AnyRequest): void;
     ping(): Promise<void>;
     setAuthorization(authToken: AuthToken, options?: AuthTokenOptions): Promise<boolean>;
     setAuthorization(signedAuthToken: SignedAuthToken, authToken?: AuthToken): Promise<boolean>;
     setReadyStatus(pingTimeoutMs: number, authError?: Error): void;
-    get socket(): ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-    set socket(value: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
+    get socket(): ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
+    set socket(value: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>);
+    transmit<TMethod extends keyof TOutgoing & string>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<void>;
+    transmit<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: [TServiceName, TMethod], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<void>;
+    transmit<TMethod extends keyof (TPrivateOutgoing & ClientPrivateMap) & string>(method: TMethod, arg?: Parameters<(TPrivateOutgoing & ClientPrivateMap)[TMethod]>[0]): Promise<void>;
     triggerAuthenticationEvents(wasSigned: boolean, wasAuthenticated: boolean): void;
     unsubscribe(channel: string): Promise<void>;
 }

package/dist/server-transport.js

@@ -1,7 +1,7 @@
-import { abortRequest, SocketTransport } from '@socket-mesh/core';
+import { abortRequest, BaseSocketTransport, toError } from '@socket-mesh/core';
 import { AuthError, BrokerError, InvalidActionError, SocketProtocolErrorStatuses } from '@socket-mesh/errors';
 import base64id from 'base64id';
-export class ServerTransport extends SocketTransport {
+export class ServerTransport extends BaseSocketTransport {
     id;
     plugins;
     request;
@@ -36,6 +36,9 @@ export class ServerTransport extends SocketTransport {
         }
         return await super.handleInboudMessage({ packet, timestamp });
     }
+    invoke(methodOptions, arg) {
+        return super.invoke(methodOptions, arg);
+    }
     onClose(code, reason) {
         const status = this.status;
         const strReason = reason?.toString() || SocketProtocolErrorStatuses[code];
@@ -179,9 +182,10 @@ export class ServerTransport extends SocketTransport {
             signedAuthToken = await auth.signToken(authToken, options);
         }
         catch (err) {
-            this.onError(err);
-            this.disconnect(4002, err.toString());
-            throw err;
+            const error = toError(err);
+            this.onError(error);
+            this.disconnect(4002, error.toString());
+            throw error;
         }
         const changed = await super.setAuthorization(signedAuthToken, authToken);
         if (changed && this.status === 'ready') {
@@ -192,15 +196,9 @@ export class ServerTransport extends SocketTransport {
                 await this.invoke('#setAuthToken', signedAuthToken)[0];
             }
             catch (err) {
-                let error;
-                if (err && typeof err.message === 'string') {
-                    error = new AuthError(`Failed to deliver auth token to client - ${err.message}`);
-                }
-                else {
-                    error = new AuthError('Failed to confirm delivery of auth token to client due to malformatted error response');
-                }
-                this.onError(error);
-                throw error;
+                const authError = new AuthError(`Failed to deliver auth token to client - ${toError(err).message}`);
+                this.onError(authError);
+                throw authError;
             }
             return changed;
         }
@@ -208,7 +206,7 @@ export class ServerTransport extends SocketTransport {
             await this.transmit('#setAuthToken', signedAuthToken);
         }
         catch (err) {
-            if (err.name !== 'BadConnectionError') {
+            if (toError(err).name !== 'BadConnectionError') {
                 throw err;
             }
         }
@@ -224,6 +222,9 @@ export class ServerTransport extends SocketTransport {
     set socket(value) {
         super.socket = value;
     }
+    transmit(serviceAndMethod, arg) {
+        return super.transmit(serviceAndMethod, arg);
+    }
     triggerAuthenticationEvents(wasSigned, wasAuthenticated) {
         if (!this.signedAuthToken) {
             throw new AuthError('Signed auth token should be set to trigger authentication events');

package/dist/server.d.ts

@@ -1,7 +1,8 @@
 import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
 import { AuthEngine } from '@socket-mesh/auth-engine';
 import { ChannelMap } from '@socket-mesh/channels';
-import { PrivateMethodMap, PublicMethodMap, ServiceMap, StreamCleanupMode } from '@socket-mesh/core';
+import { ServerPrivateMap } from '@socket-mesh/client';
+import { HandlerMap, MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, StreamCleanupMode } from '@socket-mesh/core';
 import { CodecEngine } from '@socket-mesh/formatter';
 import { DemuxedConsumableStream, StreamEvent } from '@socket-mesh/stream-demux';
 import { Server as HttpServer } from 'http';
@@ -10,10 +11,12 @@ import { Exchange } from './broker/exchange.js';
 import { CloseEvent, ConnectionEvent, ErrorEvent, HandshakeEvent, HeadersEvent, ListeningEvent, ServerEvent, SocketAuthenticateEvent, SocketAuthStateChangeEvent, SocketBadAuthTokenEvent, SocketCloseEvent, SocketConnectEvent, SocketConnectingEvent, SocketDeauthenticateEvent, SocketDisconnectEvent, SocketErrorEvent, SocketMessageEvent, SocketPingEvent, SocketPongEvent, SocketRemoveAuthTokenEvent, SocketRequestEvent, SocketResponseEvent, SocketSubscribeEvent, SocketSubscribeFailEvent, SocketSubscribeStateChangeEvent, SocketUnsubscribeEvent, WarningEvent } from './events/index.js';
 import { ServerPlugin } from './plugin/server-plugin.js';
 import { ServerOptions } from './server-options.js';
+import { ServerSocketState } from './server-socket-state.js';
 import { ServerSocket } from './server-socket.js';
-export declare class Server<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> extends AsyncStreamEmitter<ServerEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>> {
+import { ServerTransport } from './server-transport.js';
+export declare class Server<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}> extends AsyncStreamEmitter<ServerEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>> {
     private readonly _callIdGenerator;
-    private _handlers;
+    private readonly _handlers;
     private _isListening;
     private _isReady;
     private _pingIntervalRef;
@@ -24,7 +27,7 @@ export declare class Server<TIncoming extends PublicMethodMap = {}, TChannel ext
     readonly brokerEngine: Broker<TChannel>;
     clientCount: number;
     readonly clients: {
-        [id: string]: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+        [id: string]: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
     };
     readonly codecEngine: CodecEngine;
     readonly httpServer: HttpServer;
@@ -32,86 +35,135 @@ export declare class Server<TIncoming extends PublicMethodMap = {}, TChannel ext
     origins: string;
     pendingClientCount: number;
     readonly pendingClients: {
-        [id: string]: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+        [id: string]: ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>;
     };
     pingIntervalMs: number;
     pingTimeoutMs: number;
-    readonly plugins: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
+    readonly plugins: ServerPlugin<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>[];
     socketChannelLimit?: number;
     readonly socketStreamCleanupMode: StreamCleanupMode;
     strictHandshake: boolean;
-    constructor(options?: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
-    addPlugin(...plugin: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[]): void;
+    constructor(options?: ServerOptions<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>);
+    /**
+     * Register a group of strongly-typed request handlers.
+     *
+     * Handlers added this way can be added or replaced after the server has
+     * started and are immediately visible to all existing and future
+     * connections (the underlying handler map is shared by reference).
+     *
+     * When called with a service name, the handlers are grouped under that
+     * service and surfaced via {@link services} so UI/tooling can list which
+     * groups are currently installed. When the service name is known to the
+     * server's `TService` generic, TypeScript validates the handler shape
+     * against the declared method map. For ad-hoc/dynamic services not
+     * present in `TService`, pass an explicit generic argument with the
+     * method map for the new service.
+     *
+     * When called without a service name, the handlers are registered as
+     * flat (top-level) handlers routed by method name alone — the same
+     * surface as `options.handlers` on the server constructor. These do not
+     * appear in {@link services}.
+     *
+     * @example
+     * // Flat handlers (no service name):
+     * server.addHandlers({ doThing: async (args) => { ... } });
+     *
+     * @example
+     * // Statically declared on the server generic:
+     * server.addHandlers('account', { find: async (args) => { ... } });
+     *
+     * @example
+     * // Dynamically added from a module at runtime:
+     * server.addHandlers<'inventory', InventoryMethodMap>('inventory', handlers);
+     */
+    addHandlers(handlers: HandlerMap<TIncoming & TPrivateIncoming & ServerPrivateMap, TState & ServerSocketState, ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>, ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>): void;
+    addHandlers<TServiceName extends keyof TService & string>(service: TServiceName, handlers: HandlerMap<TService[TServiceName], TState & ServerSocketState, ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>, ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>): void;
+    addHandlers<TServiceName extends string, TServiceMethodMap extends MethodMap>(service: TServiceName, handlers: HandlerMap<TServiceMethodMap, TState & ServerSocketState, ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>, ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>): void;
+    addPlugin(...plugin: ServerPlugin<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>[]): void;
     private bind;
     close(keepSocketsOpen?: boolean): Promise<void>;
     emit(event: 'close', data: CloseEvent): void;
-    emit(event: 'connection', data: ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
+    emit(event: 'connection', data: ConnectionEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
     emit(event: 'error', data: ErrorEvent): void;
     emit(event: 'headers', data: HeadersEvent): void;
-    emit(event: 'handshake', data: HandshakeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
+    emit(event: 'handshake', data: HandshakeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
     emit(event: 'listening', data: ListeningEvent): void;
     emit(event: 'ready', data: {}): void;
-    emit(event: 'socketAuthStateChange', data: SocketAuthStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketAuthenticate', data: SocketAuthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketBadAuthToken', data: SocketBadAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketClose', data: SocketCloseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketConnect', data: SocketConnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketConnectAbort', data: SocketDisconnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketConnecting', data: SocketConnectingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketDeauthenticate', data: SocketDeauthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketDisconnect', data: SocketDisconnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketError', data: SocketErrorEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketMessage', data: SocketMessageEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketPing', data: SocketPingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketPong', data: SocketPongEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketRemoveAuthToken', data: SocketRemoveAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketRequest', data: SocketRequestEvent<TService, TIncoming, TPrivateIncoming>): void;
-    emit(event: 'socketResponse', data: SocketResponseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketSubscribe', data: SocketSubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketSubscribeFail', data: SocketSubscribeFailEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketSubscribeRequest', data: SocketSubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketSubscribeStateChange', data: SocketSubscribeStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: 'socketUnsubscribe', data: SocketUnsubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
+    emit(event: 'socketAuthStateChange', data: SocketAuthStateChangeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketAuthenticate', data: SocketAuthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketBadAuthToken', data: SocketBadAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketClose', data: SocketCloseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketConnect', data: SocketConnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketConnectAbort', data: SocketDisconnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketConnecting', data: SocketConnectingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketDeauthenticate', data: SocketDeauthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketDisconnect', data: SocketDisconnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketError', data: SocketErrorEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketMessage', data: SocketMessageEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketPing', data: SocketPingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketPong', data: SocketPongEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketRemoveAuthToken', data: SocketRemoveAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketRequest', data: SocketRequestEvent<TIncoming, TService, TPrivateIncoming>): void;
+    emit(event: 'socketResponse', data: SocketResponseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketSubscribe', data: SocketSubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketSubscribeFail', data: SocketSubscribeFailEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketSubscribeRequest', data: SocketSubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketSubscribeStateChange', data: SocketSubscribeStateChangeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
+    emit(event: 'socketUnsubscribe', data: SocketUnsubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>): void;
     emit(event: 'warning', data: WarningEvent): void;
     get exchange(): Exchange<TChannel>;
+    /** Method names registered under a given service, or an empty array if none. */
+    getServiceMethods(service: string): string[];
     get isListening(): boolean;
     get isReady(): boolean;
-    listen(): DemuxedConsumableStream<StreamEvent<ServerEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>>;
+    listen(): DemuxedConsumableStream<StreamEvent<ServerEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>>;
     listen(event: 'close'): DemuxedConsumableStream<CloseEvent>;
-    listen(event: 'connection'): DemuxedConsumableStream<ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
+    listen(event: 'connection'): DemuxedConsumableStream<ConnectionEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
     listen(event: 'error'): DemuxedConsumableStream<ErrorEvent>;
-    listen(event: 'handshake'): DemuxedConsumableStream<HandshakeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
+    listen(event: 'handshake'): DemuxedConsumableStream<HandshakeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
     listen(event: 'headers'): DemuxedConsumableStream<HeadersEvent>;
     listen(event: 'listening'): DemuxedConsumableStream<ListeningEvent>;
     listen(event: 'ready'): DemuxedConsumableStream<{}>;
-    listen(event: 'socketAuthStateChange'): DemuxedConsumableStream<SocketAuthStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketAuthenticate'): DemuxedConsumableStream<SocketAuthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketBadAuthToken'): DemuxedConsumableStream<SocketBadAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketClose'): DemuxedConsumableStream<SocketCloseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketConnect'): DemuxedConsumableStream<SocketConnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketConnectAbort'): DemuxedConsumableStream<SocketDisconnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketConnecting'): DemuxedConsumableStream<SocketConnectingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketDeauthenticate'): DemuxedConsumableStream<SocketDeauthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketDisconnect'): DemuxedConsumableStream<SocketDisconnectEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketError'): DemuxedConsumableStream<SocketErrorEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketMessage'): DemuxedConsumableStream<SocketMessageEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketPing'): DemuxedConsumableStream<SocketPingEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketPong'): DemuxedConsumableStream<SocketPongEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketRemoveAuthToken'): DemuxedConsumableStream<SocketRemoveAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketRequest'): DemuxedConsumableStream<SocketRequestEvent<TService, TIncoming, TPrivateIncoming>>;
-    listen(event: 'socketResponse'): DemuxedConsumableStream<SocketResponseEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketSubscribe'): DemuxedConsumableStream<SocketSubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketSubscribeFail'): DemuxedConsumableStream<SocketSubscribeFailEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketSubscribeRequest'): DemuxedConsumableStream<SocketSubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketSubscribeStateChange'): DemuxedConsumableStream<SocketSubscribeStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: 'socketUnsubscribe'): DemuxedConsumableStream<SocketUnsubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
+    listen(event: 'socketAuthStateChange'): DemuxedConsumableStream<SocketAuthStateChangeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketAuthenticate'): DemuxedConsumableStream<SocketAuthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketBadAuthToken'): DemuxedConsumableStream<SocketBadAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketClose'): DemuxedConsumableStream<SocketCloseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketConnect'): DemuxedConsumableStream<SocketConnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketConnectAbort'): DemuxedConsumableStream<SocketDisconnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketConnecting'): DemuxedConsumableStream<SocketConnectingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketDeauthenticate'): DemuxedConsumableStream<SocketDeauthenticateEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketDisconnect'): DemuxedConsumableStream<SocketDisconnectEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketError'): DemuxedConsumableStream<SocketErrorEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketMessage'): DemuxedConsumableStream<SocketMessageEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketPing'): DemuxedConsumableStream<SocketPingEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketPong'): DemuxedConsumableStream<SocketPongEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketRemoveAuthToken'): DemuxedConsumableStream<SocketRemoveAuthTokenEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketRequest'): DemuxedConsumableStream<SocketRequestEvent<TIncoming, TService, TPrivateIncoming>>;
+    listen(event: 'socketResponse'): DemuxedConsumableStream<SocketResponseEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketSubscribe'): DemuxedConsumableStream<SocketSubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketSubscribeFail'): DemuxedConsumableStream<SocketSubscribeFailEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketSubscribeRequest'): DemuxedConsumableStream<SocketSubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketSubscribeStateChange'): DemuxedConsumableStream<SocketSubscribeStateChangeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
+    listen(event: 'socketUnsubscribe'): DemuxedConsumableStream<SocketUnsubscribeEvent<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
     listen(event: 'warning'): DemuxedConsumableStream<WarningEvent>;
     private onClose;
     private onConnection;
     private onError;
     private onHeaders;
     private onListening;
-    private onUnhandledRequest;
+    /**
+     * Unregister either a whole service (when `methods` is omitted) or a
+     * specific set of methods within a service. Removing a service empties
+     * the group and drops the key so it no longer appears in {@link services}.
+     *
+     * Call with an array of method names (no service) to remove flat
+     * (top-level) handlers by name. The flat slot itself is never dropped
+     * because it holds the built-in protocol handlers.
+     */
+    removeHandlers(methods: readonly string[]): void;
+    removeHandlers(service: string, methods?: readonly string[] | string): void;
+    /** Names of all service handler groups currently registered on the server. */
+    get services(): string[];
     private socketDisconnected;
     private startPinging;
     private stopPinging;

package/dist/server.js

@@ -1,6 +1,7 @@
 import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
 import { defaultAuthEngine, isAuthEngine } from '@socket-mesh/auth-engine';
 import { removeAuthTokenHandler } from '@socket-mesh/client';
+import { toError } from '@socket-mesh/core';
 import { ServerProtocolError } from '@socket-mesh/errors';
 import defaultCodec from '@socket-mesh/formatter';
 import { WebSocketServer } from 'ws';
@@ -44,6 +45,9 @@ export class Server extends AsyncStreamEmitter {
             options = {};
         }
         options.clientTracking = true;
+        this._isListening = false;
+        this._isReady = false;
+        this._pingIntervalRef = null;
         this.ackTimeoutMs = options.ackTimeoutMs || 10000;
         this.allowClientPublish = options.allowClientPublish ?? true;
         this.auth = isAuthEngine(options.authEngine) ? options.authEngine : defaultAuthEngine(options.authEngine);
@@ -54,14 +58,23 @@ export class Server extends AsyncStreamEmitter {
         this.clients = {};
         this.clientCount = 0;
         this.codecEngine = options.codecEngine || defaultCodec;
-        this._handlers = Object.assign({
-            '#authenticate': authenticateHandler,
-            '#handshake': handshakeHandler,
-            '#publish': publishHandler,
-            '#removeAuthToken': removeAuthTokenHandler,
-            '#subscribe': subscribeHandler,
-            '#unsubscribe': unsubscribeHandler
-        }, options.handlers);
+        // Flat handlers live under the empty-string service key so dispatch
+        // (and Server.addHandlers/removeHandlers) only has to consult one map.
+        this._handlers = {
+            '': Object.assign({
+                '#authenticate': authenticateHandler,
+                '#handshake': handshakeHandler,
+                '#publish': publishHandler,
+                '#removeAuthToken': removeAuthTokenHandler,
+                '#subscribe': subscribeHandler,
+                '#unsubscribe': unsubscribeHandler
+            }, options.handlers)
+        };
+        if (options.serviceHandlers) {
+            for (const service of Object.keys(options.serviceHandlers)) {
+                this._handlers[service] = { ...options.serviceHandlers[service] };
+            }
+        }
         this.httpServer = options.server;
         this.plugins = options.plugins || [];
         this.origins = options.origins || '*:*';
@@ -100,6 +113,14 @@ export class Server extends AsyncStreamEmitter {
             })();
         }
     }
+    addHandlers(serviceOrHandlers, handlers) {
+        const service = typeof serviceOrHandlers === 'string' ? serviceOrHandlers : '';
+        const map = typeof serviceOrHandlers === 'string' ? handlers : serviceOrHandlers;
+        if (!this._handlers[service]) {
+            this._handlers[service] = {};
+        }
+        Object.assign(this._handlers[service], map);
+    }
     addPlugin(...plugin) {
         this.plugins.push(...plugin);
     }
@@ -176,6 +197,16 @@ export class Server extends AsyncStreamEmitter {
     get exchange() {
         return this.brokerEngine.exchange;
     }
+    /** Method names registered under a given service, or an empty array if none. */
+    getServiceMethods(service) {
+        if (service === '') {
+            // The empty-string slot stores flat (non-service) handlers internally
+            // and is not part of the public service surface.
+            return [];
+        }
+        const group = this._handlers[service];
+        return group ? Object.keys(group) : [];
+    }
     get isListening() {
         return this._isListening;
     }
@@ -185,6 +216,7 @@ export class Server extends AsyncStreamEmitter {
     listen(event) {
         return event ? super.listen(event) : super.listen();
     }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     onClose(code, reason) {
         this.emit('close', {});
     }
@@ -199,11 +231,10 @@ export class Server extends AsyncStreamEmitter {
             ackTimeoutMs: this.ackTimeoutMs,
             callIdGenerator: this._callIdGenerator,
             codecEngine: this.codecEngine,
-            handlers: this._handlers,
-            onUnhandledRequest: this.onUnhandledRequest.bind(this),
             plugins: this.plugins,
             request: upgradeReq,
             server: this,
+            serviceHandlers: this._handlers,
             socket: wsSocket,
             state: {},
             streamCleanupMode: this.socketStreamCleanupMode
@@ -228,7 +259,40 @@ export class Server extends AsyncStreamEmitter {
         this._isListening = true;
         this.emit('listening', {});
     }
-    onUnhandledRequest(socket, packet) {
+    removeHandlers(serviceOrMethods, methods) {
+        let service;
+        let list;
+        if (Array.isArray(serviceOrMethods)) {
+            service = '';
+            list = serviceOrMethods;
+        }
+        else {
+            service = serviceOrMethods;
+            list = typeof methods === 'string' ? [methods] : methods;
+        }
+        const group = this._handlers[service];
+        if (!group) {
+            return;
+        }
+        if (list === undefined) {
+            // Never drop the flat slot — it holds built-in protocol handlers.
+            if (service !== '') {
+                delete this._handlers[service];
+            }
+            return;
+        }
+        for (const method of list) {
+            delete group[method];
+        }
+        if (service !== '' && Object.keys(group).length === 0) {
+            delete this._handlers[service];
+        }
+    }
+    /** Names of all service handler groups currently registered on the server. */
+    get services() {
+        // The empty-string slot holds flat (non-service) handlers internally
+        // and is not part of the public service surface.
+        return Object.keys(this._handlers).filter(service => service !== '');
     }
     socketDisconnected(socket) {
         if (this.pendingClients[socket.id]) {
@@ -294,15 +358,17 @@ export class Server extends AsyncStreamEmitter {
                 }
             }
             catch (err) {
-                callback(false, 401, typeof err === 'string' ? err : err.message);
+                const error = toError(err);
+                callback(false, 401, typeof err === 'string' ? err : error.message);
                 return;
             }
             callback(true);
         }
         catch (err) {
-            this.onError(err);
-            this.emit('warning', { warning: err });
-            callback(false, 403, typeof err === 'string' ? err : err.message);
+            const error = toError(err);
+            this.onError(error);
+            this.emit('warning', { warning: error });
+            callback(false, 403, typeof err === 'string' ? err : error.message);
         }
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@socket-mesh/server",
 	"description": "A TCP socket pair for easily transmitting full messages without worrying about request size limits.",
-	"version": "18.1.5",
+	"version": "19.1.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",