@rpgjs/client 5.0.0-alpha.43 → 5.0.0-alpha.44

package/dist/node_modules/.pnpm/@signe_room@2.8.3/node_modules/@signe/room/dist/index.js

@@ -1,2689 +1,2180 @@
-import { dset } from '../../../../../dset@3.1.4/node_modules/dset/dist/index.js';
-import z from '../../../../../zod@3.24.2/node_modules/zod/lib/index.js';
-import { createStatesSnapshotDeep, syncClass, generateShortUUID as generateShortUUID$1, load, id, sync, persist, getByPath, createStatesSnapshot, DELETE_TOKEN } from '../../../../../@signe_sync@2.8.3/node_modules/@signe/sync/dist/index.js';
-import { signal } from '../../../../../@signe_reactive@2.8.3/node_modules/@signe/reactive/dist/index.js';
-
+import { signal } from "../../../../../@signe_reactive@2.8.3/node_modules/@signe/reactive/dist/index.js";
+import { createStatesSnapshot, createStatesSnapshotDeep, generateShortUUID as generateShortUUID$1, getByPath, id, load, persist, sync, syncClass } from "../../../../../@signe_sync@2.8.3/node_modules/@signe/sync/dist/index.js";
+import { dset } from "../../../../../dset@3.1.4/node_modules/dset/dist/index.js";
+import { z } from "../../../../../zod@3.24.2/node_modules/zod/lib/index.js";
+//#region ../../node_modules/.pnpm/@signe+room@2.8.3/node_modules/@signe/room/dist/index.js
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/decorators.ts
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
 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
-    });
-  };
+	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
-    });
-  };
+	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;
-    }
-  };
+	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 ?? 300 * 1e3;
+		if (options.guards) target["_roomGuards"] = options.guards;
+	};
 }
 __name(Room, "Room");
 function RoomGuard(guards) {
-  return function(target) {
-    target["_roomGuards"] = 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);
-  };
+	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;
+	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	let uuid = "";
+	for (let i = 0; i < 8; i++) {
+		const randomIndex = Math.floor(Math.random() * 62);
+		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;
-  }
+	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;
+	return value instanceof Promise;
 }
 __name(isPromise, "isPromise");
 async function awaitReturn(val) {
-  return isPromise(val) ? await val : val;
+	return isPromise(val) ? await val : val;
 }
 __name(awaitReturn, "awaitReturn");
 function isClass(obj) {
-  return typeof obj === "function" && obj.prototype && obj.prototype.constructor === 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;
-    }
-  };
+	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;
-  }
+	const regexPattern = pattern.replace(/{(\w+)}/g, "(?<$1>[\\w-]+)");
+	const match = new RegExp(`^${regexPattern}$`).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];
-  }
+	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;
+	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"
-    }
-  });
+	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
-    });
-  }
+	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
-  });
+	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);
+	return (res) => cors(res, options);
 }
 __name(createCorsInterceptor, "createCorsInterceptor");
