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

package/dist/module.d.ts

@@ -1,2 +1,44 @@
 import { FactoryProvider } from '@signe/di';
-export declare function provideServerModules(modules: any[]): FactoryProvider;
+import { RpgServer } from './RpgServer';
+/**
+ * Type for server modules that can be either:
+ * - An object implementing RpgServer interface
+ * - A class decorated with @RpgModule decorator
+ */
+export type RpgServerModule = RpgServer | (new () => any);
+/**
+ * Provides server modules configuration to Angular Dependency Injection
+ *
+ * This function accepts an array of server modules that can be either:
+ * - Objects implementing the RpgServer interface
+ * - Classes decorated with the @RpgModule decorator (which will be instantiated)
+ *
+ * @param modules - Array of server modules (objects or classes)
+ * @returns FactoryProvider configuration for Angular DI
+ * @example
+ * ```ts
+ * // Using an object
+ * provideServerModules([
+ *   {
+ *     player: {
+ *       onConnected(player) {
+ *         console.log('Player connected')
+ *       }
+ *     }
+ *   }
+ * ])
+ *
+ * // Using a decorated class
+ * @RpgModule<RpgServer>({
+ *   engine: {
+ *     onStart(server) {
+ *       console.log('Server started')
+ *     }
+ *   }
+ * })
+ * class MyServerModule {}
+ *
+ * provideServerModules([MyServerModule])
+ * ```
+ */
+export declare function provideServerModules(modules: RpgServerModule[]): FactoryProvider;

package/dist/node/connection.d.ts

@@ -0,0 +1,51 @@
+import { RpgWebSocketConnection } from './types';
+export declare class PartyConnection {
+    private ws;
+    id: string;
+    uri: string;
+    private _state;
+    private messageQueue;
+    private isProcessingQueue;
+    private sequenceCounter;
+    private incomingQueue;
+    private isProcessingIncomingQueue;
+    static packetLossRate: number;
+    static packetLossEnabled: boolean;
+    static packetLossFilter: string;
+    static bandwidthEnabled: boolean;
+    static bandwidthKbps: number;
+    static bandwidthFilter: string;
+    static latencyEnabled: boolean;
+    static latencyMs: number;
+    static latencyFilter: string;
+    constructor(ws: RpgWebSocketConnection, id?: string, uri?: string);
+    private generateId;
+    send(data: any): Promise<void>;
+    private processMessageQueue;
+    private shouldApplyLatency;
+    private waitUntil;
+    close(): void;
+    setState(value: any): void;
+    get state(): any;
+    bufferIncoming(message: string, processor: (messages: string[]) => Promise<void>): void;
+    private processIncomingQueue;
+    static configurePacketLoss(enabled: boolean, rate: number, filter?: string): void;
+    static getPacketLossStatus(): {
+        enabled: boolean;
+        rate: number;
+        filter: string;
+    };
+    static configureBandwidth(enabled: boolean, kbps: number, filter?: string): void;
+    static getBandwidthStatus(): {
+        enabled: boolean;
+        kbps: number;
+        filter: string;
+    };
+    static configureLatency(enabled: boolean, ms: number, filter?: string): void;
+    static getLatencyStatus(): {
+        enabled: boolean;
+        ms: number;
+        filter: string;
+    };
+}
+export declare function logNetworkSimulationStatus(): void;

package/dist/node/index.d.ts

@@ -0,0 +1,5 @@
+export { PartyConnection, logNetworkSimulationStatus } from './connection';
+export { createMapUpdateHeaders, isMapUpdateAuthorized, MAP_UPDATE_TOKEN_ENV, MAP_UPDATE_TOKEN_HEADER, readMapUpdateToken, resolveMapUpdateToken, } from './map';
+export { PartyRoom } from './room';
+export { createRpgServerTransport, RpgServerTransport } from './transport';
+export type { CreateRpgServerTransportOptions, HandleNodeRequestOptions, RpgTransportRequestLike, RpgTransportServer, RpgTransportServerConstructor, RpgWebSocketConnection, RpgWebSocketRequestLike, RpgWebSocketServer, SendMapUpdateOptions, } from './types';

package/dist/node/index.js

