@powerlines/engine 0.47.4 → 0.49.1

package/dist/api/docs.d.cts

@@ -0,0 +1,17 @@
+import { r as EngineResolvedConfig } from "../config-DKEmqMrh.cjs";
+import { r as EngineSystemContext } from "../context-D0_a0kRO.cjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/docs.d.ts
+/**
+ * Generate the project's documentation.
+ *
+ * @remarks
+ * This function serves as the main entry point for the documentation generation process, orchestrating the execution of documentation hooks across different environments defined in the project configuration. It ensures that all relevant documentation operations are performed in a structured manner, allowing for pre-documentation, main documentation, and post-documentation hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the documentation operation, providing insights into the performance of the documentation process.
+ *
+ * @param context - The execution context for the documentation process, which provides access to the project configuration, environment, and utility functions for performing the documentation operation. The context is used to manage the state and behavior of the documentation process, allowing for hooks to be called at different stages of the documentation and for environment-specific configurations to be applied.
+ */
+declare function docs<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { docs };
+//# sourceMappingURL=docs.d.cts.map

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

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

package/dist/api/docs.d.mts

@@ -0,0 +1,17 @@
+import { r as EngineResolvedConfig } from "../config-ByLyzMI0.mjs";
+import { r as EngineSystemContext } from "../context-DcXV6_GL.mjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/docs.d.ts
+/**
+ * Generate the project's documentation.
+ *
+ * @remarks
+ * This function serves as the main entry point for the documentation generation process, orchestrating the execution of documentation hooks across different environments defined in the project configuration. It ensures that all relevant documentation operations are performed in a structured manner, allowing for pre-documentation, main documentation, and post-documentation hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the documentation operation, providing insights into the performance of the documentation process.
+ *
+ * @param context - The execution context for the documentation process, which provides access to the project configuration, environment, and utility functions for performing the documentation operation. The context is used to manage the state and behavior of the documentation process, allowing for hooks to be called at different stages of the documentation and for environment-specific configurations to be applied.
+ */
+declare function docs<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { docs };
+//# sourceMappingURL=docs.d.mts.map

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

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

package/dist/api/docs.mjs

@@ -0,0 +1,24 @@
+import { prepare } from "./prepare.mjs";
+import { executeEnvironments } from "@powerlines/core/lib/environment";
+
+//#region src/api/docs.ts
+/**
+* Generate the project's documentation.
+*
+* @remarks
+* This function serves as the main entry point for the documentation generation process, orchestrating the execution of documentation hooks across different environments defined in the project configuration. It ensures that all relevant documentation operations are performed in a structured manner, allowing for pre-documentation, main documentation, and post-documentation hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the documentation operation, providing insights into the performance of the documentation process.
+*
+* @param context - The execution context for the documentation process, which provides access to the project configuration, environment, and utility functions for performing the documentation operation. The context is used to manage the state and behavior of the documentation process, allowing for hooks to be called at different stages of the documentation and for environment-specific configurations to be applied.
+*/
+async function docs(context) {
+	const timer = context.timer("Documentation");
+	await prepare(context);
+	await executeEnvironments(context, async (env) => {
+		await context.callHook("docs", { environment: env });
+	});
+	timer();
+}
+
+//#endregion
+export { docs };
+//# sourceMappingURL=docs.mjs.map

