vite-plugin-fvtt 0.2.2 → 0.2.4

package/CHANGELOG.md

@@ -1,8 +1,28 @@
 # Changelog
 
-## [0.2.2]
+## [0.2.4] - 2025-09-23
 
-## Fixed
+### Changed
+
+- Removed dependencies of `fs-extra` and `dotenv` to shrink the dependencies.
+- Async file loading should improve the performance for a large number of language files significantly.
+
+## [0.2.3] - 2025-09-20
+
+### Fixed
+
+- Return absolute paths from globbing.
+- Refactor path-utils import and usage across codebase, for better Windows support.
+- Refactor logger to use static Logger class methods.
+- Bump dependencies.
+
+### Added
+
+- Add Vitest and fixture-based build test.
+
+## [0.2.2] - 2025-09-10
+
+### Fixed
 
 - Improve windows path resolution.
 
@@ -75,7 +95,8 @@
 
 - Initial Release
 
-[unreleased]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.2...HEAD
+[unreleased]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.3...HEAD
+[0.2.3]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.2...v0.2.3
 [0.2.2]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.1.4...v0.2.0

package/README.md

@@ -104,7 +104,8 @@ Merging follows your manifest’s declared language paths, searching in root or
 
 ### **6. Packs**
 
-Packs are tried to be auto-discovered in the source directory. If the paths match, they are automatically compiled.
+Packs are tried to be auto-discovered in the source directory. If the paths match, they are
+automatically compiled.
 
 **Note:** Packs are currently not watched for changes.
 

package/dist/index.d.ts

@@ -3,6 +3,6 @@ import { Plugin } from "vite";
 //#region src/index.d.ts
 declare function foundryVTTPlugin(options?: {
   buildPacks: boolean;
-}): Plugin;
+}): Promise<Plugin>;
 //#endregion
 export { foundryVTTPlugin as default };

package/dist/index.js

@@ -1,8 +1,6 @@
-import fs from "fs-extra";
-import posix from "path/posix";
-import dotenv from "dotenv";
 import path from "path";
-import { globSync } from "tinyglobby";
+import { glob } from "tinyglobby";
+import fs from "fs/promises";
 import { compilePack } from "@foundryvtt/foundryvtt-cli";
 import { Server } from "socket.io";
 import { io } from "socket.io-client";
@@ -10,73 +8,126 @@ import { io } from "socket.io-client";
 //#region src/context.ts
 const context = {};
 
+//#endregion
+//#region src/utils/fs-utils.ts
+var FsUtils = class FsUtils {
+	static async checkType(p, check) {
+		try {
+			const stats = await fs.stat(p);
+			return check(stats);
+		} catch {
+			return false;
+		}
+	}
+	static async fileExists(p) {
+		return FsUtils.checkType(p, (s) => s.isFile());
+	}
+	static async dirExists(p) {
+		return FsUtils.checkType(p, (s) => s.isDirectory());
+	}
+	static async readFile(filePath, encoding = "utf-8") {
+		return fs.readFile(filePath, { encoding });
+	}
+	static async readJson(filePath) {
+		try {
+			const content = await FsUtils.readFile(filePath);
+			return JSON.parse(content);
+		} catch {
+			return null;
+		}
+	}
+};
+var fs_utils_default = FsUtils;
+
 //#endregion
 //#region src/config/env.ts
