@signe/room 2.8.3 → 2.9.2

package/dist/index.js

@@ -1,5 +1,13 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
 
 // src/decorators.ts
 function Action(name, bodyValidation) {
@@ -13,7 +21,13 @@ function Action(name, bodyValidation) {
     });
   };
 }
-__name(Action, "Action");
+function UnhandledAction() {
+  return function(target, propertyKey) {
+    target.constructor._unhandledActionMetadata = {
+      key: propertyKey
+    };
+  };
+}
 function Request2(options, bodyValidation) {
   return function(target, propertyKey) {
     if (!target.constructor._requestMetadata) {
@@ -30,7 +44,6 @@ function Request2(options, bodyValidation) {
     });
   };
 }
-__name(Request2, "Request");
 function Room(options) {
   return function(target) {
     target.path = options.path;
@@ -43,46 +56,40 @@ function Room(options) {
     }
   };
 }
-__name(Room, "Room");
 function RoomGuard(guards) {
   return function(target) {
     target["_roomGuards"] = guards;
   };
 }
-__name(RoomGuard, "RoomGuard");
 function Guard(guards) {
   return function(target, propertyKey, descriptor) {
     if (!target.constructor["_actionGuards"]) {
       target.constructor["_actionGuards"] = /* @__PURE__ */ new Map();
     }
     if (!Array.isArray(guards)) {
-      guards = [
-        guards
-      ];
+      guards = [guards];
     }
     target.constructor["_actionGuards"].set(propertyKey, guards);
   };
 }
-__name(Guard, "Guard");
 
 // ../sync/src/utils.ts
 function generateShortUUID() {
   const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const randomBytes = typeof globalThis.crypto?.getRandomValues === "function" ? globalThis.crypto.getRandomValues(new Uint8Array(8)) : null;
   let uuid = "";
   for (let i = 0; i < 8; i++) {
-    const randomIndex = Math.floor(Math.random() * chars.length);
-    uuid += chars[randomIndex];
+    const randomValue = randomBytes?.[i] ?? Math.floor(Math.random() * 256);
+    uuid += chars[randomValue % chars.length];
   }
   return uuid;
 }
