@rexeus/typeweaver-types 0.1.2 → 0.2.1

package/dist/index.js

@@ -349,6 +349,8 @@ function isPlainObject(o) {
 function shallowClone(o) {
   if (isPlainObject(o))
     return { ...o };
+  if (Array.isArray(o))
+    return [...o];
   return o;
 }
 function numKeys(data) {
@@ -1062,14 +1064,14 @@ const email$1 = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-
 const html5Email = /^[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])?)*$/;
 const rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
 const unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
-const idnEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
+const idnEmail = unicodeEmail;
 const browserEmail = /^[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])?)*$/;
 const _emoji$1 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
 function emoji$1() {
   return new RegExp(_emoji$1, "u");
 }
 const ipv4$1 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
-const ipv6$1 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/;
+const ipv6$1 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
 const cidrv4$1 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
 const cidrv6$1 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 const base64$1 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
@@ -1101,12 +1103,12 @@ const string$2 = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
 };
-const bigint$2 = /^\d+n?$/;
-const integer = /^\d+$/;
-const number$2 = /^-?\d+(?:\.\d+)?/i;
-const boolean$2 = /true|false/i;
-const _null$2 = /null/i;
-const _undefined$2 = /undefined/i;
+const bigint$2 = /^-?\d+n?$/;
+const integer = /^-?\d+$/;
+const number$2 = /^-?\d+(?:\.\d+)?/;
+const boolean$2 = /^(?:true|false)$/i;
+const _null$2 = /^null$/i;
+const _undefined$2 = /^undefined$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
 const hex$1 = /^[0-9a-fA-F]*$/;
@@ -1114,7 +1116,7 @@ function fixedBase64(bodyLength, padding) {
   return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
 }
 function fixedBase64url(length) {
-  return new RegExp(`^[A-Za-z0-9-_]{${length}}$`);
+  return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
 }
 const md5_hex = /^[0-9a-fA-F]{32}$/;
 const md5_base64 = /* @__PURE__ */ fixedBase64(22, "==");
