@shell-shock/core 0.17.8 → 0.17.11

package/dist/contexts/options.mjs

@@ -1,2 +1,58 @@
-import{CommandParameterKinds as e}from"../types/command.mjs";import{camelCase as t}from"@stryke/string-format/camel-case";import{isSetString as n}from"@stryke/type-checks/is-set-string";import r from"defu";import{createNamedContext as i,useContext as a}from"@alloy-js/core";function o(e,t){return e.__type=t,e}const s=(i.Ω=[[`&F`]],i(`ExistingOptions`,[]));function c(){return a.Ω=[[`&F`]],a(s)}c.__type=[`useExistingOptions`,`Hook to access the ExistingOptions context.`,`P"/!?"`];function l(i){return i.reduce(o((i,a)=>(i[t(a.name)]??=r({name:t(a.name)},i[a.name]??{},a),a.kind===e.boolean&&!a.variadic&&a.isNegativeOf&&(i[t(a.isNegativeOf)]=r({name:t(a.isNegativeOf)},i[a.isNegativeOf]??{},{...a,env:n(a.env)?`NO_${a.env}`:!1,description:`${a.description.replace(/\.+$/,``)}. This property is the negative form of ${a.name}.`,isNegativeOf:t(a.name),default:!a.default})),i),[`ret`,`option`,``,`P"2!"2""/#`]),{})}l.__type=[`CommandOption`,`options`,`computedOptions`,`P"w!F2""/#`];export{s as ExistingOptionsContext,l as computedOptions,c as useExistingOptions};
+import { createNamedContext, useContext } from "@alloy-js/core";
+import { camelCase } from "@stryke/string-format/camel-case";
+import { isSetString } from "@stryke/type-checks/is-set-string";
+import defu$1 from "defu";
+
+//#region src/contexts/options.ts
+function __assignType(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+/**
+* The reflection parameter context used in template rendering.
+*/
+const ExistingOptionsContext = (createNamedContext.Ω = [["&F"]], createNamedContext("ExistingOptions", []));
+/**
+* Hook to access the ExistingOptions context.
+*
+* @remarks
+* This context provides a list of option names that already exist on the interface definition.
+*
+* @returns A reactive version of the current reflection.
+*/
+function useExistingOptions() {
+	return useContext.Ω = [["&F"]], useContext(ExistingOptionsContext);
+}
+useExistingOptions.__type = [
+	"useExistingOptions",
+	"Hook to access the ExistingOptions context.",
+	"P\"/!?\""
+];
+function computedOptions(options) {
+	return options.reduce(__assignType((ret, option) => {
+		ret[camelCase(option.name)] ??= defu$1({ name: camelCase(option.name) }, ret[option.name] ?? {}, option);
+		if (option.type === "boolean" && !option.variadic && option.isNegativeOf) ret[camelCase(option.isNegativeOf)] = defu$1({ name: camelCase(option.isNegativeOf) }, ret[option.isNegativeOf] ?? {}, {
+			...option,
+			env: isSetString(option.env) ? `NO_${option.env}` : false,
+			description: `${option.description.replace(/\.+$/, "")}. This property is the negative form of ${option.name}.`,
+			isNegativeOf: camelCase(option.name),
+			default: !option.default
+		});
+		return ret;
+	}, [
+		"ret",
+		"option",
+		"",
+		"P\"2!\"2\"\"/#"
+	]), {});
+}
+computedOptions.__type = [
+	"CommandOption",
+	"options",
+	"computedOptions",
+	"P\"w!F2\"\"/#"
+];
+
+//#endregion
+export { ExistingOptionsContext, computedOptions, useExistingOptions };
 //# sourceMappingURL=options.mjs.map

package/dist/contexts/options.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"options.mjs","names":[],"sources":["../../src/contexts/options.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                  ⚡ Storm Software - Shell Shock\n\n This code was released as part of the Shell Shock project. Shell Shock\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/shell-shock.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/shell-shock\n Documentation:            https://docs.stormsoftware.com/projects/shell-shock\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { ComponentContext } from \"@alloy-js/core\";\nimport { createNamedContext, useContext } from \"@alloy-js/core\";\nimport { camelCase } from \"@stryke/string-format/camel-case\";\nimport { isSetString } from \"@stryke/type-checks/is-set-string\";\nimport defu from \"defu\";\nimport type { BooleanCommandOption, CommandOption } from \"../types/command\";\nimport { CommandParameterKinds } from \"../types/command\";\n\n/**\n * The reflection parameter context used in template rendering.\n */\nexport const ExistingOptionsContext: ComponentContext<string[]> =\n  createNamedContext<string[]>(\"ExistingOptions\", []);\n\n/**\n * Hook to access the ExistingOptions context.\n *\n * @remarks\n * This context provides a list of option names that already exist on the interface definition.\n *\n * @returns A reactive version of the current reflection.\n */\nexport function useExistingOptions() {\n  return useContext<string[]>(ExistingOptionsContext)!;\n}\n\nexport function computedOptions(options: CommandOption[]) {\n  return options.reduce(\n    (ret, option) => {\n      ret[camelCase(option.name)] ??= defu(\n        {\n          name: camelCase(option.name)\n        },\n        ret[option.name] ?? {},\n        option\n      );\n\n      if (\n        option.kind === CommandParameterKinds.boolean &&\n        !option.variadic &&\n        option.isNegativeOf\n      ) {\n        ret[camelCase(option.isNegativeOf)] = defu(\n          {\n            name: camelCase(option.isNegativeOf)\n          },\n          ret[option.isNegativeOf] ?? {},\n          {\n            ...option,\n            env: isSetString(option.env) ? `NO_${option.env}` : false,\n            description: `${option.description.replace(\n              /\\.+$/,\n              \"\"\n            )}. This property is the negative form of ${option.name}.`,\n            isNegativeOf: camelCase(option.name),\n            default: !option.default\n          }\n        ) as BooleanCommandOption;\n      }\n\n      return ret;\n    },\n    {} as Record<string, CommandOption>\n  );\n}\n"],"mappings":"kRAAA,SAAS,EAAa,EAAI,EAAM,CAE9B,kBAAO,EAUT,MAAa,GAAsB,EAAkB,EAAA,CAAA,CAAA,KAAA,CAAA,CAAA,EAAA,kBAAA,EAAA,CAAA,EASrD,SAAS,GAA4B,CACrC,MAAO,GAAW,EAAK,CAAA,CAAA,KAAA,CAAA,CAAA,EAAA,EAAA,CAEvB,EAAS,OAAA,CAAA,qBAAuC,8CAAQ,SAAA,eAEtD,OAAA,EAAA,OAAA,GAAA,EAAA,KACC,EAAI,EAAW,EAAA,KAAU,IAAQ,EAAK,CACvC,KAAA,EAAA,EAAA,KAAA,CACF,CAAO,EAAA,EAAM,OAAA,EAAA,CAAA,EAAwB,CACnC,EAAA,OAAmB,EAAW,SAAqB,CAAA,EAAA,UAAA,EAAA,eAAA,EAAA,EAAA,EAAA,aAAA,EAAA,EAAA,CAEnD,KAAA,EAAA,EAAA,aAAA,CACK,CAAC,EAAG,EAAO,eAAmB,EAAC,CAAA,CACrC,GAAA,EACG,IAAA,EAAA,EAAA,IAAA,CAAA,MAAA,EAAA,MAAA,GACI,YAAQ,GAAQ,EAAO,YAAW,QAAM,OAAK,GAAQ,CAAA,0CAAiC,EAAA,KAAA,GAC7F,aAAA,EAAA,EAAA,KAAA,CACG,QAAU,CAAA,EAAS,QACrB,CAAA,EAEO,GACT,CAAA,MAAA,SAAA,GAAA,aAAA,CAAA,CAAA,EAAA,CAAA,CAEA,EAAgB,OAAA,CAAA,gBAAyB,UAAa,kBAAI,aAAA"}
+{"version":3,"file":"options.mjs","names":[],"sources":[],"mappings":""}

