@rpgjs/client 5.0.0-alpha.10 → 5.0.0-alpha.12

package/dist/index22.js

@@ -1,114 +1,2613 @@
-import { __name } from './index29.js';
-import { load } from './index18.js';
-import { PartySocket } from './index37.js';
-import './index38.js';
+import { dset } from './index35.js';
+import z from './index36.js';
+import { createStatesSnapshot, syncClass, generateShortUUID as generateShortUUID$1, load, id, sync, persist, getByPath, DELETE_TOKEN } from './index19.js';
+import { signal } from './index37.js';
 
-function createConnection(options, roomInstance) {
-  const conn = new PartySocket(options);
-  conn.addEventListener("message", (event) => {
-    const object = JSON.parse(event.data);
-    switch (object.type) {
-      case "sync":
-        load(roomInstance, object.value, true);
-        break;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/decorators.ts
+function Action(name, bodyValidation) {
+  return function(target, propertyKey) {
+    if (!target.constructor._actionMetadata) {
+      target.constructor._actionMetadata = /* @__PURE__ */ new Map();
     }
-  });
-  return {
-    emit: /* @__PURE__ */ __name((key, value) => {
-      conn.send(JSON.stringify({
-        action: key,
-        value
-      }));
-    }, "emit"),
-    on: /* @__PURE__ */ __name((key, cb) => {
-      conn.addEventListener("message", (event) => {
-        const object = JSON.parse(event.data);
-        if (object.type === key) {
-          cb(object.value);
-        }
-      });
-    }, "on"),
-    off: /* @__PURE__ */ __name((key, cb) => {
-      conn.removeEventListener("message", (event) => {
-        const object = JSON.parse(event.data);
-        if (object.type === key) {
-          cb(object.value);
+    target.constructor._actionMetadata.set(name, {
+      key: propertyKey,
+      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;
+    target.prototype.maxUsers = options.maxUsers;
+    target.prototype.throttleStorage = options.throttleStorage;
+    target.prototype.throttleSync = options.throttleSync;
+    target.prototype.sessionExpiryTime = options.sessionExpiryTime ?? 5 * 60 * 1e3;
+    if (options.guards) {
+      target["_roomGuards"] = options.guards;
+    }
+  };
+}
+__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
+      ];
+    }
+    target.constructor["_actionGuards"].set(propertyKey, guards);
+  };
+}
+__name(Guard, "Guard");
+
+// ../sync/src/utils.ts
+function generateShortUUID() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let uuid = "";
+  for (let i = 0; i < 8; i++) {
+    const randomIndex = Math.floor(Math.random() * chars.length);
+    uuid += chars[randomIndex];
+  }
+  return uuid;
+}
+__name(generateShortUUID, "generateShortUUID");
+
+// src/storage.ts
+var Storage = class {
+  static {
+    __name(this, "Storage");
+  }
+  memory = /* @__PURE__ */ new Map();
+  async put(key, value) {
+    this.memory.set(key, value);
+  }
+  async get(key) {
+    return this.memory.get(key);
+  }
+  async delete(key) {
+    this.memory.delete(key);
+  }
+  async list() {
+    return this.memory;
+  }
+};
+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;
+  return function(...args) {
+    if (!timeout) {
+      func(...args);
+      timeout = setTimeout(() => {
+        if (lastArgs) {
+          func(...lastArgs);
+          lastArgs = null;
         }
-      });
-    }, "off"),
-    close: /* @__PURE__ */ __name(() => conn.close(), "close"),
-    conn
+        timeout = null;
+      }, wait);
+    } else {
+      lastArgs = args;
+    }
   };
 }
