@powerlines/core 0.15.0 → 0.15.1

package/dist/lib/config.d.cts

@@ -1,8 +1,86 @@
+import { LogLevelResolvedConfig } from "../types/logging.cjs";
 import { Context } from "../types/context.cjs";
-import { AnyUserConfig, ParsedUserConfig, ResolvedEngineOptions, UserConfig, WorkspaceConfig } from "../types/config.cjs";
-import { Jiti } from "jiti";
+import { AnyUserConfig, FrameworkOptions, InlineConfig, Mode, ParsedUserConfig, UserConfig, WorkspaceConfig } from "../types/config.cjs";
+import { PartialKeys } from "@stryke/types/base";
+import { PackageJson } from "@stryke/types/package-json";
 
 //#region src/lib/config.d.ts
+declare function normalizeBasePath(base?: string): string;
+interface ResolvePackageConfigsResult {
+  /**
+   * The parsed `package.json` file for the project, if it exists. This file typically contains metadata about the project, such as its name, version, dependencies, and other information relevant to the build process.
+   */
+  packageJson?: PackageJson;
+  /**
+   * The parsed `project.json` file for the project, if it exists. This file is an optional configuration file that can be used to store additional configuration or metadata specific to the project, and is not required for all projects.
+   */
+  projectJson?: Record<string, unknown>;
+}
+/**
+ * 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.
+ */
+declare function resolvePackageConfigs(cwd: string, root: string): Promise<ResolvePackageConfigsResult>;
+/**
+ * Resolve the root directory for the project based on the provided options. This function will determine the root directory by checking the provided `root` option, and if it is not provided, it will look for a configuration file (such as `powerlines.config.ts`) in the current working directory. If a configuration file is found, the root directory will be set to the directory containing that file. If no configuration file is found, the root directory will default to the current working directory.
+ *
+ * @param cwd - The current working directory to use as the base for resolving the root directory. This is typically the directory from which the Powerlines process was executed.
+ * @param root - An optional root directory to use for the project. If provided, this will be used as the root directory instead of looking for a configuration file. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+ * @param configFile - An optional path to a configuration file to look for when resolving the root directory. If provided, this file will be used to determine the root directory if the `root` option is not provided. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+ * @returns The resolved root directory for the project, which will be used as the base for resolving other paths and configurations throughout the Powerlines process. This will typically be an absolute path to the root directory of the project.
+ */
+declare function resolveRoot(cwd: string, root?: string, configFile?: string): string;
+/**
+ * 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.
+ *
+ * @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+ * @param root - An optional root directory to use as the base for searching for the configuration file. If provided, this will be used as the starting point for searching for the configuration file instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+ * @returns A promise that resolves to the workspace configuration object, or undefined if no configuration file is found.
+ */
+declare function tryResolveWorkspaceConfig(cwd: string, root?: string): Promise<WorkspaceConfig | undefined>;
+/**
+ * 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".
+ *
+ * @remarks
+ * The mode is used to determine which configuration file to load (e.g., `powerlines.development.config.js` for development mode, `powerlines.production.config.js` for production mode, etc.) and can also be used by plugins and other parts of the build process to conditionally apply certain behaviors based on the current mode.
+ *
+ * @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+ * @param root - An optional root directory to use as the base for searching for the workspace configuration. If provided, this will be used as the starting point for searching for the workspace configuration instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+ * @returns A promise that resolves to the default mode for the current execution, which can be "development", "production", or "test".
+ */
+declare function getDefaultMode(cwd: string, root?: string): Promise<Mode>;
+/**
+ * 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.
+ *
+ * @remarks
+ * The log level is used to determine which log messages should be output during the execution of the Powerlines process. For example, if the log level is set to "warn", only messages with a level of "warn", "error", or "fatal" will be output, while messages with a level of "info", "debug", or "trace" will be suppressed. This allows users to control the verbosity of the logs and focus on the most relevant information based on their current needs.
+ *
+ * @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+ * @param root - An optional root directory to use as the base for searching for the workspace configuration. If provided, this will be used as the starting point for searching for the workspace configuration instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+ * @returns A promise that resolves to the default log level for the current execution, which can be "fatal", "error", "warn", "info", "debug", or "trace".
+ */
+declare function getDefaultLogLevel(cwd: string, root?: string): Promise<LogLevelResolvedConfig>;
+/**
+ * Load the user configuration file for the project and set up the context with the loaded configuration. This function will be called during the initialization of the context to load the user configuration file based on the provided options and set up the context accordingly. It will also set up the resolver for loading modules from the user configuration file and ensure that the context is properly initialized with the loaded configuration.
+ *
+ * @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 cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+ * @param root - The root directory of the project to look for the configuration file. This is typically the root directory of the project, which may be different from the current working directory if the process was executed from a subdirectory.
+ * @param framework - The name of the framework to use when looking for configuration files (default is "powerlines"). This is used to determine the naming convention for the configuration files to look for (e.g., `powerlines.development.config.js` for the "powerlines" framework in development mode).
+ * @param orgId - The name of the organization to use when looking for configuration files (optional). This can be used to further customize the naming convention for the configuration files to look for (e.g., `powerlines.myorg.development.config.js` for the "powerlines" framework in development mode with an organization of "myorg").
+ * @param inlineConfig - The inline configuration options provided during the execution of a Powerlines command, which can include properties such as the project root, mode, and an explicit path to a configuration file. This is used to determine how the context should be initialized and which configuration file should be loaded for the execution.
+ * @returns A promise that resolves when the context has been successfully initialized with the loaded configuration and resolver setup.
+ * @throws Will throw an error if no configuration file is found in the project root or current working directory. This ensures that the context cannot be initialized without a valid configuration, which is essential for the proper functioning of the Powerlines process.
+ */
+declare function loadParsedConfig(cwd: string, root: string, framework: string, orgId: string, inlineConfig: InlineConfig): Promise<ParsedUserConfig>;
 type PartiallyResolvedContext<TContext extends Context = Context> = Omit<TContext, "config" | "tsconfig" | "entry" | "fs" | "compiler" | "unimport"> & Partial<TContext> & {
   config: TContext["config"];
 };
@@ -17,11 +95,18 @@ declare function loadWorkspaceConfig(cwd: string, root: string): Promise<Workspa
 /**
  * Loads the user configuration file for the project.
  *
- * @param options - The engine options containing the root, cwd, mode, framework, and organization.
- * @param jiti - An instance of Jiti to resolve modules from
+ * @remarks
+ * This function will attempt to locate and load the user configuration file for the project based on the provided parameters. It will look for configuration files in various formats (e.g., `.ts`, `.js`, `.mts`, `.mjs`) and with different naming conventions (e.g., `powerlines.config.ts`, `powerlines.development.config.js`, etc.) in the project root and current working directory. If a configuration file is found, it will be loaded using a Jiti resolver, and the resulting configuration object will be returned. If no configuration file is found, an empty configuration object will be returned.
+ *
+ * @param cwd - The current working directory to start searching from.
+ * @param root - The root directory of the project.
+ * @param mode - The mode to determine which configuration file to load (e.g., "development", "test", "production").
+ * @param command - The command being executed (e.g., "build", "dev", "test"), which can be used to further customize the configuration loading logic if needed.
+ * @param framework - The name of the framework to use when looking for configuration files (default is "powerlines").
+ * @param configFile - An explicit path to a configuration file to load (optional). If provided, this file will be loaded instead of searching for configuration files based on the mode and framework.
  * @returns A promise that resolves to the resolved user configuration.
  */
-declare function loadUserConfigFile(options: ResolvedEngineOptions, jiti: Jiti): Promise<ParsedUserConfig>;
+declare function loadUserConfigFile(cwd: string, root: string, mode: Mode, command: string, framework?: PartialKeys<FrameworkOptions, "orgId">, configFile?: string): Promise<ParsedUserConfig>;
 /**
  * A type helper to make it easier to use `powerlines.config.ts` files.
  *
@@ -29,7 +114,8 @@ declare function loadUserConfigFile(options: ResolvedEngineOptions, jiti: Jiti):
  * The function accepts a direct {@link AnyUserConfig} object/function and returns it typed as a {@link UserConfig} object.
  */
 declare function defineConfig(config: AnyUserConfig): UserConfig;