package/dist/engine.cjs

@@ -0,0 +1,138 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_get_framework = require('./helpers/get-framework.cjs');
+let _powerlines_engine = require("@powerlines/engine");
+
+//#region src/engine.ts
+/**
+* The Shell Shock Engine class.
+*
+* @remarks
+* This class provides methods to interact with the Shell Shock build system, including cleaning, preparing, linting, building, generating documentation, and finalizing projects.
+*/
+var Engine = class Engine {
+	#powerlines;
+	/**
+	* Creates a new instance of the {@link Engine} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.
+	*
+	* @param options - The user configuration options.
+	* @returns A promise that resolves to a {@link Engine} instance.
+	*/
+	static async from(options) {
+		return new Engine(await (0, _powerlines_engine.createEngine)({
+			...options,
+			framework: require_get_framework.getFramework()
+		}, "@shell-shock/core/api"));
+	}
+	/**
+	* Gets the current build context, which includes information about the project, environment, and configuration. This context is used internally by the Shell Shock API to manage the build process and provide relevant data to plugins and other components.
+	*
+	* @returns The current build context.
+	*/
+	get context() {
+		return this.#powerlines.context;
+	}
+	constructor(powerlines) {
+		this.#powerlines = powerlines;
+	}
+	/**
+	* Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.
+	*
+	* @param inlineConfig - The inline configuration options for the clean operation.
+	* @returns A promise that resolves when the clean operation is complete.
+	*/
+	async clean(inlineConfig) {
+		return this.#powerlines.clean(inlineConfig);
+	}
+	/**
+	* Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.
+	*
+	* @param inlineConfig - The inline configuration options for the prepare operation.
+	* @returns A promise that resolves when the prepare operation is complete.
+	*/
+	async prepare(inlineConfig) {
+		return this.#powerlines.prepare(inlineConfig);
+	}
+	/**
+	* Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.
+	*
+	* @param inlineConfig - The inline configuration options for the lint operation.
+	* @returns A promise that resolves when the lint operation is complete.
+	*/
+	async lint(inlineConfig) {
+		return this.#powerlines.lint(inlineConfig);
+	}
+	/**
+	* Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.
+	*
+	* @param inlineConfig - The inline configuration options for the build operation.
+	* @returns A promise that resolves when the build operation is complete.
+	*/
+	async build(inlineConfig) {
+		return this.#powerlines.build(inlineConfig);
+	}
+	/**
+	* Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.
+	*
+	* @param inlineConfig - The inline configuration options for the documentation operation.
+	* @returns A promise that resolves when the documentation generation is complete.
+	*/
+	async docs(inlineConfig) {
+		return this.#powerlines.docs(inlineConfig);
+	}
+	/**
+	* Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.
+	*
+	* @returns A promise that resolves when the finalize operation is complete.
+	*/
+	async finalize() {
+		return this.#powerlines.finalize();
+	}
+	static __type = [
+		"#powerlines",
+		"EngineOptions",
+		"options",
+		() => Engine,
+		"from",
+		"Creates a new instance of the {@link Engine} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.",
+		"powerlines",
+		"constructor",
+		"inlineConfig",
+		"clean",
+		"Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.",
+		"prepare",
+		"Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.",
+		"lint",
+		"Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.",
+		"build",
+		"Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.",
+		"docs",
+		"Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.",
+		"finalize",
+		"Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.",
+		"Engine",
+		"The Shell Shock Engine class.",
+		"!3!P\"w\"2#P7$`0%s?&!P!2'\"0(P!2)$`0*?+P!2)$`0,?-P!2)$`0.?/P!2)$`00?1P!2)$`02?3P$`04?55w6?7"
+	];
+};
+/**
+* Creates a new {@link Engine} instance.
+*
+* @param options - The user configuration options.
+* @returns A promise that resolves to a {@link Engine} instance.
+*/
+async function createEngine(options) {
+	return Engine.from(options);
+}
+createEngine.__type = [
+	"EngineOptions",
+	"options",
+	() => Engine,
+	"createEngine",
+	"Creates a new {@link Engine} instance.",
+	"P\"w!2\"P7#`/$?%"
+];
+
+//#endregion
+exports.Engine = Engine;
+exports.createEngine = createEngine;
+//# sourceMappingURL=engine.cjs.map

