ultraenv 1.0.0

package/dist/chunk-CIFMBJ4H.js

@@ -0,0 +1,3975 @@
+// src/schema/builder.ts
+var SchemaBuilder = class _SchemaBuilder {
+  /** Internal parser function: string → ParseResult<TOutput> */
+  _parser;
+  /** Ordered list of validator functions: value → error message or null */
+  _validators;
+  /** Ordered list of transform functions applied after validation */
+  _transforms;
+  /** Schema metadata */
+  _meta;
+  constructor(parser, typeName) {
+    this._parser = parser;
+    this._validators = [];
+    this._transforms = [];
+    this._meta = {
+      typeName,
+      required: true,
+      hasDefault: false,
+      isSecret: false,
+      isDeprecated: false,
+      aliases: []
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Core Parsing & Validation
+  // -------------------------------------------------------------------------
+  /**
+   * Parse a raw string value into the output type.
+   * Runs the parser, then all validators and transforms.
+   */
+  _parse(raw) {
+    const parsed = this._parser(raw);
+    if (!parsed.success) {
+      return parsed;
+    }
+    const validationError = this._validate(parsed.value);
+    if (validationError !== null) {
+      return { success: false, error: validationError };
+    }
+    const transformed = this._applyTransforms(parsed.value);
+    return { success: true, value: transformed };
+  }
+  /**
+   * Validate an already-parsed value against all registered validators.
+   * Returns an error message string, or null if validation passes.
+   */
+  _validate(value) {
+    for (const validator of this._validators) {
+      const error = validator(value);
+      if (error !== null) {
+        return error;
+      }
+    }
+    return null;
+  }
+  // -------------------------------------------------------------------------
+  // Metadata Accessors
+  // -------------------------------------------------------------------------
+  /** Get a readonly view of the schema metadata */
+  get meta() {
+    return this._meta;
+  }
+  /** Whether this schema is effectively optional (marked optional or has default) */
+  get isOptional() {
+    return !this._meta.required || this._meta.hasDefault;
+  }
+  /** The runtime type name string */
+  get typeName() {
+    return this._meta.typeName;
+  }
+  /** Get the default value, parsing it if a raw default exists */
+  getDefaultValue() {
+    if (!this._meta.hasDefault || this._meta.rawDefaultValue === void 0) {
+      return void 0;
+    }
+    const result = this._parse(this._meta.rawDefaultValue);
+    return result.success ? result.value : void 0;
+  }
+  /** Return a composed reference to this builder for chaining */
+  get chain() {
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Modifiers — Description & Example
+  // -------------------------------------------------------------------------
+  /** Add a human-readable description */
+  description(desc) {
+    this._meta = { ...this._meta, description: desc };
+    return this;
+  }
+  /** Set an example value for documentation */
+  example(ex) {
+    this._meta = { ...this._meta, example: String(ex) };
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Modifiers — Required / Optional / Default
+  // -------------------------------------------------------------------------
+  /**
+   * Mark this field as optional. The output type becomes `TOutput | undefined`.
+   */
+  optional() {
+    this._meta = { ...this._meta, required: false };
+    return this;
+  }
+  /**
+   * Mark this field as required.
+   */
+  required() {
+    this._meta = { ...this._meta, required: true };
+    return this;
+  }
+  /**
+   * Set a default value. The field becomes effectively optional.
+   * The output type remains `TOutput` (guaranteed by the default).
+   */
+  default(value) {
+    this._meta = {
+      ...this._meta,
+      hasDefault: true,
+      required: false,
+      rawDefaultValue: String(value)
+    };
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Modifiers — Secret & Deprecated
+  // -------------------------------------------------------------------------
+  /** Mark this field as a secret (masks in logs) */
+  secret() {
+    this._meta = { ...this._meta, isSecret: true };
+    return this;
+  }
+  /** Mark this field as deprecated with a message */
+  deprecated(message) {
+    this._meta = { ...this._meta, isDeprecated: true, deprecationMessage: message };
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Modifiers — Alias
+  // -------------------------------------------------------------------------
+  /** Add alternative variable names */
+  alias(...names) {
+    this._meta = { ...this._meta, aliases: [...this._meta.aliases, ...names] };
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Modifiers — Transform & Custom Validation
+  // -------------------------------------------------------------------------
+  /** Add a transform function applied after validation */
+  transform(fn) {
+    this._transforms = [...this._transforms, fn];
+    return this;
+  }
+  /** Add a custom validation function */
+  custom(fn) {
+    this._validators = [...this._validators, fn];
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Modifiers — Conditional
+  // -------------------------------------------------------------------------
+  /**
+   * Apply this schema only when a condition is met.
+   * The condition receives the current env values.
+   */
+  when(check2) {
+    this._meta = { ...this._meta, conditional: { check: check2 } };
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Internal Methods
+  // -------------------------------------------------------------------------
+  /** Add a validator function (used by type-specific subclasses) */
+  _addValidator(validator) {
+    this._validators = [...this._validators, validator];
+  }
+  /** Add a transform function (used by type-specific subclasses) */
+  _addTransform(fn) {
+    this._transforms = [...this._transforms, fn];
+  }
+  /** Replace the parser function (used for type narrowing) */
+  _setParser(parser) {
+    this._parser = parser;
+  }
+  /** Apply all transforms to a value */
+  _applyTransforms(value) {
+    let result = value;
+    for (const transform of this._transforms) {
+      result = transform(result);
+    }
+    return result;
+  }
+  /** Clone this builder (for composition) */
+  clone() {
+    const cloned = new _SchemaBuilder(this._parser, this._meta.typeName);
+    cloned._validators = [...this._validators];
+    cloned._transforms = [...this._transforms];
+    cloned._meta = { ...this._meta, aliases: [...this._meta.aliases] };
+    return cloned;
+  }
+};
+
+// src/schema/engine.ts
+function validate(vars, schema, options) {
+  const strict = options?.strict ?? false;
+  const abortEarly = options?.abortEarly ?? false;
+  const deprecationWarnings = options?.deprecationWarnings ?? true;
+  const errors = [];
+  const warnings = [];
+  const values = {};
+  const unknown = [];
+  const aliasMap = /* @__PURE__ */ new Map();
+  for (const [key, builder] of Object.entries(schema)) {
+    for (const alias of builder.meta.aliases) {
+      aliasMap.set(alias, key);
+      aliasMap.set(alias.toLowerCase(), key);
+    }
+  }
+  const resolvedVars = resolveVariables(vars, schema, aliasMap);
+  for (const [key, builder] of Object.entries(schema)) {
+    const conditional = builder.meta.conditional;
+    if (conditional !== void 0) {
+      try {
+        if (!conditional.check(values)) {
+          if (builder.meta.hasDefault) {
+            const defaultVal = builder.getDefaultValue();
+            if (defaultVal !== void 0) {
+              values[key] = defaultVal;
+            }
+          } else if (!builder.meta.required) {
+            values[key] = void 0;
+          }
+          continue;
+        }
+      } catch {
+      }
+    }
+    if (deprecationWarnings && builder.meta.isDeprecated) {
+      const rawValue2 = resolvedVars[key] ?? "";
+      if (rawValue2 !== "") {
+        warnings.push({
+          field: key,
+          rawValue: rawValue2,
+          message: builder.meta.deprecationMessage ?? `Variable "${key}" is deprecated`,
+          code: "DEPRECATED"
+        });
+      }
+    }
+    const rawValue = resolvedVars[key];
+    if (rawValue === void 0) {
+      if (builder.meta.hasDefault) {
+        const defaultVal = builder.getDefaultValue();
+        if (defaultVal !== void 0) {
+          values[key] = defaultVal;
+        } else {
+          errors.push({
+            field: key,
+            rawValue: builder.meta.rawDefaultValue ?? "",
+            message: `Default value "${builder.meta.rawDefaultValue ?? ""}" could not be parsed as ${builder.meta.typeName}`,
+            expected: builder.meta.typeName,
+            meta: builder.meta
+          });
+        }
+      } else if (builder.meta.required) {
+        errors.push({
+          field: key,
+          rawValue: "",
+          message: `Required variable "${key}" is missing`,
+          expected: builder.meta.typeName,
+          meta: builder.meta
+        });
+      } else {
+        values[key] = void 0;
+      }
+      continue;
+    }
+    const parseResult = builder._parse(rawValue);
+    if (!parseResult.success) {
+      errors.push({
+        field: key,
+        rawValue,
+        message: parseResult.error,
+        expected: builder.meta.typeName,
+        meta: builder.meta
+      });
+      if (abortEarly) {
+        break;
+      }
+      continue;
+    }
+    values[key] = parseResult.value;
+  }
+  if (strict) {
+    const schemaKeys = new Set(Object.keys(schema));
+    for (const alias of aliasMap.keys()) {
+      schemaKeys.add(alias);
+    }
+    for (const key of Object.keys(vars)) {
+      if (!schemaKeys.has(key) && !aliasMap.has(key)) {
+        unknown.push(key);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    values,
+    unknown
+  };
+}
+function resolveVariables(vars, schema, aliasMap) {
+  const result = {};
+  for (const key of Object.keys(schema)) {
+    if (key in vars && vars[key] !== void 0) {
+      result[key] = vars[key];
+      continue;
+    }
+    const caseInsensitiveKey = Object.keys(vars).find(
+      (k) => k.toLowerCase() === key.toLowerCase()
+    );
+    if (caseInsensitiveKey !== void 0 && vars[caseInsensitiveKey] !== void 0) {
+      result[key] = vars[caseInsensitiveKey];
+      continue;
+    }
+    let foundAlias = false;
+    for (const [alias, schemaKey] of aliasMap.entries()) {
+      if (schemaKey === key) {
+        if (alias in vars && vars[alias] !== void 0) {
+          result[key] = vars[alias];
+          foundAlias = true;
+          break;
+        }
+        const ciAlias = Object.keys(vars).find(
+          (k) => k.toLowerCase() === alias.toLowerCase()
+        );
+        if (ciAlias !== void 0 && vars[ciAlias] !== void 0) {
+          result[key] = vars[ciAlias];
+          foundAlias = true;
+          break;
+        }
+      }
+    }
+    if (!foundAlias) {
+      result[key] = void 0;
+    }
+  }
+  return result;
+}
+function validateValue(rawValue, builder) {
+  if (rawValue === void 0) {
+    if (builder.meta.hasDefault) {
+      const defaultVal = builder.getDefaultValue();
+      if (defaultVal !== void 0) {
+        return { success: true, value: defaultVal };
+      }
+      return { success: false, error: `Value is required but has no valid default` };
+    }
+    if (builder.meta.required) {
+      return { success: false, error: "Value is required" };
+    }
+    return { success: false, error: "Value is undefined and optional (use defineEnv for proper handling)" };
+  }
+  return builder._parse(rawValue);
+}
+function formatValidationResult(result) {
+  const lines = [];
+  if (result.valid) {
+    lines.push("\u2713 All validations passed");
+    if (result.warnings.length > 0) {
+      lines.push("");
+      lines.push(`\u26A0 ${result.warnings.length} warning(s):`);
+      for (const warning of result.warnings) {
+        lines.push(`  - ${warning.field}: ${warning.message}`);
+      }
+    }
+  } else {
+    lines.push(`\u2717 Validation failed with ${result.errors.length} error(s):`);
+    for (const error of result.errors) {
+      lines.push(`  - ${error.field}: ${error.message}`);
+      if (error.meta.description) {
+        lines.push(`    ${error.meta.description}`);
+      }
+    }
+    if (result.warnings.length > 0) {
+      lines.push("");
+      lines.push(`\u26A0 ${result.warnings.length} warning(s):`);
+      for (const warning of result.warnings) {
+        lines.push(`  - ${warning.field}: ${warning.message}`);
+      }
+    }
+  }
+  if (result.unknown.length > 0) {
+    lines.push("");
+    lines.push(`? Unknown variables: ${result.unknown.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
+// src/schema/validators/string.ts
+var EMAIL_REGEX = /^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$/;
+var UUID_V4_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+var UUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+var HEX_REGEX = /^(0x)?[0-9a-fA-F]+$/;
+var BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+var ALPHANUMERIC_REGEX = /^[a-zA-Z0-9]+$/;
+function validateEmail(value) {
+  if (!EMAIL_REGEX.test(value)) {
+    return `"${value}" is not a valid email address`;
+  }
+  return null;
+}
+function validateUrl(value, opts) {
+  try {
+    const url = new URL(value);
+    const protocols = opts.protocols ?? ["http", "https"];
+    const allowed = protocols.map((p) => p.toLowerCase());
+    if (!allowed.includes(url.protocol.replace(":", ""))) {
+      return `URL protocol must be one of: ${allowed.join(", ")}. Got "${url.protocol}"`;
+    }
+    return null;
+  } catch {
+    return `"${value}" is not a valid URL`;
+  }
+}
+function validateUuid(value, opts) {
+  if (opts.version === 4) {
+    if (!UUID_V4_REGEX.test(value)) {
+      return `"${value}" is not a valid UUID v4`;
+    }
+    return null;
+  }
+  if (!UUID_REGEX.test(value)) {
+    return `"${value}" is not a valid UUID`;
+  }
+  if (opts.version !== void 0) {
+    const versionDigit = value[14];
+    if (versionDigit !== String(opts.version)) {
+      return `"${value}" is not a valid UUID v${opts.version}`;
+    }
+  }
+  return null;
+}
+function validateHex(value) {
+  if (!HEX_REGEX.test(value)) {
+    return `"${value}" is not a valid hex string`;
+  }
+  return null;
+}
+function validateBase64(value) {
+  if (value.length === 0 || !BASE64_REGEX.test(value)) {
+    return `"${value}" is not a valid base64 string`;
+  }
+  return null;
+}
+function validateAlphanumeric(value) {
+  if (!ALPHANUMERIC_REGEX.test(value)) {
+    return `"${value}" must contain only letters and numbers (alphanumeric)`;
+  }
+  return null;
+}
+var StringSchemaBuilder = class extends SchemaBuilder {
+  constructor() {
+    const parser = (raw) => ({ success: true, value: raw });
+    super(parser, "string");
+  }
+  // -------------------------------------------------------------------------
+  // Format Validators
+  // -------------------------------------------------------------------------
+  /** Validate as an email address */
+  email() {
+    this._addValidator((value) => validateEmail(value));
+    return this;
+  }
+  /** Validate as a URL with optional protocol restriction */
+  url(opts) {
+    this._addValidator((value) => validateUrl(value, opts ?? {}));
+    return this;
+  }
+  /** Validate as a UUID (optionally restrict to a specific version 1-7) */
+  uuid(version) {
+    this._addValidator((value) => validateUuid(value, { version }));
+    return this;
+  }
+  /** Validate as a hex string (with optional 0x prefix) */
+  hex() {
+    this._addValidator((value) => validateHex(value));
+    return this;
+  }
+  /** Validate as a base64-encoded string */
+  base64() {
+    this._addValidator((value) => validateBase64(value));
+    return this;
+  }
+  /** Validate that the string contains only letters and numbers */
+  alphanumeric() {
+    this._addValidator((value) => validateAlphanumeric(value));
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Case & Whitespace
+  // -------------------------------------------------------------------------
+  /** Convert to lowercase */
+  lowercase() {
+    this._addTransform((value) => value.toLowerCase());
+    this._addValidator((value) => {
+      if (value !== value.toLowerCase()) {
+        return `"${String(value)}" must be lowercase`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Convert to uppercase */
+  uppercase() {
+    this._addTransform((value) => value.toUpperCase());
+    this._addValidator((value) => {
+      if (value !== value.toUpperCase()) {
+        return `"${String(value)}" must be uppercase`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Trim whitespace from both ends */
+  trim() {
+    this._addTransform((value) => value.trim());
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Length Constraints
+  // -------------------------------------------------------------------------
+  /** Minimum string length */
+  minLength(n) {
+    this._addValidator((value) => {
+      if (value.length < n) {
+        return `String must be at least ${n} characters long, got ${value.length}`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Maximum string length */
+  maxLength(n) {
+    this._addValidator((value) => {
+      if (value.length > n) {
+        return `String must be at most ${n} characters long, got ${value.length}`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Exact string length */
+  length(n) {
+    this._addValidator((value) => {
+      if (value.length !== n) {
+        return `String must be exactly ${n} characters long, got ${value.length}`;
+      }
+      return null;
+    });
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Pattern Matching
+  // -------------------------------------------------------------------------
+  /** Match a regular expression pattern */
+  pattern(regex) {
+    this._addValidator((value) => {
+      if (!regex.test(value)) {
+        return `String must match pattern ${regex.toString()}`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Must start with a specific prefix */
+  startsWith(prefix) {
+    this._addValidator((value) => {
+      if (!value.startsWith(prefix)) {
+        return `String must start with "${prefix}"`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Must end with a specific suffix */
+  endsWith(suffix) {
+    this._addValidator((value) => {
+      if (!value.endsWith(suffix)) {
+        return `String must end with "${suffix}"`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Must contain a specific substring */
+  includes(substring) {
+    this._addValidator((value) => {
+      if (!value.includes(substring)) {
+        return `String must contain "${substring}"`;
+      }
+      return null;
+    });
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Enum / OneOf — Type Narrowing
+  // -------------------------------------------------------------------------
+  /** Restrict to one of the specified values (alias for enum) */
+  oneOf(values) {
+    const set = new Set(values);
+    this._addValidator((value) => {
+      if (!set.has(value)) {
+        return `Value must be one of: ${Array.from(set).join(", ")}. Got "${value}"`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Restrict to an enum of literal values — narrows the output type */
+  enum(values) {
+    return this.oneOf(values);
+  }
+  /** Non-empty string */
+  nonempty() {
+    this._addValidator((value) => {
+      if (value.length === 0) {
+        return "String must not be empty";
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Must match a valid JSON string (checks parseability) */
+  json() {
+    this._addValidator((value) => {
+      try {
+        JSON.parse(value);
+        return null;
+      } catch {
+        return `"${String(value).slice(0, 50)}" is not valid JSON`;
+      }
+    });
+    return this;
+  }
+};
+function createStringSchema() {
+  return new StringSchemaBuilder();
+}
+
+// src/schema/validators/number.ts
+function parseNumber(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    return { success: false, error: "Value is empty, expected a number" };
+  }
+  const num = Number(trimmed);
+  if (Number.isNaN(num)) {
+    return { success: false, error: `"${trimmed}" is not a valid number` };
+  }
+  return { success: true, value: num };
+}
+function validateInteger(value) {
+  if (!Number.isInteger(value)) {
+    return `Expected an integer, got ${value}`;
+  }
+  return null;
+}
+function validateFloat(value) {
+  void value;
+  return null;
+}
+function validateMin(n) {
+  return (value) => {
+    if (value < n) {
+      return `Number must be at least ${n}, got ${value}`;
+    }
+    return null;
+  };
+}
+function validateMax(n) {
+  return (value) => {
+    if (value > n) {
+      return `Number must be at most ${n}, got ${value}`;
+    }
+    return null;
+  };
+}
+function validatePositive(value) {
+  if (value <= 0) {
+    return `Number must be positive (> 0), got ${value}`;
+  }
+  return null;
+}
+function validateNegative(value) {
+  if (value >= 0) {
+    return `Number must be negative (< 0), got ${value}`;
+  }
+  return null;
+}
+function validatePort(value) {
+  if (!Number.isInteger(value)) {
+    return `Port must be an integer, got ${value}`;
+  }
+  if (value < 1 || value > 65535) {
+    return `Port must be between 1 and 65535, got ${value}`;
+  }
+  return null;
+}
+function validatePercentage(value) {
+  if (value < 0 || value > 100) {
+    return `Percentage must be between 0 and 100, got ${value}`;
+  }
+  return null;
+}
+function validateFinite(value) {
+  if (!Number.isFinite(value)) {
+    return `Number must be finite, got ${value}`;
+  }
+  return null;
+}
+function validateNonNegative(value) {
+  if (value < 0) {
+    return `Number must be non-negative (>= 0), got ${value}`;
+  }
+  return null;
+}
+var NumberSchemaBuilder = class extends SchemaBuilder {
+  constructor() {
+    const parser = (raw) => parseNumber(raw);
+    super(parser, "number");
+  }
+  // -------------------------------------------------------------------------
+  // Type Constraints
+  // -------------------------------------------------------------------------
+  /** Must be an integer (no decimals) */
+  integer() {
+    this._addValidator((value) => validateInteger(value));
+    return this;
+  }
+  /** Must be a float (semantic marker — all JS numbers are doubles) */
+  float() {
+    this._addValidator((value) => validateFloat(value));
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Range Constraints
+  // -------------------------------------------------------------------------
+  /** Minimum value (inclusive) */
+  min(n) {
+    this._addValidator(validateMin(n));
+    return this;
+  }
+  /** Maximum value (inclusive) */
+  max(n) {
+    this._addValidator(validateMax(n));
+    return this;
+  }
+  /** Must be positive (> 0) */
+  positive() {
+    this._addValidator((value) => validatePositive(value));
+    return this;
+  }
+  /** Must be negative (< 0) */
+  negative() {
+    this._addValidator((value) => validateNegative(value));
+    return this;
+  }
+  /** Must be non-negative (>= 0) */
+  nonNegative() {
+    this._addValidator((value) => validateNonNegative(value));
+    return this;
+  }
+  // -------------------------------------------------------------------------
+  // Specialized Validators
+  // -------------------------------------------------------------------------
+  /** Must be a valid network port (1-65535) */
+  port() {
+    this._addValidator((value) => validatePort(value));
+    return this;
+  }
+  /** Must be a percentage (0-100) */
+  percentage() {
+    this._addValidator((value) => validatePercentage(value));
+    return this;
+  }
+  /** Must be finite (no Infinity or NaN) */
+  finite() {
+    this._addValidator((value) => validateFinite(value));
+    return this;
+  }
+  /** Must be one of the specified values — narrows the output type */
+  oneOf(values) {
+    const set = new Set(values);
+    this._addValidator((value) => {
+      if (!set.has(value)) {
+        return `Value must be one of: ${Array.from(set).join(", ")}. Got ${value}`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Must be a multiple of the given number */
+  step(n) {
+    this._addValidator((value) => {
+      const v = value;
+      if (n !== 0 && !Number.isFinite(v / n) || v % n !== 0) {
+        return `Value must be a multiple of ${n}, got ${v}`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Must be a safe integer (-(2^53 - 1) to 2^53 - 1) */
+  safeInt() {
+    this._addValidator((value) => {
+      if (!Number.isSafeInteger(value)) {
+        return `Value must be a safe integer, got ${value}`;
+      }
+      return null;
+    });
+    return this;
+  }
+};
+function createNumberSchema() {
+  return new NumberSchemaBuilder();
+}
+
+// src/schema/validators/boolean.ts
+var TRUTHY_SET = /* @__PURE__ */ new Set(["true", "1", "yes", "on"]);
+var FALSY_SET = /* @__PURE__ */ new Set(["false", "0", "no", "off", ""]);
+function parseBooleanFull(raw) {
+  const lower = raw.trim().toLowerCase();
+  if (TRUTHY_SET.has(lower)) {
+    return { success: true, value: true };
+  }
+  if (FALSY_SET.has(lower)) {
+    return { success: true, value: false };
+  }
+  return {
+    success: false,
+    error: `"${raw}" is not a valid boolean. Use true/false, 1/0, yes/no, or on/off`
+  };
+}
+var BooleanSchemaBuilder = class extends SchemaBuilder {
+  _truthyValues;
+  _falsyValues;
+  constructor() {
+    super(parseBooleanFull, "boolean");
+    this._truthyValues = TRUTHY_SET;
+    this._falsyValues = FALSY_SET;
+  }
+  /**
+   * Override the set of truthy values (case-insensitive).
+   * Common defaults: true, 1, yes, on
+   */
+  truthy(values) {
+    this._truthyValues = new Set(values.map((v) => v.toLowerCase()));
+    this._rebuildParser();
+    return this;
+  }
+  /**
+   * Override the set of falsy values (case-insensitive).
+   * Common defaults: false, 0, no, off, ''
+   */
+  falsy(values) {
+    this._falsyValues = new Set(values.map((v) => v.toLowerCase()));
+    this._rebuildParser();
+    return this;
+  }
+  /** Rebuild the parser function with current truthy/falsy sets */
+  _rebuildParser() {
+    const truthy = this._truthyValues;
+    const falsy = this._falsyValues;
+    const parser = (raw) => {
+      const lower = raw.trim().toLowerCase();
+      if (truthy.has(lower)) {
+        return { success: true, value: true };
+      }
+      if (falsy.has(lower)) {
+        return { success: true, value: false };
+      }
+      return {
+        success: false,
+        error: `"${raw}" is not a valid boolean. Accepted truthy: [${Array.from(truthy).join(", ")}]. Accepted falsy: [${Array.from(falsy).join(", ")}]`
+      };
+    };
+    this._setParser(parser);
+  }
+};
+function createBooleanSchema() {
+  return new BooleanSchemaBuilder();
+}
+
+// src/schema/validators/enum.ts
+var EnumSchemaBuilder = class extends SchemaBuilder {
+  _values;
+  _valuesArray;
+  _caseInsensitive;
+  constructor(values) {
+    const valueSet = new Set(values);
+    const parser = (raw) => {
+      const trimmed = raw.trim();
+      if (valueSet.has(trimmed)) {
+        return { success: true, value: trimmed };
+      }
+      return {
+        success: false,
+        error: `"${trimmed}" is not a valid enum value. Expected one of: ${Array.from(valueSet).join(", ")}`
+      };
+    };
+    super(parser, "enum");
+    this._values = valueSet;
+    this._valuesArray = values;
+    this._caseInsensitive = false;
+  }
+  /** Enable or disable case-insensitive matching */
+  caseInsensitive(enabled) {
+    this._caseInsensitive = enabled ?? true;
+    this._rebuildParser();
+    return this;
+  }
+  /** Get the list of allowed values */
+  get values() {
+    return this._valuesArray;
+  }
+  _rebuildParser() {
+    const values = this._values;
+    const caseInsensitive = this._caseInsensitive;
+    const parser = (raw) => {
+      const trimmed = raw.trim();
+      const lookup = caseInsensitive ? trimmed.toLowerCase() : trimmed;
+      if (caseInsensitive) {
+        for (const val of values) {
+          if (val.toLowerCase() === lookup) {
+            return { success: true, value: val };
+          }
+        }
+      } else {
+        if (values.has(trimmed)) {
+          return { success: true, value: trimmed };
+        }
+      }
+      return {
+        success: false,
+        error: `"${trimmed}" is not a valid enum value. Expected one of: ${Array.from(values).join(", ")}`
+      };
+    };
+    this._setParser(parser);
+  }
+};
+function createEnumSchema(values) {
+  return new EnumSchemaBuilder(values);
+}
+
+// src/schema/validators/array.ts
+var ArraySchemaBuilder = class extends SchemaBuilder {
+  _separator;
+  _trimItems;
+  _filterEmpty;
+  constructor() {
+    const parser = (raw) => {
+      return { success: true, value: raw.split(",") };
+    };
+    super(parser, "array");
+    this._separator = ",";
+    this._trimItems = false;
+    this._filterEmpty = false;
+    this._rebuildParser();
+  }
+  /** Set the separator character (default: ',') */
+  separator(char) {
+    this._separator = char;
+    this._rebuildParser();
+    return this;
+  }
+  /** Trim whitespace from each item after splitting */
+  trimItems(enabled) {
+    this._trimItems = enabled ?? true;
+    this._rebuildParser();
+    return this;
+  }
+  /** Remove empty strings from the result */
+  filterEmpty(enabled) {
+    this._filterEmpty = enabled ?? true;
+    this._rebuildParser();
+    return this;
+  }
+  /** Require unique items (no duplicates) */
+  unique() {
+    this._addValidator((value) => {
+      const seen = /* @__PURE__ */ new Set();
+      for (const item of value) {
+        if (seen.has(item)) {
+          return `Array contains duplicate value: "${item}"`;
+        }
+        seen.add(item);
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Minimum number of items */
+  minItems(n) {
+    this._addValidator((value) => {
+      if (value.length < n) {
+        return `Array must have at least ${n} item(s), got ${value.length}`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Maximum number of items */
+  maxItems(n) {
+    this._addValidator((value) => {
+      if (value.length > n) {
+        return `Array must have at most ${n} item(s), got ${value.length}`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Exact number of items */
+  items(n) {
+    this._addValidator((value) => {
+      if (value.length !== n) {
+        return `Array must have exactly ${n} item(s), got ${value.length}`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Non-empty array */
+  nonempty() {
+    this._addValidator((value) => {
+      if (value.length === 0) {
+        return "Array must not be empty";
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Validate each item against a custom function */
+  itemValidate(fn) {
+    this._addValidator((value) => {
+      for (let i = 0; i < value.length; i++) {
+        const error = fn(value[i] ?? "", i);
+        if (error !== null) {
+          return `Item at index ${i}: ${error}`;
+        }
+      }
+      return null;
+    });
+    return this;
+  }
+  _rebuildParser() {
+    const sep = this._separator;
+    const trim = this._trimItems;
+    const filterEmpty = this._filterEmpty;
+    const parser = (raw) => {
+      let items = raw.split(sep);
+      if (trim) {
+        items = items.map((item) => item.trim());
+      }
+      if (filterEmpty) {
+        items = items.filter((item) => item.length > 0);
+      }
+      return { success: true, value: items };
+    };
+    this._setParser(parser);
+  }
+};
+function createArraySchema() {
+  return new ArraySchemaBuilder();
+}
+
+// src/schema/validators/json.ts
+var JsonSchemaBuilder = class extends SchemaBuilder {
+  constructor() {
+    const parser = (raw) => {
+      try {
+        const parsed = JSON.parse(raw);
+        return { success: true, value: parsed };
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { success: false, error: `Invalid JSON: ${message}` };
+      }
+    };
+    super(parser, "json");
+  }
+  /**
+   * Add a custom schema validation function for the parsed object.
+   * Return an error message string, or null if valid.
+   */
+  schema(fn) {
+    this._addValidator(fn);
+    return this;
+  }
+  /** Require the parsed JSON to be an object (not null, array, or primitive) */
+  object() {
+    this._addValidator((value) => {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return "JSON must be an object";
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Require the parsed JSON to be an array */
+  array() {
+    this._addValidator((value) => {
+      if (!Array.isArray(value)) {
+        return "JSON must be an array";
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Require the parsed JSON to be a string primitive */
+  string() {
+    this._addValidator((value) => {
+      if (typeof value !== "string") {
+        return "JSON must be a string";
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Require the parsed JSON to be a number primitive */
+  number() {
+    this._addValidator((value) => {
+      if (typeof value !== "number") {
+        return "JSON must be a number";
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Require the parsed JSON to be a boolean primitive */
+  boolean() {
+    this._addValidator((value) => {
+      if (typeof value !== "boolean") {
+        return "JSON must be a boolean";
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Require a specific top-level key to exist */
+  hasKey(key) {
+    this._addValidator((value) => {
+      if (typeof value !== "object" || value === null || !(key in value)) {
+        return `JSON object must have key "${key}"`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Use a custom JSON reviver during parsing */
+  reviver(reviver) {
+    const parser = (raw) => {
+      try {
+        const parsed = JSON.parse(raw, reviver);
+        return { success: true, value: parsed };
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { success: false, error: `Invalid JSON: ${message}` };
+      }
+    };
+    this._setParser(parser);
+    return this;
+  }
+};
+function createJsonSchema() {
+  return new JsonSchemaBuilder();
+}
+
+// src/schema/validators/date.ts
+function parseDate(raw) {
+  const trimmed = raw.trim();
+  const timestamp = Date.parse(trimmed);
+  if (!Number.isNaN(timestamp)) {
+    return { success: true, value: new Date(timestamp) };
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const numericDate = new Date(Number(trimmed));
+    if (!Number.isNaN(numericDate.getTime())) {
+      return { success: true, value: numericDate };
+    }
+  }
+  return {
+    success: false,
+    error: `"${trimmed}" is not a valid date. Supported formats: ISO 8601, RFC 2822, or numeric timestamp`
+  };
+}
+function validatePast(value) {
+  if (value.getTime() >= Date.now()) {
+    return `Date must be in the past, got ${value.toISOString()}`;
+  }
+  return null;
+}
+function validateFuture(value) {
+  if (value.getTime() <= Date.now()) {
+    return `Date must be in the future, got ${value.toISOString()}`;
+  }
+  return null;
+}
+function validateAfter(ref) {
+  return (value) => {
+    if (value.getTime() <= ref.getTime()) {
+      return `Date must be after ${ref.toISOString()}, got ${value.toISOString()}`;
+    }
+    return null;
+  };
+}
+function validateBefore(ref) {
+  return (value) => {
+    if (value.getTime() >= ref.getTime()) {
+      return `Date must be before ${ref.toISOString()}, got ${value.toISOString()}`;
+    }
+    return null;
+  };
+}
+var DateSchemaBuilder = class extends SchemaBuilder {
+  constructor() {
+    super(parseDate, "date");
+  }
+  /** Date must be in the past */
+  past() {
+    this._addValidator(validatePast);
+    return this;
+  }
+  /** Date must be in the future */
+  future() {
+    this._addValidator(validateFuture);
+    return this;
+  }
+  /** Date must be after the given reference date */
+  after(ref) {
+    this._addValidator(validateAfter(ref));
+    return this;
+  }
+  /** Date must be before the given reference date */
+  before(ref) {
+    this._addValidator(validateBefore(ref));
+    return this;
+  }
+  /** Date must be a valid date (re-checks, useful after transforms) */
+  valid() {
+    this._addValidator((value) => {
+      if (Number.isNaN(value.getTime())) {
+        return `"${value.toISOString()}" is not a valid date`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Use a custom date parser */
+  parse(fn) {
+    const parser = (raw) => {
+      try {
+        const date = fn(raw);
+        if (Number.isNaN(date.getTime())) {
+          return { success: false, error: `"${raw}" is not a valid date` };
+        }
+        return { success: true, value: date };
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { success: false, error: `Failed to parse date: ${message}` };
+      }
+    };
+    this._setParser(parser);
+    return this;
+  }
+};
+function createDateSchema() {
+  return new DateSchemaBuilder();
+}
+
+// src/schema/validators/regex.ts
+function parseRegex(raw) {
+  const trimmed = raw.trim();
+  const regexMatch = trimmed.match(/^\/(.+)\/([gimsuy]*)$/);
+  if (regexMatch) {
+    try {
+      const pattern = regexMatch[1] ?? "";
+      const flags = regexMatch[2] ?? "";
+      return { success: true, value: new RegExp(pattern, flags) };
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      return { success: false, error: `Invalid regex: ${message}` };
+    }
+  }
+  try {
+    return { success: true, value: new RegExp(trimmed) };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    return { success: false, error: `Invalid regex: ${message}` };
+  }
+}
+var RegexSchemaBuilder = class extends SchemaBuilder {
+  constructor() {
+    super(parseRegex, "regex");
+  }
+  /** Require the regex to have a specific flag */
+  hasFlag(flag) {
+    this._addValidator((value) => {
+      if (!value.flags.includes(flag)) {
+        return `Regex must have flag "${flag}"`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Require the regex to NOT have a specific flag */
+  noFlag(flag) {
+    this._addValidator((value) => {
+      if (value.flags.includes(flag)) {
+        return `Regex must not have flag "${flag}"`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Require the regex to be case-insensitive */
+  caseInsensitive() {
+    return this.hasFlag("i");
+  }
+  /** Require the regex to be global */
+  global() {
+    return this.hasFlag("g");
+  }
+  /** Require the regex to be multiline */
+  multiline() {
+    return this.hasFlag("m");
+  }
+  /** Test the regex against a string (validation-only, doesn't change the value) */
+  test(testString, expectMatch) {
+    this._addValidator((value) => {
+      const matches = value.test(testString);
+      if (expectMatch && !matches) {
+        return `Regex must match "${testString}"`;
+      }
+      if (!expectMatch && matches) {
+        return `Regex must not match "${testString}"`;
+      }
+      return null;
+    });
+    return this;
+  }
+};
+function createRegexSchema() {
+  return new RegexSchemaBuilder();
+}
+
+// src/schema/validators/bigint.ts
+function parseBigIntProper(raw, radix) {
+  const trimmed = raw.trim();
+  try {
+    const cleaned = trimmed.replace(/^0x/i, "");
+    const value = radix === 16 && trimmed.startsWith("0x") ? BigInt("0x" + cleaned) : BigInt(cleaned);
+    return { success: true, value };
+  } catch {
+    return { success: false, error: `"${trimmed}" is not a valid BigInt (radix: ${radix})` };
+  }
+}
+function validateMin2(n) {
+  return (value) => {
+    if (value < n) {
+      return `BigInt must be at least ${n}, got ${value}`;
+    }
+    return null;
+  };
+}
+function validateMax2(n) {
+  return (value) => {
+    if (value > n) {
+      return `BigInt must be at most ${n}, got ${value}`;
+    }
+    return null;
+  };
+}
+function validatePositive2(value) {
+  if (value <= 0n) {
+    return `BigInt must be positive (> 0), got ${value}`;
+  }
+  return null;
+}
+function validateNegative2(value) {
+  if (value >= 0n) {
+    return `BigInt must be negative (< 0), got ${value}`;
+  }
+  return null;
+}
+function validateNonNegative2(value) {
+  if (value < 0n) {
+    return `BigInt must be non-negative (>= 0), got ${value}`;
+  }
+  return null;
+}
+var BigIntSchemaBuilder = class extends SchemaBuilder {
+  _radix;
+  constructor() {
+    const parser = (raw) => parseBigIntProper(raw, 10);
+    super(parser, "bigint");
+    this._radix = 10;
+  }
+  /** Set the radix for parsing (default: 10). Use 16 for hex. */
+  radix(r) {
+    this._radix = r;
+    this._rebuildParser();
+    return this;
+  }
+  /** Minimum value (inclusive) */
+  min(n) {
+    this._addValidator(validateMin2(n));
+    return this;
+  }
+  /** Maximum value (inclusive) */
+  max(n) {
+    this._addValidator(validateMax2(n));
+    return this;
+  }
+  /** Must be positive (> 0) */
+  positive() {
+    this._addValidator(validatePositive2);
+    return this;
+  }
+  /** Must be negative (< 0) */
+  negative() {
+    this._addValidator(validateNegative2);
+    return this;
+  }
+  /** Must be non-negative (>= 0) */
+  nonNegative() {
+    this._addValidator(validateNonNegative2);
+    return this;
+  }
+  /** Must be one of the specified values */
+  oneOf(values) {
+    const set = new Set(values);
+    this._addValidator((value) => {
+      if (!set.has(value)) {
+        return `Value must be one of: ${Array.from(set).map(String).join(", ")}. Got ${value}`;
+      }
+      return null;
+    });
+    return this;
+  }
+  /** Use a custom parse function */
+  parse(fn) {
+    const parser = (raw) => {
+      try {
+        const value = fn(raw);
+        return { success: true, value };
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return { success: false, error: `Failed to parse BigInt: ${message}` };
+      }
+    };
+    this._setParser(parser);
+    return this;
+  }
+  _rebuildParser() {
+    const r = this._radix;
+    const parser = (raw) => parseBigIntProper(raw, r);
+    this._setParser(parser);
+  }
+};
+function createBigIntSchema() {
+  return new BigIntSchemaBuilder();
+}
+
+// src/schema/validators/url.ts
+function parseAndValidateUrl(raw, opts) {
+  const trimmed = raw.trim();
+  try {
+    const url = new URL(trimmed);
+    const protocols = (opts.protocols ?? ["http", "https"]).map((p) => p.toLowerCase());
+    if (!protocols.includes(url.protocol.replace(":", ""))) {
+      return {
+        success: false,
+        error: `URL protocol must be one of: ${protocols.join(", ")}. Got "${url.protocol}"`
+      };
+    }
+    if (opts.hostname !== void 0 && url.hostname !== opts.hostname) {
+      return {
+        success: false,
+        error: `URL hostname must be "${opts.hostname}", got "${url.hostname}"`
+      };
+    }
+    if (opts.allowedPorts !== void 0) {
+      const port = url.port !== "" ? Number(url.port) : url.protocol === "https:" ? 443 : 80;
+      if (!opts.allowedPorts.includes(port)) {
+        return {
+          success: false,
+          error: `URL port must be one of: ${opts.allowedPorts.join(", ")}. Got ${port}`
+        };
+      }
+    }
+    if (opts.allowQuery === false && url.search !== "") {
+      return { success: false, error: "URL must not contain a query string" };
+    }
+    if (opts.allowFragment === false && url.hash !== "") {
+      return { success: false, error: "URL must not contain a fragment" };
+    }
+    const maxLen = opts.maxLength ?? 2048;
+    if (trimmed.length > maxLen) {
+      return {
+        success: false,
+        error: `URL must be at most ${maxLen} characters, got ${trimmed.length}`
+      };
+    }
+    return { success: true, value: url };
+  } catch {
+    return { success: false, error: `"${trimmed}" is not a valid URL` };
+  }
+}
+function createUrlSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateUrl(raw, options);
+  return new SchemaBuilder(parser, "url");
+}
+
+// src/schema/validators/email.ts
+var EMAIL_REGEX2 = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+function parseAndValidateEmail(raw, opts) {
+  const trimmed = raw.trim();
+  const maxLen = opts.maxLength ?? 254;
+  const maxLocal = opts.maxLocalLength ?? 64;
+  if (trimmed.length === 0) {
+    return { success: false, error: "Email must not be empty" };
+  }
+  if (trimmed.length > maxLen) {
+    return { success: false, error: `Email must be at most ${maxLen} characters, got ${trimmed.length}` };
+  }
+  if (!EMAIL_REGEX2.test(trimmed)) {
+    return { success: false, error: `"${trimmed}" is not a valid email address` };
+  }
+  const atIndex = trimmed.lastIndexOf("@");
+  const localPart = trimmed.slice(0, atIndex);
+  const domain = trimmed.slice(atIndex + 1);
+  if (localPart.length > maxLocal) {
+    return { success: false, error: `Email local part must be at most ${maxLocal} characters, got ${localPart.length}` };
+  }
+  if (opts.allowPlusAddressing === false && localPart.includes("+")) {
+    return { success: false, error: "Plus addressing (+) is not allowed" };
+  }
+  if (opts.allowedTlds !== void 0 && opts.allowedTlds.length > 0) {
+    const tld = domain.split(".").pop() ?? "";
+    const allowed = opts.allowedTlds.map((t2) => t2.toLowerCase());
+    if (!allowed.includes(tld.toLowerCase())) {
+      return { success: false, error: `Email TLD must be one of: ${allowed.join(", ")}. Got ".${tld}"` };
+    }
+  }
+  if (opts.blockedDomains !== void 0) {
+    const blocked = opts.blockedDomains.map((d) => d.toLowerCase());
+    if (blocked.includes(domain.toLowerCase())) {
+      return { success: false, error: `Email domain "${domain}" is not allowed` };
+    }
+  }
+  return { success: true, value: trimmed };
+}
+function createEmailSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateEmail(raw, options);
+  return new SchemaBuilder(parser, "email");
+}
+
+// src/schema/validators/ip.ts
+var IPV4_REGEX = /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)$/;
+var IPV6_REGEX = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|^[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,2}:(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,3}:(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,4}:(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,5}:(?:[0-9a-fA-F]{1,4}:)?[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}$|^::$/;
+var IPV4_CIDR_REGEX = /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)\/(?:3[0-2]|[12]?\d)$/;
+var IPV6_MAPPED_V4_REGEX = /^::ffff:(?:\d{1,3}\.){3}\d{1,3}$/i;
+function parseAndValidateIp(raw, opts) {
+  const trimmed = raw.trim();
+  const version = opts.version ?? "both";
+  const allowCidr = opts.allowCidr ?? false;
+  const isV4 = IPV4_REGEX.test(trimmed);
+  const isV6 = IPV6_REGEX.test(trimmed);
+  const isV4Cidr = allowCidr && IPV4_CIDR_REGEX.test(trimmed);
+  const isMappedV4 = IPV6_MAPPED_V4_REGEX.test(trimmed);
+  if (version === "4" && !isV4 && !isV4Cidr) {
+    return { success: false, error: `"${trimmed}" is not a valid IPv4 address` };
+  }
+  if (version === "6" && !isV6) {
+    if (opts.allowMappedV4 === false && isMappedV4) {
+      return { success: false, error: `"${trimmed}" is an IPv4-mapped IPv6 address, which is not allowed` };
+    }
+    return { success: false, error: `"${trimmed}" is not a valid IPv6 address` };
+  }
+  if (version === "both" && !isV4 && !isV6 && !isV4Cidr) {
+    return { success: false, error: `"${trimmed}" is not a valid IP address` };
+  }
+  if (version === "6" && isMappedV4 && opts.allowMappedV4 === false) {
+    return { success: false, error: `"${trimmed}" is an IPv4-mapped IPv6 address, which is not allowed` };
+  }
+  return { success: true, value: trimmed };
+}
+function createIpSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateIp(raw, options);
+  return new SchemaBuilder(parser, "ip");
+}
+function createIpv4Schema(opts) {
+  return createIpSchema({ ...opts, version: "4" });
+}
+function createIpv6Schema(opts) {
+  return createIpSchema({ ...opts, version: "6" });
+}
+
+// src/schema/validators/hostname.ts
+var HOSTNAME_LABEL_REGEX = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/;
+var HOSTNAME_LABEL_REGEX_UNDERSCORE = /^[a-zA-Z0-9_]([a-zA-Z0-9_-]*[a-zA-Z0-9_])?$/;
+function parseAndValidateHostname(raw, opts) {
+  const trimmed = raw.trim();
+  const maxLen = opts.maxLength ?? 253;
+  const maxLabel = opts.maxLabelLength ?? 63;
+  const allowTrailingDot = opts.allowTrailingDot ?? false;
+  const allowIdn = opts.allowIdn ?? true;
+  const allowUnderscore = opts.allowUnderscore ?? false;
+  if (trimmed.length === 0) {
+    return { success: false, error: "Hostname must not be empty" };
+  }
+  if (trimmed.length > maxLen + (allowTrailingDot ? 1 : 0)) {
+    return {
+      success: false,
+      error: `Hostname must be at most ${maxLen} characters, got ${trimmed.length}`
+    };
+  }
+  const forValidation = allowTrailingDot && trimmed.endsWith(".") ? trimmed.slice(0, -1) : trimmed;
+  if (forValidation.length === 0) {
+    return { success: false, error: "Hostname must not be just a dot" };
+  }
+  if (!allowIdn && /[^\x00-\x7F]/.test(trimmed)) {
+    return { success: false, error: "Internationalized domain names are not allowed" };
+  }
+  const labels = forValidation.split(".");
+  if (labels.length < 1) {
+    return { success: false, error: "Hostname must have at least one label" };
+  }
+  const labelRegex = allowUnderscore ? HOSTNAME_LABEL_REGEX_UNDERSCORE : HOSTNAME_LABEL_REGEX;
+  for (const label of labels) {
+    if (label.length === 0) {
+      return { success: false, error: "Hostname contains an empty label" };
+    }
+    if (label.length > maxLabel) {
+      return {
+        success: false,
+        error: `Hostname label "${label}" exceeds maximum length of ${maxLabel}`
+      };
+    }
+    if (!labelRegex.test(label)) {
+      return { success: false, error: `Hostname label "${label}" contains invalid characters` };
+    }
+  }
+  return { success: true, value: trimmed };
+}
+function createHostnameSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateHostname(raw, options);
+  return new SchemaBuilder(parser, "hostname");
+}
+
+// src/schema/validators/port.ts
+function parseAndValidatePort(raw, opts) {
+  const trimmed = raw.trim();
+  const num = Number(trimmed);
+  if (!Number.isInteger(num)) {
+    return { success: false, error: `"${trimmed}" is not a valid integer port number` };
+  }
+  if (opts.allowedPorts !== void 0) {
+    if (!opts.allowedPorts.includes(num)) {
+      return {
+        success: false,
+        error: `Port must be one of: ${opts.allowedPorts.join(", ")}. Got ${num}`
+      };
+    }
+    return { success: true, value: num };
+  }
+  if (opts.allowZero !== true && num === 0) {
+    return { success: false, error: "Port 0 is not allowed" };
+  }
+  if (num < 1 || num > 65535) {
+    return { success: false, error: `Port must be between 1 and 65535, got ${num}` };
+  }
+  const allowWellKnown = opts.allowWellKnown ?? true;
+  const allowRegistered = opts.allowRegistered ?? true;
+  const allowDynamic = opts.allowDynamic ?? true;
+  if (num <= 1023 && !allowWellKnown) {
+    return { success: false, error: `Well-known port ${num} is not allowed` };
+  }
+  if (num >= 1024 && num <= 49151 && !allowRegistered) {
+    return { success: false, error: `Registered port ${num} is not allowed` };
+  }
+  if (num >= 49152 && !allowDynamic) {
+    return { success: false, error: `Dynamic port ${num} is not allowed` };
+  }
+  return { success: true, value: num };
+}
+function createPortSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidatePort(raw, options);
+  return new SchemaBuilder(parser, "port");
+}
+
+// src/schema/validators/path.ts
+function parseAndValidatePath(raw, opts) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    return { success: false, error: "Path must not be empty" };
+  }
+  if (opts.absolute === true && !trimmed.startsWith("/")) {
+    return { success: false, error: 'Path must be absolute (start with "/")' };
+  }
+  if (opts.relative === true && trimmed.startsWith("/")) {
+    return { success: false, error: 'Path must be relative (not start with "/")' };
+  }
+  if (opts.allowHomeDir !== true && trimmed.includes("~")) {
+    return { success: false, error: 'Path must not contain "~" (home directory)' };
+  }
+  if (opts.allowParentTraversal !== true) {
+    const segments = trimmed.replace(/^\//, "").split("/");
+    for (const segment of segments) {
+      if (segment === "..") {
+        return { success: false, error: 'Path must not contain ".." (parent directory traversal)' };
+      }
+    }
+  }
+  if (opts.maxDepth !== void 0) {
+    const segments = trimmed.replace(/^\//, "").split("/").filter((s) => s.length > 0);
+    if (segments.length > opts.maxDepth) {
+      return {
+        success: false,
+        error: `Path depth must be at most ${opts.maxDepth}, got ${segments.length}`
+      };
+    }
+  }
+  if (opts.extensions !== void 0 && opts.extensions.length > 0) {
+    const validExts = opts.extensions.map((e) => e.toLowerCase());
+    const lastDot = trimmed.lastIndexOf(".");
+    const ext = lastDot >= 0 ? trimmed.slice(lastDot).toLowerCase() : "";
+    if (!validExts.includes(ext)) {
+      return {
+        success: false,
+        error: `Path extension must be one of: ${validExts.join(", ")}. Got "${ext || "(none)"}"`
+      };
+    }
+  }
+  return { success: true, value: trimmed };
+}
+function createPathSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidatePath(raw, options);
+  return new SchemaBuilder(parser, "path");
+}
+
+// src/schema/validators/uuid.ts
+var UUID_REGEX2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var NIL_UUID = "00000000-0000-0000-0000-000000000000";
+function parseAndValidateUuid(raw, opts) {
+  const trimmed = raw.trim().toLowerCase();
+  if (!UUID_REGEX2.test(trimmed)) {
+    return { success: false, error: `"${trimmed}" is not a valid UUID` };
+  }
+  if (trimmed === NIL_UUID && opts.allowNil !== true) {
+    return { success: false, error: "Nil UUID (all zeros) is not allowed" };
+  }
+  if (opts.version !== void 0) {
+    const versionDigit = trimmed[14] ?? "0";
+    if (versionDigit !== String(opts.version)) {
+      return {
+        success: false,
+        error: `Expected UUID v${opts.version}, but got v${versionDigit}`
+      };
+    }
+  }
+  if (opts.strictVariant !== false) {
+    const variantNibble = trimmed[19] ?? "0";
+    const variantNum = parseInt(variantNibble, 16);
+    if (variantNum < 8 || variantNum > 11) {
+      return {
+        success: false,
+        error: `UUID variant nibble must be 8, 9, a, or b (RFC 4122). Got "${variantNibble}"`
+      };
+    }
+    const versionNibble = trimmed[14] ?? "0";
+    const versionNum = parseInt(versionNibble, 16);
+    if (versionNum < 1 || versionNum > 8) {
+      return {
+        success: false,
+        error: `UUID version nibble must be 1-8. Got "${versionNibble}"`
+      };
+    }
+  }
+  return { success: true, value: trimmed };
+}
+function createUuidSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateUuid(raw, options);
+  return new SchemaBuilder(parser, "uuid");
+}
+
+// src/schema/validators/hex.ts
+var HEX_CHARS = new Set("0123456789abcdefABCDEF");
+function parseAndValidateHex(raw, opts) {
+  const trimmed = raw.trim();
+  let content = trimmed;
+  const allowPrefix = opts.allowPrefix ?? false;
+  const requirePrefix = opts.requirePrefix ?? false;
+  if (requirePrefix && !content.startsWith("0x") && !content.startsWith("0X")) {
+    return { success: false, error: 'Hex string must start with "0x" prefix' };
+  }
+  if (content.startsWith("0x") || content.startsWith("0X")) {
+    if (!allowPrefix && !requirePrefix) {
+      return { success: false, error: 'Hex string must not have a "0x" prefix' };
+    }
+    content = content.slice(2);
+  }
+  if (content.length === 0) {
+    return { success: false, error: "Hex string must not be empty" };
+  }
+  for (let i = 0; i < content.length; i++) {
+    if (!HEX_CHARS.has(content[i] ?? "")) {
+      return {
+        success: false,
+        error: `Invalid hex character "${content[i]}" at position ${i}`
+      };
+    }
+  }
+  const caseSensitive = opts.caseSensitive ?? "mixed";
+  if (caseSensitive === "lower" && content !== content.toLowerCase()) {
+    return { success: false, error: "Hex string must be lowercase" };
+  }
+  if (caseSensitive === "upper" && content !== content.toUpperCase()) {
+    return { success: false, error: "Hex string must be uppercase" };
+  }
+  if (opts.byteLength !== void 0) {
+    if (content.length !== opts.byteLength * 2) {
+      return {
+        success: false,
+        error: `Hex string must be ${opts.byteLength * 2} characters (${opts.byteLength} bytes), got ${content.length}`
+      };
+    }
+  }
+  if (opts.byteLength === void 0 && content.length % 2 !== 0) {
+    return {
+      success: false,
+      error: "Hex string must have an even number of characters"
+    };
+  }
+  return { success: true, value: trimmed };
+}
+function createHexSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateHex(raw, options);
+  return new SchemaBuilder(parser, "hex");
+}
+
+// src/schema/validators/base64.ts
+var BASE64_CHARS_STANDARD = /^[A-Za-z0-9+/]*={0,2}$/;
+var BASE64_CHARS_URL_SAFE = /^[A-Za-z0-9\-_]*={0,2}$/;
+function parseAndValidateBase64(raw, opts) {
+  const trimmed = raw.trim();
+  const urlSafe = opts.urlSafe ?? false;
+  const requirePadding = opts.requirePadding ?? false;
+  const noWhitespace = opts.noWhitespace ?? true;
+  const allowEmpty = opts.allowEmpty ?? false;
+  if (trimmed.length === 0) {
+    if (allowEmpty) {
+      return { success: true, value: trimmed };
+    }
+    return { success: false, error: "Base64 string must not be empty" };
+  }
+  if (noWhitespace && /\s/.test(trimmed)) {
+    return { success: false, error: "Base64 string must not contain whitespace" };
+  }
+  const regex = urlSafe ? BASE64_CHARS_URL_SAFE : BASE64_CHARS_STANDARD;
+  if (!regex.test(trimmed)) {
+    const validChars = urlSafe ? "A-Za-z0-9-_" : "A-Za-z0-9+/";
+    return {
+      success: false,
+      error: `Base64 string contains invalid characters. Allowed: ${validChars}=`
+    };
+  }
+  if (requirePadding) {
+    const mod = trimmed.replace(/=/g, "").length % 4;
+    const expectedPadding = mod === 0 ? 0 : 4 - mod;
+    const actualPadding = trimmed.length - trimmed.replace(/=/g, "").length;
+    if (actualPadding !== expectedPadding) {
+      return {
+        success: false,
+        error: `Base64 padding is invalid. Expected ${expectedPadding} padding characters, got ${actualPadding}`
+      };
+    }
+  }
+  const paddingIndex = trimmed.indexOf("=");
+  if (paddingIndex !== -1) {
+    const afterPadding = trimmed.slice(paddingIndex);
+    if (/[^=]/.test(afterPadding)) {
+      return { success: false, error: "Base64 padding (=) must only appear at the end" };
+    }
+    if (afterPadding.length > 2) {
+      return { success: false, error: "Base64 string has too many padding characters" };
+    }
+  }
+  const decoded = Buffer.from(trimmed, "base64");
+  const reEncoded = decoded.toString("base64");
+  const normalizedInput = trimmed.replace(/=+$/, "");
+  const normalizedReEncoded = reEncoded.replace(/=+$/, "");
+  if (urlSafe) {
+    const urlSafeReEncoded = normalizedReEncoded.replace(/\+/g, "-").replace(/\//g, "_");
+    if (normalizedInput !== urlSafeReEncoded) {
+      return { success: false, error: "Base64 string contains invalid characters" };
+    }
+  } else {
+    if (normalizedInput !== normalizedReEncoded) {
+      return { success: false, error: "Base64 string contains invalid characters" };
+    }
+  }
+  if (opts.minBytes !== void 0 && decoded.length < opts.minBytes) {
+    return {
+      success: false,
+      error: `Base64 decoded length must be at least ${opts.minBytes} bytes, got ${decoded.length}`
+    };
+  }
+  if (opts.maxBytes !== void 0 && decoded.length > opts.maxBytes) {
+    return {
+      success: false,
+      error: `Base64 decoded length must be at most ${opts.maxBytes} bytes, got ${decoded.length}`
+    };
+  }
+  return { success: true, value: trimmed };
+}
+function createBase64Schema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateBase64(raw, options);
+  return new SchemaBuilder(parser, "base64");
+}
+
+// src/schema/validators/semver.ts
+var SEMVER_CORE = "(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)";
+var SEMVER_PRERELEASE = "(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))";
+var SEMVER_BUILD = "(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))";
+var STRICT_SEMVER_REGEX = new RegExp(`^${SEMVER_CORE}(?:${SEMVER_PRERELEASE})?(?:${SEMVER_BUILD})?$`);
+var LOOSE_SEMVER_REGEX = /^v?(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?(?:\.(0|[1-9]\d*))?(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+function parseAndValidateSemver(raw, opts) {
+  const trimmed = raw.trim();
+  let content = trimmed;
+  const allowVPrefix = opts.allowVPrefix ?? true;
+  if (content.startsWith("v") || content.startsWith("V")) {
+    if (!allowVPrefix) {
+      return { success: false, error: 'Semver string must not start with "v" prefix' };
+    }
+    content = content.slice(1);
+  }
+  const loose = opts.loose ?? false;
+  const regex = loose ? LOOSE_SEMVER_REGEX : STRICT_SEMVER_REGEX;
+  if (!regex.test(content)) {
+    const mode = loose ? "loose" : "strict";
+    return {
+      success: false,
+      error: `"${trimmed}" is not a valid semver string (${mode} mode)`
+    };
+  }
+  if (!loose) {
+    const match = content.match(new RegExp(`^${SEMVER_CORE}(?:${SEMVER_PRERELEASE})?(?:${SEMVER_BUILD})?$`));
+    if (match) {
+      const prerelease = match[4];
+      const build = match[5];
+      if (prerelease !== void 0 && opts.allowPrerelease === false) {
+        return {
+          success: false,
+          error: "Semver string must not have a prerelease suffix"
+        };
+      }
+      if (build !== void 0 && opts.allowBuildMetadata === false) {
+        return {
+          success: false,
+          error: "Semver string must not have build metadata"
+        };
+      }
+    }
+  }
+  return { success: true, value: trimmed };
+}
+function createSemverSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateSemver(raw, options);
+  return new SchemaBuilder(parser, "semver");
+}
+
+// src/schema/validators/cron.ts
+var PREDEFINED_CRON = /* @__PURE__ */ new Set([
+  "@yearly",
+  "@annually",
+  "@monthly",
+  "@weekly",
+  "@daily",
+  "@midnight",
+  "@hourly"
+]);
+var CRON_FIELD_REGEX = /^(?:\*|[0-9]+(?:-[0-9]+)?(?:,[0-9]+(?:-[0-9]+)?)*)(?:\/[0-9]+)?$/;
+var MONTH_NAMES = {
+  jan: "1",
+  feb: "2",
+  mar: "3",
+  apr: "4",
+  may: "5",
+  jun: "6",
+  jul: "7",
+  aug: "8",
+  sep: "9",
+  oct: "10",
+  nov: "11",
+  dec: "12"
+};
+var DAY_NAMES = {
+  sun: "0",
+  mon: "1",
+  tue: "2",
+  wed: "3",
+  thu: "4",
+  fri: "5",
+  sat: "6"
+};
+function replaceNames(field, names) {
+  let result = field.toLowerCase();
+  for (const [name, num] of Object.entries(names)) {
+    result = result.replace(new RegExp(name, "gi"), num);
+  }
+  return result;
+}
+function validateCronField(field, min, max) {
+  const normalized = replaceNames(field, { ...MONTH_NAMES, ...DAY_NAMES });
+  const parts = normalized.split(",");
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!CRON_FIELD_REGEX.test(trimmed)) {
+      return `Invalid cron field: "${field}"`;
+    }
+    const rangeMatch = trimmed.match(/^(\*|\d+)(?:-(\d+))?(?:\/(\d+))?$/);
+    if (!rangeMatch) {
+      return `Invalid cron field: "${field}"`;
+    }
+    const start = rangeMatch[1] === "*" ? min : Number(rangeMatch[1]);
+    const end = rangeMatch[2] !== void 0 ? Number(rangeMatch[2]) : start;
+    const step = rangeMatch[3] !== void 0 ? Number(rangeMatch[3]) : 1;
+    if (start < min || start > max) {
+      return `Cron field value ${start} is out of range [${min}, ${max}]`;
+    }
+    if (end < min || end > max) {
+      return `Cron field value ${end} is out of range [${min}, ${max}]`;
+    }
+    if (step < 1) {
+      return `Cron step must be positive, got ${step}`;
+    }
+  }
+  return null;
+}
+function parseAndValidateCron(raw, opts) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("@")) {
+    if (opts.allowAliases !== false && PREDEFINED_CRON.has(trimmed.toLowerCase())) {
+      return { success: true, value: trimmed };
+    }
+    return { success: false, error: `Invalid predefined cron expression: "${trimmed}"` };
+  }
+  const fields = trimmed.split(/\s+/);
+  if (opts.allowSeconds === true && fields.length === 6) {
+    const ranges = [[0, 59], [0, 59], [0, 23], [1, 31], [1, 12], [0, 6]];
+    for (let i = 0; i < fields.length; i++) {
+      const range = ranges[i] ?? [0, 59];
+      const error = validateCronField(fields[i] ?? "", range[0] ?? 0, range[1] ?? 0);
+      if (error) return { success: false, error };
+    }
+    return { success: true, value: trimmed };
+  }
+  if (opts.allowYear === true && fields.length === 6) {
+    const ranges = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6], [1970, 2099]];
+    for (let i = 0; i < fields.length; i++) {
+      const range = ranges[i] ?? [0, 59];
+      const error = validateCronField(fields[i] ?? "", range[0] ?? 0, range[1] ?? 0);
+      if (error) return { success: false, error };
+    }
+    return { success: true, value: trimmed };
+  }
+  if (fields.length === 5) {
+    const ranges = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6]];
+    for (let i = 0; i < fields.length; i++) {
+      const range = ranges[i] ?? [0, 59];
+      const error = validateCronField(fields[i] ?? "", range[0] ?? 0, range[1] ?? 0);
+      if (error) return { success: false, error };
+    }
+    return { success: true, value: trimmed };
+  }
+  return {
+    success: false,
+    error: `Cron expression must have 5 fields (got ${fields.length}). Format: "min hour day month weekday"`
+  };
+}
+function createCronSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateCron(raw, options);
+  return new SchemaBuilder(parser, "cron");
+}
+
+// src/schema/validators/duration.ts
+var DURATION_UNITS = {
+  ms: 1,
+  s: 1e3,
+  sec: 1e3,
+  m: 60 * 1e3,
+  min: 60 * 1e3,
+  h: 60 * 60 * 1e3,
+  hr: 60 * 60 * 1e3,
+  d: 24 * 60 * 60 * 1e3,
+  day: 24 * 60 * 60 * 1e3,
+  w: 7 * 24 * 60 * 60 * 1e3,
+  wk: 7 * 24 * 60 * 60 * 1e3,
+  y: 365 * 24 * 60 * 60 * 1e3,
+  yr: 365 * 24 * 60 * 60 * 1e3
+};
+var DURATION_REGEX = /^(-)?(\d+(?:\.\d+)?)(ms|s|sec|m|min|h|hr|d|day|w|wk|y|yr)$/;
+function parseAndValidateDuration(raw, opts) {
+  const trimmed = raw.trim();
+  const allowNegative = opts.allowNegative ?? false;
+  if (trimmed.length === 0) {
+    return { success: false, error: "Duration string must not be empty" };
+  }
+  const match = trimmed.match(DURATION_REGEX);
+  if (!match) {
+    return {
+      success: false,
+      error: `Invalid duration format: "${trimmed}". Expected format: "<number><unit>" (e.g., "30s", "5m", "2h", "1d")`
+    };
+  }
+  const negative = match[1] === "-";
+  const numStr = match[2] ?? "";
+  const unit = match[3] ?? "ms";
+  if (negative && !allowNegative) {
+    return { success: false, error: "Negative durations are not allowed" };
+  }
+  const num = Number(numStr);
+  if (!Number.isFinite(num)) {
+    return { success: false, error: `Invalid duration number: "${numStr}"` };
+  }
+  const durationUnit = unit;
+  const multiplier = DURATION_UNITS[durationUnit] ?? 1;
+  let ms = num * multiplier;
+  if (negative) {
+    ms = -ms;
+  }
+  const outputUnit = opts.unit ?? "ms";
+  let result;
+  switch (outputUnit) {
+    case "ms":
+      result = ms;
+      break;
+    case "s":
+      result = ms / 1e3;
+      break;
+    case "m":
+      result = ms / (60 * 1e3);
+      break;
+    case "h":
+      result = ms / (60 * 60 * 1e3);
+      break;
+  }
+  if (opts.min !== void 0 && ms < opts.min) {
+    return {
+      success: false,
+      error: `Duration must be at least ${opts.min}ms, got ${Math.round(ms)}ms`
+    };
+  }
+  if (opts.max !== void 0 && ms > opts.max) {
+    return {
+      success: false,
+      error: `Duration must be at most ${opts.max}ms, got ${Math.round(ms)}ms`
+    };
+  }
+  return { success: true, value: result };
+}
+function createDurationSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateDuration(raw, options);
+  return new SchemaBuilder(parser, "duration");
+}
+
+// src/schema/validators/bytes.ts
+var BINARY_UNITS = {
+  b: 1,
+  byte: 1,
+  bytes: 1,
+  kb: 1024,
+  kib: 1024,
+  mb: 1024 * 1024,
+  mib: 1024 * 1024,
+  gb: 1024 * 1024 * 1024,
+  gib: 1024 * 1024 * 1024,
+  tb: 1024 * 1024 * 1024 * 1024,
+  tib: 1024 * 1024 * 1024 * 1024,
+  pb: 1024 * 1024 * 1024 * 1024 * 1024,
+  pib: 1024 * 1024 * 1024 * 1024 * 1024
+};
+var DECIMAL_UNITS = {
+  b: 1,
+  byte: 1,
+  bytes: 1,
+  kb: 1e3,
+  mb: 1e3 * 1e3,
+  gb: 1e3 * 1e3 * 1e3,
+  tb: 1e3 * 1e3 * 1e3 * 1e3,
+  pb: 1e3 * 1e3 * 1e3 * 1e3 * 1e3
+};
+var BYTES_REGEX = /^(\d+(?:\.\d+)?)\s*([a-zA-Z]+)$/;
+function parseAndValidateBytes(raw, opts) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    return { success: false, error: "Bytes string must not be empty" };
+  }
+  const match = trimmed.match(BYTES_REGEX);
+  if (!match) {
+    return {
+      success: false,
+      error: `Invalid bytes format: "${trimmed}". Expected format: "<number><unit>" (e.g., "1KB", "5MB", "2GB")`
+    };
+  }
+  const numStr = match[1];
+  const unitStr = (match[2] ?? "").toLowerCase();
+  const num = Number(numStr);
+  if (!Number.isFinite(num) || num < 0) {
+    return { success: false, error: `Invalid bytes number: "${numStr}"` };
+  }
+  const isBinary = opts.binary ?? true;
+  const units = isBinary ? BINARY_UNITS : DECIMAL_UNITS;
+  const multiplier = units[unitStr];
+  if (multiplier === void 0) {
+    return {
+      success: false,
+      error: `Unknown bytes unit: "${match[2]}". Supported: ${Object.keys(units).join(", ")}`
+    };
+  }
+  let bytes = num * multiplier;
+  bytes = Math.round(bytes);
+  const outputUnit = opts.unit ?? "bytes";
+  let result;
+  switch (outputUnit) {
+    case "bytes":
+      result = bytes;
+      break;
+    case "kb":
+      result = bytes / (isBinary ? 1024 : 1e3);
+      break;
+    case "mb":
+      result = bytes / (isBinary ? 1024 : 1e3) ** 2;
+      break;
+    case "gb":
+      result = bytes / (isBinary ? 1024 : 1e3) ** 3;
+      break;
+    case "tb":
+      result = bytes / (isBinary ? 1024 : 1e3) ** 4;
+      break;
+  }
+  if (opts.min !== void 0 && bytes < opts.min) {
+    return {
+      success: false,
+      error: `Bytes must be at least ${opts.min}, got ${bytes}`
+    };
+  }
+  if (opts.max !== void 0 && bytes > opts.max) {
+    return {
+      success: false,
+      error: `Bytes must be at most ${opts.max}, got ${bytes}`
+    };
+  }
+  return { success: true, value: result };
+}
+function createBytesSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateBytes(raw, options);
+  return new SchemaBuilder(parser, "bytes");
+}
+
+// src/schema/validators/color.ts
+var NAMED_COLORS = /* @__PURE__ */ new Set([
+  "aliceblue",
+  "antiquewhite",
+  "aqua",
+  "aquamarine",
+  "azure",
+  "beige",
+  "bisque",
+  "black",
+  "blanchedalmond",
+  "blue",
+  "blueviolet",
+  "brown",
+  "burlywood",
+  "cadetblue",
+  "chartreuse",
+  "chocolate",
+  "coral",
+  "cornflowerblue",
+  "cornsilk",
+  "crimson",
+  "cyan",
+  "darkblue",
+  "darkcyan",
+  "darkgoldenrod",
+  "darkgray",
+  "darkgreen",
+  "darkkhaki",
+  "darkmagenta",
+  "darkolivegreen",
+  "darkorange",
+  "darkorchid",
+  "darkred",
+  "darksalmon",
+  "darkseagreen",
+  "darkslateblue",
+  "darkslategray",
+  "darkturquoise",
+  "darkviolet",
+  "deeppink",
+  "deepskyblue",
+  "dimgray",
+  "dodgerblue",
+  "firebrick",
+  "floralwhite",
+  "forestgreen",
+  "fuchsia",
+  "gainsboro",
+  "ghostwhite",
+  "gold",
+  "goldenrod",
+  "gray",
+  "green",
+  "greenyellow",
+  "honeydew",
+  "hotpink",
+  "indianred",
+  "indigo",
+  "ivory",
+  "khaki",
+  "lavender",
+  "lavenderblush",
+  "lawngreen",
+  "lemonchiffon",
+  "lightblue",
+  "lightcoral",
+  "lightcyan",
+  "lightgoldenrodyellow",
+  "lightgray",
+  "lightgreen",
+  "lightpink",
+  "lightsalmon",
+  "lightseagreen",
+  "lightskyblue",
+  "lightslategray",
+  "lightsteelblue",
+  "lightyellow",
+  "lime",
+  "limegreen",
+  "linen",
+  "magenta",
+  "maroon",
+  "mediumaquamarine",
+  "mediumblue",
+  "mediumorchid",
+  "mediumpurple",
+  "mediumseagreen",
+  "mediumslateblue",
+  "mediumspringgreen",
+  "mediumturquoise",
+  "mediumvioletred",
+  "midnightblue",
+  "mintcream",
+  "mistyrose",
+  "moccasin",
+  "navajowhite",
+  "navy",
+  "oldlace",
+  "olive",
+  "olivedrab",
+  "orange",
+  "orangered",
+  "orchid",
+  "palegoldenrod",
+  "palegreen",
+  "paleturquoise",
+  "palevioletred",
+  "papayawhip",
+  "peachpuff",
+  "peru",
+  "pink",
+  "plum",
+  "powderblue",
+  "purple",
+  "rebeccapurple",
+  "red",
+  "rosybrown",
+  "royalblue",
+  "saddlebrown",
+  "salmon",
+  "sandybrown",
+  "seagreen",
+  "seashell",
+  "sienna",
+  "silver",
+  "skyblue",
+  "slateblue",
+  "slategray",
+  "snow",
+  "springgreen",
+  "steelblue",
+  "tan",
+  "teal",
+  "thistle",
+  "tomato",
+  "turquoise",
+  "violet",
+  "wheat",
+  "white",
+  "whitesmoke",
+  "yellow",
+  "yellowgreen"
+]);
+var HEX_3_REGEX = /^#([0-9a-fA-F]{3})$/;
+var HEX_6_REGEX = /^#([0-9a-fA-F]{6})$/;
+var HEX_8_REGEX = /^#([0-9a-fA-F]{8})$/;
+var RGB_REGEX = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*([0-9.]+)\s*)?\)$/;
+var HSL_REGEX = /^hsla?\(\s*(\d{1,3})\s*,\s*([0-9.]+)%\s*,\s*([0-9.]+)%\s*(?:,\s*([0-9.]+)\s*)?\)$/;
+function parseAndValidateColor(raw, opts) {
+  const trimmed = raw.trim();
+  const formats = opts.formats;
+  const allowShortHex = opts.allowShortHex ?? true;
+  const allowAlpha = opts.allowAlpha ?? true;
+  const allowHex = formats === void 0 || formats.includes("hex");
+  const allowRgb = formats === void 0 || formats.includes("rgb") || formats.includes("rgba");
+  const allowHsl = formats === void 0 || formats.includes("hsl") || formats.includes("hsla");
+  const allowNamed = formats === void 0 || formats.includes("named");
+  if (allowHex) {
+    if (allowAlpha && HEX_8_REGEX.test(trimmed)) {
+      return { success: true, value: trimmed };
+    }
+    if (HEX_6_REGEX.test(trimmed)) {
+      return { success: true, value: trimmed };
+    }
+    if (allowShortHex && HEX_3_REGEX.test(trimmed)) {
+      return { success: true, value: trimmed };
+    }
+  }
+  if (allowRgb && RGB_REGEX.test(trimmed)) {
+    const match = trimmed.match(RGB_REGEX);
+    if (match) {
+      const r = Number(match[1]);
+      const g = Number(match[2]);
+      const b = Number(match[3]);
+      const a = match[4] !== void 0 ? Number(match[4]) : 1;
+      if (r > 255 || g > 255 || b > 255) {
+        return { success: false, error: `RGB values must be 0-255` };
+      }
+      if (a < 0 || a > 1) {
+        return { success: false, error: `RGBA alpha must be between 0 and 1` };
+      }
+    }
+    return { success: true, value: trimmed };
+  }
+  if (allowHsl && HSL_REGEX.test(trimmed)) {
+    const match = trimmed.match(HSL_REGEX);
+    if (match) {
+      const h = Number(match[1]);
+      const s = Number(match[2]);
+      const l = Number(match[3]);
+      const a = match[4] !== void 0 ? Number(match[4]) : 1;
+      if (h > 360) {
+        return { success: false, error: `HSL hue must be 0-360` };
+      }
+      if (s > 100 || l > 100) {
+        return { success: false, error: `HSL saturation/lightness must be 0-100%` };
+      }
+      if (a < 0 || a > 1) {
+        return { success: false, error: `HSLA alpha must be between 0 and 1` };
+      }
+    }
+    return { success: true, value: trimmed };
+  }
+  if (allowNamed && NAMED_COLORS.has(trimmed.toLowerCase())) {
+    return { success: true, value: trimmed };
+  }
+  return {
+    success: false,
+    error: `"${trimmed}" is not a valid color. Supported formats: hex (#RGB, #RRGGBB), rgb(), rgba(), hsl(), hsla(), or named colors`
+  };
+}
+function createColorSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateColor(raw, options);
+  return new SchemaBuilder(parser, "color");
+}
+
+// src/schema/validators/locale.ts
+var LANGUAGE_REGION_REGEX = /^([a-zA-Z]{2,3})(?:-([a-zA-Z]{4}))?(?:-([a-zA-Z]{2}|[0-9]{3}))?/;
+var COMMON_LANGUAGES = /* @__PURE__ */ new Set([
+  "aa",
+  "ab",
+  "ae",
+  "af",
+  "ak",
+  "am",
+  "an",
+  "ar",
+  "as",
+  "av",
+  "ay",
+  "az",
+  "ba",
+  "be",
+  "bg",
+  "bh",
+  "bi",
+  "bm",
+  "bn",
+  "bo",
+  "br",
+  "bs",
+  "ca",
+  "ce",
+  "ch",
+  "co",
+  "cr",
+  "cs",
+  "cu",
+  "cv",
+  "cy",
+  "da",
+  "de",
+  "dv",
+  "dz",
+  "ee",
+  "el",
+  "en",
+  "eo",
+  "es",
+  "et",
+  "eu",
+  "fa",
+  "ff",
+  "fi",
+  "fj",
+  "fo",
+  "fr",
+  "fy",
+  "ga",
+  "gd",
+  "gl",
+  "gn",
+  "gu",
+  "gv",
+  "ha",
+  "he",
+  "hi",
+  "ho",
+  "hr",
+  "ht",
+  "hu",
+  "hy",
+  "hz",
+  "ia",
+  "id",
+  "ie",
+  "ig",
+  "ii",
+  "ik",
+  "io",
+  "is",
+  "it",
+  "iu",
+  "ja",
+  "jv",
+  "ka",
+  "kg",
+  "ki",
+  "kj",
+  "kk",
+  "kl",
+  "km",
+  "kn",
+  "ko",
+  "kr",
+  "ks",
+  "ku",
+  "kv",
+  "kw",
+  "ky",
+  "la",
+  "lb",
+  "lg",
+  "li",
+  "ln",
+  "lo",
+  "lt",
+  "lu",
+  "lv",
+  "mg",
+  "mh",
+  "mi",
+  "mk",
+  "ml",
+  "mn",
+  "mr",
+  "ms",
+  "mt",
+  "my",
+  "na",
+  "nb",
+  "nd",
+  "ne",
+  "ng",
+  "nl",
+  "nn",
+  "no",
+  "nr",
+  "nv",
+  "ny",
+  "oc",
+  "oj",
+  "om",
+  "or",
+  "os",
+  "pa",
+  "pi",
+  "pl",
+  "ps",
+  "pt",
+  "qu",
+  "rm",
+  "rn",
+  "ro",
+  "ru",
+  "rw",
+  "sa",
+  "sc",
+  "sd",
+  "se",
+  "sg",
+  "si",
+  "sk",
+  "sl",
+  "sm",
+  "sn",
+  "so",
+  "sq",
+  "sr",
+  "ss",
+  "st",
+  "su",
+  "sv",
+  "sw",
+  "ta",
+  "te",
+  "tg",
+  "th",
+  "ti",
+  "tk",
+  "tl",
+  "tn",
+  "to",
+  "tr",
+  "ts",
+  "tt",
+  "tw",
+  "ty",
+  "ug",
+  "uk",
+  "ur",
+  "uz",
+  "ve",
+  "vi",
+  "vo",
+  "wa",
+  "wo",
+  "xh",
+  "yi",
+  "yo",
+  "za",
+  "zh",
+  "zu"
+]);
+function parseAndValidateLocale(raw, opts) {
+  const trimmed = raw.trim().toLowerCase();
+  if (trimmed.length === 0) {
+    return { success: false, error: "Locale must not be empty" };
+  }
+  if (opts.allowExtensions !== true && /-[uU]-/.test(trimmed)) {
+    return { success: false, error: "Unicode locale extensions are not allowed" };
+  }
+  const baseLocale = trimmed.split("-u-")[0] ?? trimmed;
+  const match = baseLocale.match(LANGUAGE_REGION_REGEX);
+  if (!match) {
+    return {
+      success: false,
+      error: `"${trimmed}" is not a valid BCP 47 locale tag`
+    };
+  }
+  const language = match[1];
+  const script = match[2];
+  const region = match[3];
+  if (language === void 0) {
+    return { success: false, error: "Locale must include a language subtag" };
+  }
+  if (opts.allowedLanguages !== void 0) {
+    const allowed = opts.allowedLanguages.map((l) => l.toLowerCase());
+    if (!allowed.includes(language)) {
+      return {
+        success: false,
+        error: `Language "${language}" is not allowed. Allowed: ${allowed.join(", ")}`
+      };
+    }
+  }
+  if (!COMMON_LANGUAGES.has(language) && opts.allowedLanguages === void 0) {
+  }
+  if (opts.requireRegion === true && region === void 0 && script === void 0) {
+    return {
+      success: false,
+      error: 'Locale must include a region subtag (e.g., "en-US")'
+    };
+  }
+  void script;
+  return { success: true, value: trimmed };
+}
+function createLocaleSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateLocale(raw, options);
+  return new SchemaBuilder(parser, "locale");
+}
+
+// src/schema/validators/timezone.ts
+var IANA_TZ_REGEX = /^(?:Africa|America|Antarctica|Arctic|Asia|Atlantic|Australia|Europe|Indian|Pacific|Etc|UTC)\/[a-zA-Z0-9_+-]+(?:\/[a-zA-Z0-9_+-]+)*$/;
+var UTC_OFFSET_REGEX = /^(?:UTC|GMT)(?:[+-](?:[01]?\d|2[0-3])(?::(?:[0-5]\d))?)?$/;
+var SHORT_TIMEZONES = /* @__PURE__ */ new Set([
+  "UTC",
+  "GMT",
+  "EST",
+  "EDT",
+  "CST",
+  "CDT",
+  "MST",
+  "MDT",
+  "PST",
+  "PDT",
+  "AKST",
+  "AKDT",
+  "HST",
+  "HDT",
+  "SST",
+  "SDT",
+  "CHST",
+  "WET",
+  "WEST",
+  "CET",
+  "CEST",
+  "EET",
+  "EEST",
+  "MSK",
+  "MSD",
+  "AST",
+  "ADT",
+  "NST",
+  "NDT",
+  "GST",
+  "AZT",
+  "AFT",
+  "PKT",
+  "IST",
+  "NPT",
+  "BST",
+  "ICT",
+  "WIB",
+  "PHT",
+  "JST",
+  "KST",
+  "CST"
+]);
+function parseAndValidateTimezone(raw, opts) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    return { success: false, error: "Timezone must not be empty" };
+  }
+  if (trimmed === "Z") {
+    if (opts.allowZ !== false) {
+      return { success: true, value: trimmed };
+    }
+    return { success: false, error: '"Z" timezone identifier is not allowed' };
+  }
+  if (IANA_TZ_REGEX.test(trimmed)) {
+    return { success: true, value: trimmed };
+  }
+  if (opts.allowOffset !== false && UTC_OFFSET_REGEX.test(trimmed)) {
+    return { success: true, value: trimmed };
+  }
+  if (opts.allowShort === true && SHORT_TIMEZONES.has(trimmed.toUpperCase())) {
+    return { success: true, value: trimmed.toUpperCase() };
+  }
+  return {
+    success: false,
+    error: `"${trimmed}" is not a valid IANA timezone identifier. Expected format: "Area/Location" (e.g., "America/New_York", "Europe/London")`
+  };
+}
+function createTimezoneSchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateTimezone(raw, options);
+  return new SchemaBuilder(parser, "timezone");
+}
+
+// src/schema/validators/country.ts
+var ALPHA2_CODES = /* @__PURE__ */ new Set([
+  "AF",
+  "AX",
+  "AL",
+  "DZ",
+  "AS",
+  "AD",
+  "AO",
+  "AI",
+  "AQ",
+  "AG",
+  "AR",
+  "AM",
+  "AW",
+  "AU",
+  "AT",
+  "AZ",
+  "BS",
+  "BH",
+  "BD",
+  "BB",
+  "BY",
+  "BE",
+  "BZ",
+  "BJ",
+  "BM",
+  "BT",
+  "BO",
+  "BQ",
+  "BA",
+  "BW",
+  "BV",
+  "BR",
+  "IO",
+  "BN",
+  "BG",
+  "BF",
+  "BI",
+  "CV",
+  "KH",
+  "CM",
+  "CA",
+  "KY",
+  "CF",
+  "TD",
+  "CL",
+  "CN",
+  "CX",
+  "CC",
+  "CO",
+  "KM",
+  "CG",
+  "CD",
+  "CK",
+  "CR",
+  "CI",
+  "HR",
+  "CU",
+  "CW",
+  "CY",
+  "CZ",
+  "DK",
+  "DJ",
+  "DM",
+  "DO",
+  "EC",
+  "EG",
+  "SV",
+  "GQ",
+  "ER",
+  "EE",
+  "SZ",
+  "ET",
+  "FK",
+  "FO",
+  "FJ",
+  "FI",
+  "FR",
+  "GF",
+  "PF",
+  "TF",
+  "GA",
+  "GM",
+  "GE",
+  "DE",
+  "GH",
+  "GI",
+  "GR",
+  "GL",
+  "GD",
+  "GP",
+  "GU",
+  "GT",
+  "GG",
+  "GN",
+  "GW",
+  "GY",
+  "HT",
+  "HM",
+  "VA",
+  "HN",
+  "HK",
+  "HU",
+  "IS",
+  "IN",
+  "ID",
+  "IR",
+  "IQ",
+  "IE",
+  "IM",
+  "IL",
+  "IT",
+  "JM",
+  "JP",
+  "JE",
+  "JO",
+  "KZ",
+  "KE",
+  "KI",
+  "KP",
+  "KR",
+  "KW",
+  "KG",
+  "LA",
+  "LV",
+  "LB",
+  "LS",
+  "LR",
+  "LY",
+  "LI",
+  "LT",
+  "LU",
+  "MO",
+  "MG",
+  "MW",
+  "MY",
+  "MV",
+  "ML",
+  "MT",
+  "MH",
+  "MQ",
+  "MR",
+  "MU",
+  "YT",
+  "MX",
+  "FM",
+  "MD",
+  "MC",
+  "MN",
+  "ME",
+  "MS",
+  "MA",
+  "MZ",
+  "MM",
+  "NA",
+  "NR",
+  "NP",
+  "NL",
+  "NC",
+  "NZ",
+  "NI",
+  "NE",
+  "NG",
+  "NU",
+  "NF",
+  "MP",
+  "NO",
+  "OM",
+  "PK",
+  "PW",
+  "PS",
+  "PA",
+  "PG",
+  "PY",
+  "PE",
+  "PH",
+  "PN",
+  "PL",
+  "PT",
+  "PR",
+  "QA",
+  "RE",
+  "RO",
+  "RU",
+  "RW",
+  "BL",
+  "SH",
+  "KN",
+  "LC",
+  "MF",
+  "PM",
+  "VC",
+  "WS",
+  "SM",
+  "ST",
+  "SA",
+  "SN",
+  "RS",
+  "SC",
+  "SL",
+  "SG",
+  "SX",
+  "SK",
+  "SI",
+  "SB",
+  "SO",
+  "ZA",
+  "GS",
+  "SS",
+  "ES",
+  "LK",
+  "SD",
+  "SR",
+  "SJ",
+  "SE",
+  "CH",
+  "SY",
+  "TW",
+  "TJ",
+  "TZ",
+  "TH",
+  "TL",
+  "TG",
+  "TK",
+  "TO",
+  "TT",
+  "TN",
+  "TR",
+  "TM",
+  "TC",
+  "TV",
+  "UG",
+  "UA",
+  "AE",
+  "GB",
+  "US",
+  "UM",
+  "UY",
+  "UZ",
+  "VU",
+  "VE",
+  "VN",
+  "VG",
+  "VI",
+  "WF",
+  "EH",
+  "YE",
+  "ZM",
+  "ZW"
+]);
+var ALPHA3_CODES = /* @__PURE__ */ new Set([
+  "AFG",
+  "ALA",
+  "ALB",
+  "DZA",
+  "ASM",
+  "AND",
+  "AGO",
+  "AIA",
+  "ATA",
+  "ATG",
+  "ARG",
+  "ARM",
+  "ABW",
+  "AUS",
+  "AUT",
+  "AZE",
+  "BHS",
+  "BHR",
+  "BGD",
+  "BRB",
+  "BLR",
+  "BEL",
+  "BLZ",
+  "BEN",
+  "BMU",
+  "BTN",
+  "BOL",
+  "BES",
+  "BIH",
+  "BWA",
+  "BVT",
+  "BRA",
+  "IOT",
+  "BRN",
+  "BGR",
+  "BFA",
+  "BDI",
+  "CPV",
+  "KHM",
+  "CMR",
+  "CAN",
+  "CYM",
+  "CAF",
+  "TCD",
+  "CHL",
+  "CHN",
+  "CXR",
+  "CCK",
+  "COL",
+  "COM",
+  "COG",
+  "COD",
+  "COK",
+  "CRI",
+  "CIV",
+  "HRV",
+  "CUB",
+  "CUW",
+  "CYP",
+  "CZE",
+  "DNK",
+  "DJI",
+  "DMA",
+  "DOM",
+  "ECU",
+  "EGY",
+  "SLV",
+  "GNQ",
+  "ERI",
+  "EST",
+  "SWZ",
+  "ETH",
+  "FLK",
+  "FRO",
+  "FJI",
+  "FIN",
+  "FRA",
+  "GUF",
+  "PYF",
+  "ATF",
+  "GAB",
+  "GMB",
+  "GEO",
+  "DEU",
+  "GHA",
+  "GIB",
+  "GRC",
+  "GRL",
+  "GRD",
+  "GLP",
+  "GUM",
+  "GTM",
+  "GGY",
+  "GIN",
+  "GNB",
+  "GUY",
+  "HTI",
+  "HMD",
+  "VAT",
+  "HND",
+  "HKG",
+  "HUN",
+  "ISL",
+  "IND",
+  "IDN",
+  "IRN",
+  "IRQ",
+  "IRL",
+  "IMN",
+  "ISR",
+  "ITA",
+  "JAM",
+  "JPN",
+  "JEY",
+  "JOR",
+  "KAZ",
+  "KEN",
+  "KIR",
+  "PRK",
+  "KOR",
+  "KWT",
+  "KGZ",
+  "LAO",
+  "LVA",
+  "LBN",
+  "L SO",
+  "LBR",
+  "LBY",
+  "LIE",
+  "LTU",
+  "LUX",
+  "MAC",
+  "MDG",
+  "MWI",
+  "MYS",
+  "MDV",
+  "MLI",
+  "MLT",
+  "MHL",
+  "MTQ",
+  "MRT",
+  "MUS",
+  "MYT",
+  "MEX",
+  "FSM",
+  "MDA",
+  "MCO",
+  "MNG",
+  "MNE",
+  "MSR",
+  "MAR",
+  "MOZ",
+  "MMR",
+  "NAM",
+  "NRU",
+  "NPL",
+  "NLD",
+  "NCL",
+  "NZL",
+  "NIC",
+  "NER",
+  "NGA",
+  "NIU",
+  "NFK",
+  "MNP",
+  "NOR",
+  "OMN",
+  "PAK",
+  "PLW",
+  "PSE",
+  "PAN",
+  "PNG",
+  "PRY",
+  "PER",
+  "PHL",
+  "PCN",
+  "POL",
+  "PRT",
+  "PRI",
+  "QAT",
+  "REU",
+  "ROU",
+  "RUS",
+  "RWA",
+  "BLM",
+  "SHN",
+  "KNA",
+  "LCA",
+  "MAF",
+  "SPM",
+  "VCT",
+  "WSM",
+  "SMR",
+  "STP",
+  "SAU",
+  "SEN",
+  "SRB",
+  "SYC",
+  "SLE",
+  "SGP",
+  "SXM",
+  "SVK",
+  "SVN",
+  "SLB",
+  "SOM",
+  "ZAF",
+  "SGS",
+  "SSD",
+  "ESP",
+  "LKA",
+  "SDN",
+  "SUR",
+  "SJM",
+  "SWE",
+  "CHE",
+  "SYR",
+  "TWN",
+  "TJK",
+  "TZA",
+  "THA",
+  "TLS",
+  "TGO",
+  "TKL",
+  "TON",
+  "TTO",
+  "TUN",
+  "TUR",
+  "TKM",
+  "TCA",
+  "TUV",
+  "UGA",
+  "UKR",
+  "ARE",
+  "GBR",
+  "USA",
+  "UMI",
+  "URY",
+  "UZB",
+  "VUT",
+  "VEN",
+  "VNM",
+  "VGB",
+  "VIR",
+  "WLF",
+  "ESH",
+  "YEM",
+  "ZMB",
+  "ZWE"
+]);
+var NUMERIC_REGEX = /^\d{3}$/;
+function parseAndValidateCountry(raw, opts) {
+  const trimmed = raw.trim().toUpperCase();
+  const format = opts.format ?? "both";
+  if (trimmed.length === 0) {
+    return { success: false, error: "Country code must not be empty" };
+  }
+  if (opts.allowNumeric === true && NUMERIC_REGEX.test(trimmed)) {
+    return { success: true, value: trimmed };
+  }
+  if (trimmed.length === 2 && (format === "alpha2" || format === "both")) {
+    if (ALPHA2_CODES.has(trimmed)) {
+      return { success: true, value: trimmed };
+    }
+    return {
+      success: false,
+      error: `"${trimmed}" is not a valid ISO 3166-1 alpha-2 country code`
+    };
+  }
+  if (trimmed.length === 3 && (format === "alpha3" || format === "both")) {
+    if (ALPHA3_CODES.has(trimmed)) {
+      return { success: true, value: trimmed };
+    }
+    return {
+      success: false,
+      error: `"${trimmed}" is not a valid ISO 3166-1 alpha-3 country code`
+    };
+  }
+  return {
+    success: false,
+    error: `"${trimmed}" is not a valid country code. Expected ISO 3166-1 alpha-2 (e.g., "US") or alpha-3 (e.g., "USA")`
+  };
+}
+function createCountrySchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateCountry(raw, options);
+  return new SchemaBuilder(parser, "country");
+}
+
+// src/schema/validators/currency.ts
+var CURRENCY_CODES = /* @__PURE__ */ new Set([
+  "AED",
+  "AFN",
+  "ALL",
+  "AMD",
+  "ANG",
+  "AOA",
+  "ARS",
+  "AUD",
+  "AWG",
+  "AZN",
+  "BAM",
+  "BBD",
+  "BDT",
+  "BGN",
+  "BHD",
+  "BIF",
+  "BMD",
+  "BND",
+  "BOB",
+  "BOV",
+  "BRL",
+  "BSD",
+  "BTN",
+  "BWP",
+  "BYN",
+  "BZD",
+  "CAD",
+  "CDF",
+  "CHE",
+  "CHF",
+  "CHW",
+  "CLF",
+  "CLP",
+  "CNY",
+  "COP",
+  "COU",
+  "CRC",
+  "CUC",
+  "CUP",
+  "CVE",
+  "CZK",
+  "DJF",
+  "DKK",
+  "DOP",
+  "DZD",
+  "EGP",
+  "ERN",
+  "ETB",
+  "EUR",
+  "FJD",
+  "FKP",
+  "GBP",
+  "GEL",
+  "GHS",
+  "GIP",
+  "GMD",
+  "GNF",
+  "GTQ",
+  "GYD",
+  "HKD",
+  "HNL",
+  "HRK",
+  "HTG",
+  "HUF",
+  "IDR",
+  "ILS",
+  "INR",
+  "IQD",
+  "IRR",
+  "ISK",
+  "JMD",
+  "JOD",
+  "JPY",
+  "KES",
+  "KGS",
+  "KHR",
+  "KMF",
+  "KPW",
+  "KRW",
+  "KWD",
+  "KYD",
+  "KZT",
+  "LAK",
+  "LBP",
+  "LKR",
+  "LRD",
+  "LSL",
+  "LYD",
+  "MAD",
+  "MDL",
+  "MGA",
+  "MKD",
+  "MMK",
+  "MNT",
+  "MOP",
+  "MRU",
+  "MUR",
+  "MVR",
+  "MWK",
+  "MXN",
+  "MXV",
+  "MYR",
+  "MZN",
+  "NAD",
+  "NGN",
+  "NIO",
+  "NOK",
+  "NPR",
+  "NZD",
+  "OMR",
+  "PAB",
+  "PEN",
+  "PGK",
+  "PHP",
+  "PKR",
+  "PLN",
+  "PYG",
+  "QAR",
+  "RON",
+  "RSD",
+  "RUB",
+  "RWF",
+  "SAR",
+  "SBD",
+  "SCR",
+  "SDG",
+  "SEK",
+  "SGD",
+  "SHP",
+  "SLE",
+  "SLL",
+  "SOS",
+  "SRD",
+  "SSP",
+  "STN",
+  "SVC",
+  "SYP",
+  "SZL",
+  "THB",
+  "TJS",
+  "TMT",
+  "TND",
+  "TOP",
+  "TRY",
+  "TTD",
+  "TWD",
+  "TZS",
+  "UAH",
+  "UGX",
+  "USD",
+  "USN",
+  "UYI",
+  "UYU",
+  "UYW",
+  "UZS",
+  "VED",
+  "VES",
+  "VND",
+  "VUV",
+  "WST",
+  "XAF",
+  "XAG",
+  "XAU",
+  "XBA",
+  "XBB",
+  "XBC",
+  "XBD",
+  "XCD",
+  "XDR",
+  "XOF",
+  "XPD",
+  "XPF",
+  "XPT",
+  "XSU",
+  "XTS",
+  "XUA",
+  "XXX",
+  "YER",
+  "ZAR",
+  "ZMW",
+  "ZWL",
+  // Historic / commonly used
+  "BEF",
+  "BYR",
+  "CSD",
+  "EEK",
+  "FIM",
+  "GRD",
+  "IEP",
+  "ITL",
+  "LTL",
+  "LVL",
+  "MRO",
+  "NLG",
+  "PTE",
+  "ROL",
+  "RUR",
+  "SKK",
+  "SRG",
+  "STD",
+  "VEF",
+  "VEB",
+  "YUM"
+]);
+var CRYPTO_CODES = /* @__PURE__ */ new Set([
+  "BTC",
+  "ETH",
+  "LTC",
+  "BCH",
+  "XRP",
+  "DASH",
+  "NEO",
+  "EOS",
+  "XLM",
+  "ADA",
+  "XTZ",
+  "XMR",
+  "LINK",
+  "DOT",
+  "YFI",
+  "UNI",
+  "SOL",
+  "MATIC",
+  "AVAX",
+  "SHIB",
+  "DOGE",
+  "USDT",
+  "USDC",
+  "BNB",
+  "FTM",
+  "ATOM",
+  "ALGO",
+  "VET",
+  "ICP",
+  "FIL",
+  "TRX",
+  "ETC",
+  "HBAR",
+  "THETA",
+  "AXS",
+  "MANA",
+  "SAND",
+  "APE",
+  "GRT",
+  "FTT"
+]);
+var CURRENCY_REGEX = /^[A-Z]{3}$/;
+function parseAndValidateCurrency(raw, opts) {
+  const trimmed = raw.trim().toUpperCase();
+  if (trimmed.length === 0) {
+    return { success: false, error: "Currency code must not be empty" };
+  }
+  if (!CURRENCY_REGEX.test(trimmed)) {
+    return {
+      success: false,
+      error: `Currency code must be exactly 3 uppercase letters, got "${trimmed}"`
+    };
+  }
+  const allowCrypto = opts.allowCrypto ?? false;
+  if (CURRENCY_CODES.has(trimmed)) {
+    return { success: true, value: trimmed };
+  }
+  if (allowCrypto && CRYPTO_CODES.has(trimmed)) {
+    return { success: true, value: trimmed };
+  }
+  return {
+    success: false,
+    error: `"${trimmed}" is not a valid ISO 4217 currency code`
+  };
+}
+function createCurrencySchema(opts) {
+  const options = opts ?? {};
+  const parser = (raw) => parseAndValidateCurrency(raw, options);
+  return new SchemaBuilder(parser, "currency");
+}
+
+// src/schema/modifiers/required.ts
+function applyRequired(builder) {
+  void builder;
+  return builder;
+}
+function isRequired(builder) {
+  return !builder.meta.required ? false : builder.meta.required;
+}
+
+// src/schema/modifiers/optional.ts
+function applyOptional(builder) {
+  void builder;
+  return builder;
+}
+function isOptional(builder) {
+  return builder.isOptional;
+}
+
+// src/schema/modifiers/default.ts
+function applyDefault(builder, defaultValue) {
+  void builder;
+  void defaultValue;
+  return builder;
+}
+function hasDefault(builder) {
+  return builder.meta.hasDefault;
+}
+function getDefaultValue(builder) {
+  return builder.getDefaultValue();
+}
+
+// src/schema/modifiers/secret.ts
+function applySecret(builder) {
+  void builder;
+  return builder;
+}
+function isSecret(builder) {
+  return builder.meta.isSecret;
+}
+function maskValue(value, builder) {
+  if (!builder.meta.isSecret) {
+    return String(value);
+  }
+  const str = String(value);
+  if (str.length <= 4) {
+    return "****";
+  }
+  return str.slice(0, 4) + "*".repeat(Math.min(str.length - 4, 20));
+}
+
+// src/schema/modifiers/deprecated.ts
+function applyDeprecated(builder, message) {
+  void builder;
+  void message;
+  return builder;
+}
+function isDeprecated(builder) {
+  return builder.meta.isDeprecated;
+}
+function getDeprecationMessage(builder) {
+  return builder.meta.deprecationMessage;
+}
+
+// src/schema/modifiers/alias.ts
+function applyAlias(builder, ...names) {
+  void builder;
+  void names;
+  return builder;
+}
+function getAliases(builder) {
+  return builder.meta.aliases;
+}
+function isAlias(builder, name) {
+  return builder.meta.aliases.includes(name);
+}
+
+// src/schema/modifiers/transform.ts
+function applyTransform(builder, fn) {
+  void builder;
+  void fn;
+  return builder;
+}
+function composeTransforms(...fns) {
+  return (value) => {
+    let result = value;
+    for (const fn of fns) {
+      result = fn(result);
+    }
+    return result;
+  };
+}
+
+// src/schema/modifiers/custom.ts
+function applyCustom(builder, fn) {
+  void builder;
+  void fn;
+  return builder;
+}
+function minLength(n) {
+  return (value) => {
+    if (value.length < n) {
+      return `Value must be at least ${n} characters, got ${value.length}`;
+    }
+    return null;
+  };
+}
+function maxLength(n) {
+  return (value) => {
+    if (value.length > n) {
+      return `Value must be at most ${n} characters, got ${value.length}`;
+    }
+    return null;
+  };
+}
+function check(condition, message) {
+  return (value) => {
+    if (!condition(value)) {
+      return message;
+    }
+    return null;
+  };
+}
+function allOf(...validators) {
+  return (value) => {
+    for (const validator of validators) {
+      const error = validator(value);
+      if (error !== null) {
+        return error;
+      }
+    }
+    return null;
+  };
+}
+
+// src/schema/modifiers/conditional.ts
+function applyConditional(builder, check2) {
+  void builder;
+  void check2;
+  return builder;
+}
+function hasConditional(builder) {
+  return builder.meta.conditional !== void 0;
+}
+function shouldApply(builder, env) {
+  const conditional = builder.meta.conditional;
+  if (conditional === void 0) {
+    return true;
+  }
+  try {
+    return conditional.check(env);
+  } catch {
+    return true;
+  }
+}
+
+// src/schema/modifiers/description.ts
+function applyDescription(builder, desc) {
+  void builder;
+  void desc;
+  return builder;
+}
+function getDescription(builder) {
+  return builder.meta.description;
+}
+function formatSchemaDescription(builder, fieldName) {
+  const lines = [];
+  lines.push(`${fieldName} (${builder.typeName})`);
+  if (builder.meta.description) {
+    lines.push(`  ${builder.meta.description}`);
+  }
+  if (builder.meta.isSecret) {
+    lines.push("  [SECRET] - This value will be masked in logs");
+  }
+  if (builder.meta.isDeprecated) {
+    const msg = builder.meta.deprecationMessage ?? "This variable is deprecated";
+    lines.push(`  [DEPRECATED] - ${msg}`);
+  }
+  if (builder.meta.aliases.length > 0) {
+    lines.push(`  Aliases: ${builder.meta.aliases.join(", ")}`);
+  }
+  if (builder.meta.hasDefault) {
+    lines.push(`  Default: ${builder.meta.rawDefaultValue ?? "(complex)"}`);
+  }
+  return lines.join("\n");
+}
+
+// src/schema/index.ts
+var t = {
+  string: () => createStringSchema(),
+  number: () => createNumberSchema(),
+  boolean: () => createBooleanSchema(),
+  enum: (values) => createEnumSchema(values),
+  array: () => createArraySchema(),
+  json: () => createJsonSchema(),
+  date: () => createDateSchema(),
+  regex: () => createRegexSchema(),
+  bigint: () => createBigIntSchema(),
+  url: (opts) => createUrlSchema(opts),
+  email: (opts) => createEmailSchema(opts),
+  ip: (opts) => createIpSchema(opts),
+  ipv4: (opts) => createIpv4Schema(opts),
+  ipv6: (opts) => createIpv6Schema(opts),
+  hostname: (opts) => createHostnameSchema(opts),
+  port: (opts) => createPortSchema(opts),
+  path: (opts) => createPathSchema(opts),
+  uuid: (opts) => createUuidSchema(opts),
+  hex: (opts) => createHexSchema(opts),
+  base64: (opts) => createBase64Schema(opts),
+  semver: (opts) => createSemverSchema(opts),
+  cron: (opts) => createCronSchema(opts),
+  duration: (opts) => createDurationSchema(opts),
+  bytes: (opts) => createBytesSchema(opts),
+  color: (opts) => createColorSchema(opts),
+  locale: (opts) => createLocaleSchema(opts),
+  timezone: (opts) => createTimezoneSchema(opts),
+  country: (opts) => createCountrySchema(opts),
+  currency: (opts) => createCurrencySchema(opts)
+};
+function defineEnv(schema, vars, options) {
+  const envVars = vars ?? getProcessEnv();
+  const result = validate(envVars, schema, options);
+  for (const warning of result.warnings) {
+    process.stderr.write(`[ultraenv] Warning: ${warning.field}: ${warning.message}
+`);
+  }
+  if (!result.valid) {
+    const messages = result.errors.map((e) => `  - ${e.field}: ${e.message}`).join("\n");
+    const unknownMsg = result.unknown.length > 0 ? `
+Unknown variables: ${result.unknown.join(", ")}` : "";
+    throw new Error(
+      `Environment validation failed:
+${messages}${unknownMsg}`
+    );
+  }
+  return result.values;
+}
+function tryDefineEnv(schema, vars, options) {
+  const envVars = vars ?? getProcessEnv();
+  const result = validate(envVars, schema, options);
+  if (result.valid) {
+    return {
+      valid: true,
+      values: result.values,
+      warnings: result.warnings
+    };
+  }
+  return {
+    valid: false,
+    values: result.values,
+    warnings: result.warnings,
+    errors: result.errors,
+    unknown: result.unknown
+  };
+}
+function getProcessEnv() {
+  const result = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export {
+  SchemaBuilder,
+  validate,
+  validateValue,
+  formatValidationResult,
+  StringSchemaBuilder,
+  createStringSchema,
+  NumberSchemaBuilder,
+  createNumberSchema,
+  BooleanSchemaBuilder,
+  createBooleanSchema,
+  EnumSchemaBuilder,
+  createEnumSchema,
+  ArraySchemaBuilder,
+  createArraySchema,
+  JsonSchemaBuilder,
+  createJsonSchema,
+  DateSchemaBuilder,
+  createDateSchema,
+  RegexSchemaBuilder,
+  createRegexSchema,
+  BigIntSchemaBuilder,
+  createBigIntSchema,
+  createUrlSchema,
+  createEmailSchema,
+  createIpSchema,
+  createIpv4Schema,
+  createIpv6Schema,
+  createHostnameSchema,
+  createPortSchema,
+  createPathSchema,
+  createUuidSchema,
+  createHexSchema,
+  createBase64Schema,
+  createSemverSchema,
+  createCronSchema,
+  createDurationSchema,
+  createBytesSchema,
+  createColorSchema,
+  createLocaleSchema,
+  createTimezoneSchema,
+  createCountrySchema,
+  createCurrencySchema,
+  applyRequired,
+  isRequired,
+  applyOptional,
+  isOptional,
+  applyDefault,
+  hasDefault,
+  getDefaultValue,
+  applySecret,
+  isSecret,
+  maskValue,
+  applyDeprecated,
+  isDeprecated,
+  getDeprecationMessage,
+  applyAlias,
+  getAliases,
+  isAlias,
+  applyTransform,
+  composeTransforms,
+  applyCustom,
+  minLength,
+  maxLength,
+  check,
+  allOf,
+  applyConditional,
+  hasConditional,
+  shouldApply,
+  applyDescription,
+  getDescription,
+  formatSchemaDescription,
+  t,
+  defineEnv,
+  tryDefineEnv
+};