@shell-shock/core 0.17.21 → 0.17.23

package/dist/plugin.mjs

@@ -1,492 +1,3 @@
-import { getAppDescription, getAppName, getAppTitle, getDynamicPathSegmentName, isDynamicPathSegment, isPathSegmentGroup } from "./plugin-utils/context-helpers.mjs";
-import { CommandDocsFile } from "./components/docs.mjs";
-import { ExecBuiltin } from "./components/exec-builtin.mjs";
-import { traverseCommands } from "./plugin-utils/traverse-command-tree.mjs";
-import { getCommandTree } from "./plugin-utils/get-command-tree.mjs";
-import { StateBuiltin } from "./components/state-builtin.mjs";
-import { UtilsBuiltin } from "./components/utils-builtin.mjs";
-import { args, commands, options, usage } from "./helpers/automd.mjs";
-import { getFramework } from "./helpers/get-framework.mjs";
-import { findCommandsRoot, resolveCommandId, resolveCommandName, resolveCommandPath } from "./helpers/paths.mjs";
-import { readCommandsPersistence, writeCommandsPersistence } from "./helpers/persistence.mjs";
-import { formatBinaryPath, updatePackageJsonBinary } from "./helpers/update-package-json.mjs";
-import { formatCommandTree, getGlobalOptions } from "./helpers/utilities.mjs";
-import { validateCommand } from "./helpers/validations.mjs";
-import { resolve } from "./resolver/resolve.mjs";
-import { createComponent } from "@alloy-js/core/jsx-runtime";
-import { For, Show } from "@alloy-js/core";
-import { render } from "@powerlines/plugin-alloy/render";
-import automd from "@powerlines/plugin-automd";
-import { extractEnv, writeEnv } from "@powerlines/plugin-env/helpers/schema";
-import nodejs from "@powerlines/plugin-nodejs";
-import tsdown from "@powerlines/plugin-tsdown";
-import { addProperty, getCacheFilePath, getProperties, isJsonSchemaObject } from "@powerlines/schema";
-import { toArray } from "@stryke/convert/to-array";
-import { chmodX } from "@stryke/fs/chmod-x";
-import { appendPath } from "@stryke/path/append";
-import { findFilePath } from "@stryke/path/find";
-import { isParentPath } from "@stryke/path/is-parent-path";
-import { joinPaths } from "@stryke/path/join-paths";
-import { replacePath } from "@stryke/path/replace";
-import { resolveParentPath } from "@stryke/path/resolve-parent-path";
-import { camelCase } from "@stryke/string-format/camel-case";
-import { constantCase } from "@stryke/string-format/constant-case";
-import { kebabCase } from "@stryke/string-format/kebab-case";
-import { isObject } from "@stryke/type-checks/is-object";
-import { isSetObject } from "@stryke/type-checks/is-set-object";
-import { isSetString } from "@stryke/type-checks/is-set-string";
-import { defu } from "defu";
-import { isFileReference } from "powerlines";
-import { resolveInputs } from "powerlines/utils";
+import { t as plugin } from "./plugin-B-hM2twc.mjs";
 
