@powerlines/engine 0.45.2 → 0.46.0

package/dist/{execution-context-BRzNYU9u.mjs → execution-context-Cp32TarF.mjs}

@@ -1,26 +1,26 @@
-import { t as PowerlinesBaseContext } from "./base-context-BSAC5sO9.mjs";
+import { t as PowerlinesBaseContext } from "./base-context-Cmo6TTh7.mjs";
 import { a as FileSystem } from "./fs-D1nIP45P.mjs";
 import { n as FileSystemStorageAdapter, t as VirtualStorageAdapter } from "./virtual-CYGZHTDd.mjs";
-import { i as getTsconfigFilePath } from "./tsconfig-CI6bla4E.mjs";
+import { i as getTsconfigFilePath } from "./tsconfig-MeFEs21S.mjs";
 import { CACHE_HASH_LENGTH, DEFAULT_DEVELOPMENT_LOG_LEVEL, DEFAULT_ENVIRONMENT, DEFAULT_PRODUCTION_LOG_LEVEL, DEFAULT_TEST_LOG_LEVEL, GLOBAL_ENVIRONMENT, PLUGIN_NON_HOOK_FIELDS, ROOT_HASH_LENGTH } from "@powerlines/core/constants";
 import { toArray } from "@stryke/convert/to-array";
-import { getResolutionCombinations, resolve, resolvePackage, resolveSync } from "@stryke/fs/resolve";
+import { getResolutionCombinations, resolve, resolveSync } from "@stryke/fs/resolve";
 import { joinPaths } from "@stryke/path/join";
 import { isSet } from "@stryke/type-checks/is-set";
 import { isSetObject } from "@stryke/type-checks/is-set-object";
 import { isString } from "@stryke/type-checks/is-string";
+import { messageParent } from "jest-worker";
 import { isSetString } from "@stryke/type-checks/is-set-string";
 import { uuid } from "@stryke/unique-id/uuid";
 import { addPluginHook, createLogger, dedupeHooklist, isDuplicate, isPlugin, isPluginConfig, isPluginHook, isPluginHookField, mergeConfig, replacePathTokens, resolveLogLevel, withCustomLogger, withLogFn } from "@powerlines/core/plugin-utils";
 import { colorText } from "@powerlines/core/plugin-utils/logging";
 import { getEnvPaths } from "@stryke/env/get-env-paths";
 import { appendPath } from "@stryke/path/append";
-import { isEqual } from "@stryke/path/is-equal";
 import { replaceExtension, replacePath } from "@stryke/path/replace";
+import { kebabCase } from "@stryke/string-format/kebab-case";
 import chalk from "chalk";
 import defu, { defu as defu$1 } from "defu";
 import { joinPaths as joinPaths$1 } from "@stryke/path/join-paths";
-import { titleCase } from "@stryke/string-format/title-case";
 import { format } from "@powerlines/core/lib/utilities/format";
 import { formatLogMessage } from "@storm-software/config-tools/logger/console";
 import { existsSync } from "@stryke/fs/exists";
@@ -28,17 +28,18 @@ import { getUnique, getUniqueBy } from "@stryke/helpers/get-unique";
 import { omit } from "@stryke/helpers/omit";
 import { findFileDotExtensionSafe, findFileExtensionSafe, findFileName, findFilePath, hasFileExtension } from "@stryke/path/file-path-fns";
 import { isParentPath } from "@stryke/path/is-parent-path";
+import { titleCase } from "@stryke/string-format/title-case";
 import { isFunction } from "@stryke/type-checks/is-function";
 import { isObject } from "@stryke/type-checks/is-object";
+import { isPromise } from "@stryke/type-checks/is-promise";
 import { readJsonFile } from "@stryke/fs/json";
 import { deepClone } from "@stryke/helpers/deep-clone";
 import { getUniqueInputs, isTypeDefinition, resolveInputsSync } from "@powerlines/core/lib/entry";
-import { toBool } from "@stryke/convert/to-bool";
 import { relativeToWorkspaceRoot } from "@stryke/fs/get-workspace-root";
 import { murmurhash } from "@stryke/hash";
 import { hashDirectory } from "@stryke/hash/node";
 import { fetchRequest } from "@stryke/http/fetch";
-import { kebabCase } from "@stryke/string-format/kebab-case";
+import { isEqual } from "@stryke/path/is-equal";
 import { match, tsconfigPathsToRegExp } from "bundle-require";
 import { resolveCompatibilityDates } from "compatx";
 import { create } from "flat-cache";
@@ -59,9 +60,9 @@ import { fileURLToPath } from "node:url";
 import { getField } from "@stryke/helpers/get-field";
 
 //#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,
@@ -87,7 +88,7 @@ function createEnvironment(name, config = {}) {
 		} : void 0
 	});
 }
