@socket-mesh/server 18.1.4 → 18.1.5

package/dist/server.d.ts

@@ -1,69 +1,56 @@
-import { ServerSocket } from "./server-socket.js";
+import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
+import { AuthEngine } from '@socket-mesh/auth-engine';
+import { ChannelMap } from '@socket-mesh/channels';
+import { PrivateMethodMap, PublicMethodMap, ServiceMap, StreamCleanupMode } from '@socket-mesh/core';
+import { CodecEngine } from '@socket-mesh/formatter';
+import { DemuxedConsumableStream, StreamEvent } from '@socket-mesh/stream-demux';
 import { Server as HttpServer } from 'http';
-import { CodecEngine } from "@socket-mesh/formatter";
-import { PrivateMethodMap, PublicMethodMap, ServiceMap, StreamCleanupMode } from "@socket-mesh/core";
-import { AuthEngine } from "@socket-mesh/auth-engine";
-import { ServerPlugin } from "./plugin/server-plugin.js";
-import { CloseEvent, ConnectionEvent, ErrorEvent, HandshakeEvent, HeadersEvent, ListeningEvent, ServerEvent, SocketAuthenticateEvent, SocketAuthStateChangeEvent, SocketBadAuthTokenEvent, SocketCloseEvent, SocketConnectEvent, SocketConnectingEvent, SocketDeauthenticateEvent, SocketDisconnectEvent, SocketErrorEvent, SocketMessageEvent, SocketPingEvent, SocketPongEvent, SocketRemoveAuthTokenEvent, SocketRequestEvent, SocketResponseEvent, SocketSubscribeEvent, SocketSubscribeFailEvent, SocketSubscribeStateChangeEvent, SocketUnsubscribeEvent, WarningEvent } from "./server-event.js";
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
-import { DemuxedConsumableStream, StreamEvent } from "@socket-mesh/stream-demux";
-import { ServerOptions } from "./server-options.js";
-import { Broker } from "./broker/broker.js";
-import { Exchange } from "./broker/exchange.js";
-import { ChannelMap } from "@socket-mesh/channels";
+import { Broker } from './broker/broker.js';
+import { Exchange } from './broker/exchange.js';
+import { CloseEvent, ConnectionEvent, ErrorEvent, HandshakeEvent, HeadersEvent, ListeningEvent, ServerEvent, SocketAuthenticateEvent, SocketAuthStateChangeEvent, SocketBadAuthTokenEvent, SocketCloseEvent, SocketConnectEvent, SocketConnectingEvent, SocketDeauthenticateEvent, SocketDisconnectEvent, SocketErrorEvent, SocketMessageEvent, SocketPingEvent, SocketPongEvent, SocketRemoveAuthTokenEvent, SocketRequestEvent, SocketResponseEvent, SocketSubscribeEvent, SocketSubscribeFailEvent, SocketSubscribeStateChangeEvent, SocketUnsubscribeEvent, WarningEvent } from './events/index.js';
+import { ServerPlugin } from './plugin/server-plugin.js';
+import { ServerOptions } from './server-options.js';
+import { ServerSocket } from './server-socket.js';
 export declare class Server<TIncoming extends PublicMethodMap = {}, TChannel extends ChannelMap = {}, TService extends ServiceMap = {}, TOutgoing extends PublicMethodMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}, TServerState extends object = {}, TState extends object = {}> extends AsyncStreamEmitter<ServerEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>> {
     private readonly _callIdGenerator;
-    private readonly _wss;
-    private _isReady;
+    private _handlers;
     private _isListening;
+    private _isReady;
     private _pingIntervalRef;
-    private _handlers;
+    private readonly _wss;
     ackTimeoutMs: number;
     allowClientPublish: boolean;
-    pingIntervalMs: number;
-    isPingTimeoutDisabled: boolean;
-    origins: string;
-    pingTimeoutMs: number;
-    socketChannelLimit?: number;
-    strictHandshake: boolean;
     readonly auth: AuthEngine;
     readonly brokerEngine: Broker<TChannel>;
+    clientCount: number;
     readonly clients: {
         [id: string]: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     };
-    clientCount: number;
     readonly codecEngine: CodecEngine;
+    readonly httpServer: HttpServer;
+    isPingTimeoutDisabled: boolean;
+    origins: string;
+    pendingClientCount: number;
     readonly pendingClients: {
         [id: string]: ServerSocket<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>;
     };
-    pendingClientCount: number;
-    readonly socketStreamCleanupMode: StreamCleanupMode;
-    readonly httpServer: HttpServer;
+    pingIntervalMs: number;
+    pingTimeoutMs: number;
     readonly plugins: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[];
+    socketChannelLimit?: number;
+    readonly socketStreamCleanupMode: StreamCleanupMode;
+    strictHandshake: boolean;
     constructor(options?: ServerOptions<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>);
     addPlugin(...plugin: ServerPlugin<TIncoming, TChannel, TService, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>[]): void;
     private bind;
     close(keepSocketsOpen?: boolean): Promise<void>;
-    get exchange(): Exchange<TChannel>;
-    get isListening(): boolean;
-    get isReady(): boolean;
-    private onClose;
-    private onConnection;
-    private onError;
-    private onHeaders;
-    private onListening;
-    private onUnhandledRequest;
-    private socketDisconnected;
-    private startPinging;
-    private stopPinging;
-    private verifyClient;
-    emit(event: "close", data: CloseEvent): void;
-    emit(event: "connection", data: ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: "error", data: ErrorEvent): void;
-    emit(event: "headers", data: HeadersEvent): void;
-    emit(event: "handshake", data: HandshakeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: "listening", data: ListeningEvent): void;
-    emit(event: "ready", data: {}): void;
+    emit(event: 'close', data: CloseEvent): void;
+    emit(event: 'connection', data: ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
+    emit(event: 'error', data: ErrorEvent): void;
+    emit(event: 'headers', data: HeadersEvent): void;
+    emit(event: 'handshake', data: HandshakeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
+    emit(event: 'listening', data: ListeningEvent): void;
+    emit(event: 'ready', data: {}): void;
     emit(event: 'socketAuthStateChange', data: SocketAuthStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
     emit(event: 'socketAuthenticate', data: SocketAuthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
     emit(event: 'socketBadAuthToken', data: SocketBadAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
@@ -85,15 +72,18 @@ export declare class Server<TIncoming extends PublicMethodMap = {}, TChannel ext
     emit(event: 'socketSubscribeRequest', data: SocketSubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
     emit(event: 'socketSubscribeStateChange', data: SocketSubscribeStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
     emit(event: 'socketUnsubscribe', data: SocketUnsubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>): void;
-    emit(event: "warning", data: WarningEvent): void;
+    emit(event: 'warning', data: WarningEvent): void;
+    get exchange(): Exchange<TChannel>;
+    get isListening(): boolean;
+    get isReady(): boolean;
     listen(): DemuxedConsumableStream<StreamEvent<ServerEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>>;
-    listen(event: "close"): DemuxedConsumableStream<CloseEvent>;
-    listen(event: "connection"): DemuxedConsumableStream<ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: "error"): DemuxedConsumableStream<ErrorEvent>;
-    listen(event: "handshake"): DemuxedConsumableStream<HandshakeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: "headers"): DemuxedConsumableStream<HeadersEvent>;
-    listen(event: "listening"): DemuxedConsumableStream<ListeningEvent>;
-    listen(event: "ready"): DemuxedConsumableStream<{}>;
+    listen(event: 'close'): DemuxedConsumableStream<CloseEvent>;
+    listen(event: 'connection'): DemuxedConsumableStream<ConnectionEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
+    listen(event: 'error'): DemuxedConsumableStream<ErrorEvent>;
+    listen(event: 'handshake'): DemuxedConsumableStream<HandshakeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
+    listen(event: 'headers'): DemuxedConsumableStream<HeadersEvent>;
+    listen(event: 'listening'): DemuxedConsumableStream<ListeningEvent>;
+    listen(event: 'ready'): DemuxedConsumableStream<{}>;
     listen(event: 'socketAuthStateChange'): DemuxedConsumableStream<SocketAuthStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
     listen(event: 'socketAuthenticate'): DemuxedConsumableStream<SocketAuthenticateEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
     listen(event: 'socketBadAuthToken'): DemuxedConsumableStream<SocketBadAuthTokenEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
@@ -115,5 +105,15 @@ export declare class Server<TIncoming extends PublicMethodMap = {}, TChannel ext
     listen(event: 'socketSubscribeRequest'): DemuxedConsumableStream<SocketSubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
     listen(event: 'socketSubscribeStateChange'): DemuxedConsumableStream<SocketSubscribeStateChangeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
     listen(event: 'socketUnsubscribe'): DemuxedConsumableStream<SocketUnsubscribeEvent<TChannel, TService, TIncoming, TOutgoing, TPrivateIncoming, TPrivateOutgoing, TServerState, TState>>;
-    listen(event: "warning"): DemuxedConsumableStream<WarningEvent>;
+    listen(event: 'warning'): DemuxedConsumableStream<WarningEvent>;
+    private onClose;
+    private onConnection;
+    private onError;
+    private onHeaders;
+    private onListening;
+    private onUnhandledRequest;
+    private socketDisconnected;
+    private startPinging;
+    private stopPinging;
+    private verifyClient;
 }

package/dist/server.js

@@ -1,17 +1,42 @@
-import ws from "ws";
-import { ServerProtocolError } from "@socket-mesh/errors";
-import { ServerSocket } from "./server-socket.js";
-import defaultCodec from "@socket-mesh/formatter";
-import { removeAuthTokenHandler } from "@socket-mesh/client";
-import { defaultAuthEngine, isAuthEngine } from "@socket-mesh/auth-engine";
-import { handshakeHandler } from "./handlers/handshake.js";
-import { authenticateHandler } from "./handlers/authenticate.js";
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
-import { subscribeHandler } from "./handlers/subscribe.js";
-import { unsubscribeHandler } from "./handlers/unsubscribe.js";
-import { SimpleBroker } from "./broker/simple-broker.js";
-import { publishHandler } from "./handlers/publish.js";
+import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
+import { defaultAuthEngine, isAuthEngine } from '@socket-mesh/auth-engine';
+import { removeAuthTokenHandler } from '@socket-mesh/client';
+import { ServerProtocolError } from '@socket-mesh/errors';
+import defaultCodec from '@socket-mesh/formatter';
+import { WebSocketServer } from 'ws';
+import { SimpleBroker } from './broker/simple-broker.js';
+import { authenticateHandler } from './handlers/authenticate.js';
+import { handshakeHandler } from './handlers/handshake.js';
+import { publishHandler } from './handlers/publish.js';
+import { subscribeHandler } from './handlers/subscribe.js';
+import { unsubscribeHandler } from './handlers/unsubscribe.js';
+import { ServerSocket } from './server-socket.js';
 export class Server extends AsyncStreamEmitter {
+    _callIdGenerator;
+    _handlers;
+    _isListening;
+    _isReady;
+    _pingIntervalRef;
+    _wss;
+    // | ServerSocket<TIncomingMap, TServiceMap, TOutgoingMap, TPrivateIncomingMap, TPrivateOutgoingMap, TServerState, TSocketState>
+    ackTimeoutMs;
+    allowClientPublish;
+    auth;
+    brokerEngine;
+    clientCount;
+    clients;
+    codecEngine;
+    httpServer;
+    isPingTimeoutDisabled;
+    origins;
+    pendingClientCount;
+    pendingClients;
+    pingIntervalMs;
+    pingTimeoutMs;
+    plugins;
+    socketChannelLimit;
+    socketStreamCleanupMode;
+    strictHandshake;
     constructor(options) {
         super();
         let cid = 1;
@@ -30,12 +55,12 @@ export class Server extends AsyncStreamEmitter {
         this.clientCount = 0;
         this.codecEngine = options.codecEngine || defaultCodec;
         this._handlers = Object.assign({
-            "#authenticate": authenticateHandler,
-            "#handshake": handshakeHandler,
-            "#publish": publishHandler,
-            "#removeAuthToken": removeAuthTokenHandler,
-            "#subscribe": subscribeHandler,
-            "#unsubscribe": unsubscribeHandler
+            '#authenticate': authenticateHandler,
+            '#handshake': handshakeHandler,
+            '#publish': publishHandler,
+            '#removeAuthToken': removeAuthTokenHandler,
+            '#subscribe': subscribeHandler,
+            '#unsubscribe': unsubscribeHandler
         }, options.handlers);
         this.httpServer = options.server;
         this.plugins = options.plugins || [];
@@ -49,14 +74,14 @@ export class Server extends AsyncStreamEmitter {
         this.socketStreamCleanupMode = options.socketStreamCleanupMode || 'kill';
         this.strictHandshake = options.strictHandshake ?? true;
         options.verifyClient = this.verifyClient.bind(this);
-        this._wss = new ws.WebSocketServer(options);
+        this._wss = new WebSocketServer(options);
         this._wss.on('close', this.onClose.bind(this));
         this._wss.on('connection', this.onConnection.bind(this));
         this._wss.on('error', this.onError.bind(this));
         this._wss.on('headers', this.onHeaders.bind(this));
         this._wss.on('listening', this.onListening.bind(this));
         (async () => {
-            for await (let { error } of this.brokerEngine.listen('error')) {
+            for await (const { error } of this.brokerEngine.listen('error')) {
                 this.emit('warning', { warning: error });
             }
         })();
@@ -80,34 +105,34 @@ export class Server extends AsyncStreamEmitter {
     }
     bind(socket) {
         /*
-                if (socket.type === 'client') {
-                    (async () => {
-                        for await (let event of socket.listen()) {
-                            this.emit(
-                                `socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}` as any,
-                                Object.assign(
-                                    { socket },
-                                    event.value
-                                )
-                            );
-                        }
-                    })();
-            
-                    (async () => {
-                        for await (let event of socket.channels.listen()) {
-                            this.emit(
-                                `socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}` as any,
-                                Object.assign(
-                                    { socket },
-                                    event.value
-                                )
-                            );
-                        }
-                    })();
+        if (socket.type === 'client') {
+            (async () => {
+                for await (let event of socket.listen()) {
+                    this.emit(
+                        `socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}` as any,
+                        Object.assign(
+                            { socket },
+                            event.value
+                        )
+                    );
+                }
+            })();
+
+            (async () => {
+                for await (let event of socket.channels.listen()) {
+                    this.emit(
+                        `socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}` as any,
+                        Object.assign(
+                            { socket },
+                            event.value
+                        )
+                    );
                 }
-        */
+            })();
+        }
+*/
         (async () => {
-            for await (let {} of socket.listen('connect')) {
+            for await (const _ of socket.listen('connect')) {
                 if (this.pendingClients[socket.id]) {
                     delete this.pendingClients[socket.id];
                     this.pendingClientCount--;
@@ -118,12 +143,12 @@ export class Server extends AsyncStreamEmitter {
             }
         })();
         (async () => {
-            for await (let {} of socket.listen('connectAbort')) {
+            for await (const _ of socket.listen('connectAbort')) {
                 this.socketDisconnected(socket);
             }
         })();
         (async () => {
-            for await (let {} of socket.listen('disconnect')) {
+            for await (const _ of socket.listen('disconnect')) {
                 this.socketDisconnected(socket);
             }
         })();
@@ -139,12 +164,15 @@ export class Server extends AsyncStreamEmitter {
                 resolve();
             });
             if (!keepSocketsOpen) {
-                for (let socket of Object.values(this.clients)) {
+                for (const socket of Object.values(this.clients)) {
                     socket.disconnect();
                 }
             }
         });
     }
+    emit(event, data) {
+        super.emit(event, data);
+    }
     get exchange() {
         return this.brokerEngine.exchange;
     }
@@ -154,32 +182,35 @@ export class Server extends AsyncStreamEmitter {
     get isReady() {
         return this._isReady;
     }
+    listen(event) {
+        return event ? super.listen(event) : super.listen();
+    }
     onClose(code, reason) {
         this.emit('close', {});
     }
     onConnection(wsSocket, upgradeReq) {
         /*
-                if (!wsSocket.upgradeReq) {
-                    // Normalize ws modules to match.
-                    wsSocket.upgradeReq = upgradeReq;
-                }
-        */
+        if (!wsSocket.upgradeReq) {
+            // Normalize ws modules to match.
+            wsSocket.upgradeReq = upgradeReq;
+        }
+*/
         const socket = new ServerSocket({
             ackTimeoutMs: this.ackTimeoutMs,
             callIdGenerator: this._callIdGenerator,
             codecEngine: this.codecEngine,
             handlers: this._handlers,
-            plugins: this.plugins,
             onUnhandledRequest: this.onUnhandledRequest.bind(this),
+            plugins: this.plugins,
             request: upgradeReq,
-            socket: wsSocket,
             server: this,
+            socket: wsSocket,
             state: {},
             streamCleanupMode: this.socketStreamCleanupMode
         });
         this.pendingClientCount++;
         this.bind(this.pendingClients[socket.id] = socket);
-        //		ws.on('error', console.error);
+        // ws.on('error', console.error);
         this.emit('connection', { socket, upgradeReq });
         // Emit event to signal that a socket handshake has been initiated.
         this.emit('handshake', { socket });
@@ -200,11 +231,11 @@ export class Server extends AsyncStreamEmitter {
     onUnhandledRequest(socket, packet) {
     }
     socketDisconnected(socket) {
-        if (!!this.pendingClients[socket.id]) {
+        if (this.pendingClients[socket.id]) {
             delete this.pendingClients[socket.id];
             this.pendingClientCount--;
         }
-        if (!!this.clients[socket.id]) {
+        if (this.clients[socket.id]) {
             delete this.clients[socket.id];
             this.clientCount--;
         }
@@ -218,7 +249,7 @@ export class Server extends AsyncStreamEmitter {
                 for (const id in this.clients) {
                     this.clients[id]
                         .ping()
-                        .catch(err => {
+                        .catch((err) => {
                         this.onError(err);
                     });
                 }
@@ -237,16 +268,18 @@ export class Server extends AsyncStreamEmitter {
                 info.origin = '*';
             }
             if (this.origins.indexOf('*:*') === -1) {
-                let ok = false;
+                let isOk = false;
                 try {
                     const url = new URL(info.origin);
                     url.port = url.port || (url.protocol === 'https:' ? '443' : '80');
-                    ok = !!(~this.origins.indexOf(url.hostname + ':' + url.port) ||
-                        ~this.origins.indexOf(url.hostname + ':*') ||
-                        ~this.origins.indexOf('*:' + url.port));
+                    isOk = !!(~this.origins.indexOf(url.hostname + ':' + url.port)
+                        || ~this.origins.indexOf(url.hostname + ':*')
+                        || ~this.origins.indexOf('*:' + url.port));
+                }
+                catch (e) {
+                    // Intentional
                 }
-                catch (e) { }
-                if (!ok) {
+                if (!isOk) {
                     const error = new ServerProtocolError(`Failed to authorize socket handshake - Invalid origin: ${info.origin}`);
                     this.emit('warning', { warning: error });
                     callback(false, 403, error.message);
@@ -272,10 +305,4 @@ export class Server extends AsyncStreamEmitter {
             callback(false, 403, typeof err === 'string' ? err : err.message);
         }
     }
-    emit(event, data) {
-        super.emit(event, data);
-    }
-    listen(event) {
-        return super.listen(event);
-    }
 }

package/package.json

@@ -1,18 +1,42 @@
 {
 	"name": "@socket-mesh/server",
 	"description": "A TCP socket pair for easily transmitting full messages without worrying about request size limits.",
-	"version": "18.1.4",
+	"version": "18.1.5",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"files": ["./dist"],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./broker": {
+			"types": "./dist/broker/index.d.ts",
+			"import": "./dist/broker/index.js",
+			"default": "./dist/broker/index.js"
+		},
+		"./events": {
+			"types": "./dist/events/index.d.ts",
+			"import": "./dist/events/index.js",
+			"default": "./dist/events/index.js"
+		},
+		"./handlers": {
+			"types": "./dist/handlers/index.d.ts",
+			"import": "./dist/handlers/index.js",
+			"default": "./dist/handlers/index.js"
+		}
+	},
 	"author": {
 		"name": "Greg Kimmy"
 	},
 	"scripts": {
 		"build": "node ../../scripts/build.mjs && tsc --project tsconfig.build.json",
-		"deploy": "npm run build && node ../../scripts/publish.mjs",
-		"test": "cross-env node --test --import=./run-test.js test/server-test.ts"
+		"deploy": "node ../../scripts/publish.mjs",
+		"lint": "eslint . --c ../../eslint.config.mjs",
+		"lint:fix": "eslint . --c ../../eslint.config.mjs --fix",
+		"test": "tsx --tsconfig ./tsconfig.build.json --test ./src/**/*.{spec,test}.ts ./test/**/*.{spec,test}.ts"
 	},
 	"repository": {
 		"type": "git",
@@ -22,22 +46,27 @@
 		"url": "https://github.com/socket-mesh/client-server/labels/server"
 	},	
 	"devDependencies": {
-		"@socket-mesh/local-storage": "^1.0.2",
-		"@types/base64id": "^2.0.2",
-		"@types/jsonwebtoken": "^9.0.6",
-		"@types/ws": "^8.5.10"
+		"@socket-mesh/local-storage": "workspace:^",
+		"@socket-mesh/typescript-config": "workspace:^",
+		"@types/base64id": "catalog:base64id",
+		"@types/jsonwebtoken": "catalog:json-web-token",
+		"@types/ws": "catalog:ws"
 	},
 	"dependencies": {
-		"@socket-mesh/async-stream-emitter": "^7.1.2",
-		"@socket-mesh/auth": "^2.2.0",
-		"@socket-mesh/auth-engine": "^1.0.0",
-		"@socket-mesh/client": "^18.1.5",
-		"@socket-mesh/errors": "^3.2.0",
-		"@socket-mesh/formatter": "^4.1.0",
-		"base64id": "^2.0.0",
-		"events": "^3.3.0",
-		"jsonwebtoken": "^9.0.2",
-		"ws": "^8.18.0"
+		"@socket-mesh/async-stream-emitter": "workspace:^",
+		"@socket-mesh/auth": "workspace:^",
+		"@socket-mesh/auth-engine": "workspace:^",
+		"@socket-mesh/channels": "workspace:^",
+		"@socket-mesh/client": "workspace:^",
+		"@socket-mesh/core": "workspace:^",
+		"@socket-mesh/errors": "workspace:^",
+		"@socket-mesh/formatter": "workspace:^",
+		"@socket-mesh/stream-demux": "workspace:^",
+		"@socket-mesh/writable-consumable-stream": "workspace:^",
+		"base64id": "catalog:base64id",
+		"events": "catalog:",
+		"jsonwebtoken": "catalog:json-web-token",
+		"ws": "catalog:ws"
 	},
 	"keywords": [
 		"ncom",