-function loadEnv() {
-	const envPath = path.resolve(process.cwd(), ".env.foundryvtt.local");
-	const { parsed } = dotenv.config({
-		path: envPath,
-		quiet: true
-	});
+function parseEnv(content) {
+	const result = {};
+	for (const line of content.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const [key, ...rest] = trimmed.split("=");
+		result[key.trim()] = rest.join("=").trim();
+	}
+	return result;
+}
+async function loadEnv() {
+	const envPaths = await glob(".env.foundryvtt*", { absolute: true });
+	let merged = {
+		FOUNDRY_URL: "localhost",
+		FOUNDRY_PORT: "30000"
+	};
+	for (const file of envPaths) {
+		const content = await fs_utils_default.readFile(file, "utf-8");
+		merged = {
+			...merged,
+			...parseEnv(content)
+		};
+	}
 	return {
-		foundryUrl: parsed?.FOUNDRY_URL ?? "localhost",
-		foundryPort: parseInt(parsed?.FOUNDRY_PORT ?? "30000", 10)
+		foundryUrl: merged.FOUNDRY_URL,
+		foundryPort: parseInt(merged.FOUNDRY_PORT, 10)
 	};
 }
 
 //#endregion
 //#region src/utils/logger.ts
-var Logger = class {
-	namespace;
-	colors = {
-		info: "\x1B[32m",
+var Logger = class Logger {
+	static namespace = "vite-plugin-fvtt";
+	static colors = {
+		info: "\x1B[36m",
 		warn: "\x1B[33m",
 		error: "\x1B[31m"
 	};
-	constructor({ namespace = "vite-plugin-fvtt" } = {}) {
-		this.namespace = namespace;
+	static reset = "\x1B[0m";
+	initialize(namespace = "vite-plugin-fvtt") {
+		Logger.namespace = namespace;
 	}
-	format(level, message) {
-		const color = this.colors[level] ?? "";
-		const reset = "\x1B[0m";
-		return `${color}[${this.namespace}] [${level.toUpperCase()}]${reset} ${message}`;
+	static format(level, message) {
+		return `${Logger.colors[level] ?? ""}[${Logger.namespace}] [${level.toUpperCase()}]${Logger.reset} ${message}`;
 	}
-	info(message) {
-		console.log(this.format("info", message));
+	static info(message) {
+		console.log(Logger.format("info", message));
 	}
-	warn(message) {
-		console.warn(this.format("warn", message));
+	static warn(message) {
+		console.warn(Logger.format("warn", message));
 	}
-	error(message) {
-		console.error(this.format("error", message));
+	static error(message) {
+		console.error(Logger.format("error", message));
 	}
-	fail(message) {
-		this.error(message);
-		throw new Error(typeof message === "string" ? message : JSON.stringify(message, null, 2));
+	static fail(message) {
+		const formatted = Logger.format("error", Logger.stringify(message));
+		console.error(formatted);
+		throw new Error(formatted);
+	}
+	static stringify(message) {
+		if (message instanceof Error) return message.stack ?? message.message;
+		return typeof message === "string" ? message : JSON.stringify(message, null, 2);
 	}
 };
-var logger_default = new Logger();
+var logger_default = Logger;
 
 //#endregion
 //#region src/config/foundryvtt-manifest.ts
-function loadManifest(config) {
+async function loadManifest(config) {
 	if (context?.manifest) return context.manifest;
 	const publicDir = config.publicDir || "public";
-	const MANIFEST_LOCATIONS = [
+	const paths = [
 		"system.json",
 		"module.json",
 		`${publicDir}/system.json`,
 		`${publicDir}/module.json`
-	];
-	const foundPath = MANIFEST_LOCATIONS.map((relPath) => path.resolve(process.cwd(), relPath)).find((absPath) => fs.pathExistsSync(absPath));
+	].map((f) => path.resolve(process.cwd(), f));
+	const idx = (await Promise.all(paths.map((p) => fs_utils_default.fileExists(p)))).findIndex(Boolean);
+	const foundPath = idx !== -1 ? paths[idx] : void 0;
 	if (!foundPath) logger_default.fail(`Could not find a manifest file (system.json or module.json) in project root or ${publicDir}/.`);
 	try {
-		const data = fs.readJsonSync(foundPath);
+		const data = await fs_utils_default.readJson(foundPath);
 		if (!data.id || typeof data.id !== "string") logger_default.fail(`Manifest at ${foundPath} is missing required "id" field.`);
 		const hasEsmodules = Array.isArray(data.esmodules) && data.esmodules.length > 0;
 		const hasScripts = Array.isArray(data.scripts) && data.scripts.length > 0;
 		if (hasEsmodules === hasScripts) logger_default.fail(`Manifest at ${foundPath} must define exactly one of "esmodules" or "scripts".`);
-		const result = {
+		return {
 			manifestType: foundPath.includes("module.json") ? "module" : "system",
 			id: data.id,
 			esmodules: Array.isArray(data.esmodules) ? data.esmodules : [],
@@ -85,7 +136,6 @@ function loadManifest(config) {
 			languages: Array.isArray(data.languages) ? data.languages : [],
 			packs: Array.isArray(data.packs) ? data.packs : []
 		};
-		return result;
 	} catch (err) {
 		logger_default.fail(`Failed to read manifest at ${foundPath}: ${err?.message || err}`);
 	}
@@ -122,8 +172,7 @@ function createPartialViteConfig(config) {
 			rollupOptions: { output: {
 				entryFileNames: fileName,
 				assetFileNames: (assetInfo) => {
-					const names = assetInfo.names ?? [];
-					if (names.some((n) => n.endsWith(".css"))) return cssFileName;
+					if ((assetInfo.names ?? []).some((n) => n.endsWith(".css"))) return cssFileName;
 					return "[name][extname]";
 				}
 			} }
@@ -220,8 +269,7 @@ var PathUtils = class PathUtils {
 	static getSourceDirectory() {
 		if (!PathUtils._sourceDirectory) {
 			const config = PathUtils.getConfig();
-			const normalizedEntry = path.normalize(config.build.lib.entry.toString());
-			const segments = normalizedEntry.split(path.sep).filter(Boolean).filter((s) => s !== ".");
+			const segments = path.normalize(config.build.lib.entry.toString()).split(path.sep).filter(Boolean).filter((s) => s !== ".");
 			const firstFolder = segments.length > 0 ? segments[0] : ".";
 			PathUtils._sourceDirectory = path.join(config.root, firstFolder);
 		}
@@ -248,28 +296,28 @@ var PathUtils = class PathUtils {
 		}
 		return PathUtils._root;
 	}
-	static getOutDirFile(p) {
+	static async getOutDirFile(p) {
 		const file = path.join(PathUtils.getOutDir(), p);
-		return fs.existsSync(file) ? file : "";
+		return await fs_utils_default.fileExists(file) ? file : "";
 	}
-	static getPublicDirFile(p) {
+	static async getPublicDirFile(p) {
 		const file = path.join(PathUtils.getPublicDir(), p);
-		return fs.existsSync(file) ? file : "";
+		return await fs_utils_default.fileExists(file) ? file : "";
 	}
-	static findLocalFilePath(p) {
+	static async findLocalFilePath(p) {
 		const fileCandidates = [
 			PathUtils.getPublicDir(),
 			PathUtils.getSourceDirectory(),
 			PathUtils.getRoot()
 		].map((pth) => path.join(pth, p));
-		return fileCandidates.find((pth) => fs.existsSync(pth)) ?? null;
+		const idx = (await Promise.all(fileCandidates.map(fs_utils_default.fileExists))).findIndex(Boolean);
+		return idx !== -1 ? fileCandidates[idx] : null;
 	}
 	static isFoundryVTTUrl(p) {
 		const decodedBase = PathUtils.getDecodedBase();
-		const pathToCheck = path.posix.normalize(p);
-		return pathToCheck.startsWith(decodedBase);
+		return path.posix.normalize(p).startsWith(decodedBase);
 	}
-	static foundryVTTUrlToLocal(p) {
+	static async foundryVTTUrlToLocal(p) {
 		const decodedBase = PathUtils.getDecodedBase();
 		let pathToTransform = path.posix.normalize("/" + p);
 		if (!pathToTransform.startsWith(decodedBase)) return null;
@@ -290,8 +338,7 @@ var PathUtils = class PathUtils {
 	}
 	static getLanguageSourcePath(p, lang) {
 		const dir = path.parse(p).dir;
-		const lastDirName = path.basename(dir);
-		const finalSegments = lastDirName === lang ? dir : path.join(dir, lang);
+		const finalSegments = path.basename(dir) === lang ? dir : path.join(dir, lang);
 		return path.join(PathUtils.getSourceDirectory(), finalSegments);
 	}
 };
@@ -299,33 +346,33 @@ var path_utils_default = PathUtils;
 
 //#endregion
 //#region src/language/loader.ts
-function getLocalLanguageFiles(lang, outDir = false) {
-	const manifest = context.manifest;
-	const language = manifest.languages.find((l) => l.lang === lang);
+async function getLocalLanguageFiles(lang, outDir = false) {
+	const language = context.manifest.languages.find((l) => l.lang === lang);
 	if (!language) logger_default.fail(`Cannot find language "${lang}"`);
 	const langPath = language?.path ?? "";
-	if (outDir) {
-		const languageFile = path_utils_default.getOutDirFile(langPath);
-		return [languageFile];
-	}
-	const publicDirFile = path_utils_default.getPublicDirFile(langPath);
+	if (outDir) return [await path_utils_default.getOutDirFile(langPath)];
+	const publicDirFile = await path_utils_default.getPublicDirFile(langPath);
 	if (publicDirFile !== "") return [publicDirFile];
 	const sourcePath = path_utils_default.getLanguageSourcePath(langPath, lang);
-	if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isDirectory()) {
-		logger_default.warn(`No language folder found at: ${sourcePath}`);
-		return [];
-	}
-	return globSync(posix.join(sourcePath, "**/*.json"));
+	if (await fs_utils_default.dirExists(sourcePath)) return await glob(path.join(sourcePath, "**/*.json"), { absolute: true });
+	logger_default.warn(`No language folder found at: ${sourcePath}`);
+	return [];
 }
-function loadLanguage(lang, outDir = false) {
-	const files = getLocalLanguageFiles(lang, outDir);
+async function loadLanguage(lang, outDir = false) {
+	const files = await getLocalLanguageFiles(lang, outDir);
 	const result = /* @__PURE__ */ new Map();
-	for (const file of files) try {
-		result.set(file, fs.readJSONSync(file));
-		languageTracker.addFile(lang, file);
-	} catch (e) {
-		logger_default.warn(e);
-	}
+	const reads = files.map(async (file) => {
+		try {
+			const json = await fs_utils_default.readJson(file);
+			languageTracker.addFile(lang, file);
+			return [file, json];
+		} catch (e) {
+			logger_default.warn(e);
+			return null;
+		}
+	});
+	const results = await Promise.all(reads);
+	for (const entry of results) if (entry) result.set(entry[0], entry[1]);
 	return result;
 }
 
@@ -364,9 +411,9 @@ function transform(dataMap) {
 
 //#endregion
 //#region src/language/validator.ts
-function validator() {
+async function validator() {
 	const manifest = context.manifest;
-	const baseLanguageData = loadLanguage("en", true);
+	const baseLanguageData = await loadLanguage("en", true);
 	if (baseLanguageData.size === 0) {
 		logger_default.error("Base language \"en\" not found or could not be loaded.");
 		return;
@@ -374,17 +421,17 @@ function validator() {
 	const base = flattenKeys(baseLanguageData.values().next().value);
 	for (const lang of manifest.languages) {
 		if (lang.lang === "en") continue;
-		const currentLanguageData = loadLanguage(lang.lang, true);
+		const currentLanguageData = await loadLanguage(lang.lang, true);
 		if (currentLanguageData.size === 0) {
-			console.warn(`Summary for language [${lang.lang}]: Could not be loaded.`);
+			logger_default.warn(`Summary for language [${lang.lang}]: Could not be loaded.`);
 			continue;
 		}
 		const current = flattenKeys(currentLanguageData.values().next().value);
 		const missing = Object.keys(base).filter((key) => !(key in current));
 		const extra = Object.keys(current).filter((key) => !(key in base));
-		console.log(`Summary for language [${lang.lang}]:`);
-		if (missing.length) console.warn(`\tMissing keys: ${missing.length}`, missing.slice(0, 5));
-		if (extra.length) console.warn(`\tExtra keys: ${extra.length}`, extra.slice(0, 5));
+		logger_default.info(`Summary for language [${lang.lang}]:`);
+		if (missing.length) console.warn(`Missing keys: ${missing.length}`, missing.slice(0, 5));
+		if (extra.length) console.warn(`Extra keys: ${extra.length}`, extra.slice(0, 5));
 		if (!missing.length && !extra.length) console.log("	✅ All keys match.");
 	}
 }
@@ -396,16 +443,19 @@ async function compileManifestPacks() {
 	for (const pack of context.manifest.packs) {
 		const srcCandidates = [path.resolve(path_utils_default.getSourceDirectory(), pack.path), path.resolve(path_utils_default.getRoot(), pack.path)];
 		const dest = path.resolve(path_utils_default.getOutDir(), pack.path);
-		const chosenSrc = srcCandidates.find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isDirectory());
+		let chosenSrc;
+		for (const candidate of srcCandidates) if (await fs_utils_default.dirExists(candidate)) {
+			chosenSrc = candidate;
+			break;
+		}
 		if (!chosenSrc) {
 			logger_default.warn(`Pack path not found for ${pack.path}, skipped.`);
 			continue;
 		}
-		const entries = fs.readdirSync(chosenSrc, {
-			recursive: true,
-			encoding: "utf8"
-		});
-		const hasYaml = entries.some((entry) => entry.endsWith(".yaml") || entry.endsWith(".yml"));
+		const hasYaml = (await glob(["**/*.yaml", "**/*.yml"], {
+			cwd: chosenSrc,
+			absolute: true
+		})).length > 0;
 		await compilePack(chosenSrc, dest, {
 			yaml: hasYaml,
 			recursive: true
@@ -430,7 +480,7 @@ const handlebarsTracker = new HandlebarsTracker();
 //#endregion
 //#region src/server/http-middleware.ts
 function httpMiddlewareHook(server) {
-	server.middlewares.use((req, res, next) => {
+	server.middlewares.use(async (req, res, next) => {
 		const config = context.config;
 		if (!path_utils_default.isFoundryVTTUrl(req.url ?? "")) {
 			next();
@@ -447,7 +497,7 @@ function httpMiddlewareHook(server) {
 		const languages = context.manifest.languages.filter((lang) => path_utils_default.localToFoundryVTTUrl(lang.path) === path.posix.normalize(req.url ?? ""));
 		if (languages.length === 1) {
 			const lang = languages[0].lang;
-			const language = loadLanguage(lang);
+			const language = await loadLanguage(lang);
 			const jsonData = transform(language);
 			res.setHeader("Content-Type", "application/json");
 			res.end(JSON.stringify(jsonData, null, 2));
@@ -461,20 +511,20 @@ function httpMiddlewareHook(server) {
 //#region src/server/socket-proxy.ts
 function socketProxy(server) {
 	const env = context.env;
-	const ioProxy = new Server(server.httpServer, { path: "/socket.io" });
-	ioProxy.on("connection", (socket) => {
+	new Server(server.httpServer, { path: "/socket.io" }).on("connection", (socket) => {
 		const upstream = io(`http://${env.foundryUrl}:${env.foundryPort}`, {
 			transports: ["websocket"],
 			upgrade: false,
 			query: socket.handshake.query
 		});
-		socket.onAny((event, ...args) => {
+		socket.onAny(async (event, ...args) => {
 			const maybeAck = typeof args[args.length - 1] === "function" ? args.pop() : null;
 			if (event === "template") {
-				const localPath = path_utils_default.foundryVTTUrlToLocal(args[0]);
+				const localPath = await path_utils_default.foundryVTTUrlToLocal(args[0]);
 				if (localPath) {
+					const html = await fs_utils_default.readFile(localPath);
 					if (maybeAck) maybeAck({
-						html: fs.readFileSync(localPath, "utf8"),
+						html,
 						success: true
 					});
 					handlebarsTracker.addFile(args[0], localPath);
@@ -486,8 +536,7 @@ function socketProxy(server) {
 			});
 		});
 		upstream.onAny((event, ...args) => {
-			const lastArg = args[args.length - 1];
-			const maybeAck = typeof lastArg === "function" ? args.pop() : null;
+			const maybeAck = typeof args[args.length - 1] === "function" ? args.pop() : null;
 			socket.emit(event, ...args, (response) => {
 				if (maybeAck) maybeAck(response);
 			});
@@ -585,24 +634,23 @@ if (import.meta.hot) {
 
 //#endregion
 //#region src/index.ts
-function foundryVTTPlugin(options = { buildPacks: true }) {
-	context.env = loadEnv();
+async function foundryVTTPlugin(options = { buildPacks: true }) {
+	context.env = await loadEnv();
 	return {
 		name: "vite-plugin-fvtt",
-		config(config) {
-			context.manifest = loadManifest(config) ?? void 0;
+		async config(config) {
+			context.manifest = await loadManifest(config) ?? void 0;
 			return createPartialViteConfig(config);
 		},
 		configResolved(config) {
 			context.config = config;
 		},
 		async generateBundle() {
-			const manifestCandidates = ["system.json", "module.json"];
-			for (const file of manifestCandidates) {
-				const src = posix.resolve(file);
-				if (!path_utils_default.getPublicDirFile(file) && fs.existsSync(src)) {
+			for (const file of ["system.json", "module.json"]) {
+				const src = path.resolve(file);
+				if (!path_utils_default.getPublicDirFile(file) && await fs_utils_default.fileExists(src)) {
 					this.addWatchFile(src);
-					const manifest = fs.readJsonSync(src);
+					const manifest = await fs_utils_default.readJson(src);
 					this.emitFile({
 						type: "asset",
 						fileName: file,
@@ -612,13 +660,15 @@ function foundryVTTPlugin(options = { buildPacks: true }) {
 			}
 			const languages = context.manifest?.languages ?? [];
 			if (languages.length > 0) for (const language of languages) {
-				if (path_utils_default.getPublicDirFile(language.path)) continue;
-				getLocalLanguageFiles(language.lang).forEach((langFile) => this.addWatchFile(langFile));
-				const languageDataRaw = loadLanguage(language.lang);
+				if (await path_utils_default.getPublicDirFile(language.path)) continue;
+				getLocalLanguageFiles(language.lang).then((langFiles) => {
+					langFiles.forEach((file) => this.addWatchFile(file));
+				});
+				const languageDataRaw = await loadLanguage(language.lang);
 				const languageData = transform(languageDataRaw);
 				this.emitFile({
 					type: "asset",
-					fileName: posix.join(language.path),
+					fileName: path.join(language.path),
 					source: JSON.stringify(languageData, null, 2)
 				});
 			}
@@ -627,17 +677,12 @@ function foundryVTTPlugin(options = { buildPacks: true }) {
 			if (options.buildPacks) await compileManifestPacks();
 		},
 		closeBundle() {
-			const languages = context.manifest?.languages ?? [];
-			if (languages.length > 0) validator();
+			if ((context.manifest?.languages ?? []).length > 0) validator();
 		},
 		load(id) {
 			const config = context.config;
 			const jsFileName = (config.build.rollupOptions?.output).entryFileNames;
-			if (id === jsFileName || id === `/${jsFileName}`) {
-				const entryPath = posix.resolve(config.build.lib.entry);
-				const viteId = `/@fs/${entryPath}`;
-				return `import '${viteId}';\n${hmr_client_default}`;
-			}
+			if (id === jsFileName || id === `/${jsFileName}`) return `import '${`/@fs/${path.resolve(config.build.lib.entry)}`}';\n${hmr_client_default}`;
 		},
 		configureServer: setupDevServer
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-fvtt",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "A Vite plugin for module and system development for Foundry VTT",
   "keywords": [
     "vite",
@@ -28,23 +28,22 @@
   ],
   "scripts": {
     "dev": "tsdown --watch",
-    "build": "tsdown"
+    "build": "tsdown",
+    "test": "vitest"
   },
   "devDependencies": {
     "@eslint/js": "^9.34.0",
-    "@types/fs-extra": "^11.0.4",
     "@types/node": "^24.3.0",
     "eslint": "^9.34.0",
     "prettier": "^3.6.2",
-    "tsdown": "^0.14.2",
+    "tsdown": "^0.15.1",
     "typescript": "^5.9.2",
     "typescript-eslint": "^8.41.0",
-    "vite": "*"
+    "vite": "*",
+    "vitest": "^3.2.4"
   },
   "dependencies": {
     "@foundryvtt/foundryvtt-cli": "^3.0.0",
-    "dotenv": "^17.2.1",
-    "fs-extra": "^11.3.1",
     "socket.io": "^4.8.1",
     "socket.io-client": "^4.8.1",
     "tinyglobby": "^0.2.15"