powerlines 0.12.0 → 0.14.0

package/dist/lib/{context-tEqvC3yI.d.ts → config-DnifzkPt.d.ts}

@@ -1,15 +1,11 @@
-import { EnvPaths } from '@stryke/env/get-env-paths';
-import { PackageJson } from '@stryke/types/package-json';
-import { Worker } from 'jest-worker';
-import { Jiti } from 'jiti';
-import { ParserOptions, ParseResult } from 'oxc-parser';
-import { Range } from 'semver';
-import { TransformResult, ExternalIdResult, HookFilter, UnpluginOptions, UnpluginContext, UnpluginBuildContext } from 'unplugin';
+import { Format } from '@storm-software/build-tools/types';
 import { LogLevelLabel } from '@storm-software/config-tools/types';
-import { MaybePromise, FunctionLike, NonUndefined } from '@stryke/types/base';
-import { TypeDefinitionParameter, TypeDefinition } from '@stryke/types/configuration';
+import { StormWorkspaceConfig } from '@storm-software/config/types';
+import { NonUndefined, MaybePromise, FunctionLike } from '@stryke/types/base';
+import { TypeDefinition, TypeDefinitionParameter } from '@stryke/types/configuration';
 import { AssetGlob } from '@stryke/types/file';
-import { UserConfig as UserConfig$1, PreviewOptions, ResolvedPreviewOptions } from 'vite';
+import { ResolvedConfig as ResolvedConfig$1, ConfigLayer } from 'c12';
+import { UserConfig as UserConfig$1, ResolvedPreviewOptions, PreviewOptions } from 'vite';
 import { UserConfig as UserConfig$2 } from '@farmfe/core';
 import { Configuration as Configuration$1 } from '@rspack/core';
 import { ESBuildOptions } from '@storm-software/esbuild/types';
@@ -18,11 +14,15 @@ import { BuildOptions } from 'esbuild';
 import { RolldownOptions, RolldownOutput } from 'rolldown';
 import { RollupOptions, OutputOptions } from 'rollup';
 import { Configuration } from 'webpack';
-import { Format } from '@storm-software/build-tools/types';
-import { StormWorkspaceConfig } from '@storm-software/config/types';
-import { ResolvedConfig as ResolvedConfig$1, ConfigLayer } from 'c12';
-import { T as TSConfig, P as ParsedTypeScriptConfig } from './tsconfig-Bz-CiFqD.js';
+import { EnvPaths } from '@stryke/env/get-env-paths';
+import { PackageJson } from '@stryke/types/package-json';
+import { Worker } from 'jest-worker';
+import { Jiti } from 'jiti';
+import { ParserOptions, ParseResult } from 'oxc-parser';
+import { Range } from 'semver';
+import { TransformResult, ExternalIdResult, HookFilter, UnpluginOptions, UnpluginContext, UnpluginBuildContext } from 'unplugin';
 import { ArrayValues } from '@stryke/types/array';
+import { P as ParsedTypeScriptConfig, T as TSConfig } from './tsconfig-Bz-CiFqD.js';
 import { PrimitiveJsonValue } from '@stryke/json/types';
 import { Volume } from 'memfs';
 import { PathLike, StatSyncOptions, Stats, RmDirOptions, RmOptions, Mode, MakeDirectoryOptions as MakeDirectoryOptions$1, PathOrFileDescriptor, WriteFileOptions as WriteFileOptions$1 } from 'node:fs';
@@ -103,6 +103,82 @@ type UnbuildResolvedBuildConfig = UnbuildOptions & BuildResolvedConfig;
 type FarmBuildConfig = Partial<Omit<UserConfig$2, "tsconfig" | "tsconfigRaw" | "assets" | "outputPath" | "mode" | "format" | "platform" | "projectRoot" | "env" | "entry" | "entryPoints">> & BuildConfig;
 type FarmResolvedBuildConfig = UserConfig$2 & BuildResolvedConfig;
 
+interface ResolvedEntryTypeDefinition extends TypeDefinition {
+    /**
+     * The user provided entry point in the source code
+     */
+    input: TypeDefinition;
+    /**
+     * An optional name to use in the package export during the build process
+     */
+    output?: string;
+}
+type EnvironmentResolvedConfig = Omit<EnvironmentConfig, "consumer" | "mode" | "ssr" | "preview" | "mainFields" | "extensions"> & Required<Pick<EnvironmentConfig, "consumer" | "mode" | "ssr" | "mainFields" | "extensions">> & {
+    /**
+     * The name of the environment
+     */
+    name: string;
+    /**
+     * Configuration options for the preview server
+     */
+    preview?: ResolvedPreviewOptions;
+};
+type ResolvedAssetGlob = AssetGlob & Required<Pick<AssetGlob, "input">>;
+type OutputResolvedConfig = Required<Omit<OutputConfig, "assets"> & {
+    assets: ResolvedAssetGlob[];
+}>;
+/**
+ * The resolved options for the Powerlines project configuration.
+ */
+type ResolvedConfig<TUserConfig extends UserConfig = UserConfig> = Omit<TUserConfig, "name" | "title" | "plugins" | "mode" | "environments" | "platform" | "tsconfig" | "lint" | "test" | "build" | "transform" | "override" | "root" | "variant" | "type" | "output" | "logLevel" | "framework"> & Required<Pick<TUserConfig, "name" | "title" | "plugins" | "mode" | "environments" | "tsconfig" | "lint" | "test" | "build" | "transform" | "override" | "framework">> & {
+    /**
+     * The configuration options that were provided inline to the Powerlines CLI.
+     */
+    inlineConfig: InlineConfig<TUserConfig>;
+    /**
+     * The original configuration options that were provided by the user to the Powerlines process.
+     */
+    userConfig: TUserConfig;
+    /**
+     * A string identifier for the Powerlines command being executed.
+     */
+    command: NonUndefined<InlineConfig<TUserConfig>["command"]>;
+    /**
+     * The root directory of the project's source code
+     *
+     * @defaultValue "\{projectRoot\}/src"
+     */
+    sourceRoot: NonUndefined<TUserConfig["sourceRoot"]>;
+    /**
+     * The root directory of the project.
+     */
+    projectRoot: NonUndefined<TUserConfig["root"]>;
+    /**
+     * The type of project being built.
+     */
+    projectType: NonUndefined<TUserConfig["type"]>;
+    /**
+     * The output configuration options to use for the build process
+     */
+    output: OutputResolvedConfig;
+    /**
+     * The log level to use for the Powerlines processes.
+     *
+     * @defaultValue "info"
+     */
+    logLevel: "error" | "warn" | "info" | "debug" | "trace" | null;
+};
+type ViteResolvedConfig = ResolvedConfig<ViteUserConfig>;
+type WebpackResolvedConfig = ResolvedConfig<WebpackUserConfig>;
+type RspackResolvedConfig = ResolvedConfig<RspackUserConfig>;
+type ESBuildResolvedConfig = ResolvedConfig<ESBuildUserConfig>;
+type RollupResolvedConfig = ResolvedConfig<RollupUserConfig>;
+type RolldownResolvedConfig = ResolvedConfig<RolldownUserConfig>;
+type TsupResolvedConfig = ResolvedConfig<TsupUserConfig>;
+type UnbuildResolvedConfig = ResolvedConfig<UnbuildUserConfig>;
+type FarmResolvedConfig = ResolvedConfig<FarmUserConfig>;
+type InferResolvedConfig<TBuildVariant extends BuildVariant | undefined> = TBuildVariant extends undefined ? ResolvedConfig : TBuildVariant extends "webpack" ? WebpackResolvedConfig : TBuildVariant extends "rspack" ? RspackResolvedConfig : TBuildVariant extends "vite" ? ViteResolvedConfig : TBuildVariant extends "esbuild" ? ESBuildResolvedConfig : TBuildVariant extends "unbuild" ? UnbuildResolvedConfig : TBuildVariant extends "tsup" ? TsupResolvedConfig : TBuildVariant extends "rolldown" ? RolldownResolvedConfig : TBuildVariant extends "rollup" ? RollupResolvedConfig : TBuildVariant extends "farm" ? FarmResolvedConfig : ResolvedConfig;
+
 declare const SUPPORTED_COMMANDS: readonly ["new", "clean", "prepare", "lint", "test", "build", "docs", "release", "finalize"];
 type CommandType = ArrayValues<typeof SUPPORTED_COMMANDS>;
 