@@ -0,0 +1,551 @@
+import { a as isMapUpdateAuthorized, c as updateMap, h as injector, i as createMapUpdateHeaders, l as context, n as MAP_UPDATE_TOKEN_ENV, o as readMapUpdateToken, p as setInject, r as MAP_UPDATE_TOKEN_HEADER, s as resolveMapUpdateToken, t as provideServerModules } from "../module-CaCW1SDh.js";
+//#region src/node/connection.ts
+function readEnvVariable(name) {
+	const value = globalThis.process?.env?.[name];
+	return typeof value === "string" ? value : void 0;
+}
+var PartyConnection = class PartyConnection {
+	static {
+		this.packetLossRate = parseFloat(readEnvVariable("RPGJS_PACKET_LOSS_RATE") || "0.1");
+	}
+	static {
+		this.packetLossEnabled = readEnvVariable("RPGJS_ENABLE_PACKET_LOSS") === "true";
+	}
+	static {
+		this.packetLossFilter = readEnvVariable("RPGJS_PACKET_LOSS_FILTER") || "";
+	}
+	static {
+		this.bandwidthEnabled = readEnvVariable("RPGJS_ENABLE_BANDWIDTH") === "true";
+	}
+	static {
+		this.bandwidthKbps = parseInt(readEnvVariable("RPGJS_BANDWIDTH_KBPS") || "100");
+	}
+	static {
+		this.bandwidthFilter = readEnvVariable("RPGJS_BANDWIDTH_FILTER") || "";
+	}
+	static {
+		this.latencyEnabled = readEnvVariable("RPGJS_ENABLE_LATENCY") === "true";
+	}
+	static {
+		this.latencyMs = parseInt(readEnvVariable("RPGJS_LATENCY_MS") || "50");
+	}
+	static {
+		this.latencyFilter = readEnvVariable("RPGJS_LATENCY_FILTER") || "";
+	}
+	constructor(ws, id, uri) {
+		this.ws = ws;
+		this._state = {};
+		this.messageQueue = [];
+		this.isProcessingQueue = false;
+		this.sequenceCounter = 0;
+		this.incomingQueue = [];
+		this.isProcessingIncomingQueue = false;
+		this.id = id || this.generateId();
+		this.uri = uri || "";
+	}
+	generateId() {
+		return `conn_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+	}
+	async send(data) {
+		if (this.ws.readyState !== 1) return;
+		const message = typeof data === "string" ? data : JSON.stringify(data);
+		const timestamp = Date.now();
+		const sequence = ++this.sequenceCounter;
+		this.messageQueue.push({
+			message,
+			timestamp,
+			sequence
+		});
+		if (!this.isProcessingQueue) this.processMessageQueue();
+	}
+	async processMessageQueue() {
+		if (this.isProcessingQueue) return;
+		this.isProcessingQueue = true;
+		while (this.messageQueue.length > 0) {
+			const queueItem = this.messageQueue.shift();
+			if (this.shouldApplyLatency(queueItem.message)) await this.waitUntil(queueItem.timestamp + PartyConnection.latencyMs);
+			if (PartyConnection.bandwidthEnabled && PartyConnection.bandwidthKbps > 0) {
+				if (!PartyConnection.bandwidthFilter || queueItem.message.includes(PartyConnection.bandwidthFilter)) {
+					const transmissionTimeMs = queueItem.message.length * 8 / (PartyConnection.bandwidthKbps * 1e3) * 1e3;
+					const bandwidthDelayMs = Math.max(transmissionTimeMs, 10);
+					console.log(`\x1b[34m[BANDWIDTH SIMULATION]\x1b[0m Connection ${this.id}: Message #${queueItem.sequence} transmission time: ${bandwidthDelayMs.toFixed(1)}ms`);
+					await new Promise((resolve) => setTimeout(resolve, bandwidthDelayMs));
+				}
+			}
+			this.ws.send(queueItem.message);
+		}
+		this.isProcessingQueue = false;
+	}
+	shouldApplyLatency(message) {
+		if (!PartyConnection.latencyEnabled || PartyConnection.latencyMs <= 0) return false;
+		if (!PartyConnection.latencyFilter) return true;
+		return message.includes(PartyConnection.latencyFilter);
+	}
+	async waitUntil(targetTimestamp) {
+		const delayMs = targetTimestamp - Date.now();
+		if (delayMs <= 0) return;
+		await new Promise((resolve) => setTimeout(resolve, delayMs));
+	}
+	close() {
+		if (this.ws.readyState === 1) this.ws.close();
+	}
+	setState(value) {
+		this._state = value;
+	}
+	get state() {
+		return this._state;
+	}
+	bufferIncoming(message, processor) {
+		this.incomingQueue.push({
+			message,
+			timestamp: Date.now(),
+			processor
+		});
+		if (!this.isProcessingIncomingQueue) this.processIncomingQueue();
+	}
+	async processIncomingQueue() {
+		if (this.isProcessingIncomingQueue) return;
+		this.isProcessingIncomingQueue = true;
+		while (this.incomingQueue.length > 0) {
+			const item = this.incomingQueue.shift();
+			if (this.shouldApplyLatency(item.message)) await this.waitUntil(item.timestamp + PartyConnection.latencyMs);
+			try {
+				await item.processor([item.message]);
+			} catch (err) {
+				console.error("Error processing incoming message:", err);
+			}
+		}
+		this.isProcessingIncomingQueue = false;
+	}
+	static configurePacketLoss(enabled, rate, filter) {
+		PartyConnection.packetLossEnabled = enabled;
+		PartyConnection.packetLossRate = Math.max(0, Math.min(1, rate));
+		PartyConnection.packetLossFilter = filter || "";
+		if (enabled && rate > 0) {
+			const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+			console.log(`\x1b[35m[PACKET LOSS SIMULATION]\x1b[0m Enabled with ${(rate * 100).toFixed(1)}% loss rate${filterInfo}`);
+		} else if (enabled) console.log("\x1B[35m[PACKET LOSS SIMULATION]\x1B[0m Enabled but rate is 0% (no messages will be dropped)");
+		else console.log("\x1B[35m[PACKET LOSS SIMULATION]\x1B[0m Disabled");
+	}
+	static getPacketLossStatus() {
+		return {
+			enabled: PartyConnection.packetLossEnabled,
+			rate: PartyConnection.packetLossRate,
+			filter: PartyConnection.packetLossFilter
+		};
+	}
+	static configureBandwidth(enabled, kbps, filter) {
+		PartyConnection.bandwidthEnabled = enabled;
+		PartyConnection.bandwidthKbps = Math.max(1, kbps);
+		PartyConnection.bandwidthFilter = filter || "";
+		if (enabled && kbps > 0) {
+			const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+			console.log(`\x1b[35m[BANDWIDTH SIMULATION]\x1b[0m Enabled with ${kbps} kbps bandwidth${filterInfo}`);
+		} else if (enabled) console.log("\x1B[35m[BANDWIDTH SIMULATION]\x1B[0m Enabled but bandwidth is 0 kbps (no delay will be applied)");
+		else console.log("\x1B[35m[BANDWIDTH SIMULATION]\x1B[0m Disabled");
+	}
+	static getBandwidthStatus() {
+		return {
+			enabled: PartyConnection.bandwidthEnabled,
+			kbps: PartyConnection.bandwidthKbps,
+			filter: PartyConnection.bandwidthFilter
+		};
+	}
+	static configureLatency(enabled, ms, filter) {
+		PartyConnection.latencyEnabled = enabled;
+		PartyConnection.latencyMs = Math.max(0, ms);
+		PartyConnection.latencyFilter = filter || "";
+		if (enabled && ms > 0) {
+			const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+			console.log(`\x1b[35m[LATENCY SIMULATION]\x1b[0m Enabled with ${ms}ms fixed latency${filterInfo}`);
+		} else if (enabled) console.log("\x1B[35m[LATENCY SIMULATION]\x1B[0m Enabled but latency is 0ms (no delay will be applied)");
+		else console.log("\x1B[35m[LATENCY SIMULATION]\x1B[0m Disabled");
+	}
+	static getLatencyStatus() {
+		return {
+			enabled: PartyConnection.latencyEnabled,
+			ms: PartyConnection.latencyMs,
+			filter: PartyConnection.latencyFilter
+		};
+	}
+};
+function logNetworkSimulationStatus() {
+	const packetLossStatus = PartyConnection.getPacketLossStatus();
+	const bandwidthStatus = PartyConnection.getBandwidthStatus();
+	const latencyStatus = PartyConnection.getLatencyStatus();
+	if (packetLossStatus.enabled) {
+		const filterInfo = packetLossStatus.filter ? ` (filter: "${packetLossStatus.filter}")` : "";
+		console.log(`\x1b[36m[NETWORK SIMULATION]\x1b[0m Packet loss simulation: ${(packetLossStatus.rate * 100).toFixed(1)}% loss rate${filterInfo}`);
+	} else console.log("\x1B[36m[NETWORK SIMULATION]\x1B[0m Packet loss simulation: disabled");
+	if (bandwidthStatus.enabled) {
+		const filterInfo = bandwidthStatus.filter ? ` (filter: "${bandwidthStatus.filter}")` : "";
+		console.log(`\x1b[36m[NETWORK SIMULATION]\x1b[0m Bandwidth simulation: ${bandwidthStatus.kbps} kbps${filterInfo}`);
+	} else console.log("\x1B[36m[NETWORK SIMULATION]\x1B[0m Bandwidth simulation: disabled");
+	if (latencyStatus.enabled) {
+		const filterInfo = latencyStatus.filter ? ` (filter: "${latencyStatus.filter}")` : "";
+		console.log(`\x1b[36m[NETWORK SIMULATION]\x1b[0m Latency simulation: ${latencyStatus.ms}ms ping${filterInfo}`);
+	} else console.log("\x1B[36m[NETWORK SIMULATION]\x1B[0m Latency simulation: disabled");
+}
+//#endregion
+//#region src/node/room.ts
+var PartyRoom = class {
+	constructor(id) {
+		this.env = {};
+		this.context = {};
+		this.connections = /* @__PURE__ */ new Map();
+		this.storageData = /* @__PURE__ */ new Map();
+		this.id = id;
+		this.internalID = `internal_${id}_${Date.now()}`;
+	}
+	async broadcast(message, except = []) {
+		const data = typeof message === "string" ? message : JSON.stringify(message);
+		const sendPromises = [];
+		for (const [connectionId, connection] of this.connections) if (!except.includes(connectionId)) sendPromises.push(connection.send(data));
+		await Promise.all(sendPromises);
+	}
+	getConnection(id) {
+		return this.connections.get(id);
+	}
+	getConnections(tag) {
+		return this.connections.values();
+	}
+	addConnection(connection) {
+		this.connections.set(connection.id, connection);
+	}
+	removeConnection(connectionId) {
+		this.connections.delete(connectionId);
+	}
+	get storage() {
+		return {
+			put: async (key, value) => {
+				this.storageData.set(key, value);
+			},
+			get: async (key) => {
+				return this.storageData.get(key);
+			},
+			delete: async (key) => {
+				this.storageData.delete(key);
+			},
+			list: async () => {
+				return Array.from(this.storageData.entries());
+			}
+		};
+	}
+};
+//#endregion
+//#region src/node/transport.ts
+function normalizePathPrefix(path, fallback) {
+	const trimmed = (path || fallback).trim();
+	if (!trimmed) return fallback;
+	const prefixed = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+	return prefixed !== "/" ? prefixed.replace(/\/+$/, "") : prefixed;
+}
+function hasPathPrefix(pathname, prefix) {
+	return pathname === prefix || pathname.startsWith(`${prefix}/`);
+}
+function prependMountedPath(pathname, mountedPath) {
+	if (!mountedPath) return pathname;
+	const normalizedMountedPath = normalizePathPrefix(mountedPath, "/");
+	if (hasPathPrefix(pathname, normalizedMountedPath)) return pathname;
+	if (pathname === "/") return normalizedMountedPath;
+	return `${normalizedMountedPath}${pathname.startsWith("/") ? pathname : `/${pathname}`}`.replace(/\/{2,}/g, "/");
+}
+function parseHttpRoute(pathname, partiesPath) {
+	if (!hasPathPrefix(pathname, partiesPath)) return null;
+	const segments = pathname.slice(partiesPath.length).split("/").filter(Boolean);
+	if (segments.length < 2) return null;
+	return {
+		roomId: segments[0],
+		requestPath: `/${segments.slice(1).join("/")}`
+	};
+}
+function parseSocketRoute(pathname, partiesPath) {
+	if (!hasPathPrefix(pathname, partiesPath)) return null;
+	const segments = pathname.slice(partiesPath.length).split("/").filter(Boolean);
+	if (segments.length < 1) return null;
+	return { roomId: segments[0] };
+}
+function toHeaders(input) {
+	if (!input) return new Headers();
+	if (input instanceof Headers) return new Headers(input);
+	if (Array.isArray(input)) return new Headers(input);
+	if (input instanceof Map) {
+		const headers = new Headers();
+		for (const [key, value] of input) if (typeof value !== "undefined") headers.set(key, value);
+		return headers;
+	}
+	const headers = new Headers();
+	Object.entries(input).forEach(([key, value]) => {
+		if (Array.isArray(value)) {
+			if (typeof value[0] !== "undefined") headers.set(key, value[0]);
+			return;
+		}
+		if (typeof value !== "undefined") headers.set(key, String(value));
+	});
+	return headers;
+}
+function createRequestLike(url, method, headers, bodyText) {
+	return {
+		url,
+		method,
+		headers,
+		json: async () => {
+			if (!bodyText) return;
+			return JSON.parse(bodyText);
+		},
+		text: async () => bodyText
+	};
+}
+async function normalizeEngineResponse(result) {
+	if (result instanceof Response) return result;
+	if (typeof result === "string") return new Response(result, {
+		status: 200,
+		headers: { "Content-Type": "text/plain" }
+	});
+	return new Response(JSON.stringify(result ?? {}), {
+		status: 200,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+async function sendNodeResponse(res, response) {
+	res.statusCode = response.status;
+	response.headers.forEach((value, key) => {
+		res.setHeader(key, value);
+	});
+	res.end(await response.text());
+}
+async function readNodeBody(req) {
+	return await new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => {
+			chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+		});
+		req.on("end", () => {
+			resolve(Buffer.concat(chunks).toString("utf8"));
+		});
+		req.on("error", reject);
+	});
+}
+function resolveUrlFromSocketRequest(request) {
+	const headers = toHeaders(request.headers);
+	const host = headers.get("host") || "localhost";
+	const rawUrl = request.url || "/";
+	const url = new URL(rawUrl, `http://${host}`);
+	return {
+		headers,
+		method: request.method,
+		rawUrl,
+		url
+	};
+}
+function createConnectionContext(url, headers, method) {
+	const normalizedHeaders = /* @__PURE__ */ new Map();
+	headers.forEach((value, key) => {
+		normalizedHeaders.set(key.toLowerCase(), value);
+	});
+	return {
+		request: {
+			headers: {
+				has: (name) => normalizedHeaders.has(name.toLowerCase()),
+				get: (name) => normalizedHeaders.get(name.toLowerCase()),
+				entries: () => normalizedHeaders.entries(),
+				keys: () => normalizedHeaders.keys(),
+				values: () => normalizedHeaders.values()
+			},
+			method,
+			url: url.toString()
+		},
+		url
+	};
+}
+var RpgServerTransport = class {
+	constructor(serverModule, options = {}) {
+		this.serverModule = serverModule;
+		this.serverContextInitialized = false;
+		this.rooms = /* @__PURE__ */ new Map();
+		this.servers = /* @__PURE__ */ new Map();
+		this.lastKnownHost = "";
+		this.initializeMaps = options.initializeMaps ?? true;
+		this.mapUpdateToken = resolveMapUpdateToken(options.mapUpdateToken);
+		this.partiesPath = normalizePathPrefix(options.partiesPath || "/parties/main", "/parties/main");
+		this.tiledBasePaths = options.tiledBasePaths;
+	}
+	async ensureServerContext() {
+		if (this.serverContextInitialized) return;
+		setInject(context);
+		await injector(context, [provideServerModules([])]);
+		this.serverContextInitialized = true;
+	}
+	getRoom(roomId) {
+		return this.rooms.get(roomId);
+	}
+	getServer(roomId) {
+		return this.servers.get(roomId);
+	}
+	async ensureRoomAndServer(roomId, host) {
+		if (host) this.lastKnownHost = host;
+		let room = this.rooms.get(roomId);
+		if (!room) {
+			room = new PartyRoom(roomId);
+			this.rooms.set(roomId, room);
+			console.log(`Created new room: ${roomId}`);
+		}
+		let rpgServer = this.servers.get(roomId);
+		if (!rpgServer) {
+			await this.ensureServerContext();
+			rpgServer = new this.serverModule(room);
+			this.servers.set(roomId, rpgServer);
+			console.log(`Created new server instance for room: ${roomId}`);
+			if (typeof rpgServer.onStart === "function") try {
+				await rpgServer.onStart();
+				console.log(`Server started for room: ${roomId}`);
+			} catch (error) {
+				console.error(`Error starting server for room ${roomId}:`, error);
+			}
+			if (this.initializeMaps) await updateMap(roomId, rpgServer, {
+				host: host || this.lastKnownHost,
+				mapUpdateToken: this.mapUpdateToken,
+				tiledBasePaths: this.tiledBasePaths
+			});
+		}
+		room.context.parties = this.buildPartiesContext();
+		return {
+			room,
+			rpgServer
+		};
+	}
+	buildPartiesContext() {
+		return { main: { get: async (targetRoomId) => {
+			return { fetch: async (path, init) => {
+				const method = (init?.method || "GET").toUpperCase();
+				const headers = toHeaders(init?.headers);
+				const requestPath = path.startsWith("/") ? path : `/${path}`;
+				let bodyText = "";
+				if (typeof init?.body === "string") bodyText = init.body;
+				else if (typeof init?.body !== "undefined") bodyText = JSON.stringify(init.body);
+				return this.dispatchRoomRequest(targetRoomId, createRequestLike(`http://localhost${this.partiesPath}/${targetRoomId}${requestPath}`, method, headers, bodyText), this.lastKnownHost);
+			} };
+		} } };
+	}
+	async dispatchRoomRequest(roomId, requestLike, host) {
+		const { room, rpgServer } = await this.ensureRoomAndServer(roomId, host);
+		room.context.parties = this.buildPartiesContext();
+		return normalizeEngineResponse(await rpgServer.onRequest?.(requestLike));
+	}
+	async fetch(request, init) {
+		const webRequest = request instanceof Request ? request : new Request(String(request), init);
+		const url = new URL(webRequest.url);
+		const route = parseHttpRoute(url.pathname, this.partiesPath);
+		if (!route) return new Response(JSON.stringify({ error: "Not found" }), {
+			status: 404,
+			headers: { "Content-Type": "application/json" }
+		});
+		const bodyText = await webRequest.text();
+		return this.dispatchRoomRequest(route.roomId, createRequestLike(webRequest.url, webRequest.method.toUpperCase(), toHeaders(webRequest.headers), bodyText), url.host);
+	}
+	async updateMap(mapId, payload, options = {}) {
+		const roomId = mapId.startsWith("map-") ? mapId : `map-${mapId}`;
+		const headers = createMapUpdateHeaders(this.mapUpdateToken, options.headers);
+		if (!headers.has("content-type")) headers.set("content-type", "application/json");
+		return this.dispatchRoomRequest(roomId, createRequestLike(`http://localhost${this.partiesPath}/${roomId}/map/update`, "POST", headers, JSON.stringify(payload)), options.host ?? this.lastKnownHost);
+	}
+	async handleNodeRequest(req, res, next, options = {}) {
+		try {
+			const headers = toHeaders(req.headers);
+			const host = headers.get("host") || "localhost";
+			const url = new URL(req.url || "/", `http://${host}`);
+			const normalizedPathname = prependMountedPath(url.pathname, options.mountedPath);
+			const normalizedUrl = new URL(url.toString());
+			normalizedUrl.pathname = normalizedPathname;
+			const route = parseHttpRoute(normalizedUrl.pathname, this.partiesPath);
+			if (!route) {
+				next?.();
+				return false;
+			}
+			const bodyText = await readNodeBody(req);
+			await sendNodeResponse(res, await this.dispatchRoomRequest(route.roomId, createRequestLike(normalizedUrl.toString(), (req.method || "GET").toUpperCase(), headers, bodyText), host));
+			return true;
+		} catch (error) {
+			console.error("Error handling RPG-JS request:", error);
+			res.statusCode = 500;
+			res.setHeader("Content-Type", "application/json");
+			res.end(JSON.stringify({ error: "Internal server error" }));
+			return true;
+		}
+	}
+	async acceptWebSocket(ws, request) {
+		const normalizedRequest = resolveUrlFromSocketRequest(request);
+		const route = parseSocketRoute(normalizedRequest.url.pathname, this.partiesPath);
+		if (!route) return false;
+		try {
+			console.log(`WebSocket upgrade request: ${normalizedRequest.url.pathname}`);
+			const queryParams = Object.fromEntries(normalizedRequest.url.searchParams.entries());
+			console.log(`Room: ${route.roomId}, Query params:`, queryParams);
+			const { room, rpgServer } = await this.ensureRoomAndServer(route.roomId, normalizedRequest.url.host);
+			room.context.parties = this.buildPartiesContext();
+			const connection = new PartyConnection(ws, queryParams._pk, normalizedRequest.rawUrl);
+			room.addConnection(connection);
+			console.log(`WebSocket connection established: ${connection.id} in room: ${route.roomId}`);
+			let isClosed = false;
+			const cleanup = async (logMessage, error) => {
+				if (isClosed) return;
+				isClosed = true;
+				if (logMessage) console.log(logMessage);
+				if (error) console.error("WebSocket error:", error);
+				room.removeConnection(connection.id);
+				await rpgServer.onClose?.(connection);
+			};
+			ws.on("message", async (data) => {
+				try {
+					const rawMessage = typeof data === "string" ? data : data.toString();
+					if (PartyConnection.packetLossEnabled && PartyConnection.packetLossRate > 0) {
+						if (!PartyConnection.packetLossFilter || rawMessage.includes(PartyConnection.packetLossFilter)) {
+							if (Math.random() < PartyConnection.packetLossRate) {
+								console.log(`\x1b[31m[PACKET LOSS]\x1b[0m Connection ${connection.id}: Server dropped an incoming packet (${(PartyConnection.packetLossRate * 100).toFixed(1)}% loss rate)`);
+								console.log(`\x1b[33m[PACKET DATA]\x1b[0m ${rawMessage.slice(0, 100)}${rawMessage.length > 100 ? "..." : ""}`);
+								return;
+							}
+						}
+					}
+					connection.bufferIncoming(rawMessage, async (batch) => {
+						for (const message of batch) await rpgServer.onMessage?.(message, connection);
+					});
+				} catch (error) {
+					console.error("Error processing WebSocket message:", error);
+				}
+			});
+			ws.on("close", () => {
+				cleanup(`WebSocket connection closed: ${connection.id} from room: ${route.roomId}`);
+			});
+			ws.on("error", (error) => {
+				cleanup(void 0, error);
+			});
+			if (typeof rpgServer.onConnect === "function") await rpgServer.onConnect(connection, createConnectionContext(normalizedRequest.url, normalizedRequest.headers, normalizedRequest.method));
+			await connection.send({
+				type: "connected",
+				id: connection.id,
+				message: "Connected to RPG-JS server"
+			});
+			return true;
+		} catch (error) {
+			console.error("Error establishing WebSocket connection:", error);
+			ws.close();
+			return true;
+		}
+	}
+	async handleUpgrade(wsServer, request, socket, head) {
+		const host = toHeaders(request.headers).get("host") || "localhost";
+		if (!parseSocketRoute(new URL(request.url || "/", `http://${host}`).pathname, this.partiesPath)) return false;
+		wsServer.handleUpgrade(request, socket, head, (ws) => {
+			this.acceptWebSocket(ws, request);
+		});
+		return true;
+	}
+};
+function createRpgServerTransport(serverModule, options) {
+	return new RpgServerTransport(serverModule, options);
+}
+//#endregion
+export { MAP_UPDATE_TOKEN_ENV, MAP_UPDATE_TOKEN_HEADER, PartyConnection, PartyRoom, RpgServerTransport, createMapUpdateHeaders, createRpgServerTransport, isMapUpdateAuthorized, logNetworkSimulationStatus, readMapUpdateToken, resolveMapUpdateToken };
+
+//# sourceMappingURL=index.js.map