@powerlines/engine 0.47.4 → 0.49.2

package/dist/context/index.d.cts

@@ -1,150 +1,2 @@
-import { n as PowerlinesContext, r as PowerlinesBaseContext, t as PowerlinesExecutionContext } from "../execution-context-NyDjVZ6T.cjs";
-import { EngineContext, EngineOptions, EnvironmentContextPlugin, EnvironmentResolvedConfig, ExecutionOptions, ExecutionState, HooksList, InferOverridableConfig, LogFn, LogLevelResolvedConfig, Logger, LoggerOptions, Plugin, PluginContext, ResolvedConfig, SelectHookResult, SelectHooksOptions, UserConfig } from "@powerlines/core";
-import { DeepPartial, RequiredKeys } from "@stryke/types/base";
-import { Unstable_ContextInternal, Unstable_EnvironmentContext, Unstable_PluginContext } from "@powerlines/core/types/_internal";
-
-//#region src/context/engine-context.d.ts
-declare class PowerlinesEngineContext extends PowerlinesBaseContext implements EngineContext {
-  #private;
-  /**
-   * Creates a new instance of the PowerlinesEngineContext class.
-   *
-   * @param options - The options to initialize the context with.
-   * @returns A promise that resolves to an instance of the PowerlinesEngineContext class.
-   */
-  static fromInitialConfig(options: EngineOptions, initialConfig?: DeepPartial<UserConfig>): Promise<PowerlinesEngineContext>;
-  /**
-   * The initial options provided to the Powerlines process before any resolution or merging. This is typically the user configuration provided in the Powerlines configuration file, but may also include additional configuration options provided by plugins or other sources.
-   */
-  readonly initialOptions: EngineOptions;
-  /**
-   * The initial user configuration provided to the Powerlines process before any resolution or merging. This is typically the user configuration provided in the Powerlines configuration file, but may also include additional configuration options provided by plugins or other sources.
-   */
-  readonly initialConfig: DeepPartial<UserConfig>;
-  /**
-   * The options provided to the Powerlines process
-   */
-  options: RequiredKeys<Omit<EngineOptions, "logLevel">, "name" | "root" | "cwd" | "mode" | "framework"> & {
-    /**
-     * The log level to use for logging messages during the build process. This can be a string indicating the log level or a more detailed configuration object that allows for specifying different log levels for different categories of logs.
-     */
-    logLevel: LogLevelResolvedConfig;
-  };
-  /**
-   * Creates a new Context instance.
-   *
-   * @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
-   * @param initialConfig - The initial configuration provided by the user, which can be used to resolve the final configuration for the context. This typically includes the user configuration options defined in the `powerlines.config.ts` file, as well as any inline configuration options provided during execution.
-   */
-  protected constructor(options: EngineOptions, initialConfig?: DeepPartial<UserConfig>);
-  /**
-   * Initialize the context with the provided configuration options
-   *
-   * @remarks
-   * This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
-   */
-  protected init(): Promise<void>;
-  /**
-   * A list of all command executions that will be run during the lifecycle of the engine
-   *
-   * @returns An array of {@link ExecutionState} representing each execution context for the engine.
-   */
-  get executions(): ExecutionState[];
-}
-//#endregion
-//#region src/context/environment-context.d.ts
-declare class PowerlinesEnvironmentContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends PowerlinesContext<EnvironmentResolvedConfig<TResolvedConfig>> implements Unstable_EnvironmentContext<TResolvedConfig> {
-  #private;
-  /**
-   * Create a new context from the config.
-   *
-   * @param initialOptions - The resolved execution options.
-   * @param config - The user configuration options.
-   * @param overriddenConfig - The configuration options that should override all other configuration sources, such as CLI flags or environment variables. This is used to ensure that certain configuration values take precedence over any other settings defined in the user configuration or environment configuration, allowing for dynamic overrides based on the execution context.
-   * @param environment - The resolved environment configuration, which may include additional properties or modifications made during the configuration loading process. This is used to provide context about the environment in which the command is being executed, allowing for environment-specific behavior and configuration resolution.
-   * @returns A promise that resolves to an instance of the PowerlinesEnvironmentContext class, initialized with the provided configuration and environment data.
-   */
-  static createEnvironment<TResolvedConfig extends ResolvedConfig = ResolvedConfig>(initialOptions: ExecutionOptions, config: TResolvedConfig, overriddenConfig: InferOverridableConfig<EnvironmentResolvedConfig<TResolvedConfig>>, environment: EnvironmentResolvedConfig<TResolvedConfig>["environment"]): Promise<PowerlinesEnvironmentContext<TResolvedConfig>>;
-  /**
-   * The configuration options provided by plugins added by the user (and other plugins)
-   */
-  protected environmentConfig: EnvironmentResolvedConfig<TResolvedConfig>["environment"];
-  /**
-   * The list of plugins applied to this environment
-   */
-  plugins: EnvironmentContextPlugin<TResolvedConfig>[];
-  /**
-   * Internal context fields and methods
-   *
-   * @danger
-   * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-   *
-   * @internal
-   */
-  get $$internal(): Unstable_ContextInternal<TResolvedConfig>;
-  /**
-   * Internal context fields and methods
-   *
-   * @danger
-   * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-   *
-   * @internal
-   */
-  set $$internal(value: Unstable_ContextInternal<TResolvedConfig>);
-  /**
-   * The unique identifier of the environment associated with this context, which can be used for logging and other purposes to distinguish between different environments in the same process.
-   */
-  get id(): string;
-  /**
-   * The hooks registered by plugins in this environment
-   */
-  get hooks(): Record<string, HooksList<PluginContext<TResolvedConfig>>>;
-  /**
-   * A setter function to populate the environment config values provided during execution of the command, such as CLI flags or other parameters that may be relevant to the command being executed. This function can be used to update the context with the environment configuration values, which may be used during the configuration resolution process to ensure that the final configuration reflects both the user configuration and any environment configuration provided during execution.
-   *
-   * @param config - The environment configuration values to set.
-   * @returns A promise that resolves when the environment configuration values have been set.
-   */
-  protected setEnvironmentConfig(config: EnvironmentResolvedConfig<TResolvedConfig>["environment"]): Promise<void>;
-  /**
-   * Create a new logger instance
-   *
-   * @param options - The configuration options to use for the logger instance, which can be used to customize the appearance and behavior of the log messages generated by the logger. This is typically the name of the plugin or module that is creating the logger instance.
-   * @param logFn - The custom logging function to use for logging messages, which can be used to override the default logging behavior of the original logger.
-   * @returns A logger client instance that can be used to generate log messages with consistent formatting and metadata.
-   */
-  createLogger(options: LoggerOptions, logFn?: LogFn): Logger;
-  /**
-   * Extend the base logger with additional configuration options
-   *
-   * @param options - The configuration options to extend the base logger with, which can be used to add additional metadata or customize the appearance of log messages generated by the logger. This is typically the name of the plugin or module that is creating the logger instance, as well as any additional metadata such as the plugin category or environment.
-   * @returns A new logger client instance that extends the base logger with the provided configuration options.
-   */
-  extendLogger(options: LoggerOptions): Logger;
-  addPlugin(plugin: Plugin<PluginContext<TResolvedConfig>>): Promise<void>;
-  /**
-   * Retrieves the hook handlers for a specific hook name
-   */
-  selectHooks<TKey extends string>(key: TKey, options?: SelectHooksOptions): SelectHookResult<PluginContext<TResolvedConfig>, TKey>;
-  protected constructor(options: ExecutionOptions, config: TResolvedConfig, overriddenConfig: InferOverridableConfig<EnvironmentResolvedConfig<TResolvedConfig>>);
-  /**
-   * A function to merge the various configuration objects (initial, user, inline, and plugin) into a single resolved configuration object that can be used throughout the Powerlines process. This function takes into account the different sources of configuration and their respective priorities, ensuring that the final configuration reflects the intended settings for the project. The merged configuration is then returned as a new object that can be accessed through the `config` property of the context.
-   *
-   * @returns The merged configuration object that combines the initial, user, inline, and plugin configurations.
-   */
-  protected mergeConfig(): EnvironmentResolvedConfig<TResolvedConfig>;
-}
-//#endregion
-//#region src/context/plugin-context.d.ts
-/**
- * Create a Proxy-based PluginContext
- *
- * @param pluginId - The unique identifier of the plugin
- * @param plugin - The plugin instance
- * @param environment - The environment context
- * @returns The proxied plugin context
- */
-declare function createPluginContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig>(pluginId: string, plugin: Plugin<PluginContext<TResolvedConfig>>, environment: PowerlinesEnvironmentContext<TResolvedConfig>): Unstable_PluginContext<TResolvedConfig>;
-//#endregion
-export { PowerlinesBaseContext, PowerlinesContext, PowerlinesEngineContext, PowerlinesEnvironmentContext, PowerlinesExecutionContext, createPluginContext };
-//# sourceMappingURL=index.d.cts.map
+import { t as PowerlinesEngineContext } from "../engine-context-B8K6Jtkk.cjs";
+export { PowerlinesEngineContext };