+declare type __ΩResolvePackageConfigsResult = any[];
 declare type __ΩPartiallyResolvedContext = any[];
 //#endregion
-export { PartiallyResolvedContext, __ΩPartiallyResolvedContext, defineConfig, loadUserConfigFile, loadWorkspaceConfig };
+export { PartiallyResolvedContext, ResolvePackageConfigsResult, __ΩPartiallyResolvedContext, __ΩResolvePackageConfigsResult, defineConfig, getDefaultLogLevel, getDefaultMode, loadParsedConfig, loadUserConfigFile, loadWorkspaceConfig, normalizeBasePath, resolvePackageConfigs, resolveRoot, tryResolveWorkspaceConfig };
 //# sourceMappingURL=config.d.cts.map

package/dist/lib/config.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.cts","names":[],"sources":["../../src/lib/config.ts"],"mappings":";;;;;KAsCY,wBAAA,kBAA0C,OAAA,GAAU,OAAA,IAAW,IAAA,CACzE,QAAA,sEAGA,OAAA,CAAQ,QAAA;EACN,MAAA,EAAQ,QAAA;AAAA;;;;;;;;iBAUU,mBAAA,CACpB,GAAA,UACA,IAAA,WACC,OAAA,CAAQ,eAAA;;;;;;;;iBAoBW,kBAAA,CACpB,OAAA,EAAS,qBAAA,EACT,IAAA,EAAM,IAAA,GACL,OAAA,CAAQ,gBAAA;;;;;;AA1BX;iBAkMgB,YAAA,CAAa,MAAA,EAAQ,aAAA,GAAgB,UAAA;AAAA"}
+{"version":3,"file":"config.d.cts","names":[],"sources":["../../src/lib/config.ts"],"mappings":";;;;;;;iBAyDgB,iBAAA,CAAkB,IAAA;AAAA,UAMjB,2BAAA;EANgB;;;EAU/B,WAAA,GAAc,WAAA;EAJC;;;EASf,WAAA,GAAc,MAAA;AAAA;;;;;;AAahB;;;;;iBAAsB,qBAAA,CACpB,GAAA,UACA,IAAA,WACC,OAAA,CAAQ,2BAAA;;;;;AA+BX;;;;iBAAgB,WAAA,CACd,GAAA,UACA,IAAA,WACA,UAAA;;;;;AAmCF;;;iBAAsB,yBAAA,CACpB,GAAA,UACA,IAAA,YACC,OAAA,CAAQ,eAAA;;;;;;;AAiBX;;;;iBAAsB,cAAA,CACpB,GAAA,UACA,IAAA,YACC,OAAA,CAAQ,IAAA;;;;;;AAsBX;;;;;iBAAsB,kBAAA,CACpB,GAAA,UACA,IAAA,YACC,OAAA,CAAQ,sBAAA;;;;;AAgCX;;;;;;;;;;iBAAsB,gBAAA,CACpB,GAAA,UACA,IAAA,UACA,SAAA,UACA,KAAA,UACA,YAAA,EAAc,YAAA,GAAY,OAAA,CAAA,gBAAA;AAAA,KAwBhB,wBAAA,kBAA0C,OAAA,GAAU,OAAA,IAAW,IAAA,CACzE,QAAA,sEAGA,OAAA,CAAQ,QAAA;EACN,MAAA,EAAQ,QAAA;AAAA;;;;;AALZ;;;iBAesB,mBAAA,CACpB,GAAA,UACA,IAAA,WACC,OAAA,CAAQ,eAAA;;;;;;;;;;;;;;;iBA2BW,kBAAA,CACpB,GAAA,UACA,IAAA,UACA,IAAA,EAAM,IAAA,EACN,OAAA,UACA,SAAA,GAAY,WAAA,CAAY,gBAAA,YACxB,UAAA,YACC,OAAA,CAAQ,gBAAA;;;;;AArCX;;iBA+LgB,YAAA,CAAa,MAAA,EAAQ,aAAA,GAAgB,UAAA;AAAA"}

package/dist/lib/config.d.mts

@@ -1,8 +1,86 @@
+import { LogLevelResolvedConfig } from "../types/logging.mjs";
 import { Context } from "../types/context.mjs";
-import { AnyUserConfig, ParsedUserConfig, ResolvedEngineOptions, UserConfig, WorkspaceConfig } from "../types/config.mjs";
-import { Jiti } from "jiti";
+import { AnyUserConfig, FrameworkOptions, InlineConfig, Mode, ParsedUserConfig, UserConfig, WorkspaceConfig } from "../types/config.mjs";
+import { PartialKeys } from "@stryke/types/base";
+import { PackageJson } from "@stryke/types/package-json";
 
 //#region src/lib/config.d.ts
+declare function normalizeBasePath(base?: string): string;
+interface ResolvePackageConfigsResult {
+  /**
+   * The parsed `package.json` file for the project, if it exists. This file typically contains metadata about the project, such as its name, version, dependencies, and other information relevant to the build process.
+   */
+  packageJson?: PackageJson;
+  /**
+   * The parsed `project.json` file for the project, if it exists. This file is an optional configuration file that can be used to store additional configuration or metadata specific to the project, and is not required for all projects.
+   */
+  projectJson?: Record<string, unknown>;
+}
+/**
+ * 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.
+ */
+declare function resolvePackageConfigs(cwd: string, root: string): Promise<ResolvePackageConfigsResult>;
+/**
+ * Resolve the root directory for the project based on the provided options. This function will determine the root directory by checking the provided `root` option, and if it is not provided, it will look for a configuration file (such as `powerlines.config.ts`) in the current working directory. If a configuration file is found, the root directory will be set to the directory containing that file. If no configuration file is found, the root directory will default to the current working directory.
+ *
+ * @param cwd - The current working directory to use as the base for resolving the root directory. This is typically the directory from which the Powerlines process was executed.
+ * @param root - An optional root directory to use for the project. If provided, this will be used as the root directory instead of looking for a configuration file. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+ * @param configFile - An optional path to a configuration file to look for when resolving the root directory. If provided, this file will be used to determine the root directory if the `root` option is not provided. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+ * @returns The resolved root directory for the project, which will be used as the base for resolving other paths and configurations throughout the Powerlines process. This will typically be an absolute path to the root directory of the project.
+ */
+declare function resolveRoot(cwd: string, root?: string, configFile?: string): string;
+/**
+ * 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.
+ *
+ * @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+ * @param root - An optional root directory to use as the base for searching for the configuration file. If provided, this will be used as the starting point for searching for the configuration file instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+ * @returns A promise that resolves to the workspace configuration object, or undefined if no configuration file is found.
+ */
+declare function tryResolveWorkspaceConfig(cwd: string, root?: string): Promise<WorkspaceConfig | undefined>;
+/**
+ * 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".
+ *
+ * @remarks
+ * The mode is used to determine which configuration file to load (e.g., `powerlines.development.config.js` for development mode, `powerlines.production.config.js` for production mode, etc.) and can also be used by plugins and other parts of the build process to conditionally apply certain behaviors based on the current mode.
+ *
+ * @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+ * @param root - An optional root directory to use as the base for searching for the workspace configuration. If provided, this will be used as the starting point for searching for the workspace configuration instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+ * @returns A promise that resolves to the default mode for the current execution, which can be "development", "production", or "test".
+ */
+declare function getDefaultMode(cwd: string, root?: string): Promise<Mode>;
+/**
+ * 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.
+ *
+ * @remarks
+ * The log level is used to determine which log messages should be output during the execution of the Powerlines process. For example, if the log level is set to "warn", only messages with a level of "warn", "error", or "fatal" will be output, while messages with a level of "info", "debug", or "trace" will be suppressed. This allows users to control the verbosity of the logs and focus on the most relevant information based on their current needs.
+ *
+ * @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+ * @param root - An optional root directory to use as the base for searching for the workspace configuration. If provided, this will be used as the starting point for searching for the workspace configuration instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+ * @returns A promise that resolves to the default log level for the current execution, which can be "fatal", "error", "warn", "info", "debug", or "trace".
+ */
+declare function getDefaultLogLevel(cwd: string, root?: string): Promise<LogLevelResolvedConfig>;
+/**
+ * Load the user configuration file for the project and set up the context with the loaded configuration. This function will be called during the initialization of the context to load the user configuration file based on the provided options and set up the context accordingly. It will also set up the resolver for loading modules from the user configuration file and ensure that the context is properly initialized with the loaded configuration.
+ *
+ * @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 cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+ * @param root - The root directory of the project to look for the configuration file. This is typically the root directory of the project, which may be different from the current working directory if the process was executed from a subdirectory.
+ * @param framework - The name of the framework to use when looking for configuration files (default is "powerlines"). This is used to determine the naming convention for the configuration files to look for (e.g., `powerlines.development.config.js` for the "powerlines" framework in development mode).
+ * @param orgId - The name of the organization to use when looking for configuration files (optional). This can be used to further customize the naming convention for the configuration files to look for (e.g., `powerlines.myorg.development.config.js` for the "powerlines" framework in development mode with an organization of "myorg").
+ * @param inlineConfig - The inline configuration options provided during the execution of a Powerlines command, which can include properties such as the project root, mode, and an explicit path to a configuration file. This is used to determine how the context should be initialized and which configuration file should be loaded for the execution.
+ * @returns A promise that resolves when the context has been successfully initialized with the loaded configuration and resolver setup.
+ * @throws Will throw an error if no configuration file is found in the project root or current working directory. This ensures that the context cannot be initialized without a valid configuration, which is essential for the proper functioning of the Powerlines process.
+ */
+declare function loadParsedConfig(cwd: string, root: string, framework: string, orgId: string, inlineConfig: InlineConfig): Promise<ParsedUserConfig>;
 type PartiallyResolvedContext<TContext extends Context = Context> = Omit<TContext, "config" | "tsconfig" | "entry" | "fs" | "compiler" | "unimport"> & Partial<TContext> & {
   config: TContext["config"];
 };
