@rpgjs/client 5.0.0-alpha.9 → 5.0.0-beta.1

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

@@ -0,0 +1,2191 @@
+import { createStatesSnapshot, createStatesSnapshotDeep, generateShortUUID as generateShortUUID$1, getByPath, id, load, persist, sync, syncClass } from "../../../../../@signe_sync@2.9.0/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";
+import { signal } from "../../../../../@signe_reactive@2.8.3/node_modules/@signe/reactive/dist/index.js";
+//#region ../../node_modules/.pnpm/@signe+room@2.9.0/node_modules/@signe/room/dist/index.js
+var __defProp = Object.defineProperty;
+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
+		});
+	};
+}
+__name(Action, "Action");
+function UnhandledAction() {
+	return function(target, propertyKey) {
+		target.constructor._unhandledActionMetadata = { key: propertyKey };
+	};
+}
+__name(UnhandledAction, "UnhandledAction");
+function Request2(options, bodyValidation) {
+	return function(target, propertyKey) {
+		if (!target.constructor._requestMetadata) target.constructor._requestMetadata = /* @__PURE__ */ new Map();
+		const path = options.path.startsWith("/") ? options.path : `/${options.path}`;
+		const method = options.method || "GET";
+		const routeKey = `${method}:${path}`;
+		target.constructor._requestMetadata.set(routeKey, {
+			key: propertyKey,
+			path,
+			method,
+			bodyValidation
+		});
+	};
+}
+__name(Request2, "Request");
+function Room(options) {
+	return function(target) {
+		target.path = options.path;
+		target.prototype.maxUsers = options.maxUsers;
+		target.prototype.throttleStorage = options.throttleStorage;
+		target.prototype.throttleSync = options.throttleSync;
+		target.prototype.sessionExpiryTime = options.sessionExpiryTime ?? 300 * 1e3;
+		if (options.guards) target["_roomGuards"] = options.guards;
+	};
+}
+__name(Room, "Room");
+function RoomGuard(guards) {
+	return function(target) {
+		target["_roomGuards"] = guards;
+	};
+}
+__name(RoomGuard, "RoomGuard");
+function Guard(guards) {
+	return function(target, propertyKey, descriptor) {
+		if (!target.constructor["_actionGuards"]) target.constructor["_actionGuards"] = /* @__PURE__ */ new Map();
+		if (!Array.isArray(guards)) guards = [guards];
+		target.constructor["_actionGuards"].set(propertyKey, guards);
+	};
+}
+__name(Guard, "Guard");
+function generateShortUUID() {
+	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");
+var Storage = class {
+	static {
+		__name(this, "Storage");
+	}
+	memory = /* @__PURE__ */ new Map();
+	async put(key, value) {
+		this.memory.set(key, value);
+	}
+	async get(key) {
+		return this.memory.get(key);
+	}
+	async delete(key) {
+		this.memory.delete(key);
+	}
+	async list() {
+		return this.memory;
+	}
+};
+function isPromise(value) {
+	return value instanceof Promise;
+}
+__name(isPromise, "isPromise");
+async function awaitReturn(val) {
+	return isPromise(val) ? await val : val;
+}
+__name(awaitReturn, "awaitReturn");
+function isClass(obj) {
+	return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
+}
+__name(isClass, "isClass");
+function throttle(func, wait) {
+	let timeout = null;
+	let lastArgs = null;
+	return function(...args) {
+		if (!timeout) {
+			func(...args);
+			timeout = setTimeout(() => {
+				if (lastArgs) {
+					func(...lastArgs);
+					lastArgs = null;
+				}
+				timeout = null;
+			}, wait);
+		} else lastArgs = args;
+	};
+}
+__name(throttle, "throttle");
+function extractParams(pattern, str) {
+	const regexPattern = pattern.replace(/{(\w+)}/g, "(?<$1>[\\w-]+)");
+	const 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];
+}
+__name(dremove, "dremove");
+function buildObject(valuesMap, allMemory) {
+	let memoryObj = {};
+	for (let path of valuesMap.keys()) {
+		const value = valuesMap.get(path);
+		dset(memoryObj, path, value);
+		if (value === "$delete") dremove(allMemory, path);
+		else dset(allMemory, path, value);
+	}
+	return memoryObj;
+}
+__name(buildObject, "buildObject");
+function response(status, body) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+__name(response, "response");
+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 });
+	}
+};
+function cors(res, options = {}) {
+	const newHeaders = new Headers(res.headers);
+	const requestOrigin = options.origin || "*";
+	newHeaders.set("Access-Control-Allow-Origin", requestOrigin);
+	if (options.credentials) newHeaders.set("Access-Control-Allow-Credentials", "true");
+	if (options.exposedHeaders && options.exposedHeaders.length) newHeaders.set("Access-Control-Expose-Headers", options.exposedHeaders.join(", "));
+	if (options.methods && options.methods.length) newHeaders.set("Access-Control-Allow-Methods", options.methods.join(", "));
+	else newHeaders.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+	if (options.allowedHeaders && options.allowedHeaders.length) newHeaders.set("Access-Control-Allow-Headers", options.allowedHeaders.join(", "));
+	else newHeaders.set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With");
+	if (options.maxAge) newHeaders.set("Access-Control-Max-Age", options.maxAge.toString());
+	else newHeaders.set("Access-Control-Max-Age", "86400");
+	return new Response(res.body, {
+		status: res.status,
+		headers: newHeaders
+	});
+}
+__name(cors, "cors");
+function createCorsInterceptor(options = {}) {
+	return (res) => cors(res, options);
+}
+__name(createCorsInterceptor, "createCorsInterceptor");
+var Message = z.object({
+	action: z.string(),
+	value: z.any()
+});
+var Server = class {
+	static {
+		__name(this, "Server");
+	}
+	room;
+	subRoom;
+	rooms;
+	/**
+	* @constructor
+	* @param {Party.Room} room - The room object representing the current game or application instance.
+	* 
+	* @example
+	* ```typescript
+	* const server = new MyServer(new ServerIo("game"));
+	* ```
+	*/
+	constructor(room) {
+		this.room = room;
+		this.subRoom = null;
+		this.rooms = [];
+	}
+	/**
+	* @readonly
+	* @property {boolean} isHibernate - Indicates whether the server is in hibernate mode.
+	* 
+	* @example
+	* ```typescript
+	* if (!server.isHibernate) {
+	*   console.log("Server is active");
+	* }
+	* ```
+	*/
+	get isHibernate() {
+		return !!this["options"]?.hibernate;
+	}
+	get roomStorage() {
+		return this.room.storage;
+	}
+	async send(conn, obj, subRoom) {
+		obj = structuredClone(obj);
+		if (subRoom.interceptorPacket) {
+			const signal2 = this.getUsersProperty(subRoom);
+			const { publicId } = conn.state;
+			const user = signal2?.()[publicId];
+			obj = await awaitReturn(subRoom["interceptorPacket"]?.(user, obj, conn));
+			if (obj === null) return;
+		}
+		conn.send(JSON.stringify(obj));
+	}
+	broadcast(obj, subRoom) {
+		for (let conn of this.room.getConnections()) this.send(conn, obj, subRoom);
+	}
+	/**
+	* @method onStart
+	* @async
+	* @description Initializes the server and creates the initial room if not in hibernate mode.
+	* @returns {Promise<void>}
+	* 
+	* @example
+	* ```typescript
+	* async function initServer() {
+	*   await server.onStart();
+	*   console.log("Server started");
+	* }
+	* ```
+	*/
+	async onStart() {
+		if (!this.isHibernate) this.subRoom = await this.createRoom();
+	}
+	async 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"];
+		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, this.room)) return;
+			if (actionName.bodyValidation) {
+				if (!actionName.bodyValidation.safeParse(result.data.value).success) return;
+			}
+			await awaitReturn(subRoom[actionName.key](user, result.data.value, sender));
+			return;
+		}
+		const unhandledAction = subRoom.constructor["_unhandledActionMetadata"];
+		if (unhandledAction) {
+			const guards = subRoom.constructor["_actionGuards"]?.get(unhandledAction.key) || [];
+			for (const guard of guards) if (!await guard(sender, result.data, this.room)) return;
+			await awaitReturn(subRoom[unhandledAction.key](user, result.data, sender));
+		}
+	}
+	/**
+	* @method handleShardMessage
+	* @private
+	* @async
+	* @param {string} message - The message received from a shard.
+	* @param {Party.Connection} shardConnection - The connection object of the shard.
+	* @description Processes messages from shards, extracting client information.
+	* @returns {Promise<void>}
+	*/
+	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;
+	}
+};
+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 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();
+	}
+};
+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) => {
+			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);
+	return await room.onRequest(request1);
+}
+__name(request, "request");
+function tick(ms = 0) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(tick, "tick");
+var MockPartyClient = class {
+	static {
+		__name(this, "MockPartyClient");
+	}
+	server;
+	events;
+	id;
+	conn;
+	constructor(server, id2) {
+		this.server = server;
+		this.events = /* @__PURE__ */ new Map();
+		this.id = id2 || generateShortUUID();
+		this.conn = new MockConnection(this);
+	}
+	addEventListener(event, cb) {
+		if (!this.events.has(event)) this.events.set(event, []);
+		this.events.get(event).push(cb);
+	}
+	removeEventListener(event, cb) {
+		if (!this.events.has(event)) return;
+		const callbacks = this.events.get(event);
+		const index = callbacks.indexOf(cb);
+		if (index !== -1) callbacks.splice(index, 1);
+		if (callbacks.length === 0) this.events.delete(event);
+	}
+	_trigger(event, data) {
+		const callbacks = this.events.get(event);
+		if (callbacks) for (const cb of callbacks) cb(data);
+	}
+	send(data) {
+		return this.server.onMessage(JSON.stringify(data), this.conn);
+	}
+};
+var MockLobby = class MockLobby2 {
+	static {
+		__name(this, "MockLobby");
+	}
+	server;
+	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));
+		}
+	}
+};
+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();
+	}
+};
+var MockConnection = class {
+	static {
+		__name(this, "MockConnection");
+	}
+	client;
+	server;
+	id;
+	constructor(client) {
+		this.client = client;
+		this.state = {};
+		this.server = client.server;
+		this.id = client.id;
+	}
+	state;
+	setState(value) {
+		this.state = value;
+	}
+	send(data) {
+		this.client._trigger("message", data);
+	}
+	close() {
+		this.server.onClose(this);
+	}
+};
+var ServerIo = MockPartyRoom;
+var ClientIo = MockPartyClient;
+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"]);
+	}
+	/**
+	* 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");
+		}
+	}
+};
+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 {
+		if (!await jwt.verify(token)) return false;
+	} catch (error) {
+		return false;
+	}
+	return true;
+}, "guardManageWorld");
+function _ts_decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var MAX_PLAYERS_PER_SHARD = 75;
+z.object({
+	name: z.string(),
+	balancingStrategy: z.enum([
+		"round-robin",
+		"least-connections",
+		"random"
+	]),
+	public: z.boolean(),
+	maxPlayersPerShard: z.number().int().positive(),
+	minShards: z.number().int().min(0),
+	maxShards: z.number().int().positive().optional()
+});
+z.object({
+	shardId: z.string(),
+	roomId: z.string(),
+	url: z.string().url(),
+	maxConnections: z.number().int().positive()
+});
+z.object({
+	connections: z.number().int().min(0),
+	status: z.enum([
+		"active",
+		"maintenance",
+		"draining"
+	]).optional()
+});
+z.object({
+	roomId: z.string(),
+	targetShardCount: z.number().int().positive(),
+	shardTemplate: z.object({
+		urlTemplate: z.string(),
+		maxConnections: z.number().int().positive()
+	}).optional()
+});
+var RoomConfig = class RoomConfig2 {
+	static {
+		__name(this, "RoomConfig");
+	}
+	id;
+	name = signal("");
+	balancingStrategy = signal("round-robin");
+	public = signal(true);
+	maxPlayersPerShard = signal(MAX_PLAYERS_PER_SHARD);
+	minShards = signal(1);
+	maxShards = signal(void 0);
+};
+_ts_decorate([id(), _ts_metadata("design:type", String)], RoomConfig.prototype, "id", void 0);
+_ts_decorate([sync()], RoomConfig.prototype, "name", void 0);
+_ts_decorate([sync()], RoomConfig.prototype, "balancingStrategy", void 0);
+_ts_decorate([sync()], RoomConfig.prototype, "public", void 0);
+_ts_decorate([sync()], RoomConfig.prototype, "maxPlayersPerShard", void 0);
+_ts_decorate([sync()], RoomConfig.prototype, "minShards", void 0);
+_ts_decorate([sync()], RoomConfig.prototype, "maxShards", void 0);
+var ShardInfo = class ShardInfo2 {
+	static {
+		__name(this, "ShardInfo");
+	}
+	id;
+	roomId = signal("");
+	url = signal("");
+	currentConnections = signal(0);
+	maxConnections = signal(MAX_PLAYERS_PER_SHARD);
+	status = signal("active");
+	lastHeartbeat = signal(0);
+};
+_ts_decorate([id(), _ts_metadata("design:type", String)], ShardInfo.prototype, "id", void 0);
+_ts_decorate([sync()], ShardInfo.prototype, "roomId", void 0);
+_ts_decorate([sync()], ShardInfo.prototype, "url", void 0);
+_ts_decorate([sync({ persist: false })], ShardInfo.prototype, "currentConnections", void 0);
+_ts_decorate([sync()], ShardInfo.prototype, "maxConnections", void 0);
+_ts_decorate([sync()], ShardInfo.prototype, "status", void 0);
+_ts_decorate([sync()], ShardInfo.prototype, "lastHeartbeat", void 0);
+var WorldRoom = class {
+	static {
+		__name(this, "WorldRoom");
+	}
+	room;
+	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([
+	Request2({
+		path: "register-room",
+		method: "POST"
+	}),
+	Guard([guardManageWorld]),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [Object]),
+	_ts_metadata("design:returntype", Promise)
+], WorldRoom.prototype, "registerRoom", null);
+_ts_decorate([
+	Request2({
+		path: "update-shard",
+		method: "POST"
+	}),
+	Guard([guardManageWorld]),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [Object, typeof ServerResponse === "undefined" ? Object : ServerResponse]),
+	_ts_metadata("design:returntype", Promise)
+], WorldRoom.prototype, "updateShardStats", null);
+_ts_decorate([
+	Request2({
+		path: "scale-room",
+		method: "POST"
+	}),
+	Guard([guardManageWorld]),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [Object, typeof ServerResponse === "undefined" ? Object : ServerResponse]),
+	_ts_metadata("design:returntype", Promise)
+], WorldRoom.prototype, "scaleRoom", null);
+_ts_decorate([
+	Request2({
+		path: "connect",
+		method: "POST"
+	}),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [Object, typeof ServerResponse === "undefined" ? Object : ServerResponse]),
+	_ts_metadata("design:returntype", Promise)
+], WorldRoom.prototype, "connect", null);
+WorldRoom = _ts_decorate([
+	Room({
+		path: "world-{worldId}",
+		maxUsers: 100,
+		throttleStorage: 2e3,
+		throttleSync: 500
+	}),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [Object])
+], WorldRoom);
+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;
+			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 };
+
+//# sourceMappingURL=index.js.map