@socket-mesh/client 18.1.3 → 18.1.5

package/dist/client-channels.d.ts

@@ -1,22 +1,20 @@
-import { ChannelDetails, Channels, ChannelsOptions } from "@socket-mesh/channels";
+import { ChannelDetails, ChannelMap, Channels, ChannelsOptions } from "@socket-mesh/channels";
 import { ClientTransport } from "./client-transport.js";
-import { ClientMap } from "./maps/client-map.js";
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
 export interface ClientChannelsOptions extends ChannelsOptions {
     autoSubscribeOnConnect?: boolean;
 }
-export declare class ClientChannels<T extends ClientMap> extends Channels<T['Channel']> {
+export declare class ClientChannels<TChannel extends ChannelMap, TIncoming extends MethodMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TState extends object> extends Channels<TChannel> {
     autoSubscribeOnConnect: boolean;
-    protected readonly _transport: ClientTransport<T>;
+    protected readonly _transport: ClientTransport<TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>;
     protected _preparingPendingSubscriptions: boolean;
-    constructor(transport: ClientTransport<T>, options?: ClientChannelsOptions);
+    constructor(transport: ClientTransport<TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>, options?: ClientChannelsOptions);
     private suspendSubscriptions;
     protected trySubscribe(channel: ChannelDetails): void;
     private processPendingSubscriptions;
-    unsubscribe(channelName: keyof T['Channel'] & string | string): void;
+    unsubscribe(channelName: keyof TChannel & string): void;
     protected tryUnsubscribe(channel: ChannelDetails): void;
     private triggerChannelSubscribeFail;
-    transmitPublish<U extends keyof T['Channel'] & string>(channelName: U, data: T['Channel'][U]): Promise<void>;
-    transmitPublish<U>(channelName: string, data: U): Promise<void>;
-    invokePublish<U extends keyof T['Channel'] & string>(channelName: keyof T['Channel'] & string, data: T['Channel'][U]): Promise<void>;
-    invokePublish<U>(channelName: string, data: U): Promise<void>;
+    transmitPublish<U extends keyof TChannel & string>(channelName: U, data: TChannel[U]): Promise<void>;
+    invokePublish<U extends keyof TChannel & string>(channelName: keyof TChannel & string, data: TChannel[U]): Promise<void>;
 }

package/dist/client-socket-options.d.ts

@@ -1,8 +1,8 @@
 import ws from "isomorphic-ws";
-import { SocketOptions } from "@socket-mesh/core";
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, SocketOptions } from "@socket-mesh/core";
 import { ClientAuthEngine, LocalStorageAuthEngineOptions } from "./client-auth-engine.js";
