@e-n-v/env 0.0.1

package/dist/src-RlCvrI0s.js

@@ -0,0 +1,3860 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { mkdirSync, promises, readFileSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { existsSync, writeFileSync as writeFileSync$1 } from "fs";
+import { z } from "zod";
+import * as z4core from "zod/v4/core";
+import { stdin, stdout } from "node:process";
+import { Prompt, isCancel } from "@clack/core";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import color from "picocolors";
+import { clearLine, cursorTo, moveCursor } from "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 = 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();
+		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 promises.writeFile(this.filePath, nextContent, "utf8");
+	}
+	readContentSync() {
+		try {
+			return readFileSync(this.filePath, "utf8").replace(/\r\n/g, "\n");
+		} catch (error) {
+			if (error.code === "ENOENT") return "";
+			throw error;
+		}
+	}
+	async readContent() {
+		try {
+			return (await promises.readFile(this.filePath, "utf8")).replace(/\r\n/g, "\n");
+		} catch (error) {
+			if (error.code === "ENOENT") return "";
+			throw error;
+		}
+	}
+	ensureDirectorySync() {
+		try {
+			mkdirSync(dirname(this.filePath), { recursive: true });
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+	async ensureDirectory() {
+		try {
+			await promises.mkdir(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 = 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 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 (!existsSync(this.defaultPath)) writeFileSync$1(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 = z.coerce.number();
+			else if (type === "boolean") processSchema = 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 = z.coerce.number();
+			else if (type === "boolean") processSchema = z.stringbool();
+			const result = z4core.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(color.magenta);
+	primary;
+	bgPrimary;
+	subtle;
+	warn;
+	bgWarn;
+	error;
+	bgError;
+	constructor(main) {
+		this.primary = main;
+		this.bgPrimary = this.getBackgroundColor(main);
+		this.subtle = color.gray;
+		this.warn = color.yellow;
+		this.bgWarn = this.getBackgroundColor(color.yellow);
+		this.error = color.red;
+		this.bgError = this.getBackgroundColor(color.red);
+	}
+	/**
+	* Get the background version of a color function
+	*/
+	getBackgroundColor(colorFn) {
+		if (colorFn === color.black) return color.bgBlack;
+		if (colorFn === color.red) return color.bgRed;
+		if (colorFn === color.green) return color.bgGreen;
+		if (colorFn === color.yellow) return color.bgYellow;
+		if (colorFn === color.blue) return color.bgBlue;
+		if (colorFn === color.magenta) return color.bgMagenta;
+		if (colorFn === color.cyan) return color.bgCyan;
+		if (colorFn === color.white) return color.bgWhite;
+		if (colorFn === color.redBright) return color.bgRedBright;
+		if (colorFn === color.greenBright) return color.bgGreenBright;
+		if (colorFn === color.yellowBright) return color.bgYellowBright;
+		if (colorFn === color.blueBright) return color.bgBlueBright;
+		if (colorFn === color.magentaBright) return color.bgMagentaBright;
+		if (colorFn === color.cyanBright) return color.bgCyanBright;
+		if (colorFn === color.whiteBright) return color.bgWhiteBright;
+		return color.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 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: color.white,
+			bold: color.bold,
+			dim: color.dim,
+			inverse: color.inverse,
+			strikethrough: color.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++) {
+			moveCursor(output, 0, -1);
+			cursorTo(output, 0);
+			clearLine(output, 0);
+		}
+		cursorTo(output, 0);
+	} catch {}
+}
+
+//#endregion
+//#region ../prompt/src/utils/getDisplayEnvPath.ts
+function getDisplayEnvPath(envPath, cwd = process.cwd()) {
+	const relativeEnvPath = 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://") ? fileURLToPath(path) : path;
+		this.envPath = 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(`${color.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 (isCancel(value) || typeof value === "symbol" && value?.description === "clack:cancel") {
+				this.output.write(`${color.red("│")}  \n`);
+				this.output.write(`${color.red("└")}  ${color.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(`${color.gray(S_BAR_END)}  ${color.red(`Failed to save ${key}: ${error}`)}\n\n`);
+				return "error";
+			}
+			index++;
+		}
+		this.output.write(`${color.gray(S_BAR)}\n${color.gray(S_BAR_END)}  ${this.theme.primary("Setup complete!")}\n\n`);
+		return "success";
+	}
+	renderSetupHeader() {
+		const envFileUrl = pathToFileURL(this.envPath).toString();
+		const clickableEnvPath = this.toHyperlink(color.gray(this.displayEnvPath), envFileUrl);
+		const variableCount = Object.keys(this.schemas).length;
+		const variableLabel = variableCount === 1 ? "1 variable" : `${variableCount} variables`;
+		const headerBody = [
+			this.theme.bgPrimary(color.black(" Environment Variable Setup ")),
+			`${color.gray("│")}  ${clickableEnvPath}${color.gray(` · ${variableLabel}`)}`,
+			`${color.gray("│")}  `
+		].join("\n");
+		this.output.write(`\n${color.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 ?? color.magenta);
+}
+function resolveRootDirectory(rootOption) {
+	if (!rootOption) return;
+	if (rootOption.startsWith("file://")) return dirname(fileURLToPath(rootOption));
+	return rootOption;
+}
+function resolveEnvFilePath(pathOption, rootDir) {
+	if (!rootDir) return pathOption;
+	return 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 = stdin;
+	const output = 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
+export { set as A, EnvVarSchemaBase as C, DotEnvChannel as D, DotEnvXChannel as E, DefaultEnvChannel as O, stringProcessor as S, ProcessEnvChannel as T, BooleanEnvVarSchema as _, resolveSchema as a, numberProcessor as b, booleanPreprocessor as c, preprocessors as d, stringPreprocessor as f, EnumEnvVarSchema as g, NumberEnvVarSchema as h, EnvModel as i, get as j, EnvSource as k, enumPreprocessor as l, StringEnvVarSchema as m, defaults_exports as n, resolveSchemas as o, isEnvVarSchema as p, define as r, resolvePreprocessor as s, prompt as t, numberPreprocessor as u, booleanProcessor as v, resolveChannel as w, processors as x, enumProcessor as y };