@@ -315,6 +391,35 @@ interface Plugin<in out TContext extends PluginContext<ResolvedConfig> = PluginC
     applyToEnvironment?: (environment: EnvironmentResolvedConfig) => MaybePromise<boolean | Plugin<any>>;
 }
 
+type BaseHooks<TContext extends PluginContext = PluginContext> = BasePluginHookFunctions<TContext>;
+type BaseHookKeys<TContext extends PluginContext = PluginContext> = keyof BaseHooks<TContext>;
+type ExternalHooks<TContext extends PluginContext = PluginContext> = ExternalPluginHookFunctions<TContext>;
+type ExternalHookKeys<TContext extends PluginContext = PluginContext> = keyof ExternalHooks<TContext>;
+type Hooks<TContext extends PluginContext = PluginContext> = PluginHookFunctions<TContext>;
+type HookKeys<TContext extends PluginContext = PluginContext> = keyof Hooks<TContext>;
+interface BaseHooksListItem<TContext extends PluginContext = PluginContext, TKey extends BaseHookKeys<TContext> = BaseHookKeys<TContext>> extends PluginHookObject<BaseHooks<TContext>[TKey]> {
+    plugin: Plugin<TContext>;
+}
+interface BaseHooksList<TContext extends PluginContext = PluginContext, TKey extends BaseHookKeys<TContext> = BaseHookKeys<TContext>> {
+    preOrdered?: BaseHooksListItem<TContext, TKey>[];
+    preEnforced?: BaseHooksListItem<TContext, TKey>[];
+    normal?: BaseHooksListItem<TContext, TKey>[];
+    postEnforced?: BaseHooksListItem<TContext, TKey>[];
+    postOrdered?: BaseHooksListItem<TContext, TKey>[];
+}
+interface ExternalHooksListItem<TContext extends PluginContext = PluginContext, TKey extends ExternalHookKeys<TContext> = ExternalHookKeys<TContext>> {
+    plugin: Plugin<TContext>;
+    handler: ExternalHooks<TContext>[TKey];
+}
+type HooksList<TContext extends PluginContext = PluginContext> = {
+    [TKey in BaseHookKeys<TContext>]?: BaseHooksList<TContext, TKey>;
+} & {
+    [TKey in ExternalHookKeys<TContext>]?: ExternalHooksListItem<TContext, TKey>[];
+};
+type InferHookHandler<TContext extends PluginContext, TKey extends HookKeys<TContext>> = Hooks<TContext>[TKey];
+type InferHookReturnType<TContext extends PluginContext, TKey extends HookKeys<TContext>> = ReturnType<InferHookHandler<TContext, TKey>> extends Promise<infer U> ? U extends Promise<infer V> ? V : U : ReturnType<InferHookHandler<TContext, TKey>>;
+type InferHookParameters<TContext extends PluginContext, TKey extends HookKeys<TContext>> = Parameters<InferHookHandler<TContext, TKey>>;
+
 declare const __VFS_INIT__ = "__VFS_INIT__";
 declare const __VFS_REVERT__ = "__VFS_REVERT__";
 declare const __VFS_CACHE__ = "__VFS_CACHE__";
@@ -702,773 +807,668 @@ interface VirtualFileSystemInterface {
     [__VFS_UNIFIED__]: IUnionFs;
 }
 
