@opentabs-dev/opentabs-plugin-prescript-test 0.0.4 → 0.0.6

package/dist/adapter.iife.js

@@ -229,6 +229,7 @@
     ZodOptional: () => ZodOptional,
     ZodPipe: () => ZodPipe,
     ZodPrefault: () => ZodPrefault,
+    ZodPreprocess: () => ZodPreprocess,
     ZodPromise: () => ZodPromise,
     ZodReadonly: () => ZodReadonly,
     ZodRealError: () => ZodRealError,
@@ -307,6 +308,7 @@
     int32: () => int32,
     int64: () => int64,
     intersection: () => intersection,
+    invertCodec: () => invertCodec,
     ipv4: () => ipv42,
     ipv6: () => ipv62,
     iso: () => iso_exports,
@@ -488,6 +490,7 @@
     $ZodOptional: () => $ZodOptional,
     $ZodPipe: () => $ZodPipe,
     $ZodPrefault: () => $ZodPrefault,
+    $ZodPreprocess: () => $ZodPreprocess,
     $ZodPromise: () => $ZodPromise,
     $ZodReadonly: () => $ZodReadonly,
     $ZodRealError: () => $ZodRealError,
@@ -687,7 +690,8 @@
   });
 
   // node_modules/zod/v4/core/core.js
-  var NEVER = Object.freeze({
+  var _a;
+  var NEVER = /* @__PURE__ */ Object.freeze({
     status: "aborted"
   });
   // @__NO_SIDE_EFFECTS__
@@ -722,10 +726,10 @@
     }
     Object.defineProperty(Definition, "name", { value: name });
     function _(def) {
-      var _a2;
+      var _a3;
       const inst = params?.Parent ? new Definition() : this;
       init(inst, def);
-      (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
+      (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
       for (const fn of inst._zod.deferred) {
         fn();
       }
@@ -754,7 +758,8 @@
       this.name = "ZodEncodeError";
     }
   };
-  var globalConfig = {};
+  (_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
+  var globalConfig = globalThis.__zod_globalConfig;
   function config(newConfig) {
     if (newConfig)
       Object.assign(globalConfig, newConfig);
@@ -787,6 +792,7 @@
     defineLazy: () => defineLazy,
     esc: () => esc,
     escapeRegex: () => escapeRegex,
+    explicitlyAborted: () => explicitlyAborted,
     extend: () => extend,
     finalizeIssue: () => finalizeIssue,
     floatSafeRemainder: () => floatSafeRemainder,
@@ -875,19 +881,12 @@
     return source.slice(start, end);
   }
   function floatSafeRemainder(val, step) {
-    const valDecCount = (val.toString().split(".")[1] || "").length;
-    const stepString = step.toString();
-    let stepDecCount = (stepString.split(".")[1] || "").length;
-    if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
-      const match = stepString.match(/\d?e-(\d?)/);
-      if (match?.[1]) {
-        stepDecCount = Number.parseInt(match[1]);
-      }
-    }
-    const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
-    const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
-    const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
-    return valInt % stepInt / 10 ** decCount;
+    const ratio = val / step;
+    const roundedRatio = Math.round(ratio);
+    const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
+    if (Math.abs(ratio - roundedRatio) < tolerance)
+      return 0;
+    return ratio - roundedRatio;
   }
   var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
   function defineLazy(object2, key, getter) {
@@ -969,7 +968,10 @@
   function isObject(data) {
     return typeof data === "object" && data !== null && !Array.isArray(data);
   }
-  var allowsEval = cached(() => {
+  var allowsEval = /* @__PURE__ */ cached(() => {
+    if (globalConfig.jitless) {
+      return false;
+    }
     if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
       return false;
     }
@@ -1002,6 +1004,10 @@
       return { ...o };
     if (Array.isArray(o))
       return [...o];
+    if (o instanceof Map)
+      return new Map(o);
+    if (o instanceof Set)
+      return new Set(o);
     return o;
   }
   function numKeys(data) {
@@ -1058,7 +1064,14 @@
     }
   };
   var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
-  var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+  var primitiveTypes = /* @__PURE__ */ new Set([
+    "string",
+    "number",
+    "bigint",
+    "boolean",
+    "symbol",
+    "undefined"
+  ]);
   function escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
@@ -1227,6 +1240,9 @@
     return clone(schema, def);
   }
   function merge(a, b) {
+    if (a._zod.def.checks?.length) {
+      throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
+    }
     const def = mergeDefs(a._zod.def, {
       get shape() {
         const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
@@ -1236,8 +1252,7 @@
       get catchall() {
         return b._zod.def.catchall;
       },
-      checks: []
-      // delete existing checks
+      checks: b._zod.def.checks ?? []
     });
     return clone(a, def);
   }
@@ -1320,10 +1335,20 @@
     }
     return false;
   }
+  function explicitlyAborted(x, startIndex = 0) {
+    if (x.aborted === true)
+      return true;
+    for (let i = startIndex; i < x.issues.length; i++) {
+      if (x.issues[i]?.continue === false) {
+        return true;
+      }
+    }
+    return false;
+  }
   function prefixIssues(path, issues) {
     return issues.map((iss) => {
-      var _a2;
-      (_a2 = iss).path ?? (_a2.path = []);
+      var _a3;
+      (_a3 = iss).path ?? (_a3.path = []);
       iss.path.unshift(path);
       return iss;
     });
@@ -1332,17 +1357,14 @@
     return typeof message === "string" ? message : message?.message;
   }
   function finalizeIssue(iss, ctx, config2) {
-    const full = { ...iss, path: iss.path ?? [] };
-    if (!iss.message) {
-      const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
-      full.message = message;
+    const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
+    const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
+    rest.path ?? (rest.path = []);
+    rest.message = message;
+    if (ctx?.reportInput) {
+      rest.input = _input;
     }
-    delete full.inst;
-    delete full.continue;
-    if (!ctx?.reportInput) {
-      delete full.input;
-    }
-    return full;
+    return rest;
   }
   function getSizableOrigin(input) {
     if (input instanceof Set)
@@ -1459,10 +1481,10 @@
   };
   var $ZodError = $constructor("$ZodError", initializer);
   var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
-  function flattenError(error48, mapper = (issue2) => issue2.message) {
+  function flattenError(error51, mapper = (issue2) => issue2.message) {
     const fieldErrors = {};
     const formErrors = [];
-    for (const sub of error48.issues) {
+    for (const sub of error51.issues) {
       if (sub.path.length > 0) {
         fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
         fieldErrors[sub.path[0]].push(mapper(sub));
@@ -1472,50 +1494,53 @@
     }
     return { formErrors, fieldErrors };
   }
-  function formatError(error48, mapper = (issue2) => issue2.message) {
+  function formatError(error51, mapper = (issue2) => issue2.message) {
     const fieldErrors = { _errors: [] };
-    const processError = (error49) => {
-      for (const issue2 of error49.issues) {
+    const processError = (error52, path = []) => {
+      for (const issue2 of error52.issues) {
         if (issue2.code === "invalid_union" && issue2.errors.length) {
-          issue2.errors.map((issues) => processError({ issues }));
+          issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
         } else if (issue2.code === "invalid_key") {
-          processError({ issues: issue2.issues });
+          processError({ issues: issue2.issues }, [...path, ...issue2.path]);
         } else if (issue2.code === "invalid_element") {
-          processError({ issues: issue2.issues });
-        } else if (issue2.path.length === 0) {
-          fieldErrors._errors.push(mapper(issue2));
+          processError({ issues: issue2.issues }, [...path, ...issue2.path]);
         } else {
-          let curr = fieldErrors;
-          let i = 0;
-          while (i < issue2.path.length) {
-            const el = issue2.path[i];
-            const terminal = i === issue2.path.length - 1;
-            if (!terminal) {
-              curr[el] = curr[el] || { _errors: [] };
-            } else {
-              curr[el] = curr[el] || { _errors: [] };
-              curr[el]._errors.push(mapper(issue2));
+          const fullpath = [...path, ...issue2.path];
+          if (fullpath.length === 0) {
+            fieldErrors._errors.push(mapper(issue2));
+          } else {
+            let curr = fieldErrors;
+            let i = 0;
+            while (i < fullpath.length) {
+              const el = fullpath[i];
+              const terminal = i === fullpath.length - 1;
+              if (!terminal) {
+                curr[el] = curr[el] || { _errors: [] };
+              } else {
+                curr[el] = curr[el] || { _errors: [] };
+                curr[el]._errors.push(mapper(issue2));
+              }
+              curr = curr[el];
+              i++;
             }
-            curr = curr[el];
-            i++;
           }
         }
       }
     };
-    processError(error48);
+    processError(error51);
     return fieldErrors;
   }
-  function treeifyError(error48, mapper = (issue2) => issue2.message) {
+  function treeifyError(error51, mapper = (issue2) => issue2.message) {
     const result = { errors: [] };
-    const processError = (error49, path = []) => {
-      var _a2, _b;
-      for (const issue2 of error49.issues) {
+    const processError = (error52, path = []) => {
+      var _a3, _b;
+      for (const issue2 of error52.issues) {
         if (issue2.code === "invalid_union" && issue2.errors.length) {
-          issue2.errors.map((issues) => processError({ issues }, issue2.path));
+          issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
         } else if (issue2.code === "invalid_key") {
-          processError({ issues: issue2.issues }, issue2.path);
+          processError({ issues: issue2.issues }, [...path, ...issue2.path]);
         } else if (issue2.code === "invalid_element") {
-          processError({ issues: issue2.issues }, issue2.path);
+          processError({ issues: issue2.issues }, [...path, ...issue2.path]);
         } else {
           const fullpath = [...path, ...issue2.path];
           if (fullpath.length === 0) {
@@ -1529,7 +1554,7 @@
             const terminal = i === fullpath.length - 1;
             if (typeof el === "string") {
               curr.properties ?? (curr.properties = {});
-              (_a2 = curr.properties)[el] ?? (_a2[el] = { errors: [] });
+              (_a3 = curr.properties)[el] ?? (_a3[el] = { errors: [] });
               curr = curr.properties[el];
             } else {
               curr.items ?? (curr.items = []);
@@ -1544,7 +1569,7 @@
         }
       }
     };
-    processError(error48);
+    processError(error51);
     return result;
   }
   function toDotPath(_path) {
@@ -1565,9 +1590,9 @@
     }
     return segs.join("");
   }
-  function prettifyError(error48) {
+  function prettifyError(error51) {
     const lines = [];
-    const issues = [...error48.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
+    const issues = [...error51.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
     for (const issue2 of issues) {
       lines.push(`\u2716 ${issue2.message}`);
       if (issue2.path?.length)
@@ -1578,7 +1603,7 @@
 
   // node_modules/zod/v4/core/parse.js
   var _parse = (_Err) => (schema, value, _ctx, _params) => {
-    const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
     const result = schema._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise) {
       throw new $ZodAsyncError();
@@ -1592,7 +1617,7 @@
   };
   var parse = /* @__PURE__ */ _parse($ZodRealError);
   var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
-    const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise)
       result = await result;
@@ -1617,7 +1642,7 @@
   };
   var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
   var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
-    const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise)
       result = await result;
@@ -1628,7 +1653,7 @@
   };
   var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
   var _encode = (_Err) => (schema, value, _ctx) => {
-    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
     return _parse(_Err)(schema, value, ctx);
   };
   var encode = /* @__PURE__ */ _encode($ZodRealError);
@@ -1637,7 +1662,7 @@
   };
   var decode = /* @__PURE__ */ _decode($ZodRealError);
   var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
-    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
     return _parseAsync(_Err)(schema, value, ctx);
   };
   var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
@@ -1646,7 +1671,7 @@
   };
   var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
   var _safeEncode = (_Err) => (schema, value, _ctx) => {
-    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
     return _safeParse(_Err)(schema, value, ctx);
   };
   var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
@@ -1655,7 +1680,7 @@
   };
   var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
   var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
-    const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
     return _safeParseAsync(_Err)(schema, value, ctx);
   };
   var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
@@ -1688,6 +1713,7 @@
     hex: () => hex,
     hostname: () => hostname,
     html5Email: () => html5Email,
+    httpProtocol: () => httpProtocol,
     idnEmail: () => idnEmail,
     integer: () => integer,
     ipv4: () => ipv4,
@@ -1726,7 +1752,7 @@
     uuid7: () => uuid7,
     xid: () => xid
   });
-  var cuid = /^[cC][^\s-]{8,}$/;
+  var cuid = /^[cC][0-9a-z]{6,}$/;
   var cuid2 = /^[0-9a-z]+$/;
   var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
   var xid = /^[0-9a-vA-V]{20}$/;
@@ -1765,6 +1791,7 @@
   var base64url = /^[A-Za-z0-9_-]*$/;
   var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
   var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+  var httpProtocol = /^https?$/;
   var e164 = /^\+[1-9]\d{6,14}$/;
   var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
   var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
@@ -1823,10 +1850,10 @@
 
   // node_modules/zod/v4/core/checks.js
   var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
-    var _a2;
+    var _a3;
     inst._zod ?? (inst._zod = {});
     inst._zod.def = def;
-    (_a2 = inst._zod).onattach ?? (_a2.onattach = []);
+    (_a3 = inst._zod).onattach ?? (_a3.onattach = []);
   });
   var numericOriginMap = {
     number: "number",
@@ -1892,8 +1919,8 @@
   var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
     $ZodCheck.init(inst, def);
     inst._zod.onattach.push((inst2) => {
-      var _a2;
-      (_a2 = inst2._zod.bag).multipleOf ?? (_a2.multipleOf = def.value);
+      var _a3;
+      (_a3 = inst2._zod.bag).multipleOf ?? (_a3.multipleOf = def.value);
     });
     inst._zod.check = (payload) => {
       if (typeof payload.value !== typeof def.value)
@@ -2026,9 +2053,9 @@
     };
   });
   var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.size !== void 0;
     });
@@ -2054,9 +2081,9 @@
     };
   });
   var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.size !== void 0;
     });