package/dist/context/index.d.mts

@@ -1,150 +1,2 @@
-import { n as PowerlinesContext, r as PowerlinesBaseContext, t as PowerlinesExecutionContext } from "../execution-context-YrjFeD9k.mjs";
-import { EngineContext, EngineOptions, EnvironmentContextPlugin, EnvironmentResolvedConfig, ExecutionOptions, ExecutionState, HooksList, InferOverridableConfig, LogFn, LogLevelResolvedConfig, Logger, LoggerOptions, Plugin, PluginContext, ResolvedConfig, SelectHookResult, SelectHooksOptions, UserConfig } from "@powerlines/core";
-import { DeepPartial, RequiredKeys } from "@stryke/types/base";
-import { Unstable_ContextInternal, Unstable_EnvironmentContext, Unstable_PluginContext } from "@powerlines/core/types/_internal";
-
-//#region src/context/engine-context.d.ts
-declare class PowerlinesEngineContext extends PowerlinesBaseContext implements EngineContext {
-  #private;
-  /**
-   * Creates a new instance of the PowerlinesEngineContext class.
-   *
-   * @param options - The options to initialize the context with.
-   * @returns A promise that resolves to an instance of the PowerlinesEngineContext class.
-   */
-  static fromInitialConfig(options: EngineOptions, initialConfig?: DeepPartial<UserConfig>): Promise<PowerlinesEngineContext>;
-  /**
-   * The initial options provided to the Powerlines process before any resolution or merging. This is typically the user configuration provided in the Powerlines configuration file, but may also include additional configuration options provided by plugins or other sources.
-   */
-  readonly initialOptions: EngineOptions;
-  /**
-   * The initial user configuration provided to the Powerlines process before any resolution or merging. This is typically the user configuration provided in the Powerlines configuration file, but may also include additional configuration options provided by plugins or other sources.
-   */
-  readonly initialConfig: DeepPartial<UserConfig>;
-  /**
-   * The options provided to the Powerlines process
-   */
-  options: RequiredKeys<Omit<EngineOptions, "logLevel">, "name" | "root" | "cwd" | "mode" | "framework"> & {
-    /**
-     * The log level to use for logging messages during the build process. This can be a string indicating the log level or a more detailed configuration object that allows for specifying different log levels for different categories of logs.
-     */
-    logLevel: LogLevelResolvedConfig;
-  };
-  /**
-   * Creates a new Context instance.
-   *
-   * @param options - The options to use for creating the context, including the resolved configuration and workspace settings.
-   * @param initialConfig - The initial configuration provided by the user, which can be used to resolve the final configuration for the context. This typically includes the user configuration options defined in the `powerlines.config.ts` file, as well as any inline configuration options provided during execution.
-   */
-  protected constructor(options: EngineOptions, initialConfig?: DeepPartial<UserConfig>);
-  /**
-   * Initialize the context with the provided configuration options
-   *
-   * @remarks
-   * This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
-   */
-  protected init(): Promise<void>;
-  /**
-   * A list of all command executions that will be run during the lifecycle of the engine
-   *
-   * @returns An array of {@link ExecutionState} representing each execution context for the engine.
-   */
-  get executions(): ExecutionState[];
-}
-//#endregion
-//#region src/context/environment-context.d.ts
-declare class PowerlinesEnvironmentContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends PowerlinesContext<EnvironmentResolvedConfig<TResolvedConfig>> implements Unstable_EnvironmentContext<TResolvedConfig> {
-  #private;
-  /**
-   * Create a new context from the config.
-   *
-   * @param initialOptions - The resolved execution options.
-   * @param config - The user configuration options.
-   * @param overriddenConfig - The configuration options that should override all other configuration sources, such as CLI flags or environment variables. This is used to ensure that certain configuration values take precedence over any other settings defined in the user configuration or environment configuration, allowing for dynamic overrides based on the execution context.
-   * @param environment - The resolved environment configuration, which may include additional properties or modifications made during the configuration loading process. This is used to provide context about the environment in which the command is being executed, allowing for environment-specific behavior and configuration resolution.
-   * @returns A promise that resolves to an instance of the PowerlinesEnvironmentContext class, initialized with the provided configuration and environment data.
-   */
-  static createEnvironment<TResolvedConfig extends ResolvedConfig = ResolvedConfig>(initialOptions: ExecutionOptions, config: TResolvedConfig, overriddenConfig: InferOverridableConfig<EnvironmentResolvedConfig<TResolvedConfig>>, environment: EnvironmentResolvedConfig<TResolvedConfig>["environment"]): Promise<PowerlinesEnvironmentContext<TResolvedConfig>>;
-  /**
-   * The configuration options provided by plugins added by the user (and other plugins)
-   */
-  protected environmentConfig: EnvironmentResolvedConfig<TResolvedConfig>["environment"];
-  /**
-   * The list of plugins applied to this environment
-   */
-  plugins: EnvironmentContextPlugin<TResolvedConfig>[];
-  /**
-   * Internal context fields and methods
-   *
-   * @danger
-   * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-   *
-   * @internal
-   */
-  get $$internal(): Unstable_ContextInternal<TResolvedConfig>;
-  /**
-   * Internal context fields and methods
-   *
-   * @danger
-   * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-   *
-   * @internal
-   */
-  set $$internal(value: Unstable_ContextInternal<TResolvedConfig>);
-  /**
-   * The unique identifier of the environment associated with this context, which can be used for logging and other purposes to distinguish between different environments in the same process.
-   */
-  get id(): string;
-  /**
-   * The hooks registered by plugins in this environment
-   */
-  get hooks(): Record<string, HooksList<PluginContext<TResolvedConfig>>>;
-  /**
-   * A setter function to populate the environment config values provided during execution of the command, such as CLI flags or other parameters that may be relevant to the command being executed. This function can be used to update the context with the environment configuration values, which may be used during the configuration resolution process to ensure that the final configuration reflects both the user configuration and any environment configuration provided during execution.
-   *
-   * @param config - The environment configuration values to set.
-   * @returns A promise that resolves when the environment configuration values have been set.
-   */
-  protected setEnvironmentConfig(config: EnvironmentResolvedConfig<TResolvedConfig>["environment"]): Promise<void>;
-  /**
-   * Create a new logger instance
-   *
-   * @param options - The configuration options to use for the logger instance, which can be used to customize the appearance and behavior of the log messages generated by the logger. This is typically the name of the plugin or module that is creating the logger instance.
-   * @param logFn - The custom logging function to use for logging messages, which can be used to override the default logging behavior of the original logger.
-   * @returns A logger client instance that can be used to generate log messages with consistent formatting and metadata.
-   */
-  createLogger(options: LoggerOptions, logFn?: LogFn): Logger;
-  /**
-   * Extend the base logger with additional configuration options
-   *
-   * @param options - The configuration options to extend the base logger with, which can be used to add additional metadata or customize the appearance of log messages generated by the logger. This is typically the name of the plugin or module that is creating the logger instance, as well as any additional metadata such as the plugin category or environment.
-   * @returns A new logger client instance that extends the base logger with the provided configuration options.
-   */
-  extendLogger(options: LoggerOptions): Logger;
-  addPlugin(plugin: Plugin<PluginContext<TResolvedConfig>>): Promise<void>;
-  /**
-   * Retrieves the hook handlers for a specific hook name
-   */
-  selectHooks<TKey extends string>(key: TKey, options?: SelectHooksOptions): SelectHookResult<PluginContext<TResolvedConfig>, TKey>;
-  protected constructor(options: ExecutionOptions, config: TResolvedConfig, overriddenConfig: InferOverridableConfig<EnvironmentResolvedConfig<TResolvedConfig>>);
-  /**
-   * A function to merge the various configuration objects (initial, user, inline, and plugin) into a single resolved configuration object that can be used throughout the Powerlines process. This function takes into account the different sources of configuration and their respective priorities, ensuring that the final configuration reflects the intended settings for the project. The merged configuration is then returned as a new object that can be accessed through the `config` property of the context.
-   *
-   * @returns The merged configuration object that combines the initial, user, inline, and plugin configurations.
-   */
-  protected mergeConfig(): EnvironmentResolvedConfig<TResolvedConfig>;
-}
-//#endregion
-//#region src/context/plugin-context.d.ts
-/**
- * Create a Proxy-based PluginContext
- *
- * @param pluginId - The unique identifier of the plugin
- * @param plugin - The plugin instance
- * @param environment - The environment context
- * @returns The proxied plugin context
- */
-declare function createPluginContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig>(pluginId: string, plugin: Plugin<PluginContext<TResolvedConfig>>, environment: PowerlinesEnvironmentContext<TResolvedConfig>): Unstable_PluginContext<TResolvedConfig>;
-//#endregion
-export { PowerlinesBaseContext, PowerlinesContext, PowerlinesEngineContext, PowerlinesEnvironmentContext, PowerlinesExecutionContext, createPluginContext };
-//# sourceMappingURL=index.d.mts.map
+import { t as PowerlinesEngineContext } from "../engine-context-DKlA5Pgu.mjs";
+export { PowerlinesEngineContext };