package/dist/api/docs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.mjs","names":[],"sources":["../../src/api/docs.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 { ExecutionContext } from \"@powerlines/core\";\nimport { executeEnvironments } from \"@powerlines/core/lib/environment\";\nimport { EngineResolvedConfig } from \"../types/config\";\nimport { EngineSystemContext } from \"../types/context\";\nimport { prepare } from \"./prepare\";\n\n/**\n * Generate the project's documentation.\n *\n * @remarks\n * This function serves as the main entry point for the documentation generation process, orchestrating the execution of documentation hooks across different environments defined in the project configuration. It ensures that all relevant documentation operations are performed in a structured manner, allowing for pre-documentation, main documentation, and post-documentation hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the documentation operation, providing insights into the performance of the documentation process.\n *\n * @param context - The execution context for the documentation process, which provides access to the project configuration, environment, and utility functions for performing the documentation operation. The context is used to manage the state and behavior of the documentation process, allowing for hooks to be called at different stages of the documentation and for environment-specific configurations to be applied.\n */\nexport async function docs<\n  TResolvedConfig extends EngineResolvedConfig,\n  TSystemContext extends EngineSystemContext\n>(context: ExecutionContext<TResolvedConfig, TSystemContext>) {\n  const timer = context.timer(\"Documentation\");\n\n  await prepare<TResolvedConfig, TSystemContext>(context);\n  await executeEnvironments(context, async env => {\n    await context.callHook(\"docs\", {\n      environment: env\n    });\n  });\n\n  timer();\n}\n"],"mappings":";;;;;;;;;;;;AAgCA,eAAsB,KAGpB,SAA4D;CAC5D,MAAM,QAAQ,QAAQ,MAAM,eAAe;CAE3C,MAAM,QAAyC,OAAO;CACtD,MAAM,oBAAoB,SAAS,OAAM,QAAO;EAC9C,MAAM,QAAQ,SAAS,QAAQ,EAC7B,aAAa,IACf,CAAC;CACH,CAAC;CAED,MAAM;AACR"}

package/dist/api/lint.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_api_prepare = require('./prepare.cjs');
+let _powerlines_core_lib_environment = require("@powerlines/core/lib/environment");
+
+//#region src/api/lint.ts
+/**
+* Lint the project's source files and report any issues found.
+*
+* @remarks
+* This function serves as the main entry point for the linting process, orchestrating the execution of linting hooks across different environments defined in the project configuration. It ensures that all relevant linting operations are performed in a structured manner, allowing for pre-linting, main linting, and post-linting hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the linting operation, providing insights into the performance of the linting process.
+*
+* @param context - The execution context for the lint process, which provides access to the project configuration, environment, and utility functions for performing the lint operation. The context is used to manage the state and behavior of the lint process, allowing for hooks to be called at different stages of the lint and for environment-specific configurations to be applied.
+*/
+async function lint(context) {
+	const timer = context.timer("Linting");
+	await require_api_prepare.prepare(context);
+	await (0, _powerlines_core_lib_environment.executeEnvironments)(context, async (env) => {
+		await context.callHook("lint", {
+			environment: env,
+			sequential: false
+		});
+	});
+	timer();
+}
+
+//#endregion
+exports.lint = lint;

package/dist/api/lint.d.cts

@@ -0,0 +1,17 @@
+import { r as EngineResolvedConfig } from "../config-DKEmqMrh.cjs";
+import { r as EngineSystemContext } from "../context-D0_a0kRO.cjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/lint.d.ts
+/**
+ * Lint the project's source files and report any issues found.
+ *
+ * @remarks
+ * This function serves as the main entry point for the linting process, orchestrating the execution of linting hooks across different environments defined in the project configuration. It ensures that all relevant linting operations are performed in a structured manner, allowing for pre-linting, main linting, and post-linting hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the linting operation, providing insights into the performance of the linting process.
+ *
+ * @param context - The execution context for the lint process, which provides access to the project configuration, environment, and utility functions for performing the lint operation. The context is used to manage the state and behavior of the lint process, allowing for hooks to be called at different stages of the lint and for environment-specific configurations to be applied.
+ */
+declare function lint<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { lint };
+//# sourceMappingURL=lint.d.cts.map

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

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

package/dist/api/lint.d.mts

@@ -0,0 +1,17 @@
+import { r as EngineResolvedConfig } from "../config-ByLyzMI0.mjs";
+import { r as EngineSystemContext } from "../context-DcXV6_GL.mjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/lint.d.ts
+/**
+ * Lint the project's source files and report any issues found.
+ *
+ * @remarks
+ * This function serves as the main entry point for the linting process, orchestrating the execution of linting hooks across different environments defined in the project configuration. It ensures that all relevant linting operations are performed in a structured manner, allowing for pre-linting, main linting, and post-linting hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the linting operation, providing insights into the performance of the linting process.
+ *
+ * @param context - The execution context for the lint process, which provides access to the project configuration, environment, and utility functions for performing the lint operation. The context is used to manage the state and behavior of the lint process, allowing for hooks to be called at different stages of the lint and for environment-specific configurations to be applied.
+ */
+declare function lint<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { lint };
+//# sourceMappingURL=lint.d.mts.map

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

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

