baobox 0.1.0

package/dist/compile/index.js

@@ -0,0 +1,4711 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/error/locales/shared.ts
+function formatList(values) {
+  return values === undefined ? "" : values.join(", ");
+}
+function labelFor(params, fallback) {
+  return params.label ?? fallback;
+}
+
+// src/error/locales/de.ts
+var deDECatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `Erwartet: ${params.expected ?? "Wert"}` : `Erwartet: ${params.expected ?? "Wert"}, erhalten: ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "Der Wert")} muss mindestens ${params.minimum} sein`,
+  MAX_LENGTH: (params) => `${labelFor(params, "Der Wert")} darf h\xF6chstens ${params.maximum} sein`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "Der Wert")} muss einem von folgenden Mustern entsprechen: ${formatList(params.patterns)}` : `${labelFor(params, "Der Wert")} muss dem Muster ${params.pattern} entsprechen`,
+  FORMAT: (params) => `${labelFor(params, "Der Wert")} muss dem Format ${params.format} entsprechen`,
+  MINIMUM: (params) => `${labelFor(params, "Der Wert")} muss >= ${params.minimum} sein`,
+  MAXIMUM: (params) => `${labelFor(params, "Der Wert")} muss <= ${params.maximum} sein`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "Der Wert")} muss > ${params.minimum} sein`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "Der Wert")} muss < ${params.maximum} sein`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "Der Wert")} muss ein Vielfaches von ${params.divisor} sein`,
+  INVALID_CONST: (params) => `Erwartet: ${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "Das Array")} muss mindestens ${params.minimum} Elemente enthalten`,
+  MAX_ITEMS: (params) => `${labelFor(params, "Das Array")} darf h\xF6chstens ${params.maximum} Elemente enthalten`,
+  UNIQUE_ITEMS: (params) => `Die Elemente von ${labelFor(params, "diesem Array")} m\xFCssen eindeutig sein`,
+  CONTAINS: (params) => `${labelFor(params, "Das Array")} muss mindestens ein passendes Element enthalten`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "Das Array")} muss mindestens ${params.minimum} passende Elemente enthalten`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "Das Array")} darf h\xF6chstens ${params.maximum} passende Elemente enthalten`,
+  MISSING_REQUIRED: (params) => `Erforderliche Eigenschaft "${params.property}" fehlt`,
+  ADDITIONAL_PROPERTY: (params) => `Unerwartete Eigenschaft "${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `Unerwartetes Element an Index ${params.count}`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "Das Objekt")} muss mindestens ${params.minimum} Eigenschaften haben`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "Das Objekt")} darf h\xF6chstens ${params.maximum} Eigenschaften haben`,
+  INVALID_KEY: (params) => `Ung\xFCltiger Schl\xFCssel "${params.key}"`,
+  UNION: () => "Der Wert passt zu keiner Union-Variante",
+  ENUM: (params) => `Der Wert muss einer von folgenden sein: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "Nicht aufgel\xF6ste Schema-Referenz",
+  EXCLUDE: () => "Der Wert entspricht einem ausgeschlossenen Schema",
+  EXTRACT: () => "Der Wert entspricht nicht dem extrahierten Schema",
+  NEVER: () => "Der Wert ist nicht erlaubt",
+  NOT: () => "Der Wert entspricht einem negierten Schema",
+  KEYOF: (params) => `Der Wert muss einer von folgenden sein: ${formatList(params.values)}`,
+  CONDITIONAL: () => "Der Wert passt zu keinem bedingten Zweig",
+  INDEX: () => "Der Wert passt zu keinem indexierten Schema",
+  IDENTIFIER: () => "G\xFCltiger Bezeichner erwartet",
+  BASE: () => "Basisvalidierung fehlgeschlagen",
+  REFINE: (params) => params.customMessage ?? "Verfeinerung fehlgeschlagen",
+  CALL: () => "Aufrufschema konnte nicht instanziiert werden",
+  PARAMETERS_LENGTH: (params) => `${params.count} Parameter erwartet`,
+  CUSTOM_TYPE: (params) => `Validierung des benutzerdefinierten Typs "${params.kind}" fehlgeschlagen`
+};
+
+// src/error/locales/en.ts
+var enUSCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `Expected ${params.expected ?? "value"}` : `Expected ${params.expected ?? "value"}, got ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "Value")} must be at least ${params.minimum}`,
+  MAX_LENGTH: (params) => `${labelFor(params, "Value")} must be at most ${params.maximum}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "Value")} must match one of: ${formatList(params.patterns)}` : `${labelFor(params, "Value")} must match pattern ${params.pattern}`,
+  FORMAT: (params) => `${labelFor(params, "Value")} must match format ${params.format}`,
+  MINIMUM: (params) => `${labelFor(params, "Value")} must be >= ${params.minimum}`,
+  MAXIMUM: (params) => `${labelFor(params, "Value")} must be <= ${params.maximum}`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "Value")} must be > ${params.minimum}`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "Value")} must be < ${params.maximum}`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "Value")} must be a multiple of ${params.divisor}`,
+  INVALID_CONST: (params) => `Expected ${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "Array")} must have at least ${params.minimum} items`,
+  MAX_ITEMS: (params) => `${labelFor(params, "Array")} must have at most ${params.maximum} items`,
+  UNIQUE_ITEMS: (params) => `${labelFor(params, "Array")} items must be unique`,
+  CONTAINS: (params) => `${labelFor(params, "Array")} must contain at least one matching item`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "Array")} must contain at least ${params.minimum} matching items`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "Array")} must contain at most ${params.maximum} matching items`,
+  MISSING_REQUIRED: (params) => `Missing required property "${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `Unexpected property "${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `Unexpected item at index ${params.count}`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "Object")} must have at least ${params.minimum} properties`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "Object")} must have at most ${params.maximum} properties`,
+  INVALID_KEY: (params) => `Invalid record key "${params.key}"`,
+  UNION: () => "Value does not match any union variant",
+  ENUM: (params) => `Value must be one of: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "Unresolved schema reference",
+  EXCLUDE: () => "Value matched an excluded schema",
+  EXTRACT: () => "Value did not match the extracted schema",
+  NEVER: () => "Value is not allowed",
+  NOT: () => "Value matches a negated schema",
+  KEYOF: (params) => `Value must be one of: ${formatList(params.values)}`,
+  CONDITIONAL: () => "Value does not match any conditional branch",
+  INDEX: () => "Value does not match any indexed schema",
+  IDENTIFIER: () => "Expected valid identifier string",
+  BASE: () => "Base validation failed",
+  REFINE: (params) => params.customMessage ?? "Refinement failed",
+  CALL: () => "Unable to instantiate call schema",
+  PARAMETERS_LENGTH: (params) => `Expected ${params.count} parameters`,
+  CUSTOM_TYPE: (params) => `Custom type validation failed for kind "${params.kind}"`
+};
+
+// src/error/locales/es.ts
+var esESCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `Se esperaba ${params.expected ?? "un valor"}` : `Se esperaba ${params.expected ?? "un valor"}, se recibi\xF3 ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "El valor")} debe ser al menos ${params.minimum}`,
+  MAX_LENGTH: (params) => `${labelFor(params, "El valor")} debe ser como m\xE1ximo ${params.maximum}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "El valor")} debe coincidir con uno de: ${formatList(params.patterns)}` : `${labelFor(params, "El valor")} debe coincidir con el patr\xF3n ${params.pattern}`,
+  FORMAT: (params) => `${labelFor(params, "El valor")} debe coincidir con el formato ${params.format}`,
+  MINIMUM: (params) => `${labelFor(params, "El valor")} debe ser >= ${params.minimum}`,
+  MAXIMUM: (params) => `${labelFor(params, "El valor")} debe ser <= ${params.maximum}`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "El valor")} debe ser > ${params.minimum}`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "El valor")} debe ser < ${params.maximum}`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "El valor")} debe ser m\xFAltiplo de ${params.divisor}`,
+  INVALID_CONST: (params) => `Se esperaba ${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "El arreglo")} debe tener al menos ${params.minimum} elementos`,
+  MAX_ITEMS: (params) => `${labelFor(params, "El arreglo")} debe tener como m\xE1ximo ${params.maximum} elementos`,
+  UNIQUE_ITEMS: (params) => `Los elementos de ${labelFor(params, "este arreglo")} deben ser \xFAnicos`,
+  CONTAINS: (params) => `${labelFor(params, "El arreglo")} debe contener al menos un elemento coincidente`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "El arreglo")} debe contener al menos ${params.minimum} elementos coincidentes`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "El arreglo")} debe contener como m\xE1ximo ${params.maximum} elementos coincidentes`,
+  MISSING_REQUIRED: (params) => `Falta la propiedad requerida "${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `Propiedad inesperada "${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `Elemento inesperado en el \xEDndice ${params.count}`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "El objeto")} debe tener al menos ${params.minimum} propiedades`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "El objeto")} debe tener como m\xE1ximo ${params.maximum} propiedades`,
+  INVALID_KEY: (params) => `Clave de registro no v\xE1lida "${params.key}"`,
+  UNION: () => "El valor no coincide con ninguna variante de la uni\xF3n",
+  ENUM: (params) => `El valor debe ser uno de: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "Referencia de esquema no resuelta",
+  EXCLUDE: () => "El valor coincidi\xF3 con un esquema excluido",
+  EXTRACT: () => "El valor no coincidi\xF3 con el esquema extra\xEDdo",
+  NEVER: () => "El valor no est\xE1 permitido",
+  NOT: () => "El valor coincide con un esquema negado",
+  KEYOF: (params) => `El valor debe ser uno de: ${formatList(params.values)}`,
+  CONDITIONAL: () => "El valor no coincide con ninguna rama condicional",
+  INDEX: () => "El valor no coincide con ning\xFAn esquema indexado",
+  IDENTIFIER: () => "Se esperaba una cadena identificadora v\xE1lida",
+  BASE: () => "La validaci\xF3n base fall\xF3",
+  REFINE: (params) => params.customMessage ?? "La validaci\xF3n refinada fall\xF3",
+  CALL: () => "No se pudo instanciar el esquema de llamada",
+  PARAMETERS_LENGTH: (params) => `Se esperaban ${params.count} par\xE1metros`,
+  CUSTOM_TYPE: (params) => `La validaci\xF3n del tipo personalizado "${params.kind}" fall\xF3`
+};
+
+// src/error/locales/fr.ts
+var frFRCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `Valeur attendue: ${params.expected ?? "valeur"}` : `Valeur attendue: ${params.expected ?? "valeur"}, re\xE7u: ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "La valeur")} doit \xEAtre au moins ${params.minimum}`,
+  MAX_LENGTH: (params) => `${labelFor(params, "La valeur")} doit \xEAtre au plus ${params.maximum}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "La valeur")} doit correspondre \xE0 l'un de: ${formatList(params.patterns)}` : `${labelFor(params, "La valeur")} doit correspondre au motif ${params.pattern}`,
+  FORMAT: (params) => `${labelFor(params, "La valeur")} doit respecter le format ${params.format}`,
+  MINIMUM: (params) => `${labelFor(params, "La valeur")} doit \xEAtre >= ${params.minimum}`,
+  MAXIMUM: (params) => `${labelFor(params, "La valeur")} doit \xEAtre <= ${params.maximum}`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "La valeur")} doit \xEAtre > ${params.minimum}`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "La valeur")} doit \xEAtre < ${params.maximum}`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "La valeur")} doit \xEAtre un multiple de ${params.divisor}`,
+  INVALID_CONST: (params) => `Valeur attendue: ${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "Le tableau")} doit contenir au moins ${params.minimum} \xE9l\xE9ments`,
+  MAX_ITEMS: (params) => `${labelFor(params, "Le tableau")} doit contenir au plus ${params.maximum} \xE9l\xE9ments`,
+  UNIQUE_ITEMS: (params) => `Les \xE9l\xE9ments de ${labelFor(params, "ce tableau")} doivent \xEAtre uniques`,
+  CONTAINS: (params) => `${labelFor(params, "Le tableau")} doit contenir au moins un \xE9l\xE9ment correspondant`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "Le tableau")} doit contenir au moins ${params.minimum} \xE9l\xE9ments correspondants`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "Le tableau")} doit contenir au plus ${params.maximum} \xE9l\xE9ments correspondants`,
+  MISSING_REQUIRED: (params) => `Propri\xE9t\xE9 requise manquante "${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `Propri\xE9t\xE9 inattendue "${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `\xC9l\xE9ment inattendu \xE0 l'index ${params.count}`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "L\u2019objet")} doit avoir au moins ${params.minimum} propri\xE9t\xE9s`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "L\u2019objet")} doit avoir au plus ${params.maximum} propri\xE9t\xE9s`,
+  INVALID_KEY: (params) => `Cl\xE9 d\u2019enregistrement invalide "${params.key}"`,
+  UNION: () => "La valeur ne correspond \xE0 aucune variante de l\u2019union",
+  ENUM: (params) => `La valeur doit \xEAtre l\u2019une de: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "R\xE9f\xE9rence de sch\xE9ma non r\xE9solue",
+  EXCLUDE: () => "La valeur correspond \xE0 un sch\xE9ma exclu",
+  EXTRACT: () => "La valeur ne correspond pas au sch\xE9ma extrait",
+  NEVER: () => "La valeur n\u2019est pas autoris\xE9e",
+  NOT: () => "La valeur correspond \xE0 un sch\xE9ma n\xE9gatif",
+  KEYOF: (params) => `La valeur doit \xEAtre l\u2019une de: ${formatList(params.values)}`,
+  CONDITIONAL: () => "La valeur ne correspond \xE0 aucune branche conditionnelle",
+  INDEX: () => "La valeur ne correspond \xE0 aucun sch\xE9ma index\xE9",
+  IDENTIFIER: () => "Identifiant attendu valide",
+  BASE: () => "La validation de base a \xE9chou\xE9",
+  REFINE: (params) => params.customMessage ?? "Le raffinement a \xE9chou\xE9",
+  CALL: () => "Impossible d\u2019instancier le sch\xE9ma d\u2019appel",
+  PARAMETERS_LENGTH: (params) => `${params.count} param\xE8tres attendus`,
+  CUSTOM_TYPE: (params) => `La validation du type personnalis\xE9 "${params.kind}" a \xE9chou\xE9`
+};
+
+// src/error/locales/ja.ts
+var jaJPCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `${params.expected ?? "\u5024"}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059` : `${params.expected ?? "\u5024"}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u5B9F\u969B\u306E\u578B: ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "\u5024")}\u306F\u5C11\u306A\u304F\u3068\u3082${params.minimum}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  MAX_LENGTH: (params) => `${labelFor(params, "\u5024")}\u306F\u6700\u5927\u3067${params.maximum}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "\u5024")}\u306F\u6B21\u306E\u3044\u305A\u308C\u304B\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059: ${formatList(params.patterns)}` : `${labelFor(params, "\u5024")}\u306F\u30D1\u30BF\u30FC\u30F3${params.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  FORMAT: (params) => `${labelFor(params, "\u5024")}\u306F\u5F62\u5F0F${params.format}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  MINIMUM: (params) => `${labelFor(params, "\u5024")}\u306F${params.minimum}\u4EE5\u4E0A\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  MAXIMUM: (params) => `${labelFor(params, "\u5024")}\u306F${params.maximum}\u4EE5\u4E0B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "\u5024")}\u306F${params.minimum}\u3088\u308A\u5927\u304D\u3044\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "\u5024")}\u306F${params.maximum}\u3088\u308A\u5C0F\u3055\u3044\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "\u5024")}\u306F${params.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  INVALID_CONST: (params) => `${params.expectedValue}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  MIN_ITEMS: (params) => `${labelFor(params, "\u914D\u5217")}\u306B\u306F\u5C11\u306A\u304F\u3068\u3082${params.minimum}\u500B\u306E\u9805\u76EE\u304C\u5FC5\u8981\u3067\u3059`,
+  MAX_ITEMS: (params) => `${labelFor(params, "\u914D\u5217")}\u306B\u306F\u6700\u5927${params.maximum}\u500B\u306E\u9805\u76EE\u307E\u3067\u8A31\u53EF\u3055\u308C\u307E\u3059`,
+  UNIQUE_ITEMS: (params) => `${labelFor(params, "\u914D\u5217")}\u306E\u9805\u76EE\u306F\u4E00\u610F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  CONTAINS: (params) => `${labelFor(params, "\u914D\u5217")}\u306B\u306F\u4E00\u81F4\u3059\u308B\u9805\u76EE\u304C\u5C11\u306A\u304F\u3068\u30821\u3064\u5FC5\u8981\u3067\u3059`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "\u914D\u5217")}\u306B\u306F\u4E00\u81F4\u3059\u308B\u9805\u76EE\u304C\u5C11\u306A\u304F\u3068\u3082${params.minimum}\u500B\u5FC5\u8981\u3067\u3059`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "\u914D\u5217")}\u306B\u306F\u4E00\u81F4\u3059\u308B\u9805\u76EE\u3092\u6700\u5927${params.maximum}\u500B\u307E\u3067\u542B\u3081\u3089\u308C\u307E\u3059`,
+  MISSING_REQUIRED: (params) => `\u5FC5\u9808\u30D7\u30ED\u30D1\u30C6\u30A3"${params.property}"\u304C\u3042\u308A\u307E\u305B\u3093`,
+  ADDITIONAL_PROPERTY: (params) => `\u4E88\u671F\u3057\u306A\u3044\u30D7\u30ED\u30D1\u30C6\u30A3"${params.property}"\u3067\u3059`,
+  ADDITIONAL_ITEMS: (params) => `\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9${params.count}\u306B\u4E88\u671F\u3057\u306A\u3044\u9805\u76EE\u304C\u3042\u308A\u307E\u3059`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8")}\u306B\u306F\u5C11\u306A\u304F\u3068\u3082${params.minimum}\u500B\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u304C\u5FC5\u8981\u3067\u3059`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8")}\u306B\u306F\u6700\u5927${params.maximum}\u500B\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u307E\u3067\u8A31\u53EF\u3055\u308C\u307E\u3059`,
+  INVALID_KEY: (params) => `\u7121\u52B9\u306A\u30EC\u30B3\u30FC\u30C9\u30AD\u30FC"${params.key}"\u3067\u3059`,
+  UNION: () => "\u5024\u304C\u3069\u306E\u30E6\u30CB\u30AA\u30F3\u5206\u5C90\u306B\u3082\u4E00\u81F4\u3057\u307E\u305B\u3093",
+  ENUM: (params) => `\u5024\u306F\u6B21\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "\u89E3\u6C7A\u3067\u304D\u306A\u3044\u30B9\u30AD\u30FC\u30DE\u53C2\u7167\u3067\u3059",
+  EXCLUDE: () => "\u5024\u304C\u9664\u5916\u3055\u308C\u305F\u30B9\u30AD\u30FC\u30DE\u306B\u4E00\u81F4\u3057\u307E\u3057\u305F",
+  EXTRACT: () => "\u5024\u304C\u62BD\u51FA\u3055\u308C\u305F\u30B9\u30AD\u30FC\u30DE\u306B\u4E00\u81F4\u3057\u307E\u305B\u3093",
+  NEVER: () => "\u5024\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+  NOT: () => "\u5024\u304C\u5426\u5B9A\u30B9\u30AD\u30FC\u30DE\u306B\u4E00\u81F4\u3057\u3066\u3044\u307E\u3059",
+  KEYOF: (params) => `\u5024\u306F\u6B21\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059: ${formatList(params.values)}`,
+  CONDITIONAL: () => "\u5024\u304C\u3069\u306E\u6761\u4EF6\u5206\u5C90\u306B\u3082\u4E00\u81F4\u3057\u307E\u305B\u3093",
+  INDEX: () => "\u5024\u304C\u3069\u306E\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u5019\u88DC\u30B9\u30AD\u30FC\u30DE\u306B\u3082\u4E00\u81F4\u3057\u307E\u305B\u3093",
+  IDENTIFIER: () => "\u6709\u52B9\u306A\u8B58\u5225\u5B50\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+  BASE: () => "\u57FA\u672C\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  REFINE: (params) => params.customMessage ?? "\u8FFD\u52A0\u6761\u4EF6\u306E\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  CALL: () => "\u547C\u3073\u51FA\u3057\u30B9\u30AD\u30FC\u30DE\u3092\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u5316\u3067\u304D\u307E\u305B\u3093",
+  PARAMETERS_LENGTH: (params) => `\u30D1\u30E9\u30E1\u30FC\u30BF\u306F${params.count}\u500B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  CUSTOM_TYPE: (params) => `\u30AB\u30B9\u30BF\u30E0\u578B"${params.kind}"\u306E\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F`
+};
+
+// src/error/locales/ko.ts
+var koKRCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `${params.expected ?? "\uAC12"}\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4` : `${params.expected ?? "\uAC12"}\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4. \uD604\uC7AC \uAC12 \uC720\uD615: ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) \uCD5C\uC18C ${params.minimum}\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MAX_LENGTH: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) \uCD5C\uB300 ${params.maximum}\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "\uAC12")}\uC740(\uB294) \uB2E4\uC74C \uC911 \uD558\uB098\uC640 \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4: ${formatList(params.patterns)}` : `${labelFor(params, "\uAC12")}\uC740(\uB294) \uD328\uD134 ${params.pattern}\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`,
+  FORMAT: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.format} \uD615\uC2DD\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MINIMUM: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.minimum} \uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MAXIMUM: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.maximum} \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.minimum}\uBCF4\uB2E4 \uCEE4\uC57C \uD569\uB2C8\uB2E4`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.maximum}\uBCF4\uB2E4 \uC791\uC544\uC57C \uD569\uB2C8\uB2E4`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "\uAC12")}\uC740(\uB294) ${params.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`,
+  INVALID_CONST: (params) => `${params.expectedValue}\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MIN_ITEMS: (params) => `${labelFor(params, "\uBC30\uC5F4")}\uC740(\uB294) \uCD5C\uC18C ${params.minimum}\uAC1C \uD56D\uBAA9\uC774 \uD544\uC694\uD569\uB2C8\uB2E4`,
+  MAX_ITEMS: (params) => `${labelFor(params, "\uBC30\uC5F4")}\uC740(\uB294) \uCD5C\uB300 ${params.maximum}\uAC1C \uD56D\uBAA9\uB9CC \uD5C8\uC6A9\uB429\uB2C8\uB2E4`,
+  UNIQUE_ITEMS: (params) => `${labelFor(params, "\uBC30\uC5F4")} \uD56D\uBAA9\uC740 \uACE0\uC720\uD574\uC57C \uD569\uB2C8\uB2E4`,
+  CONTAINS: (params) => `${labelFor(params, "\uBC30\uC5F4")}\uC5D0 \uC77C\uCE58\uD558\uB294 \uD56D\uBAA9\uC774 \uD558\uB098 \uC774\uC0C1 \uC788\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "\uBC30\uC5F4")}\uC5D0 \uC77C\uCE58\uD558\uB294 \uD56D\uBAA9\uC774 \uCD5C\uC18C ${params.minimum}\uAC1C \uC788\uC5B4\uC57C \uD569\uB2C8\uB2E4`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "\uBC30\uC5F4")}\uC5D0 \uC77C\uCE58\uD558\uB294 \uD56D\uBAA9\uC774 \uCD5C\uB300 ${params.maximum}\uAC1C\uAE4C\uC9C0\uB9CC \uD5C8\uC6A9\uB429\uB2C8\uB2E4`,
+  MISSING_REQUIRED: (params) => `\uD544\uC218 \uC18D\uC131 "${params.property}"\uC774(\uAC00) \uC5C6\uC2B5\uB2C8\uB2E4`,
+  ADDITIONAL_PROPERTY: (params) => `\uC608\uC0C1\uD558\uC9C0 \uBABB\uD55C \uC18D\uC131 "${params.property}"\uC785\uB2C8\uB2E4`,
+  ADDITIONAL_ITEMS: (params) => `\uC778\uB371\uC2A4 ${params.count}\uC758 \uD56D\uBAA9\uC740 \uD5C8\uC6A9\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "\uAC1D\uCCB4")}\uC5D0\uB294 \uCD5C\uC18C ${params.minimum}\uAC1C\uC758 \uC18D\uC131\uC774 \uD544\uC694\uD569\uB2C8\uB2E4`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "\uAC1D\uCCB4")}\uC5D0\uB294 \uCD5C\uB300 ${params.maximum}\uAC1C\uC758 \uC18D\uC131\uB9CC \uD5C8\uC6A9\uB429\uB2C8\uB2E4`,
+  INVALID_KEY: (params) => `\uB808\uCF54\uB4DC \uD0A4 "${params.key}"\uAC00 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4`,
+  UNION: () => "\uAC12\uC774 \uC5B4\uB5A4 \uC720\uB2C8\uC5B8 \uBD84\uAE30\uC640\uB3C4 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  ENUM: (params) => `\uAC12\uC740 \uB2E4\uC74C \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "\uC2A4\uD0A4\uB9C8 \uCC38\uC870\uB97C \uD655\uC778\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+  EXCLUDE: () => "\uAC12\uC774 \uC81C\uC678\uB41C \uC2A4\uD0A4\uB9C8\uC640 \uC77C\uCE58\uD588\uC2B5\uB2C8\uB2E4",
+  EXTRACT: () => "\uAC12\uC774 \uCD94\uCD9C\uB41C \uC2A4\uD0A4\uB9C8\uC640 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  NEVER: () => "\uAC12\uC774 \uD5C8\uC6A9\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  NOT: () => "\uAC12\uC774 \uBD80\uC815 \uC2A4\uD0A4\uB9C8\uC640 \uC77C\uCE58\uD569\uB2C8\uB2E4",
+  KEYOF: (params) => `\uAC12\uC740 \uB2E4\uC74C \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4: ${formatList(params.values)}`,
+  CONDITIONAL: () => "\uAC12\uC774 \uC5B4\uB5A4 \uC870\uAC74 \uBD84\uAE30\uC640\uB3C4 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  INDEX: () => "\uAC12\uC774 \uC5B4\uB5A4 \uC778\uB371\uC2A4 \uD6C4\uBCF4 \uC2A4\uD0A4\uB9C8\uC640\uB3C4 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  IDENTIFIER: () => "\uC62C\uBC14\uB978 \uC2DD\uBCC4\uC790 \uBB38\uC790\uC5F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4",
+  BASE: () => "\uAE30\uBCF8 \uAC80\uC99D\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4",
+  REFINE: (params) => params.customMessage ?? "\uC138\uBD80 \uC870\uAC74 \uAC80\uC99D\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4",
+  CALL: () => "\uD638\uCD9C \uC2A4\uD0A4\uB9C8\uB97C \uC778\uC2A4\uD134\uC2A4\uD654\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+  PARAMETERS_LENGTH: (params) => `\uB9E4\uAC1C\uBCC0\uC218\uB294 ${params.count}\uAC1C\uC5EC\uC57C \uD569\uB2C8\uB2E4`,
+  CUSTOM_TYPE: (params) => `\uC0AC\uC6A9\uC790 \uC815\uC758 \uD0C0\uC785 "${params.kind}" \uAC80\uC99D\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4`
+};
+
+// src/error/locales/pt.ts
+var ptBRCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `Esperado ${params.expected ?? "valor"}` : `Esperado ${params.expected ?? "valor"}, recebido ${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "O valor")} deve ser no m\xEDnimo ${params.minimum}`,
+  MAX_LENGTH: (params) => `${labelFor(params, "O valor")} deve ser no m\xE1ximo ${params.maximum}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "O valor")} deve corresponder a um destes padr\xF5es: ${formatList(params.patterns)}` : `${labelFor(params, "O valor")} deve corresponder ao padr\xE3o ${params.pattern}`,
+  FORMAT: (params) => `${labelFor(params, "O valor")} deve corresponder ao formato ${params.format}`,
+  MINIMUM: (params) => `${labelFor(params, "O valor")} deve ser >= ${params.minimum}`,
+  MAXIMUM: (params) => `${labelFor(params, "O valor")} deve ser <= ${params.maximum}`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "O valor")} deve ser > ${params.minimum}`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "O valor")} deve ser < ${params.maximum}`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "O valor")} deve ser m\xFAltiplo de ${params.divisor}`,
+  INVALID_CONST: (params) => `Esperado ${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "O array")} deve ter pelo menos ${params.minimum} itens`,
+  MAX_ITEMS: (params) => `${labelFor(params, "O array")} deve ter no m\xE1ximo ${params.maximum} itens`,
+  UNIQUE_ITEMS: (params) => `Os itens de ${labelFor(params, "este array")} devem ser \xFAnicos`,
+  CONTAINS: (params) => `${labelFor(params, "O array")} deve conter ao menos um item correspondente`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "O array")} deve conter pelo menos ${params.minimum} itens correspondentes`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "O array")} deve conter no m\xE1ximo ${params.maximum} itens correspondentes`,
+  MISSING_REQUIRED: (params) => `Propriedade obrigat\xF3ria ausente "${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `Propriedade inesperada "${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `Item inesperado no \xEDndice ${params.count}`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "O objeto")} deve ter pelo menos ${params.minimum} propriedades`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "O objeto")} deve ter no m\xE1ximo ${params.maximum} propriedades`,
+  INVALID_KEY: (params) => `Chave inv\xE1lida "${params.key}"`,
+  UNION: () => "O valor n\xE3o corresponde a nenhuma variante da uni\xE3o",
+  ENUM: (params) => `O valor deve ser um destes: ${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "Refer\xEAncia de esquema n\xE3o resolvida",
+  EXCLUDE: () => "O valor correspondeu a um esquema exclu\xEDdo",
+  EXTRACT: () => "O valor n\xE3o correspondeu ao esquema extra\xEDdo",
+  NEVER: () => "O valor n\xE3o \xE9 permitido",
+  NOT: () => "O valor corresponde a um esquema negado",
+  KEYOF: (params) => `O valor deve ser um destes: ${formatList(params.values)}`,
+  CONDITIONAL: () => "O valor n\xE3o corresponde a nenhum ramo condicional",
+  INDEX: () => "O valor n\xE3o corresponde a nenhum esquema indexado",
+  IDENTIFIER: () => "Era esperado um identificador v\xE1lido",
+  BASE: () => "A valida\xE7\xE3o base falhou",
+  REFINE: (params) => params.customMessage ?? "A valida\xE7\xE3o refinada falhou",
+  CALL: () => "N\xE3o foi poss\xEDvel instanciar o esquema de chamada",
+  PARAMETERS_LENGTH: (params) => `Esperados ${params.count} par\xE2metros`,
+  CUSTOM_TYPE: (params) => `A valida\xE7\xE3o do tipo personalizado "${params.kind}" falhou`
+};
+
+// src/error/locales/zh.ts
+var zhHansCatalog = {
+  INVALID_TYPE: (params) => params.actual === undefined ? `\u5E94\u4E3A${params.expected ?? "\u503C"}` : `\u5E94\u4E3A${params.expected ?? "\u503C"}\uFF0C\u5B9E\u9645\u7C7B\u578B\u4E3A${params.actual}`,
+  MIN_LENGTH: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B\u81F3\u5C11\u4E3A${params.minimum}`,
+  MAX_LENGTH: (params) => `${labelFor(params, "\u503C")}\u6700\u591A\u53EA\u80FD\u4E3A${params.maximum}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "\u503C")}\u5FC5\u987B\u5339\u914D\u4EE5\u4E0B\u4E4B\u4E00\uFF1A${formatList(params.patterns)}` : `${labelFor(params, "\u503C")}\u5FC5\u987B\u5339\u914D\u6A21\u5F0F${params.pattern}`,
+  FORMAT: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B\u5339\u914D\u683C\u5F0F${params.format}`,
+  MINIMUM: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B >= ${params.minimum}`,
+  MAXIMUM: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B <= ${params.maximum}`,
+  EXCLUSIVE_MINIMUM: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B > ${params.minimum}`,
+  EXCLUSIVE_MAXIMUM: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B < ${params.maximum}`,
+  MULTIPLE_OF: (params) => `${labelFor(params, "\u503C")}\u5FC5\u987B\u662F${params.divisor}\u7684\u500D\u6570`,
+  INVALID_CONST: (params) => `\u5E94\u4E3A${params.expectedValue}`,
+  MIN_ITEMS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u81F3\u5C11\u9700\u8981${params.minimum}\u4E2A\u9879\u76EE`,
+  MAX_ITEMS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u6700\u591A\u53EA\u80FD\u6709${params.maximum}\u4E2A\u9879\u76EE`,
+  UNIQUE_ITEMS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u4E2D\u7684\u9879\u76EE\u5FC5\u987B\u552F\u4E00`,
+  CONTAINS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u81F3\u5C11\u8981\u5305\u542B\u4E00\u4E2A\u5339\u914D\u9879\u76EE`,
+  MIN_CONTAINS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u81F3\u5C11\u8981\u5305\u542B${params.minimum}\u4E2A\u5339\u914D\u9879\u76EE`,
+  MAX_CONTAINS: (params) => `${labelFor(params, "\u6570\u7EC4")}\u6700\u591A\u53EA\u80FD\u5305\u542B${params.maximum}\u4E2A\u5339\u914D\u9879\u76EE`,
+  MISSING_REQUIRED: (params) => `\u7F3A\u5C11\u5FC5\u586B\u5C5E\u6027"${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `\u5B58\u5728\u672A\u9884\u671F\u7684\u5C5E\u6027"${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `\u7D22\u5F15${params.count}\u5904\u5B58\u5728\u672A\u9884\u671F\u7684\u9879\u76EE`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "\u5BF9\u8C61")}\u81F3\u5C11\u9700\u8981${params.minimum}\u4E2A\u5C5E\u6027`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "\u5BF9\u8C61")}\u6700\u591A\u53EA\u80FD\u6709${params.maximum}\u4E2A\u5C5E\u6027`,
+  INVALID_KEY: (params) => `\u65E0\u6548\u7684\u8BB0\u5F55\u952E"${params.key}"`,
+  UNION: () => "\u503C\u4E0D\u7B26\u5408\u4EFB\u4F55\u8054\u5408\u5206\u652F",
+  ENUM: (params) => `\u503C\u5FC5\u987B\u662F\u4EE5\u4E0B\u4E4B\u4E00\uFF1A${formatList(params.values)}`,
+  UNRESOLVED_REF: () => "\u65E0\u6CD5\u89E3\u6790\u7684\u6A21\u5F0F\u5F15\u7528",
+  EXCLUDE: () => "\u503C\u5339\u914D\u4E86\u88AB\u6392\u9664\u7684\u6A21\u5F0F",
+  EXTRACT: () => "\u503C\u4E0D\u5339\u914D\u63D0\u53D6\u540E\u7684\u6A21\u5F0F",
+  NEVER: () => "\u4E0D\u5141\u8BB8\u8BE5\u503C",
+  NOT: () => "\u503C\u5339\u914D\u4E86\u5426\u5B9A\u6A21\u5F0F",
+  KEYOF: (params) => `\u503C\u5FC5\u987B\u662F\u4EE5\u4E0B\u4E4B\u4E00\uFF1A${formatList(params.values)}`,
+  CONDITIONAL: () => "\u503C\u4E0D\u5339\u914D\u4EFB\u4F55\u6761\u4EF6\u5206\u652F",
+  INDEX: () => "\u503C\u4E0D\u5339\u914D\u4EFB\u4F55\u7D22\u5F15\u6A21\u5F0F",
+  IDENTIFIER: () => "\u5FC5\u987B\u662F\u6709\u6548\u7684\u6807\u8BC6\u7B26\u5B57\u7B26\u4E32",
+  BASE: () => "\u57FA\u7840\u9A8C\u8BC1\u5931\u8D25",
+  REFINE: (params) => params.customMessage ?? "\u7EC6\u5316\u9A8C\u8BC1\u5931\u8D25",
+  CALL: () => "\u65E0\u6CD5\u5B9E\u4F8B\u5316\u8C03\u7528\u6A21\u5F0F",
+  PARAMETERS_LENGTH: (params) => `\u53C2\u6570\u6570\u91CF\u5FC5\u987B\u4E3A${params.count}`,
+  CUSTOM_TYPE: (params) => `\u81EA\u5B9A\u4E49\u7C7B\u578B"${params.kind}"\u9A8C\u8BC1\u5931\u8D25`
+};
+var zhHantCatalog = {
+  ...zhHansCatalog,
+  INVALID_TYPE: (params) => params.actual === undefined ? `\u61C9\u70BA${params.expected ?? "\u503C"}` : `\u61C9\u70BA${params.expected ?? "\u503C"}\uFF0C\u5BE6\u969B\u985E\u578B\u70BA${params.actual}`,
+  PATTERN: (params) => params.patterns !== undefined ? `${labelFor(params, "\u503C")}\u5FC5\u9808\u7B26\u5408\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00\uFF1A${formatList(params.patterns)}` : `${labelFor(params, "\u503C")}\u5FC5\u9808\u7B26\u5408\u6A21\u5F0F${params.pattern}`,
+  MISSING_REQUIRED: (params) => `\u7F3A\u5C11\u5FC5\u8981\u5C6C\u6027"${params.property}"`,
+  ADDITIONAL_PROPERTY: (params) => `\u5B58\u5728\u672A\u9810\u671F\u7684\u5C6C\u6027"${params.property}"`,
+  ADDITIONAL_ITEMS: (params) => `\u7D22\u5F15${params.count}\u8655\u5B58\u5728\u672A\u9810\u671F\u7684\u9805\u76EE`,
+  MIN_PROPERTIES: (params) => `${labelFor(params, "\u7269\u4EF6")}\u81F3\u5C11\u9700\u8981${params.minimum}\u500B\u5C6C\u6027`,
+  MAX_PROPERTIES: (params) => `${labelFor(params, "\u7269\u4EF6")}\u6700\u591A\u53EA\u80FD\u6709${params.maximum}\u500B\u5C6C\u6027`,
+  INVALID_KEY: (params) => `\u7121\u6548\u7684\u8A18\u9304\u9375"${params.key}"`,
+  UNRESOLVED_REF: () => "\u7121\u6CD5\u89E3\u6790\u7684\u7D50\u69CB\u53C3\u7167",
+  EXCLUDE: () => "\u503C\u7B26\u5408\u88AB\u6392\u9664\u7684\u7D50\u69CB",
+  EXTRACT: () => "\u503C\u4E0D\u7B26\u5408\u63D0\u53D6\u5F8C\u7684\u7D50\u69CB",
+  NEVER: () => "\u4E0D\u5141\u8A31\u6B64\u503C",
+  CONDITIONAL: () => "\u503C\u4E0D\u7B26\u5408\u4EFB\u4F55\u689D\u4EF6\u5206\u652F",
+  INDEX: () => "\u503C\u4E0D\u7B26\u5408\u4EFB\u4F55\u7D22\u5F15\u7D50\u69CB",
+  IDENTIFIER: () => "\u5FC5\u9808\u662F\u6709\u6548\u7684\u8B58\u5225\u5B57\u4E32",
+  BASE: () => "\u57FA\u790E\u9A57\u8B49\u5931\u6557",
+  REFINE: (params) => params.customMessage ?? "\u7D30\u5316\u9A57\u8B49\u5931\u6557",
+  CALL: () => "\u7121\u6CD5\u5BE6\u4F8B\u5316\u547C\u53EB\u7D50\u69CB",
+  PARAMETERS_LENGTH: (params) => `\u53C3\u6578\u6578\u91CF\u5FC5\u9808\u70BA${params.count}`,
+  CUSTOM_TYPE: (params) => `\u81EA\u8A02\u985E\u578B"${params.kind}"\u9A57\u8B49\u5931\u6557`
+};
+
+// src/shared/locale.ts
+var LocaleCodes = {
+  ar_001: "ar_001",
+  bn_BD: "bn_BD",
+  cs_CZ: "cs_CZ",
+  de_DE: "de_DE",
+  el_GR: "el_GR",
+  en_US: "en_US",
+  es_419: "es_419",
+  es_AR: "es_AR",
+  es_ES: "es_ES",
+  es_MX: "es_MX",
+  fa_IR: "fa_IR",
+  fil_PH: "fil_PH",
+  fr_CA: "fr_CA",
+  fr_FR: "fr_FR",
+  ha_NG: "ha_NG",
+  hi_IN: "hi_IN",
+  hu_HU: "hu_HU",
+  id_ID: "id_ID",
+  it_IT: "it_IT",
+  ja_JP: "ja_JP",
+  ko_KR: "ko_KR",
+  ms_MY: "ms_MY",
+  nl_NL: "nl_NL",
+  pl_PL: "pl_PL",
+  pt_BR: "pt_BR",
+  pt_PT: "pt_PT",
+  ro_RO: "ro_RO",
+  ru_RU: "ru_RU",
+  sv_SE: "sv_SE",
+  sw_TZ: "sw_TZ",
+  th_TH: "th_TH",
+  tr_TR: "tr_TR",
+  uk_UA: "uk_UA",
+  ur_PK: "ur_PK",
+  vi_VN: "vi_VN",
+  yo_NG: "yo_NG",
+  zh_Hans: "zh_Hans",
+  zh_Hant: "zh_Hant"
+};
+
+// src/locale/index.ts
+var ar_001 = enUSCatalog;
+var bn_BD = enUSCatalog;
+var cs_CZ = enUSCatalog;
+var de_DE = deDECatalog;
+var el_GR = enUSCatalog;
+var en_US = enUSCatalog;
+var es_419 = esESCatalog;
+var es_AR = esESCatalog;
+var es_ES = esESCatalog;
+var es_MX = esESCatalog;
+var fa_IR = enUSCatalog;
+var fil_PH = enUSCatalog;
+var fr_CA = frFRCatalog;
+var fr_FR = frFRCatalog;
+var ha_NG = enUSCatalog;
+var hi_IN = enUSCatalog;
+var hu_HU = enUSCatalog;
+var id_ID = enUSCatalog;
+var it_IT = enUSCatalog;
+var ja_JP = jaJPCatalog;
+var ko_KR = koKRCatalog;
+var ms_MY = enUSCatalog;
+var nl_NL = enUSCatalog;
+var pl_PL = enUSCatalog;
+var pt_BR = ptBRCatalog;
+var pt_PT = ptBRCatalog;
+var ro_RO = enUSCatalog;
+var ru_RU = enUSCatalog;
+var sv_SE = enUSCatalog;
+var sw_TZ = enUSCatalog;
+var th_TH = enUSCatalog;
+var tr_TR = enUSCatalog;
+var uk_UA = enUSCatalog;
+var ur_PK = enUSCatalog;
+var vi_VN = enUSCatalog;
+var yo_NG = enUSCatalog;
+var zh_Hans = zhHansCatalog;
+var zh_Hant = zhHantCatalog;
+var OfficialLocaleCatalogs = {
+  [LocaleCodes.ar_001]: ar_001,
+  [LocaleCodes.bn_BD]: bn_BD,
+  [LocaleCodes.cs_CZ]: cs_CZ,
+  [LocaleCodes.de_DE]: de_DE,
+  [LocaleCodes.el_GR]: el_GR,
+  [LocaleCodes.en_US]: en_US,
+  [LocaleCodes.es_419]: es_419,
+  [LocaleCodes.es_AR]: es_AR,
+  [LocaleCodes.es_ES]: es_ES,
+  [LocaleCodes.es_MX]: es_MX,
+  [LocaleCodes.fa_IR]: fa_IR,
+  [LocaleCodes.fil_PH]: fil_PH,
+  [LocaleCodes.fr_CA]: fr_CA,
+  [LocaleCodes.fr_FR]: fr_FR,
+  [LocaleCodes.ha_NG]: ha_NG,
+  [LocaleCodes.hi_IN]: hi_IN,
+  [LocaleCodes.hu_HU]: hu_HU,
+  [LocaleCodes.id_ID]: id_ID,
+  [LocaleCodes.it_IT]: it_IT,
+  [LocaleCodes.ja_JP]: ja_JP,
+  [LocaleCodes.ko_KR]: ko_KR,
+  [LocaleCodes.ms_MY]: ms_MY,
+  [LocaleCodes.nl_NL]: nl_NL,
+  [LocaleCodes.pl_PL]: pl_PL,
+  [LocaleCodes.pt_BR]: pt_BR,
+  [LocaleCodes.pt_PT]: pt_PT,
+  [LocaleCodes.ro_RO]: ro_RO,
+  [LocaleCodes.ru_RU]: ru_RU,
+  [LocaleCodes.sv_SE]: sv_SE,
+  [LocaleCodes.sw_TZ]: sw_TZ,
+  [LocaleCodes.th_TH]: th_TH,
+  [LocaleCodes.tr_TR]: tr_TR,
+  [LocaleCodes.uk_UA]: uk_UA,
+  [LocaleCodes.ur_PK]: ur_PK,
+  [LocaleCodes.vi_VN]: vi_VN,
+  [LocaleCodes.yo_NG]: yo_NG,
+  [LocaleCodes.zh_Hans]: zh_Hans,
+  [LocaleCodes.zh_Hant]: zh_Hant
+};
+function LocaleCatalogEntries() {
+  return Object.values(LocaleCodes).map((locale) => [locale, OfficialLocaleCatalogs[locale]]);
+}
+var LocalePacks = OfficialLocaleCatalogs;
+var locale_default = LocalePacks;
+
+// src/shared/object-utils.ts
+function deriveObjectSchema(object, options = {}) {
+  const pickSet = options.pickKeys ? new Set(options.pickKeys) : undefined;
+  const omitSet = options.omitKeys ? new Set(options.omitKeys) : undefined;
+  const originalOptional = new Set((object.optional ?? []).map(String));
+  const originalRequired = new Set((object.required ?? []).map(String));
+  const originalProperties = object.properties;
+  const properties = {};
+  for (const [key, schema] of Object.entries(originalProperties)) {
+    if (pickSet && !pickSet.has(key))
+      continue;
+    if (omitSet && omitSet.has(key))
+      continue;
+    properties[key] = schema;
+  }
+  const keys = Object.keys(properties);
+  const required = options.requiredMode === "all" ? keys : options.requiredMode === "none" ? [] : keys.filter((key) => originalRequired.has(key));
+  const optional = keys.filter((key) => originalOptional.has(key) && !required.includes(key));
+  return {
+    "~kind": "Object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    ...optional.length > 0 ? { optional } : {},
+    ...object.patternProperties !== undefined ? { patternProperties: object.patternProperties } : {},
+    ...options.additionalProperties !== undefined ? { additionalProperties: options.additionalProperties } : object.additionalProperties !== undefined ? { additionalProperties: object.additionalProperties } : {}
+  };
+}
+function getPatternPropertySchemas(patternProperties, key) {
+  if (!patternProperties)
+    return [];
+  const matches = [];
+  for (const [pattern, schema] of Object.entries(patternProperties)) {
+    if (new RegExp(pattern).test(key)) {
+      matches.push(schema);
+    }
+  }
+  return matches;
+}
+function deriveIndexSchemas(object, keySchema, checkFn) {
+  const candidates = [];
+  const properties = object.properties;
+  for (const [key, schema] of Object.entries(properties)) {
+    if (checkFn(keySchema, key)) {
+      candidates.push(schema);
+    }
+  }
+  return candidates;
+}
+function deriveIndexSchemasForEmission(object, keySchema) {
+  const candidates = [];
+  const properties = object.properties;
+  const keySchemaRecord = keySchema;
+  for (const [key, schema] of Object.entries(properties)) {
+    const keyValidationSchema = {
+      "~kind": "String",
+      ...typeof keySchemaRecord.format === "string" ? { format: keySchemaRecord.format } : {},
+      ...typeof keySchemaRecord.pattern === "string" ? { pattern: keySchemaRecord.pattern } : {}
+    };
+    if (keySchemaRecord["~kind"] === "String" ? stringMatchesKeySchema(keyValidationSchema, key) : true) {
+      candidates.push(schema);
+    }
+  }
+  return candidates;
+}
+function stringMatchesKeySchema(schema, value) {
+  return schema.pattern === undefined || new RegExp(schema.pattern).test(value);
+}
+function transformStringLiteralValue(kind, value) {
+  switch (kind) {
+    case "Capitalize":
+      return value.length === 0 ? value : value.charAt(0).toUpperCase() + value.slice(1);
+    case "Lowercase":
+      return value.toLowerCase();
+    case "Uppercase":
+      return value.toUpperCase();
+    case "Uncapitalize":
+      return value.length === 0 ? value : value.charAt(0).toLowerCase() + value.slice(1);
+    default:
+      return value;
+  }
+}
+function resolveStringActionSchema(schema) {
+  const value = schema;
+  const kind = value["~kind"];
+  if (kind !== "Capitalize" && kind !== "Lowercase" && kind !== "Uppercase" && kind !== "Uncapitalize") {
+    return schema;
+  }
+  const item = value["item"];
+  if (typeof item !== "object" || item === null) {
+    return schema;
+  }
+  const target = item;
+  const targetKind = target["~kind"];
+  if (targetKind === "Literal" && typeof target["const"] === "string") {
+    return { "~kind": "Literal", const: transformStringLiteralValue(String(kind), target["const"]) };
+  }
+  if (targetKind === "Enum" && Array.isArray(target["values"]) && target["values"].every((entry) => typeof entry === "string")) {
+    return {
+      "~kind": "Enum",
+      values: target["values"].map((entry) => transformStringLiteralValue(String(kind), entry))
+    };
+  }
+  return item;
+}
+// src/shared/runtime-guards.ts
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+function isIteratorLike(value) {
+  return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function" && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
+}
+function isAsyncIteratorLike(value) {
+  return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+// src/shared/format-constants.ts
+var EMAIL_RE = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+var URI_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+var HOSTNAME_RE = /^(?!-)[a-zA-Z0-9-]{0,63}(?<!-)(.(?!-)[a-zA-Z0-9-]{0,63}(?<!-))*$/;
+var IPV4_RE = /^(?:(?: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]?)$/;
+var IPV6_RE = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|^([0-9a-fA-F]{1,4}:){1,6}::$/;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ISO_DATE_RE = /^\d{4}-(0[1-9]|1[0-2])-([0-2]\d|3[01])$/;
+var ISO_DT_RE = /^\d{4}-(0[1-9]|1[0-2])-([0-2]\d|3[01])T([01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-][01]\d:[0-5]\d)$/;
+var ISO_TIME_RE = /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?$/;
+var ISO_DUR_RE = /^P(?:\d+Y)?(?:\d+M)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+S)?)?$/;
+var BASE64_RE = /^[a-zA-Z0-9+/]*={0,2}$/;
+var HEX_RE = /^[0-9a-fA-F]+$/;
+var HEXCLR_RE = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var LUHN_DIGITS_RE = /^\d{13,19}$/;
+var KNOWN_FORMATS = new Set([
+  "email",
+  "uri",
+  "hostname",
+  "ip",
+  "ipv4",
+  "ipv6",
+  "uuid",
+  "date",
+  "datetime",
+  "time",
+  "duration",
+  "base64",
+  "hex",
+  "hexcolor",
+  "creditcard",
+  "regex",
+  "uint8array",
+  "json"
+]);
+// src/shared/regex-json.ts
+function isAsciiDigit(value) {
+  return value >= "0" && value <= "9";
+}
+function consumeRegexQuantifier(pattern, start) {
+  let index = start;
+  const first = pattern[index];
+  if (first === undefined || !isAsciiDigit(first)) {
+    return -1;
+  }
+  while (index < pattern.length) {
+    const character = pattern[index];
+    if (character === undefined || !isAsciiDigit(character)) {
+      break;
+    }
+    index += 1;
+  }
+  if (pattern[index] === ",") {
+    index += 1;
+    while (index < pattern.length) {
+      const character = pattern[index];
+      if (character === undefined || !isAsciiDigit(character)) {
+        break;
+      }
+      index += 1;
+    }
+  }
+  return pattern[index] === "}" ? index : -1;
+}
+function isValidRegex(value) {
+  let escaped = false;
+  let inCharacterClass = false;
+  let groupDepth = 0;
+  let hasToken = false;
+  let groupPrefixAllowed = false;
+  for (let index = 0;index < value.length; index += 1) {
+    const character = value[index];
+    if (character === undefined)
+      return false;
+    if (escaped) {
+      escaped = false;
+      hasToken = true;
+      groupPrefixAllowed = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (inCharacterClass) {
+      if (character === "]") {
+        inCharacterClass = false;
+        hasToken = true;
+      }
+      continue;
+    }
+    if (groupPrefixAllowed && character === "?") {
+      groupPrefixAllowed = false;
+      continue;
+    }
+    groupPrefixAllowed = false;
+    switch (character) {
+      case "[":
+        inCharacterClass = true;
+        hasToken = true;
+        break;
+      case "(":
+        groupDepth += 1;
+        hasToken = false;
+        groupPrefixAllowed = true;
+        break;
+      case ")":
+        if (groupDepth === 0)
+          return false;
+        groupDepth -= 1;
+        hasToken = true;
+        break;
+      case "{": {
+        if (!hasToken)
+          return false;
+        const quantifierEnd = consumeRegexQuantifier(value, index + 1);
+        if (quantifierEnd < 0)
+          return false;
+        index = quantifierEnd;
+        hasToken = true;
+        break;
+      }
+      case "*":
+      case "+":
+      case "?":
+        if (!hasToken)
+          return false;
+        hasToken = true;
+        break;
+      case "]":
+      case "}":
+        return false;
+      case "|":
+        hasToken = false;
+        break;
+      default:
+        hasToken = true;
+        break;
+    }
+  }
+  return !escaped && !inCharacterClass && groupDepth === 0;
+}
+function skipWhitespace(state) {
+  while (state.index < state.text.length) {
+    const character = state.text[state.index];
+    if (character !== " " && character !== `
+` && character !== "\r" && character !== "\t") {
+      break;
+    }
+    state.index += 1;
+  }
+}
+function consumeLiteral(state, literal) {
+  if (state.text.slice(state.index, state.index + literal.length) !== literal) {
+    return false;
+  }
+  state.index += literal.length;
+  return true;
+}
+function parseString(state) {
+  if (state.text[state.index] !== '"')
+    return false;
+  state.index += 1;
+  while (state.index < state.text.length) {
+    const character = state.text[state.index];
+    if (character === undefined)
+      return false;
+    if (character === '"') {
+      state.index += 1;
+      return true;
+    }
+    if (character === "\\") {
+      const escape = state.text[state.index + 1];
+      if (escape === undefined)
+        return false;
+      if (escape === "u") {
+        for (let offset = 2;offset < 6; offset += 1) {
+          const hex = state.text[state.index + offset];
+          if (hex === undefined || !/[0-9a-fA-F]/.test(hex))
+            return false;
+        }
+        state.index += 6;
+        continue;
+      }
+      if (!'"\\/bfnrt'.includes(escape))
+        return false;
+      state.index += 2;
+      continue;
+    }
+    if (character < " ")
+      return false;
+    state.index += 1;
+  }
+  return false;
+}
+function parseNumber(state) {
+  const start = state.index;
+  if (state.text[state.index] === "-") {
+    state.index += 1;
+  }
+  const firstDigit = state.text[state.index];
+  if (firstDigit === undefined || !isAsciiDigit(firstDigit))
+    return false;
+  if (firstDigit === "0") {
+    state.index += 1;
+  } else {
+    while (state.index < state.text.length) {
+      const digit = state.text[state.index];
+      if (digit === undefined || !isAsciiDigit(digit))
+        break;
+      state.index += 1;
+    }
+  }
+  if (state.text[state.index] === ".") {
+    state.index += 1;
+    const fractionDigit = state.text[state.index];
+    if (fractionDigit === undefined || !isAsciiDigit(fractionDigit))
+      return false;
+    while (state.index < state.text.length) {
+      const digit = state.text[state.index];
+      if (digit === undefined || !isAsciiDigit(digit))
+        break;
+      state.index += 1;
+    }
+  }
+  const exponent = state.text[state.index];
+  if (exponent === "e" || exponent === "E") {
+    state.index += 1;
+    const sign = state.text[state.index];
+    if (sign === "+" || sign === "-")
+      state.index += 1;
+    const exponentDigit = state.text[state.index];
+    if (exponentDigit === undefined || !isAsciiDigit(exponentDigit))
+      return false;
+    while (state.index < state.text.length) {
+      const digit = state.text[state.index];
+      if (digit === undefined || !isAsciiDigit(digit))
+        break;
+      state.index += 1;
+    }
+  }
+  return state.index > start;
+}
+function parseArray(state) {
+  if (state.text[state.index] !== "[")
+    return false;
+  state.index += 1;
+  skipWhitespace(state);
+  if (state.text[state.index] === "]") {
+    state.index += 1;
+    return true;
+  }
+  while (state.index < state.text.length) {
+    if (!parseValue(state))
+      return false;
+    skipWhitespace(state);
+    const separator = state.text[state.index];
+    if (separator === ",") {
+      state.index += 1;
+      skipWhitespace(state);
+      continue;
+    }
+    if (separator === "]") {
+      state.index += 1;
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+function parseObject(state) {
+  if (state.text[state.index] !== "{")
+    return false;
+  state.index += 1;
+  skipWhitespace(state);
+  if (state.text[state.index] === "}") {
+    state.index += 1;
+    return true;
+  }
+  while (state.index < state.text.length) {
+    if (!parseString(state))
+      return false;
+    skipWhitespace(state);
+    if (state.text[state.index] !== ":")
+      return false;
+    state.index += 1;
+    if (!parseValue(state))
+      return false;
+    skipWhitespace(state);
+    const separator = state.text[state.index];
+    if (separator === ",") {
+      state.index += 1;
+      skipWhitespace(state);
+      continue;
+    }
+    if (separator === "}") {
+      state.index += 1;
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+function parseValue(state) {
+  skipWhitespace(state);
+  const character = state.text[state.index];
+  switch (character) {
+    case '"':
+      return parseString(state);
+    case "{":
+      return parseObject(state);
+    case "[":
+      return parseArray(state);
+    case "t":
+      return consumeLiteral(state, "true");
+    case "f":
+      return consumeLiteral(state, "false");
+    case "n":
+      return consumeLiteral(state, "null");
+    default:
+      return character === "-" || character !== undefined && isAsciiDigit(character) ? parseNumber(state) : false;
+  }
+}
+function isValidJson(value) {
+  const state = { index: 0, text: value };
+  if (!parseValue(state))
+    return false;
+  skipWhitespace(state);
+  return state.index === state.text.length;
+}
+
+// src/shared/runtime-context.ts
+var builtinLocaleCatalogEntries = LocaleCatalogEntries();
+var defaultTypePolicy = {
+  AllowNaN: false,
+  AllowArrayObject: false,
+  AllowNullVoid: true
+};
+var defaultSettings = {
+  correctiveParse: false
+};
+var runtimeContextCounter = 0;
+function cloneEntries(entries) {
+  return Array.from(entries, ([key, value]) => [key, value]);
+}
+
+class RuntimeContext {
+  id = ++runtimeContextCounter;
+  revision = 0;
+  activeLocale;
+  formatValidators = new Map;
+  localeCatalogs = new Map;
+  settings;
+  typeValidators = new Map;
+  typePolicy;
+  FormatRegistry = {
+    Clear: () => {
+      this.formatValidators.clear();
+      this.touch();
+    },
+    Delete: (name) => {
+      const deleted = this.formatValidators.delete(name);
+      if (deleted) {
+        this.touch();
+      }
+      return deleted;
+    },
+    Entries: () => Array.from(this.formatValidators.entries()),
+    Get: (name) => this.formatValidators.get(name),
+    Has: (name) => this.formatValidators.has(name),
+    Set: (name, validator) => {
+      this.formatValidators.set(name, validator);
+      this.touch();
+    }
+  };
+  Locale = {
+    ...LocaleCodes,
+    Entries: () => Array.from(this.localeCatalogs.entries()),
+    Get: () => this.activeLocale,
+    GetCatalog: (locale = this.activeLocale) => this.localeCatalogs.get(locale) ?? this.localeCatalogs.get(LocaleCodes.en_US) ?? enUSCatalog,
+    Has: (locale) => this.localeCatalogs.has(locale),
+    Register: (locale, catalog) => {
+      this.localeCatalogs.set(locale, catalog);
+      this.touch();
+    },
+    Reset: () => {
+      this.activeLocale = LocaleCodes.en_US;
+      this.touch();
+    },
+    Set: (locale) => {
+      this.activeLocale = locale;
+      this.touch();
+    }
+  };
+  Settings = {
+    Get: () => this.settings,
+    Reset: () => {
+      this.settings = { ...defaultSettings };
+      this.touch();
+    },
+    Set: (options) => {
+      this.settings = { ...this.settings, ...options };
+      this.touch();
+    }
+  };
+  TypeRegistry = {
+    Clear: () => {
+      this.typeValidators.clear();
+      this.touch();
+    },
+    Delete: (kind) => {
+      const deleted = this.typeValidators.delete(kind);
+      if (deleted) {
+        this.touch();
+      }
+      return deleted;
+    },
+    Entries: () => Array.from(this.typeValidators.entries()),
+    Get: (kind) => this.typeValidators.get(kind),
+    Has: (kind) => this.typeValidators.has(kind),
+    Set: (kind, validator) => {
+      this.typeValidators.set(kind, validator);
+      this.touch();
+    }
+  };
+  TypeSystemPolicy = {
+    Get: () => this.typePolicy,
+    Reset: () => {
+      this.typePolicy = { ...defaultTypePolicy };
+      this.touch();
+    },
+    Set: (options) => {
+      this.typePolicy = { ...this.typePolicy, ...options };
+      this.touch();
+    }
+  };
+  constructor(options = {}) {
+    this.activeLocale = options.locale ?? LocaleCodes.en_US;
+    this.settings = { ...defaultSettings, ...options.settings };
+    this.typePolicy = { ...defaultTypePolicy, ...options.typePolicy };
+    for (const [locale, catalog] of builtinLocaleCatalogEntries) {
+      this.localeCatalogs.set(locale, catalog);
+    }
+    for (const [locale, catalog] of options.localeCatalogs ?? []) {
+      this.localeCatalogs.set(locale, catalog);
+    }
+    for (const [name, validator] of options.formats ?? []) {
+      this.formatValidators.set(name, validator);
+    }
+    for (const [kind, validator] of options.types ?? []) {
+      this.typeValidators.set(kind, validator);
+    }
+  }
+  Clone(options = {}) {
+    return new RuntimeContext({
+      formats: [...cloneEntries(this.formatValidators.entries()), ...options.formats ?? []],
+      locale: options.locale ?? this.activeLocale,
+      localeCatalogs: [...cloneEntries(this.localeCatalogs.entries()), ...options.localeCatalogs ?? []],
+      settings: { ...this.settings, ...options.settings },
+      typePolicy: { ...this.typePolicy, ...options.typePolicy },
+      types: [...cloneEntries(this.typeValidators.entries()), ...options.types ?? []]
+    });
+  }
+  CacheKey(namespace = "runtime") {
+    return `${namespace}:${this.id}:${this.revision}`;
+  }
+  touch() {
+    this.revision += 1;
+  }
+}
+var defaultRuntimeContext = new RuntimeContext;
+function CreateRuntimeContext(options = {}) {
+  return new RuntimeContext(options);
+}
+function getDefaultRuntimeContext() {
+  return defaultRuntimeContext;
+}
+function resolveRuntimeContext(context) {
+  if (context instanceof RuntimeContext) {
+    return context;
+  }
+  return context?.context ?? defaultRuntimeContext;
+}
+
+// src/shared/format-validators.ts
+function luhnCheck(digits) {
+  if (!LUHN_DIGITS_RE.test(digits))
+    return false;
+  let sum = 0;
+  let alternate = false;
+  for (let index = digits.length - 1;index >= 0; index -= 1) {
+    let digit = Number.parseInt(digits.charAt(index), 10);
+    if (alternate) {
+      digit *= 2;
+      if (digit > 9)
+        digit -= 9;
+    }
+    sum += digit;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+function isValidISODate(value) {
+  const parts = value.split("-").map(Number);
+  const year = parts[0];
+  const month = parts[1];
+  const day = parts[2];
+  if (year === undefined || month === undefined || day === undefined)
+    return false;
+  const date = new globalThis.Date(year, month - 1, day);
+  return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day;
+}
+function validateFormat(value, format, context) {
+  const runtimeContext = resolveRuntimeContext(context);
+  const custom = runtimeContext.FormatRegistry.Get(format);
+  if (custom !== undefined)
+    return custom(value);
+  switch (format) {
+    case "email":
+      return EMAIL_RE.test(value);
+    case "uri":
+      return URI_RE.test(value);
+    case "ip":
+      return IPV4_RE.test(value) || IPV6_RE.test(value);
+    case "hostname":
+      return HOSTNAME_RE.test(value);
+    case "ipv4":
+      return IPV4_RE.test(value);
+    case "ipv6":
+      return IPV6_RE.test(value);
+    case "uuid":
+      return UUID_RE.test(value);
+    case "date":
+      return ISO_DATE_RE.test(value) && isValidISODate(value);
+    case "datetime":
+      return ISO_DT_RE.test(value);
+    case "time":
+      return ISO_TIME_RE.test(value);
+    case "duration":
+      return ISO_DUR_RE.test(value);
+    case "base64":
+      return BASE64_RE.test(value);
+    case "hex":
+      return HEX_RE.test(value);
+    case "hexcolor":
+      return HEXCLR_RE.test(value);
+    case "creditcard":
+      return luhnCheck(value.replace(/\D/g, ""));
+    case "regex":
+      return isValidRegex(value);
+    case "json":
+      return isValidJson(value);
+    case "uint8array":
+      return BASE64_RE.test(value);
+    default:
+      return true;
+  }
+}
+function checkStringConstraints(schema, value, context) {
+  if (schema.minLength !== undefined && value.length < schema.minLength)
+    return false;
+  if (schema.maxLength !== undefined && value.length > schema.maxLength)
+    return false;
+  if (schema.pattern !== undefined) {
+    const regex = new RegExp(schema.pattern);
+    if (!regex.test(value))
+      return false;
+  }
+  return schema.format === undefined || validateFormat(value, schema.format, context);
+}
+function checkNumberConstraints(schema, value) {
+  if (schema.minimum !== undefined && value < schema.minimum)
+    return false;
+  if (schema.maximum !== undefined && value > schema.maximum)
+    return false;
+  if (schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum)
+    return false;
+  if (schema.exclusiveMaximum !== undefined && value >= schema.exclusiveMaximum)
+    return false;
+  return schema.multipleOf === undefined || value % schema.multipleOf === 0;
+}
+// src/shared/registries.ts
+var FormatRegistry = {
+  Clear() {
+    getDefaultRuntimeContext().FormatRegistry.Clear();
+  },
+  Delete(name) {
+    return getDefaultRuntimeContext().FormatRegistry.Delete(name);
+  },
+  Entries() {
+    return getDefaultRuntimeContext().FormatRegistry.Entries();
+  },
+  Get(name) {
+    return getDefaultRuntimeContext().FormatRegistry.Get(name);
+  },
+  Has(name) {
+    return getDefaultRuntimeContext().FormatRegistry.Has(name);
+  },
+  Set(name, validator) {
+    getDefaultRuntimeContext().FormatRegistry.Set(name, validator);
+  }
+};
+var TypeRegistry = {
+  Clear() {
+    getDefaultRuntimeContext().TypeRegistry.Clear();
+  },
+  Delete(kind) {
+    return getDefaultRuntimeContext().TypeRegistry.Delete(kind);
+  },
+  Entries() {
+    return getDefaultRuntimeContext().TypeRegistry.Entries();
+  },
+  Get(kind) {
+    return getDefaultRuntimeContext().TypeRegistry.Get(kind);
+  },
+  Has(kind) {
+    return getDefaultRuntimeContext().TypeRegistry.Has(kind);
+  },
+  Set(kind, validator) {
+    getDefaultRuntimeContext().TypeRegistry.Set(kind, validator);
+  }
+};
+var TypeSystemPolicy = {
+  Get() {
+    return getDefaultRuntimeContext().TypeSystemPolicy.Get();
+  },
+  Reset() {
+    getDefaultRuntimeContext().TypeSystemPolicy.Reset();
+  },
+  Set(options) {
+    getDefaultRuntimeContext().TypeSystemPolicy.Set(options);
+  }
+};
+var Settings = {
+  Get() {
+    return getDefaultRuntimeContext().Settings.Get();
+  },
+  Reset() {
+    getDefaultRuntimeContext().Settings.Reset();
+  },
+  Set(options) {
+    getDefaultRuntimeContext().Settings.Set(options);
+  }
+};
+// src/shared/schema-access.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSchemaValue(value) {
+  return isRecord(value) && typeof value["~kind"] === "string";
+}
+function schemaNode(schema) {
+  return schema;
+}
+function schemaKind(schema) {
+  const kind = schemaNode(schema)["~kind"];
+  return typeof kind === "string" ? kind : undefined;
+}
+function schemaUnknownField(schema, field) {
+  return schemaNode(schema)[field];
+}
+function schemaStringField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return typeof value === "string" ? value : undefined;
+}
+function schemaNumberField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return typeof value === "number" ? value : undefined;
+}
+function schemaBigIntField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return typeof value === "bigint" ? value : undefined;
+}
+function schemaBooleanField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return typeof value === "boolean" ? value : undefined;
+}
+function schemaStringListField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : [];
+}
+function schemaSchemaField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return isSchemaValue(value) ? value : undefined;
+}
+function schemaSchemaListField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return Array.isArray(value) && value.every(isSchemaValue) ? value : [];
+}
+function schemaSchemaMapField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  if (!isRecord(value)) {
+    return {};
+  }
+  return Object.values(value).every(isSchemaValue) ? value : {};
+}
+function schemaBooleanOrSchemaField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  if (typeof value === "boolean" || value === undefined) {
+    return value;
+  }
+  return isSchemaValue(value) ? value : undefined;
+}
+function schemaCallbackField(schema, field) {
+  const value = schemaUnknownField(schema, field);
+  return typeof value === "function" ? value : undefined;
+}
+function schemaItem(schema) {
+  return schemaSchemaField(schema, "item");
+}
+function schemaInner(schema) {
+  return schemaSchemaField(schema, "inner");
+}
+function schemaItemOrInner(schema) {
+  return schemaItem(schema) ?? schemaInner(schema);
+}
+function schemaVariants(schema) {
+  return schemaSchemaListField(schema, "variants");
+}
+function schemaProperties(schema) {
+  return schemaSchemaMapField(schema, "properties");
+}
+function schemaDefinitions(schema) {
+  return schemaSchemaMapField(schema, "$defs");
+}
+function schemaPatternProperties(schema) {
+  return schemaSchemaMapField(schema, "patternProperties");
+}
+function schemaRequiredKeys(schema) {
+  return schemaStringListField(schema, "required");
+}
+function schemaOptionalKeys(schema) {
+  return schemaStringListField(schema, "optional");
+}
+function schemaConst(schema) {
+  return schemaUnknownField(schema, "const");
+}
+function schemaPatterns(schema) {
+  return schemaStringListField(schema, "patterns");
+}
+function schemaRefinements(schema) {
+  const value = schemaUnknownField(schema, "~refine");
+  return Array.isArray(value) ? value.filter((entry) => isRecord(entry) && typeof entry.refine === "function" && (entry.message === undefined || typeof entry.message === "string")) : [];
+}
+function schemaPath(path) {
+  return path.join(".") || "/";
+}
+
+// src/type/instantiation.ts
+function getString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function getSchema(value) {
+  if (typeof value !== "object" || value === null) {
+    return;
+  }
+  return typeof value["~kind"] === "string" ? value : undefined;
+}
+function getSchemaArray(value) {
+  return Array.isArray(value) ? value.flatMap((entry) => getSchema(entry) ? [entry] : []) : [];
+}
+function getParameterSchema(schema) {
+  const value = schema;
+  return {
+    name: getString(value["name"]) ?? "",
+    equals: getSchema(value["equals"]) ?? schema
+  };
+}
+function getInferSchema(schema) {
+  const value = schema;
+  return {
+    name: getString(value["name"]) ?? "",
+    extends: getSchema(value["extends"]) ?? schema
+  };
+}
+function getGenericSchema(schema) {
+  const value = schema;
+  const parameters = Array.isArray(value["parameters"]) ? value["parameters"].flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null)
+      return [];
+    const candidate = entry;
+    return candidate["~kind"] === "Parameter" ? [entry] : [];
+  }) : [];
+  return {
+    parameters,
+    expression: getSchema(value["expression"]) ?? schema
+  };
+}
+function getCallSchema(schema) {
+  const value = schema;
+  return {
+    target: getSchema(value["target"]) ?? schema,
+    arguments: getSchemaArray(value["arguments"])
+  };
+}
+function getCyclicSchema(schema) {
+  const value = schema;
+  const defsSource = value["$defs"];
+  const defs = typeof defsSource === "object" && defsSource !== null ? Object.fromEntries(Object.entries(defsSource).flatMap(([key, entry]) => {
+    const nextSchema = getSchema(entry);
+    return nextSchema ? [[key, nextSchema]] : [];
+  })) : {};
+  return {
+    $defs: defs,
+    $ref: getString(value["$ref"]) ?? ""
+  };
+}
+function bindParameterContext(parameters, arguments_) {
+  const context = {};
+  for (let index = 0;index < parameters.length; index += 1) {
+    const parameter = parameters[index];
+    const name = parameter.name;
+    const argument = arguments_[index] ?? parameter.equals;
+    context[name] = argument;
+  }
+  return context;
+}
+function getObjectSchema(schema) {
+  const value = schema;
+  const propertiesSource = value["properties"];
+  const patternPropertiesSource = value["patternProperties"];
+  const requiredSource = value["required"];
+  const optionalSource = value["optional"];
+  return {
+    ...schema,
+    "~kind": "Object",
+    properties: typeof propertiesSource === "object" && propertiesSource !== null ? propertiesSource : {},
+    ...typeof patternPropertiesSource === "object" && patternPropertiesSource !== null ? { patternProperties: patternPropertiesSource } : {},
+    ...Array.isArray(requiredSource) ? { required: requiredSource.filter((entry) => typeof entry === "string") } : {},
+    ...Array.isArray(optionalSource) ? { optional: optionalSource.filter((entry) => typeof entry === "string") } : {}
+  };
+}
+function instantiateObject(context, schema) {
+  const objectSchema = getObjectSchema(schema);
+  const properties = {};
+  for (const [key, value] of Object.entries(objectSchema.properties)) {
+    properties[key] = Instantiate(context, value);
+  }
+  const patternProperties = objectSchema.patternProperties === undefined ? undefined : Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => [key, Instantiate(context, value)]));
+  return {
+    ...objectSchema,
+    properties,
+    ...patternProperties !== undefined ? { patternProperties } : {},
+    ...typeof objectSchema.additionalProperties === "object" && objectSchema.additionalProperties !== null ? { additionalProperties: Instantiate(context, objectSchema.additionalProperties) } : {}
+  };
+}
+function Instantiate(context, schema) {
+  const value = schema;
+  const kind = value["~kind"];
+  switch (kind) {
+    case "Parameter": {
+      const parameter = getParameterSchema(schema);
+      return context[parameter.name] ?? parameter.equals;
+    }
+    case "Infer": {
+      const infer = getInferSchema(schema);
+      return context[infer.name] ?? infer.extends;
+    }
+    case "This":
+      return schema;
+    case "Ref": {
+      const name = value["name"];
+      return typeof name === "string" && context[name] !== undefined ? context[name] : schema;
+    }
+    case "Array":
+      return { ...schema, items: Instantiate(context, value["items"]) };
+    case "Object":
+      return instantiateObject(context, schema);
+    case "Tuple":
+      return { ...schema, items: value["items"].map((item) => Instantiate(context, item)) };
+    case "Record":
+      return {
+        ...schema,
+        key: Instantiate(context, value["key"]),
+        value: Instantiate(context, value["value"])
+      };
+    case "Union":
+    case "Intersect":
+      return { ...schema, variants: value["variants"].map((item) => Instantiate(context, item)) };
+    case "Optional":
+    case "Readonly":
+    case "Capitalize":
+    case "Lowercase":
+    case "Uppercase":
+    case "Uncapitalize":
+    case "Awaited":
+      return { ...schema, item: Instantiate(context, value["item"]) };
+    case "Immutable":
+    case "Refine":
+      return { ...schema, item: Instantiate(context, value["item"]) };
+    case "Codec":
+      return { ...schema, inner: Instantiate(context, value["inner"]) };
+    case "Exclude":
+    case "Extract":
+      return {
+        ...schema,
+        left: Instantiate(context, value["left"]),
+        right: Instantiate(context, value["right"])
+      };
+    case "Not":
+      return { ...schema, schema: Instantiate(context, value["schema"]) };
+    case "IfThenElse":
+      return {
+        ...schema,
+        if: Instantiate(context, value["if"]),
+        then: Instantiate(context, value["then"]),
+        else: Instantiate(context, value["else"])
+      };
+    case "Index":
+      return {
+        ...schema,
+        object: Instantiate(context, value["object"]),
+        key: Instantiate(context, value["key"])
+      };
+    case "Mapped":
+      return { ...schema, object: Instantiate(context, value["object"]) };
+    case "Conditional":
+      return {
+        ...schema,
+        check: Instantiate(context, value["check"]),
+        union: value["union"].map((item) => Instantiate(context, item)),
+        ...value["default"] !== undefined ? { default: Instantiate(context, value["default"]) } : {}
+      };
+    case "Function":
+    case "Constructor":
+      return {
+        ...schema,
+        parameters: value["parameters"].map((item) => Instantiate(context, item)),
+        returns: Instantiate(context, value["returns"])
+      };
+    case "Promise":
+    case "Iterator":
+    case "AsyncIterator":
+    case "Rest":
+      return { ...schema, item: Instantiate(context, value["item"]), items: Instantiate(context, value["items"] ?? value["item"]) };
+    case "Decode":
+      return { ...schema, inner: Instantiate(context, value["inner"]) };
+    case "Encode":
+      return { ...schema, inner: Instantiate(context, value["inner"]) };
+    case "ReturnType":
+    case "Parameters":
+      return { ...schema, function: Instantiate(context, value["function"]) };
+    case "InstanceType":
+    case "ConstructorParameters":
+      return { ...schema, constructor: Instantiate(context, value["constructor"]) };
+    case "Generic": {
+      const generic = getGenericSchema(schema);
+      return {
+        ...generic,
+        parameters: generic.parameters,
+        expression: Instantiate(context, generic.expression)
+      };
+    }
+    case "Call": {
+      const call = getCallSchema(schema);
+      const target = Instantiate(context, call.target);
+      const arguments_ = call.arguments.map((item) => Instantiate(context, item));
+      const targetValue = target;
+      if (targetValue["~kind"] === "Generic") {
+        const generic = getGenericSchema(target);
+        const nextContext = bindParameterContext(generic.parameters, arguments_);
+        return Instantiate({ ...context, ...nextContext }, generic.expression);
+      }
+      return {
+        "~kind": "Call",
+        target,
+        arguments: arguments_
+      };
+    }
+    case "Cyclic": {
+      const cyclic = getCyclicSchema(schema);
+      const defs = Object.fromEntries(Object.entries(cyclic.$defs).map(([key, value2]) => [key, Instantiate(context, value2)]));
+      return {
+        ...cyclic,
+        $defs: defs
+      };
+    }
+    default:
+      return schema;
+  }
+}
+
+// src/shared/bytes.ts
+import { dlopen, ptr } from "bun:ffi";
+var libcPath = process.platform === "darwin" ? "/usr/lib/libSystem.B.dylib" : process.platform === "linux" ? "libc.so.6" : process.platform === "win32" ? "msvcrt.dll" : "";
+var memcmp = libcPath === "" ? undefined : dlopen(libcPath, {
+  memcmp: {
+    args: ["ptr", "ptr", "usize"],
+    returns: "i32"
+  }
+}).symbols.memcmp;
+function encodeUint8ArrayBase64(value) {
+  return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("base64");
+}
+function decodeUint8ArrayBase64(value) {
+  const bunWithBase64 = Bun;
+  if (typeof bunWithBase64.base64ToBytes === "function") {
+    return bunWithBase64.base64ToBytes(value);
+  }
+  return new Uint8Array(Buffer.from(value, "base64"));
+}
+function getBase64DecodedByteLength(value) {
+  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+  return value.length / 4 * 3 - padding;
+}
+function areUint8ArraysEqual(left, right) {
+  if (left.byteLength !== right.byteLength) {
+    return false;
+  }
+  if (left.byteLength === 0) {
+    return true;
+  }
+  if (memcmp !== undefined) {
+    return memcmp(ptr(left), ptr(right), left.byteLength) === 0;
+  }
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isUint8ArrayWithinBounds(value, minByteLength, maxByteLength) {
+  if (minByteLength !== undefined && value.byteLength < minByteLength)
+    return false;
+  return maxByteLength === undefined || value.byteLength <= maxByteLength;
+}
+function isUint8ArrayBase64String(value, minByteLength, maxByteLength, constBytes, constBase64) {
+  if (typeof value !== "string" || !validateFormat(value, "base64")) {
+    return false;
+  }
+  if (!isUint8ArrayWithinBounds({ byteLength: getBase64DecodedByteLength(value) }, minByteLength, maxByteLength)) {
+    return false;
+  }
+  return constBytes === undefined ? true : value === (constBase64 ?? encodeUint8ArrayBase64(constBytes));
+}
+
+// src/value/check-collections-derived.ts
+function checkReferenceCollection(kind, schema, value, refs, check) {
+  switch (kind) {
+    case "Union":
+      return schemaVariants(schema).some((variant) => check(variant, value, refs));
+    case "Intersect":
+      return schemaVariants(schema).every((variant) => check(variant, value, refs));
+    case "Optional": {
+      const itemSchema = schemaItem(schema);
+      return value === undefined || (itemSchema ? check(itemSchema, value, refs) : false);
+    }
+    case "Readonly":
+    case "Immutable":
+    case "Codec": {
+      const inner = schemaItemOrInner(schema);
+      return inner ? check(inner, value, refs) : false;
+    }
+    case "Ref": {
+      const target = refs.get(schemaStringField(schema, "name") ?? "");
+      return target ? check(target, value, refs) : false;
+    }
+    case "Recursive": {
+      const name = schemaStringField(schema, "name");
+      const target = schemaSchemaField(schema, "schema");
+      if (!name || target === undefined)
+        return false;
+      const nextRefs = new Map(refs);
+      nextRefs.set(name, target);
+      nextRefs.set("#", target);
+      return check(target, value, nextRefs);
+    }
+    case "Cyclic": {
+      const defs = schemaDefinitions(schema);
+      const refName = schemaStringField(schema, "$ref");
+      const nextRefs = new Map(refs);
+      for (const [name, definition] of Object.entries(defs)) {
+        nextRefs.set(name, definition);
+      }
+      const target = refName ? defs[refName] : undefined;
+      return target ? check(target, value, nextRefs) : false;
+    }
+    case "Exclude": {
+      const left = schemaSchemaField(schema, "left");
+      const right = schemaSchemaField(schema, "right");
+      return left !== undefined && right !== undefined ? check(left, value, refs) && !check(right, value, refs) : false;
+    }
+    case "Extract": {
+      const left = schemaSchemaField(schema, "left");
+      const right = schemaSchemaField(schema, "right");
+      return left !== undefined && right !== undefined ? check(left, value, refs) && check(right, value, refs) : false;
+    }
+    default:
+      return;
+  }
+}
+function checkDerivedCollection(kind, schema, value, refs, check) {
+  switch (kind) {
+    case "Partial": {
+      const objectSchema = schemaSchemaField(schema, "object");
+      return objectSchema ? check(deriveObjectSchema(objectSchema, { requiredMode: "none" }), value, refs) : false;
+    }
+    case "Required": {
+      const objectSchema = schemaSchemaField(schema, "object");
+      return objectSchema ? check(deriveObjectSchema(objectSchema, { requiredMode: "all" }), value, refs) : false;
+    }
+    case "KeyOf": {
+      const objectSchema = schemaSchemaField(schema, "object");
+      return objectSchema ? typeof value === "string" && Object.keys(schemaProperties(objectSchema)).includes(value) : false;
+    }
+    case "Pick": {
+      const objectSchema = schemaSchemaField(schema, "object");
+      const keys = schemaUnknownField(schema, "keys");
+      return objectSchema && Array.isArray(keys) ? check(deriveObjectSchema(objectSchema, { pickKeys: keys.map(String), additionalProperties: false }), value, refs) : false;
+    }
+    case "Omit": {
+      const objectSchema = schemaSchemaField(schema, "object");
+      const keys = schemaUnknownField(schema, "keys");
+      return objectSchema && Array.isArray(keys) ? check(deriveObjectSchema(objectSchema, { omitKeys: keys.map(String), additionalProperties: false }), value, refs) : false;
+    }
+    case "Not": {
+      const target = schemaSchemaField(schema, "schema");
+      return target ? !check(target, value, refs) : false;
+    }
+    case "IfThenElse": {
+      const checkSchema = schemaSchemaField(schema, "if");
+      const thenSchema = schemaSchemaField(schema, "then");
+      const elseSchema = schemaSchemaField(schema, "else");
+      if (checkSchema === undefined || thenSchema === undefined || elseSchema === undefined)
+        return false;
+      return check(checkSchema, value, refs) ? check(thenSchema, value, refs) : check(elseSchema, value, refs);
+    }
+    case "Index": {
+      const objectSchema = schemaSchemaField(schema, "object");
+      const keySchema = schemaSchemaField(schema, "key");
+      if (objectSchema === undefined || keySchema === undefined)
+        return false;
+      const candidates = deriveIndexSchemas(objectSchema, keySchema, (candidate, candidateValue) => check(candidate, candidateValue, new Map));
+      return candidates.length > 0 && candidates.some((candidate) => check(candidate, value, refs));
+    }
+    case "Mapped": {
+      const objectSchema = schemaSchemaField(schema, "object");
+      if (objectSchema === undefined)
+        return false;
+      const transform = schemaCallbackField(schema, "transform");
+      if (!transform) {
+        return check(objectSchema, value, refs);
+      }
+      const transformed = {};
+      for (const [key, propertySchema] of Object.entries(schemaProperties(objectSchema))) {
+        transformed[key] = transform(propertySchema, key);
+      }
+      return check({ ...objectSchema, properties: transformed }, value, refs);
+    }
+    case "Conditional": {
+      const checkSchema = schemaSchemaField(schema, "check");
+      const union = schemaSchemaListField(schema, "union");
+      const defaultSchema = schemaSchemaField(schema, "default");
+      if (checkSchema === undefined)
+        return false;
+      if (check(checkSchema, value, refs)) {
+        return union.some((candidate) => check(candidate, value, refs));
+      }
+      return defaultSchema !== undefined ? check(defaultSchema, value, refs) : true;
+    }
+    case "Rest": {
+      const items = schemaSchemaField(schema, "items");
+      return Array.isArray(value) && items !== undefined && value.every((item) => check(items, item, refs));
+    }
+    case "Refine": {
+      if (schemaUnknownField(schema, "~uint8arrayCodec") === true) {
+        const constBytes = schemaUnknownField(schema, "constBytes");
+        return isUint8ArrayBase64String(value, schemaNumberField(schema, "minByteLength"), schemaNumberField(schema, "maxByteLength"), constBytes instanceof Uint8Array ? constBytes : undefined, schemaStringField(schema, "constBase64"));
+      }
+      const itemSchema = schemaItem(schema);
+      return itemSchema !== undefined && check(itemSchema, value, refs) && schemaRefinements(schema).every((entry) => entry.refine(value));
+    }
+    default:
+      return;
+  }
+}
+
+// src/value/check-collections.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function checkArrayCollection(schema, value, refs, check) {
+  if (!Array.isArray(value))
+    return false;
+  const itemSchema = schemaSchemaField(schema, "items");
+  const minItems = schemaNumberField(schema, "minItems");
+  const maxItems = schemaNumberField(schema, "maxItems");
+  const uniqueItems = schemaBooleanField(schema, "uniqueItems");
+  const containsSchema = schemaSchemaField(schema, "contains");
+  const minContains = schemaNumberField(schema, "minContains");
+  const maxContains = schemaNumberField(schema, "maxContains");
+  if (minItems !== undefined && value.length < minItems)
+    return false;
+  if (maxItems !== undefined && value.length > maxItems)
+    return false;
+  if (uniqueItems && new Set(value).size !== value.length)
+    return false;
+  if (containsSchema !== undefined) {
+    let containsCount = 0;
+    for (const item of value) {
+      if (check(containsSchema, item, refs))
+        containsCount += 1;
+    }
+    if (containsCount === 0)
+      return false;
+    if (minContains !== undefined && containsCount < minContains)
+      return false;
+    if (maxContains !== undefined && containsCount > maxContains)
+      return false;
+  }
+  return itemSchema ? value.every((item) => check(itemSchema, item, refs)) : false;
+}
+function checkObjectCollection(schema, value, refs, check) {
+  if (!isRecord2(value))
+    return false;
+  const properties = schemaProperties(schema);
+  const required = schemaRequiredKeys(schema);
+  const optional = new Set(schemaOptionalKeys(schema));
+  const patternProperties = schemaPatternProperties(schema);
+  const additionalProperties = schemaBooleanOrSchemaField(schema, "additionalProperties");
+  for (const key of required) {
+    if (!(key in value))
+      return false;
+    const propertySchema = properties[key];
+    if (propertySchema === undefined || !check(propertySchema, value[key], refs))
+      return false;
+  }
+  for (const [key, entryValue] of Object.entries(value)) {
+    const propertySchema = properties[key];
+    const matchedPatterns = getPatternPropertySchemas(patternProperties, key);
+    if (propertySchema !== undefined) {
+      if (entryValue === undefined && optional.has(key))
+        continue;
+      if (!check(propertySchema, entryValue, refs))
+        return false;
+    }
+    if (matchedPatterns.length > 0) {
+      if (!matchedPatterns.every((patternSchema) => check(patternSchema, entryValue, refs)))
+        return false;
+      continue;
+    }
+    if (propertySchema === undefined && additionalProperties === false)
+      return false;
+    if (propertySchema === undefined && typeof additionalProperties === "object") {
+      if (!check(additionalProperties, entryValue, refs))
+        return false;
+    }
+  }
+  return true;
+}
+function checkTupleCollection(schema, value, refs, check) {
+  if (!Array.isArray(value))
+    return false;
+  const items = schemaSchemaListField(schema, "items");
+  const minItems = schemaNumberField(schema, "minItems");
+  const maxItems = schemaNumberField(schema, "maxItems");
+  const additionalItems = schemaBooleanField(schema, "additionalItems");
+  if (minItems !== undefined && value.length < minItems)
+    return false;
+  if (maxItems !== undefined && value.length > maxItems)
+    return false;
+  if (value.length > items.length && additionalItems !== true)
+    return false;
+  return value.every((item, index) => {
+    const itemSchema = items[index];
+    return itemSchema ? check(itemSchema, item, refs) : true;
+  });
+}
+function checkRecordCollection(schema, value, refs, check) {
+  if (!isRecord2(value))
+    return false;
+  const keySchema = schemaSchemaField(schema, "key");
+  const valueSchema = schemaSchemaField(schema, "value");
+  const entries = Object.entries(value);
+  const minProperties = schemaNumberField(schema, "minProperties");
+  const maxProperties = schemaNumberField(schema, "maxProperties");
+  if (keySchema === undefined || valueSchema === undefined)
+    return false;
+  if (minProperties !== undefined && entries.length < minProperties)
+    return false;
+  if (maxProperties !== undefined && entries.length > maxProperties)
+    return false;
+  return entries.every(([entryKey, entryValue]) => check(keySchema, entryKey, refs) && check(valueSchema, entryValue, refs));
+}
+function checkCollectionKind(kind, schema, value, refs, check) {
+  switch (kind) {
+    case "Array":
+      return checkArrayCollection(schema, value, refs, check);
+    case "Object":
+      return checkObjectCollection(schema, value, refs, check);
+    case "Tuple":
+      return checkTupleCollection(schema, value, refs, check);
+    case "Record":
+      return checkRecordCollection(schema, value, refs, check);
+    default:
+      return checkReferenceCollection(kind, schema, value, refs, check) ?? checkDerivedCollection(kind, schema, value, refs, check);
+  }
+}
+
+// src/value/check-extensions.ts
+function checkExtensionKind(kind, schema, value, refs, check) {
+  switch (kind) {
+    case "Capitalize":
+    case "Lowercase":
+    case "Uppercase":
+    case "Uncapitalize":
+      return check(resolveStringActionSchema(schema), value, refs);
+    case "Parameter":
+      return check(schema.equals, value, refs);
+    case "This": {
+      const target = refs.get("#");
+      return target ? check(target, value, refs) : false;
+    }
+    case "Generic":
+      return check(schema.expression, value, refs);
+    case "Call": {
+      const instantiated = Instantiate({}, schema);
+      return instantiated === schema ? false : check(instantiated, value, refs);
+    }
+    case "Infer":
+      return check(schema.extends, value, refs);
+    case "Decode":
+    case "Encode":
+      return check(schema.inner, value, refs);
+    case "Awaited": {
+      const current = schema;
+      return check(current.promise.item, value, refs);
+    }
+    case "ReturnType": {
+      const current = schema;
+      return check(current.function.returns, value, refs);
+    }
+    case "Parameters": {
+      const current = schema;
+      if (!Array.isArray(value) || value.length !== current.function.parameters.length)
+        return false;
+      return value.every((item, index) => {
+        const parameterSchema = current.function.parameters[index];
+        return parameterSchema ? check(parameterSchema, item, refs) : false;
+      });
+    }
+    case "InstanceType": {
+      const current = schema;
+      return check(current.constructor.returns, value, refs);
+    }
+    case "ConstructorParameters": {
+      const current = schema;
+      if (!Array.isArray(value) || value.length !== current.constructor.parameters.length)
+        return false;
+      return value.every((item, index) => {
+        const parameterSchema = current.constructor.parameters[index];
+        return parameterSchema ? check(parameterSchema, item, refs) : false;
+      });
+    }
+    default:
+      return;
+  }
+}
+
+// src/value/check-primitives.ts
+function checkBigIntConstraints(schema, value) {
+  const minimum = schemaBigIntField(schema, "minimum");
+  const maximum = schemaBigIntField(schema, "maximum");
+  const exclusiveMinimum = schemaBigIntField(schema, "exclusiveMinimum");
+  const exclusiveMaximum = schemaBigIntField(schema, "exclusiveMaximum");
+  const multipleOf = schemaBigIntField(schema, "multipleOf");
+  if (minimum !== undefined && value < minimum)
+    return false;
+  if (maximum !== undefined && value > maximum)
+    return false;
+  if (exclusiveMinimum !== undefined && value <= exclusiveMinimum)
+    return false;
+  if (exclusiveMaximum !== undefined && value >= exclusiveMaximum)
+    return false;
+  if (multipleOf !== undefined && value % multipleOf !== 0n)
+    return false;
+  return true;
+}
+function checkDateConstraints(schema, value) {
+  if (Number.isNaN(value.getTime()))
+    return false;
+  const minimum = schemaNumberField(schema, "minimumTimestamp");
+  const maximum = schemaNumberField(schema, "maximumTimestamp");
+  const exclusiveMinimum = schemaNumberField(schema, "exclusiveMinimumTimestamp");
+  const exclusiveMaximum = schemaNumberField(schema, "exclusiveMaximumTimestamp");
+  const timestamp = value.getTime();
+  if (minimum !== undefined && timestamp < minimum)
+    return false;
+  if (maximum !== undefined && timestamp > maximum)
+    return false;
+  if (exclusiveMinimum !== undefined && timestamp <= exclusiveMinimum)
+    return false;
+  if (exclusiveMaximum !== undefined && timestamp >= exclusiveMaximum)
+    return false;
+  return true;
+}
+function checkUint8ArrayConstraints(schema, value) {
+  const minByteLength = schemaNumberField(schema, "minByteLength");
+  const maxByteLength = schemaNumberField(schema, "maxByteLength");
+  const constBytes = schemaConst(schema);
+  const expectedBytes = constBytes instanceof Uint8Array ? constBytes : undefined;
+  if (!isUint8ArrayWithinBounds(value, minByteLength, maxByteLength))
+    return false;
+  return expectedBytes === undefined || areUint8ArraysEqual(value, expectedBytes);
+}
+function checkPrimitiveKind(kind, schema, value, context) {
+  const runtimeContext = resolveRuntimeContext(context);
+  switch (kind) {
+    case "String":
+      return typeof value === "string" && checkStringConstraints(schema, value, runtimeContext);
+    case "Number": {
+      const policy = runtimeContext.TypeSystemPolicy.Get();
+      return typeof value === "number" && (policy.AllowNaN || Number.isFinite(value)) && checkNumberConstraints(schema, value);
+    }
+    case "Integer":
+      return typeof value === "number" && Number.isInteger(value) && checkNumberConstraints(schema, value);
+    case "Boolean":
+      return typeof value === "boolean";
+    case "Null":
+      return value === null;
+    case "Literal":
+      return value === schemaConst(schema);
+    case "BigInt": {
+      if (typeof value !== "bigint")
+        return false;
+      return checkBigIntConstraints(schema, value);
+    }
+    case "Date": {
+      if (!(value instanceof globalThis.Date))
+        return false;
+      return checkDateConstraints(schema, value);
+    }
+    case "Void":
+      return value === undefined || value === null;
+    case "Undefined":
+      return value === undefined;
+    case "Unknown":
+    case "Any":
+    case "Unsafe":
+      return true;
+    case "Never":
+      return false;
+    case "Enum":
+      return schemaStringListField(schema, "values").includes(String(value));
+    case "Identifier":
+      return typeof value === "string" && /^[$A-Z_a-z][$\w]*$/.test(value);
+    case "TemplateLiteral": {
+      if (typeof value !== "string")
+        return false;
+      return new RegExp(schemaPatterns(schema).join("|")).test(value);
+    }
+    case "Uint8Array": {
+      if (!(value instanceof globalThis.Uint8Array))
+        return false;
+      return checkUint8ArrayConstraints(schema, value);
+    }
+    case "RegExpInstance":
+      return value instanceof globalThis.RegExp;
+    case "Promise":
+      return isPromiseLike(value);
+    case "Iterator":
+      return isIteratorLike(value);
+    case "AsyncIterator":
+      return isAsyncIteratorLike(value);
+    case "Function":
+      return typeof value === "function";
+    case "Constructor":
+      return typeof value === "function" && "prototype" in value;
+    case "Symbol":
+      return typeof value === "symbol";
+    case "Base": {
+      const check = schemaCallbackField(schema, "Check");
+      return check ? check(value) : true;
+    }
+    default:
+      return;
+  }
+}
+
+// src/value/check.ts
+function resolveCheckContext(context) {
+  return resolveRuntimeContext(context);
+}
+function Check(schema, value, options) {
+  return CheckInternal(schema, value, new Map, resolveCheckContext(options));
+}
+function CheckInternal(schema, value, refs, context) {
+  const runtimeContext = resolveCheckContext(context);
+  const kind = schema["~kind"];
+  const primitiveResult = checkPrimitiveKind(kind, schema, value, runtimeContext);
+  if (primitiveResult !== undefined) {
+    return primitiveResult;
+  }
+  const collectionResult = checkCollectionKind(kind, schema, value, refs, (nextSchema, nextValue, nextRefs) => CheckInternal(nextSchema, nextValue, nextRefs, runtimeContext));
+  if (collectionResult !== undefined) {
+    return collectionResult;
+  }
+  const extensionResult = checkExtensionKind(kind, schema, value, refs, (nextSchema, nextValue, nextRefs) => CheckInternal(nextSchema, nextValue, nextRefs, runtimeContext));
+  if (extensionResult !== undefined) {
+    return extensionResult;
+  }
+  const customValidator = runtimeContext.TypeRegistry.Get(kind ?? "");
+  return customValidator ? customValidator(schema, value) : false;
+}
+
+// src/error/messages.ts
+function createSchemaIssue(path, code, params = {}) {
+  return { path, code, params };
+}
+function localizeSchemaIssueWithCatalog(issue, catalog, locale) {
+  return {
+    ...issue,
+    locale,
+    message: catalog[issue.code](issue.params ?? {})
+  };
+}
+
+// src/error/collector/advanced.ts
+function unresolvedRefIssue(path) {
+  return [createSchemaIssue(schemaPath(path), "UNRESOLVED_REF")];
+}
+function collectDelegatedIssues(kind, schema, value, path, refs, collectSchemaIssues) {
+  switch (kind) {
+    case "Optional":
+      return value === undefined ? [] : collectSchemaIssues(schema.item, value, path, refs);
+    case "Readonly":
+    case "Immutable":
+      return collectSchemaIssues(schema.item, value, path, refs);
+    case "Codec":
+      return collectSchemaIssues(schema.inner, value, path, refs);
+    case "Decode":
+      return collectSchemaIssues(schema.inner, value, path, refs);
+    case "Encode":
+      return collectSchemaIssues(schema.inner, value, path, refs);
+    case "Awaited":
+      return collectSchemaIssues(schema.promise.item, value, path, refs);
+    case "ReturnType":
+      return collectSchemaIssues(schema.function.returns, value, path, refs);
+    case "InstanceType":
+      return collectSchemaIssues(schema.constructor.returns, value, path, refs);
+    case "Capitalize":
+    case "Lowercase":
+    case "Uppercase":
+    case "Uncapitalize":
+      return collectSchemaIssues(resolveStringActionSchema(schema), value, path, refs);
+    case "Parameter":
+      return collectSchemaIssues(schema.equals, value, path, refs);
+    case "Generic":
+      return collectSchemaIssues(schema.expression, value, path, refs);
+    case "Infer":
+      return collectSchemaIssues(schema.extends, value, path, refs);
+    default:
+      return;
+  }
+}
+function collectReferenceIssues(kind, schema, value, path, refs, collectSchemaIssues) {
+  switch (kind) {
+    case "Recursive": {
+      const recursiveSchema = schema;
+      const nextRefs = new Map(refs);
+      nextRefs.set(recursiveSchema.name, recursiveSchema.schema);
+      nextRefs.set("#", recursiveSchema.schema);
+      return collectSchemaIssues(recursiveSchema.schema, value, path, nextRefs);
+    }
+    case "Ref": {
+      const target = refs.get(schema.name);
+      return target === undefined ? unresolvedRefIssue(path) : collectSchemaIssues(target, value, path, refs);
+    }
+    case "This": {
+      const target = refs.get("#");
+      return target === undefined ? unresolvedRefIssue(path) : collectSchemaIssues(target, value, path, refs);
+    }
+    case "Call": {
+      const instantiated = Instantiate({}, schema);
+      return instantiated === schema ? [createSchemaIssue(schemaPath(path), "CALL")] : collectSchemaIssues(instantiated, value, path, refs);
+    }
+    case "Cyclic": {
+      const cyclicSchema = schema;
+      const nextRefs = new Map(refs);
+      Object.entries(cyclicSchema.$defs).forEach(([name, definition]) => {
+        nextRefs.set(name, definition);
+      });
+      const target = cyclicSchema.$defs[cyclicSchema.$ref];
+      return target === undefined ? [] : collectSchemaIssues(target, value, path, nextRefs);
+    }
+    default:
+      return;
+  }
+}
+function collectBranchIssues(kind, schema, value, path, refs, collectSchemaIssues) {
+  const currentPath = schemaPath(path);
+  switch (kind) {
+    case "Exclude": {
+      const excludeSchema = schema;
+      if (!CheckInternal(excludeSchema.left, value, refs)) {
+        return collectSchemaIssues(excludeSchema.left, value, path, refs);
+      }
+      return CheckInternal(excludeSchema.right, value, refs) ? [createSchemaIssue(currentPath, "EXCLUDE")] : [];
+    }
+    case "Extract": {
+      const extractSchema = schema;
+      if (!CheckInternal(extractSchema.left, value, refs)) {
+        return collectSchemaIssues(extractSchema.left, value, path, refs);
+      }
+      return CheckInternal(extractSchema.right, value, refs) ? [] : [createSchemaIssue(currentPath, "EXTRACT")];
+    }
+    case "Not":
+      return CheckInternal(schema.schema, value, refs) ? [createSchemaIssue(currentPath, "NOT")] : [];
+    case "IfThenElse": {
+      const conditionalSchema = schema;
+      return collectSchemaIssues(CheckInternal(conditionalSchema.if, value, refs) ? conditionalSchema.then : conditionalSchema.else, value, path, refs);
+    }
+    case "Conditional": {
+      const conditionalSchema = schema;
+      if (CheckInternal(conditionalSchema.check, value, refs)) {
+        const variantIssues = conditionalSchema.union.map((entry) => collectSchemaIssues(entry, value, path, refs));
+        return variantIssues.some((entry) => entry.length === 0) ? [] : [createSchemaIssue(currentPath, "CONDITIONAL")];
+      }
+      return conditionalSchema.default === undefined ? [] : collectSchemaIssues(conditionalSchema.default, value, path, refs);
+    }
+    case "Refine": {
+      const refineSchema = schema;
+      const nestedIssues = collectSchemaIssues(refineSchema.item, value, path, refs);
+      if (nestedIssues.length > 0) {
+        return nestedIssues;
+      }
+      const issues = [];
+      refineSchema["~refine"].forEach((refinement) => {
+        if (!refinement.refine(value)) {
+          issues.push(createSchemaIssue(currentPath, "REFINE", { customMessage: refinement.message }));
+        }
+      });
+      return issues;
+    }
+    default:
+      return;
+  }
+}
+function collectAdvancedIssues(kind, schema, value, path, refs, collectSchemaIssues) {
+  return collectDelegatedIssues(kind, schema, value, path, refs, collectSchemaIssues) ?? collectReferenceIssues(kind, schema, value, path, refs, collectSchemaIssues) ?? collectBranchIssues(kind, schema, value, path, refs, collectSchemaIssues) ?? (() => {
+    const customValidator = TypeRegistry.Get(kind ?? "");
+    return customValidator !== undefined && !customValidator(schema, value) ? [createSchemaIssue(schemaPath(path), "CUSTOM_TYPE", { kind: kind ?? "" })] : [];
+  })();
+}
+
+// src/error/collector/shared.ts
+function appendPath(path, segment) {
+  return [...path, segment];
+}
+
+// src/error/collector/collections-basic.ts
+function collectArrayIssues(schema, value, path, refs, collectSchemaIssues) {
+  const issues = [];
+  const currentPath = schemaPath(path);
+  if (!Array.isArray(value)) {
+    issues.push(createSchemaIssue(currentPath, "INVALID_TYPE", { expected: "array" }));
+    return issues;
+  }
+  if (schema.minItems !== undefined && value.length < schema.minItems) {
+    issues.push(createSchemaIssue(currentPath, "MIN_ITEMS", { minimum: schema.minItems }));
+  }
+  if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+    issues.push(createSchemaIssue(currentPath, "MAX_ITEMS", { maximum: schema.maxItems }));
+  }
+  if (schema.uniqueItems && new Set(value).size !== value.length) {
+    issues.push(createSchemaIssue(currentPath, "UNIQUE_ITEMS"));
+  }
+  if (schema.contains !== undefined) {
+    let containsCount = 0;
+    value.forEach((item) => {
+      if (CheckInternal(schema.contains, item, refs)) {
+        containsCount += 1;
+      }
+    });
+    if (containsCount === 0) {
+      issues.push(createSchemaIssue(currentPath, "CONTAINS"));
+    }
+    if (schema.minContains !== undefined && containsCount < schema.minContains) {
+      issues.push(createSchemaIssue(currentPath, "MIN_CONTAINS", { minimum: schema.minContains }));
+    }
+    if (schema.maxContains !== undefined && containsCount > schema.maxContains) {
+      issues.push(createSchemaIssue(currentPath, "MAX_CONTAINS", { maximum: schema.maxContains }));
+    }
+  }
+  value.forEach((item, index) => {
+    issues.push(...collectSchemaIssues(schema.items, item, appendPath(path, String(index)), refs));
+  });
+  return issues;
+}
+function collectObjectIssues(schema, value, path, refs, collectSchemaIssues) {
+  const issues = [];
+  const currentPath = schemaPath(path);
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    issues.push(createSchemaIssue(currentPath, "INVALID_TYPE", { expected: "object" }));
+    return issues;
+  }
+  const objectValue = value;
+  const required = schema.required ?? [];
+  const optional = new Set((schema.optional ?? []).map(String));
+  for (const key of required) {
+    if (!(key in objectValue)) {
+      issues.push(createSchemaIssue(schemaPath(appendPath(path, String(key))), "MISSING_REQUIRED", { property: String(key) }));
+    }
+  }
+  for (const [key, entryValue] of Object.entries(objectValue)) {
+    const entryPath = appendPath(path, key);
+    const patternSchemas = getPatternPropertySchemas(schema.patternProperties, key);
+    if (schema.properties[key] !== undefined) {
+      if (!(entryValue === undefined && optional.has(key))) {
+        issues.push(...collectSchemaIssues(schema.properties[key], entryValue, entryPath, refs));
+      }
+    }
+    if (patternSchemas.length > 0) {
+      for (const patternSchema of patternSchemas) {
+        issues.push(...collectSchemaIssues(patternSchema, entryValue, entryPath, refs));
+      }
+    } else if (schema.properties[key] === undefined && schema.additionalProperties === false) {
+      issues.push(createSchemaIssue(schemaPath(entryPath), "ADDITIONAL_PROPERTY", { property: key }));
+    } else if (schema.properties[key] === undefined && typeof schema.additionalProperties === "object") {
+      issues.push(...collectSchemaIssues(schema.additionalProperties, entryValue, entryPath, refs));
+    }
+  }
+  return issues;
+}
+function collectTupleIssues(schema, value, path, refs, collectSchemaIssues) {
+  const issues = [];
+  const currentPath = schemaPath(path);
+  if (!Array.isArray(value)) {
+    issues.push(createSchemaIssue(currentPath, "INVALID_TYPE", { expected: "array" }));
+    return issues;
+  }
+  if (schema.minItems !== undefined && value.length < schema.minItems) {
+    issues.push(createSchemaIssue(currentPath, "MIN_ITEMS", { label: "Tuple", minimum: schema.minItems }));
+  }
+  if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+    issues.push(createSchemaIssue(currentPath, "MAX_ITEMS", { label: "Tuple", maximum: schema.maxItems }));
+  }
+  value.forEach((item, index) => {
+    const itemSchema = schema.items[index];
+    if (itemSchema !== undefined) {
+      issues.push(...collectSchemaIssues(itemSchema, item, appendPath(path, String(index)), refs));
+    } else if (!schema.additionalItems) {
+      issues.push(createSchemaIssue(schemaPath(appendPath(path, String(index))), "ADDITIONAL_ITEMS", { count: index }));
+    }
+  });
+  return issues;
+}
+function collectRecordIssues(schema, value, path, refs, collectSchemaIssues) {
+  const issues = [];
+  const currentPath = schemaPath(path);
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    issues.push(createSchemaIssue(currentPath, "INVALID_TYPE", { expected: "object" }));
+    return issues;
+  }
+  const entries = Object.entries(value);
+  if (schema.minProperties !== undefined && entries.length < schema.minProperties) {
+    issues.push(createSchemaIssue(currentPath, "MIN_PROPERTIES", { minimum: schema.minProperties }));
+  }
+  if (schema.maxProperties !== undefined && entries.length > schema.maxProperties) {
+    issues.push(createSchemaIssue(currentPath, "MAX_PROPERTIES", { maximum: schema.maxProperties }));
+  }
+  entries.forEach(([key, entryValue]) => {
+    if (!CheckInternal(schema.key, key, refs)) {
+      issues.push(createSchemaIssue(schemaPath(appendPath(path, key)), "INVALID_KEY", { key }));
+    }
+    issues.push(...collectSchemaIssues(schema.value, entryValue, appendPath(path, key), refs));
+  });
+  return issues;
+}
+function collectBasicCollectionIssues(kind, schema, value, path, refs, collectSchemaIssues) {
+  switch (kind) {
+    case "Array":
+      return collectArrayIssues(schema, value, path, refs, collectSchemaIssues);
+    case "Object":
+      return collectObjectIssues(schema, value, path, refs, collectSchemaIssues);
+    case "Tuple":
+      return collectTupleIssues(schema, value, path, refs, collectSchemaIssues);
+    case "Record":
+      return collectRecordIssues(schema, value, path, refs, collectSchemaIssues);
+    default:
+      return;
+  }
+}
+
+// src/error/collector/collections-derived.ts
+function collectDerivedCollectionIssues(kind, schema, value, path, refs, collectSchemaIssues) {
+  const currentPath = schemaPath(path);
+  switch (kind) {
+    case "Union": {
+      const unionSchema = schema;
+      const variantIssues = unionSchema.variants.map((variant) => collectSchemaIssues(variant, value, path, refs));
+      return variantIssues.some((entry) => entry.length === 0) ? [] : [createSchemaIssue(currentPath, "UNION")];
+    }
+    case "Intersect": {
+      const intersectSchema = schema;
+      const issues = [];
+      intersectSchema.variants.forEach((variant) => {
+        issues.push(...collectSchemaIssues(variant, value, path, refs));
+      });
+      return issues;
+    }
+    case "Partial":
+      return collectSchemaIssues(deriveObjectSchema(schema.object, { requiredMode: "none" }), value, path, refs);
+    case "Required":
+      return collectSchemaIssues(deriveObjectSchema(schema.object, { requiredMode: "all" }), value, path, refs);
+    case "KeyOf": {
+      const keyOfSchema = schema;
+      const keys = Object.keys(keyOfSchema.object.properties);
+      if (typeof value !== "string") {
+        return [createSchemaIssue(currentPath, "INVALID_TYPE", { expected: "string", actual: typeof value })];
+      }
+      return keys.includes(value) ? [] : [createSchemaIssue(currentPath, "KEYOF", { values: keys })];
+    }
+    case "Pick": {
+      const pickSchema = schema;
+      return collectSchemaIssues(deriveObjectSchema(pickSchema.object, { pickKeys: pickSchema.keys, additionalProperties: false }), value, path, refs);
+    }
+    case "Omit": {
+      const omitSchema = schema;
+      return collectSchemaIssues(deriveObjectSchema(omitSchema.object, { omitKeys: omitSchema.keys, additionalProperties: false }), value, path, refs);
+    }
+    case "Index": {
+      const indexSchema = schema;
+      const candidates = deriveIndexSchemas(indexSchema.object, indexSchema.key, (candidateSchema, candidateValue) => CheckInternal(candidateSchema, candidateValue, new Map));
+      if (candidates.length === 0) {
+        return [createSchemaIssue(currentPath, "INDEX")];
+      }
+      const candidateIssues = candidates.map((candidate) => collectSchemaIssues(candidate, value, path, refs));
+      return candidateIssues.some((entry) => entry.length === 0) ? [] : [createSchemaIssue(currentPath, "INDEX")];
+    }
+    case "Mapped":
+      return collectSchemaIssues(schema.object, value, path, refs);
+    default:
+      return;
+  }
+}
+
+// src/error/collector/collections-parameters.ts
+function collectTupleParameterIssues(parameters, value, path, refs, collectSchemaIssues) {
+  const currentPath = schemaPath(path);
+  if (!Array.isArray(value)) {
+    return [createSchemaIssue(currentPath, "INVALID_TYPE", { expected: "array" })];
+  }
+  const issues = [];
+  if (value.length !== parameters.length) {
+    issues.push(createSchemaIssue(currentPath, "PARAMETERS_LENGTH", { count: parameters.length }));
+  }
+  value.forEach((item, index) => {
+    const parameter = parameters[index];
+    if (parameter !== undefined) {
+      issues.push(...collectSchemaIssues(parameter, item, appendPath(path, String(index)), refs));
+    }
+  });
+  return issues;
+}
+function collectParameterCollectionIssues(kind, schema, value, path, refs, collectSchemaIssues) {
+  switch (kind) {
+    case "Rest": {
+      const currentPath = schemaPath(path);
+      if (!Array.isArray(value)) {
+        return [createSchemaIssue(currentPath, "INVALID_TYPE", { expected: "array" })];
+      }
+      const restSchema = schema;
+      const issues = [];
+      value.forEach((item, index) => {
+        issues.push(...collectSchemaIssues(restSchema.items, item, appendPath(path, String(index)), refs));
+      });
+      return issues;
+    }
+    case "Parameters":
+      return collectTupleParameterIssues(schema.function.parameters, value, path, refs, collectSchemaIssues);
+    case "ConstructorParameters":
+      return collectTupleParameterIssues(schema.constructor.parameters, value, path, refs, collectSchemaIssues);
+    default:
+      return;
+  }
+}
+
+// src/error/collector/collections.ts
+function collectCollectionIssues(kind, schema, value, path, refs, collectSchemaIssues) {
+  const basicIssues = collectBasicCollectionIssues(kind, schema, value, path, refs, collectSchemaIssues);
+  if (basicIssues !== undefined) {
+    return basicIssues;
+  }
+  const derivedIssues = collectDerivedCollectionIssues(kind, schema, value, path, refs, collectSchemaIssues);
+  if (derivedIssues !== undefined) {
+    return derivedIssues;
+  }
+  return collectParameterCollectionIssues(kind, schema, value, path, refs, collectSchemaIssues);
+}
+
+// src/type/combinator-core.ts
+function Union(variants, options) {
+  return { "~kind": "Union", variants, ...options };
+}
+function Intersect(variants, options) {
+  return { "~kind": "Intersect", variants, ...options };
+}
+function Evaluate(schema) {
+  if (schema["~kind"] === "Object") {
+    return schema;
+  }
+  const properties = {};
+  const required = new Set;
+  const optional = new Set;
+  const patternProperties = {};
+  let additionalProperties;
+  for (const variant of schema.variants) {
+    Object.assign(properties, variant.properties);
+    for (const key of variant.required ?? [])
+      required.add(String(key));
+    for (const key of variant.optional ?? [])
+      optional.add(String(key));
+    Object.assign(patternProperties, variant.patternProperties);
+    if (variant.additionalProperties === false) {
+      additionalProperties = false;
+    } else if (additionalProperties !== false && variant.additionalProperties !== undefined) {
+      additionalProperties = variant.additionalProperties;
+    }
+  }
+  for (const key of optional) {
+    required.delete(key);
+  }
+  return {
+    "~kind": "Object",
+    properties,
+    ...required.size > 0 ? { required: [...required] } : {},
+    ...optional.size > 0 ? { optional: [...optional] } : {},
+    ...Object.keys(patternProperties).length > 0 ? { patternProperties } : {},
+    ...additionalProperties !== undefined ? { additionalProperties } : {}
+  };
+}
+function Optional(item, options) {
+  return { "~kind": "Optional", item, ...options };
+}
+function Readonly(item, options) {
+  return { "~kind": "Readonly", item, ...options };
+}
+function Enum(values, options) {
+  return { "~kind": "Enum", values, ...options };
+}
+function Ref(name, options) {
+  return { "~kind": "Ref", name, ...options };
+}
+function Recursive(name, build, options) {
+  const self = Ref(name);
+  const schema = build(self);
+  return { "~kind": "Recursive", name, schema, ...options };
+}
+function Variant(discriminator, variants, options) {
+  return Union(variants, { discriminator, ...options });
+}
+// src/type/combinator-objects.ts
+function Exclude(left, right, options) {
+  return { "~kind": "Exclude", left, right, ...options };
+}
+function Extract(left, right, options) {
+  return { "~kind": "Extract", left, right, ...options };
+}
+function KeyOf(object, options) {
+  return { "~kind": "KeyOf", object, ...options };
+}
+function Partial(object, options) {
+  return { "~kind": "Partial", object, ...options };
+}
+function Required(object, options) {
+  return { "~kind": "Required", object, ...options };
+}
+function Pick(object, keys, options) {
+  return { "~kind": "Pick", object, keys, ...options };
+}
+function Omit(object, keys, options) {
+  return { "~kind": "Omit", object, keys, ...options };
+}
+function Not(schema, options) {
+  return { "~kind": "Not", schema, ...options };
+}
+function IfThenElse(condition, then, elseSchema, options) {
+  return {
+    "~kind": "IfThenElse",
+    if: condition,
+    then,
+    else: elseSchema,
+    ...options
+  };
+}
+function Unsafe(schema, options) {
+  return {
+    "~kind": "Unsafe",
+    schema,
+    type: undefined,
+    ...options
+  };
+}
+function Index(object, key, options) {
+  return {
+    "~kind": "Index",
+    object,
+    key: key ?? { "~kind": "String" },
+    ...options
+  };
+}
+function Mapped(object, transform, options) {
+  return { "~kind": "Mapped", object, ...transform ? { transform } : {}, ...options };
+}
+function Conditional(check, union, defaultSchema, options) {
+  return {
+    "~kind": "Conditional",
+    check,
+    union,
+    default: defaultSchema,
+    ...options
+  };
+}
+// src/type/combinator-functions.ts
+function Awaited(promise) {
+  return { "~kind": "Awaited", promise };
+}
+function ReturnType(fn) {
+  return { "~kind": "ReturnType", function: fn };
+}
+function Parameters(fn) {
+  return { "~kind": "Parameters", function: fn };
+}
+function InstanceType(ctor) {
+  return { "~kind": "InstanceType", constructor: ctor };
+}
+function ConstructorParameters(ctor) {
+  return { "~kind": "ConstructorParameters", constructor: ctor };
+}
+function Module(definitions) {
+  const mod = { "~kind": "Module", definitions };
+  return {
+    ...mod,
+    Import(name) {
+      return { "~kind": "Ref", name };
+    }
+  };
+}
+// src/type/containers.ts
+function Array2(item, options) {
+  return {
+    "~kind": "Array",
+    items: item,
+    ...options
+  };
+}
+function Object2(properties, options) {
+  return {
+    "~kind": "Object",
+    properties,
+    ...options
+  };
+}
+function Tuple(items, options) {
+  const expandedItems = ExpandTupleRest(items);
+  return {
+    "~kind": "Tuple",
+    items: expandedItems,
+    minItems: options?.minItems ?? expandedItems.length,
+    maxItems: options?.maxItems ?? (options?.additionalItems === true ? undefined : expandedItems.length),
+    additionalItems: options?.additionalItems ?? false,
+    ...options
+  };
+}
+function Record(key, value, options) {
+  return {
+    "~kind": "Record",
+    key,
+    value,
+    ...options
+  };
+}
+
+// src/value/clone.ts
+function cloneValue(value) {
+  return globalThis.structuredClone(value);
+}
+function Clone(value) {
+  return cloneValue(value);
+}
+
+// src/type/actions.ts
+function hasKind(value, kind) {
+  return value["~kind"] === kind;
+}
+function ExpandTupleRest(items) {
+  const expanded = [];
+  for (const item of items) {
+    if (hasKind(item, "Rest")) {
+      const rest = item;
+      if (hasKind(rest.items, "Tuple")) {
+        expanded.push(...rest.items.items);
+        continue;
+      }
+    }
+    expanded.push(item);
+  }
+  return expanded;
+}
+function Rest(item) {
+  return { "~kind": "Rest", type: "rest", items: item };
+}
+function Composite(objects) {
+  return Evaluate(Intersect(objects));
+}
+function Clone2(schema) {
+  return Clone(schema);
+}
+function Capitalize(item) {
+  return { "~kind": "Capitalize", item };
+}
+function Lowercase(item) {
+  return { "~kind": "Lowercase", item };
+}
+function Uppercase(item) {
+  return { "~kind": "Uppercase", item };
+}
+function Uncapitalize(item) {
+  return { "~kind": "Uncapitalize", item };
+}
+function Interface(heritage, properties, options) {
+  return {
+    ...Evaluate(Intersect([...heritage, Object2(properties)])),
+    ...options
+  };
+}
+function NonNullable(type, options) {
+  return Exclude(type, Union([Null(), Undefined()]), options);
+}
+function Options(type, options) {
+  return {
+    ...type,
+    ...options
+  };
+}
+function ReadonlyType(type, options) {
+  return Readonly(type, options);
+}
+function Identifier(name) {
+  return {
+    "~kind": "Identifier",
+    type: "identifier",
+    name
+  };
+}
+function Parameter(name, extends_, equals) {
+  const constraint = extends_ ?? Unknown();
+  const fallback = equals ?? constraint;
+  return {
+    "~kind": "Parameter",
+    name,
+    extends: constraint,
+    equals: fallback
+  };
+}
+function This(options) {
+  return {
+    "~kind": "This",
+    $ref: "#",
+    ...options
+  };
+}
+function Import(module, name) {
+  const definition = module.definitions[name];
+  if (definition === undefined) {
+    throw new Error(`Unknown module definition: ${name}`);
+  }
+  return definition;
+}
+
+// src/type/primitives.ts
+function String2(options) {
+  return { "~kind": "String", ...options };
+}
+function Number2(options) {
+  return { "~kind": "Number", ...options };
+}
+function Integer(options) {
+  return { "~kind": "Integer", ...options };
+}
+function Boolean(options) {
+  return { "~kind": "Boolean", ...options };
+}
+function Null(options) {
+  return { "~kind": "Null", ...options };
+}
+function Literal(value, options) {
+  return { "~kind": "Literal", const: value, ...options };
+}
+function Void(options) {
+  return { "~kind": "Void", ...options };
+}
+function Undefined(options) {
+  return { "~kind": "Undefined", ...options };
+}
+function Unknown(options) {
+  return { "~kind": "Unknown", ...options };
+}
+function Any(options) {
+  return { "~kind": "Any", ...options };
+}
+function Never(options) {
+  return { "~kind": "Never", ...options };
+}
+function BigInt2(options) {
+  return { "~kind": "BigInt", ...options };
+}
+function Date(options) {
+  return { "~kind": "Date", ...options };
+}
+function DateFormat(options) {
+  return String2({ format: "date", ...options });
+}
+function Uuid(options) {
+  return String2({ format: "uuid", ...options });
+}
+function Email(options) {
+  return String2({ format: "email", ...options });
+}
+function Uri(options) {
+  return String2({ format: "uri", ...options });
+}
+function Hostname(options) {
+  return String2({ format: "hostname", ...options });
+}
+function Ip(options) {
+  return String2({ format: "ip", ...options });
+}
+function Base64(options) {
+  return String2({ format: "base64", ...options });
+}
+function Hex(options) {
+  return String2({ format: "hex", ...options });
+}
+function HexColor(options) {
+  return String2({ format: "hexcolor", ...options });
+}
+function DateTime(options) {
+  return String2({ format: "datetime", ...options });
+}
+function Time(options) {
+  return String2({ format: "time", ...options });
+}
+function Duration(options) {
+  return String2({ format: "duration", ...options });
+}
+function Json(options) {
+  return String2({ format: "json", ...options });
+}
+function CreditCard(options) {
+  return String2({ format: "creditcard", ...options });
+}
+function Uint8Array2(options) {
+  return { "~kind": "Uint8Array", ...options };
+}
+function RegExpInstance(options) {
+  return { "~kind": "RegExpInstance", ...options };
+}
+function RegExp2(options) {
+  return String2({ format: "regex", ...options });
+}
+function Symbol2(options) {
+  return { "~kind": "Symbol", ...options };
+}
+function TemplateLiteral(patterns, options) {
+  return { "~kind": "TemplateLiteral", patterns, ...options };
+}
+function Function2(parameters, returns, options) {
+  const resolvedParameters = ExpandTupleRest(parameters ?? []);
+  const resolvedReturns = returns ?? Any();
+  return {
+    "~kind": "Function",
+    parameters: resolvedParameters,
+    returns: resolvedReturns,
+    ...options
+  };
+}
+function Constructor(parameters, returns, options) {
+  const resolvedParameters = ExpandTupleRest(parameters ?? []);
+  const resolvedReturns = returns ?? Any();
+  return {
+    "~kind": "Constructor",
+    parameters: resolvedParameters,
+    returns: resolvedReturns,
+    ...options
+  };
+}
+function Promise2(item, options) {
+  return { "~kind": "Promise", item, ...options };
+}
+function Iterator(item, options) {
+  return { "~kind": "Iterator", item, ...options };
+}
+function AsyncIterator(item, options) {
+  return { "~kind": "AsyncIterator", item, ...options };
+}
+function Decode(inner, decode) {
+  return { "~kind": "Decode", inner, decode };
+}
+function Encode(inner, encode) {
+  return { "~kind": "Encode", inner, encode };
+}
+
+// src/error/collector/primitives.ts
+function invalidTypeIssue(path, expected, actual) {
+  return [createSchemaIssue(schemaPath(path), "INVALID_TYPE", actual === undefined ? { expected } : { expected, actual })];
+}
+function collectStringIssues(schema, value, path, refs) {
+  const issues = [];
+  const currentPath = schemaPath(path);
+  if (typeof value !== "string") {
+    issues.push(createSchemaIssue(currentPath, "INVALID_TYPE", { expected: "string", actual: typeof value }));
+    return issues;
+  }
+  if (schema.minLength !== undefined && value.length < schema.minLength) {
+    issues.push(createSchemaIssue(currentPath, "MIN_LENGTH", { label: "String length", minimum: schema.minLength }));
+  }
+  if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+    issues.push(createSchemaIssue(currentPath, "MAX_LENGTH", { label: "String length", maximum: schema.maxLength }));
+  }
+  if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+    issues.push(createSchemaIssue(currentPath, "PATTERN", { label: "String", pattern: schema.pattern }));
+  }
+  if (typeof schema.format === "string" && !CheckInternal(String2({ format: schema.format }), value, refs)) {
+    issues.push(createSchemaIssue(currentPath, "FORMAT", { label: "String", format: schema.format }));
+  }
+  return issues;
+}
+function collectNumberIssues(schema, value, path, integerOnly) {
+  const issues = [];
+  const currentPath = schemaPath(path);
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    issues.push(createSchemaIssue(currentPath, "INVALID_TYPE", { expected: "number", actual: typeof value }));
+    return issues;
+  }
+  if (integerOnly && !Number.isInteger(value)) {
+    issues.push(createSchemaIssue(currentPath, "INVALID_TYPE", { expected: "integer" }));
+  }
+  if (schema.minimum !== undefined && value < schema.minimum) {
+    issues.push(createSchemaIssue(currentPath, "MINIMUM", { minimum: schema.minimum }));
+  }
+  if (schema.maximum !== undefined && value > schema.maximum) {
+    issues.push(createSchemaIssue(currentPath, "MAXIMUM", { maximum: schema.maximum }));
+  }
+  if (schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum) {
+    issues.push(createSchemaIssue(currentPath, "EXCLUSIVE_MINIMUM", { minimum: schema.exclusiveMinimum }));
+  }
+  if (schema.exclusiveMaximum !== undefined && value >= schema.exclusiveMaximum) {
+    issues.push(createSchemaIssue(currentPath, "EXCLUSIVE_MAXIMUM", { maximum: schema.exclusiveMaximum }));
+  }
+  if (schema.multipleOf !== undefined && value % schema.multipleOf !== 0) {
+    issues.push(createSchemaIssue(currentPath, "MULTIPLE_OF", { divisor: schema.multipleOf }));
+  }
+  return issues;
+}
+function collectBigIntIssues(schema, value, path) {
+  const issues = [];
+  const currentPath = schemaPath(path);
+  if (typeof value !== "bigint") {
+    return invalidTypeIssue(path, "bigint", typeof value);
+  }
+  if (schema.minimum !== undefined && value < schema.minimum) {
+    issues.push(createSchemaIssue(currentPath, "MINIMUM", { minimum: schema.minimum }));
+  }
+  if (schema.maximum !== undefined && value > schema.maximum) {
+    issues.push(createSchemaIssue(currentPath, "MAXIMUM", { maximum: schema.maximum }));
+  }
+  if (schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum) {
+    issues.push(createSchemaIssue(currentPath, "EXCLUSIVE_MINIMUM", { minimum: schema.exclusiveMinimum }));
+  }
+  if (schema.exclusiveMaximum !== undefined && value >= schema.exclusiveMaximum) {
+    issues.push(createSchemaIssue(currentPath, "EXCLUSIVE_MAXIMUM", { maximum: schema.exclusiveMaximum }));
+  }
+  if (schema.multipleOf !== undefined && value % schema.multipleOf !== 0n) {
+    issues.push(createSchemaIssue(currentPath, "MULTIPLE_OF", { divisor: schema.multipleOf }));
+  }
+  return issues;
+}
+function collectDateIssues(schema, value, path) {
+  const issues = [];
+  const currentPath = schemaPath(path);
+  if (!(value instanceof globalThis.Date) || Number.isNaN(value.getTime())) {
+    return invalidTypeIssue(path, "Date instance");
+  }
+  const timestamp = value.getTime();
+  if (schema.minimumTimestamp !== undefined && timestamp < schema.minimumTimestamp) {
+    issues.push(createSchemaIssue(currentPath, "MINIMUM", { label: "Date timestamp", minimum: schema.minimumTimestamp }));
+  }
+  if (schema.maximumTimestamp !== undefined && timestamp > schema.maximumTimestamp) {
+    issues.push(createSchemaIssue(currentPath, "MAXIMUM", { label: "Date timestamp", maximum: schema.maximumTimestamp }));
+  }
+  return issues;
+}
+function collectLiteralIssues(schema, value, path) {
+  return value === schema.const ? [] : [createSchemaIssue(schemaPath(path), "INVALID_CONST", { expectedValue: JSON.stringify(schema.const) })];
+}
+function collectEnumIssues(schema, value, path) {
+  if (typeof value !== "string") {
+    return invalidTypeIssue(path, "string", typeof value);
+  }
+  return schema.values.includes(value) ? [] : [createSchemaIssue(schemaPath(path), "ENUM", { values: schema.values })];
+}
+function collectTemplateLiteralIssues(schema, value, path) {
+  if (typeof value !== "string") {
+    return invalidTypeIssue(path, "string", typeof value);
+  }
+  return new RegExp(schema.patterns.join("|")).test(value) ? [] : [createSchemaIssue(schemaPath(path), "PATTERN", { label: "String", patterns: schema.patterns })];
+}
+function collectUint8ArrayIssues(schema, value, path) {
+  const issues = [];
+  const currentPath = schemaPath(path);
+  if (!(value instanceof globalThis.Uint8Array)) {
+    return invalidTypeIssue(path, "Uint8Array", typeof value);
+  }
+  if (schema.minByteLength !== undefined && value.byteLength < schema.minByteLength) {
+    issues.push(createSchemaIssue(currentPath, "MIN_LENGTH", { label: "Uint8Array byteLength", minimum: schema.minByteLength }));
+  }
+  if (schema.maxByteLength !== undefined && value.byteLength > schema.maxByteLength) {
+    issues.push(createSchemaIssue(currentPath, "MAX_LENGTH", { label: "Uint8Array byteLength", maximum: schema.maxByteLength }));
+  }
+  return issues;
+}
+function collectPrimitiveIssues(kind, schema, value, path, refs) {
+  const currentPath = schemaPath(path);
+  switch (kind) {
+    case "String":
+      return collectStringIssues(schema, value, path, refs);
+    case "Number":
+      return collectNumberIssues(schema, value, path, false);
+    case "Integer":
+      return collectNumberIssues(schema, value, path, true);
+    case "BigInt":
+      return collectBigIntIssues(schema, value, path);
+    case "Date":
+      return collectDateIssues(schema, value, path);
+    case "Boolean":
+      return typeof value === "boolean" ? [] : invalidTypeIssue(path, "boolean", typeof value);
+    case "Null":
+      return value === null ? [] : invalidTypeIssue(path, "null");
+    case "Literal":
+      return collectLiteralIssues(schema, value, path);
+    case "Enum":
+      return collectEnumIssues(schema, value, path);
+    case "Void":
+      return value === undefined || value === null ? [] : invalidTypeIssue(path, "void (undefined or null)");
+    case "Undefined":
+      return value === undefined ? [] : invalidTypeIssue(path, "undefined");
+    case "Never":
+      return [createSchemaIssue(currentPath, "NEVER")];
+    case "TemplateLiteral":
+      return collectTemplateLiteralIssues(schema, value, path);
+    case "Uint8Array":
+      return collectUint8ArrayIssues(schema, value, path);
+    case "Identifier":
+      return typeof value === "string" && /^[$A-Z_a-z][$\w]*$/.test(value) ? [] : [createSchemaIssue(currentPath, typeof value === "string" ? "IDENTIFIER" : "INVALID_TYPE", { expected: "string", actual: typeof value })];
+    case "Promise":
+      return isPromiseLike(value) ? [] : invalidTypeIssue(path, "Promise-like value");
+    case "Iterator":
+      return isIteratorLike(value) ? [] : invalidTypeIssue(path, "iterator value");
+    case "AsyncIterator":
+      return isAsyncIteratorLike(value) ? [] : invalidTypeIssue(path, "async iterator value");
+    case "Function":
+      return typeof value === "function" ? [] : invalidTypeIssue(path, "function", typeof value);
+    case "Constructor":
+      return typeof value === "function" && "prototype" in value ? [] : invalidTypeIssue(path, "constructor function");
+    case "Symbol":
+      return typeof value === "symbol" ? [] : invalidTypeIssue(path, "symbol", typeof value);
+    case "Base": {
+      const baseSchema = schema;
+      if (typeof baseSchema.Check === "function" && !baseSchema.Check(value)) {
+        return [createSchemaIssue(currentPath, "BASE")];
+      }
+      return [];
+    }
+    default:
+      return;
+  }
+}
+
+// src/error/collector.ts
+function collectSchemaIssues(schema, value, path = [], refs = new Map) {
+  const kind = schemaKind(schema);
+  const primitiveIssues = collectPrimitiveIssues(kind, schema, value, path, refs);
+  if (primitiveIssues !== undefined) {
+    return primitiveIssues;
+  }
+  const collectionIssues = collectCollectionIssues(kind, schema, value, path, refs, collectSchemaIssues);
+  if (collectionIssues !== undefined) {
+    return collectionIssues;
+  }
+  return collectAdvancedIssues(kind, schema, value, path, refs, collectSchemaIssues);
+}
+
+// src/error/errors.ts
+function Explain(schema, value, context) {
+  const runtimeContext = resolveRuntimeContext(context);
+  const locale = String(runtimeContext.Locale.Get());
+  const catalog = runtimeContext.Locale.GetCatalog(locale);
+  return collectSchemaIssues(schema, value).map((issue) => localizeSchemaIssueWithCatalog(issue, catalog, locale));
+}
+function Errors(schema, value, context) {
+  return Explain(schema, value, context).map((issue) => ({
+    path: issue.path,
+    code: issue.code,
+    message: issue.message
+  }));
+}
+
+// src/value/clean.ts
+var NOT_HANDLED = Symbol("clean.not-handled");
+function Clean(schema, value) {
+  return CleanInternal(schema, value, new Map);
+}
+function cleanStructuredValue(s, value, refs) {
+  const kind = s["~kind"];
+  switch (kind) {
+    case "Object": {
+      if (typeof value !== "object" || value === null || Array.isArray(value))
+        return value;
+      const result = {};
+      const props = s["properties"];
+      const additionalProperties = s["additionalProperties"];
+      for (const [key, val] of Object.entries(value)) {
+        const propSchema = props[key];
+        if (propSchema) {
+          result[key] = CleanInternal(propSchema, val, refs);
+        } else if (additionalProperties !== false) {
+          if (typeof additionalProperties === "object") {
+            result[key] = CleanInternal(additionalProperties, val, refs);
+          } else {
+            result[key] = val;
+          }
+        }
+      }
+      return result;
+    }
+    case "Array": {
+      if (!Array.isArray(value))
+        return value;
+      const itemSchema = s["items"];
+      return value.map((item) => CleanInternal(itemSchema, item, refs));
+    }
+    case "Tuple": {
+      if (!Array.isArray(value))
+        return value;
+      const items = s["items"];
+      const cleanedItems = value.slice(0, items.length).map((item, i) => items[i] ? CleanInternal(items[i], item, refs) : item);
+      return s["additionalItems"] === true ? [...cleanedItems, ...value.slice(items.length)] : cleanedItems;
+    }
+    case "Record": {
+      if (typeof value !== "object" || value === null || Array.isArray(value))
+        return value;
+      const result = {};
+      const valueSchema = s["value"];
+      for (const [key, val] of Object.entries(value)) {
+        result[key] = CleanInternal(valueSchema, val, refs);
+      }
+      return result;
+    }
+    default:
+      return NOT_HANDLED;
+  }
+}
+function cleanCompositeValue(s, value, refs) {
+  const kind = s["~kind"];
+  switch (kind) {
+    case "Union": {
+      const variants = s["variants"];
+      for (const variant of variants) {
+        const cleaned = CleanInternal(variant, value, refs);
+        if (cleaned !== value)
+          return cleaned;
+      }
+      return value;
+    }
+    case "Intersect": {
+      const variants = s["variants"];
+      let result = value;
+      for (const variant of variants) {
+        result = CleanInternal(variant, result, refs);
+      }
+      return result;
+    }
+    case "Optional":
+    case "Readonly":
+      return value === undefined ? value : CleanInternal(s["item"], value, refs);
+    case "Recursive": {
+      const nextRefs = new Map(refs);
+      nextRefs.set(s["name"], s["schema"]);
+      return CleanInternal(s["schema"], value, nextRefs);
+    }
+    case "Ref": {
+      const target = refs.get(s["name"]);
+      return target ? CleanInternal(target, value, refs) : value;
+    }
+    case "Decode":
+    case "Encode":
+      return CleanInternal(s["inner"], value, refs);
+    default:
+      return NOT_HANDLED;
+  }
+}
+function CleanInternal(schema, value, refs) {
+  const s = schema;
+  const structured = cleanStructuredValue(s, value, refs);
+  if (structured !== NOT_HANDLED) {
+    return structured;
+  }
+  const composite = cleanCompositeValue(s, value, refs);
+  return composite !== NOT_HANDLED ? composite : value;
+}
+
+// src/value/convert.ts
+var NOT_HANDLED2 = Symbol("convert.not-handled");
+function isBigIntText(value) {
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    return false;
+  }
+  const first = normalized[0];
+  const start = first === "+" || first === "-" ? 1 : 0;
+  if (start === normalized.length) {
+    return false;
+  }
+  for (let index = start;index < normalized.length; index += 1) {
+    const char = normalized[index];
+    if (char === undefined || char < "0" || char > "9") {
+      return false;
+    }
+  }
+  return true;
+}
+function Convert(schema, value) {
+  return ConvertInternal(schema, value, new Map);
+}
+function convertPrimitiveValue(s, value) {
+  const kind = s["~kind"];
+  switch (kind) {
+    case "String": {
+      if (typeof value === "string")
+        return value;
+      if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+        return globalThis.String(value);
+      }
+      return value;
+    }
+    case "Number": {
+      if (typeof value === "number")
+        return value;
+      if (typeof value === "string") {
+        const n = globalThis.Number(value);
+        if (!isNaN(n))
+          return n;
+      }
+      if (typeof value === "boolean")
+        return value ? 1 : 0;
+      return value;
+    }
+    case "Integer": {
+      if (typeof value === "number" && Number.isInteger(value))
+        return value;
+      if (typeof value === "string") {
+        const n = parseInt(value, 10);
+        if (!isNaN(n))
+          return n;
+      }
+      if (typeof value === "boolean")
+        return value ? 1 : 0;
+      if (typeof value === "number")
+        return Math.trunc(value);
+      return value;
+    }
+    case "Boolean": {
+      if (typeof value === "boolean")
+        return value;
+      if (typeof value === "string") {
+        if (value === "true" || value === "1")
+          return true;
+        if (value === "false" || value === "0")
+          return false;
+      }
+      if (typeof value === "number")
+        return value !== 0;
+      return value;
+    }
+    case "BigInt": {
+      if (typeof value === "bigint")
+        return value;
+      if (typeof value === "number" && Number.isInteger(value))
+        return globalThis.BigInt(value);
+      if (typeof value === "string") {
+        const normalized = value.trim();
+        if (isBigIntText(normalized)) {
+          return globalThis.BigInt(normalized);
+        }
+      }
+      return value;
+    }
+    case "Date": {
+      if (value instanceof globalThis.Date)
+        return value;
+      if (typeof value === "string" || typeof value === "number") {
+        const d = new globalThis.Date(value);
+        if (!isNaN(d.getTime()))
+          return d;
+      }
+      return value;
+    }
+    case "Null":
+      return value === null ? value : value === "null" || value === undefined ? null : value;
+    default:
+      return NOT_HANDLED2;
+  }
+}
+function convertStructuredValue(s, value, refs) {
+  const kind = s["~kind"];
+  switch (kind) {
+    case "Object": {
+      if (typeof value !== "object" || value === null || Array.isArray(value))
+        return value;
+      const result = {};
+      const props = s["properties"];
+      const obj = value;
+      for (const [key, val] of Object.entries(obj)) {
+        const propSchema = props[key];
+        result[key] = propSchema ? ConvertInternal(propSchema, val, refs) : val;
+      }
+      return result;
+    }
+    case "Array": {
+      if (!Array.isArray(value))
+        return value;
+      const itemSchema = s["items"];
+      return value.map((item) => ConvertInternal(itemSchema, item, refs));
+    }
+    case "Tuple": {
+      if (!Array.isArray(value))
+        return value;
+      const items = s["items"];
+      return value.map((item, i) => items[i] ? ConvertInternal(items[i], item, refs) : item);
+    }
+    default:
+      return NOT_HANDLED2;
+  }
+}
+function convertCompositeValue(s, value, refs) {
+  const kind = s["~kind"];
+  switch (kind) {
+    case "Optional":
+      return value === undefined ? value : ConvertInternal(s["item"], value, refs);
+    case "Readonly":
+      return ConvertInternal(s["item"], value, refs);
+    case "Union": {
+      const variants = s["variants"];
+      for (const variant of variants) {
+        const converted = ConvertInternal(variant, value, refs);
+        if (converted !== value)
+          return converted;
+      }
+      return value;
+    }
+    case "Intersect": {
+      const variants = s["variants"];
+      let result = value;
+      for (const variant of variants) {
+        result = ConvertInternal(variant, result, refs);
+      }
+      return result;
+    }
+    case "Recursive": {
+      const nextRefs = new Map(refs);
+      nextRefs.set(s["name"], s["schema"]);
+      return ConvertInternal(s["schema"], value, nextRefs);
+    }
+    case "Ref": {
+      const target = refs.get(s["name"]);
+      return target ? ConvertInternal(target, value, refs) : value;
+    }
+    case "Decode":
+    case "Encode":
+      return ConvertInternal(s["inner"], value, refs);
+    default:
+      return NOT_HANDLED2;
+  }
+}
+function ConvertInternal(schema, value, refs) {
+  const s = schema;
+  const primitive = convertPrimitiveValue(s, value);
+  if (primitive !== NOT_HANDLED2) {
+    return primitive;
+  }
+  const structured = convertStructuredValue(s, value, refs);
+  if (structured !== NOT_HANDLED2) {
+    return structured;
+  }
+  const composite = convertCompositeValue(s, value, refs);
+  return composite !== NOT_HANDLED2 ? composite : value;
+}
+
+// src/value/create.ts
+var NOT_HANDLED3 = Symbol("create.not-handled");
+function cloneValue2(value) {
+  return globalThis.structuredClone(value);
+}
+function Create(schema) {
+  return CreateInternal(schema, new Map);
+}
+function createPrimitiveValue(s) {
+  const kind = s["~kind"];
+  switch (kind) {
+    case "String":
+      return "";
+    case "Number":
+      return 0;
+    case "Integer":
+      return 0;
+    case "Boolean":
+      return false;
+    case "Null":
+      return null;
+    case "BigInt":
+      return 0n;
+    case "Date":
+      return new globalThis.Date(0);
+    case "Literal":
+      return s["const"];
+    case "Void":
+    case "Undefined":
+    case "Unknown":
+    case "Any":
+    case "Never":
+      return;
+    case "Symbol":
+      return globalThis.Symbol();
+    case "Uint8Array":
+      return new globalThis.Uint8Array(0);
+    case "Function":
+      return () => {};
+    case "Constructor":
+      return class {
+      };
+    case "Promise":
+      return globalThis.Promise.resolve(undefined);
+    default:
+      return NOT_HANDLED3;
+  }
+}
+function createStructuredValue(s, refs) {
+  const kind = s["~kind"];
+  switch (kind) {
+    case "Array":
+      return [];
+    case "Tuple": {
+      const items = s["items"];
+      return items.map((item) => CreateInternal(item, refs));
+    }
+    case "Object": {
+      const obj = {};
+      const props = s["properties"];
+      const required = s["required"] ?? [];
+      const optionalKeys = new Set(s["optional"] ?? []);
+      for (const key of required) {
+        if (props[key])
+          obj[key] = CreateInternal(props[key], refs);
+      }
+      for (const [key, propSchema] of Object.entries(props)) {
+        if (!(key in obj) && !optionalKeys.has(key)) {
+          obj[key] = CreateInternal(propSchema, refs);
+        }
+      }
+      return obj;
+    }
+    case "Record":
+    case "Partial":
+      return {};
+    case "Union": {
+      const variants = s["variants"];
+      return variants.length > 0 ? CreateInternal(variants[0], refs) : undefined;
+    }
+    case "Intersect": {
+      const variants = s["variants"];
+      let result = {};
+      for (const variant of variants) {
+        const v = CreateInternal(variant, refs);
+        if (typeof v === "object" && v !== null)
+          result = { ...result, ...v };
+      }
+      return result;
+    }
+    case "Optional":
+      return;
+    case "Readonly":
+      return CreateInternal(s["item"], refs);
+    case "Enum": {
+      const values = s["values"];
+      return values.length > 0 ? values[0] : "";
+    }
+    case "Required": {
+      const obj = s["object"];
+      const result = {};
+      for (const [key, propSchema] of Object.entries(obj.properties)) {
+        result[key] = CreateInternal(propSchema, refs);
+      }
+      return result;
+    }
+    default:
+      return NOT_HANDLED3;
+  }
+}
+function createReferenceValue(s, refs) {
+  const kind = s["~kind"];
+  switch (kind) {
+    case "Ref": {
+      const target = refs.get(s["name"]);
+      return target ? CreateInternal(target, refs) : undefined;
+    }
+    case "Recursive": {
+      const nextRefs = new Map(refs);
+      nextRefs.set(s["name"], s["schema"]);
+      return CreateInternal(s["schema"], nextRefs);
+    }
+    case "Decode":
+    case "Encode":
+      return CreateInternal(s["inner"], refs);
+    default:
+      return NOT_HANDLED3;
+  }
+}
+function CreateInternal(schema, refs) {
+  const s = schema;
+  if (s["default"] !== undefined)
+    return cloneValue2(s["default"]);
+  const primitive = createPrimitiveValue(s);
+  if (primitive !== NOT_HANDLED3) {
+    return primitive;
+  }
+  const structured = createStructuredValue(s, refs);
+  if (structured !== NOT_HANDLED3) {
+    return structured;
+  }
+  const reference = createReferenceValue(s, refs);
+  return reference !== NOT_HANDLED3 ? reference : undefined;
+}
+
+// src/value/decode.ts
+function Decode2(schema, value) {
+  return DecodeInternal(schema, value, new Map);
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function resolveCodec(schema) {
+  const codec = schemaUnknownField(schema, "codec");
+  return isRecord3(codec) && typeof codec.decode === "function" ? codec : undefined;
+}
+function decodeObject(schema, value, refs) {
+  if (!isRecord3(value) || Array.isArray(value))
+    return value;
+  const result = {};
+  const properties = schemaProperties(schema);
+  for (const [key, entryValue] of Object.entries(value)) {
+    const propertySchema = properties[key];
+    result[key] = propertySchema ? DecodeInternal(propertySchema, entryValue, refs) : entryValue;
+  }
+  return result;
+}
+function decodeArrayItems(itemSchema, value, refs) {
+  return Array.isArray(value) && itemSchema ? value.map((item) => DecodeInternal(itemSchema, item, refs)) : value;
+}
+function decodeTupleItems(schema, value, refs) {
+  if (!Array.isArray(value))
+    return value;
+  const items = schemaSchemaListField(schema, "items");
+  return value.map((item, index) => {
+    const itemSchema = items[index];
+    return itemSchema ? DecodeInternal(itemSchema, item, refs) : item;
+  });
+}
+function decodeWrappedInner(schema, value, refs) {
+  const inner = schemaInner(schema) ?? schemaItem(schema);
+  return value === undefined || inner === undefined ? value : DecodeInternal(inner, value, refs);
+}
+function decodeReferenceSchema(schema, value, refs) {
+  switch (schemaKind(schema)) {
+    case "Call": {
+      const instantiated = Instantiate({}, schema);
+      return instantiated === schema ? value : DecodeInternal(instantiated, value, refs);
+    }
+    case "Cyclic": {
+      const defs = schemaDefinitions(schema);
+      const refName = schemaStringField(schema, "$ref");
+      const nextRefs = new Map(refs);
+      for (const [key, definition] of Object.entries(defs)) {
+        nextRefs.set(key, definition);
+      }
+      const target = refName ? defs[refName] : undefined;
+      return target === undefined ? value : DecodeInternal(target, value, nextRefs);
+    }
+    case "Recursive": {
+      const name = schemaStringField(schema, "name");
+      const target = schemaSchemaField(schema, "schema");
+      if (!name || target === undefined)
+        return value;
+      const nextRefs = new Map(refs);
+      nextRefs.set(name, target);
+      nextRefs.set("#", target);
+      return DecodeInternal(target, value, nextRefs);
+    }
+    case "Ref": {
+      const target = refs.get(schemaStringField(schema, "name") ?? "");
+      return target ? DecodeInternal(target, value, refs) : value;
+    }
+    default:
+      return value;
+  }
+}
+function DecodeInternal(schema, value, refs) {
+  switch (schemaKind(schema)) {
+    case "Decode": {
+      const inner = schemaInner(schema);
+      const decode = schemaCallbackField(schema, "decode");
+      return inner && decode ? decode(DecodeInternal(inner, value, refs)) : value;
+    }
+    case "Codec": {
+      const inner = schemaInner(schema);
+      const codec = resolveCodec(schema);
+      return inner && codec ? codec.decode(DecodeInternal(inner, value, refs)) : value;
+    }
+    case "Object":
+      return decodeObject(schema, value, refs);
+    case "Array":
+      return decodeArrayItems(schemaSchemaField(schema, "items"), value, refs);
+    case "Tuple":
+      return decodeTupleItems(schema, value, refs);
+    case "Union":
+      return value;
+    case "Intersect": {
+      let result = value;
+      for (const variant of schemaSchemaListField(schema, "variants")) {
+        result = DecodeInternal(variant, result, refs);
+      }
+      return result;
+    }
+    case "Optional":
+    case "Readonly":
+    case "Immutable":
+    case "Refine":
+      return decodeWrappedInner(schema, value, refs);
+    case "Generic":
+      return DecodeInternal(schemaSchemaField(schema, "expression") ?? schema, value, refs);
+    case "Infer":
+      return DecodeInternal(schemaSchemaField(schema, "extends") ?? schema, value, refs);
+    case "Call":
+    case "Cyclic":
+    case "Recursive":
+    case "Ref":
+      return decodeReferenceSchema(schema, value, refs);
+    case "Encode":
+      return decodeWrappedInner(schema, value, refs);
+    case "Base": {
+      const convert = schemaCallbackField(schema, "Convert");
+      return convert ? convert(value) : value;
+    }
+    default:
+      return value;
+  }
+}
+
+// src/value/default.ts
+var NOT_HANDLED4 = Symbol("default.not-handled");
+function cloneValue3(value) {
+  return globalThis.structuredClone(value);
+}
+function Default(schema, value) {
+  return DefaultInternal(schema, value, new Map);
+}
+function defaultStructuredValue(s, value, refs) {
+  const kind = s["~kind"];
+  switch (kind) {
+    case "Object": {
+      if (typeof value !== "object" || value === null || Array.isArray(value))
+        return value;
+      const result = { ...value };
+      const props = s["properties"];
+      for (const [key, propSchema] of Object.entries(props)) {
+        if (result[key] === undefined) {
+          const propS = propSchema;
+          if (propS["default"] !== undefined) {
+            result[key] = cloneValue3(propS["default"]);
+          }
+        } else {
+          result[key] = DefaultInternal(propSchema, result[key], refs);
+        }
+      }
+      return result;
+    }
+    case "Array": {
+      if (!Array.isArray(value))
+        return value;
+      const itemSchema = s["items"];
+      return value.map((item) => DefaultInternal(itemSchema, item, refs));
+    }
+    case "Tuple": {
+      if (!Array.isArray(value))
+        return value;
+      const items = s["items"];
+      return value.map((item, i) => items[i] ? DefaultInternal(items[i], item, refs) : item);
+    }
+    default:
+      return NOT_HANDLED4;
+  }
+}
+function defaultCompositeValue(s, value, refs) {
+  const kind = s["~kind"];
+  switch (kind) {
+    case "Optional":
+      return value === undefined ? value : DefaultInternal(s["item"], value, refs);
+    case "Readonly":
+      return DefaultInternal(s["item"], value, refs);
+    case "Intersect": {
+      const variants = s["variants"];
+      let result = value;
+      for (const variant of variants) {
+        result = DefaultInternal(variant, result, refs);
+      }
+      return result;
+    }
+    case "Union":
+      return value;
+    case "Recursive": {
+      const nextRefs = new Map(refs);
+      nextRefs.set(s["name"], s["schema"]);
+      return DefaultInternal(s["schema"], value, nextRefs);
+    }
+    case "Ref": {
+      const target = refs.get(s["name"]);
+      return target ? DefaultInternal(target, value, refs) : value;
+    }
+    case "Decode":
+    case "Encode":
+      return DefaultInternal(s["inner"], value, refs);
+    default:
+      return NOT_HANDLED4;
+  }
+}
+function DefaultInternal(schema, value, refs) {
+  const s = schema;
+  if (value === undefined && s["default"] !== undefined) {
+    return cloneValue3(s["default"]);
+  }
+  const structured = defaultStructuredValue(s, value, refs);
+  if (structured !== NOT_HANDLED4) {
+    return structured;
+  }
+  const composite = defaultCompositeValue(s, value, refs);
+  return composite !== NOT_HANDLED4 ? composite : value;
+}
+
+// src/value/encode.ts
+function Encode2(schema, value) {
+  return EncodeInternal(schema, value, new Map);
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+function resolveCodec2(schema) {
+  const codec = schemaUnknownField(schema, "codec");
+  return isRecord4(codec) && typeof codec.encode === "function" ? codec : undefined;
+}
+function encodeObject(schema, value, refs) {
+  if (!isRecord4(value) || Array.isArray(value))
+    return value;
+  const result = {};
+  const properties = schemaProperties(schema);
+  for (const [key, entryValue] of Object.entries(value)) {
+    const propertySchema = properties[key];
+    result[key] = propertySchema ? EncodeInternal(propertySchema, entryValue, refs) : entryValue;
+  }
+  return result;
+}
+function encodeArrayItems(itemSchema, value, refs) {
+  return Array.isArray(value) && itemSchema ? value.map((item) => EncodeInternal(itemSchema, item, refs)) : value;
+}
+function encodeTupleItems(schema, value, refs) {
+  if (!Array.isArray(value))
+    return value;
+  const items = schemaSchemaListField(schema, "items");
+  return value.map((item, index) => {
+    const itemSchema = items[index];
+    return itemSchema ? EncodeInternal(itemSchema, item, refs) : item;
+  });
+}
+function encodeWrappedInner(schema, value, refs) {
+  const inner = schemaInner(schema) ?? schemaItem(schema);
+  return value === undefined || inner === undefined ? value : EncodeInternal(inner, value, refs);
+}
+function encodeReferenceSchema(schema, value, refs) {
+  switch (schemaKind(schema)) {
+    case "Call": {
+      const instantiated = Instantiate({}, schema);
+      return instantiated === schema ? value : EncodeInternal(instantiated, value, refs);
+    }
+    case "Cyclic": {
+      const defs = schemaDefinitions(schema);
+      const refName = schemaStringField(schema, "$ref");
+      const nextRefs = new Map(refs);
+      for (const [key, definition] of Object.entries(defs)) {
+        nextRefs.set(key, definition);
+      }
+      const target = refName ? defs[refName] : undefined;
+      return target === undefined ? value : EncodeInternal(target, value, nextRefs);
+    }
+    case "Recursive": {
+      const name = schemaStringField(schema, "name");
+      const target = schemaSchemaField(schema, "schema");
+      if (!name || target === undefined)
+        return value;
+      const nextRefs = new Map(refs);
+      nextRefs.set(name, target);
+      nextRefs.set("#", target);
+      return EncodeInternal(target, value, nextRefs);
+    }
+    case "Ref": {
+      const target = refs.get(schemaStringField(schema, "name") ?? "");
+      return target ? EncodeInternal(target, value, refs) : value;
+    }
+    default:
+      return value;
+  }
+}
+function EncodeInternal(schema, value, refs) {
+  switch (schemaKind(schema)) {
+    case "Encode": {
+      const inner = schemaInner(schema);
+      const encode = schemaCallbackField(schema, "encode");
+      return inner && encode ? EncodeInternal(inner, encode(value), refs) : value;
+    }
+    case "Codec": {
+      const inner = schemaInner(schema);
+      const codec = resolveCodec2(schema);
+      return inner && codec ? EncodeInternal(inner, codec.encode(value), refs) : value;
+    }
+    case "Object":
+      return encodeObject(schema, value, refs);
+    case "Array":
+      return encodeArrayItems(schemaSchemaField(schema, "items"), value, refs);
+    case "Tuple":
+      return encodeTupleItems(schema, value, refs);
+    case "Optional":
+    case "Readonly":
+    case "Immutable":
+    case "Refine":
+      return encodeWrappedInner(schema, value, refs);
+    case "Generic":
+      return EncodeInternal(schemaSchemaField(schema, "expression") ?? schema, value, refs);
+    case "Infer":
+      return EncodeInternal(schemaSchemaField(schema, "extends") ?? schema, value, refs);
+    case "Call":
+    case "Cyclic":
+    case "Recursive":
+    case "Ref":
+      return encodeReferenceSchema(schema, value, refs);
+    case "Decode":
+      return encodeWrappedInner(schema, value, refs);
+    case "Base": {
+      const convert = schemaCallbackField(schema, "Convert");
+      return convert ? convert(value) : value;
+    }
+    default:
+      return value;
+  }
+}
+
+// src/value/hash.ts
+function Hash(value) {
+  let h = 0xcbf29ce484222325n;
+  hashValue(value);
+  return h;
+  function mix(b) {
+    h ^= b & 0xffn;
+    h = BigInt.asUintN(64, h * 0x100000001b3n);
+  }
+  function hashString(s) {
+    for (let i = 0;i < s.length; i++) {
+      mix(BigInt(s.charCodeAt(i)));
+    }
+  }
+  function hashValue(v) {
+    if (v === null) {
+      mix(0n);
+      return;
+    }
+    if (v === undefined) {
+      mix(1n);
+      return;
+    }
+    switch (typeof v) {
+      case "boolean":
+        mix(v ? 2n : 3n);
+        return;
+      case "number":
+        mix(4n);
+        hashString(v.toString());
+        return;
+      case "bigint":
+        mix(5n);
+        hashString(v.toString());
+        return;
+      case "string":
+        mix(6n);
+        hashString(v);
+        return;
+      case "symbol":
+        mix(7n);
+        hashString(v.toString());
+        return;
+      case "object": {
+        if (Array.isArray(v)) {
+          mix(8n);
+          for (const item of v)
+            hashValue(item);
+          return;
+        }
+        if (v instanceof globalThis.Date) {
+          mix(9n);
+          hashString(v.toISOString());
+          return;
+        }
+        if (v instanceof globalThis.Uint8Array) {
+          mix(10n);
+          for (const byte of v)
+            mix(BigInt(byte));
+          return;
+        }
+        mix(11n);
+        const keys = Object.keys(v).sort();
+        for (const key of keys) {
+          hashString(key);
+          hashValue(v[key]);
+        }
+        return;
+      }
+      default:
+        mix(12n);
+    }
+  }
+}
+
+// src/value/parse.ts
+class ParseError extends Error {
+  errors;
+  constructor(errors) {
+    super(`Parse failed with ${errors.length} error(s)`);
+    this.name = "ParseError";
+    this.errors = errors;
+  }
+}
+function TryParse(schema, value, context) {
+  let result = Clone(value);
+  result = Default(schema, result);
+  result = Convert(schema, result);
+  result = Clean(schema, result);
+  if (!Check(schema, result, context)) {
+    return {
+      success: false,
+      errors: Errors(schema, result, context)
+    };
+  }
+  return {
+    success: true,
+    value: result
+  };
+}
+function Parse(schema, value, context) {
+  const result = TryParse(schema, value, context);
+  if (!result.success) {
+    throw new ParseError(result.errors);
+  }
+  return result.value;
+}
+
+// src/value/repair.ts
+function Repair(schema, value, context) {
+  const converted = Convert(schema, Clone(value));
+  const kind = schemaKind(schema);
+  if (Check(schema, converted, context) && kind !== "Object" && kind !== "Tuple" && kind !== "Array" && kind !== "Record") {
+    return converted;
+  }
+  return repairInternal(schema, converted, new Map, context);
+}
+function repairObject(schema, value, refs) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return Create(schema);
+  }
+  const optional = new Set((schema.optional ?? []).map(String));
+  const objectValue = value;
+  const result = {};
+  for (const [key, propertySchema] of Object.entries(schema.properties)) {
+    if (key in objectValue) {
+      const propertyValue = objectValue[key];
+      if (propertyValue === undefined && optional.has(key)) {
+        result[key] = undefined;
+      } else {
+        result[key] = repairInternal(propertySchema, propertyValue, refs);
+      }
+    } else if (!optional.has(key)) {
+      result[key] = Create(propertySchema);
+    }
+  }
+  if (schema.additionalProperties !== false) {
+    for (const [key, entryValue] of Object.entries(objectValue)) {
+      if (!(key in schema.properties))
+        result[key] = entryValue;
+    }
+  }
+  return result;
+}
+function repairArray(schema, value, refs) {
+  if (!Array.isArray(value)) {
+    const result2 = [];
+    if (schema.minItems !== undefined) {
+      for (let index = 0;index < schema.minItems; index += 1) {
+        result2.push(Create(schema.items));
+      }
+    }
+    return result2;
+  }
+  const result = value.map((entry) => repairInternal(schema.items, entry, refs));
+  if (schema.minItems !== undefined && result.length < schema.minItems) {
+    while (result.length < schema.minItems)
+      result.push(Create(schema.items));
+  }
+  if (schema.maxItems !== undefined && result.length > schema.maxItems) {
+    result.length = schema.maxItems;
+  }
+  return result;
+}
+function repairTuple(schema, value, refs) {
+  if (!Array.isArray(value))
+    return schema.items.map((item) => Create(item));
+  const repairedItems = schema.items.map((itemSchema, index) => index < value.length ? repairInternal(itemSchema, value[index], refs) : Create(itemSchema));
+  if (!schema.additionalItems) {
+    return repairedItems;
+  }
+  const extraItems = value.slice(schema.items.length);
+  if (schema.maxItems === undefined) {
+    return [...repairedItems, ...extraItems];
+  }
+  return [...repairedItems, ...extraItems.slice(0, Math.max(schema.maxItems - repairedItems.length, 0))];
+}
+function repairRecord(schema, value, refs) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return {};
+  const result = {};
+  Object.entries(value).forEach(([key, entryValue]) => {
+    result[key] = repairInternal(schema.value, entryValue, refs);
+  });
+  return result;
+}
+function repairUnion(schema, value, refs, context) {
+  for (const variant of schema.variants) {
+    const repaired = repairInternal(variant, value, refs, context);
+    if (Check(variant, repaired, context))
+      return repaired;
+  }
+  return schema.variants.length > 0 ? repairInternal(schema.variants[0], value, refs, context) : value;
+}
+function repairInternal(schema, value, refs, context) {
+  switch (schemaKind(schema)) {
+    case "Object":
+      return repairObject(schema, value, refs);
+    case "Array":
+      return repairArray(schema, value, refs);
+    case "Tuple":
+      return repairTuple(schema, value, refs);
+    case "Record":
+      return repairRecord(schema, value, refs);
+    case "Union":
+      return repairUnion(schema, value, refs, context);
+    case "Intersect": {
+      let result = value;
+      schema.variants.forEach((variant) => {
+        result = repairInternal(variant, result, refs, context);
+      });
+      return result;
+    }
+    case "Optional":
+      return value === undefined ? undefined : repairInternal(schema.item, value, refs, context);
+    case "Readonly":
+      return repairInternal(schema.item, value, refs, context);
+    case "Recursive": {
+      const recursiveSchema = schema;
+      const nextRefs = new Map(refs);
+      nextRefs.set(recursiveSchema.name, recursiveSchema.schema);
+      return repairInternal(recursiveSchema.schema, value, nextRefs, context);
+    }
+    case "Ref": {
+      const target = refs.get(schema.name);
+      return target === undefined ? value : repairInternal(target, value, refs, context);
+    }
+    case "Decode":
+    case "Encode":
+      return repairInternal(schema.inner, value, refs, context);
+    default:
+      return Check(schema, value, context) ? value : Create(schema);
+  }
+}
+
+// src/value/result.ts
+function TryCreate(schema, context) {
+  const created = Create(schema);
+  return Check(schema, created, context) ? { success: true, value: created } : { success: false, errors: Errors(schema, created, context) };
+}
+function TryDecode(schema, value, context) {
+  const decoded = Decode2(schema, value);
+  const encoded = Encode2(schema, decoded);
+  return Check(schema, encoded, context) ? { success: true, value: decoded } : { success: false, errors: Errors(schema, encoded, context) };
+}
+function TryEncode(schema, value, context) {
+  const encoded = Encode2(schema, value);
+  return Check(schema, encoded, context) ? { success: true, value: encoded } : { success: false, errors: Errors(schema, encoded, context) };
+}
+function TryRepair(schema, value, context) {
+  const repaired = Repair(schema, value, context);
+  return Check(schema, repaired, context) ? { success: true, value: repaired } : { success: false, errors: Errors(schema, repaired, context) };
+}
+
+// src/compile/bun-fast-path.ts
+function mergeStrategy(...strategies) {
+  return strategies.includes("bun-ffi") ? "bun-ffi" : "bun-native";
+}
+function containsBinaryPath(schema) {
+  switch (schemaKind(schema)) {
+    case "Uint8Array":
+      return true;
+    case "String":
+      return schemaStringField(schema, "format") === "base64" || schemaStringField(schema, "format") === "uint8array";
+    case "Array":
+      return containsBinaryPath(schemaSchemaField(schema, "items") ?? schemaItem(schema) ?? schema);
+    case "Tuple":
+      return schemaSchemaListField(schema, "items").some(containsBinaryPath);
+    case "Object":
+      return Object.values(schemaProperties(schema)).some(containsBinaryPath);
+    case "Optional":
+    case "Readonly":
+    case "Immutable":
+    case "Codec":
+    case "Decode":
+    case "Encode":
+    case "Refine":
+      return containsBinaryPath(schemaItemOrInner(schema) ?? schema);
+    case "Union":
+    case "Intersect":
+      return schemaVariants(schema).some(containsBinaryPath);
+    default:
+      return false;
+  }
+}
+function compilePrimitivePlan(schema, context) {
+  const current = schemaUnknownField(schema, "~kind");
+  switch (typeof current === "string" ? current : undefined) {
+    case "String":
+      return {
+        fn: (value) => typeof value === "string" && checkStringConstraints(schema, value, context),
+        strategy: "bun-native"
+      };
+    case "Number":
+      return {
+        fn: (value) => typeof value === "number" && (context.TypeSystemPolicy.Get().AllowNaN || Number.isFinite(value)) && checkNumberConstraints(schema, value),
+        strategy: "bun-native"
+      };
+    case "Integer":
+      return {
+        fn: (value) => typeof value === "number" && Number.isInteger(value) && checkNumberConstraints(schema, value),
+        strategy: "bun-native"
+      };
+    case "Boolean":
+      return { fn: (value) => typeof value === "boolean", strategy: "bun-native" };
+    case "Null":
+      return { fn: (value) => value === null, strategy: "bun-native" };
+    case "Literal":
+      return { fn: (value) => value === schemaUnknownField(schema, "const"), strategy: "bun-native" };
+    case "Unknown":
+    case "Any":
+    case "Unsafe":
+      return { fn: () => true, strategy: "bun-native" };
+    case "Never":
+      return { fn: () => false, strategy: "bun-native" };
+    case "Uint8Array": {
+      const expected = schemaUnknownField(schema, "constBytes");
+      const constBytes = expected instanceof Uint8Array ? expected : undefined;
+      const minByteLength = typeof schemaUnknownField(schema, "minByteLength") === "number" ? schemaUnknownField(schema, "minByteLength") : undefined;
+      const maxByteLength = typeof schemaUnknownField(schema, "maxByteLength") === "number" ? schemaUnknownField(schema, "maxByteLength") : undefined;
+      return {
+        fn: (value) => value instanceof Uint8Array && isUint8ArrayWithinBounds(value, minByteLength, maxByteLength) && (constBytes === undefined || areUint8ArraysEqual(value, constBytes)),
+        strategy: constBytes === undefined ? "bun-native" : "bun-ffi"
+      };
+    }
+    default:
+      return null;
+  }
+}
+function compileCollectionPlan(schema, context) {
+  switch (schemaKind(schema)) {
+    case "Array": {
+      const itemPlan = compilePlan(schemaItem(schema) ?? schema, context);
+      if (itemPlan === null)
+        return null;
+      return {
+        fn: (value) => Array.isArray(value) && value.every(itemPlan.fn),
+        strategy: itemPlan.strategy
+      };
+    }
+    case "Tuple": {
+      const itemPlans = schemaSchemaListField(schema, "items").map((entry) => compilePlan(entry, context));
+      if (itemPlans.some((plan) => plan === null))
+        return null;
+      const tuplePlans = itemPlans;
+      const minItems = schemaNumberField(schema, "minItems");
+      const maxItems = schemaNumberField(schema, "maxItems");
+      const additionalItems = schemaBooleanField(schema, "additionalItems");
+      return {
+        fn: (value) => Array.isArray(value) && (minItems === undefined || value.length >= minItems) && (maxItems === undefined || value.length <= maxItems) && value.length >= tuplePlans.length && (additionalItems === true || value.length === tuplePlans.length) && tuplePlans.every((plan, index) => plan.fn(value[index])),
+        strategy: mergeStrategy(...tuplePlans.map((plan) => plan.strategy))
+      };
+    }
+    case "Object": {
+      const additionalProperties = schemaBooleanOrSchemaField(schema, "additionalProperties");
+      if (Object.keys(schemaPatternProperties(schema)).length > 0 || typeof additionalProperties === "object") {
+        return null;
+      }
+      const properties = schemaProperties(schema);
+      if (Object.keys(schemaProperties(schema)).length === 0 && schemaUnknownField(schema, "properties") === undefined) {
+        return null;
+      }
+      const propertyEntries = Object.entries(properties).map(([key, propertySchema]) => [key, compilePlan(propertySchema, context)]);
+      if (propertyEntries.some(([, plan]) => plan === null))
+        return null;
+      const propertyPlans = new Map(propertyEntries);
+      const required = new Set(schemaRequiredKeys(schema).length > 0 ? schemaRequiredKeys(schema) : Object.keys(properties));
+      const optional = new Set(schemaOptionalKeys(schema));
+      return {
+        fn: (value) => {
+          if (typeof value !== "object" || value === null || Array.isArray(value))
+            return false;
+          const objectValue = value;
+          for (const key of required) {
+            if (!optional.has(key) && !(key in objectValue))
+              return false;
+          }
+          for (const [key, propertyValue] of Object.entries(objectValue)) {
+            const propertyPlan = propertyPlans.get(key);
+            if (propertyPlan === undefined) {
+              if (additionalProperties === false)
+                return false;
+              continue;
+            }
+            if (!propertyPlan.fn(propertyValue))
+              return false;
+          }
+          return true;
+        },
+        strategy: mergeStrategy(...Array.from(propertyPlans.values(), (plan) => plan.strategy))
+      };
+    }
+    case "Union": {
+      const variantPlans = schemaVariants(schema).map((entry) => compilePlan(entry, context));
+      if (variantPlans.some((plan) => plan === null))
+        return null;
+      const plans = variantPlans;
+      return {
+        fn: (value) => plans.some((plan) => plan.fn(value)),
+        strategy: mergeStrategy(...plans.map((plan) => plan.strategy))
+      };
+    }
+    case "Intersect": {
+      const variantPlans = schemaVariants(schema).map((entry) => compilePlan(entry, context));
+      if (variantPlans.some((plan) => plan === null))
+        return null;
+      const plans = variantPlans;
+      return {
+        fn: (value) => plans.every((plan) => plan.fn(value)),
+        strategy: mergeStrategy(...plans.map((plan) => plan.strategy))
+      };
+    }
+    default:
+      return null;
+  }
+}
+function compileWrapperPlan(schema, context) {
+  switch (schemaKind(schema)) {
+    case "Optional":
+    case "Readonly":
+    case "Immutable":
+    case "Codec":
+    case "Decode":
+    case "Encode": {
+      const innerPlan = compilePlan(schemaItemOrInner(schema) ?? schema, context);
+      if (innerPlan === null)
+        return null;
+      return {
+        fn: (value) => schemaKind(schema) === "Optional" && value === undefined ? true : innerPlan.fn(value),
+        strategy: innerPlan.strategy
+      };
+    }
+    case "Refine": {
+      if (schemaUnknownField(schema, "~uint8arrayCodec") === true) {
+        const minByteLength = typeof schemaUnknownField(schema, "minByteLength") === "number" ? schemaUnknownField(schema, "minByteLength") : undefined;
+        const maxByteLength = typeof schemaUnknownField(schema, "maxByteLength") === "number" ? schemaUnknownField(schema, "maxByteLength") : undefined;
+        const constBytes = schemaUnknownField(schema, "constBytes");
+        const normalizedBytes = constBytes instanceof Uint8Array ? constBytes : undefined;
+        const constBase64 = schemaStringField(schema, "constBase64");
+        if (constBase64 !== undefined) {
+          return {
+            fn: (value) => typeof value === "string" && value === constBase64,
+            strategy: "bun-native-const"
+          };
+        }
+        return {
+          fn: (value) => isUint8ArrayBase64String(value, minByteLength, maxByteLength, normalizedBytes, constBase64),
+          strategy: "bun-native"
+        };
+      }
+      const itemPlan = compilePlan(schemaItem(schema) ?? schema, context);
+      const refinementsValue = schemaUnknownField(schema, "~refine");
+      const refinements = Array.isArray(refinementsValue) ? refinementsValue.filter((entry) => typeof entry === "object" && entry !== null && typeof entry.refine === "function") : undefined;
+      if (itemPlan === null || refinements === undefined)
+        return null;
+      return {
+        fn: (value) => itemPlan.fn(value) && refinements.every((entry) => entry.refine(value)),
+        strategy: schemaUnknownField(schema, "constBytes") instanceof Uint8Array ? "bun-ffi" : itemPlan.strategy
+      };
+    }
+    default:
+      return null;
+  }
+}
+function compilePlan(schema, context) {
+  return compilePrimitivePlan(schema, context) ?? compileCollectionPlan(schema, context) ?? compileWrapperPlan(schema, context);
+}
+function compileBunFastPath(schema, context) {
+  if (!containsBinaryPath(schema)) {
+    return null;
+  }
+  const plan = compilePlan(schema, context);
+  if (plan === null) {
+    return null;
+  }
+  return {
+    fn: plan.fn,
+    code: `/* ${plan.strategy} binary validation path */`,
+    accelerated: true,
+    strategy: plan.strategy
+  };
+}
+
+// src/compile/emit.ts
+function emitStringCheck(schema, valueExpr) {
+  const checks = [`typeof ${valueExpr} === 'string'`];
+  if (schema.minLength !== undefined)
+    checks.push(`${valueExpr}.length >= ${schema.minLength}`);
+  if (schema.maxLength !== undefined)
+    checks.push(`${valueExpr}.length <= ${schema.maxLength}`);
+  if (schema.pattern !== undefined)
+    checks.push(`/${schema.pattern}/.test(${valueExpr})`);
+  if (schema.format !== undefined)
+    checks.push(`__validateFormat(${valueExpr}, ${JSON.stringify(schema.format)})`);
+  return checks.join(" && ");
+}
+function emitNumberCheck(schema, valueExpr) {
+  const checks = [`typeof ${valueExpr} === 'number'`, `(__policy.AllowNaN || Number.isFinite(${valueExpr}))`];
+  if (schema.minimum !== undefined)
+    checks.push(`${valueExpr} >= ${schema.minimum}`);
+  if (schema.maximum !== undefined)
+    checks.push(`${valueExpr} <= ${schema.maximum}`);
+  if (schema.exclusiveMinimum !== undefined)
+    checks.push(`${valueExpr} > ${schema.exclusiveMinimum}`);
+  if (schema.exclusiveMaximum !== undefined)
+    checks.push(`${valueExpr} < ${schema.exclusiveMaximum}`);
+  if (schema.multipleOf !== undefined)
+    checks.push(`${valueExpr} % ${schema.multipleOf} === 0`);
+  return checks.join(" && ");
+}
+function emitIntegerCheck(schema, valueExpr) {
+  const checks = [`typeof ${valueExpr} === 'number'`, `Number.isInteger(${valueExpr})`];
+  if (schema.minimum !== undefined)
+    checks.push(`${valueExpr} >= ${schema.minimum}`);
+  if (schema.maximum !== undefined)
+    checks.push(`${valueExpr} <= ${schema.maximum}`);
+  return checks.join(" && ");
+}
+function emitLiteralCheck(schema, valueExpr) {
+  return `${valueExpr} === ${JSON.stringify(schema.const)}`;
+}
+function emitArrayCheck(schema, valueExpr, emitSchema, nextVar) {
+  const itemVar = nextVar();
+  const checks = [`Array.isArray(${valueExpr})`];
+  if (schema.minItems !== undefined)
+    checks.push(`${valueExpr}.length >= ${schema.minItems}`);
+  if (schema.maxItems !== undefined)
+    checks.push(`${valueExpr}.length <= ${schema.maxItems}`);
+  checks.push(`${valueExpr}.every(${itemVar} => ${emitSchema(schema.items, itemVar)})`);
+  return checks.join(" && ");
+}
+function emitObjectCheck(schema, valueExpr, emitSchema) {
+  const checks = [
+    `typeof ${valueExpr} === 'object'`,
+    `${valueExpr} !== null`,
+    `!Array.isArray(${valueExpr})`
+  ];
+  const required = schema.required ?? Object.keys(schema.properties);
+  const optional = new Set((schema.optional ?? []).map(String));
+  for (const key of required) {
+    if (schema.properties[key] !== undefined && !optional.has(String(key))) {
+      checks.push(`'${String(key)}' in ${valueExpr}`);
+      checks.push(emitSchema(schema.properties[key], `${valueExpr}['${String(key)}']`));
+    }
+  }
+  return checks.join(" && ");
+}
+function emitVariantCheck(schema, valueExpr, emitSchema, operator) {
+  return schema.variants.map((variant) => `(${emitSchema(variant, valueExpr)})`).join(` ${operator} `);
+}
+function emitEnumCheck(schema, valueExpr) {
+  return `[${schema.values.map((value) => JSON.stringify(value)).join(",")}].includes(${valueExpr})`;
+}
+function emitUint8ArrayCheck(schema, valueExpr) {
+  return [
+    `${valueExpr} instanceof Uint8Array`,
+    schema.minByteLength !== undefined ? `${valueExpr}.byteLength >= ${schema.minByteLength}` : "true",
+    schema.maxByteLength !== undefined ? `${valueExpr}.byteLength <= ${schema.maxByteLength}` : "true"
+  ].join(" && ");
+}
+function emitPrimitiveSchemaCheck(currentSchema, valueExpr) {
+  switch (schemaKind(currentSchema)) {
+    case "String":
+      return emitStringCheck(currentSchema, valueExpr);
+    case "Number":
+      return emitNumberCheck(currentSchema, valueExpr);
+    case "Integer":
+      return emitIntegerCheck(currentSchema, valueExpr);
+    case "Boolean":
+      return `typeof ${valueExpr} === 'boolean'`;
+    case "Null":
+      return `${valueExpr} === null`;
+    case "BigInt":
+      return `typeof ${valueExpr} === 'bigint'`;
+    case "Date":
+      return `${valueExpr} instanceof Date && !isNaN(${valueExpr}.getTime())`;
+    case "Literal":
+      return emitLiteralCheck(currentSchema, valueExpr);
+    case "Void":
+      return `${valueExpr} === undefined || ${valueExpr} === null`;
+    case "Undefined":
+      return `${valueExpr} === undefined`;
+    case "Unknown":
+    case "Any":
+      return "true";
+    case "Never":
+      return "false";
+    case "Symbol":
+      return `typeof ${valueExpr} === 'symbol'`;
+    case "Function":
+      return `typeof ${valueExpr} === 'function'`;
+    case "Uint8Array":
+      return emitUint8ArrayCheck(currentSchema, valueExpr);
+    default:
+      return;
+  }
+}
+function emitStructuredSchemaCheck(currentSchema, valueExpr, emitSchema, nextVar) {
+  switch (schemaKind(currentSchema)) {
+    case "Array":
+      return emitArrayCheck(currentSchema, valueExpr, emitSchema, nextVar);
+    case "Object":
+      return emitObjectCheck(currentSchema, valueExpr, emitSchema);
+    case "Union":
+      return emitVariantCheck(currentSchema, valueExpr, emitSchema, "||");
+    case "Intersect":
+      return emitVariantCheck(currentSchema, valueExpr, emitSchema, "&&");
+    case "Optional": {
+      const item = schemaItem(currentSchema);
+      return `${valueExpr} === undefined || (${emitSchema(item ?? currentSchema, valueExpr)})`;
+    }
+    case "Readonly":
+      return emitSchema(schemaItem(currentSchema) ?? currentSchema, valueExpr);
+    case "Enum":
+      return emitEnumCheck(currentSchema, valueExpr);
+    default:
+      return;
+  }
+}
+
+// src/compile/index.ts
+var validatorCaches = new WeakMap;
+function getValidatorCache(context) {
+  const existing = validatorCaches.get(context);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const created = new Map;
+  validatorCaches.set(context, created);
+  return created;
+}
+function createCompiledFunction(body) {
+  return new Function("value", "__check", "__validateFormat", "__policy", body);
+}
+function createPortableArtifact(schema) {
+  let varCounter = 0;
+  function nextVar() {
+    return `v${varCounter++}`;
+  }
+  function emit(currentSchema, valueExpr) {
+    return emitPrimitiveSchemaCheck(currentSchema, valueExpr) ?? emitStructuredSchemaCheck(currentSchema, valueExpr, emit, nextVar) ?? `__check(${valueExpr})`;
+  }
+  const body = `return ${emit(schema, "value")};`;
+  return {
+    body,
+    code: `(function(value, __check, __validateFormat, __policy) { ${body} })`
+  };
+}
+function compileFromBody(schema, context, body, code, strategy) {
+  const compiled = createCompiledFunction(body);
+  const fallbackCheck = (value) => Check(schema, value, context);
+  const runtimeValidateFormat = (value, format) => validateFormat(value, format, context);
+  return {
+    accelerated: true,
+    body,
+    code,
+    fn: (value) => compiled(value, fallbackCheck, runtimeValidateFormat, context.TypeSystemPolicy.Get()),
+    strategy
+  };
+}
+function compileSchema(schema, context) {
+  const artifact = createPortableArtifact(schema);
+  return compileFromBody(schema, context, artifact.body, artifact.code, "jit");
+}
+function schemaHash(schema) {
+  return Hash(schema).toString(16);
+}
+function resolveCompileOptions(options) {
+  if (options instanceof RuntimeContext) {
+    return {
+      artifact: undefined,
+      cache: true,
+      context: resolveRuntimeContext(options)
+    };
+  }
+  return {
+    artifact: options?.artifact,
+    cache: options?.cache ?? true,
+    context: resolveRuntimeContext(options?.context)
+  };
+}
+
+class Validator {
+  schema;
+  context;
+  hash;
+  artifact;
+  result;
+  constructor(schema, context, hash, artifact, result) {
+    this.schema = schema;
+    this.context = context;
+    this.hash = hash;
+    this.artifact = artifact;
+    this.result = result;
+  }
+  Artifact() {
+    return this.artifact;
+  }
+  Check(value) {
+    return this.result.fn(value);
+  }
+  Clean(value) {
+    return Clean(this.schema, value);
+  }
+  Code() {
+    return this.result.code;
+  }
+  Context() {
+    return this.context;
+  }
+  Convert(value) {
+    return Convert(this.schema, value);
+  }
+  Create() {
+    return Create(this.schema);
+  }
+  Decode(value) {
+    return Decode2(this.schema, value);
+  }
+  Default(value) {
+    return Default(this.schema, value);
+  }
+  Encode(value) {
+    return Encode2(this.schema, value);
+  }
+  Errors(value) {
+    return Errors(this.schema, value, this.context);
+  }
+  Explain(value) {
+    return Explain(this.schema, value, this.context);
+  }
+  Hash() {
+    return this.hash;
+  }
+  IsAccelerated() {
+    return this.result.accelerated;
+  }
+  Parse(value) {
+    return Parse(this.schema, value, this.context);
+  }
+  Repair(value) {
+    return Repair(this.schema, value, this.context);
+  }
+  Strategy() {
+    return this.result.strategy;
+  }
+  TryCreate() {
+    return TryCreate(this.schema, this.context);
+  }
+  TryDecode(value) {
+    return TryDecode(this.schema, value, this.context);
+  }
+  TryEncode(value) {
+    return TryEncode(this.schema, value, this.context);
+  }
+  TryParse(value) {
+    return TryParse(this.schema, value, this.context);
+  }
+  TryRepair(value) {
+    return TryRepair(this.schema, value, this.context);
+  }
+}
+function Compile(schema, options) {
+  const resolved = resolveCompileOptions(options);
+  const hash = schemaHash(schema);
+  const artifact = resolved.artifact;
+  const cacheKey = [
+    resolved.context.CacheKey("compile"),
+    hash,
+    artifact?.hash ?? "live"
+  ].join(":");
+  if (resolved.cache) {
+    const cache = getValidatorCache(resolved.context);
+    const cached = cache.get(cacheKey);
+    if (cached !== undefined) {
+      return cached;
+    }
+  }
+  const portable = createPortableArtifact(schema);
+  const artifactValue = {
+    ...portable,
+    hash
+  };
+  const fastPath = compileBunFastPath(schema, resolved.context);
+  const compileResult = artifact !== undefined && artifact.hash === hash ? compileFromBody(schema, resolved.context, artifact.body, artifact.code, "artifact") : fastPath !== null ? { ...fastPath, body: portable.body } : compileSchema(schema, resolved.context);
+  const validator = new Validator(schema, resolved.context, hash, artifactValue, compileResult);
+  if (resolved.cache) {
+    getValidatorCache(resolved.context).set(cacheKey, validator);
+  }
+  return validator;
+}
+function Code(schema, options) {
+  return options === undefined ? Compile(schema).Code() : Compile(schema, options).Code();
+}
+var compile_default = Compile;
+export {
+  compile_default as default,
+  Validator,
+  Compile,
+  Code
+};
+
+//# debugId=4D751EE28C800EEA64756E2164756E21
+//# sourceMappingURL=index.js.map