@powerlines/engine 0.47.3 → 0.49.1

package/dist/api.mjs

@@ -1,1269 +1,36 @@
-import { a as mergeConfigs, i as callHook, s as writeMetaFile, t as PowerlinesExecutionContext } from "./execution-context-CE5H90Um.mjs";
-import { a as isIncludeMatchFound, i as getTsconfigFilePath, r as getParsedTypeScriptConfig } from "./tsconfig-HzJsMUrr.mjs";
-import { n as createProgram } from "./ts-morph-C6YBNc46.mjs";
-import { uuid } from "@stryke/unique-id/uuid";
-import { getTypescriptFileHeader } from "@powerlines/core/lib/utilities/file-header";
-import { format, formatFolder } from "@powerlines/core/lib/utilities/format";
-import { findInvalidPluginConfig, formatConfig, isDuplicate, isPlugin, isPluginConfig, isPluginConfigObject, isPluginConfigTuple } from "@powerlines/core/plugin-utils";
-import { colorText } from "@powerlines/core/plugin-utils/logging";
-import { formatLogMessage } from "@storm-software/config-tools/logger/console";
-import { toArray } from "@stryke/convert/to-array";
-import { copyFiles } from "@stryke/fs/copy-file";
-import { existsSync } from "@stryke/fs/exists";
-import { createDirectory, removeDirectory } from "@stryke/fs/helpers";
-import { install } from "@stryke/fs/install";
-import { listFiles } from "@stryke/fs/list-files";
-import { doesPackageMatch, getPackageListing, isPackageExists, isPackageListed } from "@stryke/fs/package-fns";
-import { resolvePackage } from "@stryke/fs/resolve";
-import { getUnique } from "@stryke/helpers/get-unique";
-import { omit } from "@stryke/helpers/omit";
-import { appendPath } from "@stryke/path/append";
-import { findFileName, findFilePath, relativePath } from "@stryke/path/file-path-fns";
-import { isParentPath } from "@stryke/path/is-parent-path";
-import { joinPaths } from "@stryke/path/join-paths";
-import { replaceExtension, replacePath } from "@stryke/path/replace";
-import { titleCase } from "@stryke/string-format/title-case";
-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 defu from "defu";
-import Handlebars from "handlebars";
-import { readJsonFile } from "@stryke/fs/json";
-import { prettyBytes } from "@stryke/string-format/pretty-bytes";
-import { DiagnosticCategory, Node, Project } from "ts-morph";
-import { getPackageName, getPackageVersion, hasPackageVersion } from "@stryke/string-format/package";
-import { getObjectDiff } from "@donedeal0/superdiff";
-import { StormJSON } from "@stryke/json/storm-json";
+import { prepare as prepare$1 } from "./api/prepare.mjs";
+import { build as build$1 } from "./api/build.mjs";
+import { clean as clean$1 } from "./api/clean.mjs";
+import { create as create$1 } from "./api/create.mjs";
+import { deploy as deploy$1 } from "./api/deploy.mjs";
+import { docs as docs$1 } from "./api/docs.mjs";
+import { lint as lint$1 } from "./api/lint.mjs";
+import { test as test$1 } from "./api/test.mjs";
+import { types as types$1 } from "./api/types.mjs";
+import { createExecutionHost } from "./helpers/create-execution-host.mjs";
 