package/dist/api/lint.mjs

@@ -0,0 +1,27 @@
+import { prepare } from "./prepare.mjs";
+import { executeEnvironments } from "@powerlines/core/lib/environment";
+
+//#region src/api/lint.ts
+/**
+* Lint the project's source files and report any issues found.
+*
+* @remarks
+* This function serves as the main entry point for the linting process, orchestrating the execution of linting hooks across different environments defined in the project configuration. It ensures that all relevant linting operations are performed in a structured manner, allowing for pre-linting, main linting, and post-linting hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the linting operation, providing insights into the performance of the linting process.
+*
+* @param context - The execution context for the lint process, which provides access to the project configuration, environment, and utility functions for performing the lint operation. The context is used to manage the state and behavior of the lint process, allowing for hooks to be called at different stages of the lint and for environment-specific configurations to be applied.
+*/
+async function lint(context) {
+	const timer = context.timer("Linting");
+	await prepare(context);
+	await executeEnvironments(context, async (env) => {
+		await context.callHook("lint", {
+			environment: env,
+			sequential: false
+		});
+	});
+	timer();
+}
+
+//#endregion
+export { lint };
+//# sourceMappingURL=lint.mjs.map

package/dist/api/lint.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.mjs","names":[],"sources":["../../src/api/lint.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 { ExecutionContext } from \"@powerlines/core\";\nimport { executeEnvironments } from \"@powerlines/core/lib/environment\";\nimport { EngineResolvedConfig } from \"../types/config\";\nimport { EngineSystemContext } from \"../types/context\";\nimport { prepare } from \"./prepare\";\n\n/**\n * Lint the project's source files and report any issues found.\n *\n * @remarks\n * This function serves as the main entry point for the linting process, orchestrating the execution of linting hooks across different environments defined in the project configuration. It ensures that all relevant linting operations are performed in a structured manner, allowing for pre-linting, main linting, and post-linting hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the linting operation, providing insights into the performance of the linting process.\n *\n * @param context - The execution context for the lint process, which provides access to the project configuration, environment, and utility functions for performing the lint operation. The context is used to manage the state and behavior of the lint process, allowing for hooks to be called at different stages of the lint and for environment-specific configurations to be applied.\n */\nexport async function lint<\n  TResolvedConfig extends EngineResolvedConfig,\n  TSystemContext extends EngineSystemContext\n>(context: ExecutionContext<TResolvedConfig, TSystemContext>) {\n  const timer = context.timer(\"Linting\");\n\n  await prepare<TResolvedConfig, TSystemContext>(context);\n  await executeEnvironments(context, async env => {\n    await context.callHook(\"lint\", {\n      environment: env,\n      sequential: false\n    });\n  });\n\n  timer();\n}\n"],"mappings":";;;;;;;;;;;;AAgCA,eAAsB,KAGpB,SAA4D;CAC5D,MAAM,QAAQ,QAAQ,MAAM,SAAS;CAErC,MAAM,QAAyC,OAAO;CACtD,MAAM,oBAAoB,SAAS,OAAM,QAAO;EAC9C,MAAM,QAAQ,SAAS,QAAQ;GAC7B,aAAa;GACb,YAAY;EACd,CAAC;CACH,CAAC;CAED,MAAM;AACR"}

package/dist/api/prepare.cjs

