@powerlines/engine 0.15.0 → 0.15.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/api/types.ts"],"mappings":";;;;;;;AA8CA;;;;;;iBAAsB,KAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CACvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,IAAe,OAAA"}

package/dist/api/types.mjs

@@ -0,0 +1,70 @@
+import { prepare } from "./prepare.mjs";
+import { toArray } from "@stryke/convert/to-array";
+import { isSetObject } from "@stryke/type-checks/is-set-object";
+import { executeEnvironments } from "@powerlines/core/lib/environment";
+import { handleTypes } from "@powerlines/core/lib/generate-types";
+import { installDependencies } from "@powerlines/core/lib/install-dependencies";
+import { writeMetaFile } from "@powerlines/core/lib/meta";
+import { initializeTsconfig, resolveTsconfig } from "@powerlines/core/lib/typescript/tsconfig";
+import { format } from "@powerlines/core/lib/utilities/format";
+import { createDirectory } from "@stryke/fs/helpers";
+import { isObject } from "@stryke/type-checks/is-object";
+import { formatLogMessage } from "@storm-software/config-tools/logger";
+import { omit } from "@stryke/helpers/omit";
+
+//#region src/api/types.ts
+/**
+* Generate runtime types for the Powerlines project.
+*
+* @remarks
+* This function is responsible for generating TypeScript declaration files based on the project's configuration and environment. It executes hooks at various stages of the type generation process, allowing for customization and extension by plugins. The generated types are formatted and written to the appropriate location in the project's file system, ensuring that they are available for use by other parts of the Powerlines system and by end-users of the project.
+*
+* @param context - The execution context for the build process, which provides access to the project configuration, environment, and utility functions for performing the build. The context is used to manage the state and behavior of the build process, allowing for hooks to be called at different stages of the build and for environment-specific configurations to be applied.
+*/
+async function types(context) {
+	const timer = context.timer("Type Generation");
+	context.debug(" Aggregating configuration options for the Powerlines project");
+	await executeEnvironments(context, async (env) => {
+		env.debug(`Initializing the processing options for the Powerlines project.`);
+		await context.callHook("configResolved", {
+			environment: env,
+			order: "pre"
+		});
+		await initializeTsconfig(env);
+		await context.callHook("configResolved", {
+			environment: env,
+			order: "normal"
+		});
+		if (env.entry.length > 0) env.debug(`The configuration provided ${isObject(env.config.input) ? Object.keys(env.config.input).length : toArray(env.config.input).length} entry point(s), Powerlines has found ${env.entry.length} entry files(s) for the ${env.config.title} project${env.entry.length > 0 && env.entry.length < 10 ? `: \n${env.entry.map((entry) => `- ${entry.file}${entry.output ? ` -> ${entry.output}` : ""}`).join(" \n")}` : ""}`);
+		else env.warn(`No entry files were found for the ${env.config.title} project. Please ensure this is correct. Powerlines plugins generally require at least one entry point to function properly.`);
+		await resolveTsconfig(env);
+		await installDependencies(env);
+		await context.callHook("configResolved", {
+			environment: env,
+			order: "post"
+		});
+		context.trace(`Powerlines configuration has been resolved: \n\n${formatLogMessage({
+			...env.config,
+			userConfig: isSetObject(env.config.userConfig) ? omit(env.config.userConfig, ["plugins"]) : void 0,
+			inlineConfig: isSetObject(env.config.inlineConfig) ? env.config.inlineConfig : void 0,
+			plugins: env.plugins.map((plugin) => plugin.name)
+		})}`);
+		if (!env.fs.existsSync(env.cachePath)) await createDirectory(env.cachePath);
+		if (!env.fs.existsSync(env.dataPath)) await createDirectory(env.dataPath);
+		if (env.config.skipCache === true || env.persistedMeta?.checksum !== env.meta.checksum) env.debug(`Using previously prepared files as the meta checksum has not changed.`);
+		else {
+			env.info(`Running \`prepare\` command as the meta checksum has changed since the last run.`);
+			await prepare(context, true);
+		}
+		await handleTypes(context, env);
+		context.debug("Formatting files generated during the types step.");
+		await format(env, env.typesPath, await env.fs.read(env.typesPath) ?? "");
+		await writeMetaFile(env);
+		env.persistedMeta = env.meta;
+	});
+	timer();
+}
+
+//#endregion
+export { types };
+//# sourceMappingURL=types.mjs.map

