@socket-mesh/core 1.0.4 → 2.1.0

package/dist/maps/handler-map.d.ts

@@ -1,5 +1,7 @@
 import { RequestHandler } from '../request-handler.js';
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './method-map.js';
-export type HandlerMap<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> = Partial<{
-    [K in keyof TIncoming]: RequestHandler<Parameters<TIncoming[K]>[0], ReturnType<TIncoming[K]>, TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
+import { BaseSocketTransport } from '../socket-transport.js';
+import { BaseSocket } from '../socket.js';
+import { MethodMap } from './method-map.js';
+export type HandlerMap<TIncoming extends MethodMap, TState extends object, TSocket extends BaseSocket<TState> = BaseSocket<TState>, TTransport extends BaseSocketTransport<TState> = BaseSocketTransport<TState>> = Partial<{
+    [K in keyof TIncoming]: RequestHandler<Parameters<TIncoming[K]>[0], ReturnType<TIncoming[K]>, TState, TSocket, TTransport>;
 }>;

package/dist/maps/method-map.d.ts

@@ -20,3 +20,5 @@ export type RemoveIndexSignature<T> = {
 export type ServiceMap = {
     [service: string]: MethodMap;
 };
+export type ServiceMethodName<TService extends ServiceMap, TServiceName extends ServiceName<TService>> = string & keyof TService[TServiceName];
+export type ServiceName<TService extends ServiceMap> = string & keyof TService;

package/dist/packet.d.ts

@@ -1,26 +1,41 @@
 import { MethodMap, ServiceMap } from './maps/method-map.js';
-export type AnyPacket<TIncoming extends MethodMap, TService extends ServiceMap> = MethodPacket<TIncoming> | ServicePacket<TService>;
-export type MethodPacket<TMethodMap extends MethodMap> = {
-    [TMethod in keyof TMethodMap]: MethodRequestPacket<TMethodMap, TMethod>;
+export type AnyPacket = MethodPacket | ServicePacket;
+export type IncomingMethodPacket<TMethodMap extends MethodMap> = {
+    [TMethod in keyof TMethodMap]: IncomingMethodRequestPacket<TMethodMap, TMethod>;
 }[keyof TMethodMap];
-export interface MethodRequestPacket<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends RequestPacket {
+export interface IncomingMethodRequestPacket<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends RequestPacket {
     ackTimeoutMs?: boolean | number;
     data: Parameters<TMethodMap[TMethod]>[0];
     method: TMethod;
 }
-interface RequestPacket {
-    cid?: number;
-}
-export type ServicePacket<TServiceMap extends ServiceMap> = {
+export type IncomingPacket<TIncoming extends MethodMap, TService extends ServiceMap> = IncomingMethodPacket<TIncoming> | IncomingServicePacket<TService>;
+export type IncomingServicePacket<TServiceMap extends ServiceMap> = {
     [TService in keyof TServiceMap]: {
-        [TMethod in keyof TServiceMap[TService]]: ServiceRequestPacket<TServiceMap, TService, TMethod>;
+        [TMethod in keyof TServiceMap[TService]]: IncomingServiceRequestPacket<TServiceMap, TService, TMethod>;
     }[keyof TServiceMap[TService]];
 }[keyof TServiceMap];
-export interface ServiceRequestPacket<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends RequestPacket {
+export interface IncomingServiceRequestPacket<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends RequestPacket {
     ackTimeoutMs?: boolean | number;
     data?: Parameters<TServiceMap[TService][TMethod]>[0];
     method: TMethod;
     service: TService;
 }
-export declare function isRequestPacket<TIncoming extends MethodMap, TService extends ServiceMap>(packet: unknown): packet is AnyPacket<TIncoming, TService>;
+export type MethodPacket = MethodRequestPacket;
+export interface MethodRequestPacket extends RequestPacket {
+    ackTimeoutMs?: boolean | number;
+    data?: unknown;
+    method: string;
+}
+interface RequestPacket {
+    cid?: number;
+}
+export type ServicePacket = ServiceRequestPacket;
+export interface ServiceRequestPacket extends RequestPacket {
+    ackTimeoutMs?: boolean | number;
+    data?: unknown;
+    method: string;
+    service: string;
+}
+export declare function isRequestPacket(packet: unknown): packet is AnyPacket;
+export declare function isRequestPacket<TIncoming extends MethodMap, TService extends ServiceMap = {}>(packet: unknown): packet is IncomingPacket<TIncoming, TService>;
 export {};

package/dist/plugins/plugin.d.ts

@@ -1,50 +1,50 @@
 import ws from 'isomorphic-ws';
-import { HandlerMap } from '../maps/handler-map.js';
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from '../maps/method-map.js';
 import { AnyPacket } from '../packet.js';
+import { LooseHandlerMap } from '../request-handler.js';
 import { AnyRequest } from '../request.js';
 import { AnyResponse } from '../response.js';
-import { SocketTransport } from '../socket-transport.js';
-import { Socket, SocketStatus } from '../socket.js';
-export interface DisconnectedPluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
+import { BaseSocketTransport } from '../socket-transport.js';
+import { BaseSocket, SocketStatus } from '../socket.js';
+export type AnyPlugin = Plugin<any, any>;
+export interface DisconnectedPluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> extends PluginArgs<TSocket, TTransport> {
     code: number;
     reason?: string;
     status: SocketStatus;
 }
-export interface MessagePluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
-    packet: AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>;
+export interface MessagePluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> extends PluginArgs<TSocket, TTransport> {
+    packet: AnyPacket | AnyResponse;
     timestamp: Date;
 }
-export interface MessageRawPluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
+export interface MessageRawPluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> extends PluginArgs<TSocket, TTransport> {
     message: string | ws.RawData;
     promise: Promise<void>;
     timestamp: Date;
 }
-export interface Plugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> {
-    handlers?: HandlerMap<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
-    onAuthenticated?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    onClose?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    onDeauthenticate?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    onDisconnected?(options: DisconnectedPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    onEnd?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    onMessage?(options: MessagePluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): Promise<AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>>;
-    onMessageRaw?(options: MessageRawPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): Promise<string | ws.RawData>;
-    onOpen?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    onReady?(options: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    sendRequest?(options: SendRequestPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
-    sendResponse?(options: SendResponsePluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+export interface Plugin<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> {
+    handlers?: LooseHandlerMap;
+    onAuthenticated?(options: PluginArgs<TSocket, TTransport>): void;
+    onClose?(options: PluginArgs<TSocket, TTransport>): void;
+    onDeauthenticate?(options: PluginArgs<TSocket, TTransport>): void;
+    onDisconnected?(options: DisconnectedPluginArgs<TSocket, TTransport>): void;
+    onEnd?(options: PluginArgs<TSocket, TTransport>): void;
+    onMessage?(options: MessagePluginArgs<TSocket, TTransport>): Promise<AnyPacket | AnyResponse>;
+    onMessageRaw?(options: MessageRawPluginArgs<TSocket, TTransport>): Promise<string | ws.RawData>;
+    onOpen?(options: PluginArgs<TSocket, TTransport>): void;
+    onReady?(options: PluginArgs<TSocket, TTransport>): void;
+    sendRequest?(options: SendRequestPluginArgs<TSocket, TTransport>): void;
+    sendResponse?(options: SendResponsePluginArgs<TSocket, TTransport>): void;
     type: string;
 }
-export interface PluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> {
-    socket: Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
-    transport: SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
+export interface PluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> {
+    socket: TSocket;
+    transport: TTransport;
 }
 export type PluginType = 'handshake' | 'request' | 'response';
-export interface SendRequestPluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
-    cont: (requests: AnyRequest<TOutgoing, TPrivateOutgoing, TService>[]) => void;
-    requests: AnyRequest<TOutgoing, TPrivateOutgoing, TService>[];
+export interface SendRequestPluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> extends PluginArgs<TSocket, TTransport> {
+    cont: (requests: AnyRequest[]) => void;
+    requests: AnyRequest[];
 }
-export interface SendResponsePluginArgs<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
-    cont: (requests: AnyResponse<TOutgoing, TPrivateOutgoing, TService>[]) => void;
-    responses: AnyResponse<TOutgoing, TPrivateOutgoing, TService>[];
+export interface SendResponsePluginArgs<TSocket extends BaseSocket = BaseSocket, TTransport extends BaseSocketTransport = BaseSocketTransport> extends PluginArgs<TSocket, TTransport> {
+    cont: (requests: AnyResponse[]) => void;
+    responses: AnyResponse[];
 }

package/dist/request-handler.d.ts

@@ -1,8 +1,10 @@
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
-import { SocketTransport } from './socket-transport.js';
-import { Socket } from './socket.js';
-export type RequestHandler<TOptions, U, TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object, TSocket extends Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>, TTransport extends SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>> = (args: RequestHandlerArgs<TOptions, TIncoming, TOutgoing, TPrivateOutgoing, TService, TState, TSocket, TTransport>) => Promise<U>;
-export interface RequestHandlerArgsOptions<TOptions, TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object, TSocket extends Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>, TTransport extends SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>> {
+import { BaseSocketTransport } from './socket-transport.js';
+import { BaseSocket } from './socket.js';
+export interface LooseHandlerMap {
+    [method: string]: ((args: RequestHandlerArgs<any, any, any, any>) => Promise<any>) | undefined;
+}
+export type RequestHandler<TOptions, U, TState extends object, TSocket extends BaseSocket<TState> = BaseSocket<TState>, TTransport extends BaseSocketTransport<TState> = BaseSocketTransport<TState>> = (args: RequestHandlerArgs<TOptions, TState, TSocket, TTransport>) => Promise<U>;
+export interface RequestHandlerArgsOptions<TOptions, TState extends object, TSocket extends BaseSocket<TState> = BaseSocket<TState>, TTransport extends BaseSocketTransport<TState> = BaseSocketTransport<TState>> {
     isRpc: boolean;
     method: string;
     options: TOptions;
@@ -10,7 +12,7 @@ export interface RequestHandlerArgsOptions<TOptions, TIncoming extends MethodMap
     timeoutMs?: boolean | number;
     transport: TTransport;
 }
-export declare class RequestHandlerArgs<TOptions, TIncoming extends MethodMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TService extends ServiceMap = {}, TState extends object = {}, TSocket extends Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>, TTransport extends SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>> {
+export declare class RequestHandlerArgs<TOptions, TState extends object = {}, TSocket extends BaseSocket<TState> = BaseSocket<TState>, TTransport extends BaseSocketTransport<TState> = BaseSocketTransport<TState>> {
     isRpc: boolean;
     method: string;
     options: TOptions;
@@ -18,7 +20,7 @@ export declare class RequestHandlerArgs<TOptions, TIncoming extends MethodMap =
     socket: TSocket;
     timeoutMs?: boolean | number;
     transport: TTransport;
-    constructor(options: RequestHandlerArgsOptions<TOptions, TIncoming, TOutgoing, TPrivateOutgoing, TService, TState, TSocket, TTransport>);
+    constructor(options: RequestHandlerArgsOptions<TOptions, TState, TSocket, TTransport>);
     checkTimeout(timeLeftMs?: number): void;
     getRemainingTimeMs(): number;
 }

package/dist/request.d.ts

@@ -1,51 +1,44 @@
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
-export type AnyRequest<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> = MethodRequest<TOutgoing> | MethodRequest<TPrivateOutgoing> | ServiceRequest<TService>;
-export interface InvokeMethodRequest<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends TransmitMethodRequest<TMethodMap, TMethod> {
+export type AnyRequest = MethodRequest | ServiceRequest;
+export interface InvokeMethodRequest extends TransmitMethodRequest {
     ackTimeoutMs: false | number;
-    callback: ((err: Error | null, result?: TMethodMap[TMethod]) => void) | null;
+    callback: ((err: Error | null, result?: unknown) => void) | null;
     cid: number;
     timeoutId?: NodeJS.Timeout;
 }
-export interface InvokeServiceRequest<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends TransmitServiceRequest<TServiceMap, TService, TMethod> {
+export interface InvokeServiceRequest extends TransmitServiceRequest {
     ackTimeoutMs: false | number;
-    callback: ((err: Error | null, result?: TServiceMap[TService][TMethod]) => void) | null;
+    callback: ((err: Error | null, result?: unknown) => void) | null;
     cid: number;
     timeoutId?: NodeJS.Timeout;
 }
-export type MethodRequest<TMethodMap extends MethodMap> = {
-    [TMethod in keyof TMethodMap]: InvokeMethodRequest<TMethodMap, TMethod> | TransmitMethodRequest<TMethodMap, TMethod>;
-}[keyof TMethodMap];
+export type MethodRequest = InvokeMethodRequest | TransmitMethodRequest;
 export interface Request {
     promise: Promise<void>;
     sentCallback?: (err?: Error) => void;
 }
-export type ServiceRequest<TServiceMap extends ServiceMap> = {
-    [TService in keyof TServiceMap]: {
-        [TMethod in keyof TServiceMap[TService]]: InvokeServiceRequest<TServiceMap, TService, TMethod> | TransmitServiceRequest<TServiceMap, TService, TMethod>;
-    }[keyof TServiceMap[TService]];
-}[keyof TServiceMap];
-export interface TransmitMethodRequest<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> extends Request {
-    data?: Parameters<TMethodMap[TMethod]>[0];
-    method: TMethod;
+export type ServiceRequest = InvokeServiceRequest | TransmitServiceRequest;
+export interface TransmitMethodRequest extends Request {
+    data?: unknown;
+    method: string;
 }
-export interface TransmitServiceRequest<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> extends Request {
-    data?: Parameters<TServiceMap[TService][TMethod]>[0];
-    method: TMethod;
-    service: TService;
+export interface TransmitServiceRequest extends Request {
+    data?: unknown;
+    method: string;
+    service: string;
 }
-export declare function abortRequest<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap>(request: AnyRequest<TOutgoing, TPrivateOutgoing, TService>, err: Error): void;
-export declare function isRequestDone<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap>(request: AnyRequest<TOutgoing, TPrivateOutgoing, TService>): boolean;
-export declare class RequestCollection<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> {
+export declare function abortRequest(request: AnyRequest, err: Error): void;
+export declare function isRequestDone(request: AnyRequest): boolean;
+export declare class RequestCollection {
     private readonly _callbacks;
     private readonly _requests;
-    constructor(requests: AnyRequest<TOutgoing, TPrivateOutgoing, TService> | AnyRequest<TOutgoing, TPrivateOutgoing, TService>[]);
+    constructor(requests: AnyRequest | AnyRequest[]);
     isDone(): boolean;
-    get items(): ReadonlyArray<AnyRequest<TOutgoing, TPrivateOutgoing, TService>>;
+    get items(): ReadonlyArray<AnyRequest>;
     listen(cb: () => void): void;
     [Symbol.iterator](): {
         next(): {
             done: boolean;
-            value: AnyRequest<TOutgoing, TPrivateOutgoing, TService> | undefined;
+            value: AnyRequest | undefined;
         } | {
             done: boolean;
             value?: undefined;

package/dist/response.d.ts

@@ -1,21 +1,25 @@
 import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
-export type AnyResponse<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> = ErrorResponse | MethodDataResponse<TOutgoing> | MethodDataResponse<TPrivateOutgoing> | Response | ServiceDataResponse<TService>;
-export interface DataResponse<T> extends Response {
-    data: T;
+export type AnyResponse = DataResponse | ErrorResponse | Response;
+export interface DataResponse extends Response {
+    data: unknown;
 }
 export interface ErrorResponse extends Response {
     error: Error;
 }
-export type MethodDataResponse<TMethodMap extends MethodMap> = {
-    [TMethod in keyof TMethodMap]: DataResponse<ReturnType<TMethodMap[TMethod]>>;
+export interface OutgoingDataResponse<T> extends Response {
+    data: T;
+}
+export type OutgoingMethodDataResponse<TMethodMap extends MethodMap> = {
+    [TMethod in keyof TMethodMap]: OutgoingDataResponse<ReturnType<TMethodMap[TMethod]>>;
 }[keyof TMethodMap];
+export type OutgoingResponse<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> = ErrorResponse | OutgoingMethodDataResponse<TOutgoing> | OutgoingMethodDataResponse<TPrivateOutgoing> | OutgoingServiceDataResponse<TService> | Response;
+export type OutgoingServiceDataResponse<TServiceMap extends ServiceMap> = {
+    [TService in keyof TServiceMap]: {
+        [TMethod in keyof TServiceMap[TService]]: OutgoingDataResponse<ReturnType<TServiceMap[TService][TMethod]>>;
+    }[keyof TServiceMap[TService]];
+}[keyof TServiceMap];
 export interface Response {
     rid: number;
     timeoutAt?: Date;
 }
-export type ServiceDataResponse<TServiceMap extends ServiceMap> = {
-    [TService in keyof TServiceMap]: {
-        [TMethod in keyof TServiceMap[TService]]: DataResponse<ReturnType<TServiceMap[TService][TMethod]>>;
-    }[keyof TServiceMap[TService]];
-}[keyof TServiceMap];
-export declare function isResponsePacket<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap>(packet?: unknown): packet is AnyResponse<TOutgoing, TPrivateOutgoing, TService>;
+export declare function isResponsePacket(packet?: unknown): packet is AnyResponse;

package/dist/socket-event.d.ts

@@ -1,8 +1,8 @@
 import { AuthToken, SignedAuthToken } from '@socket-mesh/auth';
 import ws from 'isomorphic-ws';
 import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
-import { MethodPacket, ServicePacket } from './packet.js';
-import { AnyResponse } from './response.js';
+import { AnyPacket, IncomingPacket } from './packet.js';
+import { AnyResponse, OutgoingResponse } from './response.js';
 export interface AuthenticatedChangeEvent {
     authToken: AuthToken | null;
     isAuthenticated: true;
@@ -54,10 +54,17 @@ export type PongEvent = object;
 export interface RemoveAuthTokenEvent {
     oldAuthToken: SignedAuthToken;
 }
-export interface RequestEvent<TIncoming extends MethodMap, TService extends ServiceMap> {
-    request: MethodPacket<TIncoming> | ServicePacket<TService>;
+export interface RequestEvent {
+    request: AnyPacket;
 }
-export interface ResponseEvent<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> {
-    response: AnyResponse<TOutgoing, TPrivateOutgoing, TService>;
+export interface ResponseEvent {
+    response: AnyResponse;
 }
-export type SocketEvent<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> = AuthenticateEvent | AuthStateChangeEvent | BadAuthTokenEvent | CloseEvent | ConnectEvent | ConnectingEvent | DeauthenticateEvent | DisconnectEvent | ErrorEvent | MessageEvent | PingEvent | PongEvent | RemoveAuthTokenEvent | RequestEvent<TIncoming, TService> | ResponseEvent<TOutgoing, TPrivateOutgoing, TService>;
+export type SocketEvent = AuthenticateEvent | AuthStateChangeEvent | BadAuthTokenEvent | CloseEvent | ConnectEvent | ConnectingEvent | DeauthenticateEvent | DisconnectEvent | ErrorEvent | MessageEvent | PingEvent | PongEvent | RemoveAuthTokenEvent | RequestEvent | ResponseEvent;
+export interface TypedRequestEvent<TIncoming extends MethodMap, TService extends ServiceMap = {}> {
+    request: IncomingPacket<TIncoming, TService>;
+}
+export interface TypedResponseEvent<TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap = {}, TService extends ServiceMap = {}> {
+    response: OutgoingResponse<TOutgoing, TPrivateOutgoing, TService>;
+}
+export type TypedSocketEvent<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap = {}, TService extends ServiceMap = {}> = AuthenticateEvent | AuthStateChangeEvent | BadAuthTokenEvent | CloseEvent | ConnectEvent | ConnectingEvent | DeauthenticateEvent | DisconnectEvent | ErrorEvent | MessageEvent | PingEvent | PongEvent | RemoveAuthTokenEvent | TypedRequestEvent<TIncoming, TService> | TypedResponseEvent<TOutgoing, TPrivateOutgoing, TService>;

package/dist/socket-transport.d.ts

@@ -1,46 +1,58 @@
 import { AuthToken, SignedAuthToken } from '@socket-mesh/auth';
 import { CodecEngine } from '@socket-mesh/formatter';
 import ws from 'isomorphic-ws';
-import { FunctionReturnType, MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
+import { FunctionReturnType, MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, ServiceMethodName, ServiceName } from './maps/method-map.js';
 import { AnyPacket } from './packet.js';
-import { Plugin } from './plugins/plugin.js';
-import { AnyRequest, InvokeMethodRequest, InvokeServiceRequest, TransmitMethodRequest, TransmitServiceRequest } from './request.js';
+import { AnyPlugin } from './plugins/plugin.js';
+import { AnyRequest } from './request.js';
 import { AnyResponse } from './response.js';
-import { Socket, SocketOptions, SocketStatus, StreamCleanupMode } from './socket.js';
+import { BaseSocket, BaseSocketOptions, Socket, SocketStatus, StreamCleanupMode } from './socket.js';
 export type CallIdGenerator = () => number;
-export interface InboundMessage<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap> {
-    packet: (AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>)[] | (AnyPacket<TIncoming, TService> | AnyResponse<TOutgoing, TPrivateOutgoing, TService>) | null;
+export interface InboundMessage {
+    packet: (AnyPacket | AnyResponse)[] | (AnyPacket | AnyResponse) | null;
     timestamp: Date;
 }
-export interface InvokeMethodOptions<TMethodMap extends MethodMap, TMethod extends keyof TMethodMap> {
+export interface InvokeMethodOptions<TMethodMap extends MethodMap = MethodMap, TMethod extends keyof TMethodMap & string = keyof TMethodMap & string> {
     ackTimeoutMs?: false | number;
     method: TMethod;
 }
-export interface InvokeServiceOptions<TServiceMap extends ServiceMap, TService extends keyof TServiceMap, TMethod extends keyof TServiceMap[TService]> {
+export interface InvokeServiceOptions<TServiceMap extends ServiceMap = ServiceMap, TService extends keyof TServiceMap & string = keyof TServiceMap & string, TMethod extends keyof TServiceMap[TService] & string = keyof TServiceMap[TService] & string> {
     ackTimeoutMs?: false | number;
     method: TMethod;
     service: TService;
 }
-export declare class SocketTransport<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> {
+export type SocketTransport<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TState extends object = {}, TService extends ServiceMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}> = Omit<BaseSocketTransport<TState>, 'invoke' | 'socket' | 'transmit'> & {
+    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 & string>(method: TMethod, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TPrivateOutgoing[TMethod]>>, () => void];
+    invoke<TMethod extends keyof TPrivateOutgoing & string>(options: InvokeMethodOptions<TPrivateOutgoing, TMethod>, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TPrivateOutgoing[TMethod]>>, () => void];
+    readonly socket: Socket<TIncoming, TOutgoing, TState, TService, TPrivateIncoming, TPrivateOutgoing>;
+    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 & string>(method: TMethod, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): Promise<void>;
+};
+export declare class BaseSocketTransport<TState extends object = {}> {
     private _authToken;
     private readonly _callbackMap;
     private readonly _callIdGenerator;
-    private readonly _handlers;
     private _inboundProcessedMessageCount;
     private _inboundReceivedMessageCount;
     private _isReady;
     private _outboundPreparedMessageCount;
     private _outboundSentMessageCount;
     private _pingTimeoutRef;
+    private readonly _serviceHandlers;
     private _signedAuthToken;
     private _socket;
     private _webSocket;
     ackTimeoutMs: number;
     readonly codecEngine: CodecEngine;
     id: null | string;
-    readonly plugins: Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>[];
+    readonly plugins: AnyPlugin[];
     streamCleanupMode: StreamCleanupMode;
-    protected constructor(options?: SocketOptions<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>);
+    protected constructor(options?: BaseSocketOptions<TState>);
     protected abortAllPendingCallbacksDueToBadConnection(status: SocketStatus): void;
     get authToken(): AuthToken | null;
     changeToUnauthenticatedState(): Promise<boolean>;
@@ -49,42 +61,35 @@ export declare class SocketTransport<TIncoming extends MethodMap, TOutgoing exte
     getBackpressure(): number;
     getInboundBackpressure(): number;
     getOutboundBackpressure(): number;
-    protected handleInboudMessage({ packet, timestamp }: InboundMessage<TIncoming, TOutgoing, TPrivateOutgoing, TService>): Promise<void>;
-    invoke<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TOutgoing[TMethod]>>, () => void];
-    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod, (false | number)?], arg?: Parameters<TService[TServiceName][TMethod]>[0]): [Promise<FunctionReturnType<TService[TServiceName][TMethod]>>, () => void];
-    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: InvokeServiceOptions<TService, TServiceName, TMethod>, arg?: Parameters<TService[TServiceName][TMethod]>[0]): [Promise<FunctionReturnType<TService[TServiceName][TMethod]>>, () => void];
-    invoke<TMethod extends keyof TOutgoing>(options: InvokeMethodOptions<TOutgoing, TMethod>, arg?: Parameters<TOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TOutgoing[TMethod]>>, () => void];
-    invoke<TMethod extends keyof TPrivateOutgoing>(method: TMethod, arg: Parameters<TPrivateOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TPrivateOutgoing[TMethod]>>, () => void];
-    invoke<TMethod extends keyof TPrivateOutgoing>(options: InvokeMethodOptions<TPrivateOutgoing, TMethod>, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): [Promise<FunctionReturnType<TPrivateOutgoing[TMethod]>>, () => void];
+    protected handleInboudMessage({ packet, timestamp }: InboundMessage): Promise<void>;
+    invoke(methodOptions: [string, string, (false | number)?] | InvokeMethodOptions | InvokeServiceOptions | string, arg?: unknown): [Promise<unknown>, () => 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: ws.Data, isBinary: boolean): void;
     protected onOpen(): void;
     protected onPingPong(): void;
-    protected onRequest(packet: AnyPacket<TIncoming, TService>, timestamp: Date, pluginError?: Error): Promise<boolean>;
-    protected onResponse(response: AnyResponse<TOutgoing, TPrivateOutgoing, TService>, pluginError?: Error): void;
+    protected onRequest(packet: AnyPacket, timestamp: Date, pluginError?: Error): Promise<boolean>;
+    protected onResponse(response: AnyResponse, pluginError?: Error): void;
     private onSocketClose;
     private onSocketError;
     private onSocketMessage;
-    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 onUnhandledRequest(packet: AnyPacket<TIncoming, TService>): boolean;
+    protected onTransmit(request: AnyRequest): void;
+    protected onUnhandledRequest(_: AnyPacket): boolean;
     protected resetPingTimeout(timeoutMs: false | number, code: number): void;
     send(data: Buffer | string): Promise<void>;
-    protected sendRequest(requests: (AnyRequest<TOutgoing, TPrivateOutgoing, TService>)[]): void;
-    protected sendRequest(index: number, requests: (AnyRequest<TOutgoing, TPrivateOutgoing, TService>)[]): void;
-    protected sendResponse(responses: (AnyResponse<TOutgoing, TPrivateOutgoing, TService>)[]): void;
-    protected sendResponse(index: number, responses: (AnyResponse<TOutgoing, TPrivateOutgoing, TService>)[]): void;
+    protected sendRequest(requests: AnyRequest[]): void;
+    protected sendRequest(index: number, requests: AnyRequest[]): void;
+    protected sendResponse(responses: AnyResponse[]): void;
+    protected sendResponse(index: number, responses: AnyResponse[]): void;
     setAuthorization(signedAuthToken: SignedAuthToken, authToken?: AuthToken): Promise<boolean>;
     setReadyStatus(pingTimeoutMs: number, authError?: Error): void;
     get signedAuthToken(): null | SignedAuthToken;
-    get socket(): Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
-    set socket(value: Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>);
+    get socket(): BaseSocket<TState>;
+    set socket(value: BaseSocket<TState>);
     get status(): SocketStatus;
-    transmit<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<void>;
-    transmit<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<void>;
-    transmit<TMethod extends keyof TPrivateOutgoing>(method: TMethod, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): Promise<void>;
+    transmit(serviceAndMethod: [string, string] | string, arg?: unknown): Promise<void>;
     triggerAuthenticationEvents(wasSigned: boolean, wasAuthenticated: boolean): void;
     get url(): string;
     protected get webSocket(): null | ws.WebSocket;

package/dist/socket-transport.js

@@ -6,18 +6,18 @@ import { isRequestPacket } from './packet.js';
 import { RequestHandlerArgs } from './request-handler.js';
 import { abortRequest, isRequestDone } from './request.js';
 import { isResponsePacket } from './response.js';
-import { toArray, wait } from './utils.js';
-export class SocketTransport {
+import { toArray, toError, wait } from './utils.js';
+export class BaseSocketTransport {
     _authToken;
     _callbackMap;
     _callIdGenerator;
-    _handlers;
     _inboundProcessedMessageCount;
     _inboundReceivedMessageCount;
     _isReady;
     _outboundPreparedMessageCount;
     _outboundSentMessageCount;
     _pingTimeoutRef;
+    _serviceHandlers;
     _signedAuthToken;
     _socket;
     _webSocket;
@@ -28,21 +28,34 @@ export class SocketTransport {
     streamCleanupMode;
     constructor(options) {
         let cid = 1;
+        this._isReady = false;
         this._authToken = null;
         this._signedAuthToken = null;
+        this._webSocket = null;
         this.ackTimeoutMs = options?.ackTimeoutMs ?? 10000;
         this._callIdGenerator = options?.callIdGenerator || (() => {
             return cid++;
         });
         this._callbackMap = {};
         this.codecEngine = options?.codecEngine || defaultCodec;
-        this._handlers = options?.handlers || {};
         this.id = null;
         this._inboundProcessedMessageCount = 0;
         this._inboundReceivedMessageCount = 0;
         this._outboundPreparedMessageCount = 0;
         this._outboundSentMessageCount = 0;
         this._pingTimeoutRef = null;
+        this._serviceHandlers = options?.serviceHandlers || {};
+        // Flat (non-service) handlers live under the empty-string service key
+        // so dispatch only has to consult one map. We merge `options.handlers`
+        // into that slot without cloning the top-level map, so dynamic mutations
+        // to the caller's serviceHandlers reference (e.g. Server.addHandlers)
+        // still propagate to this transport.
+        if (options?.handlers) {
+            this._serviceHandlers[''] = {
+                ...this._serviceHandlers[''],
+                ...options.handlers
+            };
+        }
         this.plugins = options?.plugins || [];
         this.streamCleanupMode = options?.streamCleanupMode || 'kill';
     }
@@ -80,10 +93,11 @@ export class SocketTransport {
             return this.codecEngine.decode(data);
         }
         catch (err) {
-            if (err.name === 'Error') {
-                err.name = 'InvalidMessageError';
+            const error = toError(err);
+            if (error.name === 'Error') {
+                error.name = 'InvalidMessageError';
             }
-            this.onError(err);
+            this.onError(error);
             return null;
         }
     }
@@ -117,7 +131,7 @@ export class SocketTransport {
                 }
             }
             catch (err) {
-                pluginError = err;
+                pluginError = toError(err);
             }
             // Check to see if it is a request or response packet.
             if (isResponsePacket(curPacket)) {
@@ -156,7 +170,7 @@ export class SocketTransport {
                 cid: this._callIdGenerator(),
                 data: arg,
                 method: serviceMethod,
-                service
+                service: service
             };
         }
         else {
@@ -165,7 +179,7 @@ export class SocketTransport {
                 callback: null,
                 cid: this._callIdGenerator(),
                 data: arg,
-                method: ((typeof methodOptions === 'object') ? methodOptions.method : methodOptions)
+                method: (typeof methodOptions === 'object') ? methodOptions.method : methodOptions
             };
         }
         const callbackMap = this._callbackMap;
@@ -322,13 +336,14 @@ export class SocketTransport {
             }
         }
         else {
-            const handler = this._handlers[packet.method];
+            const service = 'service' in packet ? packet.service : '';
+            const handler = this._serviceHandlers[service]?.[packet.method];
             if (handler) {
                 wasHandled = true;
                 try {
                     const data = await handler(new RequestHandlerArgs({
                         isRpc: !!packet.cid,
-                        method: packet.method.toString(),
+                        method: packet.method,
                         options: packet.data,
                         socket: this._socket,
                         timeoutMs: packet.ackTimeoutMs,
@@ -339,7 +354,7 @@ export class SocketTransport {
                     }
                 }
                 catch (err) {
-                    error = err;
+                    error = toError(err);
                     if (packet.cid) {
                         response = { error, rid: packet.cid, timeoutAt };
                     }
@@ -393,7 +408,7 @@ export class SocketTransport {
     onTransmit(request) {
         this.sendRequest([request]);
     }
-    onUnhandledRequest(packet) {
+    onUnhandledRequest(_) {
         return false;
     }
     resetPingTimeout(timeoutMs, code) {
@@ -456,8 +471,9 @@ export class SocketTransport {
                     });
                 }
                 catch (err) {
+                    const error = toError(err);
                     for (const req of requests) {
-                        abortRequest(req, err);
+                        abortRequest(req, error);
                     }
                 }
                 return;
@@ -537,7 +553,7 @@ export class SocketTransport {
         }
         // If the socket is closed we need to call them back with an error.
         if (this.status === 'closed') {
-            for (const response of responses) {
+            for (const _ of responses) {
                 this.onError(new Error(`WebSocket is not open: readyState 3 (CLOSED)`));
             }
             return;

package/dist/socket.d.ts

@@ -2,29 +2,42 @@ import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
 import { AuthToken, SignedAuthToken } from '@socket-mesh/auth';
 import { CodecEngine } from '@socket-mesh/formatter';
 import { DemuxedConsumableStream, StreamEvent } from '@socket-mesh/stream-demux';
-import { HandlerMap } from './maps/handler-map.js';
-import { FunctionReturnType, MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
-import { AnyPacket } from './packet.js';
-import { Plugin } from './plugins/plugin.js';
-import { AuthenticateEvent, AuthStateChangeEvent, BadAuthTokenEvent, CloseEvent, ConnectEvent, ConnectingEvent, DeauthenticateEvent, DisconnectEvent, ErrorEvent, MessageEvent, PingEvent, PongEvent, RemoveAuthTokenEvent, RequestEvent, ResponseEvent, SocketEvent } from './socket-event.js';
-import { CallIdGenerator, InvokeMethodOptions, InvokeServiceOptions, SocketTransport } from './socket-transport.js';
-export interface SocketOptions<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object, TSocket extends Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>> {
+import { FunctionReturnType, PrivateMethodMap, PublicMethodMap, ServiceMap, ServiceMethodName, ServiceName } from './maps/method-map.js';
+import { AnyPlugin } from './plugins/plugin.js';
+import { LooseHandlerMap } from './request-handler.js';
+import { AuthenticateEvent, AuthStateChangeEvent, BadAuthTokenEvent, CloseEvent, ConnectEvent, ConnectingEvent, DeauthenticateEvent, DisconnectEvent, ErrorEvent, MessageEvent, PingEvent, PongEvent, RemoveAuthTokenEvent, RequestEvent, ResponseEvent, SocketEvent, TypedRequestEvent, TypedResponseEvent } from './socket-event.js';
+import { BaseSocketTransport, CallIdGenerator, InvokeMethodOptions, InvokeServiceOptions } from './socket-transport.js';
+export interface BaseSocketOptions<TState extends object = {}> {
     ackTimeoutMs?: number;
     callIdGenerator?: CallIdGenerator;
     codecEngine?: CodecEngine;
-    handlers?: HandlerMap<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
+    handlers?: LooseHandlerMap;
     isPingTimeoutDisabled?: boolean;
-    onUnhandledRequest?: (socket: TSocket, packet: AnyPacket<TIncoming, TService>) => boolean;
-    plugins?: Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>[];
+    plugins?: AnyPlugin[];
+    serviceHandlers?: {
+        [service: string]: LooseHandlerMap;
+    };
     state?: Partial<TState>;
     streamCleanupMode?: StreamCleanupMode;
 }
+export type Socket<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TState extends object = {}, TService extends ServiceMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}> = Omit<BaseSocket<TState>, 'invoke' | 'listen' | 'transmit'> & {
+    invoke<TMethod extends keyof TOutgoing & string>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
+    invoke<TMethod extends keyof TOutgoing & string>(options: InvokeMethodOptions<TOutgoing, 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 TPrivateOutgoing & string>(method: TMethod, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TPrivateOutgoing[TMethod]>>;
+    listen(event: 'request'): DemuxedConsumableStream<TypedRequestEvent<TIncoming & TPrivateIncoming, TService>>;
+    listen(event: 'response'): DemuxedConsumableStream<TypedResponseEvent<TOutgoing, TPrivateOutgoing, TService>>;
+    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 & string>(method: TMethod, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): Promise<void>;
+};
 export type SocketStatus = 'closed' | 'closing' | 'connecting' | 'ready';
 export type StreamCleanupMode = 'close' | 'kill' | 'none';
-export declare class Socket<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends AsyncStreamEmitter<SocketEvent<TIncoming, TOutgoing, TPrivateOutgoing, TService> | undefined> {
+export declare class BaseSocket<TState extends object = {}> extends AsyncStreamEmitter<SocketEvent | undefined> {
     private readonly _transport;
     readonly state: Partial<TState>;
-    protected constructor(transport: SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>, options?: SocketOptions<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>);
+    protected constructor(transport: BaseSocketTransport<TState>, options?: BaseSocketOptions<TState>);
     get authToken(): AuthToken | null;
     deauthenticate(): Promise<boolean>;
     disconnect(code?: number, reason?: string): void;
@@ -43,17 +56,14 @@ export declare class Socket<TIncoming extends MethodMap, TOutgoing extends Publi
     emit(event: 'ping', data: PingEvent): void;
     emit(event: 'pong', data: PongEvent): void;
     emit(event: 'removeAuthToken', data: RemoveAuthTokenEvent): void;
-    emit(event: 'request', data: RequestEvent<TIncoming, TService>): void;
-    emit(event: 'response', data: ResponseEvent<TOutgoing, TPrivateOutgoing, TService>): void;
+    emit(event: 'request', data: RequestEvent): void;
+    emit(event: 'response', data: ResponseEvent): void;
     getBackpressure(): number;
     getInboundBackpressure(): number;
     getOutboundBackpressure(): number;
     get id(): null | string;
-    invoke<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
-    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod, (false | number)?], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
-    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: InvokeServiceOptions<TService, TServiceName, TMethod>, arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
-    invoke<TMethod extends keyof TOutgoing>(options: InvokeMethodOptions<TOutgoing, TMethod>, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
-    listen(): DemuxedConsumableStream<StreamEvent<SocketEvent<TIncoming, TOutgoing, TPrivateOutgoing, TService>>>;
+    invoke(methodOptions: [string, string, (false | number)?] | InvokeMethodOptions | InvokeServiceOptions | string, arg?: unknown): Promise<unknown>;
+    listen(): DemuxedConsumableStream<StreamEvent<SocketEvent>>;
     listen(event: 'authStateChange'): DemuxedConsumableStream<AuthStateChangeEvent>;
     listen(event: 'authenticate'): DemuxedConsumableStream<AuthenticateEvent>;
     listen(event: 'badAuthToken'): DemuxedConsumableStream<BadAuthTokenEvent>;
@@ -61,7 +71,7 @@ export declare class Socket<TIncoming extends MethodMap, TOutgoing extends Publi
     listen(event: 'connect'): DemuxedConsumableStream<ConnectEvent>;
     listen(event: 'connectAbort'): DemuxedConsumableStream<DisconnectEvent>;
     listen(event: 'connecting'): DemuxedConsumableStream<ConnectingEvent>;
-    listen(event: 'deauthenticate'): DemuxedConsumableStream<AuthenticateEvent>;
+    listen(event: 'deauthenticate'): DemuxedConsumableStream<DeauthenticateEvent>;
     listen(event: 'disconnect'): DemuxedConsumableStream<DisconnectEvent>;
     listen(event: 'end'): DemuxedConsumableStream<void>;
     listen(event: 'error'): DemuxedConsumableStream<ErrorEvent>;
@@ -69,12 +79,11 @@ export declare class Socket<TIncoming extends MethodMap, TOutgoing extends Publi
     listen(event: 'ping'): DemuxedConsumableStream<PingEvent>;
     listen(event: 'pong'): DemuxedConsumableStream<PongEvent>;
     listen(event: 'removeAuthToken'): DemuxedConsumableStream<RemoveAuthTokenEvent>;
-    listen(event: 'request'): DemuxedConsumableStream<RequestEvent<TIncoming, TService>>;
-    listen(event: 'response'): DemuxedConsumableStream<ResponseEvent<TOutgoing, TPrivateOutgoing, TService>>;
-    listen<U extends SocketEvent<TIncoming, TOutgoing, TPrivateOutgoing, TService>, V = U>(event: string): DemuxedConsumableStream<V>;
+    listen(event: 'request'): DemuxedConsumableStream<RequestEvent>;
+    listen(event: 'response'): DemuxedConsumableStream<ResponseEvent>;
+    listen<U extends SocketEvent, V = U>(event: string): DemuxedConsumableStream<V>;
     get signedAuthToken(): null | SignedAuthToken;
     get status(): SocketStatus;
-    transmit<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<void>;
-    transmit<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<void>;
+    transmit(serviceAndMethod: [string, string] | string, arg?: unknown): Promise<void>;
     get url(): string;
 }

package/dist/socket.js

@@ -1,5 +1,5 @@
 import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
-export class Socket extends AsyncStreamEmitter {
+export class BaseSocket extends AsyncStreamEmitter {
     _transport;
     state;
     constructor(transport, options) {

package/dist/utils.d.ts

@@ -1,2 +1,3 @@
 export declare function toArray<T>(arr: T | T[]): T[];
+export declare function toError(err: unknown): Error;
 export declare function wait(duration: number): Promise<void>;

package/dist/utils.js

@@ -1,6 +1,9 @@
 export function toArray(arr) {
     return Array.isArray(arr) ? arr : [arr];
 }
+export function toError(err) {
+    return err instanceof Error ? err : new Error(String(err));
+}
 export function wait(duration) {
     return new Promise((resolve) => {
         setTimeout(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@socket-mesh/core",
-	"version": "1.0.4",
+	"version": "2.1.0",
 	"description": "Core module for SocketMesh Server",
 	"type": "module",
 	"main": "dist/index.js",