-import { SocketMapFromClient } from "./maps/socket-map.js";
-import { ClientMap } from "./maps/client-map.js";
+import { ClientPrivateMap } from "./maps/client-map.js";
+import { ServerPrivateMap } from "./maps/server-map.js";
 export interface AutoReconnectOptions {
     initialDelay: number;
     randomness: number;
@@ -14,11 +14,11 @@ export interface ConnectOptions {
     connectTimeoutMs?: number;
     wsOptions?: ws.ClientOptions;
 }
-export interface ClientSocketOptions<T extends ClientMap> extends SocketOptions<SocketMapFromClient<T>>, ConnectOptions {
+export interface ClientSocketOptions<TOutgoing extends PublicMethodMap = {}, TService extends ServiceMap = {}, TIncoming extends MethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TState extends object = {}> extends SocketOptions<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService, TState>, ConnectOptions {
     autoConnect?: boolean;
     authEngine?: ClientAuthEngine | LocalStorageAuthEngineOptions | null;
     autoReconnect?: Partial<AutoReconnectOptions> | boolean;
     autoSubscribeOnConnect?: boolean;
     channelPrefix?: string;
 }
-export declare function parseClientOptions<T extends ClientMap>(options: ClientSocketOptions<T> | string | URL): ClientSocketOptions<T>;
+export declare function parseClientOptions<TIncoming extends MethodMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TState extends object>(options: ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState> | string | URL): ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState>;

package/dist/client-socket.d.ts

@@ -1,14 +1,15 @@
 import { AutoReconnectOptions, ClientSocketOptions, ConnectOptions } from "./client-socket-options.js";
 import { SignedAuthToken } from "@socket-mesh/auth";
-import { Socket } from "@socket-mesh/core";
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap, Socket } from "@socket-mesh/core";
 import { ClientChannels } from "./client-channels.js";
-import { SocketMapFromClient } from "./maps/socket-map.js";
-import { ClientMap } from "./maps/client-map.js";
-export declare class ClientSocket<T extends ClientMap> extends Socket<SocketMapFromClient<T>> {
+import { ClientPrivateMap } from "./maps/client-map.js";
+import { ChannelMap } from "@socket-mesh/channels";
+import { ServerPrivateMap } from "./maps/server-map.js";
+export declare class ClientSocket<TOutgoing extends PublicMethodMap = {}, TChannel extends ChannelMap = ChannelMap, TService extends ServiceMap = {}, TState extends object = {}, TIncoming extends MethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}> extends Socket<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService, TState> {
     private readonly _clientTransport;
-    readonly channels: ClientChannels<T>;
+    readonly channels: ClientChannels<TChannel, TIncoming, TService, TOutgoing, TPrivateOutgoing, TState>;
     constructor(address: string | URL);
-    constructor(options: ClientSocketOptions<T>);
+    constructor(options: ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState>);
     authenticate(signedAuthToken: SignedAuthToken): Promise<void>;
     get autoReconnect(): AutoReconnectOptions | false;
     set autoReconnect(value: Partial<AutoReconnectOptions> | boolean);

package/dist/client-transport.d.ts

@@ -1,12 +1,11 @@
-import { FunctionReturnType, InvokeMethodOptions, InvokeServiceOptions, SocketTransport, SocketStatus } from "@socket-mesh/core";
+import { FunctionReturnType, InvokeMethodOptions, InvokeServiceOptions, SocketTransport, SocketStatus, MethodMap, ServiceMap, PublicMethodMap, PrivateMethodMap } from "@socket-mesh/core";
 import ws from "isomorphic-ws";
 import { ClientAuthEngine } from "./client-auth-engine.js";
 import { ServerPrivateMap } from "./maps/server-map.js";
 import { AutoReconnectOptions, ClientSocketOptions, ConnectOptions } from "./client-socket-options.js";
 import { AuthToken } from "@socket-mesh/auth";
-import { SocketMapFromClient } from "./maps/socket-map.js";
-import { ClientMap } from "./maps/client-map.js";
-export declare class ClientTransport<T extends ClientMap> extends SocketTransport<SocketMapFromClient<T>> {
+import { ClientPrivateMap } from "./maps/client-map.js";
+export declare class ClientTransport<TIncoming extends MethodMap, TService extends ServiceMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TState extends object> extends SocketTransport<TIncoming & ClientPrivateMap, TOutgoing, TPrivateOutgoing & ServerPrivateMap, TService, TState> {
     readonly authEngine: ClientAuthEngine;
     private _uri;
     private _wsOptions;
@@ -17,7 +16,7 @@ export declare class ClientTransport<T extends ClientMap> extends SocketTranspor
     private _pendingReconnectTimeout;
     private _pingTimeoutMs;
     isPingTimeoutDisabled: boolean;
-    constructor(options: ClientSocketOptions<T>);
+    constructor(options: ClientSocketOptions<TOutgoing, TService, TIncoming, TPrivateOutgoing, TState>);
     get autoReconnect(): AutoReconnectOptions | false;
     set autoReconnect(value: Partial<AutoReconnectOptions> | boolean);
     connect(options?: ConnectOptions): void;
@@ -40,13 +39,13 @@ export declare class ClientTransport<T extends ClientMap> extends SocketTranspor
     get uri(): URL;
     protected get webSocket(): ws.WebSocket | null;
     protected set webSocket(value: ws.WebSocket | null);
-    transmit<TMethod extends keyof SocketMapFromClient<T>['Outgoing']>(method: TMethod, arg?: Parameters<SocketMapFromClient<T>['Outgoing'][TMethod]>[0]): Promise<void>;
-    transmit<TService extends keyof SocketMapFromClient<T>['Service'], TMethod extends keyof SocketMapFromClient<T>['Service'][TService]>(options: [TService, TMethod], arg?: Parameters<SocketMapFromClient<T>['Service'][TService][TMethod]>[0]): Promise<void>;
-    transmit<TMethod extends keyof (SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)>(method: TMethod, arg?: Parameters<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)[TMethod]>[0]): Promise<void>;
-    invoke<TMethod extends keyof SocketMapFromClient<T>['Outgoing']>(method: TMethod, arg?: Parameters<SocketMapFromClient<T>['Outgoing'][TMethod]>[0]): [Promise<FunctionReturnType<SocketMapFromClient<T>['Outgoing'][TMethod]>>, () => void];
-    invoke<TService extends keyof SocketMapFromClient<T>['Service'], TMethod extends keyof SocketMapFromClient<T>['Service'][TService]>(options: [TService, TMethod, (number | false)?], arg?: Parameters<SocketMapFromClient<T>['Service'][TService][TMethod]>[0]): [Promise<FunctionReturnType<SocketMapFromClient<T>['Service'][TService][TMethod]>>, () => void];
-    invoke<TService extends keyof SocketMapFromClient<T>['Service'], TMethod extends keyof SocketMapFromClient<T>['Service'][TService]>(options: InvokeServiceOptions<SocketMapFromClient<T>['Service'], TService, TMethod>, arg?: Parameters<SocketMapFromClient<T>['Service'][TService][TMethod]>[0]): [Promise<FunctionReturnType<SocketMapFromClient<T>['Service'][TService][TMethod]>>, () => void];
-    invoke<TMethod extends keyof SocketMapFromClient<T>['Outgoing']>(options: InvokeMethodOptions<SocketMapFromClient<T>['Outgoing'], TMethod>, arg?: Parameters<SocketMapFromClient<T>['Outgoing'][TMethod]>[0]): [Promise<FunctionReturnType<SocketMapFromClient<T>['Outgoing'][TMethod]>>, () => void];
-    invoke<TMethod extends keyof (SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)>(method: TMethod, arg: Parameters<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)[TMethod]>>, () => void];
-    invoke<TMethod extends keyof (SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)>(options: InvokeMethodOptions<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap), TMethod>, arg?: Parameters<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(SocketMapFromClient<T>['PrivateOutgoing'] & ServerPrivateMap)[TMethod]>>, () => void];
+    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 & ServerPrivateMap)>(method: TMethod, arg?: Parameters<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>[0]): 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, (number | false)?], 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 & ServerPrivateMap)>(method: TMethod, arg: Parameters<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>>, () => void];
+    invoke<TMethod extends keyof (TPrivateOutgoing & ServerPrivateMap)>(options: InvokeMethodOptions<(TPrivateOutgoing & ServerPrivateMap), TMethod>, arg?: Parameters<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>[0]): [Promise<FunctionReturnType<(TPrivateOutgoing & ServerPrivateMap)[TMethod]>>, () => void];
 }