@@ -17,11 +95,18 @@ declare function loadWorkspaceConfig(cwd: string, root: string): Promise<Workspa
 /**
  * Loads the user configuration file for the project.
  *
- * @param options - The engine options containing the root, cwd, mode, framework, and organization.
- * @param jiti - An instance of Jiti to resolve modules from
+ * @remarks
+ * This function will attempt to locate and load the user configuration file for the project based on the provided parameters. It will look for configuration files in various formats (e.g., `.ts`, `.js`, `.mts`, `.mjs`) and with different naming conventions (e.g., `powerlines.config.ts`, `powerlines.development.config.js`, etc.) in the project root and current working directory. If a configuration file is found, it will be loaded using a Jiti resolver, and the resulting configuration object will be returned. If no configuration file is found, an empty configuration object will be returned.
+ *
+ * @param cwd - The current working directory to start searching from.
+ * @param root - The root directory of the project.
+ * @param mode - The mode to determine which configuration file to load (e.g., "development", "test", "production").
+ * @param command - The command being executed (e.g., "build", "dev", "test"), which can be used to further customize the configuration loading logic if needed.
+ * @param framework - The name of the framework to use when looking for configuration files (default is "powerlines").
+ * @param configFile - An explicit path to a configuration file to load (optional). If provided, this file will be loaded instead of searching for configuration files based on the mode and framework.
  * @returns A promise that resolves to the resolved user configuration.
  */
-declare function loadUserConfigFile(options: ResolvedEngineOptions, jiti: Jiti): Promise<ParsedUserConfig>;
+declare function loadUserConfigFile(cwd: string, root: string, mode: Mode, command: string, framework?: PartialKeys<FrameworkOptions, "orgId">, configFile?: string): Promise<ParsedUserConfig>;
 /**
  * A type helper to make it easier to use `powerlines.config.ts` files.
  *
@@ -29,7 +114,8 @@ declare function loadUserConfigFile(options: ResolvedEngineOptions, jiti: Jiti):
  * The function accepts a direct {@link AnyUserConfig} object/function and returns it typed as a {@link UserConfig} object.
  */
 declare function defineConfig(config: AnyUserConfig): UserConfig;
+declare type __ΩResolvePackageConfigsResult = any[];
 declare type __ΩPartiallyResolvedContext = any[];
 //#endregion
-export { PartiallyResolvedContext, __ΩPartiallyResolvedContext, defineConfig, loadUserConfigFile, loadWorkspaceConfig };
+export { PartiallyResolvedContext, ResolvePackageConfigsResult, __ΩPartiallyResolvedContext, __ΩResolvePackageConfigsResult, defineConfig, getDefaultLogLevel, getDefaultMode, loadParsedConfig, loadUserConfigFile, loadWorkspaceConfig, normalizeBasePath, resolvePackageConfigs, resolveRoot, tryResolveWorkspaceConfig };
 //# sourceMappingURL=config.d.mts.map

package/dist/lib/config.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.mts","names":[],"sources":["../../src/lib/config.ts"],"mappings":";;;;;KAsCY,wBAAA,kBAA0C,OAAA,GAAU,OAAA,IAAW,IAAA,CACzE,QAAA,sEAGA,OAAA,CAAQ,QAAA;EACN,MAAA,EAAQ,QAAA;AAAA;;;;;;;;iBAUU,mBAAA,CACpB,GAAA,UACA,IAAA,WACC,OAAA,CAAQ,eAAA;;;;;;;;iBAoBW,kBAAA,CACpB,OAAA,EAAS,qBAAA,EACT,IAAA,EAAM,IAAA,GACL,OAAA,CAAQ,gBAAA;;;;;;AA1BX;iBAkMgB,YAAA,CAAa,MAAA,EAAQ,aAAA,GAAgB,UAAA;AAAA"}
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../src/lib/config.ts"],"mappings":";;;;;;;iBAyDgB,iBAAA,CAAkB,IAAA;AAAA,UAMjB,2BAAA;EANgB;;;EAU/B,WAAA,GAAc,WAAA;EAJC;;;EASf,WAAA,GAAc,MAAA;AAAA;;;;;;AAahB;;;;;iBAAsB,qBAAA,CACpB,GAAA,UACA,IAAA,WACC,OAAA,CAAQ,2BAAA;;;;;AA+BX;;;;iBAAgB,WAAA,CACd,GAAA,UACA,IAAA,WACA,UAAA;;;;;AAmCF;;;iBAAsB,yBAAA,CACpB,GAAA,UACA,IAAA,YACC,OAAA,CAAQ,eAAA;;;;;;;AAiBX;;;;iBAAsB,cAAA,CACpB,GAAA,UACA,IAAA,YACC,OAAA,CAAQ,IAAA;;;;;;AAsBX;;;;;iBAAsB,kBAAA,CACpB,GAAA,UACA,IAAA,YACC,OAAA,CAAQ,sBAAA;;;;;AAgCX;;;;;;;;;;iBAAsB,gBAAA,CACpB,GAAA,UACA,IAAA,UACA,SAAA,UACA,KAAA,UACA,YAAA,EAAc,YAAA,GAAY,OAAA,CAAA,gBAAA;AAAA,KAwBhB,wBAAA,kBAA0C,OAAA,GAAU,OAAA,IAAW,IAAA,CACzE,QAAA,sEAGA,OAAA,CAAQ,QAAA;EACN,MAAA,EAAQ,QAAA;AAAA;;;;;AALZ;;;iBAesB,mBAAA,CACpB,GAAA,UACA,IAAA,WACC,OAAA,CAAQ,eAAA;;;;;;;;;;;;;;;iBA2BW,kBAAA,CACpB,GAAA,UACA,IAAA,UACA,IAAA,EAAM,IAAA,EACN,OAAA,UACA,SAAA,GAAY,WAAA,CAAY,gBAAA,YACxB,UAAA,YACC,OAAA,CAAQ,gBAAA;;;;;AArCX;;iBA+LgB,YAAA,CAAa,MAAA,EAAQ,aAAA,GAAgB,UAAA;AAAA"}

package/dist/lib/config.mjs