package/dist/api/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../../src/api/types.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { executeEnvironments } from \"@powerlines/core/lib/environment\";\nimport { handleTypes } from \"@powerlines/core/lib/generate-types\";\nimport { installDependencies } from \"@powerlines/core/lib/install-dependencies\";\nimport { writeMetaFile } from \"@powerlines/core/lib/meta\";\nimport {\n  initializeTsconfig,\n  resolveTsconfig\n} from \"@powerlines/core/lib/typescript/tsconfig\";\nimport { format } from \"@powerlines/core/lib/utilities/format\";\nimport { ExecutionContext } from \"@powerlines/core/types/context\";\nimport { formatLogMessage } from \"@storm-software/config-tools/logger\";\nimport { toArray } from \"@stryke/convert/to-array\";\nimport { createDirectory } from \"@stryke/fs/helpers\";\nimport { omit } from \"@stryke/helpers/omit\";\nimport { isObject } from \"@stryke/type-checks/is-object\";\nimport { isSetObject } from \"@stryke/type-checks/is-set-object\";\nimport { EngineResolvedConfig } from \"../types/config\";\nimport { EngineSystemContext } from \"../types/context\";\nimport { prepare } from \"./prepare\";\n\n/**\n * Generate runtime types for the Powerlines project.\n *\n * @remarks\n * This function is responsible for generating TypeScript declaration files based on the project's configuration and environment. It executes hooks at various stages of the type generation process, allowing for customization and extension by plugins. The generated types are formatted and written to the appropriate location in the project's file system, ensuring that they are available for use by other parts of the Powerlines system and by end-users of the project.\n *\n * @param context - The execution context for the build process, which provides access to the project configuration, environment, and utility functions for performing the build. The context is used to manage the state and behavior of the build process, allowing for hooks to be called at different stages of the build and for environment-specific configurations to be applied.\n */\nexport async function types<\n  TResolvedConfig extends EngineResolvedConfig,\n  TSystemContext extends EngineSystemContext\n>(context: ExecutionContext<TResolvedConfig, TSystemContext>) {\n  const timer = context.timer(\"Type Generation\");\n  context.debug(\n    \" Aggregating configuration options for the Powerlines project\"\n  );\n\n  await executeEnvironments(context, async env => {\n    env.debug(\n      `Initializing the processing options for the Powerlines project.`\n    );\n\n    await context.callHook(\"configResolved\", {\n      environment: env,\n      order: \"pre\"\n    });\n\n    await initializeTsconfig<TResolvedConfig, TSystemContext>(env);\n\n    await context.callHook(\"configResolved\", {\n      environment: env,\n      order: \"normal\"\n    });\n\n    if (env.entry.length > 0) {\n      env.debug(\n        `The configuration provided ${\n          isObject(env.config.input)\n            ? Object.keys(env.config.input).length\n            : toArray(env.config.input).length\n        } entry point(s), Powerlines has found ${\n          env.entry.length\n        } entry files(s) for the ${env.config.title} project${\n          env.entry.length > 0 && env.entry.length < 10\n            ? `: \\n${env.entry\n                .map(\n                  entry =>\n                    `- ${entry.file}${\n                      entry.output ? ` -> ${entry.output}` : \"\"\n                    }`\n                )\n                .join(\" \\n\")}`\n            : \"\"\n        }`\n      );\n    } else {\n      env.warn(\n        `No entry files were found for the ${\n          env.config.title\n        } project. Please ensure this is correct. Powerlines plugins generally require at least one entry point to function properly.`\n      );\n    }\n\n    await resolveTsconfig<TResolvedConfig, TSystemContext>(env);\n    await installDependencies(env);\n\n    await context.callHook(\"configResolved\", {\n      environment: env,\n      order: \"post\"\n    });\n\n    context.trace(\n      `Powerlines configuration has been resolved: \\n\\n${formatLogMessage({\n        ...env.config,\n        userConfig: isSetObject(env.config.userConfig)\n          ? omit(env.config.userConfig, [\"plugins\"])\n          : undefined,\n        inlineConfig: isSetObject(env.config.inlineConfig)\n          ? env.config.inlineConfig\n          : undefined,\n        plugins: env.plugins.map(plugin => plugin.name)\n      })}`\n    );\n\n    if (!env.fs.existsSync(env.cachePath)) {\n      await createDirectory(env.cachePath);\n    }\n\n    if (!env.fs.existsSync(env.dataPath)) {\n      await createDirectory(env.dataPath);\n    }\n\n    if (\n      env.config.skipCache === true ||\n      env.persistedMeta?.checksum !== env.meta.checksum\n    ) {\n      env.debug(\n        `Using previously prepared files as the meta checksum has not changed.`\n      );\n    } else {\n      env.info(\n        `Running \\`prepare\\` command as the meta checksum has changed since the last run.`\n      );\n\n      await prepare(context, true);\n    }\n\n    await handleTypes(context, env);\n\n    context.debug(\"Formatting files generated during the types step.\");\n\n    await format(env, env.typesPath, (await env.fs.read(env.typesPath)) ?? \"\");\n\n    await writeMetaFile(env);\n    env.persistedMeta = env.meta;\n  });\n\n  timer();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8CA,eAAsB,MAGpB,SAA4D;CAC5D,MAAM,QAAQ,QAAQ,MAAM,kBAAkB;AAC9C,SAAQ,MACN,gEACD;AAED,OAAM,oBAAoB,SAAS,OAAM,QAAO;AAC9C,MAAI,MACF,kEACD;AAED,QAAM,QAAQ,SAAS,kBAAkB;GACvC,aAAa;GACb,OAAO;GACR,CAAC;AAEF,QAAM,mBAAoD,IAAI;AAE9D,QAAM,QAAQ,SAAS,kBAAkB;GACvC,aAAa;GACb,OAAO;GACR,CAAC;AAEF,MAAI,IAAI,MAAM,SAAS,EACrB,KAAI,MACF,8BACE,SAAS,IAAI,OAAO,MAAM,GACtB,OAAO,KAAK,IAAI,OAAO,MAAM,CAAC,SAC9B,QAAQ,IAAI,OAAO,MAAM,CAAC,OAC/B,wCACC,IAAI,MAAM,OACX,0BAA0B,IAAI,OAAO,MAAM,UAC1C,IAAI,MAAM,SAAS,KAAK,IAAI,MAAM,SAAS,KACvC,OAAO,IAAI,MACR,KACC,UACE,KAAK,MAAM,OACT,MAAM,SAAS,OAAO,MAAM,WAAW,KAE5C,CACA,KAAK,MAAM,KACd,KAEP;MAED,KAAI,KACF,qCACE,IAAI,OAAO,MACZ,8HACF;AAGH,QAAM,gBAAiD,IAAI;AAC3D,QAAM,oBAAoB,IAAI;AAE9B,QAAM,QAAQ,SAAS,kBAAkB;GACvC,aAAa;GACb,OAAO;GACR,CAAC;AAEF,UAAQ,MACN,mDAAmD,iBAAiB;GAClE,GAAG,IAAI;GACP,YAAY,YAAY,IAAI,OAAO,WAAW,GAC1C,KAAK,IAAI,OAAO,YAAY,CAAC,UAAU,CAAC,GACxC;GACJ,cAAc,YAAY,IAAI,OAAO,aAAa,GAC9C,IAAI,OAAO,eACX;GACJ,SAAS,IAAI,QAAQ,KAAI,WAAU,OAAO,KAAK;GAChD,CAAC,GACH;AAED,MAAI,CAAC,IAAI,GAAG,WAAW,IAAI,UAAU,CACnC,OAAM,gBAAgB,IAAI,UAAU;AAGtC,MAAI,CAAC,IAAI,GAAG,WAAW,IAAI,SAAS,CAClC,OAAM,gBAAgB,IAAI,SAAS;AAGrC,MACE,IAAI,OAAO,cAAc,QACzB,IAAI,eAAe,aAAa,IAAI,KAAK,SAEzC,KAAI,MACF,wEACD;OACI;AACL,OAAI,KACF,mFACD;AAED,SAAM,QAAQ,SAAS,KAAK;;AAG9B,QAAM,YAAY,SAAS,IAAI;AAE/B,UAAQ,MAAM,oDAAoD;AAElE,QAAM,OAAO,KAAK,IAAI,WAAY,MAAM,IAAI,GAAG,KAAK,IAAI,UAAU,IAAK,GAAG;AAE1E,QAAM,cAAc,IAAI;AACxB,MAAI,gBAAgB,IAAI;GACxB;AAEF,QAAO"}