-
-// src/server.ts
 var Message = z.object({
-  action: z.string(),
-  value: z.any()
+	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 runGarbageCollector() {
-    await this.garbageCollector({
-      sessionExpiryTime: -1
-    });
-  }
-  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);
-        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.$autoSync = instance["autoSync"] !== false;
-    instance.$pendingSync = /* @__PURE__ */ new Map();
-    instance.$pendingInitialSync = /* @__PURE__ */ new Map();
-    instance.$send = (conn, obj) => {
-      return this.send(conn, obj, instance);
-    };
-    instance.$broadcast = (obj) => {
-      return this.broadcast(obj, instance);
-    };
-    instance.$applySync = () => {
-      let packet;
-      if (instance.$pendingSync.size > 0) {
-        if (options.getMemoryAll) {
-          buildObject(instance.$pendingSync, instance.$memoryAll);
-        }
-        packet = buildObject(instance.$pendingSync, instance.$memoryAll);
-        instance.$pendingSync.clear();
-      } else {
-        packet = instance.$memoryAll;
-      }
-      const pendingConnections = new Set(instance.$pendingInitialSync.keys());
-      for (const [conn, publicId] of instance.$pendingInitialSync) {
-        this.send(conn, {
-          type: "sync",
-          value: {
-            pId: publicId,
-            ...packet
-          }
-        }, instance);
-      }
-      instance.$pendingInitialSync.clear();
-      for (const conn of this.room.getConnections()) {
-        if (!pendingConnections.has(conn)) {
-          this.send(conn, {
-            type: "sync",
-            value: packet
-          }, instance);
-        }
-      }
-    };
-    instance.$sessionTransfer = async (conn, targetRoomId) => {
-      let user;
-      const signal2 = this.getUsersProperty(instance);
-      if (!signal2) {
-        console.error("[sessionTransfer] `users` property not defined in the room.");
-        return null;
-      }
-      const { publicId } = conn.state;
-      user = signal2()[publicId];
-      if (!user) {
-        console.error(`[sessionTransfer] User with publicId ${publicId} not found.`);
-        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 = createStatesSnapshotDeep(user);
-      const transferData = {
-        privateId,
-        userSnapshot,
-        sessionState: userSession.state,
-        publicId
-      };
-      try {
-        const targetRoomParty = await 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();
-        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;
-      }
-      if (!instance.$autoSync) {
-        for (const [path, value] of values) {
-          instance.$pendingSync.set(path, value);
-        }
-        values.clear();
-        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: instance["throttleSync"] ? throttle(syncCb, instance["throttleSync"]) : syncCb,
-      onPersist: instance["throttleStorage"] ? throttle(persistCb, instance["throttleStorage"]) : persistCb
-    });
-    await loadMemory();
-    initPersist = false;
-    init = 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 = createStatesSnapshotDeep(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);
-    conn.setState({
-      ...conn.state,
-      publicId
-    });
-    await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
-    if (subRoom.$autoSync) {
-      this.send(conn, {
-        type: "sync",
-        value: {
-          pId: publicId,
-          ...subRoom.$memoryAll
-        }
-      }, subRoom);
-    } else {
-      subRoom.$pendingInitialSync.set(conn, publicId);
-    }
-  }
-  /**
-  * @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;
-    }
-    if (subRoom.$pendingInitialSync) {
-      subRoom.$pendingInitialSync.delete(conn);
-    }
-    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();
-          const hydratedSnapshot = await awaitReturn(subRoom["onSessionRestore"]?.({
-            userSnapshot,
-            user,
-            publicId,
-            privateId,
-            sessionState,
-            room: this.room
-          })) ?? userSnapshot;
-          signal2()[publicId] = user;
-          load(user, hydratedSnapshot, true);
-          await this.room.storage.put(`${usersPropName}.${publicId}`, userSnapshot);
-        }
-      }
-      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;
-  }
+	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 runGarbageCollector() {
+		await this.garbageCollector({ sessionExpiryTime: -1 });
+	}
+	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);
+				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.$autoSync = instance["autoSync"] !== false;
+		instance.$pendingSync = /* @__PURE__ */ new Map();
+		instance.$pendingInitialSync = /* @__PURE__ */ new Map();
+		instance.$send = (conn, obj) => {
+			return this.send(conn, obj, instance);
+		};
+		instance.$broadcast = (obj) => {
+			return this.broadcast(obj, instance);
+		};
+		instance.$applySync = () => {
+			let packet;
+			if (instance.$pendingSync.size > 0) {
+				if (options.getMemoryAll) buildObject(instance.$pendingSync, instance.$memoryAll);
+				packet = buildObject(instance.$pendingSync, instance.$memoryAll);
+				instance.$pendingSync.clear();
+			} else packet = instance.$memoryAll;
+			const pendingConnections = new Set(instance.$pendingInitialSync.keys());
+			for (const [conn, publicId] of instance.$pendingInitialSync) this.send(conn, {
+				type: "sync",
+				value: {
+					pId: publicId,
+					...packet
+				}
+			}, instance);
+			instance.$pendingInitialSync.clear();
+			for (const conn of this.room.getConnections()) if (!pendingConnections.has(conn)) this.send(conn, {
+				type: "sync",
+				value: packet
+			}, instance);
+		};
+		instance.$sessionTransfer = async (conn, targetRoomId) => {
+			let user;
+			const signal2 = this.getUsersProperty(instance);
+			if (!signal2) {
+				console.error("[sessionTransfer] `users` property not defined in the room.");
+				return null;
+			}
+			const { publicId } = conn.state;
+			user = signal2()[publicId];
+			if (!user) {
+				console.error(`[sessionTransfer] User with publicId ${publicId} not found.`);
+				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;
+			}
+			if (!this.getUsersPropName(instance)) {
+				console.error("[sessionTransfer] `users` property not defined in the room.");
+				return null;
+			}
+			const userSnapshot = createStatesSnapshotDeep(user);
+			const transferData = {
+				privateId,
+				userSnapshot,
+				sessionState: userSession.state,
+				publicId
+			};
+			try {
+				const response2 = await (await this.room.context.parties.main.get(targetRoomId)).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();
+				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;
+			}
+			if (!instance.$autoSync) {
+				for (const [path, value] of values) instance.$pendingSync.set(path, value);
+				values.clear();
+				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 itemValue = createStatesSnapshot(path == "." ? instance : getByPath(instance, path));
+				if (value == "$delete") await this.room.storage.delete(path);
+				else await this.room.storage.put(path, itemValue);
+			}
+			values.clear();
+		}, "persistCb");
+		syncClass(instance, {
+			onSync: instance["throttleSync"] ? throttle(syncCb, instance["throttleSync"]) : syncCb,
+			onPersist: instance["throttleStorage"] ? throttle(persistCb, instance["throttleStorage"]) : persistCb
+		});
+		await loadMemory();
+		initPersist = false;
+		init = 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 propId = subRoom.constructor["_propertyMetadata"]?.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 {
+			return await this.room.storage.get(`session:${privateId}`);
+		} 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) if (!await guard(conn, ctx, this.room)) {
+			conn.close();
+			return;
+		}
+		let transferToken = null;
+		if (ctx.request?.url) transferToken = new URL(ctx.request.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 = createStatesSnapshotDeep(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);
+		conn.setState({
+			...conn.state,
+			publicId
+		});
+		await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
+		if (subRoom.$autoSync) this.send(conn, {
+			type: "sync",
+			value: {
+				pId: publicId,
+				...subRoom.$memoryAll
+			}
+		}, subRoom);
+		else subRoom.$pendingInitialSync.set(conn, publicId);
+	}
+	/**
+	* @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()
+		});
+	}
+	/**
+	* @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) if (!await guard(sender, result.data.value, this.room)) 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) if (!await guard(sender, result.data.value)) return;
+				if (actionName.bodyValidation) {
+					if (!actionName.bodyValidation.safeParse(result.data.value).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;
+		}
+		shardConnection.state.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 clients = shardConnection.state.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;
+		if (subRoom.$pendingInitialSync) subRoom.$pendingInitialSync.delete(conn);
+		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) {
+		await awaitReturn((await this.getSubRoom())["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 { privateId, userSnapshot, sessionState, publicId } = await req.json();
+			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
+			});
+			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();
+					const hydratedSnapshot = await awaitReturn(subRoom["onSessionRestore"]?.({
+						userSnapshot,
+						user,
+						publicId,
+						privateId,
+						sessionState,
+						room: this.room
+					})) ?? userSnapshot;
+					signal2()[publicId] = user;
+					load(user, hydratedSnapshot, true);
+					await this.room.storage.put(`${usersPropName}.${publicId}`, userSnapshot);
+				}
+			}
+			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();
+		if (new URL(req.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 {
+					if ((req.headers.get("content-type") || "").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, "([^/]+)");
+		return new RegExp(`^${pathRegexString}`).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",
-          "x-access-shard": this.room.env.SHARD_SECRET
-        },
-        body: JSON.stringify({
-          shardId: this.room.id,
-          connections: currentConnections
-        })
-      });
-      if (!response2.ok) {
-        const errorData = await response2.json().catch(() => ({
-          error: "Unknown error"
-        }));
-        console.error(`Failed to update World stats: ${response2.status} - ${errorData.error || "Unknown error"}`);
-        return false;
-      }
-      this.lastReportedConnections = currentConnections;
-      return true;
-    } catch (error) {
-      console.error("Error updating World stats:", error);
-      return false;
-    }
-  }
-  /**
-  * @method onRequest
-  * @async
-  * @param {Party.Request} req - The HTTP request to handle
-  * @description Forwards HTTP requests to the main server, preserving client context
-  * @returns {Promise<Response>} The response from the main server
-  */
-  async onRequest(req) {
-    if (!this.mainServerStub) {
-      return response(503, {
-        error: "Shard not connected to main server"
-      });
-    }
-    try {
-      const url = new URL(req.url);
-      const path = url.pathname;
-      const method = req.method;
-      let body = null;
-      if (method !== "GET" && method !== "HEAD") {
-        body = await req.text();
-      }
-      const headers = new Headers();
-      req.headers.forEach((value, key) => {
-        headers.set(key, value);
-      });
-      headers.set("x-shard-id", this.room.id);
-      headers.set("x-forwarded-by-shard", "true");
-      const clientIp = req.headers.get("x-forwarded-for") || "unknown";
-      if (clientIp) {
-        headers.set("x-original-client-ip", clientIp);
-      }
-      const requestInit = {
-        method,
-        headers,
-        body
-      };
-      const response2 = await this.mainServerStub.fetch(path, requestInit);
-      return response2;
-    } catch (error) {
-      return response(500, {
-        error: "Error forwarding request"
-      });
-    }
-  }
-  /**
-  * @method onAlarm
-  * @async
-  * @description Executed periodically, used to perform maintenance tasks
-  */
-  async onAlarm() {
-    await this.updateWorldStats();
-  }
+	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 response2 = await this.room.context.parties.world.get("world-default").fetch("/update-shard", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"x-access-shard": this.room.env.SHARD_SECRET
+				},
+				body: JSON.stringify({
+					shardId: this.room.id,
+					connections: currentConnections
+				})
+			});
+			if (!response2.ok) {
+				const errorData = await response2.json().catch(() => ({ error: "Unknown error" }));
+				console.error(`Failed to update World stats: ${response2.status} - ${errorData.error || "Unknown error"}`);
+				return false;
+			}
+			this.lastReportedConnections = currentConnections;
+			return true;
+		} catch (error) {
+			console.error("Error updating World stats:", error);
+			return false;
+		}
+	}
+	/**
+	* @method onRequest
+	* @async
+	* @param {Party.Request} req - The HTTP request to handle
+	* @description Forwards HTTP requests to the main server, preserving client context
+	* @returns {Promise<Response>} The response from the main server
+	*/
+	async onRequest(req) {
+		if (!this.mainServerStub) return response(503, { error: "Shard not connected to main server" });
+		try {
+			const path = new URL(req.url).pathname;
+			const method = req.method;
+			let body = null;
+			if (method !== "GET" && method !== "HEAD") body = await req.text();
+			const headers = new Headers();
+			req.headers.forEach((value, key) => {
+				headers.set(key, value);
+			});
+			headers.set("x-shard-id", this.room.id);
+			headers.set("x-forwarded-by-shard", "true");
+			const clientIp = req.headers.get("x-forwarded-for") || "unknown";
+			if (clientIp) headers.set("x-original-client-ip", clientIp);
+			const requestInit = {
+				method,
+				headers,
+				body
+			};
+			return await this.mainServerStub.fetch(path, requestInit);
+		} 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,
-      ...options.parties || {}
-    },
-    partyFn: options.partyFn,
-    env: options.env
-  } : {
-    parties: options.parties,
-    partyFn: options.partyFn,
-    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;
-    if (io.context.parties.main instanceof Map) {
-      for (const lobby of io.context.parties.main.values()) {
-        await lobby.server.onStart();
-      }
-    }
-  } else {
-    server = await createServer(io);
-    if (io.context.parties.main instanceof Map) {
-      for (const lobby of io.context.parties.main.values()) {
-        if (lobby.server && lobby.server !== server) {
-          await lobby.server.onStart();
-        }
-      }
-    }
-  }
-  await server.onStart();
-  return {
-    server,
-    room: server.subRoom,
-    createClient: /* @__PURE__ */ __name(async (id2, opts) => {
-      const client = await io.connection(server, id2, opts);
-      return client;
-    }, "createClient"),
-    getServerUser: /* @__PURE__ */ __name(async (client, prop = "users") => {
-      const privateId = client.conn.id;
-      const session = await server.getSession(privateId);
-      return server.subRoom[prop]()[session?.publicId];
-    }, "getServerUser")
-  };
+	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,
+			...options.parties || {}
+		},
+		partyFn: options.partyFn,
+		env: options.env
+	} : {
+		parties: options.parties,
+		partyFn: options.partyFn,
+		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;
+		if (io.context.parties.main instanceof Map) for (const lobby of io.context.parties.main.values()) await lobby.server.onStart();
+	} else {
+		server = await createServer(io);
+		if (io.context.parties.main instanceof Map) {
+			for (const lobby of io.context.parties.main.values()) if (lobby.server && lobby.server !== server) await lobby.server.onStart();
+		}
+	}
+	await server.onStart();
+	return {
+		server,
+		room: server.subRoom,
+		createClient: /* @__PURE__ */ __name(async (id2, opts) => {
+			return await io.connection(server, id2, opts);
+		}, "createClient"),
+		getServerUser: /* @__PURE__ */ __name(async (client, prop = "users") => {
+			const privateId = client.conn.id;
+			const session = await server.getSession(privateId);
+			return server.subRoom[prop]()[session?.publicId];
+		}, "getServerUser")
+	};
 }
 __name(testRoom, "testRoom");
