playsocketjs 1.3.1 → 1.4.1

package/README.md

@@ -206,8 +206,11 @@ Creates a new PlaySocket Server instance with configuration options.
 
 - `clientRegistered`: Client registered with the server (returns the client's id `string`, customData `object`)
 - `clientDisconnected`: Client disconnected from the server (returns the client's id `string`)
+- `clientJoinedRoom`: Client joined a room – note that clients can only leave by disconnecting (returns the client's id `string`, room id `string`)
 - `roomCreated`: Client created a room (returns room id `string`)
-- `roomJoined`: Client joined a room (returns the client's id `string`, room id `string`)
+- `roomDestroyed`: Room was destroyed, this happens when all participants leave (returns room id `string`)
+- `roomCreationRequested`: Room creation requested by client (returns `object` containing the client's id `string`, room id `string` and the initialStorage `object`) – if you return an object, it will take that as the initial storage instead
+- `storageUpdateRequested`: Room storage property update requested by client (returns `object` containing the client's id `string`, room id `string` and the update `object`) – if you return `false` in the callback, the update will be blocked
 
 ### Properties (Read-only)
 

package/dist/playsocket-client.js

@@ -1791,19 +1791,19 @@ function requireCrdtManager () {
 	    /**
 	     * Update a property
 	     * @param {string} key 
-	     * @param {string} operation 
+	     * @param {string} type 
 	     * @param {*} value 
 	     * @param {*} updateValue 
 	     * @returns {Object} - Returns the property update
 	     */
-	    updateProperty(key, operation, value, updateValue) {
+	    updateProperty(key, type, value, updateValue) {
 	        try {
 	            // Sanitize inputs
 	            value = this.#sanitizeValue(value);
 	            updateValue = this.#sanitizeValue(updateValue);
 
 	            // Debug log
-	            if (this.#debug) console.log(CONSOLE_PREFIX + `Updating property with key ${key}, operation ${operation}, value ${value} and updateValue ${updateValue}.`);
+	            if (this.#debug) console.log(CONSOLE_PREFIX + `Updating property with key ${key}, type ${type}, value ${value} and updateValue ${updateValue}.`);
 
 	            // Increment vector clock
 	            const counter = this.#vectorClock.get(this.#replicaId) || 0;
@@ -1813,7 +1813,7 @@ function requireCrdtManager () {
 	            const currentOps = [...(this.#keyOperations.get(key) || [])];
 
 	            // Add operation
-	            const newOp = this.#createOperation({ operation, value, updateValue }, Array.from(this.#vectorClock.entries()));
+	            const newOp = this.#createOperation({ type, value, updateValue }, Array.from(this.#vectorClock.entries()));
 	            currentOps.push(newOp);
 	            this.#keyOperations.set(key, currentOps); // Update the operations (no need to sort via vector clock since local updates are always the latest)
 	            this.#processLocalProperty(key); // Process local value
@@ -1853,25 +1853,25 @@ function requireCrdtManager () {
 
 	            if (retainCount < operations.length) {
 	                if (this.#debug) console.log(CONSOLE_PREFIX + `Running garbage collection for key ${key} with current operations:`, operations);
-	                const retainOps = operations.slice(-retainCount); // newest ops
-	                const removeOps = operations.slice(0, -retainCount); // oldest ops (start =  idx 0, end = retainCount counted from right side)
+	                const retainOps = operations.slice(-retainCount); // Newest ops
+	                const removeOps = operations.slice(0, -retainCount); // Oldest ops (start =  idx 0, end = retainCount counted from right side)
 	                const baselineVectorClock = removeOps[removeOps.length - 1]?.vectorClock || []; // Use the vector clock from the last operation that we remove/overwrite 
 
 	                // Calculate the value at the point where retained operations start
 	                let baselineValue = null;
 	                for (const op of removeOps) {
 	                    if (!op.data) continue;
-	                    if (op.data.operation.startsWith('array') && !Array.isArray(baselineValue)) baselineValue = []; // Initialize array if required
+	                    if (op.data.type.startsWith('array') && !Array.isArray(baselineValue)) baselineValue = []; // Initialize array if required
 	                    baselineValue = this.#handleOperation(
 	                        baselineValue,
-	                        op.data.operation,
+	                        op.data.type,
 	                        op.data.value,
 	                        op.data.updateValue
 	                    );
 	                }
 
 	                // Create a compact operation with baseline value and appropriate vector clock
-	                const compactOp = this.#createOperation({ operation: "set", value: baselineValue }, baselineVectorClock);
+	                const compactOp = this.#createOperation({ type: "set", value: baselineValue }, baselineVectorClock);
 
 	                // Debug log
 	                if (this.#debug) console.log(CONSOLE_PREFIX + "Operations after garbage collection for this key:", [compactOp, ...retainOps]);
@@ -1913,10 +1913,10 @@ function requireCrdtManager () {
 
 	            for (const op of ops) {
 	                if (!op.data) continue;
-	                if (op.data.operation.startsWith('array') && !Array.isArray(value)) value = []; // Initialize array if required
+	                if (op.data.type.startsWith('array') && !Array.isArray(value)) value = []; // Initialize array if required
 	                value = this.#handleOperation(
 	                    value,
-	                    op.data.operation,
+	                    op.data.type,
 	                    op.data.value,
 	                    op.data.updateValue
 	                );
@@ -1924,7 +1924,7 @@ function requireCrdtManager () {
 
 	            this.#propertyStore[key] = value; // Save locally
 	        } catch (error) {
-	            console.error(CONSOLE_PREFIX + `Failed to process property for "${key}":`, error);
+	            console.error(CONSOLE_PREFIX + `Failed to process property for key ${key}:`, error);
 	        }
 	    }
 
@@ -1967,33 +1967,31 @@ function requireCrdtManager () {
 	    /**
 	     * Handle an operation
 	     * @param {*} curValue 
-	     * @param {string} operation 
+	     * @param {string} type 
 	     * @param {*} value 
 	     * @param {*} [updateValue]
 	     * @returns {*} - Value after the operation
 	     */
-	    #handleOperation(curValue, operation, value, updateValue) {
+	    #handleOperation(curValue, type, value, updateValue) {
 	        try {
-	            // Clone to avoid reference issues
-	            curValue = JSON.parse(JSON.stringify(curValue || null));
+	            // Deep copy to avoid reference issues in case value is or contains object(s)
+	            curValue = structuredClone(curValue);
 
 	            // Set operation
-	            if (operation === "set") return value;
+	            if (type === "set") return value;
 
 	            // Array operations
-	            if (operation.startsWith('array')) {
+	            if (type.startsWith('array')) {
 	                if (!Array.isArray(curValue)) curValue = []; // Auto-convert to array if current value isn't one
 
 	                // Comparison function
 	                const isObject = typeof value === 'object' && value !== null;
 	                const compare = (item) => {
-	                    if (isObject && typeof item === 'object' && item !== null) {
-	                        return JSON.stringify(item) === JSON.stringify(value); // Deep comparison
-	                    }
+	                    if (isObject && typeof item === 'object' && item !== null) return JSON.stringify(item) === JSON.stringify(value); // Deep comparison
 	                    return item === value; // Value comparison
 	                };
 
-	                switch (operation) {
+	                switch (type) {
 	                    case 'array-add':
 	                        curValue.push(value);
 	                        break;
@@ -2013,7 +2011,7 @@ function requireCrdtManager () {
 	            return curValue;
 
 	        } catch (error) {
-	            console.error(CONSOLE_PREFIX + `Failed to process operation with curValue ${curValue}:`, error);
+	            console.error(CONSOLE_PREFIX + `Failed to handle operation with curValue ${curValue}:`, error);
 	            return curValue;
 	        }
 	    }
@@ -2033,7 +2031,7 @@ function requireCrdtManager () {
 	    // Get property store
 	    get getPropertyStore() {
 	        try {
-	            return JSON.parse(JSON.stringify(this.#propertyStore)); // Return full copy
+	            return structuredClone(this.#propertyStore); // Return deep clone
 	        } catch {
 	            console.error(CONSOLE_PREFIX + "Failed to parse property store");
 	            return {};
@@ -2044,7 +2042,7 @@ function requireCrdtManager () {
 	    get didPropertiesChange() {
 	        try {
 	            if (JSON.stringify(this.#propertyStore) !== JSON.stringify(this.#lastPropertyStore)) {
-	                this.#lastPropertyStore = JSON.parse(JSON.stringify(this.#propertyStore));
+	                this.#lastPropertyStore = structuredClone(this.#propertyStore);
 	                return true;
 	            }
 	        } catch { }
@@ -2280,6 +2278,8 @@ class PlaySocket {
                         if (this.#pendingCreate) {
                             this.#inRoom = true;
                             this.#triggerEvent("status", `Room created${this.#pendingCreate.maxSize ? ` with max size ${this.#pendingCreate.maxSize}.` : '.'}`);
+                            this.#crdtManager.importState(message.state);
+                            this.#triggerEvent("storageUpdated", this.getStorage);
                             this.#pendingCreate.resolve(this.#pendingCreate.id);
                         }
                         break;
@@ -2318,6 +2318,12 @@ class PlaySocket {
                         }
                         break;
 
+                    case 'property_update_rejected':
+                        this.#triggerEvent("error", "Property update rejected. Re-syncing state.");
+                        this.#crdtManager.importState(message.state);
+                        this.#triggerEvent("storageUpdated", this.getStorage);
+                        break;
+
                     case 'server_stopped':
                         this.#triggerEvent("error", "Server restart.");
                         this.destroy();
@@ -2441,17 +2447,13 @@ class PlaySocket {
 
         return Promise.race([
             new Promise((resolve, reject) => {
-                Object.entries(initialStorage)?.forEach(([key, value]) => {
-                    this.#crdtManager.updateProperty(key, "set", value);
-                });
                 this.#roomHost = this.#id;
                 this.#pendingCreate = { maxSize, id: this.#id, resolve, reject };
                 this.#sendToServer({
                     type: 'create_room',
-                    state: this.#crdtManager.getState,
+                    initialStorage,
                     size: maxSize
                 });
-                this.#triggerEvent("storageUpdated", this.getStorage);
             }),
             this.#createTimeout("Room creation")
         ]).finally(() => {

package/dist/playsocket-server.js

@@ -1917,19 +1917,19 @@ function requireCrdtManager () {
 	    /**
 	     * Update a property
 	     * @param {string} key 
-	     * @param {string} operation 
+	     * @param {string} type 
 	     * @param {*} value 
 	     * @param {*} updateValue 
 	     * @returns {Object} - Returns the property update
 	     */
-	    updateProperty(key, operation, value, updateValue) {
+	    updateProperty(key, type, value, updateValue) {
 	        try {
 	            // Sanitize inputs
 	            value = this.#sanitizeValue(value);
 	            updateValue = this.#sanitizeValue(updateValue);
 
 	            // Debug log
-	            if (this.#debug) console.log(CONSOLE_PREFIX + `Updating property with key ${key}, operation ${operation}, value ${value} and updateValue ${updateValue}.`);
+	            if (this.#debug) console.log(CONSOLE_PREFIX + `Updating property with key ${key}, type ${type}, value ${value} and updateValue ${updateValue}.`);
 
 	            // Increment vector clock
 	            const counter = this.#vectorClock.get(this.#replicaId) || 0;
@@ -1939,7 +1939,7 @@ function requireCrdtManager () {
 	            const currentOps = [...(this.#keyOperations.get(key) || [])];
 
 	            // Add operation
-	            const newOp = this.#createOperation({ operation, value, updateValue }, Array.from(this.#vectorClock.entries()));
+	            const newOp = this.#createOperation({ type, value, updateValue }, Array.from(this.#vectorClock.entries()));
 	            currentOps.push(newOp);
 	            this.#keyOperations.set(key, currentOps); // Update the operations (no need to sort via vector clock since local updates are always the latest)
 	            this.#processLocalProperty(key); // Process local value
@@ -1979,25 +1979,25 @@ function requireCrdtManager () {
 
 	            if (retainCount < operations.length) {
 	                if (this.#debug) console.log(CONSOLE_PREFIX + `Running garbage collection for key ${key} with current operations:`, operations);
-	                const retainOps = operations.slice(-retainCount); // newest ops
-	                const removeOps = operations.slice(0, -retainCount); // oldest ops (start =  idx 0, end = retainCount counted from right side)
+	                const retainOps = operations.slice(-retainCount); // Newest ops
+	                const removeOps = operations.slice(0, -retainCount); // Oldest ops (start =  idx 0, end = retainCount counted from right side)
 	                const baselineVectorClock = removeOps[removeOps.length - 1]?.vectorClock || []; // Use the vector clock from the last operation that we remove/overwrite 
 
 	                // Calculate the value at the point where retained operations start
 	                let baselineValue = null;
 	                for (const op of removeOps) {
 	                    if (!op.data) continue;
-	                    if (op.data.operation.startsWith('array') && !Array.isArray(baselineValue)) baselineValue = []; // Initialize array if required
+	                    if (op.data.type.startsWith('array') && !Array.isArray(baselineValue)) baselineValue = []; // Initialize array if required
 	                    baselineValue = this.#handleOperation(
 	                        baselineValue,
-	                        op.data.operation,
+	                        op.data.type,
 	                        op.data.value,
 	                        op.data.updateValue
 	                    );
 	                }
 
 	                // Create a compact operation with baseline value and appropriate vector clock
-	                const compactOp = this.#createOperation({ operation: "set", value: baselineValue }, baselineVectorClock);
+	                const compactOp = this.#createOperation({ type: "set", value: baselineValue }, baselineVectorClock);
 
 	                // Debug log
 	                if (this.#debug) console.log(CONSOLE_PREFIX + "Operations after garbage collection for this key:", [compactOp, ...retainOps]);
@@ -2039,10 +2039,10 @@ function requireCrdtManager () {
 
 	            for (const op of ops) {
 	                if (!op.data) continue;
-	                if (op.data.operation.startsWith('array') && !Array.isArray(value)) value = []; // Initialize array if required
+	                if (op.data.type.startsWith('array') && !Array.isArray(value)) value = []; // Initialize array if required
 	                value = this.#handleOperation(
 	                    value,
-	                    op.data.operation,
+	                    op.data.type,
 	                    op.data.value,
 	                    op.data.updateValue
 	                );
@@ -2050,7 +2050,7 @@ function requireCrdtManager () {
 
 	            this.#propertyStore[key] = value; // Save locally
 	        } catch (error) {
-	            console.error(CONSOLE_PREFIX + `Failed to process property for "${key}":`, error);
+	            console.error(CONSOLE_PREFIX + `Failed to process property for key ${key}:`, error);
 	        }
 	    }
 
@@ -2093,33 +2093,31 @@ function requireCrdtManager () {
 	    /**
 	     * Handle an operation
 	     * @param {*} curValue 
-	     * @param {string} operation 
+	     * @param {string} type 
 	     * @param {*} value 
 	     * @param {*} [updateValue]
 	     * @returns {*} - Value after the operation
 	     */
-	    #handleOperation(curValue, operation, value, updateValue) {
+	    #handleOperation(curValue, type, value, updateValue) {
 	        try {
-	            // Clone to avoid reference issues
-	            curValue = JSON.parse(JSON.stringify(curValue || null));
+	            // Deep copy to avoid reference issues in case value is or contains object(s)
+	            curValue = structuredClone(curValue);
 
 	            // Set operation
-	            if (operation === "set") return value;
+	            if (type === "set") return value;
 
 	            // Array operations
-	            if (operation.startsWith('array')) {
+	            if (type.startsWith('array')) {
 	                if (!Array.isArray(curValue)) curValue = []; // Auto-convert to array if current value isn't one
 
 	                // Comparison function
 	                const isObject = typeof value === 'object' && value !== null;
 	                const compare = (item) => {
-	                    if (isObject && typeof item === 'object' && item !== null) {
-	                        return JSON.stringify(item) === JSON.stringify(value); // Deep comparison
-	                    }
+	                    if (isObject && typeof item === 'object' && item !== null) return JSON.stringify(item) === JSON.stringify(value); // Deep comparison
 	                    return item === value; // Value comparison
 	                };
 
-	                switch (operation) {
+	                switch (type) {
 	                    case 'array-add':
 	                        curValue.push(value);
 	                        break;
@@ -2139,7 +2137,7 @@ function requireCrdtManager () {
 	            return curValue;
 
 	        } catch (error) {
-	            console.error(CONSOLE_PREFIX + `Failed to process operation with curValue ${curValue}:`, error);
+	            console.error(CONSOLE_PREFIX + `Failed to handle operation with curValue ${curValue}:`, error);
 	            return curValue;
 	        }
 	    }
@@ -2159,7 +2157,7 @@ function requireCrdtManager () {
 	    // Get property store
 	    get getPropertyStore() {
 	        try {
-	            return JSON.parse(JSON.stringify(this.#propertyStore)); // Return full copy
+	            return structuredClone(this.#propertyStore); // Return deep clone
 	        } catch {
 	            console.error(CONSOLE_PREFIX + "Failed to parse property store");
 	            return {};
@@ -2170,7 +2168,7 @@ function requireCrdtManager () {
 	    get didPropertiesChange() {
 	        try {
 	            if (JSON.stringify(this.#propertyStore) !== JSON.stringify(this.#lastPropertyStore)) {
-	                this.#lastPropertyStore = JSON.parse(JSON.stringify(this.#propertyStore));
+	                this.#lastPropertyStore = structuredClone(this.#propertyStore);
 	                return true;
 	            }
 	        } catch { }
@@ -2281,20 +2279,18 @@ function requireServer () {
 	     * Handle WebSocket message
 	     * @private
 	     */
-	    #handleMessage(ws, message) {
+	    async #handleMessage(ws, message) {
 	        if (ws.isTerminating) return;
 	        try {
 	            const data = decode(message);
 
 	            // Apply rate limiting to all connections (including unregistered)
 	            if (!this.#checkRateLimit(ws.connectionId, data.type)) {
-	                ws.rateLimitViolations = (ws.rateLimitViolations || 0) + 1;
-	                if (ws.rateLimitViolations > 5 && !ws.isTerminating) {
+	                if (!ws.isTerminating) {
 	                    ws.isTerminating = true; // Prevent multiple terminate calls (it is async)
 	                    ws.terminate();
-	                    return console.error(`Connection ${ws.connectionId} terminated due to repeated rate limit violations.`);
+	                    return console.error(`Connection ${ws.connectionId} terminated due to rate limit violations.`);
 	                }
-	                return console.error(`Connection ${ws.connectionId} rate limit exceeded.`);
 	            }
 
 	            switch (data.type) {
@@ -2372,6 +2368,7 @@ function requireServer () {
 	                case 'create_room':
 	                    if (!ws.clientId) return;
 	                    const newRoomId = ws.clientId;
+
 	                    if (this.#clientRooms.get(ws.clientId) || this.#rooms[newRoomId]) {
 	                        ws.send(encode({
 	                            type: 'room_creation_failed',
@@ -2380,24 +2377,38 @@ function requireServer () {
 	                        return;
 	                    }
 
+	                    const roomCrdtManager = new CRDTManager(this.#debug); // Create the room's crdt manager
+
+	                    // Event callback with potential initial storage modifications
+	                    const reviewedStorage = await this.#triggerEvent("roomCreationRequested", { roomId: newRoomId, clientId: ws.clientId, initialStorage: structuredClone({ ...data.initialStorage }) });
+	                    if (typeof reviewedStorage === 'object') data.initialStorage = reviewedStorage;
+
+	                    // Check if client/creator is still connected
+	                    if (!this.#clients.has(ws.clientId)) {
+	                        if (this.#debug) console.log(`Room creation cancelled - client ${ws.clientId} disconnected during event callback.`);
+	                        return; // Abort room creation if client is no longer connected
+	                    }
+
+	                    // Load initial storage if provided
+	                    if (data.initialStorage) {
+	                        Object.entries(data.initialStorage)?.forEach(([key, value]) => {
+	                            roomCrdtManager.updateProperty(key, "set", value);
+	                        });
+	                    }
+
 	                    // Create room
 	                    this.#roomVersions.set(newRoomId, 0); // Start with version 0
 	                    this.#rooms[newRoomId] = {
 	                        participants: [ws.clientId],
 	                        host: ws.clientId,
 	                        maxSize: data.size || null,
-	                        crdtManager: new CRDTManager(this.#debug)
+	                        crdtManager: roomCrdtManager
 	                    };
+	                    this.#clientRooms.set(ws.clientId, newRoomId); // Add client to the room
 
-	                    // Load state if provided
-	                    if (data.state) {
-	                        this.#rooms[newRoomId].crdtManager.importState(data.state);
-	                        if (this.#debug) console.log("Room created with initial state:", data.state);
-	                    }
-
-	                    this.#clientRooms.set(ws.clientId, newRoomId); // Add client to their room
-	                    ws.send(encode({ type: 'room_created' }), { binary: true });
-	                    this.#triggerEvent("roomCreated", ws.clientId); // Client id = room id
+	                    ws.send(encode({ type: 'room_created', state: roomCrdtManager.getState }), { binary: true });
+	                    this.#triggerEvent("roomCreated", newRoomId);
+	                    if (this.#debug) console.log("Room created with initial storage:", data.initialStorage);
 	                    break;
 
 	                case 'join_room':
@@ -2442,7 +2453,7 @@ function requireServer () {
 	                            }), { binary: true });
 	                        }
 	                    });
-	                    this.#triggerEvent("roomJoined", ws.clientId, roomId);
+	                    this.#triggerEvent("clientJoinedRoom", ws.clientId, roomId);
 	                    break;
 
 	                case 'update_property':
@@ -2450,13 +2461,23 @@ function requireServer () {
 	                    const updateRoom = updateRoomId ? this.#rooms[updateRoomId] : null;
 
 	                    if (updateRoom && data.update) {
-	                        updateRoom.crdtManager.importPropertyUpdate(data.update);
+	                        // Check if update is allowed via event callback (provide clone to ensure update integrity)
+	                        const allowed = await this.#triggerEvent("storageUpdateRequested", { roomId: updateRoomId, clientId: ws.clientId, update: structuredClone(data.update) });
+	                        if (allowed === false) {
+	                            ws.send(encode({
+	                                type: 'property_update_rejected',
+	                                state: updateRoom.crdtManager.getState
+	                            }), { binary: true });
+	                            return;
+	                        }
+
+	                        updateRoom.crdtManager.importPropertyUpdate(data.update); // Import update into server state
 
 	                        // Increment version for this room
 	                        const currentVersion = this.#roomVersions.get(updateRoomId) + 1;
 	                        this.#roomVersions.set(updateRoomId, currentVersion);
-
 	                        if (this.#debug) console.log("Property update received and imported:", data.update);
+
 	                        updateRoom.participants?.forEach(p => {
 	                            const client = this.#clients.get(p);
 	                            if (client) {
@@ -2586,6 +2607,7 @@ function requireServer () {
 	            if (room.participants?.length === 0) {
 	                delete this.#rooms[roomId]; // Delete room if now empty
 	                this.#roomVersions.delete(roomId); // Delete room version
+	                this.#triggerEvent("roomDestroyed", roomId);
 	                if (this.#debug) console.log("Deleted room with id " + roomId + ".");
 	            } else {
 	                // Notify remaining participants
@@ -2609,7 +2631,7 @@ function requireServer () {
 	     * @param {Function} callback - Callback function
 	     */
 	    onEvent(event, callback) {
-	        const validEvents = ["clientRegistered", "clientDisconnected", "roomCreated", "roomJoined"];
+	        const validEvents = ["clientRegistered", "clientDisconnected", "clientJoinedRoom", "roomCreationRequested", "roomCreated", "storageUpdateRequested", "roomDestroyed"];
 	        if (!validEvents.includes(event)) return console.warn(`Invalid PlaySocket event type "${event}"`);
 	        if (!this.#callbacks.has(event)) this.#callbacks.set(event, []);
 	        this.#callbacks.get(event).push(callback);
@@ -2633,11 +2655,20 @@ function requireServer () {
 	     * Trigger an event to registered callbacks
 	     * @private
 	     */
-	    #triggerEvent(event, ...args) {
+	    async #triggerEvent(event, ...args) {
 	        const callbacks = this.#callbacks.get(event);
-	        callbacks?.forEach(callback => {
-	            try { callback(...args); } catch (error) { console.error(`PlaySocket ${event} callback error:`, error); }
-	        });
+	        if (!callbacks) return;
+
+	        for (const callback of callbacks) {
+	            try {
+	                const result = await callback(...args);
+	                if (result === false) return false; // False = block (in supported events)
+	                if (typeof result === 'object') return result; // If response object is provided -> pass on
+	            } catch (error) {
+	                console.error(`PlaySocket ${event} callback error:`, error);
+	            }
+	        }
+	        return true;
 	    }
 
 	    /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playsocketjs",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "WebSocket wrapper for creating simple multiplayer systems with ease.",
   "module": "dist/playsocket-client.js",
   "exports": {