-__name(createConnection, "createConnection");
-async function connectionRoom(options, roomInstance) {
-  return createConnection(options, roomInstance);
-}
-__name(connectionRoom, "connectionRoom");
-async function connectionWorld(options, roomInstance) {
-  const shardInfo = await getOptimalShard(options);
-  const result = createConnection({
-    ...options,
-    party: "shard",
-    room: shardInfo.url
-  }, roomInstance);
-  return {
-    ...result,
-    shardInfo
+__name(throttle, "throttle");
+function extractParams(pattern, str) {
+  const regexPattern = pattern.replace(/{(\w+)}/g, "(?<$1>[\\w-]+)");
+  const regex = new RegExp(`^${regexPattern}$`);
+  const match = regex.exec(str);
+  if (match && match.groups) {
+    return match.groups;
+  } else if (pattern === str) {
+    return {};
+  } else {
+    return null;
+  }
+}
+__name(extractParams, "extractParams");
+function dremove(obj, keys) {
+  if (typeof keys === "string") {
+    keys = keys.split(".");
+  }
+  let i = 0;
+  const l = keys.length;
+  let t = obj;
+  let k;
+  while (i < l - 1) {
+    k = keys[i++];
+    if (k === "__proto__" || k === "constructor" || k === "prototype") return;
+    if (typeof t[k] !== "object" || t[k] === null) return;
+    t = t[k];
+  }
+  k = keys[i];
+  if (t && typeof t === "object" && !(k === "__proto__" || k === "constructor" || k === "prototype")) {
+    delete t[k];
+  }
+}
+__name(dremove, "dremove");
+function buildObject(valuesMap, allMemory) {
+  let memoryObj = {};
+  for (let path of valuesMap.keys()) {
+    const value = valuesMap.get(path);
+    dset(memoryObj, path, value);
+    if (value === "$delete") {
+      dremove(allMemory, path);
+    } else {
+      dset(allMemory, path, value);
+    }
+  }
+  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);
+  const requestOrigin = options.origin || "*";
+  newHeaders.set("Access-Control-Allow-Origin", requestOrigin);
+  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());
+  } else {
+    newHeaders.set("Access-Control-Max-Age", "86400");
+  }
+  return new Response(res.body, {
+    status: res.status,
+    headers: newHeaders
+  });
+}
+__name(cors, "cors");
+function createCorsInterceptor(options = {}) {
+  return (res) => cors(res, options);
 }
