@powerlines/engine 0.49.34 → 0.49.36

package/dist/helpers/stream.d.mts

@@ -1,2 +1,45 @@
-import { i as MessagePortWritable, n as MessagePortDuplexOptions, r as MessagePortReadable, t as MessagePortDuplex } from "../stream-B9jffNbk.mjs";
-export { MessagePortDuplex, MessagePortDuplexOptions, MessagePortReadable, MessagePortWritable };
+import { Duplex, DuplexOptions, Readable, ReadableOptions, Writable, WritableOptions } from "node:stream";
+import { MessagePort } from "node:worker_threads";
+
+//#region src/helpers/stream.d.ts
+declare const kPort: unique symbol;
+interface WritevChunk {
+  chunk: unknown;
+  encoding: BufferEncoding;
+}
+declare class MessagePortWritable extends Writable {
+  private [kPort];
+  constructor(port: MessagePort, options?: WritableOptions);
+  _write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _writev(data: WritevChunk[], callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  unref(): this;
+  ref(): this;
+}
+declare class MessagePortReadable extends Readable {
+  private [kPort];
+  constructor(port: MessagePort, options?: ReadableOptions);
+  _read(_size: number): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  unref(): this;
+  ref(): this;
+}
+interface MessagePortDuplexOptions extends DuplexOptions {
+  onActivityAbort?: () => void;
+}
+declare class MessagePortDuplex extends Duplex {
+  private [kPort];
+  private _activityAbortHandler?;
+  constructor(port: MessagePort, options?: MessagePortDuplexOptions);
+  _read(_size: number): void;
+  _write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _writev(data: WritevChunk[], callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+  unref(): this;
+  ref(): this;
+}
+//#endregion
+export { MessagePortDuplex, MessagePortDuplexOptions, MessagePortReadable, MessagePortWritable };
+//# sourceMappingURL=stream.d.mts.map

package/dist/helpers/stream.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.mts","names":[],"sources":["../../src/helpers/stream.ts"],"mappings":";;;;cA0BM,KAAA;AAAA,UAMI,WAAA;EACR,KAAA;EACA,QAAA,EAAU,cAAc;AAAA;AAAA,cAeb,mBAAA,SAA4B,QAAA;EAAA,SAC9B,KAAA;cAEU,IAAA,EAAM,WAAA,EAAa,OAAA,GAAU,eAAA;EAKhC,MAAA,CACd,KAAA,WACA,SAAA,EAAW,cAAA,EACX,QAAA,GAAW,KAAA,GAAQ,KAAA;EAOL,OAAA,CACd,IAAA,EAAM,WAAA,IACN,QAAA,GAAW,KAAA,GAAQ,KAAA;EAWL,MAAA,CAAO,QAAA,GAAW,KAAA,GAAQ,KAAA;EAK1B,QAAA,CACd,KAAA,EAAO,KAAA,SACP,QAAA,GAAW,KAAA,GAAQ,KAAA;EAKd,KAAA;EAKA,GAAA;AAAA;AAAA,cAMI,mBAAA,SAA4B,QAAA;EAAA,SAC9B,KAAA;cAEU,IAAA,EAAM,WAAA,EAAa,OAAA,GAAU,eAAA;EAQhC,KAAA,CAAM,KAAA;EAIN,QAAA,CACd,KAAA,EAAO,KAAA,SACP,QAAA,GAAW,KAAA,GAAQ,KAAA;EAQd,KAAA;EAKA,GAAA;AAAA;AAAA,UAMQ,wBAAA,SAAiC,aAAa;EAC7D,eAAe;AAAA;AAAA,cAGJ,iBAAA,SAA0B,MAAA;EAAA,SAC5B,KAAA;EAAA,QAED,qBAAA;cAEW,IAAA,EAAM,WAAA,EAAa,OAAA,GAAU,wBAAA;EAUhC,KAAA,CAAM,KAAA;EAIN,MAAA,CACd,KAAA,WACA,SAAA,EAAW,cAAA,EACX,QAAA,GAAW,KAAA,GAAQ,KAAA;EAUL,OAAA,CACd,IAAA,EAAM,WAAA,IACN,QAAA,GAAW,KAAA,GAAQ,KAAA;EAWL,MAAA,CAAO,QAAA,GAAW,KAAA,GAAQ,KAAA;EAK1B,QAAA,CACd,KAAA,EAAO,KAAA,SACP,QAAA,GAAW,KAAA,GAAQ,KAAA;EAQd,KAAA;EAKA,GAAA;AAAA"}

package/dist/helpers/type-checks.d.cts

@@ -1,2 +1,19 @@
-import { o as isApiExecutionOptions, s as isEngineExecutionOptions } from "../index-QuLZgb8w.cjs";
-export { isApiExecutionOptions, isEngineExecutionOptions };
+import { ApiExecutionOptions, EngineExecutionOptions } from "../types/config.cjs";
+//#region src/helpers/type-checks.d.ts
+/**
+ * Type guard to check if the provided options are EngineExecutionOptions. This is determined by checking for the presence of the "channel" property, which is specific to EngineExecutionOptions and not present in ApiExecutionOptions.
+ *
+ * @param options - The execution options to check, which can be either ApiExecutionOptions or EngineExecutionOptions.
+ * @returns True if the options are EngineExecutionOptions, false otherwise.
+ */
+declare function isEngineExecutionOptions(options: ApiExecutionOptions | EngineExecutionOptions): options is EngineExecutionOptions;
+/**
+ * Type guard to check if the provided options are ApiExecutionOptions. This is determined by checking for the absence of the "channel" property, which is specific to EngineExecutionOptions and not present in ApiExecutionOptions.
+ *
+ * @param options - The execution options to check, which can be either ApiExecutionOptions or EngineExecutionOptions.
+ * @returns True if the options are ApiExecutionOptions, false otherwise.
+ */
+declare function isApiExecutionOptions(options: ApiExecutionOptions | EngineExecutionOptions): options is ApiExecutionOptions;
+//#endregion
+export { isApiExecutionOptions, isEngineExecutionOptions };
+//# sourceMappingURL=type-checks.d.cts.map

package/dist/helpers/type-checks.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checks.d.cts","names":[],"sources":["../../src/helpers/type-checks.ts"],"mappings":";;;;;AA0BA;;;iBAAgB,wBAAA,CACd,OAAA,EAAS,mBAAA,GAAsB,sBAAA,GAC9B,OAAA,IAAW,sBAAA;;;;;;;iBAUE,qBAAA,CACd,OAAA,EAAS,mBAAA,GAAsB,sBAAA,GAC9B,OAAA,IAAW,mBAAA"}

package/dist/helpers/type-checks.d.mts

@@ -1,2 +1,19 @@
-import { o as isApiExecutionOptions, s as isEngineExecutionOptions } from "../index-CBobV6Wm.mjs";
-export { isApiExecutionOptions, isEngineExecutionOptions };
+import { ApiExecutionOptions, EngineExecutionOptions } from "../types/config.mjs";
+//#region src/helpers/type-checks.d.ts
+/**
+ * Type guard to check if the provided options are EngineExecutionOptions. This is determined by checking for the presence of the "channel" property, which is specific to EngineExecutionOptions and not present in ApiExecutionOptions.
+ *
+ * @param options - The execution options to check, which can be either ApiExecutionOptions or EngineExecutionOptions.
+ * @returns True if the options are EngineExecutionOptions, false otherwise.
+ */
+declare function isEngineExecutionOptions(options: ApiExecutionOptions | EngineExecutionOptions): options is EngineExecutionOptions;
+/**
+ * Type guard to check if the provided options are ApiExecutionOptions. This is determined by checking for the absence of the "channel" property, which is specific to EngineExecutionOptions and not present in ApiExecutionOptions.
+ *
+ * @param options - The execution options to check, which can be either ApiExecutionOptions or EngineExecutionOptions.
+ * @returns True if the options are ApiExecutionOptions, false otherwise.
+ */
+declare function isApiExecutionOptions(options: ApiExecutionOptions | EngineExecutionOptions): options is ApiExecutionOptions;
+//#endregion
+export { isApiExecutionOptions, isEngineExecutionOptions };
+//# sourceMappingURL=type-checks.d.mts.map

package/dist/helpers/type-checks.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checks.d.mts","names":[],"sources":["../../src/helpers/type-checks.ts"],"mappings":";;;;;AA0BA;;;iBAAgB,wBAAA,CACd,OAAA,EAAS,mBAAA,GAAsB,sBAAA,GAC9B,OAAA,IAAW,sBAAA;;;;;;;iBAUE,qBAAA,CACd,OAAA,EAAS,mBAAA,GAAsB,sBAAA,GAC9B,OAAA,IAAW,mBAAA"}

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_engine = require('./engine-BKEDCOCb.cjs');
 const require_context_engine_context = require('./context/engine-context.cjs');
+const require_engine = require('./engine.cjs');
 require('./context/index.cjs');
 
 exports.PowerlinesEngine = require_engine.PowerlinesEngine;

package/dist/index.d.cts

@@ -1,6 +1,7 @@
-import { C as RpcPayloadMetadata, D as WrappedRpcFunction, E as WrapRpcFunctions, O as WrappedRpcFunctions, S as RpcPayloadEnvelop, T as WrapRpcFunction, _ as RpcClientHost, a as RpcClientOptions, b as RpcFunction, c as InputRpcFunction, d as RpcClient, f as RpcClientCall, g as RpcClientFunctions, h as RpcClientEvents, i as EngineResolvedConfig, l as InputRpcFunctions, m as RpcClientCallOptional, n as EngineExecutionOptions, o as ExtractRpcFunction, p as RpcClientCallEvent, r as EngineOptions, s as ExtractRpcFunctions, t as ApiExecutionOptions, u as LogPayload, v as RpcClientRemoteFunctions, w as RpcServerFunctions, x as RpcFunctions, y as RpcContext } from "./config-B6udgcnD.cjs";
-import { a as ExecutionHookScopeState, c as ExecutionScopeType, i as ExecutionCommandScopeState, l as ExecutionState, n as EngineExecutionItem, o as ExecutionPluginScopeState, r as EngineSystemContext, s as ExecutionScopeState, t as EngineContext } from "./context-ZbJRDGpl.cjs";
-import { a as ExecutionInterface, i as ExecutionApiWorkerInterface, n as ExecutionApi, r as ExecutionApiParams, t as Engine } from "./index-QuLZgb8w.cjs";
-import { t as PowerlinesEngineContext } from "./engine-context-DDbpdZHC.cjs";
-import { n as createContext, r as createEngine, t as PowerlinesEngine } from "./engine-B5pbfMyg.cjs";
+import { ExtractRpcFunction, ExtractRpcFunctions, InputRpcFunction, InputRpcFunctions, LogPayload, RpcClient, RpcClientCall, RpcClientCallEvent, RpcClientCallOptional, RpcClientEvents, RpcClientFunctions, RpcClientHost, RpcClientRemoteFunctions, RpcContext, RpcFunction, RpcFunctions, RpcPayloadEnvelop, RpcPayloadMetadata, RpcServerFunctions, WrapRpcFunction, WrapRpcFunctions, WrappedRpcFunction, WrappedRpcFunctions } from "./types/rpc.cjs";
+import { ApiExecutionOptions, EngineExecutionOptions, EngineOptions, EngineResolvedConfig, RpcClientOptions } from "./types/config.cjs";
+import { EngineContext, EngineExecutionItem, EngineSystemContext, ExecutionCommandScopeState, ExecutionHookScopeState, ExecutionPluginScopeState, ExecutionScopeState, ExecutionScopeType, ExecutionState } from "./types/context.cjs";
+import { Engine, ExecutionApi, ExecutionApiParams, ExecutionApiWorkerInterface, ExecutionInterface } from "./types/api.cjs";
+import { PowerlinesEngineContext } from "./context/engine-context.cjs";
+import { PowerlinesEngine, createContext, createEngine } from "./engine.cjs";
 export { type ApiExecutionOptions, type Engine, type EngineContext, type EngineExecutionItem, type EngineExecutionOptions, type EngineOptions, type EngineResolvedConfig, type EngineSystemContext, type ExecutionApi, type ExecutionApiParams, type ExecutionApiWorkerInterface, type ExecutionCommandScopeState, type ExecutionHookScopeState, type ExecutionInterface, type ExecutionPluginScopeState, type ExecutionScopeState, type ExecutionScopeType, type ExecutionState, type ExtractRpcFunction, type ExtractRpcFunctions, type InputRpcFunction, type InputRpcFunctions, type LogPayload, PowerlinesEngine, PowerlinesEngineContext, type RpcClient, type RpcClientCall, type RpcClientCallEvent, type RpcClientCallOptional, type RpcClientEvents, type RpcClientFunctions, type RpcClientHost, type RpcClientOptions, type RpcClientRemoteFunctions, type RpcContext, type RpcFunction, type RpcFunctions, type RpcPayloadEnvelop, type RpcPayloadMetadata, type RpcServerFunctions, type WrapRpcFunction, type WrapRpcFunctions, type WrappedRpcFunction, type WrappedRpcFunctions, createContext, createEngine };

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-import { C as RpcPayloadMetadata, D as WrappedRpcFunction, E as WrapRpcFunctions, O as WrappedRpcFunctions, S as RpcPayloadEnvelop, T as WrapRpcFunction, _ as RpcClientHost, a as RpcClientOptions, b as RpcFunction, c as InputRpcFunction, d as RpcClient, f as RpcClientCall, g as RpcClientFunctions, h as RpcClientEvents, i as EngineResolvedConfig, l as InputRpcFunctions, m as RpcClientCallOptional, n as EngineExecutionOptions, o as ExtractRpcFunction, p as RpcClientCallEvent, r as EngineOptions, s as ExtractRpcFunctions, t as ApiExecutionOptions, u as LogPayload, v as RpcClientRemoteFunctions, w as RpcServerFunctions, x as RpcFunctions, y as RpcContext } from "./config-DXxu0y4t.mjs";
-import { a as ExecutionHookScopeState, c as ExecutionScopeType, i as ExecutionCommandScopeState, l as ExecutionState, n as EngineExecutionItem, o as ExecutionPluginScopeState, r as EngineSystemContext, s as ExecutionScopeState, t as EngineContext } from "./context-C71mv_aw.mjs";
-import { a as ExecutionInterface, i as ExecutionApiWorkerInterface, n as ExecutionApi, r as ExecutionApiParams, t as Engine } from "./index-CBobV6Wm.mjs";
-import { t as PowerlinesEngineContext } from "./engine-context-CaPJFek0.mjs";
-import { n as createContext, r as createEngine, t as PowerlinesEngine } from "./engine-CeWEM0TT.mjs";
+import { ExtractRpcFunction, ExtractRpcFunctions, InputRpcFunction, InputRpcFunctions, LogPayload, RpcClient, RpcClientCall, RpcClientCallEvent, RpcClientCallOptional, RpcClientEvents, RpcClientFunctions, RpcClientHost, RpcClientRemoteFunctions, RpcContext, RpcFunction, RpcFunctions, RpcPayloadEnvelop, RpcPayloadMetadata, RpcServerFunctions, WrapRpcFunction, WrapRpcFunctions, WrappedRpcFunction, WrappedRpcFunctions } from "./types/rpc.mjs";
+import { ApiExecutionOptions, EngineExecutionOptions, EngineOptions, EngineResolvedConfig, RpcClientOptions } from "./types/config.mjs";
+import { EngineContext, EngineExecutionItem, EngineSystemContext, ExecutionCommandScopeState, ExecutionHookScopeState, ExecutionPluginScopeState, ExecutionScopeState, ExecutionScopeType, ExecutionState } from "./types/context.mjs";
+import { Engine, ExecutionApi, ExecutionApiParams, ExecutionApiWorkerInterface, ExecutionInterface } from "./types/api.mjs";
+import { PowerlinesEngineContext } from "./context/engine-context.mjs";
+import { PowerlinesEngine, createContext, createEngine } from "./engine.mjs";
 export { type ApiExecutionOptions, type Engine, type EngineContext, type EngineExecutionItem, type EngineExecutionOptions, type EngineOptions, type EngineResolvedConfig, type EngineSystemContext, type ExecutionApi, type ExecutionApiParams, type ExecutionApiWorkerInterface, type ExecutionCommandScopeState, type ExecutionHookScopeState, type ExecutionInterface, type ExecutionPluginScopeState, type ExecutionScopeState, type ExecutionScopeType, type ExecutionState, type ExtractRpcFunction, type ExtractRpcFunctions, type InputRpcFunction, type InputRpcFunctions, type LogPayload, PowerlinesEngine, PowerlinesEngineContext, type RpcClient, type RpcClientCall, type RpcClientCallEvent, type RpcClientCallOptional, type RpcClientEvents, type RpcClientFunctions, type RpcClientHost, type RpcClientOptions, type RpcClientRemoteFunctions, type RpcContext, type RpcFunction, type RpcFunctions, type RpcPayloadEnvelop, type RpcPayloadMetadata, type RpcServerFunctions, type WrapRpcFunction, type WrapRpcFunctions, type WrappedRpcFunction, type WrappedRpcFunctions, createContext, createEngine };

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { n as createContext, r as createEngine, t as PowerlinesEngine } from "./engine-DRAFIm5M.mjs";
 import { PowerlinesEngineContext } from "./context/engine-context.mjs";
+import { PowerlinesEngine, createContext, createEngine } from "./engine.mjs";
 import "./context/index.mjs";
 
 export { PowerlinesEngine, PowerlinesEngineContext, createContext, createEngine };

package/dist/{index-CBobV6Wm.d.mts → types/api.d.cts}

@@ -1,34 +1,8 @@
-import { i as EngineResolvedConfig, n as EngineExecutionOptions, t as ApiExecutionOptions } from "./config-DXxu0y4t.mjs";
-import { r as EngineSystemContext, t as EngineContext } from "./context-C71mv_aw.mjs";
+import { EngineExecutionOptions, EngineResolvedConfig } from "./config.cjs";
+import { EngineContext, EngineSystemContext } from "./context.cjs";
+import { createApi } from "../helpers/create-api.cjs";
 import { BuildInlineConfig, CleanInlineConfig, CreateInlineConfig, DeployInlineConfig, DocsInlineConfig, ExecutionContext, ExecutionOptions, InlineConfig, LintInlineConfig, PrepareInlineConfig, TestInlineConfig, TypesInlineConfig } from "@powerlines/core";
-import { DeepPartial, MaybePromise } from "@stryke/types/base";
 
-//#region src/helpers/create-api.d.ts
-/**
- * Creates an execution API with the provided methods. Each method will be wrapped to create an execution context and handle errors appropriately.
- *
- * @param handlers - An object where keys are command names and values are functions that take an execution context and return a promise.
- * @param inlineConfig - An optional partial inline configuration object that will be merged with the context's options when creating the execution context for each command.
- * @returns A function that can be used as an execution API handler, which takes execution parameters and invokes the appropriate command handler with a properly constructed execution context.
- */
-declare function createApi<TContext extends ExecutionContext<EngineResolvedConfig, EngineSystemContext> = ExecutionContext<EngineResolvedConfig, EngineSystemContext>, TOptions extends ExecutionOptions = ExecutionOptions, THandlers extends Record<string, (context: TContext) => Promise<void>> = Record<string, (context: TContext) => Promise<void>>>(handlers: THandlers, inlineConfig?: DeepPartial<InlineConfig> | ((prev: InlineConfig) => MaybePromise<InlineConfig>)): (params: ExecutionApiParams<TOptions, keyof THandlers & string>) => Promise<void>;
-//#endregion
-//#region src/helpers/type-checks.d.ts
-/**
- * Type guard to check if the provided options are EngineExecutionOptions. This is determined by checking for the presence of the "channel" property, which is specific to EngineExecutionOptions and not present in ApiExecutionOptions.
- *
- * @param options - The execution options to check, which can be either ApiExecutionOptions or EngineExecutionOptions.
- * @returns True if the options are EngineExecutionOptions, false otherwise.
- */
-declare function isEngineExecutionOptions(options: ApiExecutionOptions | EngineExecutionOptions): options is EngineExecutionOptions;
-/**
- * Type guard to check if the provided options are ApiExecutionOptions. This is determined by checking for the absence of the "channel" property, which is specific to EngineExecutionOptions and not present in ApiExecutionOptions.
- *
- * @param options - The execution options to check, which can be either ApiExecutionOptions or EngineExecutionOptions.
- * @returns True if the options are ApiExecutionOptions, false otherwise.
- */
-declare function isApiExecutionOptions(options: ApiExecutionOptions | EngineExecutionOptions): options is ApiExecutionOptions;
-//#endregion
 //#region src/types/api.d.ts
 /**
  * The Powerlines Base API Interface
@@ -158,5 +132,5 @@ interface Engine extends ExecutionInterface {
 }
 type ExecutionApi = ReturnType<typeof createApi<ExecutionContext<EngineResolvedConfig, EngineSystemContext>, ExecutionOptions>>;
 //#endregion
-export { ExecutionInterface as a, createApi as c, ExecutionApiWorkerInterface as i, ExecutionApi as n, isApiExecutionOptions as o, ExecutionApiParams as r, isEngineExecutionOptions as s, Engine as t };
-//# sourceMappingURL=index-CBobV6Wm.d.mts.map
+export { Engine, ExecutionApi, ExecutionApiParams, ExecutionApiWorkerInterface, ExecutionInterface };
+//# sourceMappingURL=api.d.cts.map

package/dist/types/api.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.cts","names":[],"sources":["../../src/types/api.ts"],"mappings":";;;;;;;;;AA0CA;;;UAAiB,kBAAA;EASiC;;;;;;;;EAAhD,OAAA,GAAU,YAAA,EAAc,mBAAA,KAAwB,OAAA;EAgD3B;;;;;;;;EAtCrB,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;EA6ErB;;;;;;;;;EAlEvB,MAAA,GAAS,YAAA,EAAc,kBAAA,KAAuB,OAAA;EAA9C;;;;;;;;;EAWA,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;EAQrC;;;;;;EAAP,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EAmBpB;;;;;;EAXtB,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EA6B1C;;;;;;;AAUuB;AAGzB;EA/BE,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;EA+BX;;;;;;EAvBjC,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EAwChB;;;;;;;;EA9B1B,MAAA,GAAS,YAAA,EAAc,kBAAA,KAAuB,OAAA;EA8B9C;;;AAA0B;AAG5B;;;;EAvBE,QAAA,QAAgB,OAAA;AAAA;AAAA,UAGD,kBAAA,kBACE,gBAAA,GAAmB,gBAAA;EAyBb;;;EAnBvB,OAAA,EAAS,QAAA;EAgBE;;;EAXX,OAAA,EAAS,QAAA;EAaJ;;;EARL,YAAA,EAAc,YAAA;AAAA;AAAA,UAGC,2BAAA;EACf,OAAA,GACE,OAAA,UACA,OAAA,EAAS,sBAAA,EACT,YAAA,EAAc,YAAA,KACX,OAAA;EACL,QAAA,QAAgB,OAAA;AAAA;;;;UAMD,MAAA,SAAe,kBAAA;EAAA;;;EAI9B,OAAA,EAAS,aAAA;EAKJ;;AAA2B;EAAhC,GAAA,EAAK,2BAAA;AAAA;AAAA,KAGK,YAAA,GAAe,UAAA,QAClB,SAAA,CACL,gBAAA,CAAiB,oBAAA,EAAsB,mBAAA,GACvC,gBAAA"}

package/dist/{index-QuLZgb8w.d.cts → types/api.d.mts}

@@ -1,34 +1,8 @@
-import { i as EngineResolvedConfig, n as EngineExecutionOptions, t as ApiExecutionOptions } from "./config-B6udgcnD.cjs";
-import { r as EngineSystemContext, t as EngineContext } from "./context-ZbJRDGpl.cjs";
+import { EngineExecutionOptions, EngineResolvedConfig } from "./config.mjs";
+import { EngineContext, EngineSystemContext } from "./context.mjs";
+import { createApi } from "../helpers/create-api.mjs";
 import { BuildInlineConfig, CleanInlineConfig, CreateInlineConfig, DeployInlineConfig, DocsInlineConfig, ExecutionContext, ExecutionOptions, InlineConfig, LintInlineConfig, PrepareInlineConfig, TestInlineConfig, TypesInlineConfig } from "@powerlines/core";
-import { DeepPartial, MaybePromise } from "@stryke/types/base";
 
-//#region src/helpers/create-api.d.ts
-/**
- * Creates an execution API with the provided methods. Each method will be wrapped to create an execution context and handle errors appropriately.
- *
- * @param handlers - An object where keys are command names and values are functions that take an execution context and return a promise.
- * @param inlineConfig - An optional partial inline configuration object that will be merged with the context's options when creating the execution context for each command.
- * @returns A function that can be used as an execution API handler, which takes execution parameters and invokes the appropriate command handler with a properly constructed execution context.
- */
-declare function createApi<TContext extends ExecutionContext<EngineResolvedConfig, EngineSystemContext> = ExecutionContext<EngineResolvedConfig, EngineSystemContext>, TOptions extends ExecutionOptions = ExecutionOptions, THandlers extends Record<string, (context: TContext) => Promise<void>> = Record<string, (context: TContext) => Promise<void>>>(handlers: THandlers, inlineConfig?: DeepPartial<InlineConfig> | ((prev: InlineConfig) => MaybePromise<InlineConfig>)): (params: ExecutionApiParams<TOptions, keyof THandlers & string>) => Promise<void>;
-//#endregion
-//#region src/helpers/type-checks.d.ts
-/**
- * Type guard to check if the provided options are EngineExecutionOptions. This is determined by checking for the presence of the "channel" property, which is specific to EngineExecutionOptions and not present in ApiExecutionOptions.
- *
- * @param options - The execution options to check, which can be either ApiExecutionOptions or EngineExecutionOptions.
- * @returns True if the options are EngineExecutionOptions, false otherwise.
- */
-declare function isEngineExecutionOptions(options: ApiExecutionOptions | EngineExecutionOptions): options is EngineExecutionOptions;
-/**
- * Type guard to check if the provided options are ApiExecutionOptions. This is determined by checking for the absence of the "channel" property, which is specific to EngineExecutionOptions and not present in ApiExecutionOptions.
- *
- * @param options - The execution options to check, which can be either ApiExecutionOptions or EngineExecutionOptions.
- * @returns True if the options are ApiExecutionOptions, false otherwise.
- */
-declare function isApiExecutionOptions(options: ApiExecutionOptions | EngineExecutionOptions): options is ApiExecutionOptions;
-//#endregion
 //#region src/types/api.d.ts
 /**
  * The Powerlines Base API Interface
@@ -158,5 +132,5 @@ interface Engine extends ExecutionInterface {
 }
 type ExecutionApi = ReturnType<typeof createApi<ExecutionContext<EngineResolvedConfig, EngineSystemContext>, ExecutionOptions>>;
 //#endregion
-export { ExecutionInterface as a, createApi as c, ExecutionApiWorkerInterface as i, ExecutionApi as n, isApiExecutionOptions as o, ExecutionApiParams as r, isEngineExecutionOptions as s, Engine as t };
-//# sourceMappingURL=index-QuLZgb8w.d.cts.map
+export { Engine, ExecutionApi, ExecutionApiParams, ExecutionApiWorkerInterface, ExecutionInterface };
+//# sourceMappingURL=api.d.mts.map

package/dist/types/api.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.mts","names":[],"sources":["../../src/types/api.ts"],"mappings":";;;;;;;;;AA0CA;;;UAAiB,kBAAA;EASiC;;;;;;;;EAAhD,OAAA,GAAU,YAAA,EAAc,mBAAA,KAAwB,OAAA;EAgD3B;;;;;;;;EAtCrB,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;EA6ErB;;;;;;;;;EAlEvB,MAAA,GAAS,YAAA,EAAc,kBAAA,KAAuB,OAAA;EAA9C;;;;;;;;;EAWA,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;EAQrC;;;;;;EAAP,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EAmBpB;;;;;;EAXtB,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EA6B1C;;;;;;;AAUuB;AAGzB;EA/BE,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;EA+BX;;;;;;EAvBjC,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EAwChB;;;;;;;;EA9B1B,MAAA,GAAS,YAAA,EAAc,kBAAA,KAAuB,OAAA;EA8B9C;;;AAA0B;AAG5B;;;;EAvBE,QAAA,QAAgB,OAAA;AAAA;AAAA,UAGD,kBAAA,kBACE,gBAAA,GAAmB,gBAAA;EAyBb;;;EAnBvB,OAAA,EAAS,QAAA;EAgBE;;;EAXX,OAAA,EAAS,QAAA;EAaJ;;;EARL,YAAA,EAAc,YAAA;AAAA;AAAA,UAGC,2BAAA;EACf,OAAA,GACE,OAAA,UACA,OAAA,EAAS,sBAAA,EACT,YAAA,EAAc,YAAA,KACX,OAAA;EACL,QAAA,QAAgB,OAAA;AAAA;;;;UAMD,MAAA,SAAe,kBAAA;EAAA;;;EAI9B,OAAA,EAAS,aAAA;EAKJ;;AAA2B;EAAhC,GAAA,EAAK,2BAAA;AAAA;AAAA,KAGK,YAAA,GAAe,UAAA,QAClB,SAAA,CACL,gBAAA,CAAiB,oBAAA,EAAsB,mBAAA,GACvC,gBAAA"}

package/dist/types/config.d.cts

@@ -0,0 +1,72 @@
+import { RpcClientFunctions, RpcServerFunctions } from "./rpc.cjs";
+import { CustomLogger, ExecutionOptions, FrameworkOptions, Options, ResolvedConfig, UserConfig } from "@powerlines/core";
+import { PartialKeys, RequiredKeys } from "@stryke/types/base";
+import { BirpcOptions } from "birpc";
+import { RpcCacheOptions } from "devframe/rpc";
+import { WsRpcChannelOptions } from "devframe/rpc/transports/ws-client";
+import { ConnectionMeta, DevframeDefinition } from "devframe/types";
+
+//#region src/types/config.d.ts
+/**
+ * The options required to start the Powerlines engine.
+ */
+type EngineOptions = Omit<PartialKeys<DevframeDefinition, "name" | "setup">, "id" | "basePath"> & Options & {
+  /**
+   * The host URL for the engine's WebSocket server, which is used for communication between the engine and the various hosts (e.g., dev server, CLI, etc.) that interact with it. This value is required for the engine to function properly, as it allows the engine to establish a WebSocket connection and facilitate communication with other components of the system.
+   */
+  host?: string;
+  /**
+   * The port number to use for the websocket connection between the engine and the various hosts.
+   */
+  port?: number;
+  /**
+   * An optional root directory for the engine to use when resolving paths and loading configuration files. This value can be used to specify a custom root directory for the engine, which can be useful in cases where the default behavior of using the current working directory is not desirable. If this option is not provided, the engine will use the current working directory as the root directory by default.
+   */
+  root?: string;
+  /**
+   * A custom logger instance that implements the {@link CustomLogger} interface, which can be used for logging messages during the build process instead of the default Powerlines logger.
+   *
+   * @remarks
+   * Providing a custom logger allows you to integrate Powerlines logging with your own logging system or to customize the logging behavior, such as formatting log messages differently or sending logs to an external service. If a custom logger is not provided, Powerlines will use its default logger implementation.
+   */
+  customLogger?: CustomLogger;
+  /**
+   * The framework for which the engine is being used, which can be used by plugins to customize their behavior based on the specific framework being targeted. This value is optional and can be set to `undefined` if not applicable, but providing it allows plugins to make informed decisions about how to handle certain tasks or configurations based on the framework being used.
+   */
+  framework?: FrameworkOptions;
+};
+interface ApiExecutionOptions extends ExecutionOptions {}
+interface EngineExecutionOptions extends ExecutionOptions {
+  /**
+   * The base URL for the dev server, which can be used by plugins to construct URLs for assets or API endpoints during development. This value is only relevant in "dev" mode and will be `undefined` in "build" mode.
+   */
+  baseURL: string;
+  /**
+   * Metadata for the connection used by the dev server, including the backend type and websocket configuration.
+   */
+  connection: ConnectionMeta;
+  /**
+   * The {@link MessagePort} used for communication between the execution host and the engine. This port will be used to send and receive messages, allowing the execution host to invoke API methods and return results to the engine.
+   */
+  channel: MessagePort;
+  /**
+   * Options for configuring the WebSocket RPC channel used for communication between the dev server and the client, which can be used by plugins to customize the behavior of the WebSocket connection, such as setting custom timeouts, retry strategies, or other options.
+   */
+  wsOptions?: Partial<WsRpcChannelOptions>;
+  /**
+   * Options for configuring the RPC client used for communication between the dev server and the client, which can be used by plugins to customize the behavior of the RPC client, such as setting custom timeouts, retry strategies, or other options.
+   */
+  rpcOptions?: Partial<BirpcOptions<RpcServerFunctions, RpcClientFunctions, boolean>>;
+  /**
+   * Options for configuring the RPC cache used for caching RPC responses between the dev server and the client, which can be used by plugins to customize the behavior of the RPC cache, such as setting custom cache keys, expiration times, or other options.
+   *
+   * @remarks
+   * This option can be set to `true` to enable caching with default options, or it can be set to a configuration object that allows for fine-grained control over the caching behavior.
+   */
+  cacheOptions?: boolean | Partial<RpcCacheOptions>;
+}
+type RpcClientOptions = RequiredKeys<EngineExecutionOptions, "baseURL" | "connection">;
+type EngineResolvedConfig<TUserConfig extends UserConfig = UserConfig> = ResolvedConfig<TUserConfig, EngineExecutionOptions>;
+//#endregion
+export { ApiExecutionOptions, EngineExecutionOptions, EngineOptions, EngineResolvedConfig, RpcClientOptions };
+//# sourceMappingURL=config.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.cts","names":[],"sources":["../../src/types/config.ts"],"mappings":";;;;;;;;;;;AAoCA;KAAY,aAAA,GAAgB,IAAA,CAC1B,WAAA,CAAY,kBAAA,0CAGZ,OAAA;;;;EAIE,IAAA;EAJF;;;EASE,IAAA;EAkB4B;;;EAb5B,IAAA;EAdF;;;;;;EAsBE,YAAA,GAAe,YAAA;EAKH;;AAAgB;EAA5B,SAAA,GAAY,gBAAA;AAAA;AAAA,UAGC,mBAAA,SAA4B,gBAAgB;AAAA,UAE5C,sBAAA,SAA+B,gBAAA;EAA/B;;;EAIf,OAAA;EAUS;;;EALT,UAAA,EAAY,cAAA;EAgBuB;;;EAXnC,OAAA,EAAS,WAAA;EAoBgB;;;EAfzB,SAAA,GAAY,OAAA,CAAQ,mBAAA;EAnB0B;;;EAwB9C,UAAA,GAAa,OAAA,CACX,YAAA,CAAa,kBAAA,EAAoB,kBAAA;EAXnC;;;;;;EAoBA,YAAA,aAAyB,OAAA,CAAQ,eAAA;AAAA;AAAA,KAGvB,gBAAA,GAAmB,YAAY,CACzC,sBAAA;AAAA,KAIU,oBAAA,qBAAyC,UAAA,GAAa,UAAA,IAChE,cAAA,CAAe,WAAA,EAAa,sBAAA"}

package/dist/types/config.d.mts

@@ -0,0 +1,72 @@
+import { RpcClientFunctions, RpcServerFunctions } from "./rpc.mjs";
+import { CustomLogger, ExecutionOptions, FrameworkOptions, Options, ResolvedConfig, UserConfig } from "@powerlines/core";
+import { RpcCacheOptions } from "devframe/rpc";
+import { WsRpcChannelOptions } from "devframe/rpc/transports/ws-client";
+import { PartialKeys, RequiredKeys } from "@stryke/types/base";
+import { BirpcOptions } from "birpc";
+import { ConnectionMeta, DevframeDefinition } from "devframe/types";
+
+//#region src/types/config.d.ts
+/**
+ * The options required to start the Powerlines engine.
+ */
+type EngineOptions = Omit<PartialKeys<DevframeDefinition, "name" | "setup">, "id" | "basePath"> & Options & {
+  /**
+   * The host URL for the engine's WebSocket server, which is used for communication between the engine and the various hosts (e.g., dev server, CLI, etc.) that interact with it. This value is required for the engine to function properly, as it allows the engine to establish a WebSocket connection and facilitate communication with other components of the system.
+   */
+  host?: string;
+  /**
+   * The port number to use for the websocket connection between the engine and the various hosts.
+   */
+  port?: number;
+  /**
+   * An optional root directory for the engine to use when resolving paths and loading configuration files. This value can be used to specify a custom root directory for the engine, which can be useful in cases where the default behavior of using the current working directory is not desirable. If this option is not provided, the engine will use the current working directory as the root directory by default.
+   */
+  root?: string;
+  /**
+   * A custom logger instance that implements the {@link CustomLogger} interface, which can be used for logging messages during the build process instead of the default Powerlines logger.
+   *
+   * @remarks
+   * Providing a custom logger allows you to integrate Powerlines logging with your own logging system or to customize the logging behavior, such as formatting log messages differently or sending logs to an external service. If a custom logger is not provided, Powerlines will use its default logger implementation.
+   */
+  customLogger?: CustomLogger;
+  /**
+   * The framework for which the engine is being used, which can be used by plugins to customize their behavior based on the specific framework being targeted. This value is optional and can be set to `undefined` if not applicable, but providing it allows plugins to make informed decisions about how to handle certain tasks or configurations based on the framework being used.
+   */
+  framework?: FrameworkOptions;
+};
+interface ApiExecutionOptions extends ExecutionOptions {}
+interface EngineExecutionOptions extends ExecutionOptions {
+  /**
+   * The base URL for the dev server, which can be used by plugins to construct URLs for assets or API endpoints during development. This value is only relevant in "dev" mode and will be `undefined` in "build" mode.
+   */
+  baseURL: string;
+  /**
+   * Metadata for the connection used by the dev server, including the backend type and websocket configuration.
+   */
+  connection: ConnectionMeta;
+  /**
+   * The {@link MessagePort} used for communication between the execution host and the engine. This port will be used to send and receive messages, allowing the execution host to invoke API methods and return results to the engine.
+   */
+  channel: MessagePort;
+  /**
+   * Options for configuring the WebSocket RPC channel used for communication between the dev server and the client, which can be used by plugins to customize the behavior of the WebSocket connection, such as setting custom timeouts, retry strategies, or other options.
+   */
+  wsOptions?: Partial<WsRpcChannelOptions>;
+  /**
+   * Options for configuring the RPC client used for communication between the dev server and the client, which can be used by plugins to customize the behavior of the RPC client, such as setting custom timeouts, retry strategies, or other options.
+   */
+  rpcOptions?: Partial<BirpcOptions<RpcServerFunctions, RpcClientFunctions, boolean>>;
+  /**
+   * Options for configuring the RPC cache used for caching RPC responses between the dev server and the client, which can be used by plugins to customize the behavior of the RPC cache, such as setting custom cache keys, expiration times, or other options.
+   *
+   * @remarks
+   * This option can be set to `true` to enable caching with default options, or it can be set to a configuration object that allows for fine-grained control over the caching behavior.
+   */
+  cacheOptions?: boolean | Partial<RpcCacheOptions>;
+}
+type RpcClientOptions = RequiredKeys<EngineExecutionOptions, "baseURL" | "connection">;
+type EngineResolvedConfig<TUserConfig extends UserConfig = UserConfig> = ResolvedConfig<TUserConfig, EngineExecutionOptions>;
+//#endregion
+export { ApiExecutionOptions, EngineExecutionOptions, EngineOptions, EngineResolvedConfig, RpcClientOptions };
+//# sourceMappingURL=config.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../src/types/config.ts"],"mappings":";;;;;;;;;;;AAoCA;KAAY,aAAA,GAAgB,IAAA,CAC1B,WAAA,CAAY,kBAAA,0CAGZ,OAAA;;;;EAIE,IAAA;EAJF;;;EASE,IAAA;EAkB4B;;;EAb5B,IAAA;EAdF;;;;;;EAsBE,YAAA,GAAe,YAAA;EAKH;;AAAgB;EAA5B,SAAA,GAAY,gBAAA;AAAA;AAAA,UAGC,mBAAA,SAA4B,gBAAgB;AAAA,UAE5C,sBAAA,SAA+B,gBAAA;EAA/B;;;EAIf,OAAA;EAUS;;;EALT,UAAA,EAAY,cAAA;EAgBuB;;;EAXnC,OAAA,EAAS,WAAA;EAoBgB;;;EAfzB,SAAA,GAAY,OAAA,CAAQ,mBAAA;EAnB0B;;;EAwB9C,UAAA,GAAa,OAAA,CACX,YAAA,CAAa,kBAAA,EAAoB,kBAAA;EAXnC;;;;;;EAoBA,YAAA,aAAyB,OAAA,CAAQ,eAAA;AAAA;AAAA,KAGvB,gBAAA,GAAmB,YAAY,CACzC,sBAAA;AAAA,KAIU,oBAAA,qBAAyC,UAAA,GAAa,UAAA,IAChE,cAAA,CAAe,WAAA,EAAa,sBAAA"}

package/dist/{context-C71mv_aw.d.mts → types/context.d.cts}

@@ -1,4 +1,5 @@
-import { d as RpcClient, n as EngineExecutionOptions, r as EngineOptions } from "./config-DXxu0y4t.mjs";
+import { RpcClient } from "./rpc.cjs";
+import { EngineExecutionOptions, EngineOptions } from "./config.cjs";
 import { BaseContext, InlineConfig, ParsedUserConfig } from "@powerlines/core";
 import { ConnectionMeta, DevToolsNodeContext } from "devframe/types";
 
@@ -145,5 +146,5 @@ interface EngineSystemContext {
   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-C71mv_aw.d.mts.map
+export { EngineContext, EngineExecutionItem, EngineSystemContext, ExecutionCommandScopeState, ExecutionHookScopeState, ExecutionPluginScopeState, ExecutionScopeState, ExecutionScopeType, ExecutionState };
+//# sourceMappingURL=context.d.cts.map

package/dist/types/context.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.cts","names":[],"sources":["../../src/types/context.ts"],"mappings":";;;;;;;;AA0BA;KAAY,kBAAA;;;AAAkB;UAKb,mBAAA;EAAmB;;;EAIlC,SAAA;EAKA;;;EAAA,IAAA;EAKwB;AAM1B;;EANE,IAAA,EAAM,kBAAkB;AAAA;AAUpB;AAMN;;AANM,UAJW,0BAAA,SAAmC,mBAAmB;EAUH;;;EANlE,IAAI;AAAA;AAeA;AAMN;;AANM,UATW,uBAAA,SAAgC,mBAAmB;EAejB;AAI7C;AAMN;EArBE,KAAA;;;;EAKA,IAAA;AAAA;;;;UAMe,yBAAA,SAAkC,mBAAmB;EAmB9D;;;EAfN,IAAI;AAAA;AA0BN;;;AAAA,UApBiB,cAAA;EAkCN;;;EA9BT,OAAA,EAAS,0BAAA;EAwCY;;;EAnCrB,IAAA,EAAM,uBAAA;EAyBG;;;EApBT,MAAA,EAAQ,yBAAA;AAAA;;;AA8Ba;UAxBN,mBAAA;EAiCa;;;EA7B5B,YAAA;EAgCO;;;EA3BP,OAAA;EAiDY;;;EA5CZ,OAAA,EAAS,IAAA,CAAK,sBAAA;EAqBZ;;;EAhBF,UAAA,EAAY,gBAAA;EAciB;;;EAT7B,KAAA,EAAO,cAAA;AAAA;;;;;;;UASQ,aAAA,mCAEb,WAAA,CAAY,cAAA,GACZ,IAAA,CAAK,QAAA,CAAS,aAAA;EAsBhB;;;EAlBA,OAAA,EAAS,aAAA;EA4BO;;;EAvBhB,UAAA,EAAY,cAAA;EAgCZ;;;;AAA6D;AAG/D;EA3BE,QAAA,EAAU,mBAAA;;;AA+BI;EA1Bd,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-ZbJRDGpl.d.cts → types/context.d.mts}

@@ -1,4 +1,5 @@
-import { d as RpcClient, n as EngineExecutionOptions, r as EngineOptions } from "./config-B6udgcnD.cjs";
+import { RpcClient } from "./rpc.mjs";
+import { EngineExecutionOptions, EngineOptions } from "./config.mjs";
 import { BaseContext, InlineConfig, ParsedUserConfig } from "@powerlines/core";
 import { ConnectionMeta, DevToolsNodeContext } from "devframe/types";
 
@@ -145,5 +146,5 @@ interface EngineSystemContext {
   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-ZbJRDGpl.d.cts.map
+export { EngineContext, EngineExecutionItem, EngineSystemContext, ExecutionCommandScopeState, ExecutionHookScopeState, ExecutionPluginScopeState, ExecutionScopeState, ExecutionScopeType, ExecutionState };
+//# sourceMappingURL=context.d.mts.map

package/dist/types/context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.mts","names":[],"sources":["../../src/types/context.ts"],"mappings":";;;;;;;;AA0BA;KAAY,kBAAA;;;AAAkB;UAKb,mBAAA;EAAmB;;;EAIlC,SAAA;EAKA;;;EAAA,IAAA;EAKwB;AAM1B;;EANE,IAAA,EAAM,kBAAkB;AAAA;AAUpB;AAMN;;AANM,UAJW,0BAAA,SAAmC,mBAAmB;EAUH;;;EANlE,IAAI;AAAA;AAeA;AAMN;;AANM,UATW,uBAAA,SAAgC,mBAAmB;EAejB;AAI7C;AAMN;EArBE,KAAA;;;;EAKA,IAAA;AAAA;;;;UAMe,yBAAA,SAAkC,mBAAmB;EAmB9D;;;EAfN,IAAI;AAAA;AA0BN;;;AAAA,UApBiB,cAAA;EAkCN;;;EA9BT,OAAA,EAAS,0BAAA;EAwCY;;;EAnCrB,IAAA,EAAM,uBAAA;EAyBG;;;EApBT,MAAA,EAAQ,yBAAA;AAAA;;;AA8Ba;UAxBN,mBAAA;EAiCa;;;EA7B5B,YAAA;EAgCO;;;EA3BP,OAAA;EAiDY;;;EA5CZ,OAAA,EAAS,IAAA,CAAK,sBAAA;EAqBZ;;;EAhBF,UAAA,EAAY,gBAAA;EAciB;;;EAT7B,KAAA,EAAO,cAAA;AAAA;;;;;;;UASQ,aAAA,mCAEb,WAAA,CAAY,cAAA,GACZ,IAAA,CAAK,QAAA,CAAS,aAAA;EAsBhB;;;EAlBA,OAAA,EAAS,aAAA;EA4BO;;;EAvBhB,UAAA,EAAY,cAAA;EAgCZ;;;;AAA6D;AAG/D;EA3BE,QAAA,EAAU,mBAAA;;;AA+BI;EA1Bd,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/types/index.d.cts

@@ -0,0 +1,4 @@
+import { ExtractRpcFunction, ExtractRpcFunctions, InputRpcFunction, InputRpcFunctions, LogPayload, RpcClient, RpcClientCall, RpcClientCallEvent, RpcClientCallOptional, RpcClientEvents, RpcClientFunctions, RpcClientHost, RpcClientRemoteFunctions, RpcContext, RpcFunction, RpcFunctions, RpcPayloadEnvelop, RpcPayloadMetadata, RpcServerFunctions, WrapRpcFunction, WrapRpcFunctions, WrappedRpcFunction, WrappedRpcFunctions } from "./rpc.cjs";
+import { ApiExecutionOptions, EngineExecutionOptions, EngineOptions, EngineResolvedConfig, RpcClientOptions } from "./config.cjs";
+import { EngineContext, EngineExecutionItem, EngineSystemContext, ExecutionCommandScopeState, ExecutionHookScopeState, ExecutionPluginScopeState, ExecutionScopeState, ExecutionScopeType, ExecutionState } from "./context.cjs";
+import { Engine, ExecutionApi, ExecutionApiParams, ExecutionApiWorkerInterface, ExecutionInterface } from "./api.cjs";

package/dist/types/index.d.mts

@@ -0,0 +1,4 @@
+import { ExtractRpcFunction, ExtractRpcFunctions, InputRpcFunction, InputRpcFunctions, LogPayload, RpcClient, RpcClientCall, RpcClientCallEvent, RpcClientCallOptional, RpcClientEvents, RpcClientFunctions, RpcClientHost, RpcClientRemoteFunctions, RpcContext, RpcFunction, RpcFunctions, RpcPayloadEnvelop, RpcPayloadMetadata, RpcServerFunctions, WrapRpcFunction, WrapRpcFunctions, WrappedRpcFunction, WrappedRpcFunctions } from "./rpc.mjs";
+import { ApiExecutionOptions, EngineExecutionOptions, EngineOptions, EngineResolvedConfig, RpcClientOptions } from "./config.mjs";
+import { EngineContext, EngineExecutionItem, EngineSystemContext, ExecutionCommandScopeState, ExecutionHookScopeState, ExecutionPluginScopeState, ExecutionScopeState, ExecutionScopeType, ExecutionState } from "./context.mjs";
+import { Engine, ExecutionApi, ExecutionApiParams, ExecutionApiWorkerInterface, ExecutionInterface } from "./api.mjs";

package/dist/{config-B6udgcnD.d.cts → types/rpc.d.cts}

@@ -1,9 +1,8 @@
-import { CustomLogger, ExecutionOptions, FrameworkOptions, LogMeta, Options, ResolvedConfig, UserConfig } from "@powerlines/core";
-import { MaybePromise, PartialKeys, RequiredKeys } from "@stryke/types/base";
-import { BirpcOptions, BirpcReturn, ProxifiedRemoteFunctions } from "birpc";
-import { RpcCacheManager, RpcCacheOptions, RpcFunctionsCollector } from "devframe/rpc";
-import { WsRpcChannelOptions } from "devframe/rpc/transports/ws-client";
-import { ConnectionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevframeDefinition, EventEmitter, RpcSharedStateHost } from "devframe/types";
+import { LogMeta } from "@powerlines/core";
+import { MaybePromise } from "@stryke/types/base";
+import { BirpcReturn, ProxifiedRemoteFunctions } from "birpc";
+import { RpcCacheManager, RpcFunctionsCollector } from "devframe/rpc";
+import { ConnectionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, EventEmitter, RpcSharedStateHost } from "devframe/types";
 import { Asyncify } from "@stryke/types/async";
 import { RpcStreamingClientHost } from "devframe/client";
 
@@ -143,67 +142,5 @@ interface RpcClient {
   cacheManager: RpcCacheManager;
 }
 //#endregion
-//#region src/types/config.d.ts
-/**
- * The options required to start the Powerlines engine.
- */
-type EngineOptions = Omit<PartialKeys<DevframeDefinition, "name" | "setup">, "id" | "basePath"> & Options & {
-  /**
-   * The host URL for the engine's WebSocket server, which is used for communication between the engine and the various hosts (e.g., dev server, CLI, etc.) that interact with it. This value is required for the engine to function properly, as it allows the engine to establish a WebSocket connection and facilitate communication with other components of the system.
-   */
-  host?: string;
-  /**
-   * The port number to use for the websocket connection between the engine and the various hosts.
-   */
-  port?: number;
-  /**
-   * An optional root directory for the engine to use when resolving paths and loading configuration files. This value can be used to specify a custom root directory for the engine, which can be useful in cases where the default behavior of using the current working directory is not desirable. If this option is not provided, the engine will use the current working directory as the root directory by default.
-   */
-  root?: string;
-  /**
-   * A custom logger instance that implements the {@link CustomLogger} interface, which can be used for logging messages during the build process instead of the default Powerlines logger.
-   *
-   * @remarks
-   * Providing a custom logger allows you to integrate Powerlines logging with your own logging system or to customize the logging behavior, such as formatting log messages differently or sending logs to an external service. If a custom logger is not provided, Powerlines will use its default logger implementation.
-   */
-  customLogger?: CustomLogger;
-  /**
-   * The framework for which the engine is being used, which can be used by plugins to customize their behavior based on the specific framework being targeted. This value is optional and can be set to `undefined` if not applicable, but providing it allows plugins to make informed decisions about how to handle certain tasks or configurations based on the framework being used.
-   */
-  framework?: FrameworkOptions;
-};
-interface ApiExecutionOptions extends ExecutionOptions {}
-interface EngineExecutionOptions extends ExecutionOptions {
-  /**
-   * The base URL for the dev server, which can be used by plugins to construct URLs for assets or API endpoints during development. This value is only relevant in "dev" mode and will be `undefined` in "build" mode.
-   */
-  baseURL: string;
-  /**
-   * Metadata for the connection used by the dev server, including the backend type and websocket configuration.
-   */
-  connection: ConnectionMeta;
-  /**
-   * The {@link MessagePort} used for communication between the execution host and the engine. This port will be used to send and receive messages, allowing the execution host to invoke API methods and return results to the engine.
-   */
-  channel: MessagePort;
-  /**
-   * Options for configuring the WebSocket RPC channel used for communication between the dev server and the client, which can be used by plugins to customize the behavior of the WebSocket connection, such as setting custom timeouts, retry strategies, or other options.
-   */
-  wsOptions?: Partial<WsRpcChannelOptions>;
-  /**
-   * Options for configuring the RPC client used for communication between the dev server and the client, which can be used by plugins to customize the behavior of the RPC client, such as setting custom timeouts, retry strategies, or other options.
-   */
-  rpcOptions?: Partial<BirpcOptions<RpcServerFunctions, RpcClientFunctions, boolean>>;
-  /**
-   * Options for configuring the RPC cache used for caching RPC responses between the dev server and the client, which can be used by plugins to customize the behavior of the RPC cache, such as setting custom cache keys, expiration times, or other options.
-   *
-   * @remarks
-   * This option can be set to `true` to enable caching with default options, or it can be set to a configuration object that allows for fine-grained control over the caching behavior.
-   */
-  cacheOptions?: boolean | Partial<RpcCacheOptions>;
-}
-type RpcClientOptions = RequiredKeys<EngineExecutionOptions, "baseURL" | "connection">;
-type EngineResolvedConfig<TUserConfig extends UserConfig = UserConfig> = ResolvedConfig<TUserConfig, EngineExecutionOptions>;
-//#endregion
-export { RpcPayloadMetadata as C, WrappedRpcFunction as D, WrapRpcFunctions as E, WrappedRpcFunctions as O, RpcPayloadEnvelop as S, WrapRpcFunction as T, RpcClientHost as _, RpcClientOptions as a, RpcFunction as b, InputRpcFunction as c, RpcClient as d, RpcClientCall as f, RpcClientFunctions as g, RpcClientEvents as h, EngineResolvedConfig as i, InputRpcFunctions as l, RpcClientCallOptional as m, EngineExecutionOptions as n, ExtractRpcFunction as o, RpcClientCallEvent as p, EngineOptions as r, ExtractRpcFunctions as s, ApiExecutionOptions as t, LogPayload as u, RpcClientRemoteFunctions as v, RpcServerFunctions as w, RpcFunctions as x, RpcContext as y };
-//# sourceMappingURL=config-B6udgcnD.d.cts.map
+export { ExtractRpcFunction, ExtractRpcFunctions, InputRpcFunction, InputRpcFunctions, LogPayload, RpcClient, RpcClientCall, RpcClientCallEvent, RpcClientCallOptional, RpcClientEvents, RpcClientFunctions, RpcClientHost, RpcClientRemoteFunctions, RpcContext, RpcFunction, RpcFunctions, RpcPayloadEnvelop, RpcPayloadMetadata, RpcServerFunctions, WrapRpcFunction, WrapRpcFunctions, WrappedRpcFunction, WrappedRpcFunctions };
+//# sourceMappingURL=rpc.d.cts.map

package/dist/types/rpc.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.cts","names":[],"sources":["../../src/types/rpc.ts"],"mappings":";;;;;;;;;UAkCiB,kBAAA;EAAA;;;EAIf,SAAA;EAAA;;;EAIA,IAAA;EAYA;;;EARA,SAAA;EAee;;;EAXf,WAAA;EAWiC;;;EAPjC,WAAA;EAWiB;AAAA;AAGnB;EAVE,WAAA;AAAA;AAAA,UAGe,iBAAA,mBAAoC,kBAAkB;EAOf;AACxD;;EAJE,OAAA,EAAS,QAAA;AAAA;AAAA,KAGC,WAAA,IAAe,OAAA,UAAiB,YAAY;AAAA,KAC5C,YAAA,GAAe,MAAM,SAAS,WAAA;AAAA,KAE9B,gBAAA,IAAoB,OAA+B,EAAtB,iBAAiB;AAAA,KAC9C,iBAAA,GAAoB,MAAM,SAAS,gBAAA;AAAA,KAEnC,kBAAA,IACV,OAAA,EAAS,iBAAA,UACN,OAAO;AAAA,KACA,mBAAA,GAAsB,MAAM,SAAS,kBAAA;AAAA,KAErC,kBAAA,mBAAqC,kBAAA,KAC/C,OAAA,EAAS,UAAA,CAAW,SAAA,oBACjB,UAAA,CAAW,QAAA,CAAS,SAAA;AAAA,KAEb,mBAAA,oBAAuC,mBAAA,qBAClC,UAAA,GAAa,kBAAA,CAAmB,UAAA,CAAW,IAAA;AAAA,KAGhD,eAAA,mBAAkC,WAAA,KAC5C,OAAA,EAAS,iBAAA,CAAkB,UAAA,CAAW,SAAA,UACnC,UAAA,CAAW,SAAA,UAAmB,OAAA,YAAmB,CAAA,GAAI,UAAA,CAAW,SAAA;AAAA,KAEzD,gBAAA,oBAAoC,YAAA,qBAC/B,UAAA,GAAa,eAAA,CAAgB,UAAA,CAAW,IAAA;AAAA,KAG7C,wBAAA,oBAA4C,mBAAA,IACtD,wBAAA,CAAyB,mBAAA,CAAoB,UAAA;;;;UAK9B,UAAA;EAzBL;AACZ;;EA4BE,IAAA,EAAM,OAAO;EA5BmB;AAAiC;AAEnE;EA+BE,OAAA;AAAA;AAAA,UAGe,kBAAA,SAA2B,0BAA0B;EAEpE,gBAAA,GAAmB,OAAA,EAAS,UAAA;AAAA;AAAA,UAGb,kBAAA,SAA2B,0BAA0B;AAAA,UAErD,UAAA;EAvCF;;;EAAA,SA2CJ,GAAA,EAAK,SAAS;AAAA;AAAA,KAGb,aAAA,GAAgB,qBAAA,CAC1B,kBAAA,EACA,UAAA;AAAA,KAGU,aAAA,GAAgB,WAAA,CAC1B,kBAAA,EACA,kBAAA;AAAA,KAEU,kBAAA,GAAqB,WAAA,CAC/B,kBAAA,EACA,kBAAA;AAAA,KAEU,qBAAA,GAAwB,WAAA,CAClC,kBAAA,EACA,kBAAA;AAAA,UAGe,eAAA;EAEf,wBAAA,GAA2B,SAAkB;AAAA;AAAA,UAG9B,SAAA;EAnEc;;;EAuE7B,MAAA,EAAQ,YAAA,CAAa,eAAA;EAtE0B;;;EAAA,SA2EtC,SAAA;EA3EqC;;;EAAA,SAgFrC,cAAA,EAAgB,cAAA;EAhFV;;;;;AAA+C;AAGhE;EAsFE,aAAA,GAAgB,OAAA,cAAqB,OAAA;EAtFZ;;;EA2FzB,YAAA,QAAoB,OAAA;EA1FX;;;;EAgGT,qBAAA,GAAwB,KAAA,aAAkB,OAAA;EA/Fc;;;EAoGxD,IAAA,EAAM,aAAA;EAtGsC;;;EA2G5C,SAAA,EAAW,kBAAA;EA1GX;;;EA+GA,YAAA,EAAc,qBAAA;EA9GiC;;;EAmH/C,MAAA,EAAQ,aAAA;EAnHoE;AAAA;AAE9E;EAsHE,WAAA,EAAa,kBAAA;EAtHa;;;;;EA6H1B,SAAA,EAAW,sBAAA;EA5HgC;;;EAiI3C,YAAA,EAAc,eAAA;AAAA"}