package/dist/api-6w4hZL6n.d.cts

@@ -0,0 +1,135 @@
+import { t as EngineExecutionOptions } from "./config-D6xUniHh.cjs";
+import { t as EngineContext } from "./context-epL7NPvL.cjs";
+import { BuildInlineConfig, CleanInlineConfig, CreateInlineConfig, DeployInlineConfig, DocsInlineConfig, InlineConfig, LintInlineConfig, PrepareInlineConfig, TestInlineConfig, TypesInlineConfig } from "@powerlines/core";
+import { EXECUTION_API_METHODS } from "@powerlines/core/constants/api";
+
+//#region src/types/utils.d.ts
+type Worker<TParams, TExposedMethods extends ReadonlyArray<string>> = { [K in TExposedMethods[number]]: (params: TParams) => Promise<void> } & {
+  close: () => void;
+  end: () => Promise<void>;
+};
+//#endregion
+//#region src/types/api.d.ts
+/**
+ * The Powerlines Base API Interface
+ *
+ * @remarks
+ * This interface defines the base API for Powerlines, which includes the shared context and the core commands. It is extended by the ExecutionAPI and EngineAPI interfaces to provide additional functionality specific to their respective contexts.
+ */
+interface ExecutionInterface {
+  /**
+   * Prepare the Powerlines API
+   *
+   * @remarks
+   * This method will prepare the Powerlines API for use, initializing any necessary resources.
+   *
+   * @param inlineConfig - The inline configuration for the prepare command
+   */
+  prepare: (inlineConfig: PrepareInlineConfig) => Promise<void>;
+  /**
+   * Generate the Powerlines typescript declaration file
+   *
+   * @remarks
+   * This method will only generate the typescript declaration file for the Powerlines project. It is generally recommended to run the full `prepare` command, which will run this method as part of its process.
+   *
+   * @param inlineConfig - The inline configuration for the types command
+   */
+  types: (inlineConfig: TypesInlineConfig) => Promise<void>;
+  /**
+   * Create a new Powerlines project
+   *
+   * @remarks
+   * This method will create a new Powerlines project in the current directory.
+   *
+   * @param inlineConfig - The inline configuration for the create command
+   * @returns A promise that resolves when the project has been created
+   */
+  create: (inlineConfig: CreateInlineConfig) => Promise<void>;
+  /**
+   * Clean any previously prepared artifacts
+   *
+   * @remarks
+   * This method will remove the previous Powerlines artifacts from the project.
+   *
+   * @param inlineConfig - The inline configuration for the clean command
+   * @returns A promise that resolves when the clean command has completed
+   */
+  clean: (inlineConfig: CleanInlineConfig) => Promise<void>;
+  /**
+   * Lint the project source code
+   *
+   * @param inlineConfig - The inline configuration for the lint command
+   * @returns A promise that resolves when the lint command has completed
+   */
+  lint: (inlineConfig: LintInlineConfig) => Promise<void>;
+  /**
+   * Test the project source code
+   *
+   * @param inlineConfig - The inline configuration for the test command
+   * @returns A promise that resolves when the test command has completed
+   */
+  test: (inlineConfig: TestInlineConfig) => Promise<void>;
+  /**
+   * Build the project
+   *
+   * @remarks
+   * This method will build the Powerlines project, generating the necessary artifacts.
+   *
+   * @param inlineConfig - The inline configuration for the build command
+   * @returns A promise that resolves when the build command has completed
+   */
+  build: (inlineConfig: BuildInlineConfig) => Promise<void>;
+  /**
+   * Prepare the documentation for the project
+   *
+   * @param inlineConfig - The inline configuration for the docs command
+   * @returns A promise that resolves when the documentation generation has completed
+   */
+  docs: (inlineConfig: DocsInlineConfig) => Promise<void>;
+  /**
+   * Deploy the project source code
+   *
+   * @remarks
+   * This method will prepare and build the Powerlines project, generating the necessary artifacts for the deployment.
+   *
+   * @param inlineConfig - The inline configuration for the deploy command
+   */
+  deploy: (inlineConfig: DeployInlineConfig) => Promise<void>;
+  /**
+   * Finalization process
+   *
+   * @remarks
+   * This step includes any final processes or clean up required by Powerlines. It will be run after each Powerlines command.
+   *
+   * @returns A promise that resolves when the finalization process has completed
+   */
+  finalize: () => Promise<void>;
+}
+interface ExecutionHostParams {
+  /**
+   * The execution options for the current execution instance
+   */
+  options: EngineExecutionOptions;
+  /**
+   * The inline configuration for the current execution instance, which is the result of merging the user configuration with any configuration provided by plugins during the "config" hook.
+   */
+  inlineConfig: InlineConfig;
+}
+type ExecutionHost<TExecutionAPI extends ReadonlyArray<string>> = Worker<ExecutionHostParams, TExecutionAPI>;
+type PowerlinesExecutionHost = ExecutionHost<typeof EXECUTION_API_METHODS>;
+/**
+ * The Engine interface represents the Powerlines process' orchestration and coordination API.
+ */
+interface Engine<TExecutionAPI extends ReadonlyArray<string>> extends ExecutionInterface {
+  /**
+   * The Powerlines shared context
+   */
+  context: EngineContext;
+  /**
+   * The execution host, which provides methods to call the execution API functions from the engine context. This allows the engine to invoke commands and other API functions during the execution of Powerlines commands, enabling communication between the engine and the execution contexts.
+   */
+  host: ExecutionHost<TExecutionAPI>;
+}
+//#endregion
+export { PowerlinesExecutionHost as a, ExecutionInterface as i, ExecutionHost as n, Worker as o, ExecutionHostParams as r, Engine as t };
+//# sourceMappingURL=api-6w4hZL6n.d.cts.map