@@ -0,0 +1,68 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _powerlines_core_lib_environment = require("@powerlines/core/lib/environment");
+let _powerlines_core_lib_generate_types = require("@powerlines/core/lib/generate-types");
+let _powerlines_core_lib_install_dependencies = require("@powerlines/core/lib/install-dependencies");
+let _powerlines_core_lib_meta = require("@powerlines/core/lib/meta");
+let _powerlines_core_lib_typescript_tsconfig = require("@powerlines/core/lib/typescript/tsconfig");
+let _powerlines_core_lib_utilities_format = require("@powerlines/core/lib/utilities/format");
+let _powerlines_core_plugin_utils = require("@powerlines/core/plugin-utils");
+let _stryke_convert_to_array = require("@stryke/convert/to-array");
+let _stryke_fs_helpers = require("@stryke/fs/helpers");
+let _stryke_type_checks_is_object = require("@stryke/type-checks/is-object");
+
+//#region src/api/prepare.ts
+/**
+* Prepare 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 prepare(context, skipTypes = false) {
+	const timer = context.timer("Preparation");
+	await (0, _powerlines_core_lib_environment.executeEnvironments)(context, async (env) => {
+		env.debug(`Initializing the processing options for the Powerlines project.`);
+		await context.callHook("configResolved", {
+			environment: env,
+			order: "pre"
+		});
+		await (0, _powerlines_core_lib_typescript_tsconfig.initializeTsconfig)(env);
+		await context.callHook("configResolved", {
+			environment: env,
+			order: "normal"
+		});
+		if (env.entry.length > 0) env.debug(`The configuration provided ${(0, _stryke_type_checks_is_object.isObject)(env.config.input) ? Object.keys(env.config.input).length : (0, _stryke_convert_to_array.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 (0, _powerlines_core_lib_typescript_tsconfig.resolveTsconfig)(env);
+		await (0, _powerlines_core_lib_install_dependencies.installDependencies)(env);
+		await context.callHook("configResolved", {
+			environment: env,
+			order: "post"
+		});
+		env.trace({
+			meta: { category: "config" },
+			message: `Powerlines configuration after configResolved hook: \n${(0, _powerlines_core_plugin_utils.formatConfig)(env.config)}`
+		});
+		if (!env.fs.existsSync(env.cachePath)) await (0, _stryke_fs_helpers.createDirectory)(env.cachePath);
+		if (!env.fs.existsSync(env.dataPath)) await (0, _stryke_fs_helpers.createDirectory)(env.dataPath);
+		await context.callHook("prepare", {
+			environment: env,
+			order: "pre"
+		});
+		await context.callHook("prepare", {
+			environment: env,
+			order: "normal"
+		});
+		await context.callHook("prepare", {
+			environment: env,
+			order: "post"
+		});
+		if (!skipTypes && env.config.output.types !== false) await (0, _powerlines_core_lib_generate_types.handleTypes)(context, env);
+		context.debug("Formatting files generated during the prepare step.");
+		await Promise.all([(0, _powerlines_core_lib_utilities_format.formatFolder)(env, env.builtinsPath), (0, _powerlines_core_lib_utilities_format.formatFolder)(env, env.entryPath)]);
+		await (0, _powerlines_core_lib_meta.writeMetaFile)(env);
+		env.persistedMeta = env.meta;
+	});
+	timer();
+}
+
+//#endregion
+exports.prepare = prepare;

package/dist/api/prepare.d.cts

@@ -0,0 +1,14 @@
+import { r as EngineResolvedConfig } from "../config-DKEmqMrh.cjs";
+import { r as EngineSystemContext } from "../context-D0_a0kRO.cjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/prepare.d.ts
+/**
+ * Prepare 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.
+ */
+declare function prepare<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>, skipTypes?: boolean): Promise<void>;
+//#endregion
+export { prepare };
+//# sourceMappingURL=prepare.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepare.d.cts","names":[],"sources":["../../src/api/prepare.ts"],"mappings":";;;;;;;AAwCA;;;iBAAsB,OAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CAEvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,GAC3C,SAAA,aAAiB,OAAA"}

package/dist/api/prepare.d.mts

@@ -0,0 +1,14 @@
+import { r as EngineResolvedConfig } from "../config-ByLyzMI0.mjs";
+import { r as EngineSystemContext } from "../context-DcXV6_GL.mjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/prepare.d.ts
+/**
+ * Prepare 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.
+ */
+declare function prepare<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>, skipTypes?: boolean): Promise<void>;
+//#endregion
+export { prepare };
+//# sourceMappingURL=prepare.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepare.d.mts","names":[],"sources":["../../src/api/prepare.ts"],"mappings":";;;;;;;AAwCA;;;iBAAsB,OAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CAEvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,GAC3C,SAAA,aAAiB,OAAA"}

package/dist/api/prepare.mjs