@@ -2082,9 +2109,9 @@
     };
   });
   var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.size !== void 0;
     });
@@ -2112,9 +2139,9 @@
     };
   });
   var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.length !== void 0;
     });
@@ -2141,9 +2168,9 @@
     };
   });
   var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.length !== void 0;
     });
@@ -2170,9 +2197,9 @@
     };
   });
   var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
-    var _a2;
+    var _a3;
     $ZodCheck.init(inst, def);
-    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+    (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
       const val = payload.value;
       return !nullish(val) && val.length !== void 0;
     });
@@ -2201,7 +2228,7 @@
     };
   });
   var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
-    var _a2, _b;
+    var _a3, _b;
     $ZodCheck.init(inst, def);
     inst._zod.onattach.push((inst2) => {
       const bag = inst2._zod.bag;
@@ -2212,7 +2239,7 @@
       }
     });
     if (def.pattern)
-      (_a2 = inst._zod).check ?? (_a2.check = (payload) => {
+      (_a3 = inst._zod).check ?? (_a3.check = (payload) => {
         def.pattern.lastIndex = 0;
         if (def.pattern.test(payload.value))
           return;
@@ -2408,13 +2435,13 @@
   // node_modules/zod/v4/core/versions.js
   var version = {
     major: 4,
-    minor: 3,
-    patch: 6
+    minor: 4,
+    patch: 3
   };
 
   // node_modules/zod/v4/core/schemas.js
   var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
-    var _a2;
+    var _a3;
     inst ?? (inst = {});
     inst._zod.def = def;
     inst._zod.bag = inst._zod.bag || {};
@@ -2429,7 +2456,7 @@
       }
     }
     if (checks.length === 0) {
-      (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
+      (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
       inst._zod.deferred?.push(() => {
         inst._zod.run = inst._zod.parse;
       });
@@ -2439,6 +2466,8 @@
         let asyncResult;
         for (const ch of checks2) {
           if (ch._zod.def.when) {
+            if (explicitlyAborted(payload))
+              continue;
             const shouldRun = ch._zod.def.when(payload);
             if (!shouldRun)
               continue;
@@ -2579,6 +2608,19 @@
     inst._zod.check = (payload) => {
       try {
         const trimmed = payload.value.trim();
+        if (!def.normalize && def.protocol?.source === httpProtocol.source) {
+          if (!/^https?:\/\//i.test(trimmed)) {
+            payload.issues.push({
+              code: "invalid_format",
+              format: "url",
+              note: "Invalid URL format",
+              input: payload.value,
+              inst,
+              continue: !def.abort
+            });
+            return;
+          }
+        }
         const url2 = new URL(trimmed);
         if (def.hostname) {
           def.hostname.lastIndex = 0;
@@ -2732,6 +2774,8 @@
   function isValidBase64(data) {
     if (data === "")
       return true;
+    if (/\s/.test(data))
+      return false;
     if (data.length % 4 !== 0)
       return false;
     try {
@@ -2924,8 +2968,6 @@
     $ZodType.init(inst, def);
     inst._zod.pattern = _undefined;
     inst._zod.values = /* @__PURE__ */ new Set([void 0]);
-    inst._zod.optin = "optional";
-    inst._zod.optout = "optional";
     inst._zod.parse = (payload, _ctx) => {
       const input = payload.value;
       if (typeof input === "undefined")
@@ -3054,15 +3096,27 @@
       return payload;
     };
   });
-  function handlePropertyResult(result, final, key, input, isOptionalOut) {
+  function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
+    const isPresent = key in input;
     if (result.issues.length) {
-      if (isOptionalOut && !(key in input)) {
+      if (isOptionalIn && isOptionalOut && !isPresent) {
         return;
       }
       final.issues.push(...prefixIssues(key, result.issues));
     }
+    if (!isPresent && !isOptionalIn) {
+      if (!result.issues.length) {
+        final.issues.push({
+          code: "invalid_type",
+          expected: "nonoptional",
+          input: void 0,
+          path: [key]
+        });
+      }
+      return;
+    }
     if (result.value === void 0) {
-      if (key in input) {
+      if (isPresent) {
         final.value[key] = void 0;
       }
     } else {
@@ -3090,8 +3144,11 @@
     const keySet = def.keySet;
     const _catchall = def.catchall._zod;
     const t = _catchall.def.type;
+    const isOptionalIn = _catchall.optin === "optional";
     const isOptionalOut = _catchall.optout === "optional";
     for (const key in input) {
+      if (key === "__proto__")
+        continue;
       if (keySet.has(key))
         continue;
       if (t === "never") {
@@ -3100,9 +3157,9 @@
       }
       const r = _catchall.run({ value: input[key], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
       } else {
-        handlePropertyResult(r, payload, key, input, isOptionalOut);
+        handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
       }
     }
     if (unrecognized.length) {
@@ -3168,12 +3225,13 @@
       const shape = value.shape;
       for (const key of value.keys) {
         const el = shape[key];
+        const isOptionalIn = el._zod.optin === "optional";
         const isOptionalOut = el._zod.optout === "optional";
         const r = el._zod.run({ value: input[key], issues: [] }, ctx);
         if (r instanceof Promise) {
-          proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
+          proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
         } else {
-          handlePropertyResult(r, payload, key, input, isOptionalOut);
+          handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
         }
       }
       if (!catchall) {
@@ -3204,9 +3262,10 @@
         const id = ids[key];
         const k = esc(key);
         const schema = shape[key];
+        const isOptionalIn = schema?._zod?.optin === "optional";
         const isOptionalOut = schema?._zod?.optout === "optional";
         doc.write(`const ${id} = ${parseStr(key)};`);
-        if (isOptionalOut) {
+        if (isOptionalIn && isOptionalOut) {
           doc.write(`
         if (${id}.issues.length) {
           if (${k} in input) {
@@ -3225,6 +3284,33 @@
           newResult[${k}] = ${id}.value;
         }
         
+      `);
+        } else if (!isOptionalIn) {
+          doc.write(`
+        const ${id}_present = ${k} in input;
+        if (${id}.issues.length) {
+          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${k}, ...iss.path] : [${k}]
+          })));
+        }
+        if (!${id}_present && !${id}.issues.length) {
+          payload.issues.push({
+            code: "invalid_type",
+            expected: "nonoptional",
+            input: undefined,
+            path: [${k}]
+          });
+        }
+
+        if (${id}_present) {
+          if (${id}.value === undefined) {
+            newResult[${k}] = undefined;
+          } else {
+            newResult[${k}] = ${id}.value;
+          }
+        }
+
       `);
         } else {
           doc.write(`
@@ -3318,10 +3404,9 @@
       }
       return void 0;
     });
-    const single = def.options.length === 1;
-    const first = def.options[0]._zod.run;
+    const first = def.options.length === 1 ? def.options[0]._zod.run : null;
     inst._zod.parse = (payload, ctx) => {
-      if (single) {
+      if (first) {
         return first(payload, ctx);
       }
       let async = false;
@@ -3374,10 +3459,9 @@
   var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => {
     $ZodUnion.init(inst, def);
     def.inclusive = false;
-    const single = def.options.length === 1;
-    const first = def.options[0]._zod.run;
+    const first = def.options.length === 1 ? def.options[0]._zod.run : null;
     inst._zod.parse = (payload, ctx) => {
-      if (single) {
+      if (first) {
         return first(payload, ctx);
       }
       let async = false;
@@ -3452,7 +3536,7 @@
       if (opt) {
         return opt._zod.run(payload, ctx);
       }
-      if (def.unionFallback) {
+      if (def.unionFallback || ctx.direction === "backward") {
         return _super(payload, ctx);
       }
       payload.issues.push({
@@ -3460,6 +3544,7 @@
         errors: [],
         note: "No matching discriminator",
         discriminator: def.discriminator,
+        options: Array.from(disc.value.keys()),
         input,
         path: [def.discriminator],
         inst
@@ -3581,64 +3666,96 @@
       }
       payload.value = [];
       const proms = [];
-      const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
-      const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
+      const optinStart = getTupleOptStart(items, "optin");
+      const optoutStart = getTupleOptStart(items, "optout");
       if (!def.rest) {
-        const tooBig = input.length > items.length;
-        const tooSmall = input.length < optStart - 1;
-        if (tooBig || tooSmall) {
+        if (input.length < optinStart) {
           payload.issues.push({
-            ...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length },
+            code: "too_small",
+            minimum: optinStart,
+            inclusive: true,
             input,
             inst,
             origin: "array"
           });
           return payload;
         }
-      }
-      let i = -1;
-      for (const item of items) {
-        i++;
-        if (i >= input.length) {
-          if (i >= optStart)
-            continue;
+        if (input.length > items.length) {
+          payload.issues.push({
+            code: "too_big",
+            maximum: items.length,
+            inclusive: true,
+            input,
+            inst,
+            origin: "array"
+          });
         }
-        const result = item._zod.run({
-          value: input[i],
-          issues: []
-        }, ctx);
-        if (result instanceof Promise) {
-          proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
+      }
+      const itemResults = new Array(items.length);
+      for (let i = 0; i < items.length; i++) {
+        const r = items[i]._zod.run({ value: input[i], issues: [] }, ctx);
+        if (r instanceof Promise) {
+          proms.push(r.then((rr) => {
+            itemResults[i] = rr;
+          }));
         } else {
-          handleTupleResult(result, payload, i);
+          itemResults[i] = r;
         }
       }
       if (def.rest) {
+        let i = items.length - 1;
         const rest = input.slice(items.length);
         for (const el of rest) {
           i++;
-          const result = def.rest._zod.run({
-            value: el,
-            issues: []
-          }, ctx);
+          const result = def.rest._zod.run({ value: el, issues: [] }, ctx);
           if (result instanceof Promise) {
-            proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
+            proms.push(result.then((r) => handleTupleResult(r, payload, i)));
           } else {
             handleTupleResult(result, payload, i);
           }
         }
       }
-      if (proms.length)
-        return Promise.all(proms).then(() => payload);
-      return payload;
+      if (proms.length) {
+        return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
+      }
+      return handleTupleResults(itemResults, payload, items, input, optoutStart);
     };
   });
+  function getTupleOptStart(items, key) {
+    for (let i = items.length - 1; i >= 0; i--) {
+      if (items[i]._zod[key] !== "optional")
+        return i + 1;
+    }
+    return 0;
+  }
   function handleTupleResult(result, final, index) {
     if (result.issues.length) {
       final.issues.push(...prefixIssues(index, result.issues));
     }
     final.value[index] = result.value;
   }
+  function handleTupleResults(itemResults, final, items, input, optoutStart) {
+    for (let i = 0; i < items.length; i++) {
+      const r = itemResults[i];
+      const isPresent = i < input.length;
+      if (r.issues.length) {
+        if (!isPresent && i >= optoutStart) {
+          final.value.length = i;
+          break;
+        }
+        final.issues.push(...prefixIssues(i, r.issues));
+      }
+      final.value[i] = r.value;
+    }
+    for (let i = final.value.length - 1; i >= input.length; i--) {
+      if (items[i]._zod.optout === "optional" && final.value[i] === void 0) {
+        final.value.length = i;
+      } else {
+        break;
+      }
+    }
+    return final;
+  }
   var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
@@ -3660,19 +3777,35 @@
         for (const key of values) {
           if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
             recordKeys.add(typeof key === "number" ? key.toString() : key);
+            const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+            if (keyResult instanceof Promise) {
+              throw new Error("Async schemas not supported in object keys currently");
+            }
+            if (keyResult.issues.length) {
+              payload.issues.push({
+                code: "invalid_key",
+                origin: "record",
+                issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+                input: key,
+                path: [key],
+                inst
+              });
+              continue;
+            }
+            const outKey = keyResult.value;
             const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
             if (result instanceof Promise) {
               proms.push(result.then((result2) => {
                 if (result2.issues.length) {
                   payload.issues.push(...prefixIssues(key, result2.issues));
                 }
-                payload.value[key] = result2.value;
+                payload.value[outKey] = result2.value;
               }));
             } else {
               if (result.issues.length) {
                 payload.issues.push(...prefixIssues(key, result.issues));
               }
-              payload.value[key] = result.value;
+              payload.value[outKey] = result.value;
             }
           }
         }
@@ -3696,6 +3829,8 @@
         for (const key of Reflect.ownKeys(input)) {
           if (key === "__proto__")
             continue;
+          if (!Object.prototype.propertyIsEnumerable.call(input, key))
+            continue;
           let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
           if (keyResult instanceof Promise) {
             throw new Error("Async schemas not supported in object keys currently");
@@ -3900,6 +4035,7 @@
   });
   var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
     $ZodType.init(inst, def);
+    inst._zod.optin = "optional";
     inst._zod.parse = (payload, ctx) => {
       if (ctx.direction === "backward") {
         throw new $ZodEncodeError(inst.constructor.name);
@@ -3909,6 +4045,7 @@
         const output = _out instanceof Promise ? _out : Promise.resolve(_out);
         return output.then((output2) => {
           payload.value = output2;
+          payload.fallback = true;
           return payload;
         });
       }
@@ -3916,11 +4053,12 @@
         throw new $ZodAsyncError();
       }
       payload.value = _out;
+      payload.fallback = true;
       return payload;
     };
   });
   function handleOptionalResult(result, input) {
-    if (result.issues.length && input === void 0) {
+    if (input === void 0 && (result.issues.length || result.fallback)) {
       return { issues: [], value: void 0 };
     }
     return result;
@@ -3938,10 +4076,11 @@
     });
     inst._zod.parse = (payload, ctx) => {
       if (def.innerType._zod.optin === "optional") {
+        const input = payload.value;
         const result = def.innerType._zod.run(payload, ctx);
         if (result instanceof Promise)
-          return result.then((r) => handleOptionalResult(r, payload.value));
-        return handleOptionalResult(result, payload.value);
+          return result.then((r) => handleOptionalResult(r, input));
+        return handleOptionalResult(result, input);
       }
       if (payload.value === void 0) {
         return payload;
@@ -4057,7 +4196,7 @@
   });
   var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
     $ZodType.init(inst, def);
-    defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+    inst._zod.optin = "optional";
     defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
     defineLazy(inst._zod, "values", () => def.innerType._zod.values);
     inst._zod.parse = (payload, ctx) => {
@@ -4077,6 +4216,7 @@
               input: payload.value
             });
             payload.issues = [];
+            payload.fallback = true;
           }
           return payload;
         });
@@ -4091,6 +4231,7 @@
           input: payload.value
         });
         payload.issues = [];
+        payload.fallback = true;
       }
       return payload;
     };
@@ -4136,7 +4277,7 @@
       left.aborted = true;
       return left;
     }
-    return next._zod.run({ value: left.value, issues: left.issues }, ctx);
+    return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
   }
   var $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => {
     $ZodType.init(inst, def);
@@ -4188,6 +4329,9 @@
     }
     return nextSchema._zod.run({ value, issues: left.issues }, ctx);
   }
+  var $ZodPreprocess = /* @__PURE__ */ $constructor("$ZodPreprocess", (inst, def) => {
+    $ZodPipe.init(inst, def);
+  });
   var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
     $ZodType.init(inst, def);
     defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
@@ -4339,7 +4483,12 @@
   });
   var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
     $ZodType.init(inst, def);
-    defineLazy(inst._zod, "innerType", () => def.getter());
+    defineLazy(inst._zod, "innerType", () => {
+      const d = def;
+      if (!d._cachedInner)
+        d._cachedInner = def.getter();
+      return d._cachedInner;
+    });
     defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
     defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
     defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
@@ -4394,6 +4543,7 @@
     cs: () => cs_default,
     da: () => da_default,
     de: () => de_default,
+    el: () => el_default,
     en: () => en_default,
     eo: () => eo_default,
     es: () => es_default,
@@ -4402,6 +4552,7 @@
     fr: () => fr_default,
     frCA: () => fr_CA_default,
     he: () => he_default,
+    hr: () => hr_default,
     hu: () => hu_default,
     hy: () => hy_default,
     id: () => id_default,
@@ -4421,6 +4572,7 @@
     pl: () => pl_default,
     ps: () => ps_default,
     pt: () => pt_default,
+    ro: () => ro_default,
     ru: () => ru_default,
     sl: () => sl_default,
     sv: () => sv_default,
@@ -5374,8 +5526,118 @@
     };
   }
 
-  // node_modules/zod/v4/locales/en.js
+  // node_modules/zod/v4/locales/el.js
   var error9 = () => {
+    const Sizable = {
+      string: { unit: "\u03C7\u03B1\u03C1\u03B1\u03BA\u03C4\u03AE\u03C1\u03B5\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
+      file: { unit: "bytes", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
+      array: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
+      set: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
+      map: { unit: "\u03BA\u03B1\u03C4\u03B1\u03C7\u03C9\u03C1\u03AE\u03C3\u03B5\u03B9\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" }
+    };
+    function getSizing(origin) {
+      return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
+      regex: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2",
+      email: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 email",
+      url: "URL",
+      emoji: "emoji",
+      uuid: "UUID",
+      uuidv4: "UUIDv4",
+      uuidv6: "UUIDv6",
+      nanoid: "nanoid",
+      guid: "GUID",
+      cuid: "cuid",
+      cuid2: "cuid2",
+      ulid: "ULID",
+      xid: "XID",
+      ksuid: "KSUID",
+      datetime: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1 \u03BA\u03B1\u03B9 \u03CE\u03C1\u03B1",
+      date: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1",
+      time: "ISO \u03CE\u03C1\u03B1",
+      duration: "ISO \u03B4\u03B9\u03AC\u03C1\u03BA\u03B5\u03B9\u03B1",
+      ipv4: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv4",
+      ipv6: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv6",
+      mac: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 MAC",
+      cidrv4: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv4",
+      cidrv6: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv6",
+      base64: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC \u03BA\u03C9\u03B4\u03B9\u03BA\u03BF\u03C0\u03BF\u03B9\u03B7\u03BC\u03AD\u03BD\u03B7 \u03C3\u03B5 base64",
+      base64url: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC \u03BA\u03C9\u03B4\u03B9\u03BA\u03BF\u03C0\u03BF\u03B9\u03B7\u03BC\u03AD\u03BD\u03B7 \u03C3\u03B5 base64url",
+      json_string: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC JSON",
+      e164: "\u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2 E.164",
+      jwt: "JWT",
+      template_literal: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2"
+    };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
+    return (issue2) => {
+      switch (issue2.code) {
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (typeof issue2.expected === "string" && /^[A-Z]/.test(issue2.expected)) {
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD instanceof ${issue2.expected}, \u03BB\u03AE\u03C6\u03B8\u03B7\u03BA\u03B5 ${received}`;
+          }
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${expected}, \u03BB\u03AE\u03C6\u03B8\u03B7\u03BA\u03B5 ${received}`;
+        }
+        case "invalid_value":
+          if (issue2.values.length === 1)
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${stringifyPrimitive(issue2.values[0])}`;
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03C0\u03B9\u03BB\u03BF\u03B3\u03AE: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD \u03AD\u03BD\u03B1 \u03B1\u03C0\u03CC ${joinValues(issue2.values, "|")}`;
+        case "too_big": {
+          const adj = issue2.inclusive ? "<=" : "<";
+          const sizing = getSizing(issue2.origin);
+          if (sizing)
+            return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B5\u03B3\u03AC\u03BB\u03BF: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin ?? "\u03C4\u03B9\u03BC\u03AE"} \u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1"}`;
+          return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B5\u03B3\u03AC\u03BB\u03BF: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin ?? "\u03C4\u03B9\u03BC\u03AE"} \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 ${adj}${issue2.maximum.toString()}`;
+        }
+        case "too_small": {
+          const adj = issue2.inclusive ? ">=" : ">";
+          const sizing = getSizing(issue2.origin);
+          if (sizing) {
+            return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B9\u03BA\u03C1\u03CC: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin} \u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+          }
+          return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B9\u03BA\u03C1\u03CC: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin} \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 ${adj}${issue2.minimum.toString()}`;
+        }
+        case "invalid_format": {
+          const _issue = issue2;
+          if (_issue.format === "starts_with") {
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03BE\u03B5\u03BA\u03B9\u03BD\u03AC \u03BC\u03B5 "${_issue.prefix}"`;
+          }
+          if (_issue.format === "ends_with")
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C4\u03B5\u03BB\u03B5\u03B9\u03CE\u03BD\u03B5\u03B9 \u03BC\u03B5 "${_issue.suffix}"`;
+          if (_issue.format === "includes")
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C0\u03B5\u03C1\u03B9\u03AD\u03C7\u03B5\u03B9 "${_issue.includes}"`;
+          if (_issue.format === "regex")
+            return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C4\u03B1\u03B9\u03C1\u03B9\u03AC\u03B6\u03B5\u03B9 \u03BC\u03B5 \u03C4\u03BF \u03BC\u03BF\u03C4\u03AF\u03B2\u03BF ${_issue.pattern}`;
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF: ${FormatDictionary[_issue.format] ?? issue2.format}`;
+        }
+        case "not_multiple_of":
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF\u03C2 \u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 \u03C0\u03BF\u03BB\u03BB\u03B1\u03C0\u03BB\u03AC\u03C3\u03B9\u03BF \u03C4\u03BF\u03C5 ${issue2.divisor}`;
+        case "unrecognized_keys":
+          return `\u0386\u03B3\u03BD\u03C9\u03C3\u03C4${issue2.keys.length > 1 ? "\u03B1" : "\u03BF"} \u03BA\u03BB\u03B5\u03B9\u03B4${issue2.keys.length > 1 ? "\u03B9\u03AC" : "\u03AF"}: ${joinValues(issue2.keys, ", ")}`;
+        case "invalid_key":
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF \u03BA\u03BB\u03B5\u03B9\u03B4\u03AF \u03C3\u03C4\u03BF ${issue2.origin}`;
+        case "invalid_union":
+          return "\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2";
+        case "invalid_element":
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C4\u03B9\u03BC\u03AE \u03C3\u03C4\u03BF ${issue2.origin}`;
+        default:
+          return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2`;
+      }
+    };
+  };
+  function el_default() {
+    return {
+      localeError: error9()
+    };
+  }
+
+  // node_modules/zod/v4/locales/en.js
+  var error10 = () => {
     const Sizable = {
       string: { unit: "characters", verb: "to have" },
       file: { unit: "bytes", verb: "to have" },
@@ -5469,6 +5731,10 @@
         case "invalid_key":
           return `Invalid key in ${issue2.origin}`;
         case "invalid_union":
+          if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
+            const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
+            return `Invalid discriminator value. Expected ${opts}`;
+          }
           return "Invalid input";
         case "invalid_element":
           return `Invalid value in ${issue2.origin}`;
@@ -5479,12 +5745,12 @@
   };
   function en_default() {
     return {
-      localeError: error9()
+      localeError: error10()
     };
   }
 
   // node_modules/zod/v4/locales/eo.js
-  var error10 = () => {
+  var error11 = () => {
     const Sizable = {
       string: { unit: "karaktrojn", verb: "havi" },
       file: { unit: "bajtojn", verb: "havi" },
@@ -5589,12 +5855,12 @@
   };
   function eo_default() {
     return {
-      localeError: error10()
+      localeError: error11()
     };
   }
 
   // node_modules/zod/v4/locales/es.js
-  var error11 = () => {
+  var error12 = () => {
     const Sizable = {
       string: { unit: "caracteres", verb: "tener" },
       file: { unit: "bytes", verb: "tener" },
@@ -5722,12 +5988,12 @@
   };
   function es_default() {
     return {
-      localeError: error11()
+      localeError: error12()
     };
   }
 
   // node_modules/zod/v4/locales/fa.js
-  var error12 = () => {
+  var error13 = () => {
     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" },
@@ -5837,12 +6103,12 @@
   };
   function fa_default() {
     return {
-      localeError: error12()
+      localeError: error13()
     };
   }
 
   // node_modules/zod/v4/locales/fi.js
-  var error13 = () => {
+  var error14 = () => {
     const Sizable = {
       string: { unit: "merkki\xE4", subject: "merkkijonon" },
       file: { unit: "tavua", subject: "tiedoston" },
@@ -5950,12 +6216,12 @@
   };
   function fi_default() {
     return {
-      localeError: error13()
+      localeError: error14()
     };
   }
 
   // node_modules/zod/v4/locales/fr.js
-  var error14 = () => {
+  var error15 = () => {
     const Sizable = {
       string: { unit: "caract\xE8res", verb: "avoir" },
       file: { unit: "octets", verb: "avoir" },
@@ -5996,9 +6262,27 @@
       template_literal: "entr\xE9e"
     };
     const TypeDictionary = {
-      nan: "NaN",
+      string: "cha\xEEne",
       number: "nombre",
-      array: "tableau"
+      int: "entier",
+      boolean: "bool\xE9en",
+      bigint: "grand entier",
+      symbol: "symbole",
+      undefined: "ind\xE9fini",
+      null: "null",
+      never: "jamais",
+      void: "vide",
+      date: "date",
+      array: "tableau",
+      object: "objet",
+      tuple: "tuple",
+      record: "enregistrement",
+      map: "carte",
+      set: "ensemble",
+      file: "fichier",
+      nonoptional: "non-optionnel",
+      nan: "NaN",
+      function: "fonction"
     };
     return (issue2) => {
       switch (issue2.code) {
@@ -6019,16 +6303,15 @@
           const adj = issue2.inclusive ? "<=" : "<";
           const sizing = getSizing(issue2.origin);
           if (sizing)
-            return `Trop grand : ${issue2.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
-          return `Trop grand : ${issue2.origin ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
+            return `Trop grand : ${TypeDictionary[issue2.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
+          return `Trop grand : ${TypeDictionary[issue2.origin] ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
         }
         case "too_small": {
           const adj = issue2.inclusive ? ">=" : ">";
           const sizing = getSizing(issue2.origin);
-          if (sizing) {
-            return `Trop petit : ${issue2.origin} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
-          }
-          return `Trop petit : ${issue2.origin} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
+          if (sizing)
+            return `Trop petit : ${TypeDictionary[issue2.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+          return `Trop petit : ${TypeDictionary[issue2.origin] ?? "valeur"} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
         }
         case "invalid_format": {
           const _issue = issue2;
@@ -6059,12 +6342,12 @@
   };
   function fr_default() {
     return {
-      localeError: error14()
+      localeError: error15()
     };
   }
 
   // node_modules/zod/v4/locales/fr-CA.js
-  var error15 = () => {
+  var error16 = () => {
     const Sizable = {
       string: { unit: "caract\xE8res", verb: "avoir" },
       file: { unit: "octets", verb: "avoir" },
@@ -6167,12 +6450,12 @@
   };
   function fr_CA_default() {
     return {
-      localeError: error15()
+      localeError: error16()
     };
   }
 
   // node_modules/zod/v4/locales/he.js
-  var error16 = () => {
+  var error17 = () => {
     const TypeNames = {
       string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
       number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" },
@@ -6362,24 +6645,24 @@
   };
   function he_default() {
     return {
-      localeError: error16()
+      localeError: error17()
     };
   }
 
-  // node_modules/zod/v4/locales/hu.js
-  var error17 = () => {
+  // node_modules/zod/v4/locales/hr.js
+  var error18 = () => {
     const Sizable = {
-      string: { unit: "karakter", verb: "legyen" },
-      file: { unit: "byte", verb: "legyen" },
-      array: { unit: "elem", verb: "legyen" },
-      set: { unit: "elem", verb: "legyen" }
+      string: { unit: "znakova", verb: "imati" },
+      file: { unit: "bajtova", verb: "imati" },
+      array: { unit: "stavki", verb: "imati" },
+      set: { unit: "stavki", verb: "imati" }
     };
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
     const FormatDictionary = {
-      regex: "bemenet",
-      email: "email c\xEDm",
+      regex: "unos",
+      email: "email adresa",
       url: "URL",
       emoji: "emoji",
       uuid: "UUID",
@@ -6392,25 +6675,37 @@
       ulid: "ULID",
       xid: "XID",
       ksuid: "KSUID",
-      datetime: "ISO id\u0151b\xE9lyeg",
-      date: "ISO d\xE1tum",
-      time: "ISO id\u0151",
-      duration: "ISO id\u0151intervallum",
-      ipv4: "IPv4 c\xEDm",
-      ipv6: "IPv6 c\xEDm",
-      cidrv4: "IPv4 tartom\xE1ny",
-      cidrv6: "IPv6 tartom\xE1ny",
-      base64: "base64-k\xF3dolt string",
-      base64url: "base64url-k\xF3dolt string",
-      json_string: "JSON string",
-      e164: "E.164 sz\xE1m",
+      datetime: "ISO datum i vrijeme",
+      date: "ISO datum",
+      time: "ISO vrijeme",
+      duration: "ISO trajanje",
+      ipv4: "IPv4 adresa",
+      ipv6: "IPv6 adresa",
+      cidrv4: "IPv4 raspon",
+      cidrv6: "IPv6 raspon",
+      base64: "base64 kodirani tekst",
+      base64url: "base64url kodirani tekst",
+      json_string: "JSON tekst",
+      e164: "E.164 broj",
       jwt: "JWT",
-      template_literal: "bemenet"
+      template_literal: "unos"
     };
     const TypeDictionary = {
       nan: "NaN",
-      number: "sz\xE1m",
-      array: "t\xF6mb"
+      string: "tekst",
+      number: "broj",
+      boolean: "boolean",
+      array: "niz",
+      object: "objekt",
+      set: "skup",
+      file: "datoteka",
+      date: "datum",
+      bigint: "bigint",
+      symbol: "simbol",
+      undefined: "undefined",
+      null: "null",
+      function: "funkcija",
+      map: "mapa"
     };
     return (issue2) => {
       switch (issue2.code) {
@@ -6419,20 +6714,131 @@
           const receivedType = parsedType(issue2.input);
           const received = TypeDictionary[receivedType] ?? receivedType;
           if (/^[A-Z]/.test(issue2.expected)) {
-            return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue2.expected}, a kapott \xE9rt\xE9k ${received}`;
+            return `Neispravan unos: o\u010Dekuje se instanceof ${issue2.expected}, a primljeno je ${received}`;
           }
-          return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
+          return `Neispravan unos: o\u010Dekuje se ${expected}, a primljeno je ${received}`;
         }
         case "invalid_value":
           if (issue2.values.length === 1)
-            return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue2.values[0])}`;
-          return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues(issue2.values, "|")}`;
+            return `Neispravna vrijednost: o\u010Dekivano ${stringifyPrimitive(issue2.values[0])}`;
+          return `Neispravna opcija: o\u010Dekivano jedno od ${joinValues(issue2.values, "|")}`;
         case "too_big": {
           const adj = issue2.inclusive ? "<=" : "<";
           const sizing = getSizing(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
           if (sizing)
-            return `T\xFAl nagy: ${issue2.origin ?? "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elem"}`;
-          return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${issue2.origin ?? "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue2.maximum.toString()}`;
+            return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} ima ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemenata"}`;
+          return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} bude ${adj}${issue2.maximum.toString()}`;
+        }
+        case "too_small": {
+          const adj = issue2.inclusive ? ">=" : ">";
+          const sizing = getSizing(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
+          if (sizing) {
+            return `Premalo: o\u010Dekivano da ${origin} ima ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+          }
+          return `Premalo: o\u010Dekivano da ${origin} bude ${adj}${issue2.minimum.toString()}`;
+        }
+        case "invalid_format": {
+          const _issue = issue2;
+          if (_issue.format === "starts_with")
+            return `Neispravan tekst: mora zapo\u010Dinjati s "${_issue.prefix}"`;
+          if (_issue.format === "ends_with")
+            return `Neispravan tekst: mora zavr\u0161avati s "${_issue.suffix}"`;
+          if (_issue.format === "includes")
+            return `Neispravan tekst: mora sadr\u017Eavati "${_issue.includes}"`;
+          if (_issue.format === "regex")
+            return `Neispravan tekst: mora odgovarati uzorku ${_issue.pattern}`;
+          return `Neispravna ${FormatDictionary[_issue.format] ?? issue2.format}`;
+        }
+        case "not_multiple_of":
+          return `Neispravan broj: mora biti vi\u0161ekratnik od ${issue2.divisor}`;
+        case "unrecognized_keys":
+          return `Neprepoznat${issue2.keys.length > 1 ? "i klju\u010Devi" : " klju\u010D"}: ${joinValues(issue2.keys, ", ")}`;
+        case "invalid_key":
+          return `Neispravan klju\u010D u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
+        case "invalid_union":
+          return "Neispravan unos";
+        case "invalid_element":
+          return `Neispravna vrijednost u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
+        default:
+          return `Neispravan unos`;
+      }
+    };
+  };
+  function hr_default() {
+    return {
+      localeError: error18()
+    };
+  }
+
+  // node_modules/zod/v4/locales/hu.js
+  var error19 = () => {
+    const Sizable = {
+      string: { unit: "karakter", verb: "legyen" },
+      file: { unit: "byte", verb: "legyen" },
+      array: { unit: "elem", verb: "legyen" },
+      set: { unit: "elem", verb: "legyen" }
+    };
+    function getSizing(origin) {
+      return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
+      regex: "bemenet",
+      email: "email c\xEDm",
+      url: "URL",
+      emoji: "emoji",
+      uuid: "UUID",
+      uuidv4: "UUIDv4",
+      uuidv6: "UUIDv6",
+      nanoid: "nanoid",
+      guid: "GUID",
+      cuid: "cuid",
+      cuid2: "cuid2",
+      ulid: "ULID",
+      xid: "XID",
+      ksuid: "KSUID",
+      datetime: "ISO id\u0151b\xE9lyeg",
+      date: "ISO d\xE1tum",
+      time: "ISO id\u0151",
+      duration: "ISO id\u0151intervallum",
+      ipv4: "IPv4 c\xEDm",
+      ipv6: "IPv6 c\xEDm",
+      cidrv4: "IPv4 tartom\xE1ny",
+      cidrv6: "IPv6 tartom\xE1ny",
+      base64: "base64-k\xF3dolt string",
+      base64url: "base64url-k\xF3dolt string",
+      json_string: "JSON string",
+      e164: "E.164 sz\xE1m",
+      jwt: "JWT",
+      template_literal: "bemenet"
+    };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "sz\xE1m",
+      array: "t\xF6mb"
+    };
+    return (issue2) => {
+      switch (issue2.code) {
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue2.expected}, a kapott \xE9rt\xE9k ${received}`;
+          }
+          return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
+        }
+        case "invalid_value":
+          if (issue2.values.length === 1)
+            return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue2.values[0])}`;
+          return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues(issue2.values, "|")}`;
+        case "too_big": {
+          const adj = issue2.inclusive ? "<=" : "<";
+          const sizing = getSizing(issue2.origin);
+          if (sizing)
+            return `T\xFAl nagy: ${issue2.origin ?? "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elem"}`;
+          return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${issue2.origin ?? "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue2.maximum.toString()}`;
         }
         case "too_small": {
           const adj = issue2.inclusive ? ">=" : ">";
@@ -6471,7 +6877,7 @@
   };
   function hu_default() {
     return {
-      localeError: error17()
+      localeError: error19()
     };
   }
 
@@ -6486,7 +6892,7 @@
     const lastChar = word[word.length - 1];
     return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
   }
-  var error18 = () => {
+  var error20 = () => {
     const Sizable = {
       string: {
         unit: {
@@ -6619,12 +7025,12 @@
   };
   function hy_default() {
     return {
-      localeError: error18()
+      localeError: error20()
     };
   }
 
   // node_modules/zod/v4/locales/id.js
-  var error19 = () => {
+  var error21 = () => {
     const Sizable = {
       string: { unit: "karakter", verb: "memiliki" },
       file: { unit: "byte", verb: "memiliki" },
@@ -6726,12 +7132,12 @@
   };
   function id_default() {
     return {
-      localeError: error19()
+      localeError: error21()
     };
   }
 
   // node_modules/zod/v4/locales/is.js
-  var error20 = () => {
+  var error22 = () => {
     const Sizable = {
       string: { unit: "stafi", verb: "a\xF0 hafa" },
       file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
@@ -6836,12 +7242,12 @@
   };
   function is_default() {
     return {
-      localeError: error20()
+      localeError: error22()
     };
   }
 
   // node_modules/zod/v4/locales/it.js
-  var error21 = () => {
+  var error23 = () => {
     const Sizable = {
       string: { unit: "caratteri", verb: "avere" },
       file: { unit: "byte", verb: "avere" },
@@ -6926,7 +7332,7 @@
             return `Stringa non valida: deve includere "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
-          return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
+          return `Input non valido: ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Numero non valido: deve essere un multiplo di ${issue2.divisor}`;
@@ -6945,12 +7351,12 @@
   };
   function it_default() {
     return {
-      localeError: error21()
+      localeError: error23()
     };
   }
 
   // node_modules/zod/v4/locales/ja.js
-  var error22 = () => {
+  var error24 = () => {
     const Sizable = {
       string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
       file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
@@ -7053,12 +7459,12 @@
   };
   function ja_default() {
     return {
-      localeError: error22()
+      localeError: error24()
     };
   }
 
   // node_modules/zod/v4/locales/ka.js
-  var error23 = () => {
+  var error25 = () => {
     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" },
@@ -7091,9 +7497,9 @@
       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",
+      base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10D5\u10D4\u10DA\u10D8",
+      base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10D5\u10D4\u10DA\u10D8",
+      json_string: "JSON \u10D5\u10D4\u10DA\u10D8",
       e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
       jwt: "JWT",
       template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
@@ -7101,7 +7507,7 @@
     const TypeDictionary = {
       nan: "NaN",
       number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
-      string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
+      string: "\u10D5\u10D4\u10DA\u10D8",
       boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
       function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
       array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
@@ -7139,14 +7545,14 @@
         case "invalid_format": {
           const _issue = issue2;
           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`;
+            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\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`;
+            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\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`;
+            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\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 \u10D5\u10D4\u10DA\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 ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
@@ -7166,12 +7572,12 @@
   };
   function ka_default() {
     return {
-      localeError: error23()
+      localeError: error25()
     };
   }
 
   // node_modules/zod/v4/locales/km.js
-  var error24 = () => {
+  var error26 = () => {
     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" },
@@ -7277,7 +7683,7 @@
   };
   function km_default() {
     return {
-      localeError: error24()
+      localeError: error26()
     };
   }
 
@@ -7287,7 +7693,7 @@
   }
 
   // node_modules/zod/v4/locales/ko.js
-  var error25 = () => {
+  var error27 = () => {
     const Sizable = {
       string: { unit: "\uBB38\uC790", verb: "to have" },
       file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
@@ -7394,7 +7800,7 @@
   };
   function ko_default() {
     return {
-      localeError: error25()
+      localeError: error27()
     };
   }
 
@@ -7412,7 +7818,7 @@
       return "one";
     return "few";
   }
-  var error26 = () => {
+  var error28 = () => {
     const Sizable = {
       string: {
         unit: {
@@ -7598,12 +8004,12 @@
   };
   function lt_default() {
     return {
-      localeError: error26()
+      localeError: error28()
     };
   }
 
   // node_modules/zod/v4/locales/mk.js
-  var error27 = () => {
+  var error29 = () => {
     const Sizable = {
       string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
       file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
@@ -7708,12 +8114,12 @@
   };
   function mk_default() {
     return {
-      localeError: error27()
+      localeError: error29()
     };
   }
 
   // node_modules/zod/v4/locales/ms.js
-  var error28 = () => {
+  var error30 = () => {
     const Sizable = {
       string: { unit: "aksara", verb: "mempunyai" },
       file: { unit: "bait", verb: "mempunyai" },
@@ -7816,12 +8222,12 @@
   };
   function ms_default() {
     return {
-      localeError: error28()
+      localeError: error30()
     };
   }
 
   // node_modules/zod/v4/locales/nl.js
-  var error29 = () => {
+  var error31 = () => {
     const Sizable = {
       string: { unit: "tekens", verb: "heeft" },
       file: { unit: "bytes", verb: "heeft" },
@@ -7927,12 +8333,12 @@
   };
   function nl_default() {
     return {
-      localeError: error29()
+      localeError: error31()
     };
   }
 
   // node_modules/zod/v4/locales/no.js
-  var error30 = () => {
+  var error32 = () => {
     const Sizable = {
       string: { unit: "tegn", verb: "\xE5 ha" },
       file: { unit: "bytes", verb: "\xE5 ha" },
@@ -8036,12 +8442,12 @@
   };
   function no_default() {
     return {
-      localeError: error30()
+      localeError: error32()
     };
   }
 
   // node_modules/zod/v4/locales/ota.js
-  var error31 = () => {
+  var error33 = () => {
     const Sizable = {
       string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
       file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
@@ -8146,12 +8552,12 @@
   };
   function ota_default() {
     return {
-      localeError: error31()
+      localeError: error33()
     };
   }
 
   // node_modules/zod/v4/locales/ps.js
-  var error32 = () => {
+  var error34 = () => {
     const Sizable = {
       string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
       file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
@@ -8261,12 +8667,12 @@
   };
   function ps_default() {
     return {
-      localeError: error32()
+      localeError: error34()
     };
   }
 
   // node_modules/zod/v4/locales/pl.js
-  var error33 = () => {
+  var error35 = () => {
     const Sizable = {
       string: { unit: "znak\xF3w", verb: "mie\u0107" },
       file: { unit: "bajt\xF3w", verb: "mie\u0107" },
@@ -8371,12 +8777,12 @@
   };
   function pl_default() {
     return {
-      localeError: error33()
+      localeError: error35()
     };
   }
 
   // node_modules/zod/v4/locales/pt.js
-  var error34 = () => {
+  var error36 = () => {
     const Sizable = {
       string: { unit: "caracteres", verb: "ter" },
       file: { unit: "bytes", verb: "ter" },
@@ -8480,7 +8886,127 @@
   };
   function pt_default() {
     return {
-      localeError: error34()
+      localeError: error36()
+    };
+  }
+
+  // node_modules/zod/v4/locales/ro.js
+  var error37 = () => {
+    const Sizable = {
+      string: { unit: "caractere", verb: "s\u0103 aib\u0103" },
+      file: { unit: "octe\u021Bi", verb: "s\u0103 aib\u0103" },
+      array: { unit: "elemente", verb: "s\u0103 aib\u0103" },
+      set: { unit: "elemente", verb: "s\u0103 aib\u0103" },
+      map: { unit: "intr\u0103ri", verb: "s\u0103 aib\u0103" }
+    };
+    function getSizing(origin) {
+      return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
+      regex: "intrare",
+      email: "adres\u0103 de email",
+      url: "URL",
+      emoji: "emoji",
+      uuid: "UUID",
+      uuidv4: "UUIDv4",
+      uuidv6: "UUIDv6",
+      nanoid: "nanoid",
+      guid: "GUID",
+      cuid: "cuid",
+      cuid2: "cuid2",
+      ulid: "ULID",
+      xid: "XID",
+      ksuid: "KSUID",
+      datetime: "dat\u0103 \u0219i or\u0103 ISO",
+      date: "dat\u0103 ISO",
+      time: "or\u0103 ISO",
+      duration: "durat\u0103 ISO",
+      ipv4: "adres\u0103 IPv4",
+      ipv6: "adres\u0103 IPv6",
+      mac: "adres\u0103 MAC",
+      cidrv4: "interval IPv4",
+      cidrv6: "interval IPv6",
+      base64: "\u0219ir codat base64",
+      base64url: "\u0219ir codat base64url",
+      json_string: "\u0219ir JSON",
+      e164: "num\u0103r E.164",
+      jwt: "JWT",
+      template_literal: "intrare"
+    };
+    const TypeDictionary = {
+      nan: "NaN",
+      string: "\u0219ir",
+      number: "num\u0103r",
+      boolean: "boolean",
+      function: "func\u021Bie",
+      array: "matrice",
+      object: "obiect",
+      undefined: "nedefinit",
+      symbol: "simbol",
+      bigint: "num\u0103r mare",
+      void: "void",
+      never: "never",
+      map: "hart\u0103",
+      set: "set"
+    };
+    return (issue2) => {
+      switch (issue2.code) {
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          return `Intrare invalid\u0103: a\u0219teptat ${expected}, primit ${received}`;
+        }
+        case "invalid_value":
+          if (issue2.values.length === 1)
+            return `Intrare invalid\u0103: a\u0219teptat ${stringifyPrimitive(issue2.values[0])}`;
+          return `Op\u021Biune invalid\u0103: a\u0219teptat una dintre ${joinValues(issue2.values, "|")}`;
+        case "too_big": {
+          const adj = issue2.inclusive ? "<=" : "<";
+          const sizing = getSizing(issue2.origin);
+          if (sizing)
+            return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemente"}`;
+          return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} s\u0103 fie ${adj}${issue2.maximum.toString()}`;
+        }
+        case "too_small": {
+          const adj = issue2.inclusive ? ">=" : ">";
+          const sizing = getSizing(issue2.origin);
+          if (sizing) {
+            return `Prea mic: a\u0219teptat ca ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+          }
+          return `Prea mic: a\u0219teptat ca ${issue2.origin} s\u0103 fie ${adj}${issue2.minimum.toString()}`;
+        }
+        case "invalid_format": {
+          const _issue = issue2;
+          if (_issue.format === "starts_with") {
+            return `\u0218ir invalid: trebuie s\u0103 \xEEnceap\u0103 cu "${_issue.prefix}"`;
+          }
+          if (_issue.format === "ends_with")
+            return `\u0218ir invalid: trebuie s\u0103 se termine cu "${_issue.suffix}"`;
+          if (_issue.format === "includes")
+            return `\u0218ir invalid: trebuie s\u0103 includ\u0103 "${_issue.includes}"`;
+          if (_issue.format === "regex")
+            return `\u0218ir invalid: trebuie s\u0103 se potriveasc\u0103 cu modelul ${_issue.pattern}`;
+          return `Format invalid: ${FormatDictionary[_issue.format] ?? issue2.format}`;
+        }
+        case "not_multiple_of":
+          return `Num\u0103r invalid: trebuie s\u0103 fie multiplu de ${issue2.divisor}`;
+        case "unrecognized_keys":
+          return `Chei nerecunoscute: ${joinValues(issue2.keys, ", ")}`;
+        case "invalid_key":
+          return `Cheie invalid\u0103 \xEEn ${issue2.origin}`;
+        case "invalid_union":
+          return "Intrare invalid\u0103";
+        case "invalid_element":
+          return `Valoare invalid\u0103 \xEEn ${issue2.origin}`;
+        default:
+          return `Intrare invalid\u0103`;
+      }
+    };
+  };
+  function ro_default() {
+    return {
+      localeError: error37()
     };
   }
 
@@ -8500,7 +9026,7 @@
     }
     return many;
   }
-  var error35 = () => {
+  var error38 = () => {
     const Sizable = {
       string: {
         unit: {
@@ -8637,12 +9163,12 @@
   };
   function ru_default() {
     return {
-      localeError: error35()
+      localeError: error38()
     };
   }
 
   // node_modules/zod/v4/locales/sl.js
-  var error36 = () => {
+  var error39 = () => {
     const Sizable = {
       string: { unit: "znakov", verb: "imeti" },
       file: { unit: "bajtov", verb: "imeti" },
@@ -8747,12 +9273,12 @@
   };
   function sl_default() {
     return {
-      localeError: error36()
+      localeError: error39()
     };
   }
 
   // node_modules/zod/v4/locales/sv.js
-  var error37 = () => {
+  var error40 = () => {
     const Sizable = {
       string: { unit: "tecken", verb: "att ha" },
       file: { unit: "bytes", verb: "att ha" },
@@ -8858,12 +9384,12 @@
   };
   function sv_default() {
     return {
-      localeError: error37()
+      localeError: error40()
     };
   }
 
   // node_modules/zod/v4/locales/ta.js
-  var error38 = () => {
+  var error41 = () => {
     const Sizable = {
       string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
       file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
@@ -8969,12 +9495,12 @@
   };
   function ta_default() {
     return {
-      localeError: error38()
+      localeError: error41()
     };
   }
 
   // node_modules/zod/v4/locales/th.js
-  var error39 = () => {
+  var error42 = () => {
     const Sizable = {
       string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
       file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
@@ -9080,12 +9606,12 @@
   };
   function th_default() {
     return {
-      localeError: error39()
+      localeError: error42()
     };
   }
 
   // node_modules/zod/v4/locales/tr.js
-  var error40 = () => {
+  var error43 = () => {
     const Sizable = {
       string: { unit: "karakter", verb: "olmal\u0131" },
       file: { unit: "bayt", verb: "olmal\u0131" },
@@ -9186,12 +9712,12 @@
   };
   function tr_default() {
     return {
-      localeError: error40()
+      localeError: error43()
     };
   }
 
   // node_modules/zod/v4/locales/uk.js
-  var error41 = () => {
+  var error44 = () => {
     const Sizable = {
       string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
       file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
@@ -9295,7 +9821,7 @@
   };
   function uk_default() {
     return {
-      localeError: error41()
+      localeError: error44()
     };
   }
 
@@ -9305,7 +9831,7 @@
   }
 
   // node_modules/zod/v4/locales/ur.js
-  var error42 = () => {
+  var error45 = () => {
     const Sizable = {
       string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
       file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
@@ -9411,17 +9937,18 @@
   };
   function ur_default() {
     return {
-      localeError: error42()
+      localeError: error45()
     };
   }
 
   // node_modules/zod/v4/locales/uz.js
-  var error43 = () => {
+  var error46 = () => {
     const Sizable = {
       string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
       file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
       array: { unit: "element", verb: "bo\u2018lishi kerak" },
-      set: { unit: "element", verb: "bo\u2018lishi kerak" }
+      set: { unit: "element", verb: "bo\u2018lishi kerak" },
+      map: { unit: "yozuv", verb: "bo\u2018lishi kerak" }
     };
     function getSizing(origin) {
       return Sizable[origin] ?? null;
@@ -9521,12 +10048,12 @@
   };
   function uz_default() {
     return {
-      localeError: error43()
+      localeError: error46()
     };
   }
 
   // node_modules/zod/v4/locales/vi.js
-  var error44 = () => {
+  var error47 = () => {
     const Sizable = {
       string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
       file: { unit: "byte", verb: "c\xF3" },
@@ -9630,12 +10157,12 @@
   };
   function vi_default() {
     return {
-      localeError: error44()
+      localeError: error47()
     };
   }
 
   // node_modules/zod/v4/locales/zh-CN.js
-  var error45 = () => {
+  var error48 = () => {
     const Sizable = {
       string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
       file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
@@ -9740,12 +10267,12 @@
   };
   function zh_CN_default() {
     return {
-      localeError: error45()
+      localeError: error48()
     };
   }
 
   // node_modules/zod/v4/locales/zh-TW.js
-  var error46 = () => {
+  var error49 = () => {
     const Sizable = {
       string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
       file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
@@ -9848,12 +10375,12 @@
   };
   function zh_TW_default() {
     return {
-      localeError: error46()
+      localeError: error49()
     };
   }
 
   // node_modules/zod/v4/locales/yo.js
-  var error47 = () => {
+  var error50 = () => {
     const Sizable = {
       string: { unit: "\xE0mi", verb: "n\xED" },
       file: { unit: "bytes", verb: "n\xED" },
@@ -9956,12 +10483,12 @@
   };
   function yo_default() {
     return {
-      localeError: error47()
+      localeError: error50()
     };
   }
 
   // node_modules/zod/v4/core/registries.js
-  var _a;
+  var _a2;
   var $output = /* @__PURE__ */ Symbol("ZodOutput");
   var $input = /* @__PURE__ */ Symbol("ZodInput");
   var $ZodRegistry = class {
@@ -10007,7 +10534,7 @@
   function registry() {
     return new $ZodRegistry();
   }
-  (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
+  (_a2 = globalThis).__zod_globalRegistry ?? (_a2.__zod_globalRegistry = registry());
   var globalRegistry = globalThis.__zod_globalRegistry;
 
   // node_modules/zod/v4/core/api.js
@@ -10925,7 +11452,7 @@
     return schema;
   }
   // @__NO_SIDE_EFFECTS__
-  function _superRefine(fn) {
+  function _superRefine(fn, params) {
     const ch = /* @__PURE__ */ _check((payload) => {
       payload.addIssue = (issue2) => {
         if (typeof issue2 === "string") {
@@ -10942,7 +11469,7 @@
         }
       };
       return fn(payload.value, payload);
-    });
+    }, params);
     return ch;
   }
   // @__NO_SIDE_EFFECTS__
@@ -11072,7 +11599,7 @@
     };
   }
   function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
-    var _a2;
+    var _a3;
     const def = schema._zod.def;
     const seen = ctx.seen.get(schema);
     if (seen) {
@@ -11119,8 +11646,8 @@
       delete result.schema.examples;
       delete result.schema.default;
     }
-    if (ctx.io === "input" && result.schema._prefault)
-      (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
+    if (ctx.io === "input" && "_prefault" in result.schema)
+      (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
     delete result.schema._prefault;
     const _result = ctx.seen.get(schema);
     return _result.schema;
@@ -11301,10 +11828,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       result.$id = ctx.external.uri(id);
     }
     Object.assign(result, root.def ?? root.schema);
+    const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+    if (rootMetaId !== void 0 && result.id === rootMetaId)
+      delete result.id;
     const defs = ctx.external?.defs ?? {};
     for (const entry of ctx.seen.entries()) {
       const seen = entry[1];
       if (seen.def && seen.defId) {
+        if (seen.def.id === seen.defId)
+          delete seen.def.id;
         defs[seen.defId] = seen.def;
       }
     }
@@ -11360,6 +11892,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
     }
     if (def.type === "pipe") {
+      if (_schema._zod.traits.has("$ZodCodec"))
+        return true;
       return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
     }
     if (def.type === "object") {
@@ -11449,39 +11983,28 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       json2.type = "integer";
     else
       json2.type = "number";
-    if (typeof exclusiveMinimum === "number") {
-      if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+    const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
+    const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
+    const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
+    if (exMin) {
+      if (legacy) {
         json2.minimum = exclusiveMinimum;
         json2.exclusiveMinimum = true;
       } else {
         json2.exclusiveMinimum = exclusiveMinimum;
       }
-    }
-    if (typeof minimum === "number") {
+    } else if (typeof minimum === "number") {
       json2.minimum = minimum;
-      if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
-        if (exclusiveMinimum >= minimum)
-          delete json2.minimum;
-        else
-          delete json2.exclusiveMinimum;
-      }
     }
-    if (typeof exclusiveMaximum === "number") {
-      if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+    if (exMax) {
+      if (legacy) {
         json2.maximum = exclusiveMaximum;
         json2.exclusiveMaximum = true;
       } else {
         json2.exclusiveMaximum = exclusiveMaximum;
       }
-    }
-    if (typeof maximum === "number") {
+    } else if (typeof maximum === "number") {
       json2.maximum = maximum;
-      if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
-        if (exclusiveMaximum <= maximum)
-          delete json2.maximum;
-        else
-          delete json2.exclusiveMaximum;
-      }
     }
     if (typeof multipleOf === "number")
       json2.multipleOf = multipleOf;
@@ -11653,7 +12176,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (typeof maximum === "number")
       json2.maxItems = maximum;
     json2.type = "array";
-    json2.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
+    json2.items = process2(def.element, ctx, {
+      ...params,
+      path: [...params.path, "items"]
+    });
   };
   var objectProcessor = (schema, ctx, _json, params) => {
     const json2 = _json;
@@ -11846,7 +12372,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   };
   var pipeProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
-    const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
+    const inIsTransform = def.in._zod.traits.has("$ZodTransform");
+    const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
     process2(innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = innerType;
@@ -12080,6 +12607,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ZodOptional: () => ZodOptional,
     ZodPipe: () => ZodPipe,
     ZodPrefault: () => ZodPrefault,
+    ZodPreprocess: () => ZodPreprocess,
     ZodPromise: () => ZodPromise,
     ZodReadonly: () => ZodReadonly,
     ZodRecord: () => ZodRecord,
@@ -12140,6 +12668,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     int32: () => int32,
     int64: () => int64,
     intersection: () => intersection,
+    invertCodec: () => invertCodec,
     ipv4: () => ipv42,
     ipv6: () => ipv62,
     json: () => json,
@@ -12309,8 +12838,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     });
   };
-  var ZodError = $constructor("ZodError", initializer2);
-  var ZodRealError = $constructor("ZodError", initializer2, {
+  var ZodError = /* @__PURE__ */ $constructor("ZodError", initializer2);
+  var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, {
     Parent: Error
   });
 
@@ -12329,6 +12858,43 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 
   // node_modules/zod/v4/classic/schemas.js
+  var _installedGroups = /* @__PURE__ */ new WeakMap();
+  function _installLazyMethods(inst, group, methods) {
+    const proto = Object.getPrototypeOf(inst);
+    let installed = _installedGroups.get(proto);
+    if (!installed) {
+      installed = /* @__PURE__ */ new Set();
+      _installedGroups.set(proto, installed);
+    }
+    if (installed.has(group))
+      return;
+    installed.add(group);
+    for (const key in methods) {
+      const fn = methods[key];
+      Object.defineProperty(proto, key, {
+        configurable: true,
+        enumerable: false,
+        get() {
+          const bound = fn.bind(this);
+          Object.defineProperty(this, key, {
+            configurable: true,
+            writable: true,
+            enumerable: true,
+            value: bound
+          });
+          return bound;
+        },
+        set(v) {
+          Object.defineProperty(this, key, {
+            configurable: true,
+            writable: true,
+            enumerable: true,
+            value: v
+          });
+        }
+      });
+    }
+  }
   var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     $ZodType.init(inst, def);
     Object.assign(inst["~standard"], {
@@ -12341,23 +12907,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.def = def;
     inst.type = def.type;
     Object.defineProperty(inst, "_def", { value: def });
-    inst.check = (...checks) => {
-      return inst.clone(util_exports.mergeDefs(def, {
-        checks: [
-          ...def.checks ?? [],
-          ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
-        ]
-      }), {
-        parent: true
-      });
-    };
-    inst.with = inst.check;
-    inst.clone = (def2, params) => clone(inst, def2, params);
-    inst.brand = () => inst;
-    inst.register = ((reg, meta3) => {
-      reg.add(inst, meta3);
-      return inst;
-    });
     inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
     inst.safeParse = (data, params) => safeParse2(inst, data, params);
     inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
@@ -12371,45 +12920,108 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.safeDecode = (data, params) => safeDecode2(inst, data, params);
     inst.safeEncodeAsync = async (data, params) => safeEncodeAsync2(inst, data, params);
     inst.safeDecodeAsync = async (data, params) => safeDecodeAsync2(inst, data, params);
-    inst.refine = (check2, params) => inst.check(refine(check2, params));
-    inst.superRefine = (refinement) => inst.check(superRefine(refinement));
-    inst.overwrite = (fn) => inst.check(_overwrite(fn));
-    inst.optional = () => optional(inst);
-    inst.exactOptional = () => exactOptional(inst);
-    inst.nullable = () => nullable(inst);
-    inst.nullish = () => optional(nullable(inst));
-    inst.nonoptional = (params) => nonoptional(inst, params);
-    inst.array = () => array(inst);
-    inst.or = (arg) => union([inst, arg]);
-    inst.and = (arg) => intersection(inst, arg);
-    inst.transform = (tx) => pipe(inst, transform(tx));
-    inst.default = (def2) => _default2(inst, def2);
-    inst.prefault = (def2) => prefault(inst, def2);
-    inst.catch = (params) => _catch2(inst, params);
-    inst.pipe = (target) => pipe(inst, target);
-    inst.readonly = () => readonly(inst);
-    inst.describe = (description) => {
-      const cl = inst.clone();
-      globalRegistry.add(cl, { description });
-      return cl;
-    };
+    _installLazyMethods(inst, "ZodType", {
+      check(...chks) {
+        const def2 = this.def;
+        return this.clone(util_exports.mergeDefs(def2, {
+          checks: [
+            ...def2.checks ?? [],
+            ...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
+          ]
+        }), { parent: true });
+      },
+      with(...chks) {
+        return this.check(...chks);
+      },
+      clone(def2, params) {
+        return clone(this, def2, params);
+      },
+      brand() {
+        return this;
+      },
+      register(reg, meta3) {
+        reg.add(this, meta3);
+        return this;
+      },
+      refine(check2, params) {
+        return this.check(refine(check2, params));
+      },
+      superRefine(refinement, params) {
+        return this.check(superRefine(refinement, params));
+      },
+      overwrite(fn) {
+        return this.check(_overwrite(fn));
+      },
+      optional() {
+        return optional(this);
+      },
+      exactOptional() {
+        return exactOptional(this);
+      },
+      nullable() {
+        return nullable(this);
+      },
+      nullish() {
+        return optional(nullable(this));
+      },
+      nonoptional(params) {
+        return nonoptional(this, params);
+      },
+      array() {
+        return array(this);
+      },
+      or(arg) {
+        return union([this, arg]);
+      },
+      and(arg) {
+        return intersection(this, arg);
+      },
+      transform(tx) {
+        return pipe(this, transform(tx));
+      },
+      default(d) {
+        return _default2(this, d);
+      },
+      prefault(d) {
+        return prefault(this, d);
+      },
+      catch(params) {
+        return _catch2(this, params);
+      },
+      pipe(target) {
+        return pipe(this, target);
+      },
+      readonly() {
+        return readonly(this);
+      },
+      describe(description) {
+        const cl = this.clone();
+        globalRegistry.add(cl, { description });
+        return cl;
+      },
+      meta(...args) {
+        if (args.length === 0)
+          return globalRegistry.get(this);
+        const cl = this.clone();
+        globalRegistry.add(cl, args[0]);
+        return cl;
+      },
+      isOptional() {
+        return this.safeParse(void 0).success;
+      },
+      isNullable() {
+        return this.safeParse(null).success;
+      },
+      apply(fn) {
+        return fn(this);
+      }
+    });
     Object.defineProperty(inst, "description", {
       get() {
         return globalRegistry.get(inst)?.description;
       },
       configurable: true
     });
-    inst.meta = (...args) => {
-      if (args.length === 0) {
-        return globalRegistry.get(inst);
-      }
-      const cl = inst.clone();
-      globalRegistry.add(cl, args[0]);
-      return cl;
-    };
-    inst.isOptional = () => inst.safeParse(void 0).success;
-    inst.isNullable = () => inst.safeParse(null).success;
-    inst.apply = (fn) => fn(inst);
     return inst;
   });
   var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
@@ -12420,21 +13032,53 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.format = bag.format ?? null;
     inst.minLength = bag.minimum ?? null;
     inst.maxLength = bag.maximum ?? null;
-    inst.regex = (...args) => inst.check(_regex(...args));
-    inst.includes = (...args) => inst.check(_includes(...args));
-    inst.startsWith = (...args) => inst.check(_startsWith(...args));
-    inst.endsWith = (...args) => inst.check(_endsWith(...args));
-    inst.min = (...args) => inst.check(_minLength(...args));
-    inst.max = (...args) => inst.check(_maxLength(...args));
-    inst.length = (...args) => inst.check(_length(...args));
-    inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
-    inst.lowercase = (params) => inst.check(_lowercase(params));
-    inst.uppercase = (params) => inst.check(_uppercase(params));
-    inst.trim = () => inst.check(_trim());
-    inst.normalize = (...args) => inst.check(_normalize(...args));
-    inst.toLowerCase = () => inst.check(_toLowerCase());
-    inst.toUpperCase = () => inst.check(_toUpperCase());
-    inst.slugify = () => inst.check(_slugify());
+    _installLazyMethods(inst, "_ZodString", {
+      regex(...args) {
+        return this.check(_regex(...args));
+      },
+      includes(...args) {
+        return this.check(_includes(...args));
+      },
+      startsWith(...args) {
+        return this.check(_startsWith(...args));
+      },
+      endsWith(...args) {
+        return this.check(_endsWith(...args));
+      },
+      min(...args) {
+        return this.check(_minLength(...args));
+      },
+      max(...args) {
+        return this.check(_maxLength(...args));
+      },
+      length(...args) {
+        return this.check(_length(...args));
+      },
+      nonempty(...args) {
+        return this.check(_minLength(1, ...args));
+      },
+      lowercase(params) {
+        return this.check(_lowercase(params));
+      },
+      uppercase(params) {
+        return this.check(_uppercase(params));
+      },
+      trim() {
+        return this.check(_trim());
+      },
+      normalize(...args) {
+        return this.check(_normalize(...args));
+      },
+      toLowerCase() {
+        return this.check(_toLowerCase());
+      },
+      toUpperCase() {
+        return this.check(_toUpperCase());
+      },
+      slugify() {
+        return this.check(_slugify());
+      }
+    });
   });
   var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
     $ZodString.init(inst, def);
@@ -12513,7 +13157,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   function httpUrl(params) {
     return _url(ZodURL, {
-      protocol: /^https?$/,
+      protocol: regexes_exports.httpProtocol,
       hostname: regexes_exports.domain,
       ...util_exports.normalizeParams(params)
     });
@@ -12655,21 +13299,53 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     $ZodNumber.init(inst, def);
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
-    inst.gt = (value, params) => inst.check(_gt(value, params));
-    inst.gte = (value, params) => inst.check(_gte(value, params));
-    inst.min = (value, params) => inst.check(_gte(value, params));
-    inst.lt = (value, params) => inst.check(_lt(value, params));
-    inst.lte = (value, params) => inst.check(_lte(value, params));
-    inst.max = (value, params) => inst.check(_lte(value, params));
-    inst.int = (params) => inst.check(int(params));
-    inst.safe = (params) => inst.check(int(params));
-    inst.positive = (params) => inst.check(_gt(0, params));
-    inst.nonnegative = (params) => inst.check(_gte(0, params));
-    inst.negative = (params) => inst.check(_lt(0, params));
-    inst.nonpositive = (params) => inst.check(_lte(0, params));
-    inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
-    inst.step = (value, params) => inst.check(_multipleOf(value, params));
-    inst.finite = () => inst;
+    _installLazyMethods(inst, "ZodNumber", {
+      gt(value, params) {
+        return this.check(_gt(value, params));
+      },
+      gte(value, params) {
+        return this.check(_gte(value, params));
+      },
+      min(value, params) {
+        return this.check(_gte(value, params));
+      },
+      lt(value, params) {
+        return this.check(_lt(value, params));
+      },
+      lte(value, params) {
+        return this.check(_lte(value, params));
+      },
+      max(value, params) {
+        return this.check(_lte(value, params));
+      },
+      int(params) {
+        return this.check(int(params));
+      },
+      safe(params) {
+        return this.check(int(params));
+      },
+      positive(params) {
+        return this.check(_gt(0, params));
+      },
+      nonnegative(params) {
+        return this.check(_gte(0, params));
+      },
+      negative(params) {
+        return this.check(_lt(0, params));
+      },
+      nonpositive(params) {
+        return this.check(_lte(0, params));
+      },
+      multipleOf(value, params) {
+        return this.check(_multipleOf(value, params));
+      },
+      step(value, params) {
+        return this.check(_multipleOf(value, params));
+      },
+      finite() {
+        return this;
+      }
+    });
     const bag = inst._zod.bag;
     inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
     inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
@@ -12816,11 +13492,23 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
     inst.element = def.element;
-    inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
-    inst.nonempty = (params) => inst.check(_minLength(1, params));
-    inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
-    inst.length = (len, params) => inst.check(_length(len, params));
-    inst.unwrap = () => inst.element;
+    _installLazyMethods(inst, "ZodArray", {
+      min(n, params) {
+        return this.check(_minLength(n, params));
+      },
+      nonempty(params) {
+        return this.check(_minLength(1, params));
+      },
+      max(n, params) {
+        return this.check(_maxLength(n, params));
+      },
+      length(n, params) {
+        return this.check(_length(n, params));
+      },
+      unwrap() {
+        return this.element;
+      }
+    });
   });
   function array(element, params) {
     return _array(ZodArray, element, params);
@@ -12836,23 +13524,47 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     util_exports.defineLazy(inst, "shape", () => {
       return def.shape;
     });
-    inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape));
-    inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
-    inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-    inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-    inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
-    inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
-    inst.extend = (incoming) => {
-      return util_exports.extend(inst, incoming);
-    };
-    inst.safeExtend = (incoming) => {
-      return util_exports.safeExtend(inst, incoming);
-    };
-    inst.merge = (other) => util_exports.merge(inst, other);
-    inst.pick = (mask) => util_exports.pick(inst, mask);
-    inst.omit = (mask) => util_exports.omit(inst, mask);
-    inst.partial = (...args) => util_exports.partial(ZodOptional, inst, args[0]);
-    inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]);
+    _installLazyMethods(inst, "ZodObject", {
+      keyof() {
+        return _enum2(Object.keys(this._zod.def.shape));
+      },
+      catchall(catchall) {
+        return this.clone({ ...this._zod.def, catchall });
+      },
+      passthrough() {
+        return this.clone({ ...this._zod.def, catchall: unknown() });
+      },
+      loose() {
+        return this.clone({ ...this._zod.def, catchall: unknown() });
+      },
+      strict() {
+        return this.clone({ ...this._zod.def, catchall: never() });
+      },
+      strip() {
+        return this.clone({ ...this._zod.def, catchall: void 0 });
+      },
+      extend(incoming) {
+        return util_exports.extend(this, incoming);
+      },
+      safeExtend(incoming) {
+        return util_exports.safeExtend(this, incoming);
+      },
+      merge(other) {
+        return util_exports.merge(this, other);
+      },
+      pick(mask) {
+        return util_exports.pick(this, mask);
+      },
+      omit(mask) {
+        return util_exports.omit(this, mask);
+      },
+      partial(...args) {
+        return util_exports.partial(ZodOptional, this, args[0]);
+      },
+      required(...args) {
+        return util_exports.required(ZodNonOptional, this, args[0]);
+      }
+    });
   });
   function object(shape, params) {
     const def = {
@@ -12957,6 +13669,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.valueType = def.valueType;
   });
   function record(keyType, valueType, params) {
+    if (!valueType || !valueType._zod) {
+      return new ZodRecord({
+        type: "record",
+        keyType: string2(),
+        valueType: keyType,
+        ...util_exports.normalizeParams(valueType)
+      });
+    }
     return new ZodRecord({
       type: "record",
       keyType,
@@ -13128,10 +13848,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (output instanceof Promise) {
         return output.then((output2) => {
           payload.value = output2;
+          payload.fallback = true;
           return payload;
         });
       }
       payload.value = output;
+      payload.fallback = true;
       return payload;
     };
   });
@@ -13286,6 +14008,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       reverseTransform: params.encode
     });
   }
+  function invertCodec(codec2) {
+    const def = codec2._zod.def;
+    return new ZodCodec({
+      type: "pipe",
+      in: def.out,
+      out: def.in,
+      transform: def.reverseTransform,
+      reverseTransform: def.transform
+    });
+  }
+  var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) => {
+    ZodPipe.init(inst, def);
+    $ZodPreprocess.init(inst, def);
+  });
   var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
     $ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
@@ -13365,8 +14101,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   function refine(fn, _params = {}) {
     return _refine(ZodCustom, fn, _params);
   }
-  function superRefine(fn) {
-    return _superRefine(fn);
+  function superRefine(fn, params) {
+    return _superRefine(fn, params);
   }
   var describe2 = describe;
   var meta2 = meta;
@@ -13404,7 +14140,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return jsonSchema;
   }
   function preprocess(fn, schema) {
-    return pipe(transform(fn), schema);
+    return new ZodPreprocess({
+      type: "pipe",
+      in: transform(fn),
+      out: schema
+    });
   }
 
   // node_modules/zod/v4/classic/compat.js
@@ -13825,12 +14565,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       default:
         throw new Error(`Unsupported type: ${type}`);
     }
-    if (schema.description) {
-      zodSchema = zodSchema.describe(schema.description);
-    }
-    if (schema.default !== void 0) {
-      zodSchema = zodSchema.default(schema.default);
-    }
     return zodSchema;
   }
   function convertSchema(schema, ctx) {
@@ -13867,6 +14601,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (schema.readOnly === true) {
       baseSchema = z.readonly(baseSchema);
     }
+    if (schema.default !== void 0) {
+      baseSchema = baseSchema.default(schema.default);
+    }
     const extraMeta = {};
     const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
     for (const key of coreMetadataKeys) {
@@ -13888,23 +14625,32 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (Object.keys(extraMeta).length > 0) {
       ctx.registry.add(baseSchema, extraMeta);
     }
+    if (schema.description) {
+      baseSchema = baseSchema.describe(schema.description);
+    }
     return baseSchema;
   }
   function fromJSONSchema(schema, params) {
     if (typeof schema === "boolean") {
       return schema ? z.any() : z.never();
     }
-    const version2 = detectVersion(schema, params?.defaultTarget);
-    const defs = schema.$defs || schema.definitions || {};
+    let normalized;
+    try {
+      normalized = JSON.parse(JSON.stringify(schema));
+    } catch {
+      throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
+    }
+    const version2 = detectVersion(normalized, params?.defaultTarget);
+    const defs = normalized.$defs || normalized.definitions || {};
     const ctx = {
       version: version2,
       defs,
       refs: /* @__PURE__ */ new Map(),
       processing: /* @__PURE__ */ new Set(),
-      rootSchema: schema,
+      rootSchema: normalized,
       registry: params?.registry ?? globalRegistry
     };
-    return convertSchema(schema, ctx);
+    return convertSchema(normalized, ctx);
   }
 
   // node_modules/zod/v4/classic/coerce.js
@@ -13972,7 +14718,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   };
   var src_default = new PreScriptTestPlugin();
 
-  // dist/_adapter_entry_59df686a-e5bf-42bd-b613-e8c55f4d2b70.ts
+  // dist/_adapter_entry_a7d76603-acdb-40be-8c87-59b0022833af.ts
   if (!globalThis.__openTabs) {
     globalThis.__openTabs = {};
   } else {
@@ -14190,5 +14936,5 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     };
     delete src_default.onDeactivate;
   }
-})();(function(){var o=(globalThis).__openTabs;if(o&&o.adapters&&o.adapters["prescript-test"]){var a=o.adapters["prescript-test"];a.__adapterHash="421dfa6b053b42b6a7e437fee174d1983e0011de71b1e09d558b61457b4227d7";if(a.tools&&Array.isArray(a.tools)){for(var i=0;i<a.tools.length;i++){Object.freeze(a.tools[i]);}Object.freeze(a.tools);}Object.freeze(a);Object.defineProperty(o.adapters,"prescript-test",{value:a,writable:false,configurable:false,enumerable:true});Object.defineProperty(o,"adapters",{value:o.adapters,writable:false,configurable:false});}})();
+})();(function(){var o=(globalThis).__openTabs;if(o&&o.adapters&&o.adapters["prescript-test"]){var a=o.adapters["prescript-test"];a.__adapterHash="34e72de03f51c0d59c8c2dc617f8a6771d551eb9fb8818df8ce007398c2502c3";if(a.tools&&Array.isArray(a.tools)){for(var i=0;i<a.tools.length;i++){Object.freeze(a.tools[i]);}Object.freeze(a.tools);}Object.freeze(a);Object.defineProperty(o.adapters,"prescript-test",{value:a,writable:false,configurable:false,enumerable:true});Object.defineProperty(o,"adapters",{value:o.adapters,writable:false,configurable:false});}})();
 //# sourceMappingURL=adapter.iife.js.map