package/dist/api-6w4hZL6n.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-6w4hZL6n.d.cts","names":[],"sources":["../src/types/utils.ts","../src/types/api.ts"],"mappings":";;;;;;KAkBY,MAAA,kCAAwC,aAAA,oBAC5C,eAAA,YAA2B,MAAA,EAAQ,OAAA,KAAY,OAAA;EAErD,KAAA;EACA,GAAA,QAAW,OAAA;AAAA;;;;AAJb;;;;;UCuBiB,kBAAA;EDtBsC;;;;;;;;EC+BrD,OAAA,GAAU,YAAA,EAAc,mBAAA,KAAwB,OAAA;ED/BP;;;;;;;;ECyCzC,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;;;AAnB9C;;;;;;;EA8BE,MAAA,GAAS,YAAA,EAAc,kBAAA,KAAuB,OAAA;EAAA;;;;;;;;;EAW9C,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;EAmCF;;;;;;EA3B1C,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EAxClB;;;;;;EAgDxB,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EA3B1C;;;;;;;;;EAsCA,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;EAnBrC;;;;;;EA2BP,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EARpB;;;;;;;;EAkBtB,MAAA,GAAS,YAAA,EAAc,kBAAA,KAAuB,OAAA;EAArC;;;;;;AAaX;;EAHE,QAAA,QAAgB,OAAA;AAAA;AAAA,UAGD,mBAAA;EAIN;;;EAAT,OAAA,EAAS,sBAAA;EAKiB;AAG5B;;EAHE,YAAA,EAAc,YAAA;AAAA;AAAA,KAGJ,aAAA,uBAAoC,aAAA,YAAyB,MAAA,CACvE,mBAAA,EACA,aAAA;AAAA,KAGU,uBAAA,GAA0B,aAAA,QAC7B,qBAAA;;;;UAMQ,MAAA,uBACO,aAAA,kBACd,kBAAA;EAdsC;;;EAkB9C,OAAA,EAAS,aAAA;EAhBI;;AAGf;EAkBE,IAAA,EAAM,aAAA,CAAc,aAAA;AAAA"}

