playsocketjs 3.1.2 → 4.0.0

package/README.md

@@ -1,278 +1,379 @@
-# PlaySocket Client
+# PlaySocket
 
-A reactive, optimistic WebSocket library that simplifies game & app development by abstracting away complex sync logic.
+An optimistic-first WebSocket synchronization library. Built for creating multiplayer games & collaborative experiences with reactive web frameworks.
 
 ## Why use PlaySocket?
 
-PlaySocket eliminates the traditional complexity of collaborative experiences:
+PlaySocket makes developing shared experiences a breeze:
 
-- **Streamlined architecture**: No additional backend code is required, but server-authoritative behavior supported
-- **State synchronization**: Built-in storage system keeps the full state synchronized across all clients, always conflict-free and in order
-- **Resilient & secure connections**: Automatic reconnection handling & strict rate-limiting
-- **Lightweight**: Uses WebSockets for efficient, predictable, reliable communication and has little dependencies
+- **Optimistic-first**: Updates apply locally right away and merge conflict-free across clients. Calling `updateStorage()` triggers the `storageUpdated` event instantly, without waiting for a server roundtrip.
+- **Fast prototyping**: No backend code beyond init is required, though server-authoritative validation and behavior are supported for production apps.
+- **Built for reactivity**: Assign the synced storage to a reactive variable via a callback, ideal for React, Svelte & co.
+- **Resilient & secure**: Automatic reconnection handling & strict rate-limiting.
+- **Lightweight**: Uses WebSockets, has few dependencies, and utilizes `MessagePack` for maximum efficiency.
+
+<!-- docs-start -->
 
 ## Installation
 
+Install PlaySocket with your package manager of choice to get started.
+
 ```bash
 npm install playsocketjs
 ```
 
-## Usage examples
+## PlaySocket Client
+
+The client-side part of PlaySocket.
+
+### Examples
 
-Note that in production, you should **always try...catch** promises, such as socket.init() – they can reject!
+> [!NOTE]
+> In production, you should **always try...catch** promises such as `socket.init()` as they can reject. These examples omit the error handling to keep them simple.
 
 Initializing the client:
 ```javascript
-import PlaySocket from 'playsocketjs';
+import PlaySocket from "playsocketjs";
 
 // Create a new instance
-const socket = new PlaySocket('unique-client-id', { // You can pass no ID to let the server pick one
-    endpoint: 'wss://example.com/socket'
+// Omit the ID to let the server pick one
+const socket = new PlaySocket("unique-client-id", {
+    endpoint: "wss://example.com/socket"
 });
 
-// Set up event handlers (optional)
-socket.onEvent('status', status => console.log('Status:', status));
-socket.onEvent('error', status => console.log('Error:', status));
+// Set up the event handlers you need
+socket.onEvent("status", status => console.log(status));
+socket.onEvent("error", error => console.error(error));
+...
 
-const clientId = await socket.init(); // Initialize the socket
+const clientId = await socket.init(); // Connect
 ```
 
 Creating a room:
 ```javascript
 // Create a new room
 const roomId = await socket.createRoom();
+```
 
+```javascript
 // Optionally, with initial storage
 const roomId = await socket.createRoom({
-  players: ["this-player"],
+  players: [{ name: "Player-1", level: 35 }],
   latestPlayer: null,
 });
 ```
 
 Joining a room:
 ```javascript
-await socket.joinRoom('room-id'); // Join an existing room
+await socket.joinRoom("room-id"); // Join an existing room
 ```
 
 Leaving a room:
 ```javascript
-socket.destroy(); // To leave the room, destroy the instance
+socket.destroy(); // Destroy the instance to leave
 ```
 
-Using the storage update event for reactivity:
+Using the storage update event with reactivity:
 ```javascript
-const reactiveVariable = useState(); // Or $state(), reactive(), depending on your framework
-socket.onEvent('storageUpdated', storage => (reactiveVariable = storage)); // Assign on update
+// Assign to useState(), $state(), reactive() etc. on update
+const [reactiveVar, setReactiveVar] = useState({});
+socket.onEvent("storageUpdated", storage => {
+    setReactiveVar(storage);
+});
 ```
 
