@powerlines/plugin-webpack 0.5.132 → 0.5.134

package/dist/unplugin-GJmHohOE.mjs

@@ -1,4617 +0,0 @@
-import { LogLevelLabel } from "@storm-software/config-tools/types";
-import defu$1, { createDefu, defu } from "defu";
-import { omit } from "@stryke/helpers/omit";
-import { joinPaths } from "@stryke/path/join-paths";
-import { relativeToWorkspaceRoot } from "@stryke/fs/get-workspace-root";
-import { createWebpackPlugin, setParseImpl } from "unplugin";
-import { transformAsync } from "@babel/core";
-import { formatLogMessage } from "@storm-software/config-tools/logger/console";
-import { toArray } from "@stryke/convert/to-array";
-import { createDirectory, createDirectorySync } from "@stryke/fs/helpers";
-import { install } from "@stryke/fs/install";
-import { listFiles, listFilesSync } from "@stryke/fs/list-files";
-import { doesPackageMatch, getPackageListing, isPackageExists, isPackageListed } from "@stryke/fs/package-fns";
-import { getResolutionCombinations, resolve, resolvePackage, resolveSync } from "@stryke/fs/resolve";
-import { appendPath } from "@stryke/path/append";
-import { replaceExtension, replacePath } from "@stryke/path/replace";
-import { isError } from "@stryke/type-checks/is-error";
-import { isFunction } from "@stryke/type-checks/is-function";
-import { isNumber } from "@stryke/type-checks/is-number";
-import { isObject } from "@stryke/type-checks/is-object";
-import { isPromiseLike } from "@stryke/type-checks/is-promise";
-import { isSet } from "@stryke/type-checks/is-set";
-import { isSetObject } from "@stryke/type-checks/is-set-object";
-import { isSetString } from "@stryke/type-checks/is-set-string";
-import { isString } from "@stryke/type-checks/is-string";
-import chalk from "chalk";
-import Handlebars from "handlebars";
-import { declare } from "@babel/helper-plugin-utils";
-import * as t from "@babel/types";
-import ts, { flattenDiagnosticMessageText } from "typescript";
-import { InMemoryFileSystemHost, Project } from "ts-morph";
-import { getPackageName, getPackageVersion, hasPackageVersion } from "@stryke/string-format/package";
-import { getObjectDiff } from "@donedeal0/superdiff";
-import { readJsonFile, readJsonFileSync } from "@stryke/fs/json";
-import { StormJSON } from "@stryke/json/storm-json";
-import { findFileDotExtensionSafe, findFileName, findFilePath, hasFileExtension, relativePath } from "@stryke/path/file-path-fns";
-import { titleCase } from "@stryke/string-format/title-case";
-import { exists, existsSync } from "@stryke/fs/exists";
-import { getWorkspaceConfig } from "@storm-software/config-tools/get-config";
-import { loadConfig } from "c12";
-import { getEnvPaths } from "@stryke/env/get-env-paths";
-import { hashDirectory } from "@stryke/hash/hash-files";
-import { murmurhash } from "@stryke/hash/murmurhash";
-import { getUnique, getUniqueBy } from "@stryke/helpers/get-unique";
-import { fetchRequest } from "@stryke/http/fetch";
-import { isParentPath } from "@stryke/path/is-parent-path";
-import { isAbsolute, isAbsolutePath } from "@stryke/path/is-type";
-import { joinPaths as joinPaths$1 } from "@stryke/path/join";
-import { isNull } from "@stryke/type-checks/is-null";
-import { uuid } from "@stryke/unique-id/uuid";
-import { match, tsconfigPathsToRegExp } from "bundle-require";
-import { create } from "flat-cache";
-import { parse } from "oxc-parser";
-import { Agent, Response, interceptors, setGlobalDispatcher } from "undici";
-import { createJiti } from "jiti";
-import { isUndefined } from "@stryke/type-checks/is-undefined";
-import { parseTypeDefinition } from "@stryke/convert/parse-type-definition";
-import { isDirectory, isFile } from "@stryke/fs/is-file";
-import * as $ from "@stryke/capnp";
-import { readFileBuffer, readFileBufferSync, writeFileBuffer } from "@stryke/fs/buffer";
-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 { format, resolveConfig } from "prettier";
-import { getLogFn, getLogLevel } from "@storm-software/config-tools/logger";
-import { getColor } from "@storm-software/config-tools/utilities/colors";
-import { noop } from "@stryke/helpers/noop";
-import { kebabCase } from "@stryke/string-format/kebab-case";
-import { correctPath } from "@stryke/path/correct-path";
-import { slash } from "@stryke/path/slash";
-import { readFile, readFileSync } from "@stryke/fs/read-file";
-import { writeFile, writeFileSync } from "@stryke/fs/write-file";
-import { unlinkSync } from "node:fs";
-import { unlink } from "node:fs/promises";
-import { resolve as resolve$1 } from "node:path";
-import "@stryke/fs/remove-file";
-import "magic-string";
-
-//#region ../powerlines/src/internal/babel/module-resolver-plugin.ts
-function resolveModulePath(nodePath, state) {
-	if (!t.isStringLiteral(nodePath.node)) return;
-	const resolvedPath = state.context?.fs.resolveSync(nodePath.node.value);
-	if (resolvedPath) nodePath.replaceWith(t.stringLiteral(resolvedPath.replace(/\.(?:ts|mts|cts)x?$/, "")));
-}
-const TRANSFORM_FUNCTIONS = [
-	"require",
-	"require.resolve",
-	"System.import",
-	"jest.genMockFromModule",
-	"jest.mock",
-	"jest.unmock",
-	"jest.doMock",
-	"jest.dontMock",
-	"jest.setMock",
-	"jest.requireActual",
-	"jest.requireMock",
-	"require.requireActual",
-	"require.requireMock"
-];
-function matchesPattern(state, calleePath, pattern) {
-	const { node } = calleePath;
-	if (t.isMemberExpression(node)) return calleePath.matchesPattern(pattern);
-	if (!t.isIdentifier(node) || pattern.includes(".")) return false;
-	const name = pattern.split(".")[0];
-	return node.name === name;
-}
-const importVisitors = {
-	CallExpression: (nodePath, state) => {
-		if (state.moduleResolverVisited.has(nodePath)) return;
-		const calleePath = nodePath.get("callee");
-		if (calleePath && TRANSFORM_FUNCTIONS.some((pattern) => matchesPattern(state, calleePath, pattern)) || t.isImport(nodePath.node.callee)) {
-			state.moduleResolverVisited.add(nodePath);
-			resolveModulePath(nodePath.get("arguments.0"), state);
-		}
-	},
-	"ImportDeclaration|ExportDeclaration|ExportAllDeclaration": (nodePath, state) => {
-		if (!nodePath || !nodePath.get("source") || state.moduleResolverVisited.has(nodePath)) return;
-		state.moduleResolverVisited.add(nodePath);
-		resolveModulePath(nodePath.get("source"), state);
-	}
-};
-const moduleResolverBabelPlugin = (context) => {
-	return declare(function builder(api) {
-		let moduleResolverVisited = /* @__PURE__ */ new Set();
-		return {
-			name: "powerlines:module-resolver",
-			manipulateOptions(opts) {
-				opts.filename ??= "unknown";
-			},
-			pre() {
-				moduleResolverVisited = /* @__PURE__ */ new Set();
-			},
-			visitor: { Program: {
-				enter(programPath, state) {
-					programPath.traverse(importVisitors, {
-						...state,
-						context,
-						moduleResolverVisited,
-						api
-					});
-				},
-				exit(programPath, state) {
-					programPath.traverse(importVisitors, {
-						...state,
-						context,
-						moduleResolverVisited,
-						api
-					});
-				}
-			} },
-			post() {
-				moduleResolverVisited.clear();
-			}
-		};
-	});
-};
-
-//#endregion
-//#region ../powerlines/src/lib/typescript/ts-morph.ts
-var VirtualFileSystemHost = class extends InMemoryFileSystemHost {
-	#context;
-	constructor(context) {
-		super();
-		this.#context = context;
-	}
-	deleteSync(path) {
-		this.#context.fs.removeSync(path);
-	}
-	readDirSync(dirPath) {
-		if (!this.#context.fs.isDirectorySync(dirPath)) return [];
-		return this.#context.fs.listSync(dirPath).reduce((ret, entry) => {
-			const fullPath = this.#context.fs.resolveSync(entry);
-			if (fullPath) ret.push({
-				name: entry,
-				isDirectory: this.#context.fs.isDirectorySync(fullPath),
-				isFile: this.#context.fs.isFileSync(fullPath),
-				isSymlink: false
-			});
-			return ret;
-		}, []);
-	}
-	async readFile(filePath) {
-		if (!this.#context.fs.isFileSync(filePath)) return "";
-		return await this.#context.fs.read(filePath);
-	}
-	readFileSync(filePath) {
-		if (!this.#context.fs.isFileSync(filePath)) return "";
-		return this.#context.fs.readSync(filePath);
-	}
-	async writeFile(filePath, fileText) {
-		return this.#context.fs.write(filePath, fileText);
-	}
-	writeFileSync(filePath, fileText) {
-		this.#context.fs.writeSync(filePath, fileText);
-	}
-	async mkdir(dirPath) {
-		await this.#context.fs.mkdir(dirPath);
-	}
-	mkdirSync(dirPath) {
-		this.#context.fs.mkdirSync(dirPath);
-	}
-	async move(srcPath, destPath) {
-		await this.#context.fs.move(srcPath, destPath);
-	}
-	moveSync(srcPath, destPath) {
-		this.#context.fs.moveSync(srcPath, destPath);
-	}
-	async copy(srcPath, destPath) {
-		await this.#context.fs.copy(srcPath, destPath);
-	}
-	copySync(srcPath, destPath) {
-		this.#context.fs.copySync(srcPath, destPath);
-	}
-	async fileExists(filePath) {
-		return this.#context.fs.isFile(filePath);
-	}
-	fileExistsSync(filePath) {
-		return this.#context.fs.isFileSync(filePath);
-	}
-	async directoryExists(dirPath) {
-		return this.#context.fs.isDirectory(dirPath);
-	}
-	directoryExistsSync(dirPath) {
-		return this.#context.fs.isDirectorySync(dirPath);
-	}
-	realpathSync(path) {
-		return this.#context.fs.resolveSync(path) || path;
-	}
-	getCurrentDirectory() {
-		return this.#context.workspaceConfig.workspaceRoot;
-	}
-	async glob(patterns) {
-		return this.#context.fs.glob(patterns);
-	}
-	globSync(patterns) {
-		return this.#context.fs.globSync(patterns);
-	}
-};
-/**
-* Create a ts-morph {@link Project} instance used for type reflection and module manipulation during processing
-*
-* @param context - The Powerlines context
-* @returns A ts-morph {@link Project} instance
-*/
-function createProgram(context, override) {
-	context.log(LogLevelLabel.TRACE, `Creating ts-morph Project instance with configuration from: ${context.tsconfig.tsconfigFilePath}.`);
-	return new Project(defu$1(override ?? {}, {
-		skipAddingFilesFromTsConfig: false,
-		tsConfigFilePath: context.tsconfig.tsconfigFilePath,
-		fileSystem: new VirtualFileSystemHost(context),
-		compilerOptions: defu$1(context.tsconfig.options ?? {}, { lib: ["lib.esnext.full.d.ts"] })
-	}));
-}
-
-//#endregion
-//#region ../powerlines/src/internal/helpers/generate-types.ts
-/**
-* Formats the generated TypeScript types source code.
-*
-* @param code - The generated TypeScript code.
-* @returns The formatted TypeScript code.
-*/
-function formatTypes(code) {
-	return code.replace(/import\s*(?:type\s*)?\{?[\w,\s]*(?:\}\s*)?from\s*(?:'|")@?[a-zA-Z0-9-\\/.]*(?:'|");?/g, "").replaceAll("#private;", "").replace(/__Ω/g, "");
-}
-/**
-* Emits TypeScript declaration types for the provided files using the given TypeScript configuration.
-*
-* @param context - The context containing options and environment paths.
-* @param files - The list of files to generate types for.
-* @returns A promise that resolves to the generated TypeScript declaration types.
-*/
-async function emitTypes(context, files) {
-	context.log(LogLevelLabel.TRACE, `Running the TypeScript compiler for ${files.length} generated runtime files.`);
-	const program = createProgram(context, { skipAddingFilesFromTsConfig: true });
-	program.addSourceFilesAtPaths(files);
-	const result = program.emitToMemory({ emitOnlyDtsFiles: true });
-	let builtinModules = "";
-	for (const file of result.getFiles()) if (!file.filePath.endsWith(".map")) {
-		if (context.builtins.some((builtin) => builtin === file.filePath || context.fs.metadata[builtin]?.id && context.fs.metadata[builtin]?.id === file.filePath)) {
-			const module = await context.fs.resolve(file.filePath);
-			builtinModules += `
-  declare module "${module}" {
-      ${file.text.trim().replace(/^\s*export\s*declare\s*/gm, "export ").replace(/^\s*declare\s*/gm, "")}
-  }
-  `;
-		}
-	}
-	const diagnosticMessages = [];
-	result.getDiagnostics().forEach((diagnostic) => {
-		if (diagnostic.getSourceFile()?.getBaseName()) diagnosticMessages.push(`${diagnostic.getSourceFile()?.getBaseName()} (${(diagnostic.getLineNumber() ?? 0) + 1}): ${flattenDiagnosticMessageText(diagnostic.getMessageText().toString(), "\n")}`);
-		else diagnosticMessages.push(flattenDiagnosticMessageText(diagnostic.getMessageText().toString(), "\n"));
-	});
-	const diagnosticMessage = diagnosticMessages.join("\n");
-	if (diagnosticMessage) throw new Error(`TypeScript compilation failed: \n\n${diagnosticMessage.length > 5e3 ? `${diagnosticMessage.slice(0, 5e3)}...` : diagnosticMessage}`);
-	return formatTypes(builtinModules);
-}
-
-//#endregion
-//#region ../powerlines/src/internal/helpers/hooks.ts
-const mergeResults = createDefu((obj, key, value) => {
-	if (isString(obj[key]) && isString(value)) {
-		obj[key] = `${obj[key] || ""}\n${value || ""}`.trim();
-		return true;
-	}
-	return false;
-});
-/**
-* Calls a hook with the given context, options, and arguments.
-*
-* @param context - The context to use when calling the hook.
-* @param hook - 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, hook, options, ...args) {
-	const handlers = context.selectHooks(hook, options);
-	if (handlers.length > 0) {
-		context.log(LogLevelLabel.DEBUG, ` 🧩  Calling plugin hook: ${chalk.bold.cyanBright(`${hook}${options?.order ? ` (${options.order})` : ""}`)}`);
-		let results = [];
-		if (options?.sequential === false) results = await Promise.all(handlers.map(async (handler) => {
-			if (!isFunction(handler.handle)) throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
-			return Promise.resolve(handler.handle.apply(handler.context, [...args]));
-		}));
-		else for (const handler of handlers) {
-			if (!isFunction(handler.handle)) throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
-			if (options?.result === "first" || options?.asNextParam === false) {
-				results.push(await Promise.resolve(handler.handle.apply(handler.context, [...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(handler.handle.apply(handler.context, [...sequenceArgs]));
-				if (result) {
-					if (options?.result === "last") results = [result];
-					else if (isString(result)) results = [`${isString(results[0]) ? results[0] || "" : ""}\n${result || ""}`.trim()];
-					else if (isObject(result)) results = [mergeResults(result, results[0] ?? {})];
-				}
-			}
-		}
-		const definedResults = results.filter((result) => isSet(result));
-		if (definedResults.length > 0) {
-			let mergedResult = void 0;
-			for (const result of definedResults) mergedResult = defu(result, mergedResult ?? {});
-			return mergedResult;
-		}
-	}
-}
-
-//#endregion
-//#region ../powerlines/src/internal/helpers/install.ts
-/**
-* Installs a package if it is not already installed.
-*
-* @param context - The resolved options
-* @param packageName - The name of the package to install
-* @param dev - Whether to install the package as a dev dependency
-*/
-async function installPackage(context, packageName, dev = false) {
-	if (!await isPackageListed(getPackageName(packageName), { cwd: context.config.projectRoot })) if (context.config.skipInstalls !== true) {
-		context.log(LogLevelLabel.WARN, `The package "${packageName}" is not installed. It will be installed automatically.`);
-		const result = await install(packageName, {
-			cwd: context.config.projectRoot,
-			dev
-		});
-		if (isNumber(result.exitCode) && result.exitCode > 0) {
-			context.log(LogLevelLabel.ERROR, result.stderr);
-			throw new Error(`An error occurred while installing the package "${packageName}"`);
-		}
-	} else context.log(LogLevelLabel.WARN, `The package "${packageName}" is not installed. Since the "skipInstalls" option is set to true, it will not be installed automatically.`);
-	else if (hasPackageVersion(packageName) && !process.env.POWERLINES_SKIP_VERSION_CHECK) {
-		if (!await doesPackageMatch(getPackageName(packageName), getPackageVersion(packageName), context.config.projectRoot)) {
-			const packageListing = await getPackageListing(getPackageName(packageName), { cwd: context.config.projectRoot });
-			if (!packageListing?.version.startsWith("catalog:") && !packageListing?.version.startsWith("workspace:")) context.log(LogLevelLabel.WARN, `The package "${getPackageName(packageName)}" is installed but does not match the expected version ${getPackageVersion(packageName)} (installed version: ${packageListing?.version || "<Unknown>"}). Please ensure this is intentional before proceeding. Note: You can skip this validation with the "STORM_STACK_SKIP_VERSION_CHECK" environment variable.`);
-		}
-	}
-}
-
-//#endregion
-//#region ../powerlines/src/internal/helpers/install-dependencies.ts
-/**
-* Install missing project dependencies.
-*
-* @param context - The build context.
-*/
-async function installDependencies(context) {
-	context.log(LogLevelLabel.TRACE, `Checking and installing missing project dependencies.`);
-	context.dependencies ??= {};
-	context.devDependencies ??= {};
-	if (Object.keys(context.dependencies).length === 0 && Object.keys(context.devDependencies).length === 0) {
-		context.log(LogLevelLabel.TRACE, `No dependencies or devDependencies to install. Skipping installation step.`);
-		return;
-	}
-	context.log(LogLevelLabel.DEBUG, `The following packages are required: \nDependencies: \n${Object.entries(context.dependencies).map(([name, version]) => `- ${name}@${String(version)}`).join(" \n")}\n\nDevDependencies: \n${Object.entries(context.devDependencies).map(([name, version]) => `- ${name}@${String(version)}`).join(" \n")}`);
-	await Promise.all([Promise.all(Object.entries(context.dependencies).map(async ([name, version]) => installPackage(context, `${getPackageName(name)}@${String(version)}`, false))), Promise.all(Object.entries(context.devDependencies).map(async ([name, version]) => installPackage(context, `${getPackageName(name)}@${String(version)}`, true)))]);
-}
-
-//#endregion
-//#region ../powerlines/src/lib/typescript/tsconfig.ts
-/**
-* Get the path to the tsconfig.json file.
-*
-* @param workspaceRoot - The root directory of the workspace.
-* @param projectRoot - The root directory of the project.
-* @param tsconfig - The path to the tsconfig.json file.
-* @returns The absolute path to the tsconfig.json file.
-* @throws If the tsconfig.json file does not exist.
-*/
-function getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig) {
-	let tsconfigFilePath;
-	if (tsconfig) tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, tsconfig);
-	else {
-		tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, "tsconfig.app.json");
-		if (!tsconfigFilePath) {
-			tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, "tsconfig.lib.json");
-			if (!tsconfigFilePath) tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, "tsconfig.json");
-		}
-	}
-	if (!tsconfigFilePath) throw new Error(`Cannot find the \`tsconfig.json\` configuration file for the project at ${projectRoot}.`);
-	return tsconfigFilePath;
-}
-/**
-* Get the path to the tsconfig.json file.
-*
-* @param workspaceRoot - The root directory of the workspace.
-* @param projectRoot - The root directory of the project.
-* @param tsconfig - The path to the tsconfig.json file.
-* @returns The absolute path to the tsconfig.json file.
-* @throws If the tsconfig.json file does not exist.
-*/
-function tryTsconfigFilePath(workspaceRoot, projectRoot, tsconfig) {
-	let tsconfigFilePath = tsconfig;
-	if (!existsSync(tsconfigFilePath)) {
-		tsconfigFilePath = appendPath(tsconfig, projectRoot);
-		if (!existsSync(tsconfigFilePath)) {
-			tsconfigFilePath = appendPath(tsconfig, appendPath(projectRoot, workspaceRoot));
-			if (!existsSync(tsconfigFilePath)) return;
-		}
-	}
-	return tsconfigFilePath;
-}
-/**
-* Check if the TypeScript configuration type matches any of the provided types.
-*
-* @param tsconfigType - The type from the TypeScript configuration.
-* @param types - An array of type names to check against.
-* @returns True if the TypeScript configuration type matches any of the provided types, false otherwise.
-*/
-function findMatch(tsconfigType, types, extensions = [
-	".ts",
-	".tsx",
-	".d.ts"
-]) {
-	return types.find((type) => tsconfigType?.toString().toLowerCase() === type?.toString().toLowerCase() || tsconfigType?.toString().toLowerCase() === `./${type?.toString().toLowerCase()}` || `./${tsconfigType?.toString().toLowerCase()}` === type?.toString().toLowerCase() || extensions.some((ext) => `${tsconfigType?.toString().toLowerCase()}${ext}` === type?.toString().toLowerCase() || `${tsconfigType?.toString().toLowerCase()}${ext}` === `./${type?.toString().toLowerCase()}` || `${type?.toString().toLowerCase()}${ext}` === `./${tsconfigType?.toString().toLowerCase()}` || tsconfigType?.toString().toLowerCase() === `${type?.toString().toLowerCase()}${ext}` || tsconfigType?.toString().toLowerCase() === `./${type?.toString().toLowerCase()}${ext}` || type?.toString().toLowerCase() === `./${tsconfigType?.toString().toLowerCase()}${ext}`));
-}
-/**
-* Check if the TypeScript configuration type matches any of the provided types.
-*
-* @param tsconfigType - The type from the TypeScript configuration.
-* @param types - An array of type names to check against.
-* @returns True if the TypeScript configuration type matches any of the provided types, false otherwise.
-*/
-function findIncludeMatch(tsconfigType, types) {
-	return findMatch(tsconfigType, types, [
-		".ts",
-		".tsx",
-		".d.ts",
-		".js",
-		".jsx",
-		".mjs",
-		".cjs",
-		".mts",
-		".cts",
-		"/*.ts",
-		"/*.tsx",
-		"/*.d.ts",
-		"/*.js",
-		"/*.jsx",
-		"/*.mjs",
-		"/*.cjs",
-		"/*.mts",
-		"/*.cts",
-		"/**/*.ts",
-		"/**/*.tsx",
-		"/**/*.d.ts",
-		"/**/*.js",
-		"/**/*.jsx",
-		"/**/*.mjs",
-		"/**/*.cjs",
-		"/**/*.mts",
-		"/**/*.cts"
-	]);
-}
-/**
-* Check if the TypeScript configuration type matches any of the provided types.
-*
-* @param tsconfigType - The type from the TypeScript configuration.
-* @param types - An array of type names to check against.
-* @returns True if the TypeScript configuration type matches any of the provided types, false otherwise.
-*/
-function isIncludeMatchFound(tsconfigType, types) {
-	return findIncludeMatch(tsconfigType, types) !== void 0;
-}
-/**
-* Get the parsed TypeScript configuration.
-*
-* @param workspaceRoot - The root directory of the workspace.
-* @param projectRoot - The root directory of the project.
-* @param tsconfig - The path to the tsconfig.json file.
-* @param tsconfigRaw - The raw tsconfig.json content.
-* @param originalTsconfigJson - The original tsconfig.json content.
-* @param host - The TypeScript parse config host.
-* @returns The resolved TypeScript configuration.
-*/
-function getParsedTypeScriptConfig(workspaceRoot, projectRoot, tsconfig, tsconfigRaw = {}, originalTsconfigJson, host = ts.sys) {
-	const tsconfigFilePath = getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig);
-	const tsconfigJson = readJsonFileSync(tsconfigFilePath);
-	if (!tsconfigJson) throw new Error(`Cannot find the \`tsconfig.json\` configuration file at ${joinPaths(projectRoot, tsconfig ?? "tsconfig.json")}`);
-	const parsedCommandLine = ts.parseJsonConfigFileContent(defu$1(tsconfigRaw ?? {}, tsconfigJson), host, appendPath(projectRoot, workspaceRoot));
-	if (parsedCommandLine.errors.length > 0) {
-		const errorMessage = `Cannot parse the TypeScript compiler options. Please investigate the following issues:
-${parsedCommandLine.errors.map((error) => `- ${(error.category !== void 0 && error.code ? `[${error.category}-${error.code}]: ` : "") + error.messageText.toString()}`).join("\n")}
-      `;
-		throw new Error(errorMessage);
-	}
-	return {
-		...parsedCommandLine,
-		originalTsconfigJson: originalTsconfigJson ?? tsconfigJson,
-		tsconfigJson,
-		tsconfigFilePath
-	};
-}
-
-//#endregion
-//#region ../powerlines/src/internal/helpers/resolve-tsconfig.ts
-function getTsconfigDtsPath(context) {
-	return joinPaths(relativePath(joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot), findFilePath(context.dtsPath)), findFileName(context.dtsPath));
-}
-async function resolveTsconfigChanges(context) {
-	const tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw);
-	const tsconfigJson = await readJsonFile(getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig));
-	tsconfigJson.compilerOptions ??= {};
-	if (context.config.output.dts !== false) {
-		const dtsRelativePath = getTsconfigDtsPath(context);
-		if (!tsconfigJson.include?.some((filePattern) => isIncludeMatchFound(filePattern, [context.dtsPath, dtsRelativePath]))) {
-			tsconfigJson.include ??= [];
-			tsconfigJson.include.push(dtsRelativePath.startsWith("./") ? dtsRelativePath.slice(2) : dtsRelativePath);
-		}
-	}
-	if (!tsconfig.options.lib?.some((lib) => [
-		"lib.esnext.d.ts",
-		"lib.es2021.d.ts",
-		"lib.es2022.d.ts",
-		"lib.es2023.d.ts"
-	].includes(lib.toLowerCase()))) {
-		tsconfigJson.compilerOptions.lib ??= [];
-		tsconfigJson.compilerOptions.lib.push("esnext");
-	}
-	if (tsconfig.options.esModuleInterop !== true) tsconfigJson.compilerOptions.esModuleInterop = true;
-	if (tsconfig.options.isolatedModules !== true) tsconfigJson.compilerOptions.isolatedModules = true;
-	if (context.config.build.platform === "node") {
-		if (!tsconfig.options.types?.some((type) => type.toLowerCase() === "node" || type.toLowerCase() === "@types/node")) {
-			tsconfigJson.compilerOptions.types ??= [];
-			tsconfigJson.compilerOptions.types.push("node");
-		}
-	}
-	return tsconfigJson;
-}
-async function initializeTsconfig(context) {
-	context.log(LogLevelLabel.TRACE, "Initializing TypeScript configuration (tsconfig.json) for the Powerlines project.");
-	if (!isPackageExists("typescript")) throw new Error("The TypeScript package is not installed. Please install the package using the command: \"npm install typescript --save-dev\"");
-	const tsconfigFilePath = getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
-	context.tsconfig.originalTsconfigJson = await readJsonFile(tsconfigFilePath);
-	context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
-	context.log(LogLevelLabel.TRACE, "Writing updated TypeScript configuration (tsconfig.json) file to disk.");
-	await context.fs.write(tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson));
-	context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw, context.tsconfig.originalTsconfigJson);
-}
-async function resolveTsconfig(context) {
-	const updateTsconfigJson = await readJsonFile(context.tsconfig.tsconfigFilePath);
-	if (updateTsconfigJson?.compilerOptions?.types && Array.isArray(updateTsconfigJson.compilerOptions.types) && !updateTsconfigJson.compilerOptions.types.length) delete updateTsconfigJson.compilerOptions.types;
-	const result = getObjectDiff(context.tsconfig.originalTsconfigJson, updateTsconfigJson, {
-		ignoreArrayOrder: true,
-		showOnly: {
-			statuses: [
-				"added",
-				"deleted",
-				"updated"
-			],
-			granularity: "deep"
-		}
-	});
-	const changes = [];
-	const getChanges = (difference, property) => {
-		if (difference.status === "added" || difference.status === "deleted" || difference.status === "updated") if (difference.diff) for (const diff of difference.diff) getChanges(diff, property ? `${property}.${difference.property}` : difference.property);
-		else changes.push({
-			field: property ? `${property}.${difference.property}` : difference.property,
-			status: difference.status,
-			previous: difference.status === "added" ? "---" : StormJSON.stringify(difference.previousValue),
-			current: difference.status === "deleted" ? "---" : StormJSON.stringify(difference.currentValue)
-		});
-	};
-	for (const diff of result.diff) getChanges(diff);
-	if (changes.length > 0) context.log(LogLevelLabel.WARN, `Updating the following configuration values in "${context.tsconfig.tsconfigFilePath}" file:
-
-    ${changes.map((change, i) => `${chalk.bold.whiteBright(`${i + 1}. ${titleCase(change.status)} the ${change.field} field: `)}
-    ${chalk.red(` - Previous: ${change.previous} `)}
-    ${chalk.green(` - Updated: ${change.current} `)}
-  `).join("\n")}
-    `);
-	await context.fs.write(context.tsconfig.tsconfigFilePath, StormJSON.stringify(updateTsconfigJson));
-	context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
-	if (!context.tsconfig) throw new Error("Failed to parse the TypeScript configuration file.");
-}
-
-//#endregion
-//#region ../powerlines/src/internal/helpers/environment.ts
-const DEFAULT_ENVIRONMENT = "default";
-const GLOBAL_ENVIRONMENT = "__GLOBAL__";
-function createEnvironment(name, userConfig) {
-	return defu$1(userConfig.environments?.[name] ?? {}, {
-		name,
-		title: userConfig.title || titleCase(userConfig.name),
-		ssr: false,
-		mainFields: userConfig.build?.platform === "browser" ? [
-			"browser",
-			"module",
-			"jsnext:main",
-			"jsnext"
-		] : [
-			"module",
-			"jsnext:main",
-			"jsnext"
-		],
-		extensions: [
-			".mjs",
-			".js",
-			".mts",
-			".ts",
-			".jsx",
-			".tsx",
-			".json"
-		],
-		consumer: userConfig.build?.platform === "browser" ? "client" : "server",
-		preview: userConfig.build?.platform === "browser" ? {
-			port: 5173,
-			open: true,
-			strictPort: false,
-			host: "localhost",
-			allowedHosts: ["."],
-			cors: true,
-			headers: {}
-		} : void 0
-	}, userConfig);
-}
-function createDefaultEnvironment(userConfig) {
-	return createEnvironment(DEFAULT_ENVIRONMENT, userConfig);
-}
-
-//#endregion
-//#region ../powerlines/src/lib/config-file.ts
-/**
-* Loads the workspace configuration.
-*
-* @param workspaceRoot - The root directory of the workspace.
-* @param cwd - The current working directory to start searching from.
-* @returns A promise that resolves to the loaded workspace configuration.
-*/
-async function loadWorkspaceConfig(workspaceRoot, cwd) {
-	return defu$1({ workspaceRoot }, await getWorkspaceConfig(true, {
-		cwd,
-		workspaceRoot,
-		useDefault: true
-	}));
-}
-/**
-* Loads the user configuration file for the project.
-*
-* @param projectRoot - The root directory of the project.
-* @param workspaceRoot - The root directory of the workspace.
-* @param jiti - An instance of Jiti to resolve modules from
-* @param command - The {@link PowerlinesCommand} string associated with the current running process
-* @param mode - The mode in which the project is running (default is "production").
-* @param configFile - An optional path to a specific configuration file.
-* @param framework - The framework name to use for default configuration file names.
-* @returns A promise that resolves to the resolved user configuration.
-*/
-async function loadUserConfigFile(projectRoot, workspaceRoot, jiti, command, mode = "production", configFile, framework = "powerlines") {
-	let resolvedUserConfig = {};
-	let resolvedUserConfigFile;
-	if (configFile) resolvedUserConfigFile = existsSync(replacePath(configFile, projectRoot)) ? replacePath(configFile, projectRoot) : existsSync(joinPaths(appendPath(projectRoot, workspaceRoot), replacePath(configFile, projectRoot))) ? joinPaths(appendPath(projectRoot, workspaceRoot), replacePath(configFile, projectRoot)) : existsSync(joinPaths(appendPath(projectRoot, workspaceRoot), configFile)) ? joinPaths(appendPath(projectRoot, workspaceRoot), configFile) : void 0;
-	if (!resolvedUserConfigFile) resolvedUserConfigFile = existsSync(joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.${mode}.config.ts`)) ? joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.${mode}.config.ts`) : existsSync(joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.${mode}.config.js`)) ? joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.${mode}.config.js`) : existsSync(joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.${mode}.config.mts`)) ? joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.${mode}.config.mts`) : existsSync(joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.${mode}.config.mjs`)) ? joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.${mode}.config.mjs`) : existsSync(joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.config.ts`)) ? joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.config.ts`) : existsSync(joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.config.js`)) ? joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.config.js`) : existsSync(joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.config.mts`)) ? joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.config.mts`) : existsSync(joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.config.mjs`)) ? joinPaths(appendPath(projectRoot, workspaceRoot), `${framework}.config.mjs`) : void 0;
-	if (resolvedUserConfigFile) {
-		const resolved = await jiti.import(jiti.esmResolve(resolvedUserConfigFile));
-		if (resolved) {
-			let config = {};
-			if (isFunction(resolved)) config = await Promise.resolve(resolved({
-				command,
-				mode,
-				isSsrBuild: false,
-				isPreview: false
-			}));
-			if (isSetObject(config)) resolvedUserConfig = {
-				...config,
-				config,
-				configFile: resolvedUserConfigFile
-			};
-		}
-	}
-	const result = await loadConfig({
-		cwd: projectRoot,
-		name: framework,
-		envName: mode,
-		globalRc: true,
-		packageJson: true,
-		dotenv: true,
-		jiti
-	});
-	return defu$1(resolvedUserConfig, isSetObject(result?.config) ? {
-		...result.config,
-		...result
-	} : {});
-}
-
-//#endregion
-//#region ../powerlines/src/internal/helpers/resolver.ts
-/**
-* Create a Jiti resolver for the given workspace and project root.
-*
-* @param options - The options for creating the resolver.
-* @returns A Jiti instance configured for the specified workspace and project root.
-*/
-function resolveOptions(options) {
-	return defu$1(options, {
-		interopDefault: true,
-		fsCache: options.mode !== "development" ? joinPaths(options.cacheDir, "jiti") : false,
-		moduleCache: options.mode !== "development"
-	});
-}
-/**
-* Create a Jiti resolver for the given workspace and project root.
-*
-* @param options - The options for creating the resolver.
-* @returns A Jiti instance configured for the specified workspace and project root.
-*/
-function createPluginResolver(options) {
-	return createJiti(joinPaths(options.workspaceRoot, options.projectRoot), resolveOptions({ ...options }));
-}
-/**
-* Create a Jiti resolver for the given workspace and project root.
-*
-* @param options - The options for creating the resolver.
-* @returns A Jiti instance configured for the specified workspace and project root.
-*/
-function createResolver(options) {
-	const baseResolver = createJiti(joinPaths(options.workspaceRoot, options.projectRoot), resolveOptions(options));
-	baseResolver.plugin = createPluginResolver(options);
-	return baseResolver;
-}
-
-//#endregion
-//#region ../powerlines/src/types/build.ts
-const UNPLUGIN_BUILD_VARIANTS = [
-	"rollup",
-	"webpack",
-	"rspack",
-	"vite",
-	"esbuild",
-	"farm",
-	"unloader",
-	"rolldown"
-];
-
-//#endregion
-//#region ../powerlines/src/types/commands.ts
-const SUPPORTED_COMMANDS = [
-	"new",
-	"clean",
-	"prepare",
-	"lint",
-	"test",
-	"build",
-	"docs",
-	"deploy",
-	"finalize"
-];
-
-//#endregion
-//#region ../powerlines/src/types/plugin.ts
-const PLUGIN_NON_HOOK_FIELDS = [
-	"name",
-	"api",
-	"enforce",
-	"dedupe",
-	"applyToEnvironment"
-];
-const KNOWN_HOOKS = [
-	...SUPPORTED_COMMANDS,
-	"config",
-	"configEnvironment",
-	"configResolved",
-	"buildStart",
-	"buildEnd",
-	"transform",
-	"load",
-	"resolveId",
-	"writeBundle"
-];
-const KNOWN_PLUGIN_FIELDS = [
-	...PLUGIN_NON_HOOK_FIELDS,
-	...KNOWN_HOOKS,
-	...UNPLUGIN_BUILD_VARIANTS
-];
-
-//#endregion
-//#region ../powerlines/src/plugin-utils/helpers.ts
-/**
-* Type guard to check if an object is a {@link Plugin}
-*
-* @param value - The object to check
-* @returns True if the object is a {@link Plugin}, false otherwise
-*/
-function isPlugin(value) {
-	return isSetObject(value) && "name" in value && isSetString(value.name) && (isUndefined(value.api) || "api" in value && isSetObject(value.api)) && (isUndefined(value.applyToEnvironment) || "applyToEnvironment" in value && isFunction(value.applyToEnvironment)) && (isUndefined(value.dedupe) || "dedupe" in value && isFunction(value.dedupe)) && KNOWN_HOOKS.every((hook) => isUndefined(value[hook]) || hook in value && (isPluginHookFunction(value[hook]) || hook === "config" && isSetObject(value[hook]))) && UNPLUGIN_BUILD_VARIANTS.every((variant) => isUndefined(value[variant]) || variant in value && isSetObject(value[variant]));
-}
-/**
-* Type guard to check if an object is a {@link PluginConfigObject}
-*
-* @param value - The object to check
-* @returns True if the object is a {@link PluginConfigObject}, false otherwise
-*/
-function isPluginConfigObject(value) {
-	return isSetObject(value) && "plugin" in value && ((isSetString(value.plugin) || isFunction(value.plugin)) && "options" in value && isSetObject(value.options) || isPlugin(value.plugin));
-}
-/**
-* Type guard to check if an object is a {@link PluginConfigTuple}
-*
-* @param value - The object to check
-* @returns True if the object is a {@link PluginConfigTuple}, false otherwise
-*/
-function isPluginConfigTuple(value) {
-	return Array.isArray(value) && (value.length === 1 || value.length === 2) && ((isSetString(value[0]) || isFunction(value[0])) && value.length > 1 && isSetObject(value[1]) || isPlugin(value[0]));
-}
-/**
-* Type guard to check if an object is a {@link PluginConfig}
-*
-* @param value - The object to check
-* @returns True if the object is a {@link PluginConfig}, false otherwise
-*/
-function isPluginConfig(value) {
-	return isSetString(value) || isFunction(value) || isPlugin(value) || isPluginConfigObject(value) || isPluginConfigTuple(value) || Array.isArray(value) && value.every((item) => isPluginConfig(item));
-}
-/**
-* Type guard to check if an value is a {@link PluginHook} function
-*
-* @param value - The value to check
-* @returns True if the value is a {@link PluginHook} function, false otherwise
-*/
-function isPluginHookObject(value) {
-	return isSetObject(value) && "handler" in value && isFunction(value.handler);
-}
-/**
-* Type guard to check if an value is a {@link PluginHook} function
-*
-* @param value - The value to check
-* @returns True if the value is a {@link PluginHook} function, false otherwise
-*/
-function isPluginHookFunction(value) {
-	return isFunction(value) || isPluginHookObject(value);
-}
-/**
-* Type guard to check if an object is a {@link PluginHook}
-*
-* @param value - The object to check
-* @returns True if the object is a {@link PluginHook}, false otherwise
-*/
-function isPluginHook(value) {
-	return isPluginHookFunction(value) || isPluginHookObject(value);
-}
-/**
-* Extract the hook handler function from a plugin hook
-*
-* @param pluginHook - The plugin hook to extract the handler function from
-* @returns The hook handler function
-*/
-function getHookHandler(pluginHook) {
-	return isFunction(pluginHook) ? pluginHook : pluginHook.handler;
-}
-/**
-* Check if a hook is external.
-*
-* @param hook - The name of the hook to check.
-* @returns True if the hook is external, false otherwise.
-*/
-function isHookExternal(hook) {
-	return hook.startsWith("vite:") || hook.startsWith("esbuild:") || hook.startsWith("rolldown:") || hook.startsWith("rollup:") || hook.startsWith("webpack:") || hook.startsWith("rspack:") || hook.startsWith("farm:");
-}
-/**
-* Check if a plugin should be deduplicated.
-*
-* @param plugin - The plugin to check
-* @param plugins - The list of plugins to check against
-* @returns True if the plugin should be deduplicated, false otherwise
-*/
-function checkDedupe(plugin, plugins) {
-	return plugin.dedupe === false || plugins.some((p) => p.dedupe !== false && (isFunction(p.dedupe) && p.dedupe(plugin) || p.name === plugin.name));
-}
-/**
-* Add a plugin hook to the hooks list.
-*
-* @param context - The plugin context
-* @param plugin - The plugin to add the hook from
-* @param pluginHook - The plugin hook to add
-* @param hooksList - The list of hooks to add to
-*/
-function addPluginHook(context, plugin, pluginHook, hooksList) {
-	if (!checkDedupe(plugin, hooksList.map((hook) => hook.plugin))) hooksList.push(isFunction(pluginHook) ? {
-		plugin,
-		handler: getHookHandler(pluginHook).bind(context)
-	} : {
-		plugin,
-		...pluginHook,
-		handler: getHookHandler(pluginHook).bind(context)
-	});
-}
-/**
-* Check the provided {@link PluginConfig}, and return a stringified version of the invalid configuration. If an array is provided, check each item in the array.
-*
-* @param config - The plugin configuration to check
-* @returns Null if the configuration is valid, otherwise an array of stringified invalid configurations
-*/
-function findInvalidPluginConfig(config) {
-	if (isPluginConfig(config)) return null;
-	if (Array.isArray(config)) {
-		const invalidItems = [];
-		config.forEach((item) => {
-			const invalid = findInvalidPluginConfig(item);
-			if (invalid) invalidItems.push(...invalid.map((i) => JSON.stringify(i, null, 2)));
-		});
-		return invalidItems.length > 0 ? invalidItems : null;
-	}
-	return [JSON.stringify(config, null, 2)];
-}
-
-//#endregion
-//#region ../powerlines/src/plugin-utils/paths.ts
-/**
-* Replaces tokens in the given path string with their corresponding values from the context.
-*
-* @remarks
-* The following tokens are supported:
-* - `{workspaceRoot}` - The root directory of the workspace.
-* - `{root}` - The root directory of the project (same as `{projectRoot}`).
-* - `{projectRoot}` - The root directory of the project (same as `{root}`).
-* - `{sourceRoot}` - The source root directory of the project (usually `./src`).
-* - `{powerlinesPath}` - The directory where Powerlines is installed.
-* - `{cachePath}` - The environment's directory for cached files.
-* - `{dataPath}` - The environment's directory for data files.
-* - `{logPath}` - The environment's directory for log files.
-* - `{tempPath}` - The environment's directory for temporary files.
-* - `{configPath}` - The environment's directory for configuration files.
-* - `{outputPath}` - The configured output directory for the project.
-* - `{buildPath}` - The configured distribution directory for the project.
-* - `{artifactsPath}` - The configured directory for build artifacts.
-* - `{builtinPath}` - The configured directory for generated built-in plugins.
-* - `{entryPath}` - The configured directory for generated entry files.
-*
-* @param context - The context containing the values for the path tokens.
-* @param path - The path string with tokens to replace.
-* @returns The path string with tokens replaced by their corresponding values from the context.
-*/
-function replacePathTokens(context, path) {
-	if (!path) return path;
-	return path.replaceAll("{workspaceRoot}", context.workspaceConfig.workspaceRoot).replaceAll("{root}", context.config.projectRoot).replaceAll("{projectRoot}", context.config.projectRoot).replaceAll("{sourceRoot}", context.config.sourceRoot).replaceAll("{powerlinesPath}", context.powerlinesPath).replaceAll("{cachePath}", context.cachePath).replaceAll("{dataPath}", context.dataPath).replaceAll("{logPath}", context.envPaths.log).replaceAll("{tempPath}", context.envPaths.temp).replaceAll("{configPath}", context.envPaths.config).replaceAll("{outputPath}", context.config.output.outputPath).replaceAll("{buildPath}", context.config.output.buildPath).replaceAll("{artifactsPath}", replacePath(context.artifactsPath, context.workspaceConfig.workspaceRoot)).replaceAll("{builtinPath}", replacePath(context.builtinsPath, context.workspaceConfig.workspaceRoot)).replaceAll("{entryPath}", replacePath(context.entryPath, context.workspaceConfig.workspaceRoot));
-}
-
-//#endregion
-//#region ../powerlines/src/lib/entry.ts
-function resolveEntryInputFile(context, typeDefinition) {
-	return replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot));
-}
-function resolveEntryInput(context, typeDefinition) {
-	return {
-		file: resolveEntryInputFile(context, typeDefinition),
-		name: typeDefinition.name
-	};
-}
-function resolveEntryOutput(context, typeDefinition) {
-	return replaceExtension(replacePath(replacePath(replacePath(replacePath(replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.sourceRoot)), joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot)), context.config.sourceRoot), context.config.projectRoot), replacePath(context.config.sourceRoot, context.config.projectRoot)));
-}
-function resolveEntry(context, typeDefinition) {
-	const input = resolveEntryInput(context, typeDefinition);
-	return {
-		...input,
-		input,
-		output: resolveEntryOutput(context, typeDefinition)
-	};
-}
-/**
-* Resolves multiple type definitions into their corresponding resolved entry type definitions.
-*
-* @param context - The current context
-* @param typeDefinitions - The type definitions to resolve.
-* @returns A promise that resolves to an array of resolved entry type definitions.
-*/
-function resolveEntriesSync(context, typeDefinitions) {
-	return typeDefinitions.map((entry) => isString(entry) ? replacePathTokens(context, entry) : replacePathTokens(context, entry.file)).map((typeDefinition) => {
-		const parsed = parseTypeDefinition(typeDefinition);
-		const filePath = appendPath(parsed.file, context.config.projectRoot);
-		if (isFile(filePath)) return resolveEntry(context, {
-			file: replacePath(filePath, context.config.projectRoot),
-			name: parsed.name
-		});
-		return listFilesSync(filePath).map((file) => resolveEntry(context, {
-			file,
-			name: parsed.name
-		}));
-	}).flat().filter(Boolean);
-}
-/**
-* Get unique entries from the provided list.
-*
-* @param entries - The entries to process.
-* @returns An array of unique entries (by file path or content hash).
-*/
-function getUniqueEntries(entries = []) {
-	return getUniqueBy(toArray(entries), (item) => isSetString(item) ? item : murmurhash(item ?? {}, { maxLength: 24 }));
-}
-
-//#endregion
-//#region ../powerlines/schemas/fs.ts
-var FileMetadata_KeyValuePair = class extends $.Struct {
-	static _capnp = {
-		displayName: "KeyValuePair",
-		id: "eabb26cf58b2a14c",
-		size: new $.ObjectSize(0, 2)
-	};
-	get key() {
-		return $.utils.getText(0, this);
-	}
-	set key(value) {
-		$.utils.setText(0, value, this);
-	}
-	get value() {
-		return $.utils.getText(1, this);
-	}
-	set value(value) {
-		$.utils.setText(1, value, this);
-	}
-	toString() {
-		return "FileMetadata_KeyValuePair_" + super.toString();
-	}
-};
-/**
-* The identifier for the file data.
-*
-*/
-var FileMetadata = class FileMetadata extends $.Struct {
-	static KeyValuePair = FileMetadata_KeyValuePair;
-	static _capnp = {
-		displayName: "FileMetadata",
-		id: "8e2cab5d7e28c7b3",
-		size: new $.ObjectSize(8, 3),
-		defaultType: "normal"
-	};
-	static _Properties;
-	/**
-	* The type of the file.
-	*
-	*/
-	get id() {
-		return $.utils.getText(0, this);
-	}
-	set id(value) {
-		$.utils.setText(0, value, this);
-	}
-	/**
-	* The timestamp representing the file's creation date.
-	*
-	*/
-	get type() {
-		return $.utils.getText(1, this, FileMetadata._capnp.defaultType);
-	}
-	set type(value) {
-		$.utils.setText(1, value, this);
-	}
-	/**
-	* Additional metadata associated with the file.
-	*
-	*/
-	get timestamp() {
-		return $.utils.getUint32(0, this);
-	}
-	set timestamp(value) {
-		$.utils.setUint32(0, value, this);
-	}
-	_adoptProperties(value) {
-		$.utils.adopt(value, $.utils.getPointer(2, this));
-	}
-	_disownProperties() {
-		return $.utils.disown(this.properties);
-	}
-	get properties() {
-		return $.utils.getList(2, FileMetadata._Properties, this);
-	}
-	_hasProperties() {
-		return !$.utils.isNull($.utils.getPointer(2, this));
-	}
-	_initProperties(length) {
-		return $.utils.initList(2, FileMetadata._Properties, length, this);
-	}
-	set properties(value) {
-		$.utils.copyFrom(value, $.utils.getPointer(2, this));
-	}
-	toString() {
-		return "FileMetadata_" + super.toString();
-	}
-};
-/**
-* An identifier for the file.
-*
-*/
-var FileId = class extends $.Struct {
-	static _capnp = {
-		displayName: "FileId",
-		id: "990d6a471072f997",
-		size: new $.ObjectSize(0, 2)
-	};
-	/**
-	* A virtual (or actual) path to the file in the file system.
-	*
-	*/
-	get id() {
-		return $.utils.getText(0, this);
-	}
-	set id(value) {
-		$.utils.setText(0, value, this);
-	}
-	get path() {
-		return $.utils.getText(1, this);
-	}
-	set path(value) {
-		$.utils.setText(1, value, this);
-	}
-	toString() {
-		return "FileId_" + super.toString();
-	}
-};
-/**
-* An identifier for the file.
-*
-*/
-var FileStorage = class extends $.Struct {
-	static _capnp = {
-		displayName: "FileStorage",
-		id: "9dca66ac858c9ebe",
-		size: new $.ObjectSize(0, 2)
-	};
-	/**
-	* A virtual (or actual) path to the file in the file system.
-	*
-	*/
-	get path() {
-		return $.utils.getText(0, this);
-	}
-	set path(value) {
-		$.utils.setText(0, value, this);
-	}
-	get code() {
-		return $.utils.getText(1, this);
-	}
-	set code(value) {
-		$.utils.setText(1, value, this);
-	}
-	toString() {
-		return "FileStorage_" + super.toString();
-	}
-};
-var FileSystem = class FileSystem extends $.Struct {
-	static _capnp = {
-		displayName: "FileSystem",
-		id: "ae0c23d43e56abcf",
-		size: new $.ObjectSize(0, 3)
-	};
-	static _Ids;
-	static _Storage;
-	static _Metadata;
-	_adoptIds(value) {
-		$.utils.adopt(value, $.utils.getPointer(0, this));
-	}
-	_disownIds() {
-		return $.utils.disown(this.ids);
-	}
-	get ids() {
-		return $.utils.getList(0, FileSystem._Ids, this);
-	}
-	_hasIds() {
-		return !$.utils.isNull($.utils.getPointer(0, this));
-	}
-	_initIds(length) {
-		return $.utils.initList(0, FileSystem._Ids, length, this);
-	}
-	set ids(value) {
-		$.utils.copyFrom(value, $.utils.getPointer(0, this));
-	}
-	_adoptStorage(value) {
-		$.utils.adopt(value, $.utils.getPointer(1, this));
-	}
-	_disownStorage() {
-		return $.utils.disown(this.storage);
-	}
-	get storage() {
-		return $.utils.getList(1, FileSystem._Storage, this);
-	}
-	_hasStorage() {
-		return !$.utils.isNull($.utils.getPointer(1, this));
-	}
-	_initStorage(length) {
-		return $.utils.initList(1, FileSystem._Storage, length, this);
-	}
-	set storage(value) {
-		$.utils.copyFrom(value, $.utils.getPointer(1, this));
-	}
-	_adoptMetadata(value) {
-		$.utils.adopt(value, $.utils.getPointer(2, this));
-	}
-	_disownMetadata() {
-		return $.utils.disown(this.metadata);
-	}
-	get metadata() {
-		return $.utils.getList(2, FileSystem._Metadata, this);
-	}
-	_hasMetadata() {
-		return !$.utils.isNull($.utils.getPointer(2, this));
-	}
-	_initMetadata(length) {
-		return $.utils.initList(2, FileSystem._Metadata, length, this);
-	}
-	set metadata(value) {
-		$.utils.copyFrom(value, $.utils.getPointer(2, this));
-	}
-	toString() {
-		return "FileSystem_" + super.toString();
-	}
-};
-FileMetadata._Properties = $.CompositeList(FileMetadata_KeyValuePair);
-FileSystem._Ids = $.CompositeList(FileId);
-FileSystem._Storage = $.CompositeList(FileStorage);
-FileSystem._Metadata = $.CompositeList(FileMetadata);
-
-//#endregion
-//#region ../powerlines/src/lib/logger.ts
-/**
-* Create a logging function with a specific name and options.
-*
-* @param name - The name of the logging function.
-* @param options - The options to configure the logging function.
-* @returns A logging function.
-*/
-const createLog = (name, options = {}) => {
-	const logLevel = options.logLevel === null ? LogLevelLabel.SILENT : options.logLevel || LogLevelLabel.INFO;
-	if (logLevel === LogLevelLabel.SILENT) return noop;
-	if (options.customLogger) return options.customLogger;
-	return (type, ...args) => getLogFn(getLogLevel(type), {
-		...options,
-		logLevel
-	})(`${chalk.bold.hex(getColor("brand", options))(`${name ? kebabCase(name) : ""}${options.name ? `${name ? chalk.gray(" > ") : ""}${kebabCase(options.name)}` : ""}${chalk.gray(" > ")}`)}${args.join(" ")} `.trim());
-};
-const BADGE_COLORS = [
-	"#00A0DD",
-	"#6FCE4E",
-	"#FBBF24",
-	"#F43F5E",
-	"#3B82F6",
-	"#A855F7",
-	"#469592",
-	"#288EDF",
-	"#D8B4FE",
-	"#10B981",
-	"#EF4444",
-	"#F0EC56",
-	"#F472B6",
-	"#22D3EE",
-	"#EAB308",
-	"#84CC16",
-	"#F87171",
-	"#0EA5E9",
-	"#D946EF",
-	"#FACC15",
-	"#34D399",
-	"#8B5CF6"
-];
-const extendLog = (logFn, name) => {
-	return (type, ...args) => logFn(type, ` ${chalk.inverse.hex(BADGE_COLORS[name.split("").map((char) => char.charCodeAt(0)).reduce((ret, charCode) => ret + charCode, 0) % BADGE_COLORS.length] || BADGE_COLORS[0])(` ${titleCase(name)} `)}  ${args.join(" ")} `);
-};
-
-//#endregion
-//#region ../powerlines/src/lib/fs/helpers.ts
-/**
-* Checks if an error is a file system error.
-*
-* @param err - The error to check.
-* @returns `true` if the error is a file system error, otherwise `false`.
-*/
-function isFileError(err) {
-	return isError(err) && "code" in err && err.code;
-}
-/**
-* Ignores file not found errors.
-*
-* @param err - The error to check.
-* @returns `null` if the error is a file not found error, otherwise returns the error.
-*/
-function ignoreNotfound(err) {
-	return isFileError(err) && (err.code === "ENOENT" || err.code === "EISDIR" ? null : err);
-}
-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 prepending the 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 `${prefix.replace(/:$/, "")}:${toFilePath(id).replace(/* @__PURE__ */ new RegExp(`^${prefix.replace(/:$/, "")}:`), "").replace(/^\\0/, "").replace(findFileDotExtensionSafe(toFilePath(id)), "")}`;
-}
-/**
-* 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") {
-	return isAbsolutePath(path) ? path : isValidId(toFilePath(path), prefix) ? normalizeId(toFilePath(path), prefix).replace(/* @__PURE__ */ 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$1(pattern.input || workspaceRoot, pattern.glob || "**/*");
-		else if (!isSetString(pattern)) return;
-		return pattern;
-	}).filter(isSetString));
-}
-
-//#endregion
-//#region ../powerlines/src/lib/fs/storage/base.ts
-/**
-* Abstract base class for storage adapters, providing a template for storage operations.
-*/
-var BaseStorageAdapter = class {
-	/**
-	* Indicates whether the storage adapter has been disposed.
-	*/
-	#isDisposed = false;
-	/**
-	* Configuration options for the storage adapter.
-	*/
-	options;
-	/**
-	* The storage preset for the adapter.
-	*
-	* @remarks
-	* This can be used as an alternate way to identify the type of storage being used.
-	*/
-	preset = null;
-	/**
-	* Constructor for the BaseStorageAdapter.
-	*
-	* @param options - Configuration options for the storage adapter.
-	*/
-	constructor(options = { base: "/" }) {
-		this.options = options;
-		this.options.base = resolve$1(options.base);
-		this.options.isReadOnly = !!options.isReadOnly;
-	}
-	/**
-	* Asynchronously checks if a key exists in the storage.
-	*
-	* @param key - The key to check for existence.
-	* @returns A promise that resolves to `true` if the key exists, otherwise `false`.
-	*/
-	async exists(key) {
-		return this.existsSync(key);
-	}
-	/**
-	* Asynchronously retrieves the value associated with a given key.
-	*
-	* @param key - The key whose value is to be retrieved.
-	* @returns A promise that resolves to the value associated with the key, or `null` if the key does not exist.
-	*/
-	async get(key) {
-		return this.getSync(key);
-	}
-	/**
-	* Asynchronously sets the value for a given key.
-	*
-	* @param key - The key to set the value for.
-	* @param value - The value to set.
-	*/
-	async set(key, value) {
-		if (!this.options.isReadOnly) this.setSync(key, value);
-	}
-	/**
-	* Synchronously creates a directory at the specified path.
-	*
-	* @param _ - The path of the directory to create.
-	*/
-	mkdirSync(_) {}
-	/**
-	* Creates a directory at the specified path.
-	*
-	* @param dirPath - The path of the directory to create.
-	*/
-	async mkdir(dirPath) {
-		return Promise.resolve(this.mkdirSync(dirPath));
-	}
-	/**
-	* Asynchronously removes a key from the storage.
-	*
-	* @param key - The key to remove.
-	*/
-	async remove(key) {
-		if (!this.options.isReadOnly) this.removeSync(key);
-	}
-	/**
-	* Synchronously removes all entries from the storage that match the provided base path.
-	*
-	* @param base - The base path to clear keys from.
-	*/
-	clearSync(base) {
-		if (!this.options.isReadOnly) {
-			const keys = this.listSync(base || this.options.base);
-			if (!keys.length) return;
-			keys.map((key) => this.removeSync(base && !key.startsWith(base) ? joinPaths$1(base, key) : key));
-		}
-	}
-	/**
-	* Asynchronously removes all entries from the storage that match the provided base path.
-	*
-	* @param base - The base path to clear keys from.
-	* @returns A promise that resolves when the operation is complete.
-	*/
-	async clear(base) {
-		if (!this.options.isReadOnly) {
-			const keys = await this.list(base || this.options.base);
-			if (!keys.length) return;
-			await Promise.all(keys.map(async (key) => this.remove(base && !key.startsWith(base) ? joinPaths$1(base, key) : key)));
-		}
-	}
-	/**
-	* Asynchronously lists all keys under a given base path.
-	*
-	* @param base - The base path to list keys from.
-	* @returns A promise that resolves to an array of keys under the specified base path.
-	*/
-	async list(base) {
-		return this.listSync(base);
-	}
-	/**
-	* Synchronously checks if the given key is a directory.
-	*
-	* @param _ - The key to check.
-	* @returns `true` if the key is a directory, otherwise `false`.
-	*/
-	isDirectorySync(_) {
-		return false;
-	}
-	/**
-	* Checks if the given key is a directory.
-	*
-	* @param key - The key to check.
-	* @returns A promise that resolves to `true` if the key is a directory, otherwise `false`.
-	*/
-	async isDirectory(key) {
-		return Promise.resolve(this.isDirectorySync(key));
-	}
-	/**
-	* Synchronously checks if the given key is a file.
-	*
-	* @param key - The key to check.
-	* @returns `true` if the key is a file, otherwise `false`.
-	*/
-	isFileSync(key) {
-		return this.existsSync(key) && !this.isDirectorySync(key);
-	}
-	/**
-	* Checks if the given key is a file.
-	*
-	* @param key - The key to check.
-	* @returns A promise that resolves to `true` if the key is a file, otherwise `false`.
-	*/
-	async isFile(key) {
-		return Promise.resolve(this.isFileSync(key));
-	}
-	/**
-	* Disposes of the storage adapter, releasing any held resources.
-	*
-	* @returns A promise that resolves when the disposal is complete.
-	*/
-	dispose() {
-		return Promise.resolve();
-	}
-	/**
-	* Async dispose method to clean up resources.
-	*
-	* @returns A promise that resolves when disposal is complete.
-	*/
-	async [Symbol.asyncDispose]() {
-		return this._dispose();
-	}
-	/**
-	* Resolves a given key to its full path within the storage adapter.
-	*
-	* @param key - The key to resolve.
-	* @returns The resolved full path for the key.
-	*/
-	resolve(key = this.options.base) {
-		if (/\.\.:|\.\.$/.test(key)) throw new Error(`[${this.name}]: Invalid key: ${JSON.stringify(key)} provided to storage adapter.`);
-		return appendPath(correctPath(key).replace(/:/g, "/"), this.options.base);
-	}
-	/**
-	* Disposes of the storage adapter, releasing any held resources.
-	*
-	* @returns A promise that resolves when the disposal is complete.
-	*/
-	async _dispose() {
-		if (!this.#isDisposed) {
-			await Promise.resolve(this.dispose());
-			this.#isDisposed = true;
-		}
-	}
-};
-
-//#endregion
-//#region ../powerlines/src/lib/fs/storage/file-system.ts
-/**
-* File system storage adapter implementation.
-*/
-var FileSystemStorageAdapter = class extends BaseStorageAdapter {
-	/**
-	* A name identifying the storage adapter type.
-	*/
-	name = "file-system";
-	/**
-	* The storage preset for the adapter.
-	*
-	* @remarks
-	* This can be used as an alternate way to identify the type of storage being used.
-	*/
-	preset = "fs";
-	/**
-	* Constructor for the FileSystemStorageAdapter.
-	*
-	* @param options - Configuration options for the storage adapter.
-	*/
-	constructor(options) {
-		super(options);
-	}
-	/**
-	* Synchronously checks if a key exists in the storage.
-	*
-	* @param key - The key to check for existence.
-	* @returns Returns `true` if the key exists, otherwise `false`.
-	*/
-	existsSync(key) {
-		return existsSync(this.resolve(key));
-	}
-	/**
-	* Asynchronously checks if a key exists in the storage.
-	*
-	* @param key - The key to check for existence.
-	* @returns A promise that resolves to `true` if the key exists, otherwise `false`.
-	*/
-	async exists(key) {
-		return exists(this.resolve(key));
-	}
-	/**
-	* Synchronously retrieves the value associated with a given key.
-	*
-	* @param key - The key whose value is to be retrieved.
-	* @returns The value associated with the key, or `null` if the key does not exist.
-	*/
-	getSync(key) {
-		return readFileSync(this.resolve(key));
-	}
-	/**
-	* Asynchronously retrieves the value associated with a given key.
-	*
-	* @param key - The key whose value is to be retrieved.
-	* @returns A promise that resolves to the value associated with the key, or `null` if the key does not exist.
-	*/
-	async get(key) {
-		return readFile(this.resolve(key));
-	}
-	/**
-	* Synchronously sets the value for a given key.
-	*
-	* @param key - The key to set the value for.
-	* @param value - The value to set.
-	*/
-	setSync(key, value) {
-		if (!this.options.isReadOnly) return writeFileSync(this.resolve(key), value);
-	}
-	/**
-	* Asynchronously sets the value for a given key.
-	*
-	* @param key - The key to set the value for.
-	* @param value - The value to set.
-	*/
-	async set(key, value) {
-		if (!this.options.isReadOnly) return writeFile(this.resolve(key), value);
-	}
-	/**
-	* Synchronously removes a key from the storage.
-	*
-	* @param key - The key to remove.
-	*/
-	removeSync(key) {
-		if (!this.options.isReadOnly) try {
-			return unlinkSync(this.resolve(key));
-		} catch (err) {
-			return ignoreNotfound(err);
-		}
-	}
-	/**
-	* Asynchronously removes a key from the storage.
-	*
-	* @param key - The key to remove.
-	*/
-	async remove(key) {
-		if (!this.options.isReadOnly) return unlink(this.resolve(key)).catch(ignoreNotfound);
-	}
-	/**
-	* Synchronously creates a directory at the specified path.
-	*
-	* @param dirPath - The path of the directory to create.
-	*/
-	mkdirSync(dirPath) {
-		createDirectorySync(this.resolve(dirPath));
-	}
-	/**
-	* Creates a directory at the specified path.
-	*
-	* @param dirPath - The path of the directory to create.
-	*/
-	async mkdir(dirPath) {
-		await createDirectory(this.resolve(dirPath));
-	}
-	/**
-	* Lists all keys under a given base path synchronously.
-	*
-	* @param base - The base path to list keys from.
-	* @returns An array of keys under the specified base path.
-	*/
-	listSync(base) {
-		try {
-			return listFilesSync(this.resolve(base), { ignore: this.options.ignore });
-		} catch (err) {
-			return ignoreNotfound(err) ?? [];
-		}
-	}
-	/**
-	* Asynchronously lists all keys under a given base path.
-	*
-	* @param base - The base path to list keys from.
-	* @returns A promise that resolves to an array of keys under the specified base path.
-	*/
-	async list(base) {
-		return listFiles(this.resolve(base), { ignore: this.options.ignore }).catch(ignoreNotfound).then((r) => r || []);
-	}
-	/**
-	* Synchronously checks if the given key is a directory.
-	*
-	* @param key - The key to check.
-	* @returns `true` if the key is a directory, otherwise `false`.
-	*/
-	isDirectorySync(key) {
-		return isDirectory(this.resolve(key));
-	}
-	/**
-	* Synchronously checks if the given key is a file.
-	*
-	* @param key - The key to check.
-	* @returns `true` if the key is a file, otherwise `false`.
-	*/
-	isFileSync(key) {
-		return !isFile(this.resolve(key));
-	}
-};
-
-//#endregion
-//#region ../powerlines/src/lib/fs/storage/virtual.ts
-/**
-* Virtual/in-memory storage adapter implementation.
-*/
-var VirtualStorageAdapter = class extends BaseStorageAdapter {
-	/**
-	* A name identifying the storage adapter type.
-	*/
-	name = "virtual";
-	/**
-	* The storage preset for the adapter.
-	*
-	* @remarks
-	* This can be used as an alternate way to identify the type of storage being used.
-	*/
-	preset = "virtual";
-	/**
-	* In-memory data storage.
-	*/
-	data = /* @__PURE__ */ new Map();
-	/**
-	* Constructor for the VirtualStorageAdapter.
-	*
-	* @param options - Configuration options for the storage adapter.
-	*/
-	constructor(options) {
-		super(options);
-	}
-	/**
-	* Synchronously checks if a key exists in the storage.
-	*
-	* @param key - The key to check for existence.
-	* @returns Returns `true` if the key exists, otherwise `false`.
-	*/
-	existsSync(key) {
-		return this.data.has(this.resolve(key));
-	}
-	/**
-	* Synchronously retrieves the value associated with a given key.
-	*
-	* @param key - The key whose value is to be retrieved.
-	* @returns The value associated with the key, or `null` if the key does not exist.
-	*/
-	getSync(key) {
-		return this.data.get(this.resolve(key)) ?? null;
-	}
-	/**
-	* Synchronously sets the value for a given key.
-	*
-	* @param key - The key to set the value for.
-	* @param value - The value to set.
-	*/
-	setSync(key, value) {
-		if (!this.options.isReadOnly) this.data.set(this.resolve(key), value);
-	}
-	/**
-	* Synchronously removes a key from the storage.
-	*
-	* @param key - The key to remove.
-	*/
-	removeSync(key) {
-		if (!this.options.isReadOnly) this.data.delete(this.resolve(key));
-	}
-	/**
-	* Lists all keys under a given base path synchronously.
-	*
-	* @param base - The base path to list keys from.
-	* @returns An array of keys under the specified base path.
-	*/
-	listSync(base) {
-		return [...this.data.keys().filter((key) => !base ? true : isParentPath(key, this.resolve(base)))];
-	}
-	/**
-	* Disposes of the storage adapter, releasing any held resources.
-	*
-	* @returns A promise that resolves when the disposal is complete.
-	*/
-	async dispose() {
-		return this.clear();
-	}
-};
-
-//#endregion
-//#region ../powerlines/src/lib/fs/vfs.ts
-/**
-* 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 virtual file IDs to their underlying file paths.
-	*/
-	#ids;
-	/**
-	* A map of underlying file paths to their virtual file IDs.
-	*/
-	#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 = { "": new FileSystemStorageAdapter() };
-	/**
-	* 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.output.builtinPrefix);
-	}
-	/**
-	* 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) {
-		return normalizePath(path.includes("{") || path.includes("}") ? replacePathTokens(this.#context, path) : path, this.#context.builtinsPath, this.#context.config.output.builtinPrefix);
-	}
-	/**
-	* Builds a regular expression from a string pattern for path matching.
-	*
-	* @param path - The string pattern to convert.
-	* @returns A regular expression for matching paths.
-	*/
-	#buildRegex(path) {
-		const token = "::GLOBSTAR::";
-		return /* @__PURE__ */ new RegExp(`^${this.#normalizePath(path).replace(/\*\*/g, token).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(new RegExp(token, "g"), ".*")}$`);
-	}
-	/**
-	* 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) {
-		const found = Object.entries(this.#storage).find(([, adapter]) => adapter.name === key || adapter.preset && adapter.preset.toLowerCase() === key?.toLowerCase());
-		if (found) return {
-			base: found[0],
-			relativeKey: "",
-			adapter: found[1]
-		};
-		const path = this.resolveSync(this.#normalizePath(key)) || key;
-		for (const base of Object.keys(this.#storage).filter(Boolean).sort().reverse()) if (isParentPath(path, base)) return {
-			base,
-			relativeKey: replacePath(path, base),
-			adapter: this.#storage[base]
-		};
-		return {
-			base: "",
-			relativeKey: path,
-			adapter: this.#storage[""]
-		};
-	}
-	/**
-	* 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) {
-		return Object.keys(this.#storage).sort().reverse().filter((key) => isParentPath(key, base) || includeParent && isParentPath(base, key)).map((key) => ({
-			relativeBase: base.length > key.length ? base.slice(key.length) : void 0,
-			base: key,
-			adapter: this.#storage[key]
-		}));
-	}
-	/**
-	* 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) {
-		if (!context.config.skipCache && existsSync(joinPaths(context.dataPath, "fs.bin"))) {
-			const buffer = await readFileBuffer(joinPaths(context.dataPath, "fs.bin"));
-			const fs = new $.Message(buffer, false).getRoot(FileSystem);
-			const result = new VirtualFileSystem(context, fs);
-			if (fs._hasStorage() && fs.storage.length > 0) await Promise.all(fs.storage.values().map(async (file) => {
-				await result.write(file.path, file.code);
-			}));
-		}
-		return new VirtualFileSystem(context, new $.Message().initRoot(FileSystem));
-	}
-	/**
-	* 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) {
-		if (!context.config.skipCache && existsSync(joinPaths(context.dataPath, "fs.bin"))) {
-			const buffer = readFileBufferSync(joinPaths(context.dataPath, "fs.bin"));
-			const fs = new $.Message(buffer, false).getRoot(FileSystem);
-			const result = new VirtualFileSystem(context, fs);
-			if (fs._hasStorage() && fs.storage.length > 0) fs.storage.values().map((file) => {
-				result.writeSync(file.path, file.code);
-			});
-		}
-		return new VirtualFileSystem(context, new $.Message().initRoot(FileSystem));
-	}
-	/**
-	* A map of file ids to their metadata.
-	*/
-	get metadata() {
-		return new Proxy(this.#metadata, { get: (target, prop) => {
-			return target[this.#normalizeId(prop)];
-		} });
-	}
-	/**
-	* A map of file paths to their module ids.
-	*/
-	get ids() {
-		return new Proxy(this.#paths, { get: (target, prop) => {
-			return target[this.#normalizePath(prop)];
-		} });
-	}
-	/**
-	* A map of module ids to their file paths.
-	*/
-	get paths() {
-		return new Proxy(this.#paths, { get: (target, prop) => {
-			return target[this.#normalizeId(prop)];
-		} });
-	}
-	/**
-	* Gets the resolver cache.
-	*/
-	get resolverCache() {
-		if (!this.#resolverCache) this.#resolverCache = create({
-			cacheId: "module-resolution",
-			cacheDir: this.#context.cachePath,
-			ttl: 3600 * 1e3,
-			lruSize: 5e3,
-			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;
-		if (isSetObject(this.#context.config.output.storage)) this.#storage = {
-			...this.#storage,
-			...this.#context.config.output.storage
-		};
-		this.#storage.virtual ??= new VirtualStorageAdapter({ base: "/_virtual" });
-		if (this.#context.config.output.storage !== "fs") {
-			this.#storage[this.#context.artifactsPath] ??= new VirtualStorageAdapter({ base: this.#context.artifactsPath });
-			this.#storage[this.#context.builtinsPath] ??= new VirtualStorageAdapter({ base: this.#context.builtinsPath });
-			this.#storage[this.#context.entryPath] ??= new VirtualStorageAdapter({ 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$1, item) => {
-						ret$1[item.key] = item.value;
-						return ret$1;
-					}, {}) : {}
-				};
-				return ret;
-			}, {});
-			if (context.config.skipCache !== true) Object.entries(this.#metadata).filter(([, value]) => value.type === "entry").forEach(([id, value]) => {
-				this.#context.entry ??= [];
-				this.#context.entry.push({
-					file: id,
-					name: value.properties.name,
-					output: value.properties.output,
-					input: value.properties["input.file"] ? {
-						file: value.properties["input.file"],
-						name: value.properties["input.name"]
-					} : void 0
-				});
-			});
-		}
-		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.
-	* @returns `true` if the file is virtual, otherwise `false`.
-	*/
-	isVirtual(path) {
-		const resolved = this.resolveSync(path);
-		if (!resolved) return false;
-		return this.#getStorage(resolved)?.adapter?.name === "virtual";
-	}
-	/**
-	* Checks if a path is a directory in the virtual file system (VFS).
-	*
-	* @param path - The path to check.
-	* @returns `true` if the path is a directory, otherwise `false`.
-	*/
-	isDirectorySync(path) {
-		const resolved = this.resolveSync(path);
-		if (!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.
-	* @returns `true` if the path is a directory, otherwise `false`.
-	*/
-	async isDirectory(path) {
-		const resolved = await this.resolve(path);
-		if (!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.
-	* @returns `true` if the path is a file, otherwise `false`.
-	*/
-	isFileSync(path) {
-		const resolved = this.resolveSync(path);
-		if (!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.
-	* @returns `true` if the path is a file, otherwise `false`.
-	*/
-	async isFile(path) {
-		const resolved = await this.resolve(path);
-		if (!resolved) return false;
-		return await this.#getStorage(resolved)?.adapter?.isFile(resolved) ?? false;
-	}
-	/**
-	* 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) {
-		return getUnique(this.#getStorages(path, true).map((storage) => storage.adapter.listSync(storage.relativeBase ? storage.base ? appendPath(storage.relativeBase, storage.base) : storage.relativeBase : storage.base)).flat());
-	}
-	/**
-	* 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) {
-		return getUnique((await Promise.all(this.#getStorages(path, true).map(async (storage) => storage.adapter.list(storage.relativeBase ? storage.base ? appendPath(storage.relativeBase, storage.base) : storage.relativeBase : storage.base)))).flat());
-	}
-	/**
-	* 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.workspaceConfig.workspaceRoot, 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);
-				}
-				continue;
-			}
-			const absPattern = isAbsolutePath(normalized) ? normalized : this.#normalizePath(joinPaths(this.#context.workspaceConfig.workspaceRoot, normalized));
-			const firstGlobIdx = absPattern.search(/[*?[\]{}]/);
-			const baseDir = firstGlobIdx === -1 ? findFilePath(absPattern) : absPattern.slice(0, Math.max(0, absPattern.lastIndexOf("/", firstGlobIdx)));
-			await Promise.all((await this.list(baseDir && isAbsolutePath(baseDir) ? baseDir : this.#context.workspaceConfig.workspaceRoot)).map(async (file) => {
-				if (this.#buildRegex(absPattern).test(file)) {
-					const resolved = this.resolveSync(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.workspaceConfig.workspaceRoot, 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);
-				}
-				continue;
-			}
-			const absPattern = isAbsolutePath(normalized) ? normalized : this.#normalizePath(joinPaths(this.#context.workspaceConfig.workspaceRoot, normalized));
-			const firstGlobIdx = absPattern.search(/[*?[\]{}]/);
-			const baseDir = firstGlobIdx === -1 ? findFilePath(absPattern) : absPattern.slice(0, Math.max(0, absPattern.lastIndexOf("/", firstGlobIdx)));
-			const files = this.listSync(baseDir && isAbsolutePath(baseDir) ? baseDir : this.#context.workspaceConfig.workspaceRoot);
-			for (const file of files) if (this.#buildRegex(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.workspaceConfig.workspaceRoot;
-		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.workspaceConfig.workspaceRoot;
-		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);
-		if (!filePath) return;
-		const { relativeKey, adapter } = this.#getStorage(filePath);
-		this.#log(LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
-		return await adapter.get(relativeKey) ?? 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);
-		if (!filePath) return;
-		const { relativeKey, adapter } = this.#getStorage(filePath);
-		this.#log(LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
-		return adapter.getSync(relativeKey) ?? 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 = {}) {
-		let code = data;
-		if (!options.skipFormat) {
-			const resolvedConfig = await resolveConfig(this.#normalizePath(path));
-			if (resolvedConfig) code = await format(data, {
-				absolutePath: this.#normalizePath(path),
-				...resolvedConfig
-			});
-		}
-		const { relativeKey, adapter } = this.#getStorage(options.storage || path);
-		this.#log(LogLevelLabel.TRACE, `Writing ${this.#normalizePath(relativeKey)} 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 = options?.meta?.id || this.#normalizeId(relativeKey);
-		this.#metadata[id] = {
-			variant: "normal",
-			timestamp: Date.now(),
-			...options.meta ?? {}
-		};
-		this.#paths[id] = this.#normalizePath(relativeKey);
-		this.#ids[this.#normalizePath(relativeKey)] = 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 { relativeKey, adapter } = this.#getStorage(options.storage || path);
-		this.#log(LogLevelLabel.TRACE, `Writing ${this.#normalizePath(relativeKey)} 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 = options?.meta?.id || this.#normalizeId(relativeKey);
-		this.#metadata[id] = {
-			variant: "normal",
-			timestamp: Date.now(),
-			...options.meta ?? {}
-		};
-		this.#paths[id] = this.#normalizePath(relativeKey);
-		this.#ids[this.#normalizePath(relativeKey)] = 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.build.alias) {
-			if (Array.isArray(this.#context.config.build.alias) && this.#context.config.build.alias.length > 0) {
-				const found = this.#context.config.build.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(/* @__PURE__ */ new RegExp(`^${alias.find}`), alias.replacement);
-					else if (isRegExp(alias.find)) path = path.replace(alias.find, alias.replacement);
-				}
-			} else if (isSetObject(this.#context.config.build.alias)) {
-				const found = Object.keys(this.#context.config.build.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(/* @__PURE__ */ new RegExp(`^${alias}`), this.#context.config.build.alias[alias]);
-				}
-			}
-		}
-		return path;
-	}
-	/**
-	* 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 = {}) {
-		let path = id;
-		if (path.includes("{") || path.includes("}")) path = replacePathTokens(this.#context, path);
-		if (options.skipAlias !== true) path = this.resolveAlias(path);
-		if (isAbsolutePath(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 (!result) {
-			const paths = options.paths ?? [];
-			if (importer && !paths.includes(importer)) paths.push(importer);
-			paths.push(this.#context.workspaceConfig.workspaceRoot);
-			paths.push(appendPath(this.#context.config.projectRoot, this.#context.workspaceConfig.workspaceRoot));
-			paths.push(appendPath(this.#context.config.sourceRoot, this.#context.workspaceConfig.workspaceRoot));
-			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.workspaceConfig.workspaceRoot)));
-			for (const combination of getResolutionCombinations(path, { paths })) {
-				const { relativeKey, adapter } = this.#getStorage(combination);
-				if (await adapter.exists(relativeKey)) {
-					result = combination;
-					break;
-				}
-			}
-			if (!result) try {
-				result = await resolve(path, {
-					...options,
-					paths
-				});
-			} catch {}
-		}
-		if (result && !this.#context.config.skipCache) this.resolverCache.set(resolverCacheKey, 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.
-	*/
-	resolveSync(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)) return path;
-		let result;
-		if (!this.#context.config.skipCache) {
-			result = this.resolverCache.get(this.#normalizeId(path));
-			if (result) return result;
-		}
-		result = this.paths[this.#normalizeId(path)];
-		if (!result) {
-			const paths = options.paths ?? [];
-			if (importer && !paths.includes(importer)) paths.push(importer);
-			paths.push(this.#context.workspaceConfig.workspaceRoot);
-			paths.push(appendPath(this.#context.config.projectRoot, this.#context.workspaceConfig.workspaceRoot));
-			paths.push(appendPath(this.#context.config.sourceRoot, this.#context.workspaceConfig.workspaceRoot));
-			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.workspaceConfig.workspaceRoot)));
-			for (const combination of getResolutionCombinations(path, { paths })) {
-				const { relativeKey, adapter } = this.#getStorage(combination);
-				if (adapter.existsSync(relativeKey)) {
-					result = combination;
-					break;
-				}
-			}
-			if (!result) try {
-				result = resolveSync(path, {
-					...options,
-					paths
-				});
-			} catch {}
-		}
-		if (result && !this.#context.config.skipCache) this.resolverCache.set(this.#normalizeId(path), result);
-		return result;
-	}
-	/**
-	* 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 $.Message();
-			const fs = message.initRoot(FileSystem);
-			const paths = await this.list();
-			const storage = fs._initStorage(paths.length);
-			await Promise.all(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(([, path]) => path).forEach(([id, path], 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 ?? BigInt(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$1) => {
-						const prop = props.get(index$1);
-						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$1) => storage$1.adapter.dispose()));
-			this.#log(LogLevelLabel.TRACE, "Virtual file system has been disposed.");
-		}
-	}
-	async [Symbol.asyncDispose]() {
-		return this.dispose();
-	}
-};
-
-//#endregion
-//#region ../powerlines/src/lib/utilities/meta.ts
-const PROJECT_ROOT_HASH_LENGTH = 45;
-const CACHE_HASH_LENGTH = 62;
-/**
-* 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 projectRootHash - The hash of the project root.
-* @returns An object containing the name and project root hash.
-*/
-function getPrefixedProjectRootHash(name, projectRootHash) {
-	const combined = `${kebabCase(name)}_${projectRootHash}`;
-	return combined.length > PROJECT_ROOT_HASH_LENGTH ? combined.slice(0, PROJECT_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(context.dataPath, "meta.json");
-	context.log(LogLevelLabel.DEBUG, `Writing runtime metadata to ${metaFilePath}`);
-	await context.fs.write(metaFilePath, JSON.stringify(context.meta, null, 2));
-}
-
-//#endregion
-//#region ../powerlines/src/lib/contexts/context.ts
-const configCache = /* @__PURE__ */ new WeakMap();
-const envPathCache = /* @__PURE__ */ new WeakMap();
-setGlobalDispatcher(new Agent({ keepAliveTimeout: 1e4 }).compose(interceptors.retry({
-	maxRetries: 3,
-	minTimeout: 1e3,
-	maxTimeout: 1e4,
-	timeoutFactor: 2,
-	retryAfter: true
-})));
-var PowerlinesContext = class PowerlinesContext {
-	/**
-	* 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 = {};
-	#workspaceConfig;
-	#checksum = null;
-	#buildId = uuid();
-	#releaseId = uuid();
-	#timestamp = Date.now();
-	#entry = null;
-	#fs;
-	#tsconfig;
-	#program;
-	#parserCache;
-	#requestCache;
-	#getConfigProps(config = {}) {
-		return defu$1({
-			variant: config.build?.variant,
-			projectType: config.type,
-			projectRoot: config.root,
-			name: config.name,
-			title: config.title,
-			organization: config.organization,
-			compatibilityDate: config.compatibilityDate,
-			description: config.description,
-			sourceRoot: config.sourceRoot,
-			configFile: config.configFile,
-			customLogger: config.customLogger,
-			logLevel: config.logLevel,
-			tsconfig: config.tsconfig,
-			tsconfigRaw: config.tsconfigRaw,
-			skipCache: config.skipCache,
-			skipInstalls: config.skipInstalls,
-			entry: config.entry,
-			output: config.output,
-			plugins: config.plugins,
-			mode: config.mode,
-			lint: config.lint,
-			transform: config.transform,
-			build: config.build,
-			framework: config.framework,
-			...config
-		}, { output: config.framework ? {
-			artifactsPath: joinPaths$1(config.root ?? this.config.projectRoot, `.${config.framework ?? "powerlines"}`),
-			dts: joinPaths$1(config.root ?? this.config.projectRoot, `${config.framework ?? "powerlines"}.d.ts`),
-			builtinPrefix: config.framework ?? "powerlines"
-		} : {} });
-	}
-	/**
-	* Create a new Storm context from the workspace root and user config.
-	*
-	* @param workspaceRoot - The root directory of the workspace.
-	* @param config - The user configuration options.
-	* @returns A promise that resolves to the new context.
-	*/
-	static async from(workspaceRoot, config) {
-		const context = new PowerlinesContext(await loadWorkspaceConfig(workspaceRoot, config.root));
-		await context.withUserConfig(config);
-		const powerlinesPath = await resolvePackage("powerlines");
-		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
-		context.powerlinesPath = powerlinesPath;
-		return context;
-	}
-	/**
-	* 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 path to the Powerlines package
-	*/
-	powerlinesPath;
-	/**
-	* The parsed `package.json` file for the project
-	*/
-	packageJson;
-	/**
-	* The parsed `project.json` file for the project
-	*/
-	projectJson = void 0;
-	/**
-	* The module resolver for the project
-	*/
-	resolver;
-	/**
-	* The resolved configuration options
-	*/
-	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() {
-		return resolveEntriesSync(this, !this.#entry ? toArray(this.config.entry) : this.#entry);
-	}
-	/**
-	* Sets the resolved entry type definitions for the project
-	*/
-	set entry(value) {
-		this.#entry = value;
-	}
-	/**
-	* 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,
-			projectRootHash: murmurhash({
-				workspaceRoot: this.workspaceConfig?.workspaceRoot,
-				projectRoot: this.config?.projectRoot
-			}, { maxLength: PROJECT_ROOT_HASH_LENGTH }),
-			configHash: murmurhash(this.config, { maxLength: CACHE_HASH_LENGTH })
-		};
-	}
-	/**
-	* The resolved configuration options
-	*/
-	get config() {
-		return this.resolvedConfig ?? {};
-	}
-	/**
-	* The logger function
-	*/
-	get log() {
-		if (!this.logFn) this.logFn = this.createLog();
-		return this.logFn;
-	}
-	/**
-	* The workspace configuration
-	*/
-	get workspaceConfig() {
-		return this.#workspaceConfig;
-	}
-	/**
-	* The environment paths for the project
-	*/
-	get envPaths() {
-		if (envPathCache.has({
-			workspaceRoot: this.workspaceConfig.workspaceRoot,
-			framework: this.config?.framework || "powerlines"
-		})) return envPathCache.get({
-			workspaceRoot: this.workspaceConfig.workspaceRoot,
-			framework: this.config?.framework || "powerlines"
-		});
-		const envPaths = getEnvPaths({
-			orgId: "storm-software",
-			appId: this.config?.framework || "powerlines",
-			workspaceRoot: this.workspaceConfig.workspaceRoot
-		});
-		envPathCache.set({
-			workspaceRoot: this.workspaceConfig.workspaceRoot,
-			framework: this.config?.framework || "powerlines"
-		}, envPaths);
-		return envPaths;
-	}
-	/**
-	* Get the path to the artifacts directory for the project
-	*/
-	get artifactsPath() {
-		return joinPaths$1(this.workspaceConfig.workspaceRoot, this.config.projectRoot, this.config.output.artifactsPath);
-	}
-	/**
-	* Get the path to the builtin modules used by the project
-	*/
-	get builtinsPath() {
-		return joinPaths$1(this.artifactsPath, "builtins");
-	}
-	/**
-	* Get the path to the entry directory for the project
-	*/
-	get entryPath() {
-		return joinPaths$1(this.artifactsPath, "entry");
-	}
-	/**
-	* Get the path to the data directory for the project
-	*/
-	get dataPath() {
-		return joinPaths$1(this.envPaths.data, "projects", getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
-	}
-	/**
-	* Get the path to the cache directory for the project
-	*/
-	get cachePath() {
-		return joinPaths$1(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 dtsPath() {
-		return this.config.output.dts ? appendPath(this.config.output.dts, this.workspaceConfig.workspaceRoot) : joinPaths$1(this.workspaceConfig.workspaceRoot, this.config.projectRoot, "powerlines.d.ts");
-	}
-	/**
-	* Get the project root relative to the workspace root
-	*/
-	get relativeToWorkspaceRoot() {
-		return relativeToWorkspaceRoot(this.config.projectRoot);
-	}
-	/**
-	* 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);
-	}
-	/**
-	* The {@link Project} instance used for type reflection and module manipulation
-	*
-	* @see https://ts-morph.com/
-	*
-	* @remarks
-	* This instance is created lazily on first access.
-	*/
-	get program() {
-		if (!this.#program) this.#program = createProgram(this, { skipAddingFilesFromTsConfig: true });
-		return this.#program;
-	}
-	/**
-	* 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;
-	}
-	/**
-	* 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.build.alias) {
-			if (Array.isArray(this.config.build.alias)) {
-				const alias = this.config.build.alias.find((a) => match(moduleId, [a.find]));
-				if (alias) moduleId = alias.replacement;
-			} else if (isSetObject(this.config.build.alias) && this.config.build.alias[id]) moduleId = this.config.build.alias[id];
-		}
-		if (this.fs.isVirtual(moduleId)) {
-			const result = await this.fs.resolve(moduleId, importer, {
-				conditions: this.config.build.conditions,
-				extensions: this.config.build.extensions,
-				...options
-			});
-			if (!result) return;
-			return {
-				id: `\0${result}`,
-				external: this.config.projectType !== "application"
-			};
-		}
-		if (this.config.build.skipNodeModulesBundle) {
-			if (match(moduleId, this.resolvePatterns) || match(moduleId, this.config.build.noExternal)) return;
-			if (match(moduleId, this.config.build.external) || moduleId.startsWith("node:")) return {
-				id: moduleId,
-				external: true
-			};
-			if (!/^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/.test(moduleId)) return {
-				id: moduleId,
-				external: true
-			};
-		} else {
-			if (match(moduleId, this.config.build.noExternal)) return;
-			if (match(moduleId, this.config.build.external) || moduleId.startsWith("node:")) return {
-				id: moduleId,
-				external: true
-			};
-		}
-	}
-	/**
-	* 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 ([path, meta]) => {
-			const code = await this.fs.read(path);
-			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 = {}) {
-		if (isFunction(this.emitFile) && options.emitWithBundler) return this.emitFile({
-			needsCodeReference: options.needsCodeReference,
-			originalFileName: options.originalFileName,
-			fileName: path,
-			source: code,
-			type: "asset"
-		});
-		return this.fs.write(path, 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 = {}) {
-		if (isFunction(this.emitFile) && options.emitWithBundler) return this.emitFile({
-			needsCodeReference: options.needsCodeReference,
-			originalFileName: options.originalFileName,
-			fileName: path,
-			source: code,
-			type: "asset"
-		});
-		return this.fs.writeSync(path, 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 = {}) {
-		const entryPath = isAbsolute(path) ? path : appendPath(path, this.entryPath);
-		this.entry ??= [];
-		this.entry.push({
-			name: options.name,
-			file: entryPath,
-			input: options.input,
-			output: options.output
-		});
-		return this.emit(code, entryPath, defu$1(omit(options, ["name"]), { meta: {
-			type: "entry",
-			properties: {
-				name: options.name,
-				output: options.output,
-				"input.file": options.input?.file,
-				"input.name": options.input?.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 = {}) {
-		const entryPath = isAbsolute(path) ? path : appendPath(path, this.entryPath);
-		this.entry ??= [];
-		this.entry.push({
-			name: options?.name,
-			file: entryPath,
-			input: options?.input,
-			output: options?.output
-		});
-		return this.emitSync(code, entryPath, defu$1(omit(options, ["name"]), { meta: {
-			type: "entry",
-			properties: {
-				name: options?.name,
-				output: options?.output,
-				"input.file": options?.input?.file,
-				"input.name": options?.input?.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 path - An optional path to write the builtin file to
-	* @param options - Optional write file options
-	*/
-	async emitBuiltin(code, id, path, options = {}) {
-		return this.emit(code, path ? isAbsolute(path) ? path : joinPaths$1(this.builtinsPath, path) : appendPath(id, this.builtinsPath), defu$1(options, { meta: { type: "builtin" } }));
-	}
-	/**
-	* 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 path - An optional path to write the builtin file to
-	* @param options - Optional write file options
-	*/
-	emitBuiltinSync(code, id, path, options = {}) {
-		return this.emitSync(code, path ? isAbsolute(path) ? path : joinPaths$1(this.builtinsPath, path) : appendPath(id, this.builtinsPath), defu$1(options, { meta: { type: "builtin" } }));
-	}
-	/**
-	* Update the context using a new user configuration options
-	*
-	* @param userConfig - The new user configuration options.
-	*/
-	async withUserConfig(userConfig, options = { isHighPriority: true }) {
-		this.mergeUserConfig(userConfig);
-		await this.init(this.config.userConfig, options);
-	}
-	/**
-	* Update the context using a new inline configuration options
-	*
-	* @param inlineConfig - The new inline configuration options.
-	*/
-	async withInlineConfig(inlineConfig, options = { isHighPriority: true }) {
-		this.config.inlineConfig = inlineConfig;
-		if (inlineConfig.command === "new") {
-			const workspacePackageJsonPath = joinPaths$1(this.workspaceConfig.workspaceRoot, "package.json");
-			if (!existsSync(workspacePackageJsonPath)) throw new Error(`The workspace package.json file could not be found at ${workspacePackageJsonPath}`);
-			this.packageJson = await readJsonFile(workspacePackageJsonPath);
-			this.workspaceConfig.repository ??= isSetString(this.packageJson?.repository) ? this.packageJson.repository : this.packageJson?.repository?.url;
-		}
-		await this.init(this.config.inlineConfig, options);
-	}
-	/**
-	* A logging function for fatal messages
-	*
-	* @param message - The message to log.
-	*/
-	fatal(message) {
-		this.log(LogLevelLabel.FATAL, isString(message) ? message : StormJSON.stringify(message));
-	}
-	/**
-	* A logging function for error messages
-	*
-	* @param message - The message to log.
-	*/
-	error(message) {
-		this.log(LogLevelLabel.ERROR, isString(message) ? message : StormJSON.stringify(message));
-	}
-	/**
-	* A logging function for warning messages
-	*
-	* @param message - The message to log.
-	*/
-	warn(message) {
-		this.log(LogLevelLabel.WARN, isString(message) ? message : StormJSON.stringify(message));
-	}
-	/**
-	* A logging function for informational messages
-	*
-	* @param message - The message to log.
-	*/
-	info(message) {
-		this.log(LogLevelLabel.INFO, isString(message) ? message : StormJSON.stringify(message));
-	}
-	/**
-	* A logging function for debug messages
-	*
-	* @param message - The message to log.
-	*/
-	debug(message) {
-		this.log(LogLevelLabel.DEBUG, isString(message) ? message : StormJSON.stringify(message));
-	}
-	/**
-	* A logging function for trace messages
-	*
-	* @param message - The message to log.
-	*/
-	trace(message) {
-		this.log(LogLevelLabel.TRACE, isString(message) ? message : StormJSON.stringify(message));
-	}
-	/**
-	* 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
-		});
-	}
-	/**
-	* Extend the current logger instance with a new name
-	*
-	* @param name - The name to use for the extended logger instance
-	* @returns A logger function
-	*/
-	extendLog(name) {
-		return extendLog(this.log, name);
-	}
-	/**
-	* 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.projectRoot) {
-		this.#checksum = await hashDirectory(root, { ignore: [
-			"node_modules",
-			".git",
-			".nx",
-			".cache",
-			".storm",
-			"tmp",
-			"dist"
-		] });
-		return this.#checksum;
-	}
-	/**
-	* Creates a new StormContext instance.
-	*
-	* @param workspaceConfig - The workspace configuration.
-	*/
-	constructor(workspaceConfig) {
-		this.#workspaceConfig = workspaceConfig;
-		envPathCache.set({
-			workspaceRoot: workspaceConfig.workspaceRoot,
-			framework: "powerlines"
-		}, getEnvPaths({
-			orgId: (isSetObject(workspaceConfig.organization) ? workspaceConfig.organization.name : workspaceConfig.organization) || "storm-software",
-			appId: "powerlines",
-			workspaceRoot: workspaceConfig.workspaceRoot
-		}));
-	}
-	/**
-	* The resolved configuration for this context
-	*/
-	resolvedConfig = {};
-	/**
-	* A logger function specific to this context
-	*/
-	logFn;
-	/**
-	* Initialize the context with the provided configuration options
-	*
-	* @param config - The partial user configuration to use for initialization.
-	*/
-	async init(config = {}, options = { isHighPriority: true }) {
-		const cacheKey = {
-			projectRoot: config.root ?? this.config.projectRoot ?? this.config.userConfig?.root ?? this.config.inlineConfig?.root,
-			mode: (config.mode ?? this.config.mode) || this.workspaceConfig.mode,
-			skipCache: config.skipCache ?? this.config.skipCache ?? false,
-			configFile: config.configFile ?? this.config.configFile,
-			framework: config.framework ?? this.config.framework ?? "powerlines",
-			command: this.config.inlineConfig?.command
-		};
-		if (configCache.has(cacheKey)) {
-			const result = configCache.get(cacheKey);
-			this.projectJson = result.projectJson;
-			this.packageJson = result.packageJson;
-			this.#checksum = result.checksum;
-			this.resolver = result.resolver;
-			this.mergeUserConfig(result.userConfig.config, this.config.userConfig);
-		} else {
-			const projectJsonPath = joinPaths$1(cacheKey.projectRoot, "project.json");
-			if (existsSync(projectJsonPath)) this.projectJson = await readJsonFile(projectJsonPath);
-			const packageJsonPath = joinPaths$1(cacheKey.projectRoot, "package.json");
-			if (existsSync(packageJsonPath)) this.packageJson = await readJsonFile(packageJsonPath);
-			this.#checksum = await this.generateChecksum(cacheKey.projectRoot);
-			this.resolver = createResolver({
-				workspaceRoot: this.workspaceConfig.workspaceRoot,
-				projectRoot: cacheKey.projectRoot,
-				cacheDir: this.cachePath,
-				mode: cacheKey.mode,
-				logLevel: config.logLevel || this.config?.logLevel || this.workspaceConfig.logLevel || "info",
-				skipCache: cacheKey.skipCache
-			});
-			const userConfig = await loadUserConfigFile(cacheKey.projectRoot, this.workspaceConfig.workspaceRoot, this.resolver, cacheKey.command, cacheKey.mode, cacheKey.configFile, cacheKey.framework);
-			this.mergeUserConfig(userConfig.config);
-			configCache.set(cacheKey, {
-				projectJson: this.projectJson,
-				packageJson: this.packageJson,
-				checksum: this.#checksum,
-				resolver: this.resolver,
-				userConfig
-			});
-		}
-		config.tsconfig ??= getTsconfigFilePath(this.workspaceConfig.workspaceRoot, cacheKey.projectRoot, config.tsconfig);
-		if (isSetObject(config)) this.resolvedConfig = defu$1({
-			inlineConfig: this.config.inlineConfig,
-			userConfig: this.config.userConfig
-		}, options.isHighPriority ? this.#getConfigProps(config) : {}, {
-			command: this.config.inlineConfig?.command,
-			...this.#getConfigProps(this.config.inlineConfig)
-		}, this.#getConfigProps(this.config.userConfig), {
-			mode: this.workspaceConfig?.mode,
-			logLevel: this.workspaceConfig?.logLevel,
-			skipCache: this.workspaceConfig?.skipCache
-		}, {
-			name: this.projectJson?.name || this.packageJson?.name,
-			version: this.packageJson?.version,
-			description: this.packageJson?.description,
-			sourceRoot: this.projectJson?.sourceRoot || appendPath("src", cacheKey.projectRoot),
-			output: defu$1(config.output ?? {}, {
-				outputPath: cacheKey.projectRoot ? joinPaths$1(this.workspaceConfig?.directories?.build || "dist", cacheKey.projectRoot) : this.workspaceConfig?.directories?.build || "dist",
-				artifactsPath: joinPaths$1(cacheKey.projectRoot, `.${config.framework ?? "powerlines"}`),
-				dts: joinPaths$1(cacheKey.projectRoot, `${config.framework ?? "powerlines"}.d.ts`),
-				builtinPrefix: config.framework ?? "powerlines",
-				assets: [
-					{ glob: "LICENSE" },
-					{
-						input: cacheKey.projectRoot,
-						glob: "*.md"
-					},
-					{
-						input: cacheKey.projectRoot,
-						glob: "package.json"
-					}
-				]
-			})
-		}, options.isHighPriority ? {} : this.#getConfigProps(config), {
-			inlineConfig: {},
-			userConfig: {},
-			framework: "powerlines",
-			platform: "neutral",
-			mode: "production",
-			projectType: "application",
-			logLevel: "info",
-			preview: false,
-			environments: {},
-			transform: { babel: {
-				plugins: [],
-				presets: []
-			} },
-			lint: { eslint: {} },
-			build: {
-				target: "esnext",
-				override: {}
-			}
-		});
-		this.config.entry = getUniqueEntries(this.config.entry);
-		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);
-		this.config.organization ??= (isSetObject(this.workspaceConfig.organization) ? this.workspaceConfig.organization.name : this.workspaceConfig.organization) || (isSetObject(this.packageJson?.author) ? this.packageJson?.author?.name : this.packageJson?.author) || this.config.name;
-		if (this.config.userConfig.build?.external) this.config.userConfig.build.external = getUnique(this.config.userConfig.build.external);
-		if (this.config.userConfig.build?.noExternal) this.config.userConfig.build.noExternal = getUnique(this.config.userConfig.build.noExternal);
-		if (this.config.build.external) this.config.build.external = getUnique(this.config.build.external);
-		if (this.config.build.noExternal) this.config.build.noExternal = getUnique(this.config.build.noExternal);
-		this.config.output.format = getUnique(toArray(this.config.output?.format ?? (this.config.projectType === "library" ? ["cjs", "esm"] : ["esm"])));
-		if (this.config.projectRoot && this.config.projectRoot !== "." && this.config.projectRoot !== "./" && this.config.projectRoot !== this.workspaceConfig.workspaceRoot) {
-			this.config.output.outputPath ??= joinPaths$1("dist", this.config.projectRoot);
-			this.config.output.buildPath ??= joinPaths$1(this.config.projectRoot, "dist");
-		} else {
-			this.config.output.outputPath ??= "dist";
-			this.config.output.buildPath ??= "dist";
-		}
-		this.config.output.assets = getUniqueBy(this.config.output.assets.map((asset) => {
-			return {
-				glob: isSetObject(asset) ? asset.glob : asset,
-				input: isString(asset) || !asset.input || asset.input === "." || asset.input === "/" || asset.input === "./" ? this.workspaceConfig.workspaceRoot : isParentPath(asset.input, this.workspaceConfig.workspaceRoot) || asset.input === this.workspaceConfig.workspaceRoot ? asset.input : appendPath(asset.input, this.workspaceConfig.workspaceRoot),
-				output: isSetObject(asset) && asset.output ? isParentPath(asset.output, this.workspaceConfig.workspaceRoot) ? asset.output : appendPath(joinPaths$1(this.config.output.outputPath, replacePath(replacePath(asset.output, replacePath(this.config.output.outputPath, this.workspaceConfig.workspaceRoot)), this.config.output.outputPath)), this.workspaceConfig.workspaceRoot) : appendPath(this.config.output.outputPath, this.workspaceConfig.workspaceRoot),
-				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) && checkDedupe(plugin, ret.filter((p) => isPlugin(p)))) return ret;
-			ret.push(plugin);
-			return ret;
-		}, []);
-		if (this.config.tsconfig) this.config.tsconfig = replacePathTokens(this, this.config.tsconfig);
-		if (this.config.output.dts) this.config.output.dts = replacePathTokens(this, this.config.output.dts);
-		if (this.config.build.polyfill) this.config.build.polyfill = this.config.build.polyfill.map((polyfill) => replacePathTokens(this, polyfill));
-		if (this.config.output.assets) this.config.output.assets = this.config.output.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)
-		}));
-		this.#fs ??= await VirtualFileSystem.create(this);
-	}
-	mergeUserConfig(from = {}, into = this.config.userConfig ?? {}) {
-		this.config.userConfig = defu$1({ entry: Array.isArray(from.entry) && from.entry.length > 0 ? from.entry : Array.isArray(into?.entry) && into.entry.length > 0 ? into.entry : [] }, omit(from ?? {}, ["entry"]), omit(into ?? {}, ["entry"]));
-		if (this.config.userConfig.output?.format) this.config.userConfig.output.format = getUnique(toArray(this.config.userConfig.output?.format));
-		this.config.userConfig.plugins = (this.config.userConfig.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
-			if (isPlugin(plugin) && checkDedupe(plugin, ret.filter((p) => isPlugin(p)))) return ret;
-			ret.push(plugin);
-			return ret;
-		}, []);
-	}
-};
-
-//#endregion
-//#region ../powerlines/src/lib/contexts/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);
-	};
-	return new Proxy({}, {
-		get(_, prop) {
-			if (prop === "$$internal") return {
-				...environment.$$internal,
-				environment,
-				callHook: callHookFn
-			};
-			if (prop === "log" || prop === "logger") return log;
-			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 ../powerlines/src/lib/contexts/environment-context.ts
-var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends PowerlinesContext {
-	/**
-	* The hooks registered by plugins in this environment
-	*/
-	#hooks = {};
-	/**
-	* Create a new Storm context from the workspace root and user config.
-	*
-	* @param workspaceConfig - The root directory of the workspace.
-	* @param config - The user configuration options.
-	* @returns A promise that resolves to the new context.
-	*/
-	static async fromConfig(workspaceConfig, config) {
-		const context = new PowerlinesEnvironmentContext(config, workspaceConfig);
-		await context.init();
-		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 = [];
-	/**
-	* The resolved configuration options
-	*/
-	get config() {
-		return super.config;
-	}
-	get hooks() {
-		return this.#hooks;
-	}
-	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.keys(resolvedPlugin).filter((key) => !PLUGIN_NON_HOOK_FIELDS.includes(key)).reduce((ret, key) => {
-			const hook = key;
-			const pluginHook = resolvedPlugin[hook];
-			if (!isPluginHook(pluginHook)) return ret;
-			if (!isHookExternal(hook)) {
-				ret[hook] ??= {};
-				if (resolvedPlugin.enforce) {
-					ret[hook][`${resolvedPlugin.enforce}Enforced`] ??= [];
-					addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${resolvedPlugin.enforce}Enforced`]);
-					return ret;
-				}
-				if (isFunction(pluginHook) || !pluginHook.order) {
-					ret[hook].normal ??= [];
-					addPluginHook(context, resolvedPlugin, pluginHook, ret[hook].normal);
-					return ret;
-				}
-				ret[hook][`${pluginHook.order}Ordered`] ??= [];
-				addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${pluginHook.order}Ordered`]);
-			} else {
-				ret[hook] ??= [];
-				ret[hook].push({
-					plugin: resolvedPlugin,
-					hook: getHookHandler(pluginHook).bind(context)
-				});
-			}
-			return ret;
-		}, this.hooks);
-	}
-	/**
-	* Retrieves the hook handlers for a specific hook name
-	*/
-	selectHooks(hook, options) {
-		const result = [];
-		if (this.hooks[hook]) if (!isHookExternal(hook)) {
-			const hooks = this.hooks[hook];
-			if (options?.order) if (options?.order === "pre") {
-				result.push(...(hooks.preOrdered ?? []).map((h) => {
-					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
-					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
-					return {
-						handle: h.handler,
-						context: plugin.context
-					};
-				}));
-				result.push(...(hooks.preEnforced ?? []).map((h) => {
-					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
-					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
-					return {
-						handle: h.handler,
-						context: plugin.context
-					};
-				}));
-			} else if (options?.order === "post") {
-				result.push(...(hooks.postOrdered ?? []).map((h) => {
-					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
-					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
-					return {
-						handle: h.handler,
-						context: plugin.context
-					};
-				}));
-				result.push(...(hooks.postEnforced ?? []).map((h) => {
-					const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
-					if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
-					return {
-						handle: h.handler,
-						context: plugin.context
-					};
-				}));
-			} else result.push(...(hooks.normal ?? []).map((h) => {
-				const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
-				if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
-				return {
-					handle: h.handler,
-					context: plugin.context
-				};
-			}));
-			else {
-				result.push(...this.selectHooks(hook, { order: "pre" }));
-				result.push(...this.selectHooks(hook, { order: "normal" }));
-				result.push(...this.selectHooks(hook, { order: "post" }));
-			}
-		} else result.push(...this.hooks[hook].map((h) => {
-			const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
-			if (!plugin) throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
-			return {
-				handle: h.handler,
-				context: plugin.context
-			};
-		}));
-		return result;
-	}
-	constructor(config, workspaceConfig) {
-		super(workspaceConfig);
-		this.resolvedConfig = config;
-	}
-};
-
-//#endregion
-//#region ../powerlines/src/lib/contexts/api-context.ts
-var PowerlinesAPIContext = class PowerlinesAPIContext extends PowerlinesContext {
-	#environments = {};
-	#plugins = [];
-	#log;
-	/**
-	* Create a new Storm context from the workspace root and user config.
-	*
-	* @param workspaceRoot - The root directory of the workspace.
-	* @param config - The user configuration options.
-	* @returns A promise that resolves to the new context.
-	*/
-	static async from(workspaceRoot, config) {
-		const context = new PowerlinesAPIContext(await loadWorkspaceConfig(workspaceRoot, config.root));
-		await context.withUserConfig(config);
-		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 log() {
-		if (!this.#log) this.#log = this.createLog();
-		return this.#log;
-	}
-	get plugins() {
-		return this.#plugins;
-	}
-	constructor(workspaceConfig) {
-		super(workspaceConfig);
-	}
-	/**
-	* Initialize the context with the provided configuration options
-	*
-	* @param config - The partial user configuration to use for initialization.
-	*/
-	async init(config = {}) {
-		await super.init(config);
-		await Promise.all(toArray(this.config.userConfig.environments && Object.keys(this.config.userConfig.environments).length > 0 ? Object.keys(this.config.userConfig.environments).map((name) => createEnvironment(name, this.config.userConfig)) : createDefaultEnvironment(this.config.userConfig)).map(async (env) => {
-			this.#environments[env.name] = await this.in(env);
-		}));
-	}
-	/**
-	* 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) {
-		let context;
-		if (this.environments[environment.name]) context = this.environments[environment.name];
-		else context = await PowerlinesEnvironmentContext.fromConfig(this.workspaceConfig, this.config);
-		if (isSetObject(this.config.inlineConfig)) await context.withInlineConfig(this.config.inlineConfig);
-		context.environment = environment;
-		context.plugins = [];
-		for (const plugin of this.plugins) await context.addPlugin(plugin);
-		return context;
-	}
-	/**
-	* Update the context using a new user configuration options
-	*
-	* @param userConfig - The new user configuration options.
-	*/
-	async withUserConfig(userConfig, options = { isHighPriority: true }) {
-		await super.withUserConfig(userConfig, options);
-		await Promise.all(Object.keys(this.#environments).map(async (name) => {
-			await this.#environments[name].withUserConfig(userConfig, options);
-		}));
-	}
-	/**
-	* Update the context using a new inline configuration options
-	*
-	* @param inlineConfig - The new inline configuration options.
-	*/
-	async withInlineConfig(inlineConfig, options = { isHighPriority: true }) {
-		await super.withInlineConfig(inlineConfig, options);
-		await Promise.all(Object.keys(this.#environments).map(async (name) => {
-			await this.#environments[name].withInlineConfig(inlineConfig, options);
-		}));
-	}
-	/**
-	* 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.log(LogLevelLabel.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.userConfig));
-			this.log(LogLevelLabel.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.userConfig));
-			this.log(LogLevelLabel.DEBUG, `Combined all ${Object.keys(this.environments).length} environments into a single global context.`);
-		} else environment = await this.getEnvironment();
-		return environment;
-	}
-};
-
-//#endregion
-//#region ../powerlines/src/lib/utilities/file-header.ts
-function getBaseFileHeader(context) {
-	return `
-// Generated with ${titleCase(context.config.framework)}
-// Note: Do not edit this file manually - it will be overwritten automatically
-`;
-}
-function getFileHeader(context, options = {}) {
-	const { directive = null, prettierIgnore = false } = options;
-	return `/* eslint-disable */
-// biome-ignore lint: disable
-${prettierIgnore ? `// prettier-ignore` : ""}${directive ? `\n\n${directive}\n` : "\n"}
-${getBaseFileHeader(context)}
-
-`;
-}
-
-//#endregion
-//#region ../powerlines/src/api.ts
-/**
-* The Powerlines API class
-*
-* @remarks
-* This class is responsible for managing the Powerlines project lifecycle, including initialization, building, and finalization.
-*
-* @public
-*/
-var PowerlinesAPI = class PowerlinesAPI {
-	/**
-	* The Powerlines context
-	*/
-	#context;
-	/**
-	* The Powerlines context
-	*/
-	get context() {
-		return this.#context;
-	}
-	/**
-	* Create a new Powerlines API instance
-	*
-	* @param context - The Powerlines context
-	*/
-	constructor(context) {
-		this.#context = context;
-	}
-	/**
-	* Initialize a Powerlines API instance
-	*
-	* @param workspaceRoot - The directory of the underlying workspace the Powerlines project exists in
-	* @param config - An object containing the configuration required to run Powerlines tasks.
-	* @returns A new instance of the Powerlines API
-	*/
-	static async from(workspaceRoot, config) {
-		const api = new PowerlinesAPI(await PowerlinesAPIContext.from(workspaceRoot, config));
-		api.#context.$$internal = {
-			api,
-			addPlugin: api.#addPlugin.bind(api)
-		};
-		for (const plugin of api.context.config.plugins ?? []) await api.#addPlugin(plugin);
-		if (api.context.plugins.length === 0) api.context.log(LogLevelLabel.WARN, "No Powerlines plugins were specified in the options. Please ensure this is correct, as it is generally not recommended.");
-		const pluginConfig = await api.callHook("config", {
-			environment: await api.context.getEnvironment(),
-			sequential: true,
-			result: "merge"
-		});
-		await api.context.withUserConfig(pluginConfig, { isHighPriority: false });
-		return api;
-	}
-	/**
-	* Prepare the Powerlines API
-	*
-	* @remarks
-	* This method will prepare the Powerlines API for use, initializing any necessary resources.
-	*
-	* @param inlineConfig - The inline configuration for the prepare command
-	*/
-	async prepare(inlineConfig = { command: "prepare" }) {
-		this.context.log(LogLevelLabel.TRACE, " 🏗️  Preparing the Powerlines project");
-		this.context.log(LogLevelLabel.TRACE, " ⚙️  Aggregating configuration options for the Powerlines project");
-		await this.context.withInlineConfig(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
-			context.log(LogLevelLabel.TRACE, `Initializing the processing options for the Powerlines project.`);
-			await this.callHook("configResolved", {
-				environment: context,
-				order: "pre"
-			});
-			await initializeTsconfig(context);
-			await this.callHook("configResolved", {
-				environment: context,
-				order: "normal"
-			});
-			context.log(LogLevelLabel.DEBUG, `The configuration provided ${toArray(context.config.entry).length} entry point(s), Powerlines has found ${context.entry.length} entry files(s) for the ${context.config.title} project${context.entry.length > 0 && context.entry.length < 10 ? `: \n${context.entry.map((entry) => `- ${entry.file}${entry.output ? ` -> ${entry.output}` : ""}`).join(" \n")}` : ""}.`);
-			await resolveTsconfig(context);
-			await installDependencies(context);
-			await this.callHook("configResolved", {
-				environment: context,
-				order: "post"
-			});
-			context.log(LogLevelLabel.TRACE, `Powerlines configuration has been resolved: \n\n${formatLogMessage(context.config)}`);
-			if (!context.fs.existsSync(context.cachePath)) await createDirectory(context.cachePath);
-			if (!context.fs.existsSync(context.dataPath)) await createDirectory(context.dataPath);
-			await this.callHook("prepare", {
-				environment: context,
-				order: "pre"
-			});
-			await this.callHook("prepare", {
-				environment: context,
-				order: "normal"
-			});
-			if (context.config.output.dts !== false) {
-				context.log(LogLevelLabel.TRACE, `Preparing the TypeScript definitions for the Powerlines project.`);
-				if (context.fs.existsSync(context.dtsPath)) await context.fs.remove(context.dtsPath);
-				context.log(LogLevelLabel.TRACE, "Transforming built-ins runtime modules files.");
-				const builtinFilePaths = await Promise.all((await context.getBuiltins()).map(async (file) => {
-					const result$1 = await transformAsync(file.code.toString(), {
-						highlightCode: true,
-						code: true,
-						ast: false,
-						cloneInputAst: false,
-						comments: true,
-						sourceType: "module",
-						configFile: false,
-						babelrc: false,
-						envName: context.config.mode,
-						caller: { name: "powerlines" },
-						...context.config.transform.babel,
-						filename: file.path,
-						plugins: [["@babel/plugin-syntax-typescript"], [moduleResolverBabelPlugin(context)]]
-					});
-					if (!result$1?.code) throw new Error(`Powerlines - Generate Types failed to compile ${file.id}`);
-					context.log(LogLevelLabel.TRACE, `Writing transformed built-in runtime file ${file.id}.`);
-					await context.emitBuiltin(result$1.code, file.id, file.path);
-					return file.path;
-				}));
-				if (!await resolvePackage("typescript")) throw new Error("Could not resolve TypeScript package location. Please ensure TypeScript is installed.");
-				const files = builtinFilePaths.reduce((ret, fileName) => {
-					const formatted = replacePath(fileName, context.workspaceConfig.workspaceRoot);
-					if (!ret.includes(formatted)) ret.push(formatted);
-					return ret;
-				}, []);
-				context.log(LogLevelLabel.TRACE, "Parsing TypeScript configuration for the Powerlines project.");
-				let types = await emitTypes(context, files);
-				context.log(LogLevelLabel.TRACE, `Generating TypeScript declaration file ${context.dtsPath}.`);
-				const directives = [];
-				const asNextParam = (previousResult) => isObject(previousResult) ? previousResult.code : previousResult;
-				let result = await this.callHook("types", {
-					environment: context,
-					sequential: true,
-					order: "pre",
-					result: "merge",
-					asNextParam
-				}, types);
-				if (result) {
-					if (isSetObject(result)) {
-						types = result.code;
-						if (Array.isArray(result.directives) && result.directives.length > 0) directives.push(...result.directives);
-					} else if (isSetString(result)) types = result;
-				}
-				result = await this.callHook("types", {
-					environment: context,
-					sequential: true,
-					order: "normal",
-					result: "merge",
-					asNextParam
-				}, types);
-				if (result) {
-					if (isSetObject(result)) {
-						types = result.code;
-						if (Array.isArray(result.directives) && result.directives.length > 0) directives.push(...result.directives);
-					} else if (isSetString(result)) types = result;
-				}
-				result = await this.callHook("types", {
-					environment: context,
-					sequential: true,
-					order: "post",
-					result: "merge",
-					asNextParam
-				}, types);
-				if (result) {
-					if (isSetObject(result)) {
-						types = result.code;
-						if (Array.isArray(result.directives) && result.directives.length > 0) directives.push(...result.directives);
-					} else if (isSetString(result)) types = result;
-				}
-				if (types?.trim() || directives.length > 0) await context.fs.write(context.dtsPath, `${directives ? `${directives.map((directive) => `/// <reference types="${directive}" />`).join("\n")}
-
-` : ""}${getFileHeader(context, {
-					directive: null,
-					prettierIgnore: false
-				})}
-
-${formatTypes(types)}
-`);
-				else {
-					const dtsRelativePath = getTsconfigDtsPath(context);
-					if (context.tsconfig.tsconfigJson.include && isIncludeMatchFound(dtsRelativePath, context.tsconfig.tsconfigJson.include)) {
-						const normalizedDtsRelativePath = dtsRelativePath.startsWith("./") ? dtsRelativePath.slice(2) : dtsRelativePath;
-						context.tsconfig.tsconfigJson.include = context.tsconfig.tsconfigJson.include.filter((includeValue) => includeValue?.toString() !== normalizedDtsRelativePath);
-						await context.fs.write(context.tsconfig.tsconfigFilePath, JSON.stringify(context.tsconfig.tsconfigJson, null, 2));
-					}
-				}
-			}
-			context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
-			if (!context.tsconfig) throw new Error("Failed to parse the TypeScript configuration file.");
-			await this.callHook("prepare", {
-				environment: context,
-				order: "post"
-			});
-			await writeMetaFile(context);
-			context.persistedMeta = context.meta;
-		});
-		this.context.log(LogLevelLabel.INFO, "Powerlines API has been prepared successfully");
-	}
-	/**
-	* Create a new Powerlines project
-	*
-	* @remarks
-	* This method will create a new Powerlines project in the current directory.
-	*
-	* @param inlineConfig - The inline configuration for the new command
-	* @returns A promise that resolves when the project has been created
-	*/
-	async new(inlineConfig) {
-		this.context.log(LogLevelLabel.INFO, "🆕 Creating a new Powerlines project");
-		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
-			context.log(LogLevelLabel.TRACE, `Initializing the processing options for the Powerlines project.`);
-			await this.callHook("new", {
-				environment: context,
-				order: "pre"
-			});
-			const files = await listFiles(joinPaths(context.powerlinesPath, "files/common/**/*.hbs"));
-			for (const file of files) {
-				context.log(LogLevelLabel.TRACE, `Adding template file: ${file}`);
-				const template = Handlebars.compile(file);
-				await context.fs.write(joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
-			}
-			await this.callHook("new", {
-				environment: context,
-				order: "normal"
-			});
-			if (context.config.projectType === "application") {
-				const files$1 = await listFiles(joinPaths(context.powerlinesPath, "files/application/**/*.hbs"));
-				for (const file of files$1) {
-					context.log(LogLevelLabel.TRACE, `Adding application template file: ${file}`);
-					const template = Handlebars.compile(file);
-					await context.fs.write(joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
-				}
-			} else {
-				const files$1 = await listFiles(joinPaths(context.powerlinesPath, "files/library/**/*.hbs"));
-				for (const file of files$1) {
-					context.log(LogLevelLabel.TRACE, `Adding library template file: ${file}`);
-					const template = Handlebars.compile(file);
-					await context.fs.write(joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
-				}
-			}
-			await this.callHook("new", {
-				environment: context,
-				order: "post"
-			});
-		});
-		this.context.log(LogLevelLabel.TRACE, "Powerlines - New command completed");
-	}
-	/**
-	* Clean any previously prepared artifacts
-	*
-	* @remarks
-	* This method will remove the previous Powerlines artifacts from the project.
-	*
-	* @param inlineConfig - The inline configuration for the clean command
-	* @returns A promise that resolves when the clean command has completed
-	*/
-	async clean(inlineConfig = { command: "clean" }) {
-		this.context.log(LogLevelLabel.INFO, "🧹 Cleaning the previous Powerlines artifacts");
-		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
-			this.context.log(LogLevelLabel.TRACE, "Cleaning the project's dist and artifacts directories.");
-			await context.fs.remove(joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.buildPath));
-			await context.fs.remove(joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.artifactsPath));
-			await this.callHook("clean", {
-				environment: context,
-				sequential: false
-			});
-		});
-		this.context.log(LogLevelLabel.TRACE, "Powerlines - Clean command completed");
-	}
-	/**
-	* Lint the project
-	*
-	* @param inlineConfig - The inline configuration for the lint command
-	* @returns A promise that resolves when the lint command has completed
-	*/
-	async lint(inlineConfig = { command: "lint" }) {
-		this.context.log(LogLevelLabel.INFO, "📋 Linting the Powerlines project");
-		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
-			if (context.config.lint !== false) await this.callHook("lint", {
-				environment: context,
-				sequential: false
-			});
-		});
-		this.context.log(LogLevelLabel.TRACE, "Powerlines linting completed");
-	}
-	/**
-	* Build the project
-	*
-	* @remarks
-	* This method will build the Powerlines project, generating the necessary artifacts.
-	*
-	* @param inlineConfig - The inline configuration for the build command
-	* @returns A promise that resolves when the build command has completed
-	*/
-	async build(inlineConfig = { command: "build" }) {
-		this.context.log(LogLevelLabel.INFO, "📦  Building the Powerlines project");
-		await this.prepare(inlineConfig);
-		if (this.context.config.singleBuild) await this.#handleBuild(await this.#context.toEnvironment());
-		else await this.#executeEnvironments(async (context) => {
-			await this.#handleBuild(context);
-		});
-		this.context.log(LogLevelLabel.TRACE, "Powerlines build completed");
-	}
-	/**
-	* Prepare the documentation for the project
-	*
-	* @param inlineConfig - The inline configuration for the docs command
-	* @returns A promise that resolves when the documentation generation has completed
-	*/
-	async docs(inlineConfig = { command: "docs" }) {
-		this.context.log(LogLevelLabel.INFO, "📓 Generating documentation for the Powerlines project");
-		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
-			context.log(LogLevelLabel.TRACE, "Writing documentation for the Powerlines project artifacts.");
-			await this.prepare(inlineConfig);
-			await this.#executeEnvironments(async (context$1) => {
-				await this.callHook("docs", { environment: context$1 });
-			});
-		});
-		this.#context.log(LogLevelLabel.TRACE, "Powerlines documentation generation completed");
-	}
-	/**
-	* Deploy the project source code
-	*
-	* @remarks
-	* This method will prepare and build the Powerlines project, generating the necessary artifacts for the deployment.
-	*
-	* @param inlineConfig - The inline configuration for the deploy command
-	*/
-	async deploy(inlineConfig = { command: "deploy" }) {
-		this.context.log(LogLevelLabel.INFO, "📦 Deploying the Powerlines project");
-		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
-			await this.callHook("deploy", { environment: context });
-		});
-		this.context.log(LogLevelLabel.TRACE, "Powerlines deploy completed");
-	}
-	/**
-	* Finalization process
-	*
-	* @remarks
-	* This step includes any final processes or clean up required by Powerlines. It will be run after each Powerlines command.
-	*
-	* @returns A promise that resolves when the finalization process has completed
-	*/
-	async finalize() {
-		this.context.log(LogLevelLabel.TRACE, "Powerlines finalize execution started");
-		await this.#executeEnvironments(async (context) => {
-			await this.callHook("finalize", { environment: context });
-			await context.fs.dispose();
-		});
-		this.context.log(LogLevelLabel.TRACE, "Powerlines finalize execution completed");
-	}
-	/**
-	* Invokes the configured plugin hooks
-	*
-	* @remarks
-	* By default, it will call the `"pre"`, `"normal"`, and `"post"` ordered hooks in sequence
-	*
-	* @param hook - The hook to call
-	* @param options - The options to provide to the hook
-	* @param args - The arguments to pass to the hook
-	* @returns The result of the hook call
-	*/
-	async callHook(hook, options, ...args) {
-		return callHook(isSetObject(options?.environment) ? options.environment : await this.#context.getEnvironment(options?.environment), hook, {
-			sequential: true,
-			...options
-		}, ...args);
-	}
-	/**
-	* Dispose of the Powerlines API instance
-	*
-	* @remarks
-	* This method will finalize the Powerlines API instance, cleaning up any resources used.
-	*/
-	async [Symbol.asyncDispose]() {
-		await this.finalize();
-	}
-	async #handleBuild(context) {
-		await this.callHook("build", {
-			environment: context,
-			order: "pre"
-		});
-		await this.callHook("build", {
-			environment: context,
-			order: "normal"
-		});
-		if (context.config.output.buildPath !== context.config.output.outputPath) {
-			const sourcePath = appendPath(context.config.output.buildPath, context.workspaceConfig.workspaceRoot);
-			const destinationPath = joinPaths(appendPath(context.config.output.outputPath, context.workspaceConfig.workspaceRoot), "dist");
-			if (context.fs.existsSync(sourcePath) && sourcePath !== destinationPath) {
-				context.log(LogLevelLabel.INFO, `Copying build output files from project's build directory (${context.config.output.buildPath}) to the workspace's output directory (${context.config.output.outputPath}).`);
-				await context.fs.copy(sourcePath, destinationPath);
-			}
-		}
-		await Promise.all(context.config.output.assets.map(async (asset) => {
-			context.log(LogLevelLabel.DEBUG, `Copying asset(s): ${chalk.redBright(context.workspaceConfig.workspaceRoot === asset.input ? asset.glob : joinPaths(replacePath(asset.input, context.workspaceConfig.workspaceRoot), asset.glob))} -> ${chalk.greenBright(joinPaths(replacePath(asset.output, context.workspaceConfig.workspaceRoot), asset.glob))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk.yellowBright(i)).join(", ")})` : ""}`);
-			await context.fs.copy(asset, asset.output);
-		}));
-		await this.callHook("build", {
-			environment: context,
-			order: "post"
-		});
-	}
-	/**
-	* Get the configured environments
-	*
-	* @returns The configured environments
-	*/
-	async #getEnvironments() {
-		if (!this.context.config.environments || Object.keys(this.context.config.environments).length <= 1) {
-			this.context.log(LogLevelLabel.DEBUG, "No environments are configured for this Powerlines project. Using the default environment.");
-			return [await this.context.getEnvironment()];
-		}
-		this.context.log(LogLevelLabel.DEBUG, `Found ${Object.keys(this.context.config.environments).length} configured environment(s) for this Powerlines project.`);
-		return (await Promise.all(Object.entries(this.context.config.environments).map(async ([name, config]) => {
-			if (!await this.context.getEnvironmentSafe(name)) {
-				const resolvedEnvironment = await this.callHook("configEnvironment", { environment: name }, name, config);
-				if (resolvedEnvironment) this.context.environments[name] = await this.context.in(resolvedEnvironment);
-			}
-			return this.context.environments[name];
-		}))).filter((context) => isSet(context));
-	}
-	/**
-	* Execute a handler function for each environment
-	*
-	* @param handle - The handler function to execute for each environment
-	*/
-	async #executeEnvironments(handle) {
-		await Promise.all((await this.#getEnvironments()).map(async (context) => {
-			return Promise.resolve(handle(context));
-		}));
-	}
-	/**
-	* Add a Powerlines plugin used in the build process
-	*
-	* @param config - The import path of the plugin to add
-	*/
-	async #addPlugin(config) {
-		if (config) {
-			const result = await this.#initPlugin(config);
-			if (!result) return;
-			for (const plugin of result) {
-				this.context.log(LogLevelLabel.DEBUG, `Successfully initialized the ${chalk.bold.cyanBright(plugin.name)} plugin`);
-				await this.context.addPlugin(plugin);
-			}
-		}
-	}
-	/**
-	* Initialize a Powerlines plugin
-	*
-	* @param config - The configuration for the plugin
-	* @returns The initialized plugin instance, or null if the plugin was a duplicate
-	* @throws Will throw an error if the plugin cannot be found or is invalid
-	*/
-	async #initPlugin(config) {
-		let awaited = config;
-		if (isPromiseLike(config)) awaited = await Promise.resolve(config);
-		if (!isPluginConfig(awaited)) {
-			const invalid = findInvalidPluginConfig(awaited);
-			throw new Error(`Invalid ${invalid && invalid.length > 1 ? "plugins" : "plugin"} specified in the configuration - ${invalid && invalid.length > 0 ? JSON.stringify(awaited) : invalid?.join("\n\n")} \n\nPlease ensure the value is one of the following: \n - an instance of \`Plugin\` \n - a plugin name \n - an object with the \`plugin\` and \`options\` properties \n - a tuple array with the plugin and options \n - a factory function that returns a plugin or array of plugins \n - an array of plugins or plugin configurations`);
-		}
-		let plugins;
-		if (isPlugin(awaited)) plugins = [awaited];
-		else if (isFunction(awaited)) plugins = toArray(await Promise.resolve(awaited()));
-		else if (isString(awaited)) {
-			const resolved = await this.#resolvePlugin(awaited);
-			if (isFunction(resolved)) plugins = toArray(await Promise.resolve(resolved()));
-			else plugins = toArray(resolved);
-		} else if (Array.isArray(awaited) && awaited.every(isPlugin)) plugins = awaited;
-		else if (Array.isArray(awaited) && awaited.every(isPluginConfig)) {
-			plugins = [];
-			for (const pluginConfig of awaited) {
-				const initialized = await this.#initPlugin(pluginConfig);
-				if (initialized) plugins.push(...initialized);
-			}
-		} else if (isPluginConfigTuple(awaited) || isPluginConfigObject(awaited)) {
-			let pluginConfig;
-			let pluginOptions;
-			if (isPluginConfigTuple(awaited)) {
-				pluginConfig = awaited[0];
-				pluginOptions = awaited?.length === 2 ? awaited[1] : void 0;
-			} else {
-				pluginConfig = awaited.plugin;
-				pluginOptions = awaited.options;
-			}
-			if (isSetString(pluginConfig)) {
-				const resolved = await this.#resolvePlugin(pluginConfig);
-				if (isFunction(resolved)) plugins = toArray(await Promise.resolve(pluginOptions ? resolved(pluginOptions) : resolved()));
-				else plugins = toArray(resolved);
-			} else if (isFunction(pluginConfig)) plugins = toArray(await Promise.resolve(pluginConfig(pluginOptions)));
-			else if (Array.isArray(pluginConfig) && pluginConfig.every(isPlugin)) plugins = pluginConfig;
-			else if (isPlugin(pluginConfig)) plugins = toArray(pluginConfig);
-		}
-		if (!plugins) throw new Error(`The plugin configuration ${JSON.stringify(awaited)} is invalid. This configuration must point to a valid Powerlines plugin module.`);
-		if (plugins.length > 0 && !plugins.every(isPlugin)) throw new Error(`The plugin option ${JSON.stringify(plugins)} does not export a valid module. This configuration must point to a valid Powerlines plugin module.`);
-		const result = [];
-		for (const plugin of plugins) if (checkDedupe(plugin, this.context.plugins)) this.context.log(LogLevelLabel.TRACE, `Duplicate ${chalk.bold.cyanBright(plugin.name)} plugin dependency detected - Skipping initialization.`);
-		else {
-			result.push(plugin);
-			this.context.log(LogLevelLabel.TRACE, `Initializing the ${chalk.bold.cyanBright(plugin.name)} plugin...`);
-		}
-		return result;
-	}
-	async #resolvePlugin(pluginPath) {
-		if (pluginPath.startsWith("@") && pluginPath.split("/").filter(Boolean).length > 2) {
-			const splits = pluginPath.split("/").filter(Boolean);
-			pluginPath = `${splits[0]}/${splits[1]}`;
-		}
-		const isInstalled = isPackageExists(pluginPath, { paths: [this.context.workspaceConfig.workspaceRoot, this.context.config.projectRoot] });
-		if (!isInstalled && this.context.config.skipInstalls !== true) {
-			this.#context.log(LogLevelLabel.WARN, `The plugin package "${pluginPath}" is not installed. It will be installed automatically.`);
-			const result = await install(pluginPath, { cwd: this.context.config.projectRoot });
-			if (isNumber(result.exitCode) && result.exitCode > 0) {
-				this.#context.log(LogLevelLabel.ERROR, result.stderr);
-				throw new Error(`An error occurred while installing the build plugin package "${pluginPath}" `);
-			}
-		}
-		try {
-			const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(joinPaths(pluginPath, "plugin")));
-			const result = module.plugin ?? module.default;
-			if (!result) throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
-			return result;
-		} catch (error) {
-			try {
-				const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(pluginPath));
-				const result = module.plugin ?? module.default;
-				if (!result) throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
-				return result;
-			} catch {
-				if (!isInstalled) throw new Error(`The plugin package "${pluginPath}" is not installed. Please install the package using the command: "npm install ${pluginPath} --save-dev"`);
-				else throw new Error(`An error occurred while importing the build plugin package "${pluginPath}":
-${isError(error) ? error.message : String(error)}
-
-Note: Please ensure the plugin package's default export is a class that extends \`Plugin\` with a constructor that excepts a single arguments of type \`PluginOptions\`.`);
-			}
-		}
-	}
-};
-
-//#endregion
-//#region ../powerlines/src/lib/utilities/source-file.ts
-/**
-* Get the string from the source.
-*
-* @param code - The source string or magic string.
-* @returns The source string.
-*/
-function getString(code) {
-	if (!code) return "";
-	if (isString(code)) return code;
-	if (isSetObject(code) && "code" in code) return code.code;
-	return code.toString();
-}
-
-//#endregion
-//#region ../powerlines/src/lib/unplugin/helpers.ts
-/**
-* Merges a base plugin context with an unplugin context, combining their properties.
-*
-* @param context - The base plugin context to merge into.
-* @param unplugin - The unplugin context to merge from.
-* @returns The merged context.
-*/
-function combineContexts(context, unplugin) {
-	return defu(context, unplugin);
-}
-
-//#endregion
-//#region ../powerlines/src/lib/unplugin/plugin.ts
-/**
-* Creates a Powerlines unplugin instance.
-*
-* @param context - The plugin context.
-* @returns The unplugin instance.
-*/
-function createUnplugin(context) {
-	const ctx = context;
-	setParseImpl(ctx.parse);
-	return () => {
-		const log = extendLog(ctx.log, "unplugin");
-		log(LogLevelLabel.DEBUG, "Initializing Unplugin");
-		try {
-			async function buildStart() {
-				log(LogLevelLabel.DEBUG, "Powerlines build plugin starting...");
-				await ctx.$$internal.callHook("buildStart", { sequential: true });
-			}
-			async function resolveId(id, importer, opts = { isEntry: false }) {
-				const resolved = await (async () => {
-					let result = await ctx.$$internal.callHook("resolveId", {
-						sequential: true,
-						result: "first",
-						order: "pre"
-					}, id, importer, opts);
-					if (result) return result;
-					result = await ctx.$$internal.callHook("resolveId", {
-						sequential: true,
-						result: "first",
-						order: "normal"
-					}, id, importer, opts);
-					if (result) return result;
-					result = await ctx.resolve(id, importer, opts);
-					if (result) return result;
-					return ctx.$$internal.callHook("resolveId", {
-						sequential: true,
-						result: "first",
-						order: "post"
-					}, id, importer, opts);
-				})();
-				if (resolved && opts.isEntry && ctx.config.build.polyfill && ctx.config.build.polyfill.length > 0) {
-					const entry = ctx.entry.find((entry$1) => entry$1.file === (isString(resolved) ? resolved : resolved.id));
-					if (entry) {
-						entry.file = `${replaceExtension(isString(resolved) ? resolved : resolved.id)}-polyfill.ts`;
-						entry.output ||= entry.output?.replace(findFileName(entry.output, { withExtension: true }), entry.file);
-						await ctx.emitEntry(`
-${ctx.config.build.polyfill.map((p) => `import "${p}";`).join("\n")}
-
-export * from "${isString(resolved) ? resolved : resolved.id}";
-`, entry.file);
-						return entry.file;
-					}
-				}
-				return resolved;
-			}
-			async function load(id) {
-				let result = await ctx.$$internal.callHook("load", {
-					sequential: true,
-					result: "first",
-					order: "pre"
-				}, id);
-				if (result) return result;
-				result = await ctx.$$internal.callHook("load", {
-					sequential: true,
-					result: "first",
-					order: "normal"
-				}, id);
-				if (result) return result;
-				result = await ctx.load(id);
-				if (result) return result;
-				return ctx.$$internal.callHook("load", {
-					sequential: true,
-					result: "first",
-					order: "post"
-				}, id);
-			}
-			async function transform(code, id) {
-				let transformed = code;
-				for (const handler of ctx.$$internal.environment.selectHooks("transform")) {
-					const result = await handler.handle.apply(combineContexts(ctx, this), [getString(transformed), id]);
-					if (result) transformed = result;
-				}
-				return transformed;
-			}
-			async function buildEnd() {
-				log(LogLevelLabel.DEBUG, "Powerlines build plugin finishing...");
-				return ctx.$$internal.callHook("buildEnd", { sequential: true });
-			}
-			async function writeBundle() {
-				log(LogLevelLabel.DEBUG, "Finalizing Powerlines project output...");
-				return ctx.$$internal.callHook("writeBundle", { sequential: true });
-			}
-			return {
-				name: "powerlines",
-				api: ctx.$$internal.api,
-				resolveId: {
-					filter: { id: { include: [/.*/] } },
-					handler: resolveId
-				},
-				load: {
-					filter: { id: { include: [/.*/] } },
-					handler: load
-				},
-				transform,
-				buildStart,
-				buildEnd,
-				writeBundle,
-				vite: { sharedDuringBuild: true }
-			};
-		} catch (error) {
-			log(LogLevelLabel.FATAL, error?.message);
-			throw error;
-		}
-	};
-}
-
-//#endregion
-//#region src/helpers/unplugin.ts
-function createWebpackPlugin$1(context) {
-	return createWebpackPlugin(createUnplugin(context))({});
-}
-
-//#endregion
-export { createWebpackPlugin$1 as t };