schema-dsl 1.2.5 → 2.0.1

package/dist/plugins/custom-type-example.js

@@ -0,0 +1,3781 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/parser/TypeRegistry.ts
+var INTERNAL_KEYS, BUILTIN_TYPES, CUSTOM_TYPES, DYNAMIC_TYPES, _strictMode, TypeRegistry;
+var init_TypeRegistry = __esm({
+  "src/parser/TypeRegistry.ts"() {
+    "use strict";
+    INTERNAL_KEYS = /* @__PURE__ */ new Set([
+      "_label",
+      "_customMessages",
+      "_description",
+      "_required",
+      "_isConditional",
+      "_runtimeOnlyConditional",
+      "conditions",
+      "_evaluateCondition",
+      // Custom AJV keywords (non-standard JSON Schema fields, stripped on output)
+      "exactLength",
+      "alphanum",
+      "lowercase",
+      "uppercase",
+      "trim",
+      "jsonString",
+      "port",
+      "requiredAll",
+      "strictSchema",
+      "noSparse",
+      "includesRequired",
+      "dateFormat",
+      "dateGreater",
+      "dateLess",
+      "precision"
+      // ⚠️ multipleOf is a standard JSON Schema field and is NOT in this list (fix DB-01)
+    ]);
+    BUILTIN_TYPES = /* @__PURE__ */ new Map([
+      // --- Primitive types ---
+      ["string", { baseSchema: { type: "string" } }],
+      ["number", { baseSchema: { type: "number" } }],
+      ["integer", { baseSchema: { type: "integer" } }],
+      ["boolean", { baseSchema: { type: "boolean" } }],
+      ["object", { baseSchema: { type: "object" } }],
+      ["array", { baseSchema: { type: "array" } }],
+      ["null", { baseSchema: { type: "null" } }],
+      ["any", { baseSchema: {} }],
+      // --- Format types ---
+      ["email", { baseSchema: { type: "string", format: "email" } }],
+      ["url", { baseSchema: { type: "string", format: "uri" } }],
+      ["uri", { baseSchema: { type: "string", format: "uri" } }],
+      ["uuid", { baseSchema: { type: "string", format: "uuid" } }],
+      ["ipv4", { baseSchema: { type: "string", format: "ipv4" } }],
+      ["ipv6", { baseSchema: { type: "string", format: "ipv6" } }],
+      ["ip", { baseSchema: { anyOf: [{ type: "string", format: "ipv4" }, { type: "string", format: "ipv6" }] } }],
+      ["hostname", { baseSchema: { type: "string", format: "hostname" } }],
+      ["date", { baseSchema: { type: "string", format: "date" } }],
+      ["datetime", { baseSchema: { type: "string", format: "date-time" } }],
+      ["time", { baseSchema: { type: "string", format: "time" } }],
+      // --- Special string types ---
+      ["binary", { baseSchema: { type: "string", contentEncoding: "base64" } }],
+      ["objectId", { baseSchema: { type: "string", pattern: "^[0-9a-fA-F]{24}$" }, customMessages: { pattern: "pattern.objectId" } }],
+      ["hexColor", { baseSchema: { type: "string", pattern: "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$" }, customMessages: { pattern: "pattern.hexColor" } }],
+      ["macAddress", {
+        baseSchema: { type: "string", pattern: "^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$" },
+        customMessages: { pattern: "pattern.macAddress" }
+      }],
+      ["cron", {
+        baseSchema: {
+          type: "string",
+          pattern: "^(\\*|([0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])|\\*\\/([0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9])) (\\*|([0-9]|1[0-9]|2[0-3])|\\*\\/([0-9]|1[0-9]|2[0-3])) (\\*|([1-9]|1[0-9]|2[0-9]|3[0-1])|\\*\\/([1-9]|1[0-9]|2[0-9]|3[0-1])) (\\*|([1-9]|1[0-2])|\\*\\/([1-9]|1[0-2])) (\\*|([0-6])|\\*\\/([0-6]))$"
+        },
+        customMessages: { pattern: "pattern.cron" }
+      }],
+      // --- slug (fix DB-02: v1 DslAdapter was missing slug type definition) ---
+      ["slug", {
+        baseSchema: { type: "string", pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+        customMessages: { pattern: "pattern.slug" }
+      }],
+      // --- CJK / Chinese ---
+      ["chineseName", {
+        baseSchema: { type: "string", pattern: "^[\\u4e00-\\u9fa5]{2,10}$" },
+        customMessages: { pattern: "chineseName" }
+      }],
+      ["chinese", {
+        baseSchema: { type: "string", pattern: "^[\\u4e00-\\u9fa5]+$" }
+      }],
+      // --- Domain-related (handled by CustomKeywords; only baseSchema registered here) ---
+      ["emailDomain", { baseSchema: { type: "string", format: "email" } }],
+      // --- v1 extension types (DslBuilder v1.0.2) ---
+      ["alphanum", { baseSchema: { type: "string", alphanum: true } }],
+      ["lower", { baseSchema: { type: "string", lowercase: true } }],
+      ["upper", { baseSchema: { type: "string", uppercase: true } }],
+      ["json", { baseSchema: { type: "string", jsonString: true } }],
+      ["port", { baseSchema: { type: "integer", port: true } }]
+    ]);
+    CUSTOM_TYPES = /* @__PURE__ */ new Map();
+    DYNAMIC_TYPES = /* @__PURE__ */ new Map();
+    _strictMode = false;
+    TypeRegistry = {
+      /**
+       * Resolve a type name to its TypeDefinition.
+       * Built-in types take priority; custom types may override non-primitive built-ins.
+       */
+      resolve(typeName) {
+        const dynamicFn = DYNAMIC_TYPES.get(typeName);
+        if (dynamicFn) {
+          return { baseSchema: dynamicFn() };
+        }
+        const custom = CUSTOM_TYPES.get(typeName);
+        if (custom) return custom;
+        const builtin = BUILTIN_TYPES.get(typeName);
+        if (builtin) return builtin;
+        if (_strictMode) {
+          throw new Error(`[schema-dsl] Unknown type "${typeName}"`);
+        }
+        console.warn(`[schema-dsl] Unknown type "${typeName}", falling back to string`);
+        return { baseSchema: { type: "string" } };
+      },
+      /**
+       * Register a custom type (delegated from DslBuilder.registerType)
+       */
+      register(name, def) {
+        if (!name || typeof name !== "string") {
+          throw new Error("[schema-dsl] TypeRegistry.register: name must be a non-empty string");
+        }
+        const normalized = "baseSchema" in def ? def : { baseSchema: def };
+        CUSTOM_TYPES.set(name, normalized);
+      },
+      /**
+       * Register a dynamic type (factory function invoked on every resolve call)
+       */
+      registerDynamic(name, factory) {
+        if (!name || typeof name !== "string") {
+          throw new Error("[schema-dsl] TypeRegistry.registerDynamic: name must be a non-empty string");
+        }
+        DYNAMIC_TYPES.set(name, factory);
+      },
+      /**
+       * Unregister a custom type
+       */
+      unregister(name) {
+        CUSTOM_TYPES.delete(name);
+        DYNAMIC_TYPES.delete(name);
+      },
+      /**
+       * Clear all custom and dynamic types (primarily for testing; called by DslBuilder.clearCustomTypes).
+       * Built-in types are unaffected.
+       */
+      clearCustomTypes() {
+        CUSTOM_TYPES.clear();
+        DYNAMIC_TYPES.clear();
+      },
+      /**
+       * Enable or disable strict mode for type resolution.
+       * In strict mode, resolving an unknown type throws instead of warning and falling back to string.
+       */
+      setStrict(flag) {
+        _strictMode = flag;
+      },
+      /**
+       * Check whether a type is registered (built-in or custom)
+       */
+      has(typeName) {
+        return BUILTIN_TYPES.has(typeName) || CUSTOM_TYPES.has(typeName) || DYNAMIC_TYPES.has(typeName);
+      },
+      /**
+       * Return an iterator over all registered types (built-in + custom; custom overrides same-name built-in)
+       * BC-4 compat: consumed by the DslAdapter.typeMap getter
+       */
+      entries() {
+        const merged = new Map([...BUILTIN_TYPES, ...CUSTOM_TYPES]);
+        return merged.entries();
+      },
+      /**
+       * Return the internal key set (used to strip non-standard fields during toJsonSchema)
+       */
+      getInternalKeys() {
+        return INTERNAL_KEYS;
+      },
+      /**
+       * Strip internal keys from a schema and return a clean JSON Schema.
+       *
+       * Special case for exactLength: translated to standard minLength + maxLength
+       * instead of being stripped. This preserves v1 DslBuilder string:N behavior
+       * (output {minLength:N, maxLength:N}) while keeping AJV's exactLength Unicode
+       * code-point counting advantage internally (CK-Y04).
+       */
+      toJsonSchema(schema) {
+        const result = {};
+        for (const [k, v] of Object.entries(schema)) {
+          if (k === "exactLength" && typeof v === "number") {
+            result.minLength = v;
+            result.maxLength = v;
+          } else if (!INTERNAL_KEYS.has(k)) {
+            result[k] = v;
+          }
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/parser/ConstraintParser.ts
+var ConstraintParser;
+var init_ConstraintParser = __esm({
+  "src/parser/ConstraintParser.ts"() {
+    "use strict";
+    ConstraintParser = {
+      /**
+       * Parse a constraint string
+       * @param constraintStr - The constraint portion (type name and '!' already stripped)
+       * @param baseType - Base type name ('string' | 'number' | 'integer' | 'array' | ...)
+       * @returns Partial<JSONSchema>; returns {} when unparseable (avoids polluting the target schema)
+       */
+      parse(constraintStr, baseType) {
+        if (!constraintStr) return {};
+        const s = constraintStr.trim();
+        if (!s) return {};
+        if (baseType === "number" || baseType === "integer") {
+          const gteMatch = /^>=(-?\d+(?:\.\d+)?)$/.exec(s);
+          if (gteMatch) return { minimum: parseFloat(gteMatch[1]) };
+          const lteMatch = /^<=(-?\d+(?:\.\d+)?)$/.exec(s);
+          if (lteMatch) return { maximum: parseFloat(lteMatch[1]) };
+          const gtMatch = /^>(-?\d+(?:\.\d+)?)$/.exec(s);
+          if (gtMatch) return { exclusiveMinimum: parseFloat(gtMatch[1]) };
+          const ltMatch = /^<(-?\d+(?:\.\d+)?)$/.exec(s);
+          if (ltMatch) return { exclusiveMaximum: parseFloat(ltMatch[1]) };
+          const eqMatch = /^=(-?\d+(?:\.\d+)?)$/.exec(s);
+          if (eqMatch) return { enum: [parseFloat(eqMatch[1])] };
+        }
+        if (s.includes("|") && !/^-?\d*\.?\d*--?\d*\.?\d*$/.test(s)) {
+          return { enum: s.split("|").map((v) => v.trim()) };
+        }
+        const rangeMatch = /^(-?\d*\.?\d*)-(-?\d*\.?\d*)$/.exec(s);
+        if (rangeMatch) {
+          const [, rawMin, rawMax] = rangeMatch;
+          const result = {};
+          if (baseType === "string") {
+            if (rawMin) result.minLength = Math.max(0, parseInt(rawMin, 10));
+            if (rawMax) result.maxLength = Math.abs(parseInt(rawMax, 10));
+          } else if (baseType === "array") {
+            if (rawMin) result.minItems = Math.max(0, parseInt(rawMin, 10));
+            if (rawMax) result.maxItems = Math.abs(parseInt(rawMax, 10));
+          } else {
+            if (rawMin) result.minimum = parseFloat(rawMin);
+            if (rawMax) result.maximum = parseFloat(rawMax);
+          }
+          return result;
+        }
+        const singleMatch = /^(\d+(?:\.\d+)?)$/.exec(s);
+        if (singleMatch) {
+          const value = parseFloat(singleMatch[1]);
+          if (baseType === "string") {
+            return { exactLength: Math.floor(value) };
+          } else if (baseType === "array") {
+            return { maxItems: Math.floor(value) };
+          } else {
+            return { maximum: value };
+          }
+        }
+        console.warn(`[schema-dsl] ConstraintParser: unrecognized constraint "${constraintStr}" for type "${baseType}" \u2014 ignored`);
+        return {};
+      }
+    };
+  }
+});
+
+// src/parser/SchemaCompiler.ts
+var SchemaCompiler;
+var init_SchemaCompiler = __esm({
+  "src/parser/SchemaCompiler.ts"() {
+    "use strict";
+    SchemaCompiler = {
+      /**
+       * Compile and return a JSONSchema (including internal keys; stripped by toJsonSchema).
+       */
+      compile(typeDef, constraints, meta) {
+        const schema = {
+          ...typeDef.baseSchema,
+          ...constraints
+        };
+        if (typeDef.customMessages) {
+          schema["_customMessages"] = {
+            ...schema["_customMessages"],
+            ...typeDef.customMessages
+          };
+        }
+        if (meta?.label) schema["_label"] = meta.label;
+        if (meta?.required) schema["_required"] = true;
+        if (meta?.afterCompileHook) {
+          meta.afterCompileHook(schema);
+        }
+        return schema;
+      },
+      /**
+       * Strip internal keys and return a clean JSON Schema (used by toJsonSchema() output).
+       */
+      toJsonSchema(schema, internalKeys) {
+        const result = {};
+        for (const [k, v] of Object.entries(schema)) {
+          if (!internalKeys.has(k)) {
+            result[k] = v;
+          }
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/config/patterns.ts
+var phone, idCard, creditCard, licensePlate, postalCode, passport, common, PATTERNS;
+var init_patterns = __esm({
+  "src/config/patterns.ts"() {
+    "use strict";
+    phone = {
+      cn: { pattern: /^1[3-9]\d{9}$/, min: 11, max: 11, key: "pattern.phone.cn" },
+      us: { pattern: /^\d{10}$/, min: 10, max: 10, key: "pattern.phone.us" },
+      uk: { pattern: /^(\+44\s?)?0?\d{10}$/, min: 10, max: 15, key: "pattern.phone.uk" },
+      hk: { pattern: /^[5-9]\d{7}$/, min: 8, max: 8, key: "pattern.phone.hk" },
+      tw: { pattern: /^09\d{8}$/, min: 10, max: 10, key: "pattern.phone.tw" },
+      international: { pattern: /^\+[1-9]\d{1,14}$/, min: 8, max: 15, key: "pattern.phone.international" }
+    };
+    idCard = {
+      cn: {
+        pattern: /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/,
+        min: 18,
+        max: 18,
+        key: "pattern.idCard.cn"
+      }
+    };
+    creditCard = {
+      visa: { pattern: /^4[0-9]{12}(?:[0-9]{3})?$/, key: "pattern.creditCard.visa" },
+      mastercard: { pattern: /^5[1-5][0-9]{14}$/, key: "pattern.creditCard.mastercard" },
+      amex: { pattern: /^3[47][0-9]{13}$/, key: "pattern.creditCard.amex" },
+      discover: { pattern: /^6(?:011|5[0-9]{2})[0-9]{12}$/, key: "pattern.creditCard.discover" },
+      jcb: { pattern: /^(?:2131|1800|35\d{3})\d{11}$/, key: "pattern.creditCard.jcb" },
+      unionpay: { pattern: /^62[0-9]{14,17}$/, key: "pattern.creditCard.unionpay" }
+    };
+    licensePlate = {
+      cn: {
+        pattern: /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z][A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]$/,
+        key: "pattern.licensePlate.cn"
+      }
+    };
+    postalCode = {
+      cn: { pattern: /^[1-9]\d{5}$/, key: "pattern.postalCode.cn" },
+      us: { pattern: /^\d{5}(-\d{4})?$/, key: "pattern.postalCode.us" }
+    };
+    passport = {
+      cn: {
+        pattern: /(^[EeKkGgDdHhMQqSs][0-9]{8}$)|(^(([Ee][a-fA-F])|([DdSPp][Ee])|([Kk][Jj])|([Mm][Aa])|(1[45]))[0-9]{7}$)/,
+        key: "pattern.passport.cn"
+      }
+    };
+    common = {
+      domain: {
+        pattern: /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/i,
+        key: "pattern.domain",
+        min: 3,
+        max: 253
+      },
+      ip: {
+        // Composite IPv4 + IPv6 pattern (same as v1)
+        pattern: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$|^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/,
+        key: "pattern.ip"
+      },
+      base64: {
+        pattern: /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/,
+        key: "pattern.base64"
+      },
+      jwt: {
+        pattern: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/,
+        key: "pattern.jwt"
+      }
+    };
+    PATTERNS = { phone, idCard, creditCard, licensePlate, postalCode, passport, common };
+  }
+});
+
+// src/parser/DslParser.ts
+function _isRawJsonSchema(obj) {
+  if (typeof obj["type"] === "string" && JSON_SCHEMA_TYPES.has(obj["type"])) return true;
+  if ("anyOf" in obj || "oneOf" in obj || "allOf" in obj || "$ref" in obj) return true;
+  return false;
+}
+function _cleanRequiredMarks(schema) {
+  if (!schema || typeof schema !== "object") return;
+  delete schema["_required"];
+  const obj = schema;
+  if (obj.properties) {
+    for (const prop of Object.values(obj.properties)) _cleanRequiredMarks(prop);
+  }
+  if (obj.items) _cleanRequiredMarks(obj.items);
+}
+function _copyHiddenSchemaProperties(source, target) {
+  for (const symbol of Object.getOwnPropertySymbols(source)) {
+    const descriptor = Object.getOwnPropertyDescriptor(source, symbol);
+    if (descriptor) Object.defineProperty(target, symbol, descriptor);
+  }
+}
+function _resolveDsl(value) {
+  if (value === null || value === void 0) return {};
+  if (typeof value === "string") return DslParser.parseString(value);
+  if (typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    if (typeof obj["toSchema"] === "function") return obj["toSchema"]();
+    if (_isRawJsonSchema(obj)) return value;
+    return DslParser.parseObject(value);
+  }
+  return value;
+}
+function _schemaForTarget(targetField, dslValue) {
+  const s = _resolveDsl(dslValue);
+  const isRequired = s._required;
+  _cleanRequiredMarks(s);
+  const result = { properties: { [targetField]: s } };
+  if (isRequired) result.required = [targetField];
+  return result;
+}
+function _buildMatchSchema(conditionField, targetField, map) {
+  const entries = Object.entries(map).filter(([k]) => k !== "_default");
+  const defaultDsl = map["_default"];
+  const build = (index) => {
+    if (index >= entries.length) {
+      if (defaultDsl === null || defaultDsl === void 0) return {};
+      const defaultObj = defaultDsl;
+      if (defaultObj && defaultObj["_isMatch"]) {
+        return _buildMatchSchema(String(defaultObj["field"]), targetField, defaultObj["map"]);
+      }
+      if (defaultObj && defaultObj["_isIf"]) {
+        return _buildIfSchema(String(defaultObj["condition"]), targetField, defaultObj["then"], defaultObj["else"]);
+      }
+      return _schemaForTarget(targetField, defaultDsl);
+    }
+    const [val, dslValue] = entries[index];
+    if (dslValue === null || dslValue === void 0) return build(index + 1);
+    const branchObj = dslValue;
+    let thenSchema;
+    if (branchObj && branchObj["_isMatch"]) {
+      thenSchema = _buildMatchSchema(String(branchObj["field"]), targetField, branchObj["map"]);
+    } else if (branchObj && branchObj["_isIf"]) {
+      thenSchema = _buildIfSchema(String(branchObj["condition"]), targetField, branchObj["then"], branchObj["else"]);
+    } else {
+      thenSchema = _schemaForTarget(targetField, dslValue);
+    }
+    return {
+      if: { properties: { [conditionField]: { const: val } } },
+      then: thenSchema,
+      else: build(index + 1)
+    };
+  };
+  return build(0);
+}
+function _buildIfSchema(conditionField, targetField, thenDsl, elseDsl) {
+  const thenObj = thenDsl;
+  const elseObj = elseDsl;
+  let thenResult;
+  if (thenObj && thenObj["_isMatch"]) {
+    thenResult = _buildMatchSchema(String(thenObj["field"]), targetField, thenObj["map"]);
+  } else if (thenObj && thenObj["_isIf"]) {
+    thenResult = _buildIfSchema(String(thenObj["condition"]), targetField, thenObj["then"], thenObj["else"]);
+  } else {
+    thenResult = _schemaForTarget(targetField, thenDsl);
+  }
+  let elseResult = {};
+  if (elseDsl !== null && elseDsl !== void 0) {
+    if (elseObj && elseObj["_isMatch"]) {
+      elseResult = _buildMatchSchema(String(elseObj["field"]), targetField, elseObj["map"]);
+    } else if (elseObj && elseObj["_isIf"]) {
+      elseResult = _buildIfSchema(String(elseObj["condition"]), targetField, elseObj["then"], elseObj["else"]);
+    } else {
+      elseResult = _schemaForTarget(targetField, elseDsl);
+    }
+  }
+  return {
+    if: { properties: { [conditionField]: { const: true } } },
+    then: thenResult,
+    else: elseResult
+  };
+}
+var JSON_SCHEMA_TYPES, DslParser;
+var init_DslParser = __esm({
+  "src/parser/DslParser.ts"() {
+    "use strict";
+    init_TypeRegistry();
+    init_ConstraintParser();
+    init_SchemaCompiler();
+    init_patterns();
+    JSON_SCHEMA_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "array", "object", "null"]);
+    DslParser = {
+      /**
+       * Parse a DSL string → JSONSchema
+       *
+       * Supported formats:
+       *   - 'string'          → { type: 'string' }
+       *   - 'string!'         → { type: 'string', _required: true }
+       *   - 'string:6'        → { type: 'string', exactLength: 6 }  (DA-03 fix)
+       *   - 'string:3-32'     → { type: 'string', minLength: 3, maxLength: 32 }
+       *   - 'number:0-100'    → { type: 'number', minimum: 0, maximum: 100 }
+       *   - 'number:-100-0'   → { type: 'number', minimum: -100, maximum: 0 }  (DB-03 fix)
+       *   - 'enum:a,b,c'      → { type: 'string', enum: ['a','b','c'] }
+       *   - 'a|b|c'           → { type: 'string', enum: ['a','b','c'] }
+       *   - 'array!1-10'      → { type: 'array', minItems:1, maxItems:10, _required:true }
+       */
+      parseString(dslStr) {
+        if (!dslStr || typeof dslStr !== "string") {
+          return { type: "string" };
+        }
+        let s = dslStr.trim();
+        let required = false;
+        const arrayBangMatch = /^array!([\d-]+)$/.exec(s);
+        if (arrayBangMatch) {
+          s = `array:${arrayBangMatch[1]}`;
+          required = true;
+        }
+        if (s.endsWith("!")) {
+          required = true;
+          s = s.slice(0, -1);
+        } else if (s.endsWith("?")) {
+          s = s.slice(0, -1);
+        }
+        if (s.includes("|") && !s.includes(":")) {
+          const rawValues = s.split("|").map((v) => v.trim());
+          if (rawValues.every((v) => v === "true" || v === "false")) {
+            return {
+              type: "boolean",
+              enum: rawValues.map((v) => v === "true"),
+              ...required ? { _required: true } : {}
+            };
+          }
+          const numericValues = rawValues.map((v) => Number(v));
+          if (rawValues.every((v, i) => v !== "" && !isNaN(numericValues[i]))) {
+            return {
+              type: "number",
+              enum: numericValues,
+              ...required ? { _required: true } : {}
+            };
+          }
+          return {
+            type: "string",
+            enum: rawValues,
+            ...required ? { _required: true } : {}
+          };
+        }
+        if (s.startsWith("enum:")) {
+          return DslParser._parseEnumSyntax(s, required);
+        }
+        if (s.startsWith("types:")) {
+          return DslParser._parseUnionTypes(s.slice(6), required);
+        }
+        const arrayAngleWithConstraintMatch = /^array:([^<]+)<(.+)>$/.exec(s);
+        if (arrayAngleWithConstraintMatch) {
+          const arrayConstraint = ConstraintParser.parse(arrayAngleWithConstraintMatch[1], "array");
+          const itemSchema = DslParser.parseString(arrayAngleWithConstraintMatch[2]);
+          return {
+            type: "array",
+            ...arrayConstraint,
+            items: itemSchema,
+            ...required ? { _required: true } : {}
+          };
+        }
+        const arrayAngleMatch = /^array<(.+)>$/.exec(s);
+        if (arrayAngleMatch) {
+          const itemSchema = DslParser.parseString(arrayAngleMatch[1]);
+          return {
+            type: "array",
+            items: itemSchema,
+            ...required ? { _required: true } : {}
+          };
+        }
+        const colonIdx = s.indexOf(":");
+        let typeName;
+        let constraintStr;
+        if (colonIdx === -1) {
+          typeName = s;
+          constraintStr = "";
+        } else {
+          typeName = s.slice(0, colonIdx);
+          constraintStr = s.slice(colonIdx + 1);
+        }
+        const PATTERN_TYPES = ["phone", "idCard", "creditCard", "licensePlate", "postalCode", "passport"];
+        if (PATTERN_TYPES.includes(typeName)) {
+          const patternGroup = PATTERNS[typeName];
+          if (patternGroup) {
+            const arg = constraintStr || (typeName === "creditCard" ? "visa" : "cn");
+            const cfg = patternGroup[arg.toLowerCase()];
+            if (cfg) {
+              return {
+                type: "string",
+                pattern: cfg.pattern.source,
+                ...cfg.min !== void 0 ? { minLength: cfg.min } : {},
+                ...cfg.max !== void 0 ? { maxLength: cfg.max } : {},
+                _customMessages: { pattern: cfg.key },
+                ...required ? { _required: true } : {}
+              };
+            }
+            throw new Error(`[schema-dsl] Unsupported country/variant "${arg}" for type "${typeName}"`);
+          }
+        }
+        const typeDef = TypeRegistry.resolve(typeName);
+        const resolvedBaseType = typeDef.baseSchema.type ?? typeName;
+        const constraints = ConstraintParser.parse(constraintStr, resolvedBaseType);
+        const schema = SchemaCompiler.compile(typeDef, constraints, {
+          required
+        });
+        return schema;
+      },
+      /**
+       * Parse an object DSL definition → JSONSchema (type:object + properties + required[])
+       */
+      parseObject(dslObj) {
+        const schema = {
+          type: "object",
+          properties: {},
+          required: []
+        };
+        for (const [rawKey, value] of Object.entries(dslObj)) {
+          let fieldKey = rawKey;
+          let isKeyRequired = false;
+          if (rawKey.endsWith("!")) {
+            fieldKey = rawKey.slice(0, -1);
+            isKeyRequired = true;
+          }
+          let fieldSchema;
+          if (typeof value === "string") {
+            fieldSchema = DslParser.parseString(value);
+          } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            const obj = value;
+            if (obj["_isMatch"]) {
+              if (!schema.allOf) schema.allOf = [];
+              schema.allOf.push(_buildMatchSchema(String(obj["field"]), fieldKey, obj["map"]));
+              fieldSchema = { description: `Depends on ${String(obj["field"])}` };
+            } else if (obj["_isIf"]) {
+              if (!schema.allOf) schema.allOf = [];
+              schema.allOf.push(_buildIfSchema(String(obj["condition"]), fieldKey, obj["then"], obj["else"]));
+              fieldSchema = { description: `Conditional field based on ${String(obj["condition"])}` };
+            } else if (typeof obj["toSchema"] === "function") {
+              fieldSchema = obj["toSchema"]();
+            } else if (_isRawJsonSchema(obj)) {
+              fieldSchema = value;
+            } else {
+              fieldSchema = DslParser.parseObject(value);
+            }
+          } else {
+            fieldSchema = value;
+          }
+          if (isKeyRequired) {
+            ;
+            schema.required.push(fieldKey);
+          } else if (fieldSchema._required) {
+            ;
+            schema.required.push(fieldKey);
+          }
+          const { _required: _r, ...cleanSchema } = fieldSchema;
+          void _r;
+          _copyHiddenSchemaProperties(fieldSchema, cleanSchema);
+          _cleanRequiredMarks(cleanSchema);
+          schema.properties[fieldKey] = cleanSchema;
+        }
+        if (schema.required.length === 0) {
+          delete schema.required;
+        }
+        return schema;
+      },
+      // --------------- Private helpers ---------------
+      /** Parse enum: prefix syntax */
+      _parseEnumSyntax(s, required) {
+        const rest = s.slice("enum:".length);
+        const typedEnumMatch = /^(string|number|integer|boolean):(.+)$/.exec(rest);
+        if (typedEnumMatch) {
+          const enumType = typedEnumMatch[1];
+          const rawStr = typedEnumMatch[2];
+          const rawValues = (rawStr.includes("|") ? rawStr.split("|") : rawStr.split(",")).map((v) => v.trim());
+          const values = DslParser._coerceEnumValues(rawValues, enumType);
+          return {
+            type: enumType,
+            enum: values,
+            ...required ? { _required: true } : {}
+          };
+        }
+        return {
+          type: "string",
+          enum: (rest.includes("|") ? rest.split("|") : rest.split(",")).map((v) => v.trim()),
+          ...required ? { _required: true } : {}
+        };
+      },
+      /** Convert a string array to enum values of the specified type */
+      _coerceEnumValues(values, type) {
+        if (type === "number" || type === "integer") {
+          return values.map((v) => {
+            const n = parseFloat(v);
+            if (isNaN(n)) throw new Error(`[schema-dsl] Invalid number enum value: "${v}"`);
+            return n;
+          });
+        }
+        if (type === "boolean") {
+          return values.map((v) => {
+            if (v !== "true" && v !== "false")
+              throw new Error(`[schema-dsl] Invalid boolean enum value: "${v}"`);
+            return v === "true";
+          });
+        }
+        return values;
+      },
+      /**
+       * Parse types: union type syntax (v1 compatible)
+       *
+       * Splits 'string|number' into a oneOf array, parsing each segment independently.
+       * Uses smart splitting: 'string:3-10|number:0-100' → ['string:3-10', 'number:0-100']
+       * When only a single type is present, emits a plain schema instead of a oneOf wrapper.
+       */
+      _parseUnionTypes(typesStr, required) {
+        const segments = [];
+        let current = "";
+        let depth = 0;
+        for (let i = 0; i < typesStr.length; i++) {
+          const ch = typesStr[i];
+          if (ch === "<") {
+            depth++;
+            current += ch;
+          } else if (ch === ">") {
+            depth--;
+            current += ch;
+          } else if (ch === "|" && depth === 0) {
+            if (current.trim()) segments.push(current.trim());
+            current = "";
+          } else {
+            current += ch;
+          }
+        }
+        if (current.trim()) segments.push(current.trim());
+        if (segments.length === 0) {
+          throw new Error("[schema-dsl] types: requires at least one type");
+        }
+        if (segments.length === 1) {
+          const schema = DslParser.parseString(segments[0]);
+          if (required) schema._required = true;
+          return schema;
+        }
+        const oneOf = segments.map((seg) => DslParser.parseString(seg));
+        return {
+          oneOf,
+          ...required ? { _required: true } : {}
+        };
+      }
+    };
+  }
+});
+
+// src/config/constants.ts
+var CACHE, IPV4_OCTET, PATTERN_IPV4, HEX4, IPV6_FULL, IPV6_COMPRESS, PATTERN_IPV6;
+var init_constants = __esm({
+  "src/config/constants.ts"() {
+    "use strict";
+    CACHE = {
+      ENABLED: true,
+      SCHEMA_CACHE: {
+        MAX_SIZE: 5e3,
+        TTL: 36e5,
+        // 1 hour
+        STRATEGY: "LRU"
+      },
+      STATS_ENABLED: true
+    };
+    IPV4_OCTET = "(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)";
+    PATTERN_IPV4 = new RegExp(`^(?:${IPV4_OCTET}\\.){3}${IPV4_OCTET}$`);
+    HEX4 = "[0-9a-fA-F]{1,4}";
+    IPV6_FULL = `(?:${HEX4}:){7}${HEX4}`;
+    IPV6_COMPRESS = [
+      `(?:${HEX4}:){1,7}:`,
+      // n:...:
+      `(?:${HEX4}:){1,6}:${HEX4}`,
+      // n:...:n
+      `(?:${HEX4}:){1,5}(?::${HEX4}){1,2}`,
+      `(?:${HEX4}:){1,4}(?::${HEX4}){1,3}`,
+      `(?:${HEX4}:){1,3}(?::${HEX4}){1,4}`,
+      `(?:${HEX4}:){1,2}(?::${HEX4}){1,5}`,
+      `${HEX4}:(?::${HEX4}){1,6}`,
+      `:(?::${HEX4}){1,7}`,
+      // ::n...
+      `::`
+      // standalone :: (all-zeros)
+    ].join("|");
+    PATTERN_IPV6 = new RegExp(`^(?:${IPV6_FULL}|${IPV6_COMPRESS})$`);
+  }
+});
+
+// src/core/CacheManager.ts
+import { MemoryCache } from "cache-hub";
+var CacheManager;
+var init_CacheManager = __esm({
+  "src/core/CacheManager.ts"() {
+    "use strict";
+    init_constants();
+    CacheManager = class {
+      _enabled;
+      _maxSize;
+      _ttl;
+      _cache;
+      _statsEnabled = true;
+      _clears = 0;
+      constructor(options = {}) {
+        this._maxSize = options.maxSize ?? CACHE.SCHEMA_CACHE.MAX_SIZE;
+        this._ttl = options.ttl ?? CACHE.SCHEMA_CACHE.TTL;
+        this._enabled = options.enabled !== false;
+        this._cache = new MemoryCache({ maxEntries: this._maxSize });
+        this._statsEnabled = options.statsEnabled !== false;
+      }
+      get options() {
+        return {
+          maxSize: this._maxSize,
+          ttl: this._ttl,
+          enabled: this._enabled,
+          statsEnabled: this._statsEnabled
+        };
+      }
+      set options(opts) {
+        if (opts.maxSize !== void 0 && opts.maxSize !== this._maxSize) {
+          this._maxSize = opts.maxSize;
+          const oldKeys = this._cache.keys();
+          const newCache = new MemoryCache({ maxEntries: this._maxSize });
+          for (const key of oldKeys) {
+            const val = this._cache.get(key);
+            if (val !== void 0) newCache.set(key, val);
+          }
+          this._cache = newCache;
+        }
+        if (opts.ttl !== void 0) this._ttl = opts.ttl;
+        if (opts.enabled !== void 0) this._enabled = opts.enabled;
+        if (opts.statsEnabled !== void 0) this._statsEnabled = opts.statsEnabled;
+      }
+      /**
+       * Retrieve a cached AJV compile function.
+       * @returns cached compile function, or null on miss (BD-04: undefined → null)
+       */
+      get(key) {
+        if (!this._enabled || key == null) return null;
+        try {
+          const result = this._cache.get(String(key));
+          return result !== void 0 ? result : null;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Write a value to the cache.
+       */
+      set(key, value, ttl) {
+        if (!this._enabled || key == null) return;
+        try {
+          this._cache.set(String(key), value, ttl ?? this._ttl);
+        } catch {
+        }
+      }
+      /**
+       * Delete a single cache entry.
+       */
+      delete(key) {
+        return this._cache.del(key);
+      }
+      /**
+       * Check whether a key exists in the cache.
+       */
+      has(key) {
+        if (!this._enabled) return false;
+        return this._cache.has(key);
+      }
+      /**
+       * Clear all cache entries.
+       */
+      clear() {
+        this._cache.clear();
+        this._clears++;
+      }
+      /**
+       * Return the current number of cache entries.
+       */
+      size() {
+        return this._cache.keys().length;
+      }
+      /**
+       * Return cache statistics.
+       */
+      getStats() {
+        if (!this._statsEnabled) {
+          return {
+            hits: 0,
+            misses: 0,
+            sets: 0,
+            deletes: 0,
+            evictions: 0,
+            clears: 0,
+            hitRate: "0.00",
+            size: 0,
+            maxSize: this._maxSize,
+            enabled: this._enabled
+          };
+        }
+        const inner = this._cache.getStats();
+        const total = inner.hits + inner.misses;
+        return {
+          hits: inner.hits,
+          misses: inner.misses,
+          sets: inner.sets,
+          deletes: inner.deletes,
+          evictions: inner.evictions ?? 0,
+          clears: this._clears,
+          hitRate: total > 0 ? (inner.hits / total * 100).toFixed(2) : "0.00",
+          size: inner.entries,
+          maxSize: this._maxSize,
+          enabled: this._enabled
+        };
+      }
+      /**
+       * Reset all hit/miss/eviction counters.
+       */
+      resetStats() {
+        this._cache.resetStats();
+        this._clears = 0;
+      }
+    };
+  }
+});
+
+// src/core/TemplateEngine.ts
+function renderTemplate(template, params) {
+  return template.replace(/\{\{#([^}]+)\}\}|\{([^}]+)\}/g, (match, k1, k2) => {
+    const key = k1 ?? k2;
+    if (key !== void 0 && key in params) {
+      const val = params[key];
+      if (val === null) return "null";
+      if (val === void 0) return match;
+      if (Array.isArray(val)) return val.join(", ");
+      if (val instanceof RegExp) return val.toString();
+      if (val instanceof Date) return val.toISOString();
+      return String(val);
+    }
+    return match;
+  });
+}
+var init_TemplateEngine = __esm({
+  "src/core/TemplateEngine.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/ErrorCodes.ts
+var KEYWORD_MAP;
+var init_ErrorCodes = __esm({
+  "src/core/ErrorCodes.ts"() {
+    "use strict";
+    KEYWORD_MAP = {
+      minLength: "min",
+      maxLength: "max",
+      minimum: "min",
+      maximum: "max",
+      minItems: "min",
+      maxItems: "max",
+      exclusiveMinimum: "min",
+      exclusiveMaximum: "max",
+      pattern: "pattern",
+      format: "format",
+      required: "required",
+      enum: "enum",
+      type: "type",
+      uniqueItems: "uniqueItems",
+      additionalProperties: "additionalProperties"
+    };
+  }
+});
+
+// src/locales/zh-CN.ts
+var zhCN, zh_CN_default;
+var init_zh_CN = __esm({
+  "src/locales/zh-CN.ts"() {
+    "use strict";
+    zhCN = {
+      // Generic
+      required: "{{#label}}\u4E0D\u80FD\u4E3A\u7A7A",
+      type: "{{#label}}\u5E94\u8BE5\u662F {{#expected}} \u7C7B\u578B",
+      min: "{{#label}}\u957F\u5EA6\u4E0D\u80FD\u5C11\u4E8E{{#limit}}\u4E2A\u5B57\u7B26",
+      max: "{{#label}}\u957F\u5EA6\u4E0D\u80FD\u8D85\u8FC7{{#limit}}\u4E2A\u5B57\u7B26",
+      length: "{{#label}}\u957F\u5EA6\u5FC5\u987B\u662F{{#limit}}\u4E2A\u5B57\u7B26",
+      pattern: "{{#label}}\u683C\u5F0F\u4E0D\u6B63\u786E",
+      enum: "{{#label}}\u5FC5\u987B\u662F\u4EE5\u4E0B\u503C\u4E4B\u4E00: {{#allowed}}",
+      custom: "{{#label}}\u9A8C\u8BC1\u5931\u8D25: {{#message}}",
+      circular: "{{#label}}\u68C0\u6D4B\u5230\u5FAA\u73AF\u5F15\u7528",
+      "max-depth": "\u8D85\u8FC7\u6700\u5927\u9012\u5F52\u6DF1\u5EA6 ({{#depth}}) at {{#label}}",
+      exception: "{{#label}}\u9A8C\u8BC1\u5F02\u5E38: {{#message}}",
+      // Conditional
+      "conditional.underAge": "\u672A\u6210\u5E74\u7528\u6237\u4E0D\u80FD\u6CE8\u518C",
+      "conditional.blocked": "\u8D26\u53F7\u5DF2\u88AB\u5C01\u7981",
+      "conditional.notAllowed": "\u4E0D\u5141\u8BB8\u6CE8\u518C",
+      // I18nError — generic
+      "error.notFound": "\u627E\u4E0D\u5230{{#resource}}",
+      "error.forbidden": "\u6CA1\u6709\u6743\u9650\u8BBF\u95EE{{#resource}}",
+      "error.unauthorized": "\u672A\u6388\u6743\uFF0C\u8BF7\u5148\u767B\u5F55",
+      "error.invalid": "{{#field}}\u65E0\u6548",
+      "error.duplicate": "{{#resource}}\u5DF2\u5B58\u5728",
+      "error.conflict": "\u64CD\u4F5C\u51B2\u7A81: {{#reason}}",
+      // Account
+      "account.notFound": { code: "ACCOUNT_NOT_FOUND", message: "\u8D26\u6237\u4E0D\u5B58\u5728" },
+      "account.inactive": "\u8D26\u6237\u672A\u6FC0\u6D3B",
+      "account.banned": "\u8D26\u6237\u5DF2\u88AB\u5C01\u7981",
+      "account.insufficientBalance": {
+        code: "INSUFFICIENT_BALANCE",
+        message: "\u4F59\u989D\u4E0D\u8DB3\uFF0C\u5F53\u524D\u4F59\u989D{{#balance}}\uFF0C\u9700\u8981{{#required}}"
+      },
+      "account.insufficientCredits": "\u79EF\u5206\u4E0D\u8DB3\uFF0C\u5F53\u524D\u79EF\u5206{{#credits}}\uFF0C\u9700\u8981{{#required}}",
+      // User
+      "user.notFound": "\u7528\u6237\u4E0D\u5B58\u5728",
+      "user.notVerified": "\u7528\u6237\u672A\u9A8C\u8BC1",
+      "user.noPermission": "\u6CA1\u6709\u7BA1\u7406\u5458\u6743\u9650",
+      // Order
+      "order.notPaid": { code: "ORDER_NOT_PAID", message: "\u8BA2\u5355\u672A\u652F\u4ED8" },
+      "order.paymentMissing": "\u7F3A\u5C11\u652F\u4ED8\u4FE1\u606F",
+      "order.addressMissing": "\u7F3A\u5C11\u6536\u8D27\u5730\u5740",
+      // Format
+      "format.email": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684\u90AE\u7BB1\u5730\u5740",
+      "format.url": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684URL\u5730\u5740",
+      "format.uuid": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684UUID",
+      "format.date": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684\u65E5\u671F\u683C\u5F0F (YYYY-MM-DD)",
+      "format.datetime": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684\u65E5\u671F\u65F6\u95F4\u683C\u5F0F (ISO 8601)",
+      "format.time": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684\u65F6\u95F4\u683C\u5F0F (HH:mm:ss)",
+      "format.ipv4": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684IPv4\u5730\u5740",
+      "format.ipv6": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684IPv6\u5730\u5740",
+      "format.binary": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684Base64\u7F16\u7801",
+      // String
+      "string.hostname": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684\u4E3B\u673A\u540D",
+      "string.pattern": "{{#label}}\u683C\u5F0F\u4E0D\u7B26\u5408\u8981\u6C42",
+      "string.enum": "{{#label}}\u5FC5\u987B\u662F\u4EE5\u4E0B\u503C\u4E4B\u4E00: {{#valids}}",
+      "string.length": "{{#label}}\u957F\u5EA6\u5FC5\u987B\u662F{{#limit}}\u4E2A\u5B57\u7B26",
+      "string.alphanum": "{{#label}}\u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u548C\u6570\u5B57",
+      "string.trim": "{{#label}}\u4E0D\u80FD\u5305\u542B\u524D\u540E\u7A7A\u683C",
+      "string.lowercase": "{{#label}}\u5FC5\u987B\u662F\u5C0F\u5199",
+      "string.uppercase": "{{#label}}\u5FC5\u987B\u662F\u5927\u5199",
+      // Number
+      "number.base": "{{#label}}\u5FC5\u987B\u662F\u6570\u5B57\u7C7B\u578B",
+      "number.min": "{{#label}}\u4E0D\u80FD\u5C0F\u4E8E{{#limit}}",
+      "number.max": "{{#label}}\u4E0D\u80FD\u5927\u4E8E{{#limit}}",
+      "number.integer": "{{#label}}\u5FC5\u987B\u662F\u6574\u6570",
+      "number.positive": "{{#label}}\u5FC5\u987B\u662F\u6B63\u6570",
+      "number.negative": "{{#label}}\u5FC5\u987B\u662F\u8D1F\u6570",
+      "number.precision": "{{#label}}\u5C0F\u6570\u4F4D\u6570\u4E0D\u80FD\u8D85\u8FC7{{#limit}}\u4F4D",
+      "number.port": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684\u7AEF\u53E3\u53F7(1-65535)",
+      // Boolean
+      "boolean.base": "{{#label}}\u5FC5\u987B\u662F\u5E03\u5C14\u7C7B\u578B",
+      // Object
+      "object.base": "{{#label}}\u5FC5\u987B\u662F\u5BF9\u8C61\u7C7B\u578B",
+      "object.min": "{{#label}}\u81F3\u5C11\u9700\u8981{{#limit}}\u4E2A\u5C5E\u6027",
+      "object.max": "{{#label}}\u6700\u591A\u53EA\u80FD\u6709{{#limit}}\u4E2A\u5C5E\u6027",
+      "object.unknown": "{{#label}}\u5305\u542B\u672A\u77E5\u5C5E\u6027: {{#key}}",
+      "object.missing": "{{#label}}\u7F3A\u5C11\u5FC5\u9700\u5C5E\u6027",
+      "object.schema": "{{#label}}\u5305\u542B\u989D\u5916\u5C5E\u6027",
+      "additionalProperties": "{{#label}}\u4E0D\u5141\u8BB8\u6709\u989D\u5916\u5C5E\u6027: {{#key}}",
+      // Array
+      "array.base": "{{#label}}\u5FC5\u987B\u662F\u6570\u7EC4\u7C7B\u578B",
+      "array.min": "{{#label}}\u81F3\u5C11\u9700\u8981{{#limit}}\u4E2A\u5143\u7D20",
+      "array.max": "{{#label}}\u6700\u591A\u53EA\u80FD\u6709{{#limit}}\u4E2A\u5143\u7D20",
+      "array.length": "{{#label}}\u5FC5\u987B\u6709{{#limit}}\u4E2A\u5143\u7D20",
+      "array.unique": "{{#label}}\u4E0D\u80FD\u5305\u542B\u91CD\u590D\u5143\u7D20",
+      "array.sparse": "{{#label}}\u4E0D\u80FD\u662F\u7A00\u758F\u6570\u7EC4",
+      "array.includesRequired": "{{#label}}\u5FC5\u987B\u5305\u542B\u6307\u5B9A\u5143\u7D20",
+      // Date
+      "date.base": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684\u65E5\u671F",
+      "date.min": "{{#label}}\u4E0D\u80FD\u65E9\u4E8E{{#limit}}",
+      "date.max": "{{#label}}\u4E0D\u80FD\u665A\u4E8E{{#limit}}",
+      "date.format": "{{#label}}\u65E5\u671F\u683C\u5F0F\u4E0D\u6B63\u786E",
+      "date.greater": "{{#label}}\u5FC5\u987B\u665A\u4E8E{{#limit}}",
+      "date.less": "{{#label}}\u5FC5\u987B\u65E9\u4E8E{{#limit}}",
+      // Any
+      "any.required": "{{#label}}\u662F\u5FC5\u586B\u9879",
+      "any.invalid": "{{#label}}\u5305\u542B\u65E0\u6548\u503C",
+      "any.only": "{{#label}}\u5FC5\u987B\u5339\u914D{{#valids}}",
+      "any.unknown": "\u4E0D\u5141\u8BB8\u5B57\u6BB5{{#key}}",
+      // Patterns
+      "pattern.phone": "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u624B\u673A\u53F7",
+      "pattern.phone.international": "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u56FD\u9645\u624B\u673A\u53F7",
+      "pattern.idCard": "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u8EAB\u4EFD\u8BC1\u53F7\u7801",
+      "pattern.creditCard": "\u65E0\u6548\u7684\u4FE1\u7528\u5361\u53F7",
+      "pattern.creditCard.visa": "\u65E0\u6548\u7684Visa\u5361\u53F7",
+      "pattern.creditCard.mastercard": "\u65E0\u6548\u7684\u4E07\u4E8B\u8FBE\u5361\u53F7",
+      "pattern.creditCard.amex": "\u65E0\u6548\u7684\u7F8E\u56FD\u8FD0\u901A\u5361\u53F7",
+      "pattern.creditCard.discover": "\u65E0\u6548\u7684Discover\u5361\u53F7",
+      "pattern.creditCard.jcb": "\u65E0\u6548\u7684JCB\u5361\u53F7",
+      "pattern.creditCard.unionpay": "\u65E0\u6548\u7684\u94F6\u8054\u5361\u53F7",
+      "pattern.licensePlate": "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u8F66\u724C\u53F7",
+      "pattern.postalCode": "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u90AE\u653F\u7F16\u7801",
+      "pattern.passport": "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u62A4\u7167\u53F7\u7801",
+      "pattern.objectId": "\u65E0\u6548\u7684 ObjectId",
+      "pattern.hexColor": "\u65E0\u6548\u7684\u5341\u516D\u8FDB\u5236\u989C\u8272\u503C",
+      "pattern.macAddress": "\u65E0\u6548\u7684 MAC \u5730\u5740",
+      "pattern.cron": "\u65E0\u6548\u7684 Cron \u8868\u8FBE\u5F0F",
+      "pattern.slug": "URL\u522B\u540D\u53EA\u80FD\u5305\u542B\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u8FDE\u5B57\u7B26",
+      "pattern.domain": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684\u57DF\u540D",
+      "pattern.ip": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684IP\u5730\u5740",
+      "pattern.base64": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684Base64\u7F16\u7801",
+      "pattern.jwt": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684JWT\u4EE4\u724C",
+      "pattern.json": "{{#label}}\u5FC5\u987B\u662F\u6709\u6548\u7684JSON\u5B57\u7B26\u4E32",
+      "pattern.username": "\u7528\u6237\u540D\u5FC5\u987B\u4EE5\u5B57\u6BCD\u5F00\u5934\uFF0C\u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u4E0B\u5212\u7EBF",
+      "pattern.password.weak": "\u5BC6\u7801\u81F3\u5C116\u4F4D",
+      "pattern.password.medium": "\u5BC6\u7801\u81F3\u5C118\u4F4D\uFF0C\u9700\u5305\u542B\u5B57\u6BCD\u548C\u6570\u5B57",
+      "pattern.password.strong": "\u5BC6\u7801\u81F3\u5C118\u4F4D\uFF0C\u9700\u5305\u542B\u5927\u5C0F\u5199\u5B57\u6BCD\u548C\u6570\u5B57",
+      "pattern.password.veryStrong": "\u5BC6\u7801\u81F3\u5C1110\u4F4D\uFF0C\u9700\u5305\u542B\u5927\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u7279\u6B8A\u5B57\u7B26",
+      "pattern.emailOrPhone": "\u5FC5\u987B\u662F\u90AE\u7BB1\u6216\u624B\u673A\u53F7",
+      "pattern.usernameOrEmail": "\u5FC5\u987B\u662F\u7528\u6237\u540D\u6216\u90AE\u7BB1",
+      "pattern.httpOrHttps": "\u5FC5\u987B\u662F http \u6216 https \u5F00\u5934\u7684 URL",
+      // oneOf
+      oneOf: "{{#label}}\u5FC5\u987B\u5339\u914D\u4EE5\u4E0B\u7C7B\u578B\u4E4B\u4E00",
+      "oneOf.invalid": "{{#label}}\u7684\u503C\u4E0D\u5339\u914D\u4EFB\u4F55\u5141\u8BB8\u7684\u7C7B\u578B",
+      // Error fallback
+      UNKNOWN_ERROR: "\u672A\u77E5\u7684\u9A8C\u8BC1\u9519\u8BEF",
+      CUSTOM_VALIDATION_FAILED: "\u81EA\u5B9A\u4E49\u9A8C\u8BC1\u5931\u8D25",
+      ASYNC_VALIDATION_NOT_SUPPORTED: "\u540C\u6B65\u9A8C\u8BC1\u4E0D\u652F\u6301\u5F02\u6B65\u64CD\u4F5C",
+      VALIDATE_MUST_BE_FUNCTION: "validate \u5FC5\u987B\u662F\u4E00\u4E2A\u51FD\u6570"
+    };
+    zh_CN_default = zhCN;
+  }
+});
+
+// src/locales/en-US.ts
+var enUS, en_US_default;
+var init_en_US = __esm({
+  "src/locales/en-US.ts"() {
+    "use strict";
+    enUS = {
+      // Generic
+      required: "{{#label}} is required",
+      type: "{{#label}} should be {{#expected}}, got {{#actual}}",
+      min: "{{#label}} length must be at least {{#limit}}",
+      max: "{{#label}} length must be at most {{#limit}}",
+      length: "{{#label}} length must be exactly {{#expected}}",
+      pattern: "{{#label}} format is invalid",
+      enum: "{{#label}} must be one of: {{#allowed}}",
+      custom: "{{#label}} validation failed: {{#message}}",
+      circular: "Circular reference detected at {{#label}}",
+      "max-depth": "Maximum recursion depth ({{#depth}}) exceeded at {{#label}}",
+      exception: "{{#label}} validation exception: {{#message}}",
+      // Conditional
+      "conditional.underAge": "Minors cannot register",
+      "conditional.blocked": "Account has been blocked",
+      "conditional.notAllowed": "Registration not allowed",
+      // I18nError — generic
+      "error.notFound": "{{#resource}} not found",
+      "error.forbidden": "Access to {{#resource}} is forbidden",
+      "error.unauthorized": "Unauthorized, please log in",
+      "error.invalid": "Invalid {{#field}}",
+      "error.duplicate": "{{#resource}} already exists",
+      "error.conflict": "Operation conflict: {{#reason}}",
+      // Account
+      "account.notFound": { code: "ACCOUNT_NOT_FOUND", message: "Account not found" },
+      "account.inactive": "Account is inactive",
+      "account.banned": "Account has been banned",
+      "account.insufficientBalance": {
+        code: "INSUFFICIENT_BALANCE",
+        message: "Insufficient balance, current: {{#balance}}, required: {{#required}}"
+      },
+      "account.insufficientCredits": "Insufficient credits, current: {{#credits}}, required: {{#required}}",
+      // User
+      "user.notFound": "User not found",
+      "user.notVerified": "User is not verified",
+      "user.noPermission": "No admin permission",
+      // Order
+      "order.notPaid": { code: "ORDER_NOT_PAID", message: "Order not paid" },
+      "order.paymentMissing": "Payment information missing",
+      "order.addressMissing": "Shipping address missing",
+      // Format
+      "format.email": "{{#label}} must be a valid email address",
+      "format.url": "{{#label}} must be a valid URL",
+      "format.uuid": "{{#label}} must be a valid UUID",
+      "format.date": "{{#label}} must be a valid date (YYYY-MM-DD)",
+      "format.datetime": "{{#label}} must be a valid date-time (ISO 8601)",
+      "format.time": "{{#label}} must be a valid time (HH:mm:ss)",
+      "format.ipv4": "{{#label}} must be a valid IPv4 address",
+      "format.ipv6": "{{#label}} must be a valid IPv6 address",
+      "format.binary": "{{#label}} must be a valid base64 string",
+      // String
+      "string.hostname": "{{#label}} must be a valid hostname",
+      "string.pattern": "{{#label}} format does not match required pattern",
+      "string.enum": "{{#label}} must be one of: {{#valids}}",
+      "string.length": "{{#label}} length must be exactly {{#limit}} characters",
+      "string.alphanum": "{{#label}} must only contain alphanumeric characters",
+      "string.trim": "{{#label}} must not have leading or trailing whitespace",
+      "string.lowercase": "{{#label}} must be lowercase",
+      "string.uppercase": "{{#label}} must be uppercase",
+      // Number
+      "number.base": "{{#label}} must be a number",
+      "number.min": "{{#label}} must be greater than or equal to {{#limit}}",
+      "number.max": "{{#label}} must be less than or equal to {{#limit}}",
+      "number.integer": "{{#label}} must be an integer",
+      "number.positive": "{{#label}} must be a positive number",
+      "number.negative": "{{#label}} must be a negative number",
+      "number.precision": "{{#label}} must have at most {{#limit}} decimal places",
+      "number.port": "{{#label}} must be a valid port number (1-65535)",
+      // Boolean
+      "boolean.base": "{{#label}} must be a boolean",
+      // Object
+      "object.base": "{{#label}} must be an object",
+      "object.min": "{{#label}} must have at least {{#limit}} properties",
+      "object.max": "{{#label}} must have at most {{#limit}} properties",
+      "object.unknown": "{{#label}} contains unknown property: {{#key}}",
+      "object.missing": "{{#label}} is missing required properties",
+      "object.schema": "{{#label}} contains additional properties",
+      "additionalProperties": "{{#label}} must NOT have additional properties: {{#key}}",
+      // Array
+      "array.base": "{{#label}} must be an array",
+      "array.min": "{{#label}} must have at least {{#limit}} items",
+      "array.max": "{{#label}} must have at most {{#limit}} items",
+      "array.length": "{{#label}} must have exactly {{#limit}} items",
+      "array.unique": "{{#label}} must not contain duplicate items",
+      "array.sparse": "{{#label}} must not be a sparse array",
+      "array.includesRequired": "{{#label}} must include required items",
+      // Date
+      "date.base": "{{#label}} must be a valid date",
+      "date.min": "{{#label}} must be no earlier than {{#limit}}",
+      "date.max": "{{#label}} must be no later than {{#limit}}",
+      "date.format": "{{#label}} date format is invalid",
+      "date.greater": "{{#label}} must be after {{#limit}}",
+      "date.less": "{{#label}} must be before {{#limit}}",
+      // Any
+      "any.required": "{{#label}} is required",
+      "any.invalid": "{{#label}} contains an invalid value",
+      "any.only": "{{#label}} must match {{#valids}}",
+      "any.unknown": "Field {{#key}} is not allowed",
+      // Patterns
+      "pattern.phone": "Invalid phone number",
+      "pattern.phone.international": "Invalid international phone number",
+      "pattern.idCard": "Invalid ID card number",
+      "pattern.creditCard": "Invalid credit card number",
+      "pattern.creditCard.visa": "Invalid Visa card number",
+      "pattern.creditCard.mastercard": "Invalid Mastercard number",
+      "pattern.creditCard.amex": "Invalid American Express card number",
+      "pattern.creditCard.discover": "Invalid Discover card number",
+      "pattern.creditCard.jcb": "Invalid JCB card number",
+      "pattern.creditCard.unionpay": "Invalid UnionPay card number",
+      "pattern.licensePlate": "Invalid license plate number",
+      "pattern.postalCode": "Invalid postal code",
+      "pattern.passport": "Invalid passport number",
+      "pattern.objectId": "Invalid ObjectId",
+      "pattern.hexColor": "Invalid Hex Color",
+      "pattern.macAddress": "Invalid MAC Address",
+      "pattern.cron": "Invalid Cron Expression",
+      "pattern.slug": "URL slug can only contain lowercase letters, numbers, and hyphens",
+      "pattern.domain": "{{#label}} must be a valid domain name",
+      "pattern.ip": "{{#label}} must be a valid IP address",
+      "pattern.base64": "{{#label}} must be a valid Base64 string",
+      "pattern.jwt": "{{#label}} must be a valid JWT token",
+      "pattern.json": "{{#label}} must be a valid JSON string",
+      "pattern.username": "Username must start with a letter and contain only letters, numbers, and underscores",
+      "pattern.password.weak": "Password must be at least 6 characters",
+      "pattern.password.medium": "Password must be at least 8 characters and contain letters and numbers",
+      "pattern.password.strong": "Password must be at least 8 characters and contain uppercase, lowercase letters and numbers",
+      "pattern.password.veryStrong": "Password must be at least 10 characters and contain uppercase, lowercase letters, numbers and special characters",
+      "pattern.emailOrPhone": "Must be an email or phone number",
+      "pattern.usernameOrEmail": "Must be a username or email",
+      "pattern.httpOrHttps": "Must be a URL starting with http or https",
+      // oneOf
+      oneOf: "{{#label}} must match one of the following types",
+      "oneOf.invalid": "{{#label}} value does not match any allowed type",
+      // Error fallback
+      UNKNOWN_ERROR: "Unknown validation error",
+      CUSTOM_VALIDATION_FAILED: "Validation failed",
+      ASYNC_VALIDATION_NOT_SUPPORTED: "Async validation not supported in synchronous validate()",
+      VALIDATE_MUST_BE_FUNCTION: "validate must be a function"
+    };
+    en_US_default = enUS;
+  }
+});
+
+// src/locales/ja-JP.ts
+var jaJP, ja_JP_default;
+var init_ja_JP = __esm({
+  "src/locales/ja-JP.ts"() {
+    "use strict";
+    jaJP = {
+      // Generic
+      required: "{{#label}}\u306F\u5FC5\u9808\u3067\u3059",
+      type: "{{#label}}\u306F{{#expected}}\u578B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u304C\u3001{{#actual}}\u304C\u6E21\u3055\u308C\u307E\u3057\u305F",
+      min: "{{#label}}\u306E\u9577\u3055\u306F{{#limit}}\u4EE5\u4E0A\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      max: "{{#label}}\u306E\u9577\u3055\u306F{{#limit}}\u4EE5\u4E0B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      length: "{{#label}}\u306E\u9577\u3055\u306F\u6B63\u78BA\u306B{{#expected}}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      pattern: "{{#label}}\u306E\u5F62\u5F0F\u304C\u7121\u52B9\u3067\u3059",
+      enum: "{{#label}}\u306F\u6B21\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059: {{#allowed}}",
+      custom: "{{#label}}\u306E\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {{#message}}",
+      circular: "{{#label}}\u3067\u5FAA\u74B0\u53C2\u7167\u304C\u691C\u51FA\u3055\u308C\u307E\u3057\u305F",
+      "max-depth": "{{#label}}\u3067\u6700\u5927\u518D\u5E30\u6DF1\u5EA6 ({{#depth}}) \u3092\u8D85\u3048\u307E\u3057\u305F",
+      exception: "{{#label}}\u306E\u691C\u8A3C\u4F8B\u5916: {{#message}}",
+      // Conditional
+      "conditional.underAge": "\u672A\u6210\u5E74\u8005\u306F\u767B\u9332\u3067\u304D\u307E\u305B\u3093",
+      "conditional.blocked": "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u30D6\u30ED\u30C3\u30AF\u3055\u308C\u3066\u3044\u307E\u3059",
+      "conditional.notAllowed": "\u767B\u9332\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+      // I18nError — generic (v2 additions)
+      "error.notFound": "{{#resource}}\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+      "error.forbidden": "{{#resource}}\u3078\u306E\u30A2\u30AF\u30BB\u30B9\u304C\u7981\u6B62\u3055\u308C\u3066\u3044\u307E\u3059",
+      "error.unauthorized": "\u8A8D\u8A3C\u304C\u5FC5\u8981\u3067\u3059\u3002\u30ED\u30B0\u30A4\u30F3\u3057\u3066\u304F\u3060\u3055\u3044",
+      "error.invalid": "{{#field}}\u304C\u7121\u52B9\u3067\u3059",
+      "error.duplicate": "{{#resource}}\u306F\u3059\u3067\u306B\u5B58\u5728\u3057\u307E\u3059",
+      "error.conflict": "\u64CD\u4F5C\u306E\u7AF6\u5408: {{#reason}}",
+      // Account (v2 additions)
+      "account.notFound": { code: "ACCOUNT_NOT_FOUND", message: "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093" },
+      "account.inactive": "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u7121\u52B9\u5316\u3055\u308C\u3066\u3044\u307E\u3059",
+      "account.banned": "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u7981\u6B62\u3055\u308C\u3066\u3044\u307E\u3059",
+      "account.insufficientBalance": {
+        code: "INSUFFICIENT_BALANCE",
+        message: "\u6B8B\u9AD8\u4E0D\u8DB3\u3002\u73FE\u5728: {{#balance}}\u3001\u5FC5\u8981: {{#required}}"
+      },
+      "account.insufficientCredits": "\u30AF\u30EC\u30B8\u30C3\u30C8\u4E0D\u8DB3\u3002\u73FE\u5728: {{#credits}}\u3001\u5FC5\u8981: {{#required}}",
+      // User (v2 additions)
+      "user.notFound": "\u30E6\u30FC\u30B6\u30FC\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+      "user.notVerified": "\u30E6\u30FC\u30B6\u30FC\u304C\u78BA\u8A8D\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+      "user.noPermission": "\u7BA1\u7406\u8005\u6A29\u9650\u304C\u3042\u308A\u307E\u305B\u3093",
+      // Order (v2 additions)
+      "order.notPaid": { code: "ORDER_NOT_PAID", message: "\u6CE8\u6587\u304C\u652F\u6255\u308F\u308C\u3066\u3044\u307E\u305B\u3093" },
+      "order.paymentMissing": "\u652F\u6255\u3044\u60C5\u5831\u304C\u3042\u308A\u307E\u305B\u3093",
+      "order.addressMissing": "\u914D\u9001\u5148\u4F4F\u6240\u304C\u3042\u308A\u307E\u305B\u3093",
+      // Format
+      "format.email": "{{#label}}\u306F\u6709\u52B9\u306A\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "format.url": "{{#label}}\u306F\u6709\u52B9\u306AURL\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "format.uuid": "{{#label}}\u306F\u6709\u52B9\u306AUUID\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "format.date": "{{#label}}\u306F\u6709\u52B9\u306A\u65E5\u4ED8 (YYYY-MM-DD) \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "format.datetime": "{{#label}}\u306F\u6709\u52B9\u306A\u65E5\u6642 (ISO 8601) \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "format.time": "{{#label}}\u306F\u6709\u52B9\u306A\u6642\u523B (HH:mm:ss) \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "format.ipv4": "{{#label}}\u306F\u6709\u52B9\u306AIPv4\u30A2\u30C9\u30EC\u30B9\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "format.ipv6": "{{#label}}\u306F\u6709\u52B9\u306AIPv6\u30A2\u30C9\u30EC\u30B9\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "format.binary": "{{#label}}\u306F\u6709\u52B9\u306Abase64\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      // String
+      "string.hostname": "{{#label}}\u306F\u6709\u52B9\u306A\u30DB\u30B9\u30C8\u540D\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "string.pattern": "{{#label}}\u306E\u5F62\u5F0F\u304C\u5FC5\u8981\u306A\u30D1\u30BF\u30FC\u30F3\u3068\u4E00\u81F4\u3057\u307E\u305B\u3093",
+      "string.enum": "{{#label}}\u306F\u6B21\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059: {{#valids}}",
+      "string.length": "{{#label}}\u306E\u9577\u3055\u306F\u6B63\u78BA\u306B{{#limit}}\u6587\u5B57\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "string.alphanum": "{{#label}}\u306B\u306F\u82F1\u6570\u5B57\u306E\u307F\u3092\u542B\u3081\u308B\u3053\u3068\u304C\u3067\u304D\u307E\u3059",
+      "string.trim": "{{#label}}\u306E\u524D\u5F8C\u306B\u7A7A\u767D\u3092\u542B\u3081\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093",
+      "string.lowercase": "{{#label}}\u306F\u5C0F\u6587\u5B57\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "string.uppercase": "{{#label}}\u306F\u5927\u6587\u5B57\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      // Number
+      "number.base": "{{#label}}\u306F\u6570\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "number.min": "{{#label}}\u306F{{#limit}}\u4EE5\u4E0A\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "number.max": "{{#label}}\u306F{{#limit}}\u4EE5\u4E0B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "number.integer": "{{#label}}\u306F\u6574\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "number.positive": "{{#label}}\u306F\u6B63\u306E\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "number.negative": "{{#label}}\u306F\u8CA0\u306E\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "number.precision": "{{#label}}\u306E\u5C0F\u6570\u70B9\u4EE5\u4E0B\u306F{{#limit}}\u6841\u4EE5\u5185\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "number.port": "{{#label}}\u306F\u6709\u52B9\u306A\u30DD\u30FC\u30C8\u756A\u53F7 (1-65535) \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      // Boolean
+      "boolean.base": "{{#label}}\u306F\u30D6\u30FC\u30EB\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      // Object
+      "object.base": "{{#label}}\u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "object.min": "{{#label}}\u306F\u5C11\u306A\u304F\u3068\u3082{{#limit}}\u500B\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u3092\u6301\u3064\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "object.max": "{{#label}}\u306F\u6700\u5927{{#limit}}\u500B\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u3092\u6301\u3064\u3053\u3068\u304C\u3067\u304D\u307E\u3059",
+      "object.unknown": "{{#label}}\u306B\u672A\u77E5\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u3059: {{#key}}",
+      "object.missing": "{{#label}}\u306B\u306F\u5FC5\u9808\u30D7\u30ED\u30D1\u30C6\u30A3\u304C\u3042\u308A\u307E\u305B\u3093",
+      "object.schema": "{{#label}}\u306B\u8FFD\u52A0\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u3059",
+      "additionalProperties": "{{#label}}\u306B\u8FFD\u52A0\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u3092\u542B\u3081\u3066\u306F\u3044\u3051\u307E\u305B\u3093: {{#key}}",
+      // Array
+      "array.base": "{{#label}}\u306F\u914D\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "array.min": "{{#label}}\u306F\u5C11\u306A\u304F\u3068\u3082{{#limit}}\u500B\u306E\u8981\u7D20\u3092\u6301\u3064\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "array.max": "{{#label}}\u306F\u6700\u5927{{#limit}}\u500B\u306E\u8981\u7D20\u3092\u6301\u3064\u3053\u3068\u304C\u3067\u304D\u307E\u3059",
+      "array.length": "{{#label}}\u306F\u6B63\u78BA\u306B{{#limit}}\u500B\u306E\u8981\u7D20\u3092\u6301\u3064\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "array.unique": "{{#label}}\u306B\u91CD\u8907\u3059\u308B\u8981\u7D20\u3092\u542B\u3081\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093",
+      "array.sparse": "{{#label}}\u306F\u30B9\u30D1\u30FC\u30B9\u914D\u5217\u3067\u3042\u3063\u3066\u306F\u306A\u308A\u307E\u305B\u3093",
+      "array.includesRequired": "{{#label}}\u306B\u306F\u5FC5\u9808\u30A2\u30A4\u30C6\u30E0\u3092\u542B\u3081\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      // Date
+      "date.base": "{{#label}}\u306F\u6709\u52B9\u306A\u65E5\u4ED8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "date.min": "{{#label}}\u306F{{#limit}}\u3088\u308A\u524D\u3067\u3042\u3063\u3066\u306F\u306A\u308A\u307E\u305B\u3093",
+      "date.max": "{{#label}}\u306F{{#limit}}\u3088\u308A\u5F8C\u3067\u3042\u3063\u3066\u306F\u306A\u308A\u307E\u305B\u3093",
+      "date.format": "{{#label}}\u306E\u65E5\u4ED8\u5F62\u5F0F\u304C\u7121\u52B9\u3067\u3059",
+      "date.greater": "{{#label}}\u306F{{#limit}}\u3088\u308A\u5F8C\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "date.less": "{{#label}}\u306F{{#limit}}\u3088\u308A\u524D\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      // Any
+      "any.required": "{{#label}}\u306F\u5FC5\u9808\u3067\u3059",
+      "any.invalid": "{{#label}}\u306B\u7121\u52B9\u306A\u5024\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u3059",
+      "any.only": "{{#label}}\u306F{{#valids}}\u3068\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "any.unknown": "\u30D5\u30A3\u30FC\u30EB\u30C9{{#key}}\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+      // Patterns
+      "pattern.phone": "\u7121\u52B9\u306A\u96FB\u8A71\u756A\u53F7",
+      "pattern.phone.international": "\u7121\u52B9\u306A\u56FD\u969B\u96FB\u8A71\u756A\u53F7",
+      "pattern.idCard": "\u7121\u52B9\u306AID\u30AB\u30FC\u30C9\u756A\u53F7",
+      "pattern.creditCard": "\u7121\u52B9\u306A\u30AF\u30EC\u30B8\u30C3\u30C8\u30AB\u30FC\u30C9\u756A\u53F7",
+      "pattern.creditCard.visa": "\u7121\u52B9\u306AVisa\u30AB\u30FC\u30C9\u756A\u53F7",
+      "pattern.creditCard.mastercard": "\u7121\u52B9\u306AMastercard\u30AB\u30FC\u30C9\u756A\u53F7",
+      "pattern.creditCard.amex": "\u7121\u52B9\u306AAmerican Express\u30AB\u30FC\u30C9\u756A\u53F7",
+      "pattern.creditCard.discover": "\u7121\u52B9\u306ADiscover\u30AB\u30FC\u30C9\u756A\u53F7",
+      "pattern.creditCard.jcb": "\u7121\u52B9\u306AJCB\u30AB\u30FC\u30C9\u756A\u53F7",
+      "pattern.creditCard.unionpay": "\u7121\u52B9\u306AUnionPay\u30AB\u30FC\u30C9\u756A\u53F7",
+      "pattern.licensePlate": "\u7121\u52B9\u306A\u30CA\u30F3\u30D0\u30FC\u30D7\u30EC\u30FC\u30C8",
+      "pattern.postalCode": "\u7121\u52B9\u306A\u90F5\u4FBF\u756A\u53F7",
+      "pattern.passport": "\u7121\u52B9\u306A\u30D1\u30B9\u30DD\u30FC\u30C8\u756A\u53F7",
+      "pattern.objectId": "\u7121\u52B9\u306AObjectId",
+      "pattern.hexColor": "\u7121\u52B9\u306A16\u9032\u30AB\u30E9\u30FC",
+      "pattern.macAddress": "\u7121\u52B9\u306AMAC\u30A2\u30C9\u30EC\u30B9",
+      "pattern.cron": "\u7121\u52B9\u306ACron\u5F0F",
+      "pattern.slug": "URL\u30B9\u30E9\u30C3\u30B0\u306B\u306F\u5C0F\u6587\u5B57\u3001\u6570\u5B57\u3001\u30CF\u30A4\u30D5\u30F3\u306E\u307F\u3092\u542B\u3081\u308B\u3053\u3068\u304C\u3067\u304D\u307E\u3059",
+      "pattern.domain": "{{#label}}\u306F\u6709\u52B9\u306A\u30C9\u30E1\u30A4\u30F3\u540D\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.ip": "{{#label}}\u306F\u6709\u52B9\u306AIP\u30A2\u30C9\u30EC\u30B9\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.base64": "{{#label}}\u306F\u6709\u52B9\u306ABase64\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.jwt": "{{#label}}\u306F\u6709\u52B9\u306AJWT\u30C8\u30FC\u30AF\u30F3\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.json": "{{#label}}\u306F\u6709\u52B9\u306AJSON\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.username": "\u30E6\u30FC\u30B6\u30FC\u540D\u306F\u6587\u5B57\u3067\u59CB\u307E\u308A\u3001\u6587\u5B57\u3001\u6570\u5B57\u3001\u30A2\u30F3\u30C0\u30FC\u30B9\u30B3\u30A2\u306E\u307F\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.password.weak": "\u30D1\u30B9\u30EF\u30FC\u30C9\u306F\u5C11\u306A\u304F\u3068\u30826\u6587\u5B57\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.password.medium": "\u30D1\u30B9\u30EF\u30FC\u30C9\u306F\u5C11\u306A\u304F\u3068\u30828\u6587\u5B57\u3067\u3001\u6587\u5B57\u3068\u6570\u5B57\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.password.strong": "\u30D1\u30B9\u30EF\u30FC\u30C9\u306F\u5C11\u306A\u304F\u3068\u30828\u6587\u5B57\u3067\u3001\u5927\u6587\u5B57\u3001\u5C0F\u6587\u5B57\u3001\u6570\u5B57\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.password.veryStrong": "\u30D1\u30B9\u30EF\u30FC\u30C9\u306F\u5C11\u306A\u304F\u3068\u308210\u6587\u5B57\u3067\u3001\u5927\u6587\u5B57\u3001\u5C0F\u6587\u5B57\u3001\u6570\u5B57\u3001\u7279\u6B8A\u6587\u5B57\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.emailOrPhone": "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u307E\u305F\u306F\u96FB\u8A71\u756A\u53F7\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.usernameOrEmail": "\u30E6\u30FC\u30B6\u30FC\u540D\u307E\u305F\u306F\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "pattern.httpOrHttps": "http \u307E\u305F\u306F https \u3067\u59CB\u307E\u308BURL\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      // oneOf
+      oneOf: "{{#label}}\u306F\u6B21\u306E\u3044\u305A\u308C\u304B\u306E\u578B\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+      "oneOf.invalid": "{{#label}}\u306E\u5024\u306F\u8A31\u53EF\u3055\u308C\u305F\u578B\u306E\u3044\u305A\u308C\u3068\u3082\u4E00\u81F4\u3057\u307E\u305B\u3093",
+      // Error fallback
+      UNKNOWN_ERROR: "\u4E0D\u660E\u306A\u691C\u8A3C\u30A8\u30E9\u30FC",
+      CUSTOM_VALIDATION_FAILED: "\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+      ASYNC_VALIDATION_NOT_SUPPORTED: "\u540C\u671Fvalidate()\u3067\u306F\u975E\u540C\u671F\u691C\u8A3C\u306F\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+      VALIDATE_MUST_BE_FUNCTION: "validate\u306F\u95A2\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059"
+    };
+    ja_JP_default = jaJP;
+  }
+});
+
+// src/locales/es-ES.ts
+var esES, es_ES_default;
+var init_es_ES = __esm({
+  "src/locales/es-ES.ts"() {
+    "use strict";
+    esES = {
+      // Generic
+      required: "{{#label}} es obligatorio",
+      type: "{{#label}} debe ser de tipo {{#expected}}, pero se obtuvo {{#actual}}",
+      min: "La longitud de {{#label}} debe ser al menos {{#limit}}",
+      max: "La longitud de {{#label}} debe ser como m\xE1ximo {{#limit}}",
+      length: "La longitud de {{#label}} debe ser exactamente {{#expected}}",
+      pattern: "El formato de {{#label}} no es v\xE1lido",
+      enum: "{{#label}} debe ser uno de: {{#allowed}}",
+      custom: "Validaci\xF3n fallida para {{#label}}: {{#message}}",
+      circular: "Referencia circular detectada en {{#label}}",
+      "max-depth": "Profundidad m\xE1xima de recursi\xF3n ({{#depth}}) excedida en {{#label}}",
+      exception: "Excepci\xF3n de validaci\xF3n en {{#label}}: {{#message}}",
+      // Conditional (v2 additions)
+      "conditional.underAge": "Los menores de edad no pueden registrarse",
+      "conditional.blocked": "La cuenta ha sido bloqueada",
+      "conditional.notAllowed": "El registro no est\xE1 permitido",
+      // I18nError — generic (v2 additions)
+      "error.notFound": "{{#resource}} no encontrado",
+      "error.forbidden": "Acceso a {{#resource}} est\xE1 prohibido",
+      "error.unauthorized": "No autorizado, por favor inicie sesi\xF3n",
+      "error.invalid": "{{#field}} no es v\xE1lido",
+      "error.duplicate": "{{#resource}} ya existe",
+      "error.conflict": "Conflicto de operaci\xF3n: {{#reason}}",
+      // Account (v2 additions)
+      "account.notFound": { code: "ACCOUNT_NOT_FOUND", message: "Cuenta no encontrada" },
+      "account.inactive": "La cuenta est\xE1 inactiva",
+      "account.banned": "La cuenta ha sido suspendida",
+      "account.insufficientBalance": {
+        code: "INSUFFICIENT_BALANCE",
+        message: "Saldo insuficiente, actual: {{#balance}}, requerido: {{#required}}"
+      },
+      "account.insufficientCredits": "Cr\xE9ditos insuficientes, actual: {{#credits}}, requerido: {{#required}}",
+      // User (v2 additions)
+      "user.notFound": "Usuario no encontrado",
+      "user.notVerified": "El usuario no est\xE1 verificado",
+      "user.noPermission": "Sin permisos de administrador",
+      // Order (v2 additions)
+      "order.notPaid": { code: "ORDER_NOT_PAID", message: "Pedido no pagado" },
+      "order.paymentMissing": "Falta informaci\xF3n de pago",
+      "order.addressMissing": "Falta la direcci\xF3n de env\xEDo",
+      // Format
+      "format.email": "{{#label}} debe ser una direcci\xF3n de correo electr\xF3nico v\xE1lida",
+      "format.url": "{{#label}} debe ser una URL v\xE1lida",
+      "format.uuid": "{{#label}} debe ser un UUID v\xE1lido",
+      "format.date": "{{#label}} debe ser una fecha v\xE1lida (YYYY-MM-DD)",
+      "format.datetime": "{{#label}} debe ser una fecha y hora v\xE1lida (ISO 8601)",
+      "format.time": "{{#label}} debe ser una hora v\xE1lida (HH:mm:ss)",
+      "format.ipv4": "{{#label}} debe ser una direcci\xF3n IPv4 v\xE1lida",
+      "format.ipv6": "{{#label}} debe ser una direcci\xF3n IPv6 v\xE1lida",
+      "format.binary": "{{#label}} debe ser una cadena base64 v\xE1lida",
+      // String
+      "string.hostname": "{{#label}} debe ser un nombre de host v\xE1lido",
+      "string.pattern": "El formato de {{#label}} no coincide con el patr\xF3n requerido",
+      "string.enum": "{{#label}} debe ser uno de: {{#valids}}",
+      "string.length": "La longitud de {{#label}} debe ser exactamente {{#limit}} caracteres",
+      "string.alphanum": "{{#label}} solo puede contener caracteres alfanum\xE9ricos",
+      "string.trim": "{{#label}} no debe tener espacios al principio ni al final",
+      "string.lowercase": "{{#label}} debe estar en min\xFAsculas",
+      "string.uppercase": "{{#label}} debe estar en may\xFAsculas",
+      // Number
+      "number.base": "{{#label}} debe ser un n\xFAmero",
+      "number.min": "{{#label}} debe ser mayor o igual a {{#limit}}",
+      "number.max": "{{#label}} debe ser menor o igual a {{#limit}}",
+      "number.integer": "{{#label}} debe ser un n\xFAmero entero",
+      "number.positive": "{{#label}} debe ser un n\xFAmero positivo",
+      "number.negative": "{{#label}} debe ser un n\xFAmero negativo",
+      "number.precision": "{{#label}} debe tener como m\xE1ximo {{#limit}} decimales",
+      "number.port": "{{#label}} debe ser un n\xFAmero de puerto v\xE1lido (1-65535)",
+      // Boolean
+      "boolean.base": "{{#label}} debe ser un booleano",
+      // Object
+      "object.base": "{{#label}} debe ser un objeto",
+      "object.min": "{{#label}} debe tener al menos {{#limit}} propiedades",
+      "object.max": "{{#label}} debe tener como m\xE1ximo {{#limit}} propiedades",
+      "object.unknown": "{{#label}} contiene una propiedad desconocida: {{#key}}",
+      "object.missing": "A {{#label}} le faltan propiedades requeridas",
+      "object.schema": "{{#label}} contiene propiedades adicionales",
+      "additionalProperties": "{{#label}} NO debe tener propiedades adicionales: {{#key}}",
+      // Array
+      "array.base": "{{#label}} debe ser un array",
+      "array.min": "{{#label}} debe tener al menos {{#limit}} elementos",
+      "array.max": "{{#label}} debe tener como m\xE1ximo {{#limit}} elementos",
+      "array.length": "{{#label}} debe tener exactamente {{#limit}} elementos",
+      "array.unique": "{{#label}} no debe contener elementos duplicados",
+      "array.sparse": "{{#label}} no debe ser un array disperso",
+      "array.includesRequired": "{{#label}} debe incluir los elementos requeridos",
+      // Date
+      "date.base": "{{#label}} debe ser una fecha v\xE1lida",
+      "date.min": "{{#label}} no debe ser anterior a {{#limit}}",
+      "date.max": "{{#label}} no debe ser posterior a {{#limit}}",
+      "date.format": "El formato de fecha de {{#label}} no es v\xE1lido",
+      "date.greater": "{{#label}} debe ser posterior a {{#limit}}",
+      "date.less": "{{#label}} debe ser anterior a {{#limit}}",
+      // Any
+      "any.required": "{{#label}} es obligatorio",
+      "any.invalid": "{{#label}} contiene un valor no v\xE1lido",
+      "any.only": "{{#label}} debe coincidir con {{#valids}}",
+      "any.unknown": "El campo {{#key}} no est\xE1 permitido",
+      // Patterns
+      "pattern.phone": "N\xFAmero de tel\xE9fono no v\xE1lido",
+      "pattern.phone.international": "N\xFAmero de tel\xE9fono internacional no v\xE1lido",
+      "pattern.idCard": "N\xFAmero de tarjeta de identificaci\xF3n no v\xE1lido",
+      "pattern.creditCard": "N\xFAmero de tarjeta de cr\xE9dito no v\xE1lido",
+      "pattern.creditCard.visa": "N\xFAmero de tarjeta Visa no v\xE1lido",
+      "pattern.creditCard.mastercard": "N\xFAmero de Mastercard no v\xE1lido",
+      "pattern.creditCard.amex": "N\xFAmero de tarjeta American Express no v\xE1lido",
+      "pattern.creditCard.discover": "N\xFAmero de tarjeta Discover no v\xE1lido",
+      "pattern.creditCard.jcb": "N\xFAmero de tarjeta JCB no v\xE1lido",
+      "pattern.creditCard.unionpay": "N\xFAmero de tarjeta UnionPay no v\xE1lido",
+      "pattern.licensePlate": "N\xFAmero de matr\xEDcula no v\xE1lido",
+      "pattern.postalCode": "C\xF3digo postal no v\xE1lido",
+      "pattern.passport": "N\xFAmero de pasaporte no v\xE1lido",
+      "pattern.objectId": "ObjectId no v\xE1lido",
+      "pattern.hexColor": "Color hexadecimal no v\xE1lido",
+      "pattern.macAddress": "Direcci\xF3n MAC no v\xE1lida",
+      "pattern.cron": "Expresi\xF3n Cron no v\xE1lida",
+      "pattern.slug": "El slug de URL solo puede contener letras min\xFAsculas, n\xFAmeros y guiones",
+      "pattern.domain": "{{#label}} debe ser un nombre de dominio v\xE1lido",
+      "pattern.ip": "{{#label}} debe ser una direcci\xF3n IP v\xE1lida",
+      "pattern.base64": "{{#label}} debe ser una cadena Base64 v\xE1lida",
+      "pattern.jwt": "{{#label}} debe ser un token JWT v\xE1lido",
+      "pattern.json": "{{#label}} debe ser una cadena JSON v\xE1lida",
+      "pattern.username": "El nombre de usuario debe comenzar con una letra y contener solo letras, n\xFAmeros y guiones bajos",
+      "pattern.password.weak": "La contrase\xF1a debe tener al menos 6 caracteres",
+      "pattern.password.medium": "La contrase\xF1a debe tener al menos 8 caracteres y contener letras y n\xFAmeros",
+      "pattern.password.strong": "La contrase\xF1a debe tener al menos 8 caracteres y contener letras may\xFAsculas, min\xFAsculas y n\xFAmeros",
+      "pattern.password.veryStrong": "La contrase\xF1a debe tener al menos 10 caracteres y contener letras may\xFAsculas, min\xFAsculas, n\xFAmeros y caracteres especiales",
+      "pattern.emailOrPhone": "Debe ser un correo electr\xF3nico o n\xFAmero de tel\xE9fono",
+      "pattern.usernameOrEmail": "Debe ser un nombre de usuario o correo electr\xF3nico",
+      "pattern.httpOrHttps": "Debe ser una URL que comience con http o https",
+      // oneOf
+      oneOf: "{{#label}} debe coincidir con uno de los siguientes tipos",
+      "oneOf.invalid": "El valor de {{#label}} no coincide con ning\xFAn tipo permitido",
+      // Error fallback
+      UNKNOWN_ERROR: "Error de validaci\xF3n desconocido",
+      CUSTOM_VALIDATION_FAILED: "Validaci\xF3n fallida",
+      ASYNC_VALIDATION_NOT_SUPPORTED: "La validaci\xF3n as\xEDncrona no es compatible en validate() s\xEDncrono",
+      VALIDATE_MUST_BE_FUNCTION: "validate debe ser una funci\xF3n"
+    };
+    es_ES_default = esES;
+  }
+});
+
+// src/locales/fr-FR.ts
+var frFR, fr_FR_default;
+var init_fr_FR = __esm({
+  "src/locales/fr-FR.ts"() {
+    "use strict";
+    frFR = {
+      // Generic
+      required: "{{#label}} est requis",
+      type: "{{#label}} doit \xEAtre de type {{#expected}}, mais {{#actual}} a \xE9t\xE9 re\xE7u",
+      min: "La longueur de {{#label}} doit \xEAtre d'au moins {{#limit}}",
+      max: "La longueur de {{#label}} doit \xEAtre d'au plus {{#limit}}",
+      length: "La longueur de {{#label}} doit \xEAtre exactement {{#expected}}",
+      pattern: "Le format de {{#label}} n'est pas valide",
+      enum: "{{#label}} doit \xEAtre l'un de : {{#allowed}}",
+      custom: "Validation \xE9chou\xE9e pour {{#label}} : {{#message}}",
+      circular: "R\xE9f\xE9rence circulaire d\xE9tect\xE9e dans {{#label}}",
+      "max-depth": "Profondeur maximale de r\xE9cursion ({{#depth}}) d\xE9pass\xE9e dans {{#label}}",
+      exception: "Exception de validation dans {{#label}} : {{#message}}",
+      // Conditional (v2 additions)
+      "conditional.underAge": "Les mineurs ne peuvent pas s'inscrire",
+      "conditional.blocked": "Le compte a \xE9t\xE9 bloqu\xE9",
+      "conditional.notAllowed": "L'inscription n'est pas autoris\xE9e",
+      // I18nError — generic (v2 additions)
+      "error.notFound": "{{#resource}} introuvable",
+      "error.forbidden": "Acc\xE8s \xE0 {{#resource}} interdit",
+      "error.unauthorized": "Non autoris\xE9, veuillez vous connecter",
+      "error.invalid": "{{#field}} n'est pas valide",
+      "error.duplicate": "{{#resource}} existe d\xE9j\xE0",
+      "error.conflict": "Conflit d'op\xE9ration : {{#reason}}",
+      // Account (v2 additions)
+      "account.notFound": { code: "ACCOUNT_NOT_FOUND", message: "Compte introuvable" },
+      "account.inactive": "Le compte est inactif",
+      "account.banned": "Le compte a \xE9t\xE9 banni",
+      "account.insufficientBalance": {
+        code: "INSUFFICIENT_BALANCE",
+        message: "Solde insuffisant, actuel : {{#balance}}, requis : {{#required}}"
+      },
+      "account.insufficientCredits": "Cr\xE9dits insuffisants, actuels : {{#credits}}, requis : {{#required}}",
+      // User (v2 additions)
+      "user.notFound": "Utilisateur introuvable",
+      "user.notVerified": "L'utilisateur n'est pas v\xE9rifi\xE9",
+      "user.noPermission": "Pas de permission d'administrateur",
+      // Order (v2 additions)
+      "order.notPaid": { code: "ORDER_NOT_PAID", message: "Commande non pay\xE9e" },
+      "order.paymentMissing": "Informations de paiement manquantes",
+      "order.addressMissing": "Adresse de livraison manquante",
+      // Format
+      "format.email": "{{#label}} doit \xEAtre une adresse e-mail valide",
+      "format.url": "{{#label}} doit \xEAtre une URL valide",
+      "format.uuid": "{{#label}} doit \xEAtre un UUID valide",
+      "format.date": "{{#label}} doit \xEAtre une date valide (YYYY-MM-DD)",
+      "format.datetime": "{{#label}} doit \xEAtre une date et heure valide (ISO 8601)",
+      "format.time": "{{#label}} doit \xEAtre une heure valide (HH:mm:ss)",
+      "format.ipv4": "{{#label}} doit \xEAtre une adresse IPv4 valide",
+      "format.ipv6": "{{#label}} doit \xEAtre une adresse IPv6 valide",
+      "format.binary": "{{#label}} doit \xEAtre une cha\xEEne base64 valide",
+      // String
+      "string.hostname": "{{#label}} doit \xEAtre un nom d'h\xF4te valide",
+      "string.pattern": "Le format de {{#label}} ne correspond pas au mod\xE8le requis",
+      "string.enum": "{{#label}} doit \xEAtre l'un de : {{#valids}}",
+      "string.length": "La longueur de {{#label}} doit \xEAtre exactement {{#limit}} caract\xE8res",
+      "string.alphanum": "{{#label}} ne doit contenir que des caract\xE8res alphanum\xE9riques",
+      "string.trim": "{{#label}} ne doit pas avoir d'espaces en d\xE9but ou en fin",
+      "string.lowercase": "{{#label}} doit \xEAtre en minuscules",
+      "string.uppercase": "{{#label}} doit \xEAtre en majuscules",
+      // Number
+      "number.base": "{{#label}} doit \xEAtre un nombre",
+      "number.min": "{{#label}} doit \xEAtre sup\xE9rieur ou \xE9gal \xE0 {{#limit}}",
+      "number.max": "{{#label}} doit \xEAtre inf\xE9rieur ou \xE9gal \xE0 {{#limit}}",
+      "number.integer": "{{#label}} doit \xEAtre un nombre entier",
+      "number.positive": "{{#label}} doit \xEAtre un nombre positif",
+      "number.negative": "{{#label}} doit \xEAtre un nombre n\xE9gatif",
+      "number.precision": "{{#label}} doit avoir au plus {{#limit}} d\xE9cimales",
+      "number.port": "{{#label}} doit \xEAtre un num\xE9ro de port valide (1-65535)",
+      // Boolean
+      "boolean.base": "{{#label}} doit \xEAtre un bool\xE9en",
+      // Object
+      "object.base": "{{#label}} doit \xEAtre un objet",
+      "object.min": "{{#label}} doit avoir au moins {{#limit}} propri\xE9t\xE9s",
+      "object.max": "{{#label}} doit avoir au plus {{#limit}} propri\xE9t\xE9s",
+      "object.unknown": "{{#label}} contient une propri\xE9t\xE9 inconnue : {{#key}}",
+      "object.missing": "{{#label}} est manquant les propri\xE9t\xE9s requises",
+      "object.schema": "{{#label}} contient des propri\xE9t\xE9s suppl\xE9mentaires",
+      "additionalProperties": "{{#label}} NE doit PAS avoir de propri\xE9t\xE9s suppl\xE9mentaires : {{#key}}",
+      // Array
+      "array.base": "{{#label}} doit \xEAtre un tableau",
+      "array.min": "{{#label}} doit avoir au moins {{#limit}} \xE9l\xE9ments",
+      "array.max": "{{#label}} doit avoir au plus {{#limit}} \xE9l\xE9ments",
+      "array.length": "{{#label}} doit avoir exactement {{#limit}} \xE9l\xE9ments",
+      "array.unique": "{{#label}} ne doit pas contenir d'\xE9l\xE9ments en double",
+      "array.sparse": "{{#label}} ne doit pas \xEAtre un tableau clairsem\xE9",
+      "array.includesRequired": "{{#label}} doit inclure les \xE9l\xE9ments requis",
+      // Date
+      "date.base": "{{#label}} doit \xEAtre une date valide",
+      "date.min": "{{#label}} ne doit pas \xEAtre ant\xE9rieur \xE0 {{#limit}}",
+      "date.max": "{{#label}} ne doit pas \xEAtre post\xE9rieur \xE0 {{#limit}}",
+      "date.format": "Le format de date de {{#label}} n'est pas valide",
+      "date.greater": "{{#label}} doit \xEAtre apr\xE8s {{#limit}}",
+      "date.less": "{{#label}} doit \xEAtre avant {{#limit}}",
+      // Any
+      "any.required": "{{#label}} est requis",
+      "any.invalid": "{{#label}} contient une valeur non valide",
+      "any.only": "{{#label}} doit correspondre \xE0 {{#valids}}",
+      "any.unknown": "Le champ {{#key}} n'est pas autoris\xE9",
+      // Patterns
+      "pattern.phone": "Num\xE9ro de t\xE9l\xE9phone non valide",
+      "pattern.phone.international": "Num\xE9ro de t\xE9l\xE9phone international non valide",
+      "pattern.idCard": "Num\xE9ro de carte d'identit\xE9 non valide",
+      "pattern.creditCard": "Num\xE9ro de carte de cr\xE9dit non valide",
+      "pattern.creditCard.visa": "Num\xE9ro de carte Visa non valide",
+      "pattern.creditCard.mastercard": "Num\xE9ro Mastercard non valide",
+      "pattern.creditCard.amex": "Num\xE9ro de carte American Express non valide",
+      "pattern.creditCard.discover": "Num\xE9ro de carte Discover non valide",
+      "pattern.creditCard.jcb": "Num\xE9ro de carte JCB non valide",
+      "pattern.creditCard.unionpay": "Num\xE9ro de carte UnionPay non valide",
+      "pattern.licensePlate": "Num\xE9ro de plaque d'immatriculation non valide",
+      "pattern.postalCode": "Code postal non valide",
+      "pattern.passport": "Num\xE9ro de passeport non valide",
+      "pattern.objectId": "ObjectId non valide",
+      "pattern.hexColor": "Couleur hexad\xE9cimale non valide",
+      "pattern.macAddress": "Adresse MAC non valide",
+      "pattern.cron": "Expression Cron non valide",
+      "pattern.slug": "Le slug d'URL ne peut contenir que des lettres minuscules, des chiffres et des tirets",
+      "pattern.domain": "{{#label}} doit \xEAtre un nom de domaine valide",
+      "pattern.ip": "{{#label}} doit \xEAtre une adresse IP valide",
+      "pattern.base64": "{{#label}} doit \xEAtre une cha\xEEne Base64 valide",
+      "pattern.jwt": "{{#label}} doit \xEAtre un token JWT valide",
+      "pattern.json": "{{#label}} doit \xEAtre une cha\xEEne JSON valide",
+      "pattern.username": "Le nom d'utilisateur doit commencer par une lettre et contenir uniquement des lettres, des chiffres et des tirets bas",
+      "pattern.password.weak": "Le mot de passe doit contenir au moins 6 caract\xE8res",
+      "pattern.password.medium": "Le mot de passe doit contenir au moins 8 caract\xE8res et inclure des lettres et des chiffres",
+      "pattern.password.strong": "Le mot de passe doit contenir au moins 8 caract\xE8res et inclure des lettres majuscules, minuscules et des chiffres",
+      "pattern.password.veryStrong": "Le mot de passe doit contenir au moins 10 caract\xE8res et inclure des lettres majuscules, minuscules, des chiffres et des caract\xE8res sp\xE9ciaux",
+      "pattern.emailOrPhone": "Doit \xEAtre un e-mail ou un num\xE9ro de t\xE9l\xE9phone",
+      "pattern.usernameOrEmail": "Doit \xEAtre un nom d'utilisateur ou un e-mail",
+      "pattern.httpOrHttps": "Doit \xEAtre une URL commen\xE7ant par http ou https",
+      // oneOf
+      oneOf: "{{#label}} doit correspondre \xE0 l'un des types suivants",
+      "oneOf.invalid": "{{#label}} ne correspond \xE0 aucun type autoris\xE9",
+      // Error fallback
+      UNKNOWN_ERROR: "Erreur de validation inconnue",
+      CUSTOM_VALIDATION_FAILED: "Validation \xE9chou\xE9e",
+      ASYNC_VALIDATION_NOT_SUPPORTED: "La validation asynchrone n'est pas prise en charge dans validate() synchrone",
+      VALIDATE_MUST_BE_FUNCTION: "validate doit \xEAtre une fonction"
+    };
+    fr_FR_default = frFR;
+  }
+});
+
+// src/locales/index.ts
+function getMessage(key, locale = DEFAULT_LOCALE) {
+  const messages = LOCALES[locale];
+  if (messages && key in messages) {
+    return messages[key];
+  }
+  if (locale !== DEFAULT_LOCALE) {
+    const defaultMessages = LOCALES[DEFAULT_LOCALE];
+    if (defaultMessages && key in defaultMessages) {
+      return defaultMessages[key];
+    }
+  }
+  const fallbackMessages = LOCALES[FALLBACK_LOCALE];
+  if (fallbackMessages && key in fallbackMessages) {
+    return fallbackMessages[key];
+  }
+  return key;
+}
+function getMessages(locale = DEFAULT_LOCALE) {
+  return LOCALES[locale] ?? LOCALES[DEFAULT_LOCALE];
+}
+function isSupportedLocale(locale) {
+  return locale in LOCALES;
+}
+function getSupportedLocales() {
+  return Object.keys(LOCALES);
+}
+var LOCALES, DEFAULT_LOCALE, FALLBACK_LOCALE;
+var init_locales = __esm({
+  "src/locales/index.ts"() {
+    "use strict";
+    init_zh_CN();
+    init_en_US();
+    init_ja_JP();
+    init_es_ES();
+    init_fr_FR();
+    LOCALES = {
+      "zh-CN": zh_CN_default,
+      "en-US": en_US_default,
+      "ja-JP": ja_JP_default,
+      "es-ES": es_ES_default,
+      "fr-FR": fr_FR_default
+    };
+    DEFAULT_LOCALE = "en-US";
+    FALLBACK_LOCALE = "en-US";
+  }
+});
+
+// src/core/Locale.ts
+var DEFAULT_LOCALE2, Locale;
+var init_Locale = __esm({
+  "src/core/Locale.ts"() {
+    "use strict";
+    init_locales();
+    DEFAULT_LOCALE2 = "en-US";
+    Locale = class {
+      static _currentLocale = DEFAULT_LOCALE2;
+      static _customMessages = {};
+      /** v1 compat: expose custom messages */
+      static get customMessages() {
+        return this._customMessages;
+      }
+      /** v1 compat: expose all locales as { locale: messages } map */
+      static get locales() {
+        const result = {};
+        for (const locale of getSupportedLocales()) {
+          result[locale] = getMessages(locale);
+        }
+        for (const key of Object.keys(this._customMessages)) {
+          if (key.includes(":")) {
+            const colonIdx = key.indexOf(":");
+            const locale = key.substring(0, colonIdx);
+            const msgKey = key.substring(colonIdx + 1);
+            if (!result[locale]) result[locale] = {};
+            result[locale][msgKey] = this._customMessages[key];
+          }
+        }
+        return result;
+      }
+      // ─── Locale Switching ─────────────────────────────────────────────────────
+      static setLocale(locale) {
+        this._currentLocale = locale;
+      }
+      static getLocale() {
+        return this._currentLocale;
+      }
+      // ─── Custom Messages (global override) ───────────────────────────────────
+      static setMessages(messages) {
+        this._customMessages = { ...this._customMessages, ...messages };
+      }
+      static addLocale(locale, messages) {
+        for (const [k, v] of Object.entries(messages)) {
+          this._customMessages[`${locale}:${k}`] = v;
+        }
+      }
+      static getAvailableLocales() {
+        return getSupportedLocales();
+      }
+      static isSupportedLocale(locale) {
+        return isSupportedLocale(locale);
+      }
+      // ─── Core Query Methods ───────────────────────────────────────────────────
+      /**
+       * Get a resolved message (v1 compat: returns { code, message } on hit).
+       *
+       * Priority: custom messages > locale pack > key itself.
+       */
+      static getMessage(type, customMessages = {}, locale = null) {
+        const resolved = this._resolveMessage(type, customMessages, locale);
+        if (!resolved) return type;
+        return this._normalizeResolvedMessage(type, resolved);
+      }
+      /**
+       * Get the final message text (used internally by v2 to avoid "[object Object]" in message field).
+       */
+      static getMessageText(type, customMessages = {}, locale = null) {
+        const resolved = this.getMessage(type, customMessages, locale);
+        return typeof resolved === "string" ? resolved : resolved.message;
+      }
+      /**
+       * Get raw message config (used by I18nError; may include a numeric code).
+       */
+      static getMessageConfig(type, customMessages = {}, locale = null) {
+        return this._resolveMessage(type, customMessages, locale) ?? { code: type, message: type };
+      }
+      /**
+       * Get the full message table for the given locale (built-in + custom).
+       */
+      static getMessages(locale) {
+        const targetLocale = locale ?? this._currentLocale;
+        const builtinMessages = getMessages(targetLocale);
+        const customForLocale = {};
+        for (const [k, v] of Object.entries(this._customMessages)) {
+          if (k.startsWith(`${targetLocale}:`)) {
+            customForLocale[k.slice(targetLocale.length + 1)] = v;
+          } else if (!k.includes(":")) {
+            customForLocale[k] = v;
+          }
+        }
+        return { ...builtinMessages, ...customForLocale };
+      }
+      /**
+       * Reset to defaults (for testing).
+       */
+      static reset() {
+        this._currentLocale = DEFAULT_LOCALE2;
+        this._customMessages = {};
+      }
+      // ─── Private Helpers ──────────────────────────────────────────────────────
+      static _normalizeResolvedMessage(type, msg) {
+        if (typeof msg === "string") {
+          return { code: type, message: msg };
+        }
+        return {
+          code: msg.code ?? type,
+          message: msg.message
+        };
+      }
+      static _resolveMessage(type, customMessages, locale) {
+        const targetLocale = locale ?? this._currentLocale;
+        const callerMsg = customMessages[type];
+        if (callerMsg !== void 0) return callerMsg;
+        const globalMsg = this._customMessages[type];
+        if (globalMsg !== void 0) return globalMsg;
+        const globalLocaleMsg = this._customMessages[`${targetLocale}:${type}`];
+        if (globalLocaleMsg !== void 0) return globalLocaleMsg;
+        if (this._isLocaleKey(type)) {
+          return getMessage(type, targetLocale);
+        }
+        return null;
+      }
+      static _isLocaleKey(key) {
+        const msgs = getMessages();
+        return key in msgs;
+      }
+    };
+  }
+});
+
+// src/core/ErrorFormatter.ts
+var ErrorFormatter;
+var init_ErrorFormatter = __esm({
+  "src/core/ErrorFormatter.ts"() {
+    "use strict";
+    init_TemplateEngine();
+    init_ErrorCodes();
+    init_locales();
+    init_Locale();
+    ErrorFormatter = class {
+      messages;
+      _locale;
+      _constructorCustomMessages;
+      constructor(locale = DEFAULT_LOCALE2, messages = {}) {
+        this._locale = locale;
+        const rawLocaleMessages = getMessages(locale);
+        const localeMessages = Object.fromEntries(
+          Object.entries(rawLocaleMessages).map(([k, v]) => [
+            k,
+            typeof v === "string" ? v : v.message
+          ])
+        );
+        const normMessages = Object.fromEntries(
+          Object.entries(messages).map(([k, v]) => [
+            k,
+            v == null ? void 0 : typeof v === "string" ? v : v.message
+          ])
+        );
+        this._constructorCustomMessages = normMessages;
+        this.messages = { ...localeMessages, ...normMessages };
+      }
+      get locale() {
+        return this._locale;
+      }
+      /**
+       * Format a single error object → message string (v1 API).
+       */
+      format(error, locale) {
+        let msgs = this.messages;
+        if (locale && locale !== this._locale) {
+          const rawLocaleMessages = getMessages(locale);
+          const localeMessages = Object.fromEntries(
+            Object.entries(rawLocaleMessages).map(([k, v]) => [
+              k,
+              typeof v === "string" ? v : v.message
+            ])
+          );
+          msgs = { ...localeMessages, ...this._constructorCustomMessages };
+        }
+        const raw = error;
+        const ajvError = {
+          keyword: raw["keyword"] ?? raw["type"] ?? "validation",
+          instancePath: raw["instancePath"] ?? "/" + (raw["path"] ?? ""),
+          params: raw["params"] ?? {},
+          parentSchema: raw["parentSchema"]
+        };
+        const item = this._formatOne(ajvError, msgs, locale);
+        return item.message;
+      }
+      /**
+       * Format an AJV raw error array → ValidationErrorItem[].
+       *
+       * @param alreadyMerged - when true, customMessages is already a fully merged locale+custom result;
+       *   skip `{ ...this.messages, ...customMessages }` spread (avoids 100+ key cold-spread overhead).
+       */
+      formatDetailed(errors, locale, customMessages, alreadyMerged = false) {
+        const msgs = customMessages ? alreadyMerged ? customMessages : { ...this.messages, ...customMessages } : this.messages;
+        const hasConcreteErrors = errors.some(
+          (e) => e.keyword !== "if" && e.keyword !== "anyOf" && e.keyword !== "oneOf" && e.keyword !== "error"
+        );
+        const filtered = hasConcreteErrors ? errors.filter((e) => e.keyword !== "if" && e.keyword !== "anyOf" && e.keyword !== "oneOf") : errors;
+        return filtered.map((err) => this._formatOne(err, msgs, locale));
+      }
+      /**
+       * Format a single error entry into a ValidationErrorItem.
+       */
+      _formatOne(err, messages, _locale) {
+        const keyword = err.keyword ?? "validation";
+        const instancePath = err.instancePath ?? "";
+        const params = err.params ?? {};
+        let fieldName;
+        if (keyword === "required" && params["missingProperty"]) {
+          const parentPath = instancePath.replace(/^\//, "");
+          const missing = String(params["missingProperty"]);
+          fieldName = parentPath ? `${parentPath}/${missing}` : missing;
+        } else {
+          fieldName = instancePath.replace(/^\//, "") || "value";
+        }
+        const schema = err.parentSchema ?? {};
+        let label;
+        if (keyword === "required" && params["missingProperty"]) {
+          const missingProp = String(params["missingProperty"]);
+          const properties = schema["properties"];
+          if (properties && properties[missingProp]) {
+            label = properties[missingProp]["_label"];
+          }
+        }
+        if (!label) {
+          label = schema["_label"];
+        }
+        if (label) {
+          label = (messages[label] != null ? String(messages[label]) : void 0) ?? label;
+        }
+        if (!label) {
+          let labelKey;
+          if (keyword === "required" && params["missingProperty"]) {
+            labelKey = String(params["missingProperty"]);
+          } else {
+            const parts = fieldName.split("/");
+            labelKey = parts[parts.length - 1] ?? fieldName;
+          }
+          const autoKey = `label.${labelKey.replace(/\//g, ".")}`;
+          label = messages[autoKey] ?? labelKey;
+        }
+        let schemaCustomMessages = schema["_customMessages"] ?? {};
+        if (keyword === "required" && params["missingProperty"]) {
+          const missingProp = String(params["missingProperty"]);
+          const properties = schema["properties"];
+          if (properties && properties[missingProp] && properties[missingProp]["_customMessages"]) {
+            schemaCustomMessages = { ...schemaCustomMessages, ...properties[missingProp]["_customMessages"] };
+          }
+        }
+        const hasCustomMessages = Object.keys(schemaCustomMessages).length > 0;
+        const mergedMessages = hasCustomMessages ? { ...messages, ...schemaCustomMessages } : messages;
+        const mappedKeyword = KEYWORD_MAP[keyword] ?? keyword;
+        const schemaType = typeof schema["type"] === "string" ? schema["type"] : "string";
+        let message = hasCustomMessages ? schemaCustomMessages[keyword] ?? schemaCustomMessages[mappedKeyword] : void 0;
+        if (message) {
+          message = mergedMessages[message] ?? message;
+        } else {
+          if (mappedKeyword === "format" && params["format"]) {
+            let fmt = String(params["format"]);
+            if (fmt === "uri") fmt = "url";
+            message = mergedMessages[`format.${fmt}`];
+          }
+          message ??= mergedMessages[`${schemaType}.${keyword}`] ?? mergedMessages[`${schemaType}.${mappedKeyword}`] ?? mergedMessages[mappedKeyword] ?? mergedMessages[keyword] ?? mergedMessages["default"] ?? err.message ?? "Validation error";
+        }
+        const limit = params["limit"] ?? params["limitLength"] ?? params["comparison"] ?? "";
+        const allowedVals = Array.isArray(params["allowedValues"]) ? params["allowedValues"].join(", ") : void 0;
+        const interpolateData = {
+          ...params,
+          path: label,
+          label,
+          value: err.data !== void 0 ? err.data : "",
+          limit,
+          min: limit,
+          max: limit,
+          expected: params["type"],
+          actual: err.data === null ? "null" : err.data === void 0 ? "undefined" : Array.isArray(err.data) ? "array" : typeof err.data,
+          valids: allowedVals,
+          allowed: allowedVals,
+          key: params["additionalProperty"]
+        };
+        const rendered = renderTemplate(message, interpolateData);
+        return {
+          path: fieldName,
+          message: rendered,
+          keyword,
+          params,
+          field: fieldName,
+          type: keyword,
+          expected: params["type"] !== void 0 ? String(params["type"]) : void 0
+        };
+      }
+      setLocale(locale) {
+        this._locale = locale;
+        const rawLocaleMessages = getMessages(locale);
+        const localeMessages = Object.fromEntries(
+          Object.entries(rawLocaleMessages).map(([k, v]) => [
+            k,
+            typeof v === "string" ? v : v.message
+          ])
+        );
+        this.messages = { ...localeMessages, ...this._constructorCustomMessages };
+      }
+      addMessage(type, template) {
+        this.messages[type] = template;
+      }
+      addMessages(messages) {
+        Object.assign(this.messages, messages);
+      }
+    };
+  }
+});
+
+// src/validators/CustomKeywords.ts
+import safeRegex from "safe-regex";
+var CustomKeywords;
+var init_CustomKeywords = __esm({
+  "src/validators/CustomKeywords.ts"() {
+    "use strict";
+    init_Locale();
+    CustomKeywords = class _CustomKeywords {
+      /**
+       * Register all custom keywords on an AJV instance
+       */
+      static registerAll(ajv) {
+        _CustomKeywords.registerRegexKeyword(ajv);
+        _CustomKeywords.registerFunctionKeyword(ajv);
+        _CustomKeywords.registerCustomValidatorsKeyword(ajv);
+        _CustomKeywords.registerMetadataKeywords(ajv);
+        _CustomKeywords.registerStringValidators(ajv);
+        _CustomKeywords.registerNumberValidators(ajv);
+        _CustomKeywords.registerObjectValidators(ajv);
+        _CustomKeywords.registerArrayValidators(ajv);
+        _CustomKeywords.registerDateValidators(ajv);
+      }
+      // ─── Metadata keywords ──────────────────────────────────────────────────
+      static registerMetadataKeywords(ajv) {
+        ajv.addKeyword({ keyword: "_label", metaSchema: { type: "string" } });
+        ajv.addKeyword({ keyword: "_customMessages", metaSchema: { type: "object" } });
+        ajv.addKeyword({ keyword: "_description", metaSchema: { type: "string" } });
+        ajv.addKeyword({ keyword: "_whenConditions", metaSchema: { type: "array" } });
+        ajv.addKeyword({ keyword: "_required", metaSchema: { type: "boolean" } });
+        ajv.addKeyword({ keyword: "_isConditional", metaSchema: { type: "boolean" } });
+        ajv.addKeyword({ keyword: "_runtimeOnlyConditional", metaSchema: { type: "boolean" } });
+        ajv.addKeyword({ keyword: "conditions" });
+        ajv.addKeyword({ keyword: "_evaluateCondition" });
+      }
+      // ─── _customValidators ──────────────────────────────────────────────────
+      static registerCustomValidatorsKeyword(ajv) {
+        const validate = (validators, data) => {
+          if (!Array.isArray(validators)) return true;
+          for (const validator of validators) {
+            if (typeof validator !== "function") continue;
+            try {
+              const result = validator(data);
+              if (result instanceof Promise) {
+                validate.errors = [{
+                  keyword: "_customValidators",
+                  message: "Async validation not supported in sync validate(). Use validateAsync() instead.",
+                  params: {}
+                }];
+                return false;
+              }
+              if (result === false) {
+                const msg = Locale.getMessageText("CUSTOM_VALIDATION_FAILED");
+                validate.errors = [{ keyword: "_customValidators", message: msg, params: {} }];
+                return false;
+              }
+              if (typeof result === "string") {
+                validate.errors = [{ keyword: "_customValidators", message: result, params: {} }];
+                return false;
+              }
+              if (result !== null && typeof result === "object" && result["error"]) {
+                const msg = String(result["message"] ?? Locale.getMessageText("CUSTOM_VALIDATION_FAILED"));
+                validate.errors = [{ keyword: "_customValidators", message: msg, params: {} }];
+                return false;
+              }
+            } catch (error) {
+              const msg = error instanceof Error ? error.message : String(error);
+              validate.errors = [{ keyword: "_customValidators", message: msg, params: {} }];
+              return false;
+            }
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "_customValidators", validate, errors: true });
+      }
+      // ─── regex ──────────────────────────────────────────────────────────────
+      // Detect potentially catastrophic patterns via a dedicated regex safety analyzer
+      static _isUnsafePattern(pattern) {
+        return !safeRegex(pattern);
+      }
+      static registerRegexKeyword(ajv) {
+        const validate = (schema, data) => {
+          const patternStr = String(schema);
+          try {
+            const regex = new RegExp(patternStr);
+            if (_CustomKeywords._isUnsafePattern(regex)) {
+              validate.errors = [{
+                keyword: "regex",
+                message: Locale.getMessageText("string.pattern"),
+                params: { pattern: patternStr, reason: "unsafe regex pattern" }
+              }];
+              return false;
+            }
+            if (regex.test(String(data))) return true;
+            validate.errors = [{
+              keyword: "regex",
+              message: Locale.getMessageText("string.pattern"),
+              params: { pattern: schema }
+            }];
+            return false;
+          } catch (error) {
+            validate.errors = [{
+              keyword: "regex",
+              message: Locale.getMessageText("string.pattern"),
+              params: { error: error instanceof Error ? error.message : String(error) }
+            }];
+            return false;
+          }
+        };
+        ajv.addKeyword({ keyword: "regex", type: "string", schemaType: "string", validate, errors: true });
+      }
+      // ─── validate (function validator) ──────────────────────────────────────
+      static registerFunctionKeyword(ajv) {
+        const validate = (schema, data) => {
+          if (typeof schema !== "function") {
+            validate.errors = [{
+              keyword: "validate",
+              message: Locale.getMessageText("VALIDATE_MUST_BE_FUNCTION"),
+              params: {}
+            }];
+            return false;
+          }
+          try {
+            const result = schema(data);
+            if (typeof result === "boolean") return result;
+            if (result !== null && typeof result === "object") {
+              const res = result;
+              if (typeof res["valid"] === "boolean") {
+                if (!res["valid"] && res["message"]) {
+                  validate.errors = [{
+                    keyword: "validate",
+                    message: String(res["message"]),
+                    params: {}
+                  }];
+                }
+                return res["valid"];
+              }
+            }
+            return true;
+          } catch (error) {
+            validate.errors = [{
+              keyword: "validate",
+              message: error instanceof Error ? error.message : String(error),
+              params: {}
+            }];
+            return false;
+          }
+        };
+        ajv.addKeyword({ keyword: "validate", validate, errors: true });
+      }
+      // ─── String validators ───────────────────────────────────────────────────
+      static registerStringValidators(ajv) {
+        const exactLength = (schema, data) => {
+          const codePointLength = [...String(data)].length;
+          if (codePointLength !== Number(schema)) {
+            exactLength.errors = [{
+              keyword: "exactLength",
+              message: Locale.getMessageText("string.length"),
+              params: { limit: schema }
+            }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "exactLength", type: "string", schemaType: "number", validate: exactLength, errors: true });
+        const alphanum = (schema, data) => {
+          if (schema && !/^[a-zA-Z0-9]*$/.test(String(data))) {
+            alphanum.errors = [{ keyword: "alphanum", message: Locale.getMessageText("string.alphanum"), params: {} }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "alphanum", type: "string", schemaType: "boolean", validate: alphanum, errors: true });
+        const trim = (schema, data) => {
+          const str = String(data);
+          if (schema && str !== str.trim()) {
+            trim.errors = [{ keyword: "trim", message: Locale.getMessageText("string.trim"), params: {} }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "trim", type: "string", schemaType: "boolean", validate: trim, errors: true });
+        const lowercase = (schema, data) => {
+          const str = String(data);
+          if (schema && str !== str.toLowerCase()) {
+            lowercase.errors = [{ keyword: "lowercase", message: Locale.getMessageText("string.lowercase"), params: {} }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "lowercase", type: "string", schemaType: "boolean", validate: lowercase, errors: true });
+        const uppercase = (schema, data) => {
+          const str = String(data);
+          if (schema && str !== str.toUpperCase()) {
+            uppercase.errors = [{ keyword: "uppercase", message: Locale.getMessageText("string.uppercase"), params: {} }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "uppercase", type: "string", schemaType: "boolean", validate: uppercase, errors: true });
+        const jsonString = (schema, data) => {
+          if (schema) {
+            try {
+              JSON.parse(String(data));
+            } catch {
+              jsonString.errors = [{ keyword: "jsonString", message: Locale.getMessageText("pattern.json"), params: {} }];
+              return false;
+            }
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "jsonString", type: "string", schemaType: "boolean", validate: jsonString, errors: true });
+      }
+      // ─── Number validators ───────────────────────────────────────────────────
+      static registerNumberValidators(ajv) {
+        const precision = (schema, data) => {
+          const n = data;
+          const limit = Number(schema);
+          const factor = Math.pow(10, limit);
+          const shifted = n * factor;
+          if (Math.abs(shifted - Math.round(shifted)) > 1e-10) {
+            precision.errors = [{ keyword: "precision", message: Locale.getMessageText("number.precision"), params: { limit: schema } }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "precision", type: "number", schemaType: "number", validate: precision, errors: true });
+        const port = (schema, data) => {
+          const num = data;
+          if (schema && (!Number.isInteger(num) || num < 1 || num > 65535)) {
+            port.errors = [{ keyword: "port", message: Locale.getMessageText("number.port"), params: {} }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "port", type: ["integer", "number"], schemaType: "boolean", validate: port, errors: true });
+      }
+      // ─── Object validators ──────────────────────────────────────────────────
+      static registerObjectValidators(ajv) {
+        const requiredAll = (schema, data, parentSchema) => {
+          if (!schema) return true;
+          const props = parentSchema?.["properties"] ?? {};
+          const missingKeys = Object.keys(props).filter((k) => !(k in data));
+          if (missingKeys.length > 0) {
+            requiredAll.errors = [{
+              keyword: "requiredAll",
+              message: Locale.getMessageText("object.missing"),
+              params: { missing: missingKeys }
+            }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "requiredAll", type: "object", schemaType: "boolean", validate: requiredAll, errors: true });
+        const strictSchema = (schema, data, parentSchema) => {
+          if (!schema) return true;
+          const props = parentSchema?.["properties"] ?? {};
+          const allowedKeys = Object.keys(props);
+          const extraKeys = Object.keys(data).filter((k) => !allowedKeys.includes(k));
+          if (extraKeys.length > 0) {
+            strictSchema.errors = [{
+              keyword: "strictSchema",
+              message: Locale.getMessageText("object.schema"),
+              params: { extra: extraKeys }
+            }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "strictSchema", type: "object", schemaType: "boolean", validate: strictSchema, errors: true });
+      }
+      // ─── Array validators ───────────────────────────────────────────────────
+      static _deepEqual(a, b) {
+        if (a === b) return true;
+        if (a === null || b === null || typeof a !== typeof b) return false;
+        if (typeof a !== "object") return false;
+        if (Array.isArray(a) !== Array.isArray(b)) return false;
+        if (Array.isArray(a)) {
+          if (a.length !== b.length) return false;
+          return a.every((item, i) => _CustomKeywords._deepEqual(item, b[i]));
+        }
+        const aKeys = Object.keys(a).sort();
+        const bKeys = Object.keys(b).sort();
+        if (aKeys.length !== bKeys.length) return false;
+        return aKeys.every(
+          (k) => _CustomKeywords._deepEqual(a[k], b[k])
+        );
+      }
+      static registerArrayValidators(ajv) {
+        const noSparse = (schema, data) => {
+          const arr = data;
+          if (schema) {
+            for (let i = 0; i < arr.length; i++) {
+              if (!(i in arr)) {
+                noSparse.errors = [{
+                  keyword: "noSparse",
+                  message: Locale.getMessageText("array.sparse"),
+                  params: { index: i }
+                }];
+                return false;
+              }
+            }
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "noSparse", type: "array", schemaType: "boolean", validate: noSparse, errors: true });
+        const includesRequired = (schema, data) => {
+          if (!Array.isArray(schema) || schema.length === 0) return true;
+          const arr = data;
+          const missing = schema.filter((required) => {
+            return !arr.some((item) => {
+              if (typeof required === "object" && required !== null) {
+                return _CustomKeywords._deepEqual(item, required);
+              }
+              return item === required;
+            });
+          });
+          if (missing.length > 0) {
+            includesRequired.errors = [{
+              keyword: "includesRequired",
+              message: Locale.getMessageText("array.includesRequired"),
+              params: { missing }
+            }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "includesRequired", type: "array", schemaType: "array", validate: includesRequired, errors: true });
+      }
+      // ─── Date validators ────────────────────────────────────────────────────
+      static registerDateValidators(ajv) {
+        const DATE_FORMATS = {
+          "YYYY-MM-DD": /^\d{4}-\d{2}-\d{2}$/,
+          "YYYY/MM/DD": /^\d{4}\/\d{2}\/\d{2}$/,
+          "DD-MM-YYYY": /^\d{2}-\d{2}-\d{4}$/,
+          "DD/MM/YYYY": /^\d{2}\/\d{2}\/\d{4}$/,
+          "ISO8601": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/
+        };
+        const dateFormat = (schema, data) => {
+          const fmt = String(schema);
+          const pattern = DATE_FORMATS[fmt];
+          const str = String(data);
+          if (!pattern || !pattern.test(str)) {
+            dateFormat.errors = [{
+              keyword: "dateFormat",
+              message: Locale.getMessageText("date.format"),
+              params: { format: schema }
+            }];
+            return false;
+          }
+          const sep = /[-/]/.exec(str)?.[0] ?? "-";
+          const parts = str.split(sep);
+          let y, m, dd;
+          if (fmt === "DD-MM-YYYY" || fmt === "DD/MM/YYYY") {
+            [dd, m, y] = [parseInt(parts[0], 10), parseInt(parts[1], 10), parseInt(parts[2], 10)];
+          } else if (fmt === "ISO8601") {
+            const d2 = new Date(str);
+            if (isNaN(d2.getTime())) {
+              dateFormat.errors = [{ keyword: "dateFormat", message: Locale.getMessageText("date.format"), params: { format: schema } }];
+              return false;
+            }
+            return true;
+          } else {
+            [y, m, dd] = [parseInt(parts[0], 10), parseInt(parts[1], 10), parseInt(parts[2], 10)];
+          }
+          const probe = new Date(y, m - 1, dd);
+          if (probe.getFullYear() !== y || probe.getMonth() !== m - 1 || probe.getDate() !== dd) {
+            dateFormat.errors = [{ keyword: "dateFormat", message: Locale.getMessageText("date.format"), params: { format: schema } }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "dateFormat", type: "string", schemaType: "string", validate: dateFormat, errors: true });
+        const dateGreater = (schema, data) => {
+          const dataDate = new Date(String(data));
+          const compareDate = new Date(String(schema));
+          if (isNaN(dataDate.getTime()) || isNaN(compareDate.getTime()) || dataDate <= compareDate) {
+            dateGreater.errors = [{
+              keyword: "dateGreater",
+              message: Locale.getMessageText("date.greater"),
+              params: { limit: schema }
+            }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "dateGreater", type: "string", schemaType: "string", validate: dateGreater, errors: true });
+        const dateLess = (schema, data) => {
+          const dataDate = new Date(String(data));
+          const compareDate = new Date(String(schema));
+          if (isNaN(dataDate.getTime()) || isNaN(compareDate.getTime()) || dataDate >= compareDate) {
+            dateLess.errors = [{
+              keyword: "dateLess",
+              message: Locale.getMessageText("date.less"),
+              params: { limit: schema }
+            }];
+            return false;
+          }
+          return true;
+        };
+        ajv.addKeyword({ keyword: "dateLess", type: "string", schemaType: "string", validate: dateLess, errors: true });
+      }
+    };
+  }
+});
+
+// src/core/ConditionalRuntime.ts
+var CONDITIONAL_RUNTIME_STATE;
+var init_ConditionalRuntime = __esm({
+  "src/core/ConditionalRuntime.ts"() {
+    "use strict";
+    CONDITIONAL_RUNTIME_STATE = /* @__PURE__ */ Symbol("schema-dsl.conditionalRuntimeState");
+  }
+});
+
+// src/core/ConditionalValidator.ts
+var EMPTY_ERRORS, ConditionalValidator;
+var init_ConditionalValidator = __esm({
+  "src/core/ConditionalValidator.ts"() {
+    "use strict";
+    init_DslParser();
+    init_Locale();
+    init_ConditionalRuntime();
+    EMPTY_ERRORS = [];
+    ConditionalValidator = class {
+      constructor(hooks) {
+        this.hooks = hooks;
+      }
+      hooks;
+      hasAnyConditional(schema) {
+        if (!schema.properties) return false;
+        return Object.values(schema.properties).some((fieldSchema) => {
+          const fs = fieldSchema;
+          if (fs._isConditional) return true;
+          if (fs.properties) return this.hasAnyConditional(fs);
+          return false;
+        });
+      }
+      validateWithConditionals(schema, data, options, rootData) {
+        const errors = [];
+        const effectiveRoot = rootData ?? data;
+        const cleanSchema = JSON.parse(JSON.stringify(schema));
+        const conditionalFields = {};
+        const nestedObjectFields = {};
+        for (const [fieldName, fieldSchema] of Object.entries(schema.properties ?? {})) {
+          const fs = fieldSchema;
+          if (fs._isConditional) {
+            conditionalFields[fieldName] = fs;
+            delete cleanSchema.properties?.[fieldName];
+            if (cleanSchema.required) {
+              cleanSchema.required = cleanSchema.required.filter((r) => r !== fieldName);
+            }
+          } else if (fs.properties && this.hasAnyConditional(fs)) {
+            nestedObjectFields[fieldName] = fs;
+            delete cleanSchema.properties?.[fieldName];
+          }
+        }
+        const baseResult = this.hooks.validateSchema(cleanSchema, data, options);
+        if (!baseResult.valid) {
+          errors.push(...baseResult.errors ?? []);
+        }
+        for (const [fieldName, conditionalSchema] of Object.entries(conditionalFields)) {
+          const dataRecord = data;
+          const fieldResult = this.validateConditional(conditionalSchema, effectiveRoot, fieldName, dataRecord[fieldName], options);
+          if (!fieldResult.valid) {
+            for (const err of fieldResult.errors ?? []) {
+              const errPath = !err.path || err.path === "value" ? fieldName : err.path;
+              errors.push({ ...err, path: errPath, field: errPath });
+            }
+          }
+        }
+        for (const [fieldName, nestedSchema] of Object.entries(nestedObjectFields)) {
+          const dataRecord = data;
+          const nestedData = dataRecord[fieldName];
+          if (nestedData === void 0 || nestedData === null) {
+            const partialSchema = JSON.parse(JSON.stringify(schema));
+            partialSchema.properties = { [fieldName]: nestedSchema };
+            partialSchema.required = (schema.required ?? []).filter((r) => r === fieldName);
+            const partialResult = this.hooks.validateSchema(partialSchema, data, options);
+            if (!partialResult.valid) {
+              errors.push(...partialResult.errors ?? []);
+            }
+            continue;
+          }
+          const nestedResult = this.validateWithConditionals(nestedSchema, nestedData, options, effectiveRoot);
+          if (!nestedResult.valid) {
+            for (const err of nestedResult.errors ?? []) {
+              const errPath = err.path ? `${fieldName}/${err.path}` : fieldName;
+              errors.push({ ...err, path: errPath, field: errPath });
+            }
+          }
+        }
+        if (errors.length === 0) return { valid: true, data, errors: EMPTY_ERRORS };
+        return { valid: false, data, errors, errorMessage: errors[0]?.message };
+      }
+      validateConditional(conditionalSchema, data, fieldName, fieldValue, options) {
+        const locale = options.locale ?? Locale.getLocale();
+        const runtimeState = conditionalSchema[CONDITIONAL_RUNTIME_STATE];
+        const conditions = runtimeState?.conditions ?? conditionalSchema.conditions ?? [];
+        if (conditions.length === 0 && conditionalSchema._runtimeOnlyConditional) {
+          return {
+            valid: false,
+            data: fieldValue,
+            errors: [{
+              message: "[schema-dsl] Function-based conditional schemas are runtime-only and cannot be restored from JSON serialization.",
+              path: "",
+              keyword: "conditional",
+              params: {}
+            }],
+            errorMessage: "[schema-dsl] Function-based conditional schemas are runtime-only and cannot be restored from JSON serialization."
+          };
+        }
+        try {
+          for (const cond of conditions) {
+            const evaluation = runtimeState?.evaluateCondition(cond, data) ?? conditionalSchema._evaluateCondition?.(cond, data) ?? { result: false };
+            const matched = evaluation.result;
+            if (cond.action === "throw") {
+              if (matched) {
+                const errorMsg = evaluation.failedMessage ?? cond.message ?? "Conditional validation failed";
+                const message = Locale.getMessageText(errorMsg, options.messages ?? {}, locale);
+                return {
+                  valid: false,
+                  data: fieldValue,
+                  errors: [{ message, path: "", keyword: "conditional", params: { condition: cond["type"] } }],
+                  errorMessage: message
+                };
+              }
+              continue;
+            }
+            if (matched) {
+              const thenSchema = cond["then"];
+              if (thenSchema !== void 0 && thenSchema !== null) {
+                return this.executeThenBranch(thenSchema, data, fieldValue, fieldName, options);
+              }
+              return { valid: true, data: fieldValue, errors: EMPTY_ERRORS };
+            }
+            if (evaluation.requirementFailed) {
+              const errorMsg = cond.message ?? "Condition not met";
+              const message = Locale.getMessageText(errorMsg, options.messages ?? {}, locale);
+              return {
+                valid: false,
+                data: fieldValue,
+                errors: [{ message, path: "", keyword: "conditional", params: {} }],
+                errorMessage: message
+              };
+            }
+          }
+          const elseSchema = runtimeState ? runtimeState.elseSchema : conditionalSchema.else;
+          if (elseSchema !== void 0) {
+            if (elseSchema === null) return { valid: true, data: fieldValue, errors: EMPTY_ERRORS };
+            return this.executeThenBranch(elseSchema, data, fieldValue, fieldName, options);
+          }
+          return { valid: true, data: fieldValue, errors: EMPTY_ERRORS };
+        } catch (error) {
+          return this.hooks.internalError(error, fieldValue);
+        }
+      }
+      executeThenBranch(thenSchema, data, fieldValue, fieldName, options) {
+        let resolved = thenSchema;
+        if (typeof resolved === "string") {
+          resolved = DslParser.parseString(resolved);
+        }
+        if (resolved !== null && typeof resolved === "object") {
+          const obj = resolved;
+          if (typeof obj["toSchema"] === "function") {
+            resolved = obj["toSchema"]();
+          }
+        }
+        const resolvedSchema = resolved;
+        if (resolvedSchema?._isConditional) {
+          return this.validateConditional(resolvedSchema, data, fieldName, fieldValue, options);
+        }
+        if (resolved !== null && typeof resolved === "object" && !Array.isArray(resolved)) {
+          const obj = resolved;
+          if (obj["type"] === void 0 && obj["oneOf"] === void 0 && obj["anyOf"] === void 0 && obj["allOf"] === void 0) {
+            resolved = DslParser.parseObject(resolved);
+          }
+        }
+        return this.validateFieldValue(resolved, fieldValue, options);
+      }
+      validateFieldValue(schema, fieldValue, options) {
+        const internalSchema = schema;
+        const isRequired = internalSchema._required === true;
+        if (!isRequired && (fieldValue === void 0 || fieldValue === "")) {
+          return { valid: true, data: fieldValue, errors: EMPTY_ERRORS };
+        }
+        if (isRequired && fieldValue === void 0) {
+          const locale = options.locale ?? Locale.getLocale();
+          const label = internalSchema._label ?? "";
+          const customMsgs = internalSchema._customMessages ?? {};
+          const allMsgs = { ...options.messages ?? {}, ...customMsgs };
+          let message;
+          if (allMsgs["required"]) {
+            message = Locale.getMessageText(allMsgs["required"], allMsgs, locale);
+          } else {
+            message = Locale.getMessageText("required", allMsgs, locale);
+            if (label) message = `${label} ${message}`;
+          }
+          return {
+            valid: false,
+            data: fieldValue,
+            errors: [{ message, path: "", keyword: "required", params: {} }],
+            errorMessage: message
+          };
+        }
+        return this.hooks.validateSchema(schema, fieldValue, options);
+      }
+    };
+  }
+});
+
+// src/errors/ValidationError.ts
+var ValidationError_exports = {};
+__export(ValidationError_exports, {
+  ValidationError: () => ValidationError
+});
+var ErrorCtor, ValidationError;
+var init_ValidationError = __esm({
+  "src/errors/ValidationError.ts"() {
+    "use strict";
+    ErrorCtor = Error;
+    ValidationError = class _ValidationError extends Error {
+      name = "ValidationError";
+      errors;
+      data;
+      statusCode;
+      constructor(errors, data, statusCode = 400) {
+        const messages = errors.length === 0 ? "Validation failed" : errors.map((e) => {
+          if (e.path) {
+            const field = e.path.replace(/^\//, "");
+            return field ? `${field}: ${e.message}` : e.message;
+          }
+          return e.message;
+        }).join("; ");
+        const hasNoPath = errors.every((e) => e.path === void 0 || e.path === null || e.path === "");
+        const isSingleConditional = errors.length === 1 && errors[0].keyword === "conditional" && hasNoPath;
+        if (isSingleConditional) {
+          super(messages);
+        } else {
+          super(hasNoPath ? `Validation failed - ${messages}` : `Validation failed: ${messages}`);
+        }
+        this.errors = errors;
+        this.data = data;
+        this.statusCode = statusCode;
+        if (ErrorCtor.captureStackTrace) {
+          ErrorCtor.captureStackTrace(this, _ValidationError);
+        }
+      }
+      toJSON() {
+        return {
+          error: this.name,
+          message: this.message,
+          statusCode: this.statusCode,
+          details: this.errors.map((e) => ({
+            field: e.path ? e.path.replace(/^\//, "") : null,
+            message: e.message,
+            keyword: e.keyword,
+            ...e.params !== void 0 ? { params: e.params } : {}
+          }))
+        };
+      }
+      getFieldError(field) {
+        const normalized = field.replace(/^\//, "");
+        return this.errors.find((e) => {
+          if (!e.path) return false;
+          return e.path.replace(/^\//, "") === normalized;
+        }) ?? null;
+      }
+      getFieldErrors() {
+        const result = {};
+        for (const e of this.errors) {
+          if (e.path) {
+            const field = e.path.replace(/^\//, "");
+            if (field) result[field] = e.message;
+          }
+        }
+        return result;
+      }
+      hasFieldError(field) {
+        return this.getFieldError(field) !== null;
+      }
+      getErrorCount() {
+        return this.errors.length;
+      }
+    };
+  }
+});
+
+// src/core/Validator.ts
+var Validator_exports = {};
+__export(Validator_exports, {
+  Validator: () => Validator
+});
+import { Ajv } from "ajv";
+import addFormats from "ajv-formats";
+var NON_AJV_KEYS, EMPTY_ERRORS2, Validator;
+var init_Validator = __esm({
+  "src/core/Validator.ts"() {
+    "use strict";
+    init_CacheManager();
+    init_ErrorFormatter();
+    init_CustomKeywords();
+    init_Locale();
+    init_ConditionalValidator();
+    NON_AJV_KEYS = /* @__PURE__ */ new Set([
+      "cache",
+      "smartCoerce",
+      "locale",
+      "messages",
+      "format",
+      "strict"
+      // v2 redefines this as strictSchema; do not forward to AJV
+    ]);
+    EMPTY_ERRORS2 = [];
+    Validator = class _Validator {
+      _ajvOptions;
+      _ajv;
+      _cache;
+      _errorFormatter;
+      // WeakMap: schema object → unique cacheKey (avoids JSON.stringify)
+      _schemaMap = /* @__PURE__ */ new WeakMap();
+      _schemaKeyCounter = 0;
+      // Performance: cache whether a schema has any conditional fields (avoids traversing properties on every validation)
+      _conditionalFlagCache = /* @__PURE__ */ new WeakMap();
+      _conditionalValidator = new ConditionalValidator({
+        validateSchema: (schema, data, options) => this._validateInternal(schema, data, options),
+        internalError: (error, data) => this._internalError(error, data)
+      });
+      // V-Y03 fix: cached removeAdditional Ajv instance (no longer new Validator each time)
+      _removeAdditionalAjv = null;
+      // V-Y07 fix: static singleton Ajv
+      static _quickValidateAjv = null;
+      constructor(options = {}) {
+        const ajvOptions = {
+          allErrors: options.allErrors !== false,
+          useDefaults: options.useDefaults !== false,
+          coerceTypes: options.coerceTypes ?? false,
+          removeAdditional: options.removeAdditional ?? false,
+          verbose: true
+          // verbose mode: enables parentSchema access on error objects
+        };
+        for (const [k, v] of Object.entries(options)) {
+          if (!NON_AJV_KEYS.has(k) && !(k in ajvOptions)) {
+            ajvOptions[k] = v;
+          }
+        }
+        this._ajvOptions = ajvOptions;
+        this._ajv = new Ajv(ajvOptions);
+        addFormats(this._ajv);
+        CustomKeywords.registerAll(this._ajv);
+        const cacheOpts = options.cache === false ? { enabled: false } : options.cache === true || options.cache == null ? {} : options.cache;
+        this._cache = new CacheManager({
+          ...cacheOpts.maxSize !== void 0 ? { maxSize: cacheOpts.maxSize } : {},
+          ...cacheOpts.ttl !== void 0 ? { ttl: cacheOpts.ttl } : {},
+          ...cacheOpts.enabled !== void 0 ? { enabled: cacheOpts.enabled } : {},
+          ...cacheOpts.statsEnabled !== void 0 ? { statsEnabled: cacheOpts.statsEnabled } : {}
+        });
+        this._errorFormatter = new ErrorFormatter();
+      }
+      get ajvOptions() {
+        return this._ajvOptions;
+      }
+      // ─── Public API ────────────────────────────────────────────────────────
+      /**
+       * Compile a schema → AJV validate function (with cache).
+       */
+      compile(schema, cacheKey) {
+        const key = cacheKey ?? null;
+        if (key) {
+          const cached = this._cache.get(key);
+          if (cached !== null) return cached;
+        }
+        try {
+          const validate = this._ajv.compile(schema);
+          if (key) this._cache.set(key, validate);
+          return validate;
+        } catch (error) {
+          throw new Error(`Schema compilation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      /**
+       * Synchronous validation.
+       */
+      validate(schema, data, options = {}) {
+        return this._validateInternal(schema, data, options);
+      }
+      /**
+       * Async validation (throws ValidationError on failure).
+       * V-Y02 fix: v1 validateAsync lacked smartCoerceTypes; v2 routes through _validateInternal uniformly.
+       * BC-6 fix: validateAsync runs async custom validators (sync AJV pass skips async fn; this method runs the full set).
+       */
+      async validateAsync(schema, data, options = {}) {
+        let resolvedSchema = schema;
+        if (typeof schema["toSchema"] === "function") {
+          const obj = schema;
+          resolvedSchema = obj["toSchema"]();
+        }
+        const result = this._validateInternal(schema, data, options);
+        if (!result.valid) {
+          const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_ValidationError(), ValidationError_exports));
+          throw new ValidationError2(result.errors ?? [], data);
+        }
+        const customErr = await this._runCustomValidators(resolvedSchema, data);
+        if (customErr) {
+          const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_ValidationError(), ValidationError_exports));
+          throw new ValidationError2([customErr], data);
+        }
+        return result.data;
+      }
+      /**
+       * BC-6: run all validators in schema._customValidators (including async).
+       * AJV's sync keyword skips Promise-returning validators; this method runs the complete set in validateAsync.
+       * Returns the first failing ValidationErrorItem, or null if all pass.
+       */
+      async _runCustomValidators(schema, data) {
+        const validators = schema["_customValidators"];
+        if (!validators?.length) return null;
+        for (const fn of validators) {
+          try {
+            const result = await Promise.resolve(fn(data));
+            if (result === false) {
+              return { message: Locale.getMessageText("CUSTOM_VALIDATION_FAILED"), path: "", keyword: "_customValidators", params: {} };
+            }
+            if (typeof result === "string") {
+              return { message: result, path: "", keyword: "_customValidators", params: {} };
+            }
+            if (result !== null && typeof result === "object" && result["error"]) {
+              const r = result;
+              return {
+                message: r.message ?? Locale.getMessageText("CUSTOM_VALIDATION_FAILED"),
+                path: "",
+                keyword: "_customValidators",
+                params: {}
+              };
+            }
+          } catch (err) {
+            return {
+              message: err instanceof Error ? err.message : String(err),
+              path: "",
+              keyword: "_customValidators",
+              params: {}
+            };
+          }
+        }
+        return null;
+      }
+      /**
+       * Batch validation (compile once, reuse for each item).
+       */
+      validateBatch(schema, dataArray) {
+        if (!Array.isArray(dataArray)) throw new Error("Data must be an array");
+        const cacheKey = this._generateCacheKey(schema);
+        const validate = this.compile(schema, cacheKey);
+        return dataArray.map((data) => this.validate(validate, data));
+      }
+      /**
+       * Add a custom keyword.
+       */
+      addKeyword(keyword, definition) {
+        try {
+          this._ajv.addKeyword({
+            ...definition,
+            keyword
+          });
+          return this;
+        } catch (error) {
+          throw new Error(`Failed to add keyword '${keyword}': ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      /**
+       * Add a custom format.
+       */
+      addFormat(name, validator) {
+        this._ajv.addFormat(name, validator);
+        return this;
+      }
+      /**
+       * Add a schema reference.
+       */
+      addSchema(uri, schema) {
+        this._ajv.addSchema(schema, uri);
+        return this;
+      }
+      /**
+       * Remove a schema reference.
+       */
+      removeSchema(uri) {
+        this._ajv.removeSchema(uri);
+        return this;
+      }
+      getAjv() {
+        return this._ajv;
+      }
+      get cache() {
+        return this._cache;
+      }
+      clearCache() {
+        this._cache.clear();
+      }
+      getCacheStats() {
+        return this._cache.getStats();
+      }
+      // ─── Static Factory ────────────────────────────────────────────────────
+      static create(options) {
+        return new _Validator(options);
+      }
+      /**
+       * Quick validate (V-Y07 fix: reuses singleton Ajv instead of creating new Ajv each time).
+       */
+      static quickValidate(schema, data) {
+        if (!_Validator._quickValidateAjv) {
+          _Validator._quickValidateAjv = new Ajv();
+          addFormats(_Validator._quickValidateAjv);
+          CustomKeywords.registerAll(_Validator._quickValidateAjv);
+        }
+        try {
+          return _Validator._quickValidateAjv.validate(schema, data);
+        } catch {
+          return false;
+        }
+      }
+      // ─── Internal Implementation ───────────────────────────────────────────
+      _validateInternal(schema, data, options = {}) {
+        const shouldFormat = options.format !== false;
+        const locale = options.locale ?? Locale.getLocale();
+        const messages = options.messages ?? {};
+        if (typeof schema["toSchema"] === "function") {
+          const obj = schema;
+          schema = obj["toSchema"]();
+        }
+        const internalSchema = schema;
+        if (internalSchema._isConditional) {
+          return this._conditionalValidator.validateConditional(internalSchema, data, null, data, options);
+        }
+        if (internalSchema.properties) {
+          let hasConditionals = this._conditionalFlagCache.get(internalSchema);
+          if (hasConditionals === void 0) {
+            hasConditionals = this._conditionalValidator.hasAnyConditional(internalSchema);
+            this._conditionalFlagCache.set(internalSchema, hasConditionals);
+          }
+          if (hasConditionals) {
+            return this._conditionalValidator.validateWithConditionals(internalSchema, data, options);
+          }
+        }
+        if (internalSchema._removeAdditional) {
+          if (!this._removeAdditionalAjv) {
+            this._removeAdditionalAjv = new Ajv({ ...this._ajvOptions, removeAdditional: true });
+            addFormats(this._removeAdditionalAjv);
+            CustomKeywords.registerAll(this._removeAdditionalAjv);
+          }
+          const cleanSchema = JSON.parse(JSON.stringify(schema));
+          delete cleanSchema._removeAdditional;
+          try {
+            const validate = this._removeAdditionalAjv.compile(cleanSchema);
+            const valid = validate(data);
+            if (valid) return { valid: true, data, errors: EMPTY_ERRORS2 };
+            const fmtErrors = this._formatErrors(validate.errors ?? [], messages, locale, shouldFormat);
+            return { valid: false, data, errors: fmtErrors, errorMessage: fmtErrors[0]?.message };
+          } catch (error) {
+            return this._internalError(error, data);
+          }
+        }
+        try {
+          let validate;
+          if (typeof schema === "function") {
+            validate = schema;
+          } else {
+            const schemaObj = schema;
+            let cacheKey = this._schemaMap.get(schemaObj);
+            if (!cacheKey) {
+              cacheKey = `s${++this._schemaKeyCounter}`;
+              this._schemaMap.set(schemaObj, cacheKey);
+            }
+            const cached = this._cache.get(cacheKey);
+            if (cached !== null) {
+              validate = cached;
+            } else {
+              try {
+                validate = this._ajv.compile(schema);
+                this._cache.set(cacheKey, validate);
+              } catch (error) {
+                throw new Error(`Schema compilation failed: ${error instanceof Error ? error.message : String(error)}`);
+              }
+            }
+          }
+          const valid = validate(data);
+          if (valid) return { valid: true, data, errors: EMPTY_ERRORS2 };
+          const fmtErrors2 = this._formatErrors(validate.errors ?? [], messages, locale, shouldFormat);
+          return { valid: false, data, errors: fmtErrors2, errorMessage: fmtErrors2[0]?.message };
+        } catch (error) {
+          return this._internalError(error, data);
+        }
+      }
+      // ─── Helper methods ─────────────────────────────────────────────────────
+      _generateCacheKey(schema) {
+        if (!this._schemaMap.has(schema)) {
+          this._schemaMap.set(schema, `schema_${++this._schemaKeyCounter}`);
+        }
+        return this._schemaMap.get(schema);
+      }
+      // Performance: cache flattened locale messages (key = locale, value = flat ErrorMessages)
+      // to avoid re-running Locale.getMessages + Object.entries.map on every validation failure
+      _flatLocaleCache = /* @__PURE__ */ new Map();
+      _getFlatLocaleMessages(locale) {
+        let flat = this._flatLocaleCache.get(locale);
+        if (!flat) {
+          const raw = Locale.getMessages(locale);
+          flat = Object.fromEntries(
+            Object.entries(raw).map(([k, v]) => [
+              k,
+              typeof v === "string" ? v : v.message
+            ])
+          );
+          this._flatLocaleCache.set(locale, flat);
+        }
+        return flat;
+      }
+      _formatErrors(rawErrors, messages, locale, shouldFormat) {
+        if (!shouldFormat) return rawErrors;
+        const localeMessages = this._getFlatLocaleMessages(locale);
+        const mergedMessages = Object.keys(messages).length === 0 ? localeMessages : { ...localeMessages, ...messages };
+        return this._errorFormatter.formatDetailed(rawErrors, locale, mergedMessages, true);
+      }
+      _internalError(error, data) {
+        const message = `Validation error: ${error instanceof Error ? error.message : String(error)}`;
+        return {
+          valid: false,
+          data,
+          errors: [{ message, path: "", keyword: "error", params: {} }],
+          errorMessage: message
+        };
+      }
+    };
+  }
+});
+
+// src/core/DslBuilder.ts
+init_DslParser();
+init_TypeRegistry();
+init_patterns();
+import safeRegex2 from "safe-regex";
+var PASSWORD_PATTERNS = {
+  weak: /.{6,}/,
+  medium: /^(?=.*[a-zA-Z])(?=.*\d).{8,}$/,
+  strong: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$/,
+  veryStrong: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&]).{10,}$/
+};
+var PASSWORD_MIN_LENGTHS = {
+  weak: 6,
+  medium: 8,
+  strong: 8,
+  veryStrong: 10
+};
+var DslBuilder = class _DslBuilder {
+  // Required IDslBuilder field
+  _isDslBuilder = true;
+  /** schema-dsl custom validation keyword set (stripped during toJsonSchema). */
+  static _internalKeys = TypeRegistry.getInternalKeys();
+  /** Custom type cache (BC with v1 DslBuilder._customTypes). */
+  static _customTypes = /* @__PURE__ */ new Map();
+  _baseSchema;
+  _required;
+  _optional;
+  _customMessages;
+  _label;
+  _description;
+  _customValidators;
+  _whenConditions;
+  // ==================== Constructor ====================
+  constructor(dslString) {
+    if (!dslString || typeof dslString !== "string") {
+      throw new Error("[schema-dsl] DSL string is required");
+    }
+    let s = dslString.trim();
+    const arrayBangMatch = /^array!([\d-]+)$/.exec(s);
+    if (arrayBangMatch) {
+      s = `array:${arrayBangMatch[1]}`;
+      this._required = true;
+      this._optional = false;
+    } else {
+      this._required = s.endsWith("!");
+      this._optional = s.endsWith("?") && !this._required;
+      if (this._required || this._optional) s = s.slice(0, -1);
+    }
+    this._customMessages = {};
+    this._label = null;
+    this._description = null;
+    this._customValidators = [];
+    this._whenConditions = [];
+    this._baseSchema = _DslBuilder._parseBody(s);
+  }
+  // ==================== Internal Parsing ====================
+  /**
+   * Parse DSL body (without ! or ?).
+   * Delegates to the unified parser so string and builder DSL parsing stay in lockstep.
+   */
+  static _parseBody(dsl) {
+    return DslParser.parseString(dsl);
+  }
+  // ==================== Static Methods (BC with v1) ====================
+  /**
+   * Register a custom type (delegates to TypeRegistry).
+   */
+  static registerType(name, schema) {
+    if (!name || typeof name !== "string") {
+      throw new Error("[schema-dsl] Type name must be a non-empty string");
+    }
+    if (!schema || typeof schema !== "object" && typeof schema !== "function") {
+      throw new Error("[schema-dsl] Schema must be an object or function");
+    }
+    _DslBuilder._customTypes.set(name, schema);
+    if (typeof schema === "function") {
+      TypeRegistry.registerDynamic(name, schema);
+    } else {
+      TypeRegistry.register(name, schema);
+    }
+  }
+  /** Check whether a type is registered (built-in or custom). */
+  static hasType(type) {
+    return TypeRegistry.has(type);
+  }
+  /** Get all registered custom type names. */
+  static getCustomTypes() {
+    return Array.from(_DslBuilder._customTypes.keys());
+  }
+  /** Clear all custom types (primarily for testing). */
+  static clearCustomTypes() {
+    TypeRegistry.clearCustomTypes();
+    _DslBuilder._customTypes.clear();
+  }
+  /**
+   * Validate schema nesting depth.
+   * @param schema - JSON Schema to validate
+   * @param maxDepth - maximum allowed depth (default 3)
+   */
+  static validateNestingDepth(schema, maxDepth = 3) {
+    let maxFound = 0;
+    let deepestPath = "";
+    function traverse(obj, depth, path, isRoot) {
+      if (!isRoot && (obj.properties || obj.items)) {
+        if (depth > maxFound) {
+          maxFound = depth;
+          deepestPath = path;
+        }
+      }
+      if (obj.properties) {
+        const nextDepth = depth + 1;
+        for (const key of Object.keys(obj.properties)) {
+          traverse(
+            obj.properties[key],
+            nextDepth,
+            `${path}.${key}`.replace(/^\./, ""),
+            false
+          );
+        }
+      }
+      if (obj.items && !Array.isArray(obj.items)) {
+        traverse(obj.items, depth, `${path}[]`, false);
+      }
+    }
+    traverse(schema, 0, "", true);
+    return {
+      valid: maxFound <= maxDepth,
+      depth: maxFound,
+      path: deepestPath,
+      message: maxFound > maxDepth ? `Nesting depth ${maxFound} exceeds limit ${maxDepth}, path: ${deepestPath}` : `Nesting depth ${maxFound} is within the limit`
+    };
+  }
+  // ==================== Private Utilities ====================
+  _assertType(method, ...types) {
+    const t = this._baseSchema.type;
+    if (!types.includes(t)) {
+      throw new Error(`[schema-dsl] ${method}() only applies to ${types.join("/")} type`);
+    }
+  }
+  _assertStringType(method) {
+    this._assertType(method, "string");
+  }
+  _assertNumberType(method) {
+    this._assertType(method, "number", "integer");
+  }
+  _assertObjectType(method) {
+    this._assertType(method, "object");
+  }
+  _assertArrayType(method) {
+    this._assertType(method, "array");
+  }
+  // ==================== Common Chain Methods ====================
+  /**
+   * Set format.
+   */
+  format(fmt) {
+    this._baseSchema.format = fmt;
+    return this;
+  }
+  /**
+   * Add regex validation.
+   */
+  pattern(regex, message) {
+    const source = regex instanceof RegExp ? regex.source : regex;
+    if (!safeRegex2(source)) {
+      throw new Error(`[schema-dsl] Unsafe regex pattern rejected (potential ReDoS): ${source}`);
+    }
+    return this._setPattern(source, message);
+  }
+  /** Internal: set pattern without safe-regex check (used by built-in validators with pre-approved patterns). */
+  _setPattern(source, message) {
+    this._baseSchema.pattern = source;
+    if (message) {
+      this._customMessages["string.pattern"] = message;
+    }
+    return this;
+  }
+  /**
+   * Custom error messages (IDslBuilder: error; BC alias: messages).
+   */
+  messages(msgs) {
+    Object.assign(this._customMessages, msgs);
+    return this;
+  }
+  /** IDslBuilder.error — alias for messages() */
+  error(msgs) {
+    return this.messages(msgs);
+  }
+  /**
+   * Set field label (used in error messages).
+   */
+  label(text) {
+    this._label = text;
+    return this;
+  }
+  /**
+   * Set description.
+   */
+  description(text) {
+    this._description = text;
+    return this;
+  }
+  /**
+   * Set default value.
+   */
+  default(value) {
+    this._baseSchema.default = value;
+    return this;
+  }
+  /**
+   * Set allowed enum values (IDslBuilder).
+   */
+  enum(...values) {
+    this._baseSchema.enum = values;
+    return this;
+  }
+  /**
+   * Mark field as optional.
+   */
+  optional() {
+    this._required = false;
+    this._optional = true;
+    return this;
+  }
+  /**
+   * Mark field as required.
+   */
+  required() {
+    this._required = true;
+    this._optional = false;
+    return this;
+  }
+  /**
+   * Add a custom validator function.
+   */
+  custom(validatorFn) {
+    if (typeof validatorFn !== "function") {
+      throw new Error("[schema-dsl] Custom validator must be a function");
+    }
+    this._customValidators.push(validatorFn);
+    return this;
+  }
+  // ==================== String Chain Methods ====================
+  /** String minimum length. */
+  min(n) {
+    this._assertStringType("min");
+    this._baseSchema.minLength = n;
+    return this;
+  }
+  /** String maximum length. */
+  max(n) {
+    this._assertStringType("max");
+    this._baseSchema.maxLength = n;
+    return this;
+  }
+  /** String exact length (→ exactLength custom keyword). */
+  length(n) {
+    this._assertStringType("length");
+    this._baseSchema.exactLength = n;
+    return this;
+  }
+  /** String: only alphanumeric characters allowed. */
+  alphanum() {
+    this._assertStringType("alphanum");
+    this._baseSchema.alphanum = true;
+    return this;
+  }
+  /** String: no leading/trailing whitespace. */
+  trim() {
+    this._assertStringType("trim");
+    this._baseSchema.trim = true;
+    return this;
+  }
+  /** String: must be lowercase. */
+  lowercase() {
+    this._assertStringType("lowercase");
+    this._baseSchema.lowercase = true;
+    return this;
+  }
+  /** String: must be uppercase. */
+  uppercase() {
+    this._assertStringType("uppercase");
+    this._baseSchema.uppercase = true;
+    return this;
+  }
+  /** String: must be a valid JSON string. */
+  json() {
+    this._assertStringType("json");
+    this._baseSchema.jsonString = true;
+    return this;
+  }
+  /** String date format validation. */
+  dateFormat(fmt) {
+    this._assertStringType("dateFormat");
+    this._baseSchema.dateFormat = fmt;
+    return this;
+  }
+  /** String: must be after the given date. */
+  after(date) {
+    this._assertStringType("after");
+    this._baseSchema.dateGreater = date;
+    return this;
+  }
+  /** String: must be before the given date. */
+  before(date) {
+    this._assertStringType("before");
+    this._baseSchema.dateLess = date;
+    return this;
+  }
+  /** v1.0.2 alias: dateGreater. */
+  dateGreater(date) {
+    this._assertStringType("dateGreater");
+    this._baseSchema.dateGreater = date;
+    return this;
+  }
+  /** v1.0.2 alias: dateLess. */
+  dateLess(date) {
+    this._assertStringType("dateLess");
+    this._baseSchema.dateLess = date;
+    return this;
+  }
+  /** String slug format validation. */
+  slug() {
+    this._assertStringType("slug");
+    this._baseSchema.pattern = "^[a-z0-9]+(?:-[a-z0-9]+)*$";
+    const existing = this._baseSchema._customMessages || {};
+    this._baseSchema._customMessages = { ...existing, pattern: "pattern.slug" };
+    return this;
+  }
+  /** String domain validation. */
+  domain() {
+    this._assertStringType("domain");
+    const cfg = PATTERNS.common.domain;
+    return this._setPattern(cfg.pattern.source).messages({ pattern: cfg.key });
+  }
+  /** String IP address validation (IPv4 or IPv6). */
+  ip() {
+    this._assertStringType("ip");
+    const cfg = PATTERNS.common.ip;
+    return this._setPattern(cfg.pattern.source).messages({ pattern: cfg.key });
+  }
+  /** String Base64 encoding validation. */
+  base64() {
+    this._assertStringType("base64");
+    const cfg = PATTERNS.common.base64;
+    return this._setPattern(cfg.pattern.source).messages({ pattern: cfg.key });
+  }
+  /** String JWT token validation. */
+  jwt() {
+    this._assertStringType("jwt");
+    const cfg = PATTERNS.common.jwt;
+    return this._setPattern(cfg.pattern.source).messages({ pattern: cfg.key });
+  }
+  // ==================== Identity / Pattern Chain Methods ====================
+  /** Phone number validation (auto-corrects number → string). */
+  phone(country = "cn") {
+    if (this._baseSchema.type === "number" || this._baseSchema.type === "integer") {
+      this._baseSchema.type = "string";
+      delete this._baseSchema["minimum"];
+      delete this._baseSchema["maximum"];
+    }
+    const cfg = PATTERNS.phone[country];
+    if (!cfg) throw new Error(`[schema-dsl] Unsupported country: ${country}`);
+    if (cfg.min !== void 0 && !this._baseSchema.minLength) this._baseSchema.minLength = cfg.min;
+    if (cfg.max !== void 0 && !this._baseSchema.maxLength) this._baseSchema.maxLength = cfg.max;
+    return this._setPattern(cfg.pattern.source).messages({ pattern: cfg.key });
+  }
+  /** phone() alias (BC). */
+  phoneNumber(country = "cn") {
+    return this.phone(country);
+  }
+  /** National ID (idCard) validation. */
+  idCard(country = "cn") {
+    const lower = country.toLowerCase();
+    const cfg = PATTERNS.idCard[lower];
+    if (!cfg) throw new Error(`[schema-dsl] Unsupported country for idCard: ${country}`);
+    if (cfg.min !== void 0 && !this._baseSchema.minLength) this._baseSchema.minLength = cfg.min;
+    if (cfg.max !== void 0 && !this._baseSchema.maxLength) this._baseSchema.maxLength = cfg.max;
+    return this._setPattern(cfg.pattern.source).messages({ pattern: cfg.key });
+  }
+  /** URL slug validation. */
+  slugChain() {
+    return this._setPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/.source).messages({ pattern: "pattern.slug" });
+  }
+  /** Credit card number validation. */
+  creditCard(type = "visa") {
+    const cfg = PATTERNS.creditCard[type.toLowerCase()];
+    if (!cfg) throw new Error(`[schema-dsl] Unsupported credit card type: ${type}`);
+    return this._setPattern(cfg.pattern.source).messages({ pattern: cfg.key });
+  }
+  /** Vehicle license plate validation. */
+  licensePlate(country = "cn") {
+    const cfg = PATTERNS.licensePlate[country.toLowerCase()];
+    if (!cfg) throw new Error(`[schema-dsl] Unsupported country for licensePlate: ${country}`);
+    return this._setPattern(cfg.pattern.source).messages({ pattern: cfg.key });
+  }
+  /** Postal code validation. */
+  postalCode(country = "cn") {
+    const cfg = PATTERNS.postalCode[country.toLowerCase()];
+    if (!cfg) throw new Error(`[schema-dsl] Unsupported country for postalCode: ${country}`);
+    return this._setPattern(cfg.pattern.source).messages({ pattern: cfg.key });
+  }
+  /** Passport number validation. */
+  passport(country = "cn") {
+    const cfg = PATTERNS.passport[country.toLowerCase()];
+    if (!cfg) throw new Error(`[schema-dsl] Unsupported country for passport: ${country}`);
+    return this._setPattern(cfg.pattern.source).messages({ pattern: cfg.key });
+  }
+  /**
+   * Username validation.
+   * @param preset - 'short'(3-16) | 'medium'(3-32) | 'long'(3-64) | 'N-M' | object
+   */
+  username(preset = "medium") {
+    let minLength;
+    let maxLength;
+    let allowUnderscore = true;
+    let allowNumber = true;
+    if (typeof preset === "string") {
+      const rangeMatch = /^(\d+)-(\d+)$/.exec(preset);
+      if (rangeMatch) {
+        minLength = parseInt(rangeMatch[1], 10);
+        maxLength = parseInt(rangeMatch[2], 10);
+      } else {
+        const presets = {
+          short: { min: 3, max: 16 },
+          medium: { min: 3, max: 32 },
+          long: { min: 3, max: 64 }
+        };
+        const p = presets[preset] ?? presets["medium"];
+        minLength = p.min;
+        maxLength = p.max;
+      }
+    } else {
+      minLength = preset.minLength ?? 3;
+      maxLength = preset.maxLength ?? 32;
+      allowUnderscore = preset.allowUnderscore !== false;
+      allowNumber = preset.allowNumber !== false;
+    }
+    if (!this._baseSchema.minLength) this._baseSchema.minLength = minLength;
+    if (!this._baseSchema.maxLength) this._baseSchema.maxLength = maxLength;
+    let pat = "^[a-zA-Z]";
+    if (allowUnderscore && allowNumber) {
+      pat += "[a-zA-Z0-9_]*$";
+    } else if (allowNumber) {
+      pat += "[a-zA-Z0-9]*$";
+    } else {
+      pat += "[a-zA-Z]*$";
+    }
+    return this._setPattern(pat).messages({ pattern: "pattern.username" });
+  }
+  /**
+   * Password strength validation.
+   * @param strength - 'weak' | 'medium' | 'strong' | 'veryStrong'
+   */
+  password(strength = "medium") {
+    const pat = PASSWORD_PATTERNS[strength];
+    if (!pat) throw new Error(`[schema-dsl] Invalid password strength: ${strength}`);
+    if (!this._baseSchema.minLength) this._baseSchema.minLength = PASSWORD_MIN_LENGTHS[strength];
+    if (!this._baseSchema.maxLength) this._baseSchema.maxLength = 64;
+    return this._setPattern(pat.source).messages({ pattern: `pattern.password.${strength}` });
+  }
+  // ==================== Number Chain Methods ====================
+  /** Number decimal places limit. */
+  precision(n) {
+    this._assertNumberType("precision");
+    this._baseSchema.precision = n;
+    return this;
+  }
+  /** Number multiple-of validation (standard JSON Schema multipleOf). */
+  multiple(n) {
+    this._assertNumberType("multiple");
+    this._baseSchema.multipleOf = n;
+    return this;
+  }
+  /** Number port validation (1–65535). */
+  port() {
+    this._assertNumberType("port");
+    this._baseSchema.port = true;
+    return this;
+  }
+  // ==================== Object Chain Methods ====================
+  /** Object: all defined properties are required. */
+  requireAll() {
+    this._assertObjectType("requireAll");
+    this._baseSchema.requiredAll = true;
+    return this;
+  }
+  /** Object strict mode: no additional properties allowed. */
+  strict() {
+    this._assertObjectType("strict");
+    this._baseSchema.strictSchema = true;
+    return this;
+  }
+  // ==================== Array Chain Methods ====================
+  /** Array: sparse arrays are not allowed. */
+  noSparse() {
+    this._assertArrayType("noSparse");
+    this._baseSchema.noSparse = true;
+    return this;
+  }
+  /** Array: must contain the specified element. */
+  includesRequired(items) {
+    this._assertArrayType("includesRequired");
+    if (!Array.isArray(items)) {
+      throw new Error("[schema-dsl] includesRequired() requires an array parameter");
+    }
+    this._baseSchema.includesRequired = items;
+    return this;
+  }
+  // ==================== Output Methods ====================
+  /**
+   * Convert to a schema with schema-dsl internal fields (for use by Validator).
+   */
+  toSchema() {
+    const schema = { ...this._baseSchema };
+    if (this._description) {
+      schema.description = this._description;
+    }
+    const baseCustomMsgs = schema._customMessages || {};
+    const mergedMsgs = { ...baseCustomMsgs, ...this._customMessages };
+    if (Object.keys(mergedMsgs).length > 0) {
+      schema._customMessages = mergedMsgs;
+    } else {
+      delete schema["_customMessages"];
+    }
+    if (this._label) {
+      schema._label = this._label;
+    }
+    if (this._customValidators.length > 0) {
+      schema._customValidators = this._customValidators;
+    }
+    if (this._whenConditions.length > 0) {
+      schema._whenConditions = this._whenConditions;
+    }
+    schema._required = this._required;
+    return schema;
+  }
+  /**
+   * Output a clean JSON Schema (strips all schema-dsl internal fields and custom keywords).
+   * Can be embedded directly in OpenAPI / standard JSON Schema documents.
+   */
+  toJsonSchema() {
+    return TypeRegistry.toJsonSchema(this.toSchema());
+  }
+  toString() {
+    return JSON.stringify(this.toJsonSchema());
+  }
+  /**
+   * Validate data (BC with v1).
+   * @param data - data to validate
+   */
+  _validator = null;
+  async validate(data) {
+    if (!this._validator) {
+      const { Validator: Validator2 } = await Promise.resolve().then(() => (init_Validator(), Validator_exports));
+      this._validator = new Validator2();
+    }
+    const schema = this.toSchema();
+    return this._validator.validate(schema, data);
+  }
+};
+
+// src/plugins/custom-type-example.ts
+var customTypeExamplePlugin = {
+  name: "custom-type-example",
+  version: "1.0.0",
+  description: "Custom type registration example plugin",
+  install(core, _options = {}, _context) {
+    const coreRecord = core;
+    const builder = coreRecord.DslBuilder ?? DslBuilder;
+    if (!builder || typeof builder.registerType !== "function") {
+      throw new Error("DslBuilder.registerType is not available. Please upgrade to schema-dsl v1.1.0+");
+    }
+    this.registerCustomTypes(builder);
+  },
+  uninstall() {
+  },
+  registerCustomTypes(dslBuilder) {
+    dslBuilder.registerType("order-id", {
+      type: "string",
+      pattern: /^ORD[0-9]{12}$/.source,
+      minLength: 15,
+      maxLength: 15,
+      _customMessages: {
+        pattern: "Invalid order ID format; must be 15 characters starting with ORD"
+      }
+    });
+    dslBuilder.registerType("sku", {
+      type: "string",
+      pattern: /^SKU-[A-Z0-9]{6,10}$/.source,
+      minLength: 10,
+      maxLength: 14,
+      _customMessages: {
+        pattern: "Invalid SKU format; must be SKU- followed by 6\u201310 alphanumeric characters"
+      }
+    });
+    dslBuilder.registerType("price", {
+      type: "number",
+      minimum: 0,
+      multipleOf: 0.01,
+      _customMessages: {
+        minimum: "Price cannot be negative",
+        multipleOf: "Price can have at most 2 decimal places"
+      }
+    });
+    dslBuilder.registerType("rating", {
+      type: "integer",
+      minimum: 1,
+      maximum: 5,
+      _customMessages: {
+        minimum: "Rating cannot be lower than 1 star",
+        maximum: "Rating cannot exceed 5 stars"
+      }
+    });
+    dslBuilder.registerType("color-code", {
+      oneOf: [
+        { type: "string", pattern: /^#[0-9A-Fa-f]{6}$/.source },
+        { type: "string", pattern: /^#[0-9A-Fa-f]{3}$/.source },
+        { type: "string", pattern: /^rgb\(\d{1,3},\s*\d{1,3},\s*\d{1,3}\)$/.source },
+        { type: "string", pattern: /^rgba\(\d{1,3},\s*\d{1,3},\s*\d{1,3},\s*(0|1|0?\.\d+)\)$/.source }
+      ]
+    });
+    dslBuilder.registerType("semver", {
+      type: "string",
+      pattern: /^(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-]+)*))?$/.source,
+      _customMessages: {
+        pattern: "Invalid version format; must follow semantic versioning (e.g. 1.0.0, 2.1.3-beta.1)"
+      }
+    });
+    dslBuilder.registerType("dynamic-age", () => {
+      const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+      return {
+        type: "integer",
+        minimum: 0,
+        maximum: currentYear - 1900,
+        _customMessages: {
+          minimum: "Age cannot be negative",
+          maximum: `Age cannot exceed ${currentYear - 1900} years`
+        }
+      };
+    });
+    dslBuilder.registerType("phone-intl", {
+      type: "string",
+      pattern: /^\+?[1-9]\d{1,14}$/.source,
+      minLength: 8,
+      maxLength: 15,
+      _customMessages: {
+        pattern: "Please enter a valid international phone number (E.164 format)"
+      }
+    });
+  }
+};
+var custom_type_example_default = customTypeExamplePlugin;
+export {
+  customTypeExamplePlugin,
+  custom_type_example_default as default
+};
+//# sourceMappingURL=custom-type-example.js.map