-type LogFn = (type: LogLevelLabel, ...args: string[]) => void;
-/**
- * The {@link StormWorkspaceConfig | configuration} object for an entire Powerlines workspace
- */
-type WorkspaceConfig = Partial<StormWorkspaceConfig> & Required<Pick<StormWorkspaceConfig, "workspaceRoot">>;
-type PluginFactory<in out TContext extends PluginContext = PluginContext, TOptions = any> = (options: TOptions) => MaybePromise<Plugin<TContext>>;
-/**
- * A configuration tuple for a Powerlines plugin.
- */
-type PluginConfigTuple<TContext extends PluginContext = PluginContext, TOptions = any> = [string | PluginFactory<TContext, TOptions>, TOptions] | [Plugin<TContext>];
-/**
- * A configuration object for a Powerlines plugin.
- */
-type PluginConfigObject<TContext extends PluginContext = PluginContext, TOptions = any> = {
-    plugin: string | PluginFactory<TContext, TOptions>;
-    options: TOptions;
-} | {
-    plugin: Plugin<TContext>;
-    options?: never;
+type WorkerProcess<TExposedMethods extends ReadonlyArray<string>> = {
+    [K in TExposedMethods[number]]: (data: any) => Promise<any>;
+} & {
+    close: () => void;
+    end: () => ReturnType<Worker["end"]>;
 };
-/**
- * A configuration tuple for a Powerlines plugin.
- */
-type PluginConfig<TContext extends PluginContext = PluginContext> = string | PluginFactory<TContext, void> | Plugin<TContext> | Promise<Plugin<TContext>> | PluginConfigTuple<TContext> | PluginConfigObject<TContext>;
-type ProjectType = "application" | "library";
-interface OutputConfig {
+interface MetaInfo {
     /**
-     * The path to output the final compiled files to
-     *
-     * @remarks
-     * If a value is not provided, Powerlines will attempt to:
-     * 1. Use the `outDir` value in the `tsconfig.json` file.
-     * 2. Use the `dist` directory in the project root directory.
-     *
-     * @defaultValue "dist/\{projectRoot\}"
+     * The checksum generated from the resolved options
      */
-    outputPath?: string;
+    checksum: string;
     /**
-     * The format of the output files
-     *
-     * @defaultValue "virtual"
+     * The build id
      */
-    mode?: OutputModeType;
+    buildId: string;
     /**
-     * The path of the generated runtime declaration file relative to the workspace root.
-     *
-     * @defaultValue "\{projectRoot\}/powerlines.d.ts"
+     * The release id
      */
-    dts?: string | false;
+    releaseId: string;
     /**
-     * A prefix to use for identifying builtin modules
-     *
-     * @remarks
-     * This prefix will be used to identify all builtin modules generated during the "prepare" phase. An example builtin ID for a module called `"utils"` would be `"{builtinPrefix}:utils"`.
-     *
-     * @defaultValue "powerlines"
+     * The build timestamp
      */
-    builtinPrefix?: string;
+    timestamp: number;
     /**
-     * The folder where the generated runtime artifacts will be located
-     *
-     * @remarks
-     * This folder will contain all runtime artifacts and builtins generated during the "prepare" phase.
-     *
-     * @defaultValue "\{projectRoot\}/.powerlines"
+     * A hash that represents the path to the project root directory
      */
-    artifactsFolder?: string;
+    projectRootHash: string;
     /**
-     * The module format of the output files
-     *
-     * @remarks
-     * This option can be a single format or an array of formats. If an array is provided, multiple builds will be generated for each format.
-     *
-     * @defaultValue "esm"
+     * A hash that represents the path to the project root directory
      */
-    format?: Format | Format[];
+    configHash: string;
     /**
-     * A list of assets to copy to the output directory
-     *
-     * @remarks
-     * The assets can be specified as a string (path to the asset) or as an object with a `glob` property (to match multiple files). The paths are relative to the project root directory.
+     * A mapping of runtime ids to their corresponding file paths
      */
-    assets?: Array<string | AssetGlob>;
-}
-interface BaseConfig {
+    builtinIdMap: Record<string, string>;
     /**
-     * The name of the project
+     * A mapping of virtual file paths to their corresponding file contents
      */
-    name?: string;
+    virtualFiles: Record<string, string | null>;
+}
+interface Resolver extends Jiti {
+    plugin: Jiti;
+}
+interface SelectHooksOptions {
+    order?: "pre" | "post" | "normal";
+}
+interface InitContextOptions {
     /**
-     * The project display title
+     * If false, the plugin will be loaded after all other plugins.
      *
-     * @remarks
-     * This option is used in documentation generation and other places where a human-readable title is needed.
+     * @defaultValue true
      */
-    title?: string;
+    isHighPriority: boolean;
+}
+interface Context<TResolvedConfig extends ResolvedConfig = ResolvedConfig> {
     /**
-     * A description of the project
-     *
-     * @remarks
-     * If this option is not provided, the build process will try to use the \`description\` value from the `\package.json\` file.
+     * The Storm workspace configuration
      */
-    description?: string;
+    workspaceConfig: WorkspaceConfig;
     /**
-     * The log level to use for the Powerlines processes.
-     *
-     * @defaultValue "info"
+     * An object containing the options provided to Powerlines
      */
-    logLevel?: LogLevelLabel | null;
+    config: TResolvedConfig;
     /**
-     * A custom logger function to use for logging messages
+     * A logging function for the Powerlines engine
      */
-    customLogger?: LogFn;
+    log: LogFn;
     /**
-     * Explicitly set a mode to run in. This mode will be used at various points throughout the Powerlines processes, such as when compiling the source code.
-     *
-     * @defaultValue "production"
+     * The metadata information
      */
-    mode?: "development" | "test" | "production";
+    meta: MetaInfo;
     /**
-     * The entry point(s) for the application
+     * The metadata information currently written to disk
      */
-    entry?: TypeDefinitionParameter | TypeDefinitionParameter[];
+    persistedMeta?: MetaInfo;
     /**
-     * Configuration for linting the source code
+     * The Powerlines artifacts directory
      */
-    lint?: Record<string, any> | false;
+    artifactsPath: string;
     /**
-     * Configuration for testing the source code
+     * The path to the Powerlines builtin runtime modules directory
      */
-    test?: Record<string, any> | false;
+    builtinsPath: string;
     /**
-     * Configuration for the output of the build process
+     * The path to the Powerlines entry modules directory
      */
-    output?: OutputConfig;
+    entryPath: string;
     /**
-     * Configuration for the transformation of the source code
+     * The path to the Powerlines TypeScript declaration files directory
      */
-    transform?: Record<string, any>;
+    dtsPath: string;
     /**
-     * Options to to provide to the build process
+     * The path to a directory where the reflection data buffers (used by the build processes) are stored
      */
-    build?: BuildConfig;
+    dataPath: string;
     /**
-     * Configuration for documentation generation
-     *
-     * @remarks
-     * This configuration will be used by the documentation generation plugins during the `docs` command.
+     * The path to a directory where the project cache (used by the build processes) is stored
      */
-    docs?: Record<string, any>;
+    cachePath: string;
     /**
-     * The path to the tsconfig file to be used by the compiler
-     *
-     * @remarks
-     * If a value is not provided, the plugin will attempt to find the `tsconfig.json` file in the project root directory. The parsed tsconfig compiler options will be merged with the {@link Options.tsconfigRaw} value (if provided).
-     *
-     * @defaultValue "\{projectRoot\}/tsconfig.json"
+     * The Powerlines environment paths
      */
-    tsconfig?: string;
+    envPaths: EnvPaths;
     /**
-     * The raw {@link TSConfig} object to be used by the compiler. This object will be merged with the `tsconfig.json` file.
-     *
-     * @see https://www.typescriptlang.org/tsconfig
-     *
-     * @remarks
-     * If populated, this option takes higher priority than `tsconfig`
+     * The file system path to the Powerlines package installation
      */
-    tsconfigRaw?: TSConfig;
-}
-interface EnvironmentConfig extends BaseConfig {
+    powerlinesPath: string;
     /**
-     * Array of strings indicating the order in which fields in a package.json file should be resolved to determine the entry point for a module.
-     *
-     * @defaultValue `['browser', 'module', 'jsnext:main', 'jsnext']`
+     * The relative path to the Powerlines workspace root directory
      */
-    mainFields?: string[];
+    relativeToWorkspaceRoot: string;
     /**
-     * Array of strings indicating what conditions should be used for module resolution.
+     * The project's `package.json` file content
      */
-    conditions?: string[];
+    packageJson: PackageJson & Record<string, any>;
     /**
-     * Array of strings indicating what conditions should be used for external modules.
+     * The project's `project.json` file content
      */
-    externalConditions?: string[];
+    projectJson?: Record<string, any>;
     /**
-     * Array of strings indicating what file extensions should be used for module resolution.
-     *
-     * @defaultValue `['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json']`
+     * The dependency installations required by the project
      */
-    extensions?: string[];
+    dependencies: Record<string, string | Range>;
     /**
-     * Array of strings indicating what modules should be deduplicated to a single version in the build.
-     *
-     * @remarks
-     * This option is useful for ensuring that only one version of a module is included in the bundle, which can help reduce bundle size and avoid conflicts.
+     * The development dependency installations required by the project
      */
-    dedupe?: string[];
+    devDependencies: Record<string, string | Range>;
     /**
-     * Array of strings or regular expressions that indicate what modules are builtin for the environment.
+     * The parsed TypeScript configuration from the `tsconfig.json` file
      */
-    builtins?: (string | RegExp)[];
+    tsconfig: ParsedTypeScriptConfig;
     /**
-     * Configuration options for the preview server
+     * The entry points of the source code
      */
-    preview?: PreviewOptions;
+    entry: ResolvedEntryTypeDefinition[];
     /**
-     * A flag indicating whether the build is for a Server-Side Rendering environment.
+     * The virtual file system manager used during the build process to reference generated runtime files
      */
-    ssr?: boolean;
+    fs: VirtualFileSystemInterface;
     /**
-     * Define if this environment is used for Server-Side Rendering
-     *
-     * @defaultValue "server" (if it isn't the client environment)
+     * The Jiti module resolver
      */
-    consumer?: "client" | "server";
-}
-interface CommonUserConfig extends BaseConfig {
+    resolver: Resolver;
     /**
-     * The type of project being built
-     *
-     * @defaultValue "application"
+     * The builtin module id that exist in the Powerlines virtual file system
      */
-    type?: ProjectType;
+    builtins: string[];
     /**
-     * The root directory of the project
+     * The Powerlines builtin virtual files
      */
-    root: string;
+    getBuiltins: () => Promise<VirtualFile[]>;
     /**
-     * The root directory of the project's source code
+     * Resolves a builtin virtual file and writes it to the VFS if it does not already exist
      *
-     * @defaultValue "\{root\}/src"
+     * @param code - The source code of the builtin file
+     * @param id - The unique identifier of the builtin file
+     * @param path - An optional path to write the builtin file to
+     * @param options - Options for writing the file
      */
-    sourceRoot?: string;
+    writeBuiltin: (code: string, id: string, path?: string, options?: PowerlinesWriteFileOptions) => Promise<void>;
     /**
-     * A path to a custom configuration file to be used instead of the default `storm.json`, `powerlines.config.js`, or `powerlines.config.ts` files.
+     * Resolves a entry virtual file and writes it to the VFS if it does not already exist
      *
-     * @remarks
-     * This option is useful for running Powerlines commands with different configuration files, such as in CI/CD environments or when testing different configurations.
+     * @param code - The source code of the entry file
+     * @param path - An optional path to write the entry file to
+     * @param options - Options for writing the file
      */
-    configFile?: string;
+    writeEntry: (code: string, path: string, options?: PowerlinesWriteFileOptions) => Promise<void>;
     /**
-     * Should the Powerlines CLI processes skip installing missing packages?
-     *
-     * @remarks
-     * This option is useful for CI/CD environments where the installation of packages is handled by a different process.
-     *
-     * @defaultValue false
+     * Parses the source code and returns a {@link ParseResult} object.
      */
-    skipInstalls?: boolean;
+    parse: (code: string, id: string, options?: ParserOptions | null) => Promise<ParseResult>;
     /**
-     * Should the compiler processes skip any improvements that make use of cache?
-     *
-     * @defaultValue false
+     * A function to update the context fields using a new user configuration options
      */
-    skipCache?: boolean;
+    withUserConfig: (userConfig: UserConfig, options?: InitContextOptions) => Promise<void>;
     /**
-     * A list of resolvable paths to plugins used during the build process
+     * A function to update the context fields using inline configuration options
      */
-    plugins?: PluginConfig<PluginContext<any>>[];
+    withInlineConfig: (inlineConfig: InlineConfig, options?: InitContextOptions) => Promise<void>;
     /**
-     * Environment-specific configurations
+     * Create a new logger instance
+     *
+     * @param name - The name to use for the logger instance
+     * @returns A logger function
      */
-    environments?: Record<string, EnvironmentConfig>;
+    createLog: (name: string | null) => LogFn;
     /**
-     * A string identifier that allows a child framework or tool to identify itself when using Powerlines.
+     * Extend the current logger instance with a new name
      *
-     * @defaultValue "powerlines"
+     * @param name - The name to use for the extended logger instance
+     * @returns A logger function
      */
-    framework?: string;
+    extendLog: (name: string) => LogFn;
 }
-type UserConfig<TBuildConfig extends BuildConfig = BuildConfig, TBuildResolvedConfig extends BuildResolvedConfig = BuildResolvedConfig, TBuildVariant extends string = any> = CommonUserConfig & {
-    build?: TBuildConfig & {
-        /**
-         * The build variant being used by the Powerlines engine.
-         */
-        variant?: TBuildVariant;
-    };
-    override?: Partial<TBuildResolvedConfig>;
-};
-type WebpackUserConfig = UserConfig<WebpackBuildConfig, WebpackResolvedBuildConfig, "webpack">;
-type RspackUserConfig = UserConfig<RspackBuildConfig, RspackResolvedBuildConfig, "rspack">;
-type RollupUserConfig = UserConfig<RollupBuildConfig, RollupResolvedBuildConfig, "rollup">;
-type RolldownUserConfig = UserConfig<RolldownBuildConfig, RolldownResolvedBuildConfig, "rolldown">;
-type ViteUserConfig = UserConfig<ViteBuildConfig, ViteResolvedBuildConfig, "vite">;
-type ESBuildUserConfig = UserConfig<ESBuildBuildConfig, ESBuildResolvedBuildConfig, "esbuild">;
-type UnbuildUserConfig = UserConfig<UnbuildBuildConfig, UnbuildResolvedBuildConfig, "unbuild">;
-type TsupUserConfig = UserConfig<TsupBuildConfig, TsupResolvedBuildConfig, "tsup">;
-type FarmUserConfig = UserConfig<FarmBuildConfig, FarmResolvedBuildConfig, "farm">;
-type InferUserConfig<TBuildVariant extends BuildVariant | undefined> = TBuildVariant extends "webpack" ? WebpackUserConfig : TBuildVariant extends "rspack" ? RspackUserConfig : TBuildVariant extends "vite" ? ViteUserConfig : TBuildVariant extends "esbuild" ? ESBuildUserConfig : TBuildVariant extends "unbuild" ? UnbuildUserConfig : TBuildVariant extends "tsup" ? TsupUserConfig : TBuildVariant extends "rolldown" ? RolldownUserConfig : TBuildVariant extends "rollup" ? RollupUserConfig : TBuildVariant extends "farm" ? FarmUserConfig : UserConfig;
-type InitialUserConfig<TUserConfig extends UserConfig = UserConfig> = Partial<TUserConfig> & {
-    root: string;
-};
-type ParsedUserConfig<TUserConfig extends UserConfig = UserConfig> = TUserConfig & ResolvedConfig$1<TUserConfig> & {
+interface APIContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig> {
     /**
-     * The path to the user configuration file, if it exists.
+     * The expected plugins options for the Powerlines project.
      *
      * @remarks
-     * This is typically the `powerlines.json`, `powerlines.config.js`, or `powerlines.config.ts` file in the project root.
+     * This is a record of plugin identifiers to their respective options. This field is populated by the Powerlines engine during both plugin initialization and the `init` command.
      */
-    configFile?: ConfigLayer<TUserConfig>["configFile"];
-};
-type PowerlinesCommand = "new" | "prepare" | "build" | "lint" | "test" | "docs" | "release" | "clean";
-/**
- * The configuration provided while executing Powerlines commands.
- */
-type InlineConfig<TUserConfig extends UserConfig = UserConfig> = Partial<TUserConfig> & {
+    plugins: Plugin<PluginContext<TResolvedConfig>>[];
     /**
-     * A string identifier for the Powerlines command being executed
+     * A function to add a plugin to the context and update the configuration options
      */
-    command: PowerlinesCommand;
-};
-type NewInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & Required<Pick<InlineConfig<TUserConfig>, "root">> & {
+    addPlugin: (plugin: Plugin<PluginContext<TResolvedConfig>>) => Promise<void>;
     /**
-     * A string identifier for the Powerlines command being executed
+     * A table for storing the current context for each configured environment
      */
-    command: "new";
+    environments: Record<string, EnvironmentContext<TResolvedConfig>>;
     /**
-     * The package name (from the \`package.json\`) for the project that will be used in the \`new\` command to create a new project based on this configuration
+     * Retrieves the context for a specific environment by name
+     *
+     * @throws Will throw an error if the environment does not exist
+     *
+     * @param name - The name of the environment to retrieve. If not provided, the default environment is returned.
+     * @returns A promise that resolves to the environment context.
+     *
+     * @example
+     * ```ts
+     * const devEnv = await apiContext.getEnvironment("development");
+     * const defaultEnv = await apiContext.getEnvironment();
+     * ```
      */
-    packageName?: string;
-};
-type CleanInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    getEnvironment: (name?: string) => Promise<EnvironmentContext<TResolvedConfig>>;
     /**
-     * A string identifier for the Powerlines command being executed
+     * Safely retrieves the context for a specific environment by name
+     *
+     * @param name - The name of the environment to retrieve. If not provided, the default environment is returned.
+     * @returns A promise that resolves to the environment context, or undefined if the environment does not exist.
+     *
+     * @example
+     * ```ts
+     * const devEnv = await apiContext.getEnvironmentSafe("development");
+     * const defaultEnv = await apiContext.getEnvironmentSafe();
+     * ```
+     *
+     * @remarks
+     * This method is similar to `getEnvironment`, but it returns `undefined` instead of throwing an error if the specified environment does not exist.
+     * This can be useful in scenarios where the existence of an environment is optional or uncertain.
+     *
+     * ```ts
+     * const testEnv = await apiContext.getEnvironmentSafe("test");
+     * if (testEnv) {
+     *   // Environment exists, safe to use it
+     * } else {
+     *   // Environment does not exist, handle accordingly
+     * }
+     * ```
+     *
+     * Using this method helps avoid unhandled exceptions in cases where an environment might not be defined.
      */
-    command: "clean";
-};
-type PrepareInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    getEnvironmentSafe: (name?: string) => Promise<EnvironmentContext<TResolvedConfig> | undefined>;
     /**
-     * A string identifier for the Powerlines command being executed
-     */
-    command: "prepare";
-};
-type BuildInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
-    /**
-     * A string identifier for the Powerlines command being executed
+     * 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.
      */
-    command: "build";
-};
-type LintInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    in: (environment: EnvironmentResolvedConfig) => Promise<EnvironmentContext<TResolvedConfig>>;
+}
+interface EnvironmentContextPlugin<TResolvedConfig extends ResolvedConfig = ResolvedConfig> {
+    plugin: Plugin<PluginContext<TResolvedConfig>>;
+    context: PluginContext<TResolvedConfig>;
+}
+interface EnvironmentContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig> {
     /**
-     * A string identifier for the Powerlines command being executed
+     * The expected plugins options for the Powerlines project.
+     *
+     * @remarks
+     * This is a record of plugin identifiers to their respective options. This field is populated by the Powerlines engine during both plugin initialization and the `init` command.
      */
-    command: "lint";
-};
-type DocsInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    plugins: EnvironmentContextPlugin<TResolvedConfig>[];
     /**
-     * A string identifier for the Powerlines command being executed
+     * A function to add a plugin to the context and update the configuration options
      */
