maxsimcli 1.2.1 → 1.2.3

package/dist/assets/dashboard/server.js

@@ -1,23 +1,3 @@
-import { createRequire } from "node:module";
-import { createServer } from "node:http";
-import { fileURLToPath, parse } from "node:url";
-import next from "next";
-import { createServer as createServer$1 } from "node:net";
-import { debuglog, promisify } from "node:util";
-import os from "node:os";
-import fs, { constants, lstat, readdir, realpath, stat } from "node:fs/promises";
-import childProcess, { execFile } from "node:child_process";
-import process$1 from "node:process";
-import { Buffer as Buffer$1 } from "node:buffer";
-import path, { join, relative, resolve, sep } from "node:path";
-import fs$1 from "node:fs";
-import { EventEmitter } from "events";
-import { stat as stat$1, unwatchFile, watch, watchFile } from "fs";
-import { lstat as lstat$1, open, readdir as readdir$1, realpath as realpath$1, stat as stat$2 } from "fs/promises";
-import * as sysPath from "path";
-import { Readable } from "node:stream";
-import { type } from "os";
-
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -44,13 +24,39 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
+let node_http = require("node:http");
+let node_url = require("node:url");
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let next = require("next");
+next = __toESM(next);
+let node_net = require("node:net");
+let node_util = require("node:util");
+let node_os = require("node:os");
+node_os = __toESM(node_os);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let node_child_process = require("node:child_process");
+node_child_process = __toESM(node_child_process);
+let node_process = require("node:process");
+node_process = __toESM(node_process);
+let node_buffer = require("node:buffer");
+let events = require("events");
+let fs = require("fs");
+let fs_promises = require("fs/promises");
+let path = require("path");
+path = __toESM(path);
+let node_stream = require("node:stream");
+let os = require("os");
+
 //#region ../../node_modules/.pnpm/address@2.0.3/node_modules/address/dist/esm/address.js
 function getDefaultInterfaceName() {
 	let val = "eth";
-	const platform = os.platform();
+	const platform = node_os.default.platform();
 	if (platform === "darwin") val = "en";
 	else if (platform === "win32") val = void 0;
 	return val;
@@ -72,7 +78,7 @@ function findAddressFromInterface(items, expectedFamily, ignoreLoAddress = false
 	return firstMatchItem;
 }
 function getInterfaceAddress(family, name) {
-	const interfaces = os.networkInterfaces();
+	const interfaces = node_os.default.networkInterfaces();
 	const noName = !name;
 	name = name || getDefaultInterfaceName();
 	family = family || "IPv4";
@@ -102,7 +108,7 @@ function ip(interfaceName) {
 
 //#endregion
 //#region ../../node_modules/.pnpm/detect-port@2.1.0/node_modules/detect-port/dist/esm/detect-port.js
-const debug$1 = debuglog("detect-port");
+const debug$1 = (0, node_util.debuglog)("detect-port");
 var IPAddressNotAvailableError = class extends Error {
 	constructor(options) {
 		super("The IP address is not available on this machine", options);
@@ -170,7 +176,7 @@ async function tryListen(port, maxPort, hostname) {
 	}
 }
 function listen(port, hostname) {
-	const server = createServer$1();
+	const server = (0, node_net.createServer)();
 	return new Promise((resolve, reject) => {
 		server.once("error", (err) => {
 			debug$1("listen %s:%s error: %s", hostname, port, err);
@@ -193,7 +199,7 @@ function listen(port, hostname) {
 
 //#endregion
 //#region ../../node_modules/.pnpm/detect-port@2.1.0/node_modules/detect-port/dist/esm/wait-port.js
-const debug = debuglog("detect-port:wait-port");
+const debug = (0, node_util.debuglog)("detect-port:wait-port");
 
 //#endregion
 //#region ../../node_modules/.pnpm/detect-port@2.1.0/node_modules/detect-port/dist/esm/index.js
@@ -204,7 +210,7 @@ var esm_default = detectPort;
 let isDockerCached;
 function hasDockerEnv() {
 	try {
-		fs$1.statSync("/.dockerenv");
+		node_fs.default.statSync("/.dockerenv");
 		return true;
 	} catch {
 		return false;
@@ -212,7 +218,7 @@ function hasDockerEnv() {
 }
 function hasDockerCGroup() {
 	try {
-		return fs$1.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+		return node_fs.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
 	} catch {
 		return false;
 	}
@@ -227,7 +233,7 @@ function isDocker() {
 let cachedResult;
 const hasContainerEnv = () => {
 	try {
-		fs$1.statSync("/run/.containerenv");
+		node_fs.default.statSync("/run/.containerenv");
 		return true;
 	} catch {
 		return false;
@@ -241,18 +247,18 @@ function isInsideContainer() {
 //#endregion
 //#region ../../node_modules/.pnpm/is-wsl@3.1.1/node_modules/is-wsl/index.js
 const isWsl = () => {
-	if (process$1.platform !== "linux") return false;
-	if (os.release().toLowerCase().includes("microsoft")) {
+	if (node_process.default.platform !== "linux") return false;
+	if (node_os.default.release().toLowerCase().includes("microsoft")) {
 		if (isInsideContainer()) return false;
 		return true;
 	}
 	try {
-		if (fs$1.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) return !isInsideContainer();
+		if (node_fs.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) return !isInsideContainer();
 	} catch {}
-	if (fs$1.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs$1.existsSync("/run/WSL")) return !isInsideContainer();
+	if (node_fs.default.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || node_fs.default.existsSync("/run/WSL")) return !isInsideContainer();
 	return false;
 };
-var is_wsl_default = process$1.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+var is_wsl_default = node_process.default.env.__IS_WSL_TEST__ ? isWsl : isWsl();
 
 //#endregion
 //#region ../../node_modules/.pnpm/wsl-utils@0.1.0/node_modules/wsl-utils/index.js
@@ -264,11 +270,11 @@ const wslDrivesMountPoint = (() => {
 		const configFilePath = "/etc/wsl.conf";
 		let isConfigFileExists = false;
 		try {
-			await fs.access(configFilePath, constants.F_OK);
+			await node_fs_promises.default.access(configFilePath, node_fs_promises.constants.F_OK);
 			isConfigFileExists = true;
 		} catch {}
 		if (!isConfigFileExists) return defaultMountPoint;
-		const configContent = await fs.readFile(configFilePath, { encoding: "utf8" });
+		const configContent = await node_fs_promises.default.readFile(configFilePath, { encoding: "utf8" });
 		const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
 		if (!configMountPoint) return defaultMountPoint;
 		mountPoint = configMountPoint.groups.mountPoint.trim();
@@ -281,7 +287,7 @@ const powerShellPathFromWsl = async () => {
 };
 const powerShellPath = async () => {
 	if (is_wsl_default) return powerShellPathFromWsl();
-	return `${process$1.env.SYSTEMROOT || process$1.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+	return `${node_process.default.env.SYSTEMROOT || node_process.default.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
 };
 
 //#endregion
@@ -309,9 +315,9 @@ function defineLazyProperty(object, propertyName, valueGetter) {
 
 //#endregion
 //#region ../../node_modules/.pnpm/default-browser-id@5.0.1/node_modules/default-browser-id/index.js
-const execFileAsync$3 = promisify(execFile);
+const execFileAsync$3 = (0, node_util.promisify)(node_child_process.execFile);
 async function defaultBrowserId() {
-	if (process$1.platform !== "darwin") throw new Error("macOS only");
+	if (node_process.default.platform !== "darwin") throw new Error("macOS only");
 	const { stdout } = await execFileAsync$3("defaults", [
 		"read",
 		"com.apple.LaunchServices/com.apple.launchservices.secure",
@@ -324,9 +330,9 @@ async function defaultBrowserId() {
 
 //#endregion
 //#region ../../node_modules/.pnpm/run-applescript@7.1.0/node_modules/run-applescript/index.js
-const execFileAsync$2 = promisify(execFile);
+const execFileAsync$2 = (0, node_util.promisify)(node_child_process.execFile);
 async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
-	if (process$1.platform !== "darwin") throw new Error("macOS only");
+	if (node_process.default.platform !== "darwin") throw new Error("macOS only");
 	const outputArguments = humanReadableOutput ? [] : ["-ss"];
 	const execOptions = {};
 	if (signal) execOptions.signal = signal;
@@ -346,7 +352,7 @@ async function bundleName(bundleId) {
 
 //#endregion
 //#region ../../node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/windows.js
-const execFileAsync$1 = promisify(execFile);
+const execFileAsync$1 = (0, node_util.promisify)(node_child_process.execFile);
 const windowsBrowserProgIds = {
 	MSEdgeHTM: {
 		name: "Edge",
@@ -437,17 +443,17 @@ async function defaultBrowser$1(_execFileAsync = execFileAsync$1) {
 
 //#endregion
 //#region ../../node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/index.js
-const execFileAsync = promisify(execFile);
+const execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
 const titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
 async function defaultBrowser() {
-	if (process$1.platform === "darwin") {
+	if (node_process.default.platform === "darwin") {
 		const id = await defaultBrowserId();
 		return {
 			name: await bundleName(id),
 			id
 		};
 	}
-	if (process$1.platform === "linux") {
+	if (node_process.default.platform === "linux") {
 		const { stdout } = await execFileAsync("xdg-mime", [
 			"query",
 			"default",
@@ -459,16 +465,16 @@ async function defaultBrowser() {
 			id
 		};
 	}
-	if (process$1.platform === "win32") return defaultBrowser$1();
+	if (node_process.default.platform === "win32") return defaultBrowser$1();
 	throw new Error("Only macOS, Linux, and Windows are supported");
 }
 
 //#endregion
 //#region ../../node_modules/.pnpm/open@10.2.0/node_modules/open/index.js
-const execFile$1 = promisify(childProcess.execFile);
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const localXdgOpenPath = path.join(__dirname, "xdg-open");
-const { platform, arch } = process$1;
+const execFile = (0, node_util.promisify)(node_child_process.default.execFile);
+const __dirname$1 = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+const localXdgOpenPath = node_path.default.join(__dirname$1, "xdg-open");
+const { platform, arch } = node_process.default;
 /**
 Get the default browser name in Windows from WSL.
 
@@ -477,13 +483,13 @@ Get the default browser name in Windows from WSL.
 async function getWindowsDefaultBrowserFromWsl() {
 	const powershellPath = await powerShellPath();
 	const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
-	const { stdout } = await execFile$1(powershellPath, [
+	const { stdout } = await execFile(powershellPath, [
 		"-NoProfile",
 		"-NonInteractive",
 		"-ExecutionPolicy",
 		"Bypass",
 		"-EncodedCommand",
-		Buffer$1.from(rawCommand, "utf16le").toString("base64")
+		node_buffer.Buffer.from(rawCommand, "utf16le").toString("base64")
 	], { encoding: "utf8" });
 	const progId = stdout.trim();
 	const browserMap = {
@@ -579,17 +585,17 @@ const baseOpen = async (options) => {
 			appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
 			encodedArguments.push("-ArgumentList", appArguments.join(","));
 		}
-		options.target = Buffer$1.from(encodedArguments.join(" "), "utf16le").toString("base64");
+		options.target = node_buffer.Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
 	} else {
 		if (app) command = app;
 		else {
-			const isBundled = !__dirname || __dirname === "/";
+			const isBundled = !__dirname$1 || __dirname$1 === "/";
 			let exeLocalXdgOpen = false;
 			try {
-				await fs.access(localXdgOpenPath, constants.X_OK);
+				await node_fs_promises.default.access(localXdgOpenPath, node_fs_promises.constants.X_OK);
 				exeLocalXdgOpen = true;
 			} catch {}
-			command = process$1.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen) ? "xdg-open" : localXdgOpenPath;
+			command = node_process.default.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen) ? "xdg-open" : localXdgOpenPath;
 		}
 		if (appArguments.length > 0) cliArguments.push(...appArguments);
 		if (!options.wait) {
@@ -599,7 +605,7 @@ const baseOpen = async (options) => {
 	}
 	if (platform === "darwin" && appArguments.length > 0) cliArguments.push("--args", ...appArguments);
 	if (options.target) cliArguments.push(options.target);
-	const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+	const subprocess = node_child_process.default.spawn(command, cliArguments, childProcessOptions);
 	if (options.wait) return new Promise((resolve, reject) => {
 		subprocess.once("error", reject);
 		subprocess.once("close", (exitCode) => {
@@ -778,7 +784,7 @@ var require_buffer_util = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 	/* istanbul ignore else  */
 	if (!process.env.WS_NO_BUFFER_UTIL) try {
-		const bufferUtil = __require("bufferutil");
+		const bufferUtil = require("bufferutil");
 		module.exports.mask = function(source, mask, output, offset, length) {
 			if (length < 48) _mask(source, mask, output, offset, length);
 			else bufferUtil.mask(source, mask, output, offset, length);
@@ -845,7 +851,7 @@ var require_limiter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/permessage-deflate.js
 var require_permessage_deflate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const zlib = __require("zlib");
+	const zlib = require("zlib");
 	const bufferUtil = require_buffer_util();
 	const Limiter = require_limiter();
 	const { kStatusCode } = require_constants();
@@ -1179,7 +1185,7 @@ var require_permessage_deflate = /* @__PURE__ */ __commonJSMin(((exports, module
 //#endregion
 //#region ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/validation.js
 var require_validation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { isUtf8 } = __require("buffer");
+	const { isUtf8 } = require("buffer");
 	const { hasBlob } = require_constants();
 	const tokenChars = [
 		0,
@@ -1366,7 +1372,7 @@ var require_validation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
 	};
 	else if (!process.env.WS_NO_UTF_8_VALIDATE) try {
-		const isValidUTF8 = __require("utf-8-validate");
+		const isValidUTF8 = require("utf-8-validate");
 		module.exports.isValidUTF8 = function(buf) {
 			return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
 		};
@@ -1376,7 +1382,7 @@ var require_validation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/receiver.js
 var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { Writable } = __require("stream");
+	const { Writable } = require("stream");
 	const PerMessageDeflate = require_permessage_deflate();
 	const { BINARY_TYPES, EMPTY_BUFFER, kStatusCode, kWebSocket } = require_constants();
 	const { concat, toArrayBuffer, unmask } = require_buffer_util();
@@ -1824,8 +1830,8 @@ var require_receiver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/sender.js
 var require_sender = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const { Duplex: Duplex$3 } = __require("stream");
-	const { randomFillSync } = __require("crypto");
+	const { Duplex: Duplex$3 } = require("stream");
+	const { randomFillSync } = require("crypto");
 	const PerMessageDeflate = require_permessage_deflate();
 	const { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
 	const { isBlob, isValidStatusCode } = require_validation();
@@ -2684,14 +2690,14 @@ var require_extension = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket.js
 var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const EventEmitter$2 = __require("events");
-	const https = __require("https");
-	const http$1 = __require("http");
-	const net = __require("net");
-	const tls = __require("tls");
-	const { randomBytes, createHash: createHash$1 } = __require("crypto");
-	const { Duplex: Duplex$2, Readable: Readable$1 } = __require("stream");
-	const { URL } = __require("url");
+	const EventEmitter$2 = require("events");
+	const https = require("https");
+	const http$1 = require("http");
+	const net = require("net");
+	const tls = require("tls");
+	const { randomBytes, createHash: createHash$1 } = require("crypto");
+	const { Duplex: Duplex$2, Readable: Readable$1 } = require("stream");
+	const { URL } = require("url");
 	const PerMessageDeflate = require_permessage_deflate();
 	const Receiver = require_receiver();
 	const Sender = require_sender();
@@ -3657,7 +3663,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#region ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/stream.js
 var require_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	require_websocket();
-	const { Duplex: Duplex$1 } = __require("stream");
+	const { Duplex: Duplex$1 } = require("stream");
 	/**
 	* Emits the `'close'` event on a stream.
 	*
@@ -3813,10 +3819,10 @@ var require_subprotocol = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket-server.js
 var require_websocket_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const EventEmitter$1 = __require("events");
-	const http = __require("http");
-	const { Duplex } = __require("stream");
-	const { createHash } = __require("crypto");
+	const EventEmitter$1 = require("events");
+	const http = require("http");
+	const { Duplex } = require("stream");
+	const { createHash } = require("crypto");
 	const extension = require_extension();
 	const PerMessageDeflate = require_permessage_deflate();
 	const subprotocol = require_subprotocol();
@@ -4292,7 +4298,7 @@ const normalizeFilter = (filter) => {
 	return emptyFn;
 };
 /** Readable readdir stream, emitting new files as they're being listed. */
-var ReaddirpStream = class extends Readable {
+var ReaddirpStream = class extends node_stream.Readable {
 	constructor(options = {}) {
 		super({
 			objectMode: true,
@@ -4306,14 +4312,14 @@ var ReaddirpStream = class extends Readable {
 		const { root, type } = opts;
 		this._fileFilter = normalizeFilter(opts.fileFilter);
 		this._directoryFilter = normalizeFilter(opts.directoryFilter);
-		const statMethod = opts.lstat ? lstat : stat;
+		const statMethod = opts.lstat ? node_fs_promises.lstat : node_fs_promises.stat;
 		if (wantBigintFsStats) this._stat = (path) => statMethod(path, { bigint: true });
 		else this._stat = statMethod;
 		this._maxDepth = opts.depth ?? defaultOptions.depth;
 		this._wantsDir = type ? DIR_TYPES.has(type) : false;
 		this._wantsFile = type ? FILE_TYPES.has(type) : false;
 		this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
-		this._root = resolve(root);
+		this._root = (0, node_path.resolve)(root);
 		this._isDirent = !opts.alwaysStat;
 		this._statsProp = this._isDirent ? "dirent" : "stats";
 		this._rdOptions = {
@@ -4371,7 +4377,7 @@ var ReaddirpStream = class extends Readable {
 	async _exploreDir(path, depth) {
 		let files;
 		try {
-			files = await readdir(path, this._rdOptions);
+			files = await (0, node_fs_promises.readdir)(path, this._rdOptions);
 		} catch (error) {
 			this._onError(error);
 		}
@@ -4385,9 +4391,9 @@ var ReaddirpStream = class extends Readable {
 		let entry;
 		const basename = this._isDirent ? dirent.name : dirent;
 		try {
-			const fullPath = resolve(join(path, basename));
+			const fullPath = (0, node_path.resolve)((0, node_path.join)(path, basename));
 			entry = {
-				path: relative(this._root, fullPath),
+				path: (0, node_path.relative)(this._root, fullPath),
 				fullPath,
 				basename
 			};
@@ -4410,12 +4416,12 @@ var ReaddirpStream = class extends Readable {
 		if (stats && stats.isSymbolicLink()) {
 			const full = entry.fullPath;
 			try {
-				const entryRealPath = await realpath(full);
-				const entryRealPathStats = await lstat(entryRealPath);
+				const entryRealPath = await (0, node_fs_promises.realpath)(full);
+				const entryRealPathStats = await (0, node_fs_promises.lstat)(entryRealPath);
 				if (entryRealPathStats.isFile()) return "file";
 				if (entryRealPathStats.isDirectory()) {
 					const len = entryRealPath.length;
-					if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
+					if (full.startsWith(entryRealPath) && full.substr(len, 1) === node_path.sep) {
 						const recursiveError = /* @__PURE__ */ new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
 						recursiveError.code = RECURSIVE_ERROR_CODE;
 						return this._onError(recursiveError);
@@ -4461,7 +4467,7 @@ const isWindows = pl === "win32";
 const isMacos = pl === "darwin";
 const isLinux = pl === "linux";
 const isFreeBSD = pl === "freebsd";
-const isIBMi = type() === "OS400";
+const isIBMi = (0, os.type)() === "OS400";
 const EVENTS = {
 	ALL: "all",
 	READY: "ready",
@@ -4476,8 +4482,8 @@ const EVENTS = {
 const EV = EVENTS;
 const THROTTLE_MODE_WATCH = "watch";
 const statMethods = {
-	lstat: lstat$1,
-	stat: stat$2
+	lstat: fs_promises.lstat,
+	stat: fs_promises.stat
 };
 const KEY_LISTENERS = "listeners";
 const KEY_ERR = "errHandlers";
@@ -4750,7 +4756,7 @@ const binaryExtensions = new Set([
 	"zip",
 	"zipx"
 ]);
-const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+const isBinaryPath = (filePath) => binaryExtensions.has(path.extname(filePath).slice(1).toLowerCase());
 const foreach = (val, fn) => {
 	if (val instanceof Set) val.forEach(fn);
 	else fn(val);
@@ -4781,14 +4787,14 @@ const FsWatchInstances = /* @__PURE__ */ new Map();
 * @param emitRaw emits raw event data
 * @returns {NativeFsWatcher}
 */
-function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path$23, options, listener, errHandler, emitRaw) {
 	const handleEvent = (rawEvent, evPath) => {
-		listener(path);
-		emitRaw(rawEvent, evPath, { watchedPath: path });
-		if (evPath && path !== evPath) fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+		listener(path$23);
+		emitRaw(rawEvent, evPath, { watchedPath: path$23 });
+		if (evPath && path$23 !== evPath) fsWatchBroadcast(path.resolve(path$23, evPath), KEY_LISTENERS, path.join(path$23, evPath));
 	};
 	try {
-		return watch(path, { persistent: options.persistent }, handleEvent);
+		return (0, fs.watch)(path$23, { persistent: options.persistent }, handleEvent);
 	} catch (error) {
 		errHandler(error);
 		return;
@@ -4813,12 +4819,12 @@ const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
 * @param options to be passed to fs_watch
 * @param handlers container for event listener functions
 */
-const setFsWatchListener = (path, fullPath, options, handlers) => {
+const setFsWatchListener = (path$27, fullPath, options, handlers) => {
 	const { listener, errHandler, rawEmitter } = handlers;
 	let cont = FsWatchInstances.get(fullPath);
 	let watcher;
 	if (!options.persistent) {
-		watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+		watcher = createFsWatchInstance(path$27, options, listener, errHandler, rawEmitter);
 		if (!watcher) return;
 		return watcher.close.bind(watcher);
 	}
@@ -4827,13 +4833,13 @@ const setFsWatchListener = (path, fullPath, options, handlers) => {
 		addAndConvert(cont, KEY_ERR, errHandler);
 		addAndConvert(cont, KEY_RAW, rawEmitter);
 	} else {
-		watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+		watcher = createFsWatchInstance(path$27, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
 		if (!watcher) return;
 		watcher.on(EV.ERROR, async (error) => {
 			const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
 			if (cont) cont.watcherUnusable = true;
 			if (isWindows && error.code === "EPERM") try {
-				await (await open(path, "r")).close();
+				await (await (0, fs_promises.open)(path$27, "r")).close();
 				broadcastErr(error);
 			} catch (err) {}
 			else broadcastErr(error);
@@ -4869,12 +4875,12 @@ const FsWatchFileInstances = /* @__PURE__ */ new Map();
 * @param handlers container for event listener functions
 * @returns closer
 */
-const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+const setFsWatchFileListener = (path$28, fullPath, options, handlers) => {
 	const { listener, rawEmitter } = handlers;
 	let cont = FsWatchFileInstances.get(fullPath);
 	const copts = cont && cont.options;
 	if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-		unwatchFile(fullPath);
+		(0, fs.unwatchFile)(fullPath);
 		cont = void 0;
 	}
 	if (cont) {
@@ -4885,7 +4891,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
 			listeners: listener,
 			rawEmitters: rawEmitter,
 			options,
-			watcher: watchFile(fullPath, options, (curr, prev) => {
+			watcher: (0, fs.watchFile)(fullPath, options, (curr, prev) => {
 				foreach(cont.rawEmitters, (rawEmitter) => {
 					rawEmitter(EV.CHANGE, fullPath, {
 						curr,
@@ -4893,7 +4899,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
 					});
 				});
 				const currmtime = curr.mtimeMs;
-				if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach(cont.listeners, (listener) => listener(path, curr));
+				if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach(cont.listeners, (listener) => listener(path$28, curr));
 			})
 		};
 		FsWatchFileInstances.set(fullPath, cont);
@@ -4903,7 +4909,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
 		delFromSet(cont, KEY_RAW, rawEmitter);
 		if (isEmptySet(cont.listeners)) {
 			FsWatchFileInstances.delete(fullPath);
-			unwatchFile(fullPath);
+			(0, fs.unwatchFile)(fullPath);
 			cont.options = cont.watcher = void 0;
 			Object.freeze(cont);
 		}
@@ -4923,22 +4929,22 @@ var NodeFsHandler = class {
 	* @param listener on fs change
 	* @returns closer for the watcher instance
 	*/
-	_watchWithNodeFs(path, listener) {
+	_watchWithNodeFs(path$24, listener) {
 		const opts = this.fsw.options;
-		const directory = sysPath.dirname(path);
-		const basename = sysPath.basename(path);
+		const directory = path.dirname(path$24);
+		const basename = path.basename(path$24);
 		this.fsw._getWatchedDir(directory).add(basename);
-		const absolutePath = sysPath.resolve(path);
+		const absolutePath = path.resolve(path$24);
 		const options = { persistent: opts.persistent };
 		if (!listener) listener = EMPTY_FN;
 		let closer;
 		if (opts.usePolling) {
 			options.interval = opts.interval !== opts.binaryInterval && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
-			closer = setFsWatchFileListener(path, absolutePath, options, {
+			closer = setFsWatchFileListener(path$24, absolutePath, options, {
 				listener,
 				rawEmitter: this.fsw._emitRaw
 			});
-		} else closer = setFsWatchListener(path, absolutePath, options, {
+		} else closer = setFsWatchListener(path$24, absolutePath, options, {
 			listener,
 			errHandler: this._boundHandleError,
 			rawEmitter: this.fsw._emitRaw
@@ -4951,24 +4957,24 @@ var NodeFsHandler = class {
 	*/
 	_handleFile(file, stats, initialAdd) {
 		if (this.fsw.closed) return;
-		const dirname = sysPath.dirname(file);
-		const basename = sysPath.basename(file);
+		const dirname = path.dirname(file);
+		const basename = path.basename(file);
 		const parent = this.fsw._getWatchedDir(dirname);
 		let prevStats = stats;
 		if (parent.has(basename)) return;
-		const listener = async (path, newStats) => {
+		const listener = async (path$29, newStats) => {
 			if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
 			if (!newStats || newStats.mtimeMs === 0) try {
-				const newStats = await stat$2(file);
+				const newStats = await (0, fs_promises.stat)(file);
 				if (this.fsw.closed) return;
 				const at = newStats.atimeMs;
 				const mt = newStats.mtimeMs;
 				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats);
 				if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats.ino) {
-					this.fsw._closeFile(path);
+					this.fsw._closeFile(path$29);
 					prevStats = newStats;
 					const closer = this._watchWithNodeFs(file, listener);
-					if (closer) this.fsw._addPathCloser(path, closer);
+					if (closer) this.fsw._addPathCloser(path$29, closer);
 				} else prevStats = newStats;
 			} catch (error) {
 				this.fsw._remove(dirname, basename);
@@ -4995,7 +5001,7 @@ var NodeFsHandler = class {
 	* @param item basename of this item
 	* @returns true if no more processing is needed for this entry.
 	*/
-	async _handleSymlink(entry, directory, path, item) {
+	async _handleSymlink(entry, directory, path$30, item) {
 		if (this.fsw.closed) return;
 		const full = entry.fullPath;
 		const dir = this.fsw._getWatchedDir(directory);
@@ -5003,7 +5009,7 @@ var NodeFsHandler = class {
 			this.fsw._incrReadyCount();
 			let linkPath;
 			try {
-				linkPath = await realpath$1(path);
+				linkPath = await (0, fs_promises.realpath)(path$30);
 			} catch (e) {
 				this.fsw._emitReady();
 				return true;
@@ -5012,12 +5018,12 @@ var NodeFsHandler = class {
 			if (dir.has(item)) {
 				if (this.fsw._symlinkPaths.get(full) !== linkPath) {
 					this.fsw._symlinkPaths.set(full, linkPath);
-					this.fsw._emit(EV.CHANGE, path, entry.stats);
+					this.fsw._emit(EV.CHANGE, path$30, entry.stats);
 				}
 			} else {
 				dir.add(item);
 				this.fsw._symlinkPaths.set(full, linkPath);
-				this.fsw._emit(EV.ADD, path, entry.stats);
+				this.fsw._emit(EV.ADD, path$30, entry.stats);
 			}
 			this.fsw._emitReady();
 			return true;
@@ -5026,7 +5032,7 @@ var NodeFsHandler = class {
 		this.fsw._symlinkPaths.set(full, true);
 	}
 	_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-		directory = sysPath.join(directory, "");
+		directory = path.join(directory, "");
 		throttler = this.fsw._throttle("readdir", directory, 1e3);
 		if (!throttler) return;
 		const previous = this.fsw._getWatchedDir(wh.path);
@@ -5042,17 +5048,17 @@ var NodeFsHandler = class {
 				return;
 			}
 			const item = entry.path;
-			let path = sysPath.join(directory, item);
+			let path$25 = path.join(directory, item);
 			current.add(item);
-			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) return;
+			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path$25, item)) return;
 			if (this.fsw.closed) {
 				stream = void 0;
 				return;
 			}
 			if (item === target || !target && !previous.has(item)) {
 				this.fsw._incrReadyCount();
-				path = sysPath.join(dir, sysPath.relative(dir, path));
-				this._addToNodeFs(path, initialAdd, wh, depth + 1);
+				path$25 = path.join(dir, path.relative(dir, path$25));
+				this._addToNodeFs(path$25, initialAdd, wh, depth + 1);
 			}
 		}).on(EV.ERROR, this._boundHandleError);
 		return new Promise((resolve, reject) => {
@@ -5086,10 +5092,10 @@ var NodeFsHandler = class {
 	* @returns closer for the watcher instance.
 	*/
 	async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
-		const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-		const tracked = parentDir.has(sysPath.basename(dir));
+		const parentDir = this.fsw._getWatchedDir(path.dirname(dir));
+		const tracked = parentDir.has(path.basename(dir));
 		if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) this.fsw._emit(EV.ADD_DIR, dir, stats);
-		parentDir.add(sysPath.basename(dir));
+		parentDir.add(path.basename(dir));
 		this.fsw._getWatchedDir(dir);
 		let throttler;
 		let closer;
@@ -5115,13 +5121,13 @@ var NodeFsHandler = class {
 	* @param depth Child path actually targeted for watch
 	* @param target Child path actually targeted for watch
 	*/
-	async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+	async _addToNodeFs(path$26, initialAdd, priorWh, depth, target) {
 		const ready = this.fsw._emitReady;
-		if (this.fsw._isIgnored(path) || this.fsw.closed) {
+		if (this.fsw._isIgnored(path$26) || this.fsw.closed) {
 			ready();
 			return false;
 		}
-		const wh = this.fsw._getWatchHelpers(path);
+		const wh = this.fsw._getWatchHelpers(path$26);
 		if (priorWh) {
 			wh.filterPath = (entry) => priorWh.filterPath(entry);
 			wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -5136,29 +5142,29 @@ var NodeFsHandler = class {
 			const follow = this.fsw.options.followSymlinks;
 			let closer;
 			if (stats.isDirectory()) {
-				const absPath = sysPath.resolve(path);
-				const targetPath = follow ? await realpath$1(path) : path;
+				const absPath = path.resolve(path$26);
+				const targetPath = follow ? await (0, fs_promises.realpath)(path$26) : path$26;
 				if (this.fsw.closed) return;
 				closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
 				if (this.fsw.closed) return;
 				if (absPath !== targetPath && targetPath !== void 0) this.fsw._symlinkPaths.set(absPath, targetPath);
 			} else if (stats.isSymbolicLink()) {
-				const targetPath = follow ? await realpath$1(path) : path;
+				const targetPath = follow ? await (0, fs_promises.realpath)(path$26) : path$26;
 				if (this.fsw.closed) return;
-				const parent = sysPath.dirname(wh.watchPath);
+				const parent = path.dirname(wh.watchPath);
 				this.fsw._getWatchedDir(parent).add(wh.watchPath);
 				this.fsw._emit(EV.ADD, wh.watchPath, stats);
-				closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+				closer = await this._handleDir(parent, stats, initialAdd, depth, path$26, wh, targetPath);
 				if (this.fsw.closed) return;
-				if (targetPath !== void 0) this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+				if (targetPath !== void 0) this.fsw._symlinkPaths.set(path.resolve(path$26), targetPath);
 			} else closer = this._handleFile(wh.watchPath, stats, initialAdd);
 			ready();
-			if (closer) this.fsw._addPathCloser(path, closer);
+			if (closer) this.fsw._addPathCloser(path$26, closer);
 			return false;
 		} catch (error) {
 			if (this.fsw._handleError(error)) {
 				ready();
-				return path;
+				return path$26;
 			}
 		}
 	}
@@ -5187,30 +5193,30 @@ function createPattern(matcher) {
 	if (typeof matcher === "object" && matcher !== null) return (string) => {
 		if (matcher.path === string) return true;
 		if (matcher.recursive) {
-			const relative = sysPath.relative(matcher.path, string);
+			const relative = path.relative(matcher.path, string);
 			if (!relative) return false;
-			return !relative.startsWith("..") && !sysPath.isAbsolute(relative);
+			return !relative.startsWith("..") && !path.isAbsolute(relative);
 		}
 		return false;
 	};
 	return () => false;
 }
-function normalizePath$1(path) {
-	if (typeof path !== "string") throw new Error("string expected");
-	path = sysPath.normalize(path);
-	path = path.replace(/\\/g, "/");
+function normalizePath$1(path$2) {
+	if (typeof path$2 !== "string") throw new Error("string expected");
+	path$2 = path.normalize(path$2);
+	path$2 = path$2.replace(/\\/g, "/");
 	let prepend = false;
-	if (path.startsWith("//")) prepend = true;
+	if (path$2.startsWith("//")) prepend = true;
 	const DOUBLE_SLASH_RE = /\/\//;
-	while (path.match(DOUBLE_SLASH_RE)) path = path.replace(DOUBLE_SLASH_RE, "/");
-	if (prepend) path = "/" + path;
-	return path;
+	while (path$2.match(DOUBLE_SLASH_RE)) path$2 = path$2.replace(DOUBLE_SLASH_RE, "/");
+	if (prepend) path$2 = "/" + path$2;
+	return path$2;
 }
 function matchPatterns(patterns, testString, stats) {
-	const path = normalizePath$1(testString);
+	const path$12 = normalizePath$1(testString);
 	for (let index = 0; index < patterns.length; index++) {
 		const pattern = patterns[index];
-		if (pattern(path, stats)) return true;
+		if (pattern(path$12, stats)) return true;
 	}
 	return false;
 }
@@ -5235,14 +5241,14 @@ const toUnix = (string) => {
 	if (prepend) str = SLASH + str;
 	return str;
 };
-const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
-const normalizeIgnored = (cwd = "") => (path) => {
-	if (typeof path === "string") return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
-	else return path;
+const normalizePathToUnix = (path$3) => toUnix(path.normalize(toUnix(path$3)));
+const normalizeIgnored = (cwd = "") => (path$4) => {
+	if (typeof path$4 === "string") return normalizePathToUnix(path.isAbsolute(path$4) ? path$4 : path.join(cwd, path$4));
+	else return path$4;
 };
-const getAbsolutePath = (path, cwd) => {
-	if (sysPath.isAbsolute(path)) return path;
-	return sysPath.join(cwd, path);
+const getAbsolutePath = (path$5, cwd) => {
+	if (path.isAbsolute(path$5)) return path$5;
+	return path.join(cwd, path$5);
 };
 const EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 /**
@@ -5266,9 +5272,9 @@ var DirEntry = class {
 		if (items.size > 0) return;
 		const dir = this.path;
 		try {
-			await readdir$1(dir);
+			await (0, fs_promises.readdir)(dir);
 		} catch (err) {
-			if (this._removeWatcher) this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+			if (this._removeWatcher) this._removeWatcher(path.dirname(dir), path.basename(dir));
 		}
 	}
 	has(item) {
@@ -5292,12 +5298,12 @@ var DirEntry = class {
 const STAT_METHOD_F = "stat";
 const STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-	constructor(path, follow, fsw) {
+	constructor(path$6, follow, fsw) {
 		this.fsw = fsw;
-		const watchPath = path;
-		this.path = path = path.replace(REPLACER_RE, "");
+		const watchPath = path$6;
+		this.path = path$6 = path$6.replace(REPLACER_RE, "");
 		this.watchPath = watchPath;
-		this.fullWatchPath = sysPath.resolve(watchPath);
+		this.fullWatchPath = path.resolve(watchPath);
 		this.dirParts = [];
 		this.dirParts.forEach((parts) => {
 			if (parts.length > 1) parts.pop();
@@ -5306,7 +5312,7 @@ var WatchHelper = class {
 		this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
 	}
 	entryPath(entry) {
-		return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath));
+		return path.join(this.watchPath, path.relative(this.watchPath, entry.fullPath));
 	}
 	filterPath(entry) {
 		const { stats } = entry;
@@ -5326,7 +5332,7 @@ var WatchHelper = class {
 *       .add(directories)
 *       .on('add', path => log('File', path, 'was added'))
 */
-var FSWatcher = class extends EventEmitter {
+var FSWatcher = class extends events.EventEmitter {
 	constructor(_opts = {}) {
 		super();
 		this.closed = false;
@@ -5408,23 +5414,23 @@ var FSWatcher = class extends EventEmitter {
 		this.closed = false;
 		this._closePromise = void 0;
 		let paths = unifyPaths(paths_);
-		if (cwd) paths = paths.map((path) => {
-			return getAbsolutePath(path, cwd);
+		if (cwd) paths = paths.map((path$13) => {
+			return getAbsolutePath(path$13, cwd);
 		});
-		paths.forEach((path) => {
-			this._removeIgnoredPath(path);
+		paths.forEach((path$14) => {
+			this._removeIgnoredPath(path$14);
 		});
 		this._userIgnored = void 0;
 		if (!this._readyCount) this._readyCount = 0;
 		this._readyCount += paths.length;
-		Promise.all(paths.map(async (path) => {
-			const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
+		Promise.all(paths.map(async (path$15) => {
+			const res = await this._nodeFsHandler._addToNodeFs(path$15, !_internal, void 0, 0, _origAdd);
 			if (res) this._emitReady();
 			return res;
 		})).then((results) => {
 			if (this.closed) return;
 			results.forEach((item) => {
-				if (item) this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+				if (item) this.add(path.dirname(item), path.basename(_origAdd || item));
 			});
 		});
 		return this;
@@ -5436,15 +5442,15 @@ var FSWatcher = class extends EventEmitter {
 		if (this.closed) return this;
 		const paths = unifyPaths(paths_);
 		const { cwd } = this.options;
-		paths.forEach((path) => {
-			if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
-				if (cwd) path = sysPath.join(cwd, path);
-				path = sysPath.resolve(path);
+		paths.forEach((path$7) => {
+			if (!path.isAbsolute(path$7) && !this._closers.has(path$7)) {
+				if (cwd) path$7 = path.join(cwd, path$7);
+				path$7 = path.resolve(path$7);
 			}
-			this._closePath(path);
-			this._addIgnoredPath(path);
-			if (this._watched.has(path)) this._addIgnoredPath({
-				path,
+			this._closePath(path$7);
+			this._addIgnoredPath(path$7);
+			if (this._watched.has(path$7)) this._addIgnoredPath({
+				path: path$7,
 				recursive: true
 			});
 			this._userIgnored = void 0;
@@ -5483,7 +5489,7 @@ var FSWatcher = class extends EventEmitter {
 	getWatched() {
 		const watchList = {};
 		this._watched.forEach((entry, dir) => {
-			const index = (this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir) || ONE_DOT;
+			const index = (this.options.cwd ? path.relative(this.options.cwd, dir) : dir) || ONE_DOT;
 			watchList[index] = entry.getChildren().sort();
 		});
 		return watchList;
@@ -5500,34 +5506,34 @@ var FSWatcher = class extends EventEmitter {
 	* @param stats arguments to be passed with event
 	* @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
 	*/
-	async _emit(event, path, stats) {
+	async _emit(event, path$8, stats) {
 		if (this.closed) return;
 		const opts = this.options;
-		if (isWindows) path = sysPath.normalize(path);
-		if (opts.cwd) path = sysPath.relative(opts.cwd, path);
-		const args = [path];
+		if (isWindows) path$8 = path.normalize(path$8);
+		if (opts.cwd) path$8 = path.relative(opts.cwd, path$8);
+		const args = [path$8];
 		if (stats != null) args.push(stats);
 		const awf = opts.awaitWriteFinish;
 		let pw;
-		if (awf && (pw = this._pendingWrites.get(path))) {
+		if (awf && (pw = this._pendingWrites.get(path$8))) {
 			pw.lastChange = /* @__PURE__ */ new Date();
 			return this;
 		}
 		if (opts.atomic) {
 			if (event === EVENTS.UNLINK) {
-				this._pendingUnlinks.set(path, [event, ...args]);
+				this._pendingUnlinks.set(path$8, [event, ...args]);
 				setTimeout(() => {
-					this._pendingUnlinks.forEach((entry, path) => {
+					this._pendingUnlinks.forEach((entry, path$16) => {
 						this.emit(...entry);
 						this.emit(EVENTS.ALL, ...entry);
-						this._pendingUnlinks.delete(path);
+						this._pendingUnlinks.delete(path$16);
 					});
 				}, typeof opts.atomic === "number" ? opts.atomic : 100);
 				return this;
 			}
-			if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
+			if (event === EVENTS.ADD && this._pendingUnlinks.has(path$8)) {
 				event = EVENTS.CHANGE;
-				this._pendingUnlinks.delete(path);
+				this._pendingUnlinks.delete(path$8);
 			}
 		}
 		if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -5542,17 +5548,17 @@ var FSWatcher = class extends EventEmitter {
 					this.emitWithAll(event, args);
 				}
 			};
-			this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+			this._awaitWriteFinish(path$8, awf.stabilityThreshold, event, awfEmit);
 			return this;
 		}
 		if (event === EVENTS.CHANGE) {
-			if (!this._throttle(EVENTS.CHANGE, path, 50)) return this;
+			if (!this._throttle(EVENTS.CHANGE, path$8, 50)) return this;
 		}
 		if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-			const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+			const fullPath = opts.cwd ? path.join(opts.cwd, path$8) : path$8;
 			let stats;
 			try {
-				stats = await stat$2(fullPath);
+				stats = await (0, fs_promises.stat)(fullPath);
 			} catch (err) {}
 			if (!stats || this.closed) return;
 			args.push(stats);
@@ -5576,20 +5582,20 @@ var FSWatcher = class extends EventEmitter {
 	* @param timeout duration of time to suppress duplicate actions
 	* @returns tracking object or false if action should be suppressed
 	*/
-	_throttle(actionType, path, timeout) {
+	_throttle(actionType, path$17, timeout) {
 		if (!this._throttled.has(actionType)) this._throttled.set(actionType, /* @__PURE__ */ new Map());
 		const action = this._throttled.get(actionType);
 		if (!action) throw new Error("invalid throttle");
-		const actionPath = action.get(path);
+		const actionPath = action.get(path$17);
 		if (actionPath) {
 			actionPath.count++;
 			return false;
 		}
 		let timeoutObject;
 		const clear = () => {
-			const item = action.get(path);
+			const item = action.get(path$17);
 			const count = item ? item.count : 0;
-			action.delete(path);
+			action.delete(path$17);
 			clearTimeout(timeoutObject);
 			if (item) clearTimeout(item.timeoutObject);
 			return count;
@@ -5600,7 +5606,7 @@ var FSWatcher = class extends EventEmitter {
 			clear,
 			count: 0
 		};
-		action.set(path, thr);
+		action.set(path$17, thr);
 		return thr;
 	}
 	_incrReadyCount() {
@@ -5614,34 +5620,34 @@ var FSWatcher = class extends EventEmitter {
 	* @param event
 	* @param awfEmit Callback to be called when ready for event to be emitted.
 	*/
-	_awaitWriteFinish(path, threshold, event, awfEmit) {
+	_awaitWriteFinish(path$9, threshold, event, awfEmit) {
 		const awf = this.options.awaitWriteFinish;
 		if (typeof awf !== "object") return;
 		const pollInterval = awf.pollInterval;
 		let timeoutHandler;
-		let fullPath = path;
-		if (this.options.cwd && !sysPath.isAbsolute(path)) fullPath = sysPath.join(this.options.cwd, path);
+		let fullPath = path$9;
+		if (this.options.cwd && !path.isAbsolute(path$9)) fullPath = path.join(this.options.cwd, path$9);
 		const now = /* @__PURE__ */ new Date();
 		const writes = this._pendingWrites;
 		function awaitWriteFinishFn(prevStat) {
-			stat$1(fullPath, (err, curStat) => {
-				if (err || !writes.has(path)) {
+			(0, fs.stat)(fullPath, (err, curStat) => {
+				if (err || !writes.has(path$9)) {
 					if (err && err.code !== "ENOENT") awfEmit(err);
 					return;
 				}
 				const now = Number(/* @__PURE__ */ new Date());
-				if (prevStat && curStat.size !== prevStat.size) writes.get(path).lastChange = now;
-				if (now - writes.get(path).lastChange >= threshold) {
-					writes.delete(path);
+				if (prevStat && curStat.size !== prevStat.size) writes.get(path$9).lastChange = now;
+				if (now - writes.get(path$9).lastChange >= threshold) {
+					writes.delete(path$9);
 					awfEmit(void 0, curStat);
 				} else timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
 			});
 		}
-		if (!writes.has(path)) {
-			writes.set(path, {
+		if (!writes.has(path$9)) {
+			writes.set(path$9, {
 				lastChange: now,
 				cancelWait: () => {
-					writes.delete(path);
+					writes.delete(path$9);
 					clearTimeout(timeoutHandler);
 					return event;
 				}
@@ -5652,31 +5658,31 @@ var FSWatcher = class extends EventEmitter {
 	/**
 	* Determines whether user has asked to ignore this path.
 	*/
-	_isIgnored(path, stats) {
-		if (this.options.atomic && DOT_RE.test(path)) return true;
+	_isIgnored(path$18, stats) {
+		if (this.options.atomic && DOT_RE.test(path$18)) return true;
 		if (!this._userIgnored) {
 			const { cwd } = this.options;
 			const ignored = (this.options.ignored || []).map(normalizeIgnored(cwd));
 			this._userIgnored = anymatch([...[...this._ignoredPaths].map(normalizeIgnored(cwd)), ...ignored], void 0);
 		}
-		return this._userIgnored(path, stats);
+		return this._userIgnored(path$18, stats);
 	}
-	_isntIgnored(path, stat) {
-		return !this._isIgnored(path, stat);
+	_isntIgnored(path$19, stat) {
+		return !this._isIgnored(path$19, stat);
 	}
 	/**
 	* Provides a set of common helpers and properties relating to symlink handling.
 	* @param path file or directory pattern being watched
 	*/
-	_getWatchHelpers(path) {
-		return new WatchHelper(path, this.options.followSymlinks, this);
+	_getWatchHelpers(path$20) {
+		return new WatchHelper(path$20, this.options.followSymlinks, this);
 	}
 	/**
 	* Provides directory tracking objects
 	* @param directory path of the directory
 	*/
 	_getWatchedDir(directory) {
-		const dir = sysPath.resolve(directory);
+		const dir = path.resolve(directory);
 		if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
 		return this._watched.get(dir);
 	}
@@ -5695,50 +5701,50 @@ var FSWatcher = class extends EventEmitter {
 	* @param item      base path of item/directory
 	*/
 	_remove(directory, item, isDirectory) {
-		const path = sysPath.join(directory, item);
-		const fullPath = sysPath.resolve(path);
-		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
-		if (!this._throttle("remove", path, 100)) return;
+		const path$10 = path.join(directory, item);
+		const fullPath = path.resolve(path$10);
+		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path$10) || this._watched.has(fullPath);
+		if (!this._throttle("remove", path$10, 100)) return;
 		if (!isDirectory && this._watched.size === 1) this.add(directory, item, true);
-		this._getWatchedDir(path).getChildren().forEach((nested) => this._remove(path, nested));
+		this._getWatchedDir(path$10).getChildren().forEach((nested) => this._remove(path$10, nested));
 		const parent = this._getWatchedDir(directory);
 		const wasTracked = parent.has(item);
 		parent.remove(item);
 		if (this._symlinkPaths.has(fullPath)) this._symlinkPaths.delete(fullPath);
-		let relPath = path;
-		if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
+		let relPath = path$10;
+		if (this.options.cwd) relPath = path.relative(this.options.cwd, path$10);
 		if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
 			if (this._pendingWrites.get(relPath).cancelWait() === EVENTS.ADD) return;
 		}
-		this._watched.delete(path);
+		this._watched.delete(path$10);
 		this._watched.delete(fullPath);
 		const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-		if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
-		this._closePath(path);
+		if (wasTracked && !this._isIgnored(path$10)) this._emit(eventName, path$10);
+		this._closePath(path$10);
 	}
 	/**
 	* Closes all watchers for a path
 	*/
-	_closePath(path) {
-		this._closeFile(path);
-		const dir = sysPath.dirname(path);
-		this._getWatchedDir(dir).remove(sysPath.basename(path));
+	_closePath(path$11) {
+		this._closeFile(path$11);
+		const dir = path.dirname(path$11);
+		this._getWatchedDir(dir).remove(path.basename(path$11));
 	}
 	/**
 	* Closes only file-specific watchers
 	*/
-	_closeFile(path) {
-		const closers = this._closers.get(path);
+	_closeFile(path$21) {
+		const closers = this._closers.get(path$21);
 		if (!closers) return;
 		closers.forEach((closer) => closer());
-		this._closers.delete(path);
+		this._closers.delete(path$21);
 	}
-	_addPathCloser(path, closer) {
+	_addPathCloser(path$22, closer) {
 		if (!closer) return;
-		let list = this._closers.get(path);
+		let list = this._closers.get(path$22);
 		if (!list) {
 			list = [];
-			this._closers.set(path, list);
+			this._closers.set(path$22, list);
 		}
 		list.push(closer);
 	}
@@ -5773,7 +5779,7 @@ var FSWatcher = class extends EventEmitter {
 * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
 * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
 */
-function watch$1(paths, options = {}) {
+function watch(paths, options = {}) {
 	const watcher = new FSWatcher(options);
 	watcher.add(paths);
 	return watcher;
@@ -5814,7 +5820,7 @@ function normalizePath(p) {
 function setupWatcher(cwd, wss) {
 	const planningDir = normalizePath(`${cwd}/.planning`);
 	console.error(`[watcher] Watching ${planningDir}`);
-	const watcher = watch$1(planningDir, {
+	const watcher = watch(planningDir, {
 		persistent: true,
 		ignoreInitial: true,
 		awaitWriteFinish: {
@@ -5860,21 +5866,36 @@ function setupWatcher(cwd, wss) {
 //#region server.ts
 const dev = process.env.NODE_ENV !== "production";
 const projectCwd = process.env.MAXSIM_PROJECT_CWD || process.cwd();
-const app = next({ dev });
+const standaloneDir = node_path.join(__dirname, "packages", "dashboard");
+const isStandalone = !dev && node_fs.existsSync(node_path.join(standaloneDir, ".next", "required-server-files.json"));
+let app;
+if (isStandalone) {
+	const serverFiles = JSON.parse(node_fs.readFileSync(node_path.join(standaloneDir, ".next", "required-server-files.json"), "utf8"));
+	process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(serverFiles.config);
+	const NextServer = require("next/dist/server/next-server").default;
+	app = new NextServer({
+		hostname: "localhost",
+		port: 0,
+		dir: standaloneDir,
+		dev: false,
+		customServer: true,
+		conf: serverFiles.config
+	});
+} else app = (0, next.default)({ dev });
 const handle = app.getRequestHandler();
 async function main() {
 	await app.prepare();
-	const upgradeHandler = app.getUpgradeHandler();
+	const upgradeHandler = typeof app.getUpgradeHandler === "function" ? app.getUpgradeHandler() : void 0;
 	const wss = createWSS();
-	const server = createServer((req, res) => {
-		handle(req, res, parse(req.url || "/", true));
+	const server = (0, node_http.createServer)((req, res) => {
+		handle(req, res, (0, node_url.parse)(req.url || "/", true));
 	});
 	server.on("upgrade", (req, socket, head) => {
-		const { pathname } = parse(req.url || "/", true);
+		const { pathname } = (0, node_url.parse)(req.url || "/", true);
 		if (pathname === "/api/ws") wss.handleUpgrade(req, socket, head, (ws) => {
 			wss.emit("connection", ws, req);
 		});
-		else upgradeHandler(req, socket, head);
+		else if (upgradeHandler) upgradeHandler(req, socket, head);
 	});
 	let watcher;
 	try {
@@ -5909,5 +5930,4 @@ main().catch((err) => {
 	process.exit(1);
 });
 
-//#endregion
-export {  };
+//#endregion