@signe/room 1.4.2 → 2.0.1

package/dist/index.js

@@ -14,6 +14,23 @@ function Action(name, bodyValidation) {
   };
 }
 __name(Action, "Action");
+function Request2(options, bodyValidation) {
+  return function(target, propertyKey) {
+    if (!target.constructor._requestMetadata) {
+      target.constructor._requestMetadata = /* @__PURE__ */ new Map();
+    }
+    const path = options.path.startsWith("/") ? options.path : `/${options.path}`;
+    const method = options.method || "GET";
+    const routeKey = `${method}:${path}`;
+    target.constructor._requestMetadata.set(routeKey, {
+      key: propertyKey,
+      path,
+      method,
+      bodyValidation
+    });
+  };
+}
+__name(Request2, "Request");
 function Room(options) {
   return function(target) {
     target.path = options.path;
@@ -108,6 +125,35 @@ var MockPartyClient = class {
     return this.server.onMessage(JSON.stringify(data), this.conn);
   }
 };
+var MockLobby = class MockLobby2 {
+  static {
+    __name(this, "MockLobby");
+  }
+  server;
+  constructor(server) {
+    this.server = server;
+  }
+  socket() {
+    return new MockPartyClient(this.server);
+  }
+};
+var MockContext = class MockContext2 {
+  static {
+    __name(this, "MockContext");
+  }
+  room;
+  parties;
+  constructor(room, options = {}) {
+    this.room = room;
+    this.parties = {
+      main: /* @__PURE__ */ new Map()
+    };
+    const parties = options.parties || {};
+    for (let lobbyId in parties) {
+      this.parties.main.set(lobbyId, new MockLobby(parties[lobbyId](room)));
+    }
+  }
+};
 var MockPartyRoom = class MockPartyRoom2 {
   static {
     __name(this, "MockPartyRoom");
@@ -115,18 +161,30 @@ var MockPartyRoom = class MockPartyRoom2 {
   id;
   clients;
   storage;
+  context;
   env;
-  constructor(id) {
-    this.id = id;
+  constructor(id2, options = {}) {
+    this.id = id2;
     this.clients = /* @__PURE__ */ new Map();
     this.storage = new Storage();
     this.env = {};
-    this.id = id || generateShortUUID();
+    this.id = id2 || generateShortUUID();
+    this.context = new MockContext(this, {
+      parties: options.parties || {}
+    });
+    this.env = options.env || {};
   }
   async connection(server) {
     const socket = new MockPartyClient(server);
+    const url = new URL("http://localhost");
+    const request2 = new Request(url.toString(), {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
     await server.onConnect(socket.conn, {
-      request: {}
+      request: request2
     });
     this.clients.set(socket.id, socket);
     return socket;
@@ -136,11 +194,11 @@ var MockPartyRoom = class MockPartyRoom2 {
       client._trigger("message", data);
     });
   }
-  getConnection(id) {
-    return this.clients.get(id);
+  getConnection(id2) {
+    return this.clients.get(id2);
   }
   getConnections() {
-    return this.clients;
+    return Array.from(this.clients.values()).map((client) => client.conn);
   }
   clear() {
     this.clients.clear();
@@ -258,6 +316,266 @@ 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"
+    }
+  });
+}
+__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.interceptors = interceptors;
+  }
+  /**
+   * Sets the status code for the response
+   * @param code HTTP status code
+   * @returns this instance for chaining
+   */
+  status(code) {
+    this.statusCode = code;
+    return this;
+  }
+  /**
+   * Sets the response body and returns this instance (chainable method)
+   * 
+   * @param body Response body
+   * @returns this instance for chaining
+   */
+  body(body) {
+    this.responseBody = body;
+    return this;
+  }
+  /**
+   * Adds a header to the response
+   * @param name Header name
+   * @param value Header value
+   * @returns this instance for chaining
+   */
+  header(name, value) {
+    this.responseHeaders[name] = value;
+    return this;
+  }
+  /**
+   * Adds multiple headers to the response
+   * @param headers Object containing headers
+   * @returns this instance for chaining
+   */
+  setHeaders(headers) {
+    this.responseHeaders = {
+      ...this.responseHeaders,
+      ...headers
+    };
+    return this;
+  }
+  /**
+   * Add an interceptor to the chain
+   * @param interceptor Function that takes a Response and returns a modified Response
+   * @returns this instance for chaining
+   */
+  use(interceptor) {
+    this.interceptors.push(interceptor);
+    return this;
+  }
+  /**
+   * Builds and returns the Response object after applying all interceptors
+   * @returns Promise<Response> The final Response object
+   * @private Internal method used by terminal methods
+   */
+  async buildResponse() {
+    let response2 = new Response(JSON.stringify(this.responseBody), {
+      status: this.statusCode,
+      headers: this.responseHeaders
+    });
+    for (const interceptor of this.interceptors) {
+      try {
+        const interceptedResponse = interceptor(response2);
+        if (interceptedResponse instanceof Promise) {
+          response2 = await interceptedResponse;
+        } else {
+          response2 = interceptedResponse;
+        }
+      } catch (error) {
+        console.error("Error in interceptor:", error);
+      }
+    }
+    return response2;
+  }
+  /**
+   * Sets the response body to the JSON-stringified version of the provided value
+   * and sends the response (terminal method)
+   * 
+   * @param body Response body to be JSON stringified
+   * @returns Promise<Response> The final Response object
+   */
+  async json(body) {
+    this.responseBody = body;
+    this.responseHeaders["Content-Type"] = "application/json";
+    return this.buildResponse();
+  }
+  /**
+   * Sends the response with the current configuration (terminal method)
+   * 
+   * @param body Optional body to set before sending
+   * @returns Promise<Response> The final Response object
+   */
+  async send(body) {
+    if (body !== void 0) {
+      this.responseBody = body;
+    }
+    return this.buildResponse();
+  }
+  /**
+   * Sends a plain text response (terminal method)
+   * 
+   * @param text Text to send
+   * @returns Promise<Response> The final Response object
+   */
+  async text(text) {
+    this.responseBody = text;
+    this.responseHeaders["Content-Type"] = "text/plain";
+    let response2 = new Response(text, {
+      status: this.statusCode,
+      headers: this.responseHeaders
+    });
+    for (const interceptor of this.interceptors) {
+      try {
+        const interceptedResponse = interceptor(response2);
+        if (interceptedResponse instanceof Promise) {
+          response2 = await interceptedResponse;
+        } else {
+          response2 = interceptedResponse;
+        }
+      } catch (error) {
+        console.error("Error in interceptor:", error);
+      }
+    }
+    return response2;
+  }
+  /**
+   * Redirects to the specified URL (terminal method)
+   * 
+   * @param url URL to redirect to
+   * @param statusCode HTTP status code (default: 302)
+   * @returns Promise<Response> The final Response object
+   */
+  async redirect(url, statusCode = 302) {
+    this.statusCode = statusCode;
+    this.responseHeaders["Location"] = url;
+    return this.buildResponse();
+  }
+  /**
+   * Creates a success response with status 200
+   * @param body Response body
+   * @returns Promise<Response> The final Response object
+   */
+  async success(body = {}) {
+    return this.status(200).json(body);
+  }
+  /**
+   * Creates an error response with status 400
+   * @param message Error message
+   * @param details Additional error details
+   * @returns Promise<Response> The final Response object
+   */
+  async badRequest(message, details = {}) {
+    return this.status(400).json({
+      error: message,
+      ...details
+    });
+  }
+  /**
+   * Creates an error response with status 403
+   * @param message Error message
+   * @returns Promise<Response> The final Response object
+   */
+  async notPermitted(message = "Not permitted") {
+    return this.status(403).json({
+      error: message
+    });
+  }
+  /**
+   * Creates an error response with status 401
+   * @param message Error message
+   * @returns Promise<Response> The final Response object
+   */
+  async unauthorized(message = "Unauthorized") {
+    return this.status(401).json({
+      error: message
+    });
+  }
+  /**
+   * Creates an error response with status 404
+   * @param message Error message
+   * @returns Promise<Response> The final Response object
+   */
+  async notFound(message = "Not found") {
+    return this.status(404).json({
+      error: message
+    });
+  }
+  /**
+   * Creates an error response with status 500
+   * @param message Error message
+   * @returns Promise<Response> The final Response object
+   */
+  async serverError(message = "Internal Server Error") {
+    return this.status(500).json({
+      error: message
+    });
+  }
+};
+
+// src/request/cors.ts
+function cors(res, options = {}) {
+  const newHeaders = new Headers(res.headers);
+  newHeaders.set("Access-Control-Allow-Origin", options.origin || "*");
+  if (options.credentials) {
+    newHeaders.set("Access-Control-Allow-Credentials", "true");
+  }
+  if (options.exposedHeaders && options.exposedHeaders.length) {
+    newHeaders.set("Access-Control-Expose-Headers", options.exposedHeaders.join(", "));
+  }
+  if (options.methods && options.methods.length) {
+    newHeaders.set("Access-Control-Allow-Methods", options.methods.join(", "));
+  } else {
+    newHeaders.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+  }
+  if (options.allowedHeaders && options.allowedHeaders.length) {
+    newHeaders.set("Access-Control-Allow-Headers", options.allowedHeaders.join(", "));
+  } else {
+    newHeaders.set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With");
+  }
+  if (options.maxAge) {
+    newHeaders.set("Access-Control-Max-Age", options.maxAge.toString());
+  }
+  return new Response(res.body, {
+    status: res.status,
+    headers: newHeaders
+  });
+}
+__name(cors, "cors");
+function createCorsInterceptor(options = {}) {
+  return (res) => cors(res, options);
+}
+__name(createCorsInterceptor, "createCorsInterceptor");
 
 // src/server.ts
 var Message = z.object({
@@ -302,6 +620,22 @@ var Server = class {
   get roomStorage() {
     return this.room.storage;
   }
+  async send(conn, obj, subRoom) {
+    obj = structuredClone(obj);
+    if (subRoom.interceptorPacket) {
+      const signal2 = this.getUsersProperty(subRoom);
+      const { publicId } = conn.state;
+      const user = signal2?.()[publicId];
+      obj = await awaitReturn(subRoom["interceptorPacket"]?.(user, obj, conn));
+      if (obj === null) return;
+    }
+    conn.send(JSON.stringify(obj));
+  }
+  broadcast(obj, subRoom) {
+    for (let conn of this.room.getConnections()) {
+      this.send(conn, obj, subRoom);
+    }
+  }
   /**
   * @method onStart
   * @async
@@ -415,10 +749,10 @@ var Server = class {
         return;
       }
       const packet = buildObject(values, instance.$memoryAll);
-      this.room.broadcast(JSON.stringify({
+      this.broadcast({
         type: "sync",
         value: packet
-      }));
+      }, instance);
       values.clear();
     }, "syncCb");
     const persistCb = /* @__PURE__ */ __name(async (values) => {
@@ -526,23 +860,7 @@ var Server = class {
   async deleteSession(privateId) {
     await this.room.storage.delete(`session:${privateId}`);
   }
-  /**
-  * @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) {
+  async onConnectClient(conn, ctx) {
     const subRoom = await this.getSubRoom({
       getMemoryAll: true
     });
@@ -565,13 +883,13 @@ var Server = class {
     const existingSession = await this.getSession(conn.id);
     const publicId = existingSession?.publicId || generateShortUUID2();
     let user = null;
-    const signal = this.getUsersProperty(subRoom);
+    const signal2 = this.getUsersProperty(subRoom);
     const usersPropName = this.getUsersPropName(subRoom);
-    if (signal) {
-      const { classType } = signal.options;
+    if (signal2) {
+      const { classType } = signal2.options;
       if (!existingSession?.publicId) {
         user = isClass(classType) ? new classType() : classType(conn, ctx);
-        signal()[publicId] = user;
+        signal2()[publicId] = user;
         const snapshot = createStatesSnapshot(user);
         this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
       }
@@ -585,33 +903,70 @@ var Server = class {
     }
     await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
     conn.setState({
+      ...conn.state,
       publicId
     });
-    conn.send(JSON.stringify({
+    this.send(conn, {
       type: "sync",
       value: {
         pId: publicId,
         ...subRoom.$memoryAll
       }
-    }));
+    }, subRoom);
   }
   /**
-  * @method onMessage
+  * @method onConnect
   * @async
-  * @param {string} message - The message received from a user.
-  * @param {Party.Connection} sender - The connection object of the sender.
-  * @description Processes incoming messages and triggers corresponding actions in the sub-room.
+  * @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.onMessage = async (message, sender) => {
-  *   await server.onMessage(message, sender);
-  *   console.log("Message processed from:", sender.id);
+  * 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);
+    } else {
+      await this.onConnectClient(conn, ctx);
+    }
+  }
+  /**
+  * @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({
+      shard: true,
+      shardId,
+      clients: /* @__PURE__ */ new Map()
+      // Track clients connected through this shard
+    });
+  }
+  /**
+  * @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);
+      return;
+    }
     let json;
     try {
       json = JSON.parse(message);
@@ -625,16 +980,16 @@ var Server = class {
     const subRoom = await this.getSubRoom();
     const roomGuards = subRoom.constructor["_roomGuards"] || [];
     for (const guard of roomGuards) {
-      const isAuthorized = await guard(sender, result.data.value);
+      const isAuthorized = await guard(sender, result.data.value, this.room);
       if (!isAuthorized) {
         return;
       }
     }
     const actions = subRoom.constructor["_actionMetadata"];
     if (actions) {
-      const signal = this.getUsersProperty(subRoom);
+      const signal2 = this.getUsersProperty(subRoom);
       const { publicId } = sender.state;
-      const user = signal?.()[publicId];
+      const user = signal2?.()[publicId];
       const actionName = actions.get(result.data.action);
       if (actionName) {
         const guards = subRoom.constructor["_actionGuards"]?.get(actionName.key) || [];
@@ -655,6 +1010,173 @@ var Server = class {
     }
   }
   /**
+  * @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 {
+      parsedMessage = JSON.parse(message);
+    } catch (e) {
+      console.error("Error parsing shard message:", e);
+      return;
+    }
+    const shardState = shardConnection.state;
+    const clients = shardState.clients;
+    switch (parsedMessage.type) {
+      case "shard.clientConnected":
+        await this.handleShardClientConnect(parsedMessage, shardConnection);
+        break;
+      case "shard.clientMessage":
+        await this.handleShardClientMessage(parsedMessage, shardConnection);
+        break;
+      case "shard.clientDisconnected":
+        await this.handleShardClientDisconnect(parsedMessage, shardConnection);
+        break;
+      default:
+        console.warn(`Unknown shard message type: ${parsedMessage.type}`);
+    }
+  }
+  /**
+  * @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, connectionInfo } = message;
+    const shardState = shardConnection.state;
+    const virtualContext = {
+      request: {
+        headers: new Headers({
+          "x-forwarded-for": connectionInfo.ip,
+          "user-agent": connectionInfo.userAgent
+        }),
+        method: "GET",
+        url: ""
+      }
+    };
+    const virtualConnection = {
+      id: privateId,
+      send: /* @__PURE__ */ __name((data) => {
+        shardConnection.send(JSON.stringify({
+          targetClientId: privateId,
+          data
+        }));
+      }, "send"),
+      state: {},
+      setState: /* @__PURE__ */ __name((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(() => {
+        shardConnection.send(JSON.stringify({
+          type: "shard.closeClient",
+          privateId
+        }));
+        if (shardState.clients) {
+          shardState.clients.delete(privateId);
+        }
+      }, "close")
+    };
+    if (!shardState.clients.has(privateId)) {
+      shardState.clients.set(privateId, {});
+    }
+    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>}
+  */
+  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
+      });
+    }
+    const virtualConnection = {
+      id: privateId,
+      send: /* @__PURE__ */ __name((data) => {
+        shardConnection.send(JSON.stringify({
+          targetClientId: privateId,
+          data
+        }));
+      }, "send"),
+      state: clients.get(privateId),
+      setState: /* @__PURE__ */ __name((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(() => {
+        shardConnection.send(JSON.stringify({
+          type: "shard.closeClient",
+          privateId
+        }));
+        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>}
+  */
+  async handleShardClientDisconnect(message, shardConnection) {
+    const { privateId, publicId } = message;
+    const shardState = shardConnection.state;
+    const clients = shardState.clients;
+    const clientState = clients.get(privateId);
+    if (!clientState) {
+      console.warn(`Disconnection for unknown client ${privateId}`);
+      return;
+    }
+    const virtualConnection = {
+      id: privateId,
+      send: /* @__PURE__ */ __name(() => {
+      }, "send"),
+      state: clientState,
+      setState: /* @__PURE__ */ __name(() => {
+        return {};
+      }, "setState"),
+      close: /* @__PURE__ */ __name(() => {
+      }, "close")
+    };
+    await this.onClose(virtualConnection);
+    clients.delete(privateId);
+  }
+  /**
   * @method onClose
   * @async
   * @param {Party.Connection} conn - The connection object of the disconnecting user.
@@ -674,22 +1196,22 @@ var Server = class {
     if (!subRoom) {
       return;
     }
-    const signal = this.getUsersProperty(subRoom);
+    const signal2 = this.getUsersProperty(subRoom);
     if (!conn.state) {
       return;
     }
     const privateId = conn.id;
     const { publicId } = conn.state;
-    const user = signal?.()[publicId];
+    const user = signal2?.()[publicId];
     if (!user) return;
     await awaitReturn(subRoom["onLeave"]?.(user, conn));
     await this.updateSessionConnection(privateId, false);
-    this.room.broadcast(JSON.stringify({
+    this.broadcast({
       type: "user_disconnected",
       value: {
         publicId
       }
-    }));
+    }, subRoom);
   }
   async onAlarm() {
     const subRoom = await this.getSubRoom();
@@ -699,41 +1221,440 @@ var Server = class {
     const subRoom = await this.getSubRoom();
     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
+  */
   async onRequest(req) {
+    const isFromShard = req.headers.has("x-forwarded-by-shard");
+    const shardId = req.headers.get("x-shard-id");
+    const res = new ServerResponse([
+      createCorsInterceptor()
+    ]);
+    if (isFromShard) {
+      return this.handleShardRequest(req, res, shardId);
+    }
+    return this.handleDirectRequest(req, res);
+  }
+  /**
+  * @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();
-    const res = /* @__PURE__ */ __name((body, status) => {
-      return new Response(JSON.stringify(body), {
-        status
-      });
-    }, "res");
     if (!subRoom) {
-      return res({
-        error: "Not found"
-      }, 404);
+      return res.notFound();
+    }
+    const response2 = await this.tryMatchRequestHandler(req, res, subRoom);
+    if (response2) {
+      return response2;
     }
-    const response = await awaitReturn(subRoom["onRequest"]?.(req, this.room));
-    if (!response) {
-      return res({
-        error: "Not found"
-      }, 404);
+    const legacyResponse = await awaitReturn(subRoom["onRequest"]?.(req, res));
+    if (!legacyResponse) {
+      return res.notFound();
     }
-    if (response instanceof Response) {
-      return response;
+    if (legacyResponse instanceof Response) {
+      return legacyResponse;
+    }
+    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
+  */
+  async tryMatchRequestHandler(req, res, subRoom) {
+    const requestHandlers = subRoom.constructor["_requestMetadata"];
+    if (!requestHandlers) {
+      return null;
     }
-    return res(response, 200);
+    const url = new URL(req.url);
+    const method = req.method;
+    let pathname = url.pathname;
+    pathname = "/" + pathname.split("/").slice(4).join("/");
+    for (const [routeKey, handler] of requestHandlers.entries()) {
+      const firstColonIndex = routeKey.indexOf(":");
+      const handlerMethod = routeKey.substring(0, firstColonIndex);
+      const handlerPath = routeKey.substring(firstColonIndex + 1);
+      if (handlerMethod !== method) {
+        continue;
+      }
+      if (this.pathMatches(pathname, handlerPath)) {
+        const params = this.extractPathParams(pathname, handlerPath);
+        const guards = subRoom.constructor["_actionGuards"]?.get(handler.key) || [];
+        for (const guard of guards) {
+          const isAuthorized = await guard(null, req, this.room);
+          if (isAuthorized instanceof Response) {
+            return isAuthorized;
+          }
+          if (!isAuthorized) {
+            return res.notPermitted();
+          }
+        }
+        let bodyData = null;
+        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;
+            }
+          } catch (error) {
+            return res.badRequest("Failed to parse request body");
+          }
+        }
+        try {
+          req["data"] = bodyData;
+          req["params"] = params;
+          const result = await awaitReturn(subRoom[handler.key](req, res));
+          if (result instanceof Response) {
+            return result;
+          }
+          return res.success(result);
+        } catch (error) {
+          console.error("Error executing request handler:", error);
+          return res.serverError();
+        }
+      }
+    }
+    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
+  */
+  pathMatches(requestPath, handlerPath) {
+    const pathRegexString = handlerPath.replace(/\//g, "\\/").replace(/:([^\/]+)/g, "([^/]+)");
+    const pathRegex = new RegExp(`^${pathRegexString}$`);
+    return pathRegex.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
+  */
+  extractPathParams(requestPath, handlerPath) {
+    const params = {};
+    const paramNames = [];
+    handlerPath.split("/").forEach((segment) => {
+      if (segment.startsWith(":")) {
+        paramNames.push(segment.substring(1));
+      }
+    });
+    const pathRegexString = handlerPath.replace(/\//g, "\\/").replace(/:([^\/]+)/g, "([^/]+)");
+    const pathRegex = new RegExp(`^${pathRegexString}$`);
+    const matches = requestPath.match(pathRegex);
+    if (matches && matches.length > 1) {
+      for (let i = 0; i < paramNames.length; i++) {
+        params[paramNames[i]] = matches[i + 1];
+      }
+    }
+    return params;
+  }
+  /**
+  * @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) {
+      return res.notFound();
+    }
+    const originalClientIp = req.headers.get("x-original-client-ip");
+    const enhancedReq = this.createEnhancedRequest(req, originalClientIp);
+    try {
+      const response2 = await this.tryMatchRequestHandler(enhancedReq, res, subRoom);
+      if (response2) {
+        return response2;
+      }
+      const legacyResponse = await awaitReturn(subRoom["onRequest"]?.(enhancedReq, res));
+      if (!legacyResponse) {
+        return res.notFound();
+      }
+      if (legacyResponse instanceof Response) {
+        return legacyResponse;
+      }
+      return res.success(legacyResponse);
+    } catch (error) {
+      console.error(`Error processing request from shard ${shardId}:`, error);
+      return res.serverError();
+    }
+  }
+  /**
+  * @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;
+    if (originalClientIp) {
+      clonedReq.originalClientIp = originalClientIp;
+    }
+    return clonedReq;
+  }
+};
+
+// 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();
+    this.worldUrl = null;
+    this.worldId = "default";
+    this.lastReportedConnections = 0;
+    this.statsInterval = 3e4;
+    this.statsIntervalId = null;
+  }
+  async onStart() {
+    const roomId = this.room.id.split(":")[0];
+    const roomStub = this.room.context.parties.main.get(roomId);
+    if (!roomStub) {
+      console.warn("No room room stub found in main party context");
+      return;
+    }
+    this.mainServerStub = roomStub;
+    this.ws = await roomStub.socket({
+      headers: {
+        "x-shard-id": this.room.id
+      }
+    });
+    this.ws.addEventListener("message", (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        if (message.targetClientId) {
+          const clientConn = this.connectionMap.get(message.targetClientId);
+          if (clientConn) {
+            delete message.targetClientId;
+            clientConn.send(message.data);
+          }
+        } else {
+          this.room.broadcast(event.data);
+        }
+      } catch (error) {
+        console.error("Error processing message from main server:", error);
+      }
+    });
+    await this.updateWorldStats();
+    this.startPeriodicStatsUpdates();
+  }
+  startPeriodicStatsUpdates() {
+    if (!this.worldUrl) {
+      return;
+    }
+    if (this.statsIntervalId) {
+      clearInterval(this.statsIntervalId);
+    }
+    this.statsIntervalId = setInterval(() => {
+      this.updateWorldStats().catch((error) => {
+        console.error("Error in periodic stats update:", error);
+      });
+    }, this.statsInterval);
+  }
+  stopPeriodicStatsUpdates() {
+    if (this.statsIntervalId) {
+      clearInterval(this.statsIntervalId);
+      this.statsIntervalId = null;
+    }
+  }
+  onConnect(conn, ctx) {
+    this.connectionMap.set(conn.id, conn);
+    this.ws.send(JSON.stringify({
+      type: "shard.clientConnected",
+      privateId: conn.id,
+      connectionInfo: {
+        ip: ctx.request?.headers.get("x-forwarded-for") || "unknown",
+        userAgent: ctx.request?.headers.get("user-agent") || "unknown"
+      }
+    }));
+    this.updateWorldStats();
+  }
+  onMessage(message, sender) {
+    try {
+      const parsedMessage = typeof message === "string" ? JSON.parse(message) : message;
+      const wrappedMessage = JSON.stringify({
+        type: "shard.clientMessage",
+        privateId: sender.id,
+        publicId: sender.state?.publicId,
+        payload: parsedMessage
+      });
+      this.ws.send(wrappedMessage);
+    } catch (error) {
+      console.error("Error forwarding message to main server:", error);
+    }
+  }
+  onClose(conn) {
+    this.connectionMap.delete(conn.id);
+    this.ws.send(JSON.stringify({
+      type: "shard.clientDisconnected",
+      privateId: conn.id,
+      publicId: conn.state?.publicId
+    }));
+    this.updateWorldStats();
+  }
+  async updateWorldStats() {
+    const currentConnections = this.connectionMap.size;
+    if (currentConnections === this.lastReportedConnections) {
+      return true;
+    }
+    try {
+      const worldRoom = this.room.context.parties.world.get("world-default");
+      const response2 = await worldRoom.fetch("/update-shard", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-access-shard": this.room.env.SHARD_SECRET
+        },
+        body: JSON.stringify({
+          shardId: this.room.id,
+          connections: currentConnections
+        })
+      });
+      if (!response2.ok) {
+        const errorData = await response2.json().catch(() => ({
+          error: "Unknown error"
+        }));
+        console.error(`Failed to update World stats: ${response2.status} - ${errorData.error || "Unknown error"}`);
+        return false;
+      }
+      this.lastReportedConnections = currentConnections;
+      return true;
+    } catch (error) {
+      console.error("Error updating World stats:", error);
+      return false;
+    }
+  }
+  /**
+  * @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"
+      });
+    }
+    try {
+      const url = new URL(req.url);
+      const path = url.pathname;
+      const method = req.method;
+      let body = null;
+      if (method !== "GET" && method !== "HEAD") {
+        body = await req.text();
+      }
+      const headers = new Headers();
+      req.headers.forEach((value, key) => {
+        headers.set(key, value);
+      });
+      headers.set("x-shard-id", this.room.id);
+      headers.set("x-forwarded-by-shard", "true");
+      const clientIp = req.headers.get("x-forwarded-for") || "unknown";
+      if (clientIp) {
+        headers.set("x-original-client-ip", clientIp);
+      }
+      const requestInit = {
+        method,
+        headers,
+        body
+      };
+      const response2 = await this.mainServerStub.fetch(path, requestInit);
+      return response2;
+    } catch (error) {
+      return response(500, {
+        error: "Error forwarding request"
+      });
+    }
+  }
+  /**
+  * @method onAlarm
+  * @async
+  * @description Executed periodically, used to perform maintenance tasks
+  */
+  async onAlarm() {
+    await this.updateWorldStats();
   }
 };
 
 // src/testing.ts
-async function testRoom(Room2, options = {}) {
-  const io = new ServerIo(Room2.path);
-  Room2.prototype.throttleSync = 0;
-  Room2.prototype.throttleStorage = 0;
-  Room2.prototype.options = options;
-  const server = new Server(io);
-  server.rooms = [
-    Room2
-  ];
+async function testRoom(Room3, options = {}) {
+  const createServer = /* @__PURE__ */ __name((io2) => {
+    const server2 = new Server(io2);
+    server2.rooms = [
+      Room3
+    ];
+    return server2;
+  }, "createServer");
+  const isShard = options.shard || false;
+  const io = new ServerIo(Room3.path, isShard ? {
+    parties: {
+      game: createServer
+    },
+    env: options.env
+  } : {
+    env: options.env
+  });
+  Room3.prototype.throttleSync = 0;
+  Room3.prototype.throttleStorage = 0;
+  Room3.prototype.options = options;
+  let server;
+  if (options.shard) {
+    const shardServer = new Shard(io);
+    shardServer.subRoom = null;
+    server = shardServer;
+  } else {
+    server = await createServer(io);
+  }
   await server.onStart();
   return {
     server,
@@ -745,15 +1666,682 @@ async function testRoom(Room2, options = {}) {
   };
 }
 __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);
+  return response2;
+}
+__name(request, "request");
+
+// src/world.ts
+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
+   */
+  constructor(secret) {
+    if (!secret || typeof secret !== "string") {
+      throw new Error("Secret is required and must be a string");
+    }
+    this.secret = secret;
+    this.encoder = new TextEncoder();
+    this.decoder = new TextDecoder();
+  }
+  /**
+   * Convert the secret to a CryptoKey for HMAC operations
+   * @returns {Promise<CryptoKey>} - The CryptoKey for HMAC operations
+   */
+  async getSecretKey() {
+    const keyData = this.encoder.encode(this.secret);
+    return await crypto.subtle.importKey(
+      "raw",
+      keyData,
+      {
+        name: "HMAC",
+        hash: {
+          name: "SHA-256"
+        }
+      },
+      false,
+      [
+        "sign",
+        "verify"
+      ]
+      // key usages
+    );
+  }
+  /**
+   * Base64Url encode a buffer
+   * @param {ArrayBuffer} buffer - The buffer to encode
+   * @returns {string} - The base64url encoded string
+   */
+  base64UrlEncode(buffer) {
+    const base64 = btoa(String.fromCharCode(...new Uint8Array(buffer)));
+    return base64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  }
+  /**
+   * Base64Url decode a string
+   * @param {string} base64Url - The base64url encoded string
+   * @returns {ArrayBuffer} - The decoded buffer
+   */
+  base64UrlDecode(base64Url) {
+    const padding = "=".repeat((4 - base64Url.length % 4) % 4);
+    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/") + padding;
+    const rawData = atob(base64);
+    const buffer = new Uint8Array(rawData.length);
+    for (let i = 0; i < rawData.length; i++) {
+      buffer[i] = rawData.charCodeAt(i);
+    }
+    return buffer.buffer;
+  }
+  /**
+   * Sign a payload and create a JWT token
+   * @param {JWTPayload} payload - The payload to include in the token
+   * @param {JWTOptions} [options={}] - Options for the token
+   * @param {string | number} [options.expiresIn='1h'] - Token expiration time
+   * @returns {Promise<string>} - The JWT token
+   */
+  async sign(payload, options = {}) {
+    if (!payload || typeof payload !== "object") {
+      throw new Error("Payload must be an object");
+    }
+    const expiresIn = options.expiresIn || "1h";
+    let exp;
+    if (typeof expiresIn === "number") {
+      exp = Math.floor(Date.now() / 1e3) + expiresIn;
+    } else if (typeof expiresIn === "string") {
+      const match = expiresIn.match(/^(\d+)([smhd])$/);
+      if (match) {
+        const value = parseInt(match[1]);
+        const unit = match[2];
+        const seconds = {
+          "s": value,
+          "m": value * 60,
+          "h": value * 60 * 60,
+          "d": value * 60 * 60 * 24
+        }[unit];
+        exp = Math.floor(Date.now() / 1e3) + seconds;
+      } else {
+        throw new Error('Invalid expiresIn format. Use a number (seconds) or a string like "1h", "30m", etc.');
+      }
+    }
+    const fullPayload = {
+      ...payload,
+      iat: Math.floor(Date.now() / 1e3),
+      exp
+    };
+    const header = {
+      alg: "HS256",
+      typ: "JWT"
+    };
+    const encodedHeader = this.base64UrlEncode(this.encoder.encode(JSON.stringify(header)));
+    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 encodedSignature = this.base64UrlEncode(signature);
+    return `${signatureBase}.${encodedSignature}`;
+  }
+  /**
+   * Verify a JWT token and return the decoded payload
+   * @param {string} token - The JWT token to verify
+   * @returns {Promise<JWTPayload>} - The decoded payload if verification succeeds
+   * @throws {Error} - If verification fails
+   */
+  async verify(token) {
+    if (!token || typeof token !== "string") {
+      throw new Error("Token is required and must be a string");
+    }
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      throw new Error("Invalid token format");
+    }
+    const [encodedHeader, encodedPayload, encodedSignature] = parts;
+    try {
+      const header = JSON.parse(this.decoder.decode(this.base64UrlDecode(encodedHeader)));
+      const payload = JSON.parse(this.decoder.decode(this.base64UrlDecode(encodedPayload)));
+      if (header.alg !== "HS256") {
+        throw new Error(`Unsupported algorithm: ${header.alg}`);
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      if (payload.exp && payload.exp < now) {
+        throw new Error("Token has expired");
+      }
+      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));
+      if (!isValid) {
+        throw new Error("Invalid signature");
+      }
+      return payload;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Token verification failed: ${error.message}`);
+      }
+      throw new Error("Token verification failed: Unknown error");
+    }
+  }
+};
+
+// src/world.guard.ts
+var guardManageWorld = /* @__PURE__ */ __name(async (_, req, room) => {
+  const tokenShard = req.headers.get("x-access-shard");
+  if (tokenShard) {
+    if (tokenShard !== room.env.SHARD_SECRET) {
+      return false;
+    }
+    return true;
+  }
+  const url = new URL(req.url);
+  const token = req.headers.get("Authorization") ?? url.searchParams.get("world-auth-token");
+  if (!token) {
+    return false;
+  }
+  const jwt = new JWTAuth(room.env.AUTH_JWT_SECRET);
+  try {
+    const payload = await jwt.verify(token);
+    if (!payload) {
+      return false;
+    }
+  } catch (error) {
+    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 RoomConfigSchema = z2.object({
+  name: z2.string(),
+  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({
+  connections: z2.number().int().min(0),
+  status: z2.enum([
+    "active",
+    "maintenance",
+    "draining"
+  ]).optional()
+});
+var ScaleRoomSchema = z2.object({
+  roomId: z2.string(),
+  targetShardCount: z2.number().int().positive(),
+  shardTemplate: z2.object({
+    urlTemplate: z2.string(),
+    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(100);
+  minShards = signal(1);
+  maxShards = signal(void 0);
+};
+_ts_decorate([
+  id(),
+  _ts_metadata("design:type", String)
+], RoomConfig.prototype, "id", void 0);
+_ts_decorate([
+  sync()
+], RoomConfig.prototype, "name", void 0);
+_ts_decorate([
+  sync()
+], RoomConfig.prototype, "balancingStrategy", void 0);
+_ts_decorate([
+  sync()
+], RoomConfig.prototype, "public", void 0);
+_ts_decorate([
+  sync()
+], RoomConfig.prototype, "maxPlayersPerShard", void 0);
+_ts_decorate([
+  sync()
+], RoomConfig.prototype, "minShards", void 0);
+_ts_decorate([
+  sync()
+], RoomConfig.prototype, "maxShards", void 0);
+var ShardInfo = class ShardInfo2 {
+  static {
+    __name(this, "ShardInfo");
+  }
+  id;
+  roomId = signal("");
+  url = signal("");
+  currentConnections = signal(0);
+  maxConnections = signal(100);
+  status = signal("active");
+  lastHeartbeat = signal(0);
+};
+_ts_decorate([
+  id(),
+  _ts_metadata("design:type", String)
+], ShardInfo.prototype, "id", void 0);
+_ts_decorate([
+  sync()
+], ShardInfo.prototype, "roomId", void 0);
+_ts_decorate([
+  sync()
+], ShardInfo.prototype, "url", void 0);
+_ts_decorate([
+  sync({
+    persist: false
+  })
+], ShardInfo.prototype, "currentConnections", void 0);
+_ts_decorate([
+  sync()
+], ShardInfo.prototype, "maxConnections", void 0);
+_ts_decorate([
+  sync()
+], ShardInfo.prototype, "status", void 0);
+_ts_decorate([
+  sync()
+], ShardInfo.prototype, "lastHeartbeat", void 0);
+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({});
+    this.defaultShardUrlTemplate = signal("{shardId}");
+    this.defaultMaxConnectionsPerShard = signal(100);
+    const { AUTH_JWT_SECRET, SHARD_SECRET } = this.room.env;
+    if (!AUTH_JWT_SECRET) {
+      throw new Error("AUTH_JWT_SECRET env variable is not set");
+    }
+    if (!SHARD_SECRET) {
+      throw new Error("SHARD_SECRET env variable is not set");
+    }
+    setTimeout(() => this.cleanupInactiveShards(), 6e4);
+  }
+  async onJoin(user, conn, ctx) {
+    const canConnect = await guardManageWorld(user, ctx.request, this.room);
+    conn.setState({
+      ...conn.state,
+      isAdmin: canConnect
+    });
+  }
+  interceptorPacket(_, obj, conn) {
+    if (!conn.state["isAdmin"]) {
+      return null;
+    }
+    return obj;
+  }
+  // Helper methods
+  cleanupInactiveShards() {
+    const now = Date.now();
+    const timeout = 5 * 60 * 1e3;
+    const shardsValue = this.shards();
+    let hasChanges = false;
+    Object.values(shardsValue).forEach((shard) => {
+      if (now - shard.lastHeartbeat() > timeout) {
+        delete this.shards()[shard.id];
+        hasChanges = true;
+      }
+    });
+    setTimeout(() => this.cleanupInactiveShards(), 6e4);
+  }
+  // Actions
+  async registerRoom(req) {
+    const roomConfig = await req.json();
+    const roomId = roomConfig.name;
+    if (!this.rooms()[roomId]) {
+      const newRoom = new RoomConfig();
+      newRoom.id = roomId;
+      newRoom.name.set(roomConfig.name);
+      newRoom.balancingStrategy.set(roomConfig.balancingStrategy);
+      newRoom.public.set(roomConfig.public);
+      newRoom.maxPlayersPerShard.set(roomConfig.maxPlayersPerShard);
+      newRoom.minShards.set(roomConfig.minShards);
+      newRoom.maxShards.set(roomConfig.maxShards);
+      this.rooms()[roomId] = newRoom;
+      if (roomConfig.minShards > 0) {
+        for (let i = 0; i < roomConfig.minShards; i++) {
+          await this.createShard(roomId);
+        }
+      }
+    } else {
+      const room = this.rooms()[roomId];
+      room.balancingStrategy.set(roomConfig.balancingStrategy);
+      room.public.set(roomConfig.public);
+      room.maxPlayersPerShard.set(roomConfig.maxPlayersPerShard);
+      room.minShards.set(roomConfig.minShards);
+      room.maxShards.set(roomConfig.maxShards);
+    }
+  }
+  async updateShardStats(req, res) {
+    const body = await req.json();
+    const { shardId, connections, status } = body;
+    const shard = this.shards()[shardId];
+    if (!shard) {
+      return res.notFound(`Shard ${shardId} not found`);
+    }
+    shard.currentConnections.set(connections);
+    if (status) {
+      shard.status.set(status);
+    }
+    shard.lastHeartbeat.set(Date.now());
+  }
+  async scaleRoom(req, res) {
+    const data = await req.json();
+    const { targetShardCount, shardTemplate, roomId } = data;
+    const room = this.rooms()[roomId];
+    if (!room) {
+      return res.notFound(`Room ${roomId} does not exist`);
+    }
+    const roomShards = Object.values(this.shards()).filter((shard) => shard.roomId() === roomId);
+    const previousShardCount = roomShards.length;
+    if (room.maxShards() !== void 0 && targetShardCount > room.maxShards()) {
+      return res.badRequest(`Cannot scale beyond maximum allowed shards (${room.maxShards()})`, {
+        roomId,
+        currentShardCount: previousShardCount
+      });
+    }
+    if (targetShardCount < previousShardCount) {
+      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];
+      }
+      return;
+    }
+    if (targetShardCount > previousShardCount) {
+      const newShards = [];
+      for (let i = 0; i < targetShardCount - previousShardCount; i++) {
+        const newShard = await this.createShard(roomId, shardTemplate?.urlTemplate, shardTemplate?.maxConnections);
+        if (newShard) {
+          newShards.push(newShard);
+        }
+      }
+    }
+  }
+  async connect(req, res) {
+    try {
+      let data;
+      try {
+        const body = await req.text();
+        if (!body || body.trim() === "") {
+          return res.badRequest("Request body is empty");
+        }
+        data = JSON.parse(body);
+      } catch (parseError) {
+        return res.badRequest("Invalid JSON in request body");
+      }
+      if (!data.roomId) {
+        return res.badRequest("roomId parameter is required");
+      }
+      const autoCreate = data.autoCreate !== void 0 ? data.autoCreate : true;
+      const result = await this.findOptimalShard(data.roomId, autoCreate);
+      if ("error" in result) {
+        return res.notFound(result.error);
+      }
+      return res.success({
+        success: true,
+        shardId: result.shardId,
+        url: result.url
+      });
+    } catch (error) {
+      console.error("Error connecting to shard:", error);
+      return res.serverError();
+    }
+  }
+  async findOptimalShard(roomId, autoCreate = true) {
+    let room = this.rooms()[roomId];
+    if (!room) {
+      if (autoCreate) {
+        const mockRequest = {
+          json: /* @__PURE__ */ __name(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}`
+          };
+        }
+      } else {
+        return {
+          error: `Room ${roomId} does not exist`
+        };
+      }
+    }
+    const roomShards = Object.values(this.shards()).filter((shard) => shard.roomId() === roomId);
+    if (roomShards.length === 0) {
+      if (autoCreate) {
+        const newShard = await this.createShard(roomId);
+        if (newShard) {
+          return {
+            shardId: newShard.id,
+            url: newShard.url()
+          };
+        } else {
+          return {
+            error: `Failed to create shard for room ${roomId}`
+          };
+        }
+      } else {
+        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}`
+      };
+    }
+    const balancingStrategy = room.balancingStrategy();
+    let selectedShard;
+    switch (balancingStrategy) {
+      case "least-connections":
+        selectedShard = activeShards.reduce((min, shard) => shard.currentConnections() < min.currentConnections() ? shard : min, activeShards[0]);
+        break;
+      case "random":
+        selectedShard = activeShards[Math.floor(Math.random() * activeShards.length)];
+        break;
+      case "round-robin":
+      default:
+        const counter = this.rrCounters()[roomId] || 0;
+        const nextCounter = (counter + 1) % activeShards.length;
+        this.rrCounters()[roomId] = nextCounter;
+        selectedShard = activeShards[counter];
+        break;
+    }
+    return {
+      shardId: selectedShard.id,
+      url: selectedShard.url()
+    };
+  }
+  // Private methods
+  async createShard(roomId, urlTemplate, maxConnections) {
+    const room = this.rooms()[roomId];
+    if (!room) {
+      console.error(`Cannot create shard for non-existent room: ${roomId}`);
+      return null;
+    }
+    const shardId = `${roomId}:${Date.now()}-${Math.floor(Math.random() * 1e4)}`;
+    const template = urlTemplate || this.defaultShardUrlTemplate();
+    const url = template.replace("{shardId}", shardId).replace("{roomId}", roomId);
+    const max = maxConnections || room.maxPlayersPerShard();
+    const newShard = new ShardInfo();
+    newShard.id = shardId;
+    newShard.roomId.set(roomId);
+    newShard.url.set(url);
+    newShard.maxConnections.set(max);
+    newShard.currentConnections.set(0);
+    newShard.status.set("active");
+    newShard.lastHeartbeat.set(Date.now());
+    this.shards()[shardId] = newShard;
+    return newShard;
+  }
+};
+_ts_decorate([
+  sync(RoomConfig)
+], WorldRoom.prototype, "rooms", void 0);
+_ts_decorate([
+  sync(ShardInfo)
+], WorldRoom.prototype, "shards", void 0);
+_ts_decorate([
+  persist()
+], WorldRoom.prototype, "rrCounters", void 0);
+_ts_decorate([
+  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([
+  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([
+  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([
+  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([
+  Room({
+    path: "world-{worldId}",
+    maxUsers: 100,
+    throttleStorage: 2e3,
+    throttleSync: 500
+  }),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0
+  ])
+], WorldRoom);
 export {
   Action,
   ClientIo,
   Guard,
   MockConnection,
+  Request2 as Request,
   Room,
   RoomGuard,
   Server,
   ServerIo,
+  ServerResponse,
+  Shard,
+  WorldRoom,
+  request,
   testRoom
 };
 //# sourceMappingURL=index.js.map