-async function request(room, path, options = {
-  method: "GET"
-}) {
-  const url = new URL("http://localhost" + path);
-  const request1 = new Request(url.toString(), options);
-  const response2 = await room.onRequest(request1);
-  return response2;
+async function request(room, path, options = { method: "GET" }) {
+	const url = new URL("http://localhost" + path);
+	const request1 = new Request(url.toString(), options);
+	return await room.onRequest(request1);
 }
 __name(request, "request");
 function tick(ms = 0) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 __name(tick, "tick");
-
-// src/mock.ts
 var MockPartyClient = class {
-  static {
-    __name(this, "MockPartyClient");
-  }
-  server;
-  events;
-  id;
-  conn;
-  constructor(server, id2) {
-    this.server = server;
-    this.events = /* @__PURE__ */ new Map();
-    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);
-  }
+	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;
-  lobbyId;
-  constructor(server, lobbyId) {
-    this.server = server;
-    this.lobbyId = lobbyId;
-  }
-  socket(_init) {
-    return new MockPartyClient(this.server);
-  }
-  async connection(idOrOptions, maybeOptions) {
-    const id2 = typeof idOrOptions === "string" ? idOrOptions : idOrOptions?.id;
-    const options = (typeof idOrOptions === "string" ? maybeOptions : idOrOptions) || {};
-    return this.server.room.connection(this.server, id2, options);
-  }
-  fetch(url, options) {
-    const baseUrl = url.includes("shard") ? "" : "/parties/main/" + this.lobbyId;
-    return request(this.server, baseUrl + url, options);
-  }
+	static {
+		__name(this, "MockLobby");
+	}
+	server;
+	lobbyId;
+	constructor(server, lobbyId) {
+		this.server = server;
+		this.lobbyId = lobbyId;
+	}
+	socket(_init) {
+		return new MockPartyClient(this.server);
+	}
+	async connection(idOrOptions, maybeOptions) {
+		const id2 = typeof idOrOptions === "string" ? idOrOptions : idOrOptions?.id;
+		const options = (typeof idOrOptions === "string" ? maybeOptions : idOrOptions) || {};
+		return this.server.room.connection(this.server, id2, options);
+	}
+	fetch(url, options) {
+		const baseUrl = url.includes("shard") ? "" : "/parties/main/" + this.lobbyId;
+		return request(this.server, baseUrl + 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 || {};
-    if (options.partyFn) {
-      const serverCache = /* @__PURE__ */ new Map();
-      this.parties.main = {
-        get: /* @__PURE__ */ __name(async (lobbyId) => {
-          if (!serverCache.has(lobbyId)) {
-            const server = await options.partyFn(lobbyId);
-            serverCache.set(lobbyId, new MockLobby(server, lobbyId));
-          }
-          return serverCache.get(lobbyId);
-        }, "get")
-      };
-    } else {
-      for (let lobbyId in parties) {
-        const server = parties[lobbyId](room);
-        this.parties.main.set(lobbyId, new MockLobby(server, lobbyId));
-      }
-    }
-  }
+	static {
+		__name(this, "MockContext");
+	}
+	room;
+	parties;
+	constructor(room, options = {}) {
+		this.room = room;
+		this.parties = { main: /* @__PURE__ */ new Map() };
+		const parties = options.parties || {};
+		if (options.partyFn) {
+			const serverCache = /* @__PURE__ */ new Map();
+			this.parties.main = { get: /* @__PURE__ */ __name(async (lobbyId) => {
+				if (!serverCache.has(lobbyId)) {
+					const server = await options.partyFn(lobbyId);
+					serverCache.set(lobbyId, new MockLobby(server, lobbyId));
+				}
+				return serverCache.get(lobbyId);
+			}, "get") };
+		} else for (let lobbyId in parties) {
+			const server = parties[lobbyId](room);
+			this.parties.main.set(lobbyId, new MockLobby(server, lobbyId));
+		}
+	}
 };
 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,
-      partyFn: options.partyFn
-    });
-    this.env = options.env || {};
-  }
-  async connection(server, id2, opts) {
-    const socket = new MockPartyClient(server, id2);
-    const url = new URL("http://localhost");
-    if (opts?.query) {
-      for (const [key, value] of Object.entries(opts.query)) {
-        url.searchParams.set(key, String(value));
-      }
-    }
-    const request2 = new Request(url.toString(), {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        ...opts?.headers || {}
-      }
-    });
-    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();
-  }
+	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,
+			partyFn: options.partyFn
+		});
+		this.env = options.env || {};
+	}
+	async connection(server, id2, opts) {
+		const socket = new MockPartyClient(server, id2);
+		const url = new URL("http://localhost");
+		if (opts?.query) for (const [key, value] of Object.entries(opts.query)) url.searchParams.set(key, String(value));
+		const request2 = new Request(url.toString(), {
+			method: "GET",
+			headers: {
+				"Content-Type": "application/json",
+				...opts?.headers || {}
+			}
+		});
+		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);
-  }
+	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");
-    }
-  }
+	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"]);
+	}
+	/**
+	* Base64Url encode a buffer
+	* @param {ArrayBuffer} buffer - The buffer to encode
+	* @returns {string} - The base64url encoded string
+	*/
+	base64UrlEncode(buffer) {
+		return btoa(String.fromCharCode(...new Uint8Array(buffer))).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 signatureBase = `${this.base64UrlEncode(this.encoder.encode(JSON.stringify({
+			alg: "HS256",
+			typ: "JWT"
+		})))}.${this.base64UrlEncode(this.encoder.encode(JSON.stringify(fullPayload)))}`;
+		const key = await this.getSecretKey();
+		const signature = await crypto.subtle.sign({ name: "HMAC" }, key, this.encoder.encode(signatureBase));
+		return `${signatureBase}.${this.base64UrlEncode(signature)}`;
+	}
+	/**
+	* 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);
+			if (!await crypto.subtle.verify({ name: "HMAC" }, key, signature, this.encoder.encode(signatureBase))) 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;
+	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 {
+		if (!await jwt.verify(token)) 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;
+	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);
+	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()
+	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()
+	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()
+	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()
+	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);
+	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);
+_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);
+	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);
+_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;
-  }
+	static {
+		__name(this, "WorldRoom");
+	}
+	room;
+	rooms;
+	shards;
+	rrCounters;
+	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;
+	}
+	cleanupInactiveShards() {
+		const now = Date.now();
+		const timeout = 300 * 1e3;
+		const shardsValue = this.shards();
+		Object.values(shardsValue).forEach((shard) => {
+			if (now - shard.lastHeartbeat() > timeout) delete this.shards()[shard.id];
+		});
+		setTimeout(() => this.cleanupInactiveShards(), 6e4);
+	}
+	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 { shardId, connections, status } = await req.json();
+		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 { targetShardCount, shardTemplate, roomId } = await req.json();
+		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) {
+			const newShards = [];
+			for (let i = 0; i < targetShardCount - previousShardCount; i++) {
+				const newShard = await this.createShard(roomId, shardTemplate?.urlTemplate, shardTemplate?.maxConnections);
+				if (newShard) newShards.push(newShard);
+			}
+		}
+	}
+	async connect(req, res) {
+		try {
+			let data;
+			try {
+				const body = await req.text();
+				if (!body || body.trim() === "") return res.badRequest("Request body is empty");
+				data = JSON.parse(body);
+			} catch (parseError) {
+				return res.badRequest("Invalid JSON in request body");
+			}
+			if (!data.roomId) return res.badRequest("roomId parameter is required");
+			const autoCreate = data.autoCreate !== void 0 ? data.autoCreate : true;
+			const result = await this.findOptimalShard(data.roomId, autoCreate);
+			if ("error" in result) return res.notFound(result.error);
+			return res.success({
+				success: true,
+				shardId: result.shardId,
+				url: result.url
+			});
+		} catch (error) {
+			console.error("Error connecting to shard:", error);
+			return res.serverError();
+		}
+	}
+	async findOptimalShard(roomId, autoCreate = true) {
+		let room = this.rooms()[roomId];
+		if (!room) if (autoCreate) {
+			const mockRequest = { json: /* @__PURE__ */ __name(async () => ({
+				name: roomId,
+				balancingStrategy: "round-robin",
+				public: true,
+				maxPlayersPerShard: this.defaultMaxConnectionsPerShard(),
+				minShards: 1,
+				maxShards: void 0
+			}), "json") };
+			await this.registerRoom(mockRequest);
+			room = this.rooms()[roomId];
+			if (!room) return { error: `Failed to create room ${roomId}` };
+		} else return { error: `Room ${roomId} does not exist` };
+		const roomShards = Object.values(this.shards()).filter((shard) => shard.roomId() === roomId);
+		if (roomShards.length === 0) if (autoCreate) {
+			const newShard = await this.createShard(roomId);
+			if (newShard) return {
+				shardId: newShard.id,
+				url: newShard.url()
+			};
+			else return { error: `Failed to create shard for room ${roomId}` };
+		} else return { error: `No shards available for room ${roomId}` };
+		const activeShards = roomShards.filter((shard) => shard && shard.status() === "active");
+		if (activeShards.length === 0) return { error: `No active shards available for room ${roomId}` };
+		const balancingStrategy = room.balancingStrategy();
+		let selectedShard;
+		switch (balancingStrategy) {
+			case "least-connections":
+				selectedShard = activeShards.reduce((min, shard) => shard.currentConnections() < min.currentConnections() ? shard : min, activeShards[0]);
+				break;
+			case "random":
+				selectedShard = activeShards[Math.floor(Math.random() * activeShards.length)];
+				break;
+			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()
+		};
+	}
+	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 url = (urlTemplate || this.defaultShardUrlTemplate()).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([
-  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)
+	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)
+	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)
+	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)
+	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 
-  ])
+	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;
-    }
-  };
+	return async (sender, value) => {
+		if (!sender || !sender.id) return false;
+		try {
+			const session = await storage.get(`session:${sender.id}`);
+			if (!session) return false;
+			if (!session.publicId) return false;
+			return true;
+		} catch (error) {
+			console.error("Error checking session in requireSession guard:", error);
+			return false;
+		}
+	};
 }
 __name(createRequireSessionGuard, "createRequireSessionGuard");
+//#endregion
+export { ClientIo, ServerIo };
 
-export { Action, ClientIo, Guard, MockConnection, Request2 as Request, Room, RoomGuard, Server, ServerIo, ServerResponse, Shard, WorldRoom, createRequireSessionGuard, request, testRoom, tick };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map