package/dist/handlers/kickout.d.ts

@@ -1,6 +1,7 @@
 import { RequestHandlerArgs } from "@socket-mesh/core";
 import { ClientSocket } from "../client-socket.js";
 import { ClientTransport } from "../client-transport.js";
-import { ClientMap, KickOutOptions } from "../maps/client-map.js";
-import { BasicSocketMapClient } from "../maps/socket-map.js";
-export declare function kickOutHandler({ socket, options }: RequestHandlerArgs<KickOutOptions, BasicSocketMapClient, ClientSocket<ClientMap>, ClientTransport<ClientMap>>): Promise<void>;
+import { ClientPrivateMap, KickOutOptions } from "../maps/client-map.js";
+import { ServerPrivateMap } from "../maps/server-map.js";
+import { ChannelMap } from "@socket-mesh/channels";
+export declare function kickOutHandler({ socket, options }: RequestHandlerArgs<KickOutOptions, ClientPrivateMap, {}, ServerPrivateMap, {}, {}, ClientSocket<{}, ChannelMap>, ClientTransport<{}, {}, {}, {}, {}>>): Promise<void>;

package/dist/handlers/publish.d.ts

@@ -1,7 +1,7 @@
-import { PublishOptions } from "@socket-mesh/channels";
+import { ChannelMap, PublishOptions } from "@socket-mesh/channels";
 import { RequestHandlerArgs } from "@socket-mesh/core";
 import { ClientSocket } from "../client-socket.js";
 import { ClientTransport } from "../client-transport.js";
