playsocketjs 2.4.2 → 2.5.1

package/dist/{playsocket-server.js → playsocket-server.cjs}

@@ -1,36 +1,26 @@
 'use strict';
 
-var require$$0 = require('ws');
-var require$$1 = require('http');
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+var ws = require('ws');
+var http = require('node:http');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
 }
 
-function getAugmentedNamespace(n) {
-  if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
-  var f = n.default;
-	if (typeof f == "function") {
-		var a = function a () {
-			if (this instanceof a) {
-        return Reflect.construct(f, arguments, this.constructor);
-			}
-			return f.apply(this, arguments);
-		};
-		a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
+var http__namespace = /*#__PURE__*/_interopNamespaceDefault(http);
 
 function utf8Count(str) {
     const strLength = str.length;
@@ -1712,1061 +1702,966 @@ function decode(buffer, options) {
     const decoder = new Decoder(options);
     return decoder.decode(buffer);
 }
-/**
- * It decodes multiple MessagePack objects in a buffer.
- * This is corresponding to {@link decodeMultiStream}.
- *
- * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
- * @throws {@link DecodeError} if the buffer contains invalid data.
- */
-function decodeMulti(buffer, options) {
-    const decoder = new Decoder(options);
-    return decoder.decodeMulti(buffer);
-}
 
-// utility for whatwg streams
-function isAsyncIterable(object) {
-    return object[Symbol.asyncIterator] != null;
-}
-async function* asyncIterableFromStream(stream) {
-    const reader = stream.getReader();
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                return;
+// Custom conflict-free replicated data type system with vector clocks
+
+const CONSOLE_PREFIX = "PlaySocket CRDT manager: ";
+
+class CRDTManager {
+    // Storage
+    #replicaId;
+    #keyOperations = new Map();
+    #vectorClock = new Map();
+
+    // Local only
+    #propertyStore = {}; // Current local values per key, as object
+    #lastPropertyStore = {}; // Last property store to compare against
+
+    // Local Garbage Collection
+    #lastGCCheck = 0;
+    #opUuidTimestamp = new Map(); // Map every operation to a timestamp for garbage collection
+
+    // Debug
+    #debug = false;
+
+    /**
+     * Create a new instance
+     */
+    constructor(debug) {
+        if (debug) this.#debug = true;
+        this.#replicaId = crypto.randomUUID();
+        this.#vectorClock.set(this.#replicaId, 0);
+    }
+
+    /**
+     * Import the entire state of the CRDT manager (this overwrites the old state)
+     * @param {Object} state
+     */
+    importState(state) {
+        try {
+            const { keyOperations, vectorClock } = state;
+            if (this.#debug) console.log(CONSOLE_PREFIX + "Importing state:", state);
+
+            // Resets
+            this.#opUuidTimestamp.clear();
+            this.#propertyStore = {};
+            this.#lastPropertyStore = {};
+
+            this.#keyOperations = new Map(keyOperations); // Rebuild the operations map
+            this.#vectorClock = new Map(vectorClock); // Rebuild the vector clock map
+            if (!this.#vectorClock.has(this.#replicaId)) this.#vectorClock.set(this.#replicaId, 0); // Add own vector clock if it wasn't present in the imported state
+
+            // Map all operation uuids to current timestamp
+            this.#keyOperations.forEach((value, key) => {
+                value?.forEach((operation) => {
+                    this.#opUuidTimestamp.set(operation?.uuid, Date.now());
+                });
+            });
+
+            // Process each key to update local values
+            for (const key of this.#keyOperations.keys()) this.#processLocalProperty(key);
+
+        } catch (error) {
+            console.error(CONSOLE_PREFIX + "Failed to import state:", error);
+        }
+    }
+
+    /**
+     * Import property update
+     * @param {Object} data - Data to import
+     */
+    importPropertyUpdate(data) {
+        try {
+            const { key, operation: rawOperation, vectorClock } = data;
+            const operation = this.#sanitizeValue(rawOperation);
+            if (this.#debug) console.log(CONSOLE_PREFIX + "Importing update:", data); // Debug
+
+            // Check key limit to afeguard against too many keys
+            if (this.#keyOperations.size >= 100 && !this.#keyOperations.has(key)) throw new Error('Key limit exceeded!');
+
+            // Get COPY of current ops (or empty array if none yet)
+            const currentOps = [...(this.#keyOperations.get(key) || [])];
+            // Merge vector clocks (always take max value)
+            for (const [id, counter] of vectorClock) {
+                if (!this.#vectorClock.has(id) || this.#vectorClock.get(id) < counter) {
+                    this.#vectorClock.set(id, counter);
+                }
+            }
+
+            // Safeguard against massive vector clocks
+            if (this.#vectorClock.size > 1000) this.#vectorClock = new Map([...this.#vectorClock].slice(-100));
+
+            // Add new operation if it's not already added
+            const existingUuids = new Set(currentOps.map(op => op.uuid));
+            if (operation.uuid && !existingUuids.has(operation.uuid)) {
+                currentOps.push({ ...operation }); // Add operation
+                this.#opUuidTimestamp.set(operation.uuid, Date.now()); // Add timestamp for gc
             }
-            yield value;
+
+            // Sort, update operations & local value
+            this.#keyOperations.set(key, this.#sortByVectorClock(currentOps));
+            this.#processLocalProperty(key);
+            this.#checkGarbageCollection();
+
+        } catch (error) {
+            console.error(CONSOLE_PREFIX + "Failed to import property update:", error);
         }
     }
-    finally {
-        reader.releaseLock();
+
+    /**
+     * Update a property
+     * @param {string} key 
+     * @param {string} type 
+     * @param {*} value 
+     * @param {*} updateValue 
+     * @returns {Object} - Returns the property update
+     */
+    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}, type ${type}, value ${value} and updateValue ${updateValue}.`);
+
+            // Increment vector clock
+            const counter = this.#vectorClock.get(this.#replicaId) || 0;
+            this.#vectorClock.set(this.#replicaId, counter + 1);
+
+            // Assign shallow COPY of currennt ops or fall back to empty array
+            const currentOps = [...(this.#keyOperations.get(key) || [])];
+
+            // Add operation
+            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
+            this.#checkGarbageCollection();
+
+            // Return the property update with the new operation (this can be imported using importPropertyUpdate)
+            return {
+                key,
+                operation: { ...newOp },
+                vectorClock: Array.from(this.#vectorClock.entries())
+            };
+
+        } catch (error) {
+            console.error(CONSOLE_PREFIX + `Failed to add operation for key "${key}":`, error);
+        }
     }
-}
-function ensureAsyncIterable(streamLike) {
-    if (isAsyncIterable(streamLike)) {
-        return streamLike;
+
+    #checkGarbageCollection() {
+        const MIN_GC_DELAY = 1000; // Minimum 1s delay between garbage collection runs
+        const MIN_AGE_FOR_GC = 5000; // Garbage collect ops that are older than 5s
+
+        try {
+            if (Date.now() - this.#lastGCCheck < MIN_GC_DELAY) return;
+            this.#lastGCCheck = Date.now();
+
+            for (const [key, operations] of this.#keyOperations.entries()) {
+                if (operations?.length < 5) continue; // Min op amount per key for garbage collection to run (otherwise not worth it)
+
+                let retainCount = operations.length;
+                operations.forEach((op, index) => {
+                    // Count how many ops, from last to latest, are older than the min-age in a row
+                    if (op.uuid && this.#opUuidTimestamp.has(op.uuid) && (Date.now() - this.#opUuidTimestamp.get(op.uuid)) > MIN_AGE_FOR_GC) {
+                        const removeCount = index + 1;
+                        retainCount = operations.length - removeCount;
+                        this.#opUuidTimestamp.delete(op.uuid); // Remove from timestamps if set to be deleted
+                    }
+                });
+
+                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 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;
+                        baselineValue = this.#handleOperation(
+                            baselineValue,
+                            op.data.type,
+                            op.data.value,
+                            op.data.updateValue
+                        );
+                    }
+
+                    // Create a compact operation with baseline value and appropriate vector clock
+                    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]);
+
+                    // Combine compact op with retained operations
+                    this.#keyOperations.set(key, [compactOp, ...retainOps]);
+                }
+            }
+        } catch (error) {
+            console.error(CONSOLE_PREFIX + "Error running garbage collection:", error);
+        }
     }
-    else {
-        return asyncIterableFromStream(streamLike);
+
+    /**
+     * Create an operation object
+     * @param {Object} data 
+     * @param {Array} vectorClock 
+     * @returns {Object} - Operation object
+     */
+    #createOperation(data, vectorClock) {
+        const newOperation = {
+            data,
+            vectorClock,
+            source: this.#replicaId,
+            uuid: crypto.randomUUID()
+        };
+        this.#opUuidTimestamp.set(newOperation.uuid, Date.now());
+        return newOperation;
     }
-}
 
-/**
- * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
- * @throws {@link DecodeError} if the buffer contains invalid data.
- */
-async function decodeAsync(streamLike, options) {
-    const stream = ensureAsyncIterable(streamLike);
-    const decoder = new Decoder(options);
-    return decoder.decodeAsync(stream);
-}
-/**
- * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
- * @throws {@link DecodeError} if the buffer contains invalid data.
- */
-function decodeArrayStream(streamLike, options) {
-    const stream = ensureAsyncIterable(streamLike);
-    const decoder = new Decoder(options);
-    return decoder.decodeArrayStream(stream);
+    /**
+     * Process a property's value by applying all operations and set it in the property store
+     * @param {string} key 
+     */
+    #processLocalProperty(key) {
+        try {
+            const ops = this.#keyOperations.get(key);
+            if (!ops?.length) return;
+
+            // Apply all operations in order
+            let value = null;
+
+            for (const op of ops) {
+                if (!op.data) continue;
+                value = this.#handleOperation(
+                    value,
+                    op.data.type,
+                    op.data.value,
+                    op.data.updateValue
+                );
+            }
+
+            this.#propertyStore[key] = value; // Save locally
+        } catch (error) {
+            console.error(CONSOLE_PREFIX + `Failed to process property for key ${key}:`, error);
+        }
+    }
+
+    /**
+     * Sort by vector clock (causal order)
+     * @param {Array} operations
+     * @returns {Array} - Sorted operations
+     */
+    #sortByVectorClock(operations) {
+        return [...operations].sort((a, b) => {
+            const clockA = new Map(a.vectorClock || []);
+            const clockB = new Map(b.vectorClock || []);
+
+            // First sort by causal relationship
+            let aGreater = false, bGreater = false;
+
+            const allIds = new Set([...clockA.keys(), ...clockB.keys()]);
+            for (const id of allIds) {
+                const countA = clockA.get(id) || 0;
+                const countB = clockB.get(id) || 0;
+
+                if (countA > countB) aGreater = true;
+                if (countA < countB) bGreater = true;
+            }
+
+            // Determine causal relationship (if one is greater, and the other is smaller, it's clear)
+            if (aGreater && !bGreater) return 1;     // a happens after b
+            if (!aGreater && bGreater) return -1;    // a happens before b
+
+            // Concurrent (unclear): Compare highest counter in each (sort by which one is ahead)
+            const maxA = Math.max(...Array.from(clockA.values()), 0);
+            const maxB = Math.max(...Array.from(clockB.values()), 0);
+            if (maxA !== maxB) return maxA - maxB;
+
+            // Final tiebreak: Sort by ID of Replica that actually generated the operation
+            return a.source.localeCompare(b.source);
+        });
+    }
+
+    /**
+     * Handle an operation
+     * @param {*} curValue 
+     * @param {string} type 
+     * @param {*} value 
+     * @param {*} [updateValue]
+     * @returns {*} - Value after the operation
+     */
+    #handleOperation(curValue, type, value, updateValue) {
+        try {
+            // Deep copy to avoid reference issues in case value is or contains object(s)
+            curValue = structuredClone(curValue);
+
+            // Set operation
+            if (type === "set") return value;
+
+            // Array operations
+            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
+                    return item === value; // Value comparison
+                };
+
+                switch (type) {
+                    case 'array-add':
+                        curValue.push(value);
+                        break;
+                    case 'array-add-unique':
+                        if (!curValue.some(compare)) curValue.push(value);
+                        break;
+                    case 'array-remove-matching':
+                        curValue = curValue.filter(item => !compare(item));
+                        break;
+                    case 'array-update-matching':
+                        const index = curValue.findIndex(compare);
+                        if (index !== -1) curValue[index] = updateValue;
+                        break;
+                }
+            }
+
+            return curValue;
+
+        } catch (error) {
+            console.error(CONSOLE_PREFIX + `Failed to handle operation with curValue ${curValue}:`, error);
+            return curValue;
+        }
+    }
+
+    /**
+     * Remove HTML to prevent XSS and enforce size limits
+     * @param {Object} obj
+     * @returns {Object} - Sanitized object
+     */
+    #sanitizeValue(obj) {
+        // Check total serialized size
+        const jsonString = JSON.stringify(obj);
+        if (jsonString?.length > 50000) throw new Error('Value too large!'); // 50KB limit
+
+        if (typeof obj === 'string') return (obj.includes('<') || obj.includes('>')) ? obj.replace(/[<>]/g, '') : obj;
+        if (Array.isArray(obj)) return obj.map(item => this.#sanitizeValue(item));
+        if (obj && typeof obj === 'object') return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, this.#sanitizeValue(v)]));
+        return obj;
+    }
+
+    // Get property store
+    get getPropertyStore() {
+        try {
+            return structuredClone(this.#propertyStore); // Return deep clone
+        } catch {
+            console.error(CONSOLE_PREFIX + "Failed to parse property store");
+            return {};
+        }
+    }
+
+    // Check for changes in the local property store
+    get didPropertiesChange() {
+        try {
+            if (JSON.stringify(this.#propertyStore) !== JSON.stringify(this.#lastPropertyStore)) {
+                this.#lastPropertyStore = structuredClone(this.#propertyStore);
+                return true;
+            }
+        } catch { }
+        return false;
+    }
+
+    // Get state (can be imported using importState, converts the maps to arrays for serialization)
+    get getState() {
+        return {
+            keyOperations: [...this.#keyOperations.entries()],
+            vectorClock: [...this.#vectorClock.entries()]
+        };
+    }
 }
+
 /**
- * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
- * @throws {@link DecodeError} if the buffer contains invalid data.
+ * PlaySocketServer - WebSocket server for PlaySocket multiplayer library
  */
-function decodeMultiStream(streamLike, options) {
-    const stream = ensureAsyncIterable(streamLike);
-    const decoder = new Decoder(options);
-    return decoder.decodeStream(stream);
-}
+class PlaySocketServer {
+    #server;
+    #ownsServer = false;
+    #rateLimitMaxPoints;
+    #wss;
+    #clients = new Map(); // ClientId -> WebSocket instance
+    #rooms = {};
+    #clientRooms = new Map(); // ClientId -> RoomId
+    #rateLimits = new Map(); // Rate limiting storage
+    #callbacks = new Map(); // Event -> [callback functions]
+    #heartbeatInterval;
+    #pendingDisconnects = new Map(); // ClientId -> {timeout, roomId}
+    #clientTokens = new Map(); // ClientId -> Token
+    #roomVersions = new Map(); // RoomId -> Version
+
+    // Debug
+    #debug = false;
 
-// Main Functions:
-
-var dist_esm = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	DecodeError: DecodeError,
-	Decoder: Decoder,
-	EXT_TIMESTAMP: EXT_TIMESTAMP,
-	Encoder: Encoder,
-	ExtData: ExtData,
-	ExtensionCodec: ExtensionCodec,
-	decode: decode,
-	decodeArrayStream: decodeArrayStream,
-	decodeAsync: decodeAsync,
-	decodeMulti: decodeMulti,
-	decodeMultiStream: decodeMultiStream,
-	decodeTimestampExtension: decodeTimestampExtension,
-	decodeTimestampToTimeSpec: decodeTimestampToTimeSpec,
-	encode: encode,
-	encodeDateToTimeSpec: encodeDateToTimeSpec,
-	encodeTimeSpecToTimestamp: encodeTimeSpecToTimestamp,
-	encodeTimestampExtension: encodeTimestampExtension
-});
-
-var require$$2 = /*@__PURE__*/getAugmentedNamespace(dist_esm);
-
-var crdtManager;
-var hasRequiredCrdtManager;
-
-function requireCrdtManager () {
-	if (hasRequiredCrdtManager) return crdtManager;
-	hasRequiredCrdtManager = 1;
-	// Custom conflict-free replicated data type system with vector clocks
-
-	const CONSOLE_PREFIX = "PlaySocket CRDT manager: ";
-
-	class CRDTManager {
-	    // Storage
-	    #replicaId;
-	    #keyOperations = new Map();
-	    #vectorClock = new Map();
-
-	    // Local only
-	    #propertyStore = {}; // Current local values per key, as object
-	    #lastPropertyStore = {}; // Last property store to compare against
-
-	    // Local Garbage Collection
-	    #lastGCCheck = 0;
-	    #opUuidTimestamp = new Map(); // Map every operation to a timestamp for garbage collection
-
-	    // Debug
-	    #debug = false;
-
-	    /**
-	     * Create a new instance
-	     */
-	    constructor(debug) {
-	        if (debug) this.#debug = true;
-	        this.#replicaId = crypto.randomUUID();
-	        this.#vectorClock.set(this.#replicaId, 0);
-	    }
-
-	    /**
-	     * Import the entire state of the CRDT manager (this overwrites the old state)
-	     * @param {Object} state
-	     */
-	    importState(state) {
-	        try {
-	            const { keyOperations, vectorClock } = state;
-	            if (this.#debug) console.log(CONSOLE_PREFIX + "Importing state:", state);
-
-	            // Resets
-	            this.#opUuidTimestamp.clear();
-	            this.#propertyStore = {};
-	            this.#lastPropertyStore = {};
-
-	            this.#keyOperations = new Map(keyOperations); // Rebuild the operations map
-	            this.#vectorClock = new Map(vectorClock); // Rebuild the vector clock map
-	            if (!this.#vectorClock.has(this.#replicaId)) this.#vectorClock.set(this.#replicaId, 0); // Add own vector clock if it wasn't present in the imported state
-
-	            // Map all operation uuids to current timestamp
-	            this.#keyOperations.forEach((value, key) => {
-	                value?.forEach((operation) => {
-	                    this.#opUuidTimestamp.set(operation?.uuid, Date.now());
-	                });
-	            });
-
-	            // Process each key to update local values
-	            for (const key of this.#keyOperations.keys()) this.#processLocalProperty(key);
-
-	        } catch (error) {
-	            console.error(CONSOLE_PREFIX + "Failed to import state:", error);
-	        }
-	    }
-
-	    /**
-	     * Import property update
-	     * @param {Object} data - Data to import
-	     */
-	    importPropertyUpdate(data) {
-	        try {
-	            const { key, operation: rawOperation, vectorClock } = data;
-	            const operation = this.#sanitizeValue(rawOperation);
-	            if (this.#debug) console.log(CONSOLE_PREFIX + "Importing update:", data); // Debug
-
-	            // Check key limit to afeguard against too many keys
-	            if (this.#keyOperations.size >= 100 && !this.#keyOperations.has(key)) throw new Error('Key limit exceeded!');
-
-	            // Get COPY of current ops (or empty array if none yet)
-	            const currentOps = [...(this.#keyOperations.get(key) || [])];
-	            // Merge vector clocks (always take max value)
-	            for (const [id, counter] of vectorClock) {
-	                if (!this.#vectorClock.has(id) || this.#vectorClock.get(id) < counter) {
-	                    this.#vectorClock.set(id, counter);
-	                }
-	            }
-
-	            // Safeguard against massive vector clocks
-	            if (this.#vectorClock.size > 1000) this.#vectorClock = new Map([...this.#vectorClock].slice(-100));
-
-	            // Add new operation if it's not already added
-	            const existingUuids = new Set(currentOps.map(op => op.uuid));
-	            if (operation.uuid && !existingUuids.has(operation.uuid)) {
-	                currentOps.push({ ...operation }); // Add operation
-	                this.#opUuidTimestamp.set(operation.uuid, Date.now()); // Add timestamp for gc
-	            }
-
-	            // Sort, update operations & local value
-	            this.#keyOperations.set(key, this.#sortByVectorClock(currentOps));
-	            this.#processLocalProperty(key);
-	            this.#checkGarbageCollection();
-
-	        } catch (error) {
-	            console.error(CONSOLE_PREFIX + "Failed to import property update:", error);
-	        }
-	    }
-
-	    /**
-	     * Update a property
-	     * @param {string} key 
-	     * @param {string} type 
-	     * @param {*} value 
-	     * @param {*} updateValue 
-	     * @returns {Object} - Returns the property update
-	     */
-	    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}, type ${type}, value ${value} and updateValue ${updateValue}.`);
-
-	            // Increment vector clock
-	            const counter = this.#vectorClock.get(this.#replicaId) || 0;
-	            this.#vectorClock.set(this.#replicaId, counter + 1);
-
-	            // Assign shallow COPY of currennt ops or fall back to empty array
-	            const currentOps = [...(this.#keyOperations.get(key) || [])];
-
-	            // Add operation
-	            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
-	            this.#checkGarbageCollection();
-
-	            // Return the property update with the new operation (this can be imported using importPropertyUpdate)
-	            return {
-	                key,
-	                operation: { ...newOp },
-	                vectorClock: Array.from(this.#vectorClock.entries())
-	            };
-
-	        } catch (error) {
-	            console.error(CONSOLE_PREFIX + `Failed to add operation for key "${key}":`, error);
-	        }
-	    }
-
-	    #checkGarbageCollection() {
-	        const MIN_GC_DELAY = 1000; // Minimum 1s delay between garbage collection runs
-	        const MIN_AGE_FOR_GC = 5000; // Garbage collect ops that are older than 5s
-
-	        try {
-	            if (Date.now() - this.#lastGCCheck < MIN_GC_DELAY) return;
-	            this.#lastGCCheck = Date.now();
-
-	            for (const [key, operations] of this.#keyOperations.entries()) {
-	                if (operations?.length < 5) continue; // Min op amount per key for garbage collection to run (otherwise not worth it)
-
-	                let retainCount = operations.length;
-	                operations.forEach((op, index) => {
-	                    // Count how many ops, from last to latest, are older than the min-age in a row
-	                    if (op.uuid && this.#opUuidTimestamp.has(op.uuid) && (Date.now() - this.#opUuidTimestamp.get(op.uuid)) > MIN_AGE_FOR_GC) {
-	                        const removeCount = index + 1;
-	                        retainCount = operations.length - removeCount;
-	                        this.#opUuidTimestamp.delete(op.uuid); // Remove from timestamps if set to be deleted
-	                    }
-	                });
-
-	                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 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;
-	                        baselineValue = this.#handleOperation(
-	                            baselineValue,
-	                            op.data.type,
-	                            op.data.value,
-	                            op.data.updateValue
-	                        );
-	                    }
-
-	                    // Create a compact operation with baseline value and appropriate vector clock
-	                    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]);
-
-	                    // Combine compact op with retained operations
-	                    this.#keyOperations.set(key, [compactOp, ...retainOps]);
-	                }
-	            }
-	        } catch (error) {
-	            console.error(CONSOLE_PREFIX + "Error running garbage collection:", error);
-	        }
-	    }
-
-	    /**
-	     * Create an operation object
-	     * @param {Object} data 
-	     * @param {Array} vectorClock 
-	     * @returns {Object} - Operation object
-	     */
-	    #createOperation(data, vectorClock) {
-	        const newOperation = {
-	            data,
-	            vectorClock,
-	            source: this.#replicaId,
-	            uuid: crypto.randomUUID()
-	        };
-	        this.#opUuidTimestamp.set(newOperation.uuid, Date.now());
-	        return newOperation;
-	    }
-
-	    /**
-	     * Process a property's value by applying all operations and set it in the property store
-	     * @param {string} key 
-	     */
-	    #processLocalProperty(key) {
-	        try {
-	            const ops = this.#keyOperations.get(key);
-	            if (!ops?.length) return;
-
-	            // Apply all operations in order
-	            let value = null;
-
-	            for (const op of ops) {
-	                if (!op.data) continue;
-	                value = this.#handleOperation(
-	                    value,
-	                    op.data.type,
-	                    op.data.value,
-	                    op.data.updateValue
-	                );
-	            }
-
-	            this.#propertyStore[key] = value; // Save locally
-	        } catch (error) {
-	            console.error(CONSOLE_PREFIX + `Failed to process property for key ${key}:`, error);
-	        }
-	    }
-
-	    /**
-	     * Sort by vector clock (causal order)
-	     * @param {Array} operations
-	     * @returns {Array} - Sorted operations
-	     */
-	    #sortByVectorClock(operations) {
-	        return [...operations].sort((a, b) => {
-	            const clockA = new Map(a.vectorClock || []);
-	            const clockB = new Map(b.vectorClock || []);
-
-	            // First sort by causal relationship
-	            let aGreater = false, bGreater = false;
-
-	            const allIds = new Set([...clockA.keys(), ...clockB.keys()]);
-	            for (const id of allIds) {
-	                const countA = clockA.get(id) || 0;
-	                const countB = clockB.get(id) || 0;
-
-	                if (countA > countB) aGreater = true;
-	                if (countA < countB) bGreater = true;
-	            }
-
-	            // Determine causal relationship (if one is greater, and the other is smaller, it's clear)
-	            if (aGreater && !bGreater) return 1;     // a happens after b
-	            if (!aGreater && bGreater) return -1;    // a happens before b
-
-	            // Concurrent (unclear): Compare highest counter in each (sort by which one is ahead)
-	            const maxA = Math.max(...Array.from(clockA.values()), 0);
-	            const maxB = Math.max(...Array.from(clockB.values()), 0);
-	            if (maxA !== maxB) return maxA - maxB;
-
-	            // Final tiebreak: Sort by ID of Replica that actually generated the operation
-	            return a.source.localeCompare(b.source);
-	        });
-	    }
-
-	    /**
-	     * Handle an operation
-	     * @param {*} curValue 
-	     * @param {string} type 
-	     * @param {*} value 
-	     * @param {*} [updateValue]
-	     * @returns {*} - Value after the operation
-	     */
-	    #handleOperation(curValue, type, value, updateValue) {
-	        try {
-	            // Deep copy to avoid reference issues in case value is or contains object(s)
-	            curValue = structuredClone(curValue);
-
-	            // Set operation
-	            if (type === "set") return value;
-
-	            // Array operations
-	            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
-	                    return item === value; // Value comparison
-	                };
-
-	                switch (type) {
-	                    case 'array-add':
-	                        curValue.push(value);
-	                        break;
-	                    case 'array-add-unique':
-	                        if (!curValue.some(compare)) curValue.push(value);
-	                        break;
-	                    case 'array-remove-matching':
-	                        curValue = curValue.filter(item => !compare(item));
-	                        break;
-	                    case 'array-update-matching':
-	                        const index = curValue.findIndex(compare);
-	                        if (index !== -1) curValue[index] = updateValue;
-	                        break;
-	                }
-	            }
-
-	            return curValue;
-
-	        } catch (error) {
-	            console.error(CONSOLE_PREFIX + `Failed to handle operation with curValue ${curValue}:`, error);
-	            return curValue;
-	        }
-	    }
-
-	    /**
-	     * Remove HTML to prevent XSS and enforce size limits
-	     * @param {Object} obj
-	     * @returns {Object} - Sanitized object
-	     */
-	    #sanitizeValue(obj) {
-	        // Check total serialized size
-	        const jsonString = JSON.stringify(obj);
-	        if (jsonString?.length > 50000) throw new Error('Value too large!'); // 50KB limit
-
-	        if (typeof obj === 'string') return (obj.includes('<') || obj.includes('>')) ? obj.replace(/[<>]/g, '') : obj;
-	        if (Array.isArray(obj)) return obj.map(item => this.#sanitizeValue(item));
-	        if (obj && typeof obj === 'object') return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, this.#sanitizeValue(v)]));
-	        return obj;
-	    }
-
-	    // Get property store
-	    get getPropertyStore() {
-	        try {
-	            return structuredClone(this.#propertyStore); // Return deep clone
-	        } catch {
-	            console.error(CONSOLE_PREFIX + "Failed to parse property store");
-	            return {};
-	        }
-	    }
-
-	    // Check for changes in the local property store
-	    get didPropertiesChange() {
-	        try {
-	            if (JSON.stringify(this.#propertyStore) !== JSON.stringify(this.#lastPropertyStore)) {
-	                this.#lastPropertyStore = structuredClone(this.#propertyStore);
-	                return true;
-	            }
-	        } catch { }
-	        return false;
-	    }
-
-	    // Get state (can be imported using importState, converts the maps to arrays for serialization)
-	    get getState() {
-	        return {
-	            keyOperations: [...this.#keyOperations.entries()],
-	            vectorClock: [...this.#vectorClock.entries()]
-	        };
-	    }
-	}
-
-	crdtManager = { CRDTManager };
-	return crdtManager;
-}
+    /**
+     * Create a new PlaySocketServer instance
+     * @param {Object} options - Server configuration options
+     * @param {HttpServer} [options.server] - Existing http server
+     * @param {number} [options.port=3000] - Port to listen on (if no server provided)
+     * @param {string} [options.path='/socket'] - WebSocket endpoint path
+     */
+    constructor(options = {}) {
+        const { server, port = 3000, path = '/', debug = false, rateLimit = 20 } = options;
 
-var server$1;
-var hasRequiredServer;
-
-function requireServer () {
-	if (hasRequiredServer) return server$1;
-	hasRequiredServer = 1;
-	const WebSocket = require$$0;
-	const http = require$$1;
-	const { encode, decode } = require$$2;
-	const { CRDTManager } = requireCrdtManager();
-
-	/**
-	 * PlaySocketServer - WebSocket server for PlaySocket multiplayer library
-	 */
-	class PlaySocketServer {
-	    #server;
-	    #ownsServer = false;
-	    #wss;
-	    #clients = new Map(); // ClientId -> WebSocket instance
-	    #rooms = {};
-	    #clientRooms = new Map(); // ClientId -> RoomId
-	    #rateLimits = new Map(); // Rate limiting storage
-	    #callbacks = new Map(); // Event -> [callback functions]
-	    #heartbeatInterval;
-	    #pendingDisconnects = new Map(); // ClientId -> {timeout, roomId}
-	    #clientTokens = new Map(); // ClientId -> Token
-	    #roomVersions = new Map(); // RoomId -> Version
-
-	    // Debug
-	    #debug = false;
-
-	    /**
-	     * Create a new PlaySocketServer instance
-	     * @param {Object} options - Server configuration options
-	     * @param {HttpServer} [options.server] - Existing http server
-	     * @param {number} [options.port=3000] - Port to listen on (if no server provided)
-	     * @param {string} [options.path='/socket'] - WebSocket endpoint path
-	     */
-	    constructor(options = {}) {
-	        const { server, port = 3000, path = '/', debug = false } = options;
-
-	        if (debug) this.#debug = true; // Enable extra logging
-
-	        // Handle server creation / usage
-	        if (server) {
-	            this.#server = server; // Use provided HTTP server
-	        } else {
-	            this.#ownsServer = true;
-	            this.#server = http.createServer(); // Create HTTP server and start it
-	            this.#server.listen(port, () => {
-	                console.log(`PlaySocket server running on port ${port}.`);
-	            });
-	        }
-
-	        // Create WebSocket server
-	        this.#wss = new WebSocket.Server({
-	            server: this.#server,
-	            path
-	        });
-
-	        // Set up ws event handlers
-	        this.#wss.on('connection', ws => {
-	            ws.connectionId = crypto.randomUUID();
-	            ws.isAlive = true;
-	            ws.on('pong', () => { ws.isAlive = true; });
-	            ws.on('message', msg => this.#handleMessage(ws, msg));
-	            ws.on('close', () => this.#handleDisconnection(ws));
-	            ws.on('error', (error) => {
-	                console.error(`PlaySocket WebSocket connection error for client ${ws.clientId || 'unknown'}:`, error); // Catch conn errors
-	            });
-	        });
-
-	        // Log & catch server-level errors
-	        this.#wss.on('error', (error) => {
-	            console.error('PlaySocket WebSocket server error:', error);
-	        });
-
-	        // Start heartbeat
-	        this.#heartbeatInterval = setInterval(() => {
-	            this.#wss.clients.forEach(ws => {
-	                if (!ws.isAlive) return ws.terminate();
-	                ws.isAlive = false;
-	                ws.ping();
-	            });
-	        }, 15000);
-	    }
-
-	    /**
-	     * Handle WebSocket message
-	     * @private
-	     */
-	    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)) {
-	                if (!ws.isTerminating) {
-	                    ws.isTerminating = true; // Prevent multiple terminate calls (it is async)
-	                    ws.terminate();
-	                    return console.error(`Connection ${ws.connectionId} terminated due to rate limit violations.`);
-	                }
-	            }
-
-	            switch (data.type) {
-	                case 'register':
-	                    // Register client ID if provided & check for a duplicate
-	                    if (data.id && this.#clients.get(data.id)) {
-	                        ws.send(encode({ type: 'registration_failed', reason: 'ID is taken.' }), { binary: true });
-	                        return;
-	                    }
-
-	                    // Generate client ID if none provided
-	                    if (!data.id) {
-	                        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789';
-	                        const maxAttempts = 50;
-	                        for (let i = 0; i < maxAttempts; i++) {
-	                            const id = Array.from({ length: 6 }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
-	                            if (!this.#clients.get(id)) {
-	                                data.id = id;
-	                                break;
-	                            }
-	                        }
-	                        if (!data.id) {
-	                            ws.send(encode({ type: 'registration_failed', reason: 'No available ID found.' }), { binary: true });
-	                            throw new Error('Failed to generate unique ID!');
-	                        }
-	                    }
-
-	                    // Event callback
-	                    const registrationAllowed = await this.#triggerEvent("clientRegistrationRequested", data.id, data.customData);
-	                    if (registrationAllowed === false || typeof registrationAllowed === 'string') {
-	                        ws.send(encode({
-	                            type: 'registration_failed',
-	                            reason: typeof registrationAllowed === 'string' ? registrationAllowed : 'Denied.'
-	                        }), { binary: true });
-	                        return;
-	                    }
-
-	                    ws.clientId = data.id; // Adds the provided id to the ws object as clientId
-	                    this.#clients.set(data.id, ws);
-	                    const sessionToken = this.#generateSessionToken();
-	                    this.#clientTokens.set(data.id, sessionToken); // Token is used when reconnecting to prevent impersonation attacks
-	                    ws.send(encode({ type: 'registered', id: data.id, sessionToken }), { binary: true });
-	                    this.#triggerEvent("clientRegistered", data.id, data.customData);
-	                    break;
-
-	                case 'reconnect':
-	                    // If user is pending disconnect, respond (otherwise it's too late)
-	                    const pd = this.#pendingDisconnects.get(data.id);
-	                    if (pd && data.sessionToken) {
-	                        if (data.sessionToken !== this.#clientTokens.get(data.id)) {
-	                            ws.send(encode({
-	                                type: 'reconnection_failed',
-	                                reason: "Session token does not match."
-	                            }), { binary: true });
-	                            return;
-	                        }
-	                        clearTimeout(pd.timeout);
-	                        this.#pendingDisconnects.delete(data.id);
-
-	                        // Re-assign old client ID to the new ws connection
-	                        ws.clientId = data.id;
-	                        this.#clients.set(data.id, ws);
-
-	                        // If they were in a room, provide updated room data
-	                        let roomData;
-	                        const formerRoomId = this.#clientRooms.get(data.id);
-	                        const formerRoom = this.#rooms[formerRoomId];
-	                        if (formerRoom) {
-	                            if (this.#debug) console.log(`State sent for reconnection for room ${formerRoomId}:`, formerRoom.crdtManager.getState);
-	                            roomData = {
-	                                state: formerRoom.crdtManager.getState,
-	                                participantCount: formerRoom.participants.length,
-	                                host: formerRoom.host,
-	                                version: this.#roomVersions.get(formerRoomId)
-	                            };
-	                        }
-
-	                        ws.send(encode({ type: 'reconnected', roomData }), { binary: true });
-	                    } else {
-	                        ws.send(encode({ type: 'reconnection_failed', reason: "Client unknown to server." }), { binary: true });
-	                    }
-	                    break;
-
-	                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',
-	                            reason: this.#clientRooms.get(ws.clientId) ? 'Already in a room.' : 'Room ID is taken.'
-	                        }), { binary: true });
-	                        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;
-	                    if (reviewedStorage === false) {
-	                        ws.send(encode({
-	                            type: 'room_creation_failed',
-	                            reason: 'Room creation denied.'
-	                        }), { binary: true });
-	                        return;
-	                    }
-
-	                    // 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: Math.min(Number(data.size), 100) || 100, // Max. limit is 100 clients / room
-	                        crdtManager: roomCrdtManager
-	                    };
-	                    this.#clientRooms.set(ws.clientId, newRoomId); // Add client to the room
-
-	                    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':
-	                    if (!data.roomId || !ws.clientId) return;
-	                    const roomId = data.roomId;
-	                    const room = this.#rooms[roomId];
-
-	                    const rejectJoin = (reason) => {
-	                        ws.send(encode({ type: 'join_rejected', reason }), { binary: true });
-	                    };
-
-	                    // Event callback
-	                    const joinAllowed = await this.#triggerEvent("clientJoinRequested", ws.clientId, roomId);
-	                    if (joinAllowed === false || typeof joinAllowed === 'string') return rejectJoin(typeof joinAllowed === 'string' ? joinAllowed : 'Denied.');
-
-	                    if (!room) return rejectJoin("Room not found.");
-	                    if (this.#clientRooms.get(ws.clientId)) return rejectJoin("Already in a room.");
-	                    if (room.participants.length >= room.maxSize) return rejectJoin("Room full.");
-
-	                    room.participants.push(ws.clientId);
-	                    this.#clientRooms.set(ws.clientId, roomId);
-
-	                    // Notify joiner with initial storage
-	                    if (this.#debug) console.log("Room state sent for join:", room.crdtManager.getState);
-	                    ws.send(encode({
-	                        type: 'join_accepted',
-	                        state: room.crdtManager.getState,
-	                        participantCount: room.participants.length,
-	                        host: room.host,
-	                        version: this.#roomVersions.get(roomId)
-	                    }), { binary: true });
-
-	                    // Notify existing participants
-	                    room.participants.forEach(p => {
-	                        if (p === ws.clientId) return;
-	                        const client = this.#clients.get(p);
-	                        if (client) {
-	                            client.send(encode({
-	                                type: 'client_connected',
-	                                client: ws.clientId,
-	                                participantCount: room.participants.length
-	                            }), { binary: true });
-	                        }
-	                    });
-	                    this.#triggerEvent("clientJoinedRoom", ws.clientId, roomId);
-	                    break;
-
-	                case 'update_property':
-	                    const updateRoomId = this.#clientRooms.get(ws.clientId);
-	                    const updateRoom = updateRoomId ? this.#rooms[updateRoomId] : null;
-
-	                    if (updateRoom && data.update) {
-	                        // Check if update is allowed via event callback (provide clone to ensure update integrity)
-	                        const updateAllowed = await this.#triggerEvent("storageUpdateRequested", { roomId: updateRoomId, clientId: ws.clientId, update: structuredClone(data.update) });
-	                        if (updateAllowed === 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);
-
-	                        updateRoom.participants?.forEach(p => {
-	                            const client = this.#clients.get(p);
-	                            if (client) {
-	                                client.send(encode({
-	                                    type: 'property_updated',
-	                                    update: data.update,
-	                                    version: currentVersion
-	                                }), { binary: true });
-	                            }
-	                        });
-
-	                        this.#triggerEvent("storageUpdated", { roomId: updateRoomId, clientId: ws.clientId, update: structuredClone(data.update), storage: this.getRoomStorage(updateRoomId) });
-	                        if (this.#debug) console.log("Property update received and imported:", data.update);
-	                    }
-	                    break;
-
-	                case 'request':
-	                    const requestorRoomId = this.#clientRooms.get(ws.clientId) || null;
-	                    this.#triggerEvent("requestReceived", { roomId: requestorRoomId, clientId: ws.clientId, name: data.request.name, data: data.request.data });
-	                    break;
-
-	                case 'disconnect':
-	                    // Client signals to server that it will will willfully disconnect soon
-	                    ws.willfulDisconnect = true;
-	                    break;
-	            }
-	        } catch (error) {
-	            console.error('Error in message handler:', error);
-	        }
-	    }
-
-	    /**
-	     * If the client that disconnected (and is now in the reconnection-phase) was the room host,
-	     * pick a new room host immediately to avoid host-less phase (in case important logic is attached to the host)
-	     * @param {string} roomId
-	     * @param {string} clientId
-	     */
-	    #changeHostIfDisconnected(roomId, clientId) {
-	        const room = this.#rooms[roomId];
-	        if (room && room.host === clientId && room.participants.length > 1) {
-	            const participantsWithoutClient = room.participants.filter((e) => e !== clientId);
-	            room.host = participantsWithoutClient[0]; // Set new host
-
-	            // Inform all participants about the new host
-	            participantsWithoutClient.forEach(p => {
-	                const client = this.#clients.get(p);
-	                if (client) client.send(encode({
-	                    type: 'host_migrated',
-	                    newHost: room.host,
-	                }), { binary: true });
-	            });
-	        }
-	    }
-
-	    /**
-	     * Generate a random token to prevent malicious reconnect attempts
-	     * @returns {string} - Token
-	     */
-	    #generateSessionToken() {
-	        let token = '';
-	        for (let i = 0; i < 16; i++) token += Math.floor(Math.random() * 16).toString(16);
-	        return token;
-	    }
-
-	    /**
-	     * Check rate limit using token bucket algorithm
-	     * @private
-	     */
-	    #checkRateLimit(connectionId, operationType) {
-	        const MAX_POINTS = 20;
-	        const now = Date.now();
-
-	        if (!this.#rateLimits.has(connectionId)) {
-	            this.#rateLimits.set(connectionId, { points: MAX_POINTS, lastReset: now });
-	            return true;
-	        }
-
-	        const limit = this.#rateLimits.get(connectionId);
-
-	        // Reset points if interval has passed (1s)
-	        if (now - limit.lastReset > 1000) {
-	            limit.points = MAX_POINTS;
-	            limit.lastReset = now;
-	        }
-
-	        const pointCost = operationType == "create_room" ? 5 : 1;
-	        if (limit.points < pointCost) return false;
-
-	        limit.points -= pointCost;
-	        return true;
-	    }
-
-	    /**
-	     * Handle client disconnection
-	     * @private
-	     */
-	    #handleDisconnection(ws) {
-	        this.#rateLimits.delete(ws.connectionId);
-
-	        if (ws.clientId) {
-	            this.#clients.delete(ws.clientId); // Immediately remove from active clients (otherwise, server would try to message this client)
-
-	            // If client was in a room, check if they were the host & migrate
-	            const roomId = this.#clientRooms.get(ws.clientId);
-	            if (roomId != null) this.#changeHostIfDisconnected(roomId, ws.clientId);
-
-	            if (ws.willfulDisconnect) {
-	                this.#disconnectClient(ws); // Immediate disconnection
-	            } else {
-	                // Pending complete disconnection with 5s grace period to allow for reconnections
-	                this.#pendingDisconnects.set(ws.clientId, {
-	                    timeout: setTimeout(() => {
-	                        this.#disconnectClient(ws);
-	                    }, 5000)
-	                });
-	            }
-	        }
-	    }
-
-	    /**
-	     * Disconnect a client
-	     * @private
-	     * @param {Object} ws 
-	     */
-	    #disconnectClient(ws) {
-	        this.#pendingDisconnects.delete(ws.clientId);
-	        this.#clientTokens.delete(ws.clientId);
-	        let roomId = this.#clientRooms.get(ws.clientId);
-	        const room = this.#rooms[roomId];
-
-	        if (room) {
-	            room.participants = room.participants.filter(p => p !== ws.clientId); // Remove client from room
-	            this.#clientRooms.delete(ws.clientId);
-
-	            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 + ".");
-	                roomId = null; // If room was destroyed, set roomId to null
-	            } else {
-	                // Notify remaining participants
-	                room.participants.forEach(p => {
-	                    const client = this.#clients.get(p);
-	                    if (client) client.send(encode({
-	                        type: 'client_disconnected',
-	                        client: ws.clientId,
-	                        participantCount: room.participants.length
-	                    }), { binary: true });
-	                });
-	            }
-	        }
-
-	        this.#triggerEvent("clientDisconnected", ws.clientId, roomId);
-	    }
-
-	    /**
-	     * Register an event callback
-	     * @param {string} event - Event name
-	     * @param {Function} callback - Callback function
-	     */
-	    onEvent(event, callback) {
-	        const validEvents = ["clientRegistered", "clientRegistrationRequested", "clientDisconnected", "clientJoinedRoom", "clientJoinRequested", "roomCreated", "roomCreationRequested", "requestReceived", "storageUpdated", "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);
-	    }
-
-	    /**
-	     * Kick a player from the server
-	     * @param {string} clientId - Client ID
-	     * @param {string} [reason] - Optional reason
-	     */
-	    kick(clientId, reason) {
-	        const client = this.#clients.get(clientId);
-	        if (client) {
-	            client.willfulDisconnect = true;
-	            client.send(encode({ type: 'kicked', reason }), { binary: true });
-	            client.close();
-	        }
-	    }
-
-	    /**
-	     * Trigger an event to registered callbacks
-	     * @private
-	     */
-	    async #triggerEvent(event, ...args) {
-	        const callbacks = this.#callbacks.get(event);
-	        if (!callbacks) return;
-
-	        for (const callback of callbacks) {
-	            try {
-	                const result = await callback(...args);
-	                if (result != null) return result; // Return any non-null/undefined result
-	            } catch (error) {
-	                console.error(`PlaySocket ${event} callback error:`, error);
-	            }
-	        }
-	        return true;
-	    }
-
-	    /**
-	     * Get snapshot of a room's storage
-	     * @returns {Object} - Storage object
-	     */
-	    getRoomStorage(roomId) {
-	        const room = this.#rooms[roomId];
-	        if (room) return room.crdtManager.getPropertyStore;
-	    }
-
-	    /**
-	     * Update a value in a room's storage
-	     * @param {string} roomId - Room ID
-	     * @param {string} key - Storage key
-	     * @param {string} type - Operation type
-	     * @param {*} value - New value or value to operate on
-	     * @param {*} updateValue - New value for update-matching
-	     */
-	    updateRoomStorage(roomId, key, type, value, updateValue) {
-	        if (this.#debug) console.log(`Playsocket server property update for room ${roomId}, key ${key}, operation ${type}, value ${value} and updateValue ${updateValue}.`);
-	        const room = this.#rooms[roomId];
-	        if (room) {
-	            const propertyUpdate = room.crdtManager.updateProperty(key, type, value, updateValue);
-	            const currentVersion = this.#roomVersions.get(roomId) + 1;
-	            this.#roomVersions.set(roomId, currentVersion); // Increment version for this room
-
-	            room.participants?.forEach(p => {
-	                const client = this.#clients.get(p);
-	                if (client) {
-	                    client.send(encode({
-	                        type: 'property_updated',
-	                        update: propertyUpdate,
-	                        version: currentVersion
-	                    }), { binary: true });
-	                }
-	            });
-	            this.#triggerEvent("storageUpdated", { roomId, clientId: null, update: structuredClone(propertyUpdate), storage: this.getRoomStorage(roomId) });
-	        }
-	    }
-
-	    /**
-	     * Close all client connections, then close the websocket and http server
-	     */
-	    stop() {
-	        clearInterval(this.#heartbeatInterval);
-	        if (this.#wss) {
-	            this.#clients.forEach(client => {
-	                client.send(encode({ type: 'server_stopped' }), { binary: true });
-	                client.close();
-	            });
-	            this.#wss.close();
-	        }
-	        if (this.#server && this.#ownsServer) this.#server.close(() => { console.log('PlaySocket server stopped.'); });
-	        this.#pendingDisconnects.forEach((data) => {
-	            clearTimeout(data.timeout);
-	        });
-	    }
-
-	    get getRooms() { return { ...this.#rooms } }
-	}
-
-	server$1 = PlaySocketServer;
-	return server$1;
-}
+        if (debug) this.#debug = true; // Enable extra logging
+
+        this.#rateLimitMaxPoints = rateLimit; // Set rate limit
+
+        // Handle server creation / usage
+        if (server) {
+            this.#server = server; // Use provided HTTP server
+        } else {
+            this.#ownsServer = true;
+            this.#server = http__namespace.createServer(); // Create HTTP server and start it
+            this.#server.listen(port, () => {
+                console.log(`PlaySocket server running on port ${port}.`);
+            });
+        }
+
+        // Create WebSocket server
+        this.#wss = new ws.WebSocketServer({
+            server: this.#server,
+            path
+        });
+
+        // Set up ws event handlers
+        this.#wss.on('connection', ws => {
+            ws.connectionId = crypto.randomUUID();
+            ws.isAlive = true;
+            ws.on('pong', () => { ws.isAlive = true; });
+            ws.on('message', msg => this.#handleMessage(ws, msg));
+            ws.on('close', () => this.#handleDisconnection(ws));
+            ws.on('error', (error) => {
+                console.error(`PlaySocket WebSocket connection error for client ${ws.clientId || 'unknown'}:`, error); // Catch conn errors
+            });
+        });
+
+        // Log & catch server-level errors
+        this.#wss.on('error', (error) => {
+            console.error('PlaySocket WebSocket server error:', error);
+        });
+
+        // Start heartbeat
+        this.#heartbeatInterval = setInterval(() => {
+            this.#wss.clients.forEach(ws => {
+                if (!ws.isAlive) return ws.terminate();
+                ws.isAlive = false;
+                ws.ping();
+            });
+        }, 15000);
+    }
+
+    /**
+     * Handle WebSocket message
+     * @private
+     */
+    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)) {
+                if (!ws.isTerminating) {
+                    ws.isTerminating = true; // Prevent multiple terminate calls (it is async)
+                    ws.terminate();
+                    return console.error(`Connection ${ws.connectionId} terminated due to rate limit violations.`);
+                }
+            }
+
+            switch (data.type) {
+                case 'register':
+                    // Register client ID if provided & check for a duplicate
+                    if (data.id && this.#clients.get(data.id)) {
+                        ws.send(encode({ type: 'registration_failed', reason: 'ID is taken.' }), { binary: true });
+                        return;
+                    }
+
+                    // Generate client ID if none provided
+                    if (!data.id) {
+                        for (let i = 0; i < 50; i++) {
+                            const id = this.#generateId();
+                            if (!this.#clients.get(id)) {
+                                data.id = id;
+                                break;
+                            }
+                        }
+                        if (!data.id) {
+                            ws.send(encode({ type: 'registration_failed', reason: 'No available ID found.' }), { binary: true });
+                            throw new Error('Failed to generate unique ID!');
+                        }
+                    }
+
+                    // Event callback
+                    const registrationAllowed = await this.#triggerEvent("clientRegistrationRequested", data.id, data.customData);
+                    if (registrationAllowed === false || typeof registrationAllowed === 'string') {
+                        ws.send(encode({
+                            type: 'registration_failed',
+                            reason: typeof registrationAllowed === 'string' ? registrationAllowed : 'Denied.'
+                        }), { binary: true });
+                        return;
+                    }
+
+                    ws.clientId = data.id; // Adds the provided id to the ws object as clientId
+                    this.#clients.set(data.id, ws);
+                    const sessionToken = this.#generateSessionToken();
+                    this.#clientTokens.set(data.id, sessionToken); // Token is used when reconnecting to prevent impersonation attacks
+                    ws.send(encode({ type: 'registered', id: data.id, sessionToken }), { binary: true });
+                    this.#triggerEvent("clientRegistered", data.id, data.customData);
+                    break;
+
+                case 'reconnect':
+                    // If user is pending disconnect, respond (otherwise it's too late)
+                    const pd = this.#pendingDisconnects.get(data.id);
+                    if (pd && data.sessionToken) {
+                        if (data.sessionToken !== this.#clientTokens.get(data.id)) {
+                            ws.send(encode({
+                                type: 'reconnection_failed',
+                                reason: "Session token does not match."
+                            }), { binary: true });
+                            return;
+                        }
+                        clearTimeout(pd.timeout);
+                        this.#pendingDisconnects.delete(data.id);
+
+                        // Re-assign old client ID to the new ws connection
+                        ws.clientId = data.id;
+                        this.#clients.set(data.id, ws);
+
+                        // If they were in a room, provide updated room data
+                        let roomData;
+                        const formerRoomId = this.#clientRooms.get(data.id);
+                        const formerRoom = this.#rooms[formerRoomId];
+                        if (formerRoom) {
+                            if (this.#debug) console.log(`State sent for reconnection for room ${formerRoomId}:`, formerRoom.crdtManager.getState);
+                            roomData = {
+                                state: formerRoom.crdtManager.getState,
+                                participantCount: formerRoom.participants.length,
+                                host: formerRoom.host,
+                                version: this.#roomVersions.get(formerRoomId)
+                            };
+                        }
 
-var serverExports = requireServer();
-var server = /*@__PURE__*/getDefaultExportFromCjs(serverExports);
+                        ws.send(encode({ type: 'reconnected', roomData }), { binary: true });
+                    } else {
+                        ws.send(encode({ type: 'reconnection_failed', reason: "Client unknown to server." }), { binary: true });
+                    }
+                    break;
+
+                case 'create_room':
+                    if (!ws.clientId) return;
+
+                    let newRoomId;
+
+                    if (this.#clientRooms.get(ws.clientId)) {
+                        ws.send(encode({
+                            type: 'room_creation_failed',
+                            reason: 'Already in a room.'
+                        }), { binary: true });
+                        return;
+                    }
+
+                    // Generate room ID
+                    for (let i = 0; i < 50; i++) {
+                        const id = this.#generateId();
+                        if (!this.#rooms[id]) {
+                            newRoomId = id;
+                            break;
+                        }
+                    }
+
+                    if (!newRoomId) {
+                        ws.send(encode({ type: 'room_creation_failed', reason: 'No available ID found.' }), { binary: true });
+                        throw new Error('Failed to generate unique room ID!');
+                    }
+
+                    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;
+                    if (reviewedStorage === false) {
+                        ws.send(encode({
+                            type: 'room_creation_failed',
+                            reason: 'Room creation denied.'
+                        }), { binary: true });
+                        return;
+                    }
+
+                    // 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
+                    const maxSize = Math.min(Number(data.size), 100) || 100; // Max. limit is 100 clients / room
+                    this.#roomVersions.set(newRoomId, 0); // Start with version 0
+                    this.#rooms[newRoomId] = {
+                        participants: [ws.clientId],
+                        host: ws.clientId,
+                        maxSize,
+                        crdtManager: roomCrdtManager
+                    };
+                    this.#clientRooms.set(ws.clientId, newRoomId); // Add client to the room
+
+                    ws.send(encode({ type: 'room_created', state: roomCrdtManager.getState, roomId: newRoomId, size: maxSize }), { binary: true });
+                    this.#triggerEvent("roomCreated", newRoomId);
+                    if (this.#debug) console.log(`Room ${newRoomId} created with initial storage:`, data.initialStorage);
+                    break;
+
+                case 'join_room':
+                    if (!data.roomId || !ws.clientId) return;
+                    const roomId = data.roomId;
+                    const room = this.#rooms[roomId];
+
+                    const rejectJoin = (reason) => {
+                        ws.send(encode({ type: 'join_rejected', reason }), { binary: true });
+                    };
+
+                    // Event callback
+                    const joinAllowed = await this.#triggerEvent("clientJoinRequested", ws.clientId, roomId);
+                    if (joinAllowed === false || typeof joinAllowed === 'string') return rejectJoin(typeof joinAllowed === 'string' ? joinAllowed : 'Denied.');
+
+                    if (!room) return rejectJoin("Room not found.");
+                    if (this.#clientRooms.get(ws.clientId)) return rejectJoin("Already in a room.");
+                    if (room.participants.length >= room.maxSize) return rejectJoin("Room full.");
+
+                    room.participants.push(ws.clientId);
+                    this.#clientRooms.set(ws.clientId, roomId);
+
+                    // Notify joiner with initial storage
+                    if (this.#debug) console.log("Room state sent for join:", room.crdtManager.getState);
+                    ws.send(encode({
+                        type: 'join_accepted',
+                        state: room.crdtManager.getState,
+                        participantCount: room.participants.length,
+                        host: room.host,
+                        version: this.#roomVersions.get(roomId)
+                    }), { binary: true });
+
+                    // Notify existing participants
+                    room.participants.forEach(p => {
+                        if (p === ws.clientId) return;
+                        const client = this.#clients.get(p);
+                        if (client) {
+                            client.send(encode({
+                                type: 'client_connected',
+                                client: ws.clientId,
+                                participantCount: room.participants.length
+                            }), { binary: true });
+                        }
+                    });
+                    this.#triggerEvent("clientJoinedRoom", ws.clientId, roomId);
+                    break;
+
+                case 'update_property':
+                    const updateRoomId = this.#clientRooms.get(ws.clientId);
+                    const updateRoom = updateRoomId ? this.#rooms[updateRoomId] : null;
+
+                    if (updateRoom && data.update) {
+                        // Check if update is allowed via event callback (provide clone to ensure update integrity)
+                        const updateAllowed = await this.#triggerEvent("storageUpdateRequested", { roomId: updateRoomId, clientId: ws.clientId, update: structuredClone(data.update) });
+                        if (updateAllowed === 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);
+
+                        updateRoom.participants?.forEach(p => {
+                            const client = this.#clients.get(p);
+                            if (client) {
+                                client.send(encode({
+                                    type: 'property_updated',
+                                    update: data.update,
+                                    version: currentVersion
+                                }), { binary: true });
+                            }
+                        });
+
+                        this.#triggerEvent("storageUpdated", { roomId: updateRoomId, clientId: ws.clientId, update: structuredClone(data.update), storage: this.getRoomStorage(updateRoomId) });
+                        if (this.#debug) console.log("Property update received and imported:", data.update);
+                    }
+                    break;
+
+                case 'request':
+                    if (!ws.clientId) return;
+                    const requestorRoomId = this.#clientRooms.get(ws.clientId) || null;
+                    this.#triggerEvent("requestReceived", { roomId: requestorRoomId, clientId: ws.clientId, name: data.request.name, data: data.request.data });
+                    break;
+
+                case 'disconnect':
+                    // Client signals to server that it will will willfully disconnect soon
+                    ws.willfulDisconnect = true;
+                    break;
+            }
+        } catch (error) {
+            console.error('Error in message handler:', error);
+        }
+    }
+
+    /**
+     * Generate a readable, 6 digit ID
+     */
+    #generateId() {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789';
+        return Array.from({ length: 6 }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+    }
+
+    /**
+     * If the client that disconnected (and is now in the reconnection-phase) was the room host,
+     * pick a new room host immediately to avoid host-less phase (in case important logic is attached to the host)
+     * @param {string} roomId
+     * @param {string} clientId
+     */
+    #changeHostIfDisconnected(roomId, clientId) {
+        const room = this.#rooms[roomId];
+        if (room && room.host === clientId && room.participants.length > 1) {
+            const participantsWithoutClient = room.participants.filter((e) => e !== clientId);
+            room.host = participantsWithoutClient[0]; // Set new host
+
+            // Inform all participants about the new host
+            participantsWithoutClient.forEach(p => {
+                const client = this.#clients.get(p);
+                if (client) client.send(encode({
+                    type: 'host_migrated',
+                    newHost: room.host,
+                }), { binary: true });
+            });
+        }
+    }
+
+    /**
+     * Generate a random token to prevent malicious reconnect attempts
+     * @returns {string} - Token
+     */
+    #generateSessionToken() {
+        let token = '';
+        for (let i = 0; i < 16; i++) token += Math.floor(Math.random() * 16).toString(16);
+        return token;
+    }
+
+    /**
+     * Check rate limit using token bucket algorithm
+     * @private
+     */
+    #checkRateLimit(connectionId, operationType) {
+        const now = Date.now();
+
+        if (!this.#rateLimits.has(connectionId)) {
+            this.#rateLimits.set(connectionId, { points: this.#rateLimitMaxPoints, lastReset: now });
+            return true;
+        }
+
+        const limit = this.#rateLimits.get(connectionId);
+
+        // Reset points if interval has passed (1s)
+        if (now - limit.lastReset > 1000) {
+            limit.points = this.#rateLimitMaxPoints;
+            limit.lastReset = now;
+        }
+
+        const pointCost = operationType == "create_room" ? 5 : 1;
+        if (limit.points < pointCost) return false;
+
+        limit.points -= pointCost;
+        return true;
+    }
+
+    /**
+     * Handle client disconnection
+     * @private
+     */
+    #handleDisconnection(ws) {
+        this.#rateLimits.delete(ws.connectionId);
+
+        if (ws.clientId) {
+            this.#clients.delete(ws.clientId); // Immediately remove from active clients (otherwise, server would try to message this client)
+
+            // If client was in a room, check if they were the host & migrate
+            const roomId = this.#clientRooms.get(ws.clientId);
+            if (roomId != null) this.#changeHostIfDisconnected(roomId, ws.clientId);
+
+            if (ws.willfulDisconnect) {
+                this.#disconnectClient(ws); // Immediate disconnection
+            } else {
+                // Pending complete disconnection with 5s grace period to allow for reconnections
+                this.#pendingDisconnects.set(ws.clientId, {
+                    timeout: setTimeout(() => {
+                        this.#disconnectClient(ws);
+                    }, 5000)
+                });
+            }
+        }
+    }
+
+    /**
+     * Disconnect a client
+     * @private
+     * @param {Object} ws 
+     */
+    #disconnectClient(ws) {
+        this.#pendingDisconnects.delete(ws.clientId);
+        this.#clientTokens.delete(ws.clientId);
+        let roomId = this.#clientRooms.get(ws.clientId);
+        const room = this.#rooms[roomId];
+
+        if (room) {
+            room.participants = room.participants.filter(p => p !== ws.clientId); // Remove client from room
+            this.#clientRooms.delete(ws.clientId);
+
+            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 + ".");
+                roomId = null; // If room was destroyed, set roomId to null
+            } else {
+                // Notify remaining participants
+                room.participants.forEach(p => {
+                    const client = this.#clients.get(p);
+                    if (client) client.send(encode({
+                        type: 'client_disconnected',
+                        client: ws.clientId,
+                        participantCount: room.participants.length
+                    }), { binary: true });
+                });
+            }
+        }
+
+        this.#triggerEvent("clientDisconnected", ws.clientId, roomId);
+    }
+
+    /**
+     * Register an event callback
+     * @param {string} event - Event name
+     * @param {Function} callback - Callback function
+     */
+    onEvent(event, callback) {
+        const validEvents = ["clientRegistered", "clientRegistrationRequested", "clientDisconnected", "clientJoinedRoom", "clientJoinRequested", "roomCreated", "roomCreationRequested", "requestReceived", "storageUpdated", "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);
+    }
+
+    /**
+     * Kick a player from the server
+     * @param {string} clientId - Client ID
+     * @param {string} [reason] - Optional reason
+     */
+    kick(clientId, reason) {
+        const client = this.#clients.get(clientId);
+        if (client) {
+            client.willfulDisconnect = true;
+            client.send(encode({ type: 'kicked', reason }), { binary: true });
+            client.close();
+        }
+    }
+
+    /**
+     * Trigger an event to registered callbacks
+     * @private
+     */
+    async #triggerEvent(event, ...args) {
+        const callbacks = this.#callbacks.get(event);
+        if (!callbacks) return;
+
+        for (const callback of callbacks) {
+            try {
+                const result = await callback(...args);
+                if (result != null) return result; // Return any non-null/undefined result
+            } catch (error) {
+                console.error(`PlaySocket ${event} callback error:`, error);
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Get snapshot of a room's storage
+     * @returns {Object} - Storage object
+     */
+    getRoomStorage(roomId) {
+        const room = this.#rooms[roomId];
+        if (room) return room.crdtManager.getPropertyStore;
+    }
+
+    /**
+     * Update a value in a room's storage
+     * @param {string} roomId - Room ID
+     * @param {string} key - Storage key
+     * @param {string} type - Operation type
+     * @param {*} value - New value or value to operate on
+     * @param {*} updateValue - New value for update-matching
+     */
+    updateRoomStorage(roomId, key, type, value, updateValue) {
+        if (this.#debug) console.log(`Playsocket server property update for room ${roomId}, key ${key}, operation ${type}, value ${value} and updateValue ${updateValue}.`);
+        const room = this.#rooms[roomId];
+        if (room) {
+            const propertyUpdate = room.crdtManager.updateProperty(key, type, value, updateValue);
+            const currentVersion = this.#roomVersions.get(roomId) + 1;
+            this.#roomVersions.set(roomId, currentVersion); // Increment version for this room
+
+            room.participants?.forEach(p => {
+                const client = this.#clients.get(p);
+                if (client) {
+                    client.send(encode({
+                        type: 'property_updated',
+                        update: propertyUpdate,
+                        version: currentVersion
+                    }), { binary: true });
+                }
+            });
+            this.#triggerEvent("storageUpdated", { roomId, clientId: null, update: structuredClone(propertyUpdate), storage: this.getRoomStorage(roomId) });
+        }
+    }
+
+    /**
+     * Close all client connections, then close the websocket and http server
+     */
+    stop() {
+        clearInterval(this.#heartbeatInterval);
+        if (this.#wss) {
+            this.#clients.forEach(client => {
+                client.send(encode({ type: 'server_stopped' }), { binary: true });
+                client.close();
+            });
+            this.#wss.close();
+        }
+        if (this.#server && this.#ownsServer) this.#server.close(() => { console.log('PlaySocket server stopped.'); });
+        this.#pendingDisconnects.forEach((data) => {
+            clearTimeout(data.timeout);
+        });
+    }
+
+    get getRooms() { return { ...this.#rooms } }
+}
 
-module.exports = server;
+module.exports = PlaySocketServer;