-//#region 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.replaceAll("#private;", "").replace(/__Ω/g, "");
-}
-async function extractModuleDeclarations(ctx, filePath, name, text) {
-	const imports = [];
-	const exports = [];
-	const comment = text.match(new RegExp(`\\/\\*\\*(?s:.)*?@module\\s+${ctx.context.config.framework}:${name}(?s:.)*?\\*\\/\\s+`))?.find((comment) => isSetString(comment?.trim()));
-	const sourceFile = new Project({ useInMemoryFileSystem: true }).createSourceFile("module.d.ts", text);
-	for (const ref of sourceFile.getTypeReferenceDirectives()) if (ref.getFileName() && !ctx.context.builtins.some((builtin) => ref.getFileName().endsWith(builtin))) imports.push({
-		name: ref.getFileName(),
-		ambient: true
-	});
-	for (const statement of sourceFile.getStatements()) if (Node.isImportDeclaration(statement)) {
-		const moduleSpec = statement.getModuleSpecifierValue();
-		if (statement.getNamespaceImport()) imports.push({
-			name: moduleSpec,
-			specifiers: [{ name: statement.getNamespaceImport().getText() }],
-			all: true
-		});
-		else if (statement.getNamedImports().length > 0 || statement.getDefaultImport()) {
-			const specifiers = [];
-			if (statement.getDefaultImport()) specifiers.push({
-				name: statement.getDefaultImport().getText(),
-				default: true,
-				type: statement.isTypeOnly()
-			});
-			statement.getNamedImports().forEach((named) => {
-				specifiers.push({
-					name: named.getName(),
-					alias: named.getAliasNode()?.getText(),
-					type: statement.isTypeOnly()
-				});
-			});
-			imports.push({
-				name: moduleSpec,
-				specifiers
-			});
-		}
-	} else if (Node.isExportDeclaration(statement)) {
-		const moduleSpec = statement.getModuleSpecifierValue();
-		if (moduleSpec) {
-			let resolvedSpec = moduleSpec;
-			if (!ctx.context.builtins.includes(moduleSpec)) if (ctx.emitted.has(moduleSpec)) resolvedSpec = ctx.emitted.get(moduleSpec);
-			else {
-				const resolvedModule = await ctx.context.resolve(moduleSpec, filePath);
-				if (isSetString(resolvedModule?.id)) resolvedSpec = resolvedModule.id;
-			}
-			const namedExports = statement.getNamedExports();
-			if (namedExports.length > 0) exports.push({
-				name: resolvedSpec,
-				text: statement.getText(),
-				fullText: statement.getFullText(),
-				specifiers: namedExports.map((named) => ({
-					name: named.getName(),
-					alias: named.getAliasNode()?.getText(),
-					type: statement.isTypeOnly()
-				})),
-				comment: statement.getLeadingCommentRanges().filter((c) => isSetString(c.getText().trim()) && !c.getText().includes("@module")).map((c) => c.getText().trim()).join("\n").trim()
-			});
-			else exports.push({
-				name: resolvedSpec,
-				text: statement.getText(),
-				fullText: statement.getFullText(),
-				all: true,
-				comment: statement.getLeadingCommentRanges().filter((c) => isSetString(c.getText().trim()) && !c.getText().includes("@module")).map((c) => c.getText().trim()).join("\n").trim()
-			});
-		} else {
-			const specifiers = statement.getNamedExports().map((named) => ({
-				name: named.getName(),
-				alias: named.getAliasNode()?.getText(),
-				type: statement.isTypeOnly()
-			}));
-			if (specifiers.length > 0) exports.push({
-				text: statement.getText(),
-				fullText: statement.getFullText(),
-				specifiers,
-				comment: statement.getLeadingCommentRanges().filter((c) => isSetString(c.getText().trim()) && !c.getText().includes("@module")).map((c) => c.getText().trim()).join("\n")
-			});
-		}
-	} else if (Node.isExportAssignment(statement)) exports.push({
-		text: statement.getText(),
-		fullText: statement.getFullText(),
-		comment: statement.getLeadingCommentRanges().filter((c) => isSetString(c.getText().trim()) && !c.getText().includes("@module")).map((c) => c.getText().trim()).join("\n")
-	});
-	else if (Node.isFunctionDeclaration(statement) && statement.isExported() && statement.getNameNode()) exports.push({
-		text: statement.getText(),
-		fullText: statement.getFullText(),
-		specifiers: [{ name: statement.getNameNode().getText() }],
-		comment: statement.getLeadingCommentRanges().filter((c) => isSetString(c.getText().trim()) && !c.getText().includes("@module")).map((c) => c.getText().trim()).join("\n")
-	});
-	else if (Node.isVariableStatement(statement) && statement.isExported()) exports.push({
-		text: statement.getText(),
-		fullText: statement.getFullText(),
-		specifiers: statement.getDeclarationList().getDeclarations().filter((decl) => decl.getNameNode() && Node.isIdentifier(decl.getNameNode())).map((decl) => ({ name: decl.getNameNode().getText() })),
-		comment: statement.getLeadingCommentRanges().filter((c) => isSetString(c.getText().trim()) && !c.getText().includes("@module")).map((c) => c.getText().trim()).join("\n")
-	});
-	else if (Node.isClassDeclaration(statement) && statement.isExported()) {
-		const nameNode = statement.getNameNode();
-		exports.push({
-			text: statement.getText(),
-			fullText: statement.getFullText(),
-			specifiers: nameNode ? [{ name: nameNode.getText() }] : void 0,
-			comment: statement.getLeadingCommentRanges().filter((c) => isSetString(c.getText().trim()) && !c.getText().includes("@module")).map((c) => c.getText().trim()).join("\n")
-		});
-	} else if (Node.isInterfaceDeclaration(statement) && statement.isExported()) {
-		const nameNode = statement.getNameNode();
-		exports.push({
-			text: statement.getText(),
-			fullText: statement.getFullText(),
-			specifiers: nameNode ? [{ name: nameNode.getText() }] : void 0,
-			comment: statement.getLeadingCommentRanges().filter((c) => isSetString(c.getText().trim()) && !c.getText().includes("@module")).map((c) => c.getText().trim()).join("\n")
-		});
-	} else if (Node.isTypeAliasDeclaration(statement) && statement.isExported()) {
-		const nameNode = statement.getNameNode();
-		exports.push({
-			text: statement.getText(),
-			fullText: statement.getFullText(),
-			specifiers: nameNode ? [{ name: nameNode.getText() }] : void 0,
-			comment: statement.getLeadingCommentRanges().filter((c) => isSetString(c.getText().trim()) && !c.getText().includes("@module")).map((c) => c.getText().trim()).join("\n")
-		});
-	} else if (ctx.context.config.output.sourceMap || !statement.getFullText().includes("//# sourceMappingURL=")) exports.push({
-		text: statement.getText(),
-		fullText: statement.getFullText(),
-		comment: statement.getLeadingCommentRanges().filter((c) => isSetString(c.getText().trim()) && !c.getText().includes("@module")).map((c) => c.getText().trim()).join("\n")
-	});
-	return {
-		name,
-		text,
-		sourceFile,
-		comment,
-		imports,
-		exports
-	};
-}
-/**
-* 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 emitBuiltinTypes(context, files) {
-	if (files.length === 0) {
-		context.debug("No files provided for TypeScript types generation. Typescript compilation for built-in modules will be skipped.");
-		return {
-			code: "",
-			directives: []
-		};
-	}
-	context.debug(`Running the TypeScript compiler for ${files.length} generated built-in module files.`);
-	const program = createProgram(context, {
-		skipAddingFilesFromTsConfig: true,
-		compilerOptions: {
-			declaration: true,
-			declarationMap: false,
-			emitDeclarationOnly: true,
-			sourceMap: false,
-			outDir: replacePath(context.builtinsPath, context.config.cwd),
-			composite: false,
-			incremental: false,
-			tsBuildInfoFile: void 0
-		}
-	});
-	program.addSourceFilesAtPaths(files);
-	const emitResult = program.emitToMemory({ emitOnlyDtsFiles: true });
-	const diagnostics = emitResult.getDiagnostics();
-	if (diagnostics && diagnostics.length > 0) if (diagnostics.some((d) => d.getCategory() === DiagnosticCategory.Error)) throw new Error(`The Typescript emit process failed while generating built-in types: \n ${diagnostics.filter((d) => d.getCategory() === DiagnosticCategory.Error).map((d) => `-${d.getSourceFile() ? `${d.getSourceFile()?.getFilePath()}:` : ""} ${String(d.getMessageText())} (at ${d.getStart()}:${d.getLength()})`).join("\n")}`);
-	else if (diagnostics.some((d) => d.getCategory() === DiagnosticCategory.Warning)) context.warn(`The Typescript emit process completed with warnings while generating built-in types: \n ${diagnostics.filter((d) => d.getCategory() === DiagnosticCategory.Warning).map((d) => `-${d.getSourceFile() ? `${d.getSourceFile()?.getFilePath()}:` : ""} ${String(d.getMessageText())} (at ${d.getStart()}:${d.getLength()})`).join("\n")}`);
-	else context.debug(`The Typescript emit process completed with diagnostic messages while generating built-in types: \n ${diagnostics.map((d) => `-${d.getSourceFile() ? `${d.getSourceFile()?.getFilePath()}:` : ""} ${String(d.getMessageText())} (at ${d.getStart()}:${d.getLength()})`).join("\n")}`);
-	const emittedFiles = emitResult.getFiles();
-	context.debug(`The TypeScript compiler emitted ${emittedFiles.length} files for built-in types.`);
-	if (emittedFiles.length === 0) {
-		context.warn("The TypeScript compiler did not emit any files for built-in types. This may indicate an issue with the TypeScript configuration or the provided files.");
-		return {
-			code: "",
-			directives: []
-		};
-	}
-	const ctx = {
-		context,
-		modules: [],
-		emitted: /* @__PURE__ */ new Map()
-	};
-	await Promise.all(emittedFiles.map(async (emittedFile) => {
-		const filePath = appendPath(emittedFile.filePath, context.config.cwd);
-		if (!filePath.endsWith(".map") && findFileName(filePath) !== "tsconfig.tsbuildinfo" && isParentPath(filePath, context.builtinsPath)) {
-			const moduleName = replaceExtension(replacePath(replacePath(filePath, context.builtinsPath), replacePath(context.builtinsPath, context.config.cwd)), "", { fullExtension: true });
-			if (context.builtins.includes(moduleName)) {
-				ctx.emitted.set(filePath, moduleName);
-				ctx.modules.push(await extractModuleDeclarations(ctx, filePath, moduleName, emittedFile.text));
-			}
-		}
-	}));
-	const commonDeclarations = [];
-	for (const mod of ctx.modules) for (const importRef of mod.imports.filter((importRef) => context.builtins.some((builtin) => importRef.name.endsWith(`:${builtin}`)))) {
-		const moduleRef = ctx.modules.find((moduleRef) => importRef.name.endsWith(`:${moduleRef.name}`));
-		if (moduleRef) {
-			let declaration;
-			for (const decl of moduleRef.exports.filter((decl) => isSetObject(decl))) {
-				const specifiers = decl.specifiers?.filter((specifier) => importRef.specifiers?.some((s) => (specifier.alias ? specifier.alias : specifier.name) === (s.alias ? s.alias : s.name)));
-				if (specifiers && specifiers.length > 0) {
-					importRef.specifiers = importRef.specifiers?.filter((s) => !specifiers.some((specifier) => (specifier.alias ? specifier.alias : specifier.name) === (s.alias ? s.alias : s.name)));
-					if (importRef.specifiers && importRef.specifiers.length === 0 && !importRef.all && !importRef.ambient) mod.imports = mod.imports.filter((imp) => imp.name !== importRef.name);
-					declaration = decl;
-					break;
-				}
-			}
-			if (declaration) {
-				for (const decl of moduleRef.exports.filter((decl) => isSetObject(decl) && !decl.specifiers?.some((s) => declaration?.specifiers?.some((specifier) => (specifier.alias ? specifier.alias : specifier.name) === (s.alias ? s.alias : s.name))))) {
-					const exportModuleRef = decl;
-					if ((exportModuleRef.specifiers?.some((s) => s.alias || s.name) || exportModuleRef.name) && new RegExp(`(^|\\s|\\n|\\r\\n|\\(|\\)|<|>|{|}|\\[|\\]|\\!|\\?|\\.|,|\\*|&|:)(${exportModuleRef.specifiers?.map((s) => `${s.alias ? `${s.alias}|` : ""}${s.name}`).join("|") || exportModuleRef.name})($|\\s|\\n|\\r\\n|\\(|\\)|<|>|{|}|\\[|\\]|\\!|\\?|\\.|,|\\*|&|:|;)`).test(declaration.text)) commonDeclarations.push(exportModuleRef);
-				}
-				commonDeclarations.push(declaration);
-			}
-		}
-	}
-	let code = "";
-	const directives = [];
-	for (const commonDeclaration of commonDeclarations) {
-		code += formatTypes(`${commonDeclaration.comment?.trim() ? commonDeclaration.comment.trim() : ""}${commonDeclaration.comment?.trim() ? "\n" : ""}${formatTypes(commonDeclaration.text.replace(/\s*export\s*/, "").replace(/\s*declare\s*interface\s*/, "interface ").replace(/\s*declare\s*type\s*/, "type "))}`);
-		code += "\n\n";
-	}
-	for (const mod of ctx.modules) {
-		code += mod.comment ? `${mod.comment.trim()}\n` : "";
-		code += `declare module "${context.config.framework}:${mod.name}" { \n`;
-		for (const importRef of mod.imports) if (importRef.ambient) code += directives.push(importRef.name);
-		else if (importRef.all) code += `\timport * as ${findFileName(importRef.name)} from "${importRef.name}";\n`;
-		else if (importRef.specifiers) {
-			const typeOnly = importRef.specifiers.every((s) => s.type) ? " type" : "";
-			const specifiers = importRef.specifiers.map((s) => s.alias ? `${s.name} as ${s.alias}` : s.name).join(", ");
-			code += `\timport${typeOnly} { ${specifiers} } from "${importRef.name}";\n`;
-		}
-		if (mod.imports.length > 0) code += "\n";
-		for (const exportRef of mod.exports.filter((e) => isString(e) || !e.specifiers || !commonDeclarations.some((commonDecl) => commonDecl.specifiers && commonDecl.specifiers.some((specifier) => e.specifiers?.some((s) => (s.alias ? s.alias : s.name) === (specifier.alias ? specifier.alias : specifier.name)))))) if (isSetString(exportRef)) code += `${exportRef}\n`;
-		else if (exportRef.name) {
-			if (exportRef.all) code += `${exportRef.comment?.trim() ? exportRef.comment.trim() : ""}${exportRef.comment?.trim() ? "\n" : ""}export * from "${exportRef.name}";\n`;
-			else if (exportRef.specifiers) {
-				if (exportRef.comment?.trim()) code += `${exportRef.comment.trim()}\n`;
-				code += `\texport${exportRef.specifiers.every((s) => s.type) ? " type" : ""} { ${exportRef.specifiers.map((s) => s.alias ? `${s.name} as ${s.alias}` : s.name).join(", ")} } from "${exportRef.name}";\n`;
-			}
-		} else code += `${exportRef.comment?.trim() ? exportRef.comment.trim() : ""}${exportRef.comment?.trim() ? "\n" : ""}${formatTypes(exportRef.text.replace(/\s*export\s*declare\s*/, "export ").replace(/\s*declare\s*/, " "))}\n`;
-		mod.exports.filter((e) => !isString(e) && e.specifiers && commonDeclarations.some((commonDeclaration) => commonDeclaration.specifiers && commonDeclaration.specifiers.some((specifier) => e.specifiers?.some((s) => (s.alias ? s.alias : s.name) === (specifier.alias ? specifier.alias : specifier.name))))).forEach((e, i, arr) => {
-			if (i === 0) code += "\nexport { ";
-			else code += ", ";
-			code += `${e?.specifiers?.filter((s) => commonDeclarations.some((commonDeclaration) => commonDeclaration.specifiers && commonDeclaration.specifiers.some((specifier) => (s.alias ? s.alias : s.name) === (specifier.alias ? specifier.alias : specifier.name)))).map((s) => s.alias ? `${s.name} as ${s.alias}` : s.name).join(", ") || ""}`;
-			if (i === arr.length - 1) code += ` };\n`;
-		});
-		code += "}";
-		code += "\n\n";
-	}
-	code = await format(context, context.typesPath, code);
-	context.debug(`A TypeScript declaration file (size: ${prettyBytes(new Blob(toArray(code)).size)}) emitted for the built-in modules types.`);
-	return {
-		code,
-		directives
-	};
-}
-
-//#endregion
-//#region 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.root })) if (context.config.autoInstall) {
-		context.warn(`The package "${packageName}" is not installed. It will be installed automatically.`);
-		const result = await install(packageName, {
-			cwd: context.config.root,
-			dev
-		});
-		if (isNumber(result.exitCode) && result.exitCode > 0) {
-			context.error(result.stderr);
-			throw new Error(`An error occurred while installing the package "${packageName}"`);
-		}
-	} else context.warn(`The package "${packageName}" is not installed. Since the "autoInstall" option is set to false, 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.root)) {
-			const packageListing = await getPackageListing(getPackageName(packageName), { cwd: context.config.root });
-			if (!packageListing?.version.startsWith("catalog:") && !packageListing?.version.startsWith("workspace:")) context.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 src/_internal/helpers/install-dependencies.ts
-/**
-* Install missing project dependencies.
-*
-* @param context - The build context.
-*/
-async function installDependencies(context) {
-	context.debug(`Checking and installing missing project dependencies.`);
-	context.dependencies ??= {};
-	context.devDependencies ??= {};
-	if (Object.keys(context.dependencies).length === 0 && Object.keys(context.devDependencies).length === 0) {
-		context.debug(`No dependencies or devDependencies to install. Skipping installation step.`);
-		return;
-	}
-	context.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 src/_internal/helpers/resolve-tsconfig.ts
-function getTsconfigDtsPath(context) {
-	return joinPaths(relativePath(joinPaths(context.config.cwd, context.config.root), findFilePath(context.typesPath)), findFileName(context.typesPath));
-}
-async function resolveTsconfigChanges(context) {
-	const tsconfig = getParsedTypeScriptConfig(context.config.cwd, context.config.root, context.config.tsconfig, context.config.tsconfigRaw);
-	const tsconfigJson = await readJsonFile(getTsconfigFilePath(context.config.cwd, context.config.root, context.config.tsconfig));
-	tsconfigJson.compilerOptions ??= {};
-	if (context.config.output.dts !== false) {
-		const dtsRelativePath = getTsconfigDtsPath(context);
-		if (!tsconfigJson.include?.some((filePattern) => isIncludeMatchFound(filePattern, [context.typesPath, 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.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.debug("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.config.cwd, context.config.root, context.config.tsconfig);
-	context.tsconfig.originalTsconfigJson = await readJsonFile(tsconfigFilePath);
-	context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
-	context.debug("Writing updated TypeScript configuration (tsconfig.json) file to disk.");
-	await context.fs.write(tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson));
-	context.tsconfig = getParsedTypeScriptConfig(context.config.cwd, context.config.root, 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.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.config.cwd, context.config.root, context.config.tsconfig);
-	if (!context.tsconfig) throw new Error("Failed to parse the TypeScript configuration file.");
-}
-
-//#endregion
-//#region src/_internal/execution.ts
-/**
-* The Powerlines Execution API class
-*
-* @remarks
-* This class is responsible for managing the Powerlines project lifecycle, including initialization, building, and finalization.
-*
-* @internal
-*/
-var PowerlinesExecution = class PowerlinesExecution {
-	/**
-	* The Powerlines context
-	*/
-	#context;
-	/**
-	* Initialize a Powerlines API instance
-	*
-	* @param options - The options to initialize the API with
-	* @returns A new instance of the Powerlines API
-	*/
-	static async from(options, initialConfig) {
-		const api = new PowerlinesExecution(await PowerlinesExecutionContext.fromInitialConfig(options, initialConfig ?? {}));
-		await api.init();
-		return api;
-	}
-	/**
-	* The Powerlines context
-	*/
-	get context() {
-		return this.#context;
-	}
-	/**
-	* Generate the Powerlines typescript declaration file
-	*
-	* @remarks
-	* This method will only generate the typescript declaration file for the Powerlines project. It is generally recommended to run the full `prepare` command, which will run this method as part of its process.
-	*
-	* @param inlineConfig - The inline configuration for the types command
-	*/
-	async types(inlineConfig = { command: "types" }) {
-		this.context.debug(" Aggregating configuration options for the Powerlines project");
-		inlineConfig.command ??= "types";
-		await this.context.setInlineConfig(inlineConfig);
-		await this.executeEnvironments(async (context) => {
-			context.debug(`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"
-			});
-			if (context.entry.length > 0) context.debug(`The configuration provided ${isObject(context.config.input) ? Object.keys(context.config.input).length : toArray(context.config.input).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")}` : ""}`);
-			else context.warn(`No entry files were found for the ${context.config.title} project. Please ensure this is correct. Powerlines plugins generally require at least one entry point to function properly.`);
-			await resolveTsconfig(context);
-			await installDependencies(context);
-			await this.callHook("configResolved", {
-				environment: context,
-				order: "post"
-			});
-			context.trace(`Powerlines configuration has been resolved: \n\n${formatLogMessage({
-				...context.config,
-				userConfig: isSetObject(context.config.userConfig) ? omit(context.config.userConfig, ["plugins"]) : void 0,
-				inlineConfig: isSetObject(context.config.inlineConfig) ? omit(context.config.inlineConfig, ["plugins"]) : void 0,
-				plugins: context.plugins.map((plugin) => plugin.plugin.name)
-			})}`);
-			if (!context.fs.existsSync(context.cachePath)) await createDirectory(context.cachePath);
-			if (!context.fs.existsSync(context.dataPath)) await createDirectory(context.dataPath);
-			if (context.config.skipCache === true || context.persistedMeta?.checksum !== context.meta.checksum) context.debug(`Using previously prepared files as the meta checksum has not changed.`);
-			else {
-				context.info(`Running \`prepare\` command as the meta checksum has changed since the last run.`);
-				await this.prepare(defu({ output: { types: false } }, inlineConfig));
-			}
-			await this.handleTypes(context);
-			this.context.debug("Formatting files generated during the types step.");
-			await format(context, context.typesPath, await context.fs.read(context.typesPath) ?? "");
-			await writeMetaFile(context);
-			context.persistedMeta = context.meta;
-		});
-	}
-	/**
-	* 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" }) {
-		inlineConfig.command ??= "prepare";
-		await this.context.setInlineConfig(inlineConfig);
-		await this.executeEnvironments(async (context) => {
-			context.debug(`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"
-			});
-			if (context.entry.length > 0) context.debug(`The configuration provided ${isObject(context.config.input) ? Object.keys(context.config.input).length : toArray(context.config.input).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")}` : ""}`);
-			else context.warn(`No entry files were found for the ${context.config.title} project. Please ensure this is correct. Powerlines plugins generally require at least one entry point to function properly.`);
-			await resolveTsconfig(context);
-			await installDependencies(context);
-			await this.callHook("configResolved", {
-				environment: context,
-				order: "post"
-			});
-			context.trace({
-				meta: { category: "config" },
-				message: `Powerlines configuration after configResolved hook: \n${formatConfig(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"
-			});
-			await this.callHook("prepare", {
-				environment: context,
-				order: "post"
-			});
-			if (context.config.output.types !== false) await this.handleTypes(context);
-			this.context.debug("Formatting files generated during the prepare step.");
-			await Promise.all([formatFolder(context, context.builtinsPath), formatFolder(context, context.entryPath)]);
-			await writeMetaFile(context);
-			context.persistedMeta = context.meta;
-		});
-	}
-	/**
-	* 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) {
-		inlineConfig.command ??= "new";
-		await this.prepare(inlineConfig);
-		await this.executeEnvironments(async (context) => {
-			context.debug("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.trace(`Adding template file to project: ${file}`);
-				const template = Handlebars.compile(file);
-				await context.fs.write(joinPaths(context.config.root, file.replace(".hbs", "")), template(context));
-			}
-			await this.callHook("new", {
-				environment: context,
-				order: "normal"
-			});
-			if (context.config.projectType === "application") {
-				const files = await listFiles(joinPaths(context.powerlinesPath, "files/application/**/*.hbs"));
-				for (const file of files) {
-					context.trace(`Adding application template file: ${file}`);
-					const template = Handlebars.compile(file);
-					await context.fs.write(joinPaths(context.config.root, file.replace(".hbs", "")), template(context));
-				}
-			} else {
-				const files = await listFiles(joinPaths(context.powerlinesPath, "files/library/**/*.hbs"));
-				for (const file of files) {
-					context.trace(`Adding library template file: ${file}`);
-					const template = Handlebars.compile(file);
-					await context.fs.write(joinPaths(context.config.root, file.replace(".hbs", "")), template(context));
-				}
-			}
-			await this.callHook("new", {
-				environment: context,
-				order: "post"
-			});
-		});
-	}
-	/**
-	* 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" }) {
-		inlineConfig.command ??= "clean";
-		await this.prepare(inlineConfig);
-		await this.executeEnvironments(async (context) => {
-			context.debug("Cleaning the project's dist and artifacts directories.");
-			await context.fs.remove(joinPaths(context.config.cwd, context.config.output.path));
-			await context.fs.remove(joinPaths(context.config.cwd, context.config.root, context.config.output.artifactsPath));
-			await this.callHook("clean", {
-				environment: context,
-				sequential: false
-			});
-		});
-	}
-	/**
-	* 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" }) {
-		inlineConfig.command ??= "lint";
-		await this.prepare(inlineConfig);
-		await this.executeEnvironments(async (context) => {
-			await this.callHook("lint", {
-				environment: context,
-				sequential: false
-			});
-		});
-	}
-	/**
-	* Test the project source code
-	*
-	* @param inlineConfig - The inline configuration for the test command
-	* @returns A promise that resolves when the test command has completed
-	*/
-	async test(inlineConfig = { command: "test" }) {
-		inlineConfig.command ??= "test";
-		await this.prepare(inlineConfig);
-		await this.executeEnvironments(async (context) => {
-			await this.callHook("test", {
-				environment: context,
-				sequential: false
-			});
-		});
-	}
-	/**
-	* 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" }) {
-		inlineConfig.command ??= "build";
-		await this.context.setInlineConfig(inlineConfig);
-		await this.context.generateChecksum();
-		if (this.context.meta.checksum !== this.context.persistedMeta?.checksum || this.context.config.skipCache) {
-			this.context.info(!this.context.persistedMeta?.checksum ? "No previous build cache found. Preparing the project for the initial build." : this.context.meta.checksum !== this.context.persistedMeta.checksum ? "The project has been modified since the last time `prepare` was ran. Re-preparing the project." : "The project is configured to skip cache. Re-preparing the 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);
-		});
-	}
-	/**
-	* 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" }) {
-		inlineConfig.command ??= "docs";
-		await this.context.setInlineConfig(inlineConfig);
-		await this.prepare(inlineConfig);
-		await this.executeEnvironments(async (context) => {
-			context.debug("Writing documentation for the Powerlines project artifacts.");
-			await this.callHook("docs", { environment: context });
-		});
-	}
-	/**
-	* 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" }) {
-		inlineConfig.command ??= "deploy";
-		await this.context.setInlineConfig(inlineConfig);
-		await this.prepare(inlineConfig);
-		await this.executeEnvironments(async (context) => {
-			await this.callHook("deploy", { environment: context });
-		});
-	}
-	/**
-	* Finalization/cleanup processing for the Powerlines API
-	*
-	* @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() {
-		await this.executeEnvironments(async (context) => {
-			await this.callHook("finalize", { environment: context });
-			await context.fs.dispose();
-			if (existsSync(context.cachePath) && !(await listFiles(joinPaths(context.cachePath, "**/*")))?.length) await removeDirectory(context.cachePath);
-		});
-	}
-	/**
-	* 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);
-	}
-	/**
-	* Create a new Powerlines API instance
-	*
-	* @param context - The Powerlines context
-	*/
-	constructor(context) {
-		this.#context = context;
-	}
-	/**
-	* Initialize the execution API with the provided configuration options
-	*/
-	async init() {
-		this.#context.$$internal = {
-			api: this,
-			addPlugin: this.addPlugin.bind(this)
-		};
-		const timer = this.#context.timer("Initialization");
-		for (const plugin of this.#context.config.plugins.flatMap((p) => toArray(p)) ?? []) await this.addPlugin(plugin);
-		if (this.#context.plugins.length === 0) this.#context.warn({
-			meta: { category: "plugins" },
-			message: "No Powerlines plugins were specified in the options. Please ensure this is correct, as it is generally not recommended."
-		});
-		else this.#context.info({
-			meta: { category: "plugins" },
-			message: `Loaded ${this.#context.plugins.length} ${titleCase(this.#context.config.framework)} plugin${this.#context.plugins.length > 1 ? "s" : ""}: \n${this.#context.plugins.map((plugin, index) => ` ${index + 1}. ${colorText(plugin.name)}`).join("\n")}`
-		});
-		const pluginConfig = await this.callHook("config", {
-			environment: await this.#context.getEnvironment(),
-			sequential: true,
-			result: "merge",
-			merge: mergeConfigs
-		});
-		if (pluginConfig) await this.context.setPluginConfig(pluginConfig);
-		else this.context.debug({
-			meta: { category: "config" },
-			message: "No plugin configuration was returned from the config hook."
-		});
-		timer();
-	}
-	/**
-	* 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.debug({
-					meta: { category: "plugins" },
-					message: `Successfully initialized the ${chalk.bold.cyanBright(plugin.name)} plugin`
-				});
-				await this.context.addPlugin(plugin);
-			}
-		}
-	}
-	/**
-	* 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.debug({
-				meta: { category: "config" },
-				message: "No environments are configured for this Powerlines project. Using the default environment."
-			});
-			return [await this.context.getEnvironment()];
-		}
-		this.context.debug({
-			meta: { category: "config" },
-			message: `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.createEnvironment(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));
-		}));
-	}
-	/**
-	* 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 (isDuplicate(plugin, this.context.plugins)) this.context.trace({
-			meta: { category: "plugins" },
-			message: `Duplicate ${chalk.bold.cyanBright(plugin.name)} plugin dependency detected - Skipping initialization.`
-		});
-		else {
-			result.push(plugin);
-			this.context.trace({
-				meta: { category: "plugins" },
-				message: `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.config.cwd, this.context.config.root] });
-		if (!isInstalled && this.context.config.autoInstall) {
-			this.#context.warn(`The plugin package "${pluginPath}" is not installed. It will be installed automatically.`);
-			const result = await install(pluginPath, { cwd: this.context.config.root });
-			if (isNumber(result.exitCode) && result.exitCode > 0) {
-				this.#context.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\`.`);
-			}
-		}
-	}
-	async handleBuild(context) {
-		await this.callHook("build", {
-			environment: context,
-			order: "pre"
-		});
-		context.debug("Formatting the generated entry files before the build process starts.");
-		await formatFolder(context, context.entryPath);
-		await this.callHook("build", {
-			environment: context,
-			order: "normal"
-		});
-		if (context.config.output.copy) {
-			context.debug("Copying project's files from build output directory.");
-			const destinationPath = isParentPath(appendPath(context.config.output.path, context.config.cwd), appendPath(context.config.root, context.config.cwd)) ? joinPaths(context.config.output.copy.path, relativePath(appendPath(context.config.root, context.config.cwd), appendPath(context.config.output.path, context.config.cwd))) : joinPaths(context.config.output.copy.path, "dist");
-			const sourcePath = context.config.output.path;
-			if (existsSync(sourcePath) && sourcePath !== destinationPath) {
-				context.debug(`Copying files from project's build output directory (${context.config.output.path}) to the project's copy/publish directory (${destinationPath}).`);
-				await copyFiles(sourcePath, destinationPath);
-			} else context.warn(`The source path for the copy operation ${!existsSync(sourcePath) ? "does not exist" : "is the same as the destination path"}. Source: ${sourcePath}, Destination: ${destinationPath}. Skipping copying of build output files.`);
-			if (context.config.output.copy.assets && Array.isArray(context.config.output.copy.assets)) await Promise.all(context.config.output.copy.assets.map(async (asset) => {
-				context.trace(`Copying asset(s): ${chalk.redBright(context.config.cwd === asset.input ? asset.glob : appendPath(asset.glob, replacePath(asset.input, context.config.cwd)))} -> ${chalk.greenBright(appendPath(asset.glob, replacePath(asset.output, context.config.cwd)))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk.yellowBright(i)).join(", ")})` : ""}`);
-				await context.fs.copy(asset, asset.output);
-			}));
-		} else context.debug("No copy configuration found for the project output. Skipping the copying of build output files.");
-		await this.callHook("build", {
-			environment: context,
-			order: "post"
-		});
-	}
-	/**
-	* Generate the Powerlines TypeScript declaration file
-	*
-	* @remarks
-	* This method will generate the TypeScript declaration file for the Powerlines project, including any types provided by plugins.
-	*
-	* @param context - The environment context to use for generating the TypeScript declaration file
-	* @returns A promise that resolves when the TypeScript declaration file has been generated
-	*/
-	async handleTypes(context) {
-		context.debug(`Preparing the TypeScript definitions for the Powerlines project.`);
-		if (context.fs.existsSync(context.typesPath)) await context.fs.remove(context.typesPath);
-		if (!await resolvePackage("typescript")) throw new Error("Could not resolve TypeScript package location. Please ensure TypeScript is installed.");
-		context.debug("Running TypeScript compiler for built-in runtime module files.");
-		let { code, directives } = await emitBuiltinTypes(context, (await context.getBuiltins()).reduce((ret, builtin) => {
-			const formatted = replacePath(builtin.path, context.config.cwd);
-			if (!ret.includes(formatted)) ret.push(formatted);
-			return ret;
-		}, []));
-		context.debug(`Generating TypeScript declaration file ${context.typesPath}.`);
-		const merge = async (currentResult, previousResult) => {
-			if (!isSetString(currentResult) && !isSetObject(currentResult) && !isSetString(previousResult) && !isSetObject(previousResult)) return {
-				code,
-				directives
-			};
-			const previous = (await format(context, context.typesPath, isSetString(previousResult) ? previousResult : isSetObject(previousResult) ? previousResult.code : "")).trim().replace(code, "").trim();
-			const current = (await format(context, context.typesPath, isSetString(currentResult) ? currentResult : isSetObject(currentResult) ? currentResult.code : "")).trim().replace(previous, "").trim().replace(code, "").trim();
-			return {
-				directives: [...isSetObject(currentResult) && currentResult.directives ? currentResult.directives : [], ...isSetObject(previousResult) && previousResult.directives ? previousResult.directives : []],
-				code: await format(context, context.typesPath, `${!previous.includes(getTypescriptFileHeader(context)) && !current.includes(getTypescriptFileHeader(context)) ? `${code}\n` : ""}${previous}\n${current}`.trim())
-			};
-		};
-		const asNextParam = (previousResult) => isObject(previousResult) ? previousResult.code : previousResult;
-		let result = await this.callHook("types", {
-			environment: context,
-			sequential: true,
-			order: "pre",
-			result: "merge",
-			merge,
-			asNextParam
-		}, code);
-		if (result) {
-			if (isSetObject(result)) {
-				code = result.code;
-				if (Array.isArray(result.directives) && result.directives.length > 0) directives = getUnique([...directives, ...result.directives]).filter(Boolean);
-			} else if (isSetString(result)) code = result;
-		}
-		result = await this.callHook("types", {
-			environment: context,
-			sequential: true,
-			order: "normal",
-			result: "merge",
-			merge,
-			asNextParam
-		}, code);
-		if (result) {
-			if (isSetObject(result)) {
-				code = result.code;
-				if (Array.isArray(result.directives) && result.directives.length > 0) directives = getUnique([...directives, ...result.directives]).filter(Boolean);
-			} else if (isSetString(result)) code = result;
-		}
-		result = await this.callHook("types", {
-			environment: context,
-			sequential: true,
-			order: "post",
-			result: "merge",
-			merge,
-			asNextParam
-		}, code);
-		if (result) {
-			if (isSetObject(result)) {
-				code = result.code;
-				if (Array.isArray(result.directives) && result.directives.length > 0) directives = getUnique([...directives, ...result.directives]).filter(Boolean);
-			} else if (isSetString(result)) code = result;
-		}
-		if (isSetString(code?.trim()) || directives.length > 0) await context.fs.write(context.typesPath, `${directives.length > 0 ? `${directives.map((directive) => `/// <reference types="${directive}" />`).join("\n")}
-
-` : ""}${getTypescriptFileHeader(context, {
-			directive: null,
-			prettierIgnore: false
-		})}
-
-${formatTypes(code)}
-`);
-	}
-};
-
-//#endregion
 //#region 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 extends PowerlinesExecution {