-import { ClientMap } from "../maps/client-map.js";
-import { BasicSocketMapClient } from "../maps/socket-map.js";
-export declare function publishHandler({ socket, options }: RequestHandlerArgs<PublishOptions, BasicSocketMapClient, ClientSocket<ClientMap>, ClientTransport<ClientMap>>): Promise<void>;
+import { ClientPrivateMap } from "../maps/client-map.js";
+import { ServerPrivateMap } from "../maps/server-map.js";
+export declare function publishHandler({ socket, options }: RequestHandlerArgs<PublishOptions, ClientPrivateMap, {}, ServerPrivateMap, {}, {}, ClientSocket<{}, ChannelMap>, ClientTransport<{}, {}, {}, {}, {}>>): Promise<void>;

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

@@ -1,14 +1,5 @@
 import { SignedAuthToken } from "@socket-mesh/auth";
-import { ChannelMap, PublishOptions } from "@socket-mesh/channels";
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
-export interface ClientMap {
-    Channel: ChannelMap;
-    Incoming: MethodMap;
-    Service: ServiceMap;
-    Outgoing: PublicMethodMap;
-    PrivateOutgoing: PrivateMethodMap;
-    State: object;
-}
+import { PublishOptions } from "@socket-mesh/channels";
 export interface KickOutOptions {
     channel: string;
     message: string;

package/dist/maps/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./client-map.js";
 export * from "./server-map.js";
-export * from "./socket-map.js";

package/dist/maps/index.js

@@ -1,3 +1,2 @@
 export * from "./client-map.js";
 export * from "./server-map.js";
-export * from "./socket-map.js";

package/dist/plugins/batching-plugin.d.ts

@@ -1,10 +1,10 @@
-import { EmptySocketMap, SocketMap } from "@socket-mesh/core";
+import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
 import { Plugin, SendRequestPluginArgs, SendResponsePluginArgs } from "@socket-mesh/core";
 export interface BatchingPluginOptions {
     batchOnHandshakeDuration?: number | false;
     batchInterval?: number;
 }
-export declare abstract class BatchingPlugin<T extends SocketMap = EmptySocketMap> implements Plugin<T> {
+export declare abstract class BatchingPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> implements Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
     batchOnHandshakeDuration: number | boolean;
     batchInterval: number;
     private _batchingIntervalId;
@@ -22,20 +22,20 @@ export declare abstract class BatchingPlugin<T extends SocketMap = EmptySocketMa
     stopBatching(): void;
     private stop;
 }
-export declare class RequestBatchingPlugin<T extends SocketMap = EmptySocketMap> extends BatchingPlugin<T> {
+export declare class RequestBatchingPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends BatchingPlugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
     private _requests;
     private _continue;
     constructor(options?: BatchingPluginOptions);
     cancelBatching(): void;
     protected flush(): void;
-    sendRequest({ requests, cont }: SendRequestPluginArgs<T>): void;
+    sendRequest({ requests, cont }: SendRequestPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
     type: 'requestBatching';
 }
-export declare class ResponseBatchingPlugin<T extends SocketMap = EmptySocketMap> extends BatchingPlugin<T> {
+export declare class ResponseBatchingPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends BatchingPlugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
     private _responses;
     private _continue;
     constructor(options?: BatchingPluginOptions);
     protected flush(): void;
-    sendResponse({ responses, cont }: SendResponsePluginArgs<T>): void;
+    sendResponse({ responses, cont }: SendResponsePluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
     type: 'responseBatching';
 }

package/dist/plugins/in-order-plugin.d.ts

@@ -1,10 +1,10 @@
 import { RawData } from "ws";
-import { EmptySocketMap, MessageRawPluginArgs, Plugin, PluginArgs, SocketMap } from "@socket-mesh/core";
-export declare class InOrderPlugin<T extends SocketMap = EmptySocketMap> implements Plugin<T> {
+import { MessageRawPluginArgs, MethodMap, Plugin, PluginArgs, PrivateMethodMap, PublicMethodMap, ServiceMap } from "@socket-mesh/core";
+export declare class InOrderPlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> implements Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
     type: 'inOrder';
     private readonly _inboundMessageStream;
     constructor();
     handleInboundMessageStream(): void;
-    onEnd({ transport }: PluginArgs<T>): void;
-    onMessageRaw(options: MessageRawPluginArgs<T>): Promise<string | RawData>;
+    onEnd({ transport }: PluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
+    onMessageRaw(options: MessageRawPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): Promise<string | RawData>;
 }

package/dist/plugins/offline-plugin.d.ts

@@ -1,11 +1,11 @@
-import { EmptySocketMap, Plugin, SendRequestPluginArgs, SocketMap } from "@socket-mesh/core";
-export declare class OfflinePlugin<T extends SocketMap = EmptySocketMap> implements Plugin<T> {
+import { MethodMap, Plugin, PrivateMethodMap, PublicMethodMap, SendRequestPluginArgs, ServiceMap } from "@socket-mesh/core";
+export declare class OfflinePlugin<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> implements Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> {
     private _isReady;
     private _requests;
     private _continue;
     constructor();
     type: "offline";
-    sendRequest({ requests, cont }: SendRequestPluginArgs<T>): void;
+    sendRequest({ requests, cont }: SendRequestPluginArgs<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>): void;
     onReady(): void;
     onClose(): void;
     onDisconnected(): void;

package/package.json

@@ -1,30 +1,30 @@
 {
 	"name": "@socket-mesh/client",
 	"description": "A TCP socket pair for easily transmitting full messages without worrying about request size limits.",
-	"version": "18.1.3",
-  "type": "module",
-  "main": "dist/index.js",
+	"version": "18.1.5",
+	"type": "module",
+	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"files": ["./dist"],
-  "browser": {
-    "ws": "./lib/ws-browser.js"
-  },	
+	"browser": {
+		"ws": "./lib/ws-browser.js"
+	},	
 	"author": {
 		"name": "Greg Kimmy"
 	},
 	"scripts": {
-    "build": "node ../../scripts/build.mjs && tsc --project tsconfig.build.json",
+		"build": "node ../../scripts/build.mjs && tsc --project tsconfig.build.json",
 		"bundle": "rollup --config ./rollup.config.js",
-    "deploy": "npm run build && node ../../scripts/publish.mjs",
+		"deploy": "npm run build && node ../../scripts/publish.mjs",
 		"test": "cross-env node --test --import=./run-test.js test/client-test.ts"
 	},
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/socket-mesh/client-server.git"
-  },
-  "bugs": {
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/socket-mesh/client-server.git"
+	},
+	"bugs": {
 		"url": "https://github.com/socket-mesh/client-server/labels/client"
-  },
+	},
 	"devDependencies": {
 		"@kineticcafe/rollup-plugin-delete": "^3.0.0",
 		"@rollup/plugin-alias": "^5.1.0",
@@ -38,18 +38,18 @@
 		"@types/jsonwebtoken": "^9.0.6",
 		"@types/ws": "^8.5.10",
 		"jsonwebtoken": "^9.0.2",
-		"rollup": "^4.18.1",
+		"rollup": "^4.22.5",
 		"rollup-plugin-dts": "^6.1.1",
-		"tslib": "^2.6.3"
+		"tslib": "^2.7.0"
 	},
 	"dependencies": {
 		"@socket-mesh/async-stream-emitter": "^7.1.2",
 		"@socket-mesh/auth": "^2.2.0",
-		"@socket-mesh/channels": "^6.1.1",
-		"@socket-mesh/core": "^1.0.2",
+		"@socket-mesh/channels": "^6.1.2",
+		"@socket-mesh/core": "^1.0.3",
 		"@socket-mesh/errors": "^3.2.0",
 		"@socket-mesh/formatter": "^4.1.0",
-    "buffer": "^5.2.1",
+		"buffer": "^6.0.3",
 		"events": "^3.3.0",
 		"isomorphic-ws": "^5.0.0",
 		"ws": "^8.18.0"

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

@@ -1,17 +0,0 @@
-import { ClientMap, ClientPrivateMap } from "./client-map.js";
-import { PublicMethodMap } from "@socket-mesh/core";
-import { ServerPrivateMap } from "./server-map.js";
-export interface SocketMapFromClient<T extends ClientMap> {
-    Incoming: T['Incoming'] & ClientPrivateMap;
-    Service: T['Service'];
-    Outgoing: T['Outgoing'];
-    PrivateOutgoing: T['PrivateOutgoing'] & ServerPrivateMap;
-    State: T['State'];
-}
-export interface BasicSocketMapClient<TOutgoing extends PublicMethodMap = {}, TState extends object = {}> {
-    Incoming: ClientPrivateMap;
-    Service: {};
-    Outgoing: TOutgoing;
-    PrivateOutgoing: ServerPrivateMap;
-    State: TState;
-}

package/dist/maps/socket-map.js

@@ -1 +0,0 @@
-export {};