virrun 2.31.1 → 2.32.1

package/dist/{createVirrun-rH3O-itW.js → createVirrun-F5Gqe026.js}

@@ -1,21 +1,21 @@
 import { createRequire } from "node:module";
-import { constants, tmpdir } from "node:os";
 import { execFileSync, spawn } from "node:child_process";
-import "vue";
-import "@vueuse/core";
-import { mkdtempSync } from "node:fs";
+import { appendFileSync, chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
+import { constants, homedir, tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { create } from "@platformatic/vfs";
+import { createHash } from "node:crypto";
 import process$1 from "node:process";
 import { runInThisContext } from "node:vm";
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-//#region src/models/source/SourceType.ts
-let SourceType = /* @__PURE__ */ function(SourceType) {
-	SourceType["Dir"] = "dir";
-	SourceType["Files"] = "files";
-	SourceType["Git"] = "git";
-	return SourceType;
-}({});
+//#region \0rolldown/runtime.js
+var __commonJSMin$1 = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region src/services/cli/parseCliCommand.ts
+const parseCliCommand = (argv) => {
+	const separatorIndex = argv.indexOf("--");
+	return separatorIndex === -1 ? [...argv] : argv.slice(separatorIndex + 1);
+};
 //#endregion
 //#region src/models/virrun/BackendType.ts
 let BackendType = /* @__PURE__ */ function(BackendType) {
@@ -26,71 +26,13 @@ let BackendType = /* @__PURE__ */ function(BackendType) {
 	return BackendType;
 }({});
 //#endregion
-//#region src/services/exec/toExitCode.ts
-const toExitCode = (code, signal) => code ?? (signal ? 128 + constants.signals[signal] : 0);
-//#endregion
-//#region src/services/exec/createNativeBackend.ts
-const createNativeBackend = () => ({
-	exec: (command, options) => new Promise((resolve, reject) => {
-		const [file, ...args] = Array.isArray(command) ? command : [command];
-		const child = spawn(file, args, {
-			cwd: options.cwd === "" ? void 0 : options.cwd,
-			shell: !Array.isArray(command),
-			stdio: options.stdio
-		});
-		let stdout = "";
-		let stderr = "";
-		child.stdout?.on("data", (chunk) => {
-			stdout += chunk.toString();
-		});
-		child.stderr?.on("data", (chunk) => {
-			stderr += chunk.toString();
-		});
-		child.on("error", reject);
-		child.on("close", (code, signal) => {
-			resolve({
-				exitCode: toExitCode(code, signal),
-				stderr,
-				stdout
-			});
-		});
-	}),
-	name: "native"
-});
-//#endregion
-//#region src/services/exec/buildBwrapArgs.ts
-const buildBwrapArgs = (command, cwd, { network = false, overlayDirs = [] } = {}) => {
-	const dir = cwd === "" ? process.cwd() : cwd;
-	const commandArgs = Array.isArray(command) ? [...command] : [
-		"/bin/sh",
-		"-c",
-		command
-	];
-	const overlays = [dir, ...overlayDirs].flatMap((overlayDir) => [
-		"--overlay-src",
-		overlayDir,
-		"--tmp-overlay",
-		overlayDir
-	]);
-	return [
-		"--unshare-all",
-		...network ? ["--share-net"] : [],
-		"--die-with-parent",
-		"--ro-bind",
-		"/",
-		"/",
-		"--dev",
-		"/dev",
-		"--proc",
-		"/proc",
-		"--tmpfs",
-		"/tmp",
-		...overlays,
-		"--chdir",
-		dir,
-		"--",
-		...commandArgs
-	];
+//#region src/services/configuration/matchesRoute.ts
+const matchesRoute = (command, route) => {
+	const commandTokens = typeof command === "string" ? command.split(/\s+/u).filter((token) => token !== "") : command;
+	return route.some((entry) => {
+		const entryTokens = entry.split(/\s+/u).filter((token) => token !== "");
+		return entryTokens.length > 0 && entryTokens.every((token, index) => commandTokens[index] === token);
+	});
 };
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
@@ -18679,20 +18621,232 @@ const exhaustiveGuard = (value) => {
 	throw new InvalidOperationError("Read", exhaustiveGuard.name, JSON.stringify(value));
 };
 //#endregion
-//#region src/services/exec/isOsBackendSupported.ts
+//#region src/services/exec/bwrap/buildBwrapArgs.ts
+const buildBwrapArgs = (command, cwd, { bindDirs = [], isNetworkEnabled = false } = {}, { lowerDirs = [], upperDir, workDir } = {}) => {
+	if (upperDir === void 0 !== (workDir === void 0)) throw new InvalidOperationError(Operation.Create, buildBwrapArgs.name, "a persistent overlay needs both upperDir and workDir");
+	const dir = cwd === "" ? process.cwd() : cwd;
+	const commandArgs = Array.isArray(command) ? [...command] : [
+		"/bin/sh",
+		"-c",
+		command
+	];
+	const topOverlay = upperDir !== void 0 && workDir !== void 0 ? [
+		"--overlay",
+		upperDir,
+		workDir,
+		dir
+	] : ["--tmp-overlay", dir];
+	return [
+		"--unshare-all",
+		...isNetworkEnabled ? ["--share-net"] : [],
+		"--die-with-parent",
+		"--ro-bind",
+		"/",
+		"/",
+		"--dev",
+		"/dev",
+		"--proc",
+		"/proc",
+		"--tmpfs",
+		"/tmp",
+		"--overlay-src",
+		dir,
+		...lowerDirs.flatMap((lowerDir) => ["--overlay-src", lowerDir]),
+		...topOverlay,
+		...bindDirs.flatMap((bindDir) => [
+			"--bind",
+			bindDir,
+			bindDir
+		]),
+		"--chdir",
+		dir,
+		"--",
+		...commandArgs
+	];
+};
+//#endregion
+//#region src/services/exec/util/constants.ts
+const GITIGNORE_FILENAME = ".gitignore";
+const VIRRUN_CACHE_DIRECTORY_NAME = ".virrun";
+const VIRRUN_GITIGNORE_ENTRY = `/${VIRRUN_CACHE_DIRECTORY_NAME}/`;
+const VIRRUN_STORE_DIRECTORY_NAME = "store";
+const VIRRUN_PNPM_STORE_DIRECTORY_NAME = "pnpm";
+const VIRRUN_COREPACK_STORE_DIRECTORY_NAME = "corepack";
+const VIRRUN_SNAPSHOTS_DIRECTORY_NAME = "snapshots";
+const VIRRUN_SNAPSHOT_UPPER_DIRECTORY_NAME = "upper";
+const VIRRUN_SNAPSHOT_WORK_DIRECTORY_NAME = "work";
+const PNPM_LOCKFILE_FILENAME = "pnpm-lock.yaml";
+const VIRRUN_CONFIGURATION_FILENAME = "virrun.config.json";
+const COREPACK_HOME_KEY = "COREPACK_HOME";
+const VIRRUN_CACHE_HOME_KEY = "VIRRUN_CACHE_HOME";
+const PNPM_CONFIG_PACKAGE_IMPORT_METHOD_KEY = "PNPM_CONFIG_PACKAGE_IMPORT_METHOD";
+const PNPM_CONFIG_PACKAGE_IMPORT_METHOD_VALUE = "copy";
+const PNPM_CONFIG_STORE_DIR_KEY = "PNPM_CONFIG_STORE_DIR";
+const VIRRUN_TEMP_DIR_PREFIX = "virrun-temp-";
+//#endregion
+//#region src/services/exec/os/isOsBackendSupported.ts
 let isSupported;
 const isOsBackendSupported = () => {
 	if (isSupported !== void 0) return isSupported;
-	if (process.platform !== "linux") {
-		isSupported = false;
-		return isSupported;
-	}
-	const dir = mkdtempSync(join(tmpdir(), "os-support-"));
-	isSupported = getResult(() => execFileSync("bwrap", buildBwrapArgs("true", dir), { stdio: "pipe" })).match(() => true, () => false);
+	else if (process.platform === "linux") {
+		const dir = mkdtempSync(join(tmpdir(), VIRRUN_TEMP_DIR_PREFIX));
+		isSupported = getResult(() => withFinalizer(() => execFileSync("bwrap", buildBwrapArgs("true", dir), { stdio: "pipe" }), () => {
+			rmSync(dir, {
+				force: true,
+				recursive: true
+			});
+		})).match(() => true, () => false);
+	} else if (process.platform === "win32") isSupported = getResult(() => execFileSync("wsl.exe", [
+		"--exec",
+		"mktemp",
+		"-d"
+	], { stdio: "pipe" })).map((stdout) => stdout.toString().trim()).andThen((wslDir) => getResult(() => withFinalizer(() => execFileSync("wsl.exe", [
+		"--exec",
+		"bwrap",
+		...buildBwrapArgs("true", wslDir)
+	], { stdio: "pipe" }), () => {
+		getResult(() => execFileSync("wsl.exe", [
+			"--exec",
+			"rm",
+			"-rf",
+			wslDir
+		], { stdio: "pipe" })).unwrapOr(void 0);
+	}))).match(() => true, () => false);
+	else isSupported = false;
 	return isSupported;
 };
 //#endregion
-//#region src/services/exec/parseBwrapExitCode.ts
+//#region src/services/configuration/resolveCommandBackend.ts
+const resolveCommandBackend = (command, configuration) => {
+	if (configuration === void 0 || !matchesRoute(command, configuration.route)) return "native";
+	if (configuration.backend === "os" && !isOsBackendSupported()) return configuration.fallback;
+	return configuration.backend;
+};
+//#endregion
+//#region src/services/configuration/parseVirrunConfiguration.ts
+const isBackendType = (value) => typeof value === "string" && Object.values(BackendType).includes(value);
+const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+const toBackendType = (value, field) => {
+	if (isBackendType(value)) return value;
+	throw new InvalidOperationError(Operation.Read, parseVirrunConfiguration.name, `\`${field}\` must be one of: ${Object.values(BackendType).join(", ")}`);
+};
+const parseVirrunConfiguration = (content) => {
+	const result = getResult(() => JSON.parse(content));
+	if (result.isErr()) throw new InvalidOperationError(Operation.Read, parseVirrunConfiguration.name, `not valid JSON: ${result.error.message}`);
+	const value = result.value;
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new InvalidOperationError(Operation.Read, parseVirrunConfiguration.name, "must be a JSON object");
+	const { backend = "auto", fallback = "native", route = [] } = value;
+	if (!isStringArray(route)) throw new InvalidOperationError(Operation.Read, parseVirrunConfiguration.name, "`route` must be an array of strings");
+	return {
+		backend: toBackendType(backend, "backend"),
+		fallback: toBackendType(fallback, "fallback"),
+		route
+	};
+};
+//#endregion
+//#region src/services/exec/util/resolveCwd.ts
+const resolveCwd = (cwd) => cwd === "" ? process.cwd() : cwd;
+//#endregion
+//#region ../../node_modules/.pnpm/empathic@2.0.1/node_modules/empathic/resolve.mjs
+/**
+* Resolve an absolute path from {@link root}, but only
+* if {@link input} isn't already absolute.
+*
+* @param input The path to resolve.
+* @param root The base path; default = process.cwd()
+* @returns The resolved absolute path.
+*/
+function absolute(input, root) {
+	return isAbsolute(input) ? input : resolve(root || ".", input);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/empathic@2.0.1/node_modules/empathic/walk.mjs
+/**
+* Get all parent directories of {@link base}.
+* Stops after {@link Options['last']} is processed.
+*
+* @returns An array of absolute paths of all parent directories.
+*/
+function up(base, options) {
+	let { last, cwd } = options || {};
+	let tmp = absolute(base, cwd);
+	let root = absolute(last || "/", cwd);
+	let prev, arr = [];
+	while (prev !== root) {
+		arr.push(tmp);
+		tmp = dirname(prev = tmp);
+		if (tmp === prev) break;
+	}
+	return arr;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/empathic@2.0.1/node_modules/empathic/find.mjs
+/**
+* Find a file by name, walking parent directories until found.
+*
+* > [NOTE]
+* > This function only returns a value for file matches.
+* > A directory match with the same name will be ignored.
+*
+* @param name The file name to find.
+* @returns The absolute path to the file, if found.
+*/
+function file(name, options) {
+	let dir, tmp;
+	for (dir of up(options && options.cwd || "", options)) try {
+		tmp = join(dir, name);
+		if (statSync(tmp).isFile()) return tmp;
+	} catch {}
+}
+//#endregion
+//#region src/services/configuration/resolveVirrunConfiguration.ts
+const resolveVirrunConfiguration = (cwd) => {
+	const configurationFile = file(VIRRUN_CONFIGURATION_FILENAME, { cwd: resolveCwd(cwd) });
+	if (configurationFile === void 0) return void 0;
+	return parseVirrunConfiguration(readFileSync(configurationFile, "utf8"));
+};
+//#endregion
+//#region src/models/source/SourceType.ts
+let SourceType = /* @__PURE__ */ function(SourceType) {
+	SourceType["Dir"] = "dir";
+	SourceType["Files"] = "files";
+	SourceType["Git"] = "git";
+	return SourceType;
+}({});
+//#endregion
+//#region src/services/exec/util/toExitCode.ts
+const toExitCode = (code, signal) => code ?? (signal ? 128 + constants.signals[signal] : 0);
+//#endregion
+//#region src/services/exec/native/createNativeBackend.ts
+const createNativeBackend = () => ({
+	exec: (command, options) => new Promise((resolve, reject) => {
+		const [file, ...args] = Array.isArray(command) ? command : [command];
+		const child = spawn(file, args, {
+			cwd: options.cwd === "" ? void 0 : options.cwd,
+			shell: !Array.isArray(command),
+			stdio: options.stdio
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", reject);
+		child.on("close", (code, signal) => {
+			resolve({
+				exitCode: toExitCode(code, signal),
+				stderr,
+				stdout
+			});
+		});
+	}),
+	name: "native"
+});
+//#endregion
+//#region src/services/exec/bwrap/parseBwrapExitCode.ts
 const parseBwrapExitCode = (status) => {
 	for (const line of status.split("\n")) {
 		const result = getResult(() => JSON.parse(line));
@@ -18700,53 +18854,255 @@ const parseBwrapExitCode = (status) => {
 	}
 };
 //#endregion
-//#region src/services/exec/createOsBackend.ts
-const createOsBackend = () => {
-	if (!isOsBackendSupported()) throw new InvalidOperationError(Operation.Create, createOsBackend.name, "requires Linux + bubblewrap");
+//#region src/services/exec/bwrap/constants.ts
+const WSL_BWRAP_STATUS_BEGIN = "\n__VIRRUN_BWRAP_STATUS_BEGIN__\n";
+const WSL_BWRAP_STATUS_END = "\n__VIRRUN_BWRAP_STATUS_END__\n";
+//#endregion
+//#region src/services/exec/bwrap/parseBwrapStderrStatus.ts
+const parseBwrapStderrStatus = (stderr) => {
+	const beginIndex = stderr.lastIndexOf(WSL_BWRAP_STATUS_BEGIN);
+	const endIndex = stderr.lastIndexOf(WSL_BWRAP_STATUS_END);
+	if (beginIndex === -1 || endIndex === -1 || endIndex < beginIndex) return {
+		status: "",
+		stderr
+	};
+	const statusStartIndex = beginIndex + 31;
 	return {
-		exec: (command, options) => new Promise((resolve, reject) => {
-			const stdio = [
-				options.stdio,
-				options.stdio,
-				options.stdio,
-				"pipe"
-			];
-			const child = spawn("bwrap", [
-				"--json-status-fd",
-				"3",
-				...buildBwrapArgs(command, options.cwd, options)
-			], {
-				shell: false,
-				stdio
-			});
-			let stdout = "";
-			let stderr = "";
-			let status = "";
-			child.stdout?.on("data", (chunk) => {
-				stdout += chunk.toString();
-			});
-			child.stderr?.on("data", (chunk) => {
-				stderr += chunk.toString();
-			});
-			child.stdio[3]?.on("data", (chunk) => {
-				status += chunk.toString();
-			});
-			child.on("error", reject);
-			child.on("close", () => {
-				const exitCode = parseBwrapExitCode(status);
-				if (exitCode === void 0) reject(new InvalidOperationError(Operation.Create, createOsBackend.name, "bubblewrap failed to set up the sandbox"));
-				else resolve({
-					exitCode,
-					stderr,
-					stdout
-				});
+		status: stderr.slice(statusStartIndex, endIndex),
+		stderr: `${stderr.slice(0, beginIndex)}${stderr.slice(endIndex + 29)}`
+	};
+};
+//#endregion
+//#region src/services/exec/bwrap/createBwrapBackend.ts
+const createBwrapBackend = (createBwrapArgs, createBwrapCommand, errorName) => ({
+	exec: (command, options) => new Promise((resolve, reject) => {
+		const bwrapCommand = createBwrapCommand(createBwrapArgs(command, options.cwd, options), options);
+		const [file, ...args] = bwrapCommand.command;
+		const stdio = bwrapCommand.statusSource === "fd" ? [
+			options.stdio,
+			options.stdio,
+			options.stdio,
+			"pipe"
+		] : [
+			options.stdio,
+			options.stdio,
+			"pipe"
+		];
+		const child = spawn(file, args, {
+			env: {
+				...process.env,
+				...options.env
+			},
+			shell: false,
+			stdio
+		});
+		let stdout = "";
+		let stderr = "";
+		let status = "";
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.stdio[3]?.on("data", (chunk) => {
+			status += chunk.toString();
+		});
+		child.on("error", reject);
+		child.on("close", () => {
+			const bwrapStderr = bwrapCommand.statusSource === "stderr" ? parseBwrapStderrStatus(stderr) : {
+				status,
+				stderr
+			};
+			const exitCode = parseBwrapExitCode(bwrapStderr.status);
+			if (exitCode === void 0) reject(new InvalidOperationError(Operation.Create, errorName, "bubblewrap failed to set up the sandbox"));
+			else resolve({
+				exitCode,
+				stderr: bwrapStderr.stderr,
+				stdout
 			});
-		}),
-		name: "os"
+		});
+	}),
+	name: "os"
+});
+//#endregion
+//#region src/services/exec/bwrap/createLinuxOsBackend.ts
+const createLinuxOsBackend = (errorName) => createBwrapBackend((command, cwd, options) => buildBwrapArgs(command, cwd, options, options.overlayLayers), (bwrapArgs) => ({
+	command: [
+		"bwrap",
+		"--json-status-fd",
+		"3",
+		...bwrapArgs
+	],
+	statusSource: "fd"
+}), errorName);
+//#endregion
+//#region src/services/exec/wsl/readWslPath.ts
+const wslPaths = /* @__PURE__ */ new Map();
+const readWslPath = (path) => {
+	const wslPath = wslPaths.get(path);
+	if (wslPath) return wslPath;
+	const newWslPath = execFileSync("wsl.exe", [
+		"--exec",
+		"wslpath",
+		"-a",
+		path
+	], {
+		encoding: "utf8",
+		stdio: "pipe"
+	}).trim();
+	wslPaths.set(path, newWslPath);
+	return newWslPath;
+};
+//#endregion
+//#region src/services/exec/wsl/createWslBwrapArgs.ts
+const readWslOverlayLayers = ({ lowerDirs, upperDir, workDir }) => ({
+	lowerDirs: lowerDirs?.map((lowerDir) => readWslPath(lowerDir)),
+	upperDir: upperDir === void 0 ? void 0 : readWslPath(upperDir),
+	workDir: workDir === void 0 ? void 0 : readWslPath(workDir)
+});
+const createWslBwrapArgs = (command, cwd, { bindDirs = [], isNetworkEnabled = false, overlayLayers } = {}) => {
+	return buildBwrapArgs(command, readWslPath(resolveCwd(cwd)), {
+		bindDirs: bindDirs.map((bindDir) => readWslPath(bindDir)),
+		isNetworkEnabled
+	}, overlayLayers === void 0 ? void 0 : readWslOverlayLayers(overlayLayers));
+};
+//#endregion
+//#region src/services/exec/wsl/createWslEnvArgs.ts
+const WSL_PATH_ENV_KEYS = /* @__PURE__ */ new Set([COREPACK_HOME_KEY, PNPM_CONFIG_STORE_DIR_KEY]);
+const createWslEnvArgs = ({ env = {} }) => Object.entries(env).map(([key, value]) => `${key}=${WSL_PATH_ENV_KEYS.has(key) ? readWslPath(value) : value}`);
+//#endregion
+//#region src/services/exec/wsl/createWslOsBackend.ts
+const createWslOsBackend = (errorName) => createBwrapBackend(createWslBwrapArgs, (bwrapArgs, options) => ({
+	command: [
+		"wsl.exe",
+		"--exec",
+		"env",
+		...createWslEnvArgs(options),
+		"sh",
+		"-c",
+		[
+			`status="$(mktemp)"`,
+			`bwrap --json-status-fd 3 "$@" 3>"$status"`,
+			`bwrapExitCode=$?`,
+			`printf '${WSL_BWRAP_STATUS_BEGIN.replaceAll("\n", String.raw`\n`)}' >&2`,
+			`cat "$status" >&2`,
+			`printf '${WSL_BWRAP_STATUS_END.replaceAll("\n", String.raw`\n`)}' >&2`,
+			`rm -f "$status"`,
+			`exit "$bwrapExitCode"`
+		].join("; "),
+		"virrun-bwrap",
+		...bwrapArgs
+	],
+	statusSource: "stderr"
+}), errorName);
+//#endregion
+//#region src/services/exec/os/createOsBackend.ts
+const createOsBackend = () => {
+	if (!isOsBackendSupported()) throw new InvalidOperationError(Operation.Create, createOsBackend.name, "requires Linux/WSL + bubblewrap");
+	if (process.platform === "linux") return createLinuxOsBackend(createOsBackend.name);
+	else if (process.platform === "win32") return createWslOsBackend(createOsBackend.name);
+	throw new InvalidOperationError(Operation.Create, createOsBackend.name, "requires Linux/WSL + bubblewrap");
+};
+//#endregion
+//#region src/services/exec/snapshot/removeSnapshotLocation.ts
+const makeTraversable = (dir) => {
+	chmodSync(dir, 448);
+	for (const entry of readdirSync(dir, { withFileTypes: true })) if (entry.isDirectory()) makeTraversable(join(dir, entry.name));
+};
+const removeSnapshotLocation = ({ dir }) => {
+	if (existsSync(dir)) makeTraversable(dir);
+	rmSync(dir, {
+		force: true,
+		recursive: true
+	});
+};
+//#endregion
+//#region src/services/exec/snapshot/computeLockfileHash.ts
+const computeLockfileHash = (cwd) => {
+	const dir = resolveCwd(cwd);
+	const lockfile = join(dir, PNPM_LOCKFILE_FILENAME);
+	if (!existsSync(lockfile)) throw new InvalidOperationError(Operation.Read, computeLockfileHash.name, `no ${PNPM_LOCKFILE_FILENAME} in ${dir}`);
+	return createHash("sha256").update(readFileSync(lockfile)).digest("hex");
+};
+//#endregion
+//#region src/services/exec/util/getGlobalCacheDirectory.ts
+const getGlobalCacheDirectory = () => process.env["VIRRUN_CACHE_HOME"] || join(homedir(), ".virrun");
+//#endregion
+//#region src/services/exec/snapshot/resolveSnapshotLocation.ts
+const resolveSnapshotLocation = (cwd) => {
+	const hash = computeLockfileHash(cwd);
+	const snapshotDir = join(getGlobalCacheDirectory(), VIRRUN_SNAPSHOTS_DIRECTORY_NAME, hash);
+	const upperDir = join(snapshotDir, VIRRUN_SNAPSHOT_UPPER_DIRECTORY_NAME);
+	return {
+		dir: snapshotDir,
+		exists: existsSync(upperDir),
+		hash,
+		upperDir,
+		workDir: join(snapshotDir, VIRRUN_SNAPSHOT_WORK_DIRECTORY_NAME)
+	};
+};
+//#endregion
+//#region src/services/exec/snapshot/createSnapshot.ts
+const createSnapshot = (backend, command, options) => {
+	const location = resolveSnapshotLocation(options.cwd);
+	const { upperDir, workDir } = location;
+	return getResultAsync(async () => {
+		mkdirSync(upperDir, { recursive: true });
+		mkdirSync(workDir, { recursive: true });
+		const { exitCode, stderr } = await backend.exec(command, {
+			...options,
+			overlayLayers: {
+				upperDir,
+				workDir
+			}
+		});
+		if (exitCode !== 0) throw new InvalidOperationError(Operation.Create, createSnapshot.name, `snapshot setup command exited with ${exitCode}: ${stderr}`);
+		return {
+			...location,
+			exists: true
+		};
+	}).match((value) => value, (error) => {
+		removeSnapshotLocation(location);
+		throw error;
+	});
+};
+//#endregion
+//#region src/services/exec/snapshot/forkSnapshot.ts
+const forkSnapshot = (backend, command, options) => {
+	const { exists, upperDir } = resolveSnapshotLocation(options.cwd);
+	if (!exists) throw new InvalidOperationError(Operation.Read, forkSnapshot.name, "no captured snapshot to fork; run createSnapshot first");
+	return backend.exec(command, {
+		...options,
+		overlayLayers: { lowerDirs: [upperDir] }
+	});
+};
+//#endregion
+//#region src/services/exec/util/getRepoCacheDirectory.ts
+const getRepoCacheDirectory = (cwd) => join(resolveCwd(cwd), VIRRUN_CACHE_DIRECTORY_NAME);
+//#endregion
+//#region src/services/exec/store/createSharedPackageStoreOptions.ts
+const ensureGitIgnoreEntry = (cwd) => {
+	const gitignore = join(cwd, GITIGNORE_FILENAME);
+	const gitignoreContent = existsSync(gitignore) ? readFileSync(gitignore, "utf8") : "";
+	if (gitignoreContent.split(/\r?\n/u).includes(VIRRUN_GITIGNORE_ENTRY)) return;
+	appendFileSync(gitignore, `${gitignoreContent.endsWith("\n") || gitignoreContent === "" ? "" : "\n"}${VIRRUN_GITIGNORE_ENTRY}\n`);
+};
+const createSharedPackageStoreOptions = (cwd) => {
+	const dir = resolveCwd(cwd);
+	const storeDir = join(getRepoCacheDirectory(dir), VIRRUN_STORE_DIRECTORY_NAME, VIRRUN_PNPM_STORE_DIRECTORY_NAME);
+	mkdirSync(storeDir, { recursive: true });
+	ensureGitIgnoreEntry(dir);
+	return {
+		bindDirs: [storeDir],
+		env: {
+			[PNPM_CONFIG_PACKAGE_IMPORT_METHOD_KEY]: PNPM_CONFIG_PACKAGE_IMPORT_METHOD_VALUE,
+			[PNPM_CONFIG_STORE_DIR_KEY]: storeDir
+		}
 	};
 };
 //#endregion
-//#region src/services/exec/tokenizeShellCommand.ts
+//#region src/services/exec/vfs/tokenizeShellCommand.ts
 const SHELL_OPERATORS = /* @__PURE__ */ new Set([
 	"$",
 	"&",
@@ -18791,7 +19147,7 @@ const tokenizeShellCommand = (input) => {
 	return tokens;
 };
 //#endregion
-//#region src/services/exec/parseNodeInvocation.ts
+//#region src/services/exec/vfs/parseNodeInvocation.ts
 const parseNodeInvocation = (command) => {
 	const tokens = typeof command === "string" ? tokenizeShellCommand(command) : [...command];
 	if (!tokens) return void 0;
@@ -18817,35 +19173,4003 @@ var ExitSignalError = class extends Error {
 	}
 };
 //#endregion
-//#region src/services/vfs/createPlatformaticFsProvider.ts
-const createPlatformaticFsProvider = ({ overlay = false } = {}) => {
-	const vfs = create({
-		moduleHooks: true,
-		overlay
-	});
-	return {
-		dispose: () => {
-			if (vfs.mounted) vfs.unmount();
-		},
-		exists: (path) => vfs.existsSync(path),
-		mkdir: (path) => {
-			vfs.mkdirSync(path, { recursive: true });
-		},
-		mount: (prefix) => {
-			vfs.mount(prefix);
-		},
-		name: "platformatic",
-		readFile: (path) => vfs.readFileSync(path, "utf8"),
-		unmount: () => {
-			vfs.unmount();
-		},
-		writeFile: (path, data) => {
-			vfs.writeFileSync(path, data);
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/errors.js
+var require_errors = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	/**
+	* Creates a filesystem error with the proper structure.
+	* Mirrors the UVException format from Node.js internals.
+	* @param {string} code The error code (e.g., 'ENOENT')
+	* @param {string} syscall The system call name
+	* @param {string} [path] The path that caused the error
+	* @param {string} [message] The error message
+	* @returns {Error}
+	*/
+	function createFsError(code, syscall, path, message) {
+		const msg = message || `${code}: ${getErrorDescription(code)}, ${syscall}${path ? ` '${path}'` : ""}`;
+		const err = new Error(msg);
+		err.code = code;
+		err.syscall = syscall;
+		if (path !== void 0) err.path = path;
+		Error.captureStackTrace(err, createFsError);
+		return err;
+	}
+	function getErrorDescription(code) {
+		switch (code) {
+			case "ENOENT": return "no such file or directory";
+			case "ENOTDIR": return "not a directory";
+			case "ENOTEMPTY": return "directory not empty";
+			case "EISDIR": return "illegal operation on a directory";
+			case "EBADF": return "bad file descriptor";
+			case "EEXIST": return "file already exists";
+			case "EROFS": return "read-only file system";
+			case "EINVAL": return "invalid argument";
+			case "ELOOP": return "too many levels of symbolic links";
+			default: return "unknown error";
+		}
+	}
+	function createENOENT(syscall, path) {
+		const err = createFsError("ENOENT", syscall, path);
+		Error.captureStackTrace(err, createENOENT);
+		return err;
+	}
+	function createENOTDIR(syscall, path) {
+		const err = createFsError("ENOTDIR", syscall, path);
+		Error.captureStackTrace(err, createENOTDIR);
+		return err;
+	}
+	function createENOTEMPTY(syscall, path) {
+		const err = createFsError("ENOTEMPTY", syscall, path);
+		Error.captureStackTrace(err, createENOTEMPTY);
+		return err;
+	}
+	function createEISDIR(syscall, path) {
+		const err = createFsError("EISDIR", syscall, path);
+		Error.captureStackTrace(err, createEISDIR);
+		return err;
+	}
+	function createEBADF(syscall) {
+		const err = createFsError("EBADF", syscall);
+		Error.captureStackTrace(err, createEBADF);
+		return err;
+	}
+	function createEEXIST(syscall, path) {
+		const err = createFsError("EEXIST", syscall, path);
+		Error.captureStackTrace(err, createEEXIST);
+		return err;
+	}
+	function createEROFS(syscall, path) {
+		const err = createFsError("EROFS", syscall, path);
+		Error.captureStackTrace(err, createEROFS);
+		return err;
+	}
+	function createEINVAL(syscall, path) {
+		const err = createFsError("EINVAL", syscall, path);
+		Error.captureStackTrace(err, createEINVAL);
+		return err;
+	}
+	function createELOOP(syscall, path) {
+		const err = createFsError("ELOOP", syscall, path);
+		Error.captureStackTrace(err, createELOOP);
+		return err;
+	}
+	var ERR_METHOD_NOT_IMPLEMENTED = class extends Error {
+		constructor(method) {
+			super(`The ${method} method is not implemented`);
+			this.code = "ERR_METHOD_NOT_IMPLEMENTED";
+		}
+	};
+	var ERR_INVALID_STATE = class extends Error {
+		constructor(message) {
+			super(`Invalid state: ${message}`);
+			this.code = "ERR_INVALID_STATE";
+		}
+	};
+	var ERR_INVALID_ARG_VALUE = class extends TypeError {
+		constructor(name, value, reason) {
+			super(`The argument '${name}' ${reason}. Received ${typeof value === "string" ? `'${value}'` : String(value)}`);
+			this.code = "ERR_INVALID_ARG_VALUE";
+		}
+	};
+	module.exports = {
+		createENOENT,
+		createENOTDIR,
+		createENOTEMPTY,
+		createEISDIR,
+		createEBADF,
+		createEEXIST,
+		createEROFS,
+		createEINVAL,
+		createELOOP,
+		ERR_METHOD_NOT_IMPLEMENTED,
+		ERR_INVALID_STATE,
+		ERR_INVALID_ARG_VALUE
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/provider.js
+var require_provider = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const { ERR_METHOD_NOT_IMPLEMENTED, createEROFS } = require_errors();
+	var VirtualProvider = class {
+		get readonly() {
+			return false;
+		}
+		get supportsSymlinks() {
+			return false;
+		}
+		get supportsWatch() {
+			return false;
+		}
+		async open(path, flags, mode) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("open");
+		}
+		openSync(path, flags, mode) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("openSync");
+		}
+		async stat(path, options) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("stat");
+		}
+		statSync(path, options) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("statSync");
+		}
+		async lstat(path, options) {
+			return this.stat(path, options);
+		}
+		lstatSync(path, options) {
+			return this.statSync(path, options);
+		}
+		async readdir(path, options) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("readdir");
+		}
+		readdirSync(path, options) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("readdirSync");
+		}
+		async mkdir(path, options) {
+			if (this.readonly) throw createEROFS("mkdir", path);
+			throw new ERR_METHOD_NOT_IMPLEMENTED("mkdir");
+		}
+		mkdirSync(path, options) {
+			if (this.readonly) throw createEROFS("mkdir", path);
+			throw new ERR_METHOD_NOT_IMPLEMENTED("mkdirSync");
+		}
+		async rmdir(path) {
+			if (this.readonly) throw createEROFS("rmdir", path);
+			throw new ERR_METHOD_NOT_IMPLEMENTED("rmdir");
+		}
+		rmdirSync(path) {
+			if (this.readonly) throw createEROFS("rmdir", path);
+			throw new ERR_METHOD_NOT_IMPLEMENTED("rmdirSync");
+		}
+		async unlink(path) {
+			if (this.readonly) throw createEROFS("unlink", path);
+			throw new ERR_METHOD_NOT_IMPLEMENTED("unlink");
+		}
+		unlinkSync(path) {
+			if (this.readonly) throw createEROFS("unlink", path);
+			throw new ERR_METHOD_NOT_IMPLEMENTED("unlinkSync");
+		}
+		async rename(oldPath, newPath) {
+			if (this.readonly) throw createEROFS("rename", oldPath);
+			throw new ERR_METHOD_NOT_IMPLEMENTED("rename");
+		}
+		renameSync(oldPath, newPath) {
+			if (this.readonly) throw createEROFS("rename", oldPath);
+			throw new ERR_METHOD_NOT_IMPLEMENTED("renameSync");
+		}
+		async readFile(path, options) {
+			const handle = await this.open(path, "r");
+			try {
+				return await handle.readFile(options);
+			} finally {
+				await handle.close();
+			}
+		}
+		readFileSync(path, options) {
+			const handle = this.openSync(path, "r");
+			try {
+				return handle.readFileSync(options);
+			} finally {
+				handle.closeSync();
+			}
+		}
+		async writeFile(path, data, options) {
+			if (this.readonly) throw createEROFS("open", path);
+			const handle = await this.open(path, "w", options?.mode);
+			try {
+				await handle.writeFile(data, options);
+			} finally {
+				await handle.close();
+			}
+		}
+		writeFileSync(path, data, options) {
+			if (this.readonly) throw createEROFS("open", path);
+			const handle = this.openSync(path, "w", options?.mode);
+			try {
+				handle.writeFileSync(data, options);
+			} finally {
+				handle.closeSync();
+			}
+		}
+		async appendFile(path, data, options) {
+			if (this.readonly) throw createEROFS("open", path);
+			const handle = await this.open(path, "a", options?.mode);
+			try {
+				await handle.writeFile(data, options);
+			} finally {
+				await handle.close();
+			}
+		}
+		appendFileSync(path, data, options) {
+			if (this.readonly) throw createEROFS("open", path);
+			const handle = this.openSync(path, "a", options?.mode);
+			try {
+				handle.writeFileSync(data, options);
+			} finally {
+				handle.closeSync();
+			}
+		}
+		async exists(path) {
+			try {
+				await this.stat(path);
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		existsSync(path) {
+			try {
+				this.statSync(path);
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		async copyFile(src, dest, mode) {
+			if (this.readonly) throw createEROFS("copyfile", dest);
+			const content = await this.readFile(src);
+			await this.writeFile(dest, content);
+		}
+		copyFileSync(src, dest, mode) {
+			if (this.readonly) throw createEROFS("copyfile", dest);
+			const content = this.readFileSync(src);
+			this.writeFileSync(dest, content);
+		}
+		internalModuleStat(path) {
+			try {
+				if (this.statSync(path).isDirectory()) return 1;
+				return 0;
+			} catch {
+				return -2;
+			}
+		}
+		async realpath(path, options) {
+			await this.stat(path);
+			return path;
+		}
+		realpathSync(path, options) {
+			this.statSync(path);
+			return path;
+		}
+		async access(path, mode) {
+			await this.stat(path);
+		}
+		accessSync(path, mode) {
+			this.statSync(path);
+		}
+		async readlink(path, options) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("readlink");
+		}
+		readlinkSync(path, options) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("readlinkSync");
+		}
+		async symlink(target, path, type) {
+			if (this.readonly) throw createEROFS("symlink", path);
+			throw new ERR_METHOD_NOT_IMPLEMENTED("symlink");
+		}
+		symlinkSync(target, path, type) {
+			if (this.readonly) throw createEROFS("symlink", path);
+			throw new ERR_METHOD_NOT_IMPLEMENTED("symlinkSync");
+		}
+		watch(path, options) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("watch");
+		}
+		watchAsync(path, options) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("watchAsync");
+		}
+		watchFile(path, options) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("watchFile");
+		}
+		unwatchFile(path, listener) {
+			throw new ERR_METHOD_NOT_IMPLEMENTED("unwatchFile");
+		}
+	};
+	module.exports = { VirtualProvider };
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/file_handle.js
+var require_file_handle = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const { Buffer: Buffer$3 } = __require("node:buffer");
+	const { createEBADF, ERR_METHOD_NOT_IMPLEMENTED, ERR_INVALID_STATE } = require_errors();
+	const kPath = Symbol("kPath");
+	const kFlags = Symbol("kFlags");
+	const kMode = Symbol("kMode");
+	const kPosition = Symbol("kPosition");
+	const kClosed = Symbol("kClosed");
+	var VirtualFileHandle = class {
+		constructor(path, flags, mode) {
+			this[kPath] = path;
+			this[kFlags] = flags;
+			this[kMode] = mode ?? 420;
+			this[kPosition] = 0;
+			this[kClosed] = false;
+		}
+		get path() {
+			return this[kPath];
+		}
+		get flags() {
+			return this[kFlags];
+		}
+		get mode() {
+			return this[kMode];
+		}
+		get position() {
+			return this[kPosition];
+		}
+		set position(pos) {
+			this[kPosition] = pos;
+		}
+		get closed() {
+			return this[kClosed];
+		}
+		#checkClosed() {
+			if (this[kClosed]) throw createEBADF("read");
+		}
+		async read(buffer, offset, length, position) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("read");
+		}
+		readSync(buffer, offset, length, position) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("readSync");
+		}
+		async write(buffer, offset, length, position) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("write");
+		}
+		writeSync(buffer, offset, length, position) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("writeSync");
+		}
+		async readFile(options) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("readFile");
+		}
+		readFileSync(options) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("readFileSync");
+		}
+		async writeFile(data, options) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("writeFile");
+		}
+		writeFileSync(data, options) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("writeFileSync");
+		}
+		async stat(options) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("stat");
+		}
+		statSync(options) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("statSync");
+		}
+		async truncate(len) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("truncate");
+		}
+		truncateSync(len) {
+			this.#checkClosed();
+			throw new ERR_METHOD_NOT_IMPLEMENTED("truncateSync");
+		}
+		async close() {
+			this[kClosed] = true;
+		}
+		closeSync() {
+			this[kClosed] = true;
+		}
+	};
+	var MemoryFileHandle = class extends VirtualFileHandle {
+		#content;
+		#entry;
+		#getStats;
+		#checkClosed() {
+			if (this.closed) throw createEBADF("read");
+		}
+		constructor(path, flags, mode, content, entry, getStats) {
+			super(path, flags, mode);
+			this.#content = content;
+			this.#entry = entry;
+			this.#getStats = getStats;
+			if (flags === "w" || flags === "w+") {
+				this.#content = Buffer$3.alloc(0);
+				if (entry) entry.content = this.#content;
+			} else if (flags === "a" || flags === "a+") this.position = this.#content.length;
+		}
+		get content() {
+			if (this.#entry?.isDynamic && this.#entry.isDynamic()) return this.#entry.getContentSync();
+			return this.#content;
+		}
+		async getContentAsync() {
+			if (this.#entry?.getContentAsync) return this.#entry.getContentAsync();
+			return this.#content;
+		}
+		readSync(buffer, offset, length, position) {
+			this.#checkClosed();
+			const content = this.content;
+			const readPos = position !== null && position !== void 0 ? position : this.position;
+			const available = content.length - readPos;
+			if (available <= 0) return 0;
+			const bytesToRead = Math.min(length, available);
+			content.copy(buffer, offset, readPos, readPos + bytesToRead);
+			if (position === null || position === void 0) this.position = readPos + bytesToRead;
+			return bytesToRead;
+		}
+		async read(buffer, offset, length, position) {
+			return {
+				bytesRead: this.readSync(buffer, offset, length, position),
+				buffer
+			};
+		}
+		writeSync(buffer, offset, length, position) {
+			this.#checkClosed();
+			const writePos = position !== null && position !== void 0 ? position : this.position;
+			const data = buffer.subarray(offset, offset + length);
+			if (writePos + length > this.#content.length) {
+				const newContent = Buffer$3.alloc(writePos + length);
+				this.#content.copy(newContent, 0, 0, this.#content.length);
+				this.#content = newContent;
+			}
+			data.copy(this.#content, writePos);
+			if (this.#entry) {
+				this.#entry.content = this.#content;
+				this.#entry.mtime = Date.now();
+			}
+			if (position === null || position === void 0) this.position = writePos + length;
+			return length;
+		}
+		async write(buffer, offset, length, position) {
+			return {
+				bytesWritten: this.writeSync(buffer, offset, length, position),
+				buffer
+			};
+		}
+		readFileSync(options) {
+			this.#checkClosed();
+			const content = this.content;
+			const encoding = typeof options === "string" ? options : options?.encoding;
+			if (encoding) return content.toString(encoding);
+			return Buffer$3.from(content);
+		}
+		async readFile(options) {
+			this.#checkClosed();
+			const content = await this.getContentAsync();
+			const encoding = typeof options === "string" ? options : options?.encoding;
+			if (encoding) return content.toString(encoding);
+			return Buffer$3.from(content);
+		}
+		writeFileSync(data, options) {
+			this.#checkClosed();
+			const buffer = typeof data === "string" ? Buffer$3.from(data, options?.encoding) : data;
+			if (this.flags === "a" || this.flags === "a+") {
+				const newContent = Buffer$3.alloc(this.#content.length + buffer.length);
+				this.#content.copy(newContent, 0);
+				buffer.copy(newContent, this.#content.length);
+				this.#content = newContent;
+			} else this.#content = Buffer$3.from(buffer);
+			if (this.#entry) {
+				this.#entry.content = this.#content;
+				this.#entry.mtime = Date.now();
+			}
+			this.position = this.#content.length;
+		}
+		async writeFile(data, options) {
+			this.writeFileSync(data, options);
+		}
+		statSync(options) {
+			this.#checkClosed();
+			if (this.#getStats) return this.#getStats(this.#content.length);
+			throw new ERR_INVALID_STATE("stats not available");
+		}
+		async stat(options) {
+			return this.statSync(options);
+		}
+		truncateSync(len = 0) {
+			this.#checkClosed();
+			if (len < this.#content.length) this.#content = this.#content.subarray(0, len);
+			else if (len > this.#content.length) {
+				const newContent = Buffer$3.alloc(len);
+				this.#content.copy(newContent, 0, 0, this.#content.length);
+				this.#content = newContent;
+			}
+			if (this.#entry) {
+				this.#entry.content = this.#content;
+				this.#entry.mtime = Date.now();
+			}
+		}
+		async truncate(len) {
+			this.truncateSync(len);
+		}
+	};
+	module.exports = {
+		VirtualFileHandle,
+		MemoryFileHandle
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/stats.js
+var require_stats = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const S_IFMT = 61440;
+	const S_IFREG = 32768;
+	const S_IFDIR = 16384;
+	const S_IFLNK = 40960;
+	const kDefaultBlockSize = 4096;
+	var VirtualStats = class {
+		constructor(props) {
+			this.dev = props.dev ?? 0;
+			this.mode = props.mode;
+			this.nlink = props.nlink ?? 1;
+			this.uid = props.uid ?? process.getuid?.() ?? 0;
+			this.gid = props.gid ?? process.getgid?.() ?? 0;
+			this.rdev = props.rdev ?? 0;
+			this.blksize = props.blksize ?? kDefaultBlockSize;
+			this.ino = props.ino ?? 0;
+			this.size = props.size;
+			this.blocks = props.blocks ?? Math.ceil(props.size / 512);
+			this.atimeMs = props.atimeMs;
+			this.mtimeMs = props.mtimeMs;
+			this.ctimeMs = props.ctimeMs;
+			this.birthtimeMs = props.birthtimeMs;
+			this.atime = new Date(this.atimeMs);
+			this.mtime = new Date(this.mtimeMs);
+			this.ctime = new Date(this.ctimeMs);
+			this.birthtime = new Date(this.birthtimeMs);
+		}
+		isFile() {
+			return (this.mode & S_IFMT) === S_IFREG;
+		}
+		isDirectory() {
+			return (this.mode & S_IFMT) === S_IFDIR;
+		}
+		isSymbolicLink() {
+			return (this.mode & S_IFMT) === S_IFLNK;
+		}
+		isBlockDevice() {
+			return false;
+		}
+		isCharacterDevice() {
+			return false;
+		}
+		isFIFO() {
+			return false;
+		}
+		isSocket() {
+			return false;
+		}
+	};
+	function createFileStats(size, options = {}) {
+		const now = Date.now();
+		return new VirtualStats({
+			mode: (options.mode ?? 420) | S_IFREG,
+			size,
+			atimeMs: options.atimeMs ?? now,
+			mtimeMs: options.mtimeMs ?? now,
+			ctimeMs: options.ctimeMs ?? now,
+			birthtimeMs: options.birthtimeMs ?? now
+		});
+	}
+	function createDirectoryStats(options = {}) {
+		const now = Date.now();
+		return new VirtualStats({
+			mode: (options.mode ?? 493) | S_IFDIR,
+			size: kDefaultBlockSize,
+			blocks: 8,
+			atimeMs: options.atimeMs ?? now,
+			mtimeMs: options.mtimeMs ?? now,
+			ctimeMs: options.ctimeMs ?? now,
+			birthtimeMs: options.birthtimeMs ?? now
+		});
+	}
+	function createSymlinkStats(size, options = {}) {
+		const now = Date.now();
+		return new VirtualStats({
+			mode: (options.mode ?? 511) | S_IFLNK,
+			size,
+			atimeMs: options.atimeMs ?? now,
+			mtimeMs: options.mtimeMs ?? now,
+			ctimeMs: options.ctimeMs ?? now,
+			birthtimeMs: options.birthtimeMs ?? now
+		});
+	}
+	module.exports = {
+		VirtualStats,
+		createFileStats,
+		createDirectoryStats,
+		createSymlinkStats,
+		S_IFMT,
+		S_IFREG,
+		S_IFDIR,
+		S_IFLNK
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/watcher.js
+var require_watcher = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const { EventEmitter } = __require("node:events");
+	const { basename, join: join$1 } = __require("node:path");
+	var VFSWatcher = class extends EventEmitter {
+		#vfs;
+		#path;
+		#interval;
+		#timer = null;
+		#lastStats;
+		#closed = false;
+		#persistent;
+		#recursive;
+		#trackedFiles;
+		#signal;
+		#abortHandler = null;
+		constructor(provider, path, options = {}) {
+			super();
+			this.#vfs = provider;
+			this.#path = path;
+			this.#interval = options.interval ?? 100;
+			this.#persistent = options.persistent !== false;
+			this.#recursive = options.recursive === true;
+			this.#trackedFiles = /* @__PURE__ */ new Map();
+			this.#signal = options.signal;
+			if (this.#signal) {
+				if (this.#signal.aborted) {
+					this.close();
+					return;
+				}
+				this.#abortHandler = () => this.close();
+				this.#signal.addEventListener("abort", this.#abortHandler, { once: true });
+			}
+			this.#lastStats = this.#getStats();
+			if (this.#recursive && this.#lastStats?.isDirectory()) this.#buildFileList(this.#path, "");
+			this.#startPolling();
+		}
+		#getStats() {
+			try {
+				return this.#vfs.statSync(this.#path);
+			} catch {
+				return null;
+			}
+		}
+		#startPolling() {
+			if (this.#closed) return;
+			this.#timer = setInterval(() => this.#poll(), this.#interval);
+			if (!this.#persistent && this.#timer.unref) this.#timer.unref();
+		}
+		#poll() {
+			if (this.#closed) return;
+			if (this.#recursive && this.#trackedFiles.size > 0) {
+				for (const [filePath, info] of this.#trackedFiles) {
+					const newStats = this.#getStatsFor(filePath);
+					if (this.#statsChanged(info.stats, newStats)) {
+						const eventType = this.#determineEventType(info.stats, newStats);
+						this.emit("change", eventType, info.relativePath);
+						info.stats = newStats;
+					}
+				}
+				return;
+			}
+			const newStats = this.#getStats();
+			if (this.#statsChanged(this.#lastStats, newStats)) {
+				const eventType = this.#determineEventType(this.#lastStats, newStats);
+				const filename = basename(this.#path);
+				this.emit("change", eventType, filename);
+			}
+			this.#lastStats = newStats;
+		}
+		#getStatsFor(filePath) {
+			try {
+				return this.#vfs.statSync(filePath);
+			} catch {
+				return null;
+			}
+		}
+		#buildFileList(dirPath, relativePath) {
+			try {
+				const entries = this.#vfs.readdirSync(dirPath, { withFileTypes: true });
+				for (const entry of entries) {
+					const fullPath = join$1(dirPath, entry.name);
+					const relPath = relativePath ? join$1(relativePath, entry.name) : entry.name;
+					if (entry.isDirectory()) this.#buildFileList(fullPath, relPath);
+					else {
+						const stats = this.#getStatsFor(fullPath);
+						this.#trackedFiles.set(fullPath, {
+							stats,
+							relativePath: relPath
+						});
+					}
+				}
+			} catch {}
+		}
+		#statsChanged(oldStats, newStats) {
+			if (oldStats === null !== (newStats === null)) return true;
+			if (oldStats === null && newStats === null) return false;
+			if (oldStats.mtimeMs !== newStats.mtimeMs) return true;
+			if (oldStats.size !== newStats.size) return true;
+			return false;
+		}
+		#determineEventType(oldStats, newStats) {
+			if (oldStats === null !== (newStats === null)) return "rename";
+			return "change";
+		}
+		close() {
+			if (this.#closed) return;
+			this.#closed = true;
+			if (this.#timer) {
+				clearInterval(this.#timer);
+				this.#timer = null;
+			}
+			this.#trackedFiles.clear();
+			if (this.#signal && this.#abortHandler) this.#signal.removeEventListener("abort", this.#abortHandler);
+			this.emit("close");
+		}
+		unref() {
+			this.#timer?.unref?.();
+			return this;
+		}
+		ref() {
+			this.#timer?.ref?.();
+			return this;
+		}
+	};
+	var VFSStatWatcher = class extends EventEmitter {
+		#vfs;
+		#path;
+		#interval;
+		#persistent;
+		#closed = false;
+		#timer = null;
+		#lastStats;
+		#listeners;
+		constructor(provider, path, options = {}) {
+			super();
+			this.#vfs = provider;
+			this.#path = path;
+			this.#interval = options.interval ?? 5007;
+			this.#persistent = options.persistent !== false;
+			this.#listeners = /* @__PURE__ */ new Set();
+			this.#lastStats = this.#getStats();
+			this.#startPolling();
+		}
+		#getStats() {
+			try {
+				return this.#vfs.statSync(this.#path);
+			} catch {
+				const { createFileStats } = require_stats();
+				return createFileStats(0, {
+					mode: 0,
+					mtimeMs: 0,
+					ctimeMs: 0,
+					birthtimeMs: 0
+				});
+			}
+		}
+		#startPolling() {
+			if (this.#closed) return;
+			this.#timer = setInterval(() => this.#poll(), this.#interval);
+			if (!this.#persistent && this.#timer.unref) this.#timer.unref();
+		}
+		#poll() {
+			if (this.#closed) return;
+			const newStats = this.#getStats();
+			if (this.#statsChanged(this.#lastStats, newStats)) {
+				const prevStats = this.#lastStats;
+				this.#lastStats = newStats;
+				this.emit("change", newStats, prevStats);
+			}
+		}
+		#statsChanged(oldStats, newStats) {
+			if (oldStats.mtimeMs !== newStats.mtimeMs) return true;
+			if (oldStats.ctimeMs !== newStats.ctimeMs) return true;
+			if (oldStats.size !== newStats.size) return true;
+			return false;
+		}
+		addListener(listener) {
+			this.#listeners.add(listener);
+			this.on("change", listener);
+		}
+		removeListener(listener) {
+			const had = this.#listeners.has(listener);
+			this.#listeners.delete(listener);
+			super.removeListener("change", listener);
+			return had;
+		}
+		hasNoListeners() {
+			return this.#listeners.size === 0;
+		}
+		stop() {
+			if (this.#closed) return;
+			this.#closed = true;
+			if (this.#timer) {
+				clearInterval(this.#timer);
+				this.#timer = null;
+			}
+			this.emit("stop");
+		}
+		unref() {
+			this.#timer?.unref?.();
+			return this;
+		}
+		ref() {
+			this.#timer?.ref?.();
+			return this;
+		}
+	};
+	var VFSWatchAsyncIterable = class {
+		#watcher;
+		#closed = false;
+		#pendingEvents = [];
+		#pendingResolvers = [];
+		constructor(provider, path, options = {}) {
+			this.#watcher = new VFSWatcher(provider, path, options);
+			this.#watcher.on("change", (eventType, filename) => {
+				const event = {
+					eventType,
+					filename
+				};
+				if (this.#pendingResolvers.length > 0) this.#pendingResolvers.shift()({
+					value: event,
+					done: false
+				});
+				else this.#pendingEvents.push(event);
+			});
+			this.#watcher.on("close", () => {
+				this.#closed = true;
+				while (this.#pendingResolvers.length > 0) this.#pendingResolvers.shift()({
+					value: void 0,
+					done: true
+				});
+			});
+		}
+		[Symbol.asyncIterator]() {
+			return this;
+		}
+		next() {
+			if (this.#closed) return Promise.resolve({
+				value: void 0,
+				done: true
+			});
+			if (this.#pendingEvents.length > 0) {
+				const event = this.#pendingEvents.shift();
+				return Promise.resolve({
+					value: event,
+					done: false
+				});
+			}
+			return new Promise((resolve) => {
+				this.#pendingResolvers.push(resolve);
+			});
+		}
+		return() {
+			this.#watcher.close();
+			return Promise.resolve({
+				value: void 0,
+				done: true
+			});
+		}
+		throw(error) {
+			this.#watcher.close();
+			return Promise.resolve({
+				value: void 0,
+				done: true
+			});
+		}
+	};
+	module.exports = {
+		VFSWatcher,
+		VFSStatWatcher,
+		VFSWatchAsyncIterable
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/providers/memory.js
+var require_memory = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const { Buffer: Buffer$2 } = __require("node:buffer");
+	const { posix: pathPosix$2 } = __require("node:path");
+	const { VirtualProvider } = require_provider();
+	const { MemoryFileHandle } = require_file_handle();
+	const { VFSWatcher, VFSStatWatcher, VFSWatchAsyncIterable } = require_watcher();
+	const { ERR_INVALID_STATE } = require_errors();
+	const { createENOENT, createENOTDIR, createENOTEMPTY, createEISDIR, createEEXIST, createEINVAL, createELOOP, createEROFS } = require_errors();
+	const { createFileStats, createDirectoryStats, createSymlinkStats } = require_stats();
+	const UV_DIRENT_FILE = 1;
+	const UV_DIRENT_DIR = 2;
+	const UV_DIRENT_LINK = 3;
+	var VirtualDirent = class {
+		#name;
+		#type;
+		#parentPath;
+		constructor(name, type, parentPath) {
+			this.#name = name;
+			this.#type = type;
+			this.#parentPath = parentPath;
+		}
+		get name() {
+			return this.#name;
+		}
+		get parentPath() {
+			return this.#parentPath;
+		}
+		get path() {
+			return this.#parentPath;
+		}
+		isFile() {
+			return this.#type === UV_DIRENT_FILE;
+		}
+		isDirectory() {
+			return this.#type === UV_DIRENT_DIR;
+		}
+		isSymbolicLink() {
+			return this.#type === UV_DIRENT_LINK;
+		}
+		isBlockDevice() {
+			return false;
+		}
+		isCharacterDevice() {
+			return false;
+		}
+		isFIFO() {
+			return false;
+		}
+		isSocket() {
+			return false;
+		}
+	};
+	const kRoot = Symbol("kRoot");
+	const kReadonly = Symbol("kReadonly");
+	const kStatWatchers = Symbol("kStatWatchers");
+	const TYPE_FILE = 0;
+	const TYPE_DIR = 1;
+	const TYPE_SYMLINK = 2;
+	const kMaxSymlinkDepth = 40;
+	var MemoryEntry = class {
+		constructor(type, options = {}) {
+			this.type = type;
+			this.mode = options.mode ?? (type === TYPE_DIR ? 493 : 420);
+			this.content = null;
+			this.contentProvider = null;
+			this.target = null;
+			this.children = null;
+			this.populate = null;
+			this.populated = true;
+			const now = Date.now();
+			this.mtime = now;
+			this.ctime = now;
+			this.birthtime = now;
+		}
+		getContentSync() {
+			if (this.contentProvider !== null) {
+				const result = this.contentProvider();
+				if (result && typeof result.then === "function") throw new ERR_INVALID_STATE("cannot use sync API with async content provider");
+				return typeof result === "string" ? Buffer$2.from(result) : result;
+			}
+			return this.content;
+		}
+		async getContentAsync() {
+			if (this.contentProvider !== null) {
+				const result = await this.contentProvider();
+				return typeof result === "string" ? Buffer$2.from(result) : result;
+			}
+			return this.content;
+		}
+		isDynamic() {
+			return this.contentProvider !== null;
+		}
+		isFile() {
+			return this.type === TYPE_FILE;
+		}
+		isDirectory() {
+			return this.type === TYPE_DIR;
+		}
+		isSymbolicLink() {
+			return this.type === TYPE_SYMLINK;
+		}
+	};
+	var MemoryProvider = class extends VirtualProvider {
+		constructor() {
+			super();
+			this[kRoot] = new MemoryEntry(TYPE_DIR);
+			this[kRoot].children = /* @__PURE__ */ new Map();
+			this[kReadonly] = false;
+			this[kStatWatchers] = /* @__PURE__ */ new Map();
+		}
+		get readonly() {
+			return this[kReadonly];
+		}
+		get supportsWatch() {
+			return true;
+		}
+		setReadOnly() {
+			this[kReadonly] = true;
+		}
+		get supportsSymlinks() {
+			return true;
+		}
+		#normalizePath(path) {
+			let normalized = path.replace(/\\/g, "/");
+			if (!normalized.startsWith("/")) normalized = "/" + normalized;
+			return pathPosix$2.normalize(normalized);
+		}
+		#splitPath(path) {
+			if (path === "/") return [];
+			return path.slice(1).split("/");
+		}
+		#getParentPath(path) {
+			if (path === "/") return null;
+			return pathPosix$2.dirname(path);
+		}
+		#getBaseName(path) {
+			return pathPosix$2.basename(path);
+		}
+		#resolveSymlinkTarget(symlinkPath, target) {
+			if (target.startsWith("/")) return this.#normalizePath(target);
+			const parentPath = this.#getParentPath(symlinkPath) || "/";
+			return this.#normalizePath(pathPosix$2.join(parentPath, target));
+		}
+		#lookupEntry(path, followSymlinks = true, depth = 0) {
+			const normalized = this.#normalizePath(path);
+			if (normalized === "/") return {
+				entry: this[kRoot],
+				resolvedPath: "/"
+			};
+			const segments = this.#splitPath(normalized);
+			let current = this[kRoot];
+			let currentPath = "/";
+			for (let i = 0; i < segments.length; i++) {
+				const segment = segments[i];
+				if (current.isSymbolicLink() && followSymlinks) {
+					if (depth >= kMaxSymlinkDepth) return {
+						entry: null,
+						resolvedPath: null,
+						eloop: true
+					};
+					const targetPath = this.#resolveSymlinkTarget(currentPath, current.target);
+					const result = this.#lookupEntry(targetPath, true, depth + 1);
+					if (result.eloop) return result;
+					if (!result.entry) return {
+						entry: null,
+						resolvedPath: null
+					};
+					current = result.entry;
+					currentPath = result.resolvedPath;
+				}
+				if (!current.isDirectory()) return {
+					entry: null,
+					resolvedPath: null
+				};
+				this.#ensurePopulated(current, currentPath);
+				const entry = current.children.get(segment);
+				if (!entry) return {
+					entry: null,
+					resolvedPath: null
+				};
+				currentPath = pathPosix$2.join(currentPath, segment);
+				current = entry;
+			}
+			if (current.isSymbolicLink() && followSymlinks) {
+				if (depth >= kMaxSymlinkDepth) return {
+					entry: null,
+					resolvedPath: null,
+					eloop: true
+				};
+				const targetPath = this.#resolveSymlinkTarget(currentPath, current.target);
+				return this.#lookupEntry(targetPath, true, depth + 1);
+			}
+			return {
+				entry: current,
+				resolvedPath: currentPath
+			};
+		}
+		#getEntry(path, syscall, followSymlinks = true) {
+			const result = this.#lookupEntry(path, followSymlinks);
+			if (result.eloop) throw createELOOP(syscall, path);
+			if (!result.entry) throw createENOENT(syscall, path);
+			return result.entry;
+		}
+		#ensureParent(path, create, syscall) {
+			const parentPath = this.#getParentPath(path);
+			if (parentPath === null) return this[kRoot];
+			const segments = this.#splitPath(parentPath);
+			let current = this[kRoot];
+			for (let i = 0; i < segments.length; i++) {
+				const segment = segments[i];
+				if (current.isSymbolicLink()) {
+					const currentPath = pathPosix$2.join("/", ...segments.slice(0, i));
+					const targetPath = this.#resolveSymlinkTarget(currentPath, current.target);
+					const result = this.#lookupEntry(targetPath, true, 0);
+					if (!result.entry) throw createENOENT(syscall, path);
+					current = result.entry;
+				}
+				if (!current.isDirectory()) throw createENOTDIR(syscall, path);
+				const currentPath = pathPosix$2.join("/", ...segments.slice(0, i));
+				this.#ensurePopulated(current, currentPath);
+				let entry = current.children.get(segment);
+				if (!entry) if (create) {
+					entry = new MemoryEntry(TYPE_DIR);
+					entry.children = /* @__PURE__ */ new Map();
+					current.children.set(segment, entry);
+				} else throw createENOENT(syscall, path);
+				current = entry;
+			}
+			if (!current.isDirectory()) throw createENOTDIR(syscall, path);
+			const finalPath = pathPosix$2.join("/", ...segments);
+			this.#ensurePopulated(current, finalPath);
+			return current;
+		}
+		#createStats(entry, size) {
+			const options = {
+				mode: entry.mode,
+				mtimeMs: entry.mtime,
+				ctimeMs: entry.ctime,
+				birthtimeMs: entry.birthtime
+			};
+			if (entry.isFile()) return createFileStats(size !== void 0 ? size : entry.content.length, options);
+			else if (entry.isDirectory()) return createDirectoryStats(options);
+			else if (entry.isSymbolicLink()) return createSymlinkStats(entry.target.length, options);
+			throw new ERR_INVALID_STATE("Unknown entry type");
+		}
+		#ensurePopulated(entry, path) {
+			if (entry.isDirectory() && !entry.populated && entry.populate) {
+				entry.populate({
+					addFile: (name, content, opts) => {
+						const fileEntry = new MemoryEntry(TYPE_FILE, opts);
+						if (typeof content === "function") {
+							fileEntry.content = Buffer$2.alloc(0);
+							fileEntry.contentProvider = content;
+						} else fileEntry.content = typeof content === "string" ? Buffer$2.from(content) : content;
+						entry.children.set(name, fileEntry);
+					},
+					addDirectory: (name, populate, opts) => {
+						const dirEntry = new MemoryEntry(TYPE_DIR, opts);
+						dirEntry.children = /* @__PURE__ */ new Map();
+						if (typeof populate === "function") {
+							dirEntry.populate = populate;
+							dirEntry.populated = false;
+						}
+						entry.children.set(name, dirEntry);
+					},
+					addSymlink: (name, target, opts) => {
+						const symlinkEntry = new MemoryEntry(TYPE_SYMLINK, opts);
+						symlinkEntry.target = target;
+						entry.children.set(name, symlinkEntry);
+					}
+				});
+				entry.populated = true;
+			}
+		}
+		openSync(path, flags, mode) {
+			const normalized = this.#normalizePath(path);
+			const isCreate = flags === "w" || flags === "w+" || flags === "a" || flags === "a+";
+			if (this.readonly && isCreate) throw createEROFS("open", path);
+			let entry;
+			try {
+				entry = this.#getEntry(normalized, "open");
+			} catch (err) {
+				if (err.code === "ENOENT" && isCreate) {
+					const parent = this.#ensureParent(normalized, true, "open");
+					const name = this.#getBaseName(normalized);
+					entry = new MemoryEntry(TYPE_FILE, { mode });
+					entry.content = Buffer$2.alloc(0);
+					parent.children.set(name, entry);
+				} else throw err;
+			}
+			if (entry.isDirectory()) throw createEISDIR("open", path);
+			if (entry.isSymbolicLink()) throw createEINVAL("open", path);
+			const getStats = (size) => this.#createStats(entry, size);
+			return new MemoryFileHandle(normalized, flags, mode ?? entry.mode, entry.content, entry, getStats);
+		}
+		async open(path, flags, mode) {
+			return this.openSync(path, flags, mode);
+		}
+		statSync(path, options) {
+			const entry = this.#getEntry(path, "stat", true);
+			return this.#createStats(entry);
+		}
+		async stat(path, options) {
+			return this.statSync(path, options);
+		}
+		lstatSync(path, options) {
+			const entry = this.#getEntry(path, "lstat", false);
+			return this.#createStats(entry);
+		}
+		async lstat(path, options) {
+			return this.lstatSync(path, options);
+		}
+		readdirSync(path, options) {
+			const entry = this.#getEntry(path, "scandir", true);
+			if (!entry.isDirectory()) throw createENOTDIR("scandir", path);
+			this.#ensurePopulated(entry, path);
+			const names = [...entry.children.keys()];
+			if (options?.withFileTypes) {
+				const normalized = this.#normalizePath(path);
+				const dirents = [];
+				for (const name of names) {
+					const childEntry = entry.children.get(name);
+					let type;
+					if (childEntry.isSymbolicLink()) type = UV_DIRENT_LINK;
+					else if (childEntry.isDirectory()) type = UV_DIRENT_DIR;
+					else type = UV_DIRENT_FILE;
+					dirents.push(new VirtualDirent(name, type, normalized));
+				}
+				return dirents;
+			}
+			return names;
+		}
+		async readdir(path, options) {
+			return this.readdirSync(path, options);
+		}
+		mkdirSync(path, options) {
+			if (this.readonly) throw createEROFS("mkdir", path);
+			const normalized = this.#normalizePath(path);
+			const recursive = options?.recursive === true;
+			const existing = this.#lookupEntry(normalized, true);
+			if (existing.entry) {
+				if (existing.entry.isDirectory() && recursive) return;
+				throw createEEXIST("mkdir", path);
+			}
+			if (recursive) {
+				const segments = this.#splitPath(normalized);
+				let current = this[kRoot];
+				for (const segment of segments) {
+					let entry = current.children.get(segment);
+					if (!entry) {
+						entry = new MemoryEntry(TYPE_DIR, { mode: options?.mode });
+						entry.children = /* @__PURE__ */ new Map();
+						current.children.set(segment, entry);
+					} else if (!entry.isDirectory()) throw createENOTDIR("mkdir", path);
+					current = entry;
+				}
+			} else {
+				const parent = this.#ensureParent(normalized, false, "mkdir");
+				const name = this.#getBaseName(normalized);
+				const entry = new MemoryEntry(TYPE_DIR, { mode: options?.mode });
+				entry.children = /* @__PURE__ */ new Map();
+				parent.children.set(name, entry);
+			}
+			return recursive ? normalized : void 0;
+		}
+		async mkdir(path, options) {
+			return this.mkdirSync(path, options);
+		}
+		rmdirSync(path) {
+			if (this.readonly) throw createEROFS("rmdir", path);
+			const normalized = this.#normalizePath(path);
+			const entry = this.#getEntry(normalized, "rmdir", true);
+			if (!entry.isDirectory()) throw createENOTDIR("rmdir", path);
+			if (entry.children.size > 0) throw createENOTEMPTY("rmdir", path);
+			const parent = this.#ensureParent(normalized, false, "rmdir");
+			const name = this.#getBaseName(normalized);
+			parent.children.delete(name);
+		}
+		async rmdir(path) {
+			this.rmdirSync(path);
+		}
+		unlinkSync(path) {
+			if (this.readonly) throw createEROFS("unlink", path);
+			const normalized = this.#normalizePath(path);
+			if (this.#getEntry(normalized, "unlink", false).isDirectory()) throw createEISDIR("unlink", path);
+			const parent = this.#ensureParent(normalized, false, "unlink");
+			const name = this.#getBaseName(normalized);
+			parent.children.delete(name);
+		}
+		async unlink(path) {
+			this.unlinkSync(path);
+		}
+		renameSync(oldPath, newPath) {
+			if (this.readonly) throw createEROFS("rename", oldPath);
+			const normalizedOld = this.#normalizePath(oldPath);
+			const normalizedNew = this.#normalizePath(newPath);
+			const entry = this.#getEntry(normalizedOld, "rename", false);
+			const oldParent = this.#ensureParent(normalizedOld, false, "rename");
+			const oldName = this.#getBaseName(normalizedOld);
+			oldParent.children.delete(oldName);
+			const newParent = this.#ensureParent(normalizedNew, true, "rename");
+			const newName = this.#getBaseName(normalizedNew);
+			newParent.children.set(newName, entry);
+		}
+		async rename(oldPath, newPath) {
+			this.renameSync(oldPath, newPath);
+		}
+		readlinkSync(path, options) {
+			const normalized = this.#normalizePath(path);
+			const entry = this.#getEntry(normalized, "readlink", false);
+			if (!entry.isSymbolicLink()) throw createEINVAL("readlink", path);
+			return entry.target;
+		}
+		async readlink(path, options) {
+			return this.readlinkSync(path, options);
+		}
+		symlinkSync(target, path, type) {
+			if (this.readonly) throw createEROFS("symlink", path);
+			const normalized = this.#normalizePath(path);
+			if (this.#lookupEntry(normalized, false).entry) throw createEEXIST("symlink", path);
+			const parent = this.#ensureParent(normalized, true, "symlink");
+			const name = this.#getBaseName(normalized);
+			const entry = new MemoryEntry(TYPE_SYMLINK);
+			entry.target = target;
+			parent.children.set(name, entry);
+		}
+		async symlink(target, path, type) {
+			this.symlinkSync(target, path, type);
+		}
+		realpathSync(path, options) {
+			const result = this.#lookupEntry(path, true, 0);
+			if (result.eloop) throw createELOOP("realpath", path);
+			if (!result.entry) throw createENOENT("realpath", path);
+			return result.resolvedPath;
+		}
+		async realpath(path, options) {
+			return this.realpathSync(path, options);
+		}
+		watch(path, options) {
+			const normalized = this.#normalizePath(path);
+			return new VFSWatcher(this, normalized, options);
+		}
+		watchAsync(path, options) {
+			const normalized = this.#normalizePath(path);
+			return new VFSWatchAsyncIterable(this, normalized, options);
+		}
+		watchFile(path, options, listener) {
+			const normalized = this.#normalizePath(path);
+			let watcher = this[kStatWatchers].get(normalized);
+			if (!watcher) {
+				watcher = new VFSStatWatcher(this, normalized, options);
+				this[kStatWatchers].set(normalized, watcher);
+			}
+			if (listener) watcher.addListener(listener);
+			return watcher;
+		}
+		unwatchFile(path, listener) {
+			const normalized = this.#normalizePath(path);
+			const watcher = this[kStatWatchers].get(normalized);
+			if (!watcher) return;
+			if (listener) watcher.removeListener(listener);
+			else watcher.removeAllListeners("change");
+			if (watcher.hasNoListeners()) {
+				watcher.stop();
+				this[kStatWatchers].delete(normalized);
+			}
+		}
+	};
+	module.exports = { MemoryProvider };
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/router.js
+var require_router = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const { isAbsolute: isAbsolute$1, posix: pathPosix$1 } = __require("node:path");
+	function splitPath(normalizedPath) {
+		if (normalizedPath === "/") return [];
+		return normalizedPath.slice(1).split("/");
+	}
+	function getParentPath(normalizedPath) {
+		if (normalizedPath === "/") return null;
+		return pathPosix$1.dirname(normalizedPath);
+	}
+	function getBaseName(normalizedPath) {
+		return pathPosix$1.basename(normalizedPath);
+	}
+	function isPathSeparator(char) {
+		return char === "/" || char === "\\";
+	}
+	function isUnderMountPoint(normalizedPath, mountPoint) {
+		if (normalizedPath === mountPoint) return true;
+		if (!normalizedPath.startsWith(mountPoint)) return false;
+		return isPathSeparator(normalizedPath[mountPoint.length]) || isPathSeparator(mountPoint[mountPoint.length - 1]);
+	}
+	function getRelativePath(normalizedPath, mountPoint) {
+		if (normalizedPath === mountPoint) return "/";
+		if (mountPoint === "/") return normalizedPath;
+		return normalizedPath.slice(mountPoint.length);
+	}
+	module.exports = {
+		splitPath,
+		getParentPath,
+		getBaseName,
+		isUnderMountPoint,
+		getRelativePath,
+		isAbsolutePath: isAbsolute$1
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/fd.js
+var require_fd = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const kFd = Symbol("kFd");
+	const kEntry = Symbol("kEntry");
+	let nextFd = 1e4;
+	const openFDs = /* @__PURE__ */ new Map();
+	var VirtualFD = class {
+		constructor(fd, entry) {
+			this[kFd] = fd;
+			this[kEntry] = entry;
+		}
+		get fd() {
+			return this[kFd];
+		}
+		get entry() {
+			return this[kEntry];
+		}
+	};
+	function openVirtualFd(entry) {
+		const fd = nextFd++;
+		const vfd = new VirtualFD(fd, entry);
+		openFDs.set(fd, vfd);
+		return fd;
+	}
+	function getVirtualFd(fd) {
+		return openFDs.get(fd);
+	}
+	function closeVirtualFd(fd) {
+		return openFDs.delete(fd);
+	}
+	module.exports = {
+		VirtualFD,
+		openVirtualFd,
+		getVirtualFd,
+		closeVirtualFd
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/streams.js
+var require_streams = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const { Readable } = __require("node:stream");
+	const { createEBADF } = require_errors();
+	const { getVirtualFd } = require_fd();
+	var VirtualReadStream = class extends Readable {
+		#vfs;
+		#path;
+		#fd = null;
+		#end;
+		#pos;
+		#content = null;
+		#destroyed = false;
+		#autoClose;
+		constructor(vfs, filePath, options = {}) {
+			const { start = 0, end = Infinity, highWaterMark = 64 * 1024, encoding, ...streamOptions } = options;
+			super({
+				...streamOptions,
+				highWaterMark,
+				encoding
+			});
+			this.#vfs = vfs;
+			this.#path = filePath;
+			this.#end = end;
+			this.#pos = start;
+			this.#autoClose = options.autoClose !== false;
+			process.nextTick(() => this.#openFile());
+		}
+		get path() {
+			return this.#path;
+		}
+		#openFile() {
+			try {
+				this.#fd = this.#vfs.openSync(this.#path);
+				this.emit("open", this.#fd);
+				this.emit("ready");
+			} catch (err) {
+				this.destroy(err);
+			}
+		}
+		_read(size) {
+			if (this.#destroyed || this.#fd === null) return;
+			if (this.#content === null) try {
+				const vfd = getVirtualFd(this.#fd);
+				if (!vfd) {
+					this.destroy(createEBADF("read"));
+					return;
+				}
+				this.#content = vfd.entry.readFileSync();
+			} catch (err) {
+				this.destroy(err);
+				return;
+			}
+			const endPos = this.#end === Infinity ? this.#content.length : this.#end + 1;
+			const remaining = Math.min(endPos, this.#content.length) - this.#pos;
+			if (remaining <= 0) {
+				this.push(null);
+				return;
+			}
+			const bytesToRead = Math.min(size, remaining);
+			const chunk = this.#content.subarray(this.#pos, this.#pos + bytesToRead);
+			this.#pos += bytesToRead;
+			this.push(chunk);
+			if (this.#pos >= endPos || this.#pos >= this.#content.length) this.push(null);
+		}
+		#close() {
+			if (this.#fd !== null) {
+				try {
+					this.#vfs.closeSync(this.#fd);
+				} catch {}
+				this.#fd = null;
+			}
+		}
+		_destroy(err, callback) {
+			this.#destroyed = true;
+			if (this.#autoClose) this.#close();
+			callback(err);
+		}
+	};
+	module.exports = { VirtualReadStream };
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/module_hooks.js
+var require_module_hooks = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const path$2 = __require("node:path");
+	const { dirname, extname, isAbsolute, resolve } = path$2;
+	const pathPosix = path$2.posix;
+	const { pathToFileURL, fileURLToPath } = __require("node:url");
+	const { createENOENT } = require_errors();
+	const kEmptyObject = Object.freeze(Object.create(null));
+	const NodeModule = __require("node:module");
+	const builtinSet = new Set(NodeModule.builtinModules);
+	const ESM_EXTENSIONS = [
+		".js",
+		".json",
+		".node",
+		".mjs",
+		".cjs"
+	];
+	const CJS_EXTENSIONS = [
+		".js",
+		".json",
+		".node"
+	];
+	const ESM_INDEX_FILES = [
+		"index.js",
+		"index.mjs",
+		"index.cjs",
+		"index.json"
+	];
+	const CJS_INDEX_FILES = [
+		"index.js",
+		"index.json",
+		"index.node"
+	];
+	const CJS_CONDITIONS = [
+		"require",
+		"node",
+		"default"
+	];
+	function isNodeBuiltin(name) {
+		if (typeof NodeModule.isBuiltin === "function") return NodeModule.isBuiltin(name);
+		const bare = name.startsWith("node:") ? name.slice(5) : name;
+		return builtinSet.has(bare);
+	}
+	function normalizeVFSPath(inputPath) {
+		if (process.platform === "win32" && /^V:[/\\]/.test(inputPath)) inputPath = "/" + inputPath.slice(3).replace(/\\/g, "/");
+		if (inputPath.startsWith("/")) return pathPosix.normalize(inputPath);
+		return path$2.normalize(inputPath);
+	}
+	function joinVFSParts(...parts) {
+		if (parts[0]?.startsWith("/")) return pathPosix.resolve(...parts);
+		return resolve(...parts);
+	}
+	function dirnameVFS(p) {
+		if (p.startsWith("/")) return pathPosix.dirname(p);
+		return dirname(p);
+	}
+	function vfsPathToURL(vfsPath) {
+		if (vfsPath.startsWith("/") && process.platform === "win32") return "file:///V:" + encodeURI(vfsPath);
+		return pathToFileURL(vfsPath).href;
+	}
+	function urlToVFSPath(url) {
+		const parsed = new URL(url);
+		const pathname = decodeURIComponent(parsed.pathname);
+		if (process.platform === "win32" && pathname.startsWith("/V:/")) return pathname.slice(3);
+		if (process.platform === "win32" && pathname.startsWith("/") && !/^\/[A-Za-z]:/.test(pathname)) return pathname;
+		return fileURLToPath(url);
+	}
+	const activeVFSList = [];
+	let originalReadFileSync = null;
+	let originalRealpathSync = null;
+	let originalLstatSync = null;
+	let originalStatSync = null;
+	let originalReaddirSync = null;
+	let originalExistsSync = null;
+	let originalWatch = null;
+	let originalWatchFile = null;
+	let originalUnwatchFile = null;
+	let hooksInstalled = false;
+	function registerVFS(vfs) {
+		if (activeVFSList.indexOf(vfs) === -1) {
+			activeVFSList.push(vfs);
+			if (!hooksInstalled) installHooks();
+		}
+	}
+	function deregisterVFS(vfs) {
+		const index = activeVFSList.indexOf(vfs);
+		if (index !== -1) activeVFSList.splice(index, 1);
+	}
+	function findVFSForStat(filename) {
+		const normalized = normalizeVFSPath(filename);
+		for (let i = 0; i < activeVFSList.length; i++) {
+			const vfs = activeVFSList[i];
+			if (vfs.shouldHandle(normalized)) {
+				const result = vfs.internalModuleStat(normalized);
+				if (vfs.mounted || result >= 0) return {
+					vfs,
+					result
+				};
+			}
+		}
+		return null;
+	}
+	function findVFSForRead(filename, options) {
+		const normalized = normalizeVFSPath(filename);
+		for (let i = 0; i < activeVFSList.length; i++) {
+			const vfs = activeVFSList[i];
+			if (vfs.shouldHandle(normalized)) {
+				if (vfs.existsSync(normalized)) {
+					if (vfs.internalModuleStat(normalized) !== 0) return null;
+					try {
+						return {
+							vfs,
+							content: vfs.readFileSync(normalized, options)
+						};
+					} catch (e) {
+						if (vfs.mounted) throw e;
+					}
+				} else if (vfs.mounted) throw createENOENT("open", filename);
+			}
+		}
+		return null;
+	}
+	function findVFSForExists(filename) {
+		const normalized = normalizeVFSPath(filename);
+		for (let i = 0; i < activeVFSList.length; i++) {
+			const vfs = activeVFSList[i];
+			if (vfs.shouldHandle(normalized)) {
+				const exists = vfs.existsSync(normalized);
+				if (vfs.mounted || exists) return {
+					vfs,
+					exists
+				};
+			}
+		}
+		return null;
+	}
+	function findVFSForRealpath(filename) {
+		const normalized = normalizeVFSPath(filename);
+		for (let i = 0; i < activeVFSList.length; i++) {
+			const vfs = activeVFSList[i];
+			if (vfs.shouldHandle(normalized)) {
+				if (vfs.existsSync(normalized)) try {
+					return {
+						vfs,
+						realpath: vfs.realpathSync(normalized)
+					};
+				} catch (e) {
+					if (vfs.mounted) throw e;
+				}
+				else if (vfs.mounted) throw createENOENT("realpath", filename);
+			}
+		}
+		return null;
+	}
+	function findVFSForFsStat(filename) {
+		const normalized = normalizeVFSPath(filename);
+		for (let i = 0; i < activeVFSList.length; i++) {
+			const vfs = activeVFSList[i];
+			if (vfs.shouldHandle(normalized)) {
+				if (vfs.existsSync(normalized)) try {
+					return {
+						vfs,
+						stats: vfs.statSync(normalized)
+					};
+				} catch (e) {
+					if (vfs.mounted) throw e;
+				}
+				else if (vfs.mounted) throw createENOENT("stat", filename);
+			}
+		}
+		return null;
+	}
+	function findVFSForReaddir(dirname, options) {
+		const normalized = normalizeVFSPath(dirname);
+		for (let i = 0; i < activeVFSList.length; i++) {
+			const vfs = activeVFSList[i];
+			if (vfs.shouldHandle(normalized)) {
+				if (vfs.existsSync(normalized)) try {
+					return {
+						vfs,
+						entries: vfs.readdirSync(normalized, options)
+					};
+				} catch (e) {
+					if (vfs.mounted) throw e;
+				}
+				else if (vfs.mounted) throw createENOENT("scandir", dirname);
+			}
+		}
+		return null;
+	}
+	function findVFSForWatch(filename) {
+		const normalized = normalizeVFSPath(filename);
+		for (let i = 0; i < activeVFSList.length; i++) {
+			const vfs = activeVFSList[i];
+			if (vfs.shouldHandle(normalized)) {
+				if (vfs.overlay) {
+					if (vfs.existsSync(normalized)) return { vfs };
+					continue;
+				}
+				return { vfs };
+			}
+		}
+		return null;
+	}
+	const VFS_FORMAT_MAP = {
+		"__proto__": null,
+		".cjs": "commonjs",
+		".js": null,
+		".json": "json",
+		".mjs": "module",
+		".node": "addon",
+		".wasm": "wasm"
+	};
+	function getVFSPackageType(vfs, filePath) {
+		let currentDir = dirnameVFS(filePath);
+		let lastDir;
+		while (currentDir !== lastDir) {
+			if (currentDir.endsWith("/node_modules") || currentDir.endsWith("\\node_modules")) break;
+			const pjsonPath = normalizeVFSPath(joinVFSParts(currentDir, "package.json"));
+			if (vfs.shouldHandle(pjsonPath) && vfs.internalModuleStat(pjsonPath) === 0) try {
+				const content = vfs.readFileSync(pjsonPath, "utf8");
+				const parsed = JSON.parse(content);
+				if (parsed.type === "module" || parsed.type === "commonjs") return parsed.type;
+				return "none";
+			} catch {}
+			lastDir = currentDir;
+			currentDir = dirnameVFS(currentDir);
+		}
+		return "none";
+	}
+	function getVFSFormat(vfs, filePath) {
+		const ext = extname(filePath);
+		if (ext === ".js") return getVFSPackageType(vfs, filePath) === "module" ? "module" : "commonjs";
+		return VFS_FORMAT_MAP[ext] ?? "commonjs";
+	}
+	function matchWildcardPattern(keys, subpath) {
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const starIdx = key.indexOf("*");
+			if (starIdx === -1) continue;
+			const prefix = key.slice(0, starIdx);
+			const suffix = key.slice(starIdx + 1);
+			if (subpath.startsWith(prefix) && (suffix === "" || subpath.endsWith(suffix)) && subpath.length >= prefix.length + suffix.length) return {
+				key,
+				patternMatch: subpath.slice(prefix.length, suffix.length > 0 ? -suffix.length : void 0)
+			};
+		}
+		return null;
+	}
+	function expandPattern(value, patternMatch) {
+		return patternMatch !== null ? value.replace(/\*/g, patternMatch) : value;
+	}
+	function findVFSForPath(normalizedPath) {
+		for (let i = 0; i < activeVFSList.length; i++) if (activeVFSList[i].shouldHandle(normalizedPath)) return activeVFSList[i];
+		return null;
+	}
+	function makeResolveResult(vfs, filePath) {
+		return {
+			url: vfsPathToURL(filePath),
+			format: getVFSFormat(vfs, filePath),
+			shortCircuit: true
+		};
+	}
+	function tryExtensions(vfs, basePath, extensions) {
+		for (let i = 0; i < extensions.length; i++) {
+			const candidate = basePath + extensions[i];
+			if (vfs.internalModuleStat(candidate) === 0) return candidate;
+		}
+		return null;
+	}
+	function tryIndexFiles(vfs, dirPath, indexFiles) {
+		for (let i = 0; i < indexFiles.length; i++) {
+			const candidate = normalizeVFSPath(joinVFSParts(dirPath, indexFiles[i]));
+			if (vfs.internalModuleStat(candidate) === 0) return candidate;
+		}
+		return null;
+	}
+	function resolveMainField(vfs, dirPath, main, extensions, indexFiles) {
+		const mainPath = normalizeVFSPath(joinVFSParts(dirPath, main));
+		const mainStat = vfs.internalModuleStat(mainPath);
+		if (mainStat === 0) return mainPath;
+		const withExt = tryExtensions(vfs, mainPath, extensions);
+		if (withExt) return withExt;
+		if (mainStat === 1) return tryIndexFiles(vfs, mainPath, indexFiles);
+		return null;
+	}
+	function resolveExportTarget(vfs, pkgDir, target, patternMatch, extensions) {
+		if (typeof target !== "string") return null;
+		const resolved = normalizeVFSPath(joinVFSParts(pkgDir, expandPattern(target, patternMatch)));
+		if (vfs.internalModuleStat(resolved) === 0) return resolved;
+		return extensions ? tryExtensions(vfs, resolved, extensions) : null;
+	}
+	function resolveConditionsToPath(vfs, pkgDir, condMap, conditions, patternMatch, extensions) {
+		const keys = Object.getOwnPropertyNames(condMap);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (key === "default" || conditions.indexOf(key) !== -1) {
+				const value = condMap[key];
+				if (typeof value === "string") {
+					const result = resolveExportTarget(vfs, pkgDir, value, patternMatch, extensions);
+					if (result) return result;
+					continue;
+				}
+				if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+					const result = resolveConditionsToPath(vfs, pkgDir, value, conditions, patternMatch, extensions);
+					if (result) return result;
+					continue;
+				}
+			}
+		}
+		return null;
+	}
+	function resolveExportsToPath(vfs, pkgDir, packageSubpath, exports$1, conditions, extensions) {
+		if (typeof exports$1 === "string") {
+			if (packageSubpath === ".") return resolveExportTarget(vfs, pkgDir, exports$1, null, extensions);
+			return null;
+		}
+		if (typeof exports$1 !== "object" || exports$1 === null) return null;
+		const keys = Object.getOwnPropertyNames(exports$1);
+		if (keys.length === 0) return null;
+		if (keys[0] !== "" && keys[0][0] !== ".") {
+			if (packageSubpath !== ".") return null;
+			return resolveConditionsToPath(vfs, pkgDir, exports$1, conditions, null, extensions);
+		}
+		let target = exports$1[packageSubpath];
+		let patternMatch = null;
+		if (target === void 0) {
+			const match = matchWildcardPattern(keys, packageSubpath);
+			if (match) {
+				patternMatch = match.patternMatch;
+				target = exports$1[match.key];
+			}
+		}
+		if (target === void 0) return null;
+		if (typeof target === "string") return resolveExportTarget(vfs, pkgDir, target, patternMatch, extensions);
+		if (typeof target === "object" && target !== null && !Array.isArray(target)) return resolveConditionsToPath(vfs, pkgDir, target, conditions, patternMatch, extensions);
+		return null;
+	}
+	function resolveDirectoryEntry(vfs, dirPath, context) {
+		const pjsonPath = normalizeVFSPath(joinVFSParts(dirPath, "package.json"));
+		if (vfs.internalModuleStat(pjsonPath) === 0) try {
+			const content = vfs.readFileSync(pjsonPath, "utf8");
+			const parsed = JSON.parse(content);
+			if (parsed.exports != null) {
+				const resolved = resolveExportsToPath(vfs, dirPath, ".", parsed.exports, context.conditions || [], null);
+				if (resolved) return makeResolveResult(vfs, resolved);
+			}
+			if (parsed.main) {
+				const mainResult = resolveMainField(vfs, dirPath, parsed.main, ESM_EXTENSIONS, ESM_INDEX_FILES);
+				if (mainResult) return makeResolveResult(vfs, mainResult);
+			}
+		} catch {}
+		const indexResult = tryIndexFiles(vfs, dirPath, ESM_INDEX_FILES);
+		return indexResult ? makeResolveResult(vfs, indexResult) : null;
+	}
+	function parsePackageName(specifier) {
+		let separatorIndex = specifier.indexOf("/");
+		if (specifier[0] === "@") {
+			if (separatorIndex === -1) return {
+				packageName: specifier,
+				packageSubpath: "."
+			};
+			separatorIndex = specifier.indexOf("/", separatorIndex + 1);
+		}
+		const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
+		let packageSubpath = separatorIndex === -1 ? "." : "." + specifier.slice(separatorIndex);
+		if (packageSubpath === "./") packageSubpath = ".";
+		return {
+			packageName,
+			packageSubpath
+		};
+	}
+	function urlToPath(urlOrPath) {
+		if (urlOrPath.startsWith("file:")) return fileURLToPath(urlOrPath);
+		return urlOrPath;
+	}
+	function resolveVFSPath(checkPath, context, nextResolve, specifier) {
+		const normalized = normalizeVFSPath(checkPath);
+		for (let i = 0; i < activeVFSList.length; i++) {
+			const vfs = activeVFSList[i];
+			if (!vfs.shouldHandle(normalized)) continue;
+			const stat = vfs.internalModuleStat(normalized);
+			if (stat === 0) return makeResolveResult(vfs, normalized);
+			const withExt = tryExtensions(vfs, normalized, ESM_EXTENSIONS);
+			if (withExt) return makeResolveResult(vfs, withExt);
+			if (stat === 1) {
+				const resolved = resolveDirectoryEntry(vfs, normalized, context);
+				if (resolved) return resolved;
+			}
+		}
+		return nextResolve(specifier, context);
+	}
+	function resolvePackageInVFS(vfs, startDir, packageName, packageSubpath, context) {
+		let currentDir = startDir;
+		let lastDir;
+		const conditions = context.conditions || [];
+		while (currentDir !== lastDir) {
+			const pkgDir = normalizeVFSPath(joinVFSParts(currentDir, "node_modules", packageName));
+			if (vfs.shouldHandle(pkgDir) && vfs.internalModuleStat(pkgDir) === 1) {
+				const pjsonPath = normalizeVFSPath(joinVFSParts(pkgDir, "package.json"));
+				if (vfs.internalModuleStat(pjsonPath) === 0) try {
+					const parsed = JSON.parse(vfs.readFileSync(pjsonPath, "utf8"));
+					if (parsed.exports != null) {
+						const resolved = resolveExportsToPath(vfs, pkgDir, packageSubpath, parsed.exports, conditions, null);
+						if (resolved) return makeResolveResult(vfs, resolved);
+					}
+					if (packageSubpath === ".") {
+						if (parsed.main) {
+							const mainResult = resolveMainField(vfs, pkgDir, parsed.main, ESM_EXTENSIONS, ESM_INDEX_FILES);
+							if (mainResult) return makeResolveResult(vfs, mainResult);
+						}
+						const indexResult = tryIndexFiles(vfs, pkgDir, ESM_INDEX_FILES);
+						if (indexResult) return makeResolveResult(vfs, indexResult);
+					} else {
+						const subResolved = normalizeVFSPath(joinVFSParts(pkgDir, packageSubpath));
+						if (vfs.internalModuleStat(subResolved) === 0) return makeResolveResult(vfs, subResolved);
+						const withExt = tryExtensions(vfs, subResolved, ESM_EXTENSIONS);
+						if (withExt) return makeResolveResult(vfs, withExt);
+					}
+				} catch {}
+			}
+			lastDir = currentDir;
+			currentDir = dirnameVFS(currentDir);
+		}
+		return null;
+	}
+	function resolveCJSPackageInVFS(vfs, startDir, packageName, packageSubpath) {
+		let currentDir = startDir;
+		let lastDir;
+		while (currentDir !== lastDir) {
+			const pkgDir = normalizeVFSPath(joinVFSParts(currentDir, "node_modules", packageName));
+			if (vfs.shouldHandle(pkgDir) && vfs.internalModuleStat(pkgDir) === 1) {
+				const pjsonPath = normalizeVFSPath(joinVFSParts(pkgDir, "package.json"));
+				let parsed = null;
+				if (vfs.internalModuleStat(pjsonPath) === 0) try {
+					parsed = JSON.parse(vfs.readFileSync(pjsonPath, "utf8"));
+				} catch {}
+				if (parsed?.exports != null) {
+					const exportsResult = resolveExportsToPath(vfs, pkgDir, packageSubpath, parsed.exports, CJS_CONDITIONS, CJS_EXTENSIONS);
+					if (exportsResult) return exportsResult;
+				}
+				if (packageSubpath === ".") {
+					if (parsed?.main) {
+						const mainResult = resolveMainField(vfs, pkgDir, parsed.main, CJS_EXTENSIONS, CJS_INDEX_FILES);
+						if (mainResult) return mainResult;
+					}
+					const idxResult = tryIndexFiles(vfs, pkgDir, CJS_INDEX_FILES);
+					if (idxResult) return idxResult;
+				} else {
+					const subResolved = normalizeVFSPath(joinVFSParts(pkgDir, packageSubpath));
+					const subStat = vfs.internalModuleStat(subResolved);
+					if (subStat === 0) return subResolved;
+					const withExt = tryExtensions(vfs, subResolved, CJS_EXTENSIONS);
+					if (withExt) return withExt;
+					if (subStat === 1) {
+						const subPjsonPath = normalizeVFSPath(joinVFSParts(subResolved, "package.json"));
+						if (vfs.internalModuleStat(subPjsonPath) === 0) try {
+							const subParsed = JSON.parse(vfs.readFileSync(subPjsonPath, "utf8"));
+							if (subParsed.main) {
+								const mainResult = resolveMainField(vfs, subResolved, subParsed.main, CJS_EXTENSIONS, CJS_INDEX_FILES);
+								if (mainResult) return mainResult;
+							}
+						} catch {}
+						const subIdx = tryIndexFiles(vfs, subResolved, CJS_INDEX_FILES);
+						if (subIdx) return subIdx;
+					}
+				}
+			}
+			lastDir = currentDir;
+			currentDir = dirnameVFS(currentDir);
+		}
+		return null;
+	}
+	function resolveImportTarget(vfs, baseDir, value, patternMatch, context, nextResolve) {
+		const expanded = expandPattern(value, patternMatch);
+		if (!expanded.startsWith(".") && !expanded.startsWith("/")) return resolveBareSpecifier(expanded, context, nextResolve);
+		const resolved = normalizeVFSPath(joinVFSParts(baseDir, expanded));
+		if (vfs.internalModuleStat(resolved) === 0) return makeResolveResult(vfs, resolved);
+		return null;
+	}
+	function resolveImportConditions(vfs, baseDir, condMap, conditions, patternMatch, context, nextResolve) {
+		const keys = Object.getOwnPropertyNames(condMap);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (key === "default" || conditions.indexOf(key) !== -1) {
+				const value = condMap[key];
+				if (typeof value === "string") {
+					const result = resolveImportTarget(vfs, baseDir, value, patternMatch, context, nextResolve);
+					if (result) return result;
+					continue;
+				}
+				if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+					const result = resolveImportConditions(vfs, baseDir, value, conditions, patternMatch, context, nextResolve);
+					if (result) return result;
+					continue;
+				}
+			}
+		}
+		return null;
+	}
+	function resolveHashImport(specifier, context, nextResolve) {
+		if (!context.parentURL) return nextResolve(specifier, context);
+		let parentPath;
+		try {
+			parentPath = urlToPath(context.parentURL);
+		} catch {
+			return nextResolve(specifier, context);
+		}
+		const parentNorm = normalizeVFSPath(parentPath);
+		const parentVfs = findVFSForPath(parentNorm);
+		if (!parentVfs) return nextResolve(specifier, context);
+		const conditions = context.conditions || [];
+		let currentDir = dirnameVFS(parentNorm);
+		let lastDir;
+		while (currentDir !== lastDir) {
+			const pjsonPath = normalizeVFSPath(joinVFSParts(currentDir, "package.json"));
+			if (parentVfs.shouldHandle(pjsonPath) && parentVfs.internalModuleStat(pjsonPath) === 0) try {
+				const parsed = JSON.parse(parentVfs.readFileSync(pjsonPath, "utf8"));
+				if (parsed.imports) {
+					let target = parsed.imports[specifier];
+					let patternMatch = null;
+					if (target === void 0) {
+						const match = matchWildcardPattern(Object.getOwnPropertyNames(parsed.imports), specifier);
+						if (match) {
+							patternMatch = match.patternMatch;
+							target = parsed.imports[match.key];
+						}
+					}
+					if (target !== void 0) {
+						if (typeof target === "string") {
+							const result = resolveImportTarget(parentVfs, currentDir, target, patternMatch, context, nextResolve);
+							if (result) return result;
+						}
+						if (typeof target === "object" && target !== null && !Array.isArray(target)) {
+							const result = resolveImportConditions(parentVfs, currentDir, target, conditions, patternMatch, context, nextResolve);
+							if (result) return result;
+						}
+					}
+					break;
+				}
+			} catch {}
+			lastDir = currentDir;
+			currentDir = dirnameVFS(currentDir);
+		}
+		return nextResolve(specifier, context);
+	}
+	function resolveCJSImportTarget(vfs, startDir, baseDir, value, patternMatch) {
+		const expanded = expandPattern(value, patternMatch);
+		if (!expanded.startsWith(".") && !expanded.startsWith("/")) {
+			const { packageName, packageSubpath } = parsePackageName(expanded);
+			return resolveCJSPackageInVFS(vfs, startDir, packageName, packageSubpath);
+		}
+		const resolved = normalizeVFSPath(joinVFSParts(baseDir, expanded));
+		if (vfs.internalModuleStat(resolved) === 0) return resolved;
+		return tryExtensions(vfs, resolved, CJS_EXTENSIONS);
+	}
+	function resolveCJSImportConditions(vfs, startDir, baseDir, condMap, patternMatch) {
+		const keys = Object.getOwnPropertyNames(condMap);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (key === "default" || CJS_CONDITIONS.indexOf(key) !== -1) {
+				const value = condMap[key];
+				if (typeof value === "string") {
+					const result = resolveCJSImportTarget(vfs, startDir, baseDir, value, patternMatch);
+					if (result) return result;
+					continue;
+				}
+				if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+					const result = resolveCJSImportConditions(vfs, startDir, baseDir, value, patternMatch);
+					if (result) return result;
+					continue;
+				}
+			}
+		}
+		return null;
+	}
+	function resolveCJSHashImport(specifier, parentDir) {
+		const parentNorm = normalizeVFSPath(parentDir);
+		const parentVfs = findVFSForPath(parentNorm);
+		if (!parentVfs) return null;
+		let currentDir = parentNorm;
+		let lastDir;
+		while (currentDir !== lastDir) {
+			const pjsonPath = normalizeVFSPath(joinVFSParts(currentDir, "package.json"));
+			if (parentVfs.shouldHandle(pjsonPath) && parentVfs.internalModuleStat(pjsonPath) === 0) try {
+				const parsed = JSON.parse(parentVfs.readFileSync(pjsonPath, "utf8"));
+				if (parsed.imports) {
+					let target = parsed.imports[specifier];
+					let patternMatch = null;
+					if (target === void 0) {
+						const match = matchWildcardPattern(Object.getOwnPropertyNames(parsed.imports), specifier);
+						if (match) {
+							patternMatch = match.patternMatch;
+							target = parsed.imports[match.key];
+						}
+					}
+					if (target !== void 0) {
+						if (typeof target === "string") return resolveCJSImportTarget(parentVfs, parentNorm, currentDir, target, patternMatch);
+						if (typeof target === "object" && target !== null && !Array.isArray(target)) return resolveCJSImportConditions(parentVfs, parentNorm, currentDir, target, patternMatch);
+					}
+					break;
+				}
+			} catch {}
+			lastDir = currentDir;
+			currentDir = dirnameVFS(currentDir);
+		}
+		return null;
+	}
+	function resolveBareSpecifier(specifier, context, nextResolve) {
+		if (isNodeBuiltin(specifier)) return nextResolve(specifier, context);
+		if (specifier[0] === "#") return resolveHashImport(specifier, context, nextResolve);
+		if (!context.parentURL) return nextResolve(specifier, context);
+		let parentPath;
+		try {
+			parentPath = urlToPath(context.parentURL);
+		} catch {
+			return nextResolve(specifier, context);
+		}
+		const parentNorm = normalizeVFSPath(parentPath);
+		const parentVfs = findVFSForPath(parentNorm);
+		const { packageName, packageSubpath } = parsePackageName(specifier);
+		if (parentVfs) {
+			const result = resolvePackageInVFS(parentVfs, dirnameVFS(parentNorm), packageName, packageSubpath, context);
+			if (result) return result;
+		} else for (let i = 0; i < activeVFSList.length; i++) {
+			const vfs = activeVFSList[i];
+			const mp = vfs.mountPoint;
+			if (!mp) continue;
+			const result = resolvePackageInVFS(vfs, mp, packageName, packageSubpath, context);
+			if (result) return result;
+		}
+		return nextResolve(specifier, context);
+	}
+	function vfsResolveHook(specifier, context, nextResolve) {
+		if (isNodeBuiltin(specifier)) return nextResolve(specifier, context);
+		let checkPath;
+		if (specifier.startsWith("file:")) checkPath = urlToVFSPath(specifier);
+		else if (isAbsolute(specifier)) checkPath = specifier;
+		else if (specifier[0] === ".") if (context.parentURL) checkPath = resolve(dirname(urlToPath(context.parentURL)), specifier);
+		else return nextResolve(specifier, context);
+		else return resolveBareSpecifier(specifier, context, nextResolve);
+		return resolveVFSPath(checkPath, context, nextResolve, specifier);
+	}
+	function vfsLoadHook(url, context, nextLoad) {
+		if (url.startsWith("node:")) return nextLoad(url, context);
+		if (!url.startsWith("file:")) return nextLoad(url, context);
+		const normalized = normalizeVFSPath(urlToVFSPath(url));
+		for (let i = 0; i < activeVFSList.length; i++) {
+			const vfs = activeVFSList[i];
+			if (vfs.shouldHandle(normalized) && vfs.existsSync(normalized)) {
+				if (vfs.internalModuleStat(normalized) !== 0) return nextLoad(url, context);
+				try {
+					const content = vfs.readFileSync(normalized, "utf8");
+					return {
+						format: context.format || getVFSFormat(vfs, normalized),
+						source: content,
+						shortCircuit: true
+					};
+				} catch (e) {
+					if (vfs.mounted) throw e;
+				}
+			}
+		}
+		return nextLoad(url, context);
+	}
+	function installModuleHooks() {
+		if (typeof NodeModule.registerHooks === "function") NodeModule.registerHooks({
+			resolve: vfsResolveHook,
+			load: vfsLoadHook
+		});
+		const origResolveFilename = NodeModule._resolveFilename;
+		NodeModule._resolveFilename = function(request, parent, isMain, options) {
+			if (request.startsWith("node:")) return origResolveFilename.call(this, request, parent, isMain, options);
+			let checkPath;
+			if (isAbsolute(request)) checkPath = request;
+			else if (request[0] === ".") {
+				if (parent?.filename) checkPath = resolve(dirname(parent.filename), request);
+			}
+			if (checkPath) {
+				const normalized = normalizeVFSPath(checkPath);
+				for (let i = 0; i < activeVFSList.length; i++) {
+					const vfs = activeVFSList[i];
+					if (!vfs.shouldHandle(normalized)) continue;
+					const stat = vfs.internalModuleStat(normalized);
+					if (stat === 0) return normalized;
+					const withExt = tryExtensions(vfs, normalized, CJS_EXTENSIONS);
+					if (withExt) return withExt;
+					if (stat === 1) {
+						const pjsonPath = normalizeVFSPath(resolve(normalized, "package.json"));
+						if (vfs.internalModuleStat(pjsonPath) === 0) try {
+							const parsed = JSON.parse(vfs.readFileSync(pjsonPath, "utf8"));
+							if (parsed.main) {
+								const mainResult = resolveMainField(vfs, normalized, parsed.main, CJS_EXTENSIONS, CJS_INDEX_FILES);
+								if (mainResult) return mainResult;
+							}
+						} catch {}
+						const idxResult = tryIndexFiles(vfs, normalized, CJS_INDEX_FILES);
+						if (idxResult) return idxResult;
+					}
+				}
+			}
+			if (request[0] === "#") {
+				const found = resolveCJSHashImport(request, parent?.filename ? dirname(parent.filename) : process.cwd());
+				if (found) return found;
+			}
+			if (!isAbsolute(request) && request[0] !== "." && request[0] !== "#" && !isNodeBuiltin(request)) {
+				const parentNorm = normalizeVFSPath(parent?.filename ? dirname(parent.filename) : process.cwd());
+				const { packageName, packageSubpath } = parsePackageName(request);
+				let matched = false;
+				for (let i = 0; i < activeVFSList.length; i++) {
+					const vfs = activeVFSList[i];
+					if (!vfs.shouldHandle(parentNorm)) continue;
+					matched = true;
+					const found = resolveCJSPackageInVFS(vfs, parentNorm, packageName, packageSubpath);
+					if (found) return found;
+				}
+				if (!matched) for (let i = 0; i < activeVFSList.length; i++) {
+					const vfs = activeVFSList[i];
+					const mp = vfs.mountPoint;
+					if (!mp) continue;
+					const found = resolveCJSPackageInVFS(vfs, mp, packageName, packageSubpath);
+					if (found) return found;
+				}
+			}
+			return origResolveFilename.call(this, request, parent, isMain, options);
+		};
+		const origJsHandler = NodeModule._extensions[".js"];
+		NodeModule._extensions[".js"] = function(module$1, filename) {
+			const normalized = normalizeVFSPath(filename);
+			for (let i = 0; i < activeVFSList.length; i++) {
+				const vfs = activeVFSList[i];
+				if (vfs.shouldHandle(normalized) && vfs.existsSync(normalized)) {
+					const content = vfs.readFileSync(normalized, "utf8");
+					module$1._compile(content, filename);
+					return;
+				}
+			}
+			return origJsHandler.call(this, module$1, filename);
+		};
+		const origJsonHandler = NodeModule._extensions[".json"];
+		NodeModule._extensions[".json"] = function(module$2, filename) {
+			const normalized = normalizeVFSPath(filename);
+			for (let i = 0; i < activeVFSList.length; i++) {
+				const vfs = activeVFSList[i];
+				if (vfs.shouldHandle(normalized) && vfs.existsSync(normalized)) {
+					const content = vfs.readFileSync(normalized, "utf8");
+					module$2.exports = JSON.parse(content);
+					return;
+				}
+			}
+			return origJsonHandler.call(this, module$2, filename);
+		};
+	}
+	function installFsPatches() {
+		const fs = __require("node:fs");
+		originalReadFileSync = fs.readFileSync;
+		originalRealpathSync = fs.realpathSync;
+		originalLstatSync = fs.lstatSync;
+		originalStatSync = fs.statSync;
+		fs.readFileSync = function readFileSync(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForRead(path, options);
+				if (vfsResult !== null) return vfsResult.content;
+			}
+			return originalReadFileSync.call(fs, path, options);
+		};
+		fs.realpathSync = function realpathSync(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForRealpath(path);
+				if (vfsResult !== null) return vfsResult.realpath;
+			}
+			return originalRealpathSync.call(fs, path, options);
+		};
+		if (originalRealpathSync.native) fs.realpathSync.native = originalRealpathSync.native;
+		fs.lstatSync = function lstatSync(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForFsStat(path);
+				if (vfsResult !== null) return vfsResult.stats;
+			}
+			return originalLstatSync.call(fs, path, options);
+		};
+		fs.statSync = function statSync(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForFsStat(path);
+				if (vfsResult !== null) return vfsResult.stats;
+			}
+			return originalStatSync.call(fs, path, options);
+		};
+		originalReaddirSync = fs.readdirSync;
+		fs.readdirSync = function readdirSync(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForReaddir(path, options);
+				if (vfsResult !== null) return vfsResult.entries;
+			}
+			return originalReaddirSync.call(fs, path, options);
+		};
+		originalExistsSync = fs.existsSync;
+		fs.existsSync = function existsSync(path) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForExists(path);
+				if (vfsResult !== null) return vfsResult.exists;
+			}
+			return originalExistsSync.call(fs, path);
+		};
+		const originalReadlinkSync = fs.readlinkSync;
+		fs.readlinkSync = function readlinkSync(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForRealpath(path);
+				if (vfsResult !== null) return vfsResult.realpath;
+			}
+			return originalReadlinkSync.call(fs, path, options);
+		};
+		const originalAccessSync = fs.accessSync;
+		fs.accessSync = function accessSync(path, mode) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForExists(path);
+				if (vfsResult !== null) {
+					if (!vfsResult.exists) throw createENOENT("access", path);
+					return;
+				}
+			}
+			return originalAccessSync.call(fs, path, mode);
+		};
+		const originalAccess = fs.access;
+		fs.access = function access(path, mode, callback) {
+			if (typeof mode === "function") {
+				callback = mode;
+				mode = fs.constants.F_OK;
+			}
+			if (typeof path === "string") {
+				const vfsResult = findVFSForExists(path);
+				if (vfsResult !== null) {
+					const err = vfsResult.exists ? null : createENOENT("access", path);
+					if (callback) process.nextTick(callback, err);
+					return;
+				}
+			}
+			return originalAccess.call(fs, path, mode, callback);
+		};
+		const originalStat = fs.stat;
+		fs.stat = function stat(path, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			if (typeof path === "string") try {
+				const vfsResult = findVFSForFsStat(path);
+				if (vfsResult !== null) {
+					if (callback) process.nextTick(callback, null, vfsResult.stats);
+					return;
+				}
+			} catch (err) {
+				if (callback) process.nextTick(callback, err);
+				return;
+			}
+			return originalStat.call(fs, path, options, callback);
+		};
+		const originalLstat = fs.lstat;
+		fs.lstat = function lstat(path, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			if (typeof path === "string") try {
+				const vfsResult = findVFSForFsStat(path);
+				if (vfsResult !== null) {
+					if (callback) process.nextTick(callback, null, vfsResult.stats);
+					return;
+				}
+			} catch (err) {
+				if (callback) process.nextTick(callback, err);
+				return;
+			}
+			return originalLstat.call(fs, path, options, callback);
+		};
+		const originalReadFile = fs.readFile;
+		fs.readFile = function readFile(path, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			if (typeof path === "string") try {
+				const vfsResult = findVFSForRead(path, options);
+				if (vfsResult !== null) {
+					if (callback) process.nextTick(callback, null, vfsResult.content);
+					return;
+				}
+			} catch (err) {
+				if (callback) process.nextTick(callback, err);
+				return;
+			}
+			return originalReadFile.call(fs, path, options, callback);
+		};
+		const originalCreateReadStream = fs.createReadStream;
+		fs.createReadStream = function createReadStream(path, options) {
+			if (typeof path === "string") try {
+				const vfsResult = findVFSForRead(path, options);
+				if (vfsResult !== null) {
+					const { Readable } = __require("node:stream");
+					const stream = new Readable({ read() {} });
+					stream.push(vfsResult.content);
+					stream.push(null);
+					return stream;
+				}
+			} catch (err) {
+				const { Readable } = __require("node:stream");
+				const stream = new Readable({ read() {} });
+				process.nextTick(() => stream.destroy(err));
+				return stream;
+			}
+			return originalCreateReadStream.call(fs, path, options);
+		};
+		const originalReaddir = fs.readdir;
+		fs.readdir = function readdir(path, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			if (typeof path === "string") try {
+				const vfsResult = findVFSForReaddir(path, options);
+				if (vfsResult !== null) {
+					if (callback) process.nextTick(callback, null, vfsResult.entries);
+					return;
+				}
+			} catch (err) {
+				if (callback) process.nextTick(callback, err);
+				return;
+			}
+			return originalReaddir.call(fs, path, options, callback);
+		};
+		const originalReadlink = fs.readlink;
+		fs.readlink = function readlink(path, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			if (typeof path === "string") try {
+				const vfsResult = findVFSForRealpath(path);
+				if (vfsResult !== null) {
+					if (callback) process.nextTick(callback, null, vfsResult.realpath);
+					return;
+				}
+			} catch (err) {
+				if (callback) process.nextTick(callback, err);
+				return;
+			}
+			return originalReadlink.call(fs, path, options, callback);
+		};
+		const originalRealpath = fs.realpath;
+		fs.realpath = function realpath(path, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			if (typeof path === "string") try {
+				const vfsResult = findVFSForRealpath(path);
+				if (vfsResult !== null) {
+					if (callback) process.nextTick(callback, null, vfsResult.realpath);
+					return;
+				}
+			} catch (err) {
+				if (callback) process.nextTick(callback, err);
+				return;
+			}
+			return originalRealpath.call(fs, path, options, callback);
+		};
+		if (originalRealpath.native) fs.realpath.native = originalRealpath.native;
+		const origPAccess = fs.promises.access;
+		fs.promises.access = async function access(path, mode) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForExists(path);
+				if (vfsResult !== null) {
+					if (!vfsResult.exists) throw createENOENT("access", path);
+					return;
+				}
+			}
+			return origPAccess.call(fs.promises, path, mode);
+		};
+		const origPReadFile = fs.promises.readFile;
+		fs.promises.readFile = async function readFile(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForRead(path, options);
+				if (vfsResult !== null) return vfsResult.content;
+			}
+			return origPReadFile.call(fs.promises, path, options);
+		};
+		const origPStat = fs.promises.stat;
+		fs.promises.stat = async function stat(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForFsStat(path);
+				if (vfsResult !== null) return vfsResult.stats;
+			}
+			return origPStat.call(fs.promises, path, options);
+		};
+		const origPLstat = fs.promises.lstat;
+		fs.promises.lstat = async function lstat(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForFsStat(path);
+				if (vfsResult !== null) return vfsResult.stats;
+			}
+			return origPLstat.call(fs.promises, path, options);
+		};
+		const origPReaddir = fs.promises.readdir;
+		fs.promises.readdir = async function readdir(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForReaddir(path, options);
+				if (vfsResult !== null) return vfsResult.entries;
+			}
+			return origPReaddir.call(fs.promises, path, options);
+		};
+		const origPReadlink = fs.promises.readlink;
+		fs.promises.readlink = async function readlink(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForRealpath(path);
+				if (vfsResult !== null) return vfsResult.realpath;
+			}
+			return origPReadlink.call(fs.promises, path, options);
+		};
+		const origPRealpath = fs.promises.realpath;
+		fs.promises.realpath = async function realpath(path, options) {
+			if (typeof path === "string") {
+				const vfsResult = findVFSForRealpath(path);
+				if (vfsResult !== null) return vfsResult.realpath;
+			}
+			return origPRealpath.call(fs.promises, path, options);
+		};
+		originalWatch = fs.watch;
+		fs.watch = function watch(filename, options, listener) {
+			if (typeof options === "function") {
+				listener = options;
+				options = kEmptyObject;
+			} else options ??= kEmptyObject;
+			if (typeof filename === "string") {
+				const vfsResult = findVFSForWatch(filename);
+				if (vfsResult !== null) return vfsResult.vfs.watch(filename, options, listener);
+			}
+			return originalWatch.call(fs, filename, options, listener);
+		};
+		originalWatchFile = fs.watchFile;
+		fs.watchFile = function watchFile(filename, options, listener) {
+			if (typeof options === "function") {
+				listener = options;
+				options = kEmptyObject;
+			} else options ??= kEmptyObject;
+			if (typeof filename === "string") {
+				const vfsResult = findVFSForWatch(filename);
+				if (vfsResult !== null) return vfsResult.vfs.watchFile(filename, options, listener);
+			}
+			return originalWatchFile.call(fs, filename, options, listener);
+		};
+		originalUnwatchFile = fs.unwatchFile;
+		fs.unwatchFile = function unwatchFile(filename, listener) {
+			if (typeof filename === "string") {
+				const vfsResult = findVFSForWatch(filename);
+				if (vfsResult !== null) {
+					vfsResult.vfs.unwatchFile(filename, listener);
+					return;
+				}
+			}
+			return originalUnwatchFile.call(fs, filename, listener);
+		};
+	}
+	function installHooks() {
+		if (hooksInstalled) return;
+		installModuleHooks();
+		installFsPatches();
+		hooksInstalled = true;
+	}
+	module.exports = {
+		registerVFS,
+		deregisterVFS,
+		findVFSForStat,
+		findVFSForRead
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/file_system.js
+var require_file_system = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const path$1 = __require("node:path");
+	const pathPosix = path$1.posix;
+	const { isAbsolute, resolve: resolvePath } = path$1;
+	const { MemoryProvider } = require_memory();
+	const { isUnderMountPoint, getRelativePath } = require_router();
+	const { openVirtualFd, getVirtualFd, closeVirtualFd } = require_fd();
+	const { createENOENT, createENOTDIR, createEBADF, ERR_INVALID_STATE } = require_errors();
+	const { VirtualReadStream } = require_streams();
+	const kEmptyObject = Object.freeze(Object.create(null));
+	function normalizeVFSPath(inputPath) {
+		if (inputPath.startsWith("/")) return pathPosix.normalize(inputPath);
+		return path$1.normalize(inputPath);
+	}
+	function joinVFSPath(base, part) {
+		if (base.startsWith("/")) return pathPosix.join(base, part);
+		return path$1.join(base, part);
+	}
+	const kProvider = Symbol("kProvider");
+	const kMountPoint = Symbol("kMountPoint");
+	const kMounted = Symbol("kMounted");
+	const kOverlay = Symbol("kOverlay");
+	const kModuleHooks = Symbol("kModuleHooks");
+	const kPromises = Symbol("kPromises");
+	const kVirtualCwd = Symbol("kVirtualCwd");
+	const kVirtualCwdEnabled = Symbol("kVirtualCwdEnabled");
+	const kOriginalChdir = Symbol("kOriginalChdir");
+	const kOriginalCwd = Symbol("kOriginalCwd");
+	let registerVFS;
+	let deregisterVFS;
+	function loadModuleHooks() {
+		if (!registerVFS) {
+			const hooks = require_module_hooks();
+			registerVFS = hooks.registerVFS;
+			deregisterVFS = hooks.deregisterVFS;
+		}
+	}
+	var VirtualFileSystem = class {
+		constructor(providerOrOptions, options = kEmptyObject) {
+			let provider = null;
+			if (providerOrOptions !== void 0 && providerOrOptions !== null) {
+				if (typeof providerOrOptions.openSync === "function") provider = providerOrOptions;
+				else if (typeof providerOrOptions === "object") {
+					options = providerOrOptions;
+					provider = null;
+				}
+			}
+			if (options.moduleHooks !== void 0 && typeof options.moduleHooks !== "boolean") throw new TypeError("options.moduleHooks must be a boolean");
+			if (options.virtualCwd !== void 0 && typeof options.virtualCwd !== "boolean") throw new TypeError("options.virtualCwd must be a boolean");
+			if (options.overlay !== void 0 && typeof options.overlay !== "boolean") throw new TypeError("options.overlay must be a boolean");
+			this[kProvider] = provider ?? new MemoryProvider();
+			this[kMountPoint] = null;
+			this[kMounted] = false;
+			this[kOverlay] = options.overlay === true;
+			this[kModuleHooks] = options.moduleHooks !== false;
+			this[kPromises] = null;
+			this[kVirtualCwdEnabled] = options.virtualCwd === true;
+			this[kVirtualCwd] = null;
+			this[kOriginalChdir] = null;
+			this[kOriginalCwd] = null;
+		}
+		get provider() {
+			return this[kProvider];
+		}
+		get mountPoint() {
+			return this[kMountPoint];
+		}
+		get mounted() {
+			return this[kMounted];
+		}
+		get readonly() {
+			return this[kProvider].readonly;
+		}
+		get overlay() {
+			return this[kOverlay];
+		}
+		get virtualCwdEnabled() {
+			return this[kVirtualCwdEnabled];
+		}
+		cwd() {
+			if (!this[kVirtualCwdEnabled]) throw new ERR_INVALID_STATE("virtual cwd is not enabled");
+			return this[kVirtualCwd];
+		}
+		chdir(dirPath) {
+			if (!this[kVirtualCwdEnabled]) throw new ERR_INVALID_STATE("virtual cwd is not enabled");
+			const providerPath = this.#toProviderPath(dirPath);
+			if (!this[kProvider].statSync(providerPath).isDirectory()) throw createENOTDIR("chdir", dirPath);
+			this[kVirtualCwd] = this.#toMountedPath(providerPath);
+		}
+		resolvePath(inputPath) {
+			if (isAbsolute(inputPath)) return normalizeVFSPath(inputPath);
+			if (this[kVirtualCwdEnabled] && this[kVirtualCwd] !== null) return normalizeVFSPath(`${this[kVirtualCwd]}/${inputPath}`);
+			return resolvePath(inputPath);
+		}
+		mount(prefix) {
+			if (this[kMounted]) throw new ERR_INVALID_STATE("VFS is already mounted");
+			this[kMountPoint] = normalizeVFSPath(prefix);
+			this[kMounted] = true;
+			if (this[kModuleHooks]) {
+				loadModuleHooks();
+				registerVFS(this);
+			}
+			if (this[kVirtualCwdEnabled]) this.#hookProcessCwd();
+			process.emit("vfs-mount", {
+				mountPoint: this[kMountPoint],
+				overlay: this[kOverlay],
+				readonly: this[kProvider].readonly
+			});
+			return this;
+		}
+		unmount() {
+			if (this[kMounted]) process.emit("vfs-unmount", {
+				mountPoint: this[kMountPoint],
+				overlay: this[kOverlay],
+				readonly: this[kProvider].readonly
+			});
+			this.#unhookProcessCwd();
+			if (this[kModuleHooks]) {
+				loadModuleHooks();
+				deregisterVFS(this);
+			}
+			this[kMountPoint] = null;
+			this[kMounted] = false;
+			this[kVirtualCwd] = null;
+		}
+		[Symbol.dispose]() {
+			if (this[kMounted]) this.unmount();
+		}
+		#hookProcessCwd() {
+			if (this[kOriginalChdir] !== null) return;
+			const vfs = this;
+			this[kOriginalChdir] = process.chdir;
+			this[kOriginalCwd] = process.cwd;
+			process.chdir = function chdir(directory) {
+				const normalized = isAbsolute(directory) ? normalizeVFSPath(directory) : resolvePath(directory);
+				if (vfs.shouldHandle(normalized)) {
+					vfs.chdir(normalized);
+					return;
+				}
+				return vfs[kOriginalChdir].call(process, directory);
+			};
+			process.cwd = function cwd() {
+				if (vfs[kVirtualCwd] !== null) return vfs[kVirtualCwd];
+				return vfs[kOriginalCwd].call(process);
+			};
+		}
+		#unhookProcessCwd() {
+			if (this[kOriginalChdir] === null) return;
+			process.chdir = this[kOriginalChdir];
+			process.cwd = this[kOriginalCwd];
+			this[kOriginalChdir] = null;
+			this[kOriginalCwd] = null;
+		}
+		#toProviderPath(inputPath) {
+			const resolved = this.resolvePath(inputPath);
+			if (this[kMounted] && this[kMountPoint]) {
+				if (!isUnderMountPoint(resolved, this[kMountPoint])) throw createENOENT("open", inputPath);
+				return getRelativePath(resolved, this[kMountPoint]);
+			}
+			return resolved;
+		}
+		#toMountedPath(providerPath) {
+			if (this[kMounted] && this[kMountPoint]) return joinVFSPath(this[kMountPoint], providerPath);
+			return providerPath;
+		}
+		shouldHandle(inputPath) {
+			if (!this[kMounted] || !this[kMountPoint]) return false;
+			const normalized = normalizeVFSPath(inputPath);
+			if (!isUnderMountPoint(normalized, this[kMountPoint])) return false;
+			if (this[kOverlay]) try {
+				const providerPath = getRelativePath(normalized, this[kMountPoint]);
+				return this[kProvider].existsSync(providerPath);
+			} catch {
+				return false;
+			}
+			return true;
+		}
+		existsSync(filePath) {
+			try {
+				const providerPath = this.#toProviderPath(filePath);
+				return this[kProvider].existsSync(providerPath);
+			} catch {
+				return false;
+			}
+		}
+		statSync(filePath, options) {
+			const providerPath = this.#toProviderPath(filePath);
+			return this[kProvider].statSync(providerPath, options);
+		}
+		lstatSync(filePath, options) {
+			const providerPath = this.#toProviderPath(filePath);
+			return this[kProvider].lstatSync(providerPath, options);
+		}
+		readFileSync(filePath, options) {
+			const providerPath = this.#toProviderPath(filePath);
+			return this[kProvider].readFileSync(providerPath, options);
+		}
+		writeFileSync(filePath, data, options) {
+			const providerPath = this.#toProviderPath(filePath);
+			this[kProvider].writeFileSync(providerPath, data, options);
+		}
+		appendFileSync(filePath, data, options) {
+			const providerPath = this.#toProviderPath(filePath);
+			this[kProvider].appendFileSync(providerPath, data, options);
+		}
+		readdirSync(dirPath, options) {
+			const providerPath = this.#toProviderPath(dirPath);
+			return this[kProvider].readdirSync(providerPath, options);
+		}
+		mkdirSync(dirPath, options) {
+			const providerPath = this.#toProviderPath(dirPath);
+			const result = this[kProvider].mkdirSync(providerPath, options);
+			if (result !== void 0) return this.#toMountedPath(result);
+		}
+		rmdirSync(dirPath) {
+			const providerPath = this.#toProviderPath(dirPath);
+			this[kProvider].rmdirSync(providerPath);
+		}
+		unlinkSync(filePath) {
+			const providerPath = this.#toProviderPath(filePath);
+			this[kProvider].unlinkSync(providerPath);
+		}
+		renameSync(oldPath, newPath) {
+			const oldProviderPath = this.#toProviderPath(oldPath);
+			const newProviderPath = this.#toProviderPath(newPath);
+			this[kProvider].renameSync(oldProviderPath, newProviderPath);
+		}
+		copyFileSync(src, dest, mode) {
+			const srcProviderPath = this.#toProviderPath(src);
+			const destProviderPath = this.#toProviderPath(dest);
+			this[kProvider].copyFileSync(srcProviderPath, destProviderPath, mode);
+		}
+		realpathSync(filePath, options) {
+			const providerPath = this.#toProviderPath(filePath);
+			const realProviderPath = this[kProvider].realpathSync(providerPath, options);
+			return this.#toMountedPath(realProviderPath);
+		}
+		readlinkSync(linkPath, options) {
+			const providerPath = this.#toProviderPath(linkPath);
+			return this[kProvider].readlinkSync(providerPath, options);
+		}
+		symlinkSync(target, path, type) {
+			const providerPath = this.#toProviderPath(path);
+			this[kProvider].symlinkSync(target, providerPath, type);
+		}
+		accessSync(filePath, mode) {
+			const providerPath = this.#toProviderPath(filePath);
+			this[kProvider].accessSync(providerPath, mode);
+		}
+		internalModuleStat(filePath) {
+			try {
+				const providerPath = this.#toProviderPath(filePath);
+				return this[kProvider].internalModuleStat(providerPath);
+			} catch {
+				return -2;
+			}
+		}
+		openSync(filePath, flags = "r", mode) {
+			const providerPath = this.#toProviderPath(filePath);
+			return openVirtualFd(this[kProvider].openSync(providerPath, flags, mode));
+		}
+		closeSync(fd) {
+			const vfd = getVirtualFd(fd);
+			if (!vfd) throw createEBADF("close");
+			vfd.entry.closeSync();
+			closeVirtualFd(fd);
+		}
+		readSync(fd, buffer, offset, length, position) {
+			const vfd = getVirtualFd(fd);
+			if (!vfd) throw createEBADF("read");
+			return vfd.entry.readSync(buffer, offset, length, position);
+		}
+		fstatSync(fd, options) {
+			const vfd = getVirtualFd(fd);
+			if (!vfd) throw createEBADF("fstat");
+			return vfd.entry.statSync(options);
+		}
+		readFile(filePath, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			this[kProvider].readFile(this.#toProviderPath(filePath), options).then((data) => callback(null, data), (err) => callback(err));
+		}
+		writeFile(filePath, data, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			this[kProvider].writeFile(this.#toProviderPath(filePath), data, options).then(() => callback(null), (err) => callback(err));
+		}
+		stat(filePath, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			this[kProvider].stat(this.#toProviderPath(filePath), options).then((stats) => callback(null, stats), (err) => callback(err));
+		}
+		lstat(filePath, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			this[kProvider].lstat(this.#toProviderPath(filePath), options).then((stats) => callback(null, stats), (err) => callback(err));
+		}
+		readdir(dirPath, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			this[kProvider].readdir(this.#toProviderPath(dirPath), options).then((entries) => callback(null, entries), (err) => callback(err));
+		}
+		realpath(filePath, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			this[kProvider].realpath(this.#toProviderPath(filePath), options).then((realPath) => callback(null, this.#toMountedPath(realPath)), (err) => callback(err));
+		}
+		readlink(linkPath, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			this[kProvider].readlink(this.#toProviderPath(linkPath), options).then((target) => callback(null, target), (err) => callback(err));
+		}
+		access(filePath, mode, callback) {
+			if (typeof mode === "function") {
+				callback = mode;
+				mode = void 0;
+			}
+			this[kProvider].access(this.#toProviderPath(filePath), mode).then(() => callback(null), (err) => callback(err));
+		}
+		open(filePath, flags, mode, callback) {
+			if (typeof flags === "function") {
+				callback = flags;
+				flags = "r";
+				mode = void 0;
+			} else if (typeof mode === "function") {
+				callback = mode;
+				mode = void 0;
+			}
+			const providerPath = this.#toProviderPath(filePath);
+			this[kProvider].open(providerPath, flags, mode).then((handle) => {
+				const fd = openVirtualFd(handle);
+				callback(null, fd);
+			}, (err) => callback(err));
+		}
+		close(fd, callback) {
+			const vfd = getVirtualFd(fd);
+			if (!vfd) {
+				process.nextTick(callback, createEBADF("close"));
+				return;
+			}
+			vfd.entry.close().then(() => {
+				closeVirtualFd(fd);
+				callback(null);
+			}, (err) => callback(err));
+		}
+		read(fd, buffer, offset, length, position, callback) {
+			const vfd = getVirtualFd(fd);
+			if (!vfd) {
+				process.nextTick(callback, createEBADF("read"));
+				return;
+			}
+			vfd.entry.read(buffer, offset, length, position).then(({ bytesRead }) => callback(null, bytesRead, buffer), (err) => callback(err));
+		}
+		fstat(fd, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = void 0;
+			}
+			const vfd = getVirtualFd(fd);
+			if (!vfd) {
+				process.nextTick(callback, createEBADF("fstat"));
+				return;
+			}
+			vfd.entry.stat(options).then((stats) => callback(null, stats), (err) => callback(err));
+		}
+		createReadStream(filePath, options) {
+			return new VirtualReadStream(this, filePath, options);
+		}
+		watch(filePath, options, listener) {
+			if (typeof options === "function") {
+				listener = options;
+				options = {};
+			}
+			const providerPath = this.#toProviderPath(filePath);
+			const watcher = this[kProvider].watch(providerPath, options);
+			if (listener) watcher.on("change", listener);
+			return watcher;
+		}
+		watchFile(filePath, options, listener) {
+			if (typeof options === "function") {
+				listener = options;
+				options = {};
+			}
+			const providerPath = this.#toProviderPath(filePath);
+			return this[kProvider].watchFile(providerPath, options, listener);
+		}
+		unwatchFile(filePath, listener) {
+			const providerPath = this.#toProviderPath(filePath);
+			this[kProvider].unwatchFile(providerPath, listener);
+		}
+		get promises() {
+			if (this[kPromises] === null) this[kPromises] = this.#createPromisesAPI();
+			return this[kPromises];
+		}
+		#createPromisesAPI() {
+			const provider = this[kProvider];
+			const toProviderPath = (p) => this.#toProviderPath(p);
+			const toMountedPath = (p) => this.#toMountedPath(p);
+			return Object.freeze({
+				async readFile(filePath, options) {
+					const providerPath = toProviderPath(filePath);
+					return provider.readFile(providerPath, options);
+				},
+				async writeFile(filePath, data, options) {
+					const providerPath = toProviderPath(filePath);
+					return provider.writeFile(providerPath, data, options);
+				},
+				async appendFile(filePath, data, options) {
+					const providerPath = toProviderPath(filePath);
+					return provider.appendFile(providerPath, data, options);
+				},
+				async stat(filePath, options) {
+					const providerPath = toProviderPath(filePath);
+					return provider.stat(providerPath, options);
+				},
+				async lstat(filePath, options) {
+					const providerPath = toProviderPath(filePath);
+					return provider.lstat(providerPath, options);
+				},
+				async readdir(dirPath, options) {
+					const providerPath = toProviderPath(dirPath);
+					return provider.readdir(providerPath, options);
+				},
+				async mkdir(dirPath, options) {
+					const providerPath = toProviderPath(dirPath);
+					const result = await provider.mkdir(providerPath, options);
+					if (result !== void 0) return toMountedPath(result);
+				},
+				async rmdir(dirPath) {
+					const providerPath = toProviderPath(dirPath);
+					return provider.rmdir(providerPath);
+				},
+				async unlink(filePath) {
+					const providerPath = toProviderPath(filePath);
+					return provider.unlink(providerPath);
+				},
+				async rename(oldPath, newPath) {
+					const oldProviderPath = toProviderPath(oldPath);
+					const newProviderPath = toProviderPath(newPath);
+					return provider.rename(oldProviderPath, newProviderPath);
+				},
+				async copyFile(src, dest, mode) {
+					const srcProviderPath = toProviderPath(src);
+					const destProviderPath = toProviderPath(dest);
+					return provider.copyFile(srcProviderPath, destProviderPath, mode);
+				},
+				async realpath(filePath, options) {
+					const providerPath = toProviderPath(filePath);
+					return toMountedPath(await provider.realpath(providerPath, options));
+				},
+				async readlink(linkPath, options) {
+					const providerPath = toProviderPath(linkPath);
+					return provider.readlink(providerPath, options);
+				},
+				async symlink(target, path, type) {
+					const providerPath = toProviderPath(path);
+					return provider.symlink(target, providerPath, type);
+				},
+				async access(filePath, mode) {
+					const providerPath = toProviderPath(filePath);
+					return provider.access(providerPath, mode);
+				},
+				watch(filePath, options) {
+					const providerPath = toProviderPath(filePath);
+					return provider.watchAsync(providerPath, options);
+				}
+			});
+		}
+	};
+	module.exports = { VirtualFileSystem };
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/providers/real.js
+var require_real = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const fs = __require("node:fs");
+	const path = __require("node:path");
+	const { VirtualProvider } = require_provider();
+	const { VirtualFileHandle } = require_file_handle();
+	const { createEBADF, createENOENT, ERR_INVALID_ARG_VALUE } = require_errors();
+	var RealFileHandle = class extends VirtualFileHandle {
+		#fd;
+		#realPath;
+		#checkClosed() {
+			if (this.closed) throw createEBADF("read");
+		}
+		constructor(path, flags, mode, fd, realPath) {
+			super(path, flags, mode);
+			this.#fd = fd;
+			this.#realPath = realPath;
+		}
+		get fd() {
+			return this.#fd;
+		}
+		readSync(buffer, offset, length, position) {
+			this.#checkClosed();
+			return fs.readSync(this.#fd, buffer, offset, length, position);
+		}
+		async read(buffer, offset, length, position) {
+			this.#checkClosed();
+			return new Promise((resolve, reject) => {
+				fs.read(this.#fd, buffer, offset, length, position, (err, bytesRead) => {
+					if (err) reject(err);
+					else resolve({
+						bytesRead,
+						buffer
+					});
+				});
+			});
+		}
+		writeSync(buffer, offset, length, position) {
+			this.#checkClosed();
+			return fs.writeSync(this.#fd, buffer, offset, length, position);
+		}
+		async write(buffer, offset, length, position) {
+			this.#checkClosed();
+			return new Promise((resolve, reject) => {
+				fs.write(this.#fd, buffer, offset, length, position, (err, bytesWritten) => {
+					if (err) reject(err);
+					else resolve({
+						bytesWritten,
+						buffer
+					});
+				});
+			});
+		}
+		readFileSync(options) {
+			this.#checkClosed();
+			return fs.readFileSync(this.#realPath, options);
+		}
+		async readFile(options) {
+			this.#checkClosed();
+			return fs.promises.readFile(this.#realPath, options);
+		}
+		writeFileSync(data, options) {
+			this.#checkClosed();
+			fs.writeFileSync(this.#fd, data, options);
+		}
+		async writeFile(data, options) {
+			this.#checkClosed();
+			return new Promise((resolve, reject) => {
+				fs.writeFile(this.#fd, data, options, (err) => {
+					if (err) reject(err);
+					else resolve();
+				});
+			});
+		}
+		statSync(options) {
+			this.#checkClosed();
+			return fs.fstatSync(this.#fd, options);
+		}
+		async stat(options) {
+			this.#checkClosed();
+			return new Promise((resolve, reject) => {
+				fs.fstat(this.#fd, options, (err, stats) => {
+					if (err) reject(err);
+					else resolve(stats);
+				});
+			});
+		}
+		truncateSync(len = 0) {
+			this.#checkClosed();
+			fs.ftruncateSync(this.#fd, len);
+		}
+		async truncate(len = 0) {
+			this.#checkClosed();
+			return new Promise((resolve, reject) => {
+				fs.ftruncate(this.#fd, len, (err) => {
+					if (err) reject(err);
+					else resolve();
+				});
+			});
+		}
+		closeSync() {
+			if (!this.closed) {
+				fs.closeSync(this.#fd);
+				super.closeSync();
+			}
+		}
+		async close() {
+			if (!this.closed) return new Promise((resolve, reject) => {
+				fs.close(this.#fd, (err) => {
+					if (err) reject(err);
+					else {
+						super.closeSync();
+						resolve();
+					}
+				});
+			});
+		}
+	};
+	var RealFSProvider = class extends VirtualProvider {
+		#rootPath;
+		constructor(rootPath) {
+			super();
+			if (typeof rootPath !== "string" || rootPath === "") throw new ERR_INVALID_ARG_VALUE("rootPath", rootPath, "must be a non-empty string");
+			this.#rootPath = path.resolve(rootPath);
+		}
+		get rootPath() {
+			return this.#rootPath;
+		}
+		get readonly() {
+			return false;
+		}
+		get supportsSymlinks() {
+			return true;
+		}
+		#resolvePath(vfsPath) {
+			if (vfsPath.startsWith(this.#rootPath + path.sep) || vfsPath === this.#rootPath) return path.resolve(vfsPath);
+			let normalized = vfsPath;
+			if (normalized.startsWith("/")) normalized = normalized.slice(1);
+			const realPath = path.resolve(this.#rootPath, normalized);
+			const rootWithSep = this.#rootPath.endsWith(path.sep) ? this.#rootPath : this.#rootPath + path.sep;
+			if (realPath !== this.#rootPath && !realPath.startsWith(rootWithSep)) throw createENOENT("open", vfsPath);
+			return realPath;
+		}
+		openSync(vfsPath, flags, mode) {
+			const realPath = this.#resolvePath(vfsPath);
+			const fd = fs.openSync(realPath, flags, mode);
+			return new RealFileHandle(vfsPath, flags, mode ?? 420, fd, realPath);
+		}
+		async open(vfsPath, flags, mode) {
+			const realPath = this.#resolvePath(vfsPath);
+			return new Promise((resolve, reject) => {
+				fs.open(realPath, flags, mode, (err, fd) => {
+					if (err) reject(err);
+					else resolve(new RealFileHandle(vfsPath, flags, mode ?? 420, fd, realPath));
+				});
+			});
+		}
+		statSync(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.statSync(realPath, options);
+		}
+		async stat(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.promises.stat(realPath, options);
+		}
+		lstatSync(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.lstatSync(realPath, options);
+		}
+		async lstat(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.promises.lstat(realPath, options);
+		}
+		readdirSync(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.readdirSync(realPath, options);
+		}
+		async readdir(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.promises.readdir(realPath, options);
+		}
+		mkdirSync(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.mkdirSync(realPath, options);
+		}
+		async mkdir(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.promises.mkdir(realPath, options);
+		}
+		rmdirSync(vfsPath) {
+			const realPath = this.#resolvePath(vfsPath);
+			fs.rmdirSync(realPath);
+		}
+		async rmdir(vfsPath) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.promises.rmdir(realPath);
+		}
+		unlinkSync(vfsPath) {
+			const realPath = this.#resolvePath(vfsPath);
+			fs.unlinkSync(realPath);
+		}
+		async unlink(vfsPath) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.promises.unlink(realPath);
+		}
+		renameSync(oldVfsPath, newVfsPath) {
+			const oldRealPath = this.#resolvePath(oldVfsPath);
+			const newRealPath = this.#resolvePath(newVfsPath);
+			fs.renameSync(oldRealPath, newRealPath);
+		}
+		async rename(oldVfsPath, newVfsPath) {
+			const oldRealPath = this.#resolvePath(oldVfsPath);
+			const newRealPath = this.#resolvePath(newVfsPath);
+			return fs.promises.rename(oldRealPath, newRealPath);
+		}
+		readlinkSync(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.readlinkSync(realPath, options);
+		}
+		async readlink(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.promises.readlink(realPath, options);
+		}
+		symlinkSync(target, vfsPath, type) {
+			const realPath = this.#resolvePath(vfsPath);
+			fs.symlinkSync(target, realPath, type);
+		}
+		async symlink(target, vfsPath, type) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.promises.symlink(target, realPath, type);
+		}
+		realpathSync(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			const resolved = fs.realpathSync(realPath, options);
+			if (resolved === this.#rootPath) return "/";
+			const rootWithSep = this.#rootPath + path.sep;
+			if (resolved.startsWith(rootWithSep)) return "/" + resolved.slice(rootWithSep.length).replace(/\\/g, "/");
+			return vfsPath;
+		}
+		async realpath(vfsPath, options) {
+			const realPath = this.#resolvePath(vfsPath);
+			const resolved = await fs.promises.realpath(realPath, options);
+			if (resolved === this.#rootPath) return "/";
+			const rootWithSep = this.#rootPath + path.sep;
+			if (resolved.startsWith(rootWithSep)) return "/" + resolved.slice(rootWithSep.length).replace(/\\/g, "/");
+			return vfsPath;
+		}
+		accessSync(vfsPath, mode) {
+			const realPath = this.#resolvePath(vfsPath);
+			fs.accessSync(realPath, mode);
+		}
+		async access(vfsPath, mode) {
+			const realPath = this.#resolvePath(vfsPath);
+			return fs.promises.access(realPath, mode);
+		}
+		copyFileSync(srcVfsPath, destVfsPath, mode) {
+			const srcRealPath = this.#resolvePath(srcVfsPath);
+			const destRealPath = this.#resolvePath(destVfsPath);
+			fs.copyFileSync(srcRealPath, destRealPath, mode);
+		}
+		async copyFile(srcVfsPath, destVfsPath, mode) {
+			const srcRealPath = this.#resolvePath(srcVfsPath);
+			const destRealPath = this.#resolvePath(destVfsPath);
+			return fs.promises.copyFile(srcRealPath, destRealPath, mode);
+		}
+	};
+	module.exports = {
+		RealFSProvider,
+		RealFileHandle
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@platformatic+vfs@0.4.0/node_modules/@platformatic/vfs/lib/providers/sqlite.js
+var require_sqlite = /* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const { Buffer: Buffer$1 } = __require("node:buffer");
+	const { posix: pathPosix } = __require("node:path");
+	const { DatabaseSync } = __require("node:sqlite");
+	const { VirtualProvider } = require_provider();
+	const { VirtualFileHandle } = require_file_handle();
+	const { VFSWatcher, VFSStatWatcher, VFSWatchAsyncIterable } = require_watcher();
+	const { createENOENT, createENOTDIR, createENOTEMPTY, createEISDIR, createEEXIST, createEINVAL, createELOOP, createEROFS } = require_errors();
+	const { createFileStats, createDirectoryStats, createSymlinkStats } = require_stats();
+	const UV_DIRENT_FILE = 1;
+	const UV_DIRENT_DIR = 2;
+	const UV_DIRENT_LINK = 3;
+	var VirtualDirent = class {
+		#name;
+		#type;
+		#parentPath;
+		constructor(name, type, parentPath) {
+			this.#name = name;
+			this.#type = type;
+			this.#parentPath = parentPath;
+		}
+		get name() {
+			return this.#name;
+		}
+		get parentPath() {
+			return this.#parentPath;
+		}
+		get path() {
+			return this.#parentPath;
+		}
+		isFile() {
+			return this.#type === UV_DIRENT_FILE;
+		}
+		isDirectory() {
+			return this.#type === UV_DIRENT_DIR;
+		}
+		isSymbolicLink() {
+			return this.#type === UV_DIRENT_LINK;
+		}
+		isBlockDevice() {
+			return false;
+		}
+		isCharacterDevice() {
+			return false;
+		}
+		isFIFO() {
+			return false;
+		}
+		isSocket() {
+			return false;
+		}
+	};
+	const TYPE_FILE = 0;
+	const TYPE_DIR = 1;
+	const TYPE_SYMLINK = 2;
+	const kMaxSymlinkDepth = 40;
+	var SqliteFileHandle = class extends VirtualFileHandle {
+		#content;
+		#updateStmt;
+		#path;
+		#getStats;
+		#checkClosed() {
+			if (this.closed) {
+				const { createEBADF } = require_errors();
+				throw createEBADF("read");
+			}
+		}
+		constructor(path, flags, mode, content, updateStmt, getStats) {
+			super(path, flags, mode);
+			this.#content = content;
+			this.#updateStmt = updateStmt;
+			this.#path = path;
+			this.#getStats = getStats;
+			if (flags === "w" || flags === "w+") {
+				this.#content = Buffer$1.alloc(0);
+				this.#flush();
+			} else if (flags === "a" || flags === "a+") this.position = this.#content.length;
+		}
+		#flush() {
+			const now = Date.now();
+			this.#updateStmt.run(this.#content, now, this.#path);
+		}
+		get content() {
+			return this.#content;
+		}
+		readSync(buffer, offset, length, position) {
+			this.#checkClosed();
+			const content = this.#content;
+			const readPos = position !== null && position !== void 0 ? position : this.position;
+			const available = content.length - readPos;
+			if (available <= 0) return 0;
+			const bytesToRead = Math.min(length, available);
+			content.copy(buffer, offset, readPos, readPos + bytesToRead);
+			if (position === null || position === void 0) this.position = readPos + bytesToRead;
+			return bytesToRead;
+		}
+		async read(buffer, offset, length, position) {
+			return {
+				bytesRead: this.readSync(buffer, offset, length, position),
+				buffer
+			};
+		}
+		writeSync(buffer, offset, length, position) {
+			this.#checkClosed();
+			const writePos = position !== null && position !== void 0 ? position : this.position;
+			const data = buffer.subarray(offset, offset + length);
+			if (writePos + length > this.#content.length) {
+				const newContent = Buffer$1.alloc(writePos + length);
+				this.#content.copy(newContent, 0, 0, this.#content.length);
+				this.#content = newContent;
+			}
+			data.copy(this.#content, writePos);
+			this.#flush();
+			if (position === null || position === void 0) this.position = writePos + length;
+			return length;
+		}
+		async write(buffer, offset, length, position) {
+			return {
+				bytesWritten: this.writeSync(buffer, offset, length, position),
+				buffer
+			};
+		}
+		readFileSync(options) {
+			this.#checkClosed();
+			const content = this.#content;
+			const encoding = typeof options === "string" ? options : options?.encoding;
+			if (encoding) return content.toString(encoding);
+			return Buffer$1.from(content);
+		}
+		async readFile(options) {
+			return this.readFileSync(options);
+		}
+		writeFileSync(data, options) {
+			this.#checkClosed();
+			const buffer = typeof data === "string" ? Buffer$1.from(data, options?.encoding) : data;
+			if (this.flags === "a" || this.flags === "a+") {
+				const newContent = Buffer$1.alloc(this.#content.length + buffer.length);
+				this.#content.copy(newContent, 0);
+				buffer.copy(newContent, this.#content.length);
+				this.#content = newContent;
+			} else this.#content = Buffer$1.from(buffer);
+			this.#flush();
+			this.position = this.#content.length;
+		}
+		async writeFile(data, options) {
+			this.writeFileSync(data, options);
+		}
+		statSync(options) {
+			this.#checkClosed();
+			if (this.#getStats) return this.#getStats(this.#content.length);
+			const { ERR_INVALID_STATE } = require_errors();
+			throw new ERR_INVALID_STATE("stats not available");
+		}
+		async stat(options) {
+			return this.statSync(options);
+		}
+		truncateSync(len = 0) {
+			this.#checkClosed();
+			if (len < this.#content.length) this.#content = this.#content.subarray(0, len);
+			else if (len > this.#content.length) {
+				const newContent = Buffer$1.alloc(len);
+				this.#content.copy(newContent, 0, 0, this.#content.length);
+				this.#content = newContent;
+			}
+			this.#flush();
+		}
+		async truncate(len) {
+			this.truncateSync(len);
+		}
+	};
+	var SqliteProvider = class extends VirtualProvider {
+		#db;
+		#readonly;
+		#statWatchers;
+		#stmtGet;
+		#stmtInsert;
+		#stmtUpdateContent;
+		#stmtDelete;
+		#stmtChildren;
+		#stmtDescendants;
+		constructor(pathOrMemory) {
+			super();
+			this.#readonly = false;
+			this.#statWatchers = /* @__PURE__ */ new Map();
+			this.#db = new DatabaseSync(pathOrMemory ?? ":memory:");
+			this.#db.exec(`
+      CREATE TABLE IF NOT EXISTS entries (
+        path        TEXT PRIMARY KEY,
+        parent_path TEXT,
+        name        TEXT,
+        type        INTEGER NOT NULL,
+        content     BLOB,
+        target      TEXT,
+        mode        INTEGER NOT NULL,
+        mtime       REAL NOT NULL,
+        ctime       REAL NOT NULL,
+        birthtime   REAL NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_parent ON entries(parent_path);
+    `);
+			if (!this.#db.prepare("SELECT path FROM entries WHERE path = ?").get("/")) {
+				const now = Date.now();
+				this.#db.prepare("INSERT INTO entries (path, parent_path, name, type, content, target, mode, mtime, ctime, birthtime) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run("/", null, "", TYPE_DIR, null, null, 493, now, now, now);
+			}
+			this.#stmtGet = this.#db.prepare("SELECT * FROM entries WHERE path = ?");
+			this.#stmtInsert = this.#db.prepare("INSERT INTO entries (path, parent_path, name, type, content, target, mode, mtime, ctime, birthtime) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+			this.#stmtUpdateContent = this.#db.prepare("UPDATE entries SET content=?, mtime=? WHERE path=?");
+			this.#stmtDelete = this.#db.prepare("DELETE FROM entries WHERE path = ?");
+			this.#stmtChildren = this.#db.prepare("SELECT * FROM entries WHERE parent_path = ?");
+			this.#stmtDescendants = this.#db.prepare("SELECT * FROM entries WHERE path LIKE ? AND path != ?");
+		}
+		get readonly() {
+			return this.#readonly;
+		}
+		get supportsWatch() {
+			return true;
+		}
+		get supportsSymlinks() {
+			return true;
+		}
+		setReadOnly() {
+			this.#readonly = true;
+		}
+		close() {
+			for (const watcher of this.#statWatchers.values()) watcher.stop();
+			this.#statWatchers.clear();
+			this.#db.close();
+		}
+		#normalizePath(path) {
+			let normalized = path.replace(/\\/g, "/");
+			if (!normalized.startsWith("/")) normalized = "/" + normalized;
+			return pathPosix.normalize(normalized);
+		}
+		#getParentPath(path) {
+			if (path === "/") return null;
+			return pathPosix.dirname(path);
+		}
+		#getBaseName(path) {
+			return pathPosix.basename(path);
+		}
+		#resolveSymlinkTarget(symlinkPath, target) {
+			if (target.startsWith("/")) return this.#normalizePath(target);
+			const parentPath = this.#getParentPath(symlinkPath) || "/";
+			return this.#normalizePath(pathPosix.join(parentPath, target));
+		}
+		#getRow(path) {
+			return this.#stmtGet.get(path);
+		}
+		#lookupEntry(path, followSymlinks = true, depth = 0) {
+			const normalized = this.#normalizePath(path);
+			if (normalized === "/") return {
+				row: this.#getRow("/"),
+				resolvedPath: "/"
+			};
+			const segments = normalized.slice(1).split("/");
+			let currentPath = "/";
+			for (let i = 0; i < segments.length; i++) {
+				const segment = segments[i];
+				const nextPath = currentPath === "/" ? "/" + segment : currentPath + "/" + segment;
+				const currentRow = this.#getRow(currentPath);
+				if (!currentRow) return {
+					row: null,
+					resolvedPath: null
+				};
+				if (currentRow.type === TYPE_SYMLINK) {
+					if (depth >= kMaxSymlinkDepth) return {
+						row: null,
+						resolvedPath: null,
+						eloop: true
+					};
+					const targetPath = this.#resolveSymlinkTarget(currentPath, currentRow.target);
+					const result = this.#lookupEntry(targetPath, true, depth + 1);
+					if (result.eloop) return result;
+					if (!result.row) return {
+						row: null,
+						resolvedPath: null
+					};
+					const remaining = segments.slice(i).join("/");
+					const fullPath = result.resolvedPath === "/" ? "/" + remaining : result.resolvedPath + "/" + remaining;
+					return this.#lookupEntry(fullPath, followSymlinks, depth + 1);
+				}
+				if (currentRow.type !== TYPE_DIR) return {
+					row: null,
+					resolvedPath: null
+				};
+				currentPath = nextPath;
+			}
+			const row = this.#getRow(currentPath);
+			if (!row) return {
+				row: null,
+				resolvedPath: null
+			};
+			if (row.type === TYPE_SYMLINK && followSymlinks) {
+				if (depth >= kMaxSymlinkDepth) return {
+					row: null,
+					resolvedPath: null,
+					eloop: true
+				};
+				const targetPath = this.#resolveSymlinkTarget(currentPath, row.target);
+				return this.#lookupEntry(targetPath, true, depth + 1);
+			}
+			return {
+				row,
+				resolvedPath: currentPath
+			};
+		}
+		#getEntry(path, syscall, followSymlinks = true) {
+			const result = this.#lookupEntry(path, followSymlinks);
+			if (result.eloop) throw createELOOP(syscall, path);
+			if (!result.row) throw createENOENT(syscall, path);
+			return result.row;
+		}
+		#ensureParent(path, create, syscall) {
+			const parentPath = this.#getParentPath(path);
+			if (parentPath === null) return this.#getRow("/");
+			const result = this.#lookupEntry(parentPath, true);
+			if (result.row) {
+				if (result.row.type !== TYPE_DIR) throw createENOTDIR(syscall, path);
+				return result.row;
+			}
+			if (create) {
+				const segments = parentPath.slice(1).split("/");
+				let currentPath = "";
+				for (const segment of segments) {
+					currentPath += "/" + segment;
+					const existing = this.#getRow(currentPath);
+					if (!existing) {
+						const now = Date.now();
+						const pp = this.#getParentPath(currentPath);
+						this.#stmtInsert.run(currentPath, pp, segment, TYPE_DIR, null, null, 493, now, now, now);
+					} else if (existing.type !== TYPE_DIR) throw createENOTDIR(syscall, path);
+				}
+				return this.#getRow(parentPath);
+			}
+			throw createENOENT(syscall, path);
+		}
+		#createStats(row, size) {
+			const options = {
+				mode: row.mode,
+				mtimeMs: row.mtime,
+				ctimeMs: row.ctime,
+				birthtimeMs: row.birthtime
+			};
+			if (row.type === TYPE_FILE) {
+				const content = row.content;
+				return createFileStats(size !== void 0 ? size : content ? content.byteLength : 0, options);
+			} else if (row.type === TYPE_DIR) return createDirectoryStats(options);
+			else if (row.type === TYPE_SYMLINK) return createSymlinkStats(row.target.length, options);
+			const { ERR_INVALID_STATE } = require_errors();
+			throw new ERR_INVALID_STATE("Unknown entry type");
+		}
+		openSync(path, flags, mode) {
+			const normalized = this.#normalizePath(path);
+			const isCreate = flags === "w" || flags === "w+" || flags === "a" || flags === "a+";
+			if (this.readonly && isCreate) throw createEROFS("open", path);
+			let row;
+			try {
+				row = this.#getEntry(normalized, "open");
+			} catch (err) {
+				if (err.code === "ENOENT" && isCreate) {
+					this.#ensureParent(normalized, true, "open");
+					const name = this.#getBaseName(normalized);
+					const parentPath = this.#getParentPath(normalized);
+					const now = Date.now();
+					const fileMode = mode ?? 420;
+					this.#stmtInsert.run(normalized, parentPath, name, TYPE_FILE, Buffer$1.alloc(0), null, fileMode, now, now, now);
+					row = this.#getRow(normalized);
+				} else throw err;
+			}
+			if (row.type === TYPE_DIR) throw createEISDIR("open", path);
+			if (row.type === TYPE_SYMLINK) throw createEINVAL("open", path);
+			const content = row.content ? Buffer$1.from(row.content) : Buffer$1.alloc(0);
+			const getStats = (size) => this.#createStats(this.#getRow(normalized) || row, size);
+			return new SqliteFileHandle(normalized, flags, mode ?? row.mode, content, this.#stmtUpdateContent, getStats);
+		}
+		async open(path, flags, mode) {
+			return this.openSync(path, flags, mode);
+		}
+		statSync(path, options) {
+			const row = this.#getEntry(path, "stat", true);
+			return this.#createStats(row);
+		}
+		async stat(path, options) {
+			return this.statSync(path, options);
+		}
+		lstatSync(path, options) {
+			const row = this.#getEntry(path, "lstat", false);
+			return this.#createStats(row);
+		}
+		async lstat(path, options) {
+			return this.lstatSync(path, options);
+		}
+		readdirSync(path, options) {
+			const result = this.#lookupEntry(path, true);
+			if (result.eloop) throw createELOOP("scandir", path);
+			if (!result.row) throw createENOENT("scandir", path);
+			if (result.row.type !== TYPE_DIR) throw createENOTDIR("scandir", path);
+			const children = this.#stmtChildren.all(result.resolvedPath);
+			if (options?.withFileTypes) {
+				const normalized = this.#normalizePath(path);
+				return children.map((child) => {
+					let type;
+					if (child.type === TYPE_SYMLINK) type = UV_DIRENT_LINK;
+					else if (child.type === TYPE_DIR) type = UV_DIRENT_DIR;
+					else type = UV_DIRENT_FILE;
+					return new VirtualDirent(child.name, type, normalized);
+				});
+			}
+			return children.map((child) => child.name);
+		}
+		async readdir(path, options) {
+			return this.readdirSync(path, options);
+		}
+		mkdirSync(path, options) {
+			if (this.readonly) throw createEROFS("mkdir", path);
+			const normalized = this.#normalizePath(path);
+			const recursive = options?.recursive === true;
+			const existing = this.#lookupEntry(normalized, true);
+			if (existing.row) {
+				if (existing.row.type === TYPE_DIR && recursive) return;
+				throw createEEXIST("mkdir", path);
+			}
+			if (recursive) {
+				const segments = normalized.slice(1).split("/");
+				let currentPath = "";
+				for (const segment of segments) {
+					currentPath += "/" + segment;
+					const row = this.#getRow(currentPath);
+					if (!row) {
+						const now = Date.now();
+						const pp = this.#getParentPath(currentPath);
+						this.#stmtInsert.run(currentPath, pp, segment, TYPE_DIR, null, null, options?.mode ?? 493, now, now, now);
+					} else if (row.type !== TYPE_DIR) throw createENOTDIR("mkdir", path);
+				}
+			} else {
+				this.#ensureParent(normalized, false, "mkdir");
+				const name = this.#getBaseName(normalized);
+				const parentPath = this.#getParentPath(normalized);
+				const now = Date.now();
+				this.#stmtInsert.run(normalized, parentPath, name, TYPE_DIR, null, null, options?.mode ?? 493, now, now, now);
+			}
+			return recursive ? normalized : void 0;
+		}
+		async mkdir(path, options) {
+			return this.mkdirSync(path, options);
+		}
+		rmdirSync(path) {
+			if (this.readonly) throw createEROFS("rmdir", path);
+			const normalized = this.#normalizePath(path);
+			if (this.#getEntry(normalized, "rmdir", true).type !== TYPE_DIR) throw createENOTDIR("rmdir", path);
+			if (this.#stmtChildren.all(normalized).length > 0) throw createENOTEMPTY("rmdir", path);
+			this.#stmtDelete.run(normalized);
+		}
+		async rmdir(path) {
+			this.rmdirSync(path);
+		}
+		unlinkSync(path) {
+			if (this.readonly) throw createEROFS("unlink", path);
+			const normalized = this.#normalizePath(path);
+			if (this.#getEntry(normalized, "unlink", false).type === TYPE_DIR) throw createEISDIR("unlink", path);
+			this.#stmtDelete.run(normalized);
+		}
+		async unlink(path) {
+			this.unlinkSync(path);
+		}
+		renameSync(oldPath, newPath) {
+			if (this.readonly) throw createEROFS("rename", oldPath);
+			const normalizedOld = this.#normalizePath(oldPath);
+			const normalizedNew = this.#normalizePath(newPath);
+			const row = this.#getEntry(normalizedOld, "rename", false);
+			this.#ensureParent(normalizedNew, true, "rename");
+			const newName = this.#getBaseName(normalizedNew);
+			const newParentPath = this.#getParentPath(normalizedNew);
+			if (row.type === TYPE_DIR) {
+				this.#db.exec("BEGIN");
+				try {
+					this.#stmtDelete.run(normalizedOld);
+					const now = Date.now();
+					this.#stmtDelete.run(normalizedNew);
+					this.#stmtInsert.run(normalizedNew, newParentPath, newName, row.type, row.content, row.target, row.mode, now, row.ctime, row.birthtime);
+					const prefix = normalizedOld + "/";
+					const descendants = this.#stmtDescendants.all(prefix + "%", normalizedOld);
+					for (const desc of descendants) {
+						const newDescPath = normalizedNew + desc.path.slice(normalizedOld.length);
+						const newDescParent = this.#getParentPath(newDescPath);
+						const descName = this.#getBaseName(newDescPath);
+						this.#stmtDelete.run(desc.path);
+						this.#stmtInsert.run(newDescPath, newDescParent, descName, desc.type, desc.content, desc.target, desc.mode, desc.mtime, desc.ctime, desc.birthtime);
+					}
+					this.#db.exec("COMMIT");
+				} catch (err) {
+					this.#db.exec("ROLLBACK");
+					throw err;
+				}
+			} else {
+				this.#stmtDelete.run(normalizedOld);
+				const now = Date.now();
+				this.#stmtDelete.run(normalizedNew);
+				this.#stmtInsert.run(normalizedNew, newParentPath, newName, row.type, row.content, row.target, row.mode, now, row.ctime, row.birthtime);
+			}
+		}
+		async rename(oldPath, newPath) {
+			this.renameSync(oldPath, newPath);
+		}
+		readlinkSync(path, options) {
+			const normalized = this.#normalizePath(path);
+			const row = this.#getEntry(normalized, "readlink", false);
+			if (row.type !== TYPE_SYMLINK) throw createEINVAL("readlink", path);
+			return row.target;
+		}
+		async readlink(path, options) {
+			return this.readlinkSync(path, options);
+		}
+		symlinkSync(target, path, type) {
+			if (this.readonly) throw createEROFS("symlink", path);
+			const normalized = this.#normalizePath(path);
+			if (this.#lookupEntry(normalized, false).row) throw createEEXIST("symlink", path);
+			this.#ensureParent(normalized, true, "symlink");
+			const name = this.#getBaseName(normalized);
+			const parentPath = this.#getParentPath(normalized);
+			const now = Date.now();
+			this.#stmtInsert.run(normalized, parentPath, name, TYPE_SYMLINK, null, target, 511, now, now, now);
+		}
+		async symlink(target, path, type) {
+			this.symlinkSync(target, path, type);
+		}
+		realpathSync(path, options) {
+			const result = this.#lookupEntry(path, true, 0);
+			if (result.eloop) throw createELOOP("realpath", path);
+			if (!result.row) throw createENOENT("realpath", path);
+			return result.resolvedPath;
+		}
+		async realpath(path, options) {
+			return this.realpathSync(path, options);
+		}
+		watch(path, options) {
+			const normalized = this.#normalizePath(path);
+			return new VFSWatcher(this, normalized, options);
+		}
+		watchAsync(path, options) {
+			const normalized = this.#normalizePath(path);
+			return new VFSWatchAsyncIterable(this, normalized, options);
+		}
+		watchFile(path, options, listener) {
+			const normalized = this.#normalizePath(path);
+			let watcher = this.#statWatchers.get(normalized);
+			if (!watcher) {
+				watcher = new VFSStatWatcher(this, normalized, options);
+				this.#statWatchers.set(normalized, watcher);
+			}
+			if (listener) watcher.addListener(listener);
+			return watcher;
+		}
+		unwatchFile(path, listener) {
+			const normalized = this.#normalizePath(path);
+			const watcher = this.#statWatchers.get(normalized);
+			if (!watcher) return;
+			if (listener) watcher.removeListener(listener);
+			else watcher.removeAllListeners("change");
+			if (watcher.hasNoListeners()) {
+				watcher.stop();
+				this.#statWatchers.delete(normalized);
+			}
+		}
+	};
+	module.exports = { SqliteProvider };
+}));
+//#endregion
+//#region src/services/vfs/createPlatformaticFsProvider.ts
+var import_vfs = (/* @__PURE__ */ __commonJSMin$1(((exports, module) => {
+	const { VirtualFileSystem } = require_file_system();
+	const { VirtualProvider } = require_provider();
+	const { MemoryProvider } = require_memory();
+	const { RealFSProvider } = require_real();
+	const { SqliteProvider } = require_sqlite();
+	/**
+	* Creates a new VirtualFileSystem instance.
+	* @param {VirtualProvider} [provider] The provider to use (defaults to MemoryProvider)
+	* @param {object} [options] Configuration options
+	* @param {boolean} [options.moduleHooks] Whether to enable require/import hooks (default: true)
+	* @param {boolean} [options.virtualCwd] Whether to enable virtual working directory
+	* @param {boolean} [options.overlay] Whether to enable overlay mode
+	* @returns {VirtualFileSystem}
+	*/
+	function create(provider, options) {
+		if (provider != null && !(provider instanceof VirtualProvider) && typeof provider === "object") {
+			options = provider;
+			provider = void 0;
+		}
+		return new VirtualFileSystem(provider, options);
+	}
+	module.exports = {
+		create,
+		VirtualFileSystem,
+		VirtualProvider,
+		MemoryProvider,
+		RealFSProvider,
+		SqliteProvider
+	};
+})))();
+const createPlatformaticFsProvider = ({ isOverlayEnabled = false } = {}) => {
+	const vfs = (0, import_vfs.create)({
+		moduleHooks: true,
+		overlay: isOverlayEnabled
+	});
+	return {
+		dispose: () => {
+			if (vfs.mounted) vfs.unmount();
+		},
+		exists: (path) => vfs.existsSync(path),
+		mkdir: (path) => {
+			vfs.mkdirSync(path, { recursive: true });
+		},
+		mount: (prefix) => {
+			vfs.mount(prefix);
+		},
+		name: "platformatic",
+		readFile: (path) => vfs.readFileSync(path, "utf8"),
+		unmount: () => {
+			vfs.unmount();
+		},
+		writeFile: (path, data) => {
+			vfs.writeFileSync(path, data);
 		}
 	};
 };
 //#endregion
-//#region src/services/exec/runNodeInProcess.ts
+//#region src/services/exec/vfs/runNodeInProcess.ts
 const runNodeInProcess = ({ code, file }, { cwd, stdio }) => {
 	const originalStdoutWrite = process$1.stdout.write.bind(process$1.stdout);
 	const originalStderrWrite = process$1.stderr.write.bind(process$1.stderr);
@@ -18854,7 +23178,7 @@ const runNodeInProcess = ({ code, file }, { cwd, stdio }) => {
 	const originalRequire = globalThis.require;
 	const originalCwd = cwd === "" ? "" : process$1.cwd();
 	const baseDir = cwd === "" ? process$1.cwd() : cwd;
-	const fs = createPlatformaticFsProvider({ overlay: true });
+	const fs = createPlatformaticFsProvider({ isOverlayEnabled: true });
 	const isPipe = stdio === "pipe";
 	const require = createRequire(resolve(baseDir, "[eval].js"));
 	const cachedBefore = new Set(Object.keys(require.cache));
@@ -18899,7 +23223,7 @@ const runNodeInProcess = ({ code, file }, { cwd, stdio }) => {
 	});
 };
 //#endregion
-//#region src/services/exec/createVfsBackend.ts
+//#region src/services/exec/vfs/createVfsBackend.ts
 const createVfsBackend = () => {
 	const native = createNativeBackend();
 	return {
@@ -18921,7 +23245,7 @@ const loadDirSource = (source) => Promise.resolve({
 //#endregion
 //#region src/services/source/loadFilesSource.ts
 const loadFilesSource = async (source) => {
-	const cwd = await mkdtemp(join(tmpdir(), "sandbox-"));
+	const cwd = await mkdtemp(join(tmpdir(), VIRRUN_TEMP_DIR_PREFIX));
 	const dispose = () => rm(cwd, {
 		force: true,
 		recursive: true
@@ -18999,21 +23323,28 @@ const backendFactories = {
 	["os"]: createOsBackend,
 	["vfs"]: createVfsBackend
 };
-const createVirrun = async (options = {}) => {
-	const { backend = "auto", source = {
-		dir: "",
-		type: "dir"
-	} } = options;
+const createVirrun = async ({ backend = "auto", source = {
+	dir: "",
+	type: "dir"
+} } = {}) => {
 	const execBackend = backendFactories[backend]();
 	const { cwd, dispose } = await loadSource(source);
+	const sharedPackageStoreOptions = execBackend.name === "os" ? createSharedPackageStoreOptions(cwd) : {};
+	const toOptions = (stdio) => ({
+		...sharedPackageStoreOptions,
+		cwd,
+		stdio
+	});
 	return {
 		backend: execBackend.name,
 		dispose,
-		exec: (command, stdio = "pipe") => execBackend.exec(command, {
-			cwd,
-			stdio
-		})
+		exec: (command, stdio = "pipe") => execBackend.exec(command, toOptions(stdio)),
+		fork: async (command, stdio = "pipe") => {
+			if (execBackend.name !== "os") return execBackend.exec(command, toOptions(stdio));
+			if (!resolveSnapshotLocation(cwd).exists) await createSnapshot(execBackend, command, toOptions(stdio));
+			return forkSnapshot(execBackend, command, toOptions(stdio));
+		}
 	};
 };
 //#endregion
-export { createNativeBackend as _, loadDirSource as a, SourceType as b, createPlatformaticFsProvider as c, tokenizeShellCommand as d, createOsBackend as f, buildBwrapArgs as g, withFinalizerAsync as h, loadFilesSource as i, ExitSignalError as l, isOsBackendSupported as m, loadSource as n, createVfsBackend as o, parseBwrapExitCode as p, loadGitSource as r, runNodeInProcess as s, createVirrun as t, parseNodeInvocation as u, toExitCode as v, BackendType as y };
+export { VIRRUN_SNAPSHOT_WORK_DIRECTORY_NAME as $, parseBwrapExitCode as A, GITIGNORE_FILENAME as B, createWslBwrapArgs as C, parseBwrapStderrStatus as D, createBwrapBackend as E, resolveCwd as F, VIRRUN_CACHE_DIRECTORY_NAME as G, PNPM_CONFIG_PACKAGE_IMPORT_METHOD_VALUE as H, parseVirrunConfiguration as I, VIRRUN_COREPACK_STORE_DIRECTORY_NAME as J, VIRRUN_CACHE_HOME_KEY as K, resolveCommandBackend as L, toExitCode as M, SourceType as N, WSL_BWRAP_STATUS_BEGIN as O, resolveVirrunConfiguration as P, VIRRUN_SNAPSHOT_UPPER_DIRECTORY_NAME as Q, isOsBackendSupported as R, createWslEnvArgs as S, createLinuxOsBackend as T, PNPM_CONFIG_STORE_DIR_KEY as U, PNPM_CONFIG_PACKAGE_IMPORT_METHOD_KEY as V, PNPM_LOCKFILE_FILENAME as W, VIRRUN_PNPM_STORE_DIRECTORY_NAME as X, VIRRUN_GITIGNORE_ENTRY as Y, VIRRUN_SNAPSHOTS_DIRECTORY_NAME as Z, getGlobalCacheDirectory as _, loadDirSource as a, BackendType as at, createOsBackend as b, createPlatformaticFsProvider as c, tokenizeShellCommand as d, VIRRUN_STORE_DIRECTORY_NAME as et, createSharedPackageStoreOptions as f, resolveSnapshotLocation as g, createSnapshot as h, loadFilesSource as i, matchesRoute as it, createNativeBackend as j, WSL_BWRAP_STATUS_END as k, ExitSignalError as l, forkSnapshot as m, loadSource as n, buildBwrapArgs as nt, createVfsBackend as o, parseCliCommand as ot, getRepoCacheDirectory as p, VIRRUN_CONFIGURATION_FILENAME as q, loadGitSource as r, withFinalizerAsync as rt, runNodeInProcess as s, createVirrun as t, VIRRUN_TEMP_DIR_PREFIX as tt, parseNodeInvocation as u, computeLockfileHash as v, readWslPath as w, createWslOsBackend as x, removeSnapshotLocation as y, COREPACK_HOME_KEY as z };