powerlines 0.36.28 → 0.37.0

package/dist/plugin-utils/{context-GdayEWcl.d.ts → context-BQTlTcfV.d.ts}

@@ -1,6 +1,6 @@
 import { EnvPaths } from '@stryke/env/get-env-paths';
 import { FetchRequestOptions } from '@stryke/http/fetch';
-import { MaybePromise, NonUndefined, FunctionLike, DeepPartial as DeepPartial$1 } from '@stryke/types/base';
+import { MaybePromise, NonUndefined, AnyFunction, DeepPartial as DeepPartial$1 } from '@stryke/types/base';
 import { PackageJson } from '@stryke/types/package-json';
 import { Jiti } from 'jiti';
 import { SourceMap } from 'magic-string';
@@ -8,21 +8,31 @@ import { ParserOptions, ParseResult } from 'oxc-parser';
 import { Range } from 'semver';
 import { Project } from 'ts-morph';
 import { RequestInfo, Response } from 'undici';
-import { TransformResult as TransformResult$1, ExternalIdResult, HookFilter, UnpluginOptions, UnpluginContext, UnpluginBuildContext, UnpluginMessage } from 'unplugin';
+import { UnpluginOptions as UnpluginOptions$1, HookFilter, TransformResult as TransformResult$1, ExternalIdResult, UnpluginContext, UnpluginBuildContext, UnpluginMessage } from 'unplugin';
 import { Format } from '@storm-software/build-tools/types';
 import { LogLevelLabel } from '@storm-software/config-tools/types';
 import { StormWorkspaceConfig } from '@storm-software/config/types';
 import { TypeDefinition, TypeDefinitionParameter } from '@stryke/types/configuration';
 import { AssetGlob } from '@stryke/types/file';
 import { DateString } from 'compatx';
-import { ResolvedPreviewOptions, PreviewOptions } from 'vite';
+import { UserConfig as UserConfig$1, DepOptimizationOptions, ResolvedPreviewOptions, PreviewOptions } from 'vite';
+import { UserConfig as UserConfig$3 } from '@farmfe/core';
+import { Configuration as Configuration$1 } from '@rspack/core';
+import { BuildOptions as BuildOptions$1 } from '@storm-software/tsup/types';
+import { UnbuildOptions } from '@storm-software/unbuild/types';
+import { BuildOptions } from 'esbuild';
+import { RolldownOptions } from 'rolldown';
+import { RollupOptions, OutputOptions, LoadResult } from 'rollup';
+import { UserConfig as UserConfig$2 } from 'tsdown';
+import { Configuration } from 'webpack';
 import { ResolveOptions as ResolveOptions$1 } from '@stryke/fs/resolve';
+import { ArrayValues } from '@stryke/types/array';
 import { TsConfigJson, CompilerOptions } from '@stryke/types/tsconfig';
 import ts from 'typescript';
-import { ArrayValues } from '@stryke/types/array';
 
