@powerlines/engine 0.45.3 → 0.46.1

package/dist/_internal/worker.mjs

@@ -24,7 +24,7 @@ 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 { isPromise, 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";
@@ -38,21 +38,21 @@ import { deepClone } from "@stryke/helpers/deep-clone";
 import { joinPaths as joinPaths$1 } from "@stryke/path/join";
 import { uuid } from "@stryke/unique-id/uuid";
 import { getUniqueInputs, isTypeDefinition, resolveInputsSync } from "@powerlines/core/lib/entry";
-import { toBool } from "@stryke/convert/to-bool";
 import { getEnvPaths } from "@stryke/env/get-env-paths";
 import { relativeToWorkspaceRoot } from "@stryke/fs/get-workspace-root";
 import { murmurhash } from "@stryke/hash";
 import { hashDirectory } from "@stryke/hash/node";
 import { fetchRequest } from "@stryke/http/fetch";
 import { isEqual } from "@stryke/path/is-equal";
-import { kebabCase } from "@stryke/string-format/kebab-case";
 import { match, tsconfigPathsToRegExp } from "bundle-require";
 import { resolveCompatibilityDates } from "compatx";
 import { create } from "flat-cache";
 import { parse } from "oxc-parser";
 import { Agent, Response, interceptors, setGlobalDispatcher } from "undici";
 import "@stryke/fs/remove-file";
+import { kebabCase } from "@stryke/string-format/kebab-case";
 import { LogCategories } from "@powerlines/core";
+import { messageParent } from "jest-worker";
 import * as $ from "@stryke/capnp";
 import { readFileBuffer, readFileBufferSync, writeFileBuffer } from "@stryke/fs/buffer";
 import { correctPath, stripStars } from "@stryke/path/correct-path";
@@ -73,8 +73,8 @@ import ts from "typescript";
 import { loadUserConfigFile } from "@powerlines/core/lib/config";
 import { tryGetWorkspaceConfig } from "@storm-software/config-tools/get-config";
 import { isDevelopment, isProduction, isTest } from "@stryke/env/environment-checks";
-import { readJsonFile as readJsonFile$1 } from "@stryke/fs";
-import { joinPaths as joinPaths$2 } from "@stryke/path";
+import { isFile as isFile$1, readJsonFile as readJsonFile$1 } from "@stryke/fs";
+import { findFilePath as findFilePath$1, joinPaths as joinPaths$2, relativePath as relativePath$1 } from "@stryke/path";
 import { formatDistanceToNowStrict } from "date-fns/formatDistanceToNowStrict";
 import { createJiti } from "jiti";
 import { getField } from "@stryke/helpers/get-field";
@@ -84,9 +84,9 @@ import { getObjectDiff } from "@donedeal0/superdiff";
 import { StormJSON } from "@stryke/json/storm-json";
 
 //#region src/_internal/helpers/environment.ts
-function createEnvironment(name, config = {}) {
+function createEnvironment(name, config) {
 	return defu(config.environments?.[name] ?? {}, {
-		environmentId: uuid(),
+		id: uuid(),
 		name,
 		title: config.title ?? titleCase(config.name),
 		ssr: false,
@@ -112,7 +112,7 @@ function createEnvironment(name, config = {}) {
 		} : void 0
 	});
 }
-function createDefaultEnvironment(config = {}) {
+function createDefaultEnvironment(config) {
 	return createEnvironment(DEFAULT_ENVIRONMENT, config);
 }
 
@@ -169,16 +169,16 @@ async function writeMetaFile(context) {
 
 //#endregion
 //#region src/_internal/ipc/send.ts
-function sendWriteLogMessage(context, meta, message) {
+function formatWriteLogMessage(context, meta, message) {
 	const combinedMeta = {
 		...context.logger.options,
 		...isSetObject(meta) ? meta : { type: meta }
 	};
-	process.send?.({
+	return {
 		id: uuid(),
 		type: "write-log",
-		executionId: combinedMeta.executionId || context.config.executionId,
-		executionIndex: combinedMeta.executionIndex ?? context.config.executionIndex,
+		executionId: combinedMeta.executionId || context.options.executionId,
+		executionIndex: combinedMeta.executionIndex ?? context.options.executionIndex,
 		environment: combinedMeta.environment,
 		timestamp: Date.now(),
 		payload: {
@@ -188,8 +188,8 @@ function sendWriteLogMessage(context, meta, message) {
 				logId: combinedMeta.logId || uuid(),
 				timestamp: combinedMeta.timestamp ?? Date.now(),
 				name: combinedMeta.name || context.config.name,
-				executionId: combinedMeta.executionId || context.config.executionId,
-				executionIndex: combinedMeta.executionIndex ?? context.config.executionIndex,
+				executionId: combinedMeta.executionId || context.options.executionId,
+				executionIndex: combinedMeta.executionIndex ?? context.options.executionIndex,
 				command: combinedMeta.command || context.config.command,
 				hook: combinedMeta.hook,
 				environment: combinedMeta.environment,
@@ -198,7 +198,21 @@ function sendWriteLogMessage(context, meta, message) {
 			},
 			message
 		}
-	});
+	};
+}
+function childProcessSend(message) {
+	process.send?.(message);
+}
+function workerThreadSend(message) {
+	messageParent(message);
+}
+function send(message) {
+	if (process.env.POWERLINES_EXECUTION_THREAD_TYPE === "child-process") childProcessSend(message);
+	else if (process.env.POWERLINES_EXECUTION_THREAD_TYPE === "worker-thread") workerThreadSend(message);
+	else console.warn("No IPC mechanism available to send message:", message);
+}
+function sendWriteLogMessage(context, meta, message) {
+	send(formatWriteLogMessage(context, meta, message));
 }
 
 //#endregion
@@ -1996,40 +2010,40 @@ var VirtualFileSystem = class VirtualFileSystem {
 /**
 * Get the path to the tsconfig.json file.
 *
-* @param workspaceRoot - The root directory of the workspace.
-* @param projectRoot - The root directory of the project.
+* @param cwd - The root directory of the workspace.
+* @param root - The root directory of the project.
 * @param tsconfig - The path to the tsconfig.json file.
 * @returns The absolute path to the tsconfig.json file.
 * @throws If the tsconfig.json file does not exist.
 */
-function getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig) {
+function getTsconfigFilePath(cwd, root, tsconfig) {
 	let tsconfigFilePath;
-	if (tsconfig) tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, tsconfig);
+	if (tsconfig) tsconfigFilePath = tryTsconfigFilePath(cwd, root, tsconfig);
 	else {
-		tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, "tsconfig.app.json");
+		tsconfigFilePath = tryTsconfigFilePath(cwd, root, "tsconfig.app.json");
 		if (!tsconfigFilePath) {
-			tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, "tsconfig.lib.json");
-			if (!tsconfigFilePath) tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, "tsconfig.json");
+			tsconfigFilePath = tryTsconfigFilePath(cwd, root, "tsconfig.lib.json");
+			if (!tsconfigFilePath) tsconfigFilePath = tryTsconfigFilePath(cwd, root, "tsconfig.json");
 		}
 	}
-	if (!tsconfigFilePath) throw new Error(`Cannot find the \`tsconfig.json\` configuration file for the project at ${projectRoot}.`);
+	if (!tsconfigFilePath) throw new Error(`Cannot find the \`tsconfig.json\` configuration file for the project at ${root}.`);
 	return tsconfigFilePath;
 }
 /**
 * Get the path to the tsconfig.json file.
 *
-* @param workspaceRoot - The root directory of the workspace.
-* @param projectRoot - The root directory of the project.
+* @param cwd - The root directory of the workspace.
+* @param root - The root directory of the project.
 * @param tsconfig - The path to the tsconfig.json file.
 * @returns The absolute path to the tsconfig.json file.
 * @throws If the tsconfig.json file does not exist.
 */
-function tryTsconfigFilePath(workspaceRoot, projectRoot, tsconfig) {
+function tryTsconfigFilePath(cwd, root, tsconfig) {
 	let tsconfigFilePath = tsconfig;
 	if (!existsSync(tsconfigFilePath)) {
-		tsconfigFilePath = appendPath(tsconfig, projectRoot);
+		tsconfigFilePath = appendPath(tsconfig, root);
 		if (!existsSync(tsconfigFilePath)) {
-			tsconfigFilePath = appendPath(tsconfig, appendPath(projectRoot, workspaceRoot));
+			tsconfigFilePath = appendPath(tsconfig, appendPath(root, cwd));
 			if (!existsSync(tsconfigFilePath)) return;
 		}
 	}
@@ -2156,7 +2170,7 @@ function createResolver(options) {
 
 //#endregion
 //#region src/context/base-context.ts
-var PowerlinesBaseContext = class PowerlinesBaseContext {
+var PowerlinesBaseContext = class {
 	#timestamp = Date.now();
 	/**
 	* The path to the Powerlines package
@@ -2167,17 +2181,17 @@ var PowerlinesBaseContext = class PowerlinesBaseContext {
 	*/
 	resolver;
 	/**
-	* The options provided to the Powerlines process
+	* The options provided to the Powerlines process, resolved with default values and merged with any configuration provided by plugins or other sources. This is typically the final configuration used during the build process, but may also include additional options that are relevant to the context and its interactions with the Powerlines engine.
 	*/
 	options;
 	/**
-	* The input options used to initialize the context, which may be used when cloning the context to ensure the same configuration is applied to the new context
+	* The parsed `package.json` file for the project
 	*/
-	initialOptions = {};
+	packageJson;
 	/**
-	* The initial configuration provided when initializing the context, which may be used during the setup process to ensure that the configuration is properly merged and applied to the context. This is typically the user configuration provided in the Powerlines configuration file, but may also include additional configuration options provided by plugins or other sources.
+	* The parsed `project.json` file for the project
 	*/
-	initialConfig = {};
+	projectJson = void 0;
 	/**
 	* The parsed configuration file for the project
 	*/
@@ -2208,19 +2222,6 @@ var PowerlinesBaseContext = class PowerlinesBaseContext {
 		});
 	}
 	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
-	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
-	*
-	* @returns A promise that resolves to the cloned context.
-	*/
-	async clone() {
-		const clone = new PowerlinesBaseContext();
-		await clone.init(this.options, this.initialConfig);
-		return clone;
-	}
-	/**
 	* A logging function for fatal messages
 	*
 	* @param message - The message to log.
@@ -2300,7 +2301,7 @@ var PowerlinesBaseContext = class PowerlinesBaseContext {
 	* @returns A logger client instance that can be used to generate log messages with consistent formatting and metadata.
 	*/
 	createLogger(options, logFn) {
-		return createLogger$1(this.options.name || this.options.root, {
+		return createLogger$1(this.options.name || this.options.root || "powerlines", {
 			...this.configFile.config,
 			...this.options,
 			...options
@@ -2316,6 +2317,24 @@ var PowerlinesBaseContext = class PowerlinesBaseContext {
 		return extendLogger(this.logger, options);
 	}
 	/**
+	* The input options used to initialize the context, which may be used when cloning the context to ensure the same configuration is applied to the new context
+	*/
+	initialOptions = {};
+	/**
+	* The initial configuration provided when initializing the context, which may be used during the setup process to ensure that the configuration is properly merged and applied to the context. This is typically the user configuration provided in the Powerlines configuration file, but may also include additional configuration options provided by plugins or other sources.
+	*/
+	initialConfig = {};
+	/**
+	* Initialize the context with the provided configuration options and set up the resolver and user configuration file. This method is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup as the original context.
+	*
+	* @param options - The configuration options to initialize the context with, which can include properties such as the project root, mode, log level, and other settings that affect the behavior of the context and its plugins.
+	* @param initialConfig - The initial configuration to initialize the context with, which is typically the user configuration provided in the Powerlines configuration file. This can also include additional configuration options provided by plugins or other sources that should be merged with the user configuration during initialization
+	*/
+	constructor(options, initialConfig = {}) {
+		this.initialOptions = options;
+		this.initialConfig = initialConfig;
+	}
+	/**
 	* Retrieve the workspace configuration for the current project, if it exists. This function will look for a configuration file in the project root and return its contents as a JavaScript object. If no configuration file is found, it will return undefined.
 	*
 	* @returns A promise that resolves to the workspace configuration object, or undefined if no configuration file is found.
@@ -2327,64 +2346,41 @@ var PowerlinesBaseContext = class PowerlinesBaseContext {
 		} : void 0);
 	}
 	/**
-	* Determine the default mode for the current execution based on the environment and workspace configuration. This function will check the `NODE_ENV` environment variable to determine if the current environment is development, production, or test. If `NODE_ENV` is not set, it will look for a `mode` property in the workspace configuration file. If no mode is specified in the workspace configuration, it will default to "production".
-	*
-	* @returns A promise that resolves to the default mode for the current execution, which can be "development", "production", or "test".
-	*/
-	async getDefaultMode() {
-		const workspaceConfig = await this.getWorkspaceConfig();
-		return isProduction ? "production" : isDevelopment ? "development" : isTest ? "test" : workspaceConfig?.mode || "production";
-	}
-	/**
-	* Determine the default log level for the current execution based on the environment and workspace configuration. This function will check the `logLevel` property in the workspace configuration file and resolve it to a `LogLevelResolvedConfig` value. If no log level is specified in the workspace configuration, it will default to "info" for development mode and "warn" for production mode.
-	*
-	* @returns A promise that resolves to the default log level for the current execution, which can be "fatal", "error", "warn", "info", "debug", or "trace".
-	*/
-	async getDefaultLogLevel() {
-		const workspaceConfig = await this.getWorkspaceConfig();
-		return resolveLogLevel(workspaceConfig?.logLevel ? workspaceConfig.logLevel === "success" || workspaceConfig.logLevel === "performance" ? "info" : workspaceConfig.logLevel === "all" ? "debug" : workspaceConfig.logLevel === "fatal" ? "error" : workspaceConfig.logLevel : void 0, this.options?.mode || this.initialOptions?.mode || workspaceConfig?.mode || await this.getDefaultMode());
-	}
-	/**
 	* Initialize the context with the provided configuration options
 	*
 	* @remarks
 	* This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
-	*
-	* @param options - The configuration options to initialize the context with
-	* @param initialConfig - The initial configuration to initialize the context with
 	*/
-	async init(options, initialConfig) {
-		this.initialOptions = { ...options };
-		this.initialConfig = { ...initialConfig };
+	async init() {
 		if (!this.powerlinesPath) {
 			const powerlinesPath = await resolvePackage("powerlines");
 			if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
 			this.powerlinesPath = powerlinesPath;
 		}
-		const cwd = options.cwd || this.options?.cwd || process.cwd();
-		const root = replacePath((options.root || this.options?.root) && (options.root || this.options.root).replace(/^\.\/?/, "") && !isEqual(options.root || this.options.root, cwd) ? options.root || this.options.root : ".", cwd);
-		this.options = defu({
-			name: options.name || this.initialConfig.name,
-			root,
-			cwd,
-			mode: options.mode || this.initialConfig.mode,
-			logLevel: options.logLevel || this.initialConfig.logLevel,
-			framework: options.framework || this.initialConfig.framework,
-			organization: options.organization || this.initialConfig.organization,
-			configFile: options.configFile || this.initialConfig.configFile
-		}, this.options ?? {}, {
+		this.options = defu(this.initialOptions, this.initialConfig, {
+			cwd: process.cwd(),
 			mode: await this.getDefaultMode(),
-			logLevel: await this.getDefaultLogLevel()
+			logLevel: await this.getDefaultLogLevel(),
+			framework: "powerlines"
 		});
+		if (!this.options.root) if (this.options.configFile) {
+			const configFile = appendPath(this.options.configFile, this.options.cwd);
+			if (!existsSync$1(configFile)) throw new Error(`The user-provided configuration file at "${this.options.configFile}" does not exist. Please ensure this path is correct and try again.`);
+			if (!isFile$1(configFile)) throw new Error(`The user-provided configuration file at "${this.options.configFile}" is not a file. Please ensure this path is correct and try again.`);
+			this.options.root = relativePath$1(this.options.cwd, findFilePath$1(configFile));
+		} else this.options.root = ".";
+		else this.options.root = replacePath(this.options.root, this.options.cwd);
 		this.resolver = createResolver({
-			workspaceRoot: cwd,
-			root,
+			workspaceRoot: this.options.cwd,
+			root: this.options.root,
 			cacheDir: this.envPaths.cache,
 			mode: this.options.mode
 		});
+		await this.resolvePackageConfigs();
 		this.configFile = await loadUserConfigFile(this.options, this.resolver);
-		if (!this.options.name) {
-			if (this.configFile.config) {
+		if (this.configFile.config) {
+			if (isSetString(this.configFile.configFile)) this.options.configFile ??= replacePath(this.configFile.configFile, this.options.cwd);
+			if (!this.options.name) {
 				if (isSetObject(this.configFile.config) && isSetString(this.configFile.config.name)) this.options.name = this.configFile.config.name;
 				else if (Array.isArray(this.configFile.config)) {
 					for (const config of this.configFile.config) if (isSetObject(config) && isSetString(config.name)) {
@@ -2393,22 +2389,46 @@ var PowerlinesBaseContext = class PowerlinesBaseContext {
 					}
 				}
 			}
-			if (!this.options.name) {
-				const packageJsonPath = joinPaths$2(appendPath(this.options.root, this.options.cwd), "package.json");
-				if (existsSync$1(packageJsonPath)) {
-					const packageJson = await readJsonFile$1(packageJsonPath);
-					this.options.name = packageJson.name;
-				}
-				if (!this.options.name) {
-					const projectJsonPath = joinPaths$2(appendPath(this.options.root, this.options.cwd), "project.json");
-					if (existsSync$1(projectJsonPath)) {
-						const projectJson = await readJsonFile$1(projectJsonPath);
-						this.options.name = projectJson.name;
-					}
-				}
-			}
+			if (!this.options.name) this.options.name = this.projectJson?.name || this.packageJson?.name;
+		}
+	}
+	/**
+	* Resolve the package configurations for the project by loading the `package.json` and `project.json` files, if they exist. This function will look for these files in the project root and parse their contents as JavaScript objects. The parsed contents will be stored in the context for later use by plugins and other parts of the build process.
+	*
+	* @remarks
+	* The `package.json` file is typically used to store metadata about the project, such as its name, version, dependencies, and other information. The `project.json` file is an optional file that can be used to store additional configuration or metadata specific to the project, and is not required for all projects.
+	*
+	* @param cwd - The current working directory to look for the package configurations. Defaults to the `cwd` specified in the context configuration.
+	* @param root - The root directory of the project to look for the package configurations. Defaults to the `root` specified in the context configuration.
+	* @returns A promise that resolves when the package configurations have been loaded and stored in the context.
+	*/
+	async resolvePackageConfigs(cwd = this.options.cwd, root = this.options.root) {
+		const projectJsonPath = joinPaths$2(appendPath(root, cwd), "project.json");
+		if (existsSync$1(projectJsonPath)) this.projectJson = await readJsonFile$1(projectJsonPath);
+		const packageJsonPath = joinPaths$2(appendPath(root, cwd), "package.json");
+		if (existsSync$1(packageJsonPath)) {
+			this.packageJson = await readJsonFile$1(packageJsonPath);
+			this.options.organization ??= isSetObject(this.packageJson?.author) ? kebabCase(this.packageJson?.author?.name) : kebabCase(this.packageJson?.author);
 		}
 	}
+	/**
+	* Determine the default mode for the current execution based on the environment and workspace configuration. This function will check the `NODE_ENV` environment variable to determine if the current environment is development, production, or test. If `NODE_ENV` is not set, it will look for a `mode` property in the workspace configuration file. If no mode is specified in the workspace configuration, it will default to "production".
+	*
+	* @returns A promise that resolves to the default mode for the current execution, which can be "development", "production", or "test".
+	*/
+	async getDefaultMode() {
+		const workspaceConfig = await this.getWorkspaceConfig();
+		return isProduction ? "production" : isDevelopment ? "development" : isTest ? "test" : workspaceConfig?.mode || "production";
+	}
+	/**
+	* Determine the default log level for the current execution based on the environment and workspace configuration. This function will check the `logLevel` property in the workspace configuration file and resolve it to a `LogLevelResolvedConfig` value. If no log level is specified in the workspace configuration, it will default to "info" for development mode and "warn" for production mode.
+	*
+	* @returns A promise that resolves to the default log level for the current execution, which can be "fatal", "error", "warn", "info", "debug", or "trace".
+	*/
+	async getDefaultLogLevel() {
+		const workspaceConfig = await this.getWorkspaceConfig();
+		return resolveLogLevel(workspaceConfig?.logLevel ? workspaceConfig.logLevel === "success" || workspaceConfig.logLevel === "performance" ? "info" : workspaceConfig.logLevel === "all" ? "debug" : workspaceConfig.logLevel === "fatal" ? "error" : workspaceConfig.logLevel : void 0, this.options?.mode || this.initialOptions?.mode || workspaceConfig?.mode || await this.getDefaultMode());
+	}
 };
 
 //#endregion
@@ -2420,27 +2440,13 @@ setGlobalDispatcher(new Agent({ keepAliveTimeout: 1e4 }).compose(interceptors.re
 	timeoutFactor: 2,
 	retryAfter: true
 })));
-const SKIP_CLONING_PROPS = [
-	"dependencies",
-	"devDependencies",
-	"persistedMeta",
-	"packageJson",
-	"projectJson",
-	"tsconfig",
-	"resolver",
-	"fs",
-	"$$internal"
+const UNRESOLVED_CONFIG_NAMES = [
+	"initialConfig",
+	"userConfig",
+	"inlineConfig",
+	"pluginConfig"
 ];
 var PowerlinesContext = class PowerlinesContext extends PowerlinesBaseContext {
-	/**
-	* Internal references storage
-	*
-	* @danger
-	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-	*
-	* @internal
-	*/
-	#internal = {};
 	#checksum = null;
 	#buildId = uuid();
 	#releaseId = uuid();
@@ -2448,24 +2454,22 @@ var PowerlinesContext = class PowerlinesContext extends PowerlinesBaseContext {
 	#tsconfig;
 	#parserCache;
 	#requestCache;
+	#configProxy;
 	/**
-	* Create a new Storm context from the workspace root and user config.
+	* Create a new context from the workspace root and user config.
 	*
 	* @param options - The options for resolving the context.
 	* @returns A promise that resolves to the new context.
 	*/
-	static async init(options, initialConfig) {
-		const context = new PowerlinesContext(options);
-		await context.init(options, initialConfig);
-		const powerlinesPath = await resolvePackage("powerlines");
-		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
-		context.powerlinesPath = powerlinesPath;
+	static async fromInitialConfig(options, initialConfig) {
+		const context = new PowerlinesContext(options, initialConfig);
+		await context.init();
 		return context;
 	}
 	/**
-	* The options provided to the Powerlines process
+	* The options provided to the Powerlines process, resolved with default values and merged with any configuration provided by plugins or other sources. This is typically the final configuration used during the build process, but may also include additional options that are relevant to the context and its interactions with the Powerlines engine.
 	*/
-	options;
+	options = {};
 	/**
 	* An object containing the dependencies that should be installed for the project
 	*/
@@ -2479,39 +2483,33 @@ var PowerlinesContext = class PowerlinesContext extends PowerlinesBaseContext {
 	*/
 	persistedMeta = void 0;
 	/**
-	* The parsed `package.json` file for the project
+	* The resolved tsconfig file paths for the project
 	*/
-	packageJson;
+	resolvePatterns = [];
 	/**
-	* The parsed `project.json` file for the project
+	* The input options used to initialize the context, which may be used when cloning the context to ensure the same configuration is applied to the new context
 	*/
-	projectJson = void 0;
+	initialOptions = {};
 	/**
-	* The resolved tsconfig file paths for the project
+	* The resolved configuration for this context
 	*/
-	resolvePatterns = [];
+	resolvedConfig = {};
 	/**
-	* Internal context fields and methods
-	*
-	* @danger
-	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-	*
-	* @internal
+	* The configuration options that were overridden by plugins during the build process, which may include additional properties or modifications made during the configuration loading process.
 	*/
-	get $$internal() {
-		return this.#internal;
-	}
+	overriddenConfig = {};
 	/**
-	* Internal context fields and methods
-	*
-	* @danger
-	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-	*
-	* @internal
+	* The configuration options provided inline during execution, such as CLI flags or other parameters that may be relevant to the command being executed. These options can be used to override or supplement the configuration options defined in a configuration file on disk, and are typically provided as part of the execution context when running a Powerlines command.
 	*/
-	set $$internal(value) {
-		this.#internal = value;
-	}
+	inlineConfig = {};
+	/**
+	* The configuration options read from a configuration file on disk, which may be used to resolve the final configuration for the context. This typically includes the user configuration options defined in the `powerlines.config.ts` file, as well as any inline configuration options provided during execution.
+	*/
+	userConfig = {};
+	/**
+	* The configuration options provided by plugins added by the user (and other plugins)
+	*/
+	pluginConfig = {};
 	/**
 	* The resolved entry type definitions for the project
 	*/
@@ -2566,13 +2564,14 @@ var PowerlinesContext = class PowerlinesContext extends PowerlinesBaseContext {
 	* The resolved configuration options
 	*/
 	get config() {
-		return this.resolvedConfig;
+		if (!this.#configProxy) this.#configProxy = this.createConfigProxy();
+		return this.#configProxy;
 	}
 	/**
 	* Get the path to the artifacts directory for the project
 	*/
 	get artifactsPath() {
-		return joinPaths$1(this.config.cwd, this.config.root, this.config.output.artifactsPath);
+		return joinPaths$1(this.config.cwd, this.config.root, this.config.output?.artifactsPath || `.${this.config.framework || "powerlines"}`);
 	}
 	/**
 	* Get the path to the builtin modules used by the project
@@ -2629,7 +2628,7 @@ var PowerlinesContext = class PowerlinesContext extends PowerlinesBaseContext {
 	* Additional arguments provided during execution of the command, such as CLI flags or other parameters that may be relevant to the command being executed.
 	*/
 	get additionalArgs() {
-		return Object.entries(this.config.inlineConfig?.additionalArgs ?? {}).reduce((ret, [key, value]) => {
+		return Object.entries(this.config.inlineConfig.additionalArgs ?? {}).reduce((ret, [key, value]) => {
 			const formattedKey = key.replace(/^--?/, "");
 			if (ret[formattedKey]) if (Array.isArray(ret[formattedKey])) if (Array.isArray(value)) ret[formattedKey] = [...toArray(ret[formattedKey]), ...value];
 			else ret[formattedKey] = [...toArray(ret[formattedKey]), value];
@@ -2658,29 +2657,6 @@ var PowerlinesContext = class PowerlinesContext extends PowerlinesBaseContext {
 		}, {}) : this.config.resolve.alias : {});
 	}
 	/**
-	* Create a new logger instance
-	*
-	* @param options - The configuration options to use for the logger instance, which can be used to customize the appearance and behavior of the log messages generated by the logger. This is typically the name of the plugin or module that is creating the logger instance.
-	* @param logFn - The custom logging function to use for logging messages, which can be used to override the default logging behavior of the original logger.
-	* @returns A logger client instance that can be used to generate log messages with consistent formatting and metadata.
-	*/
-	createLogger(options, logFn) {
-		let logger;
-		if (toBool(process.env.POWERLINES_WORKER_THREAD_EXECUTION)) logger = createLogger(this.config.name, {
-			...this.options,
-			...this.config,
-			...options
-		}, (meta, message) => sendWriteLogMessage(this, meta, message));
-		else logger = createLogger(this.config.name, {
-			...this.options,
-			...this.config,
-			...options
-		});
-		if (this.config.customLogger) logger = withCustomLogger(logger, this.config.customLogger);
-		if (logFn) logger = withLogFn(logger, logFn);
-		return logger;
-	}
-	/**
 	* The log level for the context, which determines the minimum level of log messages that will be emitted by the logger. This is resolved based on the configuration options provided by the user, and can be set to different levels for development, production, and test environments. The log level can also be overridden by plugins or other parts of the build process to provide more granular control over logging output.
 	*/
 	get logLevel() {
@@ -2742,25 +2718,38 @@ var PowerlinesContext = class PowerlinesContext extends PowerlinesBaseContext {
 		}).filter(Boolean);
 	}
 	/**
-	* Creates a new StormContext instance.
+	* Creates a new Context instance.
 	*
 	* @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
+	* @param initialConfig - The initial configuration provided by the user, which can be used to resolve the final configuration for the context. This typically includes the user configuration options defined in the `powerlines.config.ts` file, as well as any inline configuration options provided during execution.
 	*/
-	constructor(options) {
-		super();
-		this.options = options;
+	constructor(options, initialConfig) {
+		super(options, initialConfig);
+		this.initialOptions = options;
+		this.initialConfig = initialConfig;
 	}
 	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
-	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
+	* Create a new logger instance
 	*
-	* @returns A promise that resolves to the cloned context.
+	* @param options - The configuration options to use for the logger instance, which can be used to customize the appearance and behavior of the log messages generated by the logger. This is typically the name of the plugin or module that is creating the logger instance.
+	* @param logFn - The custom logging function to use for logging messages, which can be used to override the default logging behavior of the original logger.
+	* @returns A logger client instance that can be used to generate log messages with consistent formatting and metadata.
 	*/
-	async clone() {
-		const clone = await PowerlinesContext.init(this.options, this.initialConfig);
-		return this.copyTo(clone);
+	createLogger(options, logFn) {
+		let logger;
+		if (isSetString(process.env.POWERLINES_EXECUTION_THREAD_TYPE)) logger = createLogger(this.config.name, {
+			...this.options,
+			...this.config,
+			...options
+		}, (meta, message) => sendWriteLogMessage(this, meta, message));
+		else logger = createLogger(this.config.name, {
+			...this.options,
+			...this.config,
+			...options
+		});
+		if (this.config.customLogger) logger = withCustomLogger(logger, this.config.customLogger);
+		if (logFn) logger = withLogFn(logger, logFn);
+		return logger;
 	}
 	/**
 	* A function to perform HTTP fetch requests
@@ -3090,206 +3079,247 @@ var PowerlinesContext = class PowerlinesContext extends PowerlinesBaseContext {
 	/**
 	* Generates a checksum representing the current context state
 	*
-	* @param root - The root directory of the project to generate the checksum for
+	* @param path - The root directory of the project to generate the checksum for
 	* @returns A promise that resolves to a string representing the checksum
 	*/
-	async generateChecksum(root = this.config.root) {
-		this.#checksum = await hashDirectory(root, { ignore: [
-			"node_modules",
-			".git",
-			".nx",
-			".cache",
-			"tmp",
-			"dist"
-		] });
-		return this.#checksum;
+	async generateChecksum(path) {
+		return hashDirectory(path || appendPath(this.options.root, this.options.cwd));
 	}
 	/**
-	* Initialize the context with the provided configuration options
+	* A setter function to populate the inline config values provided during execution of the command, such as CLI flags or other parameters that may be relevant to the command being executed. This function can be used to update the context with the inline configuration values, which may be used during the configuration resolution process to ensure that the final configuration reflects both the user configuration and any inline configuration provided during execution.
+	*
+	* @param config - The inline configuration values to set.
+	* @returns A promise that resolves when the inline configuration values have been set.
 	*/
-	async setup() {
-		this.resolvedConfig = mergeConfig({
-			root: this.options.root,
-			cwd: this.options.cwd,
-			inlineConfig: this.config.inlineConfig ?? {},
-			userConfig: this.config.userConfig ?? {},
-			initialConfig: this.config.initialConfig ?? {},
-			pluginConfig: this.config.pluginConfig ?? {}
-		}, getConfigProps(this.config.inlineConfig), getConfigProps(this.config.userConfig), getConfigProps(this.config.initialConfig), getConfigProps(this.config.pluginConfig), this.options, {
-			name: this.projectJson?.name || this.packageJson?.name,
+	async setInlineConfig(config) {
+		this.logger.debug({
+			meta: { category: "config" },
+			message: `Updating inline configuration object: \n${this.logConfig(config)}`
+		});
+		this.inlineConfig = config;
+		await this.resolveConfig();
+	}
+	/**
+	* A setter function to populate the plugin config values provided during execution of the command, such as CLI flags or other parameters that may be relevant to the command being executed. This function can be used to update the context with the plugin configuration values, which may be used during the configuration resolution process to ensure that the final configuration reflects both the user configuration and any plugin configuration provided during execution.
+	*
+	* @param config - The plugin configuration values to set.
+	* @returns A promise that resolves when the plugin configuration values have been set.
+	*/
+	async setPluginConfig(config) {
+		this.logger.debug({
+			meta: { category: "config" },
+			message: `Updating plugin configuration object: \n${this.logConfig(config)}`
+		});
+		this.pluginConfig = config;
+		await this.resolveConfig();
+	}
+	/**
+	* A function to merge the various configuration objects (initial, user, inline, and plugin) into a single resolved configuration object that can be used throughout the Powerlines process. This function takes into account the different sources of configuration and their respective priorities, ensuring that the final configuration reflects the intended settings for the project. The merged configuration is then returned as a new object that can be accessed through the `config` property of the context.
+	*
+	* @returns The merged configuration object that combines the initial, user, inline, and plugin configurations.
+	*/
+	mergeConfig() {
+		return mergeConfig({
+			mode: this.initialOptions.mode,
+			framework: this.initialOptions.framework,
+			initialOptions: this.initialOptions,
+			options: this.options,
+			inlineConfig: this.inlineConfig,
+			userConfig: this.userConfig,
+			initialConfig: this.initialConfig,
+			pluginConfig: this.pluginConfig
+		}, getConfigProps(this.overriddenConfig), omit(this.options, ["mode", "framework"]), getConfigProps(this.inlineConfig), getConfigProps(this.userConfig), getConfigProps(this.initialConfig), getConfigProps(this.pluginConfig), {
 			version: this.packageJson?.version,
 			description: this.packageJson?.description
 		}, {
 			environments: {},
 			resolve: {}
 		});
-		await this.innerSetup();
 	}
 	/**
-	* The resolved configuration for this context
-	*/
-	resolvedConfig = {};
-	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
-	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
+	* A setter function to populate the user config values provided during execution of the command, such as CLI flags or other parameters that may be relevant to the command being executed. This function can be used to update the context with the user configuration values, which may be used during the configuration resolution process to ensure that the final configuration reflects both the user configuration and any inline configuration provided during execution.
 	*
-	* @returns The cloned context.
+	* @param config - The user configuration values to set.
+	* @returns A promise that resolves when the user configuration values have been set.
 	*/
-	copyTo(context) {
-		for (const [key, value] of Object.entries(this)) if (!SKIP_CLONING_PROPS.includes(key)) if (isObject(value) || Array.isArray(value)) context[key] = deepClone(value);
-		else context[key] = value;
-		context.initialConfig = deepClone(this.initialConfig);
-		context.initialOptions = deepClone(this.initialOptions);
-		context.options = deepClone(this.options);
-		context.dependencies = deepClone(this.dependencies);
-		context.devDependencies = deepClone(this.devDependencies);
-		context.persistedMeta = this.persistedMeta ? deepClone(this.persistedMeta) : void 0;
-		context.packageJson = deepClone(this.packageJson);
-		context.projectJson = this.projectJson ? deepClone(this.projectJson) : void 0;
-		context.tsconfig ??= deepClone(this.tsconfig);
-		context.resolver ??= this.resolver;
-		context.fs ??= this.#fs;
-		context.$$internal = this.$$internal;
-		return context;
+	async setUserConfig(config) {
+		this.logger.debug({
+			meta: { category: "config" },
+			message: `Updating user configuration object: \n${this.logConfig(config)}`
+		});
+		this.userConfig = config;
+		await this.resolveConfig();
 	}
 	/**
 	* Initialize the context with the provided configuration options
+	*/
+	async init() {
+		await super.init();
+		this.options.executionId = this.initialOptions.executionId || uuid();
+		this.options.executionIndex = this.initialOptions.executionIndex ?? 0;
+		this.#checksum = await this.generateChecksum();
+		const result = this.configFile.config && toArray(this.configFile.config).length > this.options.executionIndex ? toArray(this.configFile.config)[this.options.executionIndex] : this.configFile.config;
+		if (!result) this.logger.warn(`No configuration found in ${this.options.configFile} for execution index ${this.options.executionIndex}.`);
+		else await this.setUserConfig(isFunction(result) ? await Promise.resolve(result(this.options)) : result);
+	}
+	/**
+	* Resolve the package configurations for the project by loading the `package.json` and `project.json` files, if they exist. This function will look for these files in the project root and parse their contents as JavaScript objects. The parsed contents will be stored in the context for later use by plugins and other parts of the build process.
 	*
-	*   @remarks
-	* This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
+	* @remarks
+	* The `package.json` file is typically used to store metadata about the project, such as its name, version, dependencies, and other information. The `project.json` file is an optional file that can be used to store additional configuration or metadata specific to the project, and is not required for all projects.
 	*
-	* @param options - The configuration options to initialize the context with
-	*/
-	async init(options, initialConfig) {
-		await super.init(options, initialConfig ?? {});
-		this.options.executionId = options.executionId ?? this.options.executionId;
-		this.options.executionIndex = options.executionIndex ?? this.options.executionIndex ?? 0;
-		const projectJsonPath = joinPaths$1(this.options.cwd, this.options.root, "project.json");
-		if (existsSync(projectJsonPath)) this.projectJson = await readJsonFile(projectJsonPath);
-		const packageJsonPath = joinPaths$1(this.options.cwd, this.options.root, "package.json");
-		if (existsSync(packageJsonPath)) {
-			this.packageJson = await readJsonFile(packageJsonPath);
-			this.options.organization ??= isSetObject(this.packageJson?.author) ? kebabCase(this.packageJson?.author?.name) : kebabCase(this.packageJson?.author);
-		}
-		this.#checksum = await this.generateChecksum(joinPaths$1(this.options.cwd, this.options.root));
-		const userConfig = this.configFile.config ? Array.isArray(this.configFile.config) && this.configFile.config.length > this.options.executionIndex ? this.configFile.config[this.options.executionIndex] : this.configFile.config : {};
-		this.resolvedConfig = {
-			cwd: this.options.cwd,
-			root: this.options.root,
-			...this.initialOptions,
-			...initialConfig,
-			...userConfig,
-			inlineConfig: {},
-			pluginConfig: {},
-			initialConfig,
-			userConfig
-		};
+	* @param cwd - The current working directory to look for the package configurations. Defaults to the `cwd` specified in the context configuration.
+	* @param root - The root directory of the project to look for the package configurations. Defaults to the `root` specified in the context configuration.
+	* @returns A promise that resolves when the package configurations have been loaded and stored in the context.
+	*/
+	async resolvePackageConfigs(cwd = this.config.cwd, root = this.config.root) {
+		return super.resolvePackageConfigs(cwd, root);
 	}
 	/**
 	* Initialize the context with the provided configuration options
 	*/
-	async innerSetup() {
-		const logger = this.extendLogger({ category: "config" });
-		this.config.plugins = (this.config.initialConfig.plugins ?? []).concat(this.config.userConfig.plugins ?? [], this.config.inlineConfig.plugins ?? []);
-		this.config.output = defu(this.config.output ?? {}, {
+	async resolveConfig() {
+		const mergedConfig = this.mergeConfig();
+		this.logger.trace({
+			meta: { category: "config" },
+			message: `Pre-setup Powerlines configuration object: \n --- Pre-Resolved Config --- \n${this.logConfig(mergedConfig)} \n --- Initial Config --- \n${this.logConfig(this.initialConfig)} \n --- User Config --- \n${this.logConfig(this.userConfig)} \n --- Inline Config --- \n${this.logConfig(this.inlineConfig)} \n --- Plugin Config --- \n${this.logConfig(this.pluginConfig)}`
+		});
+		mergedConfig.output = defu(mergedConfig.output ?? {}, {
 			copy: { assets: [
 				{ glob: "LICENSE" },
 				{
-					input: this.config.root,
+					input: mergedConfig.root,
 					glob: "*.md"
 				},
 				{
-					input: this.config.root,
+					input: mergedConfig.root,
 					glob: "package.json"
 				}
 			] },
 			dts: true
 		});
-		logger.trace(`Pre-setup Powerlines configuration object: \n${formatLogMessage({
-			...omit(this.config, [
-				"inlineConfig",
-				"userConfig",
-				"initialConfig",
-				"pluginConfig",
-				"plugins"
-			]),
-			inlineConfig: isSetObject(this.config.inlineConfig) ? omit(this.config.inlineConfig, ["plugins"]) : void 0,
-			userConfig: isSetObject(this.config.userConfig) ? omit(this.config.userConfig, ["plugins"]) : void 0,
-			initialConfig: isSetObject(this.config.initialConfig) ? omit(this.config.initialConfig, ["plugins"]) : void 0,
-			pluginConfig: isSetObject(this.config.pluginConfig) ? omit(this.config.pluginConfig, ["plugins"]) : void 0
-		})}`);
-		if (!this.initialOptions.mode && !this.config.userConfig?.mode && !this.config.inlineConfig?.mode && !this.config.initialConfig?.mode && !this.config.pluginConfig?.mode) {
-			this.options.mode = "production";
-			this.config.mode = "production";
-		}
-		if (!this.initialOptions.framework && !this.config.userConfig?.framework && !this.config.inlineConfig?.framework && !this.config.initialConfig?.framework && !this.config.pluginConfig?.framework) {
-			this.options.framework = "powerlines";
-			this.config.framework = "powerlines";
-		}
-		if (!this.config.userConfig?.projectType && !this.config.inlineConfig?.projectType && !this.config.initialConfig?.projectType && !this.config.pluginConfig?.projectType) this.config.projectType = "application";
-		if (!this.config.userConfig?.platform && !this.config.inlineConfig?.platform && !this.config.initialConfig?.platform && !this.config.pluginConfig?.platform) this.config.platform = "neutral";
-		this.config.compatibilityDate = resolveCompatibilityDates(this.config.inlineConfig.compatibilityDate ?? this.config.userConfig.compatibilityDate ?? this.config.initialConfig.compatibilityDate ?? this.config.pluginConfig.compatibilityDate, "latest");
-		this.config.input = getUniqueInputs(this.config.input);
-		if (this.config.name?.startsWith("@") && this.config.name.split("/").filter(Boolean).length > 1) this.config.name = this.config.name.split("/").filter(Boolean)[1];
-		this.config.title ??= titleCase(this.config.name);
-		if (this.config.resolve.external) this.config.resolve.external = getUnique(this.config.resolve.external);
-		if (this.config.resolve.noExternal) this.config.resolve.noExternal = getUnique(this.config.resolve.noExternal);
-		this.config.plugins = (this.config.plugins ?? []).flatMap((plugin) => toArray(plugin)).filter(Boolean).reduce((ret, plugin) => {
+		if (!mergedConfig.mode) mergedConfig.mode = "production";
+		if (!mergedConfig.framework) mergedConfig.framework = "powerlines";
+		if (!mergedConfig.projectType) mergedConfig.projectType = "application";
+		if (!mergedConfig.platform) mergedConfig.platform = "neutral";
+		mergedConfig.compatibilityDate = resolveCompatibilityDates(mergedConfig.compatibilityDate, "latest");
+		this.resolvedConfig = mergedConfig;
+		this.#configProxy = this.createConfigProxy();
+		if (!this.packageJson) await this.resolvePackageConfigs();
+		mergedConfig.input = getUniqueInputs(mergedConfig.input);
+		if (mergedConfig.name?.startsWith("@") && mergedConfig.name.split("/").filter(Boolean).length > 1) mergedConfig.name = mergedConfig.name.split("/").filter(Boolean)[1];
+		mergedConfig.title ??= titleCase(mergedConfig.name);
+		if (mergedConfig.resolve.external) mergedConfig.resolve.external = getUnique(mergedConfig.resolve.external);
+		if (mergedConfig.resolve.noExternal) mergedConfig.resolve.noExternal = getUnique(mergedConfig.resolve.noExternal);
+		mergedConfig.plugins = (mergedConfig.plugins ?? []).flatMap((plugin) => toArray(plugin)).filter(Boolean).reduce((ret, plugin) => {
 			if (isPlugin(plugin) && isDuplicate(plugin, ret.filter((p) => isPlugin(p)))) return ret;
 			ret.push(plugin);
 			return ret;
 		}, []);
-		if (!this.config.userConfig?.logLevel && !this.config.initialConfig?.logLevel && !this.config.pluginConfig?.logLevel && !this.config.inlineConfig?.logLevel) if (this.config.mode === "development") this.config.logLevel = DEFAULT_DEVELOPMENT_LOG_LEVEL;
-		else if (this.config.mode === "test") this.config.logLevel = DEFAULT_TEST_LOG_LEVEL;
-		else this.config.logLevel = DEFAULT_PRODUCTION_LOG_LEVEL;
-		if (!this.config.userConfig?.tsconfig && !this.config.initialConfig?.tsconfig && !this.config.pluginConfig?.tsconfig && !this.config.inlineConfig?.tsconfig) this.config.tsconfig = getTsconfigFilePath(this.config.cwd, this.config.root);
-		else if (this.config.tsconfig) this.config.tsconfig = replacePath(replacePathTokens(this, this.config.tsconfig), this.config.cwd);
-		this.config.output.format = getUnique(toArray(this.config.output?.format ?? (this.config.projectType === "library" ? ["cjs", "esm"] : ["esm"])));
-		if (this.config.output.path) this.config.output.path = appendPath(replacePathTokens(this, this.config.output.path), this.config.cwd);
-		else this.config.output.path = appendPath(joinPaths$1(this.config.root, "dist"), this.config.cwd);
-		if (this.config.output.copy !== false) {
-			this.config.output.copy ??= {};
-			if (!this.config.root.replace(/^\.\/?/, "")) this.config.output.copy.path = this.config.output.copy.path ? appendPath(replacePathTokens(this, this.config.output.copy.path), this.config.cwd) : this.config.output.path;
-			else this.config.output.copy.path = appendPath(replacePathTokens(this, this.config.output.copy.path || joinPaths$1("dist", this.config.root)), this.config.cwd);
-		}
-		if (this.config.output.types !== false) this.config.output.types = appendPath(replacePathTokens(this, this.config.userConfig?.output?.types || this.config.inlineConfig?.output?.types || this.config.initialConfig?.output?.types || this.config.pluginConfig?.output?.types || joinPaths$1(this.config.root, `${this.config.framework ?? "powerlines"}.d.ts`)), this.config.cwd);
-		if (this.config.output.copy && this.config.output.copy.path && this.config.output.copy.assets && Array.isArray(this.config.output.copy.assets)) this.config.output.copy.assets = getUniqueBy(this.config.output.copy.assets.map((asset) => {
+		if (!mergedConfig.logLevel) if (mergedConfig.mode === "development") mergedConfig.logLevel = DEFAULT_DEVELOPMENT_LOG_LEVEL;
+		else if (mergedConfig.mode === "test") mergedConfig.logLevel = DEFAULT_TEST_LOG_LEVEL;
+		else mergedConfig.logLevel = DEFAULT_PRODUCTION_LOG_LEVEL;
+		if (mergedConfig.tsconfig) mergedConfig.tsconfig = replacePath(replacePathTokens(this, mergedConfig.tsconfig), mergedConfig.cwd);
+		else mergedConfig.tsconfig = getTsconfigFilePath(mergedConfig.cwd, mergedConfig.root);
+		mergedConfig.output.format = getUnique(toArray(mergedConfig.output?.format ?? (mergedConfig.projectType === "library" ? ["cjs", "esm"] : ["esm"])));
+		if (mergedConfig.output.path) mergedConfig.output.path = appendPath(replacePathTokens(this, mergedConfig.output.path), mergedConfig.cwd);
+		else mergedConfig.output.path = appendPath(joinPaths$1(mergedConfig.root, "dist"), mergedConfig.cwd);
+		mergedConfig.output.copy ??= {};
+		if (mergedConfig.output.copy !== false) if (!mergedConfig.root.replace(/^\.\/?/, "")) mergedConfig.output.copy.path = mergedConfig.output.copy.path ? appendPath(replacePathTokens(this, mergedConfig.output.copy.path), mergedConfig.cwd) : mergedConfig.output.path;
+		else mergedConfig.output.copy.path = appendPath(replacePathTokens(this, mergedConfig.output.copy.path || joinPaths$1("dist", mergedConfig.root)), mergedConfig.cwd);
+		if (mergedConfig.output.types !== false) mergedConfig.output.types = appendPath(replacePathTokens(this, mergedConfig.output.types || joinPaths$1(mergedConfig.root, `${mergedConfig.framework ?? "powerlines"}.d.ts`)), mergedConfig.cwd);
+		if (mergedConfig.output.copy && mergedConfig.output.copy.path && mergedConfig.output.copy.assets && Array.isArray(mergedConfig.output.copy.assets)) mergedConfig.output.copy.assets = getUniqueBy(mergedConfig.output.copy.assets.map((asset) => {
 			return {
 				glob: isSetObject(asset) ? asset.glob : asset,
-				input: isString(asset) || !asset.input || asset.input === "." || asset.input === "/" || asset.input === "./" ? this.options.cwd : isParentPath(asset.input, this.config.cwd) || isEqual(asset.input, this.config.cwd) ? asset.input : appendPath(asset.input, this.config.cwd),
-				output: isSetObject(asset) && asset.output ? isParentPath(asset.output, this.config.cwd) ? asset.output : appendPath(joinPaths$1(this.config.output.copy.path, replacePath(replacePath(asset.output, replacePath(this.config.output.copy.path, this.config.cwd)), this.config.output.copy.path)), this.config.cwd) : appendPath(this.config.output.copy.path, this.config.cwd),
+				input: isString(asset) || !asset.input || asset.input === "." || asset.input === "/" || asset.input === "./" ? mergedConfig.cwd : isParentPath(asset.input, mergedConfig.cwd) || isEqual(asset.input, mergedConfig.cwd) ? asset.input : appendPath(asset.input, mergedConfig.cwd),
+				output: isSetObject(asset) && asset.output ? isParentPath(asset.output, mergedConfig.cwd) ? asset.output : appendPath(joinPaths$1(mergedConfig.output.copy.path, replacePath(replacePath(asset.output, replacePath(mergedConfig.output.copy.path, mergedConfig.cwd)), mergedConfig.output.copy.path)), mergedConfig.cwd) : appendPath(mergedConfig.output.copy.path, mergedConfig.cwd),
 				ignore: isSetObject(asset) && asset.ignore ? toArray(asset.ignore) : void 0
 			};
 		}), (a) => `${a.input}-${a.glob}-${a.output}`);
-		if (!this.config.userConfig?.output?.sourceMap && !this.config.initialConfig?.output?.sourceMap && !this.config.inlineConfig?.output?.sourceMap && !this.config.pluginConfig?.output?.sourceMap) if (this.config.mode === "development") this.config.output.sourceMap = true;
-		else this.config.output.sourceMap = false;
-		if (!this.config.userConfig?.output?.minify && !this.config.initialConfig?.output?.minify && !this.config.inlineConfig?.output?.minify && !this.config.pluginConfig?.output?.minify) if (this.config.mode === "production") this.config.output.minify = true;
-		else this.config.output.minify = false;
-		if (!this.config.userConfig?.output?.artifactsPath && !this.config.initialConfig?.output?.artifactsPath && !this.config.inlineConfig?.output?.artifactsPath && !this.config.pluginConfig?.output?.artifactsPath) this.config.output.artifactsPath = `.${this.config.framework || "powerlines"}`;
-		if (this.config.output.copy && this.config.output.copy.assets) this.config.output.copy.assets = this.config.output.copy.assets.map((asset) => ({
+		if (!mergedConfig.output?.sourceMap) if (mergedConfig.mode === "development") mergedConfig.output.sourceMap = true;
+		else mergedConfig.output.sourceMap = false;
+		if (!mergedConfig.output.minify) if (mergedConfig.mode === "production") mergedConfig.output.minify = true;
+		else mergedConfig.output.minify = false;
+		if (!mergedConfig.output.artifactsPath) mergedConfig.output.artifactsPath = `.${mergedConfig.framework || "powerlines"}`;
+		if (mergedConfig.output.copy && mergedConfig.output.copy.assets) mergedConfig.output.copy.assets = mergedConfig.output.copy.assets.map((asset) => ({
 			...asset,
 			glob: replacePathTokens(this, asset.glob),
 			ignore: asset.ignore ? asset.ignore.map((ignore) => replacePathTokens(this, ignore)) : void 0,
 			input: replacePathTokens(this, asset.input),
 			output: replacePathTokens(this, asset.output)
 		}));
-		if (isSetString(this.config.output?.storage) && this.config.output.storage === "virtual" || isSetObject(this.config.output?.storage) && Object.values(this.config.output.storage).every((adapter) => adapter.preset === "virtual")) this.config.output.overwrite = true;
+		if (isSetString(mergedConfig.output?.storage) && mergedConfig.output.storage === "virtual" || isSetObject(mergedConfig.output?.storage) && Object.values(mergedConfig.output.storage).every((adapter) => adapter.preset === "virtual")) mergedConfig.output.overwrite = true;
+		this.resolvedConfig = mergedConfig;
+		this.#configProxy = this.createConfigProxy();
+		this.logger.debug({
+			meta: { category: "config" },
+			message: `Resolved Powerlines configuration object: \n --- Resolved Config --- \n${this.logConfig(this.resolvedConfig)} \n --- Initial Config --- \n${this.logConfig(this.initialConfig)} \n --- User Config --- \n${this.logConfig(this.userConfig)} \n --- Inline Config --- \n${this.logConfig(this.inlineConfig)} \n --- Plugin Config --- \n${this.logConfig(this.pluginConfig)}`
+		});
 		this.#fs ??= await VirtualFileSystem.create(this);
-		if (isSetObject(this.config.inlineConfig) && isSetObject(this.config.userConfig) && isSetObject(this.config.initialConfig) && isSetObject(this.config.pluginConfig)) logger.debug(`Resolved Powerlines configuration object: \n${formatLogMessage({
-			...omit(this.config, [
-				"inlineConfig",
-				"userConfig",
-				"initialConfig",
-				"pluginConfig",
-				"plugins"
-			]),
-			inlineConfig: isSetObject(this.config.inlineConfig) ? omit(this.config.inlineConfig, ["plugins"]) : void 0,
-			userConfig: isSetObject(this.config.userConfig) ? omit(this.config.userConfig, ["plugins"]) : void 0,
-			initialConfig: isSetObject(this.config.initialConfig) ? omit(this.config.initialConfig, ["plugins"]) : void 0,
-			pluginConfig: isSetObject(this.config.pluginConfig) ? omit(this.config.pluginConfig, ["plugins"]) : void 0
-		})}`);
+	}
+	logConfig(config) {
+		return formatLogMessage({
+			...omit(config, ["plugins"]),
+			plugins: config.plugins ? config.plugins.flatMap((plugin) => toArray(plugin)).map((plugin) => String(isSetString(plugin) ? plugin : isPromise(plugin) ? "<promise>" : isFunction(plugin) ? plugin.name || "<anonymous function>" : Array.isArray(plugin) ? plugin[0] || "<anonymous function plugin>" : "<unknown plugin>")) : void 0
+		});
+	}
+	createConfigProxy() {
+		return new Proxy(this.resolvedConfig, {
+			/**
+			* A trap for the `delete` operator.
+			* @param target - The original object which is being proxied.
+			* @param key - The name or `Symbol` of the property to delete.
+			* @returns A `boolean` indicating whether or not the property was deleted.
+			*/
+			deleteProperty: (target, key) => {
+				if (UNRESOLVED_CONFIG_NAMES.includes(key.toString())) throw new Error(`Cannot delete property ${key.toString()} from config - it is only intended to be used as a reference.`);
+				Reflect.deleteProperty(this.overriddenConfig, key);
+				return Reflect.deleteProperty(target, key);
+			},
+			/**
+			* A trap for getting a property value.
+			* @param target - The original object which is being proxied.
+			* @param key - The name or `Symbol` of the property to get.
+			* @param receiver - The proxy or an object that inherits from the proxy.
+			*/
+			get: (target, key, receiver) => {
+				if (UNRESOLVED_CONFIG_NAMES.includes(key.toString())) {
+					if (key === "initialConfig") return this.initialConfig;
+					if (key === "userConfig") return this.userConfig;
+					if (key === "inlineConfig") return this.inlineConfig;
+					if (key === "pluginConfig") return this.pluginConfig;
+				}
+				return Reflect.get(target, key, receiver);
+			},
+			/**
+			* A trap for the `in` operator.
+			* @param target - The original object which is being proxied.
+			* @param key - The name or `Symbol` of the property to check for existence.
+			*/
+			has: (target, key) => {
+				return Reflect.has(target, key) || UNRESOLVED_CONFIG_NAMES.includes(key.toString());
+			},
+			/**
+			* A trap for `Reflect.ownKeys()`.
+			* @param target - The original object which is being proxied.
+			*/
+			ownKeys: (target) => {
+				return getUnique([...Reflect.ownKeys(target), ...UNRESOLVED_CONFIG_NAMES]);
+			},
+			/**
+			* A trap for setting a property value.
+			* @param target - The original object which is being proxied.
+			* @param key - The name or `Symbol` of the property to set.
+			* @param newValue - The new value to assign to the property.
+			* @param receiver - The object to which the assignment was originally directed.
+			* @returns A `boolean` indicating whether or not the property was set.
+			*/
+			set: (target, key, newValue, receiver) => {
+				if (UNRESOLVED_CONFIG_NAMES.includes(key.toString())) throw new Error(`Cannot change property ${key.toString()} from config - it is only intended to be used as a reference.`);
+				Reflect.set(this.overriddenConfig, key, newValue, receiver);
+				return Reflect.set(target, key, newValue, receiver);
+			}
+		});
 	}
 };
 
@@ -3434,7 +3464,7 @@ function createPluginContext(pluginId, plugin, environment) {
 		return {
 			meta: {
 				...isSetObject(message) ? message.meta : {},
-				environment: environment.environment?.name,
+				environment: environment.config.environment.name,
 				plugin: plugin.name
 			},
 			message: isString(message) ? message : message.message
@@ -3457,6 +3487,8 @@ function createPluginContext(pluginId, plugin, environment) {
 				callHook: callHookFn,
 				meta
 			};
+			if (prop === "api") return environment.$$internal.api;
+			if (prop === "environment") return environment;
 			if (prop === "id") return pluginId;
 			if (prop === "logger") return logger;
 			if (prop === "log") return (type, message) => {
@@ -3509,6 +3541,15 @@ function createPluginContext(pluginId, plugin, environment) {
 //#endregion
 //#region src/context/environment-context.ts
 var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends PowerlinesContext {
+	/**
+	* Internal references storage
+	*
+	* @danger
+	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+	*
+	* @internal
+	*/
+	#internal = {};
 	/**
 	* The hooks registered by plugins in this environment
 	*/
@@ -3518,29 +3559,50 @@ var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends Po
 	*
 	* @param options - The resolved execution options.
 	* @param config - The user configuration options.
-	* @returns A promise that resolves to the new context.
+	* @param overriddenConfig - The configuration options that should override all other configuration sources, such as CLI flags or environment variables. This is used to ensure that certain configuration values take precedence over any other settings defined in the user configuration or environment configuration, allowing for dynamic overrides based on the execution context.
+	* @param environment - The resolved environment configuration, which may include additional properties or modifications made during the configuration loading process. This is used to provide context about the environment in which the command is being executed, allowing for environment-specific behavior and configuration resolution.
+	* @returns A promise that resolves to an instance of the PowerlinesEnvironmentContext class, initialized with the provided configuration and environment data.
 	*/
-	static async fromConfig(options, config, environment) {
-		const context = new PowerlinesEnvironmentContext(options, config, environment);
-		await context.setup();
-		const powerlinesPath = await resolvePackage("powerlines");
-		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
-		context.powerlinesPath = powerlinesPath;
+	static async createEnvironment(options, config, overriddenConfig, environment) {
+		const context = new PowerlinesEnvironmentContext(options, config, overriddenConfig);
+		await context.setEnvironmentConfig(environment);
 		return context;
 	}
 	/**
-	* The resolved environment configuration
+	* The configuration options provided by plugins added by the user (and other plugins)
 	*/
-	environment;
+	environmentConfig = {};
 	/**
 	* The list of plugins applied to this environment
 	*/
 	plugins = [];
 	/**
-	* The unique identifier of the environment associated with this context, which can be used for logging and other purposes to distinguish between different environments in the same process.
+	* Internal context fields and methods
+	*
+	* @danger
+	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+	*
+	* @internal
 	*/
-	get id() {
-		return this.environment.environmentId;
+	get $$internal() {
+		return this.#internal;
+	}
+	/**
+	* Internal context fields and methods
+	*
+	* @danger
+	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+	*
+	* @internal
+	*/
+	set $$internal(value) {
+		this.#internal = value;
+	}
+	/**
+	* The unique identifier of the environment associated with this context, which can be used for logging and other purposes to distinguish between different environments in the same process.
+	*/
+	get id() {
+		return this.config.environment.id;
 	}
 	/**
 	* The hooks registered by plugins in this environment
@@ -3549,6 +3611,20 @@ var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends Po
 		return this.#hooks;
 	}
 	/**
+	* A setter function to populate the environment config values provided during execution of the command, such as CLI flags or other parameters that may be relevant to the command being executed. This function can be used to update the context with the environment configuration values, which may be used during the configuration resolution process to ensure that the final configuration reflects both the user configuration and any environment configuration provided during execution.
+	*
+	* @param config - The environment configuration values to set.
+	* @returns A promise that resolves when the environment configuration values have been set.
+	*/
+	async setEnvironmentConfig(config) {
+		this.logger.debug({
+			meta: { category: "config" },
+			message: `Updating environment configuration object: \n${this.logConfig(config)}`
+		});
+		this.environmentConfig = config;
+		await this.resolveConfig();
+	}
+	/**
 	* Create a new logger instance
 	*
 	* @param options - The configuration options to use for the logger instance, which can be used to customize the appearance and behavior of the log messages generated by the logger. This is typically the name of the plugin or module that is creating the logger instance.
@@ -3558,7 +3634,7 @@ var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends Po
 	createLogger(options, logFn) {
 		return super.createLogger({
 			...options,
-			environment: this.environment?.name
+			environment: this.config.environment?.name
 		}, logFn);
 	}
 	/**
@@ -3570,47 +3646,21 @@ var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends Po
 	extendLogger(options) {
 		return super.extendLogger({
 			...options,
-			environment: this.environment?.name
+			environment: this.config.environment?.name
 		});
 	}
-	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
-	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
-	*
-	* @returns A promise that resolves to the cloned context.
-	*/
-	async clone() {
-		const context = await PowerlinesEnvironmentContext.fromConfig(deepClone(this.options), deepClone(this.config), deepClone(this.environment));
-		return this.copyTo(context);
-	}
-	/**
-	* Initialize the context with the provided configuration options
-	*/
-	async setup() {
-		this.resolvedConfig = mergeConfig({
-			name: this.config.name,
-			title: this.config.title
-		}, getConfigProps({
-			...this.environment,
-			root: this.options.root,
-			cwd: this.options.cwd
-		}), this.config);
-		await this.innerSetup();
-	}
 	async addPlugin(plugin) {
 		let resolvedPlugin = plugin;
 		if (isFunction(plugin.applyToEnvironment)) {
-			const result = await Promise.resolve(plugin.applyToEnvironment(this.environment));
+			const result = await Promise.resolve(plugin.applyToEnvironment(this.config.environment));
 			if (!result || isObject(result) && Object.keys(result).length === 0) return;
 			if (isPluginConfig(result)) return this.$$internal.addPlugin(result);
 			resolvedPlugin = isPlugin(result) ? result : plugin;
 		}
-		const pluginId = uuid();
-		const context = createPluginContext(pluginId, resolvedPlugin, this);
+		const id = uuid();
+		const context = createPluginContext(id, resolvedPlugin, this);
 		this.plugins.push({
-			pluginId,
+			id,
 			plugin: resolvedPlugin,
 			context
 		});
@@ -3653,29 +3703,51 @@ var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends Po
 		}
 		return result;
 	}
-	constructor(options, config, environment) {
-		super(options);
-		this.resolvedConfig = config;
-		this.environment = environment;
+	constructor(options, config, overriddenConfig) {
+		super(options, config.initialConfig);
+		this.userConfig = config.userConfig ?? {};
+		this.inlineConfig = config.inlineConfig ?? {};
+		this.pluginConfig = config.pluginConfig ?? {};
+		this.overriddenConfig = overriddenConfig;
 	}
 	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
+	* A function to merge the various configuration objects (initial, user, inline, and plugin) into a single resolved configuration object that can be used throughout the Powerlines process. This function takes into account the different sources of configuration and their respective priorities, ensuring that the final configuration reflects the intended settings for the project. The merged configuration is then returned as a new object that can be accessed through the `config` property of the context.
 	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
-	*
-	* @returns The cloned context.
+	* @returns The merged configuration object that combines the initial, user, inline, and plugin configurations.
 	*/
-	copyTo(context) {
-		context.plugins = this.plugins;
-		return super.copyTo(context);
+	mergeConfig() {
+		return mergeConfig({
+			...omit(this.environmentConfig ?? {}, [
+				"ssr",
+				"preview",
+				"consumer",
+				"runtime"
+			]),
+			environment: { name: this.environmentConfig?.name || DEFAULT_ENVIRONMENT },
+			environmentConfig: this.environmentConfig ?? {}
+		}, super.mergeConfig());
 	}
 };
 
 //#endregion
 //#region src/context/execution-context.ts
 var PowerlinesExecutionContext = class PowerlinesExecutionContext extends PowerlinesContext {
+	/**
+	* Internal references storage
+	*
+	* @danger
+	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+	*
+	* @internal
+	*/
+	#internal = {};
+	/**
+	* A record of all environments by name
+	*/
 	#environments = {};
+	/**
+	* The plugins added to this execution context, which may be used to track the plugins that have been added to the context and ensure that they are properly registered and executed during the build process. This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+	*/
 	#plugins = [];
 	/**
 	* Create a new Storm context from the workspace root and user config.
@@ -3683,13 +3755,9 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 	* @param options - The options for resolving the context.
 	* @returns A promise that resolves to the new context.
 	*/
-	static async init(options, initialConfig) {
-		const context = new PowerlinesExecutionContext(options);
-		await context.init(options, initialConfig);
-		const powerlinesPath = await resolvePackage("powerlines");
-		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
-		context.powerlinesPath = powerlinesPath;
-		await context.setup();
+	static async fromInitialConfig(options, initialConfig) {
+		const context = new PowerlinesExecutionContext(options, initialConfig);
+		await context.init();
 		return context;
 	}
 	/**
@@ -3698,19 +3766,10 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 	* @param options - The options for resolving the context.
 	* @returns A promise that resolves to the new context.
 	*/
-	static async inline(options, initialConfig, inlineConfig) {
-		const context = new PowerlinesExecutionContext(options);
-		await context.init(options, initialConfig);
-		context.config.inlineConfig = inlineConfig;
-		if (context.config.inlineConfig.command === "new") {
-			const workspacePackageJsonPath = joinPaths$1(context.config.cwd, "package.json");
-			if (!existsSync(workspacePackageJsonPath)) throw new Error(`The workspace package.json file could not be found at ${workspacePackageJsonPath}`);
-			context.packageJson = await readJsonFile(workspacePackageJsonPath);
-		}
-		await context.setup();
-		const powerlinesPath = await resolvePackage("powerlines");
-		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
-		context.powerlinesPath = powerlinesPath;
+	static async fromInlineConfig(options, initialConfig, inlineConfig) {
+		const context = new PowerlinesExecutionContext(options, initialConfig);
+		await context.init();
+		await context.setInlineConfig(inlineConfig);
 		return context;
 	}
 	/**
@@ -3722,7 +3781,7 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 	* @internal
 	*/
 	get $$internal() {
-		return super.$$internal;
+		return this.#internal;
 	}
 	/**
 	* Internal context fields and methods
@@ -3733,8 +3792,8 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 	* @internal
 	*/
 	set $$internal(value) {
-		super.$$internal = value;
-		for (const environment of Object.values(this.environments)) environment.$$internal = super.$$internal;
+		this.#internal = value;
+		for (const environment of Object.values(this.environments)) environment.$$internal = value;
 	}
 	/**
 	* The unique identifier of the execution context, which can be used for logging and other purposes to distinguish between different executions in the same process.
@@ -3755,9 +3814,26 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 	* Creates a new instance.
 	*
 	* @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
+	* @param initialConfig - The initial configuration options to use for the context, which can be used to provide default values for configuration options that may be overridden by user configuration or inline configuration. This is typically the configuration options provided by the user in a configuration file on disk, and can include any relevant settings such as environment definitions, plugin configurations, and other parameters that may be relevant to the execution of a Powerlines command.
+	*/
+	constructor(options, initialConfig = {}) {
+		super(options, initialConfig);
+		this.initialOptions = options;
+		this.initialConfig = initialConfig;
+	}
+	/**
+	* A setter function to populate the inline config values provided during execution of the command, such as CLI flags or other parameters that may be relevant to the command being executed. This function can be used to update the context with the inline configuration values, which may be used during the configuration resolution process to ensure that the final configuration reflects both the user configuration and any inline configuration provided during execution.
+	*
+	* @param config - The inline configuration values to set.
+	* @returns A promise that resolves when the inline configuration values have been set.
 	*/
-	constructor(options) {
-		super(options);
+	async setInlineConfig(config) {
+		await super.setInlineConfig(config);
+		if (this.inlineConfig.command === "new") {
+			const workspacePackageJsonPath = joinPaths$1(this.config.cwd, "package.json");
+			if (!existsSync(workspacePackageJsonPath)) throw new Error(`The workspace package.json file could not be found at ${workspacePackageJsonPath}`);
+			this.packageJson = await readJsonFile(workspacePackageJsonPath);
+		}
 	}
 	/**
 	* Create a new logger instance
@@ -3787,42 +3863,45 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 		});
 	}
 	/**
-	* Creates a clone of the current context with the same configuration and workspace settings. This can be useful for running multiple builds in parallel or for creating isolated contexts for different parts of the build process.
-	*
-	* @remarks
-	* The cloned context will have the same configuration and workspace settings as the original context, but will have a different build ID, release ID, and timestamp. The virtual file system and caches will also be separate between the original and cloned contexts.
-	*
-	* @returns A promise that resolves to the cloned context.
-	*/
-	async clone() {
-		const clone = await PowerlinesExecutionContext.init(this.options, this.initialConfig);
-		clone.config.userConfig = deepClone(this.config.userConfig);
-		clone.config.initialConfig = deepClone(this.config.initialConfig);
-		clone.config.inlineConfig = deepClone(this.config.inlineConfig);
-		clone.config.pluginConfig = deepClone(this.config.pluginConfig);
-		await clone.setup();
-		clone.$$internal = this.$$internal;
-		return this.copyTo(clone);
-	}
-	/**
 	* A function to copy the context and update the fields for a specific environment
 	*
 	* @param environment - The environment configuration to use.
 	* @returns A new context instance with the updated environment.
 	*/
-	async in(environment) {
-		const context = this.copyTo(await PowerlinesEnvironmentContext.fromConfig(deepClone(this.options), deepClone(this.config), deepClone(environment)));
+	async createEnvironment(environment) {
+		const context = await PowerlinesEnvironmentContext.createEnvironment(deepClone(this.options), deepClone(this.config), deepClone(this.overriddenConfig), deepClone(environment));
+		context.$$internal = this.$$internal;
+		context.dependencies = deepClone(this.dependencies);
+		context.devDependencies = deepClone(this.devDependencies);
+		context.persistedMeta = deepClone(this.persistedMeta);
+		context.resolvePatterns = deepClone(this.resolvePatterns);
+		context.powerlinesPath ??= this.powerlinesPath;
+		context.resolver ??= this.resolver;
 		context.plugins = [];
 		for (const plugin of this.plugins) await context.addPlugin(plugin);
+		for (const [key, value] of Object.entries(this)) if (![
+			"fs",
+			"$$internal",
+			"dependencies",
+			"devDependencies",
+			"persistedMeta",
+			"packageJson",
+			"projectJson",
+			"tsconfig",
+			"resolver",
+			"plugins",
+			"environments"
+		].includes(key)) if (isObject(value) || Array.isArray(value)) context[key] = deepClone(value);
+		else context[key] = value;
 		return context;
 	}
 	/**
 	* Update the context using a new inline configuration options
 	*/
-	async setup() {
-		await super.setup();
+	async resolveConfig() {
+		await super.resolveConfig();
 		await Promise.all(toArray(this.config.environments && Object.keys(this.config.environments).length > 0 ? Object.keys(this.config.environments).map((name) => createEnvironment(name, this.config)) : createDefaultEnvironment(this.config)).map(async (env) => {
-			this.#environments[env.name] = await this.in(env);
+			this.#environments[env.name] = await this.createEnvironment(env);
 		}));
 	}
 	/**
@@ -3847,12 +3926,20 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 		if (name) environment = this.environments[name];
 		if (Object.keys(this.environments).length === 1) {
 			environment = this.environments[Object.keys(this.environments)[0]];
-			this.debug(`Applying the only configured environment: ${chalk.bold.cyanBright(environment?.environment.name)}`);
+			this.trace({
+				meta: { category: "plugins" },
+				message: `Applying the only configured environment: ${chalk.bold.cyanBright(environment?.config.environment?.name)}`
+			});
 		}
 		if (!environment) {
 			if (name) throw new Error(`Environment "${name}" not found.`);
-			environment = await this.in(createDefaultEnvironment(this.config));
-			this.warn(`No environment specified, and no default environment found. Using a temporary default environment: ${chalk.bold.cyanBright(environment?.environment.name)}`);
+			environment = await PowerlinesEnvironmentContext.createEnvironment(deepClone(this.options), deepClone(this.config), deepClone(this.overriddenConfig), deepClone(createDefaultEnvironment(this.config)));
+			environment.plugins = [];
+			for (const plugin of this.plugins) await environment.addPlugin(plugin);
+			this.warn({
+				meta: { category: "plugins" },
+				message: `No environment specified, and no default environment found. Using a temporary default environment: ${chalk.bold.cyanBright(environment.config.environment?.name)}`
+			});
 		}
 		return environment;
 	}
@@ -3880,8 +3967,11 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 	async toEnvironment() {
 		let environment;
 		if (Object.keys(this.environments).length > 1) {
-			environment = await this.in(createEnvironment(GLOBAL_ENVIRONMENT, this.config));
-			this.debug(`Combined all ${Object.keys(this.environments).length} environments into a single global context.`);
+			environment = await this.createEnvironment(createEnvironment(GLOBAL_ENVIRONMENT, this.config));
+			this.debug({
+				meta: { category: "plugins" },
+				message: `Combined all ${Object.keys(this.environments).length} environments into a single global context.`
+			});
 		} else environment = await this.getEnvironment();
 		return environment;
 	}
@@ -4301,11 +4391,11 @@ async function installDependencies(context) {
 //#endregion
 //#region src/_internal/helpers/resolve-tsconfig.ts
 function getTsconfigDtsPath(context) {
-	return joinPaths(relativePath(joinPaths(context.options.cwd, context.options.root), findFilePath(context.typesPath)), findFileName(context.typesPath));
+	return joinPaths(relativePath(joinPaths(context.config.cwd, context.config.root), findFilePath(context.typesPath)), findFileName(context.typesPath));
 }
 async function resolveTsconfigChanges(context) {
-	const tsconfig = getParsedTypeScriptConfig(context.options.cwd, context.options.root, context.config.tsconfig, context.config.tsconfigRaw);
-	const tsconfigJson = await readJsonFile(getTsconfigFilePath(context.options.cwd, context.options.root, context.config.tsconfig));
+	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);
@@ -4395,353 +4485,86 @@ 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
+	* Initialize a Powerlines API instance
 	*
-	* @returns The configured environments
+	* @param options - The options to initialize the API with
+	* @returns A new instance of the Powerlines API
 	*/
-	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));
+	static async from(options, initialConfig) {
+		const api = new PowerlinesExecution(await PowerlinesExecutionContext.fromInitialConfig(options, initialConfig ?? {}));
+		await api.init();
+		return api;
 	}
 	/**
-	* Execute a handler function for each environment
-	*
-	* @param handle - The handler function to execute for each environment
+	* The Powerlines context
 	*/
-	async #executeEnvironments(handle) {
-		await Promise.all((await this.#getEnvironments()).map(async (context) => {
-			return Promise.resolve(handle(context));
-		}));
+	get context() {
+		return this.#context;
 	}
 	/**
-	* Initialize a Powerlines plugin
+	* Generate the Powerlines typescript declaration file
 	*
-	* @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
+	* @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 #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\`.`);
+	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;
+		});
 	}
 	/**
-	* Generate the Powerlines TypeScript declaration file
+	* Prepare the Powerlines API
 	*
 	* @remarks
-	* This method will generate the TypeScript declaration file for the Powerlines project, including any types provided by plugins.
+	* This method will prepare the Powerlines API for use, initializing any necessary resources.
 	*
-	* @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)}
-`);
-	}
-	/**
-	* Initialize a Powerlines API instance
-	*
-	* @param options - The options to initialize the API with
-	* @returns A new instance of the Powerlines API
-	*/
-	static async init(options, initialConfig) {
-		const api = new PowerlinesExecution(await PowerlinesExecutionContext.init(options, initialConfig ?? {}));
-		api.#context.config.initialConfig = initialConfig ?? {};
-		await api.setup();
-		return api;
-	}
-	/**
-	* The Powerlines context
-	*/
-	get context() {
-		return this.#context;
-	}
-	/**
-	* Initialize the execution API with the provided configuration options
-	*/
-	async setup() {
-		await this.#context.setup();
-		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) {
-			this.#context.config.pluginConfig = pluginConfig;
-			await this.#context.setup();
-		}
-		timer();
-	}
-	/**
-	* 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";
-		this.context.config.inlineConfig = inlineConfig;
-		await this.setup();
-		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
+	* @param inlineConfig - The inline configuration for the prepare command
 	*/
 	async prepare(inlineConfig = { command: "prepare" }) {
 		inlineConfig.command ??= "prepare";
-		this.context.config.inlineConfig = inlineConfig;
-		await this.setup();
-		await this.#executeEnvironments(async (context) => {
+		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,
@@ -4791,7 +4614,7 @@ ${formatTypes(code)}
 				environment: context,
 				order: "post"
 			});
-			if (context.config.output.types !== false) await this.#types(context);
+			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);
@@ -4810,7 +4633,7 @@ ${formatTypes(code)}
 	async new(inlineConfig) {
 		inlineConfig.command ??= "new";
 		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
+		await this.executeEnvironments(async (context) => {
 			context.debug("Initializing the processing options for the Powerlines project.");
 			await this.callHook("new", {
 				environment: context,
@@ -4859,7 +4682,7 @@ ${formatTypes(code)}
 	async clean(inlineConfig = { command: "clean" }) {
 		inlineConfig.command ??= "clean";
 		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
+		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));
@@ -4878,7 +4701,7 @@ ${formatTypes(code)}
 	async lint(inlineConfig = { command: "lint" }) {
 		inlineConfig.command ??= "lint";
 		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
+		await this.executeEnvironments(async (context) => {
 			await this.callHook("lint", {
 				environment: context,
 				sequential: false
@@ -4894,7 +4717,7 @@ ${formatTypes(code)}
 	async test(inlineConfig = { command: "test" }) {
 		inlineConfig.command ??= "test";
 		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
+		await this.executeEnvironments(async (context) => {
 			await this.callHook("test", {
 				environment: context,
 				sequential: false
@@ -4912,17 +4735,15 @@ ${formatTypes(code)}
 	*/
 	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);
-		} else {
-			this.context.config.inlineConfig = inlineConfig;
-			await this.context.setup();
 		}
-		if (this.context.config.singleBuild) await this.#handleBuild(await this.#context.toEnvironment());
-		else await this.#executeEnvironments(async (context) => {
-			await this.#handleBuild(context);
+		if (this.context.config.singleBuild) await this.handleBuild(await this.#context.toEnvironment());
+		else await this.executeEnvironments(async (context) => {
+			await this.handleBuild(context);
 		});
 	}
 	/**
@@ -4933,8 +4754,9 @@ ${formatTypes(code)}
 	*/
 	async docs(inlineConfig = { command: "docs" }) {
 		inlineConfig.command ??= "docs";
+		await this.context.setInlineConfig(inlineConfig);
 		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
+		await this.executeEnvironments(async (context) => {
 			context.debug("Writing documentation for the Powerlines project artifacts.");
 			await this.callHook("docs", { environment: context });
 		});
@@ -4949,8 +4771,9 @@ ${formatTypes(code)}
 	*/
 	async deploy(inlineConfig = { command: "deploy" }) {
 		inlineConfig.command ??= "deploy";
+		await this.context.setInlineConfig(inlineConfig);
 		await this.prepare(inlineConfig);
-		await this.#executeEnvironments(async (context) => {
+		await this.executeEnvironments(async (context) => {
 			await this.callHook("deploy", { environment: context });
 		});
 	}
@@ -4963,7 +4786,7 @@ ${formatTypes(code)}
 	* @returns A promise that resolves when the finalization process has completed
 	*/
 	async finalize() {
-		await this.#executeEnvironments(async (context) => {
+		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);
@@ -4995,13 +4818,40 @@ ${formatTypes(code)}
 		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);
+		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);
+			const result = await this.initPlugin(config);
 			if (!result) return;
 			for (const plugin of result) {
 				this.context.debug({
@@ -5012,33 +4862,266 @@ ${formatTypes(code)}
 			}
 		}
 	}
+	/**
+	* 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.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(`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\`.`);
+			}
+		}
+	}
+	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/_internal/worker.ts
 async function clean({ options, initialConfig, inlineConfig }) {
-	await (await PowerlinesExecution.init(options, initialConfig)).clean(inlineConfig);
+	await (await PowerlinesExecution.from(options, initialConfig)).clean(inlineConfig);
 }
 async function prepare({ options, initialConfig, inlineConfig }) {
-	await (await PowerlinesExecution.init(options, initialConfig)).prepare(inlineConfig);
+	await (await PowerlinesExecution.from(options, initialConfig)).prepare(inlineConfig);
 }
 async function types({ options, initialConfig, inlineConfig }) {
-	await (await PowerlinesExecution.init(options, initialConfig)).types(inlineConfig);
+	await (await PowerlinesExecution.from(options, initialConfig)).types(inlineConfig);
 }
 async function lint({ options, initialConfig, inlineConfig }) {
-	await (await PowerlinesExecution.init(options, initialConfig)).lint(inlineConfig);
+	await (await PowerlinesExecution.from(options, initialConfig)).lint(inlineConfig);
 }
 async function test({ options, initialConfig, inlineConfig }) {
-	await (await PowerlinesExecution.init(options, initialConfig)).test(inlineConfig);
+	await (await PowerlinesExecution.from(options, initialConfig)).test(inlineConfig);
 }
 async function build({ options, initialConfig, inlineConfig }) {
-	await (await PowerlinesExecution.init(options, initialConfig)).build(inlineConfig);
+	await (await PowerlinesExecution.from(options, initialConfig)).build(inlineConfig);
 }
 async function docs({ options, initialConfig, inlineConfig }) {
-	await (await PowerlinesExecution.init(options, initialConfig)).docs(inlineConfig);
+	await (await PowerlinesExecution.from(options, initialConfig)).docs(inlineConfig);
 }
 async function deploy({ options, initialConfig, inlineConfig }) {
-	await (await PowerlinesExecution.init(options, initialConfig)).deploy(inlineConfig);
+	await (await PowerlinesExecution.from(options, initialConfig)).deploy(inlineConfig);
 }
 
 //#endregion