@socket-mesh/server 18.1.4 → 19.0.0

package/dist/handlers/unsubscribe.d.ts

@@ -1,2 +1,2 @@
-import { ServerRequestHandlerArgs } from "./server-request-handler.js";
-export declare function unsubscribeHandler({ transport, options: channel }: ServerRequestHandlerArgs<string>): Promise<void>;
+import { ServerRequestHandlerArgs } from './server-request-handler.js';
+export declare function unsubscribeHandler({ options: channel, transport }: ServerRequestHandlerArgs<string>): Promise<void>;

package/dist/handlers/unsubscribe.js

@@ -1,5 +1,5 @@
-import { BrokerError } from "@socket-mesh/errors";
-export async function unsubscribeHandler({ transport, options: channel }) {
+import { BrokerError } from '@socket-mesh/errors';
+export async function unsubscribeHandler({ options: channel, transport }) {
     try {
         await transport.unsubscribe(channel);
     }

package/dist/index.d.ts

@@ -1,30 +1,32 @@
-import http from "http";
-import { Server } from "./server.js";
-import { ServerOptions } from "./server-options.js";
-import { ChannelMap } from "@socket-mesh/channels";
-import { PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
-export { Server } from "./server.js";
-export { ServerSocket } from "./server-socket.js";
-export { PluginType } from "@socket-mesh/core";
-export { ServerRequestHandlerArgs } from './handlers/server-request-handler.js';
+import { ChannelMap } from '@socket-mesh/channels';
+import { PrivateMethodMap, PublicMethodMap, ServiceMap } from '@socket-mesh/core';
+import http from 'http';
+import { ServerOptions } from './server-options.js';
+import { Server } from './server.js';
+export type { ServerRequestHandlerArgs } from './handlers/server-request-handler.js';
+export type { ServerOptions } from './server-options.js';
+export type { ServerSocketState } from './server-socket-state.js';
+export { ServerSocket } from './server-socket.js';
+export { Server } from './server.js';
+export type { PluginType } from '@socket-mesh/core';
 /**
- * Creates an http.Server exclusively used for WS upgrades.
+ * Captures upgrade requests for a http.Server.
  *
- * @param {Number} port
- * @param {Function} callback
+ * @param {http.Server} server
  * @param {Object} options
  * @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 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>;
 /**
- * Captures upgrade requests for a http.Server.
+ * Creates an http.Server exclusively used for WS upgrades.
  *
- * @param {http.Server} server
+ * @param {Number} port
+ * @param {Function} callback
  * @param {Object} options
  * @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 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/index.js

@@ -1,7 +1,22 @@
-import http from "http";
-import { Server } from "./server.js";
-export { Server } from "./server.js";
-export { ServerSocket } from "./server-socket.js";
+import http from 'http';
+import { Server } from './server.js';
+export { ServerSocket } from './server-socket.js';
+export { Server } from './server.js';
+/**
+ * Captures upgrade requests for a http.Server.
+ *
+ * @param {http.Server} server
+ * @param {Object} options
+ * @return {AGServer} websocket cluster server
+ * @api public
+ */
+export function attach(server, options) {
+    if (options == null) {
+        options = {};
+    }
+    options.server = server;
+    return new Server(options);
+}
 export function listen(port, options, fn) {
     if (typeof options === 'function') {
         fn = options;
@@ -20,19 +35,3 @@ export function listen(port, options, fn) {
     return socketClusterServer;
 }
 ;
-/**
- * Captures upgrade requests for a http.Server.
- *
- * @param {http.Server} server
- * @param {Object} options
- * @return {AGServer} websocket cluster server
- * @api public
- */
-export function attach(server, options) {
-    if (options == null) {
-        options = {};
-    }
-    options.server = server;
-    return new Server(options);
-}
-;

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

@@ -1,33 +1,31 @@
-import { IncomingMessage } from "http";
-import { Plugin, PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
-import { AuthInfo } from "../handlers/authenticate.js";
-import { ServerSocket } from "../server-socket.js";
-import { ServerTransport } from "../server-transport.js";
-import { ChannelMap, ChannelOptions } from "@socket-mesh/channels";
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-import { ServerSocketState } from "../server-socket-state.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> {
-    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-    transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+import { ChannelMap, ChannelOptions } from '@socket-mesh/channels';
+import { Plugin, PrivateMethodMap, PublicMethodMap, ServiceMap } from '@socket-mesh/core';
+import { IncomingMessage } from 'http';
+import { AuthInfo } from '../handlers/authenticate.js';
+import { ServerSocket } from '../server-socket.js';
+import { ServerTransport } from '../server-transport.js';
+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, 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 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> {
-    channel: string;
-    options: ChannelOptions;
-    socket: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-    transport: ServerTransport<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
-}
-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<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, 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,28 @@
-import ws from "ws";
-import { AuthEngine, AuthOptions } from "@socket-mesh/auth-engine";
-import { CallIdGenerator, HandlerMap, StreamCleanupMode, ServiceMap, PublicMethodMap, PrivateMethodMap } from "@socket-mesh/core";
-import { CodecEngine } from "@socket-mesh/formatter";
-import { ServerPlugin } from "./plugin/server-plugin.js";
-import { Broker } from "./broker/broker.js";
-import { ChannelMap } from "@socket-mesh/channels";
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-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 ws.ServerOptions {
+import { AuthEngine, AuthOptions } from '@socket-mesh/auth-engine';
+import { ChannelMap } from '@socket-mesh/channels';
+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';
+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, TState & ServerSocketState, ServerSocket<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>, ServerTransport<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>>;
     handshakeTimeoutMs?: number;
-    handlers?: HandlerMap<TIncoming & TPrivateIncoming & ServerPrivateMap, TOutgoing, TPrivateOutgoing & ClientPrivateMap, TService, TState>;
     isPingTimeoutDisabled?: boolean;
-    plugins?: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
     origins?: string;
     pingIntervalMs?: number;
     pingTimeoutMs?: number;
+    plugins?: ServerPlugin<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>[];
     socketChannelLimit?: number;
     socketStreamCleanupMode?: StreamCleanupMode;
     strictHandshake?: boolean;

package/dist/server-socket.d.ts

@@ -1,29 +1,78 @@
-import { HandlerMap, PrivateMethodMap, PublicMethodMap, ServiceMap, Socket, SocketOptions } from "@socket-mesh/core";
-import ws from "ws";
-import { Exchange } from "./broker/exchange.js";
-import { Server } from "./server.js";
-import { IncomingMessage } from "http";
-import { ServerPlugin } from "./plugin/server-plugin.js";
-import { ChannelMap } from "@socket-mesh/channels";
-import { ServerSocketState } from "./server-socket-state.js";
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-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>;
-    plugins?: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
+import { ChannelMap } from '@socket-mesh/channels';
+import { ClientPrivateMap, ServerPrivateMap } from '@socket-mesh/client';
+import { AuthenticateEvent, AuthStateChangeEvent, BadAuthTokenEvent, BaseSocket, BaseSocketOptions, CloseEvent, ConnectEvent, ConnectingEvent, DeauthenticateEvent, DisconnectEvent, ErrorEvent, FunctionReturnType, InvokeMethodOptions, InvokeServiceOptions, LooseHandlerMap, 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, 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> {
+    handlers: LooseHandlerMap;
     id?: string;
-    service?: string;
-    server: Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+    plugins?: ServerPlugin<TIncoming, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>[];
     request: IncomingMessage;
-    socket: ws.WebSocket;
+    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> {
-    readonly server: Server<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
+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;
-    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;
+    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,8 @@
-import { Socket } from "@socket-mesh/core";
-import { ServerTransport } from "./server-transport.js";
-export class ServerSocket extends Socket {
+import { BaseSocket, toError } from '@socket-mesh/core';
+import { ServerTransport } from './server-transport.js';
+export class ServerSocket extends BaseSocket {
+    _serverTransport;
+    server;
     constructor(options) {
         const transport = new ServerTransport(options);
         super(transport, options);
@@ -8,42 +10,59 @@ export class ServerSocket extends Socket {
         this._serverTransport = transport;
     }
     async deauthenticate(rejectOnFailedDelivery) {
-        await super.deauthenticate();
+        const result = await super.deauthenticate();
         if (rejectOnFailedDelivery) {
             try {
                 await this._serverTransport.invoke('#removeAuthToken', undefined)[0];
             }
-            catch (error) {
+            catch (err) {
+                const error = toError(err);
                 this._serverTransport.onError(error);
                 throw error;
             }
-            return;
+            return result;
         }
         try {
             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);
+        const channels = channel ? [channel] : Object.keys(this.state.channelSubscriptions || {});
         return Promise.all(channels.map((channelName) => {
             this.transmit('#kickOut', { channel: channelName, message });
             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

@@ -1,37 +1,47 @@
-import { ServerSocket, ServerSocketOptions } from "./server-socket.js";
-import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { AuthTokenOptions } from "@socket-mesh/auth-engine";
-import { Data } from "ws";
-import { AnyPacket, AnyResponse, SocketStatus, SocketTransport, InvokeMethodRequest, InvokeServiceRequest, TransmitMethodRequest, TransmitServiceRequest, InboundMessage, ServiceMap, PublicMethodMap, PrivateMethodMap } from "@socket-mesh/core";
-import { IncomingMessage } from "http";
-import { ServerPlugin } from "./plugin/server-plugin.js";
-import { ChannelMap, PublishOptions } from "@socket-mesh/channels";
-import { ClientPrivateMap, ServerPrivateMap } from "@socket-mesh/client";
-import { ServerSocketState } from "./server-socket-state.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> {
-    readonly plugins: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
-    readonly service?: string;
+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, 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 = {}, 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, TOutgoing, TChannel, TService, TState, TPrivateIncoming, TPrivateOutgoing, TServerState>[];
     readonly request: IncomingMessage;
-    constructor(options: ServerSocketOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
+    readonly service?: string;
+    type: 'server';
+    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 onClose(code: number, reason?: string | Buffer): 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;
-    type: 'server';
     unsubscribe(channel: string): Promise<void>;
 }