-//#region src/plugin.tsx
-function __assignType(fn, args) {
-	fn.__type = args;
-	return fn;
-}
-const MAX_DEPTH = 50;
-/**
-* The core Powerlines plugin to build Shell Shock projects.
-*/
-const plugin = __assignType((options$1 = {}) => {
-	return [
-		(tsdown.Ω = [["Context", "\"w!"]], tsdown()),
-		(automd.Ω = [["Context", "\"w!"]], automd()),
-		{
-			name: "shell-shock/core:config",
-			config: __assignType(async function config() {
-				this.debug("Resolving the Shell Shock configuration.");
-				return defu(options$1, {
-					name: getAppName(this),
-					title: getAppTitle(this),
-					description: getAppDescription(this),
-					platform: "node",
-					projectType: "application",
-					framework: getFramework(),
-					isCaseSensitive: false,
-					output: {
-						format: "esm",
-						dts: false
-					},
-					input: !this.config.input || Array.isArray(this.config.input) && this.config.input.length === 0 || isObject(this.config.input) && Object.keys(this.config.input).length === 0 ? ["src/**/command.ts", "src/**/command.tsx"] : void 0,
-					resolve: {
-						external: ["@powerlines/deepkit"],
-						skipNodeModulesBundle: true
-					},
-					tsdown: {
-						dts: false,
-						nodeProtocol: true,
-						unbundle: false
-					}
-				});
-			}, ["config", "P\"/!"]),
-			configResolved: {
-				order: "pre",
-				async handler() {
-					this.debug("Shell Shock configuration has been resolved.");
-					await updatePackageJsonBinary(this);
-					this.config.appSpecificEnvPrefix = isSetString(this.config.autoAssignEnv) ? this.config.autoAssignEnv : constantCase(getAppName(this));
-					if (!this.config.env.prefix || !Array.isArray(this.config.env.prefix)) this.config.env.prefix = 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 = (isSetString(this.packageJson.bin) ? { [kebabCase(this.config.name)]: this.packageJson.bin } : this.packageJson.bin) ?? { [kebabCase(this.config.name)]: formatBinaryPath(this.config.output.format) };
-					if (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(__assignType((option) => ({
-						...option,
-						name: camelCase(option.name),
-						alias: option.alias ?? [],
-						required: option.required ?? true
-					}), [
-						"option",
-						"",
-						"P\"2!\"/\""
-					]));
-				}
-			}
-		},
-		...(nodejs.Ω = [["Context", "\"w!"]], nodejs(defu(options$1 ?? {}, { env: {
-			config: "@shell-shock/core/types/env#ShellShockEnv",
-			validate: false
-		} }))),
-		{
-			name: "shell-shock/core:inputs",
-			async configResolved() {
-				const toInputLocation = __assignType((value) => {
-					if (isSetString(value)) return value;
-					if (isSetObject(value) && isFileReference(value)) return String(value.file);
-					return null;
-				}, [
-					"value",
-					"",
-					"P#2!P&,J/\""
-				]);
-				const configuredInputs = [];
-				if (Array.isArray(this.config.input)) configuredInputs.push(...this.config.input.map(toInputLocation).filter(__assignType((value) => isSetString(value), [
-					"value",
-					"",
-					"P\"2!!/\""
-				])));
-				else if (isSetString(this.config.input)) configuredInputs.push(this.config.input);
-				else if (isSetObject(this.config.input) && isFileReference(this.config.input)) configuredInputs.push(String(this.config.input.file));
-				else if (isSetObject(this.config.input)) configuredInputs.push(...Object.values(this.config.input).map(toInputLocation).filter(__assignType((value) => isSetString(value), [
-					"value",
-					"",
-					"P\"2!!/\""
-				])));
-				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(__assignType((input) => ` - ${input}`, [
-					"input",
-					"",
-					"P\"2!\"/\""
-				])).join("\n")}`);
-				this.commandsPath = await findCommandsRoot(this);
-				this.debug(`Resolved commands root path: ${this.commandsPath}`);
-				const inputs = await resolveInputs(this, this.config.input);
-				this.debug(`Found ${inputs.length} entry points specified in the configuration options.`);
-				this.inputs = inputs.reduce(__assignType((ret, entry) => {
-					if (entry.file !== this.commandsPath && !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(__assignType((existing) => existing.id === id, [
-						"existing",
-						"",
-						"P\"2!\"/\""
-					]))) {
-						const name = resolveCommandName(entry.file);
-						let segments = resolveCommandPath(this, entry.file).split("/").filter(Boolean);
-						segments = segments.map(__assignType((segment, index) => {
-							const found = segments.findIndex(__assignType((existing) => existing === segment, [
-								"existing",
-								"",
-								"P\"2!\"/\""
-							]));
-							if (found !== -1 && found !== index) segment += `_${segments.filter(__assignType((segment) => isDynamicPathSegment(segment) && getDynamicPathSegmentName(segment).replace(/_\d+$/, "") === segment, [
-								"segment",
-								"",
-								"P\"2!\"/\""
-							])).length}`;
-							return segment;
-						}, [
-							"segment",
-							"index",
-							"",
-							"P\"2!\"2\"\"/#"
-						]));
-						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;
-				}, [
-					"ret",
-					"entry",
-					"",
-					"P\"2!\"2\"\"/#"
-				]), this.inputs);
-				this.debug(`Shell Shock will process ${this.inputs.length} command entry files: \n${this.inputs.map(__assignType((command) => ` - ${command.id}: ${replacePath(command.entry.file, this.commandsPath)}`, [
-					"command",
-					"",
-					"P\"2!\"/\""
-				])).join("\n")}`);
-			},
-			prepare: __assignType(async function prepare() {
-				this.debug("Rendering base built-in modules for the Shell Shock application.");
-				return render(this, [
-					createComponent(StateBuiltin, {}),
-					createComponent(UtilsBuiltin, {}),
-					createComponent(ExecBuiltin, {})
-				]);
-			}, ["prepare", "P\"/!"])
-		},
-		{
-			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(__assignType((ret, command) => {
-							let depth = 0;
-							let parentPath = resolveParentPath(findFilePath(command.entry.file));
-							if (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(__assignType((existing) => findFilePath(existing.entry.file) === parentPath, [
-									"existing",
-									"",
-									"P\"2!\"/\""
-								]))) {
-									const file = joinPaths(parentPath, "command.ts");
-									const id = resolveCommandId(this, file);
-									if (!ret.some(__assignType((existing) => existing.id === id, [
-										"existing",
-										"",
-										"P\"2!\"/\""
-									]))) {
-										const name = resolveCommandName(file);
-										let segments = resolveCommandPath(this, file).split("/").filter(Boolean);
-										segments = segments.map(__assignType((segment, index) => {
-											const found = segments.findIndex(__assignType((existing) => existing === segment, [
-												"existing",
-												"",
-												"P\"2!\"/\""
-											]));
-											if (found !== -1 && found !== index) segment += `_${segments.filter(__assignType((segment) => isDynamicPathSegment(segment) && getDynamicPathSegmentName(segment).replace(/_\d+$/, "") === segment, [
-												"segment",
-												"",
-												"P\"2!\"/\""
-											])).length}`;
-											return segment;
-										}, [
-											"segment",
-											"index",
-											"",
-											"P\"2!\"2\"\"/#"
-										]));
-										ret.push({
-											id,
-											path: segments.join("/"),
-											segments,
-											name,
-											alias: [],
-											tags: [],
-											virtual: true,
-											entry: { file }
-										});
-									}
-								}
-								parentPath = resolveParentPath(parentPath);
-							}
-							return ret;
-						}, [
-							"ret",
-							"command",
-							"",
-							"P\"2!\"2\"\"/#"
-						]), this.inputs).sort(__assignType((a, b) => a.segments.length - b.segments.length, [
-							"a",
-							"b",
-							"",
-							"P\"2!\"2\"\"/#"
-						]));
-						this.debug(`Final command input list: \n${this.inputs.map(__assignType((command) => ` - ${command.id}${command.virtual ? " (virtual)" : ""}`, [
-							"command",
-							"",
-							"P\"2!\"/\""
-						])).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 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 (!isJsonSchemaObject(this.env.config.schema)) throw new Error("Invalid environment variable schema extracted.");
-					const env = getProperties(this.env.config);
-					this.globalOptions.filter(__assignType((option) => isSetString(option.env) && !env[option.env], [
-						"option",
-						"",
-						"P\"2!\"/\""
-					])).forEach(__assignType((option) => {
-						addProperty(this.env.config, option.env, {
-							...option,
-							name: option.env,
-							alias: option.alias.filter(__assignType((alias) => alias.length > 1, [
-								"alias",
-								"",
-								"P\"2!\"/\""
-							])).map(__assignType((alias) => constantCase(alias), [
-								"alias",
-								"",
-								"P\"2!\"/\""
-							]))
-						});
-					}, [
-						"option",
-						"",
-						"P\"2!\"/\""
-					]));
-					await 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.fs.existsSync(getCacheFilePath(this, this.env.config))) {
-						this.debug(`Skipping command resolution as the meta checksum has not changed.`);
-						await extractEnv(this);
-						await readCommandsPersistence(this);
-					} else {
-						for (const input of this.inputs.filter(__assignType((input) => input.segments.filter(__assignType((segment) => !isDynamicPathSegment(segment) && !isPathSegmentGroup(segment), [
-							"segment",
-							"",
-							"P\"2!\"/\""
-						])).length === 1, [
-							"input",
-							"",
-							"P\"2!\"/\""
-						]))) this.commands[input.name] = await resolve({
-							context: this,
-							command: input
-						});
-						this.debug("Post-processing commands to ensure proper reflection.");
-						await traverseCommands(this, __assignType((command) => {
-							command.options = Object.fromEntries(Object.entries(command.options).map(__assignType(([name, option]) => [camelCase(name), {
-								...option,
-								name: camelCase(name),
-								alias: option.alias ?? [],
-								required: option.required ?? true
-							}], [
-								"param0",
-								"",
-								"P\"2!\"/\""
-							])));
-						}, [
-							"command",
-							"",
-							"P\"2!\"/\""
-						]));
-						await writeCommandsPersistence(this);
-					}
-					this.debug("Validating the CLI applications command tree.");
-					let isValid = true;
-					await traverseCommands(this, __assignType((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(__assignType((failure) => ` - ${failure.code}: ${failure.details}`, [
-								"failure",
-								"",
-								"P\"2!\"/\""
-							])).join("\n")}\n`);
-							isValid = false;
-						}
-					}, [
-						"command",
-						"",
-						"P\"2!\"/\""
-					]));
-					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"] = __assignType(async (_) => {
-					await Promise.all(Object.values(this.config.bin).map(__assignType(async (bin) => {
-						const path = appendPath(bin, 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 chmodX(path);
-						} else this.warn(`Expected binary output file not found at path: ${path}. Skipping adding hashbang and executable permissions (chmod+x).`);
-					}, [
-						"bin",
-						"",
-						"P\"2!\"/\""
-					])));
-				}, [
-					"chunks",
-					"_",
-					"",
-					"PP!P!F4!MK2\"\"/#"
-				]);
-			}
-		},
-		{
-			name: "shell-shock/core:docs",
-			configResolved: __assignType(function configResolved() {
-				this.config.automd ??= {};
-				this.config.automd.generators = {
-					...this.config.automd.generators ?? {},
-					commands: commands(this),
-					usage: usage(this),
-					options: options(this),
-					args: args(this)
-				};
-			}, ["configResolved", "P\"/!"]),
-			async docs() {
-				this.debug("Rendering CLI command reference documentation and writing to the output directory.");
-				const commands = this.inputs.map(__assignType((input) => getCommandTree(this, input.segments), [
-					"input",
-					"",
-					"P\"2!\"/\""
-				])).filter(Boolean);
-				return render(this, createComponent(For, {
-					get each() {
-						return Object.values(commands);
-					},
-					doubleHardline: true,
-					get children() {
-						return __assignType((child) => createComponent(Show, {
-							get when() {
-								return !child.virtual;
-							},
-							get children() {
-								return createComponent(CommandDocsFile, { command: child });
-							}
-						}), [
-							"child",
-							"",
-							"P\"2!\"/\""
-						]);
-					}
-				}));
-			}
-		}
-	];
-}, [
-	"Options",
-	"options",
-	() => ({}),
-	"",
-	"P\"w!2\">#!F/$"
-]);
-
-//#endregion
-export { plugin as default, plugin };
-//# sourceMappingURL=plugin.mjs.map
+export { plugin as default, plugin };

package/dist/power-plant-LgxcvlMN.d.cts

@@ -0,0 +1,4 @@
+import { usePowerlines, usePowerlinesSafe } from "@powerlines/plugin-alloy/core/contexts/context";
+import { BuiltinFile, BuiltinFileProps } from "@powerlines/plugin-alloy/typescript/components/builtin-file";
+import { EntryFile, EntryFileProps } from "@powerlines/plugin-alloy/typescript/components/entry-file";
+export { usePowerlines as a, EntryFileProps as i, BuiltinFileProps as n, usePowerlinesSafe as o, EntryFile as r, BuiltinFile as t };

package/dist/power-plant-LgxcvlMN.d.mts

@@ -0,0 +1,4 @@
+import { usePowerlines, usePowerlinesSafe } from "@powerlines/plugin-alloy/core/contexts/context";
+import { BuiltinFile, BuiltinFileProps } from "@powerlines/plugin-alloy/typescript/components/builtin-file";
+import { EntryFile, EntryFileProps } from "@powerlines/plugin-alloy/typescript/components/entry-file";
+export { usePowerlines as a, EntryFileProps as i, BuiltinFileProps as n, usePowerlinesSafe as o, EntryFile as r, BuiltinFile as t };

package/dist/reflect-CSiffeL9.cjs

@@ -0,0 +1,27 @@
+//#region src/plugin-utils/reflect.ts
+/**
+* Sort command options alphabetically by name, placing boolean options with negatives appropriately.
+*
+* @param options - The array of command options to sort.
+* @param skipNegatives - Whether to skip negative options when sorting (default: true).
+* @returns A new array of sorted command options.
+*/
+function sortOptions(options, skipNegatives = true) {
+	if (!options || options.length === 0) return [];
+	return options.filter((arg) => arg.type !== "boolean" || arg.variadic || !skipNegatives || !arg.isNegativeOf).sort((a, b) => a.name.localeCompare(b.name)).reduce((ret, arg) => {
+		ret.push(arg);
+		if (arg.type === "boolean") {
+			const negativeArg = options.find((a) => a.type === "boolean" && !a.variadic && a.isNegativeOf === arg.name);
+			if (negativeArg) ret.push(negativeArg);
+		}
+		return ret;
+	}, []);
+}
+
+//#endregion
+Object.defineProperty(exports, 'sortOptions', {
+  enumerable: true,
+  get: function () {
+    return sortOptions;
+  }
+});

package/dist/reflect-DXKSFgvS.mjs

@@ -0,0 +1,23 @@
+//#region src/plugin-utils/reflect.ts
+/**
+* Sort command options alphabetically by name, placing boolean options with negatives appropriately.
+*
+* @param options - The array of command options to sort.
+* @param skipNegatives - Whether to skip negative options when sorting (default: true).
+* @returns A new array of sorted command options.
+*/
+function sortOptions(options, skipNegatives = true) {
+	if (!options || options.length === 0) return [];
+	return options.filter((arg) => arg.type !== "boolean" || arg.variadic || !skipNegatives || !arg.isNegativeOf).sort((a, b) => a.name.localeCompare(b.name)).reduce((ret, arg) => {
+		ret.push(arg);
+		if (arg.type === "boolean") {
+			const negativeArg = options.find((a) => a.type === "boolean" && !a.variadic && a.isNegativeOf === arg.name);
+			if (negativeArg) ret.push(negativeArg);
+		}
+		return ret;
+	}, []);
+}
+
+//#endregion
+export { sortOptions as t };
+//# sourceMappingURL=reflect-DXKSFgvS.mjs.map

package/dist/reflect-DXKSFgvS.mjs.map

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

package/dist/schemas/env.cjs

@@ -0,0 +1,91 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let zod = require("zod");
+let _powerlines_plugin_env_schemas_env = require("@powerlines/plugin-env/schemas/env");
+
+//#region src/schemas/env.ts
+/**
+* Zod schema for the Shell Shock environment configuration.
+*
+* @remarks
+* Extends the base Powerlines {@link envSchema} with CLI-specific runtime
+* environment variables used for executable resolution and npm script detection.
+*/
+const envSchema = _powerlines_plugin_env_schemas_env.envSchema.extend({
+	/**
+	* The system PATHEXT variable, used to determine which file extensions are considered executable on Windows.
+	*
+	* @remarks
+	* If not provided, it will default to '.EXE;.CMD;.BAT;.COM' on Windows, and will be ignored on other platforms. This variable is used to locate executable files when running commands, and is only relevant on Windows platforms. On non-Windows platforms, the system's executable file resolution will be used, and this variable will have no effect.
+	*/
+	PATHEXT: zod.z.string().optional().meta({
+		description: "The system PATHEXT variable, used to determine which file extensions are considered executable on Windows. If not provided, it will default to '.EXE;.CMD;.BAT;.COM' on Windows, and will be ignored on other platforms.",
+		runtime: true,
+		hidden: true,
+		category: "node"
+	}),
+	/**
+	* The system PATH variable, used to locate executable files.
+	*/
+	PATH: zod.z.string().optional().meta({
+		description: "The system PATH variable, used to locate executable files.",
+		runtime: true,
+		hidden: true,
+		category: "node"
+	}),
+	/**
+	* The npm user agent string, which can be used to detect if the environment is running within an npm script.
+	*
+	* @remarks
+	* This variable is set by npm when running scripts defined in package.json. It can be used to conditionally adjust behavior when running within an npm script context, such as modifying logging output or adjusting command execution. If this variable is not set, it can be assumed that the environment is not running within an npm script.
+	*/
+	npm_config_user_agent: zod.z.string().optional().meta({
+		description: "The npm user agent string, which can be used to detect if the environment is running within an npm script. This variable is set by npm when running scripts defined in package.json.",
+		runtime: true,
+		hidden: true,
+		category: "node"
+	}),
+	/**
+	* The npm_config_fund environment variable, which can be used to control npm's funding behavior.
+	*
+	* @remarks
+	* This variable is set by npm when running scripts defined in package.json, and can be used to control npm's funding behavior. If set to 'false', it will disable npm's funding messages. If not set, npm will use its default funding behavior. This variable is only relevant when running within an npm script context, and has no effect on command execution or behavior outside of that context.
+	*/
+	npm_config_fund: zod.z.string().optional().meta({
+		description: "The npm_config_fund environment variable, which can be used to control npm's funding behavior. If set to 'false', it will disable npm's funding messages.",
+		runtime: true,
+		hidden: true,
+		category: "node"
+	}),
+	/**
+	* The npm execution path, which can be used to determine the location of the npm executable.
+	*
+	* @remarks
+	* This variable is set by npm when running scripts defined in package.json. It provides the absolute path to the npm executable being used to run the script. This can be useful for resolving the location of npm or for debugging purposes. If this variable is not set, it may indicate that the environment is not running within an npm script context, or that npm is not available in the PATH.
+	*/
+	npm_execpath: zod.z.string().optional().meta({
+		description: "The npm execution path, which can be used to determine the location of the npm executable. This variable is set by npm when running scripts defined in package.json.",
+		runtime: true,
+		hidden: true,
+		category: "node"
+	}),
+	/**
+	* The COMSPEC environment variable, which specifies the command-line interpreter to use on Windows.
+	*
+	* @remarks
+	* This variable is used on Windows platforms to determine which command-line interpreter to use when executing commands. It typically points to cmd.exe, but can be customized by the user. If this variable is not set on Windows, it will default to 'cmd.exe'. On non-Windows platforms, this variable is ignored and has no effect on command execution.
+	*/
+	COMSPEC: zod.z.string().optional().meta({
+		description: "The COMSPEC environment variable, which specifies the command-line interpreter to use on Windows. It typically points to cmd.exe, but can be customized by the user.",
+		runtime: true,
+		hidden: true,
+		category: "node"
+	})
+});
+/**
+* Inferred Shell Shock environment configuration type from {@link ShellShockEnv}.
+*/
+/**
+* Input type for {@link ShellShockEnv} before defaults applied.
+*/
+//#endregion
+exports.envSchema = envSchema;