@@ -1,15 +1,130 @@
-import { getWorkspaceConfig } from "@storm-software/config-tools/get-config";
+import { resolveLogLevel } from "../plugin-utils/logging.mjs";
+import { createResolver } from "./resolver.mjs";
+import { getWorkspaceConfig, tryGetWorkspaceConfig } from "@storm-software/config-tools/get-config";
+import { isDevelopment, isProduction, isTest } from "@stryke/env/environment-checks";
+import { getEnvPaths } from "@stryke/env/get-env-paths";
 import { existsSync } from "@stryke/fs/exists";
+import { isFile } from "@stryke/fs/is-file";
+import { readJsonFile } from "@stryke/fs/json";
 import { appendPath } from "@stryke/path/append";
+import { findFilePath, relativePath } from "@stryke/path/file-path-fns";
 import { joinPaths } from "@stryke/path/join-paths";
 import { replacePath } from "@stryke/path/replace";
 import { camelCase } from "@stryke/string-format/camel-case";
+import { kebabCase } from "@stryke/string-format/kebab-case";
 import { isFunction } from "@stryke/type-checks/is-function";
 import { isSetObject } from "@stryke/type-checks/is-set-object";
 import { loadConfig } from "c12";
 import defu from "defu";
 
 //#region src/lib/config.ts
