@rpgjs/client 5.0.0-beta.6 → 5.0.0-beta.8

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

@@ -0,0 +1,611 @@
+import { signal } from "../../../../../@signe_reactive@2.10.0/node_modules/@signe/reactive/dist/index.js";
+import { id, persist, sync } from "../../../../../@signe_sync@2.10.0/node_modules/@signe/sync/dist/index.js";
+import { z } from "../../../../../zod@3.24.2/node_modules/zod/lib/index.js";
+//#region ../../node_modules/.pnpm/@signe+room@2.10.0/node_modules/@signe/room/dist/index.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+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) {
+		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;
+	}
+};
+z.object({
+	action: z.string(),
+	value: z.any()
+});
+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, 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 {
+	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 {
+	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) {
+		return this.clients.get(id2);
+	}
+	getConnections() {
+		return Array.from(this.clients.values()).map((client) => client.conn);
+	}
+	clear() {
+		this.clients.clear();
+	}
+};
+var MockConnection = class {
+	constructor(client) {
+		this.client = client;
+		this.state = {};
+		this.server = client.server;
+		this.id = client.id;
+	}
+	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 {
+	/**
+	* 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 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;
+};
+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 {
+	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.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, "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");
+	}
+	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) {
+			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}` };
+		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;
+	}
+};
+__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