-function createDefaultEnvironment(config = {}) {
+function createDefaultEnvironment(config) {
 	return createEnvironment(DEFAULT_ENVIRONMENT, config);
 }
 
@@ -144,16 +145,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: {
@@ -163,8 +164,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,
@@ -173,7 +174,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
@@ -1269,27 +1284,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();
@@ -1297,24 +1298,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
 	*/
@@ -1328,39 +1327,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
 	*/
@@ -1415,13 +1408,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(this.config.cwd, this.config.root, this.config.output.artifactsPath);
+		return joinPaths(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
@@ -1478,7 +1472,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];
@@ -1507,29 +1501,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() {
@@ -1591,25 +1562,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
@@ -1939,206 +1923,233 @@ 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 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.
 	*/
-	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,
+	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: {}
 		});
-		this.config.plugins = (this.config.initialConfig.plugins ?? []).concat(this.config.userConfig.plugins ?? [], this.config.inlineConfig.plugins ?? []);
-		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
-	*
-	*   @remarks
-	* This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
-	*
-	* @param options - The configuration options to initialize the context with
-	*/
-	async init(options, 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(this.options.cwd, this.options.root, "project.json");
-		if (existsSync(projectJsonPath)) this.projectJson = await readJsonFile(projectJsonPath);
-		const packageJsonPath = joinPaths(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(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
-		};
+	*/
+	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);
 	}
 	/**
 	* Initialize the context with the provided configuration options
 	*/
-	async innerSetup() {
-		const logger = this.extendLogger({ category: "config" });
-		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();
+		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(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("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(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(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("dist", mergedConfig.root)), mergedConfig.cwd);
+		if (mergedConfig.output.types !== false) mergedConfig.output.types = appendPath(replacePathTokens(this, mergedConfig.output.types || joinPaths(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(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(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);
+			}
+		});
 	}
 };
 
@@ -2283,7 +2294,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
@@ -2306,6 +2317,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) => {
@@ -2358,6 +2371,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
 	*/
@@ -2367,29 +2389,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 = [];
 	/**
+	* Internal context fields and methods
+	*
+	* @danger
+	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+	*
+	* @internal
+	*/
+	get $$internal() {
+		return this.#internal;
+	}
+	/**
+	* Internal context fields and methods
+	*
+	* @danger
+	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+	*
+	* @internal
+	*/
+	set $$internal(value) {
+		this.#internal = value;
+	}
+	/**
 	* The 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.environment.environmentId;
+		return this.config.environment.id;
 	}
 	/**
 	* The hooks registered by plugins in this environment
@@ -2398,6 +2441,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.
@@ -2407,7 +2464,7 @@ var PowerlinesEnvironmentContext = class PowerlinesEnvironmentContext extends Po
 	createLogger(options, logFn) {
 		return super.createLogger({
 			...options,
-			environment: this.environment?.name
+			environment: this.config.environment?.name
 		}, logFn);
 	}
 	/**
@@ -2419,39 +2476,13 @@ 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;
@@ -2502,29 +2533,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.
-	*
-	* @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 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 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.
@@ -2532,12 +2585,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;
+	static async fromInitialConfig(options, initialConfig) {
+		const context = new PowerlinesExecutionContext(options, initialConfig);
+		await context.init();
 		return context;
 	}
 	/**
@@ -2546,19 +2596,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(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;
 	}
 	/**
@@ -2570,7 +2611,7 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 	* @internal
 	*/
 	get $$internal() {
-		return super.$$internal;
+		return this.#internal;
 	}
 	/**
 	* Internal context fields and methods
@@ -2581,8 +2622,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.
@@ -2603,9 +2644,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) {
-		super(options);
+	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.
+	*/
+	async setInlineConfig(config) {
+		await super.setInlineConfig(config);
+		if (this.inlineConfig.command === "new") {
+			const workspacePackageJsonPath = joinPaths(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
@@ -2635,31 +2693,20 @@ 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.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.$$internal = this.$$internal;
 		context.plugins = [];
 		for (const plugin of this.plugins) await context.addPlugin(plugin);
 		return context;
@@ -2667,10 +2714,10 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 	/**
 	* 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);
 		}));
 	}
 	/**
@@ -2695,12 +2742,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;
 	}
@@ -2728,8 +2783,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;
 	}
@@ -2737,4 +2795,4 @@ var PowerlinesExecutionContext = class PowerlinesExecutionContext extends Powerl
 
 //#endregion
 export { mergeConfigs as a, callHook as i, PowerlinesEnvironmentContext as n, PowerlinesContext as o, createPluginContext as r, writeMetaFile as s, PowerlinesExecutionContext as t };
-//# sourceMappingURL=execution-context-BRzNYU9u.mjs.map
+//# sourceMappingURL=execution-context-Cp32TarF.mjs.map