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

package/dist/index.js

@@ -1,10 +1,18 @@
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "fs";
-import { dirname, extname, join, relative } from "path";
-import { build, defineConfig } from "vite";
+import fs, { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "fs";
+import path, { dirname, extname, join, relative } from "path";
+import { build, defineConfig, loadEnv } from "vite";
 import canvasengine from "@canvasengine/compiler";
 import dts from "vite-plugin-dts";
 import { existsSync as existsSync$1, rmSync } from "node:fs";
 import { resolve } from "node:path";
+import { EventEmitter } from "node:events";
+import "node:module";
+import sizeOf from "image-size";
+import * as parser from "@babel/parser";
+import _traverse from "@babel/traverse";
+import _generate from "@babel/generator";
+import { identifier, importDeclaration, importDefaultSpecifier, stringLiteral } from "@babel/types";
+import toml from "@iarna/toml";
 //#region src/tiled-map-folder-plugin.ts
 /**
 * Vite plugin that serves a data folder in development mode and copies it to assets during build
@@ -6801,7 +6809,7 @@ function replaceConfigImport() {
 	};
 }
 //#endregion
-//#region ../server/dist/module-BrK6VWLE.js
+//#region ../server/dist/module-CW79w6Lk.js
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -8369,6 +8377,7 @@ var createSyncClass = (currentClass, parentKey = null, parentClass = null, path
 	currentClass.$path = path;
 	if (parentClass) currentClass.$valuesChanges = parentClass.$valuesChanges;
 	if (parentKey) setMetadata(currentClass, "id", parentKey);
+	applyDecoratedSignalMetadata(currentClass);
 	if (currentClass.$snapshot) for (const key of currentClass.$snapshot.keys()) {
 		const signal = currentClass.$snapshot.get(key);
 		const syncToClient = signal.options?.syncToClient ?? true;
@@ -8391,8 +8400,20 @@ var createSyncClass = (currentClass, parentKey = null, parentClass = null, path
 		});
 	}
 };
+function applyDecoratedSignalMetadata(currentClass) {
+	const syncMetadata = currentClass.constructor?._syncMetadata;
+	if (!syncMetadata) return;
+	for (const [propertyKey, options] of syncMetadata) {
+		const signal = currentClass[propertyKey];
+		if (!isSignal(signal) || signal.options) continue;
+		currentClass[propertyKey] = type(signal, propertyKey, {
+			...options,
+			skipInitialSync: true
+		}, currentClass);
+	}
+}
 var type = (_signal, path, options = {}, currentInstance) => {
-	const { syncToClient = true, persist: persist2 = true, transform } = options;
+	const { syncToClient = true, persist: persist2 = true, transform, skipInitialSync = false } = options;
 	let init = true;
 	const handleObjectSubject = (value, propPath) => {
 		const newPath = `${propPath}${value.key ? `.${value.key}` : ""}`;
@@ -8424,14 +8445,15 @@ var type = (_signal, path, options = {}, currentInstance) => {
 	const savePath = (propPath, value) => {
 		const transformedValue = transform && value !== "$delete" ? transform(value) : value;
 		if (syncToClient) currentInstance.$valuesChanges.set(propPath, transformedValue);
-		if (persist2 && currentInstance.$path !== void 0) currentInstance.$valuesChanges.setPersist(transformedValue == "$delete" ? propPath : currentInstance.$path, transformedValue);
+		if (persist2 && currentInstance.$path !== void 0) currentInstance.$valuesChanges.setPersist(propPath, transformedValue);
 	};
 	const setupSubscription = (signal, signalPath) => {
 		if (!isSignal(signal)) return;
-		if (syncToClient && currentInstance.$valuesChanges) {
+		if (syncToClient && !skipInitialSync && currentInstance.$valuesChanges) {
 			const initialValue = signal();
 			const transformedInitialValue = transform ? transform(initialValue) : initialValue;
-			currentInstance.$valuesChanges.set(signalPath, transformedInitialValue);
+			const initialPath = currentInstance.$path !== void 0 ? `${currentInstance.$path ? `${currentInstance.$path}.` : ""}${signalPath}` : signalPath;
+			currentInstance.$valuesChanges.set(initialPath, transformedInitialValue);
 		}
 		signal.options = options;
 		signal.observable.subscribe((value) => {
@@ -8463,7 +8485,7 @@ var type = (_signal, path, options = {}, currentInstance) => {
 	init = false;
 	return _signal;
 };
-function sync(options) {
+function normalizeSyncOptions(options) {
 	let classType;
 	let persist2 = true;
 	let syncToClient = true;
@@ -8475,18 +8497,27 @@ function sync(options) {
 		if (options.hasOwnProperty("syncToClient")) syncToClient = options.syncToClient;
 		if (options.hasOwnProperty("transform")) transform = options.transform;
 	}
+	return {
+		classType,
+		persist: persist2,
+		syncToClient,
+		transform
+	};
+}
+function setSyncMetadata(target, propertyKey, options) {
+	if (!target.constructor._syncMetadata) target.constructor._syncMetadata = /* @__PURE__ */ new Map();
+	target.constructor._syncMetadata.set(propertyKey, options);
+}
+function sync(options) {
+	const normalizedOptions = normalizeSyncOptions(options);
 	return function(target, propertyKey) {
+		setSyncMetadata(target, propertyKey, normalizedOptions);
 		const privatePropertyKey = `__${propertyKey}`;
 		const getter = function() {
 			return this[privatePropertyKey];
 		};
 		const setter = function(newVal) {
-			this[privatePropertyKey] = type(newVal, propertyKey, {
-				classType,
-				persist: persist2,
-				syncToClient,
-				transform
-			}, this);
+			this[privatePropertyKey] = type(newVal, propertyKey, normalizedOptions, this);
 		};
 		Object.defineProperty(target, propertyKey, {
 			get: getter,
@@ -8586,13 +8617,6 @@ var toCloneableSyncValue = (value, seen = /* @__PURE__ */ new WeakSet()) => {
 	}
 	return output;
 };
-var Direction = /* @__PURE__ */ function(Direction) {
-	Direction["Up"] = "up";
-	Direction["Down"] = "down";
-	Direction["Left"] = "left";
-	Direction["Right"] = "right";
-	return Direction;
-}({});
 var RpgCommonPlayer = class {
 	constructor() {
 		this.name = signal("");
@@ -8601,7 +8625,7 @@ var RpgCommonPlayer = class {
 		this.y = signal(0);
 		this.z = signal(0);
 		this.tint = signal("white");
-		this.direction = signal(Direction.Down);
+		this.direction = signal("down");
 		this.speed = signal(4);
 		this.graphics = signal([]);
 		this.canMove = signal(true);
@@ -9345,7 +9369,6 @@ var Context = class {
 		return this.values[key];
 	}
 };
-function setInject(_context) {}
 var context = new Context();
 context["side"] = "server";
 var MAP_UPDATE_TOKEN_HEADER = "x-rpgjs-map-update-token";
@@ -9853,50 +9876,457 @@ function logNetworkSimulationStatus() {
 		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");
 }
-var PartyRoom = class {
-	constructor(id) {
-		this.env = {};
-		this.context = {};
+var DEFAULT_PARTIES_PATH = "/parties/main";
+var WEBSOCKET_OPEN = 1;
+function createMemoryNodeRoomStorage(options = {}) {
+	return new MemoryNodeRoomStorage(options);
+}
+function createNodeRoomTransport(ServerClass, options = {}) {
+	return new NodeRoomTransport(ServerClass, options);
+}
+var MemoryNodeRoomStorage = class {
+	constructor(options = {}) {
+		this.rooms = /* @__PURE__ */ new Map();
+		if (options.snapshot) this.restore(options.snapshot);
+	}
+	getStorage(namespace, roomId) {
+		const key = getStorageKey(namespace, roomId);
+		let memory = this.rooms.get(key);
+		if (!memory) {
+			memory = /* @__PURE__ */ new Map();
+			this.rooms.set(key, memory);
+		}
+		return new MemoryNodeRoomStorageInstance(memory);
+	}
+	snapshot() {
+		const snapshot = {};
+		for (const [roomKey, memory] of this.rooms) {
+			if (memory.size === 0) continue;
+			snapshot[roomKey] = Array.from(memory.entries()).map(([key, value]) => [key, cloneStorageValue(value)]);
+		}
+		return snapshot;
+	}
+	restore(snapshot) {
+		this.clear();
+		for (const [roomKey, entries] of Object.entries(snapshot)) this.rooms.set(roomKey, new Map(entries.map(([key, value]) => [key, cloneStorageValue(value)])));
+	}
+	clear() {
+		this.rooms.clear();
+	}
+};
+var MemoryNodeRoomStorageInstance = class {
+	constructor(memory) {
+		this.memory = memory;
+	}
+	async put(keyOrEntries, value) {
+		if (typeof keyOrEntries === "string") {
+			this.memory.set(keyOrEntries, value);
+			return;
+		}
+		for (const [key, entryValue] of Object.entries(keyOrEntries)) this.memory.set(key, entryValue);
+	}
+	async get(key) {
+		return this.memory.get(key);
+	}
+	async delete(keyOrKeys) {
+		if (Array.isArray(keyOrKeys)) {
+			let deleted = 0;
+			for (const key of keyOrKeys) if (this.memory.delete(key)) deleted += 1;
+			return deleted;
+		}
+		return this.memory.delete(keyOrKeys);
+	}
+	async list(options = {}) {
+		let entries = Array.from(this.memory.entries());
+		if (options.prefix !== void 0) entries = entries.filter(([key]) => key.startsWith(options.prefix));
+		if (options.start !== void 0) entries = entries.filter(([key]) => key >= options.start);
+		if (options.startAfter !== void 0) entries = entries.filter(([key]) => key > options.startAfter);
+		if (options.end !== void 0) entries = entries.filter(([key]) => key < options.end);
+		entries.sort(([a], [b]) => a.localeCompare(b));
+		if (options.reverse) entries.reverse();
+		if (options.limit !== void 0) entries = entries.slice(0, options.limit);
+		return new Map(entries);
+	}
+};
+var NodeRoomTransport = class {
+	constructor(ServerClass, options = {}) {
+		this.ServerClass = ServerClass;
+		this.records = /* @__PURE__ */ new Map();
+		this.partiesPath = normalizePath(options.partiesPath ?? DEFAULT_PARTIES_PATH);
+		this.env = options.env ?? {};
+		this.rooms = {
+			main: ServerClass,
+			...options.rooms ?? {}
+		};
+		this.storage = options.storage ?? createMemoryNodeRoomStorage();
+		this.externalParties = options.externalParties ?? {};
+	}
+	async fetch(pathOrRequest, init) {
+		const request = typeof pathOrRequest === "string" ? new Request(toLocalUrl(pathOrRequest), init) : pathOrRequest;
+		const parsed = this.parsePartyRequest(request.url);
+		if (!parsed) return new Response("Not Found", { status: 404 });
+		return (await this.getRecord(parsed.namespace, parsed.roomId)).server.onRequest?.(request) ?? new Response("Not Found", { status: 404 });
+	}
+	async handleNodeRequest(req, res, next) {
+		const url = getRequestUrl(req);
+		if (!this.parsePartyRequest(url)) {
+			if (next) {
+				next();
+				return;
+			}
+			await writeNodeResponse(res, new Response("Not Found", { status: 404 }));
+			return;
+		}
+		try {
+			const request = await createWebRequest(req, url);
+			await writeNodeResponse(res, await this.fetch(request));
+		} catch (error) {
+			if (next) {
+				next(error);
+				return;
+			}
+			await writeNodeResponse(res, new Response("Internal Server Error", { status: 500 }));
+		}
+	}
+	handleUpgrade(wsServer, request, socket, head) {
+		const parsed = this.parsePartyRequest(getRequestUrl(request));
+		if (!parsed) {
+			socket.destroy();
+			return;
+		}
+		wsServer.handleUpgrade(request, socket, head, (webSocket) => {
+			this.acceptWebSocket(webSocket, request, parsed).catch(() => {
+				webSocket.close(1011, "Unable to start room connection");
+			});
+			wsServer.emit?.("connection", webSocket, request);
+		});
+	}
+	async acceptWebSocket(webSocket, request, parsedPath) {
+		const url = request instanceof Request ? request.url : getRequestUrl(request);
+		const parsed = parsedPath ?? this.parsePartyRequest(url);
+		if (!parsed) {
+			webSocket.close(1008, "Invalid room path");
+			throw new Error(`Unable to route WebSocket URL: ${url}`);
+		}
+		const record = await this.getRecord(parsed.namespace, parsed.roomId);
+		const connection = new NodeConnection(webSocket, url, getConnectionIdFromUrl(url));
+		const connectRequest = request instanceof Request ? request : await createWebRequest(request, url, false);
+		await record.server.onConnect?.(connection, { request: connectRequest });
+		const onMessage = (data) => {
+			record.server.onMessage?.(normalizeWebSocketMessage(data), connection);
+		};
+		const onClose = () => {
+			record.room.deleteConnection(connection.id, connection);
+			record.server.onClose?.(connection);
+		};
+		const onError = (error) => {
+			record.server.onError?.(connection, error);
+		};
+		webSocket.on("message", onMessage);
+		webSocket.on("close", onClose);
+		webSocket.on("error", onError);
+		record.room.addConnection(connection);
+		return connection;
+	}
+	getRoom(namespace, roomId) {
+		return this.getRecord(namespace, roomId).then((record) => record.room);
+	}
+	getNamespacePath(namespace, roomId) {
+		return `/${[
+			...trimSlashes(this.getPartiesBase()).split("/").slice(0, -1),
+			namespace,
+			encodeURIComponent(roomId)
+		].join("/")}`;
+	}
+	async getRecord(namespace, roomId) {
+		const key = `${namespace}:${roomId}`;
+		const existing = this.records.get(key);
+		if (existing) return existing;
+		const recordPromise = this.createRecord(namespace, roomId);
+		this.records.set(key, recordPromise);
+		try {
+			return await recordPromise;
+		} catch (error) {
+			this.records.delete(key);
+			throw error;
+		}
+	}
+	async createRecord(namespace, roomId) {
+		const ServerClass = this.rooms[namespace] ?? this.ServerClass;
+		const room = new NodeRoom({
+			id: roomId,
+			name: namespace,
+			env: this.env,
+			storage: await this.resolveStorage(namespace, roomId),
+			transport: this
+		});
+		const server = new ServerClass(room);
+		const record = {
+			room,
+			server,
+			started: Promise.resolve(server.onStart?.()).then(() => void 0)
+		};
+		await record.started;
+		return record;
+	}
+	async resolveStorage(namespace, roomId) {
+		if (typeof this.storage === "function") return this.storage(namespace, roomId);
+		return this.storage.getStorage(namespace, roomId);
+	}
+	parsePartyRequest(url) {
+		const requestUrl = new URL(url, "http://localhost");
+		const partiesBase = this.getPartiesBase();
+		const segments = trimSlashes(requestUrl.pathname).split("/");
+		const baseSegments = trimSlashes(partiesBase).split("/").slice(0, -1);
+		if (segments.length < baseSegments.length + 2) return null;
+		for (let index = 0; index < baseSegments.length; index++) if (segments[index] !== baseSegments[index]) return null;
+		const namespace = decodeURIComponent(segments[baseSegments.length]);
+		const roomId = decodeURIComponent(segments[baseSegments.length + 1]);
+		const rest = segments.slice(baseSegments.length + 2).join("/");
+		return {
+			namespace,
+			roomId,
+			restPath: rest ? `/${rest}` : "/"
+		};
+	}
+	getPartiesBase() {
+		return this.partiesPath;
+	}
+};
+var NodeRoom = class {
+	constructor(options) {
 		this.connections = /* @__PURE__ */ new Map();
-		this.storageData = /* @__PURE__ */ new Map();
-		this.id = id;
-		this.internalID = `internal_${id}_${Date.now()}`;
+		this.analytics = {};
+		this.id = options.id;
+		this.internalID = `${options.name}:${options.id}`;
+		this.name = options.name;
+		this.env = options.env;
+		this.storage = options.storage;
+		this.parties = createPartiesContext(options.transport);
+		this.context = {
+			parties: this.parties,
+			ai: {},
+			vectorize: {},
+			analytics: this.analytics,
+			assets: { fetch: async () => null },
+			bindings: {
+				r2: {},
+				kv: {}
+			}
+		};
+	}
+	blockConcurrencyWhile(callback) {
+		return callback();
 	}
-	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);
+	broadcast(msg, without = []) {
+		for (const connection of this.connections.values()) if (!without.includes(connection.id)) connection.send(msg);
 	}
 	getConnection(id) {
-		return this.connections.get(id);
+		let connection;
+		for (const current of this.connections.values()) if (current.id === id || current.sessionId === id) connection = current;
+		return connection;
 	}
-	getConnections(tag) {
-		return this.connections.values();
+	getConnections() {
+		return Array.from(this.connections.values());
 	}
 	addConnection(connection) {
 		this.connections.set(connection.id, connection);
 	}
-	removeConnection(connectionId) {
-		this.connections.delete(connectionId);
+	deleteConnection(id, connection) {
+		if (connection) {
+			this.connections.delete(connection.id);
+			return;
+		}
+		for (const [connectionKey, current] of this.connections) if (current.id === id || current.sessionId === id) this.connections.delete(connectionKey);
 	}
-	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());
-			}
-		};
+};
+var NodeConnection = class {
+	constructor(webSocket, uri, sessionId) {
+		this.webSocket = webSocket;
+		this.id = createConnectionId();
+		this.socket = this;
+		this.state = null;
+		this.attachment = null;
+		this.sessionId = sessionId || this.id;
+		this.uri = uri;
+	}
+	send(data) {
+		if (this.webSocket.readyState === void 0 || this.webSocket.readyState === WEBSOCKET_OPEN) this.webSocket.send(data);
+	}
+	close(code, reason) {
+		this.webSocket.close(code, reason);
+	}
+	setState(state) {
+		this.state = typeof state === "function" ? state(this.state) : state;
+		return this.state;
+	}
+	serializeAttachment(attachment) {
+		this.attachment = attachment;
+	}
+	deserializeAttachment() {
+		return this.attachment;
 	}
 };
+function createPartiesContext(transport) {
+	return new Proxy({}, { get(_target, namespace) {
+		const externalNamespace = transport.externalParties[namespace];
+		if (externalNamespace) return externalNamespace;
+		return { get(roomId) {
+			return {
+				connect: () => {
+					throw new Error("Party stub connect() is not implemented by @signe/room/node");
+				},
+				async socket(pathOrInit, init) {
+					const path = typeof pathOrInit === "string" ? pathOrInit : "/";
+					const requestInit = typeof pathOrInit === "string" ? init : pathOrInit;
+					const request = new Request(toLocalUrl(`${transport.getNamespacePath(namespace, roomId)}${normalizeStubPath(path)}`), requestInit);
+					const pair = createInMemoryWebSocketPair();
+					transport.acceptWebSocket(pair.server, request).catch(() => {
+						pair.client.close(1011, "Unable to start room connection");
+					});
+					return pair.client;
+				},
+				fetch(pathOrInit, init) {
+					const path = typeof pathOrInit === "string" ? pathOrInit : "/";
+					const requestInit = typeof pathOrInit === "string" ? init : pathOrInit;
+					return transport.fetch(`${transport.getNamespacePath(namespace, roomId)}${normalizeStubPath(path)}`, requestInit);
+				}
+			};
+		} };
+	} });
+}
+function createInMemoryWebSocketPair() {
+	const client = new InMemoryWebSocket();
+	const server = new InMemoryWebSocket();
+	client.setPeer(server);
+	server.setPeer(client);
+	return {
+		client,
+		server
+	};
+}
+var InMemoryWebSocket = class {
+	constructor() {
+		this.readyState = WEBSOCKET_OPEN;
+		this.emitter = new EventEmitter();
+	}
+	setPeer(peer) {
+		this.peer = peer;
+	}
+	send(data, cb) {
+		if (this.readyState !== WEBSOCKET_OPEN || this.peer?.readyState !== WEBSOCKET_OPEN) {
+			cb?.(/* @__PURE__ */ new Error("WebSocket is not open"));
+			return;
+		}
+		queueMicrotask(() => {
+			this.peer?.emitMessage(data);
+			cb?.();
+		});
+	}
+	close(code, reason) {
+		if (this.readyState !== WEBSOCKET_OPEN) return;
+		this.readyState = 3;
+		this.emitter.emit("close", code, reason);
+		if (this.peer?.readyState === WEBSOCKET_OPEN) {
+			this.peer.readyState = 3;
+			this.peer.emitter.emit("close", code, reason);
+		}
+	}
+	on(event, listener) {
+		this.emitter.on(event, listener);
+		return this;
+	}
+	off(event, listener) {
+		this.emitter.off(event, listener);
+		return this;
+	}
+	removeListener(event, listener) {
+		this.emitter.removeListener(event, listener);
+		return this;
+	}
+	addEventListener(type, listener) {
+		if (type === "message") {
+			this.on("message", (data) => listener({ data }));
+			return;
+		}
+		this.on(type, (event) => listener(event));
+	}
+	emitMessage(data) {
+		if (this.readyState === WEBSOCKET_OPEN) this.emitter.emit("message", data);
+	}
+};
+async function createWebRequest(req, url, includeBody = true) {
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(req.headers)) if (Array.isArray(value)) for (const item of value) headers.append(key, item);
+	else if (value !== void 0) headers.set(key, String(value));
+	const method = req.method ?? "GET";
+	const body = includeBody && !["GET", "HEAD"].includes(method) ? await readIncomingBody(req) : void 0;
+	return new Request(url, {
+		method,
+		headers,
+		body
+	});
+}
+async function readIncomingBody(req) {
+	const chunks = [];
+	for await (const chunk of req) if (typeof chunk === "string") chunks.push(new TextEncoder().encode(chunk));
+	else chunks.push(chunk);
+	const size = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+	const body = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		body.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return body;
+}
+async function writeNodeResponse(res, response) {
+	res.statusCode = response.status;
+	response.headers.forEach((value, key) => {
+		res.setHeader(key, value);
+	});
+	const body = new Uint8Array(await response.arrayBuffer());
+	res.end(body);
+}
+function getRequestUrl(req) {
+	return `${req.headers["x-forwarded-proto"] ?? "http"}://${req.headers.host ?? "localhost"}${req.url ?? "/"}`;
+}
+function normalizeWebSocketMessage(data) {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+	if (ArrayBuffer.isView(data)) return new TextDecoder().decode(data);
+	return String(data);
+}
+function normalizePath(path) {
+	return `/${trimSlashes(path)}`;
+}
+function normalizeStubPath(path) {
+	if (!path || path === "/") return "";
+	return path.startsWith("/") ? path : `/${path}`;
+}
+function toLocalUrl(path) {
+	return path.startsWith("http://") || path.startsWith("https://") ? path : `http://localhost${path.startsWith("/") ? path : `/${path}`}`;
+}
+function getConnectionIdFromUrl(url) {
+	return new URL(url).searchParams.get("id")?.trim() || void 0;
+}
+function trimSlashes(value) {
+	return value.replace(/^\/+|\/+$/g, "");
+}
+function getStorageKey(namespace, roomId) {
+	return `${encodeURIComponent(namespace)}:${encodeURIComponent(roomId)}`;
+}
+function cloneStorageValue(value) {
+	if (typeof structuredClone === "function") try {
+		return structuredClone(value);
+	} catch {
+		return value;
+	}
+	return value;
+}
+function createConnectionId() {
+	return Math.random().toString(36).slice(2, 12);
+}
 function normalizePathPrefix(path, fallback) {
 	const trimmed = (path || fallback).trim();
 	if (!trimmed) return fallback;
@@ -10001,25 +10431,12 @@ function resolveUrlFromSocketRequest(request) {
 		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
-	};
+function ensureNodeSessionIdQuery(url) {
+	if (!url.searchParams.has("id")) {
+		const partySocketId = url.searchParams.get("_pk");
+		if (partySocketId) url.searchParams.set("id", partySocketId);
+	}
+	return url;
 }
 var RpgServerTransport = class {
 	constructor(serverModule, options = {}) {
@@ -10032,10 +10449,33 @@ var RpgServerTransport = class {
 		this.mapUpdateToken = resolveMapUpdateToken(options.mapUpdateToken);
 		this.partiesPath = normalizePathPrefix(options.partiesPath || "/parties/main", "/parties/main");
 		this.tiledBasePaths = options.tiledBasePaths;
+		const owner = this;
+		class RpgNodeServer extends serverModule {
+			constructor(room) {
+				super(room);
+				owner.rooms.set(room.id, room);
+				owner.servers.set(room.id, this);
+				console.log(`Created new server instance for room: ${room.id}`);
+			}
+			async onStart() {
+				await owner.ensureServerContext();
+				await super.onStart?.();
+				const roomId = this.room?.id;
+				console.log(`Server started for room: ${roomId}`);
+				if (owner.initializeMaps && roomId) await updateMap(roomId, this, {
+					host: owner.lastKnownHost,
+					mapUpdateToken: owner.mapUpdateToken,
+					tiledBasePaths: owner.tiledBasePaths
+				});
+			}
+		}
+		this.transport = createNodeRoomTransport(RpgNodeServer, {
+			partiesPath: this.partiesPath,
+			storage: createMemoryNodeRoomStorage()
+		});
 	}
 	async ensureServerContext() {
 		if (this.serverContextInitialized) return;
-		setInject(context);
 		await injector(context, [provideServerModules([])]);
 		this.serverContextInitialized = true;
 	}
@@ -10047,52 +10487,17 @@ var RpgServerTransport = class {
 	}
 	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();
+		await this.transport.getRoom("main", roomId);
+		const room = this.rooms.get(roomId);
+		const rpgServer = this.servers.get(roomId);
+		if (!room || !rpgServer) throw new Error(`Unable to initialize room: ${roomId}`);
 		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();
+		const { rpgServer } = await this.ensureRoomAndServer(roomId, host);
 		return normalizeEngineResponse(await rpgServer.onRequest?.(requestLike));
 	}
 	async fetch(request, init) {
@@ -10125,8 +10530,7 @@ var RpgServerTransport = class {
 				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));
+			await sendNodeResponse(res, await this.dispatchRoomRequest(route.roomId, createRequestLike(normalizedUrl.toString(), (req.method || "GET").toUpperCase(), headers, await readNodeBody(req)), host));
 			return true;
 		} catch (error) {
 			console.error("Error handling RPG-JS request:", error);
@@ -10144,51 +10548,17 @@ var RpgServerTransport = class {
 			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({
+			this.lastKnownHost = normalizedRequest.url.host;
+			ensureNodeSessionIdQuery(normalizedRequest.url);
+			const connection = await this.transport.acceptWebSocket(ws, new Request(normalizedRequest.url.toString(), {
+				headers: normalizedRequest.headers,
+				method: normalizedRequest.method || "GET"
+			}));
+			await connection.send(JSON.stringify({
 				type: "connected",
 				id: connection.id,
 				message: "Connected to RPG-JS server"
-			});
+			}));
 			return true;
 		} catch (error) {
 			console.error("Error establishing WebSocket connection:", error);
@@ -10198,7 +10568,11 @@ var RpgServerTransport = class {
 	}
 	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;
+		const url = new URL(request.url || "/", `http://${host}`);
+		if (!parseSocketRoute(url.pathname, this.partiesPath)) return false;
+		ensureNodeSessionIdQuery(url);
+		request.url = `${url.pathname}${url.search}`;
+		this.lastKnownHost = host;
 		wsServer.handleUpgrade(request, socket, head, (ws) => {
 			this.acceptWebSocket(ws, request);
 		});
@@ -10210,7 +10584,7 @@ function createRpgServerTransport(serverModule, options) {
 }
 //#endregion
 //#region src/server-plugin.ts
-async function importWebSocketServer() {
+async function importWebSocketServer$1() {
 	if (typeof process === "undefined" || !process.versions?.node) {
 		console.warn("Not in Node.js environment, WebSocket server not available");
 		return null;
@@ -10231,7 +10605,7 @@ function serverPlugin(serverModule) {
 		name: "server-plugin",
 		async configureServer(server) {
 			try {
-				const WebSocketServerClass = await importWebSocketServer();
+				const WebSocketServerClass = await importWebSocketServer$1();
 				if (WebSocketServerClass) {
 					wsServer = new WebSocketServerClass({ noServer: true });
 					console.log("WebSocket server initialized successfully");
@@ -10432,6 +10806,797 @@ function rpgjs({ server, entryPoints }) {
 	];
 }
 //#endregion
-export { directivePlugin, entryPointPlugin, removeImportsPlugin, replaceConfigImport, rpgjs, rpgjsModuleViteConfig, serverPlugin, tiledMapFolderPlugin };
+//#region src/compatibility-v4/flag-transform.ts
+function flagTransform(options = {}) {
+	function getImportSide(importer) {
+		if (importer?.includes("?server") || importer?.includes("server-entry")) return "server";
+		if (importer?.includes("?client") || importer?.includes("client-entry") || importer?.includes("standalone-entry")) return "client";
+		return options.side ?? "client";
+	}
+	function hasFlag(id, flag) {
+		return id.endsWith(`?${flag}`) || id.includes(`?${flag}&`);
+	}
+	function getSideFromId(id) {
+		return id.match(/[?&]side=(client|server)/)?.[1] === "server" ? "server" : "client";
+	}
+	return {
+		name: "rpgjs-v4-flag-transform",
+		async resolveId(source, importer, resolveOptions) {
+			for (const flag of [
+				"client!",
+				"server!",
+				"rpg!",
+				"mmorpg!",
+				"production!",
+				"development!"
+			]) {
+				if (!source.startsWith(flag)) continue;
+				const id = source.slice(flag.length);
+				const resolution = await this.resolve(id, importer, {
+					skipSelf: true,
+					...resolveOptions
+				});
+				if (!resolution) return null;
+				const importSide = getImportSide(importer);
+				return {
+					...resolution,
+					id: `${resolution.id}?${flag.slice(0, -1)}&side=${importSide}`
+				};
+			}
+			return null;
+		},
+		transform(code, id) {
+			const { mode = "development", type = "mmorpg" } = options;
+			const side = getSideFromId(id);
+			if (mode === "test") return {
+				code,
+				map: null
+			};
+			if (hasFlag(id, side === "client" ? "server" : "client") && type !== "rpg") return {
+				code: "export default null;",
+				map: null
+			};
+			if (hasFlag(id, "production") && mode !== "production" || hasFlag(id, "development") && mode !== "development" || hasFlag(id, "rpg") && type !== "rpg" || hasFlag(id, "mmorpg") && type !== "mmorpg") return {
+				code: "export default null;",
+				map: null
+			};
+			return {
+				code,
+				map: null
+			};
+		}
+	};
+}
+//#endregion
+//#region src/compatibility-v4/require-transform.ts
+var traverse = _traverse.default ?? _traverse;
+var generate = _generate.default ?? _generate;
+function readStaticRequireArg(arg, ast) {
+	if (!arg) return "";
+	if (arg.type === "StringLiteral") return arg.value;
+	if (arg.type === "Identifier") {
+		let value = "";
+		traverse(ast, { VariableDeclarator(path) {
+			if (path.node.id?.name === arg.name && path.node.init?.type === "StringLiteral") value = path.node.init.value;
+		} });
+		return value;
+	}
+	if (arg.type === "BinaryExpression" && arg.operator === "+") {
+		const left = readStaticRequireArg(arg.left, ast);
+		const right = readStaticRequireArg(arg.right, ast);
+		return left && right ? left + right : "";
+	}
+	return "";
+}
+function vitePluginRequire() {
+	return {
+		name: "rpgjs-v4-require-transform",
+		transform(code, id) {
+			if (!/(.jsx?|.tsx?)(\?.*)?$/.test(id) || !/^(?!.*node_modules(?:\/|\\)(?!rpgjs-|@rpgjs)).*$/.test(id)) return {
+				code,
+				map: null
+			};
+			const ast = parser.parse(code, {
+				sourceType: "module",
+				plugins: [
+					"typescript",
+					"jsx",
+					"decorators-legacy",
+					"classProperties"
+				]
+			});
+			let changed = false;
+			traverse(ast, { CallExpression(path) {
+				if (!path.node.callee || path.node.callee.type !== "Identifier" || path.node.callee.name !== "require") return;
+				const request = readStaticRequireArg(path.node.arguments[0], ast);
+				if (!request) return;
+				const variableName = `__rpgjs_v4_require_${path.scope.generateUidIdentifier("asset").name}`;
+				ast.program.body.unshift(importDeclaration([importDefaultSpecifier(identifier(variableName))], stringLiteral(request)));
+				path.replaceWith(identifier(variableName));
+				changed = true;
+			} });
+			if (!changed) return {
+				code,
+				map: null
+			};
+			return {
+				code: generate(ast, {}).code,
+				map: null
+			};
+		}
+	};
+}
+//#endregion
+//#region src/compatibility-v4/utils.ts
+function dedent(strings, ...values) {
+	const fullString = strings.reduce((acc, str, i) => acc + str + (values[i] ?? ""), "");
+	const lines = fullString.split("\n");
+	let minIndent = Infinity;
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		minIndent = Math.min(minIndent, line.match(/^\s*/)?.[0].length ?? 0);
+	}
+	if (minIndent === Infinity) return fullString.trim();
+	return lines.map((line) => line.trim() ? line.slice(minIndent) : line).join("\n").trim();
+}
+function warn(message) {
+	console.warn(`[RPG-JS v4 compatibility] ${message}`);
+}
+function toPosix(value) {
+	return value.replace(/\\/g, "/");
+}
+function formatVariableName(value) {
+	return value.replace(/\./g, "").replace(/[.@/\\ -]/g, "_").replace(/[^A-Za-z0-9_$]/g, "_");
+}
+function transformPathIfModule(moduleName) {
+	if (moduleName.startsWith("@rpgjs") || moduleName.startsWith("rpgjs-")) return path.join("node_modules", moduleName);
+	return moduleName;
+}
+function resolveModuleImport(moduleName) {
+	return moduleName.replace(/^\.\//, "");
+}
+function getAllFiles(dirPath) {
+	if (!fs.existsSync(dirPath)) return [];
+	const files = [];
+	const dirents = fs.readdirSync(dirPath, { withFileTypes: true });
+	for (const dirent of dirents) {
+		const fullPath = path.join(dirPath, dirent.name);
+		if (dirent.isDirectory()) files.push(...getAllFiles(fullPath));
+		else files.push(fullPath);
+	}
+	return files;
+}
+function importPathForFile(file, root) {
+	const srcPath = path.join(root, "src");
+	if (file.startsWith(srcPath + path.sep)) return `@/${toPosix(path.relative(srcPath, file))}`;
+	return `./${toPosix(path.relative(root, file))}`;
+}
+function importString(modulePath, fileName, variableName = fileName, projectRoot = process.cwd()) {
+	const file = path.resolve(projectRoot, transformPathIfModule(modulePath), `${fileName}.ts`);
+	if (!fs.existsSync(file)) return "";
+	return `import ${variableName} from '${importPathForFile(file, projectRoot)}'`;
+}
+function searchFolderAndTransformToImportString(folderPath, modulePath, extensionFilter, returnCb, options, projectRoot = process.cwd()) {
+	const folder = path.resolve(projectRoot, transformPathIfModule(modulePath), folderPath);
+	if (!fs.existsSync(folder)) return {
+		variablesString: "",
+		importString: "",
+		folder: "",
+		relativePath: ""
+	};
+	const extensions = Array.isArray(extensionFilter) ? extensionFilter : [extensionFilter];
+	let importString = "";
+	let relativePath = "";
+	return {
+		variablesString: getAllFiles(folder).filter((file) => extensions.some((ext) => file.endsWith(ext))).filter((file) => options?.customFilter ? options.customFilter(file) : true).map((file) => {
+			const importPath = importPathForFile(file, projectRoot);
+			const variableName = formatVariableName(importPath);
+			relativePath = importPath;
+			importString += `\nimport ${variableName} from '${importPath}'`;
+			return returnCb ? returnCb(importPath, variableName, file) : variableName;
+		}).join(","),
+		importString,
+		folder,
+		relativePath
+	};
+}
+function replaceEnvVars(obj, envs) {
+	if (obj == null) return obj;
+	if (typeof obj === "string" && obj.startsWith("$ENV:")) return envs[obj.slice(5)];
+	if (Array.isArray(obj)) return obj.map((item) => replaceEnvVars(item, envs));
+	if (typeof obj === "object") return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, replaceEnvVars(value, envs)]));
+	return obj;
+}
+//#endregion
+//#region src/compatibility-v4/load-config-file.ts
+function loadConfigFileSync(mode = "development", root = process.cwd()) {
+	const tomlFile = path.resolve(root, "rpg.toml");
+	const jsonFile = path.resolve(root, "rpg.json");
+	let config = {};
+	if (fs.existsSync(tomlFile)) config = toml.parse(fs.readFileSync(tomlFile, "utf8"));
+	else if (fs.existsSync(jsonFile)) config = JSON.parse(fs.readFileSync(jsonFile, "utf8"));
+	config = replaceEnvVars(config, loadEnv(mode, root, ""));
+	config.autostart = config.autostart ?? true;
+	config.modulesRoot = config.modulesRoot ?? "";
+	config.compilerOptions ??= {};
+	config.compilerOptions.build ??= {};
+	config.compilerOptions.build.pwaEnabled ??= true;
+	config.compilerOptions.build.outputDir ??= "dist";
+	if (config.modules) config.modules = config.modules.map((module) => {
+		if (module.startsWith(".")) return "./" + path.join(config.modulesRoot, module);
+		return module;
+	});
+	config.startMap = config.startMap || config.start?.map;
+	return config;
+}
+//#endregion
+//#region src/compatibility-v4/index.ts
+var MODULE_NAME = "virtual:rpgjs-v4-modules";
+var CLIENT_CONFIG = "virtual:rpgjs-v4-client-config";
+var SERVER_ENTRY = "virtual:rpgjs-v4-server-entry";
+var CLIENT_ENTRY = "virtual:rpgjs-v4-client-entry";
+var STANDALONE_ENTRY = "virtual:rpgjs-v4-standalone-entry";
+var LEGACY_MOBILE_GUI = "virtual:rpgjs-v4-legacy-mobile-gui";
+var LEGACY_DEFAULT_GUI = "virtual:rpgjs-v4-legacy-default-gui";
+var LEGACY_GAMEPAD = "virtual:rpgjs-v4-legacy-gamepad";
+var LEGACY_MODULES = {
+	"@rpgjs/mobile-gui": LEGACY_MOBILE_GUI,
+	"@rpgjs/default-gui": LEGACY_DEFAULT_GUI,
+	"@rpgjs/gamepad": LEGACY_GAMEPAD
+};
+var TILED_EXTENSIONS = [
+	".tmx",
+	".tsx",
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".svg"
+];
+async function importWebSocketServer() {
+	if (typeof process === "undefined" || !process.versions?.node) return null;
+	try {
+		const { createRequire } = await import("module");
+		const ws = createRequire(import.meta.url)("ws");
+		return ws.WebSocketServer || ws.default?.WebSocketServer || ws;
+	} catch {
+		return null;
+	}
+}
+function verifyDefaultExport(importObject) {
+	if (!importObject.variablesString) return "[]";
+	return dedent`
+    [${importObject.variablesString}].map((value) => {
+      if (!value) throw new Error('Missing default export in ${importObject.relativePath}')
+      return value
+    })
+  `;
+}
+function normalizeDatabase(variableList) {
+	if (!variableList) return "{}";
+	return dedent`
+    Object.assign({}, ...[${variableList}].map((value) => {
+      if (!value) return {}
+      if (typeof value === 'function') {
+        return { [value.id || value.name]: value }
+      }
+      return value
+    }))
+  `;
+}
+function stripQuery(url) {
+	return url.split("?", 1)[0].split("#", 1)[0];
+}
+function normalizePublicBasePath(basePath = "map") {
+	return basePath.trim().replace(/^\/+|\/+$/g, "") || "map";
+}
+function getMimeType(file) {
+	switch (path.extname(file).toLowerCase()) {
+		case ".tmx":
+		case ".tsx":
+		case ".world": return "application/xml";
+		case ".png": return "image/png";
+		case ".jpg":
+		case ".jpeg": return "image/jpeg";
+		case ".gif": return "image/gif";
+		case ".webp": return "image/webp";
+		case ".svg": return "image/svg+xml";
+		default: return "application/octet-stream";
+	}
+}
+function isTiledAsset(file) {
+	return TILED_EXTENSIONS.includes(path.extname(file).toLowerCase());
+}
+function moduleRootPath(modulePath, projectRoot = process.cwd()) {
+	return path.resolve(projectRoot, transformPathIfModule(modulePath));
+}
+function hasTiledAssets(directory) {
+	return fs.existsSync(directory) && getAllFiles(directory).some(isTiledAsset);
+}
+function getTiledAssetRoots(modulePath, projectRoot = process.cwd()) {
+	const moduleRoot = moduleRootPath(modulePath, projectRoot);
+	const roots = [];
+	const mapsRoot = path.join(moduleRoot, "maps");
+	const worldsRoot = path.join(moduleRoot, "worlds");
+	if (hasTiledAssets(mapsRoot)) roots.push({
+		root: mapsRoot,
+		moduleRoot
+	});
+	if (fs.existsSync(worldsRoot)) for (const dirent of fs.readdirSync(worldsRoot, { withFileTypes: true })) {
+		if (!dirent.isDirectory()) continue;
+		const root = path.join(worldsRoot, dirent.name);
+		if (hasTiledAssets(root)) roots.push({
+			root,
+			moduleRoot
+		});
+	}
+	return roots;
+}
+function getAllTiledAssetRoots(modules, projectRoot = process.cwd()) {
+	return modules.filter((module) => module.startsWith(".")).flatMap((module) => getTiledAssetRoots(module, projectRoot));
+}
+function mapIdFromTmx(file, assetRoot) {
+	return toPosix(path.relative(assetRoot, file)).replace(/\.tmx$/i, "");
+}
+function publicTiledFilePath(file, assetRoot, basePath = "map") {
+	return `/${normalizePublicBasePath(basePath)}/${toPosix(path.relative(assetRoot, file))}`;
+}
+function hasSiblingMapScript(file) {
+	return fs.existsSync(file.replace(/\.tmx$/i, ".ts"));
+}
+function createTiledMapEntries(modulePath, options, projectRoot = process.cwd()) {
+	return getTiledAssetRoots(modulePath, projectRoot).flatMap(({ root }) => getAllFiles(root).filter((file) => file.toLowerCase().endsWith(".tmx")).filter((file) => !hasSiblingMapScript(file)).map((file) => {
+		return `{ id: '${mapIdFromTmx(file, root)}', file: '${publicTiledFilePath(file, root, options.tiledMapBasePath)}' }`;
+	})).join(",");
+}
+function mapIdFromWorldFileName(fileName) {
+	const withoutExtension = toPosix(fileName).replace(/\.tmx$/i, "");
+	return withoutExtension.split("/").filter(Boolean).at(-1) ?? withoutExtension;
+}
+function loadWorldFile(file) {
+	const world = JSON.parse(fs.readFileSync(file, "utf8"));
+	const maps = Array.isArray(world.maps) ? world.maps.map((map) => ({
+		...map,
+		id: map.id ?? (map.fileName ? mapIdFromWorldFileName(map.fileName) : void 0),
+		worldX: map.worldX ?? map.x ?? 0,
+		worldY: map.worldY ?? map.y ?? 0,
+		width: map.width ?? map.widthPx ?? 0,
+		height: map.height ?? map.heightPx ?? 0
+	})) : [];
+	return {
+		...world,
+		id: world.id ?? path.basename(file, ".world"),
+		maps
+	};
+}
+function createWorldMapEntries(modulePath, projectRoot = process.cwd()) {
+	const worldsRoot = path.join(moduleRootPath(modulePath, projectRoot), "worlds");
+	if (!fs.existsSync(worldsRoot)) return "";
+	return getAllFiles(worldsRoot).filter((file) => file.endsWith(".world")).map((file) => JSON.stringify(loadWorldFile(file))).join(",");
+}
+function copyTiledAssets(assetRoots, outputDir, basePath = "map") {
+	const publicBasePath = normalizePublicBasePath(basePath);
+	const copied = /* @__PURE__ */ new Set();
+	for (const { root } of assetRoots) for (const file of getAllFiles(root).filter(isTiledAsset)) {
+		const relativePath = toPosix(path.relative(root, file));
+		const target = path.join(outputDir, publicBasePath, relativePath);
+		if (copied.has(target)) warn(`Tiled asset collision while copying ${relativePath}`);
+		copied.add(target);
+		fs.mkdirSync(path.dirname(target), { recursive: true });
+		fs.copyFileSync(file, target);
+	}
+}
+function serveTiledAssets(server, assetRoots, basePath = "map") {
+	const publicBasePath = `/${normalizePublicBasePath(basePath)}`;
+	server.middlewares.use((req, res, next) => {
+		if (!req.url?.startsWith(publicBasePath)) return next();
+		const requestPath = decodeURIComponent(stripQuery(req.url).slice(publicBasePath.length).replace(/^\/+/, ""));
+		for (const { root } of assetRoots) {
+			const file = path.resolve(root, requestPath);
+			if (!file.startsWith(root + path.sep) && file !== root) continue;
+			if (!fs.existsSync(file) || !fs.statSync(file).isFile() || !isTiledAsset(file)) continue;
+			res.setHeader("Content-Type", getMimeType(file));
+			res.setHeader("Cache-Control", "no-cache");
+			res.end(fs.readFileSync(file));
+			return;
+		}
+		res.statusCode = 404;
+		res.end("Not Found");
+	});
+}
+function loadServerModuleFiles(modulePath, options, config, projectRoot = process.cwd()) {
+	const modulesCreated = options.modulesCreated ?? [];
+	if (!modulesCreated.includes(modulePath)) modulesCreated.push(modulePath);
+	const importPlayer = importString(modulePath, "player", "player", projectRoot);
+	const importEngine = importString(modulePath, "server", "server", projectRoot);
+	const mapStandaloneFilesString = searchFolderAndTransformToImportString("maps", modulePath, ".ts", void 0, void 0, projectRoot);
+	const mapFilesString = createTiledMapEntries(modulePath, options, projectRoot);
+	const worldFilesString = createWorldMapEntries(modulePath, projectRoot);
+	const eventsFilesString = searchFolderAndTransformToImportString("events", modulePath, ".ts", void 0, void 0, projectRoot);
+	const databaseFilesString = searchFolderAndTransformToImportString("database", modulePath, ".ts", void 0, void 0, projectRoot);
+	const hasMaps = !!mapFilesString && !!mapStandaloneFilesString.variablesString;
+	const hitbox = config.start?.hitbox;
+	const startHook = modulesCreated.length === 1 && (config.start?.graphic || hitbox || config.startMap) ? dedent`
+      const __rpgjsV4Player = player || {}
+      const __rpgjsV4LastConnected = __rpgjsV4Player.onConnected
+      __rpgjsV4Player.onConnected = async (player) => {
+        if (__rpgjsV4LastConnected) await __rpgjsV4LastConnected(player)
+        ${config.start?.graphic ? `player.setGraphic('${config.start.graphic}')` : ""}
+        ${hitbox ? `player.setHitbox(${hitbox[0]}, ${hitbox[1]})` : ""}
+        ${config.startMap ? `await player.changeMap('${config.startMap}')` : ""}
+      }
+    ` : "";
+	return dedent`
+    ${importPlayer || "const player = {}"}
+    ${importEngine}
+    ${mapStandaloneFilesString.importString}
+    ${eventsFilesString.importString}
+    ${databaseFilesString.importString}
+
+    ${startHook}
+
+    export default {
+      player: ${startHook ? "__rpgjsV4Player" : "player"},
+      ${importEngine ? "engine: server," : ""}
+      events: ${verifyDefaultExport(eventsFilesString)},
+      database: ${normalizeDatabase(databaseFilesString.variablesString)},
+      maps: [${mapFilesString}${hasMaps ? "," : ""}${mapStandaloneFilesString.variablesString}],
+      worldMaps: [${worldFilesString}]
+    }
+  `;
+}
+function createServerEntryLoad() {
+	return dedent`
+    import { createServer, provideServerModules } from '@rpgjs/server'
+    import { provideTiledMap } from '@rpgjs/tiledmap/server'
+    import modules from '${MODULE_NAME}'
+
+    export default createServer({
+      providers: [
+        provideServerModules(modules),
+        provideTiledMap()
+      ]
+    })
+  `;
+}
+function loadSpriteSheet(directoryName, modulePath, options, projectRoot = process.cwd(), warning = false) {
+	const importSprites = searchFolderAndTransformToImportString(directoryName, modulePath, ".ts", void 0, void 0, projectRoot);
+	let propImagesString = "";
+	let variablesString = importSprites.variablesString;
+	if (importSprites.importString) {
+		const images = getAllFiles(importSprites.folder).filter((file) => {
+			return [
+				".png",
+				".jpg",
+				".jpeg",
+				".gif",
+				".bmp",
+				".webp",
+				".svg"
+			].some((ext) => file.toLowerCase().endsWith(ext));
+		});
+		if (!images.length) warn(`No spritesheet image found in ${directoryName}`);
+		else {
+			const imageImports = images.map((file) => {
+				const filename = path.basename(file);
+				const basename = filename.replace(path.extname(filename), "");
+				const importPath = `${importPathForFile(file, projectRoot)}?url`;
+				return {
+					basename,
+					importPath,
+					variableName: formatVariableName(importPath)
+				};
+			});
+			const objectString = imageImports.map(({ basename, variableName }) => `"${basename}": ${variableName}`).join(",\n");
+			const imageImportString = imageImports.map(({ importPath, variableName }) => `import ${variableName} from '${importPath}'`).join("\n");
+			const generatedSpritesheetsVariable = `__rpgjsV4Spritesheets_${formatVariableName(directoryName)}`;
+			variablesString = `...${generatedSpritesheetsVariable}`;
+			const dimensions = sizeOf(fs.readFileSync(images.at(-1)));
+			propImagesString = dedent`
+        ${imageImportString}
+        const ${generatedSpritesheetsVariable} = [${importSprites.variablesString}].flatMap((spritesheet) => {
+          return Object.entries({ ${objectString} }).map(([id, image]) => ({
+            ...spritesheet,
+            ...(spritesheet.prototype ?? {}),
+            id,
+            image,
+          }))
+        })
+        ;[${importSprites.variablesString}].forEach((spritesheet) => {
+          spritesheet.images = { ${objectString} }
+          spritesheet.prototype ||= {}
+          spritesheet.prototype.width = ${dimensions.width ?? 0}
+          spritesheet.prototype.height = ${dimensions.height ?? 0}
+        })
+        ${generatedSpritesheetsVariable}.forEach((spritesheet) => {
+          spritesheet.width = ${dimensions.width ?? 0}
+          spritesheet.height = ${dimensions.height ?? 0}
+        })
+      `;
+		}
+	} else if (warning) warn(`No spritesheet folder found in ${directoryName}`);
+	return {
+		...importSprites,
+		variablesString,
+		propImagesString
+	};
+}
+function loadClientFiles(modulePath, options, config, projectRoot = process.cwd()) {
+	const importSpriteString = importString(modulePath, "sprite", "sprite", projectRoot);
+	const importSceneMapString = importString(modulePath, "scene-map", "sceneMap", projectRoot);
+	const importEngine = importString(modulePath, "client", "engine", projectRoot);
+	const guiFilesString = searchFolderAndTransformToImportString("gui", modulePath, [
+		".vue",
+		".tsx",
+		".jsx",
+		".ce"
+	], void 0, void 0, projectRoot);
+	const soundStandaloneFilesString = searchFolderAndTransformToImportString("sounds", modulePath, ".ts", void 0, void 0, projectRoot);
+	const soundFilesString = searchFolderAndTransformToImportString("sounds", modulePath, [".mp3", ".ogg"], void 0, { customFilter: (file) => !fs.existsSync(file.replace(/\.(mp3|ogg)$/, ".ts")) }, projectRoot);
+	const spritesheets = [];
+	for (const directory of config.spritesheetDirectories ?? []) spritesheets.push(loadSpriteSheet(directory, modulePath, options, projectRoot));
+	if (!(config.spritesheetDirectories ?? []).includes("characters")) spritesheets.push(loadSpriteSheet("characters", modulePath, options, projectRoot));
+	const spritesheetRoot = path.resolve(projectRoot, transformPathIfModule(modulePath), "spritesheets");
+	if (fs.existsSync(spritesheetRoot)) {
+		for (const dirent of fs.readdirSync(spritesheetRoot, { withFileTypes: true })) if (dirent.isDirectory()) spritesheets.push(loadSpriteSheet(path.join("spritesheets", dirent.name), modulePath, options, projectRoot, true));
+	}
+	const activeSpritesheets = spritesheets.filter((spritesheet) => spritesheet.importString);
+	const hasSounds = !!soundFilesString.variablesString && !!soundStandaloneFilesString.variablesString;
+	return dedent`
+    ${importSpriteString || "const sprite = {}"}
+    ${importSceneMapString}
+    ${importEngine}
+    ${activeSpritesheets.map((spritesheet) => spritesheet.importString).join("\n")}
+    ${guiFilesString.importString}
+    ${soundFilesString.importString}
+    ${soundStandaloneFilesString.importString}
+
+    ${activeSpritesheets.map((spritesheet) => spritesheet.propImagesString).join("\n")}
+
+    export default {
+      spritesheets: [${activeSpritesheets.map((spritesheet) => spritesheet.variablesString).join(",")}],
+      sprite,
+      ${importEngine ? "engine," : ""}
+      sceneMap: ${importSceneMapString ? "sceneMap" : "{}"},
+      gui: [${guiFilesString.variablesString}],
+      sounds: [${soundFilesString.variablesString}${hasSounds ? "," : ""}${soundStandaloneFilesString.variablesString}]
+    }
+  `;
+}
+function createModuleLoad(id, variableName, modulePath, options, config, projectRoot = process.cwd()) {
+	if (modulePath === LEGACY_MOBILE_GUI) return dedent`
+      import { withMobile } from '@rpgjs/client'
+      export default { client: withMobile(), server: {} }
+    `;
+	if (modulePath === LEGACY_DEFAULT_GUI || modulePath === LEGACY_GAMEPAD) return "export default { client: {}, server: {} }";
+	const clientFile = `virtual:${variableName}-client`;
+	const serverFile = `virtual:${variableName}-server`;
+	if (id.startsWith(`${serverFile}?server`)) return loadServerModuleFiles(modulePath, options, config, projectRoot);
+	if (id.startsWith(`${clientFile}?client`)) return loadClientFiles(modulePath, options, config, projectRoot);
+	const modulePathId = path.resolve(projectRoot, transformPathIfModule(modulePath));
+	const packageJson = path.join(modulePathId, "package.json");
+	const indexFile = path.join(modulePathId, "index.ts");
+	if (fs.existsSync(packageJson)) {
+		const { main: entryPoint } = JSON.parse(fs.readFileSync(packageJson, "utf8"));
+		if (entryPoint) {
+			const entryFile = path.join(modulePathId, entryPoint);
+			return dedent`
+        import mod from '${modulePath.startsWith(".") ? importPathForFile(entryFile, projectRoot) : resolveModuleImport(toPosix(path.join(modulePath, entryPoint)))}'
+        export default mod
+      `;
+		}
+	} else if (fs.existsSync(indexFile)) return dedent`
+      import mod from '${importPathForFile(indexFile, projectRoot)}'
+      export default mod
+    `;
+	return dedent`
+    import client from 'client!${clientFile}'
+    import server from 'server!${serverFile}'
+    export default { client, server }
+  `;
+}
+function createModulesLoad(modules) {
+	const modulesToImport = modules.reduce((acc, module) => {
+		const resolvedModule = LEGACY_MODULES[module] ?? module;
+		acc[formatVariableName(resolvedModule)] = resolvedModule;
+		return acc;
+	}, {});
+	return dedent`
+    ${Object.entries(modulesToImport).map(([variableName, module]) => `import ${variableName} from '${resolveModuleImport(module)}'`).join("\n")}
+    export default [${Object.keys(modulesToImport).join(",")}]
+  `;
+}
+function createClientConfigLoad(config, options = {}) {
+	return dedent`
+    import { provideClientGlobalConfig, provideClientModules } from '@rpgjs/client'
+    import { provideTiledMap } from '@rpgjs/tiledmap/client'
+    import modules from '${MODULE_NAME}'
+    export default {
+      providers: [
+        provideTiledMap({ basePath: '${normalizePublicBasePath(options.tiledMapBasePath)}' }),
+        provideClientGlobalConfig(${JSON.stringify(config)}),
+        provideClientModules(modules)
+      ]
+    }
+  `;
+}
+function createStandaloneEntryLoad() {
+	return dedent`
+    import { mergeConfig } from '@signe/di'
+    import { provideRpg, startGame } from '@rpgjs/client'
+    import server from '${SERVER_ENTRY}'
+    import configClient from '${CLIENT_CONFIG}'
+
+    startGame(mergeConfig(configClient, {
+      providers: [provideRpg(server)]
+    }))
+  `;
+}
+function createClientEntryLoad() {
+	return dedent`
+    import { mergeConfig } from '@signe/di'
+    import { provideMmorpg, startGame } from '@rpgjs/client'
+    import configClient from '${CLIENT_CONFIG}'
+
+    startGame(mergeConfig(configClient, {
+      providers: [provideMmorpg({})]
+    }))
+  `;
+}
+function normalizeModules(config) {
+	return config.modules?.length ? config.modules : ["./src/modules/main"];
+}
+function normalizeAliases(aliases = {}) {
+	return Object.fromEntries(Object.entries(aliases).map(([key, value]) => [key, value.startsWith(".") ? path.resolve(process.cwd(), value) : value]));
+}
+function compatibilityV4Plugin(options = {}) {
+	let viteMode = "development";
+	let config = loadConfigFileSync(viteMode);
+	let modules = normalizeModules(config);
+	let modulesCreated = [];
+	let viteRoot = process.cwd();
+	let viteOutputDir = path.resolve(viteRoot, config.compilerOptions?.build?.outputDir ?? "dist");
+	let resolvedOptions = {
+		type: options.type ?? config.type ?? process.env.RPG_TYPE ?? "rpg",
+		tiledMapBasePath: normalizePublicBasePath(options.tiledMapBasePath),
+		serveMode: true,
+		side: options.side ?? "client",
+		...options,
+		config
+	};
+	let wsServer = null;
+	const flagOptions = {
+		side: resolvedOptions.side,
+		mode: viteMode,
+		type: resolvedOptions.type
+	};
+	return [
+		flagTransform(flagOptions),
+		vitePluginRequire(),
+		{
+			name: "rpgjs-v4-compatibility",
+			enforce: "pre",
+			config() {
+				return {
+					resolve: {
+						alias: {
+							"@": path.resolve(process.cwd(), "src"),
+							...normalizeAliases(config.compilerOptions?.alias)
+						},
+						extensions: [
+							".ts",
+							".js",
+							".jsx",
+							".json",
+							".vue",
+							".css",
+							".scss",
+							".sass",
+							".html",
+							".tmx",
+							".tsx",
+							".toml",
+							".ce"
+						]
+					},
+					assetsInclude: [
+						"**/*.tmx",
+						"**/*.world",
+						"{!(gui)/**/*}.tsx"
+					]
+				};
+			},
+			configResolved(viteConfig) {
+				viteMode = viteConfig.mode || "development";
+				viteRoot = viteConfig.root;
+				viteOutputDir = path.resolve(viteRoot, viteConfig.build.outDir || "dist");
+				config = loadConfigFileSync(viteMode, viteConfig.root);
+				modules = normalizeModules(config);
+				modulesCreated = [];
+				resolvedOptions = {
+					...resolvedOptions,
+					type: options.type ?? config.type ?? process.env.RPG_TYPE ?? "rpg",
+					serveMode: viteConfig.command === "serve",
+					mode: viteMode,
+					config
+				};
+				flagOptions.side = resolvedOptions.side;
+				flagOptions.mode = viteMode;
+				flagOptions.type = resolvedOptions.type;
+			},
+			transformIndexHtml: {
+				order: "pre",
+				handler(html) {
+					const script = `<script type="module">\nimport '${resolvedOptions.type === "mmorpg" ? CLIENT_ENTRY : STANDALONE_ENTRY}'\n<\/script>`;
+					if (html.includes("<script type=\"module\"")) return html.replace(/<script\s+type="module"\s+src="[^"]*"[^>]*><\/script>/gi, script);
+					return html.replace(/<\/head>/i, `  ${script}\n  </head>`);
+				}
+			},
+			handleHotUpdate() {
+				modulesCreated = [];
+			},
+			resolveId(source) {
+				if ([
+					MODULE_NAME,
+					CLIENT_CONFIG,
+					SERVER_ENTRY,
+					CLIENT_ENTRY,
+					STANDALONE_ENTRY,
+					...Object.values(LEGACY_MODULES)
+				].includes(source)) return source;
+				for (const module of modules) {
+					const moduleName = resolveModuleImport(module);
+					const variableName = formatVariableName(moduleName);
+					if (source === moduleName || source === `virtual:${variableName}-client` || source === `virtual:${variableName}-server`) return source;
+				}
+				return null;
+			},
+			load(id) {
+				if (id === MODULE_NAME) return createModulesLoad(modules);
+				if (id === CLIENT_CONFIG) return createClientConfigLoad(config, resolvedOptions);
+				if (id === SERVER_ENTRY) return createServerEntryLoad();
+				if (id === CLIENT_ENTRY) return createClientEntryLoad();
+				if (id === STANDALONE_ENTRY) return createStandaloneEntryLoad();
+				if (Object.values(LEGACY_MODULES).includes(id)) return createModuleLoad(id, formatVariableName(id), id, {
+					...resolvedOptions,
+					modulesCreated
+				}, config);
+				for (const module of modules) {
+					const moduleName = resolveModuleImport(module);
+					const variableName = formatVariableName(moduleName);
+					if (id === moduleName || id.startsWith(`virtual:${variableName}-client?client`) || id.startsWith(`virtual:${variableName}-server?server`)) return createModuleLoad(id, variableName, module, {
+						...resolvedOptions,
+						modulesCreated
+					}, config);
+				}
+				return null;
+			},
+			async configureServer(server) {
+				serveTiledAssets(server, getAllTiledAssetRoots(modules, server.config.root), resolvedOptions.tiledMapBasePath);
+				if (resolvedOptions.type !== "mmorpg") return;
+				const { default: serverModule } = await server.ssrLoadModule(SERVER_ENTRY);
+				const transport = createRpgServerTransport(serverModule);
+				const WebSocketServerClass = await importWebSocketServer();
+				if (WebSocketServerClass) wsServer = new WebSocketServerClass({ noServer: true });
+				logNetworkSimulationStatus();
+				server.middlewares.use("/parties", async (req, res, next) => {
+					await transport.handleNodeRequest(req, res, next, { mountedPath: "/parties" });
+				});
+				if (wsServer) server.httpServer?.on("upgrade", (request, socket, head) => {
+					transport.handleUpgrade(wsServer, request, socket, head);
+				});
+			},
+			buildEnd() {
+				wsServer?.close();
+			},
+			generateBundle() {
+				copyTiledAssets(getAllTiledAssetRoots(modules, viteRoot), viteOutputDir, resolvedOptions.tiledMapBasePath);
+			}
+		}
+	];
+}
+//#endregion
+export { compatibilityV4Plugin, directivePlugin, entryPointPlugin, removeImportsPlugin, replaceConfigImport, rpgjs, rpgjsModuleViteConfig, serverPlugin, tiledMapFolderPlugin };
 
 //# sourceMappingURL=index.js.map