@rpgjs/client 5.0.0-beta.1 → 5.0.0-beta.11

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

@@ -0,0 +1,696 @@
+import { signal } from "../../../../../@signe_reactive@3.0.1/node_modules/@signe/reactive/dist/index.js";
+import { id, persist, sync } from "../../../../../@signe_sync@3.0.1/node_modules/@signe/sync/dist/index.js";
+import { __decorateClass } from "./chunk-EUXUH3YW.js";
+import { z } from "../../../../../zod@3.24.2/node_modules/zod/lib/index.js";
+//#region ../../node_modules/.pnpm/@signe+room@3.0.1/node_modules/@signe/room/dist/index.js
+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
+		});
+	};
+}
+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;
+	};
+}
+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);
+	};
+}
+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;
+}
+var Storage = class {
+	constructor() {
+		this.memory = /* @__PURE__ */ new Map();
+	}
+	async put(key, value) {
+		if (typeof key === "string") {
+			this.memory.set(key, value);
+			return;
+		}
+		for (const [entryKey, entryValue] of Object.entries(key)) this.memory.set(entryKey, entryValue);
+	}
+	async get(key) {
+		return this.memory.get(key);
+	}
+	async delete(key) {
+		if (Array.isArray(key)) {
+			let deleted = 0;
+			for (const entryKey of key) if (this.memory.delete(entryKey)) deleted += 1;
+			return deleted;
+		}
+		return this.memory.delete(key);
+	}
+	async list(options) {
+		if (!options?.prefix) return this.memory;
+		return new Map(Array.from(this.memory.entries()).filter(([key]) => String(key).startsWith(options.prefix)));
+	}
+};
+z.object({
+	action: z.string(),
+	value: z.any()
+});
+var INTERNAL_PREFIX = "$room:";
+`${INTERNAL_PREFIX}`;
+`${INTERNAL_PREFIX}`;
+async function request(room, path, options = { method: "GET" }) {
+	const url = new URL("http://localhost" + path);
+	const request2 = new Request(url.toString(), options);
+	return await room.onRequest(request2);
+}
+var MockPartyClient = class {
+	constructor(server, sessionId) {
+		this.server = server;
+		this.events = /* @__PURE__ */ new Map();
+		this.id = generateShortUUID();
+		this.conn = new MockConnection(this, sessionId || this.id);
+	}
+	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 {
+	constructor(server, lobbyId) {
+		this.server = server;
+		this.lobbyId = lobbyId;
+	}
+	socket(init) {
+		return new MockPartyClient(this.server, init?.id);
+	}
+	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 {
+	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: async (lobbyId) => {
+				if (!serverCache.has(lobbyId)) {
+					const server = await options.partyFn(lobbyId);
+					serverCache.set(lobbyId, new MockLobby(server, lobbyId));
+				}
+				return serverCache.get(lobbyId);
+			} };
+		} else for (let lobbyId in parties) {
+			const server = parties[lobbyId](room);
+			this.parties.main.set(lobbyId, new MockLobby(server, lobbyId));
+		}
+	}
+};
+var MockPartyRoom = class {
+	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) {
+		let connection;
+		for (const client of this.clients.values()) if (client.conn.id === id2 || client.conn.sessionId === id2) connection = client.conn;
+		return connection;
+	}
+	getConnections() {
+		return Array.from(this.clients.values()).map((client) => client.conn);
+	}
+	clear() {
+		this.clients.clear();
+	}
+	deleteConnection(id2, connection) {
+		if (connection) {
+			this.clients.delete(connection.id);
+			return;
+		}
+		for (const [connectionKey, client] of this.clients) if (client.conn.id === id2 || client.conn.sessionId === id2) this.clients.delete(connectionKey);
+	}
+};
+var MockConnection = class {
+	constructor(client, sessionId) {
+		this.client = client;
+		this.state = {};
+		this.server = client.server;
+		this.id = client.id;
+		this.sessionId = sessionId;
+	}
+	setState(value) {
+		this.state = value;
+	}
+	send(data) {
+		this.client._trigger("message", data);
+	}
+	close() {
+		this.server.room.deleteConnection?.(this.id, this);
+		this.server.onClose(this);
+	}
+};
+var ServerIo = MockPartyRoom;
+var ClientIo = MockPartyClient;
+var JWTAuth = class {
+	/**
+	* 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 = async (_, req, room) => {
+	const tokenShard = req.headers.get("x-access-shard");
+	if (tokenShard) {
+		if (tokenShard !== room.env.SHARD_SECRET) return false;
+		return true;
+	}
+	const token = getAuthToken(req, new URL(req.url));
+	if (!token) return false;
+	const jwt = new JWTAuth(room.env.AUTH_JWT_SECRET);
+	try {
+		const payload = await jwt.verify(token);
+		if (!payload) return false;
+		if (!canAccessWorld(payload, room.id)) return false;
+	} catch (error) {
+		return false;
+	}
+	return true;
+};
+function getAuthToken(req, url) {
+	const authorization = req.headers.get("Authorization");
+	if (authorization?.startsWith("Bearer ")) return authorization.slice(7).trim();
+	return authorization ?? url.searchParams.get("world-auth-token");
+}
+function canAccessWorld(payload, worldId) {
+	const worlds = payload.worlds;
+	if (!Array.isArray(worlds)) return false;
+	return worlds.some((world) => world === "*" || world === worldId);
+}
+var MAX_PLAYERS_PER_SHARD = 75;
+var RoomConfigSchema = 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(),
+	worldId: z.string().optional(),
+	url: z.string().url(),
+	maxConnections: z.number().int().positive()
+});
+var UpdateShardStatsSchema = z.object({
+	shardId: z.string(),
+	worldId: z.string().optional(),
+	connections: z.number().int().min(0),
+	status: z.enum([
+		"active",
+		"maintenance",
+		"draining"
+	]).optional()
+});
+var ScaleRoomSchema = 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 {
+	constructor() {
+		this.name = signal("");
+		this.balancingStrategy = signal("round-robin");
+		this.public = signal(true);
+		this.maxPlayersPerShard = signal(MAX_PLAYERS_PER_SHARD);
+		this.minShards = signal(1);
+		this.maxShards = signal(void 0);
+	}
+};
+__decorateClass([id()], RoomConfig.prototype, "id", 2);
+__decorateClass([sync()], RoomConfig.prototype, "name", 2);
+__decorateClass([sync()], RoomConfig.prototype, "balancingStrategy", 2);
+__decorateClass([sync()], RoomConfig.prototype, "public", 2);
+__decorateClass([sync()], RoomConfig.prototype, "maxPlayersPerShard", 2);
+__decorateClass([sync()], RoomConfig.prototype, "minShards", 2);
+__decorateClass([sync()], RoomConfig.prototype, "maxShards", 2);
+var ShardInfo = class {
+	constructor() {
+		this.roomId = signal("");
+		this.worldId = signal("");
+		this.url = signal("");
+		this.currentConnections = signal(0);
+		this.maxConnections = signal(MAX_PLAYERS_PER_SHARD);
+		this.status = signal("active");
+		this.lastHeartbeat = signal(0);
+	}
+};
+__decorateClass([id()], ShardInfo.prototype, "id", 2);
+__decorateClass([sync()], ShardInfo.prototype, "roomId", 2);
+__decorateClass([sync()], ShardInfo.prototype, "worldId", 2);
+__decorateClass([sync()], ShardInfo.prototype, "url", 2);
+__decorateClass([sync({ persist: false })], ShardInfo.prototype, "currentConnections", 2);
+__decorateClass([sync()], ShardInfo.prototype, "maxConnections", 2);
+__decorateClass([sync()], ShardInfo.prototype, "status", 2);
+__decorateClass([sync()], ShardInfo.prototype, "lastHeartbeat", 2);
+var WorldRoom = class {
+	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");
+		this.scheduleInactiveShardCleanup();
+	}
+	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;
+	}
+	getWorldId() {
+		return this.room.id;
+	}
+	scheduleInactiveShardCleanup() {
+		setTimeout(() => this.cleanupInactiveShards(), 6e4)?.unref?.();
+	}
+	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];
+		});
+		this.scheduleInactiveShardCleanup();
+	}
+	removeShard(shardId) {
+		delete this.shards()[shardId];
+	}
+	shouldCompleteDrain(shard) {
+		return shard.status() === "draining" && shard.currentConnections() === 0;
+	}
+	async registerRoom(req, res) {
+		const parseResult = RoomConfigSchema.safeParse(await req.json());
+		if (!parseResult.success) return res?.badRequest("Invalid room configuration", { details: parseResult.error });
+		const roomConfig = parseResult.data;
+		if (roomConfig.maxShards !== void 0 && roomConfig.minShards > roomConfig.maxShards) return res?.badRequest("minShards cannot be greater than maxShards");
+		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);
+		}
+		await this.ensureMinShards(roomId);
+	}
+	async updateShardStats(req, res) {
+		const parseResult = UpdateShardStatsSchema.safeParse(await req.json());
+		if (!parseResult.success) return res.badRequest("Invalid shard stats", { details: parseResult.error });
+		const body = parseResult.data;
+		const { shardId, connections, status } = body;
+		const shard = this.shards()[shardId];
+		if (!shard) return res.notFound(`Shard ${shardId} not found`);
+		if (body.worldId && body.worldId !== this.getWorldId()) return res.badRequest(`Shard ${shardId} belongs to world ${body.worldId}, not ${this.getWorldId()}`);
+		shard.currentConnections.set(connections);
+		if (status) shard.status.set(status);
+		shard.lastHeartbeat.set(Date.now());
+		if (this.shouldCompleteDrain(shard)) this.removeShard(shard.id);
+	}
+	async scaleRoom(req, res) {
+		const parseResult = ScaleRoomSchema.safeParse(await req.json());
+		if (!parseResult.success) return res.badRequest("Invalid scale room request", { details: parseResult.error });
+		const { targetShardCount, shardTemplate, roomId } = parseResult.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 shardsToDrain = [...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);
+			for (const shard of shardsToDrain) {
+				shard.status.set("draining");
+				if (this.shouldCompleteDrain(shard)) this.removeShard(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) {
+			await this.registerRoom({ json: async () => ({
+				name: roomId,
+				balancingStrategy: "round-robin",
+				public: true,
+				maxPlayersPerShard: this.defaultMaxConnectionsPerShard(),
+				minShards: 1,
+				maxShards: void 0
+			}) });
+			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}` };
+		let activeShards = this.getAvailableShards(roomShards);
+		if (activeShards.length === 0) {
+			if (autoCreate && this.canCreateShard(room, roomShards.length)) {
+				const newShard = await this.createShard(roomId);
+				if (newShard) return {
+					shardId: newShard.id,
+					url: newShard.url()
+				};
+			}
+			if (roomShards.some((shard) => shard.status() === "active")) return { error: `No shard capacity available for room ${roomId}` };
+			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()
+		};
+	}
+	getAvailableShards(shards) {
+		return shards.filter((shard) => shard && shard.status() === "active" && shard.currentConnections() < shard.maxConnections());
+	}
+	canCreateShard(room, currentShardCount) {
+		return room.maxShards() === void 0 || currentShardCount < room.maxShards();
+	}
+	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 worldId = this.getWorldId();
+		const shardId = `${roomId}:${worldId}:${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.worldId.set(worldId);
+		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;
+	}
+	async ensureMinShards(roomId) {
+		const room = this.rooms()[roomId];
+		if (!room) return;
+		const currentShardCount = Object.values(this.shards()).filter((shard) => shard.roomId() === roomId).length;
+		const targetShardCount = room.minShards();
+		if (currentShardCount >= targetShardCount) return;
+		for (let i = currentShardCount; i < targetShardCount; i++) await this.createShard(roomId);
+	}
+};
+__decorateClass([sync(RoomConfig)], WorldRoom.prototype, "rooms", 2);
+__decorateClass([sync(ShardInfo)], WorldRoom.prototype, "shards", 2);
+__decorateClass([persist()], WorldRoom.prototype, "rrCounters", 2);
+__decorateClass([Request2({
+	path: "register-room",
+	method: "POST"
+}), Guard([guardManageWorld])], WorldRoom.prototype, "registerRoom", 1);
+__decorateClass([Request2({
+	path: "update-shard",
+	method: "POST"
+}), Guard([guardManageWorld])], WorldRoom.prototype, "updateShardStats", 1);
+__decorateClass([Request2({
+	path: "scale-room",
+	method: "POST"
+}), Guard([guardManageWorld])], WorldRoom.prototype, "scaleRoom", 1);
+__decorateClass([Request2({
+	path: "connect",
+	method: "POST"
+})], WorldRoom.prototype, "connect", 1);
+WorldRoom = __decorateClass([Room({
+	path: "world-{worldId}",
+	maxUsers: 100,
+	throttleStorage: 2e3,
+	throttleSync: 500
+})], WorldRoom);
+//#endregion
+export { ClientIo, ServerIo };
+
+//# sourceMappingURL=index.js.map