@@ -1772,7 +1774,7 @@ class Doc {
 const version = {
   major: 4,
   minor: 1,
-  patch: 5
+  patch: 11
 };
 
 const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
@@ -2068,8 +2070,11 @@ const $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
   def.pattern ?? (def.pattern = cidrv6$1);
   $ZodStringFormat.init(inst, def);
   inst._zod.check = (payload) => {
-    const [address, prefix] = payload.value.split("/");
+    const parts = payload.value.split("/");
     try {
+      if (parts.length !== 2)
+        throw new Error();
+      const [address, prefix] = parts;
       if (!prefix)
         throw new Error();
       const prefixNum = Number(prefix);
@@ -2433,7 +2438,7 @@ function handlePropertyResult(result, final, key, input) {
 function normalizeDef(def) {
   const keys = Object.keys(def.shape);
   for (const k of keys) {
-    if (!def.shape[k]._zod.traits.has("$ZodType")) {
+    if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
       throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
     }
   }
@@ -2481,6 +2486,19 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
 }
 const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   $ZodType.init(inst, def);
+  const desc = Object.getOwnPropertyDescriptor(def, "shape");
+  if (!desc?.get) {
+    const sh = def.shape;
+    Object.defineProperty(def, "shape", {
+      get: () => {
+        const newSh = { ...sh };
+        Object.defineProperty(def, "shape", {
+          value: newSh
+        });
+        return newSh;
+      }
+    });
+  }
   const _normalized = cached(() => normalizeDef(def));
   defineLazy(inst._zod, "propValues", () => {
     const shape = def.shape;
@@ -2545,7 +2563,7 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
     for (const key of normalized.keys) {
       ids[key] = `key_${counter++}`;
     }
-    doc.write(`const newResult = {}`);
+    doc.write(`const newResult = {};`);
     for (const key of normalized.keys) {
       const id = ids[key];
       const k = esc(key);
@@ -2558,6 +2576,7 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
           })));
         }
         
+        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -2565,6 +2584,7 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
         } else {
           newResult[${k}] = ${id}.value;
         }
+        
       `);
     }
     doc.write(`payload.value = newResult;`);
@@ -3601,7 +3621,7 @@ function handleRefineResult(result, payload, input, inst) {
   }
 }
 
-const error$F = () => {
+const error$H = () => {
   const Sizable = {
     string: { unit: "\u062D\u0631\u0641", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
     file: { unit: "\u0628\u0627\u064A\u062A", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
@@ -3713,11 +3733,11 @@ const error$F = () => {
 };
 function ar() {
   return {
-    localeError: error$F()
+    localeError: error$H()
   };
 }
 
-const error$E = () => {
+const error$G = () => {
   const Sizable = {
     string: { unit: "simvol", verb: "olmal\u0131d\u0131r" },
     file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
@@ -3828,7 +3848,7 @@ const error$E = () => {
 };
 function az() {
   return {
-    localeError: error$E()
+    localeError: error$G()
   };
 }
 
@@ -3847,7 +3867,7 @@ function getBelarusianPlural(count, one, few, many) {
   }
   return many;
 }
-const error$D = () => {
+const error$F = () => {
   const Sizable = {
     string: {
       unit: {
@@ -3992,11 +4012,11 @@ const error$D = () => {
 };
 function be() {
   return {
-    localeError: error$D()
+    localeError: error$F()
   };
 }
 
-const error$C = () => {
+const error$E = () => {
   const Sizable = {
     string: { unit: "car\xE0cters", verb: "contenir" },
     file: { unit: "bytes", verb: "contenir" },
@@ -4111,11 +4131,11 @@ const error$C = () => {
 };
 function ca() {
   return {
-    localeError: error$C()
+    localeError: error$E()
   };
 }
 
-const error$B = () => {
+const error$D = () => {
   const Sizable = {
     string: { unit: "znak\u016F", verb: "m\xEDt" },
     file: { unit: "bajt\u016F", verb: "m\xEDt" },
@@ -4246,11 +4266,11 @@ const error$B = () => {
 };
 function cs() {
   return {
-    localeError: error$B()
+    localeError: error$D()
   };
 }
 
-const error$A = () => {
+const error$C = () => {
   const Sizable = {
     string: { unit: "tegn", verb: "havde" },
     file: { unit: "bytes", verb: "havde" },
@@ -4377,11 +4397,11 @@ const error$A = () => {
 };
 function da() {
   return {
-    localeError: error$A()
+    localeError: error$C()
   };
 }
 
-const error$z = () => {
+const error$B = () => {
   const Sizable = {
     string: { unit: "Zeichen", verb: "zu haben" },
     file: { unit: "Bytes", verb: "zu haben" },
@@ -4493,11 +4513,11 @@ const error$z = () => {
 };
 function de() {
   return {
-    localeError: error$z()
+    localeError: error$B()
   };
 }
 
-const parsedType$3 = (data) => {
+const parsedType$5 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -4517,7 +4537,7 @@ const parsedType$3 = (data) => {
   }
   return t;
 };
-const error$y = () => {
+const error$A = () => {
   const Sizable = {
     string: { unit: "characters", verb: "to have" },
     file: { unit: "bytes", verb: "to have" },
@@ -4560,7 +4580,7 @@ const error$y = () => {
   return (issue) => {
     switch (issue.code) {
       case "invalid_type":
-        return `Invalid input: expected ${issue.expected}, received ${parsedType$3(issue.input)}`;
+        return `Invalid input: expected ${issue.expected}, received ${parsedType$5(issue.input)}`;
       case "invalid_value":
         if (issue.values.length === 1)
           return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;
@@ -4610,11 +4630,11 @@ const error$y = () => {
 };
 function en() {
   return {
-    localeError: error$y()
+    localeError: error$A()
   };
 }
 
-const parsedType$2 = (data) => {
+const parsedType$4 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -4634,7 +4654,7 @@ const parsedType$2 = (data) => {
   }
   return t;
 };
-const error$x = () => {
+const error$z = () => {
   const Sizable = {
     string: { unit: "karaktrojn", verb: "havi" },
     file: { unit: "bajtojn", verb: "havi" },
@@ -4677,7 +4697,7 @@ const error$x = () => {
   return (issue) => {
     switch (issue.code) {
       case "invalid_type":
-        return `Nevalida enigo: atendi\u011Dis ${issue.expected}, ricevi\u011Dis ${parsedType$2(issue.input)}`;
+        return `Nevalida enigo: atendi\u011Dis ${issue.expected}, ricevi\u011Dis ${parsedType$4(issue.input)}`;
       case "invalid_value":
         if (issue.values.length === 1)
           return `Nevalida enigo: atendi\u011Dis ${stringifyPrimitive(issue.values[0])}`;
@@ -4726,36 +4746,66 @@ const error$x = () => {
 };
 function eo() {
   return {
-    localeError: error$x()
+    localeError: error$z()
   };
 }
 
-const error$w = () => {
+const error$y = () => {
   const Sizable = {
     string: { unit: "caracteres", verb: "tener" },
     file: { unit: "bytes", verb: "tener" },
     array: { unit: "elementos", verb: "tener" },
     set: { unit: "elementos", verb: "tener" }
   };
+  const TypeNames = {
+    string: "texto",
+    number: "n\xFAmero",
+    boolean: "booleano",
+    array: "arreglo",
+    object: "objeto",
+    set: "conjunto",
+    file: "archivo",
+    date: "fecha",
+    bigint: "n\xFAmero grande",
+    symbol: "s\xEDmbolo",
+    undefined: "indefinido",
+    null: "nulo",
+    function: "funci\xF3n",
+    map: "mapa",
+    record: "registro",
+    tuple: "tupla",
+    enum: "enumeraci\xF3n",
+    union: "uni\xF3n",
+    literal: "literal",
+    promise: "promesa",
+    void: "vac\xEDo",
+    never: "nunca",
+    unknown: "desconocido",
+    any: "cualquiera"
+  };
   function getSizing(origin) {
     return Sizable[origin] ?? null;
   }
+  function getTypeName(type) {
+    return TypeNames[type] ?? type;
+  }
   const parsedType = (data) => {
     const t = typeof data;
     switch (t) {
       case "number": {
-        return Number.isNaN(data) ? "NaN" : "n\xFAmero";
+        return Number.isNaN(data) ? "NaN" : "number";
       }
       case "object": {
         if (Array.isArray(data)) {
-          return "arreglo";
+          return "array";
         }
         if (data === null) {
-          return "nulo";
+          return "null";
         }
         if (Object.getPrototypeOf(data) !== Object.prototype) {
           return data.constructor.name;
         }
+        return "object";
       }
     }
     return t;
@@ -4793,7 +4843,7 @@ const error$w = () => {
   return (issue) => {
     switch (issue.code) {
       case "invalid_type":
-        return `Entrada inv\xE1lida: se esperaba ${issue.expected}, recibido ${parsedType(issue.input)}`;
+        return `Entrada inv\xE1lida: se esperaba ${getTypeName(issue.expected)}, recibido ${getTypeName(parsedType(issue.input))}`;
       // return `Entrada inválida: se esperaba ${issue.expected}, recibido ${util.getParsedType(issue.input)}`;
       case "invalid_value":
         if (issue.values.length === 1)
@@ -4802,17 +4852,19 @@ const error$w = () => {
       case "too_big": {
         const adj = issue.inclusive ? "<=" : "<";
         const sizing = getSizing(issue.origin);
+        const origin = getTypeName(issue.origin);
         if (sizing)
-          return `Demasiado grande: se esperaba que ${issue.origin ?? "valor"} tuviera ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementos"}`;
-        return `Demasiado grande: se esperaba que ${issue.origin ?? "valor"} fuera ${adj}${issue.maximum.toString()}`;
+          return `Demasiado grande: se esperaba que ${origin ?? "valor"} tuviera ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementos"}`;
+        return `Demasiado grande: se esperaba que ${origin ?? "valor"} fuera ${adj}${issue.maximum.toString()}`;
       }
       case "too_small": {
         const adj = issue.inclusive ? ">=" : ">";
         const sizing = getSizing(issue.origin);
+        const origin = getTypeName(issue.origin);
         if (sizing) {
-          return `Demasiado peque\xF1o: se esperaba que ${issue.origin} tuviera ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+          return `Demasiado peque\xF1o: se esperaba que ${origin} tuviera ${adj}${issue.minimum.toString()} ${sizing.unit}`;
         }
-        return `Demasiado peque\xF1o: se esperaba que ${issue.origin} fuera ${adj}${issue.minimum.toString()}`;
+        return `Demasiado peque\xF1o: se esperaba que ${origin} fuera ${adj}${issue.minimum.toString()}`;
       }
       case "invalid_format": {
         const _issue = issue;
@@ -4831,11 +4883,11 @@ const error$w = () => {
       case "unrecognized_keys":
         return `Llave${issue.keys.length > 1 ? "s" : ""} desconocida${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
       case "invalid_key":
-        return `Llave inv\xE1lida en ${issue.origin}`;
+        return `Llave inv\xE1lida en ${getTypeName(issue.origin)}`;
       case "invalid_union":
         return "Entrada inv\xE1lida";
       case "invalid_element":
-        return `Valor inv\xE1lido en ${issue.origin}`;
+        return `Valor inv\xE1lido en ${getTypeName(issue.origin)}`;
       default:
         return `Entrada inv\xE1lida`;
     }
@@ -4843,11 +4895,11 @@ const error$w = () => {
 };
 function es() {
   return {
-    localeError: error$w()
+    localeError: error$y()
   };
 }
 
-const error$v = () => {
+const error$x = () => {
   const Sizable = {
     string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
     file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
@@ -4965,11 +5017,11 @@ const error$v = () => {
 };
 function fa() {
   return {
-    localeError: error$v()
+    localeError: error$x()
   };
 }
 
-const error$u = () => {
+const error$w = () => {
   const Sizable = {
     string: { unit: "merkki\xE4", subject: "merkkijonon" },
     file: { unit: "tavua", subject: "tiedoston" },
@@ -5087,11 +5139,11 @@ const error$u = () => {
 };
 function fi() {
   return {
-    localeError: error$u()
+    localeError: error$w()
   };
 }
 
-const error$t = () => {
+const error$v = () => {
   const Sizable = {
     string: { unit: "caract\xE8res", verb: "avoir" },
     file: { unit: "octets", verb: "avoir" },
@@ -5203,11 +5255,11 @@ const error$t = () => {
 };
 function fr() {
   return {
-    localeError: error$t()
+    localeError: error$v()
   };
 }
 
-const error$s = () => {
+const error$u = () => {
   const Sizable = {
     string: { unit: "caract\xE8res", verb: "avoir" },
     file: { unit: "octets", verb: "avoir" },
@@ -5320,11 +5372,11 @@ const error$s = () => {
 };
 function frCA() {
   return {
-    localeError: error$s()
+    localeError: error$u()
   };
 }
 
-const error$r = () => {
+const error$t = () => {
   const Sizable = {
     string: { unit: "\u05D0\u05D5\u05EA\u05D9\u05D5\u05EA", verb: "\u05DC\u05DB\u05DC\u05D5\u05DC" },
     file: { unit: "\u05D1\u05D9\u05D9\u05D8\u05D9\u05DD", verb: "\u05DC\u05DB\u05DC\u05D5\u05DC" },
@@ -5437,11 +5489,11 @@ const error$r = () => {
 };
 function he() {
   return {
-    localeError: error$r()
+    localeError: error$t()
   };
 }
 
-const error$q = () => {
+const error$s = () => {
   const Sizable = {
     string: { unit: "karakter", verb: "legyen" },
     file: { unit: "byte", verb: "legyen" },
@@ -5554,11 +5606,11 @@ const error$q = () => {
 };
 function hu() {
   return {
-    localeError: error$q()
+    localeError: error$s()
   };
 }
 
-const error$p = () => {
+const error$r = () => {
   const Sizable = {
     string: { unit: "karakter", verb: "memiliki" },
     file: { unit: "byte", verb: "memiliki" },
@@ -5670,11 +5722,11 @@ const error$p = () => {
 };
 function id() {
   return {
-    localeError: error$p()
+    localeError: error$r()
   };
 }
 
-const parsedType$1 = (data) => {
+const parsedType$3 = (data) => {
   const t = typeof data;
   switch (t) {
     case "number": {
@@ -5694,7 +5746,7 @@ const parsedType$1 = (data) => {
   }
   return t;
 };
-const error$o = () => {
+const error$q = () => {
   const Sizable = {
     string: { unit: "stafi", verb: "a\xF0 hafa" },
     file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
@@ -5737,7 +5789,7 @@ const error$o = () => {
   return (issue) => {
     switch (issue.code) {
       case "invalid_type":
-        return `Rangt gildi: \xDE\xFA sl\xF3st inn ${parsedType$1(issue.input)} \xFEar sem \xE1 a\xF0 vera ${issue.expected}`;
+        return `Rangt gildi: \xDE\xFA sl\xF3st inn ${parsedType$3(issue.input)} \xFEar sem \xE1 a\xF0 vera ${issue.expected}`;
       case "invalid_value":
         if (issue.values.length === 1)
           return `Rangt gildi: gert r\xE1\xF0 fyrir ${stringifyPrimitive(issue.values[0])}`;
@@ -5787,11 +5839,11 @@ const error$o = () => {
 };
 function is() {
   return {
-    localeError: error$o()
+    localeError: error$q()
   };
 }
 
-const error$n = () => {
+const error$p = () => {
   const Sizable = {
     string: { unit: "caratteri", verb: "avere" },
     file: { unit: "byte", verb: "avere" },
@@ -5904,11 +5956,11 @@ const error$n = () => {
 };
 function it() {
   return {
-    localeError: error$n()
+    localeError: error$p()
   };
 }
 
-const error$m = () => {
+const error$o = () => {
   const Sizable = {
     string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
     file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
@@ -6019,11 +6071,136 @@ const error$m = () => {
 };
 function ja() {
   return {
-    localeError: error$m()
+    localeError: error$o()
   };
 }
 
-const error$l = () => {
+const parsedType$2 = (data) => {
+  const t = typeof data;
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "NaN" : "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8";
+    }
+    case "object": {
+      if (Array.isArray(data)) {
+        return "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8";
+      }
+      if (data === null) {
+        return "null";
+      }
+      if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+        return data.constructor.name;
+      }
+    }
+  }
+  const typeMap = {
+    string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
+    boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
+    undefined: "undefined",
+    bigint: "bigint",
+    symbol: "symbol",
+    function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0"
+  };
+  return typeMap[t] ?? t;
+};
+const error$n = () => {
+  const Sizable = {
+    string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
+    file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
+    array: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
+    set: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" }
+  };
+  function getSizing(origin) {
+    return Sizable[origin] ?? null;
+  }
+  const Nouns = {
+    regex: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0",
+    email: "\u10D4\u10DA-\u10E4\u10DD\u10E1\u10E2\u10D8\u10E1 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
+    url: "URL",
+    emoji: "\u10D4\u10DB\u10DD\u10EF\u10D8",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8-\u10D3\u10E0\u10DD",
+    date: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8",
+    time: "\u10D3\u10E0\u10DD",
+    duration: "\u10EE\u10D0\u10DC\u10D2\u10E0\u10EB\u10DA\u10D8\u10D5\u10DD\u10D1\u10D0",
+    ipv4: "IPv4 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
+    ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
+    cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
+    cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
+    base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
+    base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
+    json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
+    e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
+    jwt: "JWT",
+    template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
+  };
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type":
+        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue.expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${parsedType$2(issue.input)}`;
+      case "invalid_value":
+        if (issue.values.length === 1)
+          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${stringifyPrimitive(issue.values[0])}`;
+        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D0\u10E0\u10D8\u10D0\u10DC\u10E2\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8\u10D0 \u10D4\u10E0\u10D7-\u10D4\u10E0\u10D7\u10D8 ${joinValues(issue.values, "|")}-\u10D3\u10D0\u10DC`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} ${sizing.verb} ${adj}${issue.maximum.toString()} ${sizing.unit}`;
+        return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue.origin} ${sizing.verb} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+        }
+        return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue.origin} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue;
+        if (_issue.format === "starts_with") {
+          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
+        }
+        if (_issue.format === "ends_with")
+          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
+        if (_issue.format === "includes")
+          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
+        if (_issue.format === "regex")
+          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
+        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${Nouns[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E0\u10D8\u10EA\u10EE\u10D5\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10E7\u10DD\u10E1 ${issue.divisor}-\u10D8\u10E1 \u10EF\u10D4\u10E0\u10D0\u10D3\u10D8`;
+      case "unrecognized_keys":
+        return `\u10E3\u10EA\u10DC\u10DD\u10D1\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1${issue.keys.length > 1 ? "\u10D4\u10D1\u10D8" : "\u10D8"}: ${joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1\u10D8 ${issue.origin}-\u10E8\u10D8`;
+      case "invalid_union":
+        return "\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0";
+      case "invalid_element":
+        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0 ${issue.origin}-\u10E8\u10D8`;
+      default:
+        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0`;
+    }
+  };
+};
+function ka() {
+  return {
+    localeError: error$n()
+  };
+}
+
+const error$m = () => {
   const Sizable = {
     string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
     file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
@@ -6134,13 +6311,17 @@ const error$l = () => {
     }
   };
 };
-function kh() {
+function km() {
   return {
-    localeError: error$l()
+    localeError: error$m()
   };
 }
 
-const error$k = () => {
+function kh() {
+  return km();
+}
+
+const error$l = () => {
   const Sizable = {
     string: { unit: "\uBB38\uC790", verb: "to have" },
     file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
@@ -6256,6 +6437,236 @@ const error$k = () => {
   };
 };
 function ko() {
+  return {
+    localeError: error$l()
+  };
+}
+
+const parsedType$1 = (data) => {
+  const t = typeof data;
+  return parsedTypeFromType(t, data);
+};
+const parsedTypeFromType = (t, data = void 0) => {
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "NaN" : "skai\u010Dius";
+    }
+    case "bigint": {
+      return "sveikasis skai\u010Dius";
+    }
+    case "string": {
+      return "eilut\u0117";
+    }
+    case "boolean": {
+      return "login\u0117 reik\u0161m\u0117";
+    }
+    case "undefined":
+    case "void": {
+      return "neapibr\u0117\u017Eta reik\u0161m\u0117";
+    }
+    case "function": {
+      return "funkcija";
+    }
+    case "symbol": {
+      return "simbolis";
+    }
+    case "object": {
+      if (data === void 0)
+        return "ne\u017Einomas objektas";
+      if (data === null)
+        return "nulin\u0117 reik\u0161m\u0117";
+      if (Array.isArray(data))
+        return "masyvas";
+      if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+        return data.constructor.name;
+      }
+      return "objektas";
+    }
+    //Zod types below
+    case "null": {
+      return "nulin\u0117 reik\u0161m\u0117";
+    }
+  }
+  return t;
+};
+const capitalizeFirstCharacter = (text) => {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+};
+function getUnitTypeFromNumber(number) {
+  const abs = Math.abs(number);
+  const last = abs % 10;
+  const last2 = abs % 100;
+  if (last2 >= 11 && last2 <= 19 || last === 0)
+    return "many";
+  if (last === 1)
+    return "one";
+  return "few";
+}
+const error$k = () => {
+  const Sizable = {
+    string: {
+      unit: {
+        one: "simbolis",
+        few: "simboliai",
+        many: "simboli\u0173"
+      },
+      verb: {
+        smaller: {
+          inclusive: "turi b\u016Bti ne ilgesn\u0117 kaip",
+          notInclusive: "turi b\u016Bti trumpesn\u0117 kaip"
+        },
+        bigger: {
+          inclusive: "turi b\u016Bti ne trumpesn\u0117 kaip",
+          notInclusive: "turi b\u016Bti ilgesn\u0117 kaip"
+        }
+      }
+    },
+    file: {
+      unit: {
+        one: "baitas",
+        few: "baitai",
+        many: "bait\u0173"
+      },
+      verb: {
+        smaller: {
+          inclusive: "turi b\u016Bti ne didesnis kaip",
+          notInclusive: "turi b\u016Bti ma\u017Eesnis kaip"
+        },
+        bigger: {
+          inclusive: "turi b\u016Bti ne ma\u017Eesnis kaip",
+          notInclusive: "turi b\u016Bti didesnis kaip"
+        }
+      }
+    },
+    array: {
+      unit: {
+        one: "element\u0105",
+        few: "elementus",
+        many: "element\u0173"
+      },
+      verb: {
+        smaller: {
+          inclusive: "turi tur\u0117ti ne daugiau kaip",
+          notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
+        },
+        bigger: {
+          inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
+          notInclusive: "turi tur\u0117ti daugiau kaip"
+        }
+      }
+    },
+    set: {
+      unit: {
+        one: "element\u0105",
+        few: "elementus",
+        many: "element\u0173"
+      },
+      verb: {
+        smaller: {
+          inclusive: "turi tur\u0117ti ne daugiau kaip",
+          notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
+        },
+        bigger: {
+          inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
+          notInclusive: "turi tur\u0117ti daugiau kaip"
+        }
+      }
+    }
+  };
+  function getSizing(origin, unitType, inclusive, targetShouldBe) {
+    const result = Sizable[origin] ?? null;
+    if (result === null)
+      return result;
+    return {
+      unit: result.unit[unitType],
+      verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
+    };
+  }
+  const Nouns = {
+    regex: "\u012Fvestis",
+    email: "el. pa\u0161to adresas",
+    url: "URL",
+    emoji: "jaustukas",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO data ir laikas",
+    date: "ISO data",
+    time: "ISO laikas",
+    duration: "ISO trukm\u0117",
+    ipv4: "IPv4 adresas",
+    ipv6: "IPv6 adresas",
+    cidrv4: "IPv4 tinklo prefiksas (CIDR)",
+    cidrv6: "IPv6 tinklo prefiksas (CIDR)",
+    base64: "base64 u\u017Ekoduota eilut\u0117",
+    base64url: "base64url u\u017Ekoduota eilut\u0117",
+    json_string: "JSON eilut\u0117",
+    e164: "E.164 numeris",
+    jwt: "JWT",
+    template_literal: "\u012Fvestis"
+  };
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type":
+        return `Gautas tipas ${parsedType$1(issue.input)}, o tik\u0117tasi - ${parsedTypeFromType(issue.expected)}`;
+      case "invalid_value":
+        if (issue.values.length === 1)
+          return `Privalo b\u016Bti ${stringifyPrimitive(issue.values[0])}`;
+        return `Privalo b\u016Bti vienas i\u0161 ${joinValues(issue.values, "|")} pasirinkim\u0173`;
+      case "too_big": {
+        const origin = parsedTypeFromType(issue.origin);
+        const sizing = getSizing(issue.origin, getUnitTypeFromNumber(Number(issue.maximum)), issue.inclusive ?? false, "smaller");
+        if (sizing?.verb)
+          return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue.maximum.toString()} ${sizing.unit ?? "element\u0173"}`;
+        const adj = issue.inclusive ? "ne didesnis kaip" : "ma\u017Eesnis kaip";
+        return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue.maximum.toString()} ${sizing?.unit}`;
+      }
+      case "too_small": {
+        const origin = parsedTypeFromType(issue.origin);
+        const sizing = getSizing(issue.origin, getUnitTypeFromNumber(Number(issue.minimum)), issue.inclusive ?? false, "bigger");
+        if (sizing?.verb)
+          return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue.minimum.toString()} ${sizing.unit ?? "element\u0173"}`;
+        const adj = issue.inclusive ? "ne ma\u017Eesnis kaip" : "didesnis kaip";
+        return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue.minimum.toString()} ${sizing?.unit}`;
+      }
+      case "invalid_format": {
+        const _issue = issue;
+        if (_issue.format === "starts_with") {
+          return `Eilut\u0117 privalo prasid\u0117ti "${_issue.prefix}"`;
+        }
+        if (_issue.format === "ends_with")
+          return `Eilut\u0117 privalo pasibaigti "${_issue.suffix}"`;
+        if (_issue.format === "includes")
+          return `Eilut\u0117 privalo \u012Ftraukti "${_issue.includes}"`;
+        if (_issue.format === "regex")
+          return `Eilut\u0117 privalo atitikti ${_issue.pattern}`;
+        return `Neteisingas ${Nouns[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Skai\u010Dius privalo b\u016Bti ${issue.divisor} kartotinis.`;
+      case "unrecognized_keys":
+        return `Neatpa\u017Eint${issue.keys.length > 1 ? "i" : "as"} rakt${issue.keys.length > 1 ? "ai" : "as"}: ${joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return "Rastas klaidingas raktas";
+      case "invalid_union":
+        return "Klaidinga \u012Fvestis";
+      case "invalid_element": {
+        const origin = parsedTypeFromType(issue.origin);
+        return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reik\u0161m\u0117")} turi klaiding\u0105 \u012Fvest\u012F`;
+      }
+      default:
+        return "Klaidinga \u012Fvestis";
+    }
+  };
+};
+function lt() {
   return {
     localeError: error$k()
   };
@@ -8059,12 +8470,16 @@ const error$5 = () => {
     }
   };
 };
-function ua() {
+function uk() {
   return {
     localeError: error$5()
   };
 }
 
+function ua() {
+  return uk();
+}
+
 const error$4 = () => {
   const Sizable = {
     string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
@@ -8668,8 +9083,11 @@ var index$1 = /*#__PURE__*/Object.freeze({
   is: is,
   it: it,
   ja: ja,
+  ka: ka,
   kh: kh,
+  km: km,
   ko: ko,
+  lt: lt,
   mk: mk,
   ms: ms,
   nl: nl,
@@ -8685,6 +9103,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
   th: th,
   tr: tr,
   ua: ua,
+  uk: uk,
   ur: ur,
   vi: vi,
   yo: yo,
@@ -8696,7 +9115,7 @@ const $output = Symbol("ZodOutput");
 const $input = Symbol("ZodInput");
 class $ZodRegistry {
   constructor() {
-    this._map = /* @__PURE__ */ new Map();
+    this._map = /* @__PURE__ */ new WeakMap();
     this._idmap = /* @__PURE__ */ new Map();
   }
   add(schema, ..._meta) {
@@ -8711,7 +9130,7 @@ class $ZodRegistry {
     return this;
   }
   clear() {
-    this._map = /* @__PURE__ */ new Map();
+    this._map = /* @__PURE__ */ new WeakMap();
     this._idmap = /* @__PURE__ */ new Map();
     return this;
   }
@@ -10799,16 +11218,12 @@ const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   inst.type = def.type;
   Object.defineProperty(inst, "_def", { value: def });
   inst.check = (...checks2) => {
-    return inst.clone(
-      {
-        ...def,
-        checks: [
-          ...def.checks ?? [],
-          ...checks2.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
-        ]
-      }
-      // { parent: true }
-    );
+    return inst.clone(mergeDefs(def, {
+      checks: [
+        ...def.checks ?? [],
+        ...checks2.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
+      ]
+    }));
   };
   inst.clone = (def2, params) => clone(inst, def2, params);
   inst.brand = () => inst;
@@ -11267,7 +11682,9 @@ function keyof(schema) {
 const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   $ZodObjectJIT.init(inst, def);
   ZodType.init(inst, def);
-  defineLazy(inst, "shape", () => def.shape);
+  defineLazy(inst, "shape", () => {
+    return def.shape;
+  });
   inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
   inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
   inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
@@ -11289,10 +11706,7 @@ const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
 function object(shape, params) {
   const def = {
     type: "object",
-    get shape() {
-      assignProp(this, "shape", shape ? objectClone(shape) : {});
-      return this.shape;
-    },
+    shape: shape ?? {},
     ...normalizeParams(params)
   };
   return new ZodObject(def);
@@ -11300,10 +11714,7 @@ function object(shape, params) {
 function strictObject(shape, params) {
   return new ZodObject({
     type: "object",
-    get shape() {
-      assignProp(this, "shape", objectClone(shape));
-      return this.shape;
-    },
+    shape,
     catchall: never(),
     ...normalizeParams(params)
   });
@@ -11311,10 +11722,7 @@ function strictObject(shape, params) {
 function looseObject(shape, params) {
   return new ZodObject({
     type: "object",
-    get shape() {
-      assignProp(this, "shape", objectClone(shape));
-      return this.shape;
-    },
+    shape,
     catchall: unknown(),
     ...normalizeParams(params)
   });

package/dist/lib/ResponseValidator.ts

@@ -5,7 +5,6 @@
  * @generated by @rexeus/typeweaver
  */
 
-import { z } from "zod";
 import type {
   HttpBodySchema,
   HttpHeaderSchema,
@@ -94,9 +93,7 @@ export abstract class ResponseValidator
       if (headerSchema) {
         const coercedHeader = this.coerceHeaderToSchema(
           response.header,
-          headerSchema instanceof z.ZodObject
-            ? headerSchema.shape
-            : headerSchema.unwrap().shape
+          this.getSchema(headerSchema)
         );
         const validateHeaderResult = headerSchema.safeParse(
           coercedHeader

package/dist/lib/Validator.ts

@@ -5,7 +5,12 @@
  * @generated by @rexeus/typeweaver
  */
 
+import z from "zod";
 import { $ZodArray, $ZodOptional } from "zod/v4/core";
+import type {
+  HttpHeaderSchema,
+  HttpQuerySchema,
+} from "@rexeus/typeweaver-core";
 import type { $ZodShape } from "zod/v4/core";
 
 type SchemaInfo = { readonly originalKey: string; readonly isArray: boolean };
@@ -52,6 +57,29 @@ export abstract class Validator {
     return schemaMap;
   }
 
+  /**
+   *
+   * Extracts a Zod schema shape from header or query schemas.
+   * This is used to support schema coercion and analysis.
+   *
+   * @param headerSchema
+   * @returns
+   */
+  protected getSchema(
+    headerSchema: HttpHeaderSchema | HttpQuerySchema
+  ): $ZodShape {
+    if (headerSchema instanceof z.ZodObject) {
+      return headerSchema.shape;
+    }
+    if (headerSchema instanceof z.ZodOptional) {
+      const unwrapped = headerSchema.unwrap();
+      if (unwrapped instanceof z.ZodObject) {
+        return unwrapped.shape;
+      }
+    }
+    return {};
+  }
+
   /**
    * Builds a schema map by analyzing the Zod shape structure.
    * Extracts type information for each field to support proper coercion.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rexeus/typeweaver-types",
-  "version": "0.1.2",
-  "description": "TypeScript type and Zod validator generators for typeweaver APIs",
+  "version": "0.2.1",
+  "description": "Generates request and response types plus validators aligned with your API contract. Powered by Typeweaver 🧵✨",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -39,17 +39,17 @@
   },
   "homepage": "https://github.com/rexeus/typeweaver#readme",
   "peerDependencies": {
-    "@rexeus/typeweaver-core": "^0.1.2",
-    "@rexeus/typeweaver-gen": "^0.1.2"
+    "@rexeus/typeweaver-core": "^0.2.1",
+    "@rexeus/typeweaver-gen": "^0.2.1"
   },
   "devDependencies": {
     "test-utils": "file:../test-utils",
-    "@rexeus/typeweaver-core": "^0.1.2",
-    "@rexeus/typeweaver-gen": "^0.1.2"
+    "@rexeus/typeweaver-gen": "^0.2.1",
+    "@rexeus/typeweaver-core": "^0.2.1"
   },
   "dependencies": {
     "case": "^1.6.3",
-    "@rexeus/typeweaver-zod-to-ts": "^0.1.2"
+    "@rexeus/typeweaver-zod-to-ts": "^0.2.1"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",