@powerlines/engine 0.0.2

package/dist/api.mjs

@@ -0,0 +1,1261 @@
+import { a as mergeConfigs, i as callHook, s as writeMetaFile, t as PowerlinesExecutionContext } from "./execution-context-CNhvjS52.mjs";
+import { a as isIncludeMatchFound, i as getTsconfigFilePath, r as getParsedTypeScriptConfig } from "./tsconfig-Cstsoprg.mjs";
+import { n as createProgram } from "./ts-morph-D0CaA37w.mjs";
+import { resolvePackage } from "@stryke/fs/resolve";
+import { isSet } from "@stryke/type-checks/is-set";
+import { isString } from "@stryke/type-checks/is-string";
+import { colorText } from "@powerlines/core/lib/logger";
+import { StormJSON } from "@stryke/json/storm-json";
+import chalk from "chalk";
+import defu from "defu";
+import { joinPaths } from "@stryke/path/join-paths";
+import { titleCase } from "@stryke/string-format/title-case";
+import { getTypescriptFileHeader } from "@powerlines/core/lib/utilities/file-header";
+import { format, formatFolder } from "@powerlines/core/lib/utilities/format";
+import { findInvalidPluginConfig, isDuplicate, isPlugin, isPluginConfig, isPluginConfigObject, isPluginConfigTuple } from "@powerlines/core/plugin-utils";
+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 { 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 { 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 { isSetObject } from "@stryke/type-checks/is-set-object";
+import { isSetString } from "@stryke/type-checks/is-set-string";
+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";
+
+//#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;
+	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"
+		});
+	}
+	/**
+	* 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("No environments are configured for this Powerlines project. Using the default environment.");
+			return [await this.context.getEnvironment()];
+		}
+		this.context.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));
+		}));
+	}
+	/**
+	* 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(`Duplicate ${chalk.bold.cyanBright(plugin.name)} plugin dependency detected - Skipping initialization.`);
+		else {
+			result.push(plugin);
+			this.context.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.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\`.`);
+			}
+		}
+	}
+	/**
+	* 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 #types(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)}
+`);
+	}
+	/**
+	* The Powerlines context
+	*/
+	get context() {
+		return this.#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 fromConfig(options, config) {
+		const api = new PowerlinesExecution(await PowerlinesExecutionContext.fromOptions(options));
+		api.#context.config.inlineConfig = config;
+		await api.#context.setup(config);
+		api.#context.$$internal = {
+			api,
+			addPlugin: api.addPlugin.bind(api)
+		};
+		const timer = api.context.timer("Initialization");
+		for (const plugin of api.context.config.plugins.flat(10) ?? []) await api.addPlugin(plugin);
+		if (api.context.plugins.length === 0) api.context.warn("No Powerlines plugins were specified in the options. Please ensure this is correct, as it is generally not recommended.");
+		else api.context.info(`Loaded ${api.context.plugins.length} ${titleCase(api.context.config.framework)} plugin${api.context.plugins.length > 1 ? "s" : ""}: \n${api.context.plugins.map((plugin, index) => ` ${index + 1}. ${colorText(plugin.name)}`).join("\n")}`);
+		const pluginConfig = await api.callHook("config", {
+			environment: await api.context.getEnvironment(),
+			sequential: true,
+			result: "merge",
+			merge: mergeConfigs
+		});
+		if (pluginConfig) {
+			api.#context.config.pluginConfig = pluginConfig;
+			await api.#context.setup(pluginConfig);
+		}
+		timer();
+		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" }) {
+		this.context.debug(" Aggregating configuration options for the Powerlines project");
+		inlineConfig.command ??= "types";
+		await this.context.setup(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.#types(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.setup(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);
+			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.#types(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" }) {
+		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.");
+			inlineConfig.command ??= "build";
+			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.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.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;
+	}
+	/**
+	* 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(`Successfully initialized the ${chalk.bold.cyanBright(plugin.name)} plugin`);
+				await this.context.addPlugin(plugin);
+			}
+		}
+	}
+};
+
+//#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 {
+	/**
+	* Create a new Powerlines API instance
+	*
+	* @param context - The Powerlines context
+	*/
+	constructor(context) {
+		super(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 fromOptions(options, override) {
+		const api = new PowerlinesAPI(await PowerlinesExecutionContext.fromOptions({
+			cwd: process.cwd(),
+			mode: "production",
+			framework: "powerlines",
+			...options,
+			configIndex: 0
+		}));
+		if (override) await api.context.setup(override);
+		api.context.$$internal = {
+			api,
+			addPlugin: api.addPlugin.bind(api)
+		};
+		const timer = api.context.timer("Initialization");
+		for (const plugin of api.context.config.plugins.flat(10) ?? []) await api.addPlugin(plugin);
+		if (api.context.plugins.length === 0) api.context.warn("No Powerlines plugins were specified in the options. Please ensure this is correct, as it is generally not recommended.");
+		else api.context.info(`Loaded ${api.context.plugins.length} ${titleCase(api.context.config.framework)} plugin${api.context.plugins.length > 1 ? "s" : ""}: \n${api.context.plugins.map((plugin, index) => ` ${index + 1}. ${colorText(plugin.name)}`).join("\n")}`);
+		const pluginConfig = await api.callHook("config", {
+			environment: await api.context.getEnvironment(),
+			sequential: true,
+			result: "merge",
+			merge: mergeConfigs
+		});
+		if (pluginConfig) {
+			api.context.config.pluginConfig = pluginConfig;
+			await api.context.setup(pluginConfig);
+		}
+		timer();
+		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();
+	}
+};
+
+//#endregion
+export { PowerlinesAPI };
+//# sourceMappingURL=api.mjs.map