package/dist/context/index.mjs

@@ -1,5 +1,3 @@
-import { n as PowerlinesEnvironmentContext, o as PowerlinesContext, r as createPluginContext, t as PowerlinesExecutionContext } from "../execution-context-CE5H90Um.mjs";
-import { t as PowerlinesBaseContext } from "../base-context-DUha4Lz-.mjs";
-import { t as PowerlinesEngineContext } from "../engine-context-BfFiKN53.mjs";
+import { PowerlinesEngineContext } from "./engine-context.mjs";
 
-export { PowerlinesBaseContext, PowerlinesContext, PowerlinesEngineContext, PowerlinesEnvironmentContext, PowerlinesExecutionContext, createPluginContext };
+export { PowerlinesEngineContext };

package/dist/context-D0_a0kRO.d.cts

@@ -0,0 +1,149 @@
+import { n as EngineOptions, t as EngineExecutionOptions, u as RpcClient } from "./config-DKEmqMrh.cjs";
+import { BaseContext, InlineConfig, ParsedUserConfig } from "@powerlines/core";
+import { ConnectionMeta, DevToolsNodeContext } from "devframe/types";
+
+//#region src/types/context.d.ts
+/**
+ * The execution scope state represents the current state of a command, hook, or plugin execution within the Powerlines engine. It includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+type ExecutionScopeType = "command" | "hook" | "plugin";
+/**
+ * The execution state for a command, hook, or plugin execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionScopeState {
+  /**
+   * The timestamp when the command, hook, or plugin execution started
+   */
+  timestamp: number;
+  /**
+   * The name of the command, hook, or plugin being executed
+   */
+  name: string;
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: ExecutionScopeType;
+}
+/**
+ * The execution state for a command execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionCommandScopeState extends ExecutionScopeState {
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "command";
+}
+/**
+ * The execution state for a hook execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionHookScopeState extends ExecutionScopeState {
+  /**
+   * The order of the hook being executed, which can be "pre", "post", or "normal". This indicates whether the hook is being executed
+   */
+  order?: "pre" | "post";
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "hook";
+}
+/**
+ * The execution state for a plugin execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionPluginScopeState extends ExecutionScopeState {
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "plugin";
+}
+/**
+ * The execution state for the Powerlines engine, which includes information about the currently active command, hook, and plugin executions. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionState {
+  /**
+   * The currently active command execution for this execution context
+   */
+  command: ExecutionCommandScopeState | null;
+  /**
+   * The currently active hook execution for this execution context, if any
+   */
+  hook: ExecutionHookScopeState | null;
+  /**
+   * The currently active plugin execution for this execution context, if any
+   */
+  plugin: ExecutionPluginScopeState | null;
+}
+/**
+ * The execution context for a command, hook, or plugin execution within the Powerlines engine. This context includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This context can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface EngineExecutionItem {
+  /**
+   * A unique identifier for the current invocation (a single invocation can include multiple executions).
+   */
+  invocationId: string;
+  /**
+   * The method being executed, which can be one of the supported Powerlines execution API methods such as "build", "docs", or "deploy". This indicates the specific command or action that is being executed within the Powerlines engine.
+   */
+  method: string;
+  /**
+   * The options provided to the Powerlines process for this execution
+   */
+  options: EngineExecutionOptions;
+  /**
+   * The parsed user configuration file provided to the Powerlines process before any resolution or merging
+   */
+  configFile: ParsedUserConfig;
+  /**
+   * An object representing the currently active command, hook, and plugin executions for this execution context
+   */
+  state: ExecutionState;
+}
+/**
+ * The Powerlines engine context.
+ *
+ * @remarks
+ * This context is used during the execution of the Powerlines engine, providing access to the input user configurations.
+ */
+interface EngineContext<TSystemContext = unknown> extends BaseContext<TSystemContext>, Pick<Required<EngineOptions>, "framework"> {
+  /**
+   * The options provided to the Powerlines process
+   */
+  options: EngineOptions;
+  /**
+   * The metadata information for the RPC connection
+   */
+  connection: ConnectionMeta;
+  /**
+   * The [Devframe](https://devtools.vite.dev/devframe/guide/) context for interacting with the DevTools.
+   *
+   * @see https://devtools.vite.dev/devframe/guide/
+   * @see https://github.com/vitejs/devtools/blob/main/devframe
+   */
+  devtools: DevToolsNodeContext;
+  /**
+   * A list of all command executions that will be run during the lifecycle of the engine
+   */
+  executions: EngineExecutionItem[];
+  /**
+   * Initialize the context with the provided configuration options
+   *
+   * @remarks
+   * This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
+   */
+  loadExecutions: (method: string, inlineConfig: InlineConfig) => Promise<EngineExecutionItem[]>;
+  /**
+   * Complete an execution by removing it from the list of active executions based on the provided invocation ID and execution ID. This method is typically called when an execution has finished or has been terminated, allowing the context to clean up any resources associated with that execution and update its internal state accordingly.
+   *
+   * @param invocationId - The unique identifier for the invocation of the execution to be completed.
+   * @param executionId - The unique identifier for the specific execution to be completed.
+   */
+  completeExecution: (invocationId: string, executionId: string) => void;
+}
+interface EngineSystemContext {
+  /**
+   * The RPC client instance used for communication between the engine and its worker threads, allowing for remote procedure calls to be made between the main thread and worker threads for tasks such as logging, file system operations, and other interactions that require communication between the different execution contexts within the Powerlines engine.
+   */
+  rpc: RpcClient;
+}
+//#endregion
+export { ExecutionHookScopeState as a, ExecutionScopeType as c, ExecutionCommandScopeState as i, ExecutionState as l, EngineExecutionItem as n, ExecutionPluginScopeState as o, EngineSystemContext as r, ExecutionScopeState as s, EngineContext as t };
+//# sourceMappingURL=context-D0_a0kRO.d.cts.map