-Interfacing with the synchronized storage (examples):
+```jsx
+<p>Players: {reactiveVar.players?.join(", ")}</p>
+```
+
+Interfacing with the synchronized storage:
 ```javascript
-const currentState = socket.storage; // Synchronous, local access
-socket.updateStorage('players', 'array-add-unique', { username: 'Player4', level: 2 }); // Special method to enable conflict-free additions for arrays
-socket.updateStorage('latestPlayer', 'set', 'Player4'); // Regular synced storage update
+const currentState = socket.storage; // Read-only access
+
+socket.updateStorage("players", "array-add-unique", { username: "Player4", level: 2 });
+socket.updateStorage("latestPlayer", "set", "Player4");
+socket.updateStorage("playerInfo", "set", { date: "22-6-2026" });
+socket.updateStorage("playerInfo", "object-set-key", "color", "red")
+
+console.log(socket.storage.players); // Log players array
 ```
 
-Sending traditional requests to the server:
+Sometimes it's convenient to send a traditional request to the server. For example, when you want to opt out of optimistic updates for asynchronous work, or when
+the validation logic would be too complex otherwise:
 ```javascript
-socket.sendRequest('chosen-request-name', { fact: "You can build server-authoritative logic using this!" })
+await socket.sendRequest("my-request-name", { fact: "You can build traditional client-server logic like this." })
 ```
 
-## API reference
+### API
 
-### Constructor
+#### Constructor
 
-Creates a new PlaySocket instance with a specified ID and configuration options.
+Create a new PlaySocket instance with a specified ID and configuration options.
 The ID can be set to `null` to let the server pick a unique one.
 
 ```javascript
 new PlaySocket(id?: string, options: PlaySocketOptions)
 ```
 