-	/**
-	* Initialize a Powerlines API instance
-	*
-	* @param options - The options to initialize the API with
-	* @param initialConfig - The initial configuration for the API, which can be used to provide additional context or override certain configuration values during initialization. This is particularly useful when initializing the API from a CLI command, where the CLI flags can be passed as part of the initial configuration to ensure they are properly merged with the configuration file and made available to plugins during their setup and execution.
-	* @returns A new instance of the Powerlines API
-	*/
-	static async from(options, initialConfig) {
-		const api = new PowerlinesAPI(await PowerlinesExecutionContext.fromInitialConfig({
-			executionId: uuid(),
-			executionIndex: 0,
-			...options
-		}, initialConfig ?? {}));
-		await api.init();
-		return api;
-	}
-	/**
-	* Generate the Powerlines typescript declaration file
-	*
-	* @remarks
-	* This method will only generate the typescript declaration file for the Powerlines project. It is generally recommended to run the full `prepare` command, which will run this method as part of its process.
-	*
-	* @param inlineConfig - The inline configuration for the types command
-	*/
-	async types(inlineConfig = { command: "types" }) {
-		const timer = this.context.timer("Types");
-		this.context.info("🏗️  Generating typescript declarations for the Powerlines project");
-		await super.types(inlineConfig);
-		this.context.debug("✔ Powerlines types generation has completed successfully");
-		timer();
-	}
-	/**
-	* 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" }) {
-		const timer = this.context.timer("Prepare");
-		this.context.info("🏗️ Preparing the Powerlines project");
-		this.context.debug(" Aggregating configuration options for the Powerlines project");
-		await super.prepare(inlineConfig);
-		this.context.debug("✔ Powerlines preparation has completed successfully");
-		timer();
-	}
-	/**
-	* 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) {
-		const timer = this.context.timer("New");
-		this.context.info("🆕 Creating a new Powerlines project");
-		await super.new(inlineConfig);
-		this.context.debug("✔ Powerlines new command completed successfully");
-		timer();
-	}
-	/**
-	* 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" }) {
-		const timer = this.context.timer("Clean");
-		this.context.info(" 🧹 Cleaning the previous Powerlines artifacts");
-		await super.clean(inlineConfig);
-		this.context.debug("✔ Powerlines cleaning completed successfully");
-		timer();
-	}
-	/**
-	* 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" }) {
-		const timer = this.context.timer("Lint");
-		this.context.info("📝 Linting the Powerlines project");
-		await super.lint(inlineConfig);
-		this.context.debug("✔ Powerlines linting completed successfully");
-		timer();
-	}
-	/**
-	* Test the project
-	*
-	* @remarks
-	* This method will run the tests for the Powerlines project.
-	*
-	* @param inlineConfig - The inline configuration for the test command
-	* @returns A promise that resolves when the test command has completed
-	*/
-	async test(inlineConfig = { command: "test" }) {
-		const timer = this.context.timer("Test");
-		this.context.info("🧪 Running tests for the Powerlines project");
-		await super.test(inlineConfig);
-		this.context.debug("✔ Powerlines testing completed successfully");
-		timer();
-	}
-	/**
-	* 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" }) {
-		const timer = this.context.timer("Build");
-		this.context.info("📦 Building the Powerlines project");
-		await super.build(inlineConfig);
-		this.context.debug("✔ Powerlines build completed successfully");
-		timer();
-	}
-	/**
-	* 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" }) {
-		const timer = this.context.timer("Docs");
-		this.context.info("📓 Generating documentation for the Powerlines project");
-		await super.docs(inlineConfig);
-		this.context.debug("✔ Powerlines documentation generation completed successfully");
-		timer();
-	}
-	/**
-	* 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" }) {
-		const timer = this.context.timer("Deploy");
-		this.context.info("🚀 Deploying the Powerlines project");
-		await super.deploy(inlineConfig);
-		this.context.debug("✔ Powerlines deploy completed successfully");
-		timer();
-	}
-	/**
-	* Finalization/cleanup processing for the Powerlines API
-	*
-	* @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() {
-		const timer = this.context.timer("Finalization");
-		this.context.info("🏁 Powerlines finalization processes started");
-		await super.finalize();
-		this.context.debug("✔ Powerlines finalization completed successfully");
-		timer();
-	}
-	/**
-	* 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();
-	}
-	/**
-	* Create a new Powerlines API instance
-	*
-	* @param context - The Powerlines context
-	*/
-	constructor(context) {
-		super(context);
-	}
-};
+const executionHost = createExecutionHost({
+	types: types$1,
+	prepare: prepare$1,
+	create: create$1,
+	clean: clean$1,
+	lint: lint$1,
+	test: test$1,
+	build: build$1,
+	docs: docs$1,
+	deploy: deploy$1
+});
+const types = executionHost.types;
+const prepare = executionHost.prepare;
+const create = executionHost.create;
+const clean = executionHost.clean;
+const lint = executionHost.lint;
+const test = executionHost.test;
+const build = executionHost.build;
+const docs = executionHost.docs;
+const deploy = executionHost.deploy;
 
 //#endregion
-export { PowerlinesAPI };
+export { build, clean, create, deploy, docs, lint, prepare, test, types };
 //# sourceMappingURL=api.mjs.map