@@ -0,0 +1,68 @@
+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 { formatFolder } from "@powerlines/core/lib/utilities/format";
+import { formatConfig } from "@powerlines/core/plugin-utils";
+import { toArray } from "@stryke/convert/to-array";
+import { createDirectory } from "@stryke/fs/helpers";
+import { isObject } from "@stryke/type-checks/is-object";
+
+//#region src/api/prepare.ts
+/**
+* Prepare 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 prepare(context, skipTypes = false) {
+	const timer = context.timer("Preparation");
+	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"
+		});
+		env.trace({
+			meta: { category: "config" },
+			message: `Powerlines configuration after configResolved hook: \n${formatConfig(env.config)}`
+		});
+		if (!env.fs.existsSync(env.cachePath)) await createDirectory(env.cachePath);
+		if (!env.fs.existsSync(env.dataPath)) await createDirectory(env.dataPath);
+		await context.callHook("prepare", {
+			environment: env,
+			order: "pre"
+		});
+		await context.callHook("prepare", {
+			environment: env,
+			order: "normal"
+		});
+		await context.callHook("prepare", {
+			environment: env,
+			order: "post"
+		});
+		if (!skipTypes && env.config.output.types !== false) await handleTypes(context, env);
+		context.debug("Formatting files generated during the prepare step.");
+		await Promise.all([formatFolder(env, env.builtinsPath), formatFolder(env, env.entryPath)]);
+		await writeMetaFile(env);
+		env.persistedMeta = env.meta;
+	});
+	timer();
+}
+
+//#endregion
+export { prepare };
+//# sourceMappingURL=prepare.mjs.map

package/dist/api/prepare.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare.mjs","names":[],"sources":["../../src/api/prepare.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 type { ExecutionContext } from \"@powerlines/core\";\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 { formatFolder } from \"@powerlines/core/lib/utilities/format\";\nimport { formatConfig } from \"@powerlines/core/plugin-utils\";\nimport { toArray } from \"@stryke/convert/to-array\";\nimport { createDirectory } from \"@stryke/fs/helpers\";\nimport { isObject } from \"@stryke/type-checks/is-object\";\nimport { EngineResolvedConfig } from \"../types/config\";\nimport { EngineSystemContext } from \"../types/context\";\n\n/**\n * Prepare 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 prepare<\n  TResolvedConfig extends EngineResolvedConfig,\n  TSystemContext extends EngineSystemContext\n>(\n  context: ExecutionContext<TResolvedConfig, TSystemContext>,\n  skipTypes = false\n) {\n  const timer = context.timer(\"Preparation\");\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    env.trace({\n      meta: {\n        category: \"config\"\n      },\n      message: `Powerlines configuration after configResolved hook: \\n${formatConfig(\n        env.config\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    await context.callHook(\"prepare\", {\n      environment: env,\n      order: \"pre\"\n    });\n    await context.callHook(\"prepare\", {\n      environment: env,\n      order: \"normal\"\n    });\n\n    await context.callHook(\"prepare\", {\n      environment: env,\n      order: \"post\"\n    });\n\n    if (!skipTypes && env.config.output.types !== false) {\n      await handleTypes(context, env);\n    }\n\n    context.debug(\"Formatting files generated during the prepare step.\");\n\n    await Promise.all([\n      formatFolder(env, env.builtinsPath),\n      formatFolder(env, env.entryPath)\n    ]);\n\n    await writeMetaFile(env);\n    env.persistedMeta = env.meta;\n  });\n\n  timer();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAwCA,eAAsB,QAIpB,SACA,YAAY,OACZ;CACA,MAAM,QAAQ,QAAQ,MAAM,aAAa;CAEzC,MAAM,oBAAoB,SAAS,OAAM,QAAO;EAC9C,IAAI,MACF,iEACF;EAEA,MAAM,QAAQ,SAAS,kBAAkB;GACvC,aAAa;GACb,OAAO;EACT,CAAC;EAED,MAAM,mBAAoD,GAAG;EAE7D,MAAM,QAAQ,SAAS,kBAAkB;GACvC,aAAa;GACb,OAAO;EACT,CAAC;EAED,IAAI,IAAI,MAAM,SAAS,GACrB,IAAI,MACF,8BACE,SAAS,IAAI,OAAO,KAAK,IACrB,OAAO,KAAK,IAAI,OAAO,KAAK,EAAE,SAC9B,QAAQ,IAAI,OAAO,KAAK,EAAE,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,IAE7C,EACC,KAAK,KAAK,MACb,IAER;OAEA,IAAI,KACF,qCACE,IAAI,OAAO,MACZ,6HACH;EAGF,MAAM,gBAAiD,GAAG;EAC1D,MAAM,oBAAoB,GAAG;EAE7B,MAAM,QAAQ,SAAS,kBAAkB;GACvC,aAAa;GACb,OAAO;EACT,CAAC;EAED,IAAI,MAAM;GACR,MAAM,EACJ,UAAU,SACZ;GACA,SAAS,yDAAyD,aAChE,IAAI,MACN;EACF,CAAC;EAED,IAAI,CAAC,IAAI,GAAG,WAAW,IAAI,SAAS,GAClC,MAAM,gBAAgB,IAAI,SAAS;EAGrC,IAAI,CAAC,IAAI,GAAG,WAAW,IAAI,QAAQ,GACjC,MAAM,gBAAgB,IAAI,QAAQ;EAGpC,MAAM,QAAQ,SAAS,WAAW;GAChC,aAAa;GACb,OAAO;EACT,CAAC;EACD,MAAM,QAAQ,SAAS,WAAW;GAChC,aAAa;GACb,OAAO;EACT,CAAC;EAED,MAAM,QAAQ,SAAS,WAAW;GAChC,aAAa;GACb,OAAO;EACT,CAAC;EAED,IAAI,CAAC,aAAa,IAAI,OAAO,OAAO,UAAU,OAC5C,MAAM,YAAY,SAAS,GAAG;EAGhC,QAAQ,MAAM,qDAAqD;EAEnE,MAAM,QAAQ,IAAI,CAChB,aAAa,KAAK,IAAI,YAAY,GAClC,aAAa,KAAK,IAAI,SAAS,CACjC,CAAC;EAED,MAAM,cAAc,GAAG;EACvB,IAAI,gBAAgB,IAAI;CAC1B,CAAC;CAED,MAAM;AACR"}

package/dist/api/test.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_api_prepare = require('./prepare.cjs');
+let _powerlines_core_lib_environment = require("@powerlines/core/lib/environment");
+
+//#region src/api/test.ts
+/**
+* Test the project's source files and report any issues found.
+*
+* @remarks
+* This function serves as the main entry point for the testing process, orchestrating the execution of testing hooks across different environments defined in the project configuration. It ensures that all relevant testing operations are performed in a structured manner, allowing for pre-testing, main testing, and post-testing hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the testing operation, providing insights into the performance of the testing process.
+*
+* @param context - The execution context for the test process, which provides access to the project configuration, environment, and utility functions for performing the test operation. The context is used to manage the state and behavior of the test process, allowing for hooks to be called at different stages of the test and for environment-specific configurations to be applied.
+*/
+async function test(context) {
+	const timer = context.timer("Testing");
+	await require_api_prepare.prepare(context);
+	await (0, _powerlines_core_lib_environment.executeEnvironments)(context, async (env) => {
+		await context.callHook("test", {
+			environment: env,
+			sequential: false
+		});
+	});
+	timer();
+}
+
+//#endregion
+exports.test = test;