package/dist/engine.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.cjs","names":[],"sources":[],"mappings":""}

package/dist/engine.d.cts

@@ -0,0 +1,79 @@
+import { EngineOptions } from "./types/config.cjs";
+import { BuildInlineConfig, CleanInlineConfig, DocsInlineConfig, LintInlineConfig, PrepareInlineConfig } from "powerlines";
+import { EngineContext } from "@powerlines/engine";
+
+//#region src/engine.d.ts
+/**
+ * The Shell Shock Engine class.
+ *
+ * @remarks
+ * This class provides methods to interact with the Shell Shock build system, including cleaning, preparing, linting, building, generating documentation, and finalizing projects.
+ */
+declare class Engine {
+  #private;
+  /**
+   * Creates a new instance of the {@link Engine} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.
+   *
+   * @param options - The user configuration options.
+   * @returns A promise that resolves to a {@link Engine} instance.
+   */
+  static from(options: EngineOptions): Promise<Engine>;
+  /**
+   * Gets the current build context, which includes information about the project, environment, and configuration. This context is used internally by the Shell Shock API to manage the build process and provide relevant data to plugins and other components.
+   *
+   * @returns The current build context.
+   */
+  get context(): EngineContext;
+  private constructor();
+  /**
+   * Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.
+   *
+   * @param inlineConfig - The inline configuration options for the clean operation.
+   * @returns A promise that resolves when the clean operation is complete.
+   */
+  clean(inlineConfig: CleanInlineConfig): Promise<void>;
+  /**
+   * Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.
+   *
+   * @param inlineConfig - The inline configuration options for the prepare operation.
+   * @returns A promise that resolves when the prepare operation is complete.
+   */
+  prepare(inlineConfig: PrepareInlineConfig): Promise<void>;
+  /**
+   * Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.
+   *
+   * @param inlineConfig - The inline configuration options for the lint operation.
+   * @returns A promise that resolves when the lint operation is complete.
+   */
+  lint(inlineConfig: LintInlineConfig): Promise<void>;
+  /**
+   * Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.
+   *
+   * @param inlineConfig - The inline configuration options for the build operation.
+   * @returns A promise that resolves when the build operation is complete.
+   */
+  build(inlineConfig: BuildInlineConfig): Promise<void>;
+  /**
+   * Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.
+   *
+   * @param inlineConfig - The inline configuration options for the documentation operation.
+   * @returns A promise that resolves when the documentation generation is complete.
+   */
+  docs(inlineConfig: DocsInlineConfig): Promise<void>;
+  /**
+   * Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.
+   *
+   * @returns A promise that resolves when the finalize operation is complete.
+   */
+  finalize(): Promise<void>;
+}
+/**
+ * Creates a new {@link Engine} instance.
+ *
+ * @param options - The user configuration options.
+ * @returns A promise that resolves to a {@link Engine} instance.
+ */
+declare function createEngine(options: EngineOptions): Promise<Engine>;
+//#endregion
+export { Engine, createEngine };
+//# sourceMappingURL=engine.d.cts.map