-#### Configuration options
+| Option | Type | Required | Default | Description |
+|--------|------|----------|---------|-------------|
+| `endpoint` | `string` | Yes | `undefined` | WebSocket server endpoint (e.g., wss://example.com/socket). |
+| `customData` | `object` | No | `{}` | Arbitrary data to pass to the "clientRegistered" server event. |
+| `debug` | `boolean` | No | `false` | Set to true to enable extra logging. |
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `endpoint` | string | `undefined` | WebSocket server endpoint (e.g., 'wss://example.com/socket') (required) |
-| `customData` | object | `{}` | Arbitrary data to pass to the "clientRegistered" server event |
-| `debug` | boolean | `false` | Set to true to enable extra logging |
+#### Methods
 
-### Methods
-
-| Method | Parameters | Return type | Description |
+| Name | Parameters | Return type | Description |
 |--------|------------|-------------|-------------|
-| `init()` | - | `Promise<string>` | Initialize the WebSocket connection – Returns a promise which resolves with the client's ID |
-| `createRoom()` | `initialStorage?: object, size?: number` | `Promise<string>` | Create a new room and become host – Returns a promise which resolves with the room ID. The room participant maximum is 100 |
-| `joinRoom()` | `roomId: string` | `Promise<void>` | Join an existing room |
-| `destroy()` | - | `void` | Use this to leave a room and close the connection |
-| `updateStorage()` | `key: string, type: 'set' \| 'array-add' \| 'array-add-unique' \| 'array-remove-matching' \| 'array-update-matching', value: any, updateValue?: any` | `void` | Update a key in the shared storage (max. 100 keys). Array operation types allow for conflict-free simultaneous array updates. For '-matching' operations, value becomes the value to match, and updateValue the replacement |
-| `sendRequest()` | `name: string, data?: any` | `void` | Send requests to the server with optional custom data (handle them in the `requestReceived` server event) |
-| `onEvent()` | `event: string, callback: Function` | `void` | Register an event callback |
+| `init()` | - | `Promise<string>` | Initialize the WebSocket connection, resolves with the client ID. |
+| `createRoom()` | `initialStorage?: object, size?: number` | `Promise<string>` | Create a new room, resolves with the room ID. Max. 500 participants. |
+| `joinRoom()` | `roomId: string` | `Promise<void>` | Join an existing room. |
+| `destroy()` | - | `void` | Leave room, close the connection, and destroy the instance. |
+| `updateStorage()` | `key: string, type: string, value: any, secondValue?: any` | `void` | Update a key in the shared storage. |
+| `sendRequest()` | `name: string, data?: any` | `Promise<void>` | Send a request to the server with optional attached data. |
+| `onEvent()` | `event: string, callback: Function` | `() => void` | Register an event callback. Returns unsubscribe function. |
 
-### Event types
+#### Events
 
 | Event | Callback parameter | Description |
 |-------|-------------------|-------------|
-| `status` | `status: string` | Connection status updates |
-| `error` | `error: string` | Error events |
-| `moved` | `roomId: string` | Moved to different room |
-| `instanceDestroyed` | - | Destruction event - triggered by manual .destroy() method invocation or by fatal errors and disconnects |
-| `storageUpdated` | `storage: object` | Storage state changes |
-| `hostMigrated` | `roomId: string` | Host changes |
-| `clientJoined` | `clientId: string` | New client joined the room |
-| `clientLeft` | `clientId: string, roomId?: string` | Client left the room |
+| `status` | `status: string` | Connection or room status updated. |
+| `error` | `error: string` | Error occurred. |
+| `moved` | `roomId: string` | Moved to different room. |
+| `instanceDestroyed` | - | Instance destroyed through `destroy()` or fatal error. |
+| `storageUpdated` | `storage: object` | Storage state changed. Does not trigger on no-op updates. |
+| `hostMigrated` | `roomId: string` | Host was changed. |
+| `clientJoined` | `clientId: string` | New client joined the room. |
+| `clientLeft` | `clientId: string, roomId?: string` | A client left the room. |
 
-### Properties (Read-only)
+#### Properties
 
 | Property | Type | Description |
 |----------|------|-------------|
-| `id` | string | Client's unique identifier on the WebSocket server |
-| `isHost` | boolean | If this user is currently assigned the host role |
-| `participantCount` | number | Number of active client connections in room (with yourself) |
-| `storage` | object | Retrieve storage object |
-
-&nbsp;
+| `id` | `string` | Client's unique ID. |
+| `isHost` | `boolean` | Whether this client is currently assigned the host role. |
+| `participantCount` | `number` | Number of active client connections in room. |
+| `storage` | `object` | Retrieve the storage object. |
 
-# PlaySocket Server
+## PlaySocket Server
 
-PlaySocket includes a server implementation that can be set up in seconds.
+The server-side part of PlaySocket.
 
-## Installation
+### Examples
 
-To use the server component, you'll need to install playsocketjs and the ws package:
-
-```bash
-npm install playsocketjs ws
-```
-
-## Usage examples
-
-Here are usage examples for a standalone server and an Express.js application.
-
-### Standalone server
+Using PlaySocket as a standalone server:
 
 ```javascript
-import PlaySocketServer from 'playsocketjs/server'; // Both ES Module & CommonJS Module syntax is supported
+import PlaySocketServer from "playsocketjs/server";
 
-const server = new PlaySocketServer(); // Create and start the server (default path is /)
+// Path defaults to "/"
+const server = new PlaySocketServer();
 
-// Gracefully disconnect all clients and close the server (optional)
 function shutdown() {
-    server.stop();
+    server.stop(); // Gracefully disconnect all clients
     process.exit(0);
 }
 
-// Handle both SIGINT and SIGTERM
-process.on('SIGINT', shutdown);
-process.on('SIGTERM', shutdown);
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
 ```
 
-### Together with Express.js (or other Backend frameworks)
+Using PlaySocket together with Express.js (or other backend frameworks):
 
 ```javascript
-const express = require('express');
-const http = require('http');
-const PlaySocketServer = require('playsocketjs/server');
+import express from "express";
+import http from "node:http";
+import PlaySocketServer from "playsocketjs/server";
 
 const app = express();
 const httpServer = http.createServer(app);
 
-// Create PlaySocket server with your HTTP server
+// Create PlaySocket server with existing HTTP server
 const playSocketServer = new PlaySocketServer({
   server: httpServer,
-  path: '/socket'
+  path: "/socket"
 });
 
 // Start the server
 httpServer.listen(3000, () => {
-  console.log('Server running on port 3000');
+  console.log("Server running on port 3000");
 });
 
-// Gracefully disconnect all clients and close the server (recommended)
 function shutdown() {
-    server.stop();
+    playSocketServer.stop(); // Gracefully disconnect clients
     process.exit(0);
 }
 
-// Handle both SIGINT and SIGTERM
-process.on('SIGINT', shutdown);
-process.on('SIGTERM', shutdown);
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
 ```
 
-## API reference
+Validating an incoming storage update:
 
-### Constructor
+```javascript
+const server = new PlaySocketServer();
 
-Creates a new PlaySocket Server instance with configuration options.
+server.onEvent("storageUpdateRequested", ({ roomId, clientId, update, storage }) => {
+    // Block updates on all keys except for "players" and "chats"
+    if (!["players", "chats"].includes(update.key)) return false;
+
+    if (update.key === "chats") {
+        const { type, value, secondValue } = server.getUpdateDetails(update);
+        if (type !== "array-add") return false; // Only allow adding chats
+        if (typeof value !== "string") return false; // Only allow strings
+    }
+});
+```
+
+Handling an incoming request:
 
 ```javascript
-new PlaySocket(options: PlaySocketServerOptions)
+const server = new PlaySocketServer();
+
+server.onEvent("requestReceived", async ({ roomId, clientId, name, data }) => {
+    if (name === "add-player-request") {
+        const players = server.getRoomStorage(roomId)?.players || [];
+
+        // Returning false or string rejects sendRequest() on the client
+        if (players.find(p => p.id === clientId)) return "Player already added!";
+
+        server.updateRoomStorage(roomId, "players", "array-add", { id: clientId, timestamp: Date.now() });
+    }
+});
+```
+
+Combining PlaySocket with a custom authentication system:
+
+```javascript
+const authedClients = [];
+const server = new PlaySocketServer();
+
+server.onEvent("clientRegistrationRequested", async (clientId, data) => {
+    try {
+        // Your custom auth logic...
+        // For example, data could contain a token
+        authedClients.push(clientId);
+    } catch (error) {
+        return "Error occurred during auth."; // Blocks the registration
+    }
+});
+
+server.onEvent("clientDisconnected", async (clientId) => {
+    const removeIndex = authedClients.indexOf(clientId);
+    if (removeIndex !== -1) authedClients.splice(removeIndex, 1);
+});
+
 ```
 
-### Configuration options
+### API
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `port` | number | 3000 | Port to listen on (used only if no server provided) |
-| `path` | string | '/' | WebSocket endpoint path |
-| `server` | http.Server | - | Existing http server (optional) |
-| `rateLimit` | number | 20 | Adjust the messages/second rate limit |
-| `debug` | boolean | false | Set to true to enable extra logging |
-| `verifyClient` | function | - | Optional callback to verify connections before WebSocket upgrade |
+#### Constructor
 
-#### verifyClient callback
+Create a new PlaySocket Server instance with configuration options.
+
+```javascript
+new PlaySocketServer(options?: PlaySocketServerOptions)
+```
+
+| Option | Type | Required | Default | Description |
+|--------|------|----------|---------|-------------|
+| `port` | `number` | No | 3000 | Port to listen on (used only if no server provided). |
+| `path` | `string` | No | "/" | WebSocket endpoint path. |
+| `server` | `http.Server` | No | - | Existing http server. |
+| `rateLimit` | `number` | No | 20 | Messages/second rate limit. |
+| `debug` | `boolean` | No | false | Enable debug logging. |
+| `verifyClient` | `function` | No | - | Callback to verify connections before WebSocket upgrade. |
 
 The `verifyClient` option allows you to implement custom connection verification logic, such as rate limiting, before the WebSocket handshake completes.
 
 ```javascript
 const server = new PlaySocketServer({
     server: httpServer,
-    path: '/socket',
+    path: "/socket",
     verifyClient: (info, callback) => {
-        // info.req - the HTTP request object, info.origin - the Origin header value
-        const ip = info.req.headers['x-forwarded-for'] || info.req.socket.remoteAddress;
-        if (isRateLimited(ip)) return callback(false, 429, 'Too Many Requests');
+        const forwarded = info.req.headers["x-forwarded-for"];
+        const ip = forwarded ? forwarded.split(",")[0].trim() : info.req.socket.remoteAddress;
+        if (isRateLimited(ip)) {
+            return callback(false, 429, "Too Many Requests");
+        }
         callback(true);
     }
 });
 ```
 
-The callback signature is `callback(verified, code?, message?)` where `code` and `message` are the optional HTTP response status for rejected connections.
+The callback signature is `callback(verified, code?, message?)` where `code` refers to an HTTP status code and `message` to a rejection reason.
 
-### Methods
+#### Methods
 
-| Method | Parameters | Return type | Description |
-|--------|------------|-------------|-------------|
-| `stop()` | - | `void` | Closes all active client connections, the websocket server and the underlying http server if it's standalone |
-| `kick()` | `clientId: string, reason?: string` | `void` | Kick a client by their clientID – this will close their connection and set an error message |
-| `move()` | `clientId: string, roomId: string` | `void` | Move a client, that is already in a room, to a different room |
-| `onEvent()` | `event: string, callback: Function` | `void` | Register a server-side event callback |
-| `getRoomStorage()` | `roomId: string` | `object` | Get a snapshot of the current room storage |
-| `updateRoomStorage()` | `roomId: string, key: string, type: 'set' \| 'array-add' \| 'array-add-unique' \| 'array-remove-matching' \| 'array-update-matching', value: any, updateValue?: any` | `void` | Update a key in the shared room storage from the server |
-| `createRoom()` | `initialStorage?: object, size?: number, host?: string` | `object` | Create a room (returns object containing room ID and state)|
-| `destroyRoom()` | `roomId: string` | `void` | Destroy a room & kick all participants |
+> [!IMPORTANT]
+> Rooms created by the server default to host ID "server". If that host string is used, the room will not be auto-deleted when all participants have left and you need to take care of its lifecycle.
 
-### Event types
+| Name | Parameters | Return type | Description |
+|--------|------------|-------------|-------------|
+| `stop()` | - | `void` | Closes active client connections and the underlying http server (if it's standalone). |
+| `kick()` | `clientId: string, reason?: string` | `void` | Kick a client by their client ID. |
+| `move()` | `clientId: string, roomId: string` | `void` | Move a client that is already in a room to a different room. |
+| `onEvent()` | `event: string, callback: Function` | `() => void` | Register a server-side event callback. Returns unsubscribe function. |
+| `getRoomStorage()` | `roomId: string` | `object` | Get a snapshot of the current room storage. |
+| `getUpdateDetails()` | `update: object` | `object` | Get the details (`type`, `value` and `secondValue`) of a storage update for building validation logic. |
+| `updateRoomStorage()` | `roomId: string, key: string, type: string, value: any, secondValue?: any` | `void` | Update a key in the shared storage of a room. |
+| `createRoom()` | `initialStorage?: object, size?: number, host?: string` | `object` | Create a room (returns object containing room ID and state).|
+| `destroyRoom()` | `roomId: string` | `void` | Destroy a room & kick all participants. |
+
+#### Events
 
 | Event | Callback parameters | Description | Return for action |
 |-------|-------------------|-------------|--------------|
-| `clientRegistered` | `clientId: string, customData: object` | Client registered with the server | - |
-| `clientRegistrationRequested` | `clientId: string, customData: object` | Client requests to register | Return `false` or rejection reason `string` to block |
-| `clientDisconnected` | `clientId: string` | Client disconnected from the server | - |
-| `clientJoinedRoom` | `clientId: string, roomId: string` | Client joined a room | - |
-| `clientJoinRequested` | `clientId: string, roomId: string` | Client requests to join a room | Return `false` or rejection reason `string` to block |
-| `clientLeftRoom` | `clientId: string, roomId: string` | Client left a room | - |
-| `roomCreated` | `roomId: string` | Client created a room | - |
-| `roomDestroyed` | `roomId: string` | Room was destroyed (happens when all participants leave, unless room host is "server") | - |
-| `roomCreationRequested` | `{clientId: string, initialStorage: object}` | Room creation requested by client | Return `object` to override initial storage, `false` to deny |
-| `storageUpdated` | `{clientId: string, roomId: string, update: object, storage: object}` | Room storage property updated | - |
-| `storageUpdateRequested` | `{clientId: string, roomId: string, update: object, storage: object}` | Room storage property update requested by client | Return `false` to block the update |
-| `requestReceived` | `{clientId: string, roomId?: string, requestName: string, data?: any}` | Request from client was received by the server | - |
-
-### Properties (Read-only)
+| `clientRegistered` | `clientId: string, customData: object` | Client registered with the server. | - |
+| `clientRegistrationRequested` | `clientId: string, customData: object` | Client requested to register. | Return `false` or rejection reason `string` to block. |
+| `clientDisconnected` | `clientId: string` | Client disconnected. | - |
+| `clientJoinedRoom` | `clientId: string, roomId: string` | Client joined a room. | - |
+| `clientJoinRequested` | `clientId: string, roomId: string` | Client requested to join a room. | Return `false` or rejection reason `string` to block. |
+| `clientLeftRoom` | `clientId: string, roomId: string` | Client left a room. | - |
+| `roomCreated` | `roomId: string` | Room was created. | - |
+| `roomDestroyed` | `roomId: string` | Room was destroyed. | - |
+| `roomCreationRequested` | `{clientId: string, initialStorage: object}` | Client requested to create room. | Return `object` to override initial storage, `false` or rejection reason `string` to block. |
+| `storageUpdated` | `{clientId: string, roomId: string, update: object, storage: object}` | Room storage updated. | - |
+| `storageUpdateRequested` | `{clientId: string, roomId: string, update: object, storage: object}` | Client requested storage update. | Return `false` or rejection reason `string` to block the update. Callback must be synchronous. |
+| `requestReceived` | `{clientId: string, roomId?: string, name: string, data?: any}` | Request from client. | Return `false` or rejection reason `string` to block. |
+
+When multiple callbacks are registered for an event, all of them run, and for events that respond to a return value, the first non-null return value is used. A callback that throws counts as returning `false`.
+
+#### Properties
 
 | Property | Type | Description |
 |----------|------|-------------|
-| `rooms` | object | Retrieve the rooms object |
+| `rooms` | `object` | Retrieve the rooms object. |
+
+## Storage
+
+Both `updateStorage()` and `updateRoomStorage()` work the same way. The only difference is that the latter takes `roomId` as the first argument and runs on the server. There's a limit of 100 storage keys.
+
+Number, array and object operation types allow for conflict-free simultaneous updates. The set operation just replaces the property and ensures correct ordering. 
+
+For `-matching` operation types, `value` becomes the value to match, and `secondValue` the replacement. For object operations, `value` is the property key, and `secondValue` the property value. 
+
+### Operation types
+- `set`
+- `number-increment`
+- `array-add`
+- `array-add-unique`
+- `array-update-matching`
+- `array-remove-matching`
+- `object-set-key`
+- `object-remove-key`
+
+Example for each type:
+- `updateStorage("color", "set", "blue")`
+- `updateStorage("score", "number-increment", 25)`
+- `updateStorage("players", "array-add", { name: "Player2" })`
+- `updateStorage("completedLevels", "array-add-unique", 14)`
+- `updateStorage("names", "array-update-matching", "Leo_cool", "TheCoolerLeo")`
+- `updateStorage("missingLevels", "array-remove-matching", 14)`
+- `updateStorage("levelNames", "object-set-key", "evilSea", "Evil sea")`
+- `updateStorage("levelNames", "object-remove-key", "darkOcean")`
+
+<!-- docs-end -->
 
 # License
 

package/package.json

@@ -1,26 +1,29 @@
 {
   "name": "playsocketjs",
-  "version": "3.1.2",
+  "version": "4.0.0",
   "description": "WebSocket wrapper for creating simple multiplayer systems with ease.",
   "type": "module",
-  "module": "dist/playsocket-client.js",
+  "module": "./src/client/client.js",
   "exports": {
     ".": {
-      "import": "./dist/playsocket-client.js"
+      "types": "./types/client/client.d.ts",
+      "import": "./src/client/client.js"
     },
     "./server": {
-      "import": "./dist/playsocket-server.js"
+      "types": "./types/server/server.d.ts",
+      "import": "./src/server/server.js"
     }
   },
   "files": [
-    "dist"
+    "src",
+    "types"
   ],
   "scripts": {
     "start": "node example/example-server.js",
     "test": "npm run build && npx playwright test --config e2e/playwright.config.js",
     "test:headed": "npm run build && npx playwright test --config e2e/playwright.config.js --headed",
-    "build": "rollup -c rollup.config.js",
-    "lint": "eslint ./src"
+    "build": "tsc -p tsconfig.declarations.json",
+    "lint": "eslint ."
   },
   "repository": {
     "type": "git",
@@ -41,16 +44,24 @@
   "homepage": "https://github.com/therealPaulPlay/PlaySocketJS#readme",
   "devDependencies": {
     "@playwright/test": "^1.58.1",
-    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@types/node": "^26.1.1",
     "eslint": "^9.35.0",
-    "eslint-plugin-jsdoc": "^54.4.0",
+    "eslint-plugin-unused-imports": "^4.4.1",
     "globals": "^16.3.0",
-    "rollup": "^4.31.0"
+    "typescript": "^7.0.2"
   },
-  "peerDependencies": {
+  "dependencies": {
+    "@msgpack/msgpack": "^3.1.1",
+    "@types/ws": "^8.18.1",
     "ws": "^8.18.1"
   },
-  "dependencies": {
-    "@msgpack/msgpack": "^3.1.1"
+  "types": "./types/client/client.d.ts",
+  "typesVersions": {
+    "*": {
+      "server": [
+        "./types/server/server.d.ts"
+      ]
+    }
   }
 }