package/dist/api-Cdw4v0W4.d.mts

@@ -0,0 +1,135 @@
+import { t as EngineExecutionOptions } from "./config-BNe23XHx.mjs";
+import { t as EngineContext } from "./context-DzgsMSWr.mjs";
+import { BuildInlineConfig, CleanInlineConfig, CreateInlineConfig, DeployInlineConfig, DocsInlineConfig, InlineConfig, LintInlineConfig, PrepareInlineConfig, TestInlineConfig, TypesInlineConfig } from "@powerlines/core";
+import { EXECUTION_API_METHODS } from "@powerlines/core/constants/api";
+
+//#region src/types/utils.d.ts
+type Worker<TParams, TExposedMethods extends ReadonlyArray<string>> = { [K in TExposedMethods[number]]: (params: TParams) => Promise<void> } & {
+  close: () => void;
+  end: () => Promise<void>;
+};
+//#endregion
+//#region src/types/api.d.ts
+/**
+ * The Powerlines Base API Interface
+ *
+ * @remarks
+ * This interface defines the base API for Powerlines, which includes the shared context and the core commands. It is extended by the ExecutionAPI and EngineAPI interfaces to provide additional functionality specific to their respective contexts.
+ */
+interface ExecutionInterface {
+  /**
+   * Prepare the Powerlines API
+   *
+   * @remarks
+   * This method will prepare the Powerlines API for use, initializing any necessary resources.
+   *
+   * @param inlineConfig - The inline configuration for the prepare command
+   */
+  prepare: (inlineConfig: PrepareInlineConfig) => Promise<void>;
+  /**
+   * Generate the Powerlines typescript declaration file
+   *
+   * @remarks
+   * This method will only generate the typescript declaration file for the Powerlines project. It is generally recommended to run the full `prepare` command, which will run this method as part of its process.
+   *
+   * @param inlineConfig - The inline configuration for the types command
+   */
+  types: (inlineConfig: TypesInlineConfig) => Promise<void>;
+  /**
+   * Create a new Powerlines project
+   *
+   * @remarks
+   * This method will create a new Powerlines project in the current directory.
+   *
+   * @param inlineConfig - The inline configuration for the create command
+   * @returns A promise that resolves when the project has been created
+   */
+  create: (inlineConfig: CreateInlineConfig) => Promise<void>;
+  /**
+   * Clean any previously prepared artifacts
+   *
+   * @remarks
+   * This method will remove the previous Powerlines artifacts from the project.
+   *
+   * @param inlineConfig - The inline configuration for the clean command
+   * @returns A promise that resolves when the clean command has completed
+   */
+  clean: (inlineConfig: CleanInlineConfig) => Promise<void>;
+  /**
+   * Lint the project source code
+   *
+   * @param inlineConfig - The inline configuration for the lint command
+   * @returns A promise that resolves when the lint command has completed
+   */
+  lint: (inlineConfig: LintInlineConfig) => Promise<void>;
+  /**
+   * Test the project source code
+   *
+   * @param inlineConfig - The inline configuration for the test command
+   * @returns A promise that resolves when the test command has completed
+   */
+  test: (inlineConfig: TestInlineConfig) => Promise<void>;
+  /**
+   * Build the project
+   *
+   * @remarks
+   * This method will build the Powerlines project, generating the necessary artifacts.
+   *
+   * @param inlineConfig - The inline configuration for the build command
+   * @returns A promise that resolves when the build command has completed
+   */
+  build: (inlineConfig: BuildInlineConfig) => Promise<void>;
+  /**
+   * Prepare the documentation for the project
+   *
+   * @param inlineConfig - The inline configuration for the docs command
+   * @returns A promise that resolves when the documentation generation has completed
+   */
+  docs: (inlineConfig: DocsInlineConfig) => Promise<void>;
+  /**
+   * Deploy the project source code
+   *
+   * @remarks
+   * This method will prepare and build the Powerlines project, generating the necessary artifacts for the deployment.
+   *
+   * @param inlineConfig - The inline configuration for the deploy command
+   */
+  deploy: (inlineConfig: DeployInlineConfig) => Promise<void>;
+  /**
+   * Finalization process
+   *
+   * @remarks
+   * This step includes any final processes or clean up required by Powerlines. It will be run after each Powerlines command.
+   *
+   * @returns A promise that resolves when the finalization process has completed
+   */
+  finalize: () => Promise<void>;
+}
+interface ExecutionHostParams {
+  /**
+   * The execution options for the current execution instance
+   */
+  options: EngineExecutionOptions;
+  /**
+   * The inline configuration for the current execution instance, which is the result of merging the user configuration with any configuration provided by plugins during the "config" hook.
+   */
+  inlineConfig: InlineConfig;
+}
+type ExecutionHost<TExecutionAPI extends ReadonlyArray<string>> = Worker<ExecutionHostParams, TExecutionAPI>;
+type PowerlinesExecutionHost = ExecutionHost<typeof EXECUTION_API_METHODS>;
+/**
+ * The Engine interface represents the Powerlines process' orchestration and coordination API.
+ */
+interface Engine<TExecutionAPI extends ReadonlyArray<string>> extends ExecutionInterface {
+  /**
+   * The Powerlines shared context
+   */
+  context: EngineContext;
+  /**
+   * The execution host, which provides methods to call the execution API functions from the engine context. This allows the engine to invoke commands and other API functions during the execution of Powerlines commands, enabling communication between the engine and the execution contexts.
+   */
+  host: ExecutionHost<TExecutionAPI>;
+}
+//#endregion
+export { PowerlinesExecutionHost as a, ExecutionInterface as i, ExecutionHost as n, Worker as o, ExecutionHostParams as r, Engine as t };
+//# sourceMappingURL=api-Cdw4v0W4.d.mts.map