package/dist/engine.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.cts","names":[],"sources":["../src/engine.ts"],"mappings":";;;;;;;AAoCA;;;;cAAa,MAAA;EAAA;EA0BW;;;;;;EAAA,OAjBF,IAAA,CAAK,OAAA,EAAS,aAAA,GAAgB,OAAA,CAAQ,MAAA;EA6DzB;;;;;EAAA,IA5CtB,OAAA,IAAW,aAAA;EAAA,QAIf,WAAA;;;;;;;EAUM,KAAA,CAAM,YAAA,EAAc,iBAAA,GAAoB,OAAA;EAd/B;;;;;;EAwBT,OAAA,CAAQ,YAAA,EAAc,mBAAA,GAAsB,OAAA;EAAtB;;;;;;EAUtB,IAAA,CAAK,YAAA,EAAc,gBAAA,GAAmB,OAAA;EAUtC;;;;;;EAAA,KAAA,CAAM,YAAA,EAAc,iBAAA,GAAoB,OAAA;EAUF;;;;AASnB;AAWlC;EApBe,IAAA,CAAK,YAAA,EAAc,gBAAA,GAAmB,OAAA;;;;;;EAStC,QAAA,IAAY,OAAA;AAAA;;;;;AAW+C;;iBAApD,YAAA,CAAa,OAAA,EAAS,aAAA,GAAgB,OAAA,CAAQ,MAAA"}