-__name(generateShortUUID, "generateShortUUID");
 
 // src/storage.ts
 var Storage = class {
-  static {
-    __name(this, "Storage");
+  constructor() {
+    this.memory = /* @__PURE__ */ new Map();
   }
-  memory = /* @__PURE__ */ new Map();
   async put(key, value) {
     this.memory.set(key, value);
   }
@@ -100,22 +107,27 @@ var Storage = class {
 // src/server.ts
 import { dset as dset2 } from "dset";
 import z from "zod";
-import { createStatesSnapshot, getByPath, load, syncClass, DELETE_TOKEN, generateShortUUID as generateShortUUID2, createStatesSnapshotDeep } from "@signe/sync";
+import {
+  createStatesSnapshot,
+  getByPath,
+  load,
+  syncClass,
+  DELETE_TOKEN,
+  generateShortUUID as generateShortUUID2,
+  createStatesSnapshotDeep
+} from "@signe/sync";
 
 // src/utils.ts
 import { dset } from "dset";
 function isPromise(value) {
   return value instanceof Promise;
 }
-__name(isPromise, "isPromise");
 async function awaitReturn(val) {
   return isPromise(val) ? await val : val;
 }
-__name(awaitReturn, "awaitReturn");
 function isClass(obj) {
   return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
 }
-__name(isClass, "isClass");
 function throttle(func, wait) {
   let timeout = null;
   let lastArgs = null;
@@ -134,7 +146,6 @@ function throttle(func, wait) {
     }
   };
 }
-__name(throttle, "throttle");
 function extractParams(pattern, str) {
   const regexPattern = pattern.replace(/{(\w+)}/g, "(?<$1>[\\w-]+)");
   const regex = new RegExp(`^${regexPattern}$`);
@@ -147,7 +158,6 @@ function extractParams(pattern, str) {
     return null;
   }
 }
-__name(extractParams, "extractParams");
 function dremove(obj, keys) {
   if (typeof keys === "string") {
     keys = keys.split(".");
@@ -167,7 +177,6 @@ function dremove(obj, keys) {
     delete t[k];
   }
 }
-__name(dremove, "dremove");
 function buildObject(valuesMap, allMemory) {
   let memoryObj = {};
   for (let path of valuesMap.keys()) {
@@ -181,33 +190,25 @@ function buildObject(valuesMap, allMemory) {
   }
   return memoryObj;
 }
-__name(buildObject, "buildObject");
 function response(status, body) {
   return new Response(JSON.stringify(body), {
     status,
-    headers: {
-      "Content-Type": "application/json"
-    }
+    headers: { "Content-Type": "application/json" }
   });
 }
-__name(response, "response");
 
 // src/request/response.ts
 var ServerResponse = class {
-  static {
-    __name(this, "ServerResponse");
-  }
-  interceptors;
-  statusCode = 200;
-  responseBody = {};
-  responseHeaders = {
-    "Content-Type": "application/json"
-  };
   /**
    * Creates a new ServerResponse instance
    * @param interceptors Array of interceptor functions that can modify the response
    */
   constructor(interceptors = []) {
+    this.statusCode = 200;
+    this.responseBody = {};
+    this.responseHeaders = {
+      "Content-Type": "application/json"
+    };
     this.interceptors = interceptors;
   }
   /**
@@ -245,10 +246,7 @@ var ServerResponse = class {
    * @returns this instance for chaining
    */
   setHeaders(headers) {
-    this.responseHeaders = {
-      ...this.responseHeaders,
-      ...headers
-    };
+    this.responseHeaders = { ...this.responseHeaders, ...headers };
     return this;
   }
   /**
@@ -373,9 +371,7 @@ var ServerResponse = class {
    * @returns Promise<Response> The final Response object
    */
   async notPermitted(message = "Not permitted") {
-    return this.status(403).json({
-      error: message
-    });
+    return this.status(403).json({ error: message });
   }
   /**
    * Creates an error response with status 401
@@ -383,9 +379,7 @@ var ServerResponse = class {
    * @returns Promise<Response> The final Response object
    */
   async unauthorized(message = "Unauthorized") {
-    return this.status(401).json({
-      error: message
-    });
+    return this.status(401).json({ error: message });
   }
   /**
    * Creates an error response with status 404
@@ -393,9 +387,7 @@ var ServerResponse = class {
    * @returns Promise<Response> The final Response object
    */
   async notFound(message = "Not found") {
-    return this.status(404).json({
-      error: message
-    });
+    return this.status(404).json({ error: message });
   }
   /**
    * Creates an error response with status 500
@@ -403,9 +395,7 @@ var ServerResponse = class {
    * @returns Promise<Response> The final Response object
    */
   async serverError(message = "Internal Server Error") {
-    return this.status(500).json({
-      error: message
-    });
+    return this.status(500).json({ error: message });
   }
 };
 
@@ -440,11 +430,9 @@ function cors(res, options = {}) {
     headers: newHeaders
   });
 }
-__name(cors, "cors");
 function createCorsInterceptor(options = {}) {
   return (res) => cors(res, options);
 }
-__name(createCorsInterceptor, "createCorsInterceptor");
 
 // src/server.ts
 var Message = z.object({
@@ -452,37 +440,31 @@ var Message = z.object({
   value: z.any()
 });
 var Server = class {
-  static {
-    __name(this, "Server");
-  }
-  room;
-  subRoom;
-  rooms;
   /**
-  * @constructor
-  * @param {Party.Room} room - The room object representing the current game or application instance.
-  * 
-  * @example
-  * ```typescript
-  * const server = new MyServer(new ServerIo("game"));
-  * ```
-  */
+   * @constructor
+   * @param {Party.Room} room - The room object representing the current game or application instance.
+   * 
+   * @example
+   * ```typescript
+   * const server = new MyServer(new ServerIo("game"));
+   * ```
+   */
   constructor(room) {
     this.room = room;
     this.subRoom = null;
     this.rooms = [];
   }
   /**
-  * @readonly
-  * @property {boolean} isHibernate - Indicates whether the server is in hibernate mode.
-  * 
-  * @example
-  * ```typescript
-  * if (!server.isHibernate) {
-  *   console.log("Server is active");
-  * }
-  * ```
-  */
+    * @readonly
+    * @property {boolean} isHibernate - Indicates whether the server is in hibernate mode.
+    * 
+    * @example
+    * ```typescript
+    * if (!server.isHibernate) {
+    *   console.log("Server is active");
+    * }
+    * ```
+    */
   get isHibernate() {
     return !!this["options"]?.hibernate;
   }
@@ -506,35 +488,31 @@ var Server = class {
     }
   }
   /**
-  * @method onStart
-  * @async
-  * @description Initializes the server and creates the initial room if not in hibernate mode.
-  * @returns {Promise<void>}
-  * 
-  * @example
-  * ```typescript
-  * async function initServer() {
-  *   await server.onStart();
-  *   console.log("Server started");
-  * }
-  * ```
-  */
+   * @method onStart
+   * @async
+   * @description Initializes the server and creates the initial room if not in hibernate mode.
+   * @returns {Promise<void>}
+   * 
+   * @example
+   * ```typescript
+   * async function initServer() {
+   *   await server.onStart();
+   *   console.log("Server started");
+   * }
+   * ```
+   */
   async onStart() {
     if (!this.isHibernate) {
       this.subRoom = await this.createRoom();
     }
   }
   async runGarbageCollector() {
-    await this.garbageCollector({
-      sessionExpiryTime: -1
-    });
+    await this.garbageCollector({ sessionExpiryTime: -1 });
   }
   async garbageCollector(options) {
     const subRoom = await this.getSubRoom();
     if (!subRoom) return;
-    const activeConnections = [
-      ...this.room.getConnections()
-    ];
+    const activeConnections = [...this.room.getConnections()];
     const activePrivateIds = new Set(activeConnections.map((conn) => conn.id));
     try {
       const sessions = await this.room.storage.list();
@@ -569,21 +547,21 @@ var Server = class {
     }
   }
   /**
-  * @method createRoom
-  * @private
-  * @async
-  * @param {CreateRoomOptions} [options={}] - Options for creating the room.
-  * @returns {Promise<Object>} The created room instance.
-  * 
-  * @example
-  * ```typescript
-  * // This method is private and called internally
-  * async function internalCreateRoom() {
-  *   const room = await this.createRoom({ getMemoryAll: true });
-  *   console.log("Room created:", room);
-  * }
-  * ```
-  */
+   * @method createRoom
+   * @private
+   * @async
+   * @param {CreateRoomOptions} [options={}] - Options for creating the room.
+   * @returns {Promise<Object>} The created room instance.
+   * 
+   * @example
+   * ```typescript
+   * // This method is private and called internally
+   * async function internalCreateRoom() {
+   *   const room = await this.createRoom({ getMemoryAll: true });
+   *   console.log("Room created:", room);
+   * }
+   * ```
+   */
   async createRoom(options = {}) {
     let instance;
     let init = true;
@@ -598,7 +576,7 @@ var Server = class {
     if (!instance) {
       return null;
     }
-    const loadMemory = /* @__PURE__ */ __name(async () => {
+    const loadMemory = async () => {
       const root = await this.room.storage.get(".");
       const memory = await this.room.storage.list();
       const tmpObject = root || {};
@@ -612,7 +590,7 @@ var Server = class {
         dset2(tmpObject, key, value);
       }
       load(instance, tmpObject, true);
-    }, "loadMemory");
+    };
     instance.$memoryAll = {};
     instance.$autoSync = instance["autoSync"] !== false;
     instance.$pendingSync = /* @__PURE__ */ new Map();
@@ -712,7 +690,7 @@ var Server = class {
         return null;
       }
     };
-    const syncCb = /* @__PURE__ */ __name((values) => {
+    const syncCb = (values) => {
       if (options.getMemoryAll) {
         buildObject(values, instance.$memoryAll);
       }
@@ -728,13 +706,16 @@ var Server = class {
         return;
       }
       const packet = buildObject(values, instance.$memoryAll);
-      this.broadcast({
-        type: "sync",
-        value: packet
-      }, instance);
+      this.broadcast(
+        {
+          type: "sync",
+          value: packet
+        },
+        instance
+      );
       values.clear();
-    }, "syncCb");
-    const persistCb = /* @__PURE__ */ __name(async (values) => {
+    };
+    const persistCb = async (values) => {
       if (initPersist) {
         values.clear();
         return;
@@ -749,7 +730,7 @@ var Server = class {
         }
       }
       values.clear();
-    }, "persistCb");
+    };
     syncClass(instance, {
       onSync: instance["throttleSync"] ? throttle(syncCb, instance["throttleSync"]) : syncCb,
       onPersist: instance["throttleStorage"] ? throttle(persistCb, instance["throttleStorage"]) : persistCb
@@ -760,21 +741,21 @@ var Server = class {
     return instance;
   }
   /**
-  * @method getSubRoom
-  * @private
-  * @async
-  * @param {Object} [options={}] - Options for getting the sub-room.
-  * @returns {Promise<Object>} The sub-room instance.
-  * 
-  * @example
-  * ```typescript
-  * // This method is private and called internally
-  * async function internalGetSubRoom() {
-  *   const subRoom = await this.getSubRoom();
-  *   console.log("Sub-room retrieved:", subRoom);
-  * }
-  * ```
-  */
+   * @method getSubRoom
+   * @private
+   * @async
+   * @param {Object} [options={}] - Options for getting the sub-room.
+   * @returns {Promise<Object>} The sub-room instance.
+   * 
+   * @example
+   * ```typescript
+   * // This method is private and called internally
+   * async function internalGetSubRoom() {
+   *   const subRoom = await this.getSubRoom();
+   *   console.log("Sub-room retrieved:", subRoom);
+   * }
+   * ```
+   */
   async getSubRoom(options = {}) {
     let subRoom;
     if (this.isHibernate) {
@@ -785,20 +766,20 @@ var Server = class {
     return subRoom;
   }
   /**
-  * @method getUsersProperty
-  * @private
-  * @param {Object} subRoom - The sub-room instance.
-  * @returns {Object|null} The users property of the sub-room, or null if not found.
-  * 
-  * @example
-  * ```typescript
-  * // This method is private and called internally
-  * function internalGetUsers(subRoom) {
-  *   const users = this.getUsersProperty(subRoom);
-  *   console.log("Users:", users);
-  * }
-  * ```
-  */
+   * @method getUsersProperty
+   * @private
+   * @param {Object} subRoom - The sub-room instance.
+   * @returns {Object|null} The users property of the sub-room, or null if not found.
+   * 
+   * @example
+   * ```typescript
+   * // This method is private and called internally
+   * function internalGetUsers(subRoom) {
+   *   const users = this.getUsersProperty(subRoom);
+   *   console.log("Users:", users);
+   * }
+   * ```
+   */
   getUsersProperty(subRoom) {
     const meta = subRoom.constructor["_propertyMetadata"];
     const propId = meta?.get("users");
@@ -814,12 +795,12 @@ var Server = class {
     return metadata.get("users");
   }
   /**
-  * Retrieves the connection status property from a user object.
-  * 
-  * @param {any} user - The user object to get the connection property from.
-  * @returns {Function|null} - The connection property signal function or null if not found.
-  * @private
-  */
+   * Retrieves the connection status property from a user object.
+   * 
+   * @param {any} user - The user object to get the connection property from.
+   * @returns {Function|null} - The connection property signal function or null if not found.
+   * @private
+   */
   getUserConnectionProperty(user) {
     if (!user) return null;
     const metadata = user.constructor._propertyMetadata;
@@ -829,13 +810,13 @@ var Server = class {
     return user[connectedPropName];
   }
   /**
-  * Updates a user's connection status in the signal.
-  * 
-  * @param {any} user - The user object to update.
-  * @param {boolean} isConnected - The new connection status.
-  * @returns {boolean} - Whether the update was successful.
-  * @private
-  */
+   * Updates a user's connection status in the signal.
+   * 
+   * @param {any} user - The user object to update.
+   * @param {boolean} isConnected - The new connection status.
+   * @returns {boolean} - Whether the update was successful.
+   * @private
+   */
   updateUserConnectionStatus(user, isConnected) {
     const connectionSignal = this.getUserConnectionProperty(user);
     if (connectionSignal) {
@@ -845,17 +826,17 @@ var Server = class {
     return false;
   }
   /**
-  * @method getSession
-  * @private
-  * @param {string} privateId - The private ID of the session.
-  * @returns {Promise<Object|null>} The session object, or null if not found.
-  * 
-  * @example
-  * ```typescript
-  * const session = await server.getSession("privateId");
-  * console.log(session);
-  * ```
-  */
+   * @method getSession
+   * @private
+   * @param {string} privateId - The private ID of the session.
+   * @returns {Promise<Object|null>} The session object, or null if not found.
+   * 
+   * @example
+   * ```typescript
+   * const session = await server.getSession("privateId");
+   * console.log(session);
+   * ```
+   */
   async getSession(privateId) {
     if (!privateId) return null;
     try {
@@ -876,23 +857,20 @@ var Server = class {
   async updateSessionConnection(privateId, connected) {
     const session = await this.getSession(privateId);
     if (session) {
-      await this.saveSession(privateId, {
-        ...session,
-        connected
-      });
+      await this.saveSession(privateId, { ...session, connected });
     }
   }
   /**
-  * @method deleteSession
-  * @private
-  * @param {string} privateId - The private ID of the session to delete.
-  * @returns {Promise<void>}
-  * 
-  * @example
-  * ```typescript
-  * await server.deleteSession("privateId");
-  * ```
-  */
+   * @method deleteSession
+   * @private
+   * @param {string} privateId - The private ID of the session to delete.
+   * @returns {Promise<void>}
+   * 
+   * @example
+   * ```typescript
+   * await server.deleteSession("privateId");
+   * ```
+   */
   async deleteSession(privateId) {
     await this.room.storage.delete(`session:${privateId}`);
   }
@@ -904,10 +882,8 @@ var Server = class {
       conn.close();
       return;
     }
-    const sessionExpiryTime = subRoom.constructor.sessionExpiryTime;
-    await this.garbageCollector({
-      sessionExpiryTime
-    });
+    const sessionExpiryTime = subRoom.sessionExpiryTime ?? subRoom.constructor.sessionExpiryTime ?? 5 * 60 * 1e3;
+    await this.garbageCollector({ sessionExpiryTime });
     const roomGuards = subRoom.constructor["_roomGuards"] || [];
     for (const guard of roomGuards) {
       const isAuthorized = await guard(conn, ctx, this.room);
@@ -975,21 +951,21 @@ var Server = class {
     }
   }
   /**
-  * @method onConnect
-  * @async
-  * @param {Party.Connection} conn - The connection object for the new user.
-  * @param {Party.ConnectionContext} ctx - The context of the connection.
-  * @description Handles a new user connection, creates a user object, and sends initial sync data.
-  * @returns {Promise<void>}
-  * 
-  * @example
-  * ```typescript
-  * server.onConnect = async (conn, ctx) => {
-  *   await server.onConnect(conn, ctx);
-  *   console.log("New user connected:", conn.id);
-  * };
-  * ```
-  */
+   * @method onConnect
+   * @async
+   * @param {Party.Connection} conn - The connection object for the new user.
+   * @param {Party.ConnectionContext} ctx - The context of the connection.
+   * @description Handles a new user connection, creates a user object, and sends initial sync data.
+   * @returns {Promise<void>}
+   * 
+   * @example
+   * ```typescript
+   * server.onConnect = async (conn, ctx) => {
+   *   await server.onConnect(conn, ctx);
+   *   console.log("New user connected:", conn.id);
+   * };
+   * ```
+   */
   async onConnect(conn, ctx) {
     if (ctx.request?.headers.has("x-shard-id")) {
       this.onConnectShard(conn, ctx);
@@ -998,13 +974,13 @@ var Server = class {
     }
   }
   /**
-  * @method onConnectShard
-  * @private
-  * @param {Party.Connection} conn - The connection object for the new shard.
-  * @param {Party.ConnectionContext} ctx - The context of the shard connection.
-  * @description Handles a new shard connection, setting up the necessary state.
-  * @returns {void}
-  */
+   * @method onConnectShard
+   * @private
+   * @param {Party.Connection} conn - The connection object for the new shard.
+   * @param {Party.ConnectionContext} ctx - The context of the shard connection.
+   * @description Handles a new shard connection, setting up the necessary state.
+   * @returns {void}
+   */
   onConnectShard(conn, ctx) {
     const shardId = ctx.request?.headers.get("x-shard-id") || "unknown-shard";
     conn.setState({
@@ -1015,13 +991,13 @@ var Server = class {
     });
   }
   /**
-  * @method onMessage
-  * @async
-  * @param {string} message - The message received from a user or shard.
-  * @param {Party.Connection} sender - The connection object of the sender.
-  * @description Processes incoming messages, handling differently based on if sender is shard or client.
-  * @returns {Promise<void>}
-  */
+   * @method onMessage
+   * @async
+   * @param {string} message - The message received from a user or shard.
+   * @param {Party.Connection} sender - The connection object of the sender.
+   * @description Processes incoming messages, handling differently based on if sender is shard or client.
+   * @returns {Promise<void>}
+   */
   async onMessage(message, sender) {
     if (sender.state && sender.state.shard) {
       await this.handleShardMessage(message, sender);
@@ -1050,38 +1026,54 @@ var Server = class {
       }
     }
     const actions = subRoom.constructor["_actionMetadata"];
-    if (actions) {
-      const signal2 = this.getUsersProperty(subRoom);
-      const { publicId } = sender.state;
-      const user = signal2?.()[publicId];
-      const actionName = actions.get(result.data.action);
-      if (actionName) {
-        const guards = subRoom.constructor["_actionGuards"]?.get(actionName.key) || [];
-        for (const guard of guards) {
-          const isAuthorized = await guard(sender, result.data.value);
-          if (!isAuthorized) {
-            return;
-          }
+    const signal2 = this.getUsersProperty(subRoom);
+    const { publicId } = sender.state;
+    const user = signal2?.()[publicId];
+    const actionName = actions?.get(result.data.action);
+    if (actionName) {
+      const guards = subRoom.constructor["_actionGuards"]?.get(actionName.key) || [];
+      for (const guard of guards) {
+        const isAuthorized = await guard(sender, result.data.value, this.room);
+        if (!isAuthorized) {
+          return;
         }
-        if (actionName.bodyValidation) {
-          const bodyResult = actionName.bodyValidation.safeParse(result.data.value);
-          if (!bodyResult.success) {
-            return;
-          }
+      }
+      if (actionName.bodyValidation) {
+        const bodyResult = actionName.bodyValidation.safeParse(
+          result.data.value
+        );
+        if (!bodyResult.success) {
+          return;
+        }
+      }
+      await awaitReturn(
+        subRoom[actionName.key](user, result.data.value, sender)
+      );
+      return;
+    }
+    const unhandledAction = subRoom.constructor["_unhandledActionMetadata"];
+    if (unhandledAction) {
+      const guards = subRoom.constructor["_actionGuards"]?.get(unhandledAction.key) || [];
+      for (const guard of guards) {
+        const isAuthorized = await guard(sender, result.data, this.room);
+        if (!isAuthorized) {
+          return;
         }
-        await awaitReturn(subRoom[actionName.key](user, result.data.value, sender));
       }
+      await awaitReturn(
+        subRoom[unhandledAction.key](user, result.data, sender)
+      );
     }
   }
   /**
-  * @method handleShardMessage
-  * @private
-  * @async
-  * @param {string} message - The message received from a shard.
-  * @param {Party.Connection} shardConnection - The connection object of the shard.
-  * @description Processes messages from shards, extracting client information.
-  * @returns {Promise<void>}
-  */
+   * @method handleShardMessage
+   * @private
+   * @async
+   * @param {string} message - The message received from a shard.
+   * @param {Party.Connection} shardConnection - The connection object of the shard.
+   * @description Processes messages from shards, extracting client information.
+   * @returns {Promise<void>}
+   */
   async handleShardMessage(message, shardConnection) {
     let parsedMessage;
     try {
@@ -1107,14 +1099,14 @@ var Server = class {
     }
   }
   /**
-  * @method handleShardClientConnect
-  * @private
-  * @async
-  * @param {Object} message - The client connection message from a shard.
-  * @param {Party.Connection} shardConnection - The connection object of the shard.
-  * @description Handles a new client connection via a shard.
-  * @returns {Promise<void>}
-  */
+   * @method handleShardClientConnect
+   * @private
+   * @async
+   * @param {Object} message - The client connection message from a shard.
+   * @param {Party.Connection} shardConnection - The connection object of the shard.
+   * @description Handles a new client connection via a shard.
+   * @returns {Promise<void>}
+   */
   async handleShardClientConnect(message, shardConnection) {
     const { privateId, requestInfo } = message;
     const shardState = shardConnection.state;
@@ -1127,22 +1119,22 @@ var Server = class {
     };
     const virtualConnection = {
       id: privateId,
-      send: /* @__PURE__ */ __name((data) => {
+      send: (data) => {
         shardConnection.send(JSON.stringify({
           targetClientId: privateId,
           data
         }));
-      }, "send"),
+      },
       state: {},
-      setState: /* @__PURE__ */ __name((state) => {
+      setState: (state) => {
         const clients = shardState.clients;
         const currentState = clients.get(privateId) || {};
         const mergedState = Object.assign({}, currentState, state);
         clients.set(privateId, mergedState);
         virtualConnection.state = clients.get(privateId);
         return virtualConnection.state;
-      }, "setState"),
-      close: /* @__PURE__ */ __name(() => {
+      },
+      close: () => {
         shardConnection.send(JSON.stringify({
           type: "shard.closeClient",
           privateId
@@ -1150,7 +1142,7 @@ var Server = class {
         if (shardState.clients) {
           shardState.clients.delete(privateId);
         }
-      }, "close")
+      }
     };
     if (!shardState.clients.has(privateId)) {
       shardState.clients.set(privateId, {});
@@ -1158,41 +1150,39 @@ var Server = class {
     await this.onConnectClient(virtualConnection, virtualContext);
   }
   /**
-  * @method handleShardClientMessage
-  * @private
-  * @async
-  * @param {Object} message - The client message from a shard.
-  * @param {Party.Connection} shardConnection - The connection object of the shard.
-  * @description Handles a message from a client via a shard.
-  * @returns {Promise<void>}
-  */
+   * @method handleShardClientMessage
+   * @private
+   * @async
+   * @param {Object} message - The client message from a shard.
+   * @param {Party.Connection} shardConnection - The connection object of the shard.
+   * @description Handles a message from a client via a shard.
+   * @returns {Promise<void>}
+   */
   async handleShardClientMessage(message, shardConnection) {
     const { privateId, publicId, payload } = message;
     const shardState = shardConnection.state;
     const clients = shardState.clients;
     if (!clients.has(privateId)) {
       console.warn(`Received message from unknown client ${privateId}, creating virtual connection`);
-      clients.set(privateId, {
-        publicId
-      });
+      clients.set(privateId, { publicId });
     }
     const virtualConnection = {
       id: privateId,
-      send: /* @__PURE__ */ __name((data) => {
+      send: (data) => {
         shardConnection.send(JSON.stringify({
           targetClientId: privateId,
           data
         }));
-      }, "send"),
+      },
       state: clients.get(privateId),
-      setState: /* @__PURE__ */ __name((state) => {
+      setState: (state) => {
         const currentState = clients.get(privateId) || {};
         const mergedState = Object.assign({}, currentState, state);
         clients.set(privateId, mergedState);
         virtualConnection.state = clients.get(privateId);
         return virtualConnection.state;
-      }, "setState"),
-      close: /* @__PURE__ */ __name(() => {
+      },
+      close: () => {
         shardConnection.send(JSON.stringify({
           type: "shard.closeClient",
           privateId
@@ -1200,20 +1190,20 @@ var Server = class {
         if (shardState.clients) {
           shardState.clients.delete(privateId);
         }
-      }, "close")
+      }
     };
     const payloadString = typeof payload === "string" ? payload : JSON.stringify(payload);
     await this.onMessage(payloadString, virtualConnection);
   }
   /**
-  * @method handleShardClientDisconnect
-  * @private
-  * @async
-  * @param {Object} message - The client disconnection message from a shard.
-  * @param {Party.Connection} shardConnection - The connection object of the shard.
-  * @description Handles a client disconnection via a shard.
-  * @returns {Promise<void>}
-  */
+   * @method handleShardClientDisconnect
+   * @private
+   * @async
+   * @param {Object} message - The client disconnection message from a shard.
+   * @param {Party.Connection} shardConnection - The connection object of the shard.
+   * @description Handles a client disconnection via a shard.
+   * @returns {Promise<void>}
+   */
   async handleShardClientDisconnect(message, shardConnection) {
     const { privateId, publicId } = message;
     const shardState = shardConnection.state;
@@ -1225,33 +1215,34 @@ var Server = class {
     }
     const virtualConnection = {
       id: privateId,
-      send: /* @__PURE__ */ __name(() => {
-      }, "send"),
+      send: () => {
+      },
+      // No-op since client is disconnecting
       state: clientState,
-      setState: /* @__PURE__ */ __name(() => {
+      setState: () => {
         return {};
-      }, "setState"),
-      close: /* @__PURE__ */ __name(() => {
-      }, "close")
+      },
+      close: () => {
+      }
     };
     await this.onClose(virtualConnection);
     clients.delete(privateId);
   }
   /**
-  * @method onClose
-  * @async
-  * @param {Party.Connection} conn - The connection object of the disconnecting user.
-  * @description Handles user disconnection, removing them from the room and triggering the onLeave event..
-  * @returns {Promise<void>}
-  * 
-  * @example
-  * ```typescript
-  * server.onClose = async (conn) => {
-  *   await server.onClose(conn);
-  *   console.log("User disconnected:", conn.id);
-  * };
-  * ```
-  */
+   * @method onClose
+   * @async
+   * @param {Party.Connection} conn - The connection object of the disconnecting user.
+   * @description Handles user disconnection, removing them from the room and triggering the onLeave event..
+   * @returns {Promise<void>}
+   * 
+   * @example
+   * ```typescript
+   * server.onClose = async (conn) => {
+   *   await server.onClose(conn);
+   *   console.log("User disconnected:", conn.id);
+   * };
+   * ```
+   */
   async onClose(conn) {
     const subRoom = await this.getSubRoom();
     if (!subRoom) {
@@ -1274,9 +1265,7 @@ var Server = class {
     if (!connectionUpdated) {
       this.broadcast({
         type: "user_disconnected",
-        value: {
-          publicId
-        }
+        value: { publicId }
       }, subRoom);
     }
   }
@@ -1289,12 +1278,12 @@ var Server = class {
     await awaitReturn(subRoom["onError"]?.(connection, error));
   }
   /**
-  * @method onRequest
-  * @async
-  * @param {Party.Request} req - The HTTP request to handle
-  * @description Handles HTTP requests, either directly from clients or forwarded by shards
-  * @returns {Promise<Response>} The response to return to the client
-  */
+   * @method onRequest
+   * @async
+   * @param {Party.Request} req - The HTTP request to handle
+   * @description Handles HTTP requests, either directly from clients or forwarded by shards
+   * @returns {Promise<Response>} The response to return to the client
+   */
   async onRequest(req) {
     const isFromShard = req.headers.has("x-forwarded-by-shard");
     const shardId = req.headers.get("x-shard-id");
@@ -1310,14 +1299,14 @@ var Server = class {
     return this.handleDirectRequest(req, res);
   }
   /**
-  * @method handleSessionRestore
-  * @private
-  * @async
-  * @param {Party.Request} req - The HTTP request for session restore
-  * @param {ServerResponse} res - The response object
-  * @description Handles session restoration from transfer data, creates session from privateId
-  * @returns {Promise<Response>} The response to return to the client
-  */
+   * @method handleSessionRestore
+   * @private
+   * @async
+   * @param {Party.Request} req - The HTTP request for session restore
+   * @param {ServerResponse} res - The response object
+   * @description Handles session restoration from transfer data, creates session from privateId
+   * @returns {Promise<Response>} The response to return to the client
+   */
   async handleSessionRestore(req, res) {
     try {
       const transferData = await req.json();
@@ -1342,14 +1331,16 @@ var Server = class {
         if (signal2 && usersPropName) {
           const { classType } = signal2.options;
           const user = isClass(classType) ? new classType() : classType();
-          const hydratedSnapshot = await awaitReturn(subRoom["onSessionRestore"]?.({
-            userSnapshot,
-            user,
-            publicId,
-            privateId,
-            sessionState,
-            room: this.room
-          })) ?? userSnapshot;
+          const hydratedSnapshot = await awaitReturn(
+            subRoom["onSessionRestore"]?.({
+              userSnapshot,
+              user,
+              publicId,
+              privateId,
+              sessionState,
+              room: this.room
+            })
+          ) ?? userSnapshot;
           signal2()[publicId] = user;
           load(user, hydratedSnapshot, true);
           await this.room.storage.put(`${usersPropName}.${publicId}`, userSnapshot);
@@ -1361,22 +1352,20 @@ var Server = class {
         publicId,
         restored: true
       });
-      return res.success({
-        transferToken
-      });
+      return res.success({ transferToken });
     } catch (error) {
       console.error("Error restoring session:", error);
       return res.serverError("Failed to restore session");
     }
   }
   /**
-  * @method handleDirectRequest
-  * @private
-  * @async
-  * @param {Party.Request} req - The HTTP request received directly from a client
-  * @description Processes requests received directly from clients
-  * @returns {Promise<Response>} The response to return to the client
-  */
+   * @method handleDirectRequest
+   * @private
+   * @async
+   * @param {Party.Request} req - The HTTP request received directly from a client
+   * @description Processes requests received directly from clients
+   * @returns {Promise<Response>} The response to return to the client
+   */
   async handleDirectRequest(req, res) {
     const subRoom = await this.getSubRoom();
     if (!subRoom) {
@@ -1400,14 +1389,14 @@ var Server = class {
     return res.success(legacyResponse);
   }
   /**
-  * @method tryMatchRequestHandler
-  * @private
-  * @async
-  * @param {Party.Request} req - The HTTP request to handle
-  * @param {Object} subRoom - The room instance
-  * @description Attempts to match the request to a registered @Request handler
-  * @returns {Promise<Response | null>} The response or null if no handler matched
-  */
+   * @method tryMatchRequestHandler
+   * @private
+   * @async
+   * @param {Party.Request} req - The HTTP request to handle
+   * @param {Object} subRoom - The room instance
+   * @description Attempts to match the request to a registered @Request handler
+   * @returns {Promise<Response | null>} The response or null if no handler matched
+   */
   async tryMatchRequestHandler(req, res, subRoom) {
     const requestHandlers = subRoom.constructor["_requestMetadata"];
     if (!requestHandlers) {
@@ -1415,8 +1404,7 @@ var Server = class {
     }
     const url = new URL(req.url);
     const method = req.method;
-    let pathname = url.pathname;
-    pathname = "/" + pathname.split("/").slice(4).join("/");
+    const pathname = this.normalizeRequestPath(url.pathname);
     for (const [routeKey, handler] of requestHandlers.entries()) {
       const firstColonIndex = routeKey.indexOf(":");
       const handlerMethod = routeKey.substring(0, firstColonIndex);
@@ -1437,23 +1425,20 @@ var Server = class {
           }
         }
         let bodyData = null;
-        if (handler.bodyValidation && [
-          "POST",
-          "PUT",
-          "PATCH"
-        ].includes(method)) {
+        if (handler.bodyValidation && ["POST", "PUT", "PATCH"].includes(method)) {
           try {
             const contentType = req.headers.get("content-type") || "";
-            if (contentType.includes("application/json")) {
-              const body = await req.json();
-              const validation = handler.bodyValidation.safeParse(body);
-              if (!validation.success) {
-                return res.badRequest("Invalid request body", {
-                  details: validation.error
-                });
-              }
-              bodyData = validation.data;
+            if (!contentType.includes("application/json")) {
+              return res.badRequest("Content-Type must be application/json");
             }
+            const body = await req.json();
+            const validation = handler.bodyValidation.safeParse(body);
+            if (!validation.success) {
+              return res.badRequest("Invalid request body", {
+                details: validation.error
+              });
+            }
+            bodyData = validation.data;
           } catch (error) {
             return res.badRequest("Failed to parse request body");
           }
@@ -1461,7 +1446,9 @@ var Server = class {
         try {
           req["data"] = bodyData;
           req["params"] = params;
-          const result = await awaitReturn(subRoom[handler.key](req, res));
+          const result = await awaitReturn(
+            subRoom[handler.key](req, res)
+          );
           if (result instanceof Response) {
             return result;
           }
@@ -1475,26 +1462,24 @@ var Server = class {
     return null;
   }
   /**
-  * @method pathMatches
-  * @private
-  * @param {string} requestPath - The path from the request
-  * @param {string} handlerPath - The path pattern from the handler
-  * @description Checks if a request path matches a handler path pattern
-  * @returns {boolean} True if the paths match
-  */
+   * @method pathMatches
+   * @private
+   * @param {string} requestPath - The path from the request
+   * @param {string} handlerPath - The path pattern from the handler
+   * @description Checks if a request path matches a handler path pattern
+   * @returns {boolean} True if the paths match
+   */
   pathMatches(requestPath, handlerPath) {
-    const pathRegexString = handlerPath.replace(/\//g, "\\/").replace(/:([^\/]+)/g, "([^/]+)");
-    const pathRegex = new RegExp(`^${pathRegexString}`);
-    return pathRegex.test(requestPath);
+    return this.pathPatternToRegex(handlerPath).test(requestPath);
   }
   /**
-  * @method extractPathParams
-  * @private
-  * @param {string} requestPath - The path from the request
-  * @param {string} handlerPath - The path pattern from the handler
-  * @description Extracts path parameters from the request path based on the handler pattern
-  * @returns {Object} An object containing the path parameters
-  */
+   * @method extractPathParams
+   * @private
+   * @param {string} requestPath - The path from the request
+   * @param {string} handlerPath - The path pattern from the handler
+   * @description Extracts path parameters from the request path based on the handler pattern
+   * @returns {Object} An object containing the path parameters
+   */
   extractPathParams(requestPath, handlerPath) {
     const params = {};
     const paramNames = [];
@@ -1503,8 +1488,7 @@ var Server = class {
         paramNames.push(segment.substring(1));
       }
     });
-    const pathRegexString = handlerPath.replace(/\//g, "\\/").replace(/:([^\/]+)/g, "([^/]+)");
-    const pathRegex = new RegExp(`^${pathRegexString}`);
+    const pathRegex = this.pathPatternToRegex(handlerPath);
     const matches = requestPath.match(pathRegex);
     if (matches && matches.length > 1) {
       for (let i = 0; i < paramNames.length; i++) {
@@ -1513,15 +1497,32 @@ var Server = class {
     }
     return params;
   }
+  normalizeRequestPath(pathname) {
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts[0] === "parties" && parts.length >= 3) {
+      const routePath = parts.slice(3).join("/");
+      return routePath ? `/${routePath}` : "/";
+    }
+    return pathname || "/";
+  }
+  pathPatternToRegex(handlerPath) {
+    const segments = handlerPath.split("/").map((segment) => {
+      if (segment.startsWith(":")) {
+        return "([^/]+)";
+      }
+      return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    });
+    return new RegExp(`^${segments.join("/")}$`);
+  }
   /**
-  * @method handleShardRequest
-  * @private
-  * @async
-  * @param {Party.Request} req - The HTTP request forwarded by a shard
-  * @param {string | null} shardId - The ID of the shard that forwarded the request
-  * @description Processes requests forwarded by shards, preserving client context
-  * @returns {Promise<Response>} The response to return to the shard (which will forward it to the client)
-  */
+   * @method handleShardRequest
+   * @private
+   * @async
+   * @param {Party.Request} req - The HTTP request forwarded by a shard
+   * @param {string | null} shardId - The ID of the shard that forwarded the request
+   * @description Processes requests forwarded by shards, preserving client context
+   * @returns {Promise<Response>} The response to return to the shard (which will forward it to the client)
+   */
   async handleShardRequest(req, res, shardId) {
     const subRoom = await this.getSubRoom();
     if (!subRoom) {
@@ -1548,13 +1549,13 @@ var Server = class {
     }
   }
   /**
-  * @method createEnhancedRequest
-  * @private
-  * @param {Party.Request} originalReq - The original request received from the shard
-  * @param {string | null} originalClientIp - The original client IP, if available
-  * @description Creates an enhanced request object that preserves the original client context
-  * @returns {Party.Request} The enhanced request object
-  */
+   * @method createEnhancedRequest
+   * @private
+   * @param {Party.Request} originalReq - The original request received from the shard
+   * @param {string | null} originalClientIp - The original client IP, if available
+   * @description Creates an enhanced request object that preserves the original client context
+   * @returns {Party.Request} The enhanced request object
+   */
   createEnhancedRequest(originalReq, originalClientIp) {
     const clonedReq = originalReq.clone();
     clonedReq.viaShard = true;
@@ -1567,18 +1568,6 @@ var Server = class {
 
 // src/shard.ts
 var Shard = class {
-  static {
-    __name(this, "Shard");
-  }
-  room;
-  ws;
-  connectionMap;
-  mainServerStub;
-  worldUrl;
-  worldId;
-  lastReportedConnections;
-  statsInterval;
-  statsIntervalId;
   constructor(room) {
     this.room = room;
     this.connectionMap = /* @__PURE__ */ new Map();
@@ -1701,9 +1690,7 @@ var Shard = class {
         })
       });
       if (!response2.ok) {
-        const errorData = await response2.json().catch(() => ({
-          error: "Unknown error"
-        }));
+        const errorData = await response2.json().catch(() => ({ error: "Unknown error" }));
         console.error(`Failed to update World stats: ${response2.status} - ${errorData.error || "Unknown error"}`);
         return false;
       }
@@ -1715,17 +1702,15 @@ var Shard = class {
     }
   }
   /**
-  * @method onRequest
-  * @async
-  * @param {Party.Request} req - The HTTP request to handle
-  * @description Forwards HTTP requests to the main server, preserving client context
-  * @returns {Promise<Response>} The response from the main server
-  */
+   * @method onRequest
+   * @async
+   * @param {Party.Request} req - The HTTP request to handle
+   * @description Forwards HTTP requests to the main server, preserving client context
+   * @returns {Promise<Response>} The response from the main server
+   */
   async onRequest(req) {
     if (!this.mainServerStub) {
-      return response(503, {
-        error: "Shard not connected to main server"
-      });
+      return response(503, { error: "Shard not connected to main server" });
     }
     try {
       const url = new URL(req.url);
@@ -1753,32 +1738,28 @@ var Shard = class {
       const response2 = await this.mainServerStub.fetch(path, requestInit);
       return response2;
     } catch (error) {
-      return response(500, {
-        error: "Error forwarding request"
-      });
+      return response(500, { error: "Error forwarding request" });
     }
   }
   /**
-  * @method onAlarm
-  * @async
-  * @description Executed periodically, used to perform maintenance tasks
-  */
+   * @method onAlarm
+   * @async
+   * @description Executed periodically, used to perform maintenance tasks
+   */
   async onAlarm() {
     await this.updateWorldStats();
   }
 };
 
 // src/testing.ts
-async function testRoom(Room3, options = {}) {
-  const createServer = /* @__PURE__ */ __name((io2) => {
+async function testRoom(Room2, options = {}) {
+  const createServer = (io2) => {
     const server2 = new Server(io2);
-    server2.rooms = [
-      Room3
-    ];
+    server2.rooms = [Room2];
     return server2;
-  }, "createServer");
+  };
   const isShard = options.shard || false;
-  const io = new ServerIo(Room3.path, isShard ? {
+  const io = new ServerIo(Room2.path, isShard ? {
     parties: {
       game: createServer,
       ...options.parties || {}
@@ -1790,9 +1771,9 @@ async function testRoom(Room3, options = {}) {
     partyFn: options.partyFn,
     env: options.env
   });
-  Room3.prototype.throttleSync = 0;
-  Room3.prototype.throttleStorage = 0;
-  Room3.prototype.options = options;
+  Room2.prototype.throttleSync = 0;
+  Room2.prototype.throttleStorage = 0;
+  Room2.prototype.options = options;
   let server;
   if (options.shard) {
     const shardServer = new Shard(io);
@@ -1817,41 +1798,31 @@ async function testRoom(Room3, options = {}) {
   return {
     server,
     room: server.subRoom,
-    createClient: /* @__PURE__ */ __name(async (id2, opts) => {
+    createClient: async (id2, opts) => {
       const client = await io.connection(server, id2, opts);
       return client;
-    }, "createClient"),
-    getServerUser: /* @__PURE__ */ __name(async (client, prop = "users") => {
+    },
+    getServerUser: async (client, prop = "users") => {
       const privateId = client.conn.id;
       const session = await server.getSession(privateId);
       return server.subRoom[prop]()[session?.publicId];
-    }, "getServerUser")
+    }
   };
 }
-__name(testRoom, "testRoom");
 async function request(room, path, options = {
   method: "GET"
 }) {
   const url = new URL("http://localhost" + path);
-  const request1 = new Request(url.toString(), options);
-  const response2 = await room.onRequest(request1);
+  const request2 = new Request(url.toString(), options);
+  const response2 = await room.onRequest(request2);
   return response2;
 }
-__name(request, "request");
 function tick(ms = 0) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-__name(tick, "tick");
 
 // src/mock.ts
 var MockPartyClient = class {
-  static {
-    __name(this, "MockPartyClient");
-  }
-  server;
-  events;
-  id;
-  conn;
   constructor(server, id2) {
     this.server = server;
     this.events = /* @__PURE__ */ new Map();
@@ -1887,12 +1858,7 @@ var MockPartyClient = class {
     return this.server.onMessage(JSON.stringify(data), this.conn);
   }
 };
-var MockLobby = class MockLobby2 {
-  static {
-    __name(this, "MockLobby");
-  }
-  server;
-  lobbyId;
+var MockLobby = class {
   constructor(server, lobbyId) {
     this.server = server;
     this.lobbyId = lobbyId;
@@ -1910,12 +1876,7 @@ var MockLobby = class MockLobby2 {
     return request(this.server, baseUrl + url, options);
   }
 };
-var MockContext = class MockContext2 {
-  static {
-    __name(this, "MockContext");
-  }
-  room;
-  parties;
+var MockContext = class {
   constructor(room, options = {}) {
     this.room = room;
     this.parties = {
@@ -1925,13 +1886,13 @@ var MockContext = class MockContext2 {
     if (options.partyFn) {
       const serverCache = /* @__PURE__ */ new Map();
       this.parties.main = {
-        get: /* @__PURE__ */ __name(async (lobbyId) => {
+        get: async (lobbyId) => {
           if (!serverCache.has(lobbyId)) {
             const server = await options.partyFn(lobbyId);
             serverCache.set(lobbyId, new MockLobby(server, lobbyId));
           }
           return serverCache.get(lobbyId);
-        }, "get")
+        }
       };
     } else {
       for (let lobbyId in parties) {
@@ -1941,15 +1902,7 @@ var MockContext = class MockContext2 {
     }
   }
 };
-var MockPartyRoom = class MockPartyRoom2 {
-  static {
-    __name(this, "MockPartyRoom");
-  }
-  id;
-  clients;
-  storage;
-  context;
-  env;
+var MockPartyRoom = class {
   constructor(id2, options = {}) {
     this.id = id2;
     this.clients = /* @__PURE__ */ new Map();
@@ -1977,9 +1930,7 @@ var MockPartyRoom = class MockPartyRoom2 {
         ...opts?.headers || {}
       }
     });
-    await server.onConnect(socket.conn, {
-      request: request2
-    });
+    await server.onConnect(socket.conn, { request: request2 });
     this.clients.set(socket.id, socket);
     return socket;
   }
@@ -1999,19 +1950,12 @@ var MockPartyRoom = class MockPartyRoom2 {
   }
 };
 var MockConnection = class {
-  static {
-    __name(this, "MockConnection");
-  }
-  client;
-  server;
-  id;
   constructor(client) {
     this.client = client;
     this.state = {};
     this.server = client.server;
     this.id = client.id;
   }
-  state;
   setState(value) {
     this.state = value;
   }
@@ -2030,17 +1974,8 @@ import { signal } from "@signe/reactive";
 import { sync, id, persist } from "@signe/sync";
 import { z as z2 } from "zod";
 
-// src/types/party.ts
-var party_exports = {};
-
 // src/jwt.ts
 var JWTAuth = class {
-  static {
-    __name(this, "JWTAuth");
-  }
-  secret;
-  encoder;
-  decoder;
   /**
    * Constructor for the JWTAuth class
    * @param {string} secret - The secret key used for signing and verifying tokens
@@ -2061,18 +1996,16 @@ var JWTAuth = class {
     const keyData = this.encoder.encode(this.secret);
     return await crypto.subtle.importKey(
       "raw",
+      // format
       keyData,
+      // key data
       {
         name: "HMAC",
-        hash: {
-          name: "SHA-256"
-        }
+        hash: { name: "SHA-256" }
       },
       false,
-      [
-        "sign",
-        "verify"
-      ]
+      // extractable
+      ["sign", "verify"]
       // key usages
     );
   }
@@ -2144,9 +2077,11 @@ var JWTAuth = class {
     const encodedPayload = this.base64UrlEncode(this.encoder.encode(JSON.stringify(fullPayload)));
     const signatureBase = `${encodedHeader}.${encodedPayload}`;
     const key = await this.getSecretKey();
-    const signature = await crypto.subtle.sign({
-      name: "HMAC"
-    }, key, this.encoder.encode(signatureBase));
+    const signature = await crypto.subtle.sign(
+      { name: "HMAC" },
+      key,
+      this.encoder.encode(signatureBase)
+    );
     const encodedSignature = this.base64UrlEncode(signature);
     return `${signatureBase}.${encodedSignature}`;
   }
@@ -2178,9 +2113,12 @@ var JWTAuth = class {
       const key = await this.getSecretKey();
       const signatureBase = `${encodedHeader}.${encodedPayload}`;
       const signature = this.base64UrlDecode(encodedSignature);
-      const isValid = await crypto.subtle.verify({
-        name: "HMAC"
-      }, key, signature, this.encoder.encode(signatureBase));
+      const isValid = await crypto.subtle.verify(
+        { name: "HMAC" },
+        key,
+        signature,
+        this.encoder.encode(signatureBase)
+      );
       if (!isValid) {
         throw new Error("Invalid signature");
       }
@@ -2195,7 +2133,7 @@ var JWTAuth = class {
 };
 
 // src/world.guard.ts
-var guardManageWorld = /* @__PURE__ */ __name(async (_, req, room) => {
+var guardManageWorld = async (_, req, room) => {
   const tokenShard = req.headers.get("x-access-shard");
   if (tokenShard) {
     if (tokenShard !== room.env.SHARD_SECRET) {
@@ -2218,46 +2156,22 @@ var guardManageWorld = /* @__PURE__ */ __name(async (_, req, room) => {
     return false;
   }
   return true;
-}, "guardManageWorld");
+};
 
 // src/world.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_ts_metadata");
 var MAX_PLAYERS_PER_SHARD = 75;
 var RoomConfigSchema = z2.object({
   name: z2.string(),
-  balancingStrategy: z2.enum([
-    "round-robin",
-    "least-connections",
-    "random"
-  ]),
+  balancingStrategy: z2.enum(["round-robin", "least-connections", "random"]),
   public: z2.boolean(),
   maxPlayersPerShard: z2.number().int().positive(),
   minShards: z2.number().int().min(0),
   maxShards: z2.number().int().positive().optional()
 });
-var RegisterShardSchema = z2.object({
-  shardId: z2.string(),
-  roomId: z2.string(),
-  url: z2.string().url(),
-  maxConnections: z2.number().int().positive()
-});
 var UpdateShardStatsSchema = z2.object({
+  shardId: z2.string(),
   connections: z2.number().int().min(0),
-  status: z2.enum([
-    "active",
-    "maintenance",
-    "draining"
-  ]).optional()
+  status: z2.enum(["active", "maintenance", "draining"]).optional()
 });
 var ScaleRoomSchema = z2.object({
   roomId: z2.string(),
@@ -2267,94 +2181,77 @@ var ScaleRoomSchema = z2.object({
     maxConnections: z2.number().int().positive()
   }).optional()
 });
-var RoomConfig = class RoomConfig2 {
-  static {
-    __name(this, "RoomConfig");
-  }
-  id;
-  name = signal("");
-  balancingStrategy = signal("round-robin");
-  public = signal(true);
-  maxPlayersPerShard = signal(MAX_PLAYERS_PER_SHARD);
-  minShards = signal(1);
-  maxShards = signal(void 0);
+var RoomConfig = class {
+  constructor() {
+    this.name = signal("");
+    this.balancingStrategy = signal("round-robin");
+    this.public = signal(true);
+    this.maxPlayersPerShard = signal(MAX_PLAYERS_PER_SHARD);
+    this.minShards = signal(1);
+    this.maxShards = signal(void 0);
+  }
 };
-_ts_decorate([
-  id(),
-  _ts_metadata("design:type", String)
-], RoomConfig.prototype, "id", void 0);
-_ts_decorate([
+__decorateClass([
+  id()
+], RoomConfig.prototype, "id", 2);
+__decorateClass([
   sync()
-], RoomConfig.prototype, "name", void 0);
-_ts_decorate([
+], RoomConfig.prototype, "name", 2);
+__decorateClass([
   sync()
-], RoomConfig.prototype, "balancingStrategy", void 0);
-_ts_decorate([
+], RoomConfig.prototype, "balancingStrategy", 2);
+__decorateClass([
   sync()
-], RoomConfig.prototype, "public", void 0);
-_ts_decorate([
+], RoomConfig.prototype, "public", 2);
+__decorateClass([
   sync()
-], RoomConfig.prototype, "maxPlayersPerShard", void 0);
-_ts_decorate([
+], RoomConfig.prototype, "maxPlayersPerShard", 2);
+__decorateClass([
   sync()
-], RoomConfig.prototype, "minShards", void 0);
-_ts_decorate([
+], RoomConfig.prototype, "minShards", 2);
+__decorateClass([
   sync()
-], RoomConfig.prototype, "maxShards", void 0);
-var ShardInfo = class ShardInfo2 {
-  static {
-    __name(this, "ShardInfo");
-  }
-  id;
-  roomId = signal("");
-  url = signal("");
-  currentConnections = signal(0);
-  maxConnections = signal(MAX_PLAYERS_PER_SHARD);
-  status = signal("active");
-  lastHeartbeat = signal(0);
+], RoomConfig.prototype, "maxShards", 2);
+var ShardInfo = class {
+  constructor() {
+    this.roomId = signal("");
+    this.url = signal("");
+    this.currentConnections = signal(0);
+    this.maxConnections = signal(MAX_PLAYERS_PER_SHARD);
+    this.status = signal("active");
+    this.lastHeartbeat = signal(0);
+  }
 };
-_ts_decorate([
-  id(),
-  _ts_metadata("design:type", String)
-], ShardInfo.prototype, "id", void 0);
-_ts_decorate([
+__decorateClass([
+  id()
+], ShardInfo.prototype, "id", 2);
+__decorateClass([
   sync()
-], ShardInfo.prototype, "roomId", void 0);
-_ts_decorate([
+], ShardInfo.prototype, "roomId", 2);
+__decorateClass([
   sync()
-], ShardInfo.prototype, "url", void 0);
-_ts_decorate([
+], ShardInfo.prototype, "url", 2);
+__decorateClass([
   sync({
     persist: false
   })
-], ShardInfo.prototype, "currentConnections", void 0);
-_ts_decorate([
+], ShardInfo.prototype, "currentConnections", 2);
+__decorateClass([
   sync()
-], ShardInfo.prototype, "maxConnections", void 0);
-_ts_decorate([
+], ShardInfo.prototype, "maxConnections", 2);
+__decorateClass([
   sync()
-], ShardInfo.prototype, "status", void 0);
-_ts_decorate([
+], ShardInfo.prototype, "status", 2);
+__decorateClass([
   sync()
-], ShardInfo.prototype, "lastHeartbeat", void 0);
+], ShardInfo.prototype, "lastHeartbeat", 2);
 var WorldRoom = class {
-  static {
-    __name(this, "WorldRoom");
-  }
-  room;
-  // Synchronized state
-  rooms;
-  shards;
-  // Only persisted state (not synced to clients)
-  rrCounters;
-  // Configuration
-  defaultShardUrlTemplate;
-  defaultMaxConnectionsPerShard;
   constructor(room) {
     this.room = room;
     this.rooms = signal({});
     this.shards = signal({});
     this.rrCounters = signal({});
+    // Configuration
     this.defaultShardUrlTemplate = signal("{shardId}");
     this.defaultMaxConnectionsPerShard = signal(MAX_PLAYERS_PER_SHARD);
     const { AUTH_JWT_SECRET, SHARD_SECRET } = this.room.env;
@@ -2392,9 +2289,14 @@ var WorldRoom = class {
     });
     setTimeout(() => this.cleanupInactiveShards(), 6e4);
   }
-  // Actions
-  async registerRoom(req) {
-    const roomConfig = await req.json();
+  async registerRoom(req, res) {
+    const roomConfigResult = RoomConfigSchema.safeParse(await req.json());
+    if (!roomConfigResult.success) {
+      return res?.badRequest("Invalid room configuration", {
+        details: roomConfigResult.error
+      });
+    }
+    const roomConfig = roomConfigResult.data;
     const roomId = roomConfig.name;
     if (!this.rooms()[roomId]) {
       const newRoom = new RoomConfig();
@@ -2421,7 +2323,13 @@ var WorldRoom = class {
     }
   }
   async updateShardStats(req, res) {
-    const body = await req.json();
+    const bodyResult = UpdateShardStatsSchema.safeParse(await req.json());
+    if (!bodyResult.success) {
+      return res.badRequest("Invalid shard statistics", {
+        details: bodyResult.error
+      });
+    }
+    const body = bodyResult.data;
     const { shardId, connections, status } = body;
     const shard = this.shards()[shardId];
     if (!shard) {
@@ -2434,7 +2342,13 @@ var WorldRoom = class {
     shard.lastHeartbeat.set(Date.now());
   }
   async scaleRoom(req, res) {
-    const data = await req.json();
+    const dataResult = ScaleRoomSchema.safeParse(await req.json());
+    if (!dataResult.success) {
+      return res.badRequest("Invalid scale request", {
+        details: dataResult.error
+      });
+    }
+    const data = dataResult.data;
     const { targetShardCount, shardTemplate, roomId } = data;
     const room = this.rooms()[roomId];
     if (!room) {
@@ -2449,14 +2363,11 @@ var WorldRoom = class {
       });
     }
     if (targetShardCount < previousShardCount) {
-      const shardsToRemove = [
-        ...roomShards
-      ].sort((a, b) => {
+      const shardsToRemove = [...roomShards].sort((a, b) => {
         if (a.status() === "draining" && b.status() !== "draining") return -1;
         if (a.status() !== "draining" && b.status() === "draining") return 1;
         return a.currentConnections() - b.currentConnections();
       }).slice(0, previousShardCount - targetShardCount);
-      const shardsToKeep = roomShards.filter((shard) => !shardsToRemove.some((s) => s.id === shard.id));
       for (const shard of shardsToRemove) {
         delete this.shards()[shard.id];
       }
@@ -2465,7 +2376,11 @@ var WorldRoom = class {
     if (targetShardCount > previousShardCount) {
       const newShards = [];
       for (let i = 0; i < targetShardCount - previousShardCount; i++) {
-        const newShard = await this.createShard(roomId, shardTemplate?.urlTemplate, shardTemplate?.maxConnections);
+        const newShard = await this.createShard(
+          roomId,
+          shardTemplate?.urlTemplate,
+          shardTemplate?.maxConnections
+        );
         if (newShard) {
           newShards.push(newShard);
         }
@@ -2507,26 +2422,22 @@ var WorldRoom = class {
     if (!room) {
       if (autoCreate) {
         const mockRequest = {
-          json: /* @__PURE__ */ __name(async () => ({
+          json: async () => ({
             name: roomId,
             balancingStrategy: "round-robin",
             public: true,
             maxPlayersPerShard: this.defaultMaxConnectionsPerShard(),
             minShards: 1,
             maxShards: void 0
-          }), "json")
+          })
         };
         await this.registerRoom(mockRequest);
         room = this.rooms()[roomId];
         if (!room) {
-          return {
-            error: `Failed to create room ${roomId}`
-          };
+          return { error: `Failed to create room ${roomId}` };
         }
       } else {
-        return {
-          error: `Room ${roomId} does not exist`
-        };
+        return { error: `Room ${roomId} does not exist` };
       }
     }
     const roomShards = Object.values(this.shards()).filter((shard) => shard.roomId() === roomId);
@@ -2539,27 +2450,24 @@ var WorldRoom = class {
             url: newShard.url()
           };
         } else {
-          return {
-            error: `Failed to create shard for room ${roomId}`
-          };
+          return { error: `Failed to create shard for room ${roomId}` };
         }
       } else {
-        return {
-          error: `No shards available for room ${roomId}`
-        };
+        return { error: `No shards available for room ${roomId}` };
       }
     }
     const activeShards = roomShards.filter((shard) => shard && shard.status() === "active");
     if (activeShards.length === 0) {
-      return {
-        error: `No active shards available for room ${roomId}`
-      };
+      return { error: `No active shards available for room ${roomId}` };
     }
     const balancingStrategy = room.balancingStrategy();
     let selectedShard;
     switch (balancingStrategy) {
       case "least-connections":
-        selectedShard = activeShards.reduce((min, shard) => shard.currentConnections() < min.currentConnections() ? shard : min, activeShards[0]);
+        selectedShard = activeShards.reduce(
+          (min, shard) => shard.currentConnections() < min.currentConnections() ? shard : min,
+          activeShards[0]
+        );
         break;
       case "random":
         selectedShard = activeShards[Math.floor(Math.random() * activeShards.length)];
@@ -2600,82 +2508,52 @@ var WorldRoom = class {
     return newShard;
   }
 };
-_ts_decorate([
+__decorateClass([
   sync(RoomConfig)
-], WorldRoom.prototype, "rooms", void 0);
-_ts_decorate([
+], WorldRoom.prototype, "rooms", 2);
+__decorateClass([
   sync(ShardInfo)
-], WorldRoom.prototype, "shards", void 0);
-_ts_decorate([
+], WorldRoom.prototype, "shards", 2);
+__decorateClass([
   persist()
-], WorldRoom.prototype, "rrCounters", void 0);
-_ts_decorate([
+], WorldRoom.prototype, "rrCounters", 2);
+__decorateClass([
   Request2({
     path: "register-room",
     method: "POST"
   }),
-  Guard([
-    guardManageWorld
-  ]),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0
-  ]),
-  _ts_metadata("design:returntype", Promise)
-], WorldRoom.prototype, "registerRoom", null);
-_ts_decorate([
+  Guard([guardManageWorld])
+], WorldRoom.prototype, "registerRoom", 1);
+__decorateClass([
   Request2({
     path: "update-shard",
     method: "POST"
   }),
-  Guard([
-    guardManageWorld
-  ]),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0,
-    typeof ServerResponse === "undefined" ? Object : ServerResponse
-  ]),
-  _ts_metadata("design:returntype", Promise)
-], WorldRoom.prototype, "updateShardStats", null);
-_ts_decorate([
+  Guard([guardManageWorld])
+], WorldRoom.prototype, "updateShardStats", 1);
+__decorateClass([
   Request2({
     path: "scale-room",
     method: "POST"
   }),
-  Guard([
-    guardManageWorld
-  ]),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0,
-    typeof ServerResponse === "undefined" ? Object : ServerResponse
-  ]),
-  _ts_metadata("design:returntype", Promise)
-], WorldRoom.prototype, "scaleRoom", null);
-_ts_decorate([
+  Guard([guardManageWorld])
+], WorldRoom.prototype, "scaleRoom", 1);
+__decorateClass([
   Request2({
     path: "connect",
     method: "POST"
-  }),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0,
-    typeof ServerResponse === "undefined" ? Object : ServerResponse
-  ]),
-  _ts_metadata("design:returntype", Promise)
-], WorldRoom.prototype, "connect", null);
-WorldRoom = _ts_decorate([
+  })
+], WorldRoom.prototype, "connect", 1);
+WorldRoom = __decorateClass([
   Room({
     path: "world-{worldId}",
     maxUsers: 100,
+    // Limit for admin connections
     throttleStorage: 2e3,
+    // Throttle storage updates (ms)
     throttleSync: 500
-  }),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0
-  ])
+    // Throttle sync updates (ms)
+  })
 ], WorldRoom);
 
 // src/session.guard.ts
@@ -2700,8 +2578,7 @@ function createRequireSessionGuard(storage) {
     }
   };
 }
-__name(createRequireSessionGuard, "createRequireSessionGuard");
-var requireSession = /* @__PURE__ */ __name(async (sender, value, room) => {
+var requireSession = async (sender, value, room) => {
   if (!sender || !sender.id) {
     return false;
   }
@@ -2719,7 +2596,7 @@ var requireSession = /* @__PURE__ */ __name(async (sender, value, room) => {
     console.error("Error checking session in requireSession guard:", error);
     return false;
   }
-}, "requireSession");
+};
 export {
   Action,
   ClientIo,
@@ -2732,6 +2609,7 @@ export {
   ServerIo,
   ServerResponse,
   Shard,
+  UnhandledAction,
   WorldRoom,
   createRequireSessionGuard,
   request,