package/dist/api-Cdw4v0W4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-Cdw4v0W4.d.mts","names":[],"sources":["../src/types/utils.ts","../src/types/api.ts"],"mappings":";;;;;;KAkBY,MAAA,kCAAwC,aAAA,oBAC5C,eAAA,YAA2B,MAAA,EAAQ,OAAA,KAAY,OAAA;EAErD,KAAA;EACA,GAAA,QAAW,OAAA;AAAA;;;;AAJb;;;;;UCuBiB,kBAAA;EDtBsC;;;;;;;;EC+BrD,OAAA,GAAU,YAAA,EAAc,mBAAA,KAAwB,OAAA;ED/BP;;;;;;;;ECyCzC,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;;;AAnB9C;;;;;;;EA8BE,MAAA,GAAS,YAAA,EAAc,kBAAA,KAAuB,OAAA;EAAA;;;;;;;;;EAW9C,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;EAmCF;;;;;;EA3B1C,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EAxClB;;;;;;EAgDxB,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EA3B1C;;;;;;;;;EAsCA,KAAA,GAAQ,YAAA,EAAc,iBAAA,KAAsB,OAAA;EAnBrC;;;;;;EA2BP,IAAA,GAAO,YAAA,EAAc,gBAAA,KAAqB,OAAA;EARpB;;;;;;;;EAkBtB,MAAA,GAAS,YAAA,EAAc,kBAAA,KAAuB,OAAA;EAArC;;;;;;AAaX;;EAHE,QAAA,QAAgB,OAAA;AAAA;AAAA,UAGD,mBAAA;EAIN;;;EAAT,OAAA,EAAS,sBAAA;EAKiB;AAG5B;;EAHE,YAAA,EAAc,YAAA;AAAA;AAAA,KAGJ,aAAA,uBAAoC,aAAA,YAAyB,MAAA,CACvE,mBAAA,EACA,aAAA;AAAA,KAGU,uBAAA,GAA0B,aAAA,QAC7B,qBAAA;;;;UAMQ,MAAA,uBACO,aAAA,kBACd,kBAAA;EAdsC;;;EAkB9C,OAAA,EAAS,aAAA;EAhBI;;AAGf;EAkBE,IAAA,EAAM,aAAA,CAAc,aAAA;AAAA"}