package/dist/engine.d.mts

@@ -0,0 +1,79 @@
+import { EngineOptions } from "./types/config.mjs";
+import { BuildInlineConfig, CleanInlineConfig, DocsInlineConfig, LintInlineConfig, PrepareInlineConfig } from "powerlines";
+import { EngineContext } from "@powerlines/engine";
+
+//#region src/engine.d.ts
+/**
+ * The Shell Shock Engine class.
+ *
+ * @remarks
+ * This class provides methods to interact with the Shell Shock build system, including cleaning, preparing, linting, building, generating documentation, and finalizing projects.
+ */
+declare class Engine {
+  #private;
+  /**
+   * Creates a new instance of the {@link Engine} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.
+   *
+   * @param options - The user configuration options.
+   * @returns A promise that resolves to a {@link Engine} instance.
+   */
+  static from(options: EngineOptions): Promise<Engine>;
+  /**
+   * Gets the current build context, which includes information about the project, environment, and configuration. This context is used internally by the Shell Shock API to manage the build process and provide relevant data to plugins and other components.
+   *
+   * @returns The current build context.
+   */
+  get context(): EngineContext;
+  private constructor();
+  /**
+   * Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.
+   *
+   * @param inlineConfig - The inline configuration options for the clean operation.
+   * @returns A promise that resolves when the clean operation is complete.
+   */
+  clean(inlineConfig: CleanInlineConfig): Promise<void>;
+  /**
+   * Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.
+   *
+   * @param inlineConfig - The inline configuration options for the prepare operation.
+   * @returns A promise that resolves when the prepare operation is complete.
+   */
+  prepare(inlineConfig: PrepareInlineConfig): Promise<void>;
+  /**
+   * Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.
+   *
+   * @param inlineConfig - The inline configuration options for the lint operation.
+   * @returns A promise that resolves when the lint operation is complete.
+   */
+  lint(inlineConfig: LintInlineConfig): Promise<void>;
+  /**
+   * Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.
+   *
+   * @param inlineConfig - The inline configuration options for the build operation.
+   * @returns A promise that resolves when the build operation is complete.
+   */
+  build(inlineConfig: BuildInlineConfig): Promise<void>;
+  /**
+   * Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.
+   *
+   * @param inlineConfig - The inline configuration options for the documentation operation.
+   * @returns A promise that resolves when the documentation generation is complete.
+   */
+  docs(inlineConfig: DocsInlineConfig): Promise<void>;
+  /**
+   * Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.
+   *
+   * @returns A promise that resolves when the finalize operation is complete.
+   */
+  finalize(): Promise<void>;
+}
+/**
+ * Creates a new {@link Engine} instance.
+ *
+ * @param options - The user configuration options.
+ * @returns A promise that resolves to a {@link Engine} instance.
+ */
+declare function createEngine(options: EngineOptions): Promise<Engine>;
+//#endregion
+export { Engine, createEngine };
+//# sourceMappingURL=engine.d.mts.map

package/dist/engine.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.mts","names":[],"sources":["../src/engine.ts"],"mappings":""}

package/dist/engine.mjs

