@shell-shock/core 0.17.21 → 0.17.23

package/dist/plugin-Bhfq0DMC.cjs

@@ -0,0 +1,1490 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_docs = require('./docs-C6ZvsVMu.cjs');
+const require_context_helpers = require('./context-helpers-_wUuFRB8.cjs');
+const require_plugin_utils_index = require('./plugin-utils/index.cjs');
+const require_helpers_power_plant = require('./helpers/power-plant.cjs');
+const require_generator = require('./generator.cjs');
+const require_get_framework = require('./get-framework-CxZc2krd.cjs');
+let _alloy_js_core_jsx_runtime = require("@alloy-js/core/jsx-runtime");
+let _alloy_js_core = require("@alloy-js/core");
+let _power_plant_schema = require("@power-plant/schema");
+let _powerlines_plugin_automd = require("@powerlines/plugin-automd");
+let _powerlines_plugin_env_helpers_schema = require("@powerlines/plugin-env/helpers/schema");
+let _powerlines_plugin_nodejs = require("@powerlines/plugin-nodejs");
+let _powerlines_plugin_tsdown = require("@powerlines/plugin-tsdown");
+let _stryke_convert_extract_file_reference = require("@stryke/convert/extract-file-reference");
+let _stryke_convert_to_array = require("@stryke/convert/to-array");
+let _stryke_fs_chmod_x = require("@stryke/fs/chmod-x");
+let _stryke_path_append = require("@stryke/path/append");
+let _stryke_path_find = require("@stryke/path/find");
+let _stryke_path_is_parent_path = require("@stryke/path/is-parent-path");
+let _stryke_path_join_paths = require("@stryke/path/join-paths");
+let _stryke_path_replace = require("@stryke/path/replace");
+let _stryke_path_resolve_parent_path = require("@stryke/path/resolve-parent-path");
+let _stryke_string_format_camel_case = require("@stryke/string-format/camel-case");
+let _stryke_string_format_constant_case = require("@stryke/string-format/constant-case");
+let _stryke_string_format_kebab_case = require("@stryke/string-format/kebab-case");
+let _stryke_type_checks_is_object = require("@stryke/type-checks/is-object");
+let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+let _stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+let defu = require("defu");
+let powerlines = require("powerlines");
+let powerlines_utils = require("powerlines/utils");
+let _alloy_js_markdown = require("@alloy-js/markdown");
+let _power_plant_alloy_js_core_components_spacing = require("@power-plant/alloy-js/core/components/spacing");
+let _stryke_string_format_title_case = require("@stryke/string-format/title-case");
+let _powerlines_plugin_alloy_render = require("@powerlines/plugin-alloy/render");
+let zod = require("zod");
+let automd = require("automd");
+let _stryke_fs_list_files = require("@stryke/fs/list-files");
+let _stryke_path_common = require("@stryke/path/common");
+let _stryke_path_file_path_fns = require("@stryke/path/file-path-fns");
+let node_fs = require("node:fs");
+let _powerlines_plugin_env_helpers = require("@powerlines/plugin-env/helpers");
+let _stryke_helpers_get_unique = require("@stryke/helpers/get-unique");
+let _stryke_json_storm_json = require("@stryke/json/storm-json");
+let _stryke_cli_utils_tree = require("@stryke/cli/utils/tree");
+let _stryke_type_checks_is_function = require("@stryke/type-checks/is-function");
+let _stryke_json = require("@stryke/json");
+let jiti = require("jiti");
+let node_path = require("node:path");
+let _stryke_type_checks_is_string = require("@stryke/type-checks/is-string");
+let typescript = require("typescript");
+typescript = __toESM(typescript, 1);
+let node_fs_promises = require("node:fs/promises");
+
+//#region src/helpers/automd.tsx
+/**
+* AutoMD generator to generate CLI command documentation
+*
+* @see https://automd.unjs.io/
+*
+* @param context - The generator context.
+* @returns The generated documentation content.
+*/
+const commands = (context) => (0, automd.defineGenerator)({
+	name: "commands",
+	async generate(ctx) {
+		let commands = Object.values(context.commands).filter((cmd) => !cmd.virtual);
+		if (ctx.args.command) {
+			if (!context.commands[ctx.args.command]) throw new Error(`The command "${ctx.args.command}" does not exist in the application.`);
+			commands = [context.commands[ctx.args.command]];
+		}
+		return { contents: (0, _powerlines_plugin_alloy_render.renderString)(context, [
+			(0, _alloy_js_core_jsx_runtime.createComponent)(_alloy_js_core.Show, {
+				get when() {
+					return !ctx.args.command;
+				},
+				get children() {
+					return [
+						(0, _alloy_js_core_jsx_runtime.createComponent)(_alloy_js_markdown.Heading, {
+							level: 2,
+							children: "Commands"
+						}),
+						(0, _alloy_js_core_jsx_runtime.createComponent)(_power_plant_alloy_js_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)(_power_plant_alloy_js_core_components_spacing.Spacing, {})
+					];
+				}
+			}),
+			(0, _alloy_js_core_jsx_runtime.createComponent)(_alloy_js_core.For, {
+				each: commands,
+				doubleHardline: true,
+				children: (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_docs.CommandDocs, {
+							command: child,
+							levelOffset: 2
+						});
+					}
+				})
+			}),
+			(0, _alloy_js_core_jsx_runtime.createComponent)(_power_plant_alloy_js_core_components_spacing.Spacing, {})
+		]) };
+	}
+});
+/**
+* AutoMD generator to generate usage examples for a specific command.
+*
+* @param context - The generator context.
+* @returns The generated usage content.
+*/
+const usage = (context) => (0, automd.defineGenerator)({
+	name: "usage",
+	async generate(ctx) {
+		if (!ctx.args.command) throw new Error("The 'usage' generator requires the \"command\" argument.");
+		if (!context.commands[ctx.args.command]) throw new Error(`The command "${ctx.args.command}" does not exist in the application.`);
+		let packageManagers = [
+			"npm",
+			"yarn",
+			"pnpm",
+			"bun"
+		];
+		if (ctx.args.packageManager) packageManagers = [String(ctx.args.packageManager)];
+		if (packageManagers.some((pm) => ![
+			"npm",
+			"yarn",
+			"pnpm",
+			"bun"
+		].includes(pm))) throw new Error(`Invalid package manager specified. Supported package managers are: npm, yarn, pnpm, and bun.`);
+		return { contents: (0, _powerlines_plugin_alloy_render.renderString)(context, [(0, _alloy_js_core_jsx_runtime.createComponent)(_alloy_js_core.For, {
+			each: packageManagers,
+			doubleHardline: true,
+			children: (packageManager) => [(0, _alloy_js_core_jsx_runtime.createComponent)(require_docs.CommandDocsUsageExample, {
+				packageManager,
+				get command() {
+					return context.commands[ctx.args.command];
+				},
+				get expand() {
+					return packageManagers && packageManagers.length > 1;
+				}
+			})]
+		})]) };
+	}
+});
+/**
+* AutoMD generator to generate options for a specific command.
+*
+* @param context - The generator context.
+* @returns The generated options content.
+*/
+const options = (context) => (0, automd.defineGenerator)({
+	name: "options",
+	async generate(ctx) {
+		if (!ctx.args.command) throw new Error("The 'options' generator requires the \"command\" argument.");
+		if (!context.commands[ctx.args.command]) throw new Error(`The command "${ctx.args.command}" does not exist in the application.`);
+		return { contents: (0, _powerlines_plugin_alloy_render.renderString)(context, (0, _alloy_js_core_jsx_runtime.createComponent)(require_docs.CommandOptionsDocs, { get command() {
+			return context.commands[ctx.args.command];
+		} })) };
+	}
+});
+/**
+* AutoMD generator to generate arguments for a specific command.
+*
+* @param context - The generator context.
+* @returns The generated arguments content.
+*/
+const args = (context) => (0, automd.defineGenerator)({
+	name: "args",
+	async generate(ctx) {
+		if (!ctx.args.command) throw new Error("The 'args' generator requires the \"command\" argument.");
+		if (!context.commands[ctx.args.command]) throw new Error(`The command "${ctx.args.command}" does not exist in the application.`);
+		return { contents: (0, _powerlines_plugin_alloy_render.renderString)(context, (0, _alloy_js_core_jsx_runtime.createComponent)(require_docs.CommandArgumentDocs, { get command() {
+			return context.commands[ctx.args.command];
+		} })) };
+	}
+});
+
+//#endregion
+//#region src/helpers/paths.ts
+function resolveCommandId(context, file) {
+	return (0, _stryke_path_replace.replacePath)((0, _stryke_path_file_path_fns.findFilePath)(file), context.commandsPath).split("/").filter((p) => Boolean(p) && !require_context_helpers.isDynamicPathSegment(p)).join("/").replaceAll(/^\/+/g, "").replaceAll(/\/+$/g, "").replaceAll("/", "-");
+}
+/**
+* Finds the command name from the given file path.
+*
+* @param file - The file path to extract the command name from.
+* @returns The command name.
+*/
+function resolveCommandName(file) {
+	let path = (0, _stryke_path_file_path_fns.findFilePath)(file);
+	let name = (0, _stryke_path_file_path_fns.findFolderName)(file, { requireExtension: true });
+	while (require_context_helpers.isDynamicPathSegment(name)) {
+		path = (0, _stryke_path_resolve_parent_path.resolveParentPath)(path);
+		name = (0, _stryke_path_file_path_fns.findFolderName)(path, { requireExtension: true });
+	}
+	return name;
+}
+function resolveCommandPath(context, file) {
+	return (0, _stryke_path_replace.replacePath)((0, _stryke_path_file_path_fns.findFilePath)(file), context.commandsPath).replaceAll(/^\/+/g, "").replaceAll(/\/+$/g, "").split("/").filter((path) => path && !require_context_helpers.isPathSegmentGroup(path)).join("/");
+}
+async function findCommandsRoot(context) {
+	let paths = [];
+	if ((0, _stryke_type_checks_is_set_string.isSetString)(context.config.input)) paths = await (0, _stryke_fs_list_files.listFiles)((0, _stryke_path_append.appendPath)((0, _stryke_path_append.appendPath)(context.config.input, context.config.root), context.config.cwd));
+	else if ((0, powerlines_utils.isFileReference)(context.config.input)) paths = await (0, _stryke_fs_list_files.listFiles)((0, _stryke_path_append.appendPath)((0, _stryke_path_append.appendPath)(context.config.input.file, context.config.root), context.config.cwd));
+	else if (Array.isArray(context.config.input) && context.config.input.length > 0) paths = (await Promise.all(context.config.input.map(async (input) => (0, _stryke_fs_list_files.listFiles)((0, _stryke_path_append.appendPath)((0, _stryke_path_append.appendPath)((0, _stryke_type_checks_is_set_string.isSetString)(input) ? input : input.file, context.config.root), context.config.cwd))))).flat();
+	else if ((0, _stryke_type_checks_is_set_object.isSetObject)(context.config.input)) paths = (await Promise.all(Object.values(context.config.input).map(async (input) => Array.isArray(input) ? (await Promise.all(input.map(async (i) => (0, _stryke_fs_list_files.listFiles)((0, _stryke_path_append.appendPath)((0, _stryke_path_append.appendPath)((0, _stryke_type_checks_is_set_string.isSetString)(i) ? i : i.file, context.config.root), context.config.cwd))))).flat() : (0, _stryke_fs_list_files.listFiles)((0, _stryke_path_append.appendPath)((0, _stryke_path_append.appendPath)((0, _stryke_type_checks_is_set_string.isSetString)(input) ? input : input.file, context.config.root), context.config.cwd))))).flat();
+	if (paths.length > 0) return (0, _stryke_path_common.commonPath)(paths.map((p) => (0, _stryke_path_file_path_fns.findFilePath)(p)));
+	let commandsPath = (0, _stryke_path_join_paths.joinPaths)(context.config.root, "src/commands");
+	if (!(0, node_fs.existsSync)(commandsPath)) {
+		commandsPath = (0, _stryke_path_join_paths.joinPaths)(context.config.root, "commands");
+		if (!(0, node_fs.existsSync)(commandsPath)) {
+			commandsPath = (0, _stryke_path_join_paths.joinPaths)(context.config.root, "src");
+			if (!(0, node_fs.existsSync)(commandsPath)) commandsPath = context.config.root;
+		}
+	}
+	paths = (await Promise.all([(0, _stryke_fs_list_files.listFiles)((0, _stryke_path_join_paths.joinPaths)((0, _stryke_path_append.appendPath)(commandsPath, context.config.cwd), "**/command.ts")), (0, _stryke_fs_list_files.listFiles)((0, _stryke_path_join_paths.joinPaths)((0, _stryke_path_append.appendPath)(commandsPath, context.config.cwd), "**/command.tsx"))])).flat();
+	if (paths.length > 0) return (0, _stryke_path_common.commonPath)(paths.map((p) => (0, _stryke_path_file_path_fns.findFilePath)(p)));
+	return (0, _stryke_path_append.appendPath)(commandsPath, context.config.cwd);
+}
+
+//#endregion
+//#region src/helpers/persistence.ts
+function serialize(command) {
+	return {
+		...command,
+		parent: command.parent?.name ? command.parent.name : null,
+		children: Object.fromEntries(Object.entries(command.children || {}).map(([name, child]) => [name, serialize(child)]))
+	};
+}
+function deserialize(command, parent = null) {
+	const result = {
+		...command,
+		parent: parent ?? null,
+		children: {}
+	};
+	result.children = Object.fromEntries(Object.entries(command.children || {}).map(([name, child]) => [name, deserialize(child, result)]));
+	return result;
+}
+/**
+* Gets the file path for persisting CLI command reflections.
+*
+* @param context - The Shell Shock context.
+* @returns The file path for persisting CLI command reflections.
+*/
+function getCommandsPersistencePath(context) {
+	return (0, _stryke_path_join_paths.joinPaths)(context.dataPath, "reflections", "commands.json");
+}
+/**
+* Reads the persisted CLI command reflections from the file system and populates the context's commands.
+*
+* @param context - The Shell Shock context.
+* @throws Will throw an error if the reflections file is empty or cannot be read.
+*/
+async function readCommandsPersistence(context) {
+	const reflections = await context.fs.read(getCommandsPersistencePath(context));
+	if (!reflections || !reflections.length) throw new Error(`CLI Command reflection file ${getCommandsPersistencePath(context)} is empty`);
+	context.commands = Object.fromEntries(Object.entries(JSON.parse(reflections) ?? {}).map(([name, command]) => [name, deserialize(command)]));
+}
+/**
+* Writes the current CLI command reflections from the context to the file system for persistence.
+*
+* @param context - The Shell Shock context.
+* @returns A promise that resolves when the reflections have been successfully written to the file system.
+* @throws Will throw an error if there is an issue writing the reflections to the file system.
+*/
+async function writeCommandsPersistence(context) {
+	const filePath = getCommandsPersistencePath(context);
+	await (0, _powerlines_plugin_env_helpers.writeEnv)(context);
+	await context.fs.write(filePath, JSON.stringify(Object.fromEntries(Object.entries(context.commands).map(([name, command]) => [name, serialize(command)])), null, context.config.mode === "production" ? 0 : 2));
+}
+
+//#endregion
+//#region src/helpers/update-package-json.ts
+function formatBinaryPath(format) {
+	return `./dist/bin.${format === "cjs" || Array.isArray(format) && format.includes("cjs") ? "cjs" : "mjs"}`;
+}
+async function updatePackageJsonBinary(context) {
+	const packageJsonPath = (0, _stryke_path_join_paths.joinPaths)(context.config.cwd, context.config.root, "package.json");
+	if (!context.packageJson) {
+		const packageJson = await context.fs.read(packageJsonPath);
+		if (packageJson) context.packageJson ??= JSON.parse(packageJson);
+	}
+	if (context.packageJson) {
+		if (context.config.bin && Array.isArray(context.config.bin) && context.config.bin.length > 0) {
+			context.packageJson.bin = Object.fromEntries((0, _stryke_helpers_get_unique.getUnique)((0, _stryke_convert_to_array.toArray)(context.config.bin)).map((bin) => [bin, formatBinaryPath(context.config.output.format)]));
+			await context.fs.write(packageJsonPath, _stryke_json_storm_json.StormJSON.stringify(context.packageJson));
+		} else {
+			if (Array.isArray(context.config.output.format) && context.config.output.format.length > 1) {
+				context.packageJson.bin = { [(0, _stryke_string_format_kebab_case.kebabCase)(require_context_helpers.getAppName(context))]: formatBinaryPath((0, _stryke_convert_to_array.toArray)(context.config.output.format)[0]) };
+				context.packageJson.bin = (0, _stryke_convert_to_array.toArray)(context.config.output.format).reduce((ret, format) => {
+					ret[`${(0, _stryke_string_format_kebab_case.kebabCase)(require_context_helpers.getAppName(context))}-${format}`] = formatBinaryPath(format);
+					return ret;
+				}, context.packageJson.bin);
+			} else context.packageJson.bin = { [(0, _stryke_string_format_kebab_case.kebabCase)(require_context_helpers.getAppName(context))]: formatBinaryPath(context.config.output.format) };
+			await context.fs.write(packageJsonPath, _stryke_json_storm_json.StormJSON.stringify(context.packageJson));
+		}
+		if (!(0, _stryke_type_checks_is_set_object.isSetObject)(context.packageJson.bin)) throw new Error("Unable to determine the CLI binary name. Please specify the `bin` option in your Shell Shock configuration or ensure that the `name` field is set in your package.json.");
+		context.config.bin = context.packageJson.bin;
+	}
+}
+
+//#endregion
+//#region src/helpers/utilities.ts
+function innerFormatCommandTree(command) {
+	return {
+		name: `${command.name}${command.virtual ? " (virtual)" : ""}`,
+		children: Object.values(command.children ?? {}).map(innerFormatCommandTree)
+	};
+}
+function formatCommandTree(context) {
+	return (0, _stryke_cli_utils_tree.formatTree)({
+		name: context.config.name,
+		children: Object.values(context.commands ?? {}).map(innerFormatCommandTree)
+	});
+}
+/**
+* Retrieves the global command options based on the context configuration.
+*
+* @param context - The build context.
+* @param command - The command for which to retrieve global options.
+* @returns A record of global command options.
+*/
+function getGlobalOptions(context, command) {
+	let options;
+	if (Array.isArray(context.config.globalOptions)) options = Object.fromEntries((0, _stryke_helpers_get_unique.getUniqueBy)(context.config.globalOptions, (item) => item.name).map((option) => [option.name, option]));
+	else if ((0, _stryke_type_checks_is_function.isFunction)(context.config.globalOptions)) options = Object.fromEntries((0, _stryke_helpers_get_unique.getUniqueBy)(context.config.globalOptions(context, command), (item) => item.name).map((option) => [option.name, option]));
+	else options = {};
+	return Object.fromEntries(Object.entries(options).map(([key, value]) => [key, {
+		...value,
+		env: value.env ?? (0, _stryke_string_format_constant_case.constantCase)(key)
+	}]));
+}
+
+//#endregion
+//#region src/helpers/validations.ts
+function validateArguments(command) {
+	const failures = [];
+	let sequential = false;
+	for (const argument of command.args ?? []) if ((argument.type === "string" || argument.type === "number") && argument.variadic) {
+		if (!sequential) sequential = true;
+		else failures.push({
+			code: "SEQUENTIAL_VARIADIC_ARGUMENTS",
+			details: `Sequential variadic arguments are not allowed - since the argument preceding ${argument.name} is variadic, it must not also be variadic.`
+		});
+	} else sequential = false;
+	return failures;
+}
+function validateOptions(command) {
+	const failures = [];
+	const optionNames = /* @__PURE__ */ new Set();
+	for (const option of Object.values(command.options ?? {})) {
+		if (optionNames.has(option.name)) failures.push({
+			code: "DUPLICATE_OPTION_NAME",
+			details: `Duplicate option name "${option.name}" found in command.`
+		});
+		optionNames.add(option.name);
+		for (const alias of option.alias) {
+			if (optionNames.has(alias)) failures.push({
+				code: "DUPLICATE_OPTION_ALIAS",
+				details: `Duplicate option name "${alias}" (an alias of "${option.name}") found in command.`
+			});
+			optionNames.add(alias);
+		}
+	}
+	return failures;
+}
+function validateCommand(command) {
+	const results = [];
+	let failures = validateOptions(command);
+	if (failures.length > 0) results.push(...failures);
+	failures = validateArguments(command);
+	if (failures.length > 0) results.push(...failures);
+	return results;
+}
+
+//#endregion
+//#region src/resolver/helpers.ts
+/**
+* Resolves the description for a command option based on its reflection.
+*
+* @param name - The name of the command option.
+* @param type - The reflection kind of the command option.
+* @param required - Whether the command option is required.
+* @param variadic - Whether the command option is variadic (i.e., an array).
+* @param title - The title of the command option, if any.
+* @param defaultValue - The default value of the command option, if any.
+* @returns The resolved description for the command option.
+*/
+function resolveCommandOptionDescription(name, type, required = true, variadic = false, title, defaultValue) {
+	return `A${!required && !defaultValue ? "n optional" : ""} command-line ${type === "boolean" ? "flag" : "option"} that allows the user to ${type === "boolean" ? "set the" : variadic ? "specify custom" : "specify a custom"} ${title?.trim() || (0, _stryke_string_format_title_case.titleCase)(name)} ${type === "boolean" ? "indicator" : `${type === "number" ? "numeric" : "string"} value${variadic ? "s" : ""}`}.`;
+}
+/**
+* Resolves the description for a command argument based on its reflection.
+*
+* @param name - The name of the command argument.
+* @param type - The reflection kind of the command argument.
+* @param required - Whether the command argument is required.
+* @param variadic - Whether the command argument is variadic (i.e., an array).
+* @param title - The title of the command argument, if any.
+* @param defaultValue - The default value of the command argument, if any.
+* @returns The resolved description for the command argument.
+*/
+function resolveCommandArgumentDescription(name, type, required = true, variadic = false, title, defaultValue) {
+	return `An${!required && !defaultValue ? " optional" : ""} argument that allows the user to ${type === "boolean" ? "set the" : variadic ? "specify custom" : "specify a custom"} ${title?.trim() || (0, _stryke_string_format_title_case.titleCase)(name)} ${type === "boolean" ? "indicator" : `${type === "number" ? "numeric" : "string"} value${variadic ? "s" : ""}`}.`;
+}
+function applyOptionsDefaults(ctx) {
+	return Object.fromEntries(Object.entries(ctx.output.options).map(([key, option]) => {
+		const name = option.name || key;
+		const title = option.title || (0, _stryke_string_format_title_case.titleCase)(name);
+		return [key, {
+			...option,
+			name,
+			title,
+			description: option.description || resolveCommandOptionDescription(name, option.type, option.required, option.type !== "boolean" && option.variadic, title, option.default),
+			env: option.env || option.env === false ? option.env : ctx.input.context.config.autoAssignEnv ? (0, _stryke_string_format_constant_case.constantCase)(name) : false
+		}];
+	}));
+}
+function applyArgsDefaults(ctx) {
+	return ctx.output.args.map((arg, i) => {
+		const name = arg.name || `arg${i + 1}`;
+		const title = arg.title || (0, _stryke_string_format_title_case.titleCase)(name);
+		return {
+			...arg,
+			name,
+			title,
+			description: arg.description || resolveCommandArgumentDescription(name, arg.type, arg.required, arg.type !== "boolean" && arg.variadic, title, arg.default),
+			env: arg.name ? arg.env || arg.env === false ? arg.env : ctx.input.context.config.autoAssignEnv ? (0, _stryke_string_format_constant_case.constantCase)(name) : false : false
+		};
+	});
+}
+function applyDefaults(ctx) {
+	ctx.output.description ??= `The ${ctx.output.title.replace(/(?:c|C)ommands?$/, "").trim()} executable command-line interface.`;
+	if (ctx.input.command.segments.length && (0, _stryke_type_checks_is_set_string.isSetString)(ctx.input.context.config.docs?.commands) && /\{(?:(?:C|c)ommands?|(?:C|c)mds?)\}/.test(ctx.input.context.config.docs.commands)) ctx.output.docs ??= ctx.input.context.config.docs.commands ? ctx.input.context.config.docs.commands.replace(/\{(?:(?:C|c)ommands?|(?:C|c)mds?)\}/, ctx.input.command.segments.filter((segment) => !require_context_helpers.isDynamicPathSegment(segment)).join("/")) : void 0;
+	else if (!ctx.input.command.segments.length && (0, _stryke_type_checks_is_set_string.isSetString)(ctx.input.context.config.docs?.app)) ctx.output.docs ??= ctx.input.context.config.docs.app;
+}
+/**
+* Resolves a virtual command by applying default values to its title and description based on the command name and application title.
+*
+* @template TContext - The type of the context object.
+* @param ctx - The resolver context containing the input and output for the command resolution process.
+*/
+function resolveVirtualCommand(ctx) {
+	ctx.output.title ??= (0, _stryke_string_format_title_case.titleCase)(ctx.input.command.name);
+	ctx.output.description ??= `A collection of available ${ctx.output.title.replace(/(?:c|C)ommands?$/, "").trim() || (0, _stryke_string_format_title_case.titleCase)(ctx.input.command.name)} commands that are included in the ${require_context_helpers.getAppTitle(ctx.input.context, true)} command-line application.`;
+}
+/**
+* Merges two command parameters, giving precedence to string values in the second configuration.
+*
+* @param objA - The first command parameter object.
+* @param objB - The second command parameter object.
+* @returns The merged command parameter object.
+*/
+const mergeCommandParameter = (0, defu.createDefu)((obj, key, value) => {
+	if ((0, _stryke_type_checks_is_string.isString)(obj[key]) && (0, _stryke_type_checks_is_string.isString)(value)) {
+		if ((0, _stryke_type_checks_is_set_string.isSetString)(value)) obj[key] = value;
+		return true;
+	} else if (Array.isArray(obj[key]) && Array.isArray(value)) {
+		if (value.length > 0) obj[key] = (0, _stryke_helpers_get_unique.getUniqueBy)(obj[key].concat(value), (item) => (0, _stryke_type_checks_is_string.isString)(item) ? item : JSON.stringify(item));
+		return true;
+	}
+	return false;
+});
+
+//#endregion
+//#region src/resolver/schema.ts
+function getTypeNodeDescription(node) {
+	const docs = typescript.getJSDocCommentsAndTags(node).filter(typescript.isJSDoc);
+	for (const doc of docs) {
+		const comment = doc.comment;
+		if (!comment) continue;
+		const text = typeof comment === "string" ? comment.trim() : comment.map((part) => "text" in part ? part.text : "").join("").trim();
+		if (text) return text;
+	}
+}
+function findTypeDeclaration(sourceFile, typeName) {
+	for (const statement of sourceFile.statements) if ((typescript.isInterfaceDeclaration(statement) || typescript.isTypeAliasDeclaration(statement)) && statement.name.text === typeName) return statement;
+}
+function parseTypeNodeFromText(typeText) {
+	const statement = typescript.createSourceFile("__shell-shock-type.ts", `type __ShellShockType = ${typeText};`, typescript.ScriptTarget.Latest, true, typescript.ScriptKind.TS).statements[0];
+	if (statement && typescript.isTypeAliasDeclaration(statement)) return statement.type;
+}
+function membersToObjectSchema(members, lookupFile) {
+	const properties = {};
+	const required = [];
+	for (const member of members) {
+		if (!typescript.isPropertySignature(member) || !member.name || !member.type) continue;
+		const name = member.name.getText();
+		const schema = typeNodeToJsonSchema(member.type, lookupFile);
+		const description = getTypeNodeDescription(member);
+		properties[name] = description ? {
+			...schema,
+			description
+		} : schema;
+		if (!member.questionToken) required.push(name);
+	}
+	return {
+		type: "object",
+		properties,
+		...required.length > 0 ? { required } : {}
+	};
+}
+function typeNodeToJsonSchema(typeNode, lookupFile) {
+	if (typescript.isParenthesizedTypeNode(typeNode)) return typeNodeToJsonSchema(typeNode.type, lookupFile);
+	if (typeNode.kind === typescript.SyntaxKind.StringKeyword) return { type: "string" };
+	if (typeNode.kind === typescript.SyntaxKind.NumberKeyword || typeNode.kind === typescript.SyntaxKind.BigIntKeyword) return { type: "number" };
+	if (typeNode.kind === typescript.SyntaxKind.BooleanKeyword) return { type: "boolean" };
+	if (typescript.isLiteralTypeNode(typeNode)) {
+		const literal = typeNode.literal;
+		if (typescript.isStringLiteral(literal)) return {
+			type: "string",
+			enum: [literal.text]
+		};
+		if (typescript.isNumericLiteral(literal)) return {
+			type: "number",
+			enum: [Number(literal.text)]
+		};
+		if (literal.kind === typescript.SyntaxKind.TrueKeyword) return {
+			type: "boolean",
+			enum: [true]
+		};
+		if (literal.kind === typescript.SyntaxKind.FalseKeyword) return {
+			type: "boolean",
+			enum: [false]
+		};
+	}
+	if (typescript.isArrayTypeNode(typeNode)) return {
+		type: "array",
+		items: typeNodeToJsonSchema(typeNode.elementType, lookupFile)
+	};
+	if (typescript.isTypeOperatorNode(typeNode) && typeNode.operator === typescript.SyntaxKind.ReadonlyKeyword) return typeNodeToJsonSchema(typeNode.type, lookupFile);
+	if (typescript.isUnionTypeNode(typeNode)) {
+		const members = typeNode.types.filter((member) => member.kind !== typescript.SyntaxKind.UndefinedKeyword && member.kind !== typescript.SyntaxKind.NullKeyword);
+		if (members.length === 1 && members[0]) return typeNodeToJsonSchema(members[0], lookupFile);
+		const stringLiterals = members.map((member) => typescript.isLiteralTypeNode(member) && typescript.isStringLiteral(member.literal) ? member.literal.text : void 0);
+		if (stringLiterals.every(_stryke_type_checks_is_set_string.isSetString)) return {
+			type: "string",
+			enum: stringLiterals
+		};
+		const numberLiterals = members.map((member) => typescript.isLiteralTypeNode(member) && typescript.isNumericLiteral(member.literal) ? Number(member.literal.text) : void 0);
+		if (numberLiterals.every(isFiniteNumber)) return {
+			type: "number",
+			enum: numberLiterals
+		};
+		return { anyOf: members.map((member) => typeNodeToJsonSchema(member, lookupFile)) };
+	}
+	if (typescript.isTypeLiteralNode(typeNode)) return membersToObjectSchema(typeNode.members, lookupFile);
+	if (typescript.isTypeReferenceNode(typeNode)) {
+		const name = typeNode.typeName.getText();
+		if ((name === "Array" || name === "ReadonlyArray") && typeNode.typeArguments?.[0]) return {
+			type: "array",
+			items: typeNodeToJsonSchema(typeNode.typeArguments[0], lookupFile)
+		};
+		const declaration = findTypeDeclaration(lookupFile, name);
+		if (declaration) {
+			if (typescript.isInterfaceDeclaration(declaration)) return membersToObjectSchema(declaration.members, lookupFile);
+			return typeNodeToJsonSchema(declaration.type, lookupFile);
+		}
+	}
+	throw new Error(`Unsupported TypeScript type "${typeNode.getText()}" for command schema extraction.`);
+}
+/**
+* Generates a JSON Schema for a TypeScript type from the command source AST.
+*
+* @param filePath - Path to the TypeScript file containing the type.
+* @param typeName - Named type to extract when available.
+* @param typeText - Inline type text used when no named type exists.
+*/
+async function extractTypeSchema(filePath, typeName, typeText, sourceText) {
+	const sourceFile = typescript.createSourceFile(filePath, sourceText ?? (0, node_fs.readFileSync)(filePath, "utf8"), typescript.ScriptTarget.Latest, true, typescript.ScriptKind.TS);
+	if (typeName && /^[A-Z_][\w.]*$/i.test(typeName) && !typeName.includes(".")) {
+		const declaration = findTypeDeclaration(sourceFile, typeName);
+		if (declaration) {
+			if (typescript.isInterfaceDeclaration(declaration)) return membersToObjectSchema(declaration.members, sourceFile);
+			return typeNodeToJsonSchema(declaration.type, sourceFile);
+		}
+	}
+	const typeNode = parseTypeNodeFromText(typeText);
+	if (!typeNode) throw new Error(`Unable to parse TypeScript type "${typeText}".`);
+	return typeNodeToJsonSchema(typeNode, sourceFile);
+}
+function asRecord(value) {
+	return (0, _stryke_type_checks_is_set_object.isSetObject)(value) ? value : {};
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function toAliasList(value) {
+	if (Array.isArray(value)) return value.filter(_stryke_type_checks_is_set_string.isSetString);
+	if (!(0, _stryke_type_checks_is_set_string.isSetString)(value)) return [];
+	return value.split(/[,\s]+/).map((part) => part.trim()).filter(Boolean);
+}
+function parseTagDefault(value) {
+	if (!(0, _stryke_type_checks_is_set_string.isSetString)(value)) return;
+	const trimmed = value.trim();
+	if (!trimmed) return;
+	if (trimmed === "true") return true;
+	if (trimmed === "false") return false;
+	if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) return Number(trimmed);
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		return trimmed;
+	}
+}
+/**
+* Resolves the root schema definition when a generator returns a `$ref`.
+*/
+function dereferenceSchema(schema) {
+	const record = asRecord(schema);
+	const ref = record.$ref;
+	const definitions = asRecord(record.definitions);
+	const defs = asRecord(record.$defs);
+	if (!(0, _stryke_type_checks_is_set_string.isSetString)(ref)) return schema;
+	const key = decodeURIComponent(ref.replace(/^#\/(?:definitions|\$defs)\//, ""));
+	const resolved = definitions[key] ?? defs[key];
+	if (!(0, _stryke_type_checks_is_set_object.isSetObject)(resolved)) return schema;
+	return {
+		...resolved,
+		...Object.keys(definitions).length > 0 ? { definitions: record.definitions } : {},
+		...Object.keys(defs).length > 0 ? { $defs: record.$defs } : {}
+	};
+}
+function isObjectLikeSchema(schema) {
+	const resolved = dereferenceSchema(schema);
+	if (!(0, _power_plant_schema.isJsonSchemaObject)(resolved)) return false;
+	const record = asRecord(resolved);
+	return record.type === "object" || (0, _stryke_type_checks_is_set_object.isSetObject)(record.properties) || Array.isArray(record.allOf) || Array.isArray(record.anyOf) || Array.isArray(record.oneOf);
+}
+function inferParameterType(input) {
+	const schemaType = input.type;
+	if (Array.isArray(schemaType)) {
+		const first = schemaType.find((type) => type !== "null");
+		if (first === "integer" || first === "number") return "number";
+		if (first === "boolean") return "boolean";
+		if (first === "array") {
+			const nestedType = asRecord(input.items).type;
+			if (nestedType === "integer" || nestedType === "number") return "number";
+			if (nestedType === "boolean") return "boolean";
+			return "string";
+		}
+		return "string";
+	}
+	if (schemaType === "integer" || schemaType === "number") return "number";
+	if (schemaType === "boolean") return "boolean";
+	if (schemaType === "array") {
+		const nestedType = asRecord(input.items).type;
+		if (nestedType === "integer" || nestedType === "number") return "number";
+		if (nestedType === "boolean") return "boolean";
+		return "string";
+	}
+	if (Array.isArray(input.enum) && input.enum.length > 0) {
+		const first = input.enum.find((value) => value !== null);
+		if (isFiniteNumber(first)) return "number";
+		if (typeof first === "boolean") return "boolean";
+	}
+	if (isFiniteNumber(input.default)) return "number";
+	if (typeof input.default === "boolean") return "boolean";
+	return "string";
+}
+function inferVariadic(input) {
+	if (typeof input.variadic === "boolean") return input.variadic;
+	return input.type === "array";
+}
+function normalizeDefault(input, type, variadic) {
+	const defaultValue = input.default;
+	if (defaultValue === void 0) return;
+	if (type === "boolean") {
+		if (variadic) {
+			if (Array.isArray(defaultValue)) return defaultValue.filter((value) => typeof value === "boolean");
+			return typeof defaultValue === "boolean" ? [defaultValue] : void 0;
+		}
+		if (Array.isArray(defaultValue)) return defaultValue.find((value) => typeof value === "boolean");
+		return typeof defaultValue === "boolean" ? defaultValue : void 0;
+	}
+	if (type === "number") {
+		if (variadic) {
+			if (Array.isArray(defaultValue)) return defaultValue.map((item) => typeof item === "bigint" ? Number(item) : item).filter(isFiniteNumber);
+			const normalized = typeof defaultValue === "bigint" ? Number(defaultValue) : defaultValue;
+			return isFiniteNumber(normalized) ? [normalized] : void 0;
+		}
+		if (Array.isArray(defaultValue)) return defaultValue.map((item) => typeof item === "bigint" ? Number(item) : item).find(isFiniteNumber);
+		const normalized = typeof defaultValue === "bigint" ? Number(defaultValue) : defaultValue;
+		return isFiniteNumber(normalized) ? normalized : void 0;
+	}
+	if (variadic) {
+		if (Array.isArray(defaultValue)) return defaultValue.filter(_stryke_type_checks_is_set_string.isSetString);
+		return (0, _stryke_type_checks_is_set_string.isSetString)(defaultValue) ? [defaultValue] : void 0;
+	}
+	if (Array.isArray(defaultValue)) return defaultValue.find(_stryke_type_checks_is_set_string.isSetString);
+	return (0, _stryke_type_checks_is_set_string.isSetString)(defaultValue) ? defaultValue : void 0;
+}
+function normalizeStringChoices(input) {
+	const source = Array.isArray(input.choices) ? input.choices : input.enum;
+	if (!Array.isArray(source)) return;
+	return source.filter(_stryke_type_checks_is_set_string.isSetString);
+}
+function normalizeNumberChoices(input) {
+	const source = Array.isArray(input.choices) ? input.choices : input.enum;
+	if (!Array.isArray(source)) return;
+	return source.map((item) => typeof item === "bigint" ? Number(item) : item).filter(isFiniteNumber);
+}
+/**
+* Maps a JSON Schema fragment to a command option or argument.
+*/
+function resolveCommandParameter(schema, defaults) {
+	const input = asRecord(schema);
+	const type = inferParameterType(input);
+	const variadic = inferVariadic(input);
+	const defaultValue = normalizeDefault(input, type, variadic);
+	const required = typeof input.required === "boolean" ? input.required : defaultValue === void 0 ? defaults.fallbackRequired : false;
+	const env = (0, _stryke_type_checks_is_set_string.isSetString)(input.env) ? input.env : false;
+	const result = {
+		name: (0, _stryke_type_checks_is_set_string.isSetString)(input.name) ? input.name : "",
+		type,
+		title: (0, _stryke_type_checks_is_set_string.isSetString)(input.title) ? input.title : "",
+		description: (0, _stryke_type_checks_is_set_string.isSetString)(input.description) ? input.description : "",
+		alias: toAliasList(input.alias),
+		default: defaultValue,
+		env,
+		required,
+		variadic
+	};
+	if (type === "string") {
+		const stringChoices = normalizeStringChoices(input);
+		if (Array.isArray(stringChoices)) result.choices = stringChoices;
+		if ((0, _stryke_type_checks_is_set_string.isSetString)(input.format)) result.format = input.format;
+	}
+	if (type === "number") {
+		const numberChoices = normalizeNumberChoices(input);
+		if (Array.isArray(numberChoices)) result.choices = numberChoices;
+	}
+	if (defaults.includeBooleanOptionFields && type === "boolean" && !variadic) {
+		const optionResult = result;
+		if ((0, _stryke_type_checks_is_set_string.isSetString)(input.isNegativeOf)) optionResult.isNegativeOf = input.isNegativeOf;
+		if (typeof input.skipAddingNegative === "boolean") optionResult.skipAddingNegative = input.skipAddingNegative;
+	}
+	return result;
+}
+function applyMemberTags(property, tags) {
+	if (!tags) return property;
+	const next = { ...property };
+	if (tags.alias !== void 0) next.alias = toAliasList(tags.alias);
+	if ((0, _stryke_type_checks_is_set_string.isSetString)(tags.title)) next.title = tags.title.trim();
+	if ((0, _stryke_type_checks_is_set_string.isSetString)(tags.env)) next.env = tags.env;
+	if (next.default === void 0) {
+		const tagDefault = parseTagDefault(tags.default ?? tags.defaultValue);
+		if (tagDefault !== void 0) next.default = tagDefault;
+	}
+	return next;
+}
+function resolveArgumentFromSchema(ctx, index, parameter, schema) {
+	const existing = ctx.output.args.length > index ? ctx.output.args[index] : {};
+	const argument = resolveCommandParameter(applyMemberTags({
+		...asRecord(schema),
+		name: parameter.name,
+		description: parameter.description ?? asRecord(schema).description,
+		required: !parameter.optional,
+		variadic: parameter.rest || asRecord(schema).type === "array",
+		...parameter.defaultValue !== void 0 ? { default: parameter.defaultValue } : {},
+		...parameter.tags.alias !== void 0 ? { alias: toAliasList(parameter.tags.alias) } : {},
+		...(0, _stryke_type_checks_is_set_string.isSetString)(parameter.tags.title) ? { title: parameter.tags.title.trim() } : {},
+		...(0, _stryke_type_checks_is_set_string.isSetString)(parameter.tags.env) ? { env: parameter.tags.env } : {}
+	}, parameter.tags), {
+		fallbackRequired: !parameter.optional,
+		includeBooleanOptionFields: false
+	});
+	return mergeCommandParameter(existing, argument, { name: `arg${index}` });
+}
+/**
+* Resolves command options and arguments from a parsed TypeScript handler signature
+* using {@link extractTypeSchema}.
+*/
+async function applySignatureParameters(ctx, filePath, signature) {
+	const parameters = signature?.parameters ?? [];
+	if (parameters.length === 0) return;
+	const first = parameters[0];
+	let hasOptions = false;
+	let optionsSchema;
+	if (first && !first.rest) {
+		optionsSchema = await extractTypeSchema(filePath, first.typeName, first.typeText, ctx.sourceText);
+		hasOptions = isObjectLikeSchema(optionsSchema);
+	}
+	if (hasOptions && !ctx.module?.options && optionsSchema && first) {
+		if (!(0, _power_plant_schema.isJsonSchemaObject)(optionsSchema)) throw new TypeError(`Unsupported options type for command "${ctx.input.command.name}". Expected an object type, received ${JSON.stringify(asRecord(optionsSchema).type ?? optionsSchema)}.`);
+		for (const property of (0, _power_plant_schema.getPropertiesList)(optionsSchema)) {
+			const tagged = applyMemberTags({
+				...asRecord(property),
+				name: property.name,
+				required: property.required
+			}, signature.typeMemberTags[property.name]);
+			const existing = ctx.output.options[property.name] ?? {};
+			const option = resolveCommandParameter(tagged, {
+				fallbackRequired: false,
+				includeBooleanOptionFields: true
+			});
+			ctx.output.options[property.name] = mergeCommandParameter(existing, option);
+		}
+	}
+	if (!ctx.module?.args) {
+		const argumentParameters = hasOptions ? parameters.slice(1) : parameters;
+		ctx.output.args = await Promise.all(argumentParameters.map(async (parameter, index) => {
+			const schema = await extractTypeSchema(filePath, parameter.typeName, parameter.typeText, ctx.sourceText);
+			if (isObjectLikeSchema(schema) && asRecord(schema).type === "object" && !parameter.rest) throw new Error(`Unsupported type for positional argument "${parameter.name}" in command "${ctx.input.command.name}". Only string, number, boolean, string[], number[], or literal unions are supported, received object.`);
+			return resolveArgumentFromSchema(ctx, index, parameter, schema);
+		}));
+	}
+}
+
+//#endregion
+//#region src/resolver/signature.ts
+function getJSDocCommentText(comment) {
+	if (!comment) return;
+	if (typeof comment === "string") return comment.trim() || void 0;
+	return comment.map((part) => "text" in part ? part.text : "").join("").trim() || void 0;
+}
+function getJSDocTags(node) {
+	const tags = {};
+	for (const tag of typescript.getJSDocTags(node)) {
+		const name = tag.tagName.text;
+		const value = getJSDocCommentText(tag.comment) ?? "";
+		const existing = tags[name];
+		if (existing === void 0) tags[name] = value;
+		else if (Array.isArray(existing)) existing.push(value);
+		else tags[name] = [existing, value];
+	}
+	return tags;
+}
+function getNodeDescription(node) {
+	const docs = typescript.getJSDocCommentsAndTags(node).filter(typescript.isJSDoc);
+	for (const doc of docs) {
+		const text = getJSDocCommentText(doc.comment);
+		if (text) return text;
+	}
+}
+function parseDefaultExpression(node) {
+	if (!node) return;
+	if (typescript.isStringLiteral(node) || typescript.isNoSubstitutionTemplateLiteral(node)) return node.text;
+	if (node.kind === typescript.SyntaxKind.TrueKeyword) return true;
+	if (node.kind === typescript.SyntaxKind.FalseKeyword) return false;
+	if (typescript.isNumericLiteral(node)) return Number(node.text);
+	if (typescript.isPrefixUnaryExpression(node) && node.operator === typescript.SyntaxKind.MinusToken && typescript.isNumericLiteral(node.operand)) return -Number(node.operand.text);
+	if (typescript.isArrayLiteralExpression(node)) return node.elements.map((element) => typescript.isSpreadElement(element) ? void 0 : parseDefaultExpression(element)).filter((value) => value !== void 0);
+	if (typescript.isAsExpression(node) || typescript.isSatisfiesExpression(node)) return parseDefaultExpression(node.expression);
+	if (typescript.isParenthesizedExpression(node)) return parseDefaultExpression(node.expression);
+}
+function findFunctionByName(sourceFile, name) {
+	for (const statement of sourceFile.statements) {
+		if (typescript.isFunctionDeclaration(statement) && statement.name?.text === name) return statement;
+		if (typescript.isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) if (typescript.isIdentifier(declaration.name) && declaration.name.text === name && declaration.initializer && (typescript.isArrowFunction(declaration.initializer) || typescript.isFunctionExpression(declaration.initializer))) return declaration.initializer;
+		}
+	}
+}
+function getDefaultExportFunction(sourceFile) {
+	for (const statement of sourceFile.statements) {
+		if (typescript.isFunctionDeclaration(statement) && statement.modifiers?.some((modifier) => modifier.kind === typescript.SyntaxKind.DefaultKeyword)) return statement;
+		if (typescript.isExportAssignment(statement) && !statement.isExportEquals) {
+			if (typescript.isIdentifier(statement.expression)) return findFunctionByName(sourceFile, statement.expression.text);
+			if (typescript.isFunctionExpression(statement.expression) || typescript.isArrowFunction(statement.expression)) return statement.expression;
+		}
+	}
+}
+function getParamName(parameter) {
+	if (typescript.isIdentifier(parameter.name)) return parameter.name.text;
+	return parameter.name.getText();
+}
+function collectTypeMemberTags(sourceFile, typeName) {
+	const result = {};
+	for (const statement of sourceFile.statements) {
+		if (typescript.isInterfaceDeclaration(statement) && statement.name.text === typeName) {
+			for (const member of statement.members) if (typescript.isPropertySignature(member) && member.name && typescript.isIdentifier(member.name)) result[member.name.text] = getJSDocTags(member);
+		}
+		if (typescript.isTypeAliasDeclaration(statement) && statement.name.text === typeName && typescript.isTypeLiteralNode(statement.type)) {
+			for (const member of statement.type.members) if (typescript.isPropertySignature(member) && member.name && typescript.isIdentifier(member.name)) result[member.name.text] = getJSDocTags(member);
+		}
+	}
+	return result;
+}
+function getParamDescriptions(functionNode) {
+	const descriptions = {};
+	for (const tag of typescript.getJSDocTags(functionNode)) if (tag.tagName.text === "param" && typescript.isJSDocParameterTag(tag) && tag.name && typescript.isIdentifier(tag.name)) {
+		const text = getJSDocCommentText(tag.comment);
+		if (text) descriptions[tag.name.text] = text;
+	}
+	return descriptions;
+}
+/**
+* Parses the default-export command handler signature from a TypeScript source file.
+*
+* @param filePath - Absolute or relative path to the command entry file.
+* @returns The parsed command signature, or `undefined` when no default export function is found.
+*/
+async function parseCommandSignature(filePath, sourceText) {
+	const sourceFile = typescript.createSourceFile(filePath, sourceText ?? await (0, node_fs_promises.readFile)(filePath, "utf8"), typescript.ScriptTarget.Latest, true, typescript.ScriptKind.TS);
+	const functionNode = getDefaultExportFunction(sourceFile);
+	if (!functionNode) return;
+	const paramDescriptions = getParamDescriptions(functionNode);
+	const parameters = functionNode.parameters.map((parameter) => {
+		const name = getParamName(parameter);
+		const typeNode = parameter.type;
+		const typeName = typeNode && typescript.isTypeReferenceNode(typeNode) ? typeNode.typeName.getText(sourceFile) : void 0;
+		const tags = getJSDocTags(parameter);
+		const description = getNodeDescription(parameter) || paramDescriptions[name] || ((0, _stryke_type_checks_is_set_string.isSetString)(tags.description) ? tags.description : void 0);
+		return {
+			name,
+			optional: Boolean(parameter.questionToken ?? parameter.initializer),
+			rest: Boolean(parameter.dotDotDotToken),
+			typeText: typeNode?.getText(sourceFile) ?? "unknown",
+			typeName,
+			description,
+			defaultValue: parseDefaultExpression(parameter.initializer),
+			tags
+		};
+	});
+	const firstNamedType = parameters.find((parameter) => parameter.typeName)?.typeName;
+	return {
+		description: getNodeDescription(functionNode),
+		parameters,
+		typeMemberTags: firstNamedType ? collectTypeMemberTags(sourceFile, firstNamedType) : {}
+	};
+}
+
+//#endregion
+//#region src/resolver/resolve.ts
+function toExtractableSchema(input) {
+	if ((0, _stryke_type_checks_is_set_object.isSetObject)(input) && "_zod" in input) return zod.z.toJSONSchema(input);
+	return input;
+}
+const CONSOLE_STUB_EXPORTS = [
+	"banner",
+	"blockquote",
+	"bold",
+	"code",
+	"cyan",
+	"debug",
+	"dim",
+	"divider",
+	"error",
+	"fatal",
+	"gray",
+	"green",
+	"help",
+	"info",
+	"inlineCode",
+	"italic",
+	"link",
+	"log",
+	"red",
+	"reset",
+	"shine",
+	"spinner",
+	"stripAnsi",
+	"success",
+	"table",
+	"trace",
+	"underline",
+	"warn",
+	"wrapAnsi",
+	"write",
+	"writeLine",
+	"yellow"
+];
+function stubExport(...args) {
+	return args[0] == null ? "" : args[0];
+}
+function createColorGroup() {
+	return {
+		primary: stubExport,
+		secondary: stubExport,
+		tertiary: stubExport
+	};
+}
+function createVirtualModuleStub(exportNames = CONSOLE_STUB_EXPORTS) {
+	const stub = { textColors: {
+		heading: createColorGroup(),
+		body: createColorGroup(),
+		message: createColorGroup()
+	} };
+	for (const name of exportNames) stub[name] = stubExport;
+	stub.default = stub;
+	return stub;
+}
+function resolveBuiltinAliases(context) {
+	const builtinsDir = context.entryPath ? (0, node_path.join)((0, node_path.dirname)(context.entryPath), "builtins") : (0, node_path.join)(context.config.cwd, ".shell-shock", "builtins");
+	if (!(0, node_fs.existsSync)(builtinsDir)) return {};
+	const aliases = {};
+	for (const file of (0, node_fs.readdirSync)(builtinsDir)) {
+		if (!/\.(c|m)?tsx?$/.test(file)) continue;
+		const name = file.replace(/\.(c|m)?tsx?$/, "");
+		const absolutePath = (0, node_path.join)(builtinsDir, file);
+		aliases[name] = absolutePath;
+		aliases[`shell-shock:${name}`] = absolutePath;
+	}
+	return aliases;
+}
+function collectVirtualModules(source) {
+	const consoleStub = createVirtualModuleStub();
+	const modules = /* @__PURE__ */ new Map([
+		["console", consoleStub],
+		["shell-shock:console", consoleStub],
+		["shell-shock:utils", createVirtualModuleStub()],
+		["shell-shock:env", createVirtualModuleStub([
+			"env",
+			"isDevelopment",
+			"isDebug"
+		])],
+		["shell-shock:state", createVirtualModuleStub(["hasFlag"])]
+	]);
+	for (const match of source.matchAll(/["'](shell-shock:[^"']+)["']/g)) {
+		const id = match[1];
+		if (id && !modules.has(id)) modules.set(id, createVirtualModuleStub());
+	}
+	for (const match of source.matchAll(/import\s+\{([^}]+)\}\s+from\s+["']((?:shell-shock:)?[^"']+)["']/g)) {
+		const id = match[2];
+		if (!id || !id.startsWith("shell-shock:") && id !== "console") continue;
+		const stub = modules.get(id) ?? createVirtualModuleStub();
+		for (const specifier of match[1]?.split(",") ?? []) {
+			const exportName = specifier.trim().split(/\s+as\s+/)[0]?.trim();
+			if (exportName && !(exportName in stub)) stub[exportName] = stubExport;
+		}
+		modules.set(id, stub);
+	}
+	return Object.fromEntries(modules);
+}
+async function preprocess(input) {
+	const { context, command, parent } = input;
+	const title = command.title || `${parent?.title ? `${parent.virtual ? parent.title.replace(/(?:c|C)ommands?$/, "").trim() : parent.title} - ` : ""}${(0, _stryke_string_format_title_case.titleCase)(command.name)}${command.virtual ? " Commands" : ""}`;
+	const result = {
+		input,
+		output: {
+			alias: [],
+			icon: parent?.icon,
+			tags: parent?.tags ?? [],
+			...command,
+			title,
+			options: parent === null ? getGlobalOptions(context, command) : {},
+			args: [],
+			parent: parent ?? null,
+			children: {}
+		}
+	};
+	if (!command.virtual) {
+		if (!command.entry.input?.file || !context.fs.existsSync(command.entry.input.file)) throw new Error(`${!command.entry.input?.file ? "Missing" : "Non-existent"} command entry file for "${command.name}"`);
+		context.debug(`Resolving CLI command schema: ${command.id} (file: ${(0, _stryke_path_replace.replacePath)(command.entry.input.file, context.config.cwd)})`);
+		const rawSource = await context.fs.read(command.entry.input.file);
+		const sourceText = typeof rawSource === "string" ? rawSource : Buffer.from(rawSource).toString("utf8");
+		result.sourceText = sourceText;
+		let loaded;
+		try {
+			loaded = await (0, jiti.createJiti)(require("url").pathToFileURL(__filename).href, {
+				jsx: true,
+				interopDefault: false,
+				alias: resolveBuiltinAliases(context),
+				virtualModules: collectVirtualModules(sourceText)
+			}).evalModule(sourceText, { filename: command.entry.input.file });
+		} catch (error) {
+			context.debug(`Command module evaluation failed for "${command.id}", falling back to signature extraction: ${error instanceof Error ? error.message : String(error)}`);
+			loaded = { default: () => void 0 };
+		}
+		result.module = (0, _stryke_type_checks_is_function.isFunction)(loaded) ? { default: loaded } : loaded;
+		if (!result.module) throw new Error(`Failed to resolve command module at path "${command.entry.input.file}". Please ensure the file exists and is a valid module.`);
+		if ((0, _stryke_type_checks_is_function.isFunction)(result.module)) result.module = { default: result.module };
+		result.signature = await parseCommandSignature(command.entry.input.file, sourceText);
+	}
+	if (!command.virtual) {
+		if (!result.module?.default) throw new Error(`The command entry file "${input.command.entry.input?.file || input.command.path}" does not include a handler function as its default export - this is required for command resolution and execution.`);
+		if (!(0, _stryke_type_checks_is_function.isFunction)(result.module.default)) throw new Error(`The command entry file "${input.command.entry.input?.file || input.command.path}" does not have a valid function as its default export - this is required for command resolution and execution.`);
+	}
+	return result;
+}
+async function postprocess(ctx) {
+	ctx.output.options = applyOptionsDefaults(ctx);
+	ctx.output.args = applyArgsDefaults(ctx);
+	ctx.output.args.forEach((arg, index) => {
+		const found = ctx.output.args.findIndex((a) => a.name === arg.name);
+		if (found !== -1 && found !== index || ctx.output.segments.some((segment) => require_context_helpers.isDynamicPathSegment(segment) && require_context_helpers.getDynamicPathSegmentName(segment) === arg.name)) {
+			arg.name += `_${ctx.output.segments.filter((segment) => require_context_helpers.isDynamicPathSegment(segment) && require_context_helpers.getDynamicPathSegmentName(segment).replace(/_\d+$/, "") === arg.name).length + ctx.output.args.filter((a) => a.name.replace(/_\d+$/, "") === arg.name).length}`;
+			arg.env = arg.name ? arg.env || arg.env === false ? arg.env : ctx.input.context.config.autoAssignEnv ? (0, _stryke_string_format_constant_case.constantCase)(arg.name) : false : false;
+		}
+	});
+	applyDefaults(ctx);
+	if (ctx.input.context.env) {
+		if ((0, _stryke_type_checks_is_set_object.isSetObject)(ctx.output.options)) Object.values(ctx.output.options).filter((option) => Boolean(option.env)).forEach((option) => {
+			(0, _power_plant_schema.addProperty)(ctx.input.context.env.config.schema, option.env, {
+				...option,
+				name: option.env,
+				alias: option.alias.filter((alias) => alias.length > 1).map((alias) => (0, _stryke_string_format_constant_case.constantCase)(alias))
+			});
+		});
+		ctx.output.args.filter((arg) => Boolean(arg.env)).forEach((arg) => (0, _power_plant_schema.addProperty)(ctx.input.context.env.config.schema, arg.env, {
+			...arg,
+			name: arg.env,
+			alias: arg.alias.filter((alias) => alias.length > 1).map((alias) => (0, _stryke_string_format_constant_case.constantCase)(alias))
+		}));
+	}
+	await Promise.all(ctx.input.context.inputs.filter((input) => input.segments.filter((segment) => !require_context_helpers.isDynamicPathSegment(segment)).length === ctx.input.command.segments.filter((segment) => !require_context_helpers.isDynamicPathSegment(segment)).length + 1 && input.segments.slice(0, ctx.input.command.segments.length).every((value, index) => value === ctx.input.command.segments[index])).map(async (input) => {
+		ctx.output.children[input.name] = await resolve({
+			context: ctx.input.context,
+			command: input,
+			parent: ctx.output
+		});
+	}));
+	return ctx.output;
+}
+/**
+* Resolves a command tree from the given resolver input.
+*
+* @param input - The resolver input containing the context, command, and optional parent command tree.
+* @returns A promise that resolves to the resolved command tree.
+*/
+async function resolve(input) {
+	const ctx = await preprocess(input);
+	if (!ctx.output.virtual) {
+		if (!ctx.module) throw new Error(`Command module at path "${ctx.input.command.path}" is undefined or null. Please ensure the module exports a valid command.`);
+		else if (!(0, _stryke_type_checks_is_set_object.isSetObject)(ctx.module)) throw new TypeError(`Command module at path "${ctx.input.command.path}" is not an object. Please ensure the module exports a valid command.`);
+		else if (!("default" in ctx.module)) throw new Error(`Command module at path "${ctx.input.command.path}" does not appear to be valid. Please ensure the module's default export is a valid command handler function.`);
+		const metadata = ctx.module.metadata ?? {};
+		if ((0, _stryke_type_checks_is_set_string.isSetString)(metadata.title)) ctx.output.title = metadata.title;
+		if ((0, _stryke_type_checks_is_set_string.isSetString)(metadata.description)) ctx.output.description = metadata.description;
+		if ((0, _stryke_type_checks_is_set_string.isSetString)(metadata.alias) || Array.isArray(metadata.alias) && metadata.alias.length > 0) ctx.output.alias = (0, _stryke_convert_to_array.toArray)(metadata.alias);
+		if ((0, _stryke_type_checks_is_set_string.isSetString)(metadata.icon)) ctx.output.icon = metadata.icon;
+		if ((0, _stryke_type_checks_is_set_string.isSetString)(metadata.tags)) ctx.output.tags = (0, _stryke_helpers_get_unique.getUnique)(ctx.output.tags.concat((0, _stryke_convert_to_array.toArray)(metadata.tags)));
+		ctx.output.description ??= ctx.input.command.description || ctx.signature?.description;
+		if (ctx.module.options) {
+			const options = await (0, _power_plant_schema.extract)(toExtractableSchema(ctx.module.options), { cwd: ctx.input.context.config.cwd });
+			if (!(0, _stryke_type_checks_is_set_object.isSetObject)(options) || !(0, _stryke_json.isJsonSchemaObjectType)(options.schema)) throw new TypeError(`Command options for command at path "${ctx.input.command.path}" must resolve to an object.`);
+			ctx.output.options = (0, _power_plant_schema.getPropertiesList)(options).reduce((ret, property) => {
+				ret[property.name] = resolveCommandParameter(property, {
+					fallbackRequired: false,
+					includeBooleanOptionFields: true
+				});
+				return ret;
+			}, {});
+		}
+		if (ctx.module.args) {
+			const args = await (0, _power_plant_schema.extract)(toExtractableSchema(ctx.module.args), { cwd: ctx.input.context.config.cwd });
+			if ((0, _stryke_type_checks_is_set_object.isSetObject)(args)) {
+				if (!(0, _stryke_json.isJsonSchemaTupleType)(args.schema) && !(0, _power_plant_schema.isJsonSchemaArray)(args.schema)) throw new TypeError(`Command arguments for command at path "${ctx.input.command.path}" must resolve to a tuple${args?.schema?.type ? `, instead received ${JSON.stringify(args.schema.type)}` : ""}.`);
+				if (Array.isArray(args.schema.items)) ctx.output.args = args.schema.items.map((item) => resolveCommandParameter(item, {
+					fallbackRequired: true,
+					includeBooleanOptionFields: false
+				}));
+			}
+		}
+		if (ctx.signature && ctx.input.command.entry.input?.file && (!ctx.module.options || !ctx.module.args)) await applySignatureParameters(ctx, ctx.input.command.entry.input.file, ctx.signature);
+	} else resolveVirtualCommand(ctx);
+	return postprocess(ctx);
+}
+
+//#endregion
+//#region src/plugin.tsx
+const MAX_DEPTH = 50;
+/**
+* The core Powerlines plugin to build Shell Shock projects.
+*/
+const plugin = (options$1 = {}) => {
+	return [
+		(0, _powerlines_plugin_tsdown.plugin)(),
+		(0, _powerlines_plugin_automd.plugin)(),
+		{
+			name: "shell-shock/core:config",
+			async config() {
+				this.debug("Resolving the Shell Shock configuration.");
+				return (0, defu.defu)(options$1, {
+					name: require_context_helpers.getAppName(this),
+					title: require_context_helpers.getAppTitle(this),
+					description: require_context_helpers.getAppDescription(this),
+					platform: "node",
+					projectType: "application",
+					framework: require_get_framework.getFramework(),
+					isCaseSensitive: false,
+					output: {
+						format: "esm",
+						dts: false
+					},
+					input: !this.config.input || Array.isArray(this.config.input) && this.config.input.length === 0 || (0, _stryke_type_checks_is_object.isObject)(this.config.input) && Object.keys(this.config.input).length === 0 ? ["src/**/command.ts", "src/**/command.tsx"] : void 0,
+					resolve: {
+						external: ["@power-plant/schema"],
+						skipNodeModulesBundle: true
+					},
+					tsdown: {
+						dts: false,
+						nodeProtocol: true,
+						unbundle: false
+					}
+				});
+			},
+			configResolved: {
+				order: "pre",
+				async handler() {
+					this.debug("Shell Shock configuration has been resolved.");
+					const envConfigReference = (0, _stryke_type_checks_is_set_string.isSetString)(this.config.env.config) ? (0, _stryke_convert_extract_file_reference.extractFileReference)(this.config.env.config) : void 0;
+					if (envConfigReference) {
+						const envConfigFile = await this.fs.resolve(envConfigReference.file);
+						if (envConfigFile) this.config.env.config = {
+							...envConfigReference,
+							file: envConfigFile
+						};
+					}
+					await updatePackageJsonBinary(this);
+					this.config.appSpecificEnvPrefix = (0, _stryke_type_checks_is_set_string.isSetString)(this.config.autoAssignEnv) ? this.config.autoAssignEnv : (0, _stryke_string_format_constant_case.constantCase)(require_context_helpers.getAppName(this));
+					if (!this.config.env.prefix || !Array.isArray(this.config.env.prefix)) this.config.env.prefix = (0, _stryke_convert_to_array.toArray)(this.config.env.prefix);
+					if (!this.config.env.prefix.includes(this.config.appSpecificEnvPrefix)) this.config.env.prefix.push(this.config.appSpecificEnvPrefix);
+					this.config.bin = ((0, _stryke_type_checks_is_set_string.isSetString)(this.packageJson.bin) ? { [(0, _stryke_string_format_kebab_case.kebabCase)(this.config.name)]: this.packageJson.bin } : this.packageJson.bin) ?? { [(0, _stryke_string_format_kebab_case.kebabCase)(this.config.name)]: formatBinaryPath(this.config.output.format) };
+					if ((0, _stryke_type_checks_is_set_string.isSetString)(this.config.docs)) {
+						const docsWithoutCommandPath = this.config.docs.replace(/\/?\{(?:command|cmd)\}.*$/, "");
+						this.config.docs = {
+							commands: this.config.docs,
+							app: this.config.docs.endsWith("/") ? docsWithoutCommandPath.endsWith("/") ? docsWithoutCommandPath : `${docsWithoutCommandPath}/` : docsWithoutCommandPath
+						};
+					}
+					this.inputs ??= [];
+					this.globalOptions = Object.values(getGlobalOptions(this, {
+						id: null,
+						name: this.config.name,
+						path: null,
+						segments: [],
+						title: this.config.title,
+						description: this.config.description,
+						alias: [],
+						virtual: false
+					})).map((option) => ({
+						...option,
+						name: (0, _stryke_string_format_camel_case.camelCase)(option.name),
+						alias: option.alias ?? [],
+						required: option.required ?? true
+					}));
+				}
+			}
+		},
+		...(0, _powerlines_plugin_nodejs.plugin)((0, defu.defu)(options$1 ?? {}, { env: {
+			config: "@shell-shock/core/schemas/env#envSchema",
+			validate: false
+		} })),
+		{
+			name: "shell-shock/core:inputs",
+			async configResolved() {
+				const toInputLocation = (value) => {
+					if ((0, _stryke_type_checks_is_set_string.isSetString)(value)) return value;
+					if ((0, _stryke_type_checks_is_set_object.isSetObject)(value) && (0, powerlines.isFileReference)(value)) return String(value.file);
+					return null;
+				};
+				const configuredInputs = [];
+				if (Array.isArray(this.config.input)) configuredInputs.push(...this.config.input.map(toInputLocation).filter((value) => (0, _stryke_type_checks_is_set_string.isSetString)(value)));
+				else if ((0, _stryke_type_checks_is_set_string.isSetString)(this.config.input)) configuredInputs.push(this.config.input);
+				else if ((0, _stryke_type_checks_is_set_object.isSetObject)(this.config.input) && (0, powerlines.isFileReference)(this.config.input)) configuredInputs.push(String(this.config.input.file));
+				else if ((0, _stryke_type_checks_is_set_object.isSetObject)(this.config.input)) configuredInputs.push(...Object.values(this.config.input).map(toInputLocation).filter((value) => (0, _stryke_type_checks_is_set_string.isSetString)(value)));
+				this.debug(configuredInputs.length <= 1 ? `Checking for command modules in the following location: ${configuredInputs[0] ?? "(none configured)"}.` : `Checking for command modules in the following locations:\n${configuredInputs.map((input) => ` - ${input}`).join("\n")}`);
+				this.commandsPath = await findCommandsRoot(this);
+				this.debug(`Resolved commands root path: ${this.commandsPath}`);
+				const inputs = await (0, powerlines_utils.resolveInputs)(this, this.config.input);
+				this.debug(`Found ${inputs.length} entry points specified in the configuration options.`);
+				this.inputs = inputs.reduce((ret, entry) => {
+					if (entry.file !== this.commandsPath && !(0, _stryke_path_is_parent_path.isParentPath)(entry.file, this.commandsPath)) throw new Error(`Command entry point "${entry.file}" is not located within the commands root "${this.commandsPath}". Please ensure that all command entry points are located within the current project.`);
+					const id = resolveCommandId(this, entry.file);
+					if (!ret.some((existing) => existing.id === id)) {
+						const name = resolveCommandName(entry.file);
+						let segments = resolveCommandPath(this, entry.file).split("/").filter(Boolean);
+						segments = segments.map((segment, index) => {
+							const found = segments.findIndex((existing) => existing === segment);
+							if (found !== -1 && found !== index) segment += `_${segments.filter((segment) => require_context_helpers.isDynamicPathSegment(segment) && require_context_helpers.getDynamicPathSegmentName(segment).replace(/_\d+$/, "") === segment).length}`;
+							return segment;
+						});
+						ret.push({
+							id,
+							path: segments.join("/"),
+							segments,
+							name,
+							alias: [],
+							tags: [],
+							virtual: false,
+							entry: {
+								...entry,
+								input: {
+									file: entry.file,
+									export: entry.export
+								},
+								output: name
+							}
+						});
+					}
+					return ret;
+				}, this.inputs);
+				this.debug(`Shell Shock will process ${this.inputs.length} command entry files: \n${this.inputs.map((command) => ` - ${command.id}: ${(0, _stryke_path_replace.replacePath)(command.entry.file, this.commandsPath)}`).join("\n")}`);
+			},
+			async prepare() {
+				this.debug("Rendering base built-in modules for the Shell Shock application via Power Plant.");
+				return require_helpers_power_plant.executeCommandGenerator(this, require_generator.coreBuiltinsGenerator);
+			}
+		},
+		{
+			name: "shell-shock/core:virtual-inputs",
+			configResolved: {
+				order: "post",
+				async handler() {
+					if (this.inputs.length === 0) this.warn("No commands were found in the project. Please ensure at least one command exists.");
+					else {
+						this.debug("Finding and adding virtual command inputs for each command previously found.");
+						this.inputs = this.inputs.reduce((ret, command) => {
+							let depth = 0;
+							let parentPath = (0, _stryke_path_resolve_parent_path.resolveParentPath)((0, _stryke_path_find.findFilePath)(command.entry.file));
+							if ((0, _stryke_path_is_parent_path.isParentPath)(parentPath, this.commandsPath)) while (parentPath !== this.commandsPath) {
+								if (depth++ > MAX_DEPTH) throw new Error(`Unable to process virtual commands for ${command.name} \n\nPlease ensure ${command.entry.file} is a valid command entry file and does not have an invalid path.`);
+								if (!ret.some((existing) => (0, _stryke_path_find.findFilePath)(existing.entry.file) === parentPath)) {
+									const file = (0, _stryke_path_join_paths.joinPaths)(parentPath, "command.ts");
+									const id = resolveCommandId(this, file);
+									if (!ret.some((existing) => existing.id === id)) {
+										const name = resolveCommandName(file);
+										let segments = resolveCommandPath(this, file).split("/").filter(Boolean);
+										segments = segments.map((segment, index) => {
+											const found = segments.findIndex((existing) => existing === segment);
+											if (found !== -1 && found !== index) segment += `_${segments.filter((segment) => require_context_helpers.isDynamicPathSegment(segment) && require_context_helpers.getDynamicPathSegmentName(segment).replace(/_\d+$/, "") === segment).length}`;
+											return segment;
+										});
+										ret.push({
+											id,
+											path: segments.join("/"),
+											segments,
+											name,
+											alias: [],
+											tags: [],
+											virtual: true,
+											entry: { file }
+										});
+									}
+								}
+								parentPath = (0, _stryke_path_resolve_parent_path.resolveParentPath)(parentPath);
+							}
+							return ret;
+						}, this.inputs).sort((a, b) => a.segments.length - b.segments.length);
+						this.debug(`Final command input list: \n${this.inputs.map((command) => ` - ${command.id}${command.virtual ? " (virtual)" : ""}`).join("\n")}`);
+					}
+				}
+			}
+		},
+		{
+			name: "shell-shock/core:update-env",
+			configResolved: {
+				order: "post",
+				async handler() {
+					this.debug("Adding global options to the CLI application's environment variables.");
+					if (!this.env.config) {
+						this.debug("Environment variable schema not found in plugin context. Extracting environment variable schema from type definitions provided in plugin options.");
+						await (0, _powerlines_plugin_env_helpers_schema.extractEnv)(this);
+						if (!this.env.config) throw new Error("Failed to extract environment variable schema from type definitions provided in plugin options. Please ensure the `env.types` option is correctly specified and points to a valid TypeScript type definition file.");
+					}
+					if (!(0, _power_plant_schema.isJsonSchemaObject)(this.env.config.schema)) throw new Error("Invalid environment variable schema extracted.");
+					const env = (0, _power_plant_schema.getProperties)(this.env.config);
+					this.globalOptions.filter((option) => (0, _stryke_type_checks_is_set_string.isSetString)(option.env) && !env[option.env]).forEach((option) => {
+						(0, _power_plant_schema.addProperty)(this.env.config, option.env, {
+							...option,
+							name: option.env,
+							alias: option.alias.filter((alias) => alias.length > 1).map((alias) => (0, _stryke_string_format_constant_case.constantCase)(alias))
+						});
+					});
+					await (0, _powerlines_plugin_env_helpers_schema.writeEnv)(this);
+				}
+			}
+		},
+		{
+			name: "shell-shock/core:resolve-commands",
+			prepare: {
+				order: "post",
+				async handler() {
+					this.debug("Initializing the CLI application's command tree.");
+					this.commands = {};
+					if (this.config.command !== "prepare" && this.config.skipCache !== true && this.persistedMeta?.checksum === this.meta.checksum) {
+						this.debug(`Skipping command resolution as the meta checksum has not changed.`);
+						await (0, _powerlines_plugin_env_helpers_schema.extractEnv)(this);
+						await readCommandsPersistence(this);
+					} else {
+						for (const input of this.inputs.filter((input) => input.segments.filter((segment) => !require_context_helpers.isDynamicPathSegment(segment) && !require_context_helpers.isPathSegmentGroup(segment)).length === 1)) this.commands[input.name] = await resolve({
+							context: this,
+							command: input
+						});
+						this.debug("Post-processing commands to ensure proper reflection.");
+						await require_plugin_utils_index.traverseCommands(this, (command) => {
+							command.options = Object.fromEntries(Object.entries(command.options).map(([name, option]) => [(0, _stryke_string_format_camel_case.camelCase)(name), {
+								...option,
+								name: (0, _stryke_string_format_camel_case.camelCase)(name),
+								alias: option.alias ?? [],
+								required: option.required ?? true
+							}]));
+						});
+						await writeCommandsPersistence(this);
+					}
+					this.debug("Validating the CLI applications command tree.");
+					let isValid = true;
+					await require_plugin_utils_index.traverseCommands(this, (command) => {
+						const failures = validateCommand(command);
+						if (failures.length > 0) {
+							this.error(`Found ${failures.length} issue${failures.length > 1 ? "s" : ""} with the ${command.title} command: \n${failures.map((failure) => ` - ${failure.code}: ${failure.details}`).join("\n")}\n`);
+							isValid = false;
+						}
+					});
+					if (!isValid) throw new Error(`One or more commands in the command tree are invalid. Please review the errors above and correct them before proceeding.`);
+					this.info(`\nCreating an application with the following command tree: \n${formatCommandTree(this)}\n`);
+				}
+			}
+		},
+		{
+			name: "shell-shock/core:chmod+x",
+			configResolved() {
+				this.config.tsdown.hooks ??= {};
+				this.config.tsdown.hooks["build:done"] = async (_) => {
+					await Promise.all(Object.values(this.config.bin ?? {}).map(async (bin) => {
+						const path = (0, _stryke_path_append.appendPath)(bin ?? "", (0, _stryke_path_join_paths.joinPaths)(this.config.cwd, this.config.root));
+						if (this.fs.existsSync(path)) {
+							this.debug(`Adding hashbang to binary executable output file: ${path}`);
+							const content = await this.fs.read(path);
+							if (content && !content.startsWith("#!")) await this.fs.write(path, `#!/usr/bin/env ${this.config.mode === "development" ? "-S NODE_OPTIONS=--enable-source-maps" : ""} node\n\n${content}`);
+							this.debug(`Adding executable permissions (chmod+x) to binary executable output file: ${path}`);
+							await (0, _stryke_fs_chmod_x.chmodX)(path);
+						} else this.warn(`Expected binary output file not found at path: ${path}. Skipping adding hashbang and executable permissions (chmod+x).`);
+					}));
+				};
+			}
+		},
+		{
+			name: "shell-shock/core:docs",
+			configResolved() {
+				this.config.automd ??= {};
+				this.config.automd.generators = {
+					...this.config.automd.generators ?? {},
+					commands: commands(this),
+					usage: usage(this),
+					options: options(this),
+					args: args(this)
+				};
+			},
+			async docs() {
+				this.debug("Rendering CLI command reference documentation via Power Plant.");
+				const commands = this.inputs.map((input) => require_plugin_utils_index.getCommandTree(this, input.segments)).filter(Boolean);
+				return require_helpers_power_plant.executeCommandGenerator(this, require_generator.coreDocsGenerator, { template: (0, _alloy_js_core_jsx_runtime.createComponent)(_alloy_js_core.For, {
+					get each() {
+						return Object.values(commands);
+					},
+					doubleHardline: true,
+					children: (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_docs.CommandDocsFile, { command: child });
+						}
+					})
+				}) });
+			}
+		}
+	];
+};
+
+//#endregion
+Object.defineProperty(exports, 'plugin', {
+  enumerable: true,
+  get: function () {
+    return plugin;
+  }
+});