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

package/dist/index21.js

@@ -1,2421 +1,114 @@
-import { dset } from './index34.js';
-import z from './index35.js';
-import { syncClass, generateShortUUID as generateShortUUID$1, createStatesSnapshot, id, sync, persist, load, getByPath, DELETE_TOKEN } from './index18.js';
-import { signal } from './index36.js';
+import { __name } from './index26.js';
+import { load } from './index17.js';
+import { PartySocket } from './index31.js';
+import './index32.js';
 
-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();
-    }
-    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;
-        }
-        timeout = null;
-      }, wait);
-    } else {
-      lastArgs = args;
-    }
-  };
-}
-__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(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 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);
+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;
-      }
-    }
-    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);
-    };
-    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);
-      if (!isAuthorized) {
-        conn.close();
-        return;
-      }
-    }
-    const existingSession = await this.getSession(conn.id);
-    const publicId = existingSession?.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) {
-        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) {
-        await this.saveSession(conn.id, {
-          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);
+  });
+  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);
         }
-      }, "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 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 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);
+    }, "on"),
+    off: /* @__PURE__ */ __name((key, cb) => {
+      conn.removeEventListener("message", (event) => {
+        const object = JSON.parse(event.data);
+        if (object.type === key) {
+          cb(object.value);
         }
-      } 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;
-    }
+    }, "off"),
+    close: /* @__PURE__ */ __name(() => conn.close(), "close"),
+    conn
+  };
+}
+__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(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) {
     try {
-      const worldRoom = this.room.context.parties.world.get("world-default");
-      const response2 = await worldRoom.fetch("/update-shard", {
+      const response = await fetch(requestUrl, {
         method: "POST",
         headers: {
-          "Content-Type": "application/json",
-          "x-access-shard": this.room.env.SHARD_SECRET
+          "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          shardId: this.room.id,
-          connections: currentConnections
+          roomId: room,
+          autoCreate
         })
       });
-      if (!response2.ok) {
-        const errorData = await response2.json().catch(() => ({
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({
           error: "Unknown error"
         }));
-        console.error(`Failed to update World stats: ${response2.status} - ${errorData.error || "Unknown error"}`);
-        return false;
+        throw new Error(`World service returned ${response.status}: ${errorData.error || "Unknown error"}`);
       }
-      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 data = await response.json();
+      if (!data.url || !data.shardId) {
+        throw new Error("Invalid response from World service: missing url or shardId");
       }
-      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
+      return {
+        shardId: data.shardId,
+        url: data.url
       };
-      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);
+      attempts++;
+      if (attempts >= retryCount) {
+        throw error;
       }
+      console.warn(`Failed to get shard (attempt ${attempts}/${retryCount}). Retrying in ${retryDelay}ms...`);
+      await new Promise((resolve) => setTimeout(resolve, retryDelay));
     }
   }
-  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) {
-      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);
+  throw new Error("Failed to get shard after all retry attempts");
 }
-__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;
-  }
-  // 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);
+__name(getOptimalShard, "getOptimalShard");
 
-export { Action, ClientIo, Guard, MockConnection, Request2 as Request, Room, RoomGuard, Server, ServerIo, ServerResponse, Shard, WorldRoom, request, testRoom };
+export { PartySocket, connectionRoom, connectionWorld };
 //# sourceMappingURL=index21.js.map