package/dist/context-D0_a0kRO.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-D0_a0kRO.d.cts","names":[],"sources":["../src/types/context.ts"],"mappings":";;;;;;AA0BA;;KAAY,kBAAA;;AAAkB;AAK9B;UAAiB,mBAAA;;;;EAIf,SAAA;EAUA;;;EALA,IAAA;EAWe;;;EANf,IAAA,EAAM,kBAAkB;AAAA;AAgB1B;;;AAAA,UAViB,0BAAA,SAAmC,mBAAmB;EAUtB;;;EAN/C,IAAI;AAAA;AAqBN;;;AAAA,UAfiB,uBAAA,SAAgC,mBAAmB;EAmB9D;AAMN;;EArBE,KAAA;EAyBS;;;EApBT,IAAA;AAAA;;;;UAMe,yBAAA,SAAkC,mBAAmB;EAwBpE;;;EApBA,IAAI;AAAA;;;;UAMW,cAAA;EA4CR;;;EAxCP,OAAA,EAAS,0BAAA;EAyBT;;;EApBA,IAAA,EAAM,uBAAA;EA8BM;;;EAzBZ,MAAA,EAAQ,yBAAA;AAAA;AAuCV;;;AAAA,UAjCiB,mBAAA;EAoCC;;;EAhChB,YAAA;EAiDU;;;EA5CV,MAAA;EA4DK;;;EAvDL,OAAA,EAAS,sBAAA;EAsBH;;;EAjBN,UAAA,EAAY,gBAAA;EAiBV;;;EAZF,KAAA,EAAO,cAAA;AAAA;;;;;;;UASQ,aAAA,mCAEb,WAAA,CAAY,cAAA,GACZ,IAAA,CAAK,QAAA,CAAS,aAAA;EA+Bd;;;EA3BF,OAAA,EAAS,aAAA;EA6BI;;;EAxBb,UAAA,EAAY,cAAA;EAgCiD;AAAA;AAG/D;;;;EA3BE,QAAA,EAAU,mBAAA;;;;EAKV,UAAA,EAAY,mBAAA;;;;;;;EAQZ,cAAA,GACE,MAAA,UACA,YAAA,EAAc,YAAA,KACX,OAAA,CAAQ,mBAAA;;;;;;;EAQb,iBAAA,GAAoB,YAAA,UAAsB,WAAA;AAAA;AAAA,UAG3B,mBAAA;;;;EAIf,GAAA,EAAK,SAAS;AAAA"}