-    command: "docs";
-};
-type ReleaseInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    addPlugin: (plugin: Plugin<PluginContext<TResolvedConfig>>) => Promise<void>;
     /**
-     * A string identifier for the Powerlines command being executed
+     * The environment specific resolved configuration
      */
-    command: "release";
-};
-
-interface ResolvedEntryTypeDefinition extends TypeDefinition {
+    environment: EnvironmentResolvedConfig;
     /**
-     * The user provided entry point in the source code
+     * A table holding references to hook functions registered by plugins
      */
-    input: TypeDefinition;
+    hooks: HooksList<PluginContext<TResolvedConfig>>;
     /**
-     * An optional name to use in the package export during the build process
+     * Retrieves the hook handlers for a specific hook name
      */
-    output?: string;
+    selectHooks: <TKey extends HookKeys<PluginContext<TResolvedConfig>>>(hook: TKey, options?: SelectHooksOptions) => Hooks[TKey][];
 }
-type EnvironmentResolvedConfig = Omit<EnvironmentConfig, "consumer" | "mode" | "ssr" | "preview" | "mainFields" | "extensions"> & Required<Pick<EnvironmentConfig, "consumer" | "mode" | "ssr" | "mainFields" | "extensions">> & {
+interface PluginContext<out TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig>, UnpluginContext {
     /**
-     * The name of the environment
+     * The environment specific resolved configuration
      */
-    name: string;
+    environment: EnvironmentResolvedConfig;
     /**
-     * Configuration options for the preview server
+     * An alternative property name for the {@link log} property
+     *
+     * @remarks
+     * This is provided for compatibility with other logging libraries that expect a `logger` property.
      */
-    preview?: ResolvedPreviewOptions;
+    logger: LogFn;
+}
+type BuildPluginContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> = PluginContext<TResolvedConfig> & Omit<UnpluginBuildContext, "parse">;
+
+type LogFn = (type: LogLevelLabel, ...args: string[]) => void;
+/**
+ * The {@link StormWorkspaceConfig | configuration} object for an entire Powerlines workspace
+ */
+type WorkspaceConfig = Partial<StormWorkspaceConfig> & Required<Pick<StormWorkspaceConfig, "workspaceRoot">>;
+type PluginFactory<in out TContext extends PluginContext = PluginContext, TOptions = any> = (options: TOptions) => MaybePromise<Plugin<TContext>>;
+/**
+ * A configuration tuple for a Powerlines plugin.
+ */
+type PluginConfigTuple<TContext extends PluginContext = PluginContext, TOptions = any> = [string | PluginFactory<TContext, TOptions>, TOptions] | [Plugin<TContext>];
+/**
+ * A configuration object for a Powerlines plugin.
+ */
+type PluginConfigObject<TContext extends PluginContext = PluginContext, TOptions = any> = {
+    plugin: string | PluginFactory<TContext, TOptions>;
+    options: TOptions;
+} | {
+    plugin: Plugin<TContext>;
+    options?: never;
 };
-type ResolvedAssetGlob = AssetGlob & Required<Pick<AssetGlob, "input">>;
-type OutputResolvedConfig = Required<Omit<OutputConfig, "assets"> & {
-    assets: ResolvedAssetGlob[];
-}>;
 /**
- * The resolved options for the Powerlines project configuration.
+ * A configuration tuple for a Powerlines plugin.
  */
-type ResolvedConfig<TUserConfig extends UserConfig = UserConfig> = Omit<TUserConfig, "name" | "title" | "plugins" | "mode" | "environments" | "platform" | "tsconfig" | "lint" | "test" | "build" | "transform" | "override" | "root" | "variant" | "type" | "output" | "logLevel" | "framework"> & Required<Pick<TUserConfig, "name" | "title" | "plugins" | "mode" | "environments" | "tsconfig" | "lint" | "test" | "build" | "transform" | "override" | "framework">> & {
-    /**
-     * The configuration options that were provided inline to the Powerlines CLI.
-     */
-    inlineConfig: InlineConfig<TUserConfig>;
-    /**
-     * The original configuration options that were provided by the user to the Powerlines process.
-     */
-    userConfig: TUserConfig;
-    /**
-     * A string identifier for the Powerlines command being executed.
-     */
-    command: NonUndefined<InlineConfig<TUserConfig>["command"]>;
+type PluginConfig<TContext extends PluginContext = PluginContext> = string | PluginFactory<TContext, void> | Plugin<TContext> | Promise<Plugin<TContext>> | PluginConfigTuple<TContext> | PluginConfigObject<TContext>;
+type ProjectType = "application" | "library";
+interface OutputConfig {
     /**
-     * The root directory of the project's source code
+     * The path to output the final compiled files to
      *
-     * @defaultValue "\{projectRoot\}/src"
-     */
-    sourceRoot: NonUndefined<TUserConfig["sourceRoot"]>;
-    /**
-     * The root directory of the project.
-     */
-    projectRoot: NonUndefined<TUserConfig["root"]>;
-    /**
-     * The type of project being built.
-     */
-    projectType: NonUndefined<TUserConfig["type"]>;
-    /**
-     * The output configuration options to use for the build process
-     */
-    output: OutputResolvedConfig;
-    /**
-     * The log level to use for the Powerlines processes.
+     * @remarks
+     * If a value is not provided, Powerlines will attempt to:
+     * 1. Use the `outDir` value in the `tsconfig.json` file.
+     * 2. Use the `dist` directory in the project root directory.
      *
-     * @defaultValue "info"
-     */
-    logLevel: LogLevelLabel | null;
-};
-type ViteResolvedConfig = ResolvedConfig<ViteUserConfig>;
-type WebpackResolvedConfig = ResolvedConfig<WebpackUserConfig>;
-type RspackResolvedConfig = ResolvedConfig<RspackUserConfig>;
-type ESBuildResolvedConfig = ResolvedConfig<ESBuildUserConfig>;
-type RollupResolvedConfig = ResolvedConfig<RollupUserConfig>;
-type RolldownResolvedConfig = ResolvedConfig<RolldownUserConfig>;
-type TsupResolvedConfig = ResolvedConfig<TsupUserConfig>;
-type UnbuildResolvedConfig = ResolvedConfig<UnbuildUserConfig>;
-type FarmResolvedConfig = ResolvedConfig<FarmUserConfig>;
-type InferResolvedConfig<TBuildVariant extends BuildVariant | undefined> = TBuildVariant extends undefined ? ResolvedConfig : TBuildVariant extends "webpack" ? WebpackResolvedConfig : TBuildVariant extends "rspack" ? RspackResolvedConfig : TBuildVariant extends "vite" ? ViteResolvedConfig : TBuildVariant extends "esbuild" ? ESBuildResolvedConfig : TBuildVariant extends "unbuild" ? UnbuildResolvedConfig : TBuildVariant extends "tsup" ? TsupResolvedConfig : TBuildVariant extends "rolldown" ? RolldownResolvedConfig : TBuildVariant extends "rollup" ? RollupResolvedConfig : TBuildVariant extends "farm" ? FarmResolvedConfig : ResolvedConfig;
-
-type BaseHooks<TContext extends PluginContext = PluginContext> = BasePluginHookFunctions<TContext>;
-type BaseHookKeys<TContext extends PluginContext = PluginContext> = keyof BaseHooks<TContext>;
-type ExternalHooks<TContext extends PluginContext = PluginContext> = ExternalPluginHookFunctions<TContext>;
-type ExternalHookKeys<TContext extends PluginContext = PluginContext> = keyof ExternalHooks<TContext>;
-type Hooks<TContext extends PluginContext = PluginContext> = PluginHookFunctions<TContext>;
-type HookKeys<TContext extends PluginContext = PluginContext> = keyof Hooks<TContext>;
-interface BaseHooksListItem<TContext extends PluginContext = PluginContext, TKey extends BaseHookKeys<TContext> = BaseHookKeys<TContext>> extends PluginHookObject<BaseHooks<TContext>[TKey]> {
-    plugin: Plugin<TContext>;
-}
-interface BaseHooksList<TContext extends PluginContext = PluginContext, TKey extends BaseHookKeys<TContext> = BaseHookKeys<TContext>> {
-    preOrdered?: BaseHooksListItem<TContext, TKey>[];
-    preEnforced?: BaseHooksListItem<TContext, TKey>[];
-    normal?: BaseHooksListItem<TContext, TKey>[];
-    postEnforced?: BaseHooksListItem<TContext, TKey>[];
-    postOrdered?: BaseHooksListItem<TContext, TKey>[];
-}
-interface ExternalHooksListItem<TContext extends PluginContext = PluginContext, TKey extends ExternalHookKeys<TContext> = ExternalHookKeys<TContext>> {
-    plugin: Plugin<TContext>;
-    handler: ExternalHooks<TContext>[TKey];
-}
-type HooksList<TContext extends PluginContext = PluginContext> = {
-    [TKey in BaseHookKeys<TContext>]?: BaseHooksList<TContext, TKey>;
-} & {
-    [TKey in ExternalHookKeys<TContext>]?: ExternalHooksListItem<TContext, TKey>[];
-};
-type InferHookHandler<TContext extends PluginContext, TKey extends HookKeys<TContext>> = Hooks<TContext>[TKey];
-type InferHookReturnType<TContext extends PluginContext, TKey extends HookKeys<TContext>> = ReturnType<InferHookHandler<TContext, TKey>> extends Promise<infer U> ? U extends Promise<infer V> ? V : U : ReturnType<InferHookHandler<TContext, TKey>>;
-type InferHookParameters<TContext extends PluginContext, TKey extends HookKeys<TContext>> = Parameters<InferHookHandler<TContext, TKey>>;
-
-type WorkerProcess<TExposedMethods extends ReadonlyArray<string>> = {
-    [K in TExposedMethods[number]]: (data: any) => Promise<any>;
-} & {
-    close: () => void;
-    end: () => ReturnType<Worker["end"]>;
-};
-interface MetaInfo {
-    /**
-     * The checksum generated from the resolved options
-     */
-    checksum: string;
-    /**
-     * The build id
-     */
-    buildId: string;
-    /**
-     * The release id
+     * @defaultValue "dist/\{projectRoot\}"
      */
-    releaseId: string;
+    outputPath?: string;
     /**
-     * The build timestamp
+     * The format of the output files
+     *
+     * @defaultValue "virtual"
      */
-    timestamp: number;
+    mode?: OutputModeType;
     /**
-     * A hash that represents the path to the project root directory
+     * The path of the generated runtime declaration file relative to the workspace root.
+     *
+     * @defaultValue "\{projectRoot\}/powerlines.d.ts"
      */
-    projectRootHash: string;
+    dts?: string | false;
     /**
-     * A hash that represents the path to the project root directory
+     * A prefix to use for identifying builtin modules
+     *
+     * @remarks
+     * This prefix will be used to identify all builtin modules generated during the "prepare" phase. An example builtin ID for a module called `"utils"` would be `"{builtinPrefix}:utils"`.
+     *
+     * @defaultValue "powerlines"
      */
-    configHash: string;
+    builtinPrefix?: string;
     /**
-     * A mapping of runtime ids to their corresponding file paths
+     * The folder where the generated runtime artifacts will be located
+     *
+     * @remarks
+     * This folder will contain all runtime artifacts and builtins generated during the "prepare" phase.
+     *
+     * @defaultValue "\{projectRoot\}/.powerlines"
      */
-    builtinIdMap: Record<string, string>;
+    artifactsFolder?: string;
     /**
-     * A mapping of virtual file paths to their corresponding file contents
+     * The module format of the output files
+     *
+     * @remarks
+     * This option can be a single format or an array of formats. If an array is provided, multiple builds will be generated for each format.
+     *
+     * @defaultValue "esm"
      */
-    virtualFiles: Record<string, string | null>;
-}
-interface Resolver extends Jiti {
-    plugin: Jiti;
-}
-interface SelectHooksOptions {
-    order?: "pre" | "post" | "normal";
-}
-interface InitContextOptions {
+    format?: Format | Format[];
     /**
-     * If false, the plugin will be loaded after all other plugins.
+     * A list of assets to copy to the output directory
      *
-     * @defaultValue true
+     * @remarks
+     * The assets can be specified as a string (path to the asset) or as an object with a `glob` property (to match multiple files). The paths are relative to the project root directory.
      */
-    isHighPriority: boolean;
+    assets?: Array<string | AssetGlob>;
 }
-interface Context<TResolvedConfig extends ResolvedConfig = ResolvedConfig> {
-    /**
-     * The Storm workspace configuration
-     */
-    workspaceConfig: WorkspaceConfig;
+interface BaseConfig {
     /**
-     * An object containing the options provided to Powerlines
+     * The name of the project
      */
-    config: TResolvedConfig;
+    name?: string;
     /**
-     * A logging function for the Powerlines engine
+     * The project display title
+     *
+     * @remarks
+     * This option is used in documentation generation and other places where a human-readable title is needed.
      */
-    log: LogFn;
+    title?: string;
     /**
-     * The metadata information
+     * A description of the project
+     *
+     * @remarks
+     * If this option is not provided, the build process will try to use the \`description\` value from the `\package.json\` file.
      */
-    meta: MetaInfo;
+    description?: string;
     /**
-     * The metadata information currently written to disk
+     * The log level to use for the Powerlines processes.
+     *
+     * @defaultValue "info"
      */
-    persistedMeta?: MetaInfo;
+    logLevel?: LogLevelLabel | null;
     /**
-     * The Powerlines artifacts directory
+     * A custom logger function to use for logging messages
      */
-    artifactsPath: string;
+    customLogger?: LogFn;
     /**
-     * The path to the Powerlines builtin runtime modules directory
+     * Explicitly set a mode to run in. This mode will be used at various points throughout the Powerlines processes, such as when compiling the source code.
+     *
+     * @defaultValue "production"
      */
-    builtinsPath: string;
+    mode?: "development" | "test" | "production";
     /**
-     * The path to the Powerlines entry modules directory
+     * The entry point(s) for the application
      */
-    entryPath: string;
+    entry?: TypeDefinitionParameter | TypeDefinitionParameter[];
     /**
-     * The path to the Powerlines TypeScript declaration files directory
+     * Configuration for linting the source code
      */
-    dtsPath: string;
+    lint?: Record<string, any> | false;
     /**
-     * The path to a directory where the reflection data buffers (used by the build processes) are stored
+     * Configuration for testing the source code
      */
-    dataPath: string;
+    test?: Record<string, any> | false;
     /**
-     * The path to a directory where the project cache (used by the build processes) is stored
+     * Configuration for the output of the build process
      */
-    cachePath: string;
+    output?: OutputConfig;
     /**
-     * The Powerlines environment paths
+     * Configuration for the transformation of the source code
      */
-    envPaths: EnvPaths;
+    transform?: Record<string, any>;
     /**
-     * The file system path to the Powerlines package installation
+     * Options to to provide to the build process
      */
-    powerlinesPath: string;
+    build?: BuildConfig;
     /**
-     * The relative path to the Powerlines workspace root directory
+     * Configuration for documentation generation
+     *
+     * @remarks
+     * This configuration will be used by the documentation generation plugins during the `docs` command.
      */
-    relativeToWorkspaceRoot: string;
+    docs?: Record<string, any>;
     /**
-     * The project's `package.json` file content
+     * The path to the tsconfig file to be used by the compiler
+     *
+     * @remarks
+     * If a value is not provided, the plugin will attempt to find the `tsconfig.json` file in the project root directory. The parsed tsconfig compiler options will be merged with the {@link Options.tsconfigRaw} value (if provided).
+     *
+     * @defaultValue "\{projectRoot\}/tsconfig.json"
      */
-    packageJson: PackageJson & Record<string, any>;
+    tsconfig?: string;
     /**
-     * The project's `project.json` file content
+     * The raw {@link TSConfig} object to be used by the compiler. This object will be merged with the `tsconfig.json` file.
+     *
+     * @see https://www.typescriptlang.org/tsconfig
+     *
+     * @remarks
+     * If populated, this option takes higher priority than `tsconfig`
      */
-    projectJson?: Record<string, any>;
+    tsconfigRaw?: TSConfig;
+}
+interface EnvironmentConfig extends BaseConfig {
     /**
-     * The dependency installations required by the project
+     * Array of strings indicating the order in which fields in a package.json file should be resolved to determine the entry point for a module.
+     *
+     * @defaultValue `['browser', 'module', 'jsnext:main', 'jsnext']`
      */
-    dependencies: Record<string, string | Range>;
+    mainFields?: string[];
     /**
-     * The development dependency installations required by the project
+     * Array of strings indicating what conditions should be used for module resolution.
      */
-    devDependencies: Record<string, string | Range>;
+    conditions?: string[];
     /**
-     * The parsed TypeScript configuration from the `tsconfig.json` file
+     * Array of strings indicating what conditions should be used for external modules.
      */
-    tsconfig: ParsedTypeScriptConfig;
+    externalConditions?: string[];
     /**
-     * The entry points of the source code
+     * Array of strings indicating what file extensions should be used for module resolution.
+     *
+     * @defaultValue `['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json']`
      */
-    entry: ResolvedEntryTypeDefinition[];
+    extensions?: string[];
     /**
-     * The virtual file system manager used during the build process to reference generated runtime files
+     * Array of strings indicating what modules should be deduplicated to a single version in the build.
+     *
+     * @remarks
+     * This option is useful for ensuring that only one version of a module is included in the bundle, which can help reduce bundle size and avoid conflicts.
      */
-    fs: VirtualFileSystemInterface;
+    dedupe?: string[];
     /**
-     * The Jiti module resolver
+     * Array of strings or regular expressions that indicate what modules are builtin for the environment.
      */
-    resolver: Resolver;
+    builtins?: (string | RegExp)[];
     /**
-     * The builtin module id that exist in the Powerlines virtual file system
+     * Configuration options for the preview server
      */
-    builtins: string[];
+    preview?: PreviewOptions;
     /**
-     * The Powerlines builtin virtual files
+     * A flag indicating whether the build is for a Server-Side Rendering environment.
      */
-    getBuiltins: () => Promise<VirtualFile[]>;
+    ssr?: boolean;
     /**
-     * Resolves a builtin virtual file and writes it to the VFS if it does not already exist
+     * Define if this environment is used for Server-Side Rendering
      *
-     * @param code - The source code of the builtin file
-     * @param id - The unique identifier of the builtin file
-     * @param path - An optional path to write the builtin file to
-     * @param options - Options for writing the file
+     * @defaultValue "server" (if it isn't the client environment)
      */
-    writeBuiltin: (code: string, id: string, path?: string, options?: PowerlinesWriteFileOptions) => Promise<void>;
+    consumer?: "client" | "server";
+}
+interface CommonUserConfig extends BaseConfig {
     /**
-     * Resolves a entry virtual file and writes it to the VFS if it does not already exist
+     * The type of project being built
      *
-     * @param code - The source code of the entry file
-     * @param path - An optional path to write the entry file to
-     * @param options - Options for writing the file
-     */
-    writeEntry: (code: string, path: string, options?: PowerlinesWriteFileOptions) => Promise<void>;
-    /**
-     * Parses the source code and returns a {@link ParseResult} object.
+     * @defaultValue "application"
      */
-    parse: (code: string, id: string, options?: ParserOptions | null) => Promise<ParseResult>;
+    type?: ProjectType;
     /**
-     * A function to update the context fields using a new user configuration options
+     * The root directory of the project
      */
-    withUserConfig: (userConfig: UserConfig, options?: InitContextOptions) => Promise<void>;
+    root: string;
     /**
-     * A function to update the context fields using inline configuration options
+     * The root directory of the project's source code
+     *
+     * @defaultValue "\{root\}/src"
      */
-    withInlineConfig: (inlineConfig: InlineConfig, options?: InitContextOptions) => Promise<void>;
+    sourceRoot?: string;
     /**
-     * Create a new logger instance
+     * A path to a custom configuration file to be used instead of the default `storm.json`, `powerlines.config.js`, or `powerlines.config.ts` files.
      *
-     * @param name - The name to use for the logger instance
-     * @returns A logger function
+     * @remarks
+     * This option is useful for running Powerlines commands with different configuration files, such as in CI/CD environments or when testing different configurations.
      */
-    createLog: (name: string | null) => LogFn;
+    configFile?: string;
     /**
-     * Extend the current logger instance with a new name
+     * Should the Powerlines CLI processes skip installing missing packages?
      *
-     * @param name - The name to use for the extended logger instance
-     * @returns A logger function
+     * @remarks
+     * This option is useful for CI/CD environments where the installation of packages is handled by a different process.
+     *
+     * @defaultValue false
      */
-    extendLog: (name: string) => LogFn;
-}
-interface APIContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig> {
+    skipInstalls?: boolean;
     /**
-     * The expected plugins options for the Powerlines project.
+     * Should the compiler processes skip any improvements that make use of cache?
      *
-     * @remarks
-     * This is a record of plugin identifiers to their respective options. This field is populated by the Powerlines engine during both plugin initialization and the `init` command.
+     * @defaultValue false
      */
-    plugins: Plugin<PluginContext<TResolvedConfig>>[];
+    skipCache?: boolean;
     /**
-     * A function to add a plugin to the context and update the configuration options
+     * A list of resolvable paths to plugins used during the build process
      */
-    addPlugin: (plugin: Plugin<PluginContext<TResolvedConfig>>) => Promise<void>;
+    plugins?: PluginConfig<PluginContext<any>>[];
     /**
-     * A table for storing the current context for each configured environment
+     * Environment-specific configurations
      */
-    environments: Record<string, EnvironmentContext<TResolvedConfig>>;
+    environments?: Record<string, EnvironmentConfig>;
     /**
-     * Retrieves the context for a specific environment by name
-     *
-     * @throws Will throw an error if the environment does not exist
-     *
-     * @param name - The name of the environment to retrieve. If not provided, the default environment is returned.
-     * @returns A promise that resolves to the environment context.
+     * A string identifier that allows a child framework or tool to identify itself when using Powerlines.
      *
-     * @example
-     * ```ts
-     * const devEnv = await apiContext.getEnvironment("development");
-     * const defaultEnv = await apiContext.getEnvironment();
-     * ```
+     * @defaultValue "powerlines"
      */
-    getEnvironment: (name?: string) => Promise<EnvironmentContext<TResolvedConfig>>;
+    framework?: string;
+}
+type UserConfig<TBuildConfig extends BuildConfig = BuildConfig, TBuildResolvedConfig extends BuildResolvedConfig = BuildResolvedConfig, TBuildVariant extends string = any> = CommonUserConfig & {
+    build?: TBuildConfig & {
+        /**
+         * The build variant being used by the Powerlines engine.
+         */
+        variant?: TBuildVariant;
+    };
+    override?: Partial<TBuildResolvedConfig>;
+};
+type WebpackUserConfig = UserConfig<WebpackBuildConfig, WebpackResolvedBuildConfig, "webpack">;
+type RspackUserConfig = UserConfig<RspackBuildConfig, RspackResolvedBuildConfig, "rspack">;
+type RollupUserConfig = UserConfig<RollupBuildConfig, RollupResolvedBuildConfig, "rollup">;
+type RolldownUserConfig = UserConfig<RolldownBuildConfig, RolldownResolvedBuildConfig, "rolldown">;
+type ViteUserConfig = UserConfig<ViteBuildConfig, ViteResolvedBuildConfig, "vite">;
+type ESBuildUserConfig = UserConfig<ESBuildBuildConfig, ESBuildResolvedBuildConfig, "esbuild">;
+type UnbuildUserConfig = UserConfig<UnbuildBuildConfig, UnbuildResolvedBuildConfig, "unbuild">;
+type TsupUserConfig = UserConfig<TsupBuildConfig, TsupResolvedBuildConfig, "tsup">;
+type FarmUserConfig = UserConfig<FarmBuildConfig, FarmResolvedBuildConfig, "farm">;
+type InferUserConfig<TBuildVariant extends BuildVariant | undefined> = TBuildVariant extends "webpack" ? WebpackUserConfig : TBuildVariant extends "rspack" ? RspackUserConfig : TBuildVariant extends "vite" ? ViteUserConfig : TBuildVariant extends "esbuild" ? ESBuildUserConfig : TBuildVariant extends "unbuild" ? UnbuildUserConfig : TBuildVariant extends "tsup" ? TsupUserConfig : TBuildVariant extends "rolldown" ? RolldownUserConfig : TBuildVariant extends "rollup" ? RollupUserConfig : TBuildVariant extends "farm" ? FarmUserConfig : UserConfig;
+type InitialUserConfig<TUserConfig extends UserConfig = UserConfig> = Partial<TUserConfig> & {
+    root: string;
+};
+type ParsedUserConfig<TUserConfig extends UserConfig = UserConfig> = TUserConfig & ResolvedConfig$1<TUserConfig> & {
     /**
-     * Safely retrieves the context for a specific environment by name
-     *
-     * @param name - The name of the environment to retrieve. If not provided, the default environment is returned.
-     * @returns A promise that resolves to the environment context, or undefined if the environment does not exist.
-     *
-     * @example
-     * ```ts
-     * const devEnv = await apiContext.getEnvironmentSafe("development");
-     * const defaultEnv = await apiContext.getEnvironmentSafe();
-     * ```
+     * The path to the user configuration file, if it exists.
      *
      * @remarks
-     * This method is similar to `getEnvironment`, but it returns `undefined` instead of throwing an error if the specified environment does not exist.
-     * This can be useful in scenarios where the existence of an environment is optional or uncertain.
-     *
-     * ```ts
-     * const testEnv = await apiContext.getEnvironmentSafe("test");
-     * if (testEnv) {
-     *   // Environment exists, safe to use it
-     * } else {
-     *   // Environment does not exist, handle accordingly
-     * }
-     * ```
-     *
-     * Using this method helps avoid unhandled exceptions in cases where an environment might not be defined.
+     * This is typically the `powerlines.json`, `powerlines.config.js`, or `powerlines.config.ts` file in the project root.
      */
-    getEnvironmentSafe: (name?: string) => Promise<EnvironmentContext<TResolvedConfig> | undefined>;
+    configFile?: ConfigLayer<TUserConfig>["configFile"];
+};
+type PowerlinesCommand = "new" | "prepare" | "build" | "lint" | "test" | "docs" | "release" | "clean";
+/**
+ * The configuration provided while executing Powerlines commands.
+ */
+type InlineConfig<TUserConfig extends UserConfig = UserConfig> = Partial<TUserConfig> & {
     /**
-     * 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.
+     * A string identifier for the Powerlines command being executed
      */
-    in: (environment: EnvironmentResolvedConfig) => Promise<EnvironmentContext<TResolvedConfig>>;
-}
-interface EnvironmentContextPlugin<TResolvedConfig extends ResolvedConfig = ResolvedConfig> {
-    plugin: Plugin<PluginContext<TResolvedConfig>>;
-    context: PluginContext<TResolvedConfig>;
-}
-interface EnvironmentContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig> {
+    command: PowerlinesCommand;
+};
+type NewInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & Required<Pick<InlineConfig<TUserConfig>, "root">> & {
     /**
-     * The expected plugins options for the Powerlines project.
-     *
-     * @remarks
-     * This is a record of plugin identifiers to their respective options. This field is populated by the Powerlines engine during both plugin initialization and the `init` command.
+     * A string identifier for the Powerlines command being executed
      */
-    plugins: EnvironmentContextPlugin<TResolvedConfig>[];
+    command: "new";
     /**
-     * A function to add a plugin to the context and update the configuration options
+     * The package name (from the \`package.json\`) for the project that will be used in the \`new\` command to create a new project based on this configuration
      */
-    addPlugin: (plugin: Plugin<PluginContext<TResolvedConfig>>) => Promise<void>;
+    packageName?: string;
+};
+type CleanInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
     /**
-     * The environment specific resolved configuration
+     * A string identifier for the Powerlines command being executed
      */
-    environment: EnvironmentResolvedConfig;
+    command: "clean";
+};
+type PrepareInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
     /**
-     * A table holding references to hook functions registered by plugins
+     * A string identifier for the Powerlines command being executed
      */
-    hooks: HooksList<PluginContext<TResolvedConfig>>;
+    command: "prepare";
+};
+type BuildInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
     /**
-     * Retrieves the hook handlers for a specific hook name
+     * A string identifier for the Powerlines command being executed
      */
-    selectHooks: <TKey extends HookKeys<PluginContext<TResolvedConfig>>>(hook: TKey, options?: SelectHooksOptions) => Hooks[TKey][];
-}
-interface PluginContext<out TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig>, UnpluginContext {
+    command: "build";
+};
+type LintInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
     /**
-     * The environment specific resolved configuration
+     * A string identifier for the Powerlines command being executed
      */