-__name(connectionWorld, "connectionWorld");
-async function getOptimalShard(worldOptions) {
-  const {
-    host,
-    room,
-    worldId = "world-default",
-    retryCount = 3,
-    retryDelay = 1e3,
-    autoCreate = true
-    // Default to true for auto-creation
-  } = worldOptions;
-  let attempts = 0;
-  const url = new URL(`${host}/parties/world/${encodeURIComponent(worldId)}/connect`);
-  const requestUrl = url.toString();
-  while (attempts < retryCount) {
+__name(createCorsInterceptor, "createCorsInterceptor");
+
+// src/server.ts
+var Message = z.object({
+  action: z.string(),
+  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(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");
+  * }
+  * ```
+  */
+  get isHibernate() {
+    return !!this["options"]?.hibernate;
+  }
+  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
+  * @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 garbageCollector(options) {
+    const subRoom = await this.getSubRoom();
+    if (!subRoom) return;
+    const activeConnections = [
+      ...this.room.getConnections()
+    ];
+    const activePrivateIds = new Set(activeConnections.map((conn) => conn.id));
     try {
-      const response = await fetch(requestUrl, {
+      const sessions = await this.room.storage.list();
+      const users = this.getUsersProperty(subRoom);
+      const usersPropName = this.getUsersPropName(subRoom);
+      const validPublicIds = /* @__PURE__ */ new Set();
+      const expiredPublicIds = /* @__PURE__ */ new Set();
+      const SESSION_EXPIRY_TIME = options.sessionExpiryTime;
+      const now = Date.now();
+      for (const [key, session] of sessions) {
+        if (!key.startsWith("session:")) continue;
+        const privateId = key.replace("session:", "");
+        const typedSession = session;
+        if (!activePrivateIds.has(privateId) && !typedSession.connected && now - typedSession.created > SESSION_EXPIRY_TIME) {
+          await this.deleteSession(privateId);
+          expiredPublicIds.add(typedSession.publicId);
+        } else if (typedSession && typedSession.publicId) {
+          validPublicIds.add(typedSession.publicId);
+        }
+      }
+      if (users && usersPropName) {
+        const currentUsers = users();
+        for (const publicId in currentUsers) {
+          if (expiredPublicIds.has(publicId) && !validPublicIds.has(publicId)) {
+            delete currentUsers[publicId];
+            await this.room.storage.delete(`${usersPropName}.${publicId}`);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error in garbage collector:", error);
+    }
+  }
+  /**
+  * @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;
+    let initPersist = true;
+    for (let room of this.rooms) {
+      const params = extractParams(room.path, this.room.id);
+      if (params) {
+        instance = new room(this.room, params);
+        break;
+      }
+    }
+    if (!instance) {
+      return null;
+    }
+    const loadMemory = /* @__PURE__ */ __name(async () => {
+      const root = await this.room.storage.get(".");
+      const memory = await this.room.storage.list();
+      const tmpObject = root || {};
+      for (let [key, value] of memory) {
+        if (key.startsWith("session:")) {
+          continue;
+        }
+        if (key == ".") {
+          continue;
+        }
+        dset(tmpObject, key, value);
+      }
+      load(instance, tmpObject, true);
+    }, "loadMemory");
+    instance.$memoryAll = {};
+    instance.$send = (conn, obj) => {
+      return this.send(conn, obj, instance);
+    };
+    instance.$broadcast = (obj) => {
+      return this.broadcast(obj, instance);
+    };
+    instance.$sessionTransfer = async (userOrPublicId, targetRoomId) => {
+      let user;
+      let publicId = null;
+      const signal2 = this.getUsersProperty(instance);
+      if (!signal2) {
+        console.error("[sessionTransfer] `users` property not defined in the room.");
+        return null;
+      }
+      if (typeof userOrPublicId === "string") {
+        publicId = userOrPublicId;
+        user = signal2()[publicId];
+        if (!user) {
+          console.error(`[sessionTransfer] User with publicId ${publicId} not found.`);
+          return null;
+        }
+      } else {
+        user = userOrPublicId;
+        const users = signal2();
+        for (const [id2, u] of Object.entries(users)) {
+          if (u === user) {
+            publicId = id2;
+            break;
+          }
+        }
+        if (!publicId && user && typeof user === "object") {
+          for (const [id2, u] of Object.entries(users)) {
+            if (u && typeof u === "object") {
+              if (u.constructor === user.constructor) {
+                publicId = id2;
+                break;
+              }
+            }
+          }
+        }
+        if (!publicId) {
+          console.error("[sessionTransfer] User not found in users collection.", {
+            userType: user?.constructor?.name,
+            userKeys: user ? Object.keys(user) : "null",
+            usersCount: Object.keys(users).length,
+            userIds: Object.keys(users)
+          });
+          return null;
+        }
+      }
+      const sessions = await this.room.storage.list();
+      let userSession = null;
+      let privateId = null;
+      for (const [key, session] of sessions) {
+        if (key.startsWith("session:") && session.publicId === publicId) {
+          userSession = session;
+          privateId = key.replace("session:", "");
+          break;
+        }
+      }
+      if (!userSession || !privateId) {
+        console.error(`[sessionTransfer] Session for publicId ${publicId} not found.`);
+        return null;
+      }
+      const usersPropName = this.getUsersPropName(instance);
+      if (!usersPropName) {
+        console.error("[sessionTransfer] `users` property not defined in the room.");
+        return null;
+      }
+      const userSnapshot = createStatesSnapshot(user);
+      const transferData = {
+        privateId,
+        userSnapshot,
+        sessionState: userSession.state,
+        publicId
+      };
+      try {
+        const targetRoomParty = this.room.context.parties.main.get(targetRoomId);
+        const response2 = await targetRoomParty.fetch("/session-transfer", {
+          method: "POST",
+          body: JSON.stringify(transferData),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response2.ok) {
+          throw new Error(`Transfer request failed: ${await response2.text()}`);
+        }
+        const { transferToken } = await response2.json();
+        await this.deleteSession(privateId);
+        await this.room.storage.delete(`${usersPropName}.${publicId}`);
+        const currentUsers = signal2();
+        if (currentUsers[publicId]) {
+          delete currentUsers[publicId];
+        }
+        return transferToken;
+      } catch (error) {
+        console.error(`[sessionTransfer] Failed to transfer session to room ${targetRoomId}:`, error);
+        return null;
+      }
+    };
+    const syncCb = /* @__PURE__ */ __name((values) => {
+      if (options.getMemoryAll) {
+        buildObject(values, instance.$memoryAll);
+      }
+      if (init && this.isHibernate) {
+        init = false;
+        return;
+      }
+      const packet = buildObject(values, instance.$memoryAll);
+      this.broadcast({
+        type: "sync",
+        value: packet
+      }, instance);
+      values.clear();
+    }, "syncCb");
+    const persistCb = /* @__PURE__ */ __name(async (values) => {
+      if (initPersist) {
+        values.clear();
+        return;
+      }
+      for (let [path, value] of values) {
+        const _instance = path == "." ? instance : getByPath(instance, path);
+        const itemValue = createStatesSnapshot(_instance);
+        if (value == DELETE_TOKEN) {
+          await this.room.storage.delete(path);
+        } else {
+          await this.room.storage.put(path, itemValue);
+        }
+      }
+      values.clear();
+    }, "persistCb");
+    syncClass(instance, {
+      onSync: throttle(syncCb, instance["throttleSync"] ?? 500),
+      onPersist: throttle(persistCb, instance["throttleStorage"] ?? 2e3)
+    });
+    await loadMemory();
+    initPersist = false;
+    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);
+  * }
+  * ```
+  */
+  async getSubRoom(options = {}) {
+    let subRoom;
+    if (this.isHibernate) {
+      subRoom = await this.createRoom(options);
+    } else {
+      subRoom = this.subRoom;
+    }
+    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);
+  * }
+  * ```
+  */
+  getUsersProperty(subRoom) {
+    const meta = subRoom.constructor["_propertyMetadata"];
+    const propId = meta?.get("users");
+    if (propId) {
+      return subRoom[propId];
+    }
+    return null;
+  }
+  getUsersPropName(subRoom) {
+    if (!subRoom) return null;
+    const metadata = subRoom.constructor._propertyMetadata;
+    if (!metadata) return null;
+    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
+  */
+  getUserConnectionProperty(user) {
+    if (!user) return null;
+    const metadata = user.constructor._propertyMetadata;
+    if (!metadata) return null;
+    const connectedPropName = metadata.get("connected");
+    if (!connectedPropName) return null;
+    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
+  */
+  updateUserConnectionStatus(user, isConnected) {
+    const connectionSignal = this.getUserConnectionProperty(user);
+    if (connectionSignal) {
+      connectionSignal.set(isConnected);
+      return true;
+    }
+    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);
+  * ```
+  */
+  async getSession(privateId) {
+    if (!privateId) return null;
+    try {
+      const session = await this.room.storage.get(`session:${privateId}`);
+      return session;
+    } catch (e) {
+      return null;
+    }
+  }
+  async saveSession(privateId, data) {
+    const sessionData = {
+      ...data,
+      created: data.created || Date.now(),
+      connected: data.connected !== void 0 ? data.connected : true
+    };
+    await this.room.storage.put(`session:${privateId}`, sessionData);
+  }
+  async updateSessionConnection(privateId, connected) {
+    const session = await this.getSession(privateId);
+    if (session) {
+      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");
+  * ```
+  */
+  async deleteSession(privateId) {
+    await this.room.storage.delete(`session:${privateId}`);
+  }
+  async onConnectClient(conn, ctx) {
+    const subRoom = await this.getSubRoom({
+      getMemoryAll: true
+    });
+    if (!subRoom) {
+      conn.close();
+      return;
+    }
+    const sessionExpiryTime = subRoom.constructor.sessionExpiryTime;
+    await this.garbageCollector({
+      sessionExpiryTime
+    });
+    const roomGuards = subRoom.constructor["_roomGuards"] || [];
+    for (const guard of roomGuards) {
+      const isAuthorized = await guard(conn, ctx, this.room);
+      if (!isAuthorized) {
+        conn.close();
+        return;
+      }
+    }
+    let transferToken = null;
+    if (ctx.request?.url) {
+      const url = new URL(ctx.request.url);
+      transferToken = url.searchParams.get("transferToken");
+    }
+    let transferData = null;
+    if (transferToken) {
+      transferData = await this.room.storage.get(`transfer:${transferToken}`);
+      if (transferData) {
+        await this.room.storage.delete(`transfer:${transferToken}`);
+      }
+    }
+    const existingSession = await this.getSession(conn.id);
+    const publicId = existingSession?.publicId || transferData?.publicId || generateShortUUID$1();
+    let user = null;
+    const signal2 = this.getUsersProperty(subRoom);
+    const usersPropName = this.getUsersPropName(subRoom);
+    if (signal2) {
+      const { classType } = signal2.options;
+      if (!existingSession?.publicId) {
+        if (transferData?.restored && signal2()[publicId]) {
+          user = signal2()[publicId];
+        } else {
+          user = isClass(classType) ? new classType() : classType(conn, ctx);
+          signal2()[publicId] = user;
+          const snapshot = createStatesSnapshot(user);
+          this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
+        }
+      } else {
+        user = signal2()[existingSession.publicId];
+      }
+      if (!existingSession) {
+        const sessionPrivateId = transferData?.privateId || conn.id;
+        await this.saveSession(sessionPrivateId, {
+          publicId
+        });
+      } else {
+        await this.updateSessionConnection(conn.id, true);
+      }
+    }
+    this.updateUserConnectionStatus(user, true);
+    await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
+    conn.setState({
+      ...conn.state,
+      publicId
+    });
+    this.send(conn, {
+      type: "sync",
+      value: {
+        pId: publicId,
+        ...subRoom.$memoryAll
+      }
+    }, subRoom);
+  }
+  /**
+  * @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);
+    } 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);
+    } catch (e) {
+      return;
+    }
+    const result = Message.safeParse(json);
+    if (!result.success) {
+      return;
+    }
+    const subRoom = await this.getSubRoom();
+    if (!subRoom) {
+      console.warn("Room not found");
+      return;
+    }
+    const roomGuards = subRoom.constructor["_roomGuards"] || [];
+    for (const guard of roomGuards) {
+      const isAuthorized = await guard(sender, result.data.value, this.room);
+      if (!isAuthorized) {
+        return;
+      }
+    }
+    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;
+          }
+        }
+        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));
+      }
+    }
+  }
+  /**
+  * @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;
+    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, requestInfo } = message;
+    const shardState = shardConnection.state;
+    const virtualContext = {
+      request: requestInfo ? {
+        headers: new Headers(requestInfo.headers),
+        method: requestInfo.method,
+        url: requestInfo.url
+      } : void 0
+    };
+    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.
+  * @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) {
+      return;
+    }
+    const signal2 = this.getUsersProperty(subRoom);
+    if (!conn.state) {
+      return;
+    }
+    const privateId = conn.id;
+    const { publicId } = conn.state;
+    const user = signal2?.()[publicId];
+    if (!user) return;
+    await this.updateSessionConnection(privateId, false);
+    const connectionUpdated = this.updateUserConnectionStatus(user, false);
+    await awaitReturn(subRoom["onLeave"]?.(user, conn));
+    if (!connectionUpdated) {
+      this.broadcast({
+        type: "user_disconnected",
+        value: {
+          publicId
+        }
+      }, subRoom);
+    }
+  }
+  async onAlarm() {
+    const subRoom = await this.getSubRoom();
+    await awaitReturn(subRoom["onAlarm"]?.(subRoom));
+  }
+  async onError(connection, error) {
+    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 (req.method === "OPTIONS") {
+      return res.status(200).send({});
+    }
+    if (isFromShard) {
+      return this.handleShardRequest(req, res, shardId);
+    }
+    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
+  */
+  async handleSessionRestore(req, res) {
+    try {
+      const transferData = await req.json();
+      const { privateId, userSnapshot, sessionState, publicId } = transferData;
+      if (!privateId || !publicId) {
+        return res.badRequest("Missing privateId or publicId in transfer data");
+      }
+      const subRoom = await this.getSubRoom();
+      if (!subRoom) {
+        return res.serverError("Room not available");
+      }
+      await this.saveSession(privateId, {
+        publicId,
+        state: sessionState,
+        created: Date.now(),
+        connected: false
+        // Will be set to true when user connects
+      });
+      if (userSnapshot) {
+        const signal2 = this.getUsersProperty(subRoom);
+        const usersPropName = this.getUsersPropName(subRoom);
+        if (signal2 && usersPropName) {
+          const { classType } = signal2.options;
+          const user = isClass(classType) ? new classType() : classType();
+          load(user, userSnapshot, true);
+          signal2()[publicId] = user;
+          await this.room.storage.put(`${usersPropName}.${publicId}`, userSnapshot);
+        }
+      }
+      const transferToken = generateShortUUID$1();
+      await this.room.storage.put(`transfer:${transferToken}`, {
+        privateId,
+        publicId,
+        restored: true
+      });
+      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
+  */
+  async handleDirectRequest(req, res) {
+    const subRoom = await this.getSubRoom();
+    if (!subRoom) {
+      return res.notFound();
+    }
+    const url = new URL(req.url);
+    if (url.pathname.endsWith("/session-transfer") && req.method === "POST") {
+      return this.handleSessionRestore(req, res);
+    }
+    const response2 = await this.tryMatchRequestHandler(req, res, subRoom);
+    if (response2) {
+      return response2;
+    }
+    const legacyResponse = await awaitReturn(subRoom["onRequest"]?.(req, res));
+    if (!legacyResponse) {
+      return res.notFound();
+    }
+    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;
+    }
+    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);
+    const headers = {};
+    if (ctx.request?.headers) {
+      ctx.request.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+    }
+    const requestInfo = ctx.request ? {
+      headers,
+      url: ctx.request.url,
+      method: ctx.request.method
+    } : null;
+    this.ws.send(JSON.stringify({
+      type: "shard.clientConnected",
+      privateId: conn.id,
+      requestInfo
+    }));
+    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"
+          "Content-Type": "application/json",
+          "x-access-shard": this.room.env.SHARD_SECRET
         },
         body: JSON.stringify({
-          roomId: room,
-          autoCreate
+          shardId: this.room.id,
+          connections: currentConnections
         })
       });
-      if (!response.ok) {
-        const errorData = await response.json().catch(() => ({
+      if (!response2.ok) {
+        const errorData = await response2.json().catch(() => ({
           error: "Unknown error"
         }));
-        throw new Error(`World service returned ${response.status}: ${errorData.error || "Unknown error"}`);
+        console.error(`Failed to update World stats: ${response2.status} - ${errorData.error || "Unknown error"}`);
+        return false;
       }
-      const data = await response.json();
-      if (!data.url || !data.shardId) {
-        throw new Error("Invalid response from World service: missing url or shardId");
+      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();
       }
-      return {
-        shardId: data.shardId,
-        url: data.url
+      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(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;
+    for (const lobby of io.context.parties.main.values()) {
+      await lobby.server.onStart();
+    }
+  } else {
+    server = await createServer(io);
+  }
+  await server.onStart();
+  return {
+    server,
+    room: server.subRoom,
+    createClient: /* @__PURE__ */ __name(async (id2) => {
+      const client = await io.connection(server, id2);
+      return client;
+    }, "createClient")
+  };
+}
+__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/mock.ts
+var MockPartyClient = class {
+  static {
+    __name(this, "MockPartyClient");
+  }
+  server;
+  events;
+  id;
+  conn;
+  constructor(server, id2) {
+    this.server = server;
+    this.events = /* @__PURE__ */ new Map();
+    this.id = id2 || generateShortUUID();
+    this.conn = new MockConnection(this);
+  }
+  addEventListener(event, cb) {
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+    this.events.get(event).push(cb);
+  }
+  removeEventListener(event, cb) {
+    if (!this.events.has(event)) return;
+    const callbacks = this.events.get(event);
+    const index = callbacks.indexOf(cb);
+    if (index !== -1) {
+      callbacks.splice(index, 1);
+    }
+    if (callbacks.length === 0) {
+      this.events.delete(event);
+    }
+  }
+  _trigger(event, data) {
+    const callbacks = this.events.get(event);
+    if (callbacks) {
+      for (const cb of callbacks) {
+        cb(data);
+      }
+    }
+  }
+  send(data) {
+    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);
+  }
+  fetch(url, options) {
+    return request(this.server, url, options);
+  }
+};
+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");
+  }
+  id;
+  clients;
+  storage;
+  context;
+  env;
+  constructor(id2, options = {}) {
+    this.id = id2;
+    this.clients = /* @__PURE__ */ new Map();
+    this.storage = new Storage();
+    this.env = {};
+    this.id = id2 || generateShortUUID();
+    this.context = new MockContext(this, {
+      parties: options.parties || {}
+    });
+    this.env = options.env || {};
+  }
+  async connection(server, id2) {
+    const socket = new MockPartyClient(server, id2);
+    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: request2
+    });
+    this.clients.set(socket.id, socket);
+    return socket;
+  }
+  broadcast(data) {
+    this.clients.forEach((client) => {
+      client._trigger("message", data);
+    });
+  }
+  getConnection(id2) {
+    return this.clients.get(id2);
+  }
+  getConnections() {
+    return Array.from(this.clients.values()).map((client) => client.conn);
+  }
+  clear() {
+    this.clients.clear();
+  }
+};
+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;
+  }
+  send(data) {
+    this.client._trigger("message", data);
+  }
+  close() {
+    this.server.onClose(this);
+  }
+};
+var ServerIo = MockPartyRoom;
+var ClientIo = MockPartyClient;
+
+// 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) {
-      attempts++;
-      if (attempts >= retryCount) {
-        throw error;
+      if (error instanceof Error) {
+        throw new Error(`Token verification failed: ${error.message}`);
       }
-      console.warn(`Failed to get shard (attempt ${attempts}/${retryCount}). Retrying in ${retryDelay}ms...`);
-      await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      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 MAX_PLAYERS_PER_SHARD = 75;
+z.object({
+  name: z.string(),
+  balancingStrategy: z.enum([
+    "round-robin",
+    "least-connections",
+    "random"
+  ]),
+  public: z.boolean(),
+  maxPlayersPerShard: z.number().int().positive(),
+  minShards: z.number().int().min(0),
+  maxShards: z.number().int().positive().optional()
+});
+z.object({
+  shardId: z.string(),
+  roomId: z.string(),
+  url: z.string().url(),
+  maxConnections: z.number().int().positive()
+});
+z.object({
+  connections: z.number().int().min(0),
+  status: z.enum([
+    "active",
+    "maintenance",
+    "draining"
+  ]).optional()
+});
+z.object({
+  roomId: z.string(),
+  targetShardCount: z.number().int().positive(),
+  shardTemplate: z.object({
+    urlTemplate: z.string(),
+    maxConnections: z.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);
+};
+_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(MAX_PLAYERS_PER_SHARD);
+  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(MAX_PLAYERS_PER_SHARD);
+    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");
+    }
+  }
+  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;
   }
-  throw new Error("Failed to get shard after all retry attempts");
+  // Helper methods
+  cleanupInactiveShards() {
+    const now = Date.now();
+    const timeout = 5 * 60 * 1e3;
+    const shardsValue = this.shards();
+    Object.values(shardsValue).forEach((shard) => {
+      if (now - shard.lastHeartbeat() > timeout) {
+        delete this.shards()[shard.id];
+      }
+    });
+    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);
+      roomShards.filter((shard) => !shardsToRemove.some((s) => s.id === shard.id));
+      for (const shard of shardsToRemove) {
+        delete this.shards()[shard.id];
+      }
+      return;
+    }
+    if (targetShardCount > previousShardCount) {
+      for (let i = 0; i < targetShardCount - previousShardCount; i++) {
+        await this.createShard(roomId, shardTemplate?.urlTemplate, shardTemplate?.maxConnections);
+      }
+    }
+  }
+  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", [
+    Object 
+  ]),
+  _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", [
+    Object ,
+    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", [
+    Object ,
+    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", [
+    Object ,
+    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", [
+    Object 
+  ])
+], WorldRoom);
+
+// src/session.guard.ts
+function createRequireSessionGuard(storage) {
+  return async (sender, value) => {
+    if (!sender || !sender.id) {
+      return false;
+    }
+    try {
+      const session = await storage.get(`session:${sender.id}`);
+      if (!session) {
+        return false;
+      }
+      const typedSession = session;
+      if (!typedSession.publicId) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error("Error checking session in requireSession guard:", error);
+      return false;
+    }
+  };
 }
-__name(getOptimalShard, "getOptimalShard");
+__name(createRequireSessionGuard, "createRequireSessionGuard");
 
-export { PartySocket, connectionRoom, connectionWorld };
+export { Action, ClientIo, Guard, MockConnection, Request2 as Request, Room, RoomGuard, Server, ServerIo, ServerResponse, Shard, WorldRoom, createRequireSessionGuard, request, testRoom };
 //# sourceMappingURL=index22.js.map