package/dist/context-DcXV6_GL.d.mts

@@ -0,0 +1,149 @@
+import { n as EngineOptions, t as EngineExecutionOptions, u as RpcClient } from "./config-ByLyzMI0.mjs";
+import { BaseContext, InlineConfig, ParsedUserConfig } from "@powerlines/core";
+import { ConnectionMeta, DevToolsNodeContext } from "devframe/types";
+
+//#region src/types/context.d.ts
+/**
+ * The execution scope state represents the current state of a command, hook, or plugin execution within the Powerlines engine. It includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+type ExecutionScopeType = "command" | "hook" | "plugin";
+/**
+ * The execution state for a command, hook, or plugin execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionScopeState {
+  /**
+   * The timestamp when the command, hook, or plugin execution started
+   */
+  timestamp: number;
+  /**
+   * The name of the command, hook, or plugin being executed
+   */
+  name: string;
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: ExecutionScopeType;
+}
+/**
+ * The execution state for a command execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionCommandScopeState extends ExecutionScopeState {
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "command";
+}
+/**
+ * The execution state for a hook execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionHookScopeState extends ExecutionScopeState {
+  /**
+   * The order of the hook being executed, which can be "pre", "post", or "normal". This indicates whether the hook is being executed
+   */
+  order?: "pre" | "post";
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "hook";
+}
+/**
+ * The execution state for a plugin execution within the Powerlines engine. This state includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionPluginScopeState extends ExecutionScopeState {
+  /**
+   * The type of execution scope, which can be "command", "hook", or "plugin". This indicates whether the execution state represents a command being executed, a hook being executed, or a plugin being executed.
+   */
+  type: "plugin";
+}
+/**
+ * The execution state for the Powerlines engine, which includes information about the currently active command, hook, and plugin executions. This state can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface ExecutionState {
+  /**
+   * The currently active command execution for this execution context
+   */
+  command: ExecutionCommandScopeState | null;
+  /**
+   * The currently active hook execution for this execution context, if any
+   */
+  hook: ExecutionHookScopeState | null;
+  /**
+   * The currently active plugin execution for this execution context, if any
+   */
+  plugin: ExecutionPluginScopeState | null;
+}
+/**
+ * The execution context for a command, hook, or plugin execution within the Powerlines engine. This context includes information about the name and type of the execution, as well as any relevant metadata such as the order of hook execution or the timestamp of when the execution started. This context can be used for logging, debugging, and other purposes to provide insight into the behavior of the Powerlines engine during its operation.
+ */
+interface EngineExecutionItem {
+  /**
+   * A unique identifier for the current invocation (a single invocation can include multiple executions).
+   */
+  invocationId: string;
+  /**
+   * The method being executed, which can be one of the supported Powerlines execution API methods such as "build", "docs", or "deploy". This indicates the specific command or action that is being executed within the Powerlines engine.
+   */
+  method: string;
+  /**
+   * The options provided to the Powerlines process for this execution
+   */
+  options: EngineExecutionOptions;
+  /**
+   * The parsed user configuration file provided to the Powerlines process before any resolution or merging
+   */
+  configFile: ParsedUserConfig;
+  /**
+   * An object representing the currently active command, hook, and plugin executions for this execution context
+   */
+  state: ExecutionState;
+}
+/**
+ * The Powerlines engine context.
+ *
+ * @remarks
+ * This context is used during the execution of the Powerlines engine, providing access to the input user configurations.
+ */
+interface EngineContext<TSystemContext = unknown> extends BaseContext<TSystemContext>, Pick<Required<EngineOptions>, "framework"> {
+  /**
+   * The options provided to the Powerlines process
+   */
+  options: EngineOptions;
+  /**
+   * The metadata information for the RPC connection
+   */
+  connection: ConnectionMeta;
+  /**
+   * The [Devframe](https://devtools.vite.dev/devframe/guide/) context for interacting with the DevTools.
+   *
+   * @see https://devtools.vite.dev/devframe/guide/
+   * @see https://github.com/vitejs/devtools/blob/main/devframe
+   */
+  devtools: DevToolsNodeContext;
+  /**
+   * A list of all command executions that will be run during the lifecycle of the engine
+   */
+  executions: EngineExecutionItem[];
+  /**
+   * Initialize the context with the provided configuration options
+   *
+   * @remarks
+   * This method will set up the resolver and load the user configuration file based on the provided options. It is called during the construction of the context and can also be called when cloning the context to ensure that the new context has the same configuration and resolver setup.
+   */
+  loadExecutions: (method: string, inlineConfig: InlineConfig) => Promise<EngineExecutionItem[]>;
+  /**
+   * Complete an execution by removing it from the list of active executions based on the provided invocation ID and execution ID. This method is typically called when an execution has finished or has been terminated, allowing the context to clean up any resources associated with that execution and update its internal state accordingly.
+   *
+   * @param invocationId - The unique identifier for the invocation of the execution to be completed.
+   * @param executionId - The unique identifier for the specific execution to be completed.
+   */
+  completeExecution: (invocationId: string, executionId: string) => void;
+}
+interface EngineSystemContext {
+  /**
+   * The RPC client instance used for communication between the engine and its worker threads, allowing for remote procedure calls to be made between the main thread and worker threads for tasks such as logging, file system operations, and other interactions that require communication between the different execution contexts within the Powerlines engine.
+   */
+  rpc: RpcClient;
+}
+//#endregion
+export { ExecutionHookScopeState as a, ExecutionScopeType as c, ExecutionCommandScopeState as i, ExecutionState as l, EngineExecutionItem as n, ExecutionPluginScopeState as o, EngineSystemContext as r, ExecutionScopeState as s, EngineContext as t };
+//# sourceMappingURL=context-DcXV6_GL.d.mts.map