package/dist/api/test.d.cts

@@ -0,0 +1,17 @@
+import { r as EngineResolvedConfig } from "../config-DKEmqMrh.cjs";
+import { r as EngineSystemContext } from "../context-D0_a0kRO.cjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/test.d.ts
+/**
+ * Test the project's source files and report any issues found.
+ *
+ * @remarks
+ * This function serves as the main entry point for the testing process, orchestrating the execution of testing hooks across different environments defined in the project configuration. It ensures that all relevant testing operations are performed in a structured manner, allowing for pre-testing, main testing, and post-testing hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the testing operation, providing insights into the performance of the testing process.
+ *
+ * @param context - The execution context for the test process, which provides access to the project configuration, environment, and utility functions for performing the test operation. The context is used to manage the state and behavior of the test process, allowing for hooks to be called at different stages of the test and for environment-specific configurations to be applied.
+ */
+declare function test<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { test };
+//# sourceMappingURL=test.d.cts.map

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

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

package/dist/api/test.d.mts

@@ -0,0 +1,17 @@
+import { r as EngineResolvedConfig } from "../config-ByLyzMI0.mjs";
+import { r as EngineSystemContext } from "../context-DcXV6_GL.mjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/test.d.ts
+/**
+ * Test the project's source files and report any issues found.
+ *
+ * @remarks
+ * This function serves as the main entry point for the testing process, orchestrating the execution of testing hooks across different environments defined in the project configuration. It ensures that all relevant testing operations are performed in a structured manner, allowing for pre-testing, main testing, and post-testing hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the testing operation, providing insights into the performance of the testing process.
+ *
+ * @param context - The execution context for the test process, which provides access to the project configuration, environment, and utility functions for performing the test operation. The context is used to manage the state and behavior of the test process, allowing for hooks to be called at different stages of the test and for environment-specific configurations to be applied.
+ */
+declare function test<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { test };
+//# sourceMappingURL=test.d.mts.map

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

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