+function normalizeBasePath(base = "/") {
+	let out = base.startsWith("/") ? base : `/${base}`;
+	if (!out.endsWith("/")) out = `${out}/`;
+	return out.replace(/\/+/g, "/");
+}
+/**
+* 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 function resolvePackageConfigs(cwd, root) {
+	const result = {};
+	if (cwd || root) {
+		const projectJsonPath = joinPaths(appendPath(root || ".", cwd || "."), "project.json");
+		if (existsSync(projectJsonPath)) result.projectJson = await readJsonFile(projectJsonPath);
+		const packageJsonPath = joinPaths(appendPath(root || ".", cwd || "."), "package.json");
+		if (existsSync(packageJsonPath)) result.packageJson = await readJsonFile(packageJsonPath);
+	}
+	return result;
+}
+/**
+* Resolve the root directory for the project based on the provided options. This function will determine the root directory by checking the provided `root` option, and if it is not provided, it will look for a configuration file (such as `powerlines.config.ts`) in the current working directory. If a configuration file is found, the root directory will be set to the directory containing that file. If no configuration file is found, the root directory will default to the current working directory.
+*
+* @param cwd - The current working directory to use as the base for resolving the root directory. This is typically the directory from which the Powerlines process was executed.
+* @param root - An optional root directory to use for the project. If provided, this will be used as the root directory instead of looking for a configuration file. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+* @param configFile - An optional path to a configuration file to look for when resolving the root directory. If provided, this file will be used to determine the root directory if the `root` option is not provided. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+* @returns The resolved root directory for the project, which will be used as the base for resolving other paths and configurations throughout the Powerlines process. This will typically be an absolute path to the root directory of the project.
+*/
+function resolveRoot(cwd, root, configFile) {
+	let result = root || ".";
+	if (!root) {
+		if (configFile) {
+			if (!existsSync(appendPath(configFile, cwd))) throw new Error(`The user-provided configuration file at "${configFile}" does not exist. Please ensure this path is correct and try again.`);
+			if (!isFile(configFile)) throw new Error(`The user-provided configuration file at "${configFile}" is not a file. Please ensure this path is correct and try again.`);
+			result = relativePath(cwd, findFilePath(configFile));
+		}
+	} else result = replacePath(root, cwd);
+	return result;
+}
+/**
+* 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.
+*
+* @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+* @param root - An optional root directory to use as the base for searching for the configuration file. If provided, this will be used as the starting point for searching for the configuration file instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+* @returns A promise that resolves to the workspace configuration object, or undefined if no configuration file is found.
+*/
+async function tryResolveWorkspaceConfig(cwd, root) {
+	return tryGetWorkspaceConfig(false, {
+		cwd: root ? appendPath(root, cwd) : void 0,
+		workspaceRoot: cwd
+	});
+}
+/**
+* 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".
+*
+* @remarks
+* The mode is used to determine which configuration file to load (e.g., `powerlines.development.config.js` for development mode, `powerlines.production.config.js` for production mode, etc.) and can also be used by plugins and other parts of the build process to conditionally apply certain behaviors based on the current mode.
+*
+* @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+* @param root - An optional root directory to use as the base for searching for the workspace configuration. If provided, this will be used as the starting point for searching for the workspace configuration instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+* @returns A promise that resolves to the default mode for the current execution, which can be "development", "production", or "test".
+*/
+async function getDefaultMode(cwd, root) {
+	const workspaceConfig = await tryResolveWorkspaceConfig(cwd, root);
+	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.
+*
+* @remarks
+* The log level is used to determine which log messages should be output during the execution of the Powerlines process. For example, if the log level is set to "warn", only messages with a level of "warn", "error", or "fatal" will be output, while messages with a level of "info", "debug", or "trace" will be suppressed. This allows users to control the verbosity of the logs and focus on the most relevant information based on their current needs.
+*
+* @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+* @param root - An optional root directory to use as the base for searching for the workspace configuration. If provided, this will be used as the starting point for searching for the workspace configuration instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.
+* @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 function getDefaultLogLevel(cwd, root) {
+	const workspaceConfig = await tryResolveWorkspaceConfig(cwd, root);
+	return resolveLogLevel(workspaceConfig?.logLevel ? workspaceConfig.logLevel === "success" || workspaceConfig.logLevel === "performance" ? "info" : workspaceConfig.logLevel === "all" ? "debug" : workspaceConfig.logLevel === "fatal" ? "error" : workspaceConfig.logLevel : void 0, workspaceConfig?.mode || await getDefaultMode(cwd, root));
+}
+/**
+* Load the user configuration file for the project and set up the context with the loaded configuration. This function will be called during the initialization of the context to load the user configuration file based on the provided options and set up the context accordingly. It will also set up the resolver for loading modules from the user configuration file and ensure that the context is properly initialized with the loaded configuration.
+*
+* @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 cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.
+* @param root - The root directory of the project to look for the configuration file. This is typically the root directory of the project, which may be different from the current working directory if the process was executed from a subdirectory.
+* @param framework - The name of the framework to use when looking for configuration files (default is "powerlines"). This is used to determine the naming convention for the configuration files to look for (e.g., `powerlines.development.config.js` for the "powerlines" framework in development mode).
+* @param orgId - The name of the organization to use when looking for configuration files (optional). This can be used to further customize the naming convention for the configuration files to look for (e.g., `powerlines.myorg.development.config.js` for the "powerlines" framework in development mode with an organization of "myorg").
+* @param inlineConfig - The inline configuration options provided during the execution of a Powerlines command, which can include properties such as the project root, mode, and an explicit path to a configuration file. This is used to determine how the context should be initialized and which configuration file should be loaded for the execution.
+* @returns A promise that resolves when the context has been successfully initialized with the loaded configuration and resolver setup.
+* @throws Will throw an error if no configuration file is found in the project root or current working directory. This ensures that the context cannot be initialized without a valid configuration, which is essential for the proper functioning of the Powerlines process.
+*/
+async function loadParsedConfig(cwd, root, framework, orgId, inlineConfig) {
+	const configFile = await loadUserConfigFile(cwd, root, inlineConfig.mode || await getDefaultMode(cwd, root), inlineConfig.command, {
+		name: framework,
+		orgId
+	}, inlineConfig.configFile);
+	if (!configFile) throw new Error(`No configuration file found in ${appendPath(root, cwd)}. Please ensure you have a valid configuration file in your project.`);
+	return configFile;
+}
 /**
 * Loads the workspace configuration.
 *
@@ -27,20 +142,44 @@ async function loadWorkspaceConfig(cwd, root) {
 /**
 * Loads the user configuration file for the project.
 *
-* @param options - The engine options containing the root, cwd, mode, framework, and organization.
-* @param jiti - An instance of Jiti to resolve modules from
+* @remarks
+* This function will attempt to locate and load the user configuration file for the project based on the provided parameters. It will look for configuration files in various formats (e.g., `.ts`, `.js`, `.mts`, `.mjs`) and with different naming conventions (e.g., `powerlines.config.ts`, `powerlines.development.config.js`, etc.) in the project root and current working directory. If a configuration file is found, it will be loaded using a Jiti resolver, and the resulting configuration object will be returned. If no configuration file is found, an empty configuration object will be returned.
+*
+* @param cwd - The current working directory to start searching from.
+* @param root - The root directory of the project.
+* @param mode - The mode to determine which configuration file to load (e.g., "development", "test", "production").
+* @param command - The command being executed (e.g., "build", "dev", "test"), which can be used to further customize the configuration loading logic if needed.
+* @param framework - The name of the framework to use when looking for configuration files (default is "powerlines").
+* @param configFile - An explicit path to a configuration file to load (optional). If provided, this file will be loaded instead of searching for configuration files based on the mode and framework.
 * @returns A promise that resolves to the resolved user configuration.
 */
-async function loadUserConfigFile(options, jiti) {
+async function loadUserConfigFile(cwd, root, mode, command, framework, configFile) {
+	const frameworkName = kebabCase(framework?.name || "powerlines");
+	const frameworkOrgId = kebabCase(framework?.orgId || "storm-software");
 	let resolvedUserConfig = {};
 	let resolvedUserConfigFile;
-	if (options.configFile) resolvedUserConfigFile = existsSync(replacePath(options.configFile, options.root)) ? replacePath(options.configFile, options.root) : existsSync(joinPaths(appendPath(options.root, options.cwd), replacePath(options.configFile, options.root))) ? joinPaths(appendPath(options.root, options.cwd), replacePath(options.configFile, options.root)) : existsSync(joinPaths(appendPath(options.root, options.cwd), options.configFile)) ? joinPaths(appendPath(options.root, options.cwd), options.configFile) : void 0;
-	if (!resolvedUserConfigFile) resolvedUserConfigFile = existsSync(joinPaths(appendPath(options.root, options.cwd), `${options.framework}.${options.mode}.config.ts`)) ? joinPaths(appendPath(options.root, options.cwd), `${options.framework}.${options.mode}.config.ts`) : existsSync(joinPaths(appendPath(options.root, options.cwd), `${options.framework}.${options.mode}.config.js`)) ? joinPaths(appendPath(options.root, options.cwd), `${options.framework}.${options.mode}.config.js`) : existsSync(joinPaths(appendPath(options.root, options.cwd), `${options.framework}.${options.mode}.config.mts`)) ? joinPaths(appendPath(options.root, options.cwd), `${options.framework}.${options.mode}.config.mts`) : existsSync(joinPaths(appendPath(options.root, options.cwd), `${options.framework}.${options.mode}.config.mjs`)) ? joinPaths(appendPath(options.root, options.cwd), `${options.framework}.${options.mode}.config.mjs`) : existsSync(joinPaths(appendPath(options.root, options.cwd), `${options.framework}.config.ts`)) ? joinPaths(appendPath(options.root, options.cwd), `${options.framework}.config.ts`) : existsSync(joinPaths(appendPath(options.root, options.cwd), `${options.framework}.config.js`)) ? joinPaths(appendPath(options.root, options.cwd), `${options.framework}.config.js`) : existsSync(joinPaths(appendPath(options.root, options.cwd), `${options.framework}.config.mts`)) ? joinPaths(appendPath(options.root, options.cwd), `${options.framework}.config.mts`) : existsSync(joinPaths(appendPath(options.root, options.cwd), `${options.framework}.config.mjs`)) ? joinPaths(appendPath(options.root, options.cwd), `${options.framework}.config.mjs`) : void 0;
+	if (configFile) resolvedUserConfigFile = existsSync(replacePath(configFile, root)) ? replacePath(configFile, root) : existsSync(joinPaths(appendPath(root, cwd), replacePath(configFile, root))) ? joinPaths(appendPath(root, cwd), replacePath(configFile, root)) : existsSync(joinPaths(appendPath(root, cwd), configFile)) ? joinPaths(appendPath(root, cwd), configFile) : void 0;
+	if (!resolvedUserConfigFile) resolvedUserConfigFile = existsSync(joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.ts`)) ? joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.ts`) : existsSync(joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.js`)) ? joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.js`) : existsSync(joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.mts`)) ? joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.mts`) : existsSync(joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.mjs`)) ? joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.mjs`) : existsSync(joinPaths(appendPath(root, cwd), `${frameworkName}.config.ts`)) ? joinPaths(appendPath(root, cwd), `${frameworkName}.config.ts`) : existsSync(joinPaths(appendPath(root, cwd), `${frameworkName}.config.js`)) ? joinPaths(appendPath(root, cwd), `${frameworkName}.config.js`) : existsSync(joinPaths(appendPath(root, cwd), `${frameworkName}.config.mts`)) ? joinPaths(appendPath(root, cwd), `${frameworkName}.config.mts`) : existsSync(joinPaths(appendPath(root, cwd), `${frameworkName}.config.mjs`)) ? joinPaths(appendPath(root, cwd), `${frameworkName}.config.mjs`) : void 0;
+	const jiti = createResolver({
+		cwd,
+		root,
+		cacheDir: getEnvPaths({
+			orgId: frameworkOrgId,
+			appId: frameworkName,
+			workspaceRoot: cwd
+		}).cache,
+		mode
+	});
 	if (resolvedUserConfigFile) {
 		const resolved = await jiti.import(jiti.esmResolve(resolvedUserConfigFile));
 		if (resolved?.default) {
 			let config = {};
-			if (isFunction(resolved.default)) config = await Promise.resolve(resolved.default(options));
+			if (isFunction(resolved.default)) config = await Promise.resolve(resolved.default({
+				root,
+				cwd,
+				mode,
+				command
+			}));
 			else if (isSetObject(resolved.default) || Array.isArray(resolved.default)) config = resolved.default;
 			if (isSetObject(config) || Array.isArray(config)) resolvedUserConfig = {
 				...config,
@@ -50,19 +189,18 @@ async function loadUserConfigFile(options, jiti) {
 		}
 	}
 	const result = await loadConfig({
-		cwd: options.root,
-		name: options.framework,
-		envName: options.mode,
+		cwd: root,
+		name: frameworkName,
+		envName: mode,
 		globalRc: true,
-		packageJson: camelCase(options.framework),
+		packageJson: camelCase(frameworkName),
 		dotenv: true,
 		jiti
 	});
 	return defu({ config: {
-		root: options.root,
-		cwd: options.cwd,
-		framework: options.framework,
-		organization: options.organization
+		root,
+		cwd,
+		framework
 	} }, resolvedUserConfig, isSetObject(result?.config) ? {
 		...result.config,
 		...result
@@ -79,5 +217,5 @@ function defineConfig(config) {
 }
 
 //#endregion
-export { defineConfig, loadUserConfigFile, loadWorkspaceConfig };
+export { defineConfig, getDefaultLogLevel, getDefaultMode, loadParsedConfig, loadUserConfigFile, loadWorkspaceConfig, normalizeBasePath, resolvePackageConfigs, resolveRoot, tryResolveWorkspaceConfig };
 //# sourceMappingURL=config.mjs.map

package/dist/lib/config.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"config.mjs","names":["loadConfigC12"],"sources":["../../src/lib/config.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { getWorkspaceConfig } from \"@storm-software/config-tools/get-config\";\nimport { existsSync } from \"@stryke/fs/exists\";\nimport { appendPath } from \"@stryke/path/append\";\nimport { joinPaths } from \"@stryke/path/join-paths\";\nimport { replacePath } from \"@stryke/path/replace\";\nimport { camelCase } from \"@stryke/string-format/camel-case\";\nimport { isFunction } from \"@stryke/type-checks/is-function\";\nimport { isSetObject } from \"@stryke/type-checks/is-set-object\";\nimport { loadConfig as loadConfigC12 } from \"c12\";\nimport defu from \"defu\";\nimport type { Jiti } from \"jiti\";\nimport type {\n  ParsedUserConfig,\n  ResolvedEngineOptions,\n  UserConfig,\n  WorkspaceConfig\n} from \"../types/config\";\nimport { AnyUserConfig } from \"../types/config\";\nimport { Context } from \"../types/context\";\n\nexport type PartiallyResolvedContext<TContext extends Context = Context> = Omit<\n  TContext,\n  \"config\" | \"tsconfig\" | \"entry\" | \"fs\" | \"compiler\" | \"unimport\"\n> &\n  Partial<TContext> & {\n    config: TContext[\"config\"];\n  };\n\n/**\n * Loads the workspace configuration.\n *\n * @param cwd - The root directory of the workspace.\n * @param root - The current working directory to start searching from.\n * @returns A promise that resolves to the loaded workspace configuration.\n */\nexport async function loadWorkspaceConfig(\n  cwd: string,\n  root: string\n): Promise<WorkspaceConfig> {\n  return defu(\n    {\n      workspaceRoot: cwd\n    },\n    await getWorkspaceConfig(true, {\n      cwd: root,\n      workspaceRoot: cwd,\n      useDefault: true\n    })\n  );\n}\n\n/**\n * Loads the user configuration file for the project.\n *\n * @param options - The engine options containing the root, cwd, mode, framework, and organization.\n * @param jiti - An instance of Jiti to resolve modules from\n * @returns A promise that resolves to the resolved user configuration.\n */\nexport async function loadUserConfigFile(\n  options: ResolvedEngineOptions,\n  jiti: Jiti\n): Promise<ParsedUserConfig> {\n  let resolvedUserConfig: Partial<ParsedUserConfig> = {};\n\n  let resolvedUserConfigFile: string | undefined;\n  if (options.configFile) {\n    resolvedUserConfigFile = existsSync(\n      replacePath(options.configFile, options.root)\n    )\n      ? replacePath(options.configFile, options.root)\n      : existsSync(\n            joinPaths(\n              appendPath(options.root, options.cwd),\n              replacePath(options.configFile, options.root)\n            )\n          )\n        ? joinPaths(\n            appendPath(options.root, options.cwd),\n            replacePath(options.configFile, options.root)\n          )\n        : existsSync(\n              joinPaths(\n                appendPath(options.root, options.cwd),\n                options.configFile\n              )\n            )\n          ? joinPaths(appendPath(options.root, options.cwd), options.configFile)\n          : undefined;\n  }\n\n  if (!resolvedUserConfigFile) {\n    resolvedUserConfigFile = existsSync(\n      joinPaths(\n        appendPath(options.root, options.cwd),\n        `${options.framework}.${options.mode}.config.ts`\n      )\n    )\n      ? joinPaths(\n          appendPath(options.root, options.cwd),\n          `${options.framework}.${options.mode}.config.ts`\n        )\n      : existsSync(\n            joinPaths(\n              appendPath(options.root, options.cwd),\n              `${options.framework}.${options.mode}.config.js`\n            )\n          )\n        ? joinPaths(\n            appendPath(options.root, options.cwd),\n            `${options.framework}.${options.mode}.config.js`\n          )\n        : existsSync(\n              joinPaths(\n                appendPath(options.root, options.cwd),\n                `${options.framework}.${options.mode}.config.mts`\n              )\n            )\n          ? joinPaths(\n              appendPath(options.root, options.cwd),\n              `${options.framework}.${options.mode}.config.mts`\n            )\n          : existsSync(\n                joinPaths(\n                  appendPath(options.root, options.cwd),\n                  `${options.framework}.${options.mode}.config.mjs`\n                )\n              )\n            ? joinPaths(\n                appendPath(options.root, options.cwd),\n                `${options.framework}.${options.mode}.config.mjs`\n              )\n            : existsSync(\n                  joinPaths(\n                    appendPath(options.root, options.cwd),\n                    `${options.framework}.config.ts`\n                  )\n                )\n              ? joinPaths(\n                  appendPath(options.root, options.cwd),\n                  `${options.framework}.config.ts`\n                )\n              : existsSync(\n                    joinPaths(\n                      appendPath(options.root, options.cwd),\n                      `${options.framework}.config.js`\n                    )\n                  )\n                ? joinPaths(\n                    appendPath(options.root, options.cwd),\n                    `${options.framework}.config.js`\n                  )\n                : existsSync(\n                      joinPaths(\n                        appendPath(options.root, options.cwd),\n                        `${options.framework}.config.mts`\n                      )\n                    )\n                  ? joinPaths(\n                      appendPath(options.root, options.cwd),\n                      `${options.framework}.config.mts`\n                    )\n                  : existsSync(\n                        joinPaths(\n                          appendPath(options.root, options.cwd),\n                          `${options.framework}.config.mjs`\n                        )\n                      )\n                    ? joinPaths(\n                        appendPath(options.root, options.cwd),\n                        `${options.framework}.config.mjs`\n                      )\n                    : undefined;\n  }\n\n  if (resolvedUserConfigFile) {\n    const resolved = await jiti.import<{ default: AnyUserConfig }>(\n      jiti.esmResolve(resolvedUserConfigFile)\n    );\n    if (resolved?.default) {\n      let config = {};\n      if (isFunction(resolved.default)) {\n        config = await Promise.resolve(resolved.default(options));\n      } else if (\n        isSetObject(resolved.default) ||\n        Array.isArray(resolved.default)\n      ) {\n        config = resolved.default;\n      }\n\n      if (isSetObject(config) || Array.isArray(config)) {\n        resolvedUserConfig = {\n          ...config,\n          config,\n          configFile: resolvedUserConfigFile\n        };\n      }\n    }\n  }\n\n  const result = await loadConfigC12({\n    cwd: options.root,\n    name: options.framework,\n    envName: options.mode,\n    globalRc: true,\n    packageJson: camelCase(options.framework),\n    dotenv: true,\n    jiti\n  });\n\n  return defu(\n    {\n      config: {\n        root: options.root,\n        cwd: options.cwd,\n        framework: options.framework,\n        organization: options.organization\n      }\n    },\n    resolvedUserConfig,\n    isSetObject(result?.config) ? { ...result.config, ...result } : {}\n  );\n}\n\n/**\n * A type helper to make it easier to use `powerlines.config.ts` files.\n *\n * @remarks\n * The function accepts a direct {@link AnyUserConfig} object/function and returns it typed as a {@link UserConfig} object.\n */\nexport function defineConfig(config: AnyUserConfig): UserConfig {\n  return config as any;\n}\n"],"mappings":"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"}
+{"version":3,"file":"config.mjs","names":["loadConfigC12"],"sources":["../../src/lib/config.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport {\n  getWorkspaceConfig,\n  tryGetWorkspaceConfig\n} from \"@storm-software/config-tools/get-config\";\nimport {\n  isDevelopment,\n  isProduction,\n  isTest\n} from \"@stryke/env/environment-checks\";\nimport { getEnvPaths } from \"@stryke/env/get-env-paths\";\nimport { existsSync } from \"@stryke/fs/exists\";\nimport { isFile } from \"@stryke/fs/is-file\";\nimport { readJsonFile } from \"@stryke/fs/json\";\nimport { appendPath } from \"@stryke/path/append\";\nimport { findFilePath, relativePath } from \"@stryke/path/file-path-fns\";\nimport { joinPaths } from \"@stryke/path/join-paths\";\nimport { replacePath } from \"@stryke/path/replace\";\nimport { camelCase } from \"@stryke/string-format/camel-case\";\nimport { kebabCase } from \"@stryke/string-format/kebab-case\";\nimport { isFunction } from \"@stryke/type-checks/is-function\";\nimport { isSetObject } from \"@stryke/type-checks/is-set-object\";\nimport { PartialKeys } from \"@stryke/types/base\";\nimport { PackageJson } from \"@stryke/types/package-json\";\nimport { loadConfig as loadConfigC12 } from \"c12\";\nimport defu from \"defu\";\nimport { resolveLogLevel } from \"../plugin-utils/logging\";\nimport type {\n  FrameworkOptions,\n  InlineConfig,\n  Mode,\n  ParsedUserConfig,\n  UserConfig,\n  WorkspaceConfig\n} from \"../types/config\";\nimport { AnyUserConfig } from \"../types/config\";\nimport { Context } from \"../types/context\";\nimport { LogLevelResolvedConfig } from \"../types/logging\";\nimport { createResolver } from \"./resolver\";\n\nexport function normalizeBasePath(base: string = \"/\"): string {\n  let out = base.startsWith(\"/\") ? base : `/${base}`;\n  if (!out.endsWith(\"/\")) out = `${out}/`;\n  return out.replace(/\\/+/g, \"/\");\n}\n\nexport interface ResolvePackageConfigsResult {\n  /**\n   * The parsed `package.json` file for the project, if it exists. This file typically contains metadata about the project, such as its name, version, dependencies, and other information relevant to the build process.\n   */\n  packageJson?: PackageJson;\n\n  /**\n   * The parsed `project.json` file for the project, if it exists. This file is an optional configuration file that can be used to store additional configuration or metadata specific to the project, and is not required for all projects.\n   */\n  projectJson?: Record<string, unknown>;\n}\n\n/**\n * 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.\n *\n * @remarks\n * 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.\n *\n * @param cwd - The current working directory to look for the package configurations. Defaults to the `cwd` specified in the context configuration.\n * @param root - The root directory of the project to look for the package configurations. Defaults to the `root` specified in the context configuration.\n * @returns A promise that resolves when the package configurations have been loaded and stored in the context.\n */\nexport async function resolvePackageConfigs(\n  cwd: string,\n  root: string\n): Promise<ResolvePackageConfigsResult> {\n  const result: ResolvePackageConfigsResult = {};\n  if (cwd || root) {\n    const projectJsonPath = joinPaths(\n      appendPath(root || \".\", cwd || \".\"),\n      \"project.json\"\n    );\n    if (existsSync(projectJsonPath)) {\n      result.projectJson = await readJsonFile(projectJsonPath);\n    }\n\n    const packageJsonPath = joinPaths(\n      appendPath(root || \".\", cwd || \".\"),\n      \"package.json\"\n    );\n    if (existsSync(packageJsonPath)) {\n      result.packageJson = await readJsonFile<PackageJson>(packageJsonPath);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Resolve the root directory for the project based on the provided options. This function will determine the root directory by checking the provided `root` option, and if it is not provided, it will look for a configuration file (such as `powerlines.config.ts`) in the current working directory. If a configuration file is found, the root directory will be set to the directory containing that file. If no configuration file is found, the root directory will default to the current working directory.\n *\n * @param cwd - The current working directory to use as the base for resolving the root directory. This is typically the directory from which the Powerlines process was executed.\n * @param root - An optional root directory to use for the project. If provided, this will be used as the root directory instead of looking for a configuration file. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.\n * @param configFile - An optional path to a configuration file to look for when resolving the root directory. If provided, this file will be used to determine the root directory if the `root` option is not provided. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.\n * @returns The resolved root directory for the project, which will be used as the base for resolving other paths and configurations throughout the Powerlines process. This will typically be an absolute path to the root directory of the project.\n */\nexport function resolveRoot(\n  cwd: string,\n  root?: string,\n  configFile?: string\n): string {\n  let result = root || \".\";\n  if (!root) {\n    if (configFile) {\n      const configFilePath = appendPath(configFile, cwd);\n      if (!existsSync(configFilePath)) {\n        throw new Error(\n          `The user-provided configuration file at \"${configFile}\" does not exist. Please ensure this path is correct and try again.`\n        );\n      }\n      if (!isFile(configFile)) {\n        throw new Error(\n          `The user-provided configuration file at \"${\n            configFile\n          }\" is not a file. Please ensure this path is correct and try again.`\n        );\n      }\n\n      result = relativePath(cwd, findFilePath(configFile));\n    }\n  } else {\n    result = replacePath(root, cwd);\n  }\n\n  return result;\n}\n\n/**\n * 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.\n *\n * @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.\n * @param root - An optional root directory to use as the base for searching for the configuration file. If provided, this will be used as the starting point for searching for the configuration file instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.\n * @returns A promise that resolves to the workspace configuration object, or undefined if no configuration file is found.\n */\nexport async function tryResolveWorkspaceConfig(\n  cwd: string,\n  root?: string\n): Promise<WorkspaceConfig | undefined> {\n  return tryGetWorkspaceConfig(false, {\n    cwd: root ? appendPath(root, cwd) : undefined,\n    workspaceRoot: cwd\n  });\n}\n\n/**\n * 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\".\n *\n * @remarks\n * The mode is used to determine which configuration file to load (e.g., `powerlines.development.config.js` for development mode, `powerlines.production.config.js` for production mode, etc.) and can also be used by plugins and other parts of the build process to conditionally apply certain behaviors based on the current mode.\n *\n * @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.\n * @param root - An optional root directory to use as the base for searching for the workspace configuration. If provided, this will be used as the starting point for searching for the workspace configuration instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.\n * @returns A promise that resolves to the default mode for the current execution, which can be \"development\", \"production\", or \"test\".\n */\nexport async function getDefaultMode(\n  cwd: string,\n  root?: string\n): Promise<Mode> {\n  const workspaceConfig = await tryResolveWorkspaceConfig(cwd, root);\n\n  return isProduction\n    ? \"production\"\n    : isDevelopment\n      ? \"development\"\n      : isTest\n        ? \"test\"\n        : workspaceConfig?.mode || \"production\";\n}\n\n/**\n * 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.\n *\n * @remarks\n * The log level is used to determine which log messages should be output during the execution of the Powerlines process. For example, if the log level is set to \"warn\", only messages with a level of \"warn\", \"error\", or \"fatal\" will be output, while messages with a level of \"info\", \"debug\", or \"trace\" will be suppressed. This allows users to control the verbosity of the logs and focus on the most relevant information based on their current needs.\n *\n * @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.\n * @param root - An optional root directory to use as the base for searching for the workspace configuration. If provided, this will be used as the starting point for searching for the workspace configuration instead of the current working directory. This can be an absolute or relative path, and if it is relative, it will be resolved based on the current working directory.\n * @returns A promise that resolves to the default log level for the current execution, which can be \"fatal\", \"error\", \"warn\", \"info\", \"debug\", or \"trace\".\n */\nexport async function getDefaultLogLevel(\n  cwd: string,\n  root?: string\n): Promise<LogLevelResolvedConfig> {\n  const workspaceConfig = await tryResolveWorkspaceConfig(cwd, root);\n\n  return resolveLogLevel(\n    workspaceConfig?.logLevel\n      ? workspaceConfig.logLevel === \"success\" ||\n        workspaceConfig.logLevel === \"performance\"\n        ? \"info\"\n        : workspaceConfig.logLevel === \"all\"\n          ? \"debug\"\n          : workspaceConfig.logLevel === \"fatal\"\n            ? \"error\"\n            : workspaceConfig.logLevel\n      : undefined,\n    workspaceConfig?.mode || (await getDefaultMode(cwd, root))\n  );\n}\n\n/**\n * Load the user configuration file for the project and set up the context with the loaded configuration. This function will be called during the initialization of the context to load the user configuration file based on the provided options and set up the context accordingly. It will also set up the resolver for loading modules from the user configuration file and ensure that the context is properly initialized with the loaded configuration.\n *\n * @remarks\n * 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.\n *\n * @param cwd - The current working directory to start searching from. This is typically the directory from which the Powerlines process was executed.\n * @param root - The root directory of the project to look for the configuration file. This is typically the root directory of the project, which may be different from the current working directory if the process was executed from a subdirectory.\n * @param framework - The name of the framework to use when looking for configuration files (default is \"powerlines\"). This is used to determine the naming convention for the configuration files to look for (e.g., `powerlines.development.config.js` for the \"powerlines\" framework in development mode).\n * @param orgId - The name of the organization to use when looking for configuration files (optional). This can be used to further customize the naming convention for the configuration files to look for (e.g., `powerlines.myorg.development.config.js` for the \"powerlines\" framework in development mode with an organization of \"myorg\").\n * @param inlineConfig - The inline configuration options provided during the execution of a Powerlines command, which can include properties such as the project root, mode, and an explicit path to a configuration file. This is used to determine how the context should be initialized and which configuration file should be loaded for the execution.\n * @returns A promise that resolves when the context has been successfully initialized with the loaded configuration and resolver setup.\n * @throws Will throw an error if no configuration file is found in the project root or current working directory. This ensures that the context cannot be initialized without a valid configuration, which is essential for the proper functioning of the Powerlines process.\n */\nexport async function loadParsedConfig(\n  cwd: string,\n  root: string,\n  framework: string,\n  orgId: string,\n  inlineConfig: InlineConfig\n) {\n  const mode = inlineConfig.mode || (await getDefaultMode(cwd, root));\n\n  const configFile = await loadUserConfigFile(\n    cwd,\n    root,\n    mode,\n    inlineConfig.command,\n    { name: framework, orgId },\n    inlineConfig.configFile\n  );\n  if (!configFile) {\n    throw new Error(\n      `No configuration file found in ${appendPath(\n        root,\n        cwd\n      )}. Please ensure you have a valid configuration file in your project.`\n    );\n  }\n\n  return configFile;\n}\n\nexport type PartiallyResolvedContext<TContext extends Context = Context> = Omit<\n  TContext,\n  \"config\" | \"tsconfig\" | \"entry\" | \"fs\" | \"compiler\" | \"unimport\"\n> &\n  Partial<TContext> & {\n    config: TContext[\"config\"];\n  };\n\n/**\n * Loads the workspace configuration.\n *\n * @param cwd - The root directory of the workspace.\n * @param root - The current working directory to start searching from.\n * @returns A promise that resolves to the loaded workspace configuration.\n */\nexport async function loadWorkspaceConfig(\n  cwd: string,\n  root: string\n): Promise<WorkspaceConfig> {\n  return defu(\n    {\n      workspaceRoot: cwd\n    },\n    await getWorkspaceConfig(true, {\n      cwd: root,\n      workspaceRoot: cwd,\n      useDefault: true\n    })\n  );\n}\n\n/**\n * Loads the user configuration file for the project.\n *\n * @remarks\n * This function will attempt to locate and load the user configuration file for the project based on the provided parameters. It will look for configuration files in various formats (e.g., `.ts`, `.js`, `.mts`, `.mjs`) and with different naming conventions (e.g., `powerlines.config.ts`, `powerlines.development.config.js`, etc.) in the project root and current working directory. If a configuration file is found, it will be loaded using a Jiti resolver, and the resulting configuration object will be returned. If no configuration file is found, an empty configuration object will be returned.\n *\n * @param cwd - The current working directory to start searching from.\n * @param root - The root directory of the project.\n * @param mode - The mode to determine which configuration file to load (e.g., \"development\", \"test\", \"production\").\n * @param command - The command being executed (e.g., \"build\", \"dev\", \"test\"), which can be used to further customize the configuration loading logic if needed.\n * @param framework - The name of the framework to use when looking for configuration files (default is \"powerlines\").\n * @param configFile - An explicit path to a configuration file to load (optional). If provided, this file will be loaded instead of searching for configuration files based on the mode and framework.\n * @returns A promise that resolves to the resolved user configuration.\n */\nexport async function loadUserConfigFile(\n  cwd: string,\n  root: string,\n  mode: Mode,\n  command: string,\n  framework?: PartialKeys<FrameworkOptions, \"orgId\">,\n  configFile?: string\n): Promise<ParsedUserConfig> {\n  const frameworkName = kebabCase(framework?.name || \"powerlines\");\n  const frameworkOrgId = kebabCase(framework?.orgId || \"storm-software\");\n\n  let resolvedUserConfig: Partial<ParsedUserConfig> = {};\n\n  let resolvedUserConfigFile: string | undefined;\n  if (configFile) {\n    resolvedUserConfigFile = existsSync(replacePath(configFile, root))\n      ? replacePath(configFile, root)\n      : existsSync(\n            joinPaths(appendPath(root, cwd), replacePath(configFile, root))\n          )\n        ? joinPaths(appendPath(root, cwd), replacePath(configFile, root))\n        : existsSync(joinPaths(appendPath(root, cwd), configFile))\n          ? joinPaths(appendPath(root, cwd), configFile)\n          : undefined;\n  }\n\n  if (!resolvedUserConfigFile) {\n    resolvedUserConfigFile = existsSync(\n      joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.ts`)\n    )\n      ? joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.ts`)\n      : existsSync(\n            joinPaths(\n              appendPath(root, cwd),\n              `${frameworkName}.${mode}.config.js`\n            )\n          )\n        ? joinPaths(appendPath(root, cwd), `${frameworkName}.${mode}.config.js`)\n        : existsSync(\n              joinPaths(\n                appendPath(root, cwd),\n                `${frameworkName}.${mode}.config.mts`\n              )\n            )\n          ? joinPaths(\n              appendPath(root, cwd),\n              `${frameworkName}.${mode}.config.mts`\n            )\n          : existsSync(\n                joinPaths(\n                  appendPath(root, cwd),\n                  `${frameworkName}.${mode}.config.mjs`\n                )\n              )\n            ? joinPaths(\n                appendPath(root, cwd),\n                `${frameworkName}.${mode}.config.mjs`\n              )\n            : existsSync(\n                  joinPaths(appendPath(root, cwd), `${frameworkName}.config.ts`)\n                )\n              ? joinPaths(appendPath(root, cwd), `${frameworkName}.config.ts`)\n              : existsSync(\n                    joinPaths(\n                      appendPath(root, cwd),\n                      `${frameworkName}.config.js`\n                    )\n                  )\n                ? joinPaths(appendPath(root, cwd), `${frameworkName}.config.js`)\n                : existsSync(\n                      joinPaths(\n                        appendPath(root, cwd),\n                        `${frameworkName}.config.mts`\n                      )\n                    )\n                  ? joinPaths(\n                      appendPath(root, cwd),\n                      `${frameworkName}.config.mts`\n                    )\n                  : existsSync(\n                        joinPaths(\n                          appendPath(root, cwd),\n                          `${frameworkName}.config.mjs`\n                        )\n                      )\n                    ? joinPaths(\n                        appendPath(root, cwd),\n                        `${frameworkName}.config.mjs`\n                      )\n                    : undefined;\n  }\n\n  const envPaths = getEnvPaths({\n    orgId: frameworkOrgId,\n    appId: frameworkName,\n    workspaceRoot: cwd\n  });\n\n  const jiti = createResolver({\n    cwd,\n    root,\n    cacheDir: envPaths.cache,\n    mode\n  });\n\n  if (resolvedUserConfigFile) {\n    const resolved = await jiti.import<{ default: AnyUserConfig }>(\n      jiti.esmResolve(resolvedUserConfigFile)\n    );\n    if (resolved?.default) {\n      let config = {};\n      if (isFunction(resolved.default)) {\n        config = await Promise.resolve(\n          resolved.default({ root, cwd, mode, command })\n        );\n      } else if (\n        isSetObject(resolved.default) ||\n        Array.isArray(resolved.default)\n      ) {\n        config = resolved.default;\n      }\n\n      if (isSetObject(config) || Array.isArray(config)) {\n        resolvedUserConfig = {\n          ...config,\n          config,\n          configFile: resolvedUserConfigFile\n        };\n      }\n    }\n  }\n\n  const result = await loadConfigC12({\n    cwd: root,\n    name: frameworkName,\n    envName: mode,\n    globalRc: true,\n    packageJson: camelCase(frameworkName),\n    dotenv: true,\n    jiti\n  });\n\n  return defu(\n    {\n      config: {\n        root,\n        cwd,\n        framework\n      }\n    },\n    resolvedUserConfig,\n    isSetObject(result?.config) ? { ...result.config, ...result } : {}\n  );\n}\n\n/**\n * A type helper to make it easier to use `powerlines.config.ts` files.\n *\n * @remarks\n * The function accepts a direct {@link AnyUserConfig} object/function and returns it typed as a {@link UserConfig} object.\n */\nexport function defineConfig(config: AnyUserConfig): UserConfig {\n  return config as any;\n}\n"],"mappings":"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"}