-type UnpluginBuildVariant = "rollup" | "webpack" | "rspack" | "vite" | "esbuild" | "farm" | "unloader" | "rolldown";
-type BuildVariant = UnpluginBuildVariant | "tsup" | "tsdown" | "unbuild";
+type UnpluginBuilderVariant = "rollup" | "webpack" | "rspack" | "vite" | "esbuild" | "farm" | "unloader" | "rolldown" | "bun";
+type BuilderVariant = UnpluginBuilderVariant | "tsup" | "tsdown" | "unbuild";
+type InferUnpluginVariant<TBuildVariant extends BuilderVariant> = TBuildVariant extends "tsup" ? "esbuild" : TBuildVariant extends "tsdown" ? "rolldown" : TBuildVariant extends "unbuild" ? "rollup" : TBuildVariant;
 interface BuildConfig {
     /**
      * The platform to build the project for
@@ -163,6 +173,34 @@ interface BuildConfig {
     override?: Record<string, any>;
 }
 type BuildResolvedConfig = Omit<BuildConfig, "override">;
+type ESBuildBuildConfig = Omit<BuildOptions, "entryPoints" | "sourceRoot" | "platform" | "outdir" | "env" | "assets" | "external" | "inject" | "tsconfig" | "tsconfigRaw" | "logLevel"> & BuildConfig;
+type ESBuildResolvedBuildConfig = Omit<BuildOptions, "inject"> & BuildResolvedConfig;
+type ViteBuildConfig = Omit<UserConfig$1, "entry" | "entryPoints" | "tsconfig" | "tsconfigRaw" | "environments" | "output"> & BuildConfig & {
+    /**
+     * Optimize deps config
+     */
+    optimizeDeps?: Omit<DepOptimizationOptions, "extensions">;
+};
+type ViteResolvedBuildConfig = UserConfig$1 & BuildResolvedConfig;
+type WebpackBuildConfig = Omit<Configuration, "name" | "entry" | "entryPoints" | "tsconfig" | "tsconfigRaw"> & BuildConfig;
+type WebpackResolvedBuildConfig = Configuration & BuildResolvedConfig;
+type RspackBuildConfig = Omit<Configuration$1, "name" | "entry" | "entryPoints" | "tsconfig" | "tsconfigRaw"> & BuildConfig;
+type RspackResolvedBuildConfig = Configuration$1 & BuildResolvedConfig;
+type RollupBuildOutputConfig = Omit<OutputOptions, "dir" | "format">;
+type RollupBuildConfig = Omit<RollupOptions, "entry" | "external" | "input" | "output" | "logLevel"> & {
+    output: RollupBuildOutputConfig | RollupBuildOutputConfig[];
+} & BuildConfig;
+type RollupResolvedBuildConfig = RollupOptions & BuildResolvedConfig;
+type RolldownBuildConfig = Omit<RolldownOptions, "input" | "external" | "tsconfig" | "logLevel" | "output"> & BuildConfig;
+type RolldownResolvedBuildConfig = RolldownOptions & BuildResolvedConfig;
+type TsupBuildConfig = Partial<Omit<BuildOptions$1, "userOptions" | "tsconfig" | "tsconfigRaw" | "assets" | "outputPath" | "mode" | "format" | "platform" | "projectRoot" | "clean" | "env" | "entry" | "entryPoints" | "external" | "noExternal" | "skipNodeModulesBundle">> & BuildConfig;
+type TsupResolvedBuildConfig = BuildOptions$1 & BuildResolvedConfig;
+type TsdownBuildConfig = Partial<Omit<UserConfig$2, "name" | "outDir" | "clean" | "cwd" | "tsconfig" | "publicDir" | "copy" | "alias" | "format" | "platform" | "env" | "define" | "entry" | "external" | "noExternal" | "skipNodeModulesBundle">> & BuildConfig;
+type TsdownResolvedBuildConfig = UserConfig$2 & BuildResolvedConfig;
+type UnbuildBuildConfig = Partial<Omit<UnbuildOptions, "tsconfig" | "tsconfigRaw" | "assets" | "outputPath" | "mode" | "format" | "platform" | "projectRoot" | "env" | "entry" | "entryPoints">> & BuildConfig;
+type UnbuildResolvedBuildConfig = UnbuildOptions & BuildResolvedConfig;
+type FarmBuildConfig = Partial<Omit<UserConfig$3, "tsconfig" | "tsconfigRaw" | "assets" | "outputPath" | "mode" | "format" | "platform" | "projectRoot" | "env" | "entry" | "entryPoints">> & BuildConfig;
+type FarmResolvedBuildConfig = UserConfig$3 & BuildResolvedConfig;
 
 type StoragePreset = "fs" | "virtual";
 /**
@@ -708,7 +746,7 @@ type ResolvedConfig<TUserConfig extends UserConfig = UserConfig> = Omit<TUserCon
      * Configuration provided to build processes
      *
      * @remarks
-     * This configuration can be used by plugins during the `build` command. It will generally contain options specific to the selected {@link BuildVariant | build variant}.
+     * This configuration can be used by plugins during the `build` command. It will generally contain options specific to the selected {@link BuilderVariant | build variant}.
      */
     build: Omit<TUserConfig["build"], "override"> & Required<Pick<Required<TUserConfig["build"]>, "override">>;
     /**
@@ -718,8 +756,205 @@ type ResolvedConfig<TUserConfig extends UserConfig = UserConfig> = Omit<TUserCon
      */
     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 TsdownResolvedConfig = ResolvedConfig<TsdownUserConfig>;