package/dist/api/test.mjs

@@ -0,0 +1,27 @@
+import { prepare } from "./prepare.mjs";
+import { executeEnvironments } from "@powerlines/core/lib/environment";
+
+//#region src/api/test.ts
+/**
+* Test the project's source files and report any issues found.
+*
+* @remarks
+* This function serves as the main entry point for the testing process, orchestrating the execution of testing hooks across different environments defined in the project configuration. It ensures that all relevant testing operations are performed in a structured manner, allowing for pre-testing, main testing, and post-testing hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the testing operation, providing insights into the performance of the testing process.
+*
+* @param context - The execution context for the test process, which provides access to the project configuration, environment, and utility functions for performing the test operation. The context is used to manage the state and behavior of the test process, allowing for hooks to be called at different stages of the test and for environment-specific configurations to be applied.
+*/
+async function test(context) {
+	const timer = context.timer("Testing");
+	await prepare(context);
+	await executeEnvironments(context, async (env) => {
+		await context.callHook("test", {
+			environment: env,
+			sequential: false
+		});
+	});
+	timer();
+}
+
+//#endregion
+export { test };
+//# sourceMappingURL=test.mjs.map

package/dist/api/test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.mjs","names":[],"sources":["../../src/api/test.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 { ExecutionContext } from \"@powerlines/core\";\nimport { executeEnvironments } from \"@powerlines/core/lib/environment\";\nimport { EngineResolvedConfig } from \"../types/config\";\nimport { EngineSystemContext } from \"../types/context\";\nimport { prepare } from \"./prepare\";\n\n/**\n * Test the project's source files and report any issues found.\n *\n * @remarks\n * This function serves as the main entry point for the testing process, orchestrating the execution of testing hooks across different environments defined in the project configuration. It ensures that all relevant testing operations are performed in a structured manner, allowing for pre-testing, main testing, and post-testing hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the testing operation, providing insights into the performance of the testing process.\n *\n * @param context - The execution context for the test process, which provides access to the project configuration, environment, and utility functions for performing the test operation. The context is used to manage the state and behavior of the test process, allowing for hooks to be called at different stages of the test and for environment-specific configurations to be applied.\n */\nexport async function test<\n  TResolvedConfig extends EngineResolvedConfig,\n  TSystemContext extends EngineSystemContext\n>(context: ExecutionContext<TResolvedConfig, TSystemContext>) {\n  const timer = context.timer(\"Testing\");\n\n  await prepare(context);\n  await executeEnvironments(context, async env => {\n    await context.callHook(\"test\", {\n      environment: env,\n      sequential: false\n    });\n  });\n\n  timer();\n}\n"],"mappings":";;;;;;;;;;;;AAgCA,eAAsB,KAGpB,SAA4D;CAC5D,MAAM,QAAQ,QAAQ,MAAM,SAAS;CAErC,MAAM,QAAQ,OAAO;CACrB,MAAM,oBAAoB,SAAS,OAAM,QAAO;EAC9C,MAAM,QAAQ,SAAS,QAAQ;GAC7B,aAAa;GACb,YAAY;EACd,CAAC;CACH,CAAC;CAED,MAAM;AACR"}

package/dist/api/types.cjs

