@powerlines/engine 0.15.0 → 0.15.2

package/dist/execution-context-D_CXpe9I.mjs

@@ -1,2570 +0,0 @@
-import { t as PowerlinesBaseContext } from "./base-context-BUnL_9z8.mjs";
-import { a as FileSystem } from "./fs-D1nIP45P.mjs";
-import { n as FileSystemStorageAdapter, t as VirtualStorageAdapter } from "./virtual-gIlTc3Lj.mjs";
-import { i as getTsconfigFilePath } from "./tsconfig-Cstsoprg.mjs";
-import { CACHE_HASH_LENGTH, DEFAULT_ENVIRONMENT, GLOBAL_ENVIRONMENT, PLUGIN_NON_HOOK_FIELDS, ROOT_HASH_LENGTH } from "@powerlines/core/constants";
-import { getResolutionCombinations, resolve, resolvePackage, resolveSync } from "@stryke/fs/resolve";
-import { joinPaths } from "@stryke/path/join";
-import { LogLevelLabel } from "@storm-software/config-tools/types";
-import { isSet } from "@stryke/type-checks/is-set";
-import { isString } from "@stryke/type-checks/is-string";
-import { colorText, createLog, extendLog } from "@powerlines/core/lib/logger";
-import { isNull } from "@stryke/type-checks/is-null";
-import chalk from "chalk";
-import defu, { createDefu, defu as defu$1 } from "defu";
-import { joinPaths as joinPaths$1 } from "@stryke/path/join-paths";
-import { titleCase } from "@stryke/string-format/title-case";
-import { isSetObject } from "@stryke/type-checks/is-set-object";
-import { format } from "@powerlines/core/lib/utilities/format";
-import { addPluginHook, dedupeHooklist, isDuplicate, isPlugin, isPluginConfig, isPluginHook, isPluginHookField, mergeConfig, replacePathTokens } from "@powerlines/core/plugin-utils";
-import { toArray } from "@stryke/convert/to-array";
-import { existsSync } from "@stryke/fs/exists";
-import { getUnique, getUniqueBy } from "@stryke/helpers/get-unique";
-import { omit } from "@stryke/helpers/omit";
-import { appendPath } from "@stryke/path/append";
-import { findFileDotExtensionSafe, findFileExtensionSafe, findFileName, findFilePath, hasFileExtension } from "@stryke/path/file-path-fns";
-import { isParentPath } from "@stryke/path/is-parent-path";
-import { replaceExtension, replacePath } from "@stryke/path/replace";
-import { isFunction } from "@stryke/type-checks/is-function";
-import { isObject } from "@stryke/type-checks/is-object";
-import { isSetString } from "@stryke/type-checks/is-set-string";
-import { readJsonFile } from "@stryke/fs/json";
-import { deepClone } from "@stryke/helpers/deep-clone";
-import { getUniqueInputs, isTypeDefinition, resolveInputsSync } from "@powerlines/core/lib/entry";
-import { relativeToWorkspaceRoot } from "@stryke/fs/get-workspace-root";
-import { murmurhash } from "@stryke/hash";
-import { hashDirectory } from "@stryke/hash/node";
-import { fetchRequest } from "@stryke/http/fetch";
-import { kebabCase } from "@stryke/string-format/kebab-case";
-import { uuid } from "@stryke/unique-id/uuid";
-import { match, tsconfigPathsToRegExp } from "bundle-require";
-import { resolveCompatibilityDates } from "compatx";
-import { create } from "flat-cache";
-import { parse } from "oxc-parser";
-import { Agent, Response, interceptors, setGlobalDispatcher } from "undici";
-import "@stryke/fs/remove-file";
-import * as capnp from "@stryke/capnp";
-import { readFileBuffer, readFileBufferSync, writeFileBuffer } from "@stryke/fs/buffer";
-import { correctPath, stripStars } from "@stryke/path/correct-path";
-import { globToRegex } from "@stryke/path/glob-to-regex";
-import { isAbsolutePath } from "@stryke/path/is-type";
-import { slash } from "@stryke/path/slash";
-import { prettyBytes } from "@stryke/string-format/pretty-bytes";
-import { isRegExp } from "@stryke/type-checks/is-regexp";
-import { Blob } from "node:buffer";
-import { fileURLToPath } from "node:url";
-import { getField } from "@stryke/helpers/get-field";
-
-//#region src/_internal/helpers/environment.ts
-function createEnvironment(name, config = {}) {
-	return defu(config.environments?.[name] ?? {}, {
-		name,
-		title: config.title ?? titleCase(config.name),
-		ssr: false,
-		resolve: { mainFields: config.platform === "browser" ? [
-			"browser",
-			"module",
-			"jsnext:main",
-			"jsnext"
-		] : [
-			"module",
-			"jsnext:main",
-			"jsnext"
-		] },
-		consumer: config.platform === "browser" ? "client" : "server",
-		preview: config.platform === "browser" ? {
-			port: 5173,
-			open: true,
-			strictPort: false,
-			host: "localhost",
-			allowedHosts: ["."],
-			cors: true,
-			headers: {}
-		} : void 0
-	});
-}
-function createDefaultEnvironment(config = {}) {
-	return createEnvironment(DEFAULT_ENVIRONMENT, config);
-}
-
-//#endregion
-//#region src/_internal/helpers/context.ts
-function getConfigProps(config = {}, root, cwd) {
-	return {
-		name: config.name,
-		title: config.title,
-		description: config.description,
-		projectType: config.projectType,
-		customLogger: config.customLogger,
-		logLevel: config.logLevel,
-		tsconfig: config.tsconfig,
-		tsconfigRaw: config.tsconfigRaw,
-		skipCache: config.skipCache,
-		autoInstall: config.autoInstall,
-		input: isSetString(config.input) ? [config.input] : config.input,
-		plugins: config.plugins,
-		mode: config.mode,
-		resolve: config.resolve,
-		framework: config.framework,
-		...config,
-		output: {
-			...config.output ?? {},
-			path: config.output?.path ? appendPath(config.output.path, appendPath(root, cwd)) : void 0
-		}
-	};
-}
-
-//#endregion
-//#region src/_internal/helpers/meta.ts
-/**
-* Generates a prefixed project root hash object.
-*
-* @remarks
-* This function returns a string where the project root hash is prefixed with the project name plus a hyphen. If the total length of this string combination exceeds 45 characters, it will truncate the hash.
-*
-* @param name - The name of the project.
-* @param rootHash - The hash of the project root.
-* @returns An object containing the name and project root hash.
-*/
-function getPrefixedRootHash(name, rootHash) {
-	const combined = `${kebabCase(name)}_${rootHash}`;
-	return combined.length > ROOT_HASH_LENGTH ? combined.slice(0, ROOT_HASH_LENGTH) : combined;
-}
-/**
-* Writes the meta file for the context.
-*
-* @param context - The context to write the meta file for.
-* @returns A promise that resolves when the meta file has been written.
-*/
-async function writeMetaFile(context) {
-	const metaFilePath = joinPaths$1(context.dataPath, "meta.json");
-	context.debug(`Writing runtime metadata to ${metaFilePath}`);
-	await context.fs.write(metaFilePath, JSON.stringify(context.meta, null, 2));
-}
-
-//#endregion
-//#region src/_internal/helpers/constants.ts
-const DEFAULT_EXTENSIONS = [
-	"js",
-	"ts",
-	"cjs",
-	"cts",
-	"mjs",
-	"mts",
-	"tsx",
-	"jsx",
-	"json",
-	"json5",
-	"jsonc",
-	"md",
-	"mdx"
-];
-
-//#endregion
-//#region src/_internal/vfs.ts
-function toFilePath(path) {
-	return correctPath(slash(path?.toString() || ".").replace(/^file:\/\//, ""));
-}
-/**
-* Checks if a given file id is valid based on the specified prefix.
-*
-* @param id - The file ID to check.
-* @param prefix - The prefix to use for built-in files. Default is "powerlines".
-* @returns `true` if the file ID is valid, otherwise `false`.
-*/
-function isValidId(id, prefix = "powerlines") {
-	return id.replace(/^\\0/, "").startsWith(`${prefix.replace(/:$/, "")}`);
-}
-/**
-* Formats a file id by removing the file extension and prepended runtime prefix.
-*
-* @param id - The file ID to format.
-* @param prefix - The prefix to use for built-in files. Default is "powerlines".
-* @returns The formatted file ID.
-*/
-function normalizeId(id, prefix = "powerlines") {
-	return replaceExtension(toFilePath(id)).replace(/^\\0/, "").replace(/^powerlines:/, "").replace(new RegExp(`^${prefix.replace(/:$/, "")}:`), "");
-}
-/**
-* Normalizes a given path by resolving it against the project root, workspace root, and built-ins path.
-*
-* @param path - The path to normalize.
-* @param builtinsPath - The path to built-in files.
-* @param prefix - The prefix to use for built-in files. Default is "powerlines".
-* @returns The normalized path.
-*/
-function normalizePath(path, builtinsPath, prefix = "powerlines") {
-	if (!isSetString(path)) {
-		if (!isString(path)) throw new Error("Path type must be a string or a file descriptor");
-		throw new Error("Path cannot be empty");
-	}
-	return isAbsolutePath(path) ? path : isValidId(toFilePath(path), prefix) ? normalizeId(toFilePath(path), prefix).replace(new RegExp(`^${prefix.replace(/:$/, "")}:`), builtinsPath) : toFilePath(path);
-}
-/**
-* Normalizes glob patterns by resolving them against the workspace root.
-*
-* @param workspaceRoot - The root directory of the workspace.
-* @param patterns - The glob patterns to normalize.
-* @returns An array of normalized glob patterns.
-*/
-function normalizeGlobPatterns(workspaceRoot, patterns) {
-	return getUnique(toArray(patterns).map((pattern) => {
-		if (isSetObject(pattern) && (isSetString(pattern.input) || isSetString(pattern.glob))) return joinPaths(pattern.input || workspaceRoot, pattern.glob || "**/*");
-		else if (!isSetString(pattern)) return;
-		return pattern;
-	}).filter(isSetString));
-}
-/**
-* Represents a virtual file system (VFS) that stores files and their associated metadata in virtual memory.
-*
-* @remarks
-* This class provides methods to manage virtual files, check their existence, retrieve their content, and manipulate the virtual file system. It allows for efficient file management and retrieval without relying on the actual file system.
-*/
-var VirtualFileSystem = class VirtualFileSystem {
-	/**
-	* A map of virtual file IDs to their associated metadata.
-	*/
-	#metadata;
-	/**
-	* A map of underlying file paths to their virtual file IDs.
-	*/
-	#ids;
-	/**
-	* A map of virtual file IDs to their underlying file paths.
-	*/
-	#paths;
-	/**
-	* The unified volume that combines the virtual file system with the real file system.
-	*
-	* @remarks
-	* This volume allows for seamless access to both virtual and real files.
-	*/
-	#storage;
-	/**
-	* A cache for module resolution results.
-	*/
-	#resolverCache;
-	/**
-	* Indicator specifying if the virtual file system (VFS) is disposed
-	*/
-	#isDisposed = false;
-	/**
-	* The context of the virtual file system.
-	*/
-	#context;
-	/**
-	* The file system's logging function.
-	*/
-	#log;
-	/**
-	* Normalizes a given module id by resolving it against the built-ins path.
-	*
-	* @param id - The module id to normalize.
-	* @returns The normalized module id.
-	*/
-	#normalizeId(id) {
-		let normalized = id;
-		if (isParentPath(normalized, this.#context.builtinsPath)) normalized = replacePath(normalized, this.#context.builtinsPath);
-		return normalizeId(normalized, this.#context.config.framework);
-	}
-	/**
-	* Normalizes a given path by resolving it against the project root, workspace root, and built-ins path.
-	*
-	* @param path - The path to normalize.
-	* @returns The normalized path.
-	*/
-	#normalizePath(path) {
-		if (!isSetString(path)) {
-			if (!isString(path)) throw new Error("Path type must be a string or a file descriptor");
-			throw new Error("Path cannot be empty");
-		}
-		return normalizePath(path.includes("{") || path.includes("}") ? replacePathTokens(this.#context, path) : path, this.#context.builtinsPath, this.#context.config.framework);
-	}
-	/**
-	* Gets the storage adapter and relative key for a given key.
-	*
-	* @remarks
-	* The `key` can be either a path or a storage adapter name.
-	*
-	* @param key - The key to get the storage adapter for.
-	* @returns The storage adapter and relative key for the given key.
-	*/
-	#getStorage(key, preset) {
-		const path = this.resolveSync(this.#normalizePath(key)) || key;
-		for (const base of Object.keys(this.#storage).filter(Boolean).sort().reverse()) if ((path === base || isParentPath(path, base)) && (!preset || this.#storage[base]?.preset?.toLowerCase() === preset.toLowerCase())) return {
-			base,
-			relativeKey: replacePath(path, base),
-			adapter: this.#storage[base]
-		};
-		if (!preset || this.#storage[""]?.preset?.toLowerCase() === preset.toLowerCase()) return {
-			base: "",
-			relativeKey: path,
-			adapter: this.#storage[""]
-		};
-		this.#storage[path] = preset === "virtual" ? new VirtualStorageAdapter(this.#context, { base: path }) : new FileSystemStorageAdapter(this.#context, { base: path });
-		return {
-			base: path,
-			relativeKey: "",
-			adapter: this.#storage[path]
-		};
-	}
-	/**
-	* Gets all storage adapters that match a given base key.
-	*
-	* @param base - The base key to match storage adapters against.
-	* @param includeParent - Whether to include parent storage adapters.
-	* @returns An array of storage adapters that match the given base key.
-	*/
-	#getStorages(base = "", includeParent = false) {
-		const baseKey = this.resolveSync(base) || base;
-		return Object.keys(this.#storage).sort().reverse().filter((key) => isParentPath(key, baseKey) || includeParent && isParentPath(baseKey, key) || baseKey.includes("*") && (isParentPath(stripStars(baseKey), key) || globToRegex(replaceExtension(baseKey)).test(key))).map((key) => ({
-			relativeBase: baseKey.length > key.length ? baseKey.slice(key.length) : void 0,
-			base: key,
-			adapter: this.#storage[key]
-		}));
-	}
-	/**
-	* A helper function to resolve modules in the virtual file system (VFS).
-	*
-	* @remarks
-	* This function can be used to resolve modules relative to the project root directory.
-	*
-	* @example
-	* ```ts
-	* const resolved = await context.resolvePath("some-module", "/path/to/importer");
-	* ```
-	*
-	* @param id - The module to resolve.
-	* @param importer - An optional path to the importer module.
-	* @param options - Additional resolution options.
-	* @returns A promise that resolves to the resolved module path.
-	*/
-	#innerResolve = async (id, importer, options = {}) => {
-		let path = id;
-		if (path.includes("{") || path.includes("}")) path = replacePathTokens(this.#context, path);
-		if (options.skipAlias !== true) path = this.resolveAlias(path);
-		if (isAbsolutePath(path) && (!options.isFile || !await this.isDirectory(path))) return path;
-		const resolverCacheKey = murmurhash({
-			path: this.#normalizeId(path),
-			importer,
-			options
-		});
-		let result;
-		if (!this.#context.config.skipCache) {
-			result = this.resolverCache.get(resolverCacheKey);
-			if (result) return result;
-		}
-		result = this.paths[this.#normalizeId(path)];
-		if (!isSetString(result)) {
-			const paths = options.paths ?? [];
-			if (importer && !paths.includes(importer)) paths.push(importer);
-			if (!importer) {
-				paths.push(this.#context.config.cwd);
-				paths.push(appendPath(this.#context.config.root, this.#context.config.cwd));
-				paths.push(appendPath(joinPaths(this.#context.config.root, "src"), this.#context.config.cwd));
-			}
-			paths.push(...Object.keys(this.#context.tsconfig?.options?.paths ?? {}).filter((tsconfigPath) => path.startsWith(tsconfigPath.replace(/\*$/, ""))).map((tsconfigPath) => this.#context.tsconfig?.options?.paths?.[tsconfigPath]).flat().filter(Boolean).map((tsconfigPath) => appendPath(tsconfigPath, this.#context.config.cwd)));
-			for (const combination of getResolutionCombinations(path, { paths: getUnique(paths) })) {
-				const { relativeKey, adapter } = this.#getStorage(combination);
-				if (await adapter.exists(relativeKey)) {
-					result = combination;
-					break;
-				}
-			}
-			if (!isSetString(result)) try {
-				result = await resolve(path, {
-					...options,
-					paths
-				});
-			} catch {}
-		}
-		if (isSetString(result)) {
-			if (!this.#context.config.skipCache) this.resolverCache.set(this.#normalizeId(path), result);
-			return result;
-		}
-	};
-	/**
-	* A synchronous helper function to resolve modules using the Jiti resolver
-	*
-	* @remarks
-	* This function can be used to resolve modules relative to the project root directory.
-	*
-	* @example
-	* ```ts
-	* const resolvedPath = context.resolveSync("some-module", "/path/to/importer");
-	* ```
-	*
-	* @param id - The module to resolve.
-	* @param importer - An optional path to the importer module.
-	* @param options - Additional resolution options.
-	* @returns The resolved module path.
-	*/
-	#innerResolveSync = (id, importer, options = {}) => {
-		let path = id;
-		if (path.includes("{") || path.includes("}")) path = replacePathTokens(this.#context, path);
-		if (options.skipAlias !== true) path = this.resolveAlias(path);
-		if (isAbsolutePath(path) && (!options.isFile || !this.isDirectorySync(path))) return path;
-		let result;
-		if (!this.#context.config.skipCache) {
-			result = this.resolverCache.get(this.#normalizeId(path));
-			if (isSetString(result)) return result;
-		}
-		result = this.paths[this.#normalizeId(path)];
-		if (!isSetString(result)) {
-			const paths = options.paths ?? [];
-			if (importer && !paths.includes(importer)) paths.push(importer);
-			if (!importer) {
-				paths.push(this.#context.config.cwd);
-				paths.push(appendPath(this.#context.config.root, this.#context.config.cwd));
-				paths.push(appendPath(joinPaths(this.#context.config.root, "src"), this.#context.config.cwd));
-			}
-			paths.push(...Object.keys(this.#context.tsconfig?.options?.paths ?? {}).filter((tsconfigPath) => path.startsWith(tsconfigPath.replace(/\*$/, ""))).map((tsconfigPath) => this.#context.tsconfig?.options?.paths?.[tsconfigPath]).flat().filter(Boolean).map((tsconfigPath) => appendPath(tsconfigPath, this.#context.config.cwd)));
-			for (const combination of getResolutionCombinations(path, { paths })) {
-				const { relativeKey, adapter } = this.#getStorage(combination);
-				if (adapter.existsSync(relativeKey)) {
-					result = combination;
-					break;
-				}
-			}
-			if (!isSetString(result)) try {
-				result = resolveSync(path, {
-					...options,
-					paths
-				});
-			} catch {}
-		}
-		if (isSetString(result)) {
-			if (!this.#context.config.skipCache) this.resolverCache.set(this.#normalizeId(path), result);
-			return result;
-		}
-	};
-	/**
-	* Creates a virtual file system (VFS) that is backed up to a Cap'n Proto message buffer.
-	*
-	* @param context - The context of the virtual file system, typically containing options and logging functions.
-	* @returns A promise that resolves to a new virtual file system instance.
-	*/
-	static async create(context) {
-		context.debug("Starting virtual file system (VFS) initialization processes...");
-		let result;
-		if (!context.config.skipCache && existsSync(joinPaths(context.dataPath, "fs.bin"))) {
-			const buffer = await readFileBuffer(joinPaths(context.dataPath, "fs.bin"));
-			const fs = new capnp.Message(buffer, false).getRoot(FileSystem);
-			result = new VirtualFileSystem(context, fs);
-			if (fs._hasStorage() && fs.storage.length > 0) await Promise.all(fs.storage.values().map(async (file) => {
-				if (file.path && file.code) {
-					let id;
-					if (fs._hasIds()) id = fs.ids.find((fileId) => fileId.path === file.path);
-					let metadata;
-					if (fs._hasMetadata()) metadata = fs.metadata.find((meta) => meta.id === result.#normalizeId(id?.id ?? file.path));
-					await result.write(file.path, file.code, { meta: {
-						id: result.#normalizeId(id?.id ?? metadata?.id ?? file.path),
-						type: metadata?.type || "normal",
-						properties: metadata?._hasProperties() ? metadata?.properties.values().reduce((ret, kvp) => {
-							ret[kvp.key] = kvp.value;
-							return ret;
-						}, {}) : void 0,
-						timestamp: metadata?.timestamp
-					} });
-				}
-			}));
-		} else result = new VirtualFileSystem(context, new capnp.Message().initRoot(FileSystem));
-		result.#log(LogLevelLabel.DEBUG, "Successfully completed virtual file system (VFS) initialization.");
-		return result;
-	}
-	/**
-	* Synchronously creates a virtual file system (VFS) that is backed up to a Cap'n Proto message buffer.
-	*
-	* @param context - The context of the virtual file system, typically containing options and logging functions.
-	* @returns A new virtual file system instance.
-	*/
-	static createSync(context) {
-		context.debug("Starting virtual file system (VFS) initialization processes...");
-		let result;
-		if (!context.config.skipCache && existsSync(joinPaths(context.dataPath, "fs.bin"))) {
-			const buffer = readFileBufferSync(joinPaths(context.dataPath, "fs.bin"));
-			const fs = new capnp.Message(buffer, false).getRoot(FileSystem);
-			result = new VirtualFileSystem(context, fs);
-			if (fs._hasStorage() && fs.storage.length > 0) fs.storage.values().forEach((file) => {
-				if (file.path && file.code) {
-					let id;
-					if (fs._hasIds()) id = fs.ids.find((fileId) => fileId.path === file.path);
-					let metadata;
-					if (fs._hasMetadata()) metadata = fs.metadata.find((meta) => meta.id === result.#normalizeId(id?.id ?? file.path));
-					result.writeSync(file.path, file.code, { meta: {
-						id: result.#normalizeId(id?.id ?? metadata?.id ?? file.path),
-						type: metadata?.type,
-						properties: metadata?._hasProperties() ? metadata?.properties.values().reduce((ret, kvp) => {
-							ret[kvp.key] = kvp.value;
-							return ret;
-						}, {}) : void 0,
-						timestamp: metadata?.timestamp
-					} });
-				}
-			});
-		} else result = new VirtualFileSystem(context, new capnp.Message().initRoot(FileSystem));
-		result.#log(LogLevelLabel.DEBUG, "Successfully completed virtual file system (VFS) initialization.");
-		return result;
-	}
-	/**
-	* A map of file ids to their metadata.
-	*/
-	get metadata() {
-		return new Proxy(this.#metadata, {
-			get: (target, prop) => {
-				return target[this.#normalizeId(prop)];
-			},
-			set: (target, prop, value) => {
-				target[this.#normalizeId(prop)] = value;
-				return true;
-			},
-			deleteProperty: (target, prop) => {
-				delete target[this.#normalizeId(prop)];
-				return true;
-			},
-			has: (target, prop) => {
-				return this.#normalizeId(prop) in target;
-			},
-			ownKeys: (target) => {
-				return getUnique(Reflect.ownKeys(target).map((key) => this.#normalizeId(key)));
-			}
-		});
-	}
-	/**
-	* A map of file paths to their module ids.
-	*/
-	get ids() {
-		return new Proxy(this.#ids, {
-			get: (target, prop) => {
-				return target[this.#normalizePath(prop)];
-			},
-			set: (target, prop, value) => {
-				target[this.#normalizePath(prop)] = value;
-				return true;
-			},
-			deleteProperty: (target, prop) => {
-				delete target[this.#normalizePath(prop)];
-				return true;
-			},
-			has: (target, prop) => {
-				return this.#normalizePath(prop) in target;
-			},
-			ownKeys: (target) => {
-				return getUnique(Reflect.ownKeys(target).map((key) => this.#normalizePath(key)));
-			}
-		});
-	}
-	/**
-	* A map of module ids to their file paths.
-	*/
-	get paths() {
-		return new Proxy(this.#paths, {
-			get: (target, prop) => {
-				return this.#normalizeId(prop) in target ? target[this.#normalizeId(prop)] : void 0;
-			},
-			set: (target, prop, value) => {
-				target[this.#normalizeId(prop)] = value;
-				return true;
-			},
-			deleteProperty: (target, prop) => {
-				delete target[this.#normalizeId(prop)];
-				return true;
-			},
-			has: (target, prop) => {
-				return this.#normalizeId(prop) in target;
-			},
-			ownKeys: (target) => {
-				return getUnique(Reflect.ownKeys(target).map((key) => this.#normalizeId(key)));
-			}
-		});
-	}
-	/**
-	* Gets the resolver cache.
-	*/
-	get resolverCache() {
-		if (!this.#resolverCache) this.#resolverCache = create({
-			cacheId: "module-resolution",
-			cacheDir: this.#context.cachePath,
-			ttl: 2.5 * 60 * 1e3,
-			lruSize: 8e3,
-			persistInterval: 100
-		});
-		return this.#resolverCache;
-	}
-	/**
-	* Creates a new instance of the {@link VirtualFileSystem}.
-	*
-	* @param context - The context of the virtual file system, typically containing options and logging functions.
-	* @param fs - A buffer containing the serialized virtual file system data.
-	*/
-	constructor(context, fs) {
-		this.#context = context;
-		this.#storage = { "": new FileSystemStorageAdapter(context) };
-		if (isSetObject(this.#context.config.output.storage)) this.#storage = {
-			...this.#storage,
-			...this.#context.config.output.storage
-		};
-		this.#storage.virtual ??= new VirtualStorageAdapter(context, { base: "/_virtual" });
-		this.#storage[this.#context.config.output.path] ??= new FileSystemStorageAdapter(context, { base: this.#context.config.output.path });
-		if (this.#context.config.output.copy && this.#context.config.output.copy.path) this.#storage[this.#context.config.output.copy.path] ??= new FileSystemStorageAdapter(context, { base: this.#context.config.output.copy.path });
-		if (this.#context.config.output.storage !== "fs") {
-			this.#storage[this.#context.artifactsPath] ??= new VirtualStorageAdapter(context, { base: this.#context.artifactsPath });
-			this.#storage[this.#context.builtinsPath] ??= new VirtualStorageAdapter(context, { base: this.#context.builtinsPath });
-			this.#storage[this.#context.entryPath] ??= new VirtualStorageAdapter(context, { base: this.#context.entryPath });
-		}
-		this.#metadata = {};
-		if (fs._hasMetadata()) this.#metadata = fs.metadata.values().reduce((ret, metadata) => {
-			ret[metadata.id] = {
-				id: metadata.id,
-				type: metadata.type,
-				timestamp: metadata.timestamp ?? Date.now(),
-				properties: metadata._hasProperties() ? metadata.properties.values().reduce((ret, item) => {
-					ret[item.key] = item.value;
-					return ret;
-				}, {}) : {}
-			};
-			return ret;
-		}, {});
-		this.#ids = {};
-		this.#paths = {};
-		if (fs._hasIds()) {
-			this.#ids = fs.ids.values().reduce((ret, identifier) => {
-				ret[identifier.path] ??= identifier.id;
-				return ret;
-			}, {});
-			this.#paths = fs.ids.values().reduce((ret, identifier) => {
-				ret[identifier.id] ??= identifier.path;
-				return ret;
-			}, {});
-		}
-		this.#log = extendLog(this.#context.log, "file-system");
-	}
-	/**
-	* Asynchronously checks if a file exists in the virtual file system (VFS).
-	*
-	* @param path - The path to the file.
-	* @returns A promise that resolves to `true` if the file exists, otherwise `false`.
-	*/
-	async exists(path) {
-		const { relativeKey, adapter } = this.#getStorage(path);
-		return adapter.exists(relativeKey);
-	}
-	/**
-	* Synchronously checks if a file exists in the virtual file system (VFS).
-	*
-	* @param path - The path to the file.
-	* @returns `true` if the file exists, otherwise `false`.
-	*/
-	existsSync(path) {
-		const { relativeKey, adapter } = this.#getStorage(path);
-		return adapter.existsSync(relativeKey);
-	}
-	/**
-	* Checks if a file is virtual in the virtual file system (VFS).
-	*
-	* @param path - The path to the file.
-	* @param importer - An optional path to the importer module.
-	* @param options - Additional resolution options.
-	* @returns `true` if the file is virtual, otherwise `false`.
-	*/
-	isVirtual(path, importer, options) {
-		const resolved = this.resolveSync(path, importer, options);
-		if (!isSetString(resolved)) {
-			if (isSet(resolved)) throw new Error(`Resolved path is not a string: ${String(resolved)}`);
-			return false;
-		}
-		return this.#getStorage(resolved)?.adapter?.preset === "virtual" || resolved.startsWith(`${this.#context.config.framework}:`) || path.startsWith(`${this.#context.config.framework}:`);
-	}
-	/**
-	* Checks if a path is a directory in the virtual file system (VFS).
-	*
-	* @param path - The path to check.
-	* @param importer - An optional path to the importer module.
-	* @param options - Additional resolution options.
-	* @returns `true` if the path is a directory, otherwise `false`.
-	*/
-	isDirectorySync(path, importer, options) {
-		const resolved = this.resolveSync(path, importer, options);
-		if (!isSetString(resolved)) {
-			if (isSet(resolved)) throw new Error(`Resolved path is not a string: ${String(resolved)}`);
-			return false;
-		}
-		return !!(this.existsSync(resolved) && this.#getStorage(resolved)?.adapter?.isDirectorySync(resolved));
-	}
-	/**
-	* Checks if a path is a directory in the virtual file system (VFS).
-	*
-	* @param path - The path to check.
-	* @param importer - An optional path to the importer module.
-	* @param options - Additional resolution options.
-	* @returns `true` if the path is a directory, otherwise `false`.
-	*/
-	async isDirectory(path, importer, options) {
-		const resolved = await this.resolve(path, importer, options);
-		if (!isSetString(resolved)) {
-			if (isSet(resolved)) throw new Error(`Resolved path is not a string: ${String(resolved)}`);
-			return false;
-		}
-		return !!(await this.exists(resolved) && await this.#getStorage(resolved)?.adapter?.isDirectory(resolved));
-	}
-	/**
-	* Checks if a path is a file in the virtual file system (VFS).
-	*
-	* @param path - The path to check.
-	* @param importer - An optional path to the importer module.
-	* @param options - Additional resolution options.
-	* @returns `true` if the path is a file, otherwise `false`.
-	*/
-	isFileSync(path, importer, options) {
-		const resolved = this.resolveSync(path, importer, options);
-		if (!isSetString(resolved)) {
-			if (isSet(resolved)) throw new Error(`Resolved path is not a string: ${String(resolved)}`);
-			return false;
-		}
-		return this.#getStorage(resolved)?.adapter?.isFileSync(resolved) ?? false;
-	}
-	/**
-	* Checks if a path is a file in the virtual file system (VFS).
-	*
-	* @param path - The path to check.
-	* @param importer - An optional path to the importer module.
-	* @param options - Additional resolution options.
-	* @returns `true` if the path is a file, otherwise `false`.
-	*/
-	async isFile(path, importer, options) {
-		const resolved = await this.resolve(path, importer, options);
-		if (!isSetString(resolved)) {
-			if (isSet(resolved)) throw new Error(`Resolved path is not a string: ${String(resolved)}`);
-			return false;
-		}
-		return await this.#getStorage(resolved)?.adapter?.isFile(resolved) ?? false;
-	}
-	/**
-	* Checks if a file Id must be resolved by the virtual file system (VFS).
-	*
-	* @remarks
-	* Examples of file Ids that would be considered virtual include:
-	* - Ids that start with the framework specific prefix (e.g. `powerlines:`)
-	* - Ids that match a configured alias for virtual modules (returned true from {@link VirtualFileSystemInterface.isVirtual})
-	*
-	* @param path - The path or id of the file.
-	* @param importer - An optional path to the importer module, used for resolving the file path.
-	* @param options - Additional options for resolving the file path.
-	* @returns `true` if the file is virtual, otherwise `false`.
-	*/
-	isResolvableId(path, importer, options) {
-		return path.startsWith(`${this.#context.config.framework}:`) || this.isVirtual(path, importer, options) || this.isAlias(path) || this.isTsconfigPath(path);
-	}
-	/**
-	* Lists files in a given path.
-	*
-	* @param path - The path to list files from.
-	* @returns An array of file names in the specified path.
-	*/
-	listSync(path) {
-		let resolvedPath = path;
-		if (resolvedPath.includes("*")) {
-			this.#log(LogLevelLabel.WARN, `Invoking "listSync" with a glob pattern is not supported. It is likely you meant to use "globSync". Path: ${path}`);
-			resolvedPath = stripStars(resolvedPath);
-		}
-		return getUnique(this.#getStorages(resolvedPath, true).map((storage) => storage.adapter.listSync(storage.relativeBase ? storage.base ? appendPath(storage.relativeBase, storage.base) : storage.relativeBase : storage.base)).flat().filter(Boolean));
-	}
-	/**
-	* Lists files in a given path.
-	*
-	* @param path - The path to list files from.
-	* @returns An array of file names in the specified path.
-	*/
-	async list(path) {
-		let resolvedPath = path;
-		if (resolvedPath.includes("*")) {
-			this.#log(LogLevelLabel.WARN, `Invoking "list" with a glob pattern is not supported. It is likely you meant to use "glob". Path: ${path}`);
-			resolvedPath = stripStars(resolvedPath);
-		}
-		return getUnique((await Promise.all(this.#getStorages(resolvedPath, true).map(async (storage) => storage.adapter.list(storage.relativeBase ? storage.base ? appendPath(storage.relativeBase, storage.base) : storage.relativeBase : storage.base)))).flat().filter(Boolean));
-	}
-	/**
-	* Removes a file in the virtual file system (VFS).
-	*
-	* @param path - The path to create the directory at.
-	*/
-	async remove(path) {
-		const normalizedPath = this.#normalizePath(path);
-		this.#log(LogLevelLabel.TRACE, `Removing file: ${normalizedPath}`);
-		const { relativeKey, adapter } = this.#getStorage(normalizedPath);
-		if (hasFileExtension(normalizedPath)) await adapter.remove(relativeKey);
-		else await adapter.clear(relativeKey);
-		const id = this.#ids[normalizedPath];
-		if (id && this.#metadata[id]) {
-			delete this.#metadata[id];
-			delete this.#ids[normalizedPath];
-			delete this.#paths[id];
-		}
-	}
-	/**
-	* Removes a file in the virtual file system (VFS).
-	*
-	* @param path - The path to create the directory at.
-	*/
-	removeSync(path) {
-		const normalizedPath = this.#normalizePath(path);
-		this.#log(LogLevelLabel.TRACE, `Removing file: ${normalizedPath}`);
-		const { relativeKey, adapter } = this.#getStorage(normalizedPath);
-		if (hasFileExtension(normalizedPath)) adapter.removeSync(relativeKey);
-		else adapter.clearSync(relativeKey);
-		const id = this.#ids[normalizedPath];
-		if (id && this.#metadata[id]) {
-			delete this.#metadata[id];
-			delete this.#ids[normalizedPath];
-			delete this.#paths[id];
-		}
-	}
-	/**
-	* Glob files in the virtual file system (VFS) based on the provided pattern(s).
-	*
-	* @param patterns - A pattern (or multiple patterns) to use to determine the file paths to return
-	* @returns An array of file paths matching the provided pattern(s)
-	*/
-	async glob(patterns) {
-		const results = [];
-		for (const pattern of normalizeGlobPatterns(this.#context.config.cwd, patterns)) {
-			const normalized = this.#normalizePath(pattern);
-			if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("*")) if (this.isDirectorySync(normalized)) results.push(...await this.list(normalized));
-			else {
-				const resolved = await this.resolve(normalized);
-				if (resolved && !results.includes(resolved)) results.push(resolved);
-			}
-			else {
-				const absPattern = isAbsolutePath(normalized) ? normalized : this.#normalizePath(appendPath(normalized, this.#context.config.cwd));
-				await Promise.all((await this.list(stripStars(absPattern))).map(async (file) => {
-					if (globToRegex(absPattern).test(file)) {
-						const resolved = await this.resolve(file);
-						if (resolved && !results.includes(resolved)) results.push(resolved);
-					}
-				}));
-			}
-		}
-		return results;
-	}
-	/**
-	* Synchronously glob files in the virtual file system (VFS) based on the provided pattern(s).
-	*
-	* @param patterns - A pattern (or multiple patterns) to use to determine the file paths to return
-	* @returns An array of file paths matching the provided pattern(s)
-	*/
-	globSync(patterns) {
-		const results = [];
-		for (const pattern of normalizeGlobPatterns(this.#context.config.cwd, patterns)) {
-			const normalized = this.#normalizePath(pattern);
-			if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("*")) if (this.isDirectorySync(normalized)) results.push(...this.listSync(normalized));
-			else {
-				const resolved = this.resolveSync(normalized);
-				if (resolved && !results.includes(resolved)) results.push(resolved);
-			}
-			else {
-				const absPattern = isAbsolutePath(normalized) ? normalized : this.#normalizePath(appendPath(normalized, this.#context.config.cwd));
-				const files = this.listSync(stripStars(absPattern));
-				for (const file of files) if (globToRegex(absPattern).test(file)) {
-					const resolved = this.resolveSync(file);
-					if (resolved && !results.includes(resolved)) results.push(resolved);
-				}
-			}
-		}
-		return results;
-	}
-	/**
-	* Copies a file from one path to another in the virtual file system (VFS).
-	*
-	* @param srcPath - The source path to copy
-	* @param destPath - The destination path to copy to
-	*/
-	async copy(srcPath, destPath) {
-		const src = srcPath instanceof URL ? fileURLToPath(srcPath) : srcPath;
-		const dest = destPath instanceof URL ? fileURLToPath(destPath) : destPath;
-		if (!isSetString(src) && (!isSetObject(src) || !isSetString(src.input)) || !isSetString(dest)) return;
-		const sourceStr = isString(src) ? src : src.input ? src.input : this.#context.config.cwd;
-		const source = await this.resolve(sourceStr);
-		if (!source) return;
-		if (this.isDirectorySync(source) || isSetString(src) && src.includes("*") || isSetObject(src) && isSetString(src.glob)) await Promise.all((await this.glob(src)).map(async (file) => {
-			return this.copy(file, appendPath(replacePath(file, sourceStr), dest));
-		}));
-		else {
-			const content = await this.read(source);
-			if (content !== void 0) await this.write(this.#normalizePath(dest), content, { skipFormat: true });
-		}
-	}
-	/**
-	* Synchronously copies a file from one path to another in the virtual file system (VFS).
-	*
-	* @param srcPath - The source path to copy
-	* @param destPath - The destination path to copy to
-	*/
-	copySync(srcPath, destPath) {
-		const src = srcPath instanceof URL ? fileURLToPath(srcPath) : srcPath;
-		const dest = destPath instanceof URL ? fileURLToPath(destPath) : destPath;
-		if (!isSetString(src) && (!isSetObject(src) || !isSetString(src.input)) || !isSetString(dest)) return;
-		const sourceStr = isString(src) ? src : src.input ? src.input : this.#context.config.cwd;
-		const source = this.resolveSync(sourceStr);
-		if (!source) return;
-		if (this.isDirectorySync(source) || isSetString(src) && src.includes("*") || isSetObject(src) && isSetString(src.glob)) this.globSync(src).map((file) => {
-			return this.copySync(file, appendPath(findFilePath(replacePath(file, sourceStr)), dest));
-		});
-		else {
-			const content = this.readSync(source);
-			if (content !== void 0) this.writeSync(this.#normalizePath(hasFileExtension(dest) ? dest : appendPath(findFileName(source), dest)), content, { skipFormat: true });
-		}
-	}
-	/**
-	* Moves a file (or files) from one path to another in the virtual file system (VFS).
-	*
-	* @param srcPath - The source path to move
-	* @param destPath - The destination path to move to
-	*/
-	async move(srcPath, destPath) {
-		if (hasFileExtension(srcPath)) {
-			await this.copy(srcPath, destPath);
-			await this.remove(srcPath);
-		} else await Promise.all((await this.list(srcPath)).map(async (file) => {
-			await this.copy(file, destPath);
-			await this.remove(file);
-		}));
-	}
-	/**
-	* Synchronously moves a file (or files) from one path to another in the virtual file system (VFS).
-	*
-	* @param srcPath - The source path to move
-	* @param destPath - The destination path to move to
-	*/
-	moveSync(srcPath, destPath) {
-		if (hasFileExtension(srcPath)) {
-			this.copySync(srcPath, destPath);
-			this.removeSync(srcPath);
-		} else this.listSync(srcPath).forEach((file) => {
-			this.copySync(file, destPath);
-			this.removeSync(file);
-		});
-	}
-	/**
-	* Asynchronously reads a file from the virtual file system (VFS).
-	*
-	* @param path - The path or ID of the file to read.
-	* @returns A promise that resolves to the contents of the file as a string, or undefined if the file does not exist.
-	*/
-	async read(path) {
-		const filePath = await this.resolve(path, void 0, { isFile: true });
-		if (!filePath || !this.existsSync(filePath)) return;
-		const { adapter } = this.#getStorage(filePath);
-		this.#log(LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
-		return await adapter.get(filePath) ?? void 0;
-	}
-	/**
-	* Synchronously reads a file from the virtual file system (VFS).
-	*
-	* @param path - The path or ID of the file to read.
-	* @returns The contents of the file as a string, or undefined if the file does not exist.
-	*/
-	readSync(path) {
-		const filePath = this.resolveSync(path, void 0, { isFile: true });
-		if (!filePath || !this.existsSync(filePath)) return;
-		const { adapter } = this.#getStorage(filePath);
-		this.#log(LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
-		return adapter.getSync(filePath) ?? void 0;
-	}
-	/**
-	* Writes a file to the virtual file system (VFS).
-	*
-	* @param path - The path to the file.
-	* @param data - The contents of the file.
-	* @param options - Optional parameters for writing the file.
-	* @returns A promise that resolves when the file is written.
-	*/
-	async write(path, data = "", options = {}) {
-		const meta = options.meta ?? {};
-		const resolvedPath = await this.resolve(this.#normalizePath(path)) || path;
-		const { relativeKey, adapter } = this.#getStorage(resolvedPath, options.storage);
-		this.#log(LogLevelLabel.TRACE, `Writing ${resolvedPath} to ${adapter.name === "virtual" ? "the virtual file system" : adapter.name === "file-system" ? "the local file system" : adapter.name} (size: ${prettyBytes(new Blob(toArray(data)).size)})`);
-		let code = data;
-		try {
-			if (!options.skipFormat) code = await format(this.#context, resolvedPath, data);
-		} catch (err) {
-			if (DEFAULT_EXTENSIONS.includes(findFileExtensionSafe(resolvedPath, { fullExtension: true }))) this.#log(LogLevelLabel.WARN, `Failed to format file ${resolvedPath} before writing: ${err.message}`);
-			code = data;
-		}
-		this.#log(LogLevelLabel.TRACE, `Writing ${resolvedPath} to ${adapter.name === "virtual" ? "the virtual file system" : adapter.name === "file-system" ? "the local file system" : adapter.name} (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
-		const id = this.#normalizeId(meta.id || resolvedPath);
-		this.metadata[id] = {
-			type: "normal",
-			timestamp: Date.now(),
-			...this.metadata[id] ?? {},
-			...meta
-		};
-		this.paths[id] = resolvedPath;
-		this.ids[resolvedPath] = id;
-		return adapter.set(relativeKey, code);
-	}
-	/**
-	* Synchronously writes a file to the virtual file system (VFS).
-	*
-	* @param path - The file to write.
-	* @param data - The contents of the file.
-	* @param options - Optional parameters for writing the file.
-	*/
-	writeSync(path, data = "", options = {}) {
-		const meta = options.meta ?? {};
-		const resolvedPath = this.resolveSync(this.#normalizePath(path)) || path;
-		const { relativeKey, adapter } = this.#getStorage(resolvedPath, options.storage);
-		this.#log(LogLevelLabel.TRACE, `Writing ${resolvedPath} file to ${adapter.name === "virtual" ? "the virtual file system" : adapter.name === "file-system" ? "the local file system" : adapter.name} (size: ${prettyBytes(new Blob(toArray(data)).size)})`);
-		const id = this.#normalizeId(meta.id || resolvedPath);
-		this.metadata[id] = {
-			type: "normal",
-			timestamp: Date.now(),
-			...this.metadata[id] ?? {},
-			...meta
-		};
-		this.paths[id] = resolvedPath;
-		this.ids[resolvedPath] = id;
-		return adapter.setSync(relativeKey, data);
-	}
-	/**
-	* Synchronously creates a directory at the specified path.
-	*
-	* @param dirPath - The path of the directory to create.
-	*/
-	mkdirSync(dirPath) {
-		return this.#getStorage(dirPath)?.adapter?.mkdirSync(dirPath);
-	}
-	/**
-	* Creates a directory at the specified path.
-	*
-	* @param path - The path of the directory to create.
-	*/
-	async mkdir(path) {
-		return this.#getStorage(path)?.adapter?.mkdir(path);
-	}
-	/**
-	* Retrieves the metadata of a file in the virtual file system (VFS).
-	*
-	* @param pathOrId - The path or ID of the file to retrieve metadata for.
-	* @returns The metadata of the file, or undefined if the file does not exist.
-	*/
-	getMetadata(pathOrId) {
-		const resolved = this.resolveSync(pathOrId);
-		if (resolved && this.metadata[resolved]) return this.metadata[resolved];
-	}
-	/**
-	* Resolves a given module ID using the configured aliases.
-	*
-	* @remarks
-	* This function can be used to map module IDs to different paths based on the alias configuration.
-	*
-	* @param id - The module ID to resolve.
-	* @returns The resolved module ID - after applying any configured aliases (this will be the same as the input ID if no aliases match).
-	*/
-	resolveAlias(id) {
-		let path = id;
-		if (this.#context.config.resolve.alias) {
-			if (Array.isArray(this.#context.config.resolve.alias) && this.#context.config.resolve.alias.length > 0) {
-				const found = this.#context.config.resolve.alias.filter((alias) => isSetString(alias.find) && (alias.find === path || path.startsWith(`${alias.find}/`)) || isRegExp(alias.find) && alias.find.test(path));
-				if (found.length > 0) {
-					const alias = found.reduce((ret, current) => {
-						return (isSetString(ret.find) ? ret.find.length : isRegExp(ret.find) ? ret.find.source.length : 0) > (isSetString(current.find) ? current.find.length : isRegExp(current.find) ? current.find.source.length : 0) ? ret : current;
-					});
-					if (isSetString(alias.find)) path = path.replace(new RegExp(`^${alias.find}`), alias.replacement);
-					else if (isRegExp(alias.find)) path = path.replace(alias.find, alias.replacement);
-				}
-			} else if (isSetObject(this.#context.config.resolve.alias)) {
-				const found = Object.keys(this.#context.config.resolve.alias).filter((key) => key === path || path.startsWith(`${key}/`));
-				if (found.length > 0) {
-					const alias = found.reduce((ret, current) => {
-						return ret.length > current.length ? ret : current;
-					});
-					path = path.replace(new RegExp(`^${alias}`), this.#context.config.resolve.alias[alias]);
-				}
-			}
-		}
-		return path;
-	}
-	/**
-	* Checks if a given module ID is an alias.
-	*
-	* @remarks
-	* This function can be used to determine if a module ID matches any configured aliases.
-	*
-	* @param id - The module ID to check.
-	* @returns A boolean indicating whether the module ID is an alias.
-	*/
-	isAlias(id) {
-		const path = id;
-		if (this.#context.config.resolve.alias) {
-			if (Array.isArray(this.#context.config.resolve.alias) && this.#context.config.resolve.alias.length > 0) return this.#context.config.resolve.alias.filter((alias) => isSetString(alias.find) && (alias.find === path || path.startsWith(`${alias.find}/`)) || isRegExp(alias.find) && alias.find.test(path)).length > 0;
-			else if (isSetObject(this.#context.config.resolve.alias)) return Object.keys(this.#context.config.resolve.alias).filter((key) => key === path || path.startsWith(`${key}/`)).length > 0;
-		}
-		return false;
-	}
-	/**
-	* Checks if a given module ID is a tsconfig path.
-	*
-	* @remarks
-	* This function can be used to determine if a module ID matches any configured tsconfig paths.
-	*
-	* @param id - The module ID to check.
-	* @returns A boolean indicating whether the module ID is a tsconfig path.
-	*/
-	isTsconfigPath(id) {
-		return !!(this.#context.tsconfig.options.paths && Object.keys(this.#context.tsconfig.options.paths).length > 0 && match(id, this.#context.resolvePatterns));
-	}
-	/**
-	* A helper function to resolve modules in the virtual file system (VFS).
-	*
-	* @remarks
-	* This function can be used to resolve modules relative to the project root directory.
-	*
-	* @example
-	* ```ts
-	* const resolved = await context.resolvePath("some-module", "/path/to/importer");
-	* ```
-	*
-	* @param id - The module to resolve.
-	* @param importer - An optional path to the importer module.
-	* @param options - Additional resolution options.
-	* @returns A promise that resolves to the resolved module path.
-	*/
-	async resolve(id, importer, options = {}) {
-		const origResult = await this.#innerResolve(id, importer, options);
-		if (origResult && options.isFile && await this.isDirectory(origResult)) {
-			const indexResult = await this.resolve(joinPaths(origResult, "index"), importer, options);
-			if (indexResult) return indexResult;
-			if (!hasFileExtension(origResult)) for (const ext of DEFAULT_EXTENSIONS) {
-				const extResult = await this.resolve(`${origResult}.${ext}`, importer, options);
-				if (extResult) return extResult;
-			}
-			return;
-		}
-		return origResult;
-	}
-	/**
-	* A synchronous helper function to resolve modules using the Jiti resolver
-	*
-	* @remarks
-	* This function can be used to resolve modules relative to the project root directory.
-	*
-	* @example
-	* ```ts
-	* const resolvedPath = context.resolveSync("some-module", "/path/to/importer");
-	* ```
-	*
-	* @param id - The module to resolve.
-	* @param importer - An optional path to the importer module.
-	* @param options - Additional resolution options.
-	* @returns The resolved module path.
-	*/
-	resolveSync(id, importer, options = {}) {
-		const origResult = this.#innerResolveSync(id, importer, options);
-		if (origResult && options.isFile && this.isDirectorySync(origResult)) {
-			const indexResult = this.resolveSync(joinPaths(origResult, "index"), importer, options);
-			if (indexResult) return indexResult;
-			if (!hasFileExtension(origResult)) for (const ext of DEFAULT_EXTENSIONS) {
-				const extResult = this.resolveSync(`${origResult}.${ext}`, importer, options);
-				if (extResult) return extResult;
-			}
-			return;
-		}
-		return origResult;
-	}
-	/**
-	* Disposes of the virtual file system (VFS) by saving its state to disk.
-	*/
-	async dispose() {
-		if (!this.#isDisposed) {
-			this.#isDisposed = true;
-			this.#log(LogLevelLabel.DEBUG, "Disposing virtual file system...");
-			await this.remove(joinPaths(this.#context.dataPath, "fs.bin"));
-			const message = new capnp.Message();
-			const fs = message.initRoot(FileSystem);
-			const storage = fs._initStorage(Object.keys(this.#paths).length);
-			await Promise.all(Object.values(this.#paths).map(async (path, index) => {
-				const code = await this.read(path);
-				const fd = storage.get(index);
-				fd.path = path;
-				fd.code = code || "";
-			}));
-			const ids = fs._initIds(Object.keys(this.#ids).length);
-			Object.entries(this.#ids).filter(([, id]) => id).forEach(([path, id], index) => {
-				const fileId = ids.get(index);
-				fileId.id = id;
-				fileId.path = path;
-			});
-			const metadata = fs._initMetadata(Object.keys(this.#metadata).length);
-			Object.entries(this.#metadata).filter(([, value]) => value).forEach(([id, value], index) => {
-				const fileMetadata = metadata.get(index);
-				fileMetadata.id = id;
-				fileMetadata.type = value.type;
-				fileMetadata.timestamp = value.timestamp ?? Date.now();
-				if (value.properties) {
-					const props = fileMetadata._initProperties(Object.keys(value.properties).length);
-					Object.entries(value.properties).filter(([, val]) => isSetString(val)).forEach(([key, val], index) => {
-						const prop = props.get(index);
-						prop.key = key;
-						prop.value = val;
-					});
-				}
-			});
-			await writeFileBuffer(joinPaths(this.#context.dataPath, "fs.bin"), message.toArrayBuffer());
-			if (!this.#context.config.skipCache) this.resolverCache.save(true);
-			await Promise.all(this.#getStorages().map(async (storage) => storage.adapter.dispose()));
-			this.#log(LogLevelLabel.TRACE, "Virtual file system has been disposed.");
-		}
-	}
-	async [Symbol.asyncDispose]() {
-		return this.dispose();
-	}
-};
-
-//#endregion
-//#region src/context/context.ts
-setGlobalDispatcher(new Agent({ keepAliveTimeout: 1e4 }).compose(interceptors.retry({
-	maxRetries: 3,
-	minTimeout: 1e3,
-	maxTimeout: 1e4,
-	timeoutFactor: 2,
-	retryAfter: true
-})));
-const SKIP_CLONING_PROPS = [
-	"dependencies",
-	"devDependencies",
-	"persistedMeta",
-	"packageJson",
-	"projectJson",
-	"tsconfig",
-	"resolver",
-	"fs",
-	"$$internal"
-];
-var PowerlinesContext = class PowerlinesContext extends PowerlinesBaseContext {
-	/**
-	* Internal references storage
-	*
-	* @danger
-	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-	*
-	* @internal
-	*/
-	#internal = {};
-	#checksum = null;
-	#buildId = uuid();
-	#releaseId = uuid();
-	#fs;
-	#tsconfig;
-	#parserCache;
-	#requestCache;
-	/**
-	* Create a new Storm context from the workspace root and user config.
-	*
-	* @param options - The options for resolving the context.
-	* @returns A promise that resolves to the new context.
-	*/
-	static async fromOptions(options) {
-		const context = new PowerlinesContext(options);
-		await context.init(options);
-		const powerlinesPath = await resolvePackage("powerlines");
-		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
-		context.powerlinesPath = powerlinesPath;
-		return context;
-	}
-	/**
-	* The options provided to the Powerlines process
-	*/
-	options;
-	/**
-	* An object containing the dependencies that should be installed for the project
-	*/
-	dependencies = {};
-	/**
-	* An object containing the development dependencies that should be installed for the project
-	*/
-	devDependencies = {};
-	/**
-	* The persisted meta information about the current build
-	*/
-	persistedMeta = void 0;
-	/**
-	* The parsed `package.json` file for the project
-	*/
-	packageJson;
-	/**
-	* The parsed `project.json` file for the project
-	*/
-	projectJson = void 0;
-	/**
-	* The resolved tsconfig file paths for the project
-	*/
-	resolvePatterns = [];
-	/**
-	* Internal context fields and methods
-	*
-	* @danger
-	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-	*
-	* @internal
-	*/
-	get $$internal() {
-		return this.#internal;
-	}
-	/**
-	* Internal context fields and methods
-	*
-	* @danger
-	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-	*
-	* @internal
-	*/
-	set $$internal(value) {
-		this.#internal = value;
-	}
-	/**
-	* The resolved entry type definitions for the project
-	*/
-	get entry() {
-		const entry = this.resolvedEntry;
-		return resolveInputsSync(this, entry && entry.length > 0 ? entry : Array.isArray(this.config.input) || isSetObject(this.config.input) && !isTypeDefinition(this.config.input) ? this.config.input : toArray(this.config.input).flat());
-	}
-	/**
-	* The TypeScript configuration parsed from the tsconfig file
-	*/
-	get tsconfig() {
-		if (!this.#tsconfig) this.tsconfig = { tsconfigFilePath: this.config.tsconfig };
-		return this.#tsconfig;
-	}
-	/**
-	* Sets the TypeScript configuration parsed from the tsconfig file
-	*/
-	set tsconfig(value) {
-		this.#tsconfig = value;
-		this.resolvePatterns = tsconfigPathsToRegExp(value?.options?.paths ?? {});
-	}
-	/**
-	* The virtual file system interface for the project
-	*/
-	get fs() {
-		if (!this.#fs) this.#fs = VirtualFileSystem.createSync(this);
-		return this.#fs;
-	}
-	/**
-	* Get the checksum of the project's current state
-	*/
-	get checksum() {
-		return this.#checksum;
-	}
-	/**
-	* The meta information about the current build
-	*/
-	get meta() {
-		return {
-			buildId: this.#buildId,
-			releaseId: this.#releaseId,
-			checksum: this.#checksum,
-			timestamp: this.timestamp.getTime(),
-			rootHash: murmurhash({
-				workspaceRoot: this.options?.cwd,
-				root: this.config?.root
-			}, { maxLength: ROOT_HASH_LENGTH }),
-			configHash: murmurhash(this.config, { maxLength: CACHE_HASH_LENGTH })
-		};
-	}
-	/**
-	* The resolved configuration options
-	*/
-	get config() {
-		return this.resolvedConfig;
-	}
-	/**
-	* Get the path to the artifacts directory for the project
-	*/
-	get artifactsPath() {
-		return joinPaths(this.config.cwd, this.config.root, this.config.output.artifactsPath);
-	}
-	/**
-	* Get the path to the builtin modules used by the project
-	*/
-	get builtinsPath() {
-		return joinPaths(this.artifactsPath, "builtins");
-	}
-	/**
-	* Get the path to the entry directory for the project
-	*/
-	get entryPath() {
-		return joinPaths(this.artifactsPath, "entry");
-	}
-	/**
-	* Get the path to the infrastructure modules used by the project
-	*/
-	get infrastructurePath() {
-		return joinPaths(this.artifactsPath, "infrastructure");
-	}
-	/**
-	* Get the path to the data directory for the project
-	*/
-	get dataPath() {
-		return joinPaths(this.envPaths.data, "projects", getPrefixedRootHash(this.config.name, this.meta.rootHash));
-	}
-	/**
-	* Get the path to the cache directory for the project
-	*/
-	get cachePath() {
-		return joinPaths(this.envPaths.cache, "projects", murmurhash({
-			checksum: this.#checksum,
-			config: this.meta.configHash
-		}, { maxLength: CACHE_HASH_LENGTH }));
-	}
-	/**
-	* Get the path to the generated declaration file for the project
-	*/
-	get typesPath() {
-		return this.config.output.types ? appendPath(this.config.output.types, this.config.cwd) : joinPaths(this.config.cwd, this.config.root, "powerlines.d.ts");
-	}
-	/**
-	* Get the project root relative to the workspace root
-	*/
-	get relativeToWorkspaceRoot() {
-		return relativeToWorkspaceRoot(this.config.root);
-	}
-	/**
-	* The builtin module id that exist in the Powerlines virtual file system
-	*/
-	get builtins() {
-		return Object.values(this.fs.metadata).filter((meta) => meta && meta.type === "builtin").map((meta) => meta?.id).filter(Boolean);
-	}
-	/**
-	* Additional arguments provided during execution of the command, such as CLI flags or other parameters that may be relevant to the command being executed.
-	*/
-	get additionalArgs() {
-		return Object.entries(this.config.inlineConfig?.additionalArgs ?? {}).reduce((ret, [key, value]) => {
-			const formattedKey = key.replace(/^--?/, "");
-			if (ret[formattedKey]) if (Array.isArray(ret[formattedKey])) if (Array.isArray(value)) ret[formattedKey] = [...toArray(ret[formattedKey]), ...value];
-			else ret[formattedKey] = [...toArray(ret[formattedKey]), value];
-			else ret[formattedKey] = [ret[formattedKey], ...Array.isArray(value) ? value : [value]];
-			else ret[formattedKey] = value;
-			return ret;
-		}, {});
-	}
-	/**
-	* The alias mappings for the project used during module resolution
-	*
-	* @remarks
-	* This includes both the built-in module aliases as well as any custom aliases defined in the build configuration.
-	*/
-	get alias() {
-		return this.builtins.reduce((ret, id) => {
-			const moduleId = `${this.config?.framework || "powerlines"}:${id.replace(/^.*:/, "")}`;
-			if (!ret[moduleId]) {
-				const path = this.fs.paths[id];
-				if (path) ret[moduleId] = path;
-			}
-			return ret;
-		}, this.config.resolve.alias ? Array.isArray(this.config.resolve.alias) ? this.config.resolve.alias.reduce((ret, alias) => {
-			if (!ret[alias.find.toString()]) ret[alias.find.toString()] = alias.replacement;
-			return ret;
-		}, {}) : this.config.resolve.alias : {});
-	}
-	/**
-	* Gets the parser cache.
-	*/
-	get parserCache() {
-		if (!this.#parserCache) this.#parserCache = create({
-			cacheId: "parser",
-			cacheDir: this.cachePath,
-			ttl: 7200 * 1e3,
-			lruSize: 5e3,
-			persistInterval: 250
-		});
-		return this.#parserCache;
-	}
-	/**
-	* Gets the request cache.
-	*/
-	get requestCache() {
-		if (!this.#requestCache) this.#requestCache = create({
-			cacheId: "http",
-			cacheDir: this.cachePath,
-			ttl: 360 * 60 * 1e3,
-			lruSize: 5e3,
-			persistInterval: 250
-		});
-		return this.#requestCache;
-	}
-	/**
-	* The entry points that exist in the Powerlines virtual file system
-	*/
-	get resolvedEntry() {
-		return Object.entries(this.fs.metadata).filter(([, meta]) => meta && meta.type === "entry").map(([path, meta]) => {
-			const typeDefinition = { file: path };
-			if (meta.properties) {
-				if (isSetString(meta.properties.file)) typeDefinition.file = meta.properties.file;
-				if (isSetString(meta.properties.name)) typeDefinition.name = meta.properties.name;
-				if (isSetString(meta.properties["input.file"]) || isSetString(meta.properties["input.name"])) {
-					typeDefinition.input ??= {};
-					if (isSetString(meta.properties["input.file"])) typeDefinition.input.file = meta.properties["input.file"];
-					if (isSetString(meta.properties["input.name"])) typeDefinition.input.name = meta.properties["input.name"];
-				}
-				if (isSetString(meta.properties.output)) typeDefinition.output = meta.properties.output;
-			}
-			return typeDefinition;
-		}).filter(Boolean);
-	}
-	/**
-	* Creates a new StormContext instance.
-	*
-	* @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
-	*/
-	constructor(options) {
-		super();
-		this.options = options;
-	}
-	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
-	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
-	*
-	* @returns A promise that resolves to the cloned context.
-	*/
-	async clone() {
-		const clone = await PowerlinesContext.fromOptions(this.config);
-		return this.copyTo(clone);
-	}
-	/**
-	* Create a new logger instance
-	*
-	* @param name - The name to use for the logger instance
-	* @returns A logger function
-	*/
-	createLog(name = null) {
-		return createLog(name, {
-			...this.config,
-			logLevel: isNull(this.logLevel) ? "silent" : this.logLevel
-		});
-	}
-	/**
-	* A function to perform HTTP fetch requests
-	*
-	* @remarks
-	* This function uses a caching layer to avoid duplicate requests during the Powerlines process.
-	*
-	* @example
-	* ```ts
-	* const response = await context.fetch("https://api.example.com/data");
-	* const data = await response.json();
-	* ```
-	*
-	* @see https://github.com/nodejs/undici
-	*
-	* @param input - The URL to fetch.
-	* @param options - The fetch request options.
-	* @returns A promise that resolves to a response returned by the fetch.
-	*/
-	async fetch(input, options = {}) {
-		const cacheKey = murmurhash({
-			input: input.toString(),
-			options: JSON.stringify(options)
-		});
-		if (!this.config.skipCache && !options.skipCache) {
-			const cached = this.requestCache.get(cacheKey);
-			if (cached) return new Response(cached.body, {
-				status: cached.status,
-				statusText: cached.statusText,
-				headers: cached.headers
-			});
-		}
-		const response = await fetchRequest(input, {
-			timeout: 12e3,
-			...options
-		});
-		const result = {
-			body: await response.text(),
-			status: response.status,
-			statusText: response.statusText,
-			headers: Object.fromEntries(response.headers.entries())
-		};
-		if (!this.config.skipCache && !options.skipCache) try {
-			this.requestCache.set(cacheKey, result);
-		} catch {}
-		return new Response(result.body, {
-			status: result.status,
-			statusText: result.statusText,
-			headers: result.headers
-		});
-	}
-	/**
-	* Parse code using [Oxc-Parser](https://github.com/oxc/oxc) into an (ESTree-compatible)[https://github.com/estree/estree] AST object.
-	*
-	* @remarks
-	* This function can be used to parse TypeScript code into an AST for further analysis or transformation.
-	*
-	* @example
-	* ```ts
-	* const ast = context.parse("const x: number = 42;");
-	* ```
-	*
-	* @see https://rollupjs.org/plugin-development/#this-parse
-	* @see https://github.com/oxc/oxc
-	*
-	* @param code - The source code to parse.
-	* @param options - The options to pass to the parser.
-	* @returns An (ESTree-compatible)[https://github.com/estree/estree] AST object.
-	*/
-	async parse(code, options = {}) {
-		const cacheKey = murmurhash({
-			code,
-			options
-		});
-		let result;
-		if (!this.config.skipCache) {
-			result = this.parserCache.get(cacheKey);
-			if (result) return result;
-		}
-		result = await parse(`source.${options.lang || "ts"}`, code, {
-			...options,
-			sourceType: "module",
-			showSemanticErrors: this.config.mode === "development"
-		});
-		if (!this.config.skipCache) this.parserCache.set(cacheKey, result);
-		return result;
-	}
-	/**
-	* A helper function to resolve modules in the Virtual File System
-	*
-	* @remarks
-	* This function can be used to resolve modules relative to the project root directory.
-	*
-	* @example
-	* ```ts
-	* const resolved = await context.resolve("some-module", "/path/to/importer");
-	* ```
-	*
-	* @param id - The module to resolve.
-	* @param importer - An optional path to the importer module.
-	* @param options - Additional resolution options.
-	* @returns A promise that resolves to the resolved module path.
-	*/
-	async resolve(id, importer, options = {}) {
-		let moduleId = id;
-		if (this.config.resolve.alias) {
-			if (Array.isArray(this.config.resolve.alias)) {
-				const alias = this.config.resolve.alias.find((a) => match(moduleId, [a.find]));
-				if (alias) moduleId = alias.replacement;
-			} else if (isSetObject(this.config.resolve.alias) && this.config.resolve.alias[id]) moduleId = this.config.resolve.alias[id];
-		}
-		if (this.fs.isResolvableId(moduleId) || importer && this.fs.isResolvableId(importer)) {
-			let resolvedImporter = importer;
-			if (importer && this.fs.isResolvableId(importer)) resolvedImporter = await this.fs.resolve(importer, void 0, defu({
-				conditions: this.config.resolve.conditions,
-				extensions: this.config.resolve.extensions
-			}, options));
-			const result = await this.fs.resolve(moduleId, resolvedImporter, defu({
-				conditions: this.config.resolve.conditions,
-				extensions: this.config.resolve.extensions
-			}, options));
-			if (!result) return;
-			const external = Boolean(!match(moduleId, this.config.resolve.noExternal) && (match(moduleId, this.config.resolve.external) || moduleId.startsWith("node:") || (!this.fs.isVirtual(moduleId, importer, options) || this.fs.isVirtual(moduleId, importer, options) && this.config.projectType !== "application") && this.config.resolve.skipNodeModulesBundle && !/^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/.test(moduleId)));
-			return {
-				id: result,
-				external,
-				virtual: !external
-			};
-		}
-		if (this.config.resolve.skipNodeModulesBundle) {
-			if (match(moduleId, this.resolvePatterns) || match(moduleId, this.config.resolve.noExternal)) return;
-			if (match(moduleId, this.config.resolve.external) || moduleId.startsWith("node:")) return {
-				id: moduleId,
-				external: true,
-				virtual: false
-			};
-			if (!/^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/.test(moduleId)) return {
-				id: moduleId,
-				external: true,
-				virtual: false
-			};
-		} else {
-			if (match(moduleId, this.config.resolve.noExternal)) return;
-			if (match(moduleId, this.config.resolve.external) || moduleId.startsWith("node:")) return {
-				id: moduleId,
-				external: true,
-				virtual: false
-			};
-		}
-	}
-	/**
-	* A helper function to load modules from the Virtual File System
-	*
-	* @remarks
-	* This function can be used to load modules relative to the project root directory.
-	*
-	* @example
-	* ```ts
-	* const module = await context.load("some-module", "/path/to/importer");
-	* ```
-	*
-	* @param id - The module to load.
-	* @returns A promise that resolves to the loaded module.
-	*/
-	async load(id) {
-		const resolvedId = await this.fs.resolve(id);
-		if (!resolvedId) return;
-		const code = await this.fs.read(resolvedId);
-		if (!code) return;
-		return {
-			code,
-			map: null
-		};
-	}
-	/**
-	* Get the builtin virtual files that exist in the Powerlines virtual file system
-	*/
-	async getBuiltins() {
-		return Promise.all(Object.entries(this.fs.metadata).filter(([, meta]) => meta && meta.type === "builtin").map(async ([id, meta]) => {
-			const code = await this.fs.read(id);
-			const path = this.fs.paths[id];
-			return {
-				...meta,
-				path,
-				code
-			};
-		}));
-	}
-	/**
-	* Resolves a file and writes it to the VFS if it does not already exist
-	*
-	* @param code - The source code of the file
-	* @param path - The path to write the file to
-	* @param options - Additional options for writing the file
-	*/
-	async emit(code, path, options = {}) {
-		const filePath = options.extension ? findFileExtensionSafe(path) ? options.extension.startsWith(".") ? path.replace(findFileDotExtensionSafe(path), options.extension) : path.replace(findFileExtensionSafe(path), options.extension) : options.extension.startsWith(".") ? `${path}${options.extension}` : `${path}.${options.extension}` : findFileExtensionSafe(path) ? path : `${path}.ts`;
-		if (isFunction(this.emitFile) && options.emitWithBundler) return this.emitFile({
-			needsCodeReference: options.needsCodeReference,
-			originalFileName: options.originalFileName,
-			fileName: filePath,
-			source: code,
-			type: "asset"
-		});
-		return this.fs.write(filePath, code, options);
-	}
-	/**
-	* Synchronously resolves a file and writes it to the VFS if it does not already exist
-	*
-	* @param code - The source code of the file
-	* @param path - The path to write the file to
-	* @param options - Additional options for writing the file
-	*/
-	emitSync(code, path, options = {}) {
-		const filePath = options.extension ? findFileExtensionSafe(path) ? options.extension.startsWith(".") ? path.replace(findFileDotExtensionSafe(path), options.extension) : path.replace(findFileExtensionSafe(path), options.extension) : options.extension.startsWith(".") ? `${path}${options.extension}` : `${path}.${options.extension}` : findFileExtensionSafe(path) ? path : `${path}.ts`;
-		if (isFunction(this.emitFile) && options.emitWithBundler) return this.emitFile({
-			needsCodeReference: options.needsCodeReference,
-			originalFileName: options.originalFileName,
-			fileName: filePath,
-			source: code,
-			type: "asset"
-		});
-		return this.fs.writeSync(filePath, code, options);
-	}
-	/**
-	* Resolves a entry virtual file and writes it to the VFS if it does not already exist
-	*
-	* @param code - The source code of the entry file
-	* @param path - A path to write the entry file to
-	* @param options - Optional write file options
-	*/
-	async emitEntry(code, path, options = {}) {
-		return this.emit(code, appendPath(path, this.entryPath), defu({ meta: {
-			type: "entry",
-			properties: {
-				file: appendPath(path, this.entryPath),
-				name: options?.name,
-				output: options?.output,
-				"input.file": options?.input?.file,
-				"input.name": options?.input?.name
-			}
-		} }, omit(options, ["name"])));
-	}
-	/**
-	* Synchronously resolves a entry virtual file and writes it to the VFS if it does not already exist
-	*
-	* @param code - The source code of the entry file
-	* @param path - A path to write the entry file to
-	* @param options - Optional write file options
-	*/
-	emitEntrySync(code, path, options = {}) {
-		return this.emitSync(code, appendPath(path, this.entryPath), defu({ meta: {
-			type: "entry",
-			properties: {
-				file: appendPath(path, this.entryPath),
-				name: options?.name,
-				output: options?.output,
-				"input.file": options?.input?.file,
-				"input.name": options?.input?.name
-			}
-		} }, omit(options, ["name"])));
-	}
-	/**
-	* Resolves a builtin virtual file and writes it to the VFS if it does not already exist
-	*
-	* @param code - The source code of the builtin file
-	* @param id - The unique identifier of the builtin file
-	* @param options - Optional write file options
-	*/
-	async emitBuiltin(code, id, options = {}) {
-		if (!this.builtinsPath) throw new Error(`The builtins path is not set. Cannot emit builtin file with id "${id}".`);
-		if (!isSetString(id)) throw new Error(`The builtin id must be a non-empty string. Received: ${String(id)}`);
-		return this.emit(code, appendPath(id, this.builtinsPath), defu(options, { meta: {
-			type: "builtin",
-			id
-		} }));
-	}
-	/**
-	* Synchronously resolves a builtin virtual file and writes it to the VFS if it does not already exist
-	*
-	* @param code - The source code of the builtin file
-	* @param id - The unique identifier of the builtin file
-	* @param options - Optional write file options
-	*/
-	emitBuiltinSync(code, id, options = {}) {
-		if (!this.builtinsPath) throw new Error(`The builtins path is not set. Cannot emit builtin file with id "${id}".`);
-		if (!isSetString(id)) throw new Error(`The builtin id must be a non-empty string. Received: ${String(id)}`);
-		return this.emitSync(code, appendPath(id, this.builtinsPath), defu(options, { meta: {
-			type: "builtin",
-			id
-		} }));
-	}
-	/**
-	* Resolves a builtin virtual file and writes it to the VFS if it does not already exist
-	*
-	* @param code - The source code of the builtin file
-	* @param id - The unique identifier of the builtin file
-	* @param options - Optional write file options
-	*/
-	async emitInfrastructure(code, id, options = {}) {
-		if (!this.infrastructurePath) throw new Error(`The infrastructure path is not set. Cannot emit infrastructure file with id "${id}".`);
-		if (!isSetString(id)) throw new Error(`The infrastructure id must be a non-empty string. Received: ${String(id)}`);
-		return this.emit(code, appendPath(id, this.infrastructurePath), defu(options, { meta: {
-			type: "infrastructure",
-			id
-		} }));
-	}
-	/**
-	* Synchronously resolves an infrastructure virtual file and writes it to the VFS if it does not already exist
-	*
-	* @param code - The source code of the infrastructure file
-	* @param id - The unique identifier of the infrastructure file
-	* @param options - Optional write file options
-	*/
-	emitInfrastructureSync(code, id, options = {}) {
-		if (!this.infrastructurePath) throw new Error(`The infrastructure path is not set. Cannot emit infrastructure file with id "${id}".`);
-		if (!isSetString(id)) throw new Error(`The infrastructure id must be a non-empty string. Received: ${String(id)}`);
-		return this.emitSync(code, appendPath(id, this.infrastructurePath), defu(options, { meta: {
-			type: "infrastructure",
-			id
-		} }));
-	}
-	/**
-	* Generates a checksum representing the current context state
-	*
-	* @param root - The root directory of the project to generate the checksum for
-	* @returns A promise that resolves to a string representing the checksum
-	*/
-	async generateChecksum(root = this.config.root) {
-		this.#checksum = await hashDirectory(root, { ignore: [
-			"node_modules",
-			".git",
-			".nx",
-			".cache",
-			"tmp",
-			"dist"
-		] });
-		return this.#checksum;
-	}
-	/**
-	* Initialize the context with the provided configuration options
-	*/
-	async setup() {
-		this.resolvedConfig = mergeConfig({
-			inlineConfig: this.config.inlineConfig ?? {},
-			userConfig: this.config.userConfig ?? {},
-			pluginConfig: this.config.pluginConfig ?? {}
-		}, this.options, this.config.inlineConfig ? getConfigProps(this.config.inlineConfig, this.options.root, this.options.cwd) : {}, this.config.userConfig ? getConfigProps(this.config.userConfig, this.options.root, this.options.cwd) : {}, this.config.pluginConfig ? getConfigProps(this.config.pluginConfig, this.options.root, this.options.cwd) : {}, {
-			name: this.projectJson?.name || this.packageJson?.name,
-			version: this.packageJson?.version,
-			description: this.packageJson?.description
-		}, {
-			projectType: "application",
-			platform: "neutral",
-			logLevel: "info",
-			preview: false,
-			environments: {},
-			resolve: {}
-		});
-		await this.innerSetup();
-	}
-	/**
-	* The resolved configuration for this context
-	*/
-	resolvedConfig = {};
-	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
-	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
-	*
-	* @returns The cloned context.
-	*/
-	copyTo(context) {
-		for (const [key, value] of Object.entries(this)) if (!SKIP_CLONING_PROPS.includes(key)) if (isObject(value) || Array.isArray(value)) context[key] = deepClone(value);
-		else context[key] = value;
-		context.dependencies = deepClone(this.dependencies);
-		context.devDependencies = deepClone(this.devDependencies);
-		context.persistedMeta = this.persistedMeta ? deepClone(this.persistedMeta) : void 0;
-		context.packageJson = deepClone(this.packageJson);
-		context.projectJson = this.projectJson ? deepClone(this.projectJson) : void 0;
-		context.tsconfig ??= deepClone(this.tsconfig);
-		context.resolver ??= this.resolver;
-		context.fs ??= this.#fs;
-		context.$$internal = this.$$internal;
-		return context;
-	}
-	/**
-	* Initialize the context with the provided configuration options
-	*
-	*   @remarks
-	* This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
-	*
-	* @param options - The configuration options to initialize the context with
-	*/
-	async init(options = {}) {
-		await super.init(options);
-		this.options.configIndex = options.configIndex ?? this.options.configIndex ?? 0;
-		const projectJsonPath = joinPaths(this.options.root, "project.json");
-		if (existsSync(projectJsonPath)) this.projectJson = await readJsonFile(projectJsonPath);
-		const packageJsonPath = joinPaths(this.options.root, "package.json");
-		if (existsSync(packageJsonPath)) {
-			this.packageJson = await readJsonFile(packageJsonPath);
-			this.options.organization ??= isSetObject(this.packageJson?.author) ? kebabCase(this.packageJson?.author?.name) : kebabCase(this.packageJson?.author);
-		}
-		this.#checksum = await this.generateChecksum(this.options.root);
-		const userConfig = this.configFile.config ? Array.isArray(this.configFile.config) && this.configFile.config.length > this.options.configIndex ? this.configFile.config[this.options.configIndex] : this.configFile.config : {};
-		this.resolvedConfig = {
-			...this.options,
-			...userConfig,
-			userConfig
-		};
-	}
-	/**
-	* Initialize the context with the provided configuration options
-	*/
-	async innerSetup() {
-		this.resolvedConfig.compatibilityDate = resolveCompatibilityDates(this.config.inlineConfig.compatibilityDate ?? this.config.userConfig.compatibilityDate ?? this.config.pluginConfig.compatibilityDate, "latest");
-		this.resolvedConfig.output = defu(this.resolvedConfig.output ?? {}, {
-			path: appendPath(joinPaths(this.config.root, "dist"), this.config.cwd),
-			copy: { assets: [
-				{ glob: "LICENSE" },
-				{
-					input: this.config.root,
-					glob: "*.md"
-				},
-				{
-					input: this.config.root,
-					glob: "package.json"
-				}
-			] },
-			artifactsPath: `.${this.config.framework ?? "powerlines"}`,
-			dts: true,
-			types: joinPaths(this.config.root, `${this.config.framework ?? "powerlines"}.d.ts`)
-		});
-		this.logger = {
-			log: this.createLog(this.config.name),
-			level: isNull(this.logLevel) ? "silent" : this.logLevel
-		};
-		if (this.config.output?.format) this.config.output.format = getUnique(toArray(this.config.output?.format));
-		this.config.plugins = (this.config.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
-			if (isPlugin(plugin) && isDuplicate(plugin, ret.filter((p) => isPlugin(p)))) return ret;
-			ret.push(plugin);
-			return ret;
-		}, []);
-		this.config.input = getUniqueInputs(this.config.input);
-		if (this.config.name?.startsWith("@") && this.config.name.split("/").filter(Boolean).length > 1) this.config.name = this.config.name.split("/").filter(Boolean)[1];
-		this.config.title ??= titleCase(this.config.name);
-		if (this.config.userConfig.resolve?.external) this.config.userConfig.resolve.external = getUnique(this.config.userConfig.resolve.external);
-		if (this.config.userConfig.resolve?.noExternal) this.config.userConfig.resolve.noExternal = getUnique(this.config.userConfig.resolve.noExternal);
-		if (this.config.resolve.external) this.config.resolve.external = getUnique(this.config.resolve.external);
-		if (this.config.resolve.noExternal) this.config.resolve.noExternal = getUnique(this.config.resolve.noExternal);
-		this.config.output.format = getUnique(toArray(this.config.output?.format ?? (this.config.projectType === "library" ? ["cjs", "esm"] : ["esm"])));
-		if (this.config.output.dts !== false && !this.config.output.types) this.config.output.types = `${this.config.root ? `${this.config.root}/` : ""}${this.config.framework ?? "powerlines"}.d.ts`;
-		if (this.config.root && this.config.output.copy !== false) this.config.output.copy = {
-			path: joinPaths(this.config.cwd, "dist", replacePath(this.config.root, this.config.cwd)),
-			...this.config.output.copy || {}
-		};
-		if (this.config.output.copy && this.config.output.copy.path && this.config.output.copy.assets && Array.isArray(this.config.output.copy.assets)) this.config.output.copy.assets = getUniqueBy(this.config.output.copy.assets.map((asset) => {
-			return {
-				glob: isSetObject(asset) ? asset.glob : asset,
-				input: isString(asset) || !asset.input || asset.input === "." || asset.input === "/" || asset.input === "./" ? this.options.cwd : isParentPath(asset.input, this.config.cwd) || asset.input === this.config.cwd ? asset.input : appendPath(asset.input, this.config.cwd),
-				output: isSetObject(asset) && asset.output ? isParentPath(asset.output, this.config.cwd) ? asset.output : appendPath(joinPaths(this.config.output.copy.path, replacePath(replacePath(asset.output, replacePath(this.config.output.copy.path, this.config.cwd)), this.config.output.copy.path)), this.config.cwd) : appendPath(this.config.output.copy.path, this.config.cwd),
-				ignore: isSetObject(asset) && asset.ignore ? toArray(asset.ignore) : void 0
-			};
-		}), (a) => `${a.input}-${a.glob}-${a.output}`);
-		this.config.plugins = (this.config.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
-			if (isPlugin(plugin) && isDuplicate(plugin, ret.filter((p) => isPlugin(p)))) return ret;
-			ret.push(plugin);
-			return ret;
-		}, []);
-		if (this.config.output.types) if (isSetString(this.config.output.types)) this.config.output.types = replacePathTokens(this, this.config.output.types);
-		else this.config.output.types = joinPaths(this.config.root, `${this.config.framework ?? "powerlines"}.d.ts`);
-		if (!this.config.userConfig?.logLevel && !this.config.inlineConfig?.logLevel) if (this.config.mode === "development") this.config.logLevel = "debug";
-		else this.config.logLevel = "info";
-		if (!this.config.userConfig?.output?.sourceMap && !this.config.inlineConfig?.output?.sourceMap) if (this.config.mode === "development") this.config.output.sourceMap = true;
-		else this.config.output.sourceMap = false;
-		if (!this.config.userConfig?.output?.minify && !this.config.inlineConfig?.output?.minify) if (this.config.mode === "production") this.config.output.minify = true;
-		else this.config.output.minify = false;
-		if (!this.config.userConfig?.tsconfig && !this.config.inlineConfig?.tsconfig) this.config.tsconfig = getTsconfigFilePath(this.options.cwd, this.options.root);
-		else if (this.config.tsconfig) this.config.tsconfig = replacePath(replacePathTokens(this, this.config.tsconfig), this.config.cwd);
-		if (this.config.output.copy && this.config.output.copy.assets) this.config.output.copy.assets = this.config.output.copy.assets.map((asset) => ({
-			...asset,
-			glob: replacePathTokens(this, asset.glob),
-			ignore: asset.ignore ? asset.ignore.map((ignore) => replacePathTokens(this, ignore)) : void 0,
-			input: replacePathTokens(this, asset.input),
-			output: replacePathTokens(this, asset.output)
-		}));
-		if (isSetString(this.config.output?.storage) && this.config.output.storage === "virtual" || isSetObject(this.config.output?.storage) && Object.values(this.config.output.storage).every((adapter) => adapter.preset === "virtual")) this.config.output.overwrite = true;
-		this.#fs ??= await VirtualFileSystem.create(this);
-	}
-};
-
-//#endregion
-//#region src/_internal/helpers/hooks.ts
-const mergeResultObjects = createDefu((obj, key, value) => {
-	if (isString(obj[key]) && isString(value)) {
-		obj[key] = `${obj[key] || ""}\n${value || ""}`.trim();
-		return true;
-	}
-	return false;
-});
-/**
-* Merges the current hook result with the previous results based on their types.
-*
-* @param currentResult - The current hook result to merge with the previous results.
-* @param previousResults - The previous hook results to merge with the current result.
-* @returns The merged result.
-*/
-function mergeResults(currentResult, previousResults) {
-	if (!previousResults || previousResults.length === 0) return [currentResult];
-	if (isSetString(currentResult)) previousResults = [`${isSetString(previousResults[0]) ? previousResults[0] || "" : ""}\n${isSetString(previousResults[0]) ? currentResult.replace(previousResults[0], "") : currentResult}`.trim()];
-	else if (isObject(currentResult)) previousResults = [mergeResultObjects(currentResult, previousResults[0] ?? {})];
-	return previousResults;
-}
-/**
-* Merges multiple hook results together, with special handling for string values and object values.
-*
-* @param currentResult - The current hook result to merge with the previous results.
-* @param previousResults - The previous hook results to merge with the current result.
-* @returns The merged result.
-*/
-function mergeConfigs(currentResult, previousResults) {
-	if (isString(currentResult)) previousResults = `${isString(previousResults) ? previousResults || "" : ""}\n${currentResult || ""}`.trim();
-	else if (isObject(currentResult)) previousResults = mergeConfig(currentResult, previousResults ?? {});
-	return previousResults;
-}
-/**
-* Calls a hook with the given context, options, and arguments.
-*
-* @param context - The context to use when calling the hook.
-* @param key - The hook to call.
-* @param options - Options for calling the hook.
-* @param args - Arguments to pass to the hook.
-* @returns The return value of the hook.
-*/
-async function callHook(context, key, options, ...args) {
-	const hooks = context.selectHooks(key, options);
-	if (hooks.length > 0) {
-		context.debug(` 🧩 Calling ${hooks.length} ${chalk.bold.cyanBright(`${key}${options?.order ? ` (${options.order})` : ""}`)} plugin hook${hooks.length > 1 ? "s" : ""}:\n${hooks.map((hook, index) => ` ${index + 1}. ${colorText(hook.plugin.name)}`).join("\n")}`);
-		const invokeHook = async (hook, hookArgs) => {
-			return Reflect.apply(hook.handler, hook.context, hookArgs);
-		};
-		let results = [];
-		if (options?.sequential === false) results = await Promise.all(hooks.map(async (hook) => {
-			if (!isFunction(hook.handler)) throw new Error(`Plugin hook handler for hook "${key}" is not a function.`);
-			return invokeHook(hook, [...args]);
-		}));
-		else for (const hook of hooks) {
-			if (!isFunction(hook.handler)) throw new Error(`Plugin hook handler for hook "${key}" is not a function.`);
-			if (options?.result === "first" || options?.asNextParam === false) {
-				results.push(await Promise.resolve(invokeHook(hook, [...args])));
-				if (options?.result === "first" && isSet(results[results.length - 1])) break;
-			} else {
-				const sequenceArgs = [...args];
-				if (results.length > 0 && sequenceArgs.length > 0) sequenceArgs[0] = isFunction(options.asNextParam) ? await Promise.resolve(options.asNextParam(results[0])) : results[0];
-				const result = await Promise.resolve(invokeHook(hook, [...sequenceArgs]));
-				if (result) if (options.result === "last") results = [result];
-				else if (options.result === "merge" && options.merge) results = [results.length > 0 && results[0] ? await Promise.resolve(options.merge(result, results[0])) : result];
-				else results = mergeResults(result, results);
-			}
-		}
-		const definedResults = results.filter((result) => isSet(result));
-		if (definedResults.length > 0) {
-			let mergedResult = void 0;
-			for (const result of definedResults) mergedResult = defu$1(result, mergedResult ?? {});
-			return mergedResult;
-		}
-	}
-}
-function extractHooks(context, hooks, plugin, key, parentKey) {
-	const combinedKey = parentKey ? `${parentKey}:${key}` : key;
-	const pluginField = getField(plugin, combinedKey.replace(/:/g, "."));
-	if (isPluginHookField(combinedKey) && isPluginHook(pluginField)) {
-		const pluginHook = pluginField;
-		if (!isPluginHook(pluginHook)) return hooks;
-		hooks[combinedKey] ??= {
-			preEnforced: [],
-			preOrdered: [],
-			normal: [],
-			postEnforced: [],
-			postOrdered: []
-		};
-		if (plugin.enforce) {
-			const hookListOrder = `${plugin.enforce}Enforced`;
-			hooks[combinedKey][hookListOrder] ??= [];
-			hooks[combinedKey][hookListOrder] = addPluginHook(context, plugin, pluginHook, hooks[combinedKey][hookListOrder]);
-			return hooks;
-		}
-		if (isFunction(pluginHook) || !pluginHook.order) {
-			hooks[combinedKey].normal ??= [];
-			hooks[combinedKey].normal = addPluginHook(context, plugin, pluginHook, hooks[combinedKey].normal);
-			return hooks;
-		}
-		const hookListOrder = `${pluginHook.order}Ordered`;
-		hooks[combinedKey][hookListOrder] ??= [];
-		hooks[combinedKey][hookListOrder] = addPluginHook(context, plugin, pluginHook, hooks[combinedKey][hookListOrder]);
-		return hooks;
-	} else if (isSetObject(pluginField)) return Object.keys(pluginField).map((pluginKey) => extractHooks(context, hooks, plugin, pluginKey, combinedKey)).reduce((ret, current) => {
-		Object.keys(current).forEach((key) => {
-			ret[key] ??= {
-				preEnforced: [],
-				preOrdered: [],
-				normal: [],
-				postEnforced: [],
-				postOrdered: []
-			};
-			[
-				"preEnforced",
-				"preOrdered",
-				"normal",
-				"postEnforced",
-				"postOrdered"
-			].forEach((order) => {
-				if (current[key]?.[order]) {
-					ret[key][order] ??= [];
-					ret[key][order] = ret[key][order].concat(current[key][order]);
-				}
-			});
-		});
-		return ret;
-	}, hooks);
-	return hooks;
-}
-
-//#endregion
-//#region src/context/plugin-context.ts
-/**
-* Create a Proxy-based PluginContext
-*
-* @param plugin - The plugin instance
-* @param environment - The environment context
-* @returns The proxied plugin context
-*/
-function createPluginContext(plugin, environment) {
-	const normalizeMessage = (message) => {
-		return isString(message) ? message : message.message;
-	};
-	const log = environment.extendLog(plugin.name.replaceAll(":", " - "));
-	const callHookFn = async (hook, options, ...args) => {
-		return environment.$$internal.api.callHook(hook, {
-			sequential: true,
-			result: "merge",
-			...options,
-			environment
-		}, ...args);
-	};
-	const meta = {};
-	return new Proxy({}, {
-		get(_, prop) {
-			if (prop === "$$internal") return {
-				...environment.$$internal,
-				environment,
-				callHook: callHookFn,
-				meta
-			};
-			if (prop === "log" || prop === "logger") return log;
-			if (prop === "fatal") return (message) => {
-				log(LogLevelLabel.FATAL, normalizeMessage(message));
-			};
-			if (prop === "error") return (message) => {
-				log(LogLevelLabel.ERROR, normalizeMessage(message));
-			};
-			if (prop === "warn") return (message) => {
-				log(LogLevelLabel.WARN, normalizeMessage(message));
-			};
-			if (prop === "info") return (message) => {
-				log(LogLevelLabel.INFO, normalizeMessage(message));
-			};
-			if (prop === "debug") return (message) => {
-				log(LogLevelLabel.DEBUG, normalizeMessage(message));
-			};
-			if (prop === "trace") return (message) => {
-				log(LogLevelLabel.TRACE, normalizeMessage(message));
-			};
-			return environment[prop];
-		},
-		set(_, prop, value) {
-			if ([
-				"$$internal",
-				"environment",
-				"config",
-				"log",
-				"logger",
-				"error",
-				"warn",
-				"plugins",
-				"hooks",
-				"addPlugin",
-				"selectHooks"
-			].includes(prop)) {
-				log(LogLevelLabel.WARN, `Cannot set read-only property "${String(prop)}"`);
-				return false;
-			}
-			environment[prop] = value;
-			return true;
-		}
-	});
-}
-
-//#endregion
-//#region src/context/environment-context.ts
-var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends PowerlinesContext {
-	/**
-	* The hooks registered by plugins in this environment
-	*/
-	#hooks = {};
-	/**
-	* Create a new context from the config.
-	*
-	* @param options - The resolved execution options.
-	* @param config - The user configuration options.
-	* @returns A promise that resolves to the new context.
-	*/
-	static async fromConfig(options, config, environment) {
-		const context = new PowerlinesEnvironmentContext(options, config, environment);
-		await context.setup();
-		const powerlinesPath = await resolvePackage("powerlines");
-		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
-		context.powerlinesPath = powerlinesPath;
-		return context;
-	}
-	/**
-	* The resolved environment configuration
-	*/
-	environment;
-	/**
-	* The list of plugins applied to this environment
-	*/
-	plugins = [];
-	/**
-	* Create a new logger instance
-	*
-	* @param name - The name to use for the logger instance
-	* @returns A logger function
-	*/
-	createLog(name = null) {
-		return createLog(name, {
-			...this.config,
-			logLevel: isNull(this.config.logLevel) ? "silent" : this.config.logLevel,
-			environment: this.environment?.name
-		});
-	}
-	/**
-	* The hooks registered by plugins in this environment
-	*/
-	get hooks() {
-		return this.#hooks;
-	}
-	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
-	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
-	*
-	* @returns A promise that resolves to the cloned context.
-	*/
-	async clone() {
-		const context = await PowerlinesEnvironmentContext.fromConfig(deepClone(this.options), deepClone(this.config), deepClone(this.environment));
-		return this.copyTo(context);
-	}
-	/**
-	* Initialize the context with the provided configuration options
-	*/
-	async setup() {
-		this.resolvedConfig = mergeConfig({
-			name: this.config.name,
-			title: this.config.title
-		}, getConfigProps(this.environment, this.options.root, this.options.cwd), this.config);
-		await this.innerSetup();
-	}
-	async addPlugin(plugin) {
-		let resolvedPlugin = plugin;
-		if (isFunction(plugin.applyToEnvironment)) {
-			const result = await Promise.resolve(plugin.applyToEnvironment(this.environment));
-			if (!result || isObject(result) && Object.keys(result).length === 0) return;
-			if (isPluginConfig(result)) return this.$$internal.addPlugin(result);
-			resolvedPlugin = isPlugin(result) ? result : plugin;
-		}
-		const context = createPluginContext(resolvedPlugin, this);
-		this.plugins.push({
-			plugin: resolvedPlugin,
-			context
-		});
-		this.#hooks = Object.entries(Object.keys(resolvedPlugin).filter((key) => !PLUGIN_NON_HOOK_FIELDS.includes(key)).reduce((ret, key) => extractHooks(context, ret, resolvedPlugin, key), this.hooks)).reduce((ret, [key, value]) => {
-			if (isSetObject(value)) Object.entries(value).forEach(([type, list]) => {
-				ret[key] ??= {};
-				ret[key][type] = dedupeHooklist(list);
-			});
-			return ret;
-		}, {});
-	}
-	/**
-	* Retrieves the hook handlers for a specific hook name
-	*/
-	selectHooks(key, options) {
-		const result = [];
-		if (isPluginHookField(key) && this.hooks[key]) {
-			if (this.hooks[key]) if (options?.order) {
-				const mapHooksToResult = (hooksList) => hooksList.map((hook) => {
-					const plugin = this.plugins.find((p) => p.plugin.name === hook.plugin.name);
-					if (!plugin) throw new Error(`Could not find plugin context for plugin "${hook.plugin.name}".`);
-					return {
-						handler: hook.handler,
-						plugin: hook.plugin,
-						context: plugin.context
-					};
-				});
-				if (options?.order === "pre") {
-					result.push(...mapHooksToResult(this.hooks[key].preOrdered ?? []));
-					result.push(...mapHooksToResult(this.hooks[key].preEnforced ?? []));
-				} else if (options?.order === "post") {
-					result.push(...mapHooksToResult(this.hooks[key].postOrdered ?? []));
-					result.push(...mapHooksToResult(this.hooks[key].postEnforced ?? []));
-				} else result.push(...mapHooksToResult(this.hooks[key].normal ?? []));
-			} else {
-				result.push(...this.selectHooks(key, { order: "pre" }));
-				result.push(...this.selectHooks(key, { order: "normal" }));
-				result.push(...this.selectHooks(key, { order: "post" }));
-			}
-		}
-		return result;
-	}
-	constructor(options, config, environment) {
-		super(options);
-		this.resolvedConfig = config;
-		this.environment = environment;
-	}
-	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
-	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
-	*
-	* @returns The cloned context.
-	*/
-	copyTo(context) {
-		context.plugins = this.plugins;
-		return super.copyTo(context);
-	}
-};
-
-//#endregion
-//#region src/context/execution-context.ts
-var PowerlinesExecutionContext = class PowerlinesExecutionContext extends PowerlinesContext {
-	#environments = {};
-	#plugins = [];
-	/**
-	* Create a new Storm context from the workspace root and user config.
-	*
-	* @param options - The options for resolving the context.
-	* @returns A promise that resolves to the new context.
-	*/
-	static async fromOptions(options) {
-		const context = new PowerlinesExecutionContext(options);
-		await context.init(options);
-		const powerlinesPath = await resolvePackage("powerlines");
-		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
-		context.powerlinesPath = powerlinesPath;
-		return context;
-	}
-	/**
-	* Create a new Storm context from the workspace root and user config.
-	*
-	* @param options - The options for resolving the context.
-	* @returns A promise that resolves to the new context.
-	*/
-	static async fromConfig(options, config) {
-		const context = new PowerlinesExecutionContext(options);
-		await context.init(options);
-		context.config.inlineConfig = config;
-		if (context.config.inlineConfig.command === "new") {
-			const workspacePackageJsonPath = joinPaths(context.config.cwd, "package.json");
-			if (!existsSync(workspacePackageJsonPath)) throw new Error(`The workspace package.json file could not be found at ${workspacePackageJsonPath}`);
-			context.packageJson = await readJsonFile(workspacePackageJsonPath);
-		}
-		await context.setup();
-		const powerlinesPath = await resolvePackage("powerlines");
-		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
-		context.powerlinesPath = powerlinesPath;
-		return context;
-	}
-	/**
-	* Internal context fields and methods
-	*
-	* @danger
-	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-	*
-	* @internal
-	*/
-	get $$internal() {
-		return super.$$internal;
-	}
-	/**
-	* Internal context fields and methods
-	*
-	* @danger
-	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-	*
-	* @internal
-	*/
-	set $$internal(value) {
-		super.$$internal = value;
-		for (const environment of Object.values(this.environments)) environment.$$internal = super.$$internal;
-	}
-	/**
-	* A record of all environments by name
-	*/
-	get environments() {
-		return this.#environments;
-	}
-	get plugins() {
-		return this.#plugins;
-	}
-	/**
-	* Creates a new instance.
-	*
-	* @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
-	*/
-	constructor(options) {
-		super(options);
-	}
-	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
-	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
-	*
-	* @returns A promise that resolves to the cloned context.
-	*/
-	async clone() {
-		const clone = await PowerlinesExecutionContext.fromOptions(this.options);
-		clone.config.userConfig = deepClone(this.config.userConfig);
-		clone.config.inlineConfig = deepClone(this.config.inlineConfig);
-		clone.config.pluginConfig = deepClone(this.config.pluginConfig);
-		await clone.setup();
-		clone.$$internal = this.$$internal;
-		return this.copyTo(clone);
-	}
-	/**
-	* A function to copy the context and update the fields for a specific environment
-	*
-	* @param environment - The environment configuration to use.
-	* @returns A new context instance with the updated environment.
-	*/
-	async in(environment) {
-		const context = this.copyTo(await PowerlinesEnvironmentContext.fromConfig(deepClone(this.options), deepClone(this.config), deepClone(environment)));
-		context.plugins = [];
-		for (const plugin of this.plugins) await context.addPlugin(plugin);
-		return context;
-	}
-	/**
-	* Update the context using a new inline configuration options
-	*/
-	async setup() {
-		await super.setup();
-		await Promise.all(toArray(this.config.environments && Object.keys(this.config.environments).length > 0 ? Object.keys(this.config.environments).map((name) => createEnvironment(name, this.config)) : createDefaultEnvironment(this.config)).map(async (env) => {
-			this.#environments[env.name] = await this.in(env);
-		}));
-	}
-	/**
-	* Add a plugin to the API context and all environments
-	*
-	* @param plugin - The plugin to add.
-	*/
-	async addPlugin(plugin) {
-		this.plugins.push(plugin);
-		await Promise.all(Object.keys(this.environments).map(async (name) => {
-			await this.environments[name].addPlugin(plugin);
-		}));
-	}
-	/**
-	* Get an environment by name, or the default environment if no name is provided
-	*
-	* @param name - The name of the environment to retrieve.
-	* @returns The requested environment context.
-	*/
-	async getEnvironment(name) {
-		let environment;
-		if (name) environment = this.environments[name];
-		if (Object.keys(this.environments).length === 1) {
-			environment = this.environments[Object.keys(this.environments)[0]];
-			this.debug(`Applying the only configured environment: ${chalk.bold.cyanBright(environment?.environment.name)}`);
-		}
-		if (!environment) {
-			if (name) throw new Error(`Environment "${name}" not found.`);
-			environment = await this.in(createDefaultEnvironment(this.config));
-			this.warn(`No environment specified, and no default environment found. Using a temporary default environment: ${chalk.bold.cyanBright(environment?.environment.name)}`);
-		}
-		return environment;
-	}
-	/**
-	* A safe version of `getEnvironment` that returns `undefined` if the environment is not found
-	*
-	* @param name - The name of the environment to retrieve.
-	* @returns The requested environment context or `undefined` if not found.
-	*/
-	async getEnvironmentSafe(name) {
-		try {
-			return await this.getEnvironment(name);
-		} catch {
-			return;
-		}
-	}
-	/**
-	* A function to merge all configured environments into a single context.
-	*
-	* @remarks
-	* If only one environment is configured, that environment will be returned directly.
-	*
-	* @returns A promise that resolves to a merged/global environment context.
-	*/
-	async toEnvironment() {
-		let environment;
-		if (Object.keys(this.environments).length > 1) {
-			environment = await this.in(createEnvironment(GLOBAL_ENVIRONMENT, this.config));
-			this.debug(`Combined all ${Object.keys(this.environments).length} environments into a single global context.`);
-		} else environment = await this.getEnvironment();
-		return environment;
-	}
-};
-
-//#endregion
-export { mergeConfigs as a, callHook as i, PowerlinesEnvironmentContext as n, PowerlinesContext as o, createPluginContext as r, writeMetaFile as s, PowerlinesExecutionContext as t };
-//# sourceMappingURL=execution-context-D_CXpe9I.mjs.map