package/dist/config-BNe23XHx.d.mts

@@ -0,0 +1,204 @@
+import { CustomLogger, ExecutionOptions, FrameworkOptions, LogMeta, Options, ResolvedConfig, UserConfig } from "@powerlines/core";
+import { RpcStreamingClientHost } from "devframe/client";
+import { RpcCacheManager, RpcCacheOptions, RpcFunctionsCollector } from "devframe/rpc";
+import { WsRpcChannelOptions } from "devframe/rpc/transports/ws-client";
+import { MaybePromise, PartialKeys, RequiredKeys } from "@stryke/types/base";
+import { BirpcOptions, BirpcReturn, ProxifiedRemoteFunctions } from "birpc";
+import { ConnectionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevframeDefinition, EventEmitter, RpcSharedStateHost } from "devframe/types";
+import { Asyncify } from "@stryke/types/async";
+
+//#region src/types/rpc.d.ts
+interface RpcPayloadMetadata {
+  /**
+   * A unique identifier for correlating related Rpc messages, which can be used to group messages that belong to the same logical operation or workflow across different parts of the system. This is a required field and should be generated by the sender of the message.
+   */
+  messageId: string;
+  /**
+   * The type of the Rpc message, which indicates the purpose of the message and how it should be handled by the receiving end. This is a required field and must be one of the predefined values in the IpcMessageType enum.
+   */
+  type: string;
+  /**
+   * The timestamp when the Rpc message was created, represented as the number of milliseconds since the Unix epoch.
+   */
+  timestamp: number;
+  /**
+   * A unique identifier for the current execution instance, which can be used for logging and other purposes to distinguish between different executions in the same process.
+   */
+  executionId?: string;
+  /**
+   * The zero-based index of the current execution within the sequence of executions in the same process.
+   */
+  configIndex?: number;
+  /**
+   * Optional environment identifier to specify the context or environment in which the message is being processed.
+   */
+  environment?: string;
+}
+interface RpcPayloadEnvelop<TPayload> extends RpcPayloadMetadata {
+  /**
+   * The payload data associated with the Rpc message, typed according to the message type.
+   */
+  payload: TPayload;
+}
+type RpcFunction = (payload: any) => MaybePromise<any>;
+type RpcFunctions = Record<string, RpcFunction>;
+type InputRpcFunction = (envelop: RpcPayloadEnvelop<any>) => any;
+type InputRpcFunctions = Record<string, InputRpcFunction>;
+type WrappedRpcFunction = (envelop: RpcPayloadEnvelop<any>) => Promise<any>;
+type WrappedRpcFunctions = Record<string, WrappedRpcFunction>;
+type ExtractRpcFunction<TFunction extends WrappedRpcFunction> = (payload: Parameters<TFunction>[0]["payload"]) => ReturnType<Asyncify<TFunction>>;
+type ExtractRpcFunctions<TFunctions extends WrappedRpcFunctions> = { [TKey in keyof TFunctions]: ExtractRpcFunction<TFunctions[TKey]> };
+type WrapRpcFunction<TFunction extends RpcFunction> = (envelop: RpcPayloadEnvelop<Parameters<TFunction>[0]>) => ReturnType<TFunction> extends Promise<infer A> ? A : ReturnType<TFunction>;
+type WrapRpcFunctions<TFunctions extends RpcFunctions> = { [TKey in keyof TFunctions]: WrapRpcFunction<TFunctions[TKey]> };
+type RpcClientRemoteFunctions<TFunctions extends WrappedRpcFunctions> = ProxifiedRemoteFunctions<ExtractRpcFunctions<TFunctions>>;
+/**
+ * Payload for write log Rpc messages.
+ */
+interface LogPayload {
+  /**
+   * Metadata associated with the log message, excluding fields that are automatically added by the engine such as executionId, configIndex, environment, and timestamp. This can include custom fields relevant to the log entry, such as category, name, command, hook, plugin, and source.
+   */
+  meta: LogMeta;
+  /**
+   * The log message content, which can be a string or an array of strings representing the log entry. This field is required and should contain the actual message to be logged.
+   */
+  message: string;
+}
+interface RpcServerFunctions extends DevToolsRpcServerFunctions {
+  "powerlines:log": (payload: LogPayload) => void;
+}
+interface RpcClientFunctions extends DevToolsRpcClientFunctions {}
+interface RpcContext {
+  /**
+   * The Rpc client to interact with the server
+   */
+  readonly rpc: RpcClient;
+}
+type RpcClientHost = RpcFunctionsCollector<RpcClientFunctions, RpcContext>;
+type RpcClientCall = BirpcReturn<RpcServerFunctions, RpcClientFunctions>["$call"];
+type RpcClientCallEvent = BirpcReturn<RpcServerFunctions, RpcClientFunctions>["$callEvent"];
+type RpcClientCallOptional = BirpcReturn<RpcServerFunctions, RpcClientFunctions>["$callOptional"];
+interface RpcClientEvents {
+  "rpc:is-trusted:updated": (isTrusted: boolean) => void;
+}
+interface RpcClient {
+  /**
+   * The events of the client
+   */
+  events: EventEmitter<RpcClientEvents>;
+  /**
+   * Whether the client is trusted
+   */
+  readonly isTrusted: boolean | null;
+  /**
+   * The connection meta
+   */
+  readonly connectionMeta: ConnectionMeta;
+  /**
+   * Return a promise that resolves when the client is trusted
+   *
+   * Rejects with an error if the timeout is reached
+   *
+   * @param timeout - The timeout in milliseconds, default to 60 seconds
+   */
+  ensureTrusted: (timeout?: number) => Promise<boolean>;
+  /**
+   * Request trust from the server
+   */
+  requestTrust: () => Promise<boolean>;
+  /**
+   * Request trust from the server using a specific auth token.
+   * Updates the stored token and re-requests trust without reloading the page.
+   */
+  requestTrustWithToken: (token: string) => Promise<boolean>;
+  /**
+   * Call a Rpc function on the server
+   */
+  call: RpcClientCall;
+  /**
+   * Call a Rpc event on the server, and does not expect a response
+   */
+  callEvent: RpcClientCallEvent;
+  /**
+   * Call a Rpc optional function on the server
+   */
+  callOptional: RpcClientCallOptional;
+  /**
+   * The client Rpc host
+   */
+  client: RpcClientHost;
+  /**
+   * The shared state host
+   */
+  sharedState: RpcSharedStateHost;
+  /**
+   * The streaming channel host. Subscribe to a server-side stream by
+   * channel + id; the returned reader is both `AsyncIterable<T>` and
+   * exposes `.readable: ReadableStream<T>` for `pipeTo` consumption.
+   */
+  streaming: RpcStreamingClientHost;
+  /**
+   * The Rpc cache manager
+   */
+  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 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;
+  /**
+   * 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 { RpcServerFunctions as C, WrappedRpcFunctions as D, WrappedRpcFunction as E, RpcPayloadMetadata as S, WrapRpcFunctions as T, RpcClientRemoteFunctions as _, ExtractRpcFunction as a, RpcFunctions as b, InputRpcFunctions as c, RpcClientCall as d, RpcClientCallEvent as f, RpcClientHost as g, RpcClientFunctions as h, RpcClientOptions as i, LogPayload as l, RpcClientEvents as m, EngineOptions as n, ExtractRpcFunctions as o, RpcClientCallOptional as p, EngineResolvedConfig as r, InputRpcFunction as s, EngineExecutionOptions as t, RpcClient as u, RpcContext as v, WrapRpcFunction as w, RpcPayloadEnvelop as x, RpcFunction as y };
+//# sourceMappingURL=config-BNe23XHx.d.mts.map

package/dist/config-BNe23XHx.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-BNe23XHx.d.mts","names":[],"sources":["../src/types/rpc.ts","../src/types/config.ts"],"mappings":"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"}