@@ -0,0 +1,70 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_api_prepare = require('./prepare.cjs');
+let _powerlines_core_lib_environment = require("@powerlines/core/lib/environment");
+let _powerlines_core_lib_generate_types = require("@powerlines/core/lib/generate-types");
+let _powerlines_core_lib_install_dependencies = require("@powerlines/core/lib/install-dependencies");
+let _powerlines_core_lib_meta = require("@powerlines/core/lib/meta");
+let _powerlines_core_lib_typescript_tsconfig = require("@powerlines/core/lib/typescript/tsconfig");
+let _powerlines_core_lib_utilities_format = require("@powerlines/core/lib/utilities/format");
+let _stryke_convert_to_array = require("@stryke/convert/to-array");
+let _stryke_fs_helpers = require("@stryke/fs/helpers");
+let _stryke_type_checks_is_object = require("@stryke/type-checks/is-object");
+let _storm_software_config_tools_logger = require("@storm-software/config-tools/logger");
+let _stryke_helpers_omit = require("@stryke/helpers/omit");
+let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+
+//#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 (0, _powerlines_core_lib_environment.executeEnvironments)(context, async (env) => {
+		env.debug(`Initializing the processing options for the Powerlines project.`);
+		await context.callHook("configResolved", {
+			environment: env,
+			order: "pre"
+		});
+		await (0, _powerlines_core_lib_typescript_tsconfig.initializeTsconfig)(env);
+		await context.callHook("configResolved", {
+			environment: env,
+			order: "normal"
+		});
+		if (env.entry.length > 0) env.debug(`The configuration provided ${(0, _stryke_type_checks_is_object.isObject)(env.config.input) ? Object.keys(env.config.input).length : (0, _stryke_convert_to_array.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 (0, _powerlines_core_lib_typescript_tsconfig.resolveTsconfig)(env);
+		await (0, _powerlines_core_lib_install_dependencies.installDependencies)(env);
+		await context.callHook("configResolved", {
+			environment: env,
+			order: "post"
+		});
+		context.trace(`Powerlines configuration has been resolved: \n\n${(0, _storm_software_config_tools_logger.formatLogMessage)({
+			...env.config,
+			userConfig: (0, _stryke_type_checks_is_set_object.isSetObject)(env.config.userConfig) ? (0, _stryke_helpers_omit.omit)(env.config.userConfig, ["plugins"]) : void 0,
+			inlineConfig: (0, _stryke_type_checks_is_set_object.isSetObject)(env.config.inlineConfig) ? env.config.inlineConfig : void 0,
+			plugins: env.plugins.map((plugin) => plugin.name)
+		})}`);
+		if (!env.fs.existsSync(env.cachePath)) await (0, _stryke_fs_helpers.createDirectory)(env.cachePath);
+		if (!env.fs.existsSync(env.dataPath)) await (0, _stryke_fs_helpers.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 require_api_prepare.prepare(context, true);
+		}
+		await (0, _powerlines_core_lib_generate_types.handleTypes)(context, env);
+		context.debug("Formatting files generated during the types step.");
+		await (0, _powerlines_core_lib_utilities_format.format)(env, env.typesPath, await env.fs.read(env.typesPath) ?? "");
+		await (0, _powerlines_core_lib_meta.writeMetaFile)(env);
+		env.persistedMeta = env.meta;
+	});
+	timer();
+}
+
+//#endregion
+exports.types = types;

package/dist/api/types.d.cts

@@ -0,0 +1,17 @@
+import { r as EngineResolvedConfig } from "../config-DKEmqMrh.cjs";
+import { r as EngineSystemContext } from "../context-D0_a0kRO.cjs";
+import { ExecutionContext } from "@powerlines/core/types/context";
+
+//#region src/api/types.d.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.
+ */
+declare function types<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { types };
+//# sourceMappingURL=types.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","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.d.mts

@@ -0,0 +1,17 @@
+import { r as EngineResolvedConfig } from "../config-ByLyzMI0.mjs";
+import { r as EngineSystemContext } from "../context-DcXV6_GL.mjs";
+import { ExecutionContext } from "@powerlines/core/types/context";
+
+//#region src/api/types.d.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.
+ */
+declare function types<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { types };
+//# sourceMappingURL=types.d.mts.map