@e-n-v/env 0.0.1

package/dist/src-oetJm-nZ.cjs

@@ -0,0 +1,4098 @@
+//#region rolldown:runtime
+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 __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+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 ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let fs = require("fs");
+fs = __toESM(fs);
+let zod = require("zod");
+zod = __toESM(zod);
+let zod_v4_core = require("zod/v4/core");
+zod_v4_core = __toESM(zod_v4_core);
+let node_process = require("node:process");
+node_process = __toESM(node_process);
+let __clack_core = require("@clack/core");
+__clack_core = __toESM(__clack_core);
+let node_url = require("node:url");
+node_url = __toESM(node_url);
+let picocolors = require("picocolors");
+picocolors = __toESM(picocolors);
+let node_readline = require("node:readline");
+node_readline = __toESM(node_readline);
+
+//#region ../files/src/utils.ts
+function normalizeContent(content) {
+	return content.replace(/\r\n/g, "\n");
+}
+function splitLines(content) {
+	return content === "" ? [] : content.split("\n");
+}
+function validateKey(key) {
+	const trimmed = key.trim();
+	if (!trimmed) throw new TypeError("Environment variable name cannot be empty");
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed)) throw new TypeError(`Invalid environment variable name: ${trimmed}`);
+	return trimmed;
+}
+function parseAssignmentEndingAt(lines, endIndex) {
+	const lastLine = lines[endIndex];
+	if (typeof lastLine !== "string" || isSkippableLine(lastLine)) return null;
+	const block = [];
+	let start = endIndex;
+	while (start >= 0) {
+		const currentLine = lines[start];
+		if (typeof currentLine !== "string") break;
+		block.unshift(currentLine);
+		if (containsAssignmentOperator(currentLine)) {
+			const parsed = tryParseAssignmentBlock(block);
+			if (!parsed) return null;
+			return {
+				...parsed,
+				startIndex: start,
+				endIndex
+			};
+		}
+		start -= 1;
+	}
+	return null;
+}
+function isSkippableLine(line) {
+	const trimmed = line.trim();
+	return trimmed.length === 0 || trimmed.startsWith("#");
+}
+function containsAssignmentOperator(line) {
+	const trimmed = line.trimStart();
+	if (trimmed.length === 0 || trimmed.startsWith("#")) return false;
+	const commentIndex = trimmed.indexOf("#");
+	return (commentIndex === -1 ? trimmed : trimmed.slice(0, commentIndex)).includes("=");
+}
+function tryParseAssignmentBlock(blockLines) {
+	if (blockLines.length === 0) return null;
+	const firstLine = blockLines[0];
+	const leadingMatch = firstLine.match(/^\s*/);
+	const leading = leadingMatch ? leadingMatch[0] : "";
+	let remainder = firstLine.slice(leading.length);
+	if (remainder.length === 0 || remainder.startsWith("#")) return null;
+	let exportPrefix = "";
+	if (remainder.startsWith("export")) {
+		const afterExport = remainder.slice(6);
+		if (/^\s/.test(afterExport)) {
+			const spacingMatch = afterExport.match(/^\s+/);
+			const spacing = spacingMatch ? spacingMatch[0] : " ";
+			exportPrefix = `export${spacing}`;
+			remainder = afterExport.slice(spacing.length);
+		}
+	}
+	const equalsIndex = remainder.indexOf("=");
+	if (equalsIndex === -1) return null;
+	const key = validateKey(remainder.slice(0, equalsIndex).trim());
+	const parsedValue = parseValueSource([remainder.slice(equalsIndex + 1).replace(/^\s+/, ""), ...blockLines.slice(1)].join("\n"));
+	if (!parsedValue) return null;
+	const trailingTrimmed = parsedValue.trailing.trim();
+	if (trailingTrimmed.length > 0 && !trailingTrimmed.startsWith("#")) return null;
+	return {
+		key,
+		value: parsedValue.value,
+		leading,
+		exportPrefix,
+		trailing: parsedValue.trailing,
+		lines: [...blockLines]
+	};
+}
+function parseValueSource(source) {
+	if (source.length === 0) return {
+		value: "",
+		trailing: ""
+	};
+	const firstChar = source[0];
+	if (firstChar === "\"") return parseDoubleQuotedValue(source);
+	if (firstChar === "'") return parseSingleQuotedValue(source);
+	if (source.includes("\n")) return null;
+	const commentIndex = source.indexOf(" #");
+	const raw = commentIndex === -1 ? source : source.slice(0, commentIndex);
+	const trailing = commentIndex === -1 ? source.slice(raw.length) : source.slice(commentIndex);
+	return {
+		value: raw.trim(),
+		trailing
+	};
+}
+function parseDoubleQuotedValue(source) {
+	let value = "";
+	let escaping = false;
+	for (let i = 1; i < source.length; i += 1) {
+		const char = source[i] ?? "";
+		if (escaping) {
+			switch (char) {
+				case "n":
+					value += "\n";
+					break;
+				case "r":
+					value += "\r";
+					break;
+				case "t":
+					value += "	";
+					break;
+				case "\"":
+					value += "\"";
+					break;
+				case "\\":
+					value += "\\";
+					break;
+				default:
+					value += char;
+					break;
+			}
+			escaping = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaping = true;
+			continue;
+		}
+		if (char === "\"") {
+			const trailing = source.slice(i + 1);
+			return {
+				value,
+				trailing
+			};
+		}
+		if (char === "\n") {
+			value += "\n";
+			continue;
+		}
+		value += char;
+	}
+	return null;
+}
+function parseSingleQuotedValue(source) {
+	let value = "";
+	for (let i = 1; i < source.length; i += 1) {
+		const char = source[i] ?? "";
+		if (char === "'") {
+			const trailing = source.slice(i + 1);
+			return {
+				value,
+				trailing
+			};
+		}
+		if (char === "\n") {
+			value += "\n";
+			continue;
+		}
+		value += char;
+	}
+	return null;
+}
+
+//#endregion
+//#region ../files/src/get.ts
+function get(content, arg) {
+	const lines = splitLines(normalizeContent(content));
+	if (typeof arg === "undefined") {
+		const map = scanAll(lines);
+		return Object.fromEntries(map);
+	}
+	if (typeof arg === "string") return scanForSingle(lines, arg);
+	const normalizedTargets = Array.from(new Set(arg.map((name) => validateKey(name))));
+	const lookup = scanForMany(lines, new Set(normalizedTargets));
+	const ordered = normalizedTargets.map((key) => [key, lookup.get(key)]);
+	return Object.fromEntries(ordered);
+}
+function scanAll(lines) {
+	const result = /* @__PURE__ */ new Map();
+	iterateAssignments(lines, (assignment) => {
+		if (!result.has(assignment.key)) result.set(assignment.key, assignment.value);
+	});
+	return result;
+}
+function scanForSingle(lines, target) {
+	const name = validateKey(target);
+	let found;
+	iterateAssignments(lines, (assignment) => {
+		if (assignment.key === name) {
+			found = assignment.value;
+			return true;
+		}
+	});
+	return found;
+}
+function scanForMany(lines, targets) {
+	const normalizedTargets = /* @__PURE__ */ new Set();
+	for (const target of targets) normalizedTargets.add(validateKey(target));
+	const found = /* @__PURE__ */ new Map();
+	const remaining = new Set(normalizedTargets);
+	iterateAssignments(lines, (assignment) => {
+		if (!remaining.has(assignment.key) || found.has(assignment.key)) return;
+		found.set(assignment.key, assignment.value);
+		remaining.delete(assignment.key);
+		if (remaining.size === 0) return true;
+	});
+	return found;
+}
+function iterateAssignments(lines, callback) {
+	for (let i = lines.length - 1; i >= 0;) {
+		const parsed = parseAssignmentEndingAt(lines, i);
+		if (!parsed) {
+			i -= 1;
+			continue;
+		}
+		if (callback(parsed) === true) return;
+		i = parsed.startIndex - 1;
+	}
+}
+
+//#endregion
+//#region ../files/src/set.ts
+function set(content, arg, value) {
+	const normalized = normalizeContent(content);
+	const lines = splitLines(normalized);
+	const entries = normalizeWriteArguments(arg, value);
+	if (entries.length === 0) return ensureTrailingNewline(normalized);
+	const replacements = new Map(entries);
+	const touched = /* @__PURE__ */ new Set();
+	for (let i = lines.length - 1; i >= 0;) {
+		if (replacements.size === 0) break;
+		const parsed = parseAssignmentEndingAt(lines, i);
+		if (!parsed) {
+			i -= 1;
+			continue;
+		}
+		const { key, startIndex, endIndex, leading, exportPrefix, trailing, value: currentValue } = parsed;
+		const nextValue = replacements.get(key);
+		if (typeof nextValue === "undefined" || touched.has(key)) {
+			i = startIndex - 1;
+			continue;
+		}
+		if (nextValue === currentValue) {
+			touched.add(key);
+			replacements.delete(key);
+			i = startIndex - 1;
+			continue;
+		}
+		const block = buildAssignmentLines(key, nextValue, {
+			leading,
+			exportPrefix,
+			trailing
+		});
+		lines.splice(startIndex, endIndex - startIndex + 1, ...block);
+		touched.add(key);
+		replacements.delete(key);
+		i = startIndex - 1;
+	}
+	for (const [key, val] of entries) {
+		if (touched.has(key)) continue;
+		const block = buildAssignmentLines(key, val);
+		const insertIndex = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+		lines.splice(insertIndex, 0, ...block);
+		touched.add(key);
+	}
+	return ensureTrailingNewline(lines.join("\n"));
+}
+function ensureTrailingNewline(content) {
+	if (content.length === 0) return "";
+	if (!content.endsWith("\n")) return `${content}\n`;
+	return content;
+}
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeWriteArguments(arg, value) {
+	if (typeof arg === "string") {
+		if (typeof value === "undefined") throw new TypeError(`Value for variable "${arg}" must be provided`);
+		return [[validateKey(arg), formatValueInput(value)]];
+	}
+	if (!isObjectRecord(arg)) throw new TypeError("Argument must be a string name or an object of key-value pairs");
+	const entries = [];
+	for (const [key, rawValue] of Object.entries(arg)) {
+		if (typeof rawValue === "undefined") throw new TypeError(`Value for variable "${key}" must be provided`);
+		entries.push([validateKey(key), formatValueInput(rawValue)]);
+	}
+	return entries;
+}
+function formatValueInput(value) {
+	if (typeof value === "bigint") return value.toString();
+	return String(value);
+}
+function serializeValue(value) {
+	const normalized = value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+	if (!(normalized.length === 0 || /[\s"'\\#]/.test(normalized) || normalized.includes("\n"))) return normalized;
+	let result = "\"";
+	for (const char of normalized) {
+		if (char === "\"") {
+			result += "\\\"";
+			continue;
+		}
+		if (char === "\\") {
+			result += "\\\\";
+			continue;
+		}
+		if (char === "\n") {
+			result += "\n";
+			continue;
+		}
+		result += char;
+	}
+	result += "\"";
+	return result;
+}
+function buildAssignmentLines(key, value, style = {}) {
+	const leading = style.leading ?? "";
+	const exportPrefix = style.exportPrefix ?? "";
+	const trailing = style.trailing ?? "";
+	const segments = serializeValue(value).split("\n");
+	return segments.map((segment, index) => {
+		if (index === 0) return `${leading}${exportPrefix}${key}=${segment}${segments.length === 1 ? trailing : ""}`;
+		if (index === segments.length - 1 && trailing && segments.length > 1) return `${segment}${trailing}`;
+		return segment;
+	});
+}
+
+//#endregion
+//#region ../files/src/EnvSource.ts
+var EnvSource = class {
+	filePath;
+	constructor(filePath) {
+		this.filePath = (0, node_path.resolve)(process.cwd(), filePath);
+	}
+	readSync(arg) {
+		const content = this.readContentSync();
+		if (typeof arg === "undefined") return get(content);
+		if (typeof arg === "string") return get(content, arg);
+		return get(content, arg);
+	}
+	async read(arg) {
+		const content = await this.readContent();
+		if (typeof arg === "undefined") return get(content);
+		if (typeof arg === "string") return get(content, arg);
+		return get(content, arg);
+	}
+	writeSync(arg, value) {
+		const originalContent = this.readContentSync();
+		let nextContent;
+		if (typeof arg === "string") nextContent = set(originalContent, arg, value);
+		else nextContent = set(originalContent, arg);
+		if (nextContent === originalContent) return;
+		this.ensureDirectorySync();
+		(0, node_fs.writeFileSync)(this.filePath, nextContent, "utf8");
+	}
+	async write(arg, value) {
+		const originalContent = await this.readContent();
+		let nextContent;
+		if (typeof arg === "string") nextContent = set(originalContent, arg, value);
+		else nextContent = set(originalContent, arg);
+		if (nextContent === originalContent) return;
+		await this.ensureDirectory();
+		await node_fs.promises.writeFile(this.filePath, nextContent, "utf8");
+	}
+	readContentSync() {
+		try {
+			return (0, node_fs.readFileSync)(this.filePath, "utf8").replace(/\r\n/g, "\n");
+		} catch (error) {
+			if (error.code === "ENOENT") return "";
+			throw error;
+		}
+	}
+	async readContent() {
+		try {
+			return (await node_fs.promises.readFile(this.filePath, "utf8")).replace(/\r\n/g, "\n");
+		} catch (error) {
+			if (error.code === "ENOENT") return "";
+			throw error;
+		}
+	}
+	ensureDirectorySync() {
+		try {
+			(0, node_fs.mkdirSync)((0, node_path.dirname)(this.filePath), { recursive: true });
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+	async ensureDirectory() {
+		try {
+			await node_fs.promises.mkdir((0, node_path.dirname)(this.filePath), { recursive: true });
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+};
+
+//#endregion
+//#region ../channels/src/channels/default/DefaultEnvChannel.ts
+/**
+* Default implementation of EnvChannel that works with .env files using envrw
+*/
+var DefaultEnvChannel = class {
+	envSource;
+	/**
+	* Create a new DefaultEnvChannel
+	* @param filePath - Path to the .env file to manage
+	*/
+	constructor(filePath) {
+		this.envSource = new EnvSource(filePath);
+	}
+	/**
+	* Get all environment variables
+	* @returns Promise that resolves to object containing all environment variable key-value pairs
+	*/
+	async get() {
+		return await this.envSource.read();
+	}
+	/**
+	* Set multiple environment variables
+	* @param values - Object containing key-value pairs to set
+	* @returns Promise that resolves when the values have been set
+	*/
+	async set(values) {
+		await this.envSource.write(values);
+	}
+};
+
+//#endregion
+//#region ../channels/src/channels/dotenv/DotEnvChannel.ts
+function isFileNotFound(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function normalizeParsed(parsed) {
+	if (!parsed) return {};
+	const result = {};
+	for (const [key, value] of Object.entries(parsed)) {
+		if (typeof value === "undefined") continue;
+		result[key] = value;
+	}
+	return result;
+}
+var DotEnvChannel = class {
+	dotenv;
+	targetPath;
+	absolutePath;
+	encoding;
+	parseOptions;
+	envSource;
+	constructor(dotenv, defaultPath = ".env", getOptions = {}, parseOptions = {}) {
+		this.dotenv = dotenv;
+		this.targetPath = (typeof getOptions.path === "string" ? getOptions.path : void 0) ?? defaultPath;
+		this.absolutePath = (0, node_path.resolve)(process.cwd(), this.targetPath);
+		this.encoding = getOptions.encoding ?? "utf8";
+		this.parseOptions = { ...parseOptions };
+		this.envSource = new EnvSource(this.targetPath);
+	}
+	async get() {
+		try {
+			const content = await (0, node_fs_promises.readFile)(this.absolutePath, { encoding: this.encoding });
+			return normalizeParsed(this.dotenv.parse(content, this.parseOptions));
+		} catch (error) {
+			if (isFileNotFound(error)) return {};
+			throw error;
+		}
+	}
+	async set(values) {
+		await this.envSource.write(values);
+		const parsed = await this.get();
+		const mismatches = [];
+		for (const [key, expected] of Object.entries(values)) {
+			const actual = parsed[key];
+			if (actual !== expected) mismatches.push(`${key}=expected(${JSON.stringify(expected)}) actual(${JSON.stringify(actual)})`);
+		}
+		if (mismatches.length > 0) throw new Error(`Failed to correctly write values to ${this.targetPath}: ${mismatches.join(", ")}`);
+	}
+	getPrimaryPath() {
+		return this.targetPath;
+	}
+	clearCache() {}
+};
+
+//#endregion
+//#region ../channels/src/channels/dotenvx/DotEnvXChannel.ts
+/**
+* Simple DotEnvX implementation of EnvChannel that wraps @dotenvx/dotenvx library
+* This is just an API mapping wrapper without caching or complex state management
+*/
+var DotEnvXChannel = class {
+	dotenvx;
+	getOptions;
+	setOptions;
+	defaultPath;
+	/**
+	* Create a new DotEnvXChannel
+	* @param dotenvx - The dotenvx instance to use
+	* @param defaultPath - Default path for env files
+	* @param getOptions - Options for get operations
+	* @param setOptions - Options for set operations
+	*/
+	constructor(dotenvx, defaultPath = ".env", getOptions = {}, setOptions = {}) {
+		this.dotenvx = dotenvx;
+		this.defaultPath = defaultPath;
+		this.getOptions = getOptions;
+		this.setOptions = setOptions;
+	}
+	/**
+	* Get all environment variables
+	* @returns Promise that resolves to object containing all environment variable key-value pairs
+	*/
+	async get() {
+		try {
+			return this.dotenvx.config({
+				processEnv: {},
+				quiet: true,
+				ignore: ["MISSING_ENV_FILE"],
+				path: this.defaultPath,
+				...this.getOptions
+			}).parsed || {};
+		} catch {
+			return {};
+		}
+	}
+	/**
+	* Set multiple environment variables
+	* @param values - Object containing key-value pairs to set
+	* @returns Promise that resolves when the values have been set
+	*/
+	async set(values) {
+		if (!(0, fs.existsSync)(this.defaultPath)) (0, fs.writeFileSync)(this.defaultPath, "", "utf8");
+		try {
+			const options = {
+				path: this.defaultPath,
+				...this.setOptions
+			};
+			for (const [key, value] of Object.entries(values)) this.dotenvx.set(key, value, options);
+		} catch (error) {
+			throw new Error(`Failed to set environment variables: ${error}`);
+		}
+	}
+	/**
+	* Get the primary path being used for env files
+	* @returns The primary path
+	*/
+	getPrimaryPath() {
+		return this.defaultPath;
+	}
+	/**
+	* Clear any cached data (no-op for this implementation since we don't cache)
+	*/
+	clearCache() {}
+};
+
+//#endregion
+//#region ../channels/src/channels/processenv/ProcessEnvChannel.ts
+/**
+* EnvChannel implementation that works with process.env
+* This channel reads from and writes to the current process environment
+*/
+var ProcessEnvChannel = class {
+	/**
+	* Get all environment variables from process.env
+	* @returns Promise that resolves to object containing all environment variable key-value pairs
+	*/
+	async get() {
+		const env = {};
+		for (const [key, value] of Object.entries(process.env)) if (value !== void 0) env[key] = value;
+		return env;
+	}
+	/**
+	* Set multiple environment variables in process.env
+	* @param values - Object containing key-value pairs to set
+	* @returns Promise that resolves when the values have been set
+	*/
+	async set(values) {
+		for (const [key, value] of Object.entries(values)) process.env[key] = value;
+	}
+};
+
+//#endregion
+//#region ../channels/src/resolveChannel.ts
+/**
+* Resolve channel options into an EnvChannel instance
+* @param options - The channel options to resolve
+* @param defaultPath - Default path to use for env files (default: ".env")
+* @returns An EnvChannel instance
+*/
+function resolveChannel(options, defaultPath = ".env") {
+	if (options === void 0 || options === "default") return new DefaultEnvChannel(defaultPath);
+	if (options === "processenv") return new ProcessEnvChannel();
+	if (typeof options === "object" && options !== null) {
+		if ("dotenv" in options) {
+			const { dotenv, get: getOptions = {}, parse: parseOptions = {}, path } = options;
+			if (!dotenv) throw new Error("Dotenv instance is required for dotenv channel");
+			const resolvedPath = path ?? defaultPath;
+			const mergedGetOptions = { ...getOptions };
+			if (typeof mergedGetOptions.path !== "string") mergedGetOptions.path = resolvedPath;
+			return new DotEnvChannel(dotenv, resolvedPath, mergedGetOptions, parseOptions ?? {});
+		}
+		if ("dotenvx" in options) {
+			const { dotenvx, get: getOptions = {}, set: setOptions = {} } = options;
+			if (!dotenvx) throw new Error("DotEnvX instance is required for dotenvx channel");
+			return new DotEnvXChannel(dotenvx, defaultPath, getOptions, setOptions);
+		}
+		if ("process" in options) {
+			if (options.process && typeof options.process === "object" && "env" in options.process) return new ProcessEnvChannel();
+			throw new Error("Invalid process object provided to channel config");
+		}
+		if ("name" in options) if (options.name === "default") return new DefaultEnvChannel(defaultPath);
+		else if (options.name === "processenv") return new ProcessEnvChannel();
+		else throw new Error(`Unknown channel name: ${options.name}`);
+	}
+	throw new Error(`Invalid channel options: ${options}`);
+}
+
+//#endregion
+//#region ../core/src/schemas/EnvVarSchemaBase.ts
+var EnvVarSchemaBase = class {
+	required;
+	default;
+	description;
+	process;
+	constructor(input) {
+		this.required = input?.required ?? true;
+		this.default = input?.default;
+		this.description = input?.description;
+		this.process = input.process;
+	}
+};
+
+//#endregion
+//#region ../core/src/processing/processors.ts
+/**
+* Default processors for environment variable types.
+* Each processor factory returns a function that takes a value and returns T | undefined.
+* Returns undefined for empty/null values, throws descriptive errors for invalid values.
+*/
+/**
+* Create a string processor - pass through as-is
+*/
+const stringProcessor = () => (value) => {
+	if (typeof value !== "string") throw new Error("Value must be a string");
+	return value === "" ? void 0 : value;
+};
+/**
+* Create a number processor using parseFloat
+*/
+const numberProcessor = () => (value) => {
+	if (typeof value !== "string") throw new Error("Value must be a string");
+	const trimmed = value.trim();
+	if (trimmed === "") return;
+	const parsed = parseFloat(trimmed);
+	if (isNaN(parsed)) throw new Error(`"${value}" is not a valid number`);
+	return parsed;
+};
+/**
+* Create a boolean processor from string representation
+*/
+const booleanProcessor = () => (value) => {
+	if (typeof value !== "string") throw new Error("Value must be a string");
+	const trimmed = value.trim().toLowerCase();
+	if (trimmed === "") return;
+	if (trimmed === "true" || trimmed === "1" || trimmed === "yes" || trimmed === "on") return true;
+	if (trimmed === "false" || trimmed === "0" || trimmed === "no" || trimmed === "off") return false;
+	throw new Error(`"${value}" is not a valid boolean. Use: true/false, 1/0, yes/no, or on/off`);
+};
+/**
+* Create an enum processor that validates values against allowed options
+*/
+const enumProcessor = (allowedValues) => (value) => {
+	if (typeof value !== "string") throw new Error("Value must be a string");
+	const trimmed = value.trim();
+	if (trimmed === "") return;
+	if (!allowedValues.includes(trimmed)) throw new Error(`"${value}" is not a valid option. Must be one of: ${allowedValues.join(", ")}`);
+	return trimmed;
+};
+/**
+* Default processors map for each environment variable type
+*/
+const processors = {
+	string: stringProcessor,
+	number: numberProcessor,
+	boolean: booleanProcessor,
+	enum: enumProcessor
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/BooleanEnvVarSchema.ts
+var BooleanEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "boolean";
+	constructor(input = {}) {
+		super({
+			...input,
+			process: input.process ?? processors.boolean()
+		});
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/EnumEnvVarSchema.ts
+var EnumEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "enum";
+	values;
+	constructor(input) {
+		super({
+			...input,
+			process: input.process ?? processors.enum(input.values)
+		});
+		this.values = input.values;
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/NumberEnvVarSchema.ts
+var NumberEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "number";
+	constructor(input = {}) {
+		super({
+			...input,
+			process: input.process ?? processors.number()
+		});
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/StringEnvVarSchema.ts
+var StringEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "string";
+	secret;
+	constructor(input = {}) {
+		super({
+			...input,
+			process: input.process ?? processors.string()
+		});
+		this.secret = input.secret;
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/EnvVarSchema.ts
+/**
+* Type guard to check if a value is a EnvVarSchema instance
+*/
+function isEnvVarSchema(value) {
+	return value instanceof StringEnvVarSchema || value instanceof NumberEnvVarSchema || value instanceof BooleanEnvVarSchema || value instanceof EnumEnvVarSchema;
+}
+
+//#endregion
+//#region ../core/src/processing/preprocessors.ts
+const defaultBooleanPreprocessorOptions = {
+	true: [
+		"on",
+		"enabled",
+		"active",
+		"yes"
+	],
+	false: [
+		"off",
+		"disabled",
+		"inactive",
+		"no"
+	]
+};
+/**
+* Create a string preprocessor - pass through unchanged
+*/
+const stringPreprocessor = () => (value) => value;
+/**
+* Create a number preprocessor that strips commas and whitespace
+*/
+const numberPreprocessor = () => (value) => {
+	try {
+		const cleaned = value.replace(/,/g, "").trim();
+		if (/^-?\d*\.?\d+$/.test(cleaned)) return cleaned;
+	} catch {}
+	return value;
+};
+/**
+* Create a boolean preprocessor that normalizes common truthy/falsy phrases
+*/
+const booleanPreprocessor = (options = defaultBooleanPreprocessorOptions) => {
+	const normalize = (candidate) => candidate.toLowerCase().trim();
+	const trueValues = new Set(options.true.map(normalize));
+	const falseValues = new Set(options.false.map(normalize));
+	for (const candidate of trueValues) if (falseValues.has(candidate)) throw new Error(`Boolean preprocessor option value "${candidate}" cannot map to both true and false`);
+	return (value) => {
+		try {
+			const cleaned = normalize(value);
+			if (trueValues.has(cleaned)) return true;
+			if (falseValues.has(cleaned)) return false;
+		} catch {}
+		return value;
+	};
+};
+/**
+* Create an enum preprocessor - pass through unchanged
+*/
+const enumPreprocessor = () => (value) => value;
+/**
+* Default preprocessors map for each environment variable type
+*/
+const preprocessors = {
+	string: stringPreprocessor,
+	number: numberPreprocessor,
+	boolean: booleanPreprocessor,
+	enum: enumPreprocessor
+};
+
+//#endregion
+//#region ../core/src/processing/Preprocessor.ts
+const optionKeyMap = {
+	string: "string",
+	number: "number",
+	boolean: "boolean",
+	enum: "enum"
+};
+const explicitPreprocessorFactories = {
+	string: stringPreprocessor,
+	number: numberPreprocessor,
+	boolean: booleanPreprocessor,
+	enum: enumPreprocessor
+};
+function createDefaultPreprocessor(envVarType) {
+	switch (envVarType) {
+		case "number": return numberPreprocessor();
+		case "boolean": return booleanPreprocessor();
+		default: return;
+	}
+}
+function createExplicitPreprocessor(envVarType) {
+	const factory = explicitPreprocessorFactories[envVarType];
+	if (!factory) return;
+	return factory();
+}
+/**
+* Resolve the effective preprocessor for a given environment variable type.
+* Respects custom overrides and falls back to built-in defaults (number, boolean).
+*/
+function resolvePreprocessor(envVarType, preprocessorOptions) {
+	if (envVarType === "boolean") {
+		const override = preprocessorOptions?.boolean;
+		if (override === void 0) return createDefaultPreprocessor(envVarType);
+		if (override === false) return;
+		if (override === true) return createExplicitPreprocessor(envVarType);
+		if (typeof override === "function") return override;
+		return booleanPreprocessor(override);
+	}
+	const key = optionKeyMap[envVarType];
+	const custom = preprocessorOptions?.[key];
+	if (custom === void 0) return createDefaultPreprocessor(envVarType);
+	if (custom === false) return;
+	if (custom === true) return createExplicitPreprocessor(envVarType);
+	return custom;
+}
+
+//#endregion
+//#region ../converters/src/converters/zod/ZodV3Converter.ts
+/**
+* Zod v3 schema converter implementation
+*/
+var ZodV3Converter = class {
+	applies(schema) {
+		return isZodV3Schema(schema);
+	}
+	convert(schema) {
+		return convertFromZodV3Schema(schema);
+	}
+};
+/**
+* Check if a schema is a Zod v3 schema
+*/
+function isZodV3Schema(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	const candidate = schema;
+	return Boolean(candidate._def && !("_zod" in candidate) && (candidate._def.typeName || typeof candidate.parse === "function"));
+}
+/**
+* Extract definition from Zod v3 schema
+*/
+function getV3Def(schema) {
+	return schema._def || {};
+}
+/**
+* Get the type name from a Zod v3 definition
+*/
+function getV3TypeName(def) {
+	return def.typeName || "unknown";
+}
+/**
+* Check if a type is a wrapper type that should be unwrapped
+*/
+function isV3WrapperType(typeName) {
+	return [
+		"ZodOptional",
+		"ZodDefault",
+		"ZodEffects",
+		"ZodNullable",
+		"ZodNullish",
+		"ZodReadonly",
+		"ZodBranded",
+		"ZodCatch"
+	].includes(typeName);
+}
+/**
+* Get inner schema from wrapper
+*/
+function getV3InnerSchema(def) {
+	return def.innerType || def.schema;
+}
+/**
+* Get default value from definition
+*/
+function getV3DefaultValue(def) {
+	if (def.defaultValue === void 0) return void 0;
+	return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+}
+/**
+* Extract enum values from schema
+*/
+function extractV3EnumValues(def) {
+	if (!Array.isArray(def.values)) return void 0;
+	return def.values.map((v) => String(v));
+}
+/**
+* Get description from schema
+*/
+function getV3Description(schema, def) {
+	const directDesc = schema.description;
+	if (typeof directDesc === "string" && directDesc.length > 0) return directDesc;
+	if (typeof def.description === "string" && def.description.length > 0) return def.description;
+}
+/**
+* Resolve environment variable type from schema
+*/
+function resolveV3EnvVarType(schema) {
+	const def = getV3Def(schema);
+	switch (getV3TypeName(def)) {
+		case "ZodString": return "string";
+		case "ZodNumber": return "number";
+		case "ZodBoolean": return "boolean";
+		case "ZodEnum": return "enum";
+		default:
+			if (def.values) return "enum";
+			return "string";
+	}
+}
+function peelV3Schema(schema) {
+	let current = schema;
+	let required = true;
+	let defaultValue = void 0;
+	let description = void 0;
+	for (let i = 0; i < 20; i++) {
+		const def = getV3Def(current);
+		const typeName = getV3TypeName(def);
+		if (!description) description = getV3Description(current, def);
+		if (!isV3WrapperType(typeName)) break;
+		if (typeName === "ZodOptional" || typeName === "ZodNullish") required = false;
+		if (typeName === "ZodDefault" && defaultValue === void 0) defaultValue = getV3DefaultValue(def);
+		const inner = getV3InnerSchema(def);
+		if (!inner) break;
+		current = inner;
+	}
+	return {
+		schema: current,
+		required,
+		default: defaultValue,
+		description
+	};
+}
+/**
+* Create a process function for Zod v3 schemas
+*/
+function createV3ProcessFunction(schema, type) {
+	return (value) => {
+		try {
+			let processSchema = schema;
+			if (type === "number") processSchema = zod.z.coerce.number();
+			else if (type === "boolean") processSchema = zod.z.string().transform((val) => {
+				const lower = val.toLowerCase().trim();
+				if ([
+					"true",
+					"1",
+					"yes",
+					"on",
+					"enabled"
+				].includes(lower)) return true;
+				if ([
+					"false",
+					"0",
+					"no",
+					"off",
+					"disabled"
+				].includes(lower)) return false;
+				throw new Error(`Expected boolean value, received "${val}"`);
+			});
+			const result = processSchema.safeParse(value);
+			if (result.success) return result.data;
+			throw new Error(`Failed to parse value "${value}": ${result.error.issues.map((issue) => issue.message).join("; ")}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(message);
+		}
+	};
+}
+/**
+* Convert Zod v3 schema to EnvVarSchema
+*/
+function convertFromZodV3Schema(schema) {
+	const peeled = peelV3Schema(schema);
+	const type = resolveV3EnvVarType(peeled.schema);
+	const def = getV3Def(peeled.schema);
+	switch (type) {
+		case "boolean": return new BooleanEnvVarSchema({
+			process: createV3ProcessFunction(peeled.schema, "boolean"),
+			required: peeled.required,
+			default: typeof peeled.default === "boolean" ? peeled.default : void 0,
+			description: peeled.description
+		});
+		case "number": return new NumberEnvVarSchema({
+			process: createV3ProcessFunction(peeled.schema, "number"),
+			required: peeled.required,
+			default: typeof peeled.default === "number" ? peeled.default : void 0,
+			description: peeled.description
+		});
+		case "enum": {
+			const values = extractV3EnumValues(def) || [];
+			return new EnumEnvVarSchema({
+				process: createV3ProcessFunction(peeled.schema, "enum"),
+				values,
+				required: peeled.required,
+				default: typeof peeled.default === "string" ? peeled.default : void 0,
+				description: peeled.description
+			});
+		}
+		case "string":
+		default: {
+			const process$1 = createV3ProcessFunction(peeled.schema, "string");
+			const defaultValue = typeof peeled.default === "string" ? peeled.default : void 0;
+			return new StringEnvVarSchema({
+				process: process$1,
+				required: peeled.required,
+				default: defaultValue,
+				description: peeled.description
+			});
+		}
+	}
+}
+
+//#endregion
+//#region ../converters/src/converters/zod/ZodV4Converter.ts
+/**
+* Zod v4 schema converter implementation
+*/
+var ZodV4Converter = class {
+	applies(schema) {
+		return isZodV4Schema(schema);
+	}
+	convert(schema) {
+		return convertFromZodV4Schema(schema);
+	}
+};
+/**
+* Check if a schema is a Zod v4 schema
+*/
+function isZodV4Schema(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	return "_zod" in schema;
+}
+/**
+* Extract definition from Zod v4 schema
+*/
+function getV4Def(schema) {
+	const container = schema;
+	if (container._zod && container._zod.def) return container._zod.def;
+	return {};
+}
+/**
+* Get the type name from a Zod v4 definition
+*/
+function getV4TypeName(def) {
+	return def.type || "unknown";
+}
+/**
+* Check if a type is a wrapper type that should be unwrapped
+*/
+function isV4WrapperType(typeName) {
+	return [
+		"optional",
+		"default",
+		"catch",
+		"readonly",
+		"brand",
+		"prefault",
+		"nullable",
+		"nullish"
+	].includes(typeName);
+}
+/**
+* Get inner schema from wrapper
+*/
+function getV4InnerSchema(def) {
+	return def.innerType || def.schema || def.in || def.inner;
+}
+/**
+* Get default value from definition
+*/
+function getV4DefaultValue(def) {
+	if (def.defaultValue !== void 0) return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+	if (def.prefaultValue !== void 0) return typeof def.prefaultValue === "function" ? def.prefaultValue() : def.prefaultValue;
+}
+/**
+* Extract enum values from schema
+*/
+function extractV4EnumValues(def) {
+	if (Array.isArray(def.values)) return def.values.map((v) => String(v));
+	if (def.entries && typeof def.entries === "object") return Object.values(def.entries).map((v) => String(v));
+}
+/**
+* Get description from schema
+*/
+function getV4Description(schema, def) {
+	const directDesc = schema.description;
+	if (typeof directDesc === "string" && directDesc.length > 0) return directDesc;
+	if (typeof def.description === "string" && def.description.length > 0) return def.description;
+	const metaFn = schema.meta;
+	if (typeof metaFn === "function") {
+		const meta = metaFn.call(schema);
+		if (meta?.description && typeof meta.description === "string") return meta.description.trim();
+	}
+}
+/**
+* Resolve environment variable type from schema
+*/
+function resolveV4EnvVarType(schema) {
+	const def = getV4Def(schema);
+	switch (getV4TypeName(def)) {
+		case "string": return "string";
+		case "number":
+		case "int": return "number";
+		case "boolean":
+		case "stringbool": return "boolean";
+		case "pipe":
+			if (def.in && def.out) {
+				const inType = resolveV4EnvVarType(def.in);
+				const outType = resolveV4EnvVarType(def.out);
+				if (inType === "string" && outType === "boolean") return "boolean";
+			}
+			return "string";
+		case "enum": return "enum";
+		default:
+			if (def.values || def.entries) return "enum";
+			return "string";
+	}
+}
+function peelV4Schema(schema) {
+	let current = schema;
+	let required = true;
+	let defaultValue = void 0;
+	let description = void 0;
+	for (let i = 0; i < 20; i++) {
+		const def = getV4Def(current);
+		const typeName = getV4TypeName(def);
+		if (!description) description = getV4Description(current, def);
+		if (!isV4WrapperType(typeName)) if (typeName === "pipe" && def.in && def.out) {
+			const inType = resolveV4EnvVarType(def.in);
+			const outType = resolveV4EnvVarType(def.out);
+			if (inType === "string" && outType === "boolean") break;
+		} else break;
+		if (typeName === "optional" || typeName === "nullish") required = false;
+		if ((typeName === "default" || typeName === "prefault") && defaultValue === void 0) defaultValue = getV4DefaultValue(def);
+		const inner = getV4InnerSchema(def);
+		if (!inner) break;
+		current = inner;
+	}
+	return {
+		schema: current,
+		required,
+		default: defaultValue,
+		description
+	};
+}
+/**
+* Create a process function for Zod v4 schemas
+*/
+function createV4ProcessFunction(schema, type, originalSchema) {
+	return (value) => {
+		try {
+			let processSchema = schema;
+			const def = getV4Def(schema);
+			const typeName = getV4TypeName(def);
+			if (typeName === "stringbool" || typeName === "pipe" && def.in && def.out && resolveV4EnvVarType(def.in) === "string" && resolveV4EnvVarType(def.out) === "boolean") processSchema = originalSchema;
+			else if (type === "number") processSchema = zod.z.coerce.number();
+			else if (type === "boolean") processSchema = zod.z.stringbool();
+			const result = zod_v4_core.safeParse(processSchema, value);
+			if (result.success) return result.data;
+			throw new Error(`Failed to parse value "${value}": ${result.error.issues.map((issue) => issue.message).join("; ")}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(message);
+		}
+	};
+}
+/**
+* Convert Zod v4 schema to EnvVarSchema
+*/
+function convertFromZodV4Schema(schema) {
+	const peeled = peelV4Schema(schema);
+	const type = resolveV4EnvVarType(peeled.schema);
+	const def = getV4Def(peeled.schema);
+	switch (type) {
+		case "boolean": return new BooleanEnvVarSchema({
+			process: createV4ProcessFunction(peeled.schema, "boolean", schema),
+			required: peeled.required,
+			default: typeof peeled.default === "boolean" ? peeled.default : void 0,
+			description: peeled.description
+		});
+		case "number": return new NumberEnvVarSchema({
+			process: createV4ProcessFunction(peeled.schema, "number", schema),
+			required: peeled.required,
+			default: typeof peeled.default === "number" ? peeled.default : void 0,
+			description: peeled.description
+		});
+		case "enum": {
+			const values = extractV4EnumValues(def) || [];
+			return new EnumEnvVarSchema({
+				process: createV4ProcessFunction(peeled.schema, "enum", schema),
+				values,
+				required: peeled.required,
+				default: typeof peeled.default === "string" ? peeled.default : void 0,
+				description: peeled.description
+			});
+		}
+		case "string":
+		default: {
+			const process$1 = createV4ProcessFunction(peeled.schema, "string", schema);
+			const defaultValue = typeof peeled.default === "string" ? peeled.default : void 0;
+			return new StringEnvVarSchema({
+				process: process$1,
+				required: peeled.required,
+				default: defaultValue,
+				description: peeled.description
+			});
+		}
+	}
+}
+
+//#endregion
+//#region ../converters/src/converters/joi/JoiConverter.ts
+/**
+* Joi schema converter implementation
+*/
+var JoiConverter = class {
+	applies(schema) {
+		return isJoiSchema(schema);
+	}
+	convert(schema) {
+		return convertFromJoiSchema(schema);
+	}
+};
+/**
+* Check if a schema is a Joi schema using the official API
+*/
+function isJoiSchema(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	const candidate = schema;
+	if (!(typeof candidate.describe === "function" && typeof candidate.validate === "function")) return false;
+	if (candidate.isJoi === true) return true;
+	const hasAsyncVariant = typeof candidate.validateAsync === "function";
+	const hasRoot = typeof candidate.$_root === "object" && candidate.$_root !== null;
+	const hasFlags = typeof candidate._flags === "object" && candidate._flags !== null;
+	return hasAsyncVariant || hasRoot || hasFlags;
+}
+/**
+* Get description from Joi schema using public API first, internal as fallback
+*/
+function getJoiDescription(schema) {
+	try {
+		return schema.describe()?.flags?.description;
+	} catch {
+		return schema._flags?.description;
+	}
+}
+/**
+* Check if schema is required using public API first, internal as fallback
+*/
+function isJoiRequired(schema) {
+	try {
+		const presence = schema.describe()?.flags?.presence;
+		if (presence === "required") return true;
+		if (presence === "optional") return false;
+		return presence === void 0;
+	} catch {
+		const flags = schema._flags;
+		if (flags?.presence === "required") return true;
+		if (flags?.presence === "optional") return false;
+		return true;
+	}
+}
+/**
+* Get default value from Joi schema using public API first, internal as fallback
+*/
+function getJoiDefaultValue(schema) {
+	try {
+		const defaultValue = schema.describe()?.flags?.default;
+		return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+	} catch {
+		const flags = schema._flags;
+		if (flags?.default !== void 0) {
+			const defaultValue = flags.default;
+			return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+		}
+		return;
+	}
+}
+/**
+* Get valid values for enum-like schemas using public API first, internal as fallback
+*/
+function getJoiValidValues(schema) {
+	const values = [];
+	let isOnlySchema = false;
+	try {
+		const description = schema.describe();
+		if (description?.allow && Array.isArray(description.allow)) values.push(...description.allow);
+		isOnlySchema = description?.flags?.only === true;
+	} catch {
+		if (schema._valids?._values) values.push(...Array.from(schema._valids._values));
+		isOnlySchema = schema._flags?.only === true;
+	}
+	if (isOnlySchema && values.length > 0) return values.map((v) => String(v));
+}
+/**
+* Resolve environment variable type from Joi schema using public API first, internal as fallback
+*/
+function resolveJoiEnvVarType(schema) {
+	let type;
+	const exposedSchema = schema;
+	try {
+		type = schema.describe()?.type;
+	} catch {
+		type = exposedSchema._type || schema.type;
+	}
+	const validValues = getJoiValidValues(schema);
+	if (validValues && validValues.length > 0) return "enum";
+	switch (type) {
+		case "string": return "string";
+		case "number": return "number";
+		case "boolean": return "boolean";
+		default: return "string";
+	}
+}
+/**
+* Create a process function for Joi schemas
+*/
+function createJoiProcessFunction(schema, type) {
+	return (value) => {
+		try {
+			let processValue$1 = value;
+			if (type === "number") {
+				const num = Number(value);
+				if (Number.isNaN(num)) throw new Error(`Expected number, received "${value}"`);
+				processValue$1 = num;
+			} else if (type === "boolean") {
+				const lower = value.toLowerCase().trim();
+				if ([
+					"true",
+					"1",
+					"yes",
+					"on",
+					"enabled"
+				].includes(lower)) processValue$1 = true;
+				else if ([
+					"false",
+					"0",
+					"no",
+					"off",
+					"disabled"
+				].includes(lower)) processValue$1 = false;
+				else throw new Error(`Expected boolean value, received "${value}"`);
+			}
+			const result = schema.validate(processValue$1, { convert: true });
+			if (result.error) {
+				const message = result.error.details ? result.error.details.map((d) => d.message).join("; ") : result.error.message || String(result.error);
+				throw new Error(`Validation failed: ${message}`);
+			}
+			return result.value;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(message);
+		}
+	};
+}
+/**
+* Convert Joi schema to EnvVarSchema
+*/
+function convertFromJoiSchema(schema) {
+	const type = resolveJoiEnvVarType(schema);
+	const required = isJoiRequired(schema);
+	const defaultValue = getJoiDefaultValue(schema);
+	const description = getJoiDescription(schema);
+	switch (type) {
+		case "boolean": return new BooleanEnvVarSchema({
+			process: createJoiProcessFunction(schema, "boolean"),
+			required,
+			default: typeof defaultValue === "boolean" ? defaultValue : void 0,
+			description
+		});
+		case "number": return new NumberEnvVarSchema({
+			process: createJoiProcessFunction(schema, "number"),
+			required,
+			default: typeof defaultValue === "number" ? defaultValue : void 0,
+			description
+		});
+		case "enum": {
+			const values = getJoiValidValues(schema) || [];
+			return new EnumEnvVarSchema({
+				process: createJoiProcessFunction(schema, "enum"),
+				values,
+				required,
+				default: typeof defaultValue === "string" ? defaultValue : void 0,
+				description
+			});
+		}
+		case "string":
+		default: return new StringEnvVarSchema({
+			process: createJoiProcessFunction(schema, "string"),
+			required,
+			default: typeof defaultValue === "string" ? defaultValue : void 0,
+			description
+		});
+	}
+}
+
+//#endregion
+//#region ../converters/src/converters/superstruct/SuperstructConverter.ts
+/**
+* Superstruct schema converter implementation
+*/
+var SuperstructConverter = class {
+	applies(schema) {
+		return isSuperstructSchema(schema);
+	}
+	convert(schema) {
+		return convertFromSuperstruct(schema);
+	}
+};
+/**
+* Detect if a value looks like a Superstruct Struct instance
+*/
+function isSuperstructSchema(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.type === "string" && typeof candidate.validate === "function" && typeof candidate.create === "function";
+}
+/**
+* Convert a Superstruct schema to an EnvVarSchema
+*/
+function convertFromSuperstruct(schema) {
+	const resolvedType = resolveSuperstructEnvVarType(schema);
+	const required = isStructRequired(schema);
+	const description = getStructDescription(schema);
+	const defaultValue = getStructDefault(schema);
+	if (resolvedType === "enum") {
+		const values = extractEnumValues(schema);
+		if (!values || values.length === 0) return createStringEnvVarSchema(schema, required, defaultValue, description);
+		const readonlyValues = values;
+		return new EnumEnvVarSchema({
+			process: createSuperstructProcessFunction(schema, "enum"),
+			values: readonlyValues,
+			required,
+			default: typeof defaultValue === "string" ? defaultValue : void 0,
+			description
+		});
+	}
+	if (resolvedType === "boolean") return new BooleanEnvVarSchema({
+		process: createSuperstructProcessFunction(schema, "boolean"),
+		required,
+		default: typeof defaultValue === "boolean" ? defaultValue : void 0,
+		description
+	});
+	if (resolvedType === "number") return new NumberEnvVarSchema({
+		process: createSuperstructProcessFunction(schema, "number"),
+		required,
+		default: typeof defaultValue === "number" ? defaultValue : void 0,
+		description
+	});
+	return createStringEnvVarSchema(schema, required, defaultValue, description);
+}
+function createStringEnvVarSchema(schema, required, defaultValue, description) {
+	return new StringEnvVarSchema({
+		process: createSuperstructProcessFunction(schema, "string"),
+		required,
+		default: typeof defaultValue === "string" ? defaultValue : void 0,
+		description
+	});
+}
+function resolveSuperstructEnvVarType(schema) {
+	switch (getStructType(schema)) {
+		case "boolean": return "boolean";
+		case "number":
+		case "integer": return "number";
+		case "enums": return "enum";
+		case "literal": return typeof schema.schema === "string" ? "enum" : "string";
+		default: return "string";
+	}
+}
+function getStructType(schema) {
+	const typeValue = schema.type;
+	return typeof typeValue === "string" ? typeValue : "unknown";
+}
+function extractEnumValues(schema) {
+	const typeName = getStructType(schema);
+	if (typeName === "enums") {
+		const structSchema = schema.schema;
+		if (structSchema && typeof structSchema === "object") {
+			const rawValues = Object.values(structSchema);
+			if (rawValues.every((value) => typeof value === "string")) return rawValues;
+		}
+	}
+	if (typeName === "literal") {
+		const value = schema.schema;
+		if (typeof value === "string") return [value];
+	}
+}
+function isStructRequired(schema) {
+	try {
+		const [error] = schema.validate(void 0);
+		return !!error;
+	} catch {
+		return true;
+	}
+}
+function getStructDefault(schema) {
+	try {
+		const [error, value] = schema.validate(void 0, { coerce: true });
+		if (!error && value !== void 0) return value;
+	} catch {}
+}
+function getStructDescription(schema) {
+	const structSchema = schema.schema;
+	if (structSchema && typeof structSchema === "object" && typeof structSchema.description === "string") return structSchema.description;
+	if (typeof schema.description === "string") return schema.description;
+}
+function createSuperstructProcessFunction(schema, type) {
+	return (value) => {
+		if (typeof value !== "string") throw new Error("Value must be a string");
+		let candidate = value;
+		if (type === "number") {
+			const trimmed = value.trim();
+			if (trimmed === "") candidate = void 0;
+			else {
+				const parsed = Number(trimmed);
+				if (Number.isNaN(parsed) || !Number.isFinite(parsed)) throw new Error(`"${value}" is not a valid number`);
+				candidate = parsed;
+			}
+		} else if (type === "boolean") {
+			const trimmed = value.trim().toLowerCase();
+			if (trimmed === "") candidate = void 0;
+			else if ([
+				"true",
+				"1",
+				"yes",
+				"on",
+				"enabled"
+			].includes(trimmed)) candidate = true;
+			else if ([
+				"false",
+				"0",
+				"no",
+				"off",
+				"disabled"
+			].includes(trimmed)) candidate = false;
+			else throw new Error(`"${value}" is not a valid boolean. Use: true/false, 1/0, yes/no, on/off, or enabled/disabled`);
+		} else if (value === "") candidate = void 0;
+		const [error, result] = schema.validate(candidate, { coerce: true });
+		if (error) throw new Error(error.message);
+		return result;
+	};
+}
+
+//#endregion
+//#region ../converters/src/converters.ts
+/**
+* Registry of available schema converters
+*/
+const converters = [
+	new ZodV4Converter(),
+	new ZodV3Converter(),
+	new JoiConverter(),
+	new SuperstructConverter()
+];
+
+//#endregion
+//#region ../models/src/resolve.ts
+/**
+* Resolve any supported schema to a EnvVarSchema.
+*
+* This is the main entry point for converting external schemas
+* (like Zod schemas) to envcredible's internal schema format.
+* If the input is already a EnvVarSchema, it returns it directly.
+*
+* @param schema - The schema to convert (e.g., Zod v3/v4 schema or EnvVarSchema)
+* @returns EnvVarSchema that can be used with envcredible
+* @throws Error if no converter can handle the schema
+*/
+function resolveSchema(schema) {
+	if (isEnvVarSchema(schema)) return schema;
+	for (const converter of converters) if (converter.applies(schema)) return converter.convert(schema);
+	throw new Error(`No converter found for schema. Supported types: Zod v3, Zod v4, Joi, Superstruct, EnvVarSchema. Received: ${typeof schema}`);
+}
+/**
+* Resolve mixed schema map (Zod schemas or EnvVarSchema) to pure EnvVarSchema map.
+*
+* This function takes a map where values can be:
+* - Zod v3 schemas
+* - Zod v4 schemas
+* - Already resolved EnvVarSchema instances
+*
+* And converts everything to EnvVarSchema instances that can be used throughout envcredible.
+*
+* @param schemas - Object mapping environment variable names to various schema types
+* @returns Record mapping env var names to EnvVarSchema instances
+*/
+function resolveSchemas(schemas) {
+	const resolved = {};
+	for (const [key, schema] of Object.entries(schemas)) try {
+		resolved[key] = resolveSchema(schema);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to resolve schema for environment variable "${key}": ${message}`);
+	}
+	return resolved;
+}
+
+//#endregion
+//#region ../models/src/EnvModel.ts
+/**
+* Environment variable specification container
+* Encapsulates schemas and preprocessor configuration
+*/
+var EnvModel = class {
+	/**
+	* Resolved environment variable schemas
+	*/
+	schemas;
+	/**
+	* Preprocessing configuration for environment variable types
+	*/
+	preprocess;
+	/**
+	* Create an EnvModel instance from options
+	* @param options - Specification options
+	*/
+	constructor(options) {
+		this.schemas = resolveSchemas(options.schemas);
+		this.preprocess = this.resolvePreprocessors(options.preprocess);
+	}
+	/**
+	* Resolve preprocessor configuration from options
+	* @param config - Preprocessor configuration (true, false, or partial object)
+	* @returns Resolved preprocessors object
+	*/
+	resolvePreprocessors(config) {
+		if (config === false) return {
+			string: false,
+			number: false,
+			boolean: false,
+			enum: false
+		};
+		if (config === true || config === void 0) return {};
+		return { ...config };
+	}
+};
+
+//#endregion
+//#region ../models/src/model.ts
+/**
+* Create an environment variable model
+*
+* Sugar utility for creating EnvModel instances with full type inference
+*
+* @param options - Model options
+* @returns EnvModel instance with inferred types
+*
+* @example
+* ```typescript
+* import { define, s } from "@e-n-v/models";
+*
+* export default define({
+*   schemas: {
+*     PORT: s.number({ default: 3000 }),
+*     DATABASE_URL: s.string(),
+*     DEBUG: s.boolean({ default: false })
+*   },
+*   preprocess: true
+* });
+* ```
+*/
+function define(options) {
+	return new EnvModel(options);
+}
+
+//#endregion
+//#region ../prompt/src/options/defaults.ts
+var defaults_exports = /* @__PURE__ */ __export({
+	ENV_PATH: () => ENV_PATH,
+	SECRET_PATTERNS: () => SECRET_PATTERNS,
+	TRUNCATE_LENGTH: () => TRUNCATE_LENGTH
+});
+const ENV_PATH = ".env";
+const TRUNCATE_LENGTH = 40;
+const SECRET_PATTERNS = Object.freeze([
+	/password/i,
+	/passphrase/i,
+	/secret/i,
+	/token/i,
+	/api[_-]?key/i,
+	/client[_-]?secret/i,
+	/private[_-]?key/i,
+	/(?:database|db|redis|mongo|sql|postgres|mysql)[_-]?(?:connection[_-]?)?(?:string|url)/i,
+	/database(?:[_-]?url)?/i,
+	/access[_-]?key/i,
+	/credential/i
+]);
+
+//#endregion
+//#region ../prompt/src/visuals/Theme.ts
+var Theme = class Theme {
+	static default = new Theme(picocolors.default.magenta);
+	primary;
+	bgPrimary;
+	subtle;
+	warn;
+	bgWarn;
+	error;
+	bgError;
+	constructor(main) {
+		this.primary = main;
+		this.bgPrimary = this.getBackgroundColor(main);
+		this.subtle = picocolors.default.gray;
+		this.warn = picocolors.default.yellow;
+		this.bgWarn = this.getBackgroundColor(picocolors.default.yellow);
+		this.error = picocolors.default.red;
+		this.bgError = this.getBackgroundColor(picocolors.default.red);
+	}
+	/**
+	* Get the background version of a color function
+	*/
+	getBackgroundColor(colorFn) {
+		if (colorFn === picocolors.default.black) return picocolors.default.bgBlack;
+		if (colorFn === picocolors.default.red) return picocolors.default.bgRed;
+		if (colorFn === picocolors.default.green) return picocolors.default.bgGreen;
+		if (colorFn === picocolors.default.yellow) return picocolors.default.bgYellow;
+		if (colorFn === picocolors.default.blue) return picocolors.default.bgBlue;
+		if (colorFn === picocolors.default.magenta) return picocolors.default.bgMagenta;
+		if (colorFn === picocolors.default.cyan) return picocolors.default.bgCyan;
+		if (colorFn === picocolors.default.white) return picocolors.default.bgWhite;
+		if (colorFn === picocolors.default.redBright) return picocolors.default.bgRedBright;
+		if (colorFn === picocolors.default.greenBright) return picocolors.default.bgGreenBright;
+		if (colorFn === picocolors.default.yellowBright) return picocolors.default.bgYellowBright;
+		if (colorFn === picocolors.default.blueBright) return picocolors.default.bgBlueBright;
+		if (colorFn === picocolors.default.magentaBright) return picocolors.default.bgMagentaBright;
+		if (colorFn === picocolors.default.cyanBright) return picocolors.default.bgCyanBright;
+		if (colorFn === picocolors.default.whiteBright) return picocolors.default.bgWhiteBright;
+		return picocolors.default.bgBlack;
+	}
+};
+
+//#endregion
+//#region ../prompt/src/visuals/symbols.ts
+const S_BAR = "│";
+const S_BAR_END = "└";
+const S_BAR_START = "┌";
+const S_STEP_ACTIVE = "◆";
+const S_STEP_SUBMIT = "✔";
+const S_STEP_SKIP = "⏭";
+const S_STEP_CANCEL = "✕";
+const S_STEP_ERROR = "▲";
+const S_STEP_PREVIOUS = "⏮";
+const S_TOOL_ACTIVE = "■";
+const S_TOOL_INACTIVE = "□";
+const S_RADIO_ACTIVE = "●";
+const S_RADIO_INACTIVE = "○";
+const S_CURSOR = "█";
+const SECRET_MASK = "•";
+
+//#endregion
+//#region ../prompt/src/prompts/ThemedPrompt.ts
+var ThemedPrompt = class extends __clack_core.Prompt {
+	theme;
+	constructor(opts, trackValue = false) {
+		super(opts, trackValue);
+		this.theme = opts.theme || Theme.default;
+	}
+	/**
+	* Get the appropriate symbol based on prompt state
+	*/
+	getSymbol() {
+		switch (this.state) {
+			case "initial":
+			case "active": return this.theme.primary(S_STEP_ACTIVE);
+			case "error": return this.theme.warn(S_STEP_ERROR);
+			case "submit": return this.theme.primary(S_STEP_SUBMIT);
+			case "cancel": return this.theme.error(S_STEP_CANCEL);
+			default: return this.theme.primary(S_STEP_ACTIVE);
+		}
+	}
+	/**
+	* Get bar color based on error state - yellow for errors, theme primary otherwise
+	*/
+	getBarColor(barSymbol) {
+		return this.state === "error" ? this.theme.warn(barSymbol) : this.theme.primary(barSymbol);
+	}
+	/**
+	* Get bar symbols with appropriate coloring
+	*/
+	getBar() {
+		return this.getBarColor(S_BAR);
+	}
+	getBarEnd() {
+		return this.getBarColor(S_BAR_END);
+	}
+	/**
+	* Color utilities for consistent theming
+	*/
+	get colors() {
+		return {
+			primary: this.theme.primary,
+			subtle: this.theme.subtle,
+			warn: this.theme.warn,
+			error: this.theme.error,
+			white: picocolors.default.white,
+			bold: picocolors.default.bold,
+			dim: picocolors.default.dim,
+			inverse: picocolors.default.inverse,
+			strikethrough: picocolors.default.strikethrough
+		};
+	}
+};
+
+//#endregion
+//#region ../prompt/src/prompts/utils/ClackPromptInternals.ts
+/** Hacks to access private members of Clack prompts */
+var ClackPromptInternals = class {
+	prompt;
+	constructor(prompt$1) {
+		this.prompt = prompt$1;
+	}
+	set track(enabled) {
+		this.prompt._track = enabled;
+	}
+	get track() {
+		return this.prompt._track;
+	}
+};
+
+//#endregion
+//#region ../prompt/src/prompts/utils/padActiveRender.ts
+/**
+* Ensures active prompts leave a blank line beneath their output while leaving
+* submitted or cancelled renders untouched.
+*/
+function padActiveRender(render) {
+	return function paddedRender() {
+		const result = render.call(this);
+		if (typeof result !== "string") return result;
+		if (this.state === "submit" || this.state === "cancel") return result;
+		const normalized = result.replace(/\r\n/g, "\n");
+		if (!normalized) return "\n";
+		if (normalized.endsWith("\n")) return result;
+		return result + "\n";
+	};
+}
+
+//#endregion
+//#region ../prompt/src/prompts/toolbar/Toolbar.ts
+var Toolbar = class {
+	_isOpen = false;
+	cursor = 0;
+	previous;
+	theme;
+	actions;
+	secret;
+	constructor(config) {
+		this.previous = config.previous;
+		this.secret = config.secret;
+		this.theme = config.theme;
+		this.actions = config.actions;
+	}
+	get isOpen() {
+		return this._isOpen;
+	}
+	open() {
+		this._isOpen = true;
+		this.cursor = 0;
+	}
+	close() {
+		this._isOpen = false;
+		this.cursor = 0;
+	}
+	handleKey(char, info) {
+		if (!info) return false;
+		if (info.name === "tab") {
+			if (!this._isOpen) this.open();
+			else this.close();
+			return true;
+		}
+		if (!this._isOpen) return false;
+		switch (info.name) {
+			case "left":
+			case "up":
+				this.shiftCursor(-1);
+				return true;
+			case "right":
+			case "down":
+				this.shiftCursor(1);
+				return true;
+			case "return":
+			case "enter":
+				this.activateOption();
+				return true;
+		}
+		if (char && char.length === 1 && !info.ctrl && !info.meta) {
+			this.close();
+			return false;
+		}
+		return false;
+	}
+	render() {
+		if (!this._isOpen) return "";
+		const options = this.getOptions();
+		this.ensureCursor(options);
+		if (!options.length) return this.theme.subtle("Tab to return");
+		const separator = this.theme.subtle(" / ");
+		return `${options.map((option, index) => {
+			const isFocused = index === this.cursor;
+			const label = `${isFocused ? S_TOOL_ACTIVE : S_TOOL_INACTIVE} ${option.label}`;
+			return isFocused ? this.theme.primary(label) : this.theme.subtle(label);
+		}).join(separator)}${separator}${this.theme.subtle("Tab to return")}`;
+	}
+	shiftCursor(delta) {
+		const options = this.getOptions();
+		if (!options.length) return;
+		let nextIndex = this.cursor;
+		const len = options.length;
+		for (let step = 0; step < len; step++) {
+			nextIndex = (nextIndex + delta + len) % len;
+			this.cursor = nextIndex;
+			return;
+		}
+	}
+	activateOption() {
+		const options = this.getOptions();
+		this.ensureCursor(options);
+		const selected = options[this.cursor];
+		if (!selected) return;
+		this.close();
+		selected.action();
+	}
+	ensureCursor(options) {
+		if (!options.length) {
+			this.cursor = 0;
+			return;
+		}
+		if (this.cursor >= options.length) this.cursor = 0;
+	}
+	getOptions() {
+		const options = [{
+			key: "skip",
+			label: "Skip",
+			action: this.actions.skip
+		}];
+		if (this.previous) options.push({
+			key: "previous",
+			label: "Previous",
+			action: this.actions.previous
+		});
+		if (this.secret !== false) options.push({
+			key: "toggleSecret",
+			label: this.secret === "shown" ? "Hide" : "Show",
+			action: this.actions.toggleSecret
+		});
+		return options;
+	}
+};
+
+//#endregion
+//#region ../prompt/src/prompts/state/EnvPromptModeDetails.ts
+/**
+* Creates initial mode details for a prompt
+*/
+function createInitialModeDetails(options) {
+	return {
+		mode: options.hasOptions ? "selection" : "typing",
+		intention: "commit",
+		secretVisibility: options.hasSecret ? "hidden" : "not-secret",
+		validation: "pending",
+		cursor: 0,
+		inputValue: options.initialInputValue || "",
+		toolbarOpen: false,
+		consumeSubmit: false
+	};
+}
+/**
+* Computes derived state from the core mode details
+*/
+function computeState(modeDetails) {
+	return {
+		canSubmit: modeDetails.intention === "commit" && modeDetails.validation !== "invalid",
+		shouldTrackInput: modeDetails.mode === "typing",
+		shouldDimUI: modeDetails.toolbarOpen,
+		shouldConsumeSubmit: modeDetails.consumeSubmit,
+		shouldSkipValidation: modeDetails.validation === "suppressed"
+	};
+}
+/**
+* Creates complete state by combining mode details and computed properties
+*/
+function createState(modeDetails) {
+	return {
+		...modeDetails,
+		...computeState(modeDetails)
+	};
+}
+
+//#endregion
+//#region ../prompt/src/prompts/state/EnvPromptMode.ts
+/**
+* Encapsulates the prompt's interaction mode state and transitions.
+*/
+var EnvPromptMode = class {
+	_details;
+	_listeners = [];
+	constructor(initialModeDetails) {
+		this._details = { ...initialModeDetails };
+	}
+	get intention() {
+		return this._details.intention;
+	}
+	set intention(intention) {
+		this.updateModeDetails({ intention });
+	}
+	/**
+	* Complete computed state for observers.
+	*/
+	get state() {
+		return createState(this._details);
+	}
+	/**
+	* Snapshot of the raw mode details (without computed props).
+	*/
+	get modeDetails() {
+		return { ...this._details };
+	}
+	subscribe(listener) {
+		this._listeners.push(listener);
+		return () => {
+			const index = this._listeners.indexOf(listener);
+			if (index >= 0) this._listeners.splice(index, 1);
+		};
+	}
+	notifyListeners() {
+		const snapshot = this.state;
+		this._listeners.forEach((listener) => listener(snapshot));
+	}
+	updateModeDetails(updates) {
+		this._details = {
+			...this._details,
+			...updates
+		};
+		this.notifyListeners();
+	}
+	enterTyping(inputValue = "") {
+		if (this._details.mode === "selection") this.updateModeDetails({
+			mode: "typing",
+			inputValue,
+			validation: "pending"
+		});
+	}
+	exitTyping() {
+		if (this._details.mode === "typing") this.updateModeDetails({
+			mode: "selection",
+			inputValue: "",
+			validation: "pending"
+		});
+	}
+	openToolbar() {
+		this.updateModeDetails({ toolbarOpen: true });
+	}
+	closeToolbar() {
+		this.updateModeDetails({ toolbarOpen: false });
+	}
+	moveCursor(direction, maxIndex) {
+		if (this._details.mode === "selection" && !this._details.toolbarOpen) {
+			const delta = direction === "up" ? -1 : 1;
+			let cursor = this._details.cursor + delta;
+			if (cursor < 0) cursor = maxIndex;
+			else if (cursor > maxIndex) cursor = 0;
+			this.updateModeDetails({
+				cursor,
+				validation: "pending"
+			});
+		}
+	}
+	setCursor(position) {
+		if (this._details.mode === "selection") this.updateModeDetails({
+			cursor: position,
+			validation: "pending"
+		});
+	}
+	setIntention(intention) {
+		this.intention = intention;
+	}
+	toggleSecretVisibility() {
+		if (this._details.secretVisibility !== "not-secret") {
+			const next = this._details.secretVisibility === "hidden" ? "revealed" : "hidden";
+			this.updateModeDetails({
+				secretVisibility: next,
+				validation: "suppressed",
+				consumeSubmit: true
+			});
+		}
+	}
+	resetSecretVisibility() {
+		if (this._details.secretVisibility === "revealed") this.updateModeDetails({ secretVisibility: "hidden" });
+	}
+	setValidationState(validation) {
+		this.updateModeDetails({ validation });
+	}
+	suppressValidation() {
+		this.updateModeDetails({
+			validation: "suppressed",
+			consumeSubmit: true
+		});
+	}
+	restoreValidation() {
+		if (this._details.validation === "suppressed") this.updateModeDetails({ validation: "pending" });
+	}
+	clearConsumeSubmit() {
+		if (this._details.consumeSubmit) this.updateModeDetails({ consumeSubmit: false });
+	}
+	updateInput(value) {
+		if (this._details.mode === "typing") this.updateModeDetails({
+			inputValue: value,
+			validation: "pending"
+		});
+	}
+	clearInput() {
+		this.updateModeDetails({
+			inputValue: "",
+			validation: "pending"
+		});
+	}
+	isInInteraction(kind) {
+		return this._details.mode === kind;
+	}
+	canTransitionToInteraction(kind) {
+		switch (kind) {
+			case "typing": return this._details.mode === "selection" && !this._details.toolbarOpen;
+			case "selection": return this._details.mode === "typing";
+			case "toolbar": return !this._details.toolbarOpen;
+			default: return false;
+		}
+	}
+	shouldPreventSubmission() {
+		const snapshot = this.state;
+		return !snapshot.canSubmit || snapshot.shouldConsumeSubmit;
+	}
+	isToolbarOpen() {
+		return this._details.toolbarOpen;
+	}
+	isSecretRevealed() {
+		return this._details.secretVisibility === "revealed";
+	}
+	hasSecret() {
+		return this._details.secretVisibility !== "not-secret";
+	}
+	getCursor() {
+		return this._details.cursor;
+	}
+	getInputValue() {
+		return this._details.inputValue;
+	}
+	getIntention() {
+		return this.intention;
+	}
+};
+
+//#endregion
+//#region ../prompt/src/prompts/processing/processValue.ts
+/**
+* Process a value through schema validation and return detailed results
+*/
+function processValue(envKey, value, schema, preprocess) {
+	try {
+		if (!value || value.trim() === "") return {
+			value: void 0,
+			rawValue: value,
+			isValid: true
+		};
+		const activePreprocessor = (() => {
+			if (preprocess === false) return;
+			if (preprocess === true) return resolvePreprocessor(schema.type, { [schema.type]: true });
+			if (typeof preprocess === "function") return preprocess;
+			return resolvePreprocessor(schema.type);
+		})();
+		const processedValue = activePreprocessor ? activePreprocessor(value) : value;
+		if (schema.type === "boolean" && typeof processedValue === "boolean") return {
+			value: processedValue,
+			rawValue: value,
+			isValid: true
+		};
+		if (schema.type === "number" && typeof processedValue === "number") return {
+			value: processedValue,
+			rawValue: value,
+			isValid: true
+		};
+		if (typeof processedValue === "string") return {
+			value: schema.process(processedValue),
+			rawValue: value,
+			isValid: true
+		};
+		return {
+			value: schema.process(value),
+			rawValue: value,
+			isValid: true
+		};
+	} catch (error) {
+		return {
+			value: void 0,
+			rawValue: value,
+			isValid: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+
+//#endregion
+//#region ../prompt/src/prompts/EnvPrompt.ts
+var EnvPrompt = class extends ThemedPrompt {
+	/** Schema describing the environment variable. */
+	schema;
+	/** Flag indicating whether the variable must be provided. */
+	required;
+	/** Environment variable key, e.g. `NODE_ENV`. */
+	key;
+	/** Optional preprocessing applied before schema validation. */
+	preprocess;
+	/** Raw string value read from the environment. */
+	rawCurrent;
+	/** Result of preprocessing/validation for the raw current value. */
+	currentResult;
+	/** Latest committed value for this prompt, if any. */
+	current;
+	/** Fallback value supplied by the schema. */
+	default;
+	/** Maximum number of characters to display before truncation. */
+	truncate;
+	/** Zero-based index of this prompt in the session. */
+	index;
+	/** Total number of prompts in the session. */
+	total;
+	/** Indicates whether the value should be treated as secret. */
+	secret;
+	/** Internal helpers for managing clack prompt behavior. */
+	internals;
+	/** Toolbar instance controlling auxiliary actions. */
+	toolbar;
+	/** State machine managing prompt interaction modes. */
+	mode;
+	constructor(schema, opts) {
+		const { pad = true,...promptOpts } = opts;
+		const promptOptions = {
+			...promptOpts,
+			default: schema.default,
+			render: pad ? padActiveRender(promptOpts.render) : promptOpts.render
+		};
+		super(promptOptions);
+		this.schema = schema;
+		this.internals = new ClackPromptInternals(this);
+		this.required = schema.required;
+		this.internals.track = false;
+		this.key = promptOptions.key;
+		this.preprocess = promptOptions.preprocess;
+		this.rawCurrent = promptOptions.current;
+		if (this.rawCurrent !== void 0) {
+			const result = processValue(this.key, this.rawCurrent, this.schema, this.preprocess ?? void 0);
+			this.currentResult = result;
+			this.current = result.isValid ? result.value : void 0;
+		} else {
+			this.currentResult = void 0;
+			this.current = void 0;
+		}
+		this.default = schema.default;
+		this.truncate = promptOptions.truncate ?? 40;
+		this.index = promptOptions.index ?? 0;
+		this.total = promptOptions.total ?? 1;
+		const hasSecret = Boolean(promptOptions.secret);
+		const hasOptions = this.rawCurrent !== void 0 || this.default !== void 0;
+		this.secret = hasSecret;
+		this.mode = new EnvPromptMode(createInitialModeDetails({
+			hasSecret,
+			hasOptions,
+			initialInputValue: ""
+		}));
+		this.mode.subscribe((state) => {
+			this.internals.track = state.shouldTrackInput;
+			if (this.mode.hasSecret()) this.toolbar.secret = state.secretVisibility === "revealed" ? "shown" : "hidden";
+		});
+		this.toolbar = new Toolbar({
+			previous: this.index > 0,
+			secret: hasSecret ? this.mode.isSecretRevealed() ? "shown" : "hidden" : false,
+			theme: this.theme,
+			actions: {
+				toggleSecret: () => this.handleToggleSecret(),
+				skip: () => this.handleSkip(),
+				previous: () => this.handlePrevious()
+			}
+		});
+		this.on("finalize", () => {
+			const shouldConsumeSubmit = this.mode.state.shouldConsumeSubmit;
+			if (!shouldConsumeSubmit) this.mode.resetSecretVisibility();
+			this.toolbar.close();
+			if (shouldConsumeSubmit) {
+				this.state = "active";
+				this.error = "";
+				this.mode.restoreValidation();
+				this.mode.clearConsumeSubmit();
+				this.mode.intention = "commit";
+			}
+		});
+	}
+	runSchemaValidation(value) {
+		if (!value || value.trim() === "") return {
+			success: true,
+			value: void 0
+		};
+		const result = processValue(this.key, value, this.schema, this.preprocess ?? void 0);
+		if (result.isValid) return {
+			success: true,
+			value: result.value
+		};
+		return {
+			success: false,
+			error: result.error ?? "Invalid value"
+		};
+	}
+	setCommittedValue(value) {
+		this.mode.intention = "commit";
+		this.value = value;
+	}
+	getOutcome() {
+		return this.mode.intention;
+	}
+	buildSkipHint(base) {
+		const skipLower = "tab for options";
+		const skipCapitalized = "Tab for options";
+		if (base && base.trim().length > 0) return `${base} or ${skipLower}`;
+		return skipCapitalized;
+	}
+	renderFooter(baseHint) {
+		const errorFooter = this.renderFooterError();
+		if (errorFooter) return errorFooter;
+		const toolbarFooter = this.renderFooterToolbar();
+		if (toolbarFooter) return toolbarFooter;
+		return this.renderFooterHint(baseHint);
+	}
+	renderFooterError() {
+		if (!this.error) return;
+		return this.colors.warn(this.error);
+	}
+	renderFooterToolbar() {
+		if (this.mode.hasSecret()) this.toolbar.secret = this.mode.isSecretRevealed() ? "shown" : "hidden";
+		const toolbarOutput = this.toolbar.render();
+		if (!toolbarOutput) return;
+		return toolbarOutput;
+	}
+	renderFooterHint(baseHint) {
+		const hint = this.buildSkipHint(baseHint);
+		return this.colors.subtle(hint);
+	}
+	getFooterState() {
+		if (this.error) return "warn";
+		if (this.mode.isToolbarOpen()) return "tools";
+		return "hint";
+	}
+	handleToolbarKey(char, info) {
+		const handled = this.toolbar.handleKey(char, info);
+		if (handled && info?.name === "tab") {
+			if (this.toolbar.isOpen) this.mode.openToolbar();
+			else this.mode.closeToolbar();
+			return true;
+		}
+		if (handled && (info?.name === "return" || info?.name === "enter")) {
+			if (this.toolbar.isOpen) this.mode.suppressValidation();
+			if (!this.toolbar.isOpen && this.mode.isToolbarOpen()) this.mode.closeToolbar();
+			return true;
+		}
+		if (handled && info?.name === "escape") {
+			this.mode.closeToolbar();
+			return true;
+		}
+		if (handled && info?.name === "backspace") {
+			this.mode.closeToolbar();
+			return false;
+		}
+		if (handled && char && char.length === 1 && !info?.ctrl && !info?.meta) {
+			this.mode.closeToolbar();
+			return false;
+		}
+		if (handled && !this.toolbar.isOpen && this.mode.isToolbarOpen()) this.mode.closeToolbar();
+		return handled;
+	}
+	truncateValue(value) {
+		if (value.length <= this.truncate) return value;
+		return `${value.substring(0, this.truncate)}...`;
+	}
+	renderSkipped() {
+		return `${this.colors.dim(this.theme.primary(S_STEP_SKIP))}  ${this.colors.subtle(this.colors.bold(this.key))}`;
+	}
+	renderPrevious() {
+		return `${this.colors.dim(this.theme.primary(S_STEP_PREVIOUS))}  ${this.colors.subtle(this.colors.bold(this.key))}`;
+	}
+	renderOutcomeResult() {
+		const intention = this.mode.intention;
+		if (intention === "skip") return this.renderSkipped();
+		if (intention === "previous") return this.renderPrevious();
+	}
+	renderCancelled() {
+		return `${this.theme.error(S_STEP_CANCEL)}  ${this.colors.subtle(this.colors.bold(this.key))}`;
+	}
+	toggleSecretReveal() {
+		if (!this.mode.hasSecret()) return;
+		this.mode.toggleSecretVisibility();
+		if (this.mode.hasSecret()) this.toolbar.secret = this.mode.isSecretRevealed() ? "shown" : "hidden";
+	}
+	resetSecretReveal() {
+		if (!this.mode.hasSecret()) return;
+		this.mode.resetSecretVisibility();
+	}
+	isSecretRevealed() {
+		return this.mode.isSecretRevealed();
+	}
+	handleToggleSecret() {
+		this.toggleSecretReveal();
+	}
+	handleSkip() {
+		this.mode.intention = "skip";
+		this.value = void 0;
+		this.state = "submit";
+	}
+	handlePrevious() {
+		this.mode.intention = "previous";
+		this.value = void 0;
+		this.state = "submit";
+	}
+	consumeSkipValidation() {
+		if (this.mode.state.shouldSkipValidation) {
+			this.mode.restoreValidation();
+			return true;
+		}
+		return false;
+	}
+	getAnnotationLabel(value) {
+		const matchesCurrent = Boolean(this.currentResult?.isValid) && this.current === value;
+		const matchesDefault = this.default === value;
+		return this.buildAnnotation({
+			isCurrent: matchesCurrent,
+			isDefault: matchesDefault
+		});
+	}
+	/**
+	* Clears any active validation error so the prompt can return to the default hint state.
+	*/
+	clearErrorState() {
+		if (this.state === "error" || this.error) {
+			this.state = "active";
+			this.error = "";
+			this.mode.restoreValidation();
+			this.mode.clearConsumeSubmit();
+		}
+	}
+	buildAnnotation(flags) {
+		const labels = [];
+		if (flags.isCurrent) labels.push("current");
+		if (flags.isDefault) labels.push("default");
+		if (flags.invalid) labels.push("invalid");
+		return labels.length > 0 ? labels.join(", ") : void 0;
+	}
+};
+
+//#endregion
+//#region ../prompt/src/prompts/utils/selectableOptions.ts
+function buildSelectableOptions(params) {
+	const invalidOptionKey = params.invalidOptionKey ?? "invalid";
+	const baseOptions = params.baseOptions.map((option) => ({ ...option }));
+	const currentRaw = params.currentResult?.rawValue;
+	if (!(currentRaw !== void 0 && params.currentResult?.isValid === false)) return baseOptions;
+	return [{
+		key: invalidOptionKey,
+		value: void 0,
+		display: params.formatInvalidDisplay(currentRaw),
+		annotation: params.buildAnnotation({
+			isCurrent: true,
+			invalid: true
+		}) ?? void 0,
+		invalid: true
+	}, ...baseOptions];
+}
+function resolveInitialCursor(options, params) {
+	if (!options.length) return 0;
+	const equals = params.isEqual ?? ((left, right) => left === right);
+	const findIndexForValue = (value) => {
+		if (value === void 0) return -1;
+		return options.findIndex((option) => !option.invalid && equals(option.value, value));
+	};
+	const currentIndex = findIndexForValue(params.currentValue);
+	if (currentIndex >= 0) return currentIndex;
+	const defaultIndex = findIndexForValue(params.defaultValue);
+	if (defaultIndex >= 0) return defaultIndex;
+	const firstValid = options.findIndex((option) => !option.invalid);
+	return firstValid >= 0 ? firstValid : 0;
+}
+function getOptionAtCursor(options, cursor) {
+	if (!options.length) return {
+		option: void 0,
+		index: 0
+	};
+	const index = Math.max(0, Math.min(cursor, options.length - 1));
+	return {
+		option: options[index],
+		index
+	};
+}
+
+//#endregion
+//#region ../prompt/src/prompts/typed/EnvBooleanPrompt.ts
+var EnvBooleanPrompt = class extends EnvPrompt {
+	cursor;
+	constructor(schema, opts) {
+		super(schema, {
+			...opts,
+			render: function() {
+				if (this.state === "submit") {
+					const outcomeResult = this.renderOutcomeResult();
+					if (outcomeResult) return outcomeResult;
+					const valueStr = this.value ? "true" : "false";
+					return `${this.getSymbol()}  ${this.colors.bold(this.colors.white(this.key))}${this.colors.subtle("=")}${this.colors.white(this.truncateValue(valueStr))}`;
+				}
+				if (this.state === "cancel") return this.renderCancelled();
+				let output = "";
+				output += `${this.getSymbol()}  ${this.colors.bold(this.colors.white(this.key))}`;
+				if (this.schema.description) output += ` ${this.colors.subtle(this.schema.description)}`;
+				output += "\n";
+				const options$1 = this.buildOptions();
+				const dimInputs = !this.error && this.mode.isToolbarOpen();
+				options$1.forEach((option, index) => {
+					const isSelected = index === this.cursor;
+					const circle = dimInputs ? this.colors.dim(isSelected ? S_RADIO_ACTIVE : S_RADIO_INACTIVE) : isSelected ? this.theme.primary(S_RADIO_ACTIVE) : this.colors.dim(S_RADIO_INACTIVE);
+					const formatText = (value) => {
+						if (dimInputs) return this.colors.dim(value);
+						if (isSelected) return this.colors.white(value);
+						return this.colors.subtle(value);
+					};
+					let text = formatText(option.display);
+					if (option.invalid) text = `\u001b[9m${text}\u001b[29m`;
+					const annotation = option.annotation ? ` (${option.annotation})` : "";
+					let suffix = "";
+					if (annotation && isSelected) suffix = dimInputs ? this.colors.dim(annotation) : this.colors.subtle(annotation);
+					output += `${this.getBar()}  ${circle} ${text}${suffix}\n`;
+				});
+				output += `${this.getBarEnd()}  ${this.renderFooter()}`;
+				return output;
+			},
+			validate: (_value) => {
+				if (this.consumeSkipValidation()) return;
+				if (this.getOutcome() !== "commit") return;
+				const selectedOption = this.getSelectedOption();
+				if (selectedOption?.invalid) return this.currentResult?.error ?? "Current value is invalid";
+				const candidateValue = selectedOption && selectedOption.value !== void 0 ? selectedOption.value : this.default ?? false;
+				const validation = this.runSchemaValidation(candidateValue.toString());
+				if (!validation.success) return validation.error;
+			}
+		});
+		const options = this.buildOptions();
+		this.cursor = this.getInitialCursor(options);
+		this.updateValue();
+		this.on("cursor", (action) => {
+			this.clearErrorState();
+			if (!this.error && this.mode.isToolbarOpen()) return;
+			const options$1 = this.buildOptions();
+			if (!options$1.length) return;
+			const lastIndex = options$1.length - 1;
+			switch (action) {
+				case "up":
+					this.cursor = this.cursor === 0 ? lastIndex : this.cursor - 1;
+					break;
+				case "down":
+					this.cursor = this.cursor >= lastIndex ? 0 : this.cursor + 1;
+					break;
+				default:
+					if (this.cursor > lastIndex) this.cursor = lastIndex;
+					if (this.cursor < 0) this.cursor = 0;
+					break;
+			}
+			this.updateValue();
+		});
+		this.on("key", (char, info) => {
+			if (!info) return;
+			this.clearErrorState();
+			if (this.handleToolbarKey(char, info)) return;
+			if (!this.error && this.mode.isToolbarOpen()) return;
+		});
+	}
+	updateValue() {
+		const selected = this.getSelectedOption();
+		if (!selected || selected.invalid) {
+			this.setCommittedValue(this.default ?? false);
+			return;
+		}
+		this.setCommittedValue(selected.value ?? this.default ?? false);
+	}
+	buildOptions() {
+		return buildSelectableOptions({
+			currentResult: this.currentResult,
+			formatInvalidDisplay: (raw) => this.truncateValue(raw ?? ""),
+			buildAnnotation: (flags) => this.buildAnnotation(flags) ?? void 0,
+			baseOptions: [{
+				key: "true",
+				value: true,
+				display: "true",
+				annotation: this.getAnnotationLabel(true) ?? void 0
+			}, {
+				key: "false",
+				value: false,
+				display: "false",
+				annotation: this.getAnnotationLabel(false) ?? void 0
+			}]
+		});
+	}
+	getInitialCursor(options) {
+		return resolveInitialCursor(options, {
+			currentValue: this.currentResult?.isValid !== false ? this.current : void 0,
+			defaultValue: this.default
+		});
+	}
+	getSelectedOption() {
+		const { option, index } = getOptionAtCursor(this.buildOptions(), this.cursor);
+		if (index !== this.cursor) this.cursor = index;
+		return option;
+	}
+};
+
+//#endregion
+//#region ../prompt/src/prompts/typed/EnvEnumPrompt.ts
+var EnvEnumPrompt = class extends EnvPrompt {
+	cursor = 0;
+	options;
+	values;
+	constructor(schema, opts) {
+		super(schema, {
+			...opts,
+			render: function() {
+				if (this.state === "submit") {
+					const outcomeResult = this.renderOutcomeResult();
+					if (outcomeResult) return outcomeResult;
+					return `${this.getSymbol()}  ${this.colors.bold(this.colors.white(this.key))}${this.colors.subtle("=")}${this.colors.white(this.truncateValue(this.value ?? ""))}`;
+				}
+				if (this.state === "cancel") return this.renderCancelled();
+				let output = "";
+				output += `${this.getSymbol()}  ${this.colors.bold(this.colors.white(this.key))}`;
+				if (this.schema.description) output += ` ${this.colors.subtle(this.schema.description)}`;
+				output += "\n";
+				const options$1 = this.buildOptions();
+				const dimInputs = !this.error && this.mode.isToolbarOpen();
+				options$1.forEach((option, index) => {
+					const isSelected = index === this.cursor;
+					const circle = dimInputs ? this.colors.dim(isSelected ? S_RADIO_ACTIVE : S_RADIO_INACTIVE) : isSelected ? this.theme.primary(S_RADIO_ACTIVE) : this.colors.dim(S_RADIO_INACTIVE);
+					const formatText = (value) => {
+						if (dimInputs) return this.colors.dim(value);
+						if (isSelected) return this.colors.white(value);
+						return this.colors.subtle(value);
+					};
+					let text = formatText(option.display);
+					if (option.invalid) text = `\u001b[9m${text}\u001b[29m`;
+					const annotation = option.annotation ? ` (${option.annotation})` : "";
+					let suffix = "";
+					if (annotation && isSelected) suffix = dimInputs ? this.colors.dim(annotation) : this.colors.subtle(annotation);
+					output += `${this.getBar()}  ${circle} ${text}${suffix}\n`;
+				});
+				output += `${this.getBarEnd()}  ${this.renderFooter()}`;
+				return output;
+			},
+			validate: () => {
+				if (this.consumeSkipValidation()) return;
+				if (this.getOutcome() !== "commit") return;
+				const selectedOption = this.getSelectedOption();
+				if (!selectedOption) return;
+				if (selectedOption.invalid) return this.currentResult?.error ?? "Current value is invalid";
+				const candidateValue = selectedOption.value ?? this.default ?? this.values[0];
+				if (candidateValue === void 0) return;
+				const validation = this.runSchemaValidation(candidateValue);
+				if (!validation.success) return validation.error;
+			}
+		});
+		this.options = opts;
+		this.values = [...schema.values];
+		const options = this.buildOptions();
+		this.cursor = this.getInitialCursor(options);
+		this.updateValue();
+		this.on("cursor", (action) => {
+			this.clearErrorState();
+			if (!this.error && this.mode.isToolbarOpen()) return;
+			const options$1 = this.buildOptions();
+			if (!options$1.length) return;
+			const lastIndex = options$1.length - 1;
+			switch (action) {
+				case "up":
+					this.cursor = this.cursor === 0 ? lastIndex : this.cursor - 1;
+					break;
+				case "down":
+					this.cursor = this.cursor >= lastIndex ? 0 : this.cursor + 1;
+					break;
+				default:
+					if (this.cursor > lastIndex) this.cursor = lastIndex;
+					if (this.cursor < 0) this.cursor = 0;
+					break;
+			}
+			this.updateValue();
+		});
+		this.on("key", (char, info) => {
+			if (!info) return;
+			this.clearErrorState();
+			if (this.handleToolbarKey(char, info)) return;
+			if (!this.error && this.mode.isToolbarOpen()) return;
+		});
+	}
+	updateValue() {
+		const selected = this.getSelectedOption();
+		if (!selected) {
+			this.setCommittedValue(this.default ?? this.values[0]);
+			return;
+		}
+		if (selected.invalid) {
+			const fallback$1 = this.default ?? this.values[0];
+			this.setCommittedValue(fallback$1);
+			return;
+		}
+		const fallback = this.default ?? this.values[0];
+		this.setCommittedValue(selected.value ?? fallback);
+	}
+	buildOptions() {
+		return buildSelectableOptions({
+			currentResult: this.currentResult,
+			formatInvalidDisplay: (raw) => this.truncateValue(raw ?? ""),
+			buildAnnotation: (flags) => this.buildAnnotation(flags) ?? void 0,
+			baseOptions: this.values.map((value) => ({
+				key: value,
+				value,
+				display: this.truncateValue(value),
+				annotation: this.getAnnotationLabel(value) ?? void 0
+			}))
+		});
+	}
+	getInitialCursor(options) {
+		return resolveInitialCursor(options, {
+			currentValue: this.currentResult?.isValid !== false ? this.current : void 0,
+			defaultValue: this.default
+		});
+	}
+	getSelectedOption() {
+		const { option, index } = getOptionAtCursor(this.buildOptions(), this.cursor);
+		if (index !== this.cursor) this.cursor = index;
+		return option;
+	}
+};
+
+//#endregion
+//#region ../prompt/src/prompts/typed/EnvNumberPrompt.ts
+var EnvNumberPrompt = class extends EnvPrompt {
+	otherInputCache = "";
+	shouldStitchInput = false;
+	isRestoringInput = false;
+	constructor(schema, opts) {
+		super(schema, {
+			...opts,
+			render: function() {
+				if (this.state === "submit") {
+					const outcomeResult = this.renderOutcomeResult();
+					if (outcomeResult) return outcomeResult;
+					return `${this.getSymbol()}  ${this.colors.bold(this.colors.white(this.key))}${this.colors.subtle("=")}${this.colors.white(this.formatValue(this.value))}`;
+				}
+				if (this.state === "cancel") return this.renderCancelled();
+				let output = "";
+				output += `${this.getSymbol()}  ${this.colors.bold(this.colors.white(this.key))}`;
+				if (this.schema.description) output += ` ${this.colors.subtle(this.schema.description)}`;
+				output += "\n";
+				const dimInputs = !this.error && this.mode.isToolbarOpen();
+				if (!this.hasPresetOptions()) {
+					if (this.mode.isInInteraction("typing")) {
+						const displayText = dimInputs ? this.colors.dim(this.getInputDisplay(false)) : this.colors.white(this.getInputDisplay(true));
+						output += `${this.getBar()}  ${displayText}`;
+					} else {
+						const idleDisplay = dimInputs ? this.colors.dim(this.getInputDisplay(false)) : this.colors.white(this.getInputDisplay(true));
+						output += `${this.getBar()}  ${idleDisplay}`;
+					}
+					output += "\n";
+					output += `${this.getBarEnd()}  ${this.renderFooter("Enter a number")}`;
+					return output;
+				}
+				this.buildSelectionOptions().forEach((option, index) => {
+					const isSelected = index === this.mode.getCursor();
+					const circle = dimInputs ? this.colors.dim(isSelected ? S_RADIO_ACTIVE : S_RADIO_INACTIVE) : isSelected ? this.theme.primary(S_RADIO_ACTIVE) : this.colors.dim(S_RADIO_INACTIVE);
+					if (option.type === "other") {
+						if (this.mode.isInInteraction("typing")) {
+							const displayText = dimInputs ? this.colors.dim(this.getInputDisplay(false)) : this.colors.white(this.getInputDisplay(true));
+							output += `${this.getBar()}  ${circle} ${displayText}\n`;
+						} else if (isSelected) if (dimInputs) output += `${this.getBar()}  ${circle} ${this.colors.dim(option.label)}\n`;
+						else output += `${this.getBar()}  ${circle} ${this.colors.white(this.getInputDisplay(true))}\n`;
+						else {
+							const text$1 = dimInputs ? this.colors.dim(option.label) : this.colors.subtle(option.label);
+							output += `${this.getBar()}  ${circle} ${text$1}\n`;
+						}
+						return;
+					}
+					const formatText = (value) => {
+						if (dimInputs) return this.colors.dim(value);
+						if (isSelected) return this.colors.white(value);
+						return this.colors.subtle(value);
+					};
+					let text = formatText(option.display);
+					if (option.invalid) text = `\u001b[9m${text}\u001b[29m`;
+					const annotation = option.annotation ? ` (${option.annotation})` : "";
+					let suffix = "";
+					if (annotation && isSelected) suffix = dimInputs ? this.colors.dim(annotation) : this.colors.subtle(annotation);
+					output += `${this.getBar()}  ${circle} ${text}${suffix}\n`;
+				});
+				output += `${this.getBarEnd()}  ${this.renderFooter("Enter a number")}`;
+				return output;
+			},
+			validate: (_value) => {
+				if (this.consumeSkipValidation()) return;
+				if (this.getOutcome() !== "commit") return;
+				if (!this.hasPresetOptions()) {
+					if (!this.userInput || !this.userInput.trim()) return "Please enter a number";
+					const validation = this.runSchemaValidation(this.userInput);
+					if (!validation.success) return validation.error;
+					return;
+				}
+				const selectedOption = this.getSelectedOption();
+				if (!this.mode.isInInteraction("typing") && selectedOption && selectedOption.type === "value" && selectedOption.key === "current" && selectedOption.invalid) return this.currentResult?.error ?? "Current value is invalid";
+				const textInputIndex = this.getTextInputIndex();
+				if (this.mode.getCursor() === textInputIndex && !this.mode.isInInteraction("typing")) {
+					this.mode.enterTyping();
+					this.mode.clearInput();
+					this._setUserInput("");
+					this.otherInputCache = "";
+					this.updateValue();
+					return "Please enter a number";
+				}
+				if (this.mode.getCursor() === textInputIndex && this.mode.isInInteraction("typing") && (!this.userInput || !this.userInput.trim())) return "Please enter a number";
+				if (this.mode.isInInteraction("typing") && this.userInput) {
+					const inputValidation = this.validateInput(this.userInput);
+					if (inputValidation) return inputValidation;
+					const validation = this.runSchemaValidation(this.userInput);
+					if (!validation.success) return validation.error;
+				}
+				if (!this.mode.isInInteraction("typing")) {
+					const candidate = selectedOption && selectedOption.type === "value" ? selectedOption.value : this.value;
+					const validation = this.runSchemaValidation(candidate !== void 0 ? candidate.toString() : void 0);
+					if (!validation.success) return validation.error;
+				}
+			}
+		});
+		if (!this.hasPresetOptions()) {
+			this.mode.enterTyping();
+			this.mode.clearInput();
+			this._setUserInput("");
+			this.otherInputCache = "";
+			this.setCommittedValue(this.getDefaultValue());
+		} else {
+			const options = this.buildValueOptions();
+			const currentValue = this.currentResult?.isValid !== false ? this.current : void 0;
+			const defaultValue = this.default;
+			const baseCursor = resolveInitialCursor(options, {
+				currentValue,
+				defaultValue
+			});
+			const initialCursor = options[baseCursor]?.invalid ? options.length : baseCursor;
+			this.mode.setCursor(initialCursor);
+			this.updateValue();
+			queueMicrotask(() => {
+				const refreshedOptions = this.buildValueOptions();
+				const refreshedBase = resolveInitialCursor(refreshedOptions, {
+					currentValue,
+					defaultValue
+				});
+				const refreshedCursor = refreshedOptions[refreshedBase]?.invalid ? refreshedOptions.length : refreshedBase;
+				this.mode.setCursor(refreshedCursor);
+				this.updateValue();
+			});
+		}
+		this.on("cursor", (action) => {
+			this.clearErrorState();
+			if (!this.hasPresetOptions()) return;
+			if (!this.error && this.mode.isToolbarOpen()) return;
+			switch (action) {
+				case "up":
+					const maxIndex = this.buildSelectionOptions().length - 1;
+					if (this.mode.isInInteraction("typing") || this.mode.getCursor() === maxIndex) {
+						this.mode.exitTyping();
+						this._clearUserInput();
+						this.mode.clearInput();
+						this.otherInputCache = "";
+					}
+					this.mode.moveCursor("up", maxIndex);
+					break;
+				case "down":
+					const maxIndexDown = this.buildSelectionOptions().length - 1;
+					if (this.mode.isInInteraction("typing") || this.mode.getCursor() === maxIndexDown) {
+						this.mode.exitTyping();
+						this._clearUserInput();
+						this.mode.clearInput();
+						this.otherInputCache = "";
+					}
+					this.mode.moveCursor("down", maxIndexDown);
+					break;
+			}
+			this.updateValue();
+		});
+		this.on("userInput", (rawInput) => {
+			this.clearErrorState();
+			let input = rawInput.includes("	") ? rawInput.replace(/\t/g, "") : rawInput;
+			if (this.isRestoringInput) {
+				this.isRestoringInput = false;
+				this.otherInputCache = input;
+				return;
+			}
+			if (this.mode.isInInteraction("typing")) {
+				let nextInput = input;
+				if (this.shouldStitchInput && this.otherInputCache) if (!input || input === this.otherInputCache) nextInput = this.otherInputCache;
+				else if (input.startsWith(this.otherInputCache)) {
+					nextInput = input;
+					this.shouldStitchInput = false;
+				} else {
+					nextInput = `${this.otherInputCache}${input}`;
+					this.shouldStitchInput = false;
+				}
+				else this.shouldStitchInput = false;
+				this.mode.updateInput(nextInput);
+				this.userInput = nextInput;
+				this.otherInputCache = nextInput;
+				try {
+					const parsed = this.parseInput(nextInput);
+					this.setCommittedValue(parsed ?? this.getDefaultValue());
+				} catch {}
+			} else this.shouldStitchInput = false;
+		});
+		this.on("key", (char, info) => {
+			if (!info) return;
+			this.clearErrorState();
+			if (this.handleToolbarKey(char, info)) return;
+			if (!this.error && this.mode.isToolbarOpen()) return;
+			if (!this.hasPresetOptions()) {
+				if (this.mode.isInInteraction("typing")) try {
+					const parsed = this.parseInput(this.userInput);
+					this.setCommittedValue(parsed ?? this.getDefaultValue());
+				} catch {}
+				return;
+			}
+			if (char && char.length === 1 && !info.ctrl && !info.meta && !this.mode.isInInteraction("typing")) {
+				const isArrowKey = [
+					"up",
+					"down",
+					"left",
+					"right"
+				].includes(info.name || "");
+				const isControlKey = [
+					"return",
+					"enter",
+					"escape",
+					"tab"
+				].includes(info.name || "");
+				if (!isArrowKey && !isControlKey) {
+					const textInputIndex$1 = this.getTextInputIndex();
+					this.mode.setCursor(textInputIndex$1);
+					const existingInput = this.mode.getInputValue() || this.userInput || this.otherInputCache || "";
+					this.mode.enterTyping(existingInput);
+					const nextInput = `${existingInput}${char}`;
+					this.otherInputCache = nextInput;
+					this._setUserInput(nextInput);
+					this.mode.updateInput(nextInput);
+					this.syncCursorToInputEnd();
+					this.updateValue();
+					return;
+				}
+			}
+			const textInputIndex = this.getTextInputIndex();
+			if (this.mode.getCursor() === textInputIndex) {
+				if (info.name === "escape") {
+					this.mode.exitTyping();
+					this._clearUserInput();
+					this.mode.clearInput();
+					this.otherInputCache = "";
+					this.updateValue();
+					return;
+				}
+			}
+		});
+	}
+	getInputDisplay(includeCursor) {
+		const inputValue = this.mode.getInputValue();
+		if (!includeCursor) return inputValue;
+		const rawCursor = this.mode.isInInteraction("typing") ? Math.max(0, this._cursor ?? inputValue.length) : 0;
+		const cursorIndex = Math.min(rawCursor, inputValue.length);
+		if (cursorIndex >= inputValue.length) return `${inputValue}${S_CURSOR}`;
+		const before = inputValue.slice(0, cursorIndex);
+		const cursorChar = inputValue.charAt(cursorIndex) || " ";
+		const after = inputValue.slice(cursorIndex + 1);
+		return `${before}${this.colors.inverse(cursorChar)}${after}`;
+	}
+	syncCursorToInputEnd() {
+		const cursorHost = this;
+		cursorHost._cursor = this.mode.getInputValue().length;
+	}
+	toggleSecretReveal() {
+		const cachedInput = this.mode.getInputValue() || this.userInput || this.otherInputCache;
+		super.toggleSecretReveal();
+		if (!cachedInput) return;
+		this.shouldStitchInput = Boolean(this.otherInputCache || cachedInput);
+		const stitchedBaseline = cachedInput;
+		queueMicrotask(() => {
+			const restored = this.otherInputCache || stitchedBaseline;
+			if (!restored) return;
+			if (!this.mode.isInInteraction("typing")) this.mode.enterTyping(restored);
+			this.isRestoringInput = true;
+			this.internals.track = true;
+			this.mode.updateInput(restored);
+			this.otherInputCache = restored;
+			this._setUserInput(restored, true);
+			this.syncCursorToInputEnd();
+		});
+	}
+	updateValue() {
+		if (!this.hasPresetOptions()) {
+			try {
+				const parsed = this.parseInput(this.mode.getInputValue());
+				this.setCommittedValue(parsed ?? this.getDefaultValue());
+			} catch {
+				this.setCommittedValue(this.getDefaultValue());
+			}
+			return;
+		}
+		if (!this.mode.isInInteraction("typing")) {
+			const selected = this.buildSelectionOptions()[this.mode.getCursor()];
+			if (!selected) {
+				this.setCommittedValue(this.getDefaultValue());
+				return;
+			}
+			if (selected.type === "value") {
+				if (selected.invalid) {
+					this.setCommittedValue(this.getDefaultValue());
+					return;
+				}
+				this.setCommittedValue(selected.value ?? this.getDefaultValue());
+				return;
+			}
+			this.setCommittedValue(this.getDefaultValue());
+		} else try {
+			const parsed = this.parseInput(this.mode.getInputValue());
+			this.setCommittedValue(parsed ?? this.getDefaultValue());
+		} catch {
+			this.setCommittedValue(this.getDefaultValue());
+		}
+	}
+	formatValue(value) {
+		const str = value !== void 0 ? value.toString() : "";
+		return this.truncateValue(str);
+	}
+	parseInput(input) {
+		if (!input || !input.trim()) return;
+		const parsed = Number(input.trim());
+		if (isNaN(parsed)) return;
+		return parsed;
+	}
+	validateInput(input) {
+		if (!input || !input.trim()) return "Please enter a number";
+		const parsed = Number(input.trim());
+		if (isNaN(parsed)) return "Please enter a valid number";
+	}
+	getDefaultValue() {
+		return 0;
+	}
+	hasPresetOptions() {
+		return this.currentResult?.rawValue !== void 0 || this.default !== void 0;
+	}
+	buildValueOptions() {
+		const hasValidCurrent = this.currentResult?.isValid !== false && this.current !== void 0;
+		const baseOptions = [];
+		if (hasValidCurrent && this.current !== void 0) {
+			const isSameAsDefault = this.current === this.default;
+			baseOptions.push({
+				key: "current",
+				value: this.current,
+				display: this.formatValue(this.current),
+				annotation: this.buildAnnotation({
+					isCurrent: true,
+					isDefault: isSameAsDefault
+				}) ?? void 0
+			});
+		}
+		if (this.default !== void 0 && (!hasValidCurrent || this.current !== this.default) && this.default !== void 0) {
+			const isSameAsCurrent = hasValidCurrent && this.current === this.default;
+			baseOptions.push({
+				key: "default",
+				value: this.default,
+				display: this.formatValue(this.default),
+				annotation: this.buildAnnotation({
+					isDefault: true,
+					isCurrent: isSameAsCurrent
+				}) ?? void 0
+			});
+		}
+		return buildSelectableOptions({
+			currentResult: this.currentResult,
+			formatInvalidDisplay: (raw) => this.formatRawValue(raw ?? ""),
+			buildAnnotation: (flags) => this.buildAnnotation(flags) ?? void 0,
+			baseOptions,
+			invalidOptionKey: "current"
+		});
+	}
+	buildSelectionOptions() {
+		const options = this.buildValueOptions().map((option) => ({
+			type: "value",
+			key: option.key,
+			value: option.value,
+			display: option.display,
+			annotation: option.annotation,
+			invalid: option.invalid
+		}));
+		options.push({
+			type: "other",
+			label: "Other"
+		});
+		return options;
+	}
+	getSelectedOption() {
+		if (!this.hasPresetOptions()) return;
+		return this.buildSelectionOptions()[this.mode.getCursor()];
+	}
+	formatRawValue(raw) {
+		if (!raw) return "";
+		return this.truncateValue(raw);
+	}
+	getTextInputIndex() {
+		if (!this.hasPresetOptions()) return 0;
+		const options = this.buildSelectionOptions();
+		const index = options.findIndex((option) => option.type === "other");
+		return index === -1 ? options.length - 1 : index;
+	}
+};
+
+//#endregion
+//#region ../prompt/src/utils/secrets.ts
+function isSecretMatch(value, pattern) {
+	if (!value) return false;
+	if (typeof pattern === "string") {
+		const needle = pattern.trim().toLowerCase();
+		if (!needle) return false;
+		return value.toLowerCase().includes(needle);
+	}
+	pattern.lastIndex = 0;
+	const matched = pattern.test(value);
+	pattern.lastIndex = 0;
+	return matched;
+}
+function isSecretKey(key, description, patterns) {
+	if (patterns.length === 0) return false;
+	for (const pattern of patterns) if (isSecretMatch(key, pattern) || isSecretMatch(description, pattern)) return true;
+	return false;
+}
+function maskSecretValue(value, maskChar = SECRET_MASK) {
+	if (!value) return value;
+	return value.replace(/./g, maskChar);
+}
+function resolveShouldMask(key, schema, patterns) {
+	if (schema.type !== "string") return false;
+	if ("secret" in schema && schema.secret !== void 0) return schema.secret;
+	return isSecretKey(key, schema.description, patterns);
+}
+
+//#endregion
+//#region ../prompt/src/prompts/typed/EnvStringPrompt.ts
+var EnvStringPrompt = class extends EnvPrompt {
+	otherInputCache = "";
+	shouldStitchInput = false;
+	isRestoringInput = false;
+	constructor(schema, opts) {
+		super(schema, {
+			...opts,
+			render: function() {
+				if (this.state === "submit") {
+					const outcomeResult = this.renderOutcomeResult();
+					if (outcomeResult) return outcomeResult;
+					const base = `${this.getSymbol()}  ${this.colors.bold(this.colors.white(this.key))}`;
+					if (!this.required && (this.value === void 0 || this.value === "")) return base;
+					return `${base}${this.colors.subtle("=")}${this.colors.white(this.formatValue(this.value))}`;
+				}
+				if (this.state === "cancel") return this.renderCancelled();
+				let output = "";
+				output += `${this.getSymbol()}  ${this.colors.bold(this.colors.white(this.key))}`;
+				if (this.schema.description) output += ` ${this.colors.subtle(this.schema.description)}`;
+				output += "\n";
+				const dimInputs = !this.error && this.mode.isToolbarOpen();
+				if (!this.hasPresetOptions()) {
+					const displayText = dimInputs ? this.colors.dim(this.getInputDisplay(false)) : this.colors.white(this.getInputDisplay(true));
+					output += `${this.getBar()}  ${displayText}`;
+					output += "\n";
+					output += `${this.getBarEnd()}  ${this.renderFooter(this.getEntryHint())}`;
+					return output;
+				}
+				this.buildSelectionOptions().forEach((option, index) => {
+					const isSelected = index === this.mode.getCursor();
+					const circle = dimInputs ? this.colors.dim(isSelected ? S_RADIO_ACTIVE : S_RADIO_INACTIVE) : isSelected ? this.theme.primary(S_RADIO_ACTIVE) : this.colors.dim(S_RADIO_INACTIVE);
+					if (option.type === "other") {
+						if (this.mode.isInInteraction("typing")) {
+							const displayText = dimInputs ? this.colors.dim(this.getInputDisplay(false)) : this.colors.white(this.getInputDisplay(true));
+							output += `${this.getBar()}  ${circle} ${displayText}\n`;
+						} else if (isSelected) if (dimInputs) output += `${this.getBar()}  ${circle} ${this.colors.dim(option.label)}\n`;
+						else output += `${this.getBar()}  ${circle} ${this.colors.white(this.getInputDisplay(true))}\n`;
+						else {
+							const text$1 = dimInputs ? this.colors.dim(option.label) : this.colors.subtle(option.label);
+							output += `${this.getBar()}  ${circle} ${text$1}\n`;
+						}
+						return;
+					}
+					const formatText = (value) => {
+						if (dimInputs) return this.colors.dim(value);
+						if (isSelected) return this.colors.white(value);
+						return this.colors.subtle(value);
+					};
+					let text = formatText(option.display);
+					if (option.invalid) text = `\u001b[9m${text}\u001b[29m`;
+					const annotation = option.annotation ? ` (${option.annotation})` : "";
+					let suffix = "";
+					if (annotation && isSelected) suffix = dimInputs ? this.colors.dim(annotation) : this.colors.subtle(annotation);
+					output += `${this.getBar()}  ${circle} ${text}${suffix}\n`;
+				});
+				output += `${this.getBarEnd()}  ${this.renderFooter(this.getEntryHint())}`;
+				return output;
+			},
+			validate: (_value) => {
+				if (this.consumeSkipValidation()) return;
+				if (this.getOutcome() !== "commit") return;
+				if (!this.hasPresetOptions()) {
+					const input = this.userInput ?? "";
+					if (!input.trim()) {
+						if (this.required) return "Please enter a value";
+						return;
+					}
+					const inputValidation = this.validateInput(input);
+					if (inputValidation) return inputValidation;
+					const validation = this.runSchemaValidation(input);
+					if (!validation.success) return validation.error;
+					return;
+				}
+				const selectedOption = this.getSelectedOption();
+				if (!this.mode.isInInteraction("typing") && selectedOption && selectedOption.type === "value" && selectedOption.key === "current" && selectedOption.invalid) return this.currentResult?.error ?? "Current value is invalid";
+				const textInputIndex = this.getTextInputIndex();
+				if (this.mode.getCursor() === textInputIndex && !this.mode.isInInteraction("typing")) {
+					this.mode.enterTyping();
+					this.mode.clearInput();
+					this._setUserInput("");
+					this.otherInputCache = "";
+					this.updateValue();
+					return "Value cannot be empty";
+				}
+				if (this.mode.getCursor() === textInputIndex && this.mode.isInInteraction("typing") && !(this.userInput && this.userInput.trim())) {
+					if (this.required) return "Please enter a value";
+					return;
+				}
+				if (this.mode.isInInteraction("typing") && this.userInput) {
+					const inputValidation = this.validateInput(this.userInput);
+					if (inputValidation) return inputValidation;
+					const validation = this.runSchemaValidation(this.userInput);
+					if (!validation.success) return validation.error;
+				}
+				if (!this.mode.isInInteraction("typing")) {
+					const candidate = selectedOption && selectedOption.type === "value" ? selectedOption.value : this.value;
+					const validation = this.runSchemaValidation(candidate !== void 0 ? candidate : void 0);
+					if (!validation.success) return validation.error;
+				}
+			}
+		});
+		if (!this.hasPresetOptions()) {
+			this.mode.enterTyping();
+			this.mode.clearInput();
+			this._setUserInput("");
+			this.otherInputCache = "";
+			this.setCommittedValue(this.getDefaultValue());
+		} else {
+			const options = this.buildValueOptions();
+			const currentValue = this.currentResult?.isValid !== false ? this.current : void 0;
+			const defaultValue = this.default;
+			const baseCursor = resolveInitialCursor(options, {
+				currentValue,
+				defaultValue
+			});
+			const initialCursor = options[baseCursor]?.invalid ? options.length : baseCursor;
+			this.mode.setCursor(initialCursor);
+			this.updateValue();
+			queueMicrotask(() => {
+				const refreshedOptions = this.buildValueOptions();
+				const refreshedBase = resolveInitialCursor(refreshedOptions, {
+					currentValue,
+					defaultValue
+				});
+				const refreshedCursor = refreshedOptions[refreshedBase]?.invalid ? refreshedOptions.length : refreshedBase;
+				this.mode.setCursor(refreshedCursor);
+				this.updateValue();
+			});
+		}
+		this.on("cursor", (action) => {
+			this.clearErrorState();
+			if (!this.hasPresetOptions()) return;
+			if (!this.error && this.mode.isToolbarOpen()) return;
+			switch (action) {
+				case "up": {
+					const maxIndex = this.buildSelectionOptions().length - 1;
+					if (this.mode.isInInteraction("typing") || this.mode.getCursor() === maxIndex) {
+						this.mode.exitTyping();
+						this._clearUserInput();
+						this.mode.clearInput();
+						this.otherInputCache = "";
+					}
+					this.mode.moveCursor("up", maxIndex);
+					break;
+				}
+				case "down": {
+					const maxIndex = this.buildSelectionOptions().length - 1;
+					if (this.mode.isInInteraction("typing") || this.mode.getCursor() === maxIndex) {
+						this.mode.exitTyping();
+						this._clearUserInput();
+						this.mode.clearInput();
+						this.otherInputCache = "";
+					}
+					this.mode.moveCursor("down", maxIndex);
+					break;
+				}
+			}
+			this.updateValue();
+		});
+		this.on("userInput", (rawInput) => {
+			this.clearErrorState();
+			let input = rawInput.includes("	") ? rawInput.replace(/\t/g, "") : rawInput;
+			if (this.isRestoringInput) {
+				this.isRestoringInput = false;
+				this.otherInputCache = input;
+				return;
+			}
+			if (this.mode.isInInteraction("typing")) {
+				let nextInput = input;
+				if (this.shouldStitchInput && this.otherInputCache) if (!input || input === this.otherInputCache) nextInput = this.otherInputCache;
+				else if (input.startsWith(this.otherInputCache)) {
+					nextInput = input;
+					this.shouldStitchInput = false;
+				} else {
+					nextInput = `${this.otherInputCache}${input}`;
+					this.shouldStitchInput = false;
+				}
+				else this.shouldStitchInput = false;
+				this.mode.updateInput(nextInput);
+				this.userInput = nextInput;
+				this.otherInputCache = nextInput;
+				try {
+					const parsed = this.parseInput(nextInput);
+					this.setCommittedValue(parsed ?? this.getDefaultValue());
+				} catch {}
+			} else this.shouldStitchInput = false;
+		});
+		this.on("key", (char, info) => {
+			if (!info) return;
+			this.clearErrorState();
+			if (this.handleToolbarKey(char, info)) return;
+			if (!this.error && this.mode.isToolbarOpen()) return;
+			if (!this.hasPresetOptions()) {
+				if (this.mode.isInInteraction("typing")) try {
+					const parsed = this.parseInput(this.userInput);
+					this.setCommittedValue(parsed ?? this.getDefaultValue());
+				} catch {}
+				return;
+			}
+			if (char && char.length === 1 && !info.ctrl && !info.meta && !this.mode.isInInteraction("typing")) {
+				const isArrowKey = [
+					"up",
+					"down",
+					"left",
+					"right"
+				].includes(info.name || "");
+				const isControlKey = [
+					"return",
+					"enter",
+					"escape",
+					"tab"
+				].includes(info.name || "");
+				if (!isArrowKey && !isControlKey) {
+					const textInputIndex$1 = this.getTextInputIndex();
+					this.mode.setCursor(textInputIndex$1);
+					const existingInput = this.mode.getInputValue() || this.userInput || this.otherInputCache || "";
+					this.mode.enterTyping(existingInput);
+					const nextInput = `${existingInput}${char}`;
+					this.otherInputCache = nextInput;
+					this._setUserInput(nextInput);
+					this.mode.updateInput(nextInput);
+					this.syncCursorToInputEnd();
+					this.updateValue();
+					return;
+				}
+			}
+			const textInputIndex = this.getTextInputIndex();
+			if (this.mode.getCursor() === textInputIndex) {
+				if (info.name === "escape") {
+					this.mode.exitTyping();
+					this._clearUserInput();
+					this.mode.clearInput();
+					this.otherInputCache = "";
+					this.updateValue();
+					return;
+				}
+			}
+		});
+	}
+	get cursor() {
+		return this.mode.getCursor();
+	}
+	get isTyping() {
+		return this.mode.isInInteraction("typing");
+	}
+	updateValue() {
+		if (!this.hasPresetOptions()) {
+			try {
+				const parsed = this.parseInput(this.mode.getInputValue());
+				this.setCommittedValue(parsed ?? this.getDefaultValue());
+			} catch {
+				this.setCommittedValue(this.getDefaultValue());
+			}
+			return;
+		}
+		if (!this.mode.isInInteraction("typing")) {
+			const selected = this.buildSelectionOptions()[this.mode.getCursor()];
+			if (!selected) {
+				this.setCommittedValue(this.getDefaultValue());
+				return;
+			}
+			if (selected.type === "value") {
+				if (selected.invalid) {
+					this.setCommittedValue(this.getDefaultValue());
+					return;
+				}
+				this.setCommittedValue(selected.value ?? this.getDefaultValue());
+				return;
+			}
+			this.setCommittedValue(this.getDefaultValue());
+			return;
+		}
+		try {
+			const parsed = this.parseInput(this.mode.getInputValue());
+			this.setCommittedValue(parsed ?? this.getDefaultValue());
+		} catch {
+			this.setCommittedValue(this.getDefaultValue());
+		}
+	}
+	formatValue(value) {
+		const hasExplicitEmpty = value === "";
+		const str = value ?? "";
+		let display = this.secret && str && !this.isSecretRevealed() ? this.maskValue(str) : str;
+		if (!display && hasExplicitEmpty) display = "\"\"";
+		return this.truncateValue(display);
+	}
+	parseInput(input) {
+		return input || void 0;
+	}
+	validateInput(_input) {}
+	getDefaultValue() {
+		return "";
+	}
+	hasPresetOptions() {
+		return this.currentResult?.rawValue !== void 0 || this.default !== void 0;
+	}
+	buildValueOptions() {
+		const hasValidCurrent = this.currentResult?.isValid !== false && this.current !== void 0;
+		const baseOptions = [];
+		if (hasValidCurrent && this.current !== void 0) {
+			const isSameAsDefault = this.current === this.default;
+			baseOptions.push({
+				key: "current",
+				value: this.current,
+				display: this.formatValue(this.current),
+				annotation: this.buildAnnotation({
+					isCurrent: true,
+					isDefault: isSameAsDefault
+				}) ?? void 0
+			});
+		}
+		if (this.default !== void 0 && (!hasValidCurrent || this.current !== this.default) && this.default !== void 0) {
+			const isSameAsCurrent = hasValidCurrent && this.current === this.default;
+			baseOptions.push({
+				key: "default",
+				value: this.default,
+				display: this.formatValue(this.default),
+				annotation: this.buildAnnotation({
+					isDefault: true,
+					isCurrent: isSameAsCurrent
+				}) ?? void 0
+			});
+		}
+		return buildSelectableOptions({
+			currentResult: this.currentResult,
+			formatInvalidDisplay: (raw) => this.formatRawValue(raw ?? ""),
+			buildAnnotation: (flags) => this.buildAnnotation(flags) ?? void 0,
+			baseOptions,
+			invalidOptionKey: "current"
+		});
+	}
+	buildSelectionOptions() {
+		const options = this.buildValueOptions().map((option) => ({
+			type: "value",
+			key: option.key,
+			value: option.value,
+			display: option.display,
+			annotation: option.annotation,
+			invalid: option.invalid
+		}));
+		options.push({
+			type: "other",
+			label: "Other"
+		});
+		return options;
+	}
+	getSelectedOption() {
+		if (!this.hasPresetOptions()) return;
+		return this.buildSelectionOptions()[this.mode.getCursor()];
+	}
+	formatRawValue(raw) {
+		if (!raw) return "";
+		const display = this.secret && !this.isSecretRevealed() ? this.maskValue(raw) : raw;
+		return this.truncateValue(display);
+	}
+	maskValue(value) {
+		return maskSecretValue(value, SECRET_MASK);
+	}
+	getTextInputIndex() {
+		if (!this.hasPresetOptions()) return 0;
+		const options = this.buildSelectionOptions();
+		const index = options.findIndex((option) => option.type === "other");
+		return index === -1 ? options.length - 1 : index;
+	}
+	getInputDisplay(includeCursor) {
+		const inputValue = this.mode.getInputValue();
+		const isMasked = this.secret && inputValue && !this.isSecretRevealed();
+		const base = isMasked ? this.maskValue(inputValue) : inputValue;
+		if (!includeCursor) return base;
+		const rawCursor = this.mode.isInInteraction("typing") ? Math.max(0, this._cursor ?? inputValue.length) : 0;
+		const maskLength = isMasked ? Math.max(1, SECRET_MASK.length) : 1;
+		const cursorIndex = Math.min(rawCursor * maskLength, base.length);
+		if (cursorIndex >= base.length) return `${base}${S_CURSOR}`;
+		const segmentLength = maskLength;
+		const before = base.slice(0, cursorIndex);
+		const cursorSegment = base.slice(cursorIndex, cursorIndex + segmentLength) || " ";
+		const after = base.slice(cursorIndex + segmentLength);
+		return `${before}${this.colors.inverse(cursorSegment)}${after}`;
+	}
+	getEntryHint() {
+		return this.secret ? "Enter a secret value" : "Enter a value";
+	}
+	syncCursorToInputEnd() {
+		const cursorHost = this;
+		cursorHost._cursor = this.mode.getInputValue().length;
+	}
+	toggleSecretReveal() {
+		const cachedInput = this.mode.getInputValue() || this.userInput || this.otherInputCache;
+		super.toggleSecretReveal();
+		if (!cachedInput) return;
+		this.shouldStitchInput = Boolean(this.otherInputCache || cachedInput);
+		const stitchedBaseline = cachedInput;
+		queueMicrotask(() => {
+			const restored = this.otherInputCache || stitchedBaseline;
+			if (!restored) return;
+			if (!this.mode.isInInteraction("typing")) this.mode.enterTyping(restored);
+			this.isRestoringInput = true;
+			this.internals.track = true;
+			this.mode.updateInput(restored);
+			this.otherInputCache = restored;
+			this._setUserInput(restored, true);
+			this.syncCursorToInputEnd();
+		});
+	}
+};
+
+//#endregion
+//#region ../prompt/src/prompts/create/createPrompt.ts
+function createPrompt({ key, schema, currentValue, theme, truncate, shouldMask, index, total, input, output, preprocessors: preprocessors$1 }) {
+	const baseOptions = {
+		key,
+		theme,
+		truncate,
+		index,
+		total,
+		input,
+		output
+	};
+	switch (schema.type) {
+		case "boolean":
+			const booleanOverride = preprocessors$1?.boolean;
+			let booleanPreprocess;
+			if (booleanOverride === void 0) booleanPreprocess = void 0;
+			else if (booleanOverride === true) booleanPreprocess = booleanPreprocessor();
+			else if (booleanOverride === false) booleanPreprocess = false;
+			else if (typeof booleanOverride === "function") booleanPreprocess = booleanOverride;
+			else booleanPreprocess = booleanPreprocessor(booleanOverride);
+			return new EnvBooleanPrompt(schema, {
+				...baseOptions,
+				current: currentValue,
+				preprocess: booleanPreprocess
+			});
+		case "number": return new EnvNumberPrompt(schema, {
+			...baseOptions,
+			current: currentValue,
+			preprocess: preprocessors$1?.number
+		});
+		case "enum": return new EnvEnumPrompt(schema, {
+			...baseOptions,
+			current: currentValue,
+			preprocess: preprocessors$1?.enum
+		});
+		default: return new EnvStringPrompt(schema, {
+			...baseOptions,
+			current: currentValue,
+			secret: shouldMask,
+			preprocess: preprocessors$1?.string
+		});
+	}
+}
+
+//#endregion
+//#region ../prompt/src/utils/clearConsoleLines.ts
+function clearConsoleLines(lineCount) {
+	const output = process.stdout;
+	if (!output?.isTTY) return;
+	try {
+		for (let i = 0; i < lineCount; i++) {
+			(0, node_readline.moveCursor)(output, 0, -1);
+			(0, node_readline.cursorTo)(output, 0);
+			(0, node_readline.clearLine)(output, 0);
+		}
+		(0, node_readline.cursorTo)(output, 0);
+	} catch {}
+}
+
+//#endregion
+//#region ../prompt/src/utils/getDisplayEnvPath.ts
+function getDisplayEnvPath(envPath, cwd = process.cwd()) {
+	const relativeEnvPath = (0, node_path.relative)(cwd, envPath);
+	if (relativeEnvPath === "") return ".";
+	if (relativeEnvPath.startsWith(".")) return relativeEnvPath;
+	return `./${relativeEnvPath}`;
+}
+
+//#endregion
+//#region ../prompt/src/session/Session.ts
+var Session = class Session {
+	schemas;
+	newValues = {};
+	promptLineHistory = [];
+	channel;
+	secrets;
+	truncate;
+	theme;
+	output;
+	input;
+	displayEnvPath;
+	envPath;
+	preprocessors;
+	constructor({ channel, secrets, truncate, theme, output, input, schemas, path, preprocess }) {
+		this.channel = channel;
+		this.secrets = secrets;
+		this.truncate = truncate;
+		this.theme = theme;
+		this.output = output;
+		this.input = input;
+		this.displayEnvPath = getDisplayEnvPath(path);
+		const normalizedEnvPath = path.startsWith("file://") ? (0, node_url.fileURLToPath)(path) : path;
+		this.envPath = (0, node_path.resolve)(process.cwd(), normalizedEnvPath);
+		this.schemas = schemas;
+		this.preprocessors = preprocess;
+	}
+	static fromOptions(options) {
+		return new Session(options);
+	}
+	async run() {
+		this.renderSetupHeader();
+		let currentValues = await this.channel.get();
+		const schemaKeys = Object.keys(this.schemas);
+		let index = 0;
+		while (index < schemaKeys.length) {
+			const key = schemaKeys[index];
+			const envVarSchema = this.schemas[key];
+			let addedLines = 0;
+			if (index > 0) {
+				this.output.write(`${picocolors.default.gray("│")}  \n`);
+				addedLines++;
+			}
+			const shouldMask = resolveShouldMask(key, envVarSchema, this.secrets);
+			const storedValue = this.newValues[key] ?? currentValues[key];
+			const prompt$1 = createPrompt({
+				key,
+				schema: envVarSchema,
+				currentValue: storedValue && storedValue.trim() !== "" ? storedValue : void 0,
+				theme: this.theme,
+				truncate: this.truncate,
+				shouldMask,
+				index,
+				total: schemaKeys.length,
+				input: this.input,
+				output: this.output,
+				preprocessors: this.preprocessors
+			});
+			const value = await prompt$1.prompt();
+			addedLines++;
+			const outcome = prompt$1.getOutcome();
+			if ((0, __clack_core.isCancel)(value) || typeof value === "symbol" && value?.description === "clack:cancel") {
+				this.output.write(`${picocolors.default.red("│")}  \n`);
+				this.output.write(`${picocolors.default.red("└")}  ${picocolors.default.red("Setup cancelled.")}\n\n`);
+				return "cancelled";
+			}
+			if (outcome === "previous") {
+				clearConsoleLines(addedLines);
+				const previousLines = this.promptLineHistory.pop() ?? 0;
+				if (previousLines > 0) clearConsoleLines(previousLines);
+				index = Math.max(index - 1, 0);
+				continue;
+			}
+			this.promptLineHistory.push(addedLines);
+			if (outcome === "skip") {
+				index++;
+				continue;
+			}
+			const stringValue = String(value);
+			try {
+				await this.channel.set({ [key]: stringValue });
+				currentValues = await this.channel.get();
+				this.newValues[key] = stringValue;
+			} catch (error) {
+				this.output.write(`${picocolors.default.gray(S_BAR_END)}  ${picocolors.default.red(`Failed to save ${key}: ${error}`)}\n\n`);
+				return "error";
+			}
+			index++;
+		}
+		this.output.write(`${picocolors.default.gray(S_BAR)}\n${picocolors.default.gray(S_BAR_END)}  ${this.theme.primary("Setup complete!")}\n\n`);
+		return "success";
+	}
+	renderSetupHeader() {
+		const envFileUrl = (0, node_url.pathToFileURL)(this.envPath).toString();
+		const clickableEnvPath = this.toHyperlink(picocolors.default.gray(this.displayEnvPath), envFileUrl);
+		const variableCount = Object.keys(this.schemas).length;
+		const variableLabel = variableCount === 1 ? "1 variable" : `${variableCount} variables`;
+		const headerBody = [
+			this.theme.bgPrimary(picocolors.default.black(" Environment Variable Setup ")),
+			`${picocolors.default.gray("│")}  ${clickableEnvPath}${picocolors.default.gray(` · ${variableLabel}`)}`,
+			`${picocolors.default.gray("│")}  `
+		].join("\n");
+		this.output.write(`\n${picocolors.default.gray(S_BAR_START)}  ${headerBody}\n`);
+	}
+	toHyperlink(text, url) {
+		const escapeCode = "\x1B";
+		const oscSequence = `${escapeCode}]8;;`;
+		const stringTerminator = `${escapeCode}\\`;
+		return `${oscSequence}${url}${stringTerminator}${text}${oscSequence}${stringTerminator}`;
+	}
+};
+
+//#endregion
+//#region ../prompt/src/options/resolve.ts
+function resolveTheme(themeOption) {
+	return new Theme(themeOption ?? picocolors.default.magenta);
+}
+function resolveRootDirectory(rootOption) {
+	if (!rootOption) return;
+	if (rootOption.startsWith("file://")) return (0, node_path.dirname)((0, node_url.fileURLToPath)(rootOption));
+	return rootOption;
+}
+function resolveEnvFilePath(pathOption, rootDir) {
+	if (!rootDir) return pathOption;
+	return (0, node_path.resolve)(rootDir, pathOption);
+}
+
+//#endregion
+//#region ../prompt/src/utils/isEnvChannel.ts
+/**
+* Type guard to check if a value is an EnvChannel instance
+*/
+function isEnvChannel(value) {
+	return typeof value === "object" && value !== null && "get" in value && "set" in value && typeof value.get === "function" && typeof value.set === "function";
+}
+
+//#endregion
+//#region ../prompt/src/prompt.ts
+/**
+* Interactive CLI tool to generate .env files with schema validation
+*/
+async function prompt(modelOrOptions, interactiveOptions) {
+	let schemas;
+	let preprocessConfig;
+	let finalOptions;
+	if (modelOrOptions instanceof EnvModel) {
+		const model = modelOrOptions;
+		finalOptions = interactiveOptions || {};
+		schemas = model.schemas;
+		preprocessConfig = model.preprocess;
+	} else {
+		const options = modelOrOptions;
+		finalOptions = options;
+		if (options.schemas) {
+			schemas = resolveSchemas(options.schemas);
+			preprocessConfig = options.preprocess;
+		} else throw new Error("Either provide a model or schemas in options");
+	}
+	const rootDirectory = resolveRootDirectory(finalOptions.root);
+	const path = resolveEnvFilePath(finalOptions.path ?? ENV_PATH, rootDirectory);
+	const truncate = finalOptions.truncate ?? TRUNCATE_LENGTH;
+	const secrets = finalOptions.secrets ?? SECRET_PATTERNS;
+	const input = node_process.stdin;
+	const output = node_process.stdout;
+	const channel = isEnvChannel(finalOptions.channel) ? finalOptions.channel : resolveChannel(finalOptions.channel, path);
+	const theme = resolveTheme(finalOptions.theme);
+	await new Session({
+		schemas,
+		channel,
+		secrets,
+		truncate,
+		theme,
+		input,
+		output,
+		path,
+		preprocess: preprocessConfig
+	}).run();
+}
+
+//#endregion
+Object.defineProperty(exports, 'BooleanEnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return BooleanEnvVarSchema;
+  }
+});
+Object.defineProperty(exports, 'DefaultEnvChannel', {
+  enumerable: true,
+  get: function () {
+    return DefaultEnvChannel;
+  }
+});
+Object.defineProperty(exports, 'DotEnvChannel', {
+  enumerable: true,
+  get: function () {
+    return DotEnvChannel;
+  }
+});
+Object.defineProperty(exports, 'DotEnvXChannel', {
+  enumerable: true,
+  get: function () {
+    return DotEnvXChannel;
+  }
+});
+Object.defineProperty(exports, 'EnumEnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return EnumEnvVarSchema;
+  }
+});
+Object.defineProperty(exports, 'EnvModel', {
+  enumerable: true,
+  get: function () {
+    return EnvModel;
+  }
+});
+Object.defineProperty(exports, 'EnvSource', {
+  enumerable: true,
+  get: function () {
+    return EnvSource;
+  }
+});
+Object.defineProperty(exports, 'EnvVarSchemaBase', {
+  enumerable: true,
+  get: function () {
+    return EnvVarSchemaBase;
+  }
+});
+Object.defineProperty(exports, 'NumberEnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return NumberEnvVarSchema;
+  }
+});
+Object.defineProperty(exports, 'ProcessEnvChannel', {
+  enumerable: true,
+  get: function () {
+    return ProcessEnvChannel;
+  }
+});
+Object.defineProperty(exports, 'StringEnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return StringEnvVarSchema;
+  }
+});
+Object.defineProperty(exports, '__export', {
+  enumerable: true,
+  get: function () {
+    return __export;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'booleanPreprocessor', {
+  enumerable: true,
+  get: function () {
+    return booleanPreprocessor;
+  }
+});
+Object.defineProperty(exports, 'booleanProcessor', {
+  enumerable: true,
+  get: function () {
+    return booleanProcessor;
+  }
+});
+Object.defineProperty(exports, 'defaults_exports', {
+  enumerable: true,
+  get: function () {
+    return defaults_exports;
+  }
+});
+Object.defineProperty(exports, 'define', {
+  enumerable: true,
+  get: function () {
+    return define;
+  }
+});
+Object.defineProperty(exports, 'enumPreprocessor', {
+  enumerable: true,
+  get: function () {
+    return enumPreprocessor;
+  }
+});
+Object.defineProperty(exports, 'enumProcessor', {
+  enumerable: true,
+  get: function () {
+    return enumProcessor;
+  }
+});
+Object.defineProperty(exports, 'get', {
+  enumerable: true,
+  get: function () {
+    return get;
+  }
+});
+Object.defineProperty(exports, 'isEnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return isEnvVarSchema;
+  }
+});
+Object.defineProperty(exports, 'numberPreprocessor', {
+  enumerable: true,
+  get: function () {
+    return numberPreprocessor;
+  }
+});
+Object.defineProperty(exports, 'numberProcessor', {
+  enumerable: true,
+  get: function () {
+    return numberProcessor;
+  }
+});
+Object.defineProperty(exports, 'preprocessors', {
+  enumerable: true,
+  get: function () {
+    return preprocessors;
+  }
+});
+Object.defineProperty(exports, 'processors', {
+  enumerable: true,
+  get: function () {
+    return processors;
+  }
+});
+Object.defineProperty(exports, 'prompt', {
+  enumerable: true,
+  get: function () {
+    return prompt;
+  }
+});
+Object.defineProperty(exports, 'resolveChannel', {
+  enumerable: true,
+  get: function () {
+    return resolveChannel;
+  }
+});
+Object.defineProperty(exports, 'resolvePreprocessor', {
+  enumerable: true,
+  get: function () {
+    return resolvePreprocessor;
+  }
+});
+Object.defineProperty(exports, 'resolveSchema', {
+  enumerable: true,
+  get: function () {
+    return resolveSchema;
+  }
+});
+Object.defineProperty(exports, 'resolveSchemas', {
+  enumerable: true,
+  get: function () {
+    return resolveSchemas;
+  }
+});
+Object.defineProperty(exports, 'set', {
+  enumerable: true,
+  get: function () {
+    return set;
+  }
+});
+Object.defineProperty(exports, 'stringPreprocessor', {
+  enumerable: true,
+  get: function () {
+    return stringPreprocessor;
+  }
+});
+Object.defineProperty(exports, 'stringProcessor', {
+  enumerable: true,
+  get: function () {
+    return stringProcessor;
+  }
+});