+type UnbuildResolvedConfig = ResolvedConfig<UnbuildUserConfig>;
+type FarmResolvedConfig = ResolvedConfig<FarmUserConfig>;
+type InferResolvedConfig<TBuildVariant extends BuilderVariant | 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 "tsdown" ? TsdownResolvedConfig : TBuildVariant extends "rolldown" ? RolldownResolvedConfig : TBuildVariant extends "rollup" ? RollupResolvedConfig : TBuildVariant extends "farm" ? FarmResolvedConfig : ResolvedConfig;
+
+type HookListOrders = "preOrdered" | "preEnforced" | "normal" | "postEnforced" | "postOrdered";
+type UnpluginHookFunctions<TContext extends PluginContext = PluginContext, TUnpluginBuilderVariant extends UnpluginBuilderVariant = UnpluginBuilderVariant, TField extends keyof Required<UnpluginOptions$1>[TUnpluginBuilderVariant] = keyof Required<UnpluginOptions$1>[TUnpluginBuilderVariant]> = Required<UnpluginOptions$1>[TUnpluginBuilderVariant][TField] extends infer THandler | {
+    handler: infer THandler;
+} ? THandler extends (this: infer THandlerOriginalContext, ...args: infer THandlerArgs) => infer THandlerReturn ? (this: THandlerOriginalContext & WithUnpluginBuildContext<TContext>, ...args: THandlerArgs) => THandlerReturn : THandler extends {
+    handler: infer THandlerFunction;
+} ? THandlerFunction extends (this: infer THandlerFunctionOriginalContext, ...args: infer THandlerFunctionArgs) => infer THandlerFunctionReturn ? (this: THandlerFunctionOriginalContext & WithUnpluginBuildContext<TContext>, ...args: THandlerFunctionArgs) => THandlerFunctionReturn : never : never : never;
+interface PluginHooksListItem<TContext extends PluginContext = PluginContext, TFields extends PluginHookFields<TContext> = PluginHookFields<TContext>> {
+    plugin: Plugin<TContext>;
+    handler: PluginHookFunctions<TContext>[TFields];
+}
+type PluginHooksList<TContext extends PluginContext = PluginContext, TFields extends PluginHookFields<TContext> = PluginHookFields<TContext>> = {
+    [TKey in HookListOrders]?: PluginHooksListItem<TContext, TFields>[] | undefined;
+};
+interface UnpluginHooksListItem<TContext extends PluginContext = PluginContext, TUnpluginBuilderVariant extends UnpluginBuilderVariant = UnpluginBuilderVariant, TField extends keyof Required<UnpluginOptions$1>[TUnpluginBuilderVariant] = keyof Required<UnpluginOptions$1>[TUnpluginBuilderVariant]> {
+    plugin: Plugin<TContext>;
+    handler: UnpluginHookFunctions<TContext, TUnpluginBuilderVariant, TField>;
+}
+type UnpluginHookList<TContext extends PluginContext = PluginContext, TUnpluginBuilderVariant extends UnpluginBuilderVariant = UnpluginBuilderVariant, TField extends keyof UnpluginOptions$1[TUnpluginBuilderVariant] = keyof UnpluginOptions$1[TUnpluginBuilderVariant]> = {
+    [TKey in HookListOrders]?: UnpluginHooksListItem<TContext, TUnpluginBuilderVariant, TField>[] | undefined;
+};
+type UnpluginHookVariantField<TContext extends PluginContext = PluginContext, TUnpluginBuilderVariant extends UnpluginBuilderVariant = UnpluginBuilderVariant> = {
+    [TKey in keyof UnpluginOptions$1[TUnpluginBuilderVariant]]?: UnpluginHookList<TContext, TUnpluginBuilderVariant, TKey>;
+};
+type UnpluginHookVariant<TContext extends PluginContext = PluginContext> = {
+    [TKey in UnpluginBuilderVariant]?: UnpluginHookVariantField<TContext, TKey>;
+};
+type HookFields<TContext extends PluginContext = PluginContext> = PluginHookFields<TContext> | UnpluginBuilderVariant;
+type HooksList<TContext extends PluginContext = PluginContext> = {
+    [TField in HookFields<TContext>]?: TField extends PluginHookFields<TContext> ? PluginHooksList<TContext, TField> : TField extends UnpluginBuilderVariant ? UnpluginHookVariant<TContext>[TField] : never;
+};
+type InferHooksListItem<TContext extends PluginContext, TKey extends string> = TKey extends `${infer TUnpluginBuilderVariant}:${infer TUnpluginField}` ? TUnpluginBuilderVariant extends UnpluginBuilderVariant ? TUnpluginField extends keyof Required<UnpluginOptions$1>[TUnpluginBuilderVariant] ? UnpluginHooksListItem<TContext, TUnpluginBuilderVariant, TUnpluginField> : never : never : TKey extends keyof PluginHookFunctions<TContext> ? PluginHooksListItem<TContext, TKey> : never;
+type InferHookFunction<TContext extends PluginContext, TKey extends string> = TKey extends `${infer TUnpluginBuilderVariant}:${infer TUnpluginField}` ? TUnpluginBuilderVariant extends UnpluginBuilderVariant ? TUnpluginField extends keyof Required<UnpluginOptions$1>[TUnpluginBuilderVariant] ? UnpluginHookFunctions<TContext, TUnpluginBuilderVariant, TUnpluginField> : never : never : TKey extends keyof PluginHookFunctions<TContext> ? PluginHookFunctions<TContext>[TKey] : never;
+type InferHookReturnType<TContext extends PluginContext, TKey extends string> = ReturnType<InferHookFunction<TContext, TKey>>;
+type InferHookParameters<TContext extends PluginContext, TKey extends string> = Parameters<InferHookFunction<TContext, TKey>>;
+
+type CallHookOptions = SelectHooksOptions & (({
+    /**
+     * Whether to call the hooks sequentially or in parallel.
+     *
+     * @defaultValue true
+     */
+    sequential?: true;
+} & ({
+    /**
+     * How to handle multiple return values from hooks.
+     * - "merge": Merge all non-undefined return values (if they are objects).
+     * - "first": Return the first non-undefined value.
+     *
+     * @remarks
+     * Merging only works if the return values are objects.
+     *
+     * @defaultValue "merge"
+     */
+    result: "first";
+} | {
+    /**
+     * How to handle multiple return values from hooks.
+     * - "merge": Merge all non-undefined return values (if they are objects).
+     * - "first": Return the first non-undefined value.
+     *
+     * @remarks
+     * Merging only works if the return values are objects.
+     *
+     * @defaultValue "merge"
+     */
+    result?: "merge" | "last";
+    /**
+     * An indicator specifying if the results of the previous hook should be provided as the **first** parameter of the next hook function, or a function to process the result of the previous hook function and pass the returned value as the next hook's **first** parameter
+     */
+    asNextParam?: false | ((previousResult: any) => MaybePromise<any>);
+})) | {
+    /**
+     * Whether to call the hooks sequentially or in parallel.
+     */
+    sequential: false;
+});
+
+/**
+ * Powerlines API Interface
+ */
+interface API<TResolvedConfig extends ResolvedConfig = ResolvedConfig> {
+    /**
+     * The Powerlines shared API context
+     */
+    context: APIContext<TResolvedConfig>;
+    /**
+     * Prepare the Powerlines API
+     *
+     * @remarks
+     * This method will prepare the Powerlines API for use, initializing any necessary resources.
+     *
+     * @param inlineConfig - The inline configuration for the prepare command
+     */
+    prepare: (inlineConfig: PrepareInlineConfig | NewInlineConfig | CleanInlineConfig | BuildInlineConfig | LintInlineConfig | DocsInlineConfig | DeployInlineConfig) => Promise<void>;
+    /**
+     * Create a new Powerlines project
+     *
+     * @remarks
+     * This method will create a new Powerlines project in the current directory.
+     *
+     * @param inlineConfig - The inline configuration for the new command
+     * @returns A promise that resolves when the project has been created
+     */
+    new: (inlineConfig: NewInlineConfig) => Promise<void>;
+    /**
+     * Clean any previously prepared artifacts
+     *
+     * @remarks
+     * This method will remove the previous Powerlines artifacts from the project.
+     *
+     * @param inlineConfig - The inline configuration for the clean command
+     * @returns A promise that resolves when the clean command has completed
+     */
+    clean: (inlineConfig: CleanInlineConfig | PrepareInlineConfig) => Promise<void>;
+    /**
+     * Lint the project source code
+     *
+     * @param inlineConfig - The inline configuration for the lint command
+     * @returns A promise that resolves when the lint command has completed
+     */
+    lint: (inlineConfig: LintInlineConfig) => Promise<void>;
+    /**
+     * Build the project
+     *
+     * @remarks
+     * This method will build the Powerlines project, generating the necessary artifacts.
+     *
+     * @param inlineConfig - The inline configuration for the build command
+     * @returns A promise that resolves when the build command has completed
+     */
+    build: (inlineConfig: BuildInlineConfig) => Promise<void>;
+    /**
+     * Prepare the documentation for the project
+     *
+     * @param inlineConfig - The inline configuration for the docs command
+     * @returns A promise that resolves when the documentation generation has completed
+     */
+    docs: (inlineConfig: DocsInlineConfig) => Promise<void>;
+    /**
+     * Deploy the project source code
+     *
+     * @remarks
+     * This method will prepare and build the Powerlines project, generating the necessary artifacts for the deployment.
+     *
+     * @param inlineConfig - The inline configuration for the deploy command
+     */
+    deploy: (inlineConfig: DeployInlineConfig) => Promise<void>;
+    /**
+     * Finalization process
+     *
+     * @remarks
+     * This step includes any final processes or clean up required by Powerlines. It will be run after each Powerlines command.
+     *
+     * @returns A promise that resolves when the finalization process has completed
+     */
+    finalize: () => Promise<void>;
+    /**
+     * Invokes the configured plugin hooks
+     *
+     * @remarks
+     * By default, it will call the `"pre"`, `"normal"`, and `"post"` ordered hooks in sequence
+     *
+     * @param hook - The hook to call
+     * @param options - The options to provide to the hook
+     * @param args - The arguments to pass to the hook
+     * @returns The result of the hook call
+     */
+    callHook: <TKey extends string>(hook: TKey, options: CallHookOptions & {
+        environment?: string | EnvironmentContext<TResolvedConfig>;
+    }, ...args: InferHookParameters<PluginContext<TResolvedConfig>, TKey>) => Promise<InferHookReturnType<PluginContext<TResolvedConfig>, TKey> | undefined>;
+}
+
+interface UnpluginOptions<TUnpluginBuilderVariant extends UnpluginBuilderVariant = UnpluginBuilderVariant> extends UnpluginOptions$1 {
+    /**
+     * An API object that can be used for inter-plugin communication.
+     *
+     * @see https://rollupjs.org/plugin-development/#direct-plugin-communication
+     */
+    api: API<InferResolvedConfig<TUnpluginBuilderVariant>>;
+}
+type InferUnpluginOptions<TContext extends Context = Context, TBuilderVariant extends BuilderVariant = BuilderVariant, TUnpluginVariant extends InferUnpluginVariant<TBuilderVariant> = InferUnpluginVariant<TBuilderVariant>> = {
+    [TKey in keyof Required<UnpluginOptions<TUnpluginVariant>>[TUnpluginVariant]]?: Required<UnpluginOptions<TUnpluginVariant>>[TUnpluginVariant][TKey] extends infer THandler | {
+        handler: infer THandler;
+    } ? THandler extends (this: infer TOriginalContext, ...args: infer TArgs) => infer TReturn ? PluginHook<(this: TOriginalContext & TContext, ...args: TArgs) => MaybePromise<TReturn>, keyof HookFilter> : Required<UnpluginOptions<TUnpluginVariant>>[TUnpluginVariant][TKey] : Required<UnpluginOptions<TUnpluginVariant>>[TUnpluginVariant][TKey];
+};
 
