@e-n-v/env 0.0.1 → 0.0.4

package/dist/{src-RlCvrI0s.js → src-Dtv7TlJx.js}

@@ -1,1716 +1,14 @@
 import { t as __export } from "./chunk-Bp6m_JJh.js";
-import { mkdirSync, promises, readFileSync, writeFileSync } from "node:fs";
+import { t as resolveChannel } from "./resolveChannel-v9BDsw-M.js";
+import { i as preprocessors, r as resolvePreprocessor } from "./src-CLTURaoo.js";
+import { i as resolveSchemas, n as EnvModel } from "./src-CVdUqK3q.js";
 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 { fileURLToPath, pathToFileURL } from "node:url";
 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,
@@ -1723,7 +21,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,
@@ -2215,23 +513,13 @@ function processValue(envKey, value, schema, 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
-		};
+		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
 		};
@@ -3624,10 +1912,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 = preprocessors.boolean();
 			else if (booleanOverride === false) booleanPreprocess = false;
 			else if (typeof booleanOverride === "function") booleanPreprocess = booleanOverride;
-			else booleanPreprocess = booleanPreprocessor(booleanOverride);
+			else booleanPreprocess = preprocessors.boolean(booleanOverride);
 			return new EnvBooleanPrompt(schema, {
 				...baseOptions,
 				current: currentValue,
@@ -3857,4 +2145,4 @@ async function prompt(modelOrOptions, interactiveOptions) {
 }
 
 //#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 };
+export { defaults_exports as n, prompt as t };