package/dist/context-DcXV6_GL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-DcXV6_GL.d.mts","names":[],"sources":["../src/types/context.ts"],"mappings":";;;;;;AA0BA;;KAAY,kBAAA;;AAAkB;AAK9B;UAAiB,mBAAA;;;;EAIf,SAAA;EAUA;;;EALA,IAAA;EAWe;;;EANf,IAAA,EAAM,kBAAkB;AAAA;AAgB1B;;;AAAA,UAViB,0BAAA,SAAmC,mBAAmB;EAUtB;;;EAN/C,IAAI;AAAA;AAqBN;;;AAAA,UAfiB,uBAAA,SAAgC,mBAAmB;EAmB9D;AAMN;;EArBE,KAAA;EAyBS;;;EApBT,IAAA;AAAA;;;;UAMe,yBAAA,SAAkC,mBAAmB;EAwBpE;;;EApBA,IAAI;AAAA;;;;UAMW,cAAA;EA4CR;;;EAxCP,OAAA,EAAS,0BAAA;EAyBT;;;EApBA,IAAA,EAAM,uBAAA;EA8BM;;;EAzBZ,MAAA,EAAQ,yBAAA;AAAA;AAuCV;;;AAAA,UAjCiB,mBAAA;EAoCC;;;EAhChB,YAAA;EAiDU;;;EA5CV,MAAA;EA4DK;;;EAvDL,OAAA,EAAS,sBAAA;EAsBH;;;EAjBN,UAAA,EAAY,gBAAA;EAiBV;;;EAZF,KAAA,EAAO,cAAA;AAAA;;;;;;;UASQ,aAAA,mCAEb,WAAA,CAAY,cAAA,GACZ,IAAA,CAAK,QAAA,CAAS,aAAA;EA+Bd;;;EA3BF,OAAA,EAAS,aAAA;EA6BI;;;EAxBb,UAAA,EAAY,cAAA;EAgCiD;AAAA;AAG/D;;;;EA3BE,QAAA,EAAU,mBAAA;;;;EAKV,UAAA,EAAY,mBAAA;;;;;;;EAQZ,cAAA,GACE,MAAA,UACA,YAAA,EAAc,YAAA,KACX,OAAA,CAAQ,mBAAA;;;;;;;EAQb,iBAAA,GAAoB,YAAA,UAAsB,WAAA;AAAA;AAAA,UAG3B,mBAAA;;;;EAIf,GAAA,EAAK,SAAS;AAAA"}