-interface PluginHookObject<THookFunction extends FunctionLike, TFilter extends keyof HookFilter = never> {
+interface PluginHookObject<THookFunction extends AnyFunction, TFilter extends keyof HookFilter = never> {
     /**
      * The order in which the plugin should be applied.
      */
@@ -733,7 +968,7 @@ interface PluginHookObject<THookFunction extends FunctionLike, TFilter extends k
      */
     handler: THookFunction;
 }
-type PluginHook<THookFunction extends FunctionLike, TFilter extends keyof HookFilter = never> = THookFunction | PluginHookObject<THookFunction, TFilter>;
+type PluginHook<THookFunction extends AnyFunction, TFilter extends keyof HookFilter = never> = THookFunction | PluginHookObject<THookFunction, TFilter>;
 /**
  * A result returned by the plugin from the `types` hook that describes the declaration types output file.
  */
@@ -741,11 +976,9 @@ interface TypesResult {
     directives?: string[];
     code: string;
 }
-type DeepPartial<T> = {
-    [K in keyof T]?: DeepPartial<T[K]>;
-};
-type ConfigResult<TContext extends PluginContext = PluginContext> = DeepPartial<TContext["config"]> & Record<string, any>;
-interface BasePluginHookFunctions<TContext extends PluginContext = PluginContext> extends Record<CommandType, (this: TContext) => MaybePromise<void>> {
+type PluginHookFunctions<TContext extends PluginContext> = {
+    [TCommandType in CommandType]: (this: TContext) => MaybePromise<void>;
+} & {
     /**
      * A function that returns configuration options to be merged with the build context's options.
      *
@@ -760,7 +993,7 @@ interface BasePluginHookFunctions<TContext extends PluginContext = PluginContext
      * @param config - The partial configuration object to be modified.
      * @returns A promise that resolves to a partial configuration object.
      */
-    config: (this: UnresolvedContext<TContext["config"]>) => MaybePromise<ConfigResult<TContext>>;
+    config: (this: UnresolvedContext<TContext["config"]>) => MaybePromise<DeepPartial<TContext["config"]> & Record<string, any>>;
     /**
      * Modify environment configs before it's resolved. The hook can either mutate the passed-in environment config directly, or return a partial config object that will be deeply merged into existing config.
      *
@@ -822,7 +1055,7 @@ interface BasePluginHookFunctions<TContext extends PluginContext = PluginContext
      * @param id - The identifier of the source code.
      * @returns A promise that resolves when the hook is complete.
      */
-    load: (this: BuildPluginContext<TContext["config"]> & TContext, id: string) => MaybePromise<TransformResult$1>;
+    load: (this: BuildPluginContext<TContext["config"]> & TContext, id: string) => MaybePromise<LoadResult>;
     /**
      * A hook that is called to resolve the identifier of the source code.
      *
@@ -842,67 +1075,18 @@ interface BasePluginHookFunctions<TContext extends PluginContext = PluginContext
      * @returns A promise that resolves when the hook is complete.
      */
     writeBundle: (this: TContext) => MaybePromise<void>;
-}
-type BuildPlugin<TContext extends PluginContext = PluginContext, TBuildVariant extends UnpluginBuildVariant = UnpluginBuildVariant, TOptions extends Required<UnpluginOptions>[TBuildVariant] = Required<UnpluginOptions>[TBuildVariant]> = {
-    [TKey in keyof TOptions]: TOptions[TKey] extends FunctionLike ? (this: ThisParameterType<TOptions[TKey]> & TContext, ...args: Parameters<TOptions[TKey]>) => ReturnType<TOptions[TKey]> | MaybePromise<ReturnType<TOptions[TKey]>> : TOptions[TKey];
 };
-type ExternalPluginHookFunctionsVariant<TContext extends PluginContext = PluginContext, TBuildVariant extends UnpluginBuildVariant = UnpluginBuildVariant> = {
-    [TKey in keyof BuildPlugin<TContext, TBuildVariant> & string as `${TBuildVariant}:${TKey}`]: BuildPlugin<TContext, TBuildVariant>[TKey];
-};
-type ExternalPluginHookFunctions<TContext extends PluginContext> = ExternalPluginHookFunctionsVariant<TContext, "vite"> & ExternalPluginHookFunctionsVariant<TContext, "esbuild"> & ExternalPluginHookFunctionsVariant<TContext, "rolldown"> & ExternalPluginHookFunctionsVariant<TContext, "rollup"> & ExternalPluginHookFunctionsVariant<TContext, "webpack"> & ExternalPluginHookFunctionsVariant<TContext, "rspack"> & ExternalPluginHookFunctionsVariant<TContext, "farm">;
-type PluginHookFunctions<TContext extends PluginContext = PluginContext> = BasePluginHookFunctions<TContext> & ExternalPluginHookFunctions<TContext>;
-type PluginHooks<TContext extends PluginContext = PluginContext> = {
-    [TKey in keyof BasePluginHookFunctions<TContext>]: PluginHook<BasePluginHookFunctions<TContext>[TKey]>;
+type PluginHooks<TContext extends PluginContext> = {
+    [TPluginHook in keyof PluginHookFunctions<TContext>]?: PluginHook<PluginHookFunctions<TContext>[TPluginHook]>;
 } & {
-    /**
-     * A function that returns configuration options to be merged with the build context's options.
-     *
-     * @remarks
-     * Modify config before it's resolved. The hook can either mutate {@link Context.config} on the passed-in context directly, or return a partial config object that will be deeply merged into existing config.
-     *
-     * @warning User plugins are resolved before running this hook so injecting other plugins inside the config hook will have no effect. If you want to add plugins, consider doing so in the {@link Plugin.dependsOn} property instead.
-     *
-     * @see https://vitejs.dev/guide/api-plugin#config
-     *
-     * @param this - The build context.
-     * @param config - The partial configuration object to be modified.
-     * @returns A promise that resolves to a partial configuration object.
-     */
-    config: PluginHook<(this: UnresolvedContext<TContext["config"]>) => MaybePromise<ConfigResult<TContext>>> | ConfigResult<TContext>;
-    /**
-     * A hook that is called to transform the source code.
-     *
-     * @param this - The build context, unplugin build context, and unplugin context.
-     * @param code - The source code to transform.
-     * @param id - The identifier of the source code.
-     * @returns A promise that resolves when the hook is complete.
-     */
-    transform: PluginHook<(this: BuildPluginContext<TContext["config"]> & TContext, code: string, id: string) => MaybePromise<TransformResult$1>, "code" | "id">;
-    /**
-     * A hook that is called to load the source code.
-     *
-     * @param this - The build context, unplugin build context, and unplugin context.
-     * @param id - The identifier of the source code.
-     * @returns A promise that resolves when the hook is complete.
-     */
-    load: PluginHook<(this: BuildPluginContext<TContext["config"]> & TContext, id: string) => MaybePromise<TransformResult$1>, "id">;
-    /**
-     * A hook that is called to resolve the identifier of the source code.
-     *
-     * @param this - The build context, unplugin build context, and unplugin context.
-     * @param id - The identifier of the source code.
-     * @param importer - The importer of the source code.
-     * @param options - The options for resolving the identifier.
-     * @returns A promise that resolves when the hook is complete.
-     */
-    resolveId: PluginHook<(this: BuildPluginContext<TContext["config"]> & TContext, id: string, importer: string | undefined, options: {
-        isEntry: boolean;
-    }) => MaybePromise<string | ExternalIdResult | null | undefined>, "id">;
+    transform: PluginHook<PluginHookFunctions<TContext>["transform"], "code" | "id">;
+    load: PluginHook<PluginHookFunctions<TContext>["load"], "id">;
+    resolveId: PluginHook<PluginHookFunctions<TContext>["resolveId"], "id">;
 };
-type PluginBuildPlugins<TContext extends PluginContext = PluginContext> = {
-    [TBuildVariant in UnpluginBuildVariant]?: BuildPlugin<TContext, TBuildVariant>;
+type DeepPartial<T> = {
+    [K in keyof T]?: DeepPartial<T[K]>;
 };
-interface Plugin<TContext extends PluginContext<ResolvedConfig> = PluginContext<ResolvedConfig>> extends Partial<PluginHooks<TContext>>, PluginBuildPlugins<TContext> {
+type Plugin<TContext extends PluginContext<ResolvedConfig> = PluginContext<ResolvedConfig>> = Partial<PluginHooks<TContext>> & {
     /**
      * The name of the plugin, for use in deduplication, error messages and logs.
      */
@@ -950,7 +1134,25 @@ interface Plugin<TContext extends PluginContext<ResolvedConfig> = PluginContext<
      * @returns `true` if the plugin should be active in the specified environment, `false` otherwise.
      */
     applyToEnvironment?: (environment: EnvironmentResolvedConfig) => boolean | PluginConfig<TContext>;
-}
+    /**
+     * A function that returns configuration options to be merged with the build context's options.
+     *
+     * @remarks
+     * Modify config before it's resolved. The hook can either mutate {@link Context.config} on the passed-in context directly, or return a partial config object that will be deeply merged into existing config.
+     *
+     * @warning User plugins are resolved before running this hook so injecting other plugins inside the config hook will have no effect. If you want to add plugins, consider doing so in the {@link Plugin.dependsOn} property instead.
+     *
+     * @see https://vitejs.dev/guide/api-plugin#config
+     *
+     * @param this - The build context.
+     * @param config - The partial configuration object to be modified.
+     * @returns A promise that resolves to a partial configuration object.
+     */
+    config?: PluginHook<(this: UnresolvedContext<TContext["config"]>) => MaybePromise<DeepPartial<TContext["config"]> & Record<string, any>>> | (DeepPartial<TContext["config"]> & Record<string, any>);
+} & {
+    [TBuilderVariant in BuilderVariant]?: InferUnpluginOptions<TContext, TBuilderVariant>;
+};
+type PluginHookFields<TContext extends PluginContext = PluginContext> = keyof PluginHookFunctions<TContext>;
 
 type ReflectionMode = "default" | "explicit" | "never";
 type RawReflectionMode = ReflectionMode | "" | boolean | string | string[] | undefined;
@@ -1040,7 +1242,7 @@ type PluginConfigObject<TContext extends PluginContext = PluginContext, TOptions
  * A configuration tuple for a Powerlines plugin.
  */
 type PluginConfig<TContext extends PluginContext = PluginContext> = string | PluginFactory<TContext, void> | Plugin<TContext> | PluginConfigTuple<TContext> | PluginConfigObject<TContext> | Promise<PluginConfig<TContext>> | PluginConfig<TContext>[];
-type PartialPlugin<in out TContext extends PluginContext = PluginContext> = DeepPartial$1<Plugin<TContext>>;
+type PartialPlugin<TContext extends PluginContext = PluginContext> = DeepPartial$1<Plugin<TContext>>;
 type PartialPluginFactory<in out TContext extends PluginContext = PluginContext, TOptions = any> = (options: TOptions) => MaybePromise<PartialPlugin<TContext> | PartialPlugin<TContext>[]>;
 type ProjectType = "application" | "library";
 interface DeployConfig {
@@ -1366,6 +1568,16 @@ interface UserConfig<TBuildConfig extends BuildConfig = BuildConfig, TBuildResol
         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 TsdownUserConfig = UserConfig<TsdownBuildConfig, TsdownResolvedBuildConfig, "tsdown">;
+type FarmUserConfig = UserConfig<FarmBuildConfig, FarmResolvedBuildConfig, "farm">;
 type PowerlinesCommand = "new" | "prepare" | "build" | "lint" | "test" | "docs" | "deploy" | "clean";
 /**
  * The configuration provided while executing Powerlines commands.
@@ -1376,6 +1588,52 @@ type InlineConfig<TUserConfig extends UserConfig = UserConfig> = Partial<TUserCo
      */
     command: PowerlinesCommand;
 };
+type NewInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & Required<Pick<InlineConfig<TUserConfig>, "root">> & {
+    /**
+     * A string identifier for the Powerlines command being executed
+     */
+    command: "new";
+    /**
+     * 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
+     */
+    packageName?: string;
+};
+type CleanInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    /**
+     * A string identifier for the Powerlines command being executed
+     */
+    command: "clean";
+};
+type PrepareInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    /**
+     * 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
+     */
+    command: "build";
+};
+type LintInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    /**
+     * A string identifier for the Powerlines command being executed
+     */
+    command: "lint";
+};
+type DocsInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    /**
+     * A string identifier for the Powerlines command being executed
+     */
+    command: "docs";
+};
+type DeployInlineConfig<TUserConfig extends UserConfig = UserConfig> = InlineConfig<TUserConfig> & {
+    /**
+     * A string identifier for the Powerlines command being executed
+     */
+    command: "deploy";
+};
 
 interface MetaInfo {
     /**
@@ -1410,6 +1668,9 @@ interface TransformResult {
     code: string;
     map: SourceMap | null;
 }
+interface SelectHooksOptions {
+    order?: "pre" | "post" | "normal";
+}
 /**
  * Options for initializing or updating the context with new configuration values
  */
@@ -1746,6 +2007,112 @@ type Context<TResolvedConfig extends ResolvedConfig = ResolvedConfig> = Omit<Unr
      */
     config: TResolvedConfig;
 };