-    environment: EnvironmentResolvedConfig;
+    command: "lint";
+};
+type DocsInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
     /**
-     * An alternative property name for the {@link log} property
-     *
-     * @remarks
-     * This is provided for compatibility with other logging libraries that expect a `logger` property.
+     * A string identifier for the Powerlines command being executed
      */
-    logger: LogFn;
-}
-type BuildPluginContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> = PluginContext<TResolvedConfig> & Omit<UnpluginBuildContext, "parse">;
+    command: "docs";
+};
+type ReleaseInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    /**
+     * A string identifier for the Powerlines command being executed
+     */
+    command: "release";
+};
 
 export type { APIContext as A, BaseHookKeys as B, Context as C, InitialUserConfig as D, ESBuildResolvedBuildConfig as E, PrepareInlineConfig as F, CleanInlineConfig as G, HookKeys as H, InferHookParameters as I, BuildInlineConfig as J, LintInlineConfig as K, LogFn as L, MetaInfo as M, NewInlineConfig as N, DocsInlineConfig as O, PowerlinesCommand as P, ReleaseInlineConfig as Q, ResolvedEntryTypeDefinition as R, SelectHooksOptions as S, TsupBuildConfig as T, UnbuildBuildConfig as U, ViteResolvedBuildConfig as V, WorkspaceConfig as W, ParsedUserConfig as a, RolldownResolvedBuildConfig as b, RollupResolvedBuildConfig as c, TsupResolvedBuildConfig as d, PluginContext as e, ResolvedConfig as f, Plugin as g, PluginConfigObject as h, PluginConfigTuple as i, PluginConfig as j, PluginHookObject as k, PluginHook as l, EnvironmentConfig as m, EnvironmentResolvedConfig as n, ExternalHookKeys as o, BaseHooksListItem as p, WorkerProcess as q, EnvironmentContext as r, InferHookReturnType as s, UnbuildResolvedBuildConfig as t, BuildVariant as u, InferUnpluginVariant as v, BuildPlugin as w, InferResolvedConfig as x, UnpluginBuildVariant as y, InferUserConfig as z };