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

package/dist/node_modules/.pnpm/{@signe_room@2.10.0 → @signe_room@3.0.1}/node_modules/@signe/room/dist/index.js

@@ -1,15 +1,8 @@
-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 { 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@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;
-};
+//#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();
@@ -55,33 +48,46 @@ var Storage = class {
 		this.memory = /* @__PURE__ */ new Map();
 	}
 	async put(key, value) {
-		this.memory.set(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) {
-		this.memory.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() {
-		return this.memory;
+	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, id2) {
+	constructor(server, sessionId) {
 		this.server = server;
 		this.events = /* @__PURE__ */ new Map();
-		this.id = id2 || generateShortUUID();
-		this.conn = new MockConnection(this);
+		this.id = generateShortUUID();
+		this.conn = new MockConnection(this, sessionId || this.id);
 	}
 	addEventListener(event, cb) {
 		if (!this.events.has(event)) this.events.set(event, []);
@@ -107,8 +113,8 @@ var MockLobby = class {
 		this.server = server;
 		this.lobbyId = lobbyId;
 	}
-	socket(_init) {
-		return new MockPartyClient(this.server);
+	socket(init) {
+		return new MockPartyClient(this.server, init?.id);
 	}
 	async connection(idOrOptions, maybeOptions) {
 		const id2 = typeof idOrOptions === "string" ? idOrOptions : idOrOptions?.id;
@@ -174,7 +180,9 @@ var MockPartyRoom = class {
 		});
 	}
 	getConnection(id2) {
-		return this.clients.get(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);
@@ -182,13 +190,21 @@ var MockPartyRoom = class {
 	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) {
+	constructor(client, sessionId) {
 		this.client = client;
 		this.state = {};
 		this.server = client.server;
 		this.id = client.id;
+		this.sessionId = sessionId;
 	}
 	setState(value) {
 		this.state = value;
@@ -197,6 +213,7 @@ var MockConnection = class {
 		this.client._trigger("message", data);
 	}
 	close() {
+		this.server.room.deleteConnection?.(this.id, this);
 		this.server.onClose(this);
 	}
 };
@@ -318,19 +335,30 @@ var guardManageWorld = async (_, req, room) => {
 		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");
+	const token = getAuthToken(req, new URL(req.url));
 	if (!token) return false;
 	const jwt = new JWTAuth(room.env.AUTH_JWT_SECRET);
 	try {
-		if (!await jwt.verify(token)) return false;
+		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;
-z.object({
+var RoomConfigSchema = z.object({
 	name: z.string(),
 	balancingStrategy: z.enum([
 		"round-robin",
@@ -345,10 +373,13 @@ z.object({
 z.object({
 	shardId: z.string(),
 	roomId: z.string(),
+	worldId: z.string().optional(),
 	url: z.string().url(),
 	maxConnections: z.number().int().positive()
 });
-z.object({
+var UpdateShardStatsSchema = z.object({
+	shardId: z.string(),
+	worldId: z.string().optional(),
 	connections: z.number().int().min(0),
 	status: z.enum([
 		"active",
@@ -356,7 +387,7 @@ z.object({
 		"draining"
 	]).optional()
 });
-z.object({
+var ScaleRoomSchema = z.object({
 	roomId: z.string(),
 	targetShardCount: z.number().int().positive(),
 	shardTemplate: z.object({
@@ -384,6 +415,7 @@ __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);
@@ -393,6 +425,7 @@ var ShardInfo = class {
 };
 __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);
@@ -409,6 +442,7 @@ var WorldRoom = class {
 		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);
@@ -421,6 +455,12 @@ var WorldRoom = class {
 		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;
@@ -428,10 +468,19 @@ var WorldRoom = class {
 		Object.values(shardsValue).forEach((shard) => {
 			if (now - shard.lastHeartbeat() > timeout) delete this.shards()[shard.id];
 		});
-		setTimeout(() => this.cleanupInactiveShards(), 6e4);
+		this.scheduleInactiveShardCleanup();
 	}
-	async registerRoom(req) {
-		const roomConfig = await req.json();
+	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();
@@ -452,17 +501,25 @@ var WorldRoom = class {
 			room.minShards.set(roomConfig.minShards);
 			room.maxShards.set(roomConfig.maxShards);
 		}
+		await this.ensureMinShards(roomId);
 	}
 	async updateShardStats(req, res) {
-		const { shardId, connections, status } = await req.json();
+		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 { targetShardCount, shardTemplate, roomId } = await req.json();
+		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);
@@ -472,13 +529,15 @@ var WorldRoom = class {
 			currentShardCount: previousShardCount
 		});
 		if (targetShardCount < previousShardCount) {
-			const shardsToRemove = [...roomShards].sort((a, b) => {
+			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);
-			roomShards.filter((shard) => !shardsToRemove.some((s) => s.id === shard.id));
-			for (const shard of shardsToRemove) delete this.shards()[shard.id];
+			for (const shard of shardsToDrain) {
+				shard.status.set("draining");
+				if (this.shouldCompleteDrain(shard)) this.removeShard(shard.id);
+			}
 			return;
 		}
 		if (targetShardCount > previousShardCount) {
@@ -536,8 +595,18 @@ var WorldRoom = class {
 			};
 			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}` };
+		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) {
@@ -559,18 +628,26 @@ var WorldRoom = class {
 			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 shardId = `${roomId}:${Date.now()}-${Math.floor(Math.random() * 1e4)}`;
+		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);
@@ -579,6 +656,14 @@ var WorldRoom = class {
 		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);