+interface APIContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig> {
+    /**
+     * 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.
+     */
+    plugins: Plugin<PluginContext<TResolvedConfig>>[];
+    /**
+     * A function to add a plugin to the context and update the configuration options
+     */
+    addPlugin: (plugin: Plugin<PluginContext<TResolvedConfig>>) => Promise<void>;
+    /**
+     * A table for storing the current context for each configured environment
+     */
+    environments: Record<string, EnvironmentContext<TResolvedConfig>>;
+    /**
+     * 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();
+     * ```
+     */
+    getEnvironment: (name?: string) => Promise<EnvironmentContext<TResolvedConfig>>;
+    /**
+     * 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.
+     */
+    getEnvironmentSafe: (name?: string) => Promise<EnvironmentContext<TResolvedConfig> | undefined>;
+    /**
+     * 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.
+     */
+    in: (environment: EnvironmentResolvedConfig) => Promise<EnvironmentContext<TResolvedConfig>>;
+    /**
+     * A function to merge all configured environments into a single context
+     *
+     * @returns A promise that resolves to the merged environment context.
+     */
+    toEnvironment: () => Promise<EnvironmentContext<TResolvedConfig>>;
+}
+interface EnvironmentContextPlugin<TResolvedConfig extends ResolvedConfig = ResolvedConfig> {
+    plugin: Plugin<PluginContext<TResolvedConfig>>;
+    context: PluginContext<TResolvedConfig>;
+}
+type SelectHookResultItem<TContext extends PluginContext, TKey extends string> = InferHooksListItem<TContext, TKey> & {
+    context: TContext;
+};
+type SelectHookResult<TContext extends PluginContext, TKey extends string> = SelectHookResultItem<TContext, TKey>[];
+interface EnvironmentContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig> {
+    /**
+     * 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.
+     */
+    plugins: EnvironmentContextPlugin<TResolvedConfig>[];
+    /**
+     * A function to add a plugin to the context and update the configuration options
+     */
+    addPlugin: (plugin: Plugin<PluginContext<TResolvedConfig>>) => Promise<void>;
+    /**
+     * The environment specific resolved configuration
+     */
+    environment: EnvironmentResolvedConfig;
+    /**
+     * A table holding references to hook functions registered by plugins
+     */
+    hooks: HooksList<PluginContext<TResolvedConfig>>;
+    /**
+     * Retrieves the hook handlers for a specific hook name
+     */
+    selectHooks: <TKey extends string>(key: TKey, options?: SelectHooksOptions) => SelectHookResult<PluginContext<TResolvedConfig>, TKey>;
+}
 interface PluginContext<out TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig>, UnpluginContext {
     /**
      * The environment specific resolved configuration
@@ -1760,5 +2127,6 @@ interface PluginContext<out TResolvedConfig extends ResolvedConfig = ResolvedCon
     logger: LogFn;
 }
 type BuildPluginContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> = UnpluginBuildContext & PluginContext<TResolvedConfig>;
+type WithUnpluginBuildContext<TContext extends PluginContext> = UnpluginBuildContext & TContext;
 
-export type { BuildVariant as B, ConfigResult as C, ExternalPluginHookFunctions as E, PluginContext as P, ResolvedConfig as R, TypesResult as T, UnresolvedContext as U, Plugin as a, PluginFactory as b, PartialPluginFactory as c, PartialPlugin as d, BasePluginHookFunctions as e, PluginHookFunctions as f, PluginHookObject as g, PluginConfigObject as h, PluginConfigTuple as i, PluginConfig as j, PluginHook as k, EnvironmentConfig as l, EnvironmentResolvedConfig as m };
+export type { BuilderVariant as B, EnvironmentConfig as E, HookFields as H, PluginContext as P, ResolvedConfig as R, TypesResult as T, UnresolvedContext as U, Plugin as a, PluginFactory as b, PartialPluginFactory as c, PartialPlugin as d, PluginConfigObject as e, PluginConfigTuple as f, PluginConfig as g, PluginHookObject as h, PluginHook as i, PluginHookFields as j, PluginHooksListItem as k, UnpluginBuilderVariant as l, UnpluginHooksListItem as m, PluginHooks as n, EnvironmentResolvedConfig as o, UnpluginOptions as p };