@@ -0,0 +1,136 @@
+import { getFramework } from "./helpers/get-framework.mjs";
+import { createEngine as createEngine$1 } from "@powerlines/engine";
+
+//#region src/engine.ts
+/**
+* The Shell Shock Engine class.
+*
+* @remarks
+* This class provides methods to interact with the Shell Shock build system, including cleaning, preparing, linting, building, generating documentation, and finalizing projects.
+*/
+var Engine = class Engine {
+	#powerlines;
+	/**
+	* Creates a new instance of the {@link Engine} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.
+	*
+	* @param options - The user configuration options.
+	* @returns A promise that resolves to a {@link Engine} instance.
+	*/
+	static async from(options) {
+		return new Engine(await createEngine$1({
+			...options,
+			framework: getFramework()
+		}, "@shell-shock/core/api"));
+	}
+	/**
+	* Gets the current build context, which includes information about the project, environment, and configuration. This context is used internally by the Shell Shock API to manage the build process and provide relevant data to plugins and other components.
+	*
+	* @returns The current build context.
+	*/
+	get context() {
+		return this.#powerlines.context;
+	}
+	constructor(powerlines) {
+		this.#powerlines = powerlines;
+	}
+	/**
+	* Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.
+	*
+	* @param inlineConfig - The inline configuration options for the clean operation.
+	* @returns A promise that resolves when the clean operation is complete.
+	*/
+	async clean(inlineConfig) {
+		return this.#powerlines.clean(inlineConfig);
+	}
+	/**
+	* Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.
+	*
+	* @param inlineConfig - The inline configuration options for the prepare operation.
+	* @returns A promise that resolves when the prepare operation is complete.
+	*/
+	async prepare(inlineConfig) {
+		return this.#powerlines.prepare(inlineConfig);
+	}
+	/**
+	* Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.
+	*
+	* @param inlineConfig - The inline configuration options for the lint operation.
+	* @returns A promise that resolves when the lint operation is complete.
+	*/
+	async lint(inlineConfig) {
+		return this.#powerlines.lint(inlineConfig);
+	}
+	/**
+	* Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.
+	*
+	* @param inlineConfig - The inline configuration options for the build operation.
+	* @returns A promise that resolves when the build operation is complete.
+	*/
+	async build(inlineConfig) {
+		return this.#powerlines.build(inlineConfig);
+	}
+	/**
+	* Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.
+	*
+	* @param inlineConfig - The inline configuration options for the documentation operation.
+	* @returns A promise that resolves when the documentation generation is complete.
+	*/
+	async docs(inlineConfig) {
+		return this.#powerlines.docs(inlineConfig);
+	}
+	/**
+	* Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.
+	*
+	* @returns A promise that resolves when the finalize operation is complete.
+	*/
+	async finalize() {
+		return this.#powerlines.finalize();
+	}
+	static __type = [
+		"#powerlines",
+		"EngineOptions",
+		"options",
+		() => Engine,
+		"from",
+		"Creates a new instance of the {@link Engine} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.",
+		"powerlines",
+		"constructor",
+		"inlineConfig",
+		"clean",
+		"Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.",
+		"prepare",
+		"Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.",
+		"lint",
+		"Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.",
+		"build",
+		"Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.",
+		"docs",
+		"Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.",
+		"finalize",
+		"Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.",
+		"Engine",
+		"The Shell Shock Engine class.",
+		"!3!P\"w\"2#P7$`0%s?&!P!2'\"0(P!2)$`0*?+P!2)$`0,?-P!2)$`0.?/P!2)$`00?1P!2)$`02?3P$`04?55w6?7"
+	];
+};
+/**
+* Creates a new {@link Engine} instance.
+*
+* @param options - The user configuration options.
+* @returns A promise that resolves to a {@link Engine} instance.
+*/
+async function createEngine(options) {
+	return Engine.from(options);
+}
+createEngine.__type = [
+	"EngineOptions",
+	"options",
+	() => Engine,
+	"createEngine",
+	"Creates a new {@link Engine} instance.",
+	"P\"w!2\"P7#`/$?%"
+];
+
+//#endregion
+export { Engine, createEngine };
+//# sourceMappingURL=engine.mjs.map

package/dist/engine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.mjs","names":[],"sources":[],"mappings":""}

package/dist/helpers/automd.cjs

