@e-n-v/env 0.0.2 → 0.0.4

package/dist/{src-oetJm-nZ.cjs → src-DWYoqPX1.cjs}

@@ -1,1759 +1,22 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (all) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs);
-let node_path = require("node:path");
-node_path = __toESM(node_path);
-let node_fs_promises = require("node:fs/promises");
-node_fs_promises = __toESM(node_fs_promises);
-let fs = require("fs");
-fs = __toESM(fs);
-let zod = require("zod");
-zod = __toESM(zod);
-let zod_v4_core = require("zod/v4/core");
-zod_v4_core = __toESM(zod_v4_core);
-let node_process = require("node:process");
-node_process = __toESM(node_process);
-let __clack_core = require("@clack/core");
-__clack_core = __toESM(__clack_core);
-let node_url = require("node:url");
-node_url = __toESM(node_url);
-let picocolors = require("picocolors");
-picocolors = __toESM(picocolors);
-let node_readline = require("node:readline");
-node_readline = __toESM(node_readline);
-
-//#region ../files/src/utils.ts
-function normalizeContent(content) {
-	return content.replace(/\r\n/g, "\n");
-}
-function splitLines(content) {
-	return content === "" ? [] : content.split("\n");
-}
-function validateKey(key) {
-	const trimmed = key.trim();
-	if (!trimmed) throw new TypeError("Environment variable name cannot be empty");
-	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed)) throw new TypeError(`Invalid environment variable name: ${trimmed}`);
-	return trimmed;
-}
-function parseAssignmentEndingAt(lines, endIndex) {
-	const lastLine = lines[endIndex];
-	if (typeof lastLine !== "string" || isSkippableLine(lastLine)) return null;
-	const block = [];
-	let start = endIndex;
-	while (start >= 0) {
-		const currentLine = lines[start];
-		if (typeof currentLine !== "string") break;
-		block.unshift(currentLine);
-		if (containsAssignmentOperator(currentLine)) {
-			const parsed = tryParseAssignmentBlock(block);
-			if (!parsed) return null;
-			return {
-				...parsed,
-				startIndex: start,
-				endIndex
-			};
-		}
-		start -= 1;
-	}
-	return null;
-}
-function isSkippableLine(line) {
-	const trimmed = line.trim();
-	return trimmed.length === 0 || trimmed.startsWith("#");
-}
-function containsAssignmentOperator(line) {
-	const trimmed = line.trimStart();
-	if (trimmed.length === 0 || trimmed.startsWith("#")) return false;
-	const commentIndex = trimmed.indexOf("#");
-	return (commentIndex === -1 ? trimmed : trimmed.slice(0, commentIndex)).includes("=");
-}
-function tryParseAssignmentBlock(blockLines) {
-	if (blockLines.length === 0) return null;
-	const firstLine = blockLines[0];
-	const leadingMatch = firstLine.match(/^\s*/);
-	const leading = leadingMatch ? leadingMatch[0] : "";
-	let remainder = firstLine.slice(leading.length);
-	if (remainder.length === 0 || remainder.startsWith("#")) return null;
-	let exportPrefix = "";
-	if (remainder.startsWith("export")) {
-		const afterExport = remainder.slice(6);
-		if (/^\s/.test(afterExport)) {
-			const spacingMatch = afterExport.match(/^\s+/);
-			const spacing = spacingMatch ? spacingMatch[0] : " ";
-			exportPrefix = `export${spacing}`;
-			remainder = afterExport.slice(spacing.length);
-		}
-	}
-	const equalsIndex = remainder.indexOf("=");
-	if (equalsIndex === -1) return null;
-	const key = validateKey(remainder.slice(0, equalsIndex).trim());
-	const parsedValue = parseValueSource([remainder.slice(equalsIndex + 1).replace(/^\s+/, ""), ...blockLines.slice(1)].join("\n"));
-	if (!parsedValue) return null;
-	const trailingTrimmed = parsedValue.trailing.trim();
-	if (trailingTrimmed.length > 0 && !trailingTrimmed.startsWith("#")) return null;
-	return {
-		key,
-		value: parsedValue.value,
-		leading,
-		exportPrefix,
-		trailing: parsedValue.trailing,
-		lines: [...blockLines]
-	};
-}
-function parseValueSource(source) {
-	if (source.length === 0) return {
-		value: "",
-		trailing: ""
-	};
-	const firstChar = source[0];
-	if (firstChar === "\"") return parseDoubleQuotedValue(source);
-	if (firstChar === "'") return parseSingleQuotedValue(source);
-	if (source.includes("\n")) return null;
-	const commentIndex = source.indexOf(" #");
-	const raw = commentIndex === -1 ? source : source.slice(0, commentIndex);
-	const trailing = commentIndex === -1 ? source.slice(raw.length) : source.slice(commentIndex);
-	return {
-		value: raw.trim(),
-		trailing
-	};
-}
-function parseDoubleQuotedValue(source) {
-	let value = "";
-	let escaping = false;
-	for (let i = 1; i < source.length; i += 1) {
-		const char = source[i] ?? "";
-		if (escaping) {
-			switch (char) {
-				case "n":
-					value += "\n";
-					break;
-				case "r":
-					value += "\r";
-					break;
-				case "t":
-					value += "	";
-					break;
-				case "\"":
-					value += "\"";
-					break;
-				case "\\":
-					value += "\\";
-					break;
-				default:
-					value += char;
-					break;
-			}
-			escaping = false;
-			continue;
-		}
-		if (char === "\\") {
-			escaping = true;
-			continue;
-		}
-		if (char === "\"") {
-			const trailing = source.slice(i + 1);
-			return {
-				value,
-				trailing
-			};
-		}
-		if (char === "\n") {
-			value += "\n";
-			continue;
-		}
-		value += char;
-	}
-	return null;
-}
-function parseSingleQuotedValue(source) {
-	let value = "";
-	for (let i = 1; i < source.length; i += 1) {
-		const char = source[i] ?? "";
-		if (char === "'") {
-			const trailing = source.slice(i + 1);
-			return {
-				value,
-				trailing
-			};
-		}
-		if (char === "\n") {
-			value += "\n";
-			continue;
-		}
-		value += char;
-	}
-	return null;
-}
-
-//#endregion
-//#region ../files/src/get.ts
-function get(content, arg) {
-	const lines = splitLines(normalizeContent(content));
-	if (typeof arg === "undefined") {
-		const map = scanAll(lines);
-		return Object.fromEntries(map);
-	}
-	if (typeof arg === "string") return scanForSingle(lines, arg);
-	const normalizedTargets = Array.from(new Set(arg.map((name) => validateKey(name))));
-	const lookup = scanForMany(lines, new Set(normalizedTargets));
-	const ordered = normalizedTargets.map((key) => [key, lookup.get(key)]);
-	return Object.fromEntries(ordered);
-}
-function scanAll(lines) {
-	const result = /* @__PURE__ */ new Map();
-	iterateAssignments(lines, (assignment) => {
-		if (!result.has(assignment.key)) result.set(assignment.key, assignment.value);
-	});
-	return result;
-}
-function scanForSingle(lines, target) {
-	const name = validateKey(target);
-	let found;
-	iterateAssignments(lines, (assignment) => {
-		if (assignment.key === name) {
-			found = assignment.value;
-			return true;
-		}
-	});
-	return found;
-}
-function scanForMany(lines, targets) {
-	const normalizedTargets = /* @__PURE__ */ new Set();
-	for (const target of targets) normalizedTargets.add(validateKey(target));
-	const found = /* @__PURE__ */ new Map();
-	const remaining = new Set(normalizedTargets);
-	iterateAssignments(lines, (assignment) => {
-		if (!remaining.has(assignment.key) || found.has(assignment.key)) return;
-		found.set(assignment.key, assignment.value);
-		remaining.delete(assignment.key);
-		if (remaining.size === 0) return true;
-	});
-	return found;
-}
-function iterateAssignments(lines, callback) {
-	for (let i = lines.length - 1; i >= 0;) {
-		const parsed = parseAssignmentEndingAt(lines, i);
-		if (!parsed) {
-			i -= 1;
-			continue;
-		}
-		if (callback(parsed) === true) return;
-		i = parsed.startIndex - 1;
-	}
-}
-
-//#endregion
-//#region ../files/src/set.ts
-function set(content, arg, value) {
-	const normalized = normalizeContent(content);
-	const lines = splitLines(normalized);
-	const entries = normalizeWriteArguments(arg, value);
-	if (entries.length === 0) return ensureTrailingNewline(normalized);
-	const replacements = new Map(entries);
-	const touched = /* @__PURE__ */ new Set();
-	for (let i = lines.length - 1; i >= 0;) {
-		if (replacements.size === 0) break;
-		const parsed = parseAssignmentEndingAt(lines, i);
-		if (!parsed) {
-			i -= 1;
-			continue;
-		}
-		const { key, startIndex, endIndex, leading, exportPrefix, trailing, value: currentValue } = parsed;
-		const nextValue = replacements.get(key);
-		if (typeof nextValue === "undefined" || touched.has(key)) {
-			i = startIndex - 1;
-			continue;
-		}
-		if (nextValue === currentValue) {
-			touched.add(key);
-			replacements.delete(key);
-			i = startIndex - 1;
-			continue;
-		}
-		const block = buildAssignmentLines(key, nextValue, {
-			leading,
-			exportPrefix,
-			trailing
-		});
-		lines.splice(startIndex, endIndex - startIndex + 1, ...block);
-		touched.add(key);
-		replacements.delete(key);
-		i = startIndex - 1;
-	}
-	for (const [key, val] of entries) {
-		if (touched.has(key)) continue;
-		const block = buildAssignmentLines(key, val);
-		const insertIndex = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
-		lines.splice(insertIndex, 0, ...block);
-		touched.add(key);
-	}
-	return ensureTrailingNewline(lines.join("\n"));
-}
-function ensureTrailingNewline(content) {
-	if (content.length === 0) return "";
-	if (!content.endsWith("\n")) return `${content}\n`;
-	return content;
-}
-function isObjectRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeWriteArguments(arg, value) {
-	if (typeof arg === "string") {
-		if (typeof value === "undefined") throw new TypeError(`Value for variable "${arg}" must be provided`);
-		return [[validateKey(arg), formatValueInput(value)]];
-	}
-	if (!isObjectRecord(arg)) throw new TypeError("Argument must be a string name or an object of key-value pairs");
-	const entries = [];
-	for (const [key, rawValue] of Object.entries(arg)) {
-		if (typeof rawValue === "undefined") throw new TypeError(`Value for variable "${key}" must be provided`);
-		entries.push([validateKey(key), formatValueInput(rawValue)]);
-	}
-	return entries;
-}
-function formatValueInput(value) {
-	if (typeof value === "bigint") return value.toString();
-	return String(value);
-}
-function serializeValue(value) {
-	const normalized = value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-	if (!(normalized.length === 0 || /[\s"'\\#]/.test(normalized) || normalized.includes("\n"))) return normalized;
-	let result = "\"";
-	for (const char of normalized) {
-		if (char === "\"") {
-			result += "\\\"";
-			continue;
-		}
-		if (char === "\\") {
-			result += "\\\\";
-			continue;
-		}
-		if (char === "\n") {
-			result += "\n";
-			continue;
-		}
-		result += char;
-	}
-	result += "\"";
-	return result;
-}
-function buildAssignmentLines(key, value, style = {}) {
-	const leading = style.leading ?? "";
-	const exportPrefix = style.exportPrefix ?? "";
-	const trailing = style.trailing ?? "";
-	const segments = serializeValue(value).split("\n");
-	return segments.map((segment, index) => {
-		if (index === 0) return `${leading}${exportPrefix}${key}=${segment}${segments.length === 1 ? trailing : ""}`;
-		if (index === segments.length - 1 && trailing && segments.length > 1) return `${segment}${trailing}`;
-		return segment;
-	});
-}
-
-//#endregion
-//#region ../files/src/EnvSource.ts
-var EnvSource = class {
-	filePath;
-	constructor(filePath) {
-		this.filePath = (0, node_path.resolve)(process.cwd(), filePath);
-	}
-	readSync(arg) {
-		const content = this.readContentSync();
-		if (typeof arg === "undefined") return get(content);
-		if (typeof arg === "string") return get(content, arg);
-		return get(content, arg);
-	}
-	async read(arg) {
-		const content = await this.readContent();
-		if (typeof arg === "undefined") return get(content);
-		if (typeof arg === "string") return get(content, arg);
-		return get(content, arg);
-	}
-	writeSync(arg, value) {
-		const originalContent = this.readContentSync();
-		let nextContent;
-		if (typeof arg === "string") nextContent = set(originalContent, arg, value);
-		else nextContent = set(originalContent, arg);
-		if (nextContent === originalContent) return;
-		this.ensureDirectorySync();
-		(0, node_fs.writeFileSync)(this.filePath, nextContent, "utf8");
-	}
-	async write(arg, value) {
-		const originalContent = await this.readContent();
-		let nextContent;
-		if (typeof arg === "string") nextContent = set(originalContent, arg, value);
-		else nextContent = set(originalContent, arg);
-		if (nextContent === originalContent) return;
-		await this.ensureDirectory();
-		await node_fs.promises.writeFile(this.filePath, nextContent, "utf8");
-	}
-	readContentSync() {
-		try {
-			return (0, node_fs.readFileSync)(this.filePath, "utf8").replace(/\r\n/g, "\n");
-		} catch (error) {
-			if (error.code === "ENOENT") return "";
-			throw error;
-		}
-	}
-	async readContent() {
-		try {
-			return (await node_fs.promises.readFile(this.filePath, "utf8")).replace(/\r\n/g, "\n");
-		} catch (error) {
-			if (error.code === "ENOENT") return "";
-			throw error;
-		}
-	}
-	ensureDirectorySync() {
-		try {
-			(0, node_fs.mkdirSync)((0, node_path.dirname)(this.filePath), { recursive: true });
-		} catch (error) {
-			if (error.code !== "EEXIST") throw error;
-		}
-	}
-	async ensureDirectory() {
-		try {
-			await node_fs.promises.mkdir((0, node_path.dirname)(this.filePath), { recursive: true });
-		} catch (error) {
-			if (error.code !== "EEXIST") throw error;
-		}
-	}
-};
-
-//#endregion
-//#region ../channels/src/channels/default/DefaultEnvChannel.ts
-/**
-* Default implementation of EnvChannel that works with .env files using envrw
-*/
-var DefaultEnvChannel = class {
-	envSource;
-	/**
-	* Create a new DefaultEnvChannel
-	* @param filePath - Path to the .env file to manage
-	*/
-	constructor(filePath) {
-		this.envSource = new EnvSource(filePath);
-	}
-	/**
-	* Get all environment variables
-	* @returns Promise that resolves to object containing all environment variable key-value pairs
-	*/
-	async get() {
-		return await this.envSource.read();
-	}
-	/**
-	* Set multiple environment variables
-	* @param values - Object containing key-value pairs to set
-	* @returns Promise that resolves when the values have been set
-	*/
-	async set(values) {
-		await this.envSource.write(values);
-	}
-};
-
-//#endregion
-//#region ../channels/src/channels/dotenv/DotEnvChannel.ts
-function isFileNotFound(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-function normalizeParsed(parsed) {
-	if (!parsed) return {};
-	const result = {};
-	for (const [key, value] of Object.entries(parsed)) {
-		if (typeof value === "undefined") continue;
-		result[key] = value;
-	}
-	return result;
-}
-var DotEnvChannel = class {
-	dotenv;
-	targetPath;
-	absolutePath;
-	encoding;
-	parseOptions;
-	envSource;
-	constructor(dotenv, defaultPath = ".env", getOptions = {}, parseOptions = {}) {
-		this.dotenv = dotenv;
-		this.targetPath = (typeof getOptions.path === "string" ? getOptions.path : void 0) ?? defaultPath;
-		this.absolutePath = (0, node_path.resolve)(process.cwd(), this.targetPath);
-		this.encoding = getOptions.encoding ?? "utf8";
-		this.parseOptions = { ...parseOptions };
-		this.envSource = new EnvSource(this.targetPath);
-	}
-	async get() {
-		try {
-			const content = await (0, node_fs_promises.readFile)(this.absolutePath, { encoding: this.encoding });
-			return normalizeParsed(this.dotenv.parse(content, this.parseOptions));
-		} catch (error) {
-			if (isFileNotFound(error)) return {};
-			throw error;
-		}
-	}
-	async set(values) {
-		await this.envSource.write(values);
-		const parsed = await this.get();
-		const mismatches = [];
-		for (const [key, expected] of Object.entries(values)) {
-			const actual = parsed[key];
-			if (actual !== expected) mismatches.push(`${key}=expected(${JSON.stringify(expected)}) actual(${JSON.stringify(actual)})`);
-		}
-		if (mismatches.length > 0) throw new Error(`Failed to correctly write values to ${this.targetPath}: ${mismatches.join(", ")}`);
-	}
-	getPrimaryPath() {
-		return this.targetPath;
-	}
-	clearCache() {}
-};
-
-//#endregion
-//#region ../channels/src/channels/dotenvx/DotEnvXChannel.ts
-/**
-* Simple DotEnvX implementation of EnvChannel that wraps @dotenvx/dotenvx library
-* This is just an API mapping wrapper without caching or complex state management
-*/
-var DotEnvXChannel = class {
-	dotenvx;
-	getOptions;
-	setOptions;
-	defaultPath;
-	/**
-	* Create a new DotEnvXChannel
-	* @param dotenvx - The dotenvx instance to use
-	* @param defaultPath - Default path for env files
-	* @param getOptions - Options for get operations
-	* @param setOptions - Options for set operations
-	*/
-	constructor(dotenvx, defaultPath = ".env", getOptions = {}, setOptions = {}) {
-		this.dotenvx = dotenvx;
-		this.defaultPath = defaultPath;
-		this.getOptions = getOptions;
-		this.setOptions = setOptions;
-	}
-	/**
-	* Get all environment variables
-	* @returns Promise that resolves to object containing all environment variable key-value pairs
-	*/
-	async get() {
-		try {
-			return this.dotenvx.config({
-				processEnv: {},
-				quiet: true,
-				ignore: ["MISSING_ENV_FILE"],
-				path: this.defaultPath,
-				...this.getOptions
-			}).parsed || {};
-		} catch {
-			return {};
-		}
-	}
-	/**
-	* Set multiple environment variables
-	* @param values - Object containing key-value pairs to set
-	* @returns Promise that resolves when the values have been set
-	*/
-	async set(values) {
-		if (!(0, fs.existsSync)(this.defaultPath)) (0, fs.writeFileSync)(this.defaultPath, "", "utf8");
-		try {
-			const options = {
-				path: this.defaultPath,
-				...this.setOptions
-			};
-			for (const [key, value] of Object.entries(values)) this.dotenvx.set(key, value, options);
-		} catch (error) {
-			throw new Error(`Failed to set environment variables: ${error}`);
-		}
-	}
-	/**
-	* Get the primary path being used for env files
-	* @returns The primary path
-	*/
-	getPrimaryPath() {
-		return this.defaultPath;
-	}
-	/**
-	* Clear any cached data (no-op for this implementation since we don't cache)
-	*/
-	clearCache() {}
-};
-
-//#endregion
-//#region ../channels/src/channels/processenv/ProcessEnvChannel.ts
-/**
-* EnvChannel implementation that works with process.env
-* This channel reads from and writes to the current process environment
-*/
-var ProcessEnvChannel = class {
-	/**
-	* Get all environment variables from process.env
-	* @returns Promise that resolves to object containing all environment variable key-value pairs
-	*/
-	async get() {
-		const env = {};
-		for (const [key, value] of Object.entries(process.env)) if (value !== void 0) env[key] = value;
-		return env;
-	}
-	/**
-	* Set multiple environment variables in process.env
-	* @param values - Object containing key-value pairs to set
-	* @returns Promise that resolves when the values have been set
-	*/
-	async set(values) {
-		for (const [key, value] of Object.entries(values)) process.env[key] = value;
-	}
-};
-
-//#endregion
-//#region ../channels/src/resolveChannel.ts
-/**
-* Resolve channel options into an EnvChannel instance
-* @param options - The channel options to resolve
-* @param defaultPath - Default path to use for env files (default: ".env")
-* @returns An EnvChannel instance
-*/
-function resolveChannel(options, defaultPath = ".env") {
-	if (options === void 0 || options === "default") return new DefaultEnvChannel(defaultPath);
-	if (options === "processenv") return new ProcessEnvChannel();
-	if (typeof options === "object" && options !== null) {
-		if ("dotenv" in options) {
-			const { dotenv, get: getOptions = {}, parse: parseOptions = {}, path } = options;
-			if (!dotenv) throw new Error("Dotenv instance is required for dotenv channel");
-			const resolvedPath = path ?? defaultPath;
-			const mergedGetOptions = { ...getOptions };
-			if (typeof mergedGetOptions.path !== "string") mergedGetOptions.path = resolvedPath;
-			return new DotEnvChannel(dotenv, resolvedPath, mergedGetOptions, parseOptions ?? {});
-		}
-		if ("dotenvx" in options) {
-			const { dotenvx, get: getOptions = {}, set: setOptions = {} } = options;
-			if (!dotenvx) throw new Error("DotEnvX instance is required for dotenvx channel");
-			return new DotEnvXChannel(dotenvx, defaultPath, getOptions, setOptions);
-		}
-		if ("process" in options) {
-			if (options.process && typeof options.process === "object" && "env" in options.process) return new ProcessEnvChannel();
-			throw new Error("Invalid process object provided to channel config");
-		}
-		if ("name" in options) if (options.name === "default") return new DefaultEnvChannel(defaultPath);
-		else if (options.name === "processenv") return new ProcessEnvChannel();
-		else throw new Error(`Unknown channel name: ${options.name}`);
-	}
-	throw new Error(`Invalid channel options: ${options}`);
-}
-
-//#endregion
-//#region ../core/src/schemas/EnvVarSchemaBase.ts
-var EnvVarSchemaBase = class {
-	required;
-	default;
-	description;
-	process;
-	constructor(input) {
-		this.required = input?.required ?? true;
-		this.default = input?.default;
-		this.description = input?.description;
-		this.process = input.process;
-	}
-};
-
-//#endregion
-//#region ../core/src/processing/processors.ts
-/**
-* Default processors for environment variable types.
-* Each processor factory returns a function that takes a value and returns T | undefined.
-* Returns undefined for empty/null values, throws descriptive errors for invalid values.
-*/
-/**
-* Create a string processor - pass through as-is
-*/
-const stringProcessor = () => (value) => {
-	if (typeof value !== "string") throw new Error("Value must be a string");
-	return value === "" ? void 0 : value;
-};
-/**
-* Create a number processor using parseFloat
-*/
-const numberProcessor = () => (value) => {
-	if (typeof value !== "string") throw new Error("Value must be a string");
-	const trimmed = value.trim();
-	if (trimmed === "") return;
-	const parsed = parseFloat(trimmed);
-	if (isNaN(parsed)) throw new Error(`"${value}" is not a valid number`);
-	return parsed;
-};
-/**
-* Create a boolean processor from string representation
-*/
-const booleanProcessor = () => (value) => {
-	if (typeof value !== "string") throw new Error("Value must be a string");
-	const trimmed = value.trim().toLowerCase();
-	if (trimmed === "") return;
-	if (trimmed === "true" || trimmed === "1" || trimmed === "yes" || trimmed === "on") return true;
-	if (trimmed === "false" || trimmed === "0" || trimmed === "no" || trimmed === "off") return false;
-	throw new Error(`"${value}" is not a valid boolean. Use: true/false, 1/0, yes/no, or on/off`);
-};
-/**
-* Create an enum processor that validates values against allowed options
-*/
-const enumProcessor = (allowedValues) => (value) => {
-	if (typeof value !== "string") throw new Error("Value must be a string");
-	const trimmed = value.trim();
-	if (trimmed === "") return;
-	if (!allowedValues.includes(trimmed)) throw new Error(`"${value}" is not a valid option. Must be one of: ${allowedValues.join(", ")}`);
-	return trimmed;
-};
-/**
-* Default processors map for each environment variable type
-*/
-const processors = {
-	string: stringProcessor,
-	number: numberProcessor,
-	boolean: booleanProcessor,
-	enum: enumProcessor
-};
-
-//#endregion
-//#region ../core/src/schemas/typed/BooleanEnvVarSchema.ts
-var BooleanEnvVarSchema = class extends EnvVarSchemaBase {
-	type = "boolean";
-	constructor(input = {}) {
-		super({
-			...input,
-			process: input.process ?? processors.boolean()
-		});
-	}
-};
-
-//#endregion
-//#region ../core/src/schemas/typed/EnumEnvVarSchema.ts
-var EnumEnvVarSchema = class extends EnvVarSchemaBase {
-	type = "enum";
-	values;
-	constructor(input) {
-		super({
-			...input,
-			process: input.process ?? processors.enum(input.values)
-		});
-		this.values = input.values;
-	}
-};
-
-//#endregion
-//#region ../core/src/schemas/typed/NumberEnvVarSchema.ts
-var NumberEnvVarSchema = class extends EnvVarSchemaBase {
-	type = "number";
-	constructor(input = {}) {
-		super({
-			...input,
-			process: input.process ?? processors.number()
-		});
-	}
-};
-
-//#endregion
-//#region ../core/src/schemas/typed/StringEnvVarSchema.ts
-var StringEnvVarSchema = class extends EnvVarSchemaBase {
-	type = "string";
-	secret;
-	constructor(input = {}) {
-		super({
-			...input,
-			process: input.process ?? processors.string()
-		});
-		this.secret = input.secret;
-	}
-};
-
-//#endregion
-//#region ../core/src/schemas/EnvVarSchema.ts
-/**
-* Type guard to check if a value is a EnvVarSchema instance
-*/
-function isEnvVarSchema(value) {
-	return value instanceof StringEnvVarSchema || value instanceof NumberEnvVarSchema || value instanceof BooleanEnvVarSchema || value instanceof EnumEnvVarSchema;
-}
-
-//#endregion
-//#region ../core/src/processing/preprocessors.ts
-const defaultBooleanPreprocessorOptions = {
-	true: [
-		"on",
-		"enabled",
-		"active",
-		"yes"
-	],
-	false: [
-		"off",
-		"disabled",
-		"inactive",
-		"no"
-	]
-};
-/**
-* Create a string preprocessor - pass through unchanged
-*/
-const stringPreprocessor = () => (value) => value;
-/**
-* Create a number preprocessor that strips commas and whitespace
-*/
-const numberPreprocessor = () => (value) => {
-	try {
-		const cleaned = value.replace(/,/g, "").trim();
-		if (/^-?\d*\.?\d+$/.test(cleaned)) return cleaned;
-	} catch {}
-	return value;
-};
-/**
-* Create a boolean preprocessor that normalizes common truthy/falsy phrases
-*/
-const booleanPreprocessor = (options = defaultBooleanPreprocessorOptions) => {
-	const normalize = (candidate) => candidate.toLowerCase().trim();
-	const trueValues = new Set(options.true.map(normalize));
-	const falseValues = new Set(options.false.map(normalize));
-	for (const candidate of trueValues) if (falseValues.has(candidate)) throw new Error(`Boolean preprocessor option value "${candidate}" cannot map to both true and false`);
-	return (value) => {
-		try {
-			const cleaned = normalize(value);
-			if (trueValues.has(cleaned)) return true;
-			if (falseValues.has(cleaned)) return false;
-		} catch {}
-		return value;
-	};
-};
-/**
-* Create an enum preprocessor - pass through unchanged
-*/
-const enumPreprocessor = () => (value) => value;
-/**
-* Default preprocessors map for each environment variable type
-*/
-const preprocessors = {
-	string: stringPreprocessor,
-	number: numberPreprocessor,
-	boolean: booleanPreprocessor,
-	enum: enumPreprocessor
-};
-
-//#endregion
-//#region ../core/src/processing/Preprocessor.ts
-const optionKeyMap = {
-	string: "string",
-	number: "number",
-	boolean: "boolean",
-	enum: "enum"
-};
-const explicitPreprocessorFactories = {
-	string: stringPreprocessor,
-	number: numberPreprocessor,
-	boolean: booleanPreprocessor,
-	enum: enumPreprocessor
-};
-function createDefaultPreprocessor(envVarType) {
-	switch (envVarType) {
-		case "number": return numberPreprocessor();
-		case "boolean": return booleanPreprocessor();
-		default: return;
-	}
-}
-function createExplicitPreprocessor(envVarType) {
-	const factory = explicitPreprocessorFactories[envVarType];
-	if (!factory) return;
-	return factory();
-}
-/**
-* Resolve the effective preprocessor for a given environment variable type.
-* Respects custom overrides and falls back to built-in defaults (number, boolean).
-*/
-function resolvePreprocessor(envVarType, preprocessorOptions) {
-	if (envVarType === "boolean") {
-		const override = preprocessorOptions?.boolean;
-		if (override === void 0) return createDefaultPreprocessor(envVarType);
-		if (override === false) return;
-		if (override === true) return createExplicitPreprocessor(envVarType);
-		if (typeof override === "function") return override;
-		return booleanPreprocessor(override);
-	}
-	const key = optionKeyMap[envVarType];
-	const custom = preprocessorOptions?.[key];
-	if (custom === void 0) return createDefaultPreprocessor(envVarType);
-	if (custom === false) return;
-	if (custom === true) return createExplicitPreprocessor(envVarType);
-	return custom;
-}
-
-//#endregion
-//#region ../converters/src/converters/zod/ZodV3Converter.ts
-/**
-* Zod v3 schema converter implementation
-*/
-var ZodV3Converter = class {
-	applies(schema) {
-		return isZodV3Schema(schema);
-	}
-	convert(schema) {
-		return convertFromZodV3Schema(schema);
-	}
-};
-/**
-* Check if a schema is a Zod v3 schema
-*/
-function isZodV3Schema(schema) {
-	if (!schema || typeof schema !== "object") return false;
-	const candidate = schema;
-	return Boolean(candidate._def && !("_zod" in candidate) && (candidate._def.typeName || typeof candidate.parse === "function"));
-}
-/**
-* Extract definition from Zod v3 schema
-*/
-function getV3Def(schema) {
-	return schema._def || {};
-}
-/**
-* Get the type name from a Zod v3 definition
-*/
-function getV3TypeName(def) {
-	return def.typeName || "unknown";
-}
-/**
-* Check if a type is a wrapper type that should be unwrapped
-*/
-function isV3WrapperType(typeName) {
-	return [
-		"ZodOptional",
-		"ZodDefault",
-		"ZodEffects",
-		"ZodNullable",
-		"ZodNullish",
-		"ZodReadonly",
-		"ZodBranded",
-		"ZodCatch"
-	].includes(typeName);
-}
-/**
-* Get inner schema from wrapper
-*/
-function getV3InnerSchema(def) {
-	return def.innerType || def.schema;
-}
-/**
-* Get default value from definition
-*/
-function getV3DefaultValue(def) {
-	if (def.defaultValue === void 0) return void 0;
-	return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
-}
-/**
-* Extract enum values from schema
-*/
-function extractV3EnumValues(def) {
-	if (!Array.isArray(def.values)) return void 0;
-	return def.values.map((v) => String(v));
-}
-/**
-* Get description from schema
-*/
-function getV3Description(schema, def) {
-	const directDesc = schema.description;
-	if (typeof directDesc === "string" && directDesc.length > 0) return directDesc;
-	if (typeof def.description === "string" && def.description.length > 0) return def.description;
-}
-/**
-* Resolve environment variable type from schema
-*/
-function resolveV3EnvVarType(schema) {
-	const def = getV3Def(schema);
-	switch (getV3TypeName(def)) {
-		case "ZodString": return "string";
-		case "ZodNumber": return "number";
-		case "ZodBoolean": return "boolean";
-		case "ZodEnum": return "enum";
-		default:
-			if (def.values) return "enum";
-			return "string";
-	}
-}
-function peelV3Schema(schema) {
-	let current = schema;
-	let required = true;
-	let defaultValue = void 0;
-	let description = void 0;
-	for (let i = 0; i < 20; i++) {
-		const def = getV3Def(current);
-		const typeName = getV3TypeName(def);
-		if (!description) description = getV3Description(current, def);
-		if (!isV3WrapperType(typeName)) break;
-		if (typeName === "ZodOptional" || typeName === "ZodNullish") required = false;
-		if (typeName === "ZodDefault" && defaultValue === void 0) defaultValue = getV3DefaultValue(def);
-		const inner = getV3InnerSchema(def);
-		if (!inner) break;
-		current = inner;
-	}
-	return {
-		schema: current,
-		required,
-		default: defaultValue,
-		description
-	};
-}
-/**
-* Create a process function for Zod v3 schemas
-*/
-function createV3ProcessFunction(schema, type) {
-	return (value) => {
-		try {
-			let processSchema = schema;
-			if (type === "number") processSchema = zod.z.coerce.number();
-			else if (type === "boolean") processSchema = zod.z.string().transform((val) => {
-				const lower = val.toLowerCase().trim();
-				if ([
-					"true",
-					"1",
-					"yes",
-					"on",
-					"enabled"
-				].includes(lower)) return true;
-				if ([
-					"false",
-					"0",
-					"no",
-					"off",
-					"disabled"
-				].includes(lower)) return false;
-				throw new Error(`Expected boolean value, received "${val}"`);
-			});
-			const result = processSchema.safeParse(value);
-			if (result.success) return result.data;
-			throw new Error(`Failed to parse value "${value}": ${result.error.issues.map((issue) => issue.message).join("; ")}`);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			throw new Error(message);
-		}
-	};
-}
-/**
-* Convert Zod v3 schema to EnvVarSchema
-*/
-function convertFromZodV3Schema(schema) {
-	const peeled = peelV3Schema(schema);
-	const type = resolveV3EnvVarType(peeled.schema);
-	const def = getV3Def(peeled.schema);
-	switch (type) {
-		case "boolean": return new BooleanEnvVarSchema({
-			process: createV3ProcessFunction(peeled.schema, "boolean"),
-			required: peeled.required,
-			default: typeof peeled.default === "boolean" ? peeled.default : void 0,
-			description: peeled.description
-		});
-		case "number": return new NumberEnvVarSchema({
-			process: createV3ProcessFunction(peeled.schema, "number"),
-			required: peeled.required,
-			default: typeof peeled.default === "number" ? peeled.default : void 0,
-			description: peeled.description
-		});
-		case "enum": {
-			const values = extractV3EnumValues(def) || [];
-			return new EnumEnvVarSchema({
-				process: createV3ProcessFunction(peeled.schema, "enum"),
-				values,
-				required: peeled.required,
-				default: typeof peeled.default === "string" ? peeled.default : void 0,
-				description: peeled.description
-			});
-		}
-		case "string":
-		default: {
-			const process$1 = createV3ProcessFunction(peeled.schema, "string");
-			const defaultValue = typeof peeled.default === "string" ? peeled.default : void 0;
-			return new StringEnvVarSchema({
-				process: process$1,
-				required: peeled.required,
-				default: defaultValue,
-				description: peeled.description
-			});
-		}
-	}
-}
-
-//#endregion
-//#region ../converters/src/converters/zod/ZodV4Converter.ts
-/**
-* Zod v4 schema converter implementation
-*/
-var ZodV4Converter = class {
-	applies(schema) {
-		return isZodV4Schema(schema);
-	}
-	convert(schema) {
-		return convertFromZodV4Schema(schema);
-	}
-};
-/**
-* Check if a schema is a Zod v4 schema
-*/
-function isZodV4Schema(schema) {
-	if (!schema || typeof schema !== "object") return false;
-	return "_zod" in schema;
-}
-/**
-* Extract definition from Zod v4 schema
-*/
-function getV4Def(schema) {
-	const container = schema;
-	if (container._zod && container._zod.def) return container._zod.def;
-	return {};
-}
-/**
-* Get the type name from a Zod v4 definition
-*/
-function getV4TypeName(def) {
-	return def.type || "unknown";
-}
-/**
-* Check if a type is a wrapper type that should be unwrapped
-*/
-function isV4WrapperType(typeName) {
-	return [
-		"optional",
-		"default",
-		"catch",
-		"readonly",
-		"brand",
-		"prefault",
-		"nullable",
-		"nullish"
-	].includes(typeName);
-}
-/**
-* Get inner schema from wrapper
-*/
-function getV4InnerSchema(def) {
-	return def.innerType || def.schema || def.in || def.inner;
-}
-/**
-* Get default value from definition
-*/
-function getV4DefaultValue(def) {
-	if (def.defaultValue !== void 0) return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
-	if (def.prefaultValue !== void 0) return typeof def.prefaultValue === "function" ? def.prefaultValue() : def.prefaultValue;
-}
-/**
-* Extract enum values from schema
-*/
-function extractV4EnumValues(def) {
-	if (Array.isArray(def.values)) return def.values.map((v) => String(v));
-	if (def.entries && typeof def.entries === "object") return Object.values(def.entries).map((v) => String(v));
-}
-/**
-* Get description from schema
-*/
-function getV4Description(schema, def) {
-	const directDesc = schema.description;
-	if (typeof directDesc === "string" && directDesc.length > 0) return directDesc;
-	if (typeof def.description === "string" && def.description.length > 0) return def.description;
-	const metaFn = schema.meta;
-	if (typeof metaFn === "function") {
-		const meta = metaFn.call(schema);
-		if (meta?.description && typeof meta.description === "string") return meta.description.trim();
-	}
-}
-/**
-* Resolve environment variable type from schema
-*/
-function resolveV4EnvVarType(schema) {
-	const def = getV4Def(schema);
-	switch (getV4TypeName(def)) {
-		case "string": return "string";
-		case "number":
-		case "int": return "number";
-		case "boolean":
-		case "stringbool": return "boolean";
-		case "pipe":
-			if (def.in && def.out) {
-				const inType = resolveV4EnvVarType(def.in);
-				const outType = resolveV4EnvVarType(def.out);
-				if (inType === "string" && outType === "boolean") return "boolean";
-			}
-			return "string";
-		case "enum": return "enum";
-		default:
-			if (def.values || def.entries) return "enum";
-			return "string";
-	}
-}
-function peelV4Schema(schema) {
-	let current = schema;
-	let required = true;
-	let defaultValue = void 0;
-	let description = void 0;
-	for (let i = 0; i < 20; i++) {
-		const def = getV4Def(current);
-		const typeName = getV4TypeName(def);
-		if (!description) description = getV4Description(current, def);
-		if (!isV4WrapperType(typeName)) if (typeName === "pipe" && def.in && def.out) {
-			const inType = resolveV4EnvVarType(def.in);
-			const outType = resolveV4EnvVarType(def.out);
-			if (inType === "string" && outType === "boolean") break;
-		} else break;
-		if (typeName === "optional" || typeName === "nullish") required = false;
-		if ((typeName === "default" || typeName === "prefault") && defaultValue === void 0) defaultValue = getV4DefaultValue(def);
-		const inner = getV4InnerSchema(def);
-		if (!inner) break;
-		current = inner;
-	}
-	return {
-		schema: current,
-		required,
-		default: defaultValue,
-		description
-	};
-}
-/**
-* Create a process function for Zod v4 schemas
-*/
-function createV4ProcessFunction(schema, type, originalSchema) {
-	return (value) => {
-		try {
-			let processSchema = schema;
-			const def = getV4Def(schema);
-			const typeName = getV4TypeName(def);
-			if (typeName === "stringbool" || typeName === "pipe" && def.in && def.out && resolveV4EnvVarType(def.in) === "string" && resolveV4EnvVarType(def.out) === "boolean") processSchema = originalSchema;
-			else if (type === "number") processSchema = zod.z.coerce.number();
-			else if (type === "boolean") processSchema = zod.z.stringbool();
-			const result = zod_v4_core.safeParse(processSchema, value);
-			if (result.success) return result.data;
-			throw new Error(`Failed to parse value "${value}": ${result.error.issues.map((issue) => issue.message).join("; ")}`);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			throw new Error(message);
-		}
-	};
-}
-/**
-* Convert Zod v4 schema to EnvVarSchema
-*/
-function convertFromZodV4Schema(schema) {
-	const peeled = peelV4Schema(schema);
-	const type = resolveV4EnvVarType(peeled.schema);
-	const def = getV4Def(peeled.schema);
-	switch (type) {
-		case "boolean": return new BooleanEnvVarSchema({
-			process: createV4ProcessFunction(peeled.schema, "boolean", schema),
-			required: peeled.required,
-			default: typeof peeled.default === "boolean" ? peeled.default : void 0,
-			description: peeled.description
-		});
-		case "number": return new NumberEnvVarSchema({
-			process: createV4ProcessFunction(peeled.schema, "number", schema),
-			required: peeled.required,
-			default: typeof peeled.default === "number" ? peeled.default : void 0,
-			description: peeled.description
-		});
-		case "enum": {
-			const values = extractV4EnumValues(def) || [];
-			return new EnumEnvVarSchema({
-				process: createV4ProcessFunction(peeled.schema, "enum", schema),
-				values,
-				required: peeled.required,
-				default: typeof peeled.default === "string" ? peeled.default : void 0,
-				description: peeled.description
-			});
-		}
-		case "string":
-		default: {
-			const process$1 = createV4ProcessFunction(peeled.schema, "string", schema);
-			const defaultValue = typeof peeled.default === "string" ? peeled.default : void 0;
-			return new StringEnvVarSchema({
-				process: process$1,
-				required: peeled.required,
-				default: defaultValue,
-				description: peeled.description
-			});
-		}
-	}
-}
-
-//#endregion
-//#region ../converters/src/converters/joi/JoiConverter.ts
-/**
-* Joi schema converter implementation
-*/
-var JoiConverter = class {
-	applies(schema) {
-		return isJoiSchema(schema);
-	}
-	convert(schema) {
-		return convertFromJoiSchema(schema);
-	}
-};
-/**
-* Check if a schema is a Joi schema using the official API
-*/
-function isJoiSchema(schema) {
-	if (!schema || typeof schema !== "object") return false;
-	const candidate = schema;
-	if (!(typeof candidate.describe === "function" && typeof candidate.validate === "function")) return false;
-	if (candidate.isJoi === true) return true;
-	const hasAsyncVariant = typeof candidate.validateAsync === "function";
-	const hasRoot = typeof candidate.$_root === "object" && candidate.$_root !== null;
-	const hasFlags = typeof candidate._flags === "object" && candidate._flags !== null;
-	return hasAsyncVariant || hasRoot || hasFlags;
-}
-/**
-* Get description from Joi schema using public API first, internal as fallback
-*/
-function getJoiDescription(schema) {
-	try {
-		return schema.describe()?.flags?.description;
-	} catch {
-		return schema._flags?.description;
-	}
-}
-/**
-* Check if schema is required using public API first, internal as fallback
-*/
-function isJoiRequired(schema) {
-	try {
-		const presence = schema.describe()?.flags?.presence;
-		if (presence === "required") return true;
-		if (presence === "optional") return false;
-		return presence === void 0;
-	} catch {
-		const flags = schema._flags;
-		if (flags?.presence === "required") return true;
-		if (flags?.presence === "optional") return false;
-		return true;
-	}
-}
-/**
-* Get default value from Joi schema using public API first, internal as fallback
-*/
-function getJoiDefaultValue(schema) {
-	try {
-		const defaultValue = schema.describe()?.flags?.default;
-		return typeof defaultValue === "function" ? defaultValue() : defaultValue;
-	} catch {
-		const flags = schema._flags;
-		if (flags?.default !== void 0) {
-			const defaultValue = flags.default;
-			return typeof defaultValue === "function" ? defaultValue() : defaultValue;
-		}
-		return;
-	}
-}
-/**
-* Get valid values for enum-like schemas using public API first, internal as fallback
-*/
-function getJoiValidValues(schema) {
-	const values = [];
-	let isOnlySchema = false;
-	try {
-		const description = schema.describe();
-		if (description?.allow && Array.isArray(description.allow)) values.push(...description.allow);
-		isOnlySchema = description?.flags?.only === true;
-	} catch {
-		if (schema._valids?._values) values.push(...Array.from(schema._valids._values));
-		isOnlySchema = schema._flags?.only === true;
-	}
-	if (isOnlySchema && values.length > 0) return values.map((v) => String(v));
-}
-/**
-* Resolve environment variable type from Joi schema using public API first, internal as fallback
-*/
-function resolveJoiEnvVarType(schema) {
-	let type;
-	const exposedSchema = schema;
-	try {
-		type = schema.describe()?.type;
-	} catch {
-		type = exposedSchema._type || schema.type;
-	}
-	const validValues = getJoiValidValues(schema);
-	if (validValues && validValues.length > 0) return "enum";
-	switch (type) {
-		case "string": return "string";
-		case "number": return "number";
-		case "boolean": return "boolean";
-		default: return "string";
-	}
-}
-/**
-* Create a process function for Joi schemas
-*/
-function createJoiProcessFunction(schema, type) {
-	return (value) => {
-		try {
-			let processValue$1 = value;
-			if (type === "number") {
-				const num = Number(value);
-				if (Number.isNaN(num)) throw new Error(`Expected number, received "${value}"`);
-				processValue$1 = num;
-			} else if (type === "boolean") {
-				const lower = value.toLowerCase().trim();
-				if ([
-					"true",
-					"1",
-					"yes",
-					"on",
-					"enabled"
-				].includes(lower)) processValue$1 = true;
-				else if ([
-					"false",
-					"0",
-					"no",
-					"off",
-					"disabled"
-				].includes(lower)) processValue$1 = false;
-				else throw new Error(`Expected boolean value, received "${value}"`);
-			}
-			const result = schema.validate(processValue$1, { convert: true });
-			if (result.error) {
-				const message = result.error.details ? result.error.details.map((d) => d.message).join("; ") : result.error.message || String(result.error);
-				throw new Error(`Validation failed: ${message}`);
-			}
-			return result.value;
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			throw new Error(message);
-		}
-	};
-}
-/**
-* Convert Joi schema to EnvVarSchema
-*/
-function convertFromJoiSchema(schema) {
-	const type = resolveJoiEnvVarType(schema);
-	const required = isJoiRequired(schema);
-	const defaultValue = getJoiDefaultValue(schema);
-	const description = getJoiDescription(schema);
-	switch (type) {
-		case "boolean": return new BooleanEnvVarSchema({
-			process: createJoiProcessFunction(schema, "boolean"),
-			required,
-			default: typeof defaultValue === "boolean" ? defaultValue : void 0,
-			description
-		});
-		case "number": return new NumberEnvVarSchema({
-			process: createJoiProcessFunction(schema, "number"),
-			required,
-			default: typeof defaultValue === "number" ? defaultValue : void 0,
-			description
-		});
-		case "enum": {
-			const values = getJoiValidValues(schema) || [];
-			return new EnumEnvVarSchema({
-				process: createJoiProcessFunction(schema, "enum"),
-				values,
-				required,
-				default: typeof defaultValue === "string" ? defaultValue : void 0,
-				description
-			});
-		}
-		case "string":
-		default: return new StringEnvVarSchema({
-			process: createJoiProcessFunction(schema, "string"),
-			required,
-			default: typeof defaultValue === "string" ? defaultValue : void 0,
-			description
-		});
-	}
-}
-
-//#endregion
-//#region ../converters/src/converters/superstruct/SuperstructConverter.ts
-/**
-* Superstruct schema converter implementation
-*/
-var SuperstructConverter = class {
-	applies(schema) {
-		return isSuperstructSchema(schema);
-	}
-	convert(schema) {
-		return convertFromSuperstruct(schema);
-	}
-};
-/**
-* Detect if a value looks like a Superstruct Struct instance
-*/
-function isSuperstructSchema(value) {
-	if (!value || typeof value !== "object") return false;
-	const candidate = value;
-	return typeof candidate.type === "string" && typeof candidate.validate === "function" && typeof candidate.create === "function";
-}
-/**
-* Convert a Superstruct schema to an EnvVarSchema
-*/
-function convertFromSuperstruct(schema) {
-	const resolvedType = resolveSuperstructEnvVarType(schema);
-	const required = isStructRequired(schema);
-	const description = getStructDescription(schema);
-	const defaultValue = getStructDefault(schema);
-	if (resolvedType === "enum") {
-		const values = extractEnumValues(schema);
-		if (!values || values.length === 0) return createStringEnvVarSchema(schema, required, defaultValue, description);
-		const readonlyValues = values;
-		return new EnumEnvVarSchema({
-			process: createSuperstructProcessFunction(schema, "enum"),
-			values: readonlyValues,
-			required,
-			default: typeof defaultValue === "string" ? defaultValue : void 0,
-			description
-		});
-	}
-	if (resolvedType === "boolean") return new BooleanEnvVarSchema({
-		process: createSuperstructProcessFunction(schema, "boolean"),
-		required,
-		default: typeof defaultValue === "boolean" ? defaultValue : void 0,
-		description
-	});
-	if (resolvedType === "number") return new NumberEnvVarSchema({
-		process: createSuperstructProcessFunction(schema, "number"),
-		required,
-		default: typeof defaultValue === "number" ? defaultValue : void 0,
-		description
-	});
-	return createStringEnvVarSchema(schema, required, defaultValue, description);
-}
-function createStringEnvVarSchema(schema, required, defaultValue, description) {
-	return new StringEnvVarSchema({
-		process: createSuperstructProcessFunction(schema, "string"),
-		required,
-		default: typeof defaultValue === "string" ? defaultValue : void 0,
-		description
-	});
-}
-function resolveSuperstructEnvVarType(schema) {
-	switch (getStructType(schema)) {
-		case "boolean": return "boolean";
-		case "number":
-		case "integer": return "number";
-		case "enums": return "enum";
-		case "literal": return typeof schema.schema === "string" ? "enum" : "string";
-		default: return "string";
-	}
-}
-function getStructType(schema) {
-	const typeValue = schema.type;
-	return typeof typeValue === "string" ? typeValue : "unknown";
-}
-function extractEnumValues(schema) {
-	const typeName = getStructType(schema);
-	if (typeName === "enums") {
-		const structSchema = schema.schema;
-		if (structSchema && typeof structSchema === "object") {
-			const rawValues = Object.values(structSchema);
-			if (rawValues.every((value) => typeof value === "string")) return rawValues;
-		}
-	}
-	if (typeName === "literal") {
-		const value = schema.schema;
-		if (typeof value === "string") return [value];
-	}
-}
-function isStructRequired(schema) {
-	try {
-		const [error] = schema.validate(void 0);
-		return !!error;
-	} catch {
-		return true;
-	}
-}
-function getStructDefault(schema) {
-	try {
-		const [error, value] = schema.validate(void 0, { coerce: true });
-		if (!error && value !== void 0) return value;
-	} catch {}
-}
-function getStructDescription(schema) {
-	const structSchema = schema.schema;
-	if (structSchema && typeof structSchema === "object" && typeof structSchema.description === "string") return structSchema.description;
-	if (typeof schema.description === "string") return schema.description;
-}
-function createSuperstructProcessFunction(schema, type) {
-	return (value) => {
-		if (typeof value !== "string") throw new Error("Value must be a string");
-		let candidate = value;
-		if (type === "number") {
-			const trimmed = value.trim();
-			if (trimmed === "") candidate = void 0;
-			else {
-				const parsed = Number(trimmed);
-				if (Number.isNaN(parsed) || !Number.isFinite(parsed)) throw new Error(`"${value}" is not a valid number`);
-				candidate = parsed;
-			}
-		} else if (type === "boolean") {
-			const trimmed = value.trim().toLowerCase();
-			if (trimmed === "") candidate = void 0;
-			else if ([
-				"true",
-				"1",
-				"yes",
-				"on",
-				"enabled"
-			].includes(trimmed)) candidate = true;
-			else if ([
-				"false",
-				"0",
-				"no",
-				"off",
-				"disabled"
-			].includes(trimmed)) candidate = false;
-			else throw new Error(`"${value}" is not a valid boolean. Use: true/false, 1/0, yes/no, on/off, or enabled/disabled`);
-		} else if (value === "") candidate = void 0;
-		const [error, result] = schema.validate(candidate, { coerce: true });
-		if (error) throw new Error(error.message);
-		return result;
-	};
-}
-
-//#endregion
-//#region ../converters/src/converters.ts
-/**
-* Registry of available schema converters
-*/
-const converters = [
-	new ZodV4Converter(),
-	new ZodV3Converter(),
-	new JoiConverter(),
-	new SuperstructConverter()
-];
-
-//#endregion
-//#region ../models/src/resolve.ts
-/**
-* Resolve any supported schema to a EnvVarSchema.
-*
-* This is the main entry point for converting external schemas
-* (like Zod schemas) to envcredible's internal schema format.
-* If the input is already a EnvVarSchema, it returns it directly.
-*
-* @param schema - The schema to convert (e.g., Zod v3/v4 schema or EnvVarSchema)
-* @returns EnvVarSchema that can be used with envcredible
-* @throws Error if no converter can handle the schema
-*/
-function resolveSchema(schema) {
-	if (isEnvVarSchema(schema)) return schema;
-	for (const converter of converters) if (converter.applies(schema)) return converter.convert(schema);
-	throw new Error(`No converter found for schema. Supported types: Zod v3, Zod v4, Joi, Superstruct, EnvVarSchema. Received: ${typeof schema}`);
-}
-/**
-* Resolve mixed schema map (Zod schemas or EnvVarSchema) to pure EnvVarSchema map.
-*
-* This function takes a map where values can be:
-* - Zod v3 schemas
-* - Zod v4 schemas
-* - Already resolved EnvVarSchema instances
-*
-* And converts everything to EnvVarSchema instances that can be used throughout envcredible.
-*
-* @param schemas - Object mapping environment variable names to various schema types
-* @returns Record mapping env var names to EnvVarSchema instances
-*/
-function resolveSchemas(schemas) {
-	const resolved = {};
-	for (const [key, schema] of Object.entries(schemas)) try {
-		resolved[key] = resolveSchema(schema);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to resolve schema for environment variable "${key}": ${message}`);
-	}
-	return resolved;
-}
-
-//#endregion
-//#region ../models/src/EnvModel.ts
-/**
-* Environment variable specification container
-* Encapsulates schemas and preprocessor configuration
-*/
-var EnvModel = class {
-	/**
-	* Resolved environment variable schemas
-	*/
-	schemas;
-	/**
-	* Preprocessing configuration for environment variable types
-	*/
-	preprocess;
-	/**
-	* Create an EnvModel instance from options
-	* @param options - Specification options
-	*/
-	constructor(options) {
-		this.schemas = resolveSchemas(options.schemas);
-		this.preprocess = this.resolvePreprocessors(options.preprocess);
-	}
-	/**
-	* Resolve preprocessor configuration from options
-	* @param config - Preprocessor configuration (true, false, or partial object)
-	* @returns Resolved preprocessors object
-	*/
-	resolvePreprocessors(config) {
-		if (config === false) return {
-			string: false,
-			number: false,
-			boolean: false,
-			enum: false
-		};
-		if (config === true || config === void 0) return {};
-		return { ...config };
-	}
-};
-
-//#endregion
-//#region ../models/src/model.ts
-/**
-* Create an environment variable model
-*
-* Sugar utility for creating EnvModel instances with full type inference
-*
-* @param options - Model options
-* @returns EnvModel instance with inferred types
-*
-* @example
-* ```typescript
-* import { define, s } from "@e-n-v/models";
-*
-* export default define({
-*   schemas: {
-*     PORT: s.number({ default: 3000 }),
-*     DATABASE_URL: s.string(),
-*     DEBUG: s.boolean({ default: false })
-*   },
-*   preprocess: true
-* });
-* ```
-*/
-function define(options) {
-	return new EnvModel(options);
-}
+const require_chunk = require('./chunk-pbleEpgJ.cjs');
+const require_resolveChannel = require('./resolveChannel-CjAuxy3p.cjs');
+const require_src = require('./src-meUnCASg.cjs');
+const require_src$1 = require('./src-XjL5cyPG.cjs');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_url = require("node:url");
+node_url = require_chunk.__toESM(node_url);
+let node_process = require("node:process");
+node_process = require_chunk.__toESM(node_process);
+let __clack_core = require("@clack/core");
+__clack_core = require_chunk.__toESM(__clack_core);
+let picocolors = require("picocolors");
+picocolors = require_chunk.__toESM(picocolors);
+let node_readline = require("node:readline");
+node_readline = require_chunk.__toESM(node_readline);
 
-//#endregion
 //#region ../prompt/src/options/defaults.ts
-var defaults_exports = /* @__PURE__ */ __export({
+var defaults_exports = /* @__PURE__ */ require_chunk.__export({
 	ENV_PATH: () => ENV_PATH,
 	SECRET_PATTERNS: () => SECRET_PATTERNS,
 	TRUNCATE_LENGTH: () => TRUNCATE_LENGTH
@@ -1764,7 +27,7 @@ const SECRET_PATTERNS = Object.freeze([
 	/password/i,
 	/passphrase/i,
 	/secret/i,
-	/token/i,
+	/(?<!expires[_-]?in[_-]?)token(?![_-]?(?:expires|expiry|expiration|ttl|lifetime|duration|age|max[_-]?age|validity))/i,
 	/api[_-]?key/i,
 	/client[_-]?secret/i,
 	/private[_-]?key/i,
@@ -2251,28 +514,18 @@ function processValue(envKey, value, schema, preprocess) {
 		};
 		const activePreprocessor = (() => {
 			if (preprocess === false) return;
-			if (preprocess === true) return resolvePreprocessor(schema.type, { [schema.type]: true });
+			if (preprocess === true) return require_src.resolvePreprocessor(schema.type, { [schema.type]: true });
 			if (typeof preprocess === "function") return preprocess;
-			return resolvePreprocessor(schema.type);
+			return require_src.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
-		};
+		let stringValue;
+		if (typeof processedValue === "boolean") stringValue = String(processedValue);
+		else if (typeof processedValue === "number") stringValue = String(processedValue);
+		else if (typeof processedValue === "string") stringValue = processedValue;
+		else stringValue = value;
 		return {
-			value: schema.process(value),
+			value: schema.process(stringValue),
 			rawValue: value,
 			isValid: true
 		};
@@ -3665,10 +1918,10 @@ function createPrompt({ key, schema, currentValue, theme, truncate, shouldMask,
 			const booleanOverride = preprocessors$1?.boolean;
 			let booleanPreprocess;
 			if (booleanOverride === void 0) booleanPreprocess = void 0;
-			else if (booleanOverride === true) booleanPreprocess = booleanPreprocessor();
+			else if (booleanOverride === true) booleanPreprocess = require_src.preprocessors.boolean();
 			else if (booleanOverride === false) booleanPreprocess = false;
 			else if (typeof booleanOverride === "function") booleanPreprocess = booleanOverride;
-			else booleanPreprocess = booleanPreprocessor(booleanOverride);
+			else booleanPreprocess = require_src.preprocessors.boolean(booleanOverride);
 			return new EnvBooleanPrompt(schema, {
 				...baseOptions,
 				current: currentValue,
@@ -3863,7 +2116,7 @@ async function prompt(modelOrOptions, interactiveOptions) {
 	let schemas;
 	let preprocessConfig;
 	let finalOptions;
-	if (modelOrOptions instanceof EnvModel) {
+	if (modelOrOptions instanceof require_src$1.EnvModel) {
 		const model = modelOrOptions;
 		finalOptions = interactiveOptions || {};
 		schemas = model.schemas;
@@ -3872,7 +2125,7 @@ async function prompt(modelOrOptions, interactiveOptions) {
 		const options = modelOrOptions;
 		finalOptions = options;
 		if (options.schemas) {
-			schemas = resolveSchemas(options.schemas);
+			schemas = require_src$1.resolveSchemas(options.schemas);
 			preprocessConfig = options.preprocess;
 		} else throw new Error("Either provide a model or schemas in options");
 	}
@@ -3882,7 +2135,7 @@ async function prompt(modelOrOptions, interactiveOptions) {
 	const secrets = finalOptions.secrets ?? SECRET_PATTERNS;
 	const input = node_process.stdin;
 	const output = node_process.stdout;
-	const channel = isEnvChannel(finalOptions.channel) ? finalOptions.channel : resolveChannel(finalOptions.channel, path);
+	const channel = isEnvChannel(finalOptions.channel) ? finalOptions.channel : require_resolveChannel.resolveChannel(finalOptions.channel, path);
 	const theme = resolveTheme(finalOptions.theme);
 	await new Session({
 		schemas,
@@ -3898,201 +2151,15 @@ async function prompt(modelOrOptions, interactiveOptions) {
 }
 
 //#endregion
-Object.defineProperty(exports, 'BooleanEnvVarSchema', {
-  enumerable: true,
-  get: function () {
-    return BooleanEnvVarSchema;
-  }
-});
-Object.defineProperty(exports, 'DefaultEnvChannel', {
-  enumerable: true,
-  get: function () {
-    return DefaultEnvChannel;
-  }
-});
-Object.defineProperty(exports, 'DotEnvChannel', {
-  enumerable: true,
-  get: function () {
-    return DotEnvChannel;
-  }
-});
-Object.defineProperty(exports, 'DotEnvXChannel', {
-  enumerable: true,
-  get: function () {
-    return DotEnvXChannel;
-  }
-});
-Object.defineProperty(exports, 'EnumEnvVarSchema', {
-  enumerable: true,
-  get: function () {
-    return EnumEnvVarSchema;
-  }
-});
-Object.defineProperty(exports, 'EnvModel', {
-  enumerable: true,
-  get: function () {
-    return EnvModel;
-  }
-});
-Object.defineProperty(exports, 'EnvSource', {
-  enumerable: true,
-  get: function () {
-    return EnvSource;
-  }
-});
-Object.defineProperty(exports, 'EnvVarSchemaBase', {
-  enumerable: true,
-  get: function () {
-    return EnvVarSchemaBase;
-  }
-});
-Object.defineProperty(exports, 'NumberEnvVarSchema', {
-  enumerable: true,
-  get: function () {
-    return NumberEnvVarSchema;
-  }
-});
-Object.defineProperty(exports, 'ProcessEnvChannel', {
-  enumerable: true,
-  get: function () {
-    return ProcessEnvChannel;
-  }
-});
-Object.defineProperty(exports, 'StringEnvVarSchema', {
-  enumerable: true,
-  get: function () {
-    return StringEnvVarSchema;
-  }
-});
-Object.defineProperty(exports, '__export', {
-  enumerable: true,
-  get: function () {
-    return __export;
-  }
-});
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});
-Object.defineProperty(exports, 'booleanPreprocessor', {
-  enumerable: true,
-  get: function () {
-    return booleanPreprocessor;
-  }
-});
-Object.defineProperty(exports, 'booleanProcessor', {
-  enumerable: true,
-  get: function () {
-    return booleanProcessor;
-  }
-});
 Object.defineProperty(exports, 'defaults_exports', {
   enumerable: true,
   get: function () {
     return defaults_exports;
   }
 });
-Object.defineProperty(exports, 'define', {
-  enumerable: true,
-  get: function () {
-    return define;
-  }
-});
-Object.defineProperty(exports, 'enumPreprocessor', {
-  enumerable: true,
-  get: function () {
-    return enumPreprocessor;
-  }
-});
-Object.defineProperty(exports, 'enumProcessor', {
-  enumerable: true,
-  get: function () {
-    return enumProcessor;
-  }
-});
-Object.defineProperty(exports, 'get', {
-  enumerable: true,
-  get: function () {
-    return get;
-  }
-});
-Object.defineProperty(exports, 'isEnvVarSchema', {
-  enumerable: true,
-  get: function () {
-    return isEnvVarSchema;
-  }
-});
-Object.defineProperty(exports, 'numberPreprocessor', {
-  enumerable: true,
-  get: function () {
-    return numberPreprocessor;
-  }
-});
-Object.defineProperty(exports, 'numberProcessor', {
-  enumerable: true,
-  get: function () {
-    return numberProcessor;
-  }
-});
-Object.defineProperty(exports, 'preprocessors', {
-  enumerable: true,
-  get: function () {
-    return preprocessors;
-  }
-});
-Object.defineProperty(exports, 'processors', {
-  enumerable: true,
-  get: function () {
-    return processors;
-  }
-});
 Object.defineProperty(exports, 'prompt', {
   enumerable: true,
   get: function () {
     return prompt;
   }
-});
-Object.defineProperty(exports, 'resolveChannel', {
-  enumerable: true,
-  get: function () {
-    return resolveChannel;
-  }
-});
-Object.defineProperty(exports, 'resolvePreprocessor', {
-  enumerable: true,
-  get: function () {
-    return resolvePreprocessor;
-  }
-});
-Object.defineProperty(exports, 'resolveSchema', {
-  enumerable: true,
-  get: function () {
-    return resolveSchema;
-  }
-});
-Object.defineProperty(exports, 'resolveSchemas', {
-  enumerable: true,
-  get: function () {
-    return resolveSchemas;
-  }
-});
-Object.defineProperty(exports, 'set', {
-  enumerable: true,
-  get: function () {
-    return set;
-  }
-});
-Object.defineProperty(exports, 'stringPreprocessor', {
-  enumerable: true,
-  get: function () {
-    return stringPreprocessor;
-  }
-});
-Object.defineProperty(exports, 'stringProcessor', {
-  enumerable: true,
-  get: function () {
-    return stringProcessor;
-  }
 });