@@ -1 +1,70 @@
-require(`../_virtual/_rolldown/runtime.cjs`);const e=require(`../plugin-utils/context-helpers.cjs`),t=require(`../components/docs.cjs`);require(`../plugin-utils/index.cjs`);let n=require(`@alloy-js/core/jsx-runtime`),r=require(`@alloy-js/core/components`),i=require(`@powerlines/plugin-alloy/render`),a=require(`@alloy-js/core`),o=require(`@alloy-js/markdown`),s=require(`@powerlines/plugin-alloy/core/components/spacing`),c=require(`automd`);function l(e,t){return e.__type=t,e}const u=l(u=>(0,c.defineGenerator)({name:`commands`,async generate(){return{contents:(0,i.renderString)(u,[(0,n.createComponent)(o.Heading,{level:2,children:`Commands`}),(0,n.createComponent)(s.Spacing,{}),(0,n.memo)(()=>a.code`The following commands are available in the ${e.getAppTitle(u,!0)} command-line interface application:`),(0,n.createComponent)(s.Spacing,{}),(0,n.createComponent)(r.For,{get each(){return Object.values(u.commands)},doubleHardline:!0,get children(){return l(e=>(0,n.createComponent)(r.Show,{get when(){return!e.isVirtual},get children(){return(0,n.createComponent)(t.CommandDocs,{command:e,levelOffset:2})}}),[`child`,``,`P"2!"/"`])}}),(0,n.createComponent)(s.Spacing,{})])}}}),[`Context`,`context`,``,`P"w!2""/#`]);exports.commands=u;
+const require_context_helpers = require('../plugin-utils/context-helpers.cjs');
+const require_components_docs = require('../components/docs.cjs');
+require('../plugin-utils/index.cjs');
+let _alloy_js_core_jsx_runtime = require("@alloy-js/core/jsx-runtime");
+let _alloy_js_core = require("@alloy-js/core");
+let _powerlines_plugin_alloy_render = require("@powerlines/plugin-alloy/render");
+let _alloy_js_markdown = require("@alloy-js/markdown");
+let _powerlines_plugin_alloy_core_components_spacing = require("@powerlines/plugin-alloy/core/components/spacing");
+let automd = require("automd");
+
+//#region src/helpers/automd.tsx
+function __assignType(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+/**
+* AutoMD generator to generate CLI command documentation
+*
+* @see https://automd.unjs.io/
+*
+* @param context - The generator context.
+* @returns The generated documentation content.
+*/
+const commands = __assignType((context) => (0, automd.defineGenerator)({
+	name: "commands",
+	async generate() {
+		return { contents: (0, _powerlines_plugin_alloy_render.renderString)(context, [
+			(0, _alloy_js_core_jsx_runtime.createComponent)(_alloy_js_markdown.Heading, {
+				level: 2,
+				children: "Commands"
+			}),
+			(0, _alloy_js_core_jsx_runtime.createComponent)(_powerlines_plugin_alloy_core_components_spacing.Spacing, {}),
+			(0, _alloy_js_core_jsx_runtime.memo)(() => _alloy_js_core.code`The following commands are available in the ${require_context_helpers.getAppTitle(context, true)} command-line interface application:`),
+			(0, _alloy_js_core_jsx_runtime.createComponent)(_powerlines_plugin_alloy_core_components_spacing.Spacing, {}),
+			(0, _alloy_js_core_jsx_runtime.createComponent)(_alloy_js_core.For, {
+				get each() {
+					return Object.values(context.commands);
+				},
+				doubleHardline: true,
+				get children() {
+					return __assignType((child) => (0, _alloy_js_core_jsx_runtime.createComponent)(_alloy_js_core.Show, {
+						get when() {
+							return !child.virtual;
+						},
+						get children() {
+							return (0, _alloy_js_core_jsx_runtime.createComponent)(require_components_docs.CommandDocs, {
+								command: child,
+								levelOffset: 2
+							});
+						}
+					}), [
+						"child",
+						"",
+						"P\"2!\"/\""
+					]);
+				}
+			}),
+			(0, _alloy_js_core_jsx_runtime.createComponent)(_powerlines_plugin_alloy_core_components_spacing.Spacing, {})
+		]) };
+	}
+}), [
+	"Context",
+	"context",
+	"",
+	"P\"w!2\"\"/#"
+]);
+
+//#endregion
+exports.commands = commands;
+//# sourceMappingURL=automd.cjs.map

package/dist/helpers/automd.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"automd.cjs","names":[],"sources":[],"mappings":""}