@turbofy-ai/app-runtime 0.0.12 → 0.0.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/src/dsl.js CHANGED
@@ -699,7 +699,6 @@ __export(external_exports, {
699
699
  ZodOptional: () => ZodOptional,
700
700
  ZodPipe: () => ZodPipe,
701
701
  ZodPrefault: () => ZodPrefault,
702
- ZodPreprocess: () => ZodPreprocess,
703
702
  ZodPromise: () => ZodPromise,
704
703
  ZodReadonly: () => ZodReadonly,
705
704
  ZodRealError: () => ZodRealError,
@@ -778,7 +777,6 @@ __export(external_exports, {
778
777
  int32: () => int32,
779
778
  int64: () => int64,
780
779
  intersection: () => intersection,
781
- invertCodec: () => invertCodec,
782
780
  ipv4: () => ipv42,
783
781
  ipv6: () => ipv62,
784
782
  iso: () => iso_exports,
@@ -960,7 +958,6 @@ __export(core_exports2, {
960
958
  $ZodOptional: () => $ZodOptional,
961
959
  $ZodPipe: () => $ZodPipe,
962
960
  $ZodPrefault: () => $ZodPrefault,
963
- $ZodPreprocess: () => $ZodPreprocess,
964
961
  $ZodPromise: () => $ZodPromise,
965
962
  $ZodReadonly: () => $ZodReadonly,
966
963
  $ZodRealError: () => $ZodRealError,
@@ -1160,8 +1157,7 @@ __export(core_exports2, {
1160
1157
  });
1161
1158
 
1162
1159
  // ../../node_modules/zod/v4/core/core.js
1163
- var _a;
1164
- var NEVER = /* @__PURE__ */ Object.freeze({
1160
+ var NEVER = Object.freeze({
1165
1161
  status: "aborted"
1166
1162
  });
1167
1163
  // @__NO_SIDE_EFFECTS__
@@ -1196,10 +1192,10 @@ function $constructor(name, initializer3, params) {
1196
1192
  }
1197
1193
  Object.defineProperty(Definition, "name", { value: name });
1198
1194
  function _(def) {
1199
- var _a3;
1195
+ var _a2;
1200
1196
  const inst = params?.Parent ? new Definition() : this;
1201
1197
  init(inst, def);
1202
- (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
1198
+ (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
1203
1199
  for (const fn of inst._zod.deferred) {
1204
1200
  fn();
1205
1201
  }
@@ -1228,8 +1224,7 @@ var $ZodEncodeError = class extends Error {
1228
1224
  this.name = "ZodEncodeError";
1229
1225
  }
1230
1226
  };
1231
- (_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
1232
- var globalConfig = globalThis.__zod_globalConfig;
1227
+ var globalConfig = {};
1233
1228
  function config(newConfig) {
1234
1229
  if (newConfig)
1235
1230
  Object.assign(globalConfig, newConfig);
@@ -1262,7 +1257,6 @@ __export(util_exports, {
1262
1257
  defineLazy: () => defineLazy,
1263
1258
  esc: () => esc,
1264
1259
  escapeRegex: () => escapeRegex,
1265
- explicitlyAborted: () => explicitlyAborted,
1266
1260
  extend: () => extend,
1267
1261
  finalizeIssue: () => finalizeIssue,
1268
1262
  floatSafeRemainder: () => floatSafeRemainder,
@@ -1351,12 +1345,19 @@ function cleanRegex(source) {
1351
1345
  return source.slice(start, end);
1352
1346
  }
1353
1347
  function floatSafeRemainder(val, step2) {
1354
- const ratio = val / step2;
1355
- const roundedRatio = Math.round(ratio);
1356
- const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
1357
- if (Math.abs(ratio - roundedRatio) < tolerance)
1358
- return 0;
1359
- return ratio - roundedRatio;
1348
+ const valDecCount = (val.toString().split(".")[1] || "").length;
1349
+ const stepString = step2.toString();
1350
+ let stepDecCount = (stepString.split(".")[1] || "").length;
1351
+ if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
1352
+ const match = stepString.match(/\d?e-(\d?)/);
1353
+ if (match?.[1]) {
1354
+ stepDecCount = Number.parseInt(match[1]);
1355
+ }
1356
+ }
1357
+ const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
1358
+ const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
1359
+ const stepInt = Number.parseInt(step2.toFixed(decCount).replace(".", ""));
1360
+ return valInt % stepInt / 10 ** decCount;
1360
1361
  }
1361
1362
  var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
1362
1363
  function defineLazy(object2, key, getter) {
@@ -1438,10 +1439,7 @@ var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace :
1438
1439
  function isObject(data2) {
1439
1440
  return typeof data2 === "object" && data2 !== null && !Array.isArray(data2);
1440
1441
  }
1441
- var allowsEval = /* @__PURE__ */ cached(() => {
1442
- if (globalConfig.jitless) {
1443
- return false;
1444
- }
1442
+ var allowsEval = cached(() => {
1445
1443
  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
1446
1444
  return false;
1447
1445
  }
@@ -1474,10 +1472,6 @@ function shallowClone(o) {
1474
1472
  return { ...o };
1475
1473
  if (Array.isArray(o))
1476
1474
  return [...o];
1477
- if (o instanceof Map)
1478
- return new Map(o);
1479
- if (o instanceof Set)
1480
- return new Set(o);
1481
1475
  return o;
1482
1476
  }
1483
1477
  function numKeys(data2) {
@@ -1534,14 +1528,7 @@ var getParsedType = (data2) => {
1534
1528
  }
1535
1529
  };
1536
1530
  var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
1537
- var primitiveTypes = /* @__PURE__ */ new Set([
1538
- "string",
1539
- "number",
1540
- "bigint",
1541
- "boolean",
1542
- "symbol",
1543
- "undefined"
1544
- ]);
1531
+ var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
1545
1532
  function escapeRegex(str) {
1546
1533
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
1547
1534
  }
@@ -1710,9 +1697,6 @@ function safeExtend(schema, shape) {
1710
1697
  return clone(schema, def);
1711
1698
  }
1712
1699
  function merge(a, b) {
1713
- if (a._zod.def.checks?.length) {
1714
- throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
1715
- }
1716
1700
  const def = mergeDefs(a._zod.def, {
1717
1701
  get shape() {
1718
1702
  const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
@@ -1722,7 +1706,8 @@ function merge(a, b) {
1722
1706
  get catchall() {
1723
1707
  return b._zod.def.catchall;
1724
1708
  },
1725
- checks: b._zod.def.checks ?? []
1709
+ checks: []
1710
+ // delete existing checks
1726
1711
  });
1727
1712
  return clone(a, def);
1728
1713
  }
@@ -1805,20 +1790,10 @@ function aborted(x, startIndex = 0) {
1805
1790
  }
1806
1791
  return false;
1807
1792
  }
1808
- function explicitlyAborted(x, startIndex = 0) {
1809
- if (x.aborted === true)
1810
- return true;
1811
- for (let i = startIndex; i < x.issues.length; i++) {
1812
- if (x.issues[i]?.continue === false) {
1813
- return true;
1814
- }
1815
- }
1816
- return false;
1817
- }
1818
1793
  function prefixIssues(path, issues) {
1819
1794
  return issues.map((iss) => {
1820
- var _a3;
1821
- (_a3 = iss).path ?? (_a3.path = []);
1795
+ var _a2;
1796
+ (_a2 = iss).path ?? (_a2.path = []);
1822
1797
  iss.path.unshift(path);
1823
1798
  return iss;
1824
1799
  });
@@ -1827,14 +1802,17 @@ function unwrapMessage(message) {
1827
1802
  return typeof message === "string" ? message : message?.message;
1828
1803
  }
1829
1804
  function finalizeIssue(iss, ctx, config2) {
1830
- 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";
1831
- const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
1832
- rest.path ?? (rest.path = []);
1833
- rest.message = message;
1834
- if (ctx?.reportInput) {
1835
- rest.input = _input;
1805
+ const full = { ...iss, path: iss.path ?? [] };
1806
+ if (!iss.message) {
1807
+ const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
1808
+ full.message = message;
1836
1809
  }
1837
- return rest;
1810
+ delete full.inst;
1811
+ delete full.continue;
1812
+ if (!ctx?.reportInput) {
1813
+ delete full.input;
1814
+ }
1815
+ return full;
1838
1816
  }
1839
1817
  function getSizableOrigin(input) {
1840
1818
  if (input instanceof Set)
@@ -1951,10 +1929,10 @@ var initializer = (inst, def) => {
1951
1929
  };
1952
1930
  var $ZodError = $constructor("$ZodError", initializer);
1953
1931
  var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
1954
- function flattenError(error51, mapper = (issue2) => issue2.message) {
1932
+ function flattenError(error48, mapper = (issue2) => issue2.message) {
1955
1933
  const fieldErrors = {};
1956
1934
  const formErrors = [];
1957
- for (const sub of error51.issues) {
1935
+ for (const sub of error48.issues) {
1958
1936
  if (sub.path.length > 0) {
1959
1937
  fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
1960
1938
  fieldErrors[sub.path[0]].push(mapper(sub));
@@ -1964,53 +1942,50 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
1964
1942
  }
1965
1943
  return { formErrors, fieldErrors };
1966
1944
  }
1967
- function formatError(error51, mapper = (issue2) => issue2.message) {
1945
+ function formatError(error48, mapper = (issue2) => issue2.message) {
1968
1946
  const fieldErrors = { _errors: [] };
1969
- const processError = (error52, path = []) => {
1970
- for (const issue2 of error52.issues) {
1947
+ const processError = (error49) => {
1948
+ for (const issue2 of error49.issues) {
1971
1949
  if (issue2.code === "invalid_union" && issue2.errors.length) {
1972
- issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
1950
+ issue2.errors.map((issues) => processError({ issues }));
1973
1951
  } else if (issue2.code === "invalid_key") {
1974
- processError({ issues: issue2.issues }, [...path, ...issue2.path]);
1952
+ processError({ issues: issue2.issues });
1975
1953
  } else if (issue2.code === "invalid_element") {
1976
- processError({ issues: issue2.issues }, [...path, ...issue2.path]);
1954
+ processError({ issues: issue2.issues });
1955
+ } else if (issue2.path.length === 0) {
1956
+ fieldErrors._errors.push(mapper(issue2));
1977
1957
  } else {
1978
- const fullpath = [...path, ...issue2.path];
1979
- if (fullpath.length === 0) {
1980
- fieldErrors._errors.push(mapper(issue2));
1981
- } else {
1982
- let curr = fieldErrors;
1983
- let i = 0;
1984
- while (i < fullpath.length) {
1985
- const el = fullpath[i];
1986
- const terminal = i === fullpath.length - 1;
1987
- if (!terminal) {
1988
- curr[el] = curr[el] || { _errors: [] };
1989
- } else {
1990
- curr[el] = curr[el] || { _errors: [] };
1991
- curr[el]._errors.push(mapper(issue2));
1992
- }
1993
- curr = curr[el];
1994
- i++;
1958
+ let curr = fieldErrors;
1959
+ let i = 0;
1960
+ while (i < issue2.path.length) {
1961
+ const el = issue2.path[i];
1962
+ const terminal = i === issue2.path.length - 1;
1963
+ if (!terminal) {
1964
+ curr[el] = curr[el] || { _errors: [] };
1965
+ } else {
1966
+ curr[el] = curr[el] || { _errors: [] };
1967
+ curr[el]._errors.push(mapper(issue2));
1995
1968
  }
1969
+ curr = curr[el];
1970
+ i++;
1996
1971
  }
1997
1972
  }
1998
1973
  }
1999
1974
  };
2000
- processError(error51);
1975
+ processError(error48);
2001
1976
  return fieldErrors;
2002
1977
  }
2003
- function treeifyError(error51, mapper = (issue2) => issue2.message) {
1978
+ function treeifyError(error48, mapper = (issue2) => issue2.message) {
2004
1979
  const result = { errors: [] };
2005
- const processError = (error52, path = []) => {
2006
- var _a3, _b;
2007
- for (const issue2 of error52.issues) {
1980
+ const processError = (error49, path = []) => {
1981
+ var _a2, _b;
1982
+ for (const issue2 of error49.issues) {
2008
1983
  if (issue2.code === "invalid_union" && issue2.errors.length) {
2009
- issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
1984
+ issue2.errors.map((issues) => processError({ issues }, issue2.path));
2010
1985
  } else if (issue2.code === "invalid_key") {
2011
- processError({ issues: issue2.issues }, [...path, ...issue2.path]);
1986
+ processError({ issues: issue2.issues }, issue2.path);
2012
1987
  } else if (issue2.code === "invalid_element") {
2013
- processError({ issues: issue2.issues }, [...path, ...issue2.path]);
1988
+ processError({ issues: issue2.issues }, issue2.path);
2014
1989
  } else {
2015
1990
  const fullpath = [...path, ...issue2.path];
2016
1991
  if (fullpath.length === 0) {
@@ -2024,7 +1999,7 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
2024
1999
  const terminal = i === fullpath.length - 1;
2025
2000
  if (typeof el === "string") {
2026
2001
  curr.properties ?? (curr.properties = {});
2027
- (_a3 = curr.properties)[el] ?? (_a3[el] = { errors: [] });
2002
+ (_a2 = curr.properties)[el] ?? (_a2[el] = { errors: [] });
2028
2003
  curr = curr.properties[el];
2029
2004
  } else {
2030
2005
  curr.items ?? (curr.items = []);
@@ -2039,7 +2014,7 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
2039
2014
  }
2040
2015
  }
2041
2016
  };
2042
- processError(error51);
2017
+ processError(error48);
2043
2018
  return result;
2044
2019
  }
2045
2020
  function toDotPath(_path) {
@@ -2060,9 +2035,9 @@ function toDotPath(_path) {
2060
2035
  }
2061
2036
  return segs.join("");
2062
2037
  }
2063
- function prettifyError(error51) {
2038
+ function prettifyError(error48) {
2064
2039
  const lines = [];
2065
- const issues = [...error51.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
2040
+ const issues = [...error48.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
2066
2041
  for (const issue2 of issues) {
2067
2042
  lines.push(`\u2716 ${issue2.message}`);
2068
2043
  if (issue2.path?.length)
@@ -2073,7 +2048,7 @@ function prettifyError(error51) {
2073
2048
 
2074
2049
  // ../../node_modules/zod/v4/core/parse.js
2075
2050
  var _parse = (_Err) => (schema, value, _ctx, _params) => {
2076
- const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
2051
+ const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
2077
2052
  const result = schema._zod.run({ value, issues: [] }, ctx);
2078
2053
  if (result instanceof Promise) {
2079
2054
  throw new $ZodAsyncError();
@@ -2087,7 +2062,7 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
2087
2062
  };
2088
2063
  var parse = /* @__PURE__ */ _parse($ZodRealError);
2089
2064
  var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
2090
- const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
2065
+ const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
2091
2066
  let result = schema._zod.run({ value, issues: [] }, ctx);
2092
2067
  if (result instanceof Promise)
2093
2068
  result = await result;
@@ -2112,7 +2087,7 @@ var _safeParse = (_Err) => (schema, value, _ctx) => {
2112
2087
  };
2113
2088
  var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
2114
2089
  var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
2115
- const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
2090
+ const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
2116
2091
  let result = schema._zod.run({ value, issues: [] }, ctx);
2117
2092
  if (result instanceof Promise)
2118
2093
  result = await result;
@@ -2123,7 +2098,7 @@ var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
2123
2098
  };
2124
2099
  var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
2125
2100
  var _encode = (_Err) => (schema, value, _ctx) => {
2126
- const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
2101
+ const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
2127
2102
  return _parse(_Err)(schema, value, ctx);
2128
2103
  };
2129
2104
  var encode = /* @__PURE__ */ _encode($ZodRealError);
@@ -2132,7 +2107,7 @@ var _decode = (_Err) => (schema, value, _ctx) => {
2132
2107
  };
2133
2108
  var decode = /* @__PURE__ */ _decode($ZodRealError);
2134
2109
  var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
2135
- const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
2110
+ const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
2136
2111
  return _parseAsync(_Err)(schema, value, ctx);
2137
2112
  };
2138
2113
  var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
@@ -2141,7 +2116,7 @@ var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
2141
2116
  };
2142
2117
  var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
2143
2118
  var _safeEncode = (_Err) => (schema, value, _ctx) => {
2144
- const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
2119
+ const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
2145
2120
  return _safeParse(_Err)(schema, value, ctx);
2146
2121
  };
2147
2122
  var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
@@ -2150,7 +2125,7 @@ var _safeDecode = (_Err) => (schema, value, _ctx) => {
2150
2125
  };
2151
2126
  var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
2152
2127
  var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
2153
- const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
2128
+ const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
2154
2129
  return _safeParseAsync(_Err)(schema, value, ctx);
2155
2130
  };
2156
2131
  var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
@@ -2183,7 +2158,6 @@ __export(regexes_exports, {
2183
2158
  hex: () => hex,
2184
2159
  hostname: () => hostname,
2185
2160
  html5Email: () => html5Email,
2186
- httpProtocol: () => httpProtocol,
2187
2161
  idnEmail: () => idnEmail,
2188
2162
  integer: () => integer,
2189
2163
  ipv4: () => ipv4,
@@ -2222,7 +2196,7 @@ __export(regexes_exports, {
2222
2196
  uuid7: () => uuid7,
2223
2197
  xid: () => xid
2224
2198
  });
2225
- var cuid = /^[cC][0-9a-z]{6,}$/;
2199
+ var cuid = /^[cC][^\s-]{8,}$/;
2226
2200
  var cuid2 = /^[0-9a-z]+$/;
2227
2201
  var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
2228
2202
  var xid = /^[0-9a-vA-V]{20}$/;
@@ -2261,7 +2235,6 @@ var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/
2261
2235
  var base64url = /^[A-Za-z0-9_-]*$/;
2262
2236
  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])?)*\.?$/;
2263
2237
  var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
2264
- var httpProtocol = /^https?$/;
2265
2238
  var e164 = /^\+[1-9]\d{6,14}$/;
2266
2239
  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])))`;
2267
2240
  var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
@@ -2320,10 +2293,10 @@ var sha512_base64url = /* @__PURE__ */ fixedBase64url(86);
2320
2293
 
2321
2294
  // ../../node_modules/zod/v4/core/checks.js
2322
2295
  var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
2323
- var _a3;
2296
+ var _a2;
2324
2297
  inst._zod ?? (inst._zod = {});
2325
2298
  inst._zod.def = def;
2326
- (_a3 = inst._zod).onattach ?? (_a3.onattach = []);
2299
+ (_a2 = inst._zod).onattach ?? (_a2.onattach = []);
2327
2300
  });
2328
2301
  var numericOriginMap = {
2329
2302
  number: "number",
@@ -2389,8 +2362,8 @@ var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan",
2389
2362
  var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
2390
2363
  $ZodCheck.init(inst, def);
2391
2364
  inst._zod.onattach.push((inst2) => {
2392
- var _a3;
2393
- (_a3 = inst2._zod.bag).multipleOf ?? (_a3.multipleOf = def.value);
2365
+ var _a2;
2366
+ (_a2 = inst2._zod.bag).multipleOf ?? (_a2.multipleOf = def.value);
2394
2367
  });
2395
2368
  inst._zod.check = (payload) => {
2396
2369
  if (typeof payload.value !== typeof def.value)
@@ -2523,9 +2496,9 @@ var $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor("$ZodCheckBigIntFormat"
2523
2496
  };
2524
2497
  });
2525
2498
  var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => {
2526
- var _a3;
2499
+ var _a2;
2527
2500
  $ZodCheck.init(inst, def);
2528
- (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2501
+ (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2529
2502
  const val = payload.value;
2530
2503
  return !nullish(val) && val.size !== void 0;
2531
2504
  });
@@ -2551,9 +2524,9 @@ var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, d
2551
2524
  };
2552
2525
  });
2553
2526
  var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => {
2554
- var _a3;
2527
+ var _a2;
2555
2528
  $ZodCheck.init(inst, def);
2556
- (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2529
+ (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2557
2530
  const val = payload.value;
2558
2531
  return !nullish(val) && val.size !== void 0;
2559
2532
  });
@@ -2579,9 +2552,9 @@ var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, d
2579
2552
  };
2580
2553
  });
2581
2554
  var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => {
2582
- var _a3;
2555
+ var _a2;
2583
2556
  $ZodCheck.init(inst, def);
2584
- (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2557
+ (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2585
2558
  const val = payload.value;
2586
2559
  return !nullish(val) && val.size !== void 0;
2587
2560
  });
@@ -2609,9 +2582,9 @@ var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (i
2609
2582
  };
2610
2583
  });
2611
2584
  var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
2612
- var _a3;
2585
+ var _a2;
2613
2586
  $ZodCheck.init(inst, def);
2614
- (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2587
+ (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2615
2588
  const val = payload.value;
2616
2589
  return !nullish(val) && val.length !== void 0;
2617
2590
  });
@@ -2638,9 +2611,9 @@ var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (ins
2638
2611
  };
2639
2612
  });
2640
2613
  var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
2641
- var _a3;
2614
+ var _a2;
2642
2615
  $ZodCheck.init(inst, def);
2643
- (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2616
+ (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2644
2617
  const val = payload.value;
2645
2618
  return !nullish(val) && val.length !== void 0;
2646
2619
  });
@@ -2667,9 +2640,9 @@ var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (ins
2667
2640
  };
2668
2641
  });
2669
2642
  var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
2670
- var _a3;
2643
+ var _a2;
2671
2644
  $ZodCheck.init(inst, def);
2672
- (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2645
+ (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2673
2646
  const val = payload.value;
2674
2647
  return !nullish(val) && val.length !== void 0;
2675
2648
  });
@@ -2698,7 +2671,7 @@ var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals"
2698
2671
  };
2699
2672
  });
2700
2673
  var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
2701
- var _a3, _b;
2674
+ var _a2, _b;
2702
2675
  $ZodCheck.init(inst, def);
2703
2676
  inst._zod.onattach.push((inst2) => {
2704
2677
  const bag = inst2._zod.bag;
@@ -2709,7 +2682,7 @@ var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat"
2709
2682
  }
2710
2683
  });
2711
2684
  if (def.pattern)
2712
- (_a3 = inst._zod).check ?? (_a3.check = (payload) => {
2685
+ (_a2 = inst._zod).check ?? (_a2.check = (payload) => {
2713
2686
  def.pattern.lastIndex = 0;
2714
2687
  if (def.pattern.test(payload.value))
2715
2688
  return;
@@ -2905,13 +2878,13 @@ var Doc = class {
2905
2878
  // ../../node_modules/zod/v4/core/versions.js
2906
2879
  var version = {
2907
2880
  major: 4,
2908
- minor: 4,
2909
- patch: 3
2881
+ minor: 3,
2882
+ patch: 6
2910
2883
  };
2911
2884
 
2912
2885
  // ../../node_modules/zod/v4/core/schemas.js
2913
2886
  var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
2914
- var _a3;
2887
+ var _a2;
2915
2888
  inst ?? (inst = {});
2916
2889
  inst._zod.def = def;
2917
2890
  inst._zod.bag = inst._zod.bag || {};
@@ -2926,7 +2899,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
2926
2899
  }
2927
2900
  }
2928
2901
  if (checks.length === 0) {
2929
- (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
2902
+ (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
2930
2903
  inst._zod.deferred?.push(() => {
2931
2904
  inst._zod.run = inst._zod.parse;
2932
2905
  });
@@ -2936,8 +2909,6 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
2936
2909
  let asyncResult;
2937
2910
  for (const ch of checks2) {
2938
2911
  if (ch._zod.def.when) {
2939
- if (explicitlyAborted(payload))
2940
- continue;
2941
2912
  const shouldRun = ch._zod.def.when(payload);
2942
2913
  if (!shouldRun)
2943
2914
  continue;
@@ -3078,19 +3049,6 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
3078
3049
  inst._zod.check = (payload) => {
3079
3050
  try {
3080
3051
  const trimmed = payload.value.trim();
3081
- if (!def.normalize && def.protocol?.source === httpProtocol.source) {
3082
- if (!/^https?:\/\//i.test(trimmed)) {
3083
- payload.issues.push({
3084
- code: "invalid_format",
3085
- format: "url",
3086
- note: "Invalid URL format",
3087
- input: payload.value,
3088
- inst,
3089
- continue: !def.abort
3090
- });
3091
- return;
3092
- }
3093
- }
3094
3052
  const url2 = new URL(trimmed);
3095
3053
  if (def.hostname) {
3096
3054
  def.hostname.lastIndex = 0;
@@ -3244,8 +3202,6 @@ var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
3244
3202
  function isValidBase64(data2) {
3245
3203
  if (data2 === "")
3246
3204
  return true;
3247
- if (/\s/.test(data2))
3248
- return false;
3249
3205
  if (data2.length % 4 !== 0)
3250
3206
  return false;
3251
3207
  try {
@@ -3438,6 +3394,8 @@ var $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) =>
3438
3394
  $ZodType.init(inst, def);
3439
3395
  inst._zod.pattern = _undefined;
3440
3396
  inst._zod.values = /* @__PURE__ */ new Set([void 0]);
3397
+ inst._zod.optin = "optional";
3398
+ inst._zod.optout = "optional";
3441
3399
  inst._zod.parse = (payload, _ctx) => {
3442
3400
  const input = payload.value;
3443
3401
  if (typeof input === "undefined")
@@ -3566,27 +3524,15 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
3566
3524
  return payload;
3567
3525
  };
3568
3526
  });
3569
- function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
3570
- const isPresent = key in input;
3527
+ function handlePropertyResult(result, final, key, input, isOptionalOut) {
3571
3528
  if (result.issues.length) {
3572
- if (isOptionalIn && isOptionalOut && !isPresent) {
3529
+ if (isOptionalOut && !(key in input)) {
3573
3530
  return;
3574
3531
  }
3575
3532
  final.issues.push(...prefixIssues(key, result.issues));
3576
3533
  }
3577
- if (!isPresent && !isOptionalIn) {
3578
- if (!result.issues.length) {
3579
- final.issues.push({
3580
- code: "invalid_type",
3581
- expected: "nonoptional",
3582
- input: void 0,
3583
- path: [key]
3584
- });
3585
- }
3586
- return;
3587
- }
3588
3534
  if (result.value === void 0) {
3589
- if (isPresent) {
3535
+ if (key in input) {
3590
3536
  final.value[key] = void 0;
3591
3537
  }
3592
3538
  } else {
@@ -3614,11 +3560,8 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
3614
3560
  const keySet = def.keySet;
3615
3561
  const _catchall = def.catchall._zod;
3616
3562
  const t = _catchall.def.type;
3617
- const isOptionalIn = _catchall.optin === "optional";
3618
3563
  const isOptionalOut = _catchall.optout === "optional";
3619
3564
  for (const key in input) {
3620
- if (key === "__proto__")
3621
- continue;
3622
3565
  if (keySet.has(key))
3623
3566
  continue;
3624
3567
  if (t === "never") {
@@ -3627,9 +3570,9 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
3627
3570
  }
3628
3571
  const r = _catchall.run({ value: input[key], issues: [] }, ctx);
3629
3572
  if (r instanceof Promise) {
3630
- proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
3573
+ proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
3631
3574
  } else {
3632
- handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
3575
+ handlePropertyResult(r, payload, key, input, isOptionalOut);
3633
3576
  }
3634
3577
  }
3635
3578
  if (unrecognized.length) {
@@ -3695,13 +3638,12 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
3695
3638
  const shape = value.shape;
3696
3639
  for (const key of value.keys) {
3697
3640
  const el = shape[key];
3698
- const isOptionalIn = el._zod.optin === "optional";
3699
3641
  const isOptionalOut = el._zod.optout === "optional";
3700
3642
  const r = el._zod.run({ value: input[key], issues: [] }, ctx);
3701
3643
  if (r instanceof Promise) {
3702
- proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
3644
+ proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
3703
3645
  } else {
3704
- handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
3646
+ handlePropertyResult(r, payload, key, input, isOptionalOut);
3705
3647
  }
3706
3648
  }
3707
3649
  if (!catchall) {
@@ -3732,10 +3674,9 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
3732
3674
  const id = ids[key];
3733
3675
  const k = esc(key);
3734
3676
  const schema = shape[key];
3735
- const isOptionalIn = schema?._zod?.optin === "optional";
3736
3677
  const isOptionalOut = schema?._zod?.optout === "optional";
3737
3678
  doc.write(`const ${id} = ${parseStr(key)};`);
3738
- if (isOptionalIn && isOptionalOut) {
3679
+ if (isOptionalOut) {
3739
3680
  doc.write(`
3740
3681
  if (${id}.issues.length) {
3741
3682
  if (${k} in input) {
@@ -3754,33 +3695,6 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
3754
3695
  newResult[${k}] = ${id}.value;
3755
3696
  }
3756
3697
 
3757
- `);
3758
- } else if (!isOptionalIn) {
3759
- doc.write(`
3760
- const ${id}_present = ${k} in input;
3761
- if (${id}.issues.length) {
3762
- payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
3763
- ...iss,
3764
- path: iss.path ? [${k}, ...iss.path] : [${k}]
3765
- })));
3766
- }
3767
- if (!${id}_present && !${id}.issues.length) {
3768
- payload.issues.push({
3769
- code: "invalid_type",
3770
- expected: "nonoptional",
3771
- input: undefined,
3772
- path: [${k}]
3773
- });
3774
- }
3775
-
3776
- if (${id}_present) {
3777
- if (${id}.value === undefined) {
3778
- newResult[${k}] = undefined;
3779
- } else {
3780
- newResult[${k}] = ${id}.value;
3781
- }
3782
- }
3783
-
3784
3698
  `);
3785
3699
  } else {
3786
3700
  doc.write(`
@@ -3874,9 +3788,10 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
3874
3788
  }
3875
3789
  return void 0;
3876
3790
  });
3877
- const first = def.options.length === 1 ? def.options[0]._zod.run : null;
3791
+ const single = def.options.length === 1;
3792
+ const first = def.options[0]._zod.run;
3878
3793
  inst._zod.parse = (payload, ctx) => {
3879
- if (first) {
3794
+ if (single) {
3880
3795
  return first(payload, ctx);
3881
3796
  }
3882
3797
  let async = false;
@@ -3929,9 +3844,10 @@ function handleExclusiveUnionResults(results, final, inst, ctx) {
3929
3844
  var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => {
3930
3845
  $ZodUnion.init(inst, def);
3931
3846
  def.inclusive = false;
3932
- const first = def.options.length === 1 ? def.options[0]._zod.run : null;
3847
+ const single = def.options.length === 1;
3848
+ const first = def.options[0]._zod.run;
3933
3849
  inst._zod.parse = (payload, ctx) => {
3934
- if (first) {
3850
+ if (single) {
3935
3851
  return first(payload, ctx);
3936
3852
  }
3937
3853
  let async = false;
@@ -4006,7 +3922,7 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
4006
3922
  if (opt) {
4007
3923
  return opt._zod.run(payload, ctx);
4008
3924
  }
4009
- if (def.unionFallback || ctx.direction === "backward") {
3925
+ if (def.unionFallback) {
4010
3926
  return _super(payload, ctx);
4011
3927
  }
4012
3928
  payload.issues.push({
@@ -4014,7 +3930,6 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
4014
3930
  errors: [],
4015
3931
  note: "No matching discriminator",
4016
3932
  discriminator: def.discriminator,
4017
- options: Array.from(disc.value.keys()),
4018
3933
  input,
4019
3934
  path: [def.discriminator],
4020
3935
  inst
@@ -4136,96 +4051,64 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
4136
4051
  }
4137
4052
  payload.value = [];
4138
4053
  const proms = [];
4139
- const optinStart = getTupleOptStart(items, "optin");
4140
- const optoutStart = getTupleOptStart(items, "optout");
4054
+ const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
4055
+ const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
4141
4056
  if (!def.rest) {
4142
- if (input.length < optinStart) {
4057
+ const tooBig = input.length > items.length;
4058
+ const tooSmall = input.length < optStart - 1;
4059
+ if (tooBig || tooSmall) {
4143
4060
  payload.issues.push({
4144
- code: "too_small",
4145
- minimum: optinStart,
4146
- inclusive: true,
4061
+ ...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length },
4147
4062
  input,
4148
4063
  inst,
4149
4064
  origin: "array"
4150
4065
  });
4151
4066
  return payload;
4152
4067
  }
4153
- if (input.length > items.length) {
4154
- payload.issues.push({
4155
- code: "too_big",
4156
- maximum: items.length,
4157
- inclusive: true,
4158
- input,
4159
- inst,
4160
- origin: "array"
4161
- });
4162
- }
4163
4068
  }
4164
- const itemResults = new Array(items.length);
4165
- for (let i = 0; i < items.length; i++) {
4166
- const r = items[i]._zod.run({ value: input[i], issues: [] }, ctx);
4167
- if (r instanceof Promise) {
4168
- proms.push(r.then((rr) => {
4169
- itemResults[i] = rr;
4170
- }));
4069
+ let i = -1;
4070
+ for (const item of items) {
4071
+ i++;
4072
+ if (i >= input.length) {
4073
+ if (i >= optStart)
4074
+ continue;
4075
+ }
4076
+ const result = item._zod.run({
4077
+ value: input[i],
4078
+ issues: []
4079
+ }, ctx);
4080
+ if (result instanceof Promise) {
4081
+ proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
4171
4082
  } else {
4172
- itemResults[i] = r;
4083
+ handleTupleResult(result, payload, i);
4173
4084
  }
4174
4085
  }
4175
4086
  if (def.rest) {
4176
- let i = items.length - 1;
4177
4087
  const rest = input.slice(items.length);
4178
4088
  for (const el of rest) {
4179
4089
  i++;
4180
- const result = def.rest._zod.run({ value: el, issues: [] }, ctx);
4090
+ const result = def.rest._zod.run({
4091
+ value: el,
4092
+ issues: []
4093
+ }, ctx);
4181
4094
  if (result instanceof Promise) {
4182
- proms.push(result.then((r) => handleTupleResult(r, payload, i)));
4095
+ proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
4183
4096
  } else {
4184
4097
  handleTupleResult(result, payload, i);
4185
4098
  }
4186
4099
  }
4187
4100
  }
4188
- if (proms.length) {
4189
- return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
4190
- }
4191
- return handleTupleResults(itemResults, payload, items, input, optoutStart);
4101
+ if (proms.length)
4102
+ return Promise.all(proms).then(() => payload);
4103
+ return payload;
4192
4104
  };
4193
4105
  });
4194
- function getTupleOptStart(items, key) {
4195
- for (let i = items.length - 1; i >= 0; i--) {
4196
- if (items[i]._zod[key] !== "optional")
4197
- return i + 1;
4198
- }
4199
- return 0;
4200
- }
4201
4106
  function handleTupleResult(result, final, index) {
4202
4107
  if (result.issues.length) {
4203
4108
  final.issues.push(...prefixIssues(index, result.issues));
4204
4109
  }
4205
4110
  final.value[index] = result.value;
4206
4111
  }
4207
- function handleTupleResults(itemResults, final, items, input, optoutStart) {
4208
- for (let i = 0; i < items.length; i++) {
4209
- const r = itemResults[i];
4210
- const isPresent = i < input.length;
4211
- if (r.issues.length) {
4212
- if (!isPresent && i >= optoutStart) {
4213
- final.value.length = i;
4214
- break;
4215
- }
4216
- final.issues.push(...prefixIssues(i, r.issues));
4217
- }
4218
- final.value[i] = r.value;
4219
- }
4220
- for (let i = final.value.length - 1; i >= input.length; i--) {
4221
- if (items[i]._zod.optout === "optional" && final.value[i] === void 0) {
4222
- final.value.length = i;
4223
- } else {
4224
- break;
4225
- }
4226
- }
4227
- return final;
4228
- }
4229
4112
  var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
4230
4113
  $ZodType.init(inst, def);
4231
4114
  inst._zod.parse = (payload, ctx) => {
@@ -4247,35 +4130,19 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
4247
4130
  for (const key of values) {
4248
4131
  if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
4249
4132
  recordKeys.add(typeof key === "number" ? key.toString() : key);
4250
- const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
4251
- if (keyResult instanceof Promise) {
4252
- throw new Error("Async schemas not supported in object keys currently");
4253
- }
4254
- if (keyResult.issues.length) {
4255
- payload.issues.push({
4256
- code: "invalid_key",
4257
- origin: "record",
4258
- issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
4259
- input: key,
4260
- path: [key],
4261
- inst
4262
- });
4263
- continue;
4264
- }
4265
- const outKey = keyResult.value;
4266
4133
  const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
4267
4134
  if (result instanceof Promise) {
4268
4135
  proms.push(result.then((result2) => {
4269
4136
  if (result2.issues.length) {
4270
4137
  payload.issues.push(...prefixIssues(key, result2.issues));
4271
4138
  }
4272
- payload.value[outKey] = result2.value;
4139
+ payload.value[key] = result2.value;
4273
4140
  }));
4274
4141
  } else {
4275
4142
  if (result.issues.length) {
4276
4143
  payload.issues.push(...prefixIssues(key, result.issues));
4277
4144
  }
4278
- payload.value[outKey] = result.value;
4145
+ payload.value[key] = result.value;
4279
4146
  }
4280
4147
  }
4281
4148
  }
@@ -4299,8 +4166,6 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
4299
4166
  for (const key of Reflect.ownKeys(input)) {
4300
4167
  if (key === "__proto__")
4301
4168
  continue;
4302
- if (!Object.prototype.propertyIsEnumerable.call(input, key))
4303
- continue;
4304
4169
  let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
4305
4170
  if (keyResult instanceof Promise) {
4306
4171
  throw new Error("Async schemas not supported in object keys currently");
@@ -4505,7 +4370,6 @@ var $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => {
4505
4370
  });
4506
4371
  var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
4507
4372
  $ZodType.init(inst, def);
4508
- inst._zod.optin = "optional";
4509
4373
  inst._zod.parse = (payload, ctx) => {
4510
4374
  if (ctx.direction === "backward") {
4511
4375
  throw new $ZodEncodeError(inst.constructor.name);
@@ -4515,7 +4379,6 @@ var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) =>
4515
4379
  const output = _out instanceof Promise ? _out : Promise.resolve(_out);
4516
4380
  return output.then((output2) => {
4517
4381
  payload.value = output2;
4518
- payload.fallback = true;
4519
4382
  return payload;
4520
4383
  });
4521
4384
  }
@@ -4523,12 +4386,11 @@ var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) =>
4523
4386
  throw new $ZodAsyncError();
4524
4387
  }
4525
4388
  payload.value = _out;
4526
- payload.fallback = true;
4527
4389
  return payload;
4528
4390
  };
4529
4391
  });
4530
4392
  function handleOptionalResult(result, input) {
4531
- if (input === void 0 && (result.issues.length || result.fallback)) {
4393
+ if (result.issues.length && input === void 0) {
4532
4394
  return { issues: [], value: void 0 };
4533
4395
  }
4534
4396
  return result;
@@ -4546,11 +4408,10 @@ var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
4546
4408
  });
4547
4409
  inst._zod.parse = (payload, ctx) => {
4548
4410
  if (def.innerType._zod.optin === "optional") {
4549
- const input = payload.value;
4550
4411
  const result = def.innerType._zod.run(payload, ctx);
4551
4412
  if (result instanceof Promise)
4552
- return result.then((r) => handleOptionalResult(r, input));
4553
- return handleOptionalResult(result, input);
4413
+ return result.then((r) => handleOptionalResult(r, payload.value));
4414
+ return handleOptionalResult(result, payload.value);
4554
4415
  }
4555
4416
  if (payload.value === void 0) {
4556
4417
  return payload;
@@ -4666,7 +4527,7 @@ var $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => {
4666
4527
  });
4667
4528
  var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
4668
4529
  $ZodType.init(inst, def);
4669
- inst._zod.optin = "optional";
4530
+ defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
4670
4531
  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
4671
4532
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
4672
4533
  inst._zod.parse = (payload, ctx) => {
@@ -4686,7 +4547,6 @@ var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
4686
4547
  input: payload.value
4687
4548
  });
4688
4549
  payload.issues = [];
4689
- payload.fallback = true;
4690
4550
  }
4691
4551
  return payload;
4692
4552
  });
@@ -4701,7 +4561,6 @@ var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
4701
4561
  input: payload.value
4702
4562
  });
4703
4563
  payload.issues = [];
4704
- payload.fallback = true;
4705
4564
  }
4706
4565
  return payload;
4707
4566
  };
@@ -4747,7 +4606,7 @@ function handlePipeResult(left, next, ctx) {
4747
4606
  left.aborted = true;
4748
4607
  return left;
4749
4608
  }
4750
- return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
4609
+ return next._zod.run({ value: left.value, issues: left.issues }, ctx);
4751
4610
  }
4752
4611
  var $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => {
4753
4612
  $ZodType.init(inst, def);
@@ -4799,9 +4658,6 @@ function handleCodecTxResult(left, value, nextSchema, ctx) {
4799
4658
  }
4800
4659
  return nextSchema._zod.run({ value, issues: left.issues }, ctx);
4801
4660
  }
4802
- var $ZodPreprocess = /* @__PURE__ */ $constructor("$ZodPreprocess", (inst, def) => {
4803
- $ZodPipe.init(inst, def);
4804
- });
4805
4661
  var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
4806
4662
  $ZodType.init(inst, def);
4807
4663
  defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
@@ -4953,12 +4809,7 @@ var $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def) => {
4953
4809
  });
4954
4810
  var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
4955
4811
  $ZodType.init(inst, def);
4956
- defineLazy(inst._zod, "innerType", () => {
4957
- const d = def;
4958
- if (!d._cachedInner)
4959
- d._cachedInner = def.getter();
4960
- return d._cachedInner;
4961
- });
4812
+ defineLazy(inst._zod, "innerType", () => def.getter());
4962
4813
  defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
4963
4814
  defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
4964
4815
  defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
@@ -5013,7 +4864,6 @@ __export(locales_exports, {
5013
4864
  cs: () => cs_default,
5014
4865
  da: () => da_default,
5015
4866
  de: () => de_default,
5016
- el: () => el_default,
5017
4867
  en: () => en_default,
5018
4868
  eo: () => eo_default,
5019
4869
  es: () => es_default,
@@ -5022,7 +4872,6 @@ __export(locales_exports, {
5022
4872
  fr: () => fr_default,
5023
4873
  frCA: () => fr_CA_default,
5024
4874
  he: () => he_default,
5025
- hr: () => hr_default,
5026
4875
  hu: () => hu_default,
5027
4876
  hy: () => hy_default,
5028
4877
  id: () => id_default,
@@ -5042,7 +4891,6 @@ __export(locales_exports, {
5042
4891
  pl: () => pl_default,
5043
4892
  ps: () => ps_default,
5044
4893
  pt: () => pt_default,
5045
- ro: () => ro_default,
5046
4894
  ru: () => ru_default,
5047
4895
  sl: () => sl_default,
5048
4896
  sv: () => sv_default,
@@ -5996,118 +5844,8 @@ function de_default() {
5996
5844
  };
5997
5845
  }
5998
5846
 
5999
- // ../../node_modules/zod/v4/locales/el.js
6000
- var error9 = () => {
6001
- const Sizable = {
6002
- string: { unit: "\u03C7\u03B1\u03C1\u03B1\u03BA\u03C4\u03AE\u03C1\u03B5\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
6003
- file: { unit: "bytes", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
6004
- array: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
6005
- set: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
6006
- map: { unit: "\u03BA\u03B1\u03C4\u03B1\u03C7\u03C9\u03C1\u03AE\u03C3\u03B5\u03B9\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" }
6007
- };
6008
- function getSizing(origin) {
6009
- return Sizable[origin] ?? null;
6010
- }
6011
- const FormatDictionary = {
6012
- regex: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2",
6013
- email: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 email",
6014
- url: "URL",
6015
- emoji: "emoji",
6016
- uuid: "UUID",
6017
- uuidv4: "UUIDv4",
6018
- uuidv6: "UUIDv6",
6019
- nanoid: "nanoid",
6020
- guid: "GUID",
6021
- cuid: "cuid",
6022
- cuid2: "cuid2",
6023
- ulid: "ULID",
6024
- xid: "XID",
6025
- ksuid: "KSUID",
6026
- datetime: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1 \u03BA\u03B1\u03B9 \u03CE\u03C1\u03B1",
6027
- date: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1",
6028
- time: "ISO \u03CE\u03C1\u03B1",
6029
- duration: "ISO \u03B4\u03B9\u03AC\u03C1\u03BA\u03B5\u03B9\u03B1",
6030
- ipv4: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv4",
6031
- ipv6: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv6",
6032
- mac: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 MAC",
6033
- cidrv4: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv4",
6034
- cidrv6: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv6",
6035
- 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",
6036
- 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",
6037
- json_string: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC JSON",
6038
- e164: "\u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2 E.164",
6039
- jwt: "JWT",
6040
- template_literal: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2"
6041
- };
6042
- const TypeDictionary = {
6043
- nan: "NaN"
6044
- };
6045
- return (issue2) => {
6046
- switch (issue2.code) {
6047
- case "invalid_type": {
6048
- const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
6049
- const receivedType = parsedType(issue2.input);
6050
- const received = TypeDictionary[receivedType] ?? receivedType;
6051
- if (typeof issue2.expected === "string" && /^[A-Z]/.test(issue2.expected)) {
6052
- 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}`;
6053
- }
6054
- 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}`;
6055
- }
6056
- case "invalid_value":
6057
- if (issue2.values.length === 1)
6058
- 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])}`;
6059
- 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, "|")}`;
6060
- case "too_big": {
6061
- const adj = issue2.inclusive ? "<=" : "<";
6062
- const sizing = getSizing(issue2.origin);
6063
- if (sizing)
6064
- 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"}`;
6065
- 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()}`;
6066
- }
6067
- case "too_small": {
6068
- const adj = issue2.inclusive ? ">=" : ">";
6069
- const sizing = getSizing(issue2.origin);
6070
- if (sizing) {
6071
- 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}`;
6072
- }
6073
- 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()}`;
6074
- }
6075
- case "invalid_format": {
6076
- const _issue = issue2;
6077
- if (_issue.format === "starts_with") {
6078
- 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}"`;
6079
- }
6080
- if (_issue.format === "ends_with")
6081
- 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}"`;
6082
- if (_issue.format === "includes")
6083
- 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}"`;
6084
- if (_issue.format === "regex")
6085
- 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}`;
6086
- return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF: ${FormatDictionary[_issue.format] ?? issue2.format}`;
6087
- }
6088
- case "not_multiple_of":
6089
- 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}`;
6090
- case "unrecognized_keys":
6091
- 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, ", ")}`;
6092
- case "invalid_key":
6093
- return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF \u03BA\u03BB\u03B5\u03B9\u03B4\u03AF \u03C3\u03C4\u03BF ${issue2.origin}`;
6094
- case "invalid_union":
6095
- return "\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2";
6096
- case "invalid_element":
6097
- return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C4\u03B9\u03BC\u03AE \u03C3\u03C4\u03BF ${issue2.origin}`;
6098
- default:
6099
- return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2`;
6100
- }
6101
- };
6102
- };
6103
- function el_default() {
6104
- return {
6105
- localeError: error9()
6106
- };
6107
- }
6108
-
6109
5847
  // ../../node_modules/zod/v4/locales/en.js
6110
- var error10 = () => {
5848
+ var error9 = () => {
6111
5849
  const Sizable = {
6112
5850
  string: { unit: "characters", verb: "to have" },
6113
5851
  file: { unit: "bytes", verb: "to have" },
@@ -6201,10 +5939,6 @@ var error10 = () => {
6201
5939
  case "invalid_key":
6202
5940
  return `Invalid key in ${issue2.origin}`;
6203
5941
  case "invalid_union":
6204
- if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
6205
- const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
6206
- return `Invalid discriminator value. Expected ${opts}`;
6207
- }
6208
5942
  return "Invalid input";
6209
5943
  case "invalid_element":
6210
5944
  return `Invalid value in ${issue2.origin}`;
@@ -6215,12 +5949,12 @@ var error10 = () => {
6215
5949
  };
6216
5950
  function en_default() {
6217
5951
  return {
6218
- localeError: error10()
5952
+ localeError: error9()
6219
5953
  };
6220
5954
  }
6221
5955
 
6222
5956
  // ../../node_modules/zod/v4/locales/eo.js
6223
- var error11 = () => {
5957
+ var error10 = () => {
6224
5958
  const Sizable = {
6225
5959
  string: { unit: "karaktrojn", verb: "havi" },
6226
5960
  file: { unit: "bajtojn", verb: "havi" },
@@ -6325,12 +6059,12 @@ var error11 = () => {
6325
6059
  };
6326
6060
  function eo_default() {
6327
6061
  return {
6328
- localeError: error11()
6062
+ localeError: error10()
6329
6063
  };
6330
6064
  }
6331
6065
 
6332
6066
  // ../../node_modules/zod/v4/locales/es.js
6333
- var error12 = () => {
6067
+ var error11 = () => {
6334
6068
  const Sizable = {
6335
6069
  string: { unit: "caracteres", verb: "tener" },
6336
6070
  file: { unit: "bytes", verb: "tener" },
@@ -6458,12 +6192,12 @@ var error12 = () => {
6458
6192
  };
6459
6193
  function es_default() {
6460
6194
  return {
6461
- localeError: error12()
6195
+ localeError: error11()
6462
6196
  };
6463
6197
  }
6464
6198
 
6465
6199
  // ../../node_modules/zod/v4/locales/fa.js
6466
- var error13 = () => {
6200
+ var error12 = () => {
6467
6201
  const Sizable = {
6468
6202
  string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
6469
6203
  file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
@@ -6573,12 +6307,12 @@ var error13 = () => {
6573
6307
  };
6574
6308
  function fa_default() {
6575
6309
  return {
6576
- localeError: error13()
6310
+ localeError: error12()
6577
6311
  };
6578
6312
  }
6579
6313
 
6580
6314
  // ../../node_modules/zod/v4/locales/fi.js
6581
- var error14 = () => {
6315
+ var error13 = () => {
6582
6316
  const Sizable = {
6583
6317
  string: { unit: "merkki\xE4", subject: "merkkijonon" },
6584
6318
  file: { unit: "tavua", subject: "tiedoston" },
@@ -6686,12 +6420,12 @@ var error14 = () => {
6686
6420
  };
6687
6421
  function fi_default() {
6688
6422
  return {
6689
- localeError: error14()
6423
+ localeError: error13()
6690
6424
  };
6691
6425
  }
6692
6426
 
6693
6427
  // ../../node_modules/zod/v4/locales/fr.js
6694
- var error15 = () => {
6428
+ var error14 = () => {
6695
6429
  const Sizable = {
6696
6430
  string: { unit: "caract\xE8res", verb: "avoir" },
6697
6431
  file: { unit: "octets", verb: "avoir" },
@@ -6732,27 +6466,9 @@ var error15 = () => {
6732
6466
  template_literal: "entr\xE9e"
6733
6467
  };
6734
6468
  const TypeDictionary = {
6735
- string: "cha\xEEne",
6736
- number: "nombre",
6737
- int: "entier",
6738
- boolean: "bool\xE9en",
6739
- bigint: "grand entier",
6740
- symbol: "symbole",
6741
- undefined: "ind\xE9fini",
6742
- null: "null",
6743
- never: "jamais",
6744
- void: "vide",
6745
- date: "date",
6746
- array: "tableau",
6747
- object: "objet",
6748
- tuple: "tuple",
6749
- record: "enregistrement",
6750
- map: "carte",
6751
- set: "ensemble",
6752
- file: "fichier",
6753
- nonoptional: "non-optionnel",
6754
6469
  nan: "NaN",
6755
- function: "fonction"
6470
+ number: "nombre",
6471
+ array: "tableau"
6756
6472
  };
6757
6473
  return (issue2) => {
6758
6474
  switch (issue2.code) {
@@ -6773,15 +6489,16 @@ var error15 = () => {
6773
6489
  const adj = issue2.inclusive ? "<=" : "<";
6774
6490
  const sizing = getSizing(issue2.origin);
6775
6491
  if (sizing)
6776
- return `Trop grand : ${TypeDictionary[issue2.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
6777
- return `Trop grand : ${TypeDictionary[issue2.origin] ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
6492
+ return `Trop grand : ${issue2.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
6493
+ return `Trop grand : ${issue2.origin ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
6778
6494
  }
6779
6495
  case "too_small": {
6780
6496
  const adj = issue2.inclusive ? ">=" : ">";
6781
6497
  const sizing = getSizing(issue2.origin);
6782
- if (sizing)
6783
- return `Trop petit : ${TypeDictionary[issue2.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
6784
- return `Trop petit : ${TypeDictionary[issue2.origin] ?? "valeur"} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
6498
+ if (sizing) {
6499
+ return `Trop petit : ${issue2.origin} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
6500
+ }
6501
+ return `Trop petit : ${issue2.origin} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
6785
6502
  }
6786
6503
  case "invalid_format": {
6787
6504
  const _issue = issue2;
@@ -6812,12 +6529,12 @@ var error15 = () => {
6812
6529
  };
6813
6530
  function fr_default() {
6814
6531
  return {
6815
- localeError: error15()
6532
+ localeError: error14()
6816
6533
  };
6817
6534
  }
6818
6535
 
6819
6536
  // ../../node_modules/zod/v4/locales/fr-CA.js
6820
- var error16 = () => {
6537
+ var error15 = () => {
6821
6538
  const Sizable = {
6822
6539
  string: { unit: "caract\xE8res", verb: "avoir" },
6823
6540
  file: { unit: "octets", verb: "avoir" },
@@ -6920,12 +6637,12 @@ var error16 = () => {
6920
6637
  };
6921
6638
  function fr_CA_default() {
6922
6639
  return {
6923
- localeError: error16()
6640
+ localeError: error15()
6924
6641
  };
6925
6642
  }
6926
6643
 
6927
6644
  // ../../node_modules/zod/v4/locales/he.js
6928
- var error17 = () => {
6645
+ var error16 = () => {
6929
6646
  const TypeNames = {
6930
6647
  string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
6931
6648
  number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" },
@@ -7115,24 +6832,24 @@ var error17 = () => {
7115
6832
  };
7116
6833
  function he_default() {
7117
6834
  return {
7118
- localeError: error17()
6835
+ localeError: error16()
7119
6836
  };
7120
6837
  }
7121
6838
 
7122
- // ../../node_modules/zod/v4/locales/hr.js
7123
- var error18 = () => {
6839
+ // ../../node_modules/zod/v4/locales/hu.js
6840
+ var error17 = () => {
7124
6841
  const Sizable = {
7125
- string: { unit: "znakova", verb: "imati" },
7126
- file: { unit: "bajtova", verb: "imati" },
7127
- array: { unit: "stavki", verb: "imati" },
7128
- set: { unit: "stavki", verb: "imati" }
6842
+ string: { unit: "karakter", verb: "legyen" },
6843
+ file: { unit: "byte", verb: "legyen" },
6844
+ array: { unit: "elem", verb: "legyen" },
6845
+ set: { unit: "elem", verb: "legyen" }
7129
6846
  };
7130
6847
  function getSizing(origin) {
7131
6848
  return Sizable[origin] ?? null;
7132
6849
  }
7133
6850
  const FormatDictionary = {
7134
- regex: "unos",
7135
- email: "email adresa",
6851
+ regex: "bemenet",
6852
+ email: "email c\xEDm",
7136
6853
  url: "URL",
7137
6854
  emoji: "emoji",
7138
6855
  uuid: "UUID",
@@ -7145,37 +6862,25 @@ var error18 = () => {
7145
6862
  ulid: "ULID",
7146
6863
  xid: "XID",
7147
6864
  ksuid: "KSUID",
7148
- datetime: "ISO datum i vrijeme",
7149
- date: "ISO datum",
7150
- time: "ISO vrijeme",
7151
- duration: "ISO trajanje",
7152
- ipv4: "IPv4 adresa",
7153
- ipv6: "IPv6 adresa",
7154
- cidrv4: "IPv4 raspon",
7155
- cidrv6: "IPv6 raspon",
7156
- base64: "base64 kodirani tekst",
7157
- base64url: "base64url kodirani tekst",
7158
- json_string: "JSON tekst",
7159
- e164: "E.164 broj",
6865
+ datetime: "ISO id\u0151b\xE9lyeg",
6866
+ date: "ISO d\xE1tum",
6867
+ time: "ISO id\u0151",
6868
+ duration: "ISO id\u0151intervallum",
6869
+ ipv4: "IPv4 c\xEDm",
6870
+ ipv6: "IPv6 c\xEDm",
6871
+ cidrv4: "IPv4 tartom\xE1ny",
6872
+ cidrv6: "IPv6 tartom\xE1ny",
6873
+ base64: "base64-k\xF3dolt string",
6874
+ base64url: "base64url-k\xF3dolt string",
6875
+ json_string: "JSON string",
6876
+ e164: "E.164 sz\xE1m",
7160
6877
  jwt: "JWT",
7161
- template_literal: "unos"
6878
+ template_literal: "bemenet"
7162
6879
  };
7163
6880
  const TypeDictionary = {
7164
6881
  nan: "NaN",
7165
- string: "tekst",
7166
- number: "broj",
7167
- boolean: "boolean",
7168
- array: "niz",
7169
- object: "objekt",
7170
- set: "skup",
7171
- file: "datoteka",
7172
- date: "datum",
7173
- bigint: "bigint",
7174
- symbol: "simbol",
7175
- undefined: "undefined",
7176
- null: "null",
7177
- function: "funkcija",
7178
- map: "mapa"
6882
+ number: "sz\xE1m",
6883
+ array: "t\xF6mb"
7179
6884
  };
7180
6885
  return (issue2) => {
7181
6886
  switch (issue2.code) {
@@ -7184,125 +6889,14 @@ var error18 = () => {
7184
6889
  const receivedType = parsedType(issue2.input);
7185
6890
  const received = TypeDictionary[receivedType] ?? receivedType;
7186
6891
  if (/^[A-Z]/.test(issue2.expected)) {
7187
- return `Neispravan unos: o\u010Dekuje se instanceof ${issue2.expected}, a primljeno je ${received}`;
6892
+ return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue2.expected}, a kapott \xE9rt\xE9k ${received}`;
7188
6893
  }
7189
- return `Neispravan unos: o\u010Dekuje se ${expected}, a primljeno je ${received}`;
6894
+ return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
7190
6895
  }
7191
6896
  case "invalid_value":
7192
6897
  if (issue2.values.length === 1)
7193
- return `Neispravna vrijednost: o\u010Dekivano ${stringifyPrimitive(issue2.values[0])}`;
7194
- return `Neispravna opcija: o\u010Dekivano jedno od ${joinValues(issue2.values, "|")}`;
7195
- case "too_big": {
7196
- const adj = issue2.inclusive ? "<=" : "<";
7197
- const sizing = getSizing(issue2.origin);
7198
- const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
7199
- if (sizing)
7200
- return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} ima ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemenata"}`;
7201
- return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} bude ${adj}${issue2.maximum.toString()}`;
7202
- }
7203
- case "too_small": {
7204
- const adj = issue2.inclusive ? ">=" : ">";
7205
- const sizing = getSizing(issue2.origin);
7206
- const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
7207
- if (sizing) {
7208
- return `Premalo: o\u010Dekivano da ${origin} ima ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
7209
- }
7210
- return `Premalo: o\u010Dekivano da ${origin} bude ${adj}${issue2.minimum.toString()}`;
7211
- }
7212
- case "invalid_format": {
7213
- const _issue = issue2;
7214
- if (_issue.format === "starts_with")
7215
- return `Neispravan tekst: mora zapo\u010Dinjati s "${_issue.prefix}"`;
7216
- if (_issue.format === "ends_with")
7217
- return `Neispravan tekst: mora zavr\u0161avati s "${_issue.suffix}"`;
7218
- if (_issue.format === "includes")
7219
- return `Neispravan tekst: mora sadr\u017Eavati "${_issue.includes}"`;
7220
- if (_issue.format === "regex")
7221
- return `Neispravan tekst: mora odgovarati uzorku ${_issue.pattern}`;
7222
- return `Neispravna ${FormatDictionary[_issue.format] ?? issue2.format}`;
7223
- }
7224
- case "not_multiple_of":
7225
- return `Neispravan broj: mora biti vi\u0161ekratnik od ${issue2.divisor}`;
7226
- case "unrecognized_keys":
7227
- return `Neprepoznat${issue2.keys.length > 1 ? "i klju\u010Devi" : " klju\u010D"}: ${joinValues(issue2.keys, ", ")}`;
7228
- case "invalid_key":
7229
- return `Neispravan klju\u010D u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
7230
- case "invalid_union":
7231
- return "Neispravan unos";
7232
- case "invalid_element":
7233
- return `Neispravna vrijednost u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
7234
- default:
7235
- return `Neispravan unos`;
7236
- }
7237
- };
7238
- };
7239
- function hr_default() {
7240
- return {
7241
- localeError: error18()
7242
- };
7243
- }
7244
-
7245
- // ../../node_modules/zod/v4/locales/hu.js
7246
- var error19 = () => {
7247
- const Sizable = {
7248
- string: { unit: "karakter", verb: "legyen" },
7249
- file: { unit: "byte", verb: "legyen" },
7250
- array: { unit: "elem", verb: "legyen" },
7251
- set: { unit: "elem", verb: "legyen" }
7252
- };
7253
- function getSizing(origin) {
7254
- return Sizable[origin] ?? null;
7255
- }
7256
- const FormatDictionary = {
7257
- regex: "bemenet",
7258
- email: "email c\xEDm",
7259
- url: "URL",
7260
- emoji: "emoji",
7261
- uuid: "UUID",
7262
- uuidv4: "UUIDv4",
7263
- uuidv6: "UUIDv6",
7264
- nanoid: "nanoid",
7265
- guid: "GUID",
7266
- cuid: "cuid",
7267
- cuid2: "cuid2",
7268
- ulid: "ULID",
7269
- xid: "XID",
7270
- ksuid: "KSUID",
7271
- datetime: "ISO id\u0151b\xE9lyeg",
7272
- date: "ISO d\xE1tum",
7273
- time: "ISO id\u0151",
7274
- duration: "ISO id\u0151intervallum",
7275
- ipv4: "IPv4 c\xEDm",
7276
- ipv6: "IPv6 c\xEDm",
7277
- cidrv4: "IPv4 tartom\xE1ny",
7278
- cidrv6: "IPv6 tartom\xE1ny",
7279
- base64: "base64-k\xF3dolt string",
7280
- base64url: "base64url-k\xF3dolt string",
7281
- json_string: "JSON string",
7282
- e164: "E.164 sz\xE1m",
7283
- jwt: "JWT",
7284
- template_literal: "bemenet"
7285
- };
7286
- const TypeDictionary = {
7287
- nan: "NaN",
7288
- number: "sz\xE1m",
7289
- array: "t\xF6mb"
7290
- };
7291
- return (issue2) => {
7292
- switch (issue2.code) {
7293
- case "invalid_type": {
7294
- const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
7295
- const receivedType = parsedType(issue2.input);
7296
- const received = TypeDictionary[receivedType] ?? receivedType;
7297
- if (/^[A-Z]/.test(issue2.expected)) {
7298
- return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue2.expected}, a kapott \xE9rt\xE9k ${received}`;
7299
- }
7300
- return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
7301
- }
7302
- case "invalid_value":
7303
- if (issue2.values.length === 1)
7304
- return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue2.values[0])}`;
7305
- return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues(issue2.values, "|")}`;
6898
+ return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue2.values[0])}`;
6899
+ return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues(issue2.values, "|")}`;
7306
6900
  case "too_big": {
7307
6901
  const adj = issue2.inclusive ? "<=" : "<";
7308
6902
  const sizing = getSizing(issue2.origin);
@@ -7347,7 +6941,7 @@ var error19 = () => {
7347
6941
  };
7348
6942
  function hu_default() {
7349
6943
  return {
7350
- localeError: error19()
6944
+ localeError: error17()
7351
6945
  };
7352
6946
  }
7353
6947
 
@@ -7362,7 +6956,7 @@ function withDefiniteArticle(word) {
7362
6956
  const lastChar = word[word.length - 1];
7363
6957
  return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
7364
6958
  }
7365
- var error20 = () => {
6959
+ var error18 = () => {
7366
6960
  const Sizable = {
7367
6961
  string: {
7368
6962
  unit: {
@@ -7495,12 +7089,12 @@ var error20 = () => {
7495
7089
  };
7496
7090
  function hy_default() {
7497
7091
  return {
7498
- localeError: error20()
7092
+ localeError: error18()
7499
7093
  };
7500
7094
  }
7501
7095
 
7502
7096
  // ../../node_modules/zod/v4/locales/id.js
7503
- var error21 = () => {
7097
+ var error19 = () => {
7504
7098
  const Sizable = {
7505
7099
  string: { unit: "karakter", verb: "memiliki" },
7506
7100
  file: { unit: "byte", verb: "memiliki" },
@@ -7602,12 +7196,12 @@ var error21 = () => {
7602
7196
  };
7603
7197
  function id_default() {
7604
7198
  return {
7605
- localeError: error21()
7199
+ localeError: error19()
7606
7200
  };
7607
7201
  }
7608
7202
 
7609
7203
  // ../../node_modules/zod/v4/locales/is.js
7610
- var error22 = () => {
7204
+ var error20 = () => {
7611
7205
  const Sizable = {
7612
7206
  string: { unit: "stafi", verb: "a\xF0 hafa" },
7613
7207
  file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
@@ -7712,12 +7306,12 @@ var error22 = () => {
7712
7306
  };
7713
7307
  function is_default() {
7714
7308
  return {
7715
- localeError: error22()
7309
+ localeError: error20()
7716
7310
  };
7717
7311
  }
7718
7312
 
7719
7313
  // ../../node_modules/zod/v4/locales/it.js
7720
- var error23 = () => {
7314
+ var error21 = () => {
7721
7315
  const Sizable = {
7722
7316
  string: { unit: "caratteri", verb: "avere" },
7723
7317
  file: { unit: "byte", verb: "avere" },
@@ -7802,7 +7396,7 @@ var error23 = () => {
7802
7396
  return `Stringa non valida: deve includere "${_issue.includes}"`;
7803
7397
  if (_issue.format === "regex")
7804
7398
  return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
7805
- return `Input non valido: ${FormatDictionary[_issue.format] ?? issue2.format}`;
7399
+ return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
7806
7400
  }
7807
7401
  case "not_multiple_of":
7808
7402
  return `Numero non valido: deve essere un multiplo di ${issue2.divisor}`;
@@ -7821,12 +7415,12 @@ var error23 = () => {
7821
7415
  };
7822
7416
  function it_default() {
7823
7417
  return {
7824
- localeError: error23()
7418
+ localeError: error21()
7825
7419
  };
7826
7420
  }
7827
7421
 
7828
7422
  // ../../node_modules/zod/v4/locales/ja.js
7829
- var error24 = () => {
7423
+ var error22 = () => {
7830
7424
  const Sizable = {
7831
7425
  string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
7832
7426
  file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
@@ -7929,12 +7523,12 @@ var error24 = () => {
7929
7523
  };
7930
7524
  function ja_default() {
7931
7525
  return {
7932
- localeError: error24()
7526
+ localeError: error22()
7933
7527
  };
7934
7528
  }
7935
7529
 
7936
7530
  // ../../node_modules/zod/v4/locales/ka.js
7937
- var error25 = () => {
7531
+ var error23 = () => {
7938
7532
  const Sizable = {
7939
7533
  string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
7940
7534
  file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
@@ -7967,9 +7561,9 @@ var error25 = () => {
7967
7561
  ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
7968
7562
  cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
7969
7563
  cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
7970
- base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10D5\u10D4\u10DA\u10D8",
7971
- base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10D5\u10D4\u10DA\u10D8",
7972
- json_string: "JSON \u10D5\u10D4\u10DA\u10D8",
7564
+ base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
7565
+ base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
7566
+ json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
7973
7567
  e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
7974
7568
  jwt: "JWT",
7975
7569
  template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
@@ -7977,7 +7571,7 @@ var error25 = () => {
7977
7571
  const TypeDictionary = {
7978
7572
  nan: "NaN",
7979
7573
  number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
7980
- string: "\u10D5\u10D4\u10DA\u10D8",
7574
+ string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
7981
7575
  boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
7982
7576
  function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
7983
7577
  array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
@@ -8015,14 +7609,14 @@ var error25 = () => {
8015
7609
  case "invalid_format": {
8016
7610
  const _issue = issue2;
8017
7611
  if (_issue.format === "starts_with") {
8018
- 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`;
7612
+ 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`;
8019
7613
  }
8020
7614
  if (_issue.format === "ends_with")
8021
- 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`;
7615
+ 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`;
8022
7616
  if (_issue.format === "includes")
8023
- 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`;
7617
+ 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`;
8024
7618
  if (_issue.format === "regex")
8025
- 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}`;
7619
+ 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}`;
8026
7620
  return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${FormatDictionary[_issue.format] ?? issue2.format}`;
8027
7621
  }
8028
7622
  case "not_multiple_of":
@@ -8042,12 +7636,12 @@ var error25 = () => {
8042
7636
  };
8043
7637
  function ka_default() {
8044
7638
  return {
8045
- localeError: error25()
7639
+ localeError: error23()
8046
7640
  };
8047
7641
  }
8048
7642
 
8049
7643
  // ../../node_modules/zod/v4/locales/km.js
8050
- var error26 = () => {
7644
+ var error24 = () => {
8051
7645
  const Sizable = {
8052
7646
  string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
8053
7647
  file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
@@ -8153,7 +7747,7 @@ var error26 = () => {
8153
7747
  };
8154
7748
  function km_default() {
8155
7749
  return {
8156
- localeError: error26()
7750
+ localeError: error24()
8157
7751
  };
8158
7752
  }
8159
7753
 
@@ -8163,7 +7757,7 @@ function kh_default() {
8163
7757
  }
8164
7758
 
8165
7759
  // ../../node_modules/zod/v4/locales/ko.js
8166
- var error27 = () => {
7760
+ var error25 = () => {
8167
7761
  const Sizable = {
8168
7762
  string: { unit: "\uBB38\uC790", verb: "to have" },
8169
7763
  file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
@@ -8270,7 +7864,7 @@ var error27 = () => {
8270
7864
  };
8271
7865
  function ko_default() {
8272
7866
  return {
8273
- localeError: error27()
7867
+ localeError: error25()
8274
7868
  };
8275
7869
  }
8276
7870
 
@@ -8288,7 +7882,7 @@ function getUnitTypeFromNumber(number4) {
8288
7882
  return "one";
8289
7883
  return "few";
8290
7884
  }
8291
- var error28 = () => {
7885
+ var error26 = () => {
8292
7886
  const Sizable = {
8293
7887
  string: {
8294
7888
  unit: {
@@ -8474,12 +8068,12 @@ var error28 = () => {
8474
8068
  };
8475
8069
  function lt_default() {
8476
8070
  return {
8477
- localeError: error28()
8071
+ localeError: error26()
8478
8072
  };
8479
8073
  }
8480
8074
 
8481
8075
  // ../../node_modules/zod/v4/locales/mk.js
8482
- var error29 = () => {
8076
+ var error27 = () => {
8483
8077
  const Sizable = {
8484
8078
  string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
8485
8079
  file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
@@ -8584,12 +8178,12 @@ var error29 = () => {
8584
8178
  };
8585
8179
  function mk_default() {
8586
8180
  return {
8587
- localeError: error29()
8181
+ localeError: error27()
8588
8182
  };
8589
8183
  }
8590
8184
 
8591
8185
  // ../../node_modules/zod/v4/locales/ms.js
8592
- var error30 = () => {
8186
+ var error28 = () => {
8593
8187
  const Sizable = {
8594
8188
  string: { unit: "aksara", verb: "mempunyai" },
8595
8189
  file: { unit: "bait", verb: "mempunyai" },
@@ -8692,12 +8286,12 @@ var error30 = () => {
8692
8286
  };
8693
8287
  function ms_default() {
8694
8288
  return {
8695
- localeError: error30()
8289
+ localeError: error28()
8696
8290
  };
8697
8291
  }
8698
8292
 
8699
8293
  // ../../node_modules/zod/v4/locales/nl.js
8700
- var error31 = () => {
8294
+ var error29 = () => {
8701
8295
  const Sizable = {
8702
8296
  string: { unit: "tekens", verb: "heeft" },
8703
8297
  file: { unit: "bytes", verb: "heeft" },
@@ -8803,12 +8397,12 @@ var error31 = () => {
8803
8397
  };
8804
8398
  function nl_default() {
8805
8399
  return {
8806
- localeError: error31()
8400
+ localeError: error29()
8807
8401
  };
8808
8402
  }
8809
8403
 
8810
8404
  // ../../node_modules/zod/v4/locales/no.js
8811
- var error32 = () => {
8405
+ var error30 = () => {
8812
8406
  const Sizable = {
8813
8407
  string: { unit: "tegn", verb: "\xE5 ha" },
8814
8408
  file: { unit: "bytes", verb: "\xE5 ha" },
@@ -8912,12 +8506,12 @@ var error32 = () => {
8912
8506
  };
8913
8507
  function no_default() {
8914
8508
  return {
8915
- localeError: error32()
8509
+ localeError: error30()
8916
8510
  };
8917
8511
  }
8918
8512
 
8919
8513
  // ../../node_modules/zod/v4/locales/ota.js
8920
- var error33 = () => {
8514
+ var error31 = () => {
8921
8515
  const Sizable = {
8922
8516
  string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
8923
8517
  file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
@@ -9022,12 +8616,12 @@ var error33 = () => {
9022
8616
  };
9023
8617
  function ota_default() {
9024
8618
  return {
9025
- localeError: error33()
8619
+ localeError: error31()
9026
8620
  };
9027
8621
  }
9028
8622
 
9029
8623
  // ../../node_modules/zod/v4/locales/ps.js
9030
- var error34 = () => {
8624
+ var error32 = () => {
9031
8625
  const Sizable = {
9032
8626
  string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
9033
8627
  file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
@@ -9137,12 +8731,12 @@ var error34 = () => {
9137
8731
  };
9138
8732
  function ps_default() {
9139
8733
  return {
9140
- localeError: error34()
8734
+ localeError: error32()
9141
8735
  };
9142
8736
  }
9143
8737
 
9144
8738
  // ../../node_modules/zod/v4/locales/pl.js
9145
- var error35 = () => {
8739
+ var error33 = () => {
9146
8740
  const Sizable = {
9147
8741
  string: { unit: "znak\xF3w", verb: "mie\u0107" },
9148
8742
  file: { unit: "bajt\xF3w", verb: "mie\u0107" },
@@ -9247,12 +8841,12 @@ var error35 = () => {
9247
8841
  };
9248
8842
  function pl_default() {
9249
8843
  return {
9250
- localeError: error35()
8844
+ localeError: error33()
9251
8845
  };
9252
8846
  }
9253
8847
 
9254
8848
  // ../../node_modules/zod/v4/locales/pt.js
9255
- var error36 = () => {
8849
+ var error34 = () => {
9256
8850
  const Sizable = {
9257
8851
  string: { unit: "caracteres", verb: "ter" },
9258
8852
  file: { unit: "bytes", verb: "ter" },
@@ -9356,127 +8950,7 @@ var error36 = () => {
9356
8950
  };
9357
8951
  function pt_default() {
9358
8952
  return {
9359
- localeError: error36()
9360
- };
9361
- }
9362
-
9363
- // ../../node_modules/zod/v4/locales/ro.js
9364
- var error37 = () => {
9365
- const Sizable = {
9366
- string: { unit: "caractere", verb: "s\u0103 aib\u0103" },
9367
- file: { unit: "octe\u021Bi", verb: "s\u0103 aib\u0103" },
9368
- array: { unit: "elemente", verb: "s\u0103 aib\u0103" },
9369
- set: { unit: "elemente", verb: "s\u0103 aib\u0103" },
9370
- map: { unit: "intr\u0103ri", verb: "s\u0103 aib\u0103" }
9371
- };
9372
- function getSizing(origin) {
9373
- return Sizable[origin] ?? null;
9374
- }
9375
- const FormatDictionary = {
9376
- regex: "intrare",
9377
- email: "adres\u0103 de email",
9378
- url: "URL",
9379
- emoji: "emoji",
9380
- uuid: "UUID",
9381
- uuidv4: "UUIDv4",
9382
- uuidv6: "UUIDv6",
9383
- nanoid: "nanoid",
9384
- guid: "GUID",
9385
- cuid: "cuid",
9386
- cuid2: "cuid2",
9387
- ulid: "ULID",
9388
- xid: "XID",
9389
- ksuid: "KSUID",
9390
- datetime: "dat\u0103 \u0219i or\u0103 ISO",
9391
- date: "dat\u0103 ISO",
9392
- time: "or\u0103 ISO",
9393
- duration: "durat\u0103 ISO",
9394
- ipv4: "adres\u0103 IPv4",
9395
- ipv6: "adres\u0103 IPv6",
9396
- mac: "adres\u0103 MAC",
9397
- cidrv4: "interval IPv4",
9398
- cidrv6: "interval IPv6",
9399
- base64: "\u0219ir codat base64",
9400
- base64url: "\u0219ir codat base64url",
9401
- json_string: "\u0219ir JSON",
9402
- e164: "num\u0103r E.164",
9403
- jwt: "JWT",
9404
- template_literal: "intrare"
9405
- };
9406
- const TypeDictionary = {
9407
- nan: "NaN",
9408
- string: "\u0219ir",
9409
- number: "num\u0103r",
9410
- boolean: "boolean",
9411
- function: "func\u021Bie",
9412
- array: "matrice",
9413
- object: "obiect",
9414
- undefined: "nedefinit",
9415
- symbol: "simbol",
9416
- bigint: "num\u0103r mare",
9417
- void: "void",
9418
- never: "never",
9419
- map: "hart\u0103",
9420
- set: "set"
9421
- };
9422
- return (issue2) => {
9423
- switch (issue2.code) {
9424
- case "invalid_type": {
9425
- const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
9426
- const receivedType = parsedType(issue2.input);
9427
- const received = TypeDictionary[receivedType] ?? receivedType;
9428
- return `Intrare invalid\u0103: a\u0219teptat ${expected}, primit ${received}`;
9429
- }
9430
- case "invalid_value":
9431
- if (issue2.values.length === 1)
9432
- return `Intrare invalid\u0103: a\u0219teptat ${stringifyPrimitive(issue2.values[0])}`;
9433
- return `Op\u021Biune invalid\u0103: a\u0219teptat una dintre ${joinValues(issue2.values, "|")}`;
9434
- case "too_big": {
9435
- const adj = issue2.inclusive ? "<=" : "<";
9436
- const sizing = getSizing(issue2.origin);
9437
- if (sizing)
9438
- return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemente"}`;
9439
- return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} s\u0103 fie ${adj}${issue2.maximum.toString()}`;
9440
- }
9441
- case "too_small": {
9442
- const adj = issue2.inclusive ? ">=" : ">";
9443
- const sizing = getSizing(issue2.origin);
9444
- if (sizing) {
9445
- return `Prea mic: a\u0219teptat ca ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
9446
- }
9447
- return `Prea mic: a\u0219teptat ca ${issue2.origin} s\u0103 fie ${adj}${issue2.minimum.toString()}`;
9448
- }
9449
- case "invalid_format": {
9450
- const _issue = issue2;
9451
- if (_issue.format === "starts_with") {
9452
- return `\u0218ir invalid: trebuie s\u0103 \xEEnceap\u0103 cu "${_issue.prefix}"`;
9453
- }
9454
- if (_issue.format === "ends_with")
9455
- return `\u0218ir invalid: trebuie s\u0103 se termine cu "${_issue.suffix}"`;
9456
- if (_issue.format === "includes")
9457
- return `\u0218ir invalid: trebuie s\u0103 includ\u0103 "${_issue.includes}"`;
9458
- if (_issue.format === "regex")
9459
- return `\u0218ir invalid: trebuie s\u0103 se potriveasc\u0103 cu modelul ${_issue.pattern}`;
9460
- return `Format invalid: ${FormatDictionary[_issue.format] ?? issue2.format}`;
9461
- }
9462
- case "not_multiple_of":
9463
- return `Num\u0103r invalid: trebuie s\u0103 fie multiplu de ${issue2.divisor}`;
9464
- case "unrecognized_keys":
9465
- return `Chei nerecunoscute: ${joinValues(issue2.keys, ", ")}`;
9466
- case "invalid_key":
9467
- return `Cheie invalid\u0103 \xEEn ${issue2.origin}`;
9468
- case "invalid_union":
9469
- return "Intrare invalid\u0103";
9470
- case "invalid_element":
9471
- return `Valoare invalid\u0103 \xEEn ${issue2.origin}`;
9472
- default:
9473
- return `Intrare invalid\u0103`;
9474
- }
9475
- };
9476
- };
9477
- function ro_default() {
9478
- return {
9479
- localeError: error37()
8953
+ localeError: error34()
9480
8954
  };
9481
8955
  }
9482
8956
 
@@ -9496,7 +8970,7 @@ function getRussianPlural(count, one, few, many) {
9496
8970
  }
9497
8971
  return many;
9498
8972
  }
9499
- var error38 = () => {
8973
+ var error35 = () => {
9500
8974
  const Sizable = {
9501
8975
  string: {
9502
8976
  unit: {
@@ -9633,12 +9107,12 @@ var error38 = () => {
9633
9107
  };
9634
9108
  function ru_default() {
9635
9109
  return {
9636
- localeError: error38()
9110
+ localeError: error35()
9637
9111
  };
9638
9112
  }
9639
9113
 
9640
9114
  // ../../node_modules/zod/v4/locales/sl.js
9641
- var error39 = () => {
9115
+ var error36 = () => {
9642
9116
  const Sizable = {
9643
9117
  string: { unit: "znakov", verb: "imeti" },
9644
9118
  file: { unit: "bajtov", verb: "imeti" },
@@ -9743,12 +9217,12 @@ var error39 = () => {
9743
9217
  };
9744
9218
  function sl_default() {
9745
9219
  return {
9746
- localeError: error39()
9220
+ localeError: error36()
9747
9221
  };
9748
9222
  }
9749
9223
 
9750
9224
  // ../../node_modules/zod/v4/locales/sv.js
9751
- var error40 = () => {
9225
+ var error37 = () => {
9752
9226
  const Sizable = {
9753
9227
  string: { unit: "tecken", verb: "att ha" },
9754
9228
  file: { unit: "bytes", verb: "att ha" },
@@ -9854,12 +9328,12 @@ var error40 = () => {
9854
9328
  };
9855
9329
  function sv_default() {
9856
9330
  return {
9857
- localeError: error40()
9331
+ localeError: error37()
9858
9332
  };
9859
9333
  }
9860
9334
 
9861
9335
  // ../../node_modules/zod/v4/locales/ta.js
9862
- var error41 = () => {
9336
+ var error38 = () => {
9863
9337
  const Sizable = {
9864
9338
  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" },
9865
9339
  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" },
@@ -9965,12 +9439,12 @@ var error41 = () => {
9965
9439
  };
9966
9440
  function ta_default() {
9967
9441
  return {
9968
- localeError: error41()
9442
+ localeError: error38()
9969
9443
  };
9970
9444
  }
9971
9445
 
9972
9446
  // ../../node_modules/zod/v4/locales/th.js
9973
- var error42 = () => {
9447
+ var error39 = () => {
9974
9448
  const Sizable = {
9975
9449
  string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
9976
9450
  file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
@@ -10076,12 +9550,12 @@ var error42 = () => {
10076
9550
  };
10077
9551
  function th_default() {
10078
9552
  return {
10079
- localeError: error42()
9553
+ localeError: error39()
10080
9554
  };
10081
9555
  }
10082
9556
 
10083
9557
  // ../../node_modules/zod/v4/locales/tr.js
10084
- var error43 = () => {
9558
+ var error40 = () => {
10085
9559
  const Sizable = {
10086
9560
  string: { unit: "karakter", verb: "olmal\u0131" },
10087
9561
  file: { unit: "bayt", verb: "olmal\u0131" },
@@ -10182,12 +9656,12 @@ var error43 = () => {
10182
9656
  };
10183
9657
  function tr_default() {
10184
9658
  return {
10185
- localeError: error43()
9659
+ localeError: error40()
10186
9660
  };
10187
9661
  }
10188
9662
 
10189
9663
  // ../../node_modules/zod/v4/locales/uk.js
10190
- var error44 = () => {
9664
+ var error41 = () => {
10191
9665
  const Sizable = {
10192
9666
  string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
10193
9667
  file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
@@ -10291,7 +9765,7 @@ var error44 = () => {
10291
9765
  };
10292
9766
  function uk_default() {
10293
9767
  return {
10294
- localeError: error44()
9768
+ localeError: error41()
10295
9769
  };
10296
9770
  }
10297
9771
 
@@ -10301,7 +9775,7 @@ function ua_default() {
10301
9775
  }
10302
9776
 
10303
9777
  // ../../node_modules/zod/v4/locales/ur.js
10304
- var error45 = () => {
9778
+ var error42 = () => {
10305
9779
  const Sizable = {
10306
9780
  string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
10307
9781
  file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
@@ -10407,18 +9881,17 @@ var error45 = () => {
10407
9881
  };
10408
9882
  function ur_default() {
10409
9883
  return {
10410
- localeError: error45()
9884
+ localeError: error42()
10411
9885
  };
10412
9886
  }
10413
9887
 
10414
9888
  // ../../node_modules/zod/v4/locales/uz.js
10415
- var error46 = () => {
9889
+ var error43 = () => {
10416
9890
  const Sizable = {
10417
9891
  string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
10418
9892
  file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
10419
9893
  array: { unit: "element", verb: "bo\u2018lishi kerak" },
10420
- set: { unit: "element", verb: "bo\u2018lishi kerak" },
10421
- map: { unit: "yozuv", verb: "bo\u2018lishi kerak" }
9894
+ set: { unit: "element", verb: "bo\u2018lishi kerak" }
10422
9895
  };
10423
9896
  function getSizing(origin) {
10424
9897
  return Sizable[origin] ?? null;
@@ -10518,12 +9991,12 @@ var error46 = () => {
10518
9991
  };
10519
9992
  function uz_default() {
10520
9993
  return {
10521
- localeError: error46()
9994
+ localeError: error43()
10522
9995
  };
10523
9996
  }
10524
9997
 
10525
9998
  // ../../node_modules/zod/v4/locales/vi.js
10526
- var error47 = () => {
9999
+ var error44 = () => {
10527
10000
  const Sizable = {
10528
10001
  string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
10529
10002
  file: { unit: "byte", verb: "c\xF3" },
@@ -10627,12 +10100,12 @@ var error47 = () => {
10627
10100
  };
10628
10101
  function vi_default() {
10629
10102
  return {
10630
- localeError: error47()
10103
+ localeError: error44()
10631
10104
  };
10632
10105
  }
10633
10106
 
10634
10107
  // ../../node_modules/zod/v4/locales/zh-CN.js
10635
- var error48 = () => {
10108
+ var error45 = () => {
10636
10109
  const Sizable = {
10637
10110
  string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
10638
10111
  file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
@@ -10737,12 +10210,12 @@ var error48 = () => {
10737
10210
  };
10738
10211
  function zh_CN_default() {
10739
10212
  return {
10740
- localeError: error48()
10213
+ localeError: error45()
10741
10214
  };
10742
10215
  }
10743
10216
 
10744
10217
  // ../../node_modules/zod/v4/locales/zh-TW.js
10745
- var error49 = () => {
10218
+ var error46 = () => {
10746
10219
  const Sizable = {
10747
10220
  string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
10748
10221
  file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
@@ -10845,12 +10318,12 @@ var error49 = () => {
10845
10318
  };
10846
10319
  function zh_TW_default() {
10847
10320
  return {
10848
- localeError: error49()
10321
+ localeError: error46()
10849
10322
  };
10850
10323
  }
10851
10324
 
10852
10325
  // ../../node_modules/zod/v4/locales/yo.js
10853
- var error50 = () => {
10326
+ var error47 = () => {
10854
10327
  const Sizable = {
10855
10328
  string: { unit: "\xE0mi", verb: "n\xED" },
10856
10329
  file: { unit: "bytes", verb: "n\xED" },
@@ -10953,12 +10426,12 @@ var error50 = () => {
10953
10426
  };
10954
10427
  function yo_default() {
10955
10428
  return {
10956
- localeError: error50()
10429
+ localeError: error47()
10957
10430
  };
10958
10431
  }
10959
10432
 
10960
10433
  // ../../node_modules/zod/v4/core/registries.js
10961
- var _a2;
10434
+ var _a;
10962
10435
  var $output = /* @__PURE__ */ Symbol("ZodOutput");
10963
10436
  var $input = /* @__PURE__ */ Symbol("ZodInput");
10964
10437
  var $ZodRegistry = class {
@@ -11004,7 +10477,7 @@ var $ZodRegistry = class {
11004
10477
  function registry() {
11005
10478
  return new $ZodRegistry();
11006
10479
  }
11007
- (_a2 = globalThis).__zod_globalRegistry ?? (_a2.__zod_globalRegistry = registry());
10480
+ (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
11008
10481
  var globalRegistry = globalThis.__zod_globalRegistry;
11009
10482
 
11010
10483
  // ../../node_modules/zod/v4/core/api.js
@@ -11922,7 +11395,7 @@ function _refine(Class2, fn, _params) {
11922
11395
  return schema;
11923
11396
  }
11924
11397
  // @__NO_SIDE_EFFECTS__
11925
- function _superRefine(fn, params) {
11398
+ function _superRefine(fn) {
11926
11399
  const ch = /* @__PURE__ */ _check((payload) => {
11927
11400
  payload.addIssue = (issue2) => {
11928
11401
  if (typeof issue2 === "string") {
@@ -11939,7 +11412,7 @@ function _superRefine(fn, params) {
11939
11412
  }
11940
11413
  };
11941
11414
  return fn(payload.value, payload);
11942
- }, params);
11415
+ });
11943
11416
  return ch;
11944
11417
  }
11945
11418
  // @__NO_SIDE_EFFECTS__
@@ -12069,7 +11542,7 @@ function initializeContext(params) {
12069
11542
  };
12070
11543
  }
12071
11544
  function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
12072
- var _a3;
11545
+ var _a2;
12073
11546
  const def = schema._zod.def;
12074
11547
  const seen = ctx.seen.get(schema);
12075
11548
  if (seen) {
@@ -12116,8 +11589,8 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
12116
11589
  delete result.schema.examples;
12117
11590
  delete result.schema.default;
12118
11591
  }
12119
- if (ctx.io === "input" && "_prefault" in result.schema)
12120
- (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
11592
+ if (ctx.io === "input" && result.schema._prefault)
11593
+ (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
12121
11594
  delete result.schema._prefault;
12122
11595
  const _result = ctx.seen.get(schema);
12123
11596
  return _result.schema;
@@ -12298,15 +11771,10 @@ function finalize(ctx, schema) {
12298
11771
  result.$id = ctx.external.uri(id);
12299
11772
  }
12300
11773
  Object.assign(result, root.def ?? root.schema);
12301
- const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
12302
- if (rootMetaId !== void 0 && result.id === rootMetaId)
12303
- delete result.id;
12304
11774
  const defs = ctx.external?.defs ?? {};
12305
11775
  for (const entry of ctx.seen.entries()) {
12306
11776
  const seen = entry[1];
12307
11777
  if (seen.def && seen.defId) {
12308
- if (seen.def.id === seen.defId)
12309
- delete seen.def.id;
12310
11778
  defs[seen.defId] = seen.def;
12311
11779
  }
12312
11780
  }
@@ -12362,8 +11830,6 @@ function isTransforming(_schema, _ctx) {
12362
11830
  return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
12363
11831
  }
12364
11832
  if (def.type === "pipe") {
12365
- if (_schema._zod.traits.has("$ZodCodec"))
12366
- return true;
12367
11833
  return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
12368
11834
  }
12369
11835
  if (def.type === "object") {
@@ -12453,28 +11919,39 @@ var numberProcessor = (schema, ctx, _json, _params) => {
12453
11919
  json2.type = "integer";
12454
11920
  else
12455
11921
  json2.type = "number";
12456
- const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
12457
- const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
12458
- const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
12459
- if (exMin) {
12460
- if (legacy) {
11922
+ if (typeof exclusiveMinimum === "number") {
11923
+ if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
12461
11924
  json2.minimum = exclusiveMinimum;
12462
11925
  json2.exclusiveMinimum = true;
12463
11926
  } else {
12464
11927
  json2.exclusiveMinimum = exclusiveMinimum;
12465
11928
  }
12466
- } else if (typeof minimum === "number") {
11929
+ }
11930
+ if (typeof minimum === "number") {
12467
11931
  json2.minimum = minimum;
11932
+ if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
11933
+ if (exclusiveMinimum >= minimum)
11934
+ delete json2.minimum;
11935
+ else
11936
+ delete json2.exclusiveMinimum;
11937
+ }
12468
11938
  }
12469
- if (exMax) {
12470
- if (legacy) {
11939
+ if (typeof exclusiveMaximum === "number") {
11940
+ if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
12471
11941
  json2.maximum = exclusiveMaximum;
12472
11942
  json2.exclusiveMaximum = true;
12473
11943
  } else {
12474
11944
  json2.exclusiveMaximum = exclusiveMaximum;
12475
11945
  }
12476
- } else if (typeof maximum === "number") {
11946
+ }
11947
+ if (typeof maximum === "number") {
12477
11948
  json2.maximum = maximum;
11949
+ if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
11950
+ if (exclusiveMaximum <= maximum)
11951
+ delete json2.maximum;
11952
+ else
11953
+ delete json2.exclusiveMaximum;
11954
+ }
12478
11955
  }
12479
11956
  if (typeof multipleOf === "number")
12480
11957
  json2.multipleOf = multipleOf;
@@ -12646,10 +12123,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
12646
12123
  if (typeof maximum === "number")
12647
12124
  json2.maxItems = maximum;
12648
12125
  json2.type = "array";
12649
- json2.items = process(def.element, ctx, {
12650
- ...params,
12651
- path: [...params.path, "items"]
12652
- });
12126
+ json2.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
12653
12127
  };
12654
12128
  var objectProcessor = (schema, ctx, _json, params) => {
12655
12129
  const json2 = _json;
@@ -12842,8 +12316,7 @@ var catchProcessor = (schema, ctx, json2, params) => {
12842
12316
  };
12843
12317
  var pipeProcessor = (schema, ctx, _json, params) => {
12844
12318
  const def = schema._zod.def;
12845
- const inIsTransform = def.in._zod.traits.has("$ZodTransform");
12846
- const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
12319
+ const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
12847
12320
  process(innerType, ctx, params);
12848
12321
  const seen = ctx.seen.get(schema);
12849
12322
  seen.ref = innerType;
@@ -13077,7 +12550,6 @@ __export(schemas_exports2, {
13077
12550
  ZodOptional: () => ZodOptional,
13078
12551
  ZodPipe: () => ZodPipe,
13079
12552
  ZodPrefault: () => ZodPrefault,
13080
- ZodPreprocess: () => ZodPreprocess,
13081
12553
  ZodPromise: () => ZodPromise,
13082
12554
  ZodReadonly: () => ZodReadonly,
13083
12555
  ZodRecord: () => ZodRecord,
@@ -13138,7 +12610,6 @@ __export(schemas_exports2, {
13138
12610
  int32: () => int32,
13139
12611
  int64: () => int64,
13140
12612
  intersection: () => intersection,
13141
- invertCodec: () => invertCodec,
13142
12613
  ipv4: () => ipv42,
13143
12614
  ipv6: () => ipv62,
13144
12615
  json: () => json,
@@ -13308,8 +12779,8 @@ var initializer2 = (inst, issues) => {
13308
12779
  }
13309
12780
  });
13310
12781
  };
13311
- var ZodError = /* @__PURE__ */ $constructor("ZodError", initializer2);
13312
- var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, {
12782
+ var ZodError = $constructor("ZodError", initializer2);
12783
+ var ZodRealError = $constructor("ZodError", initializer2, {
13313
12784
  Parent: Error
13314
12785
  });
13315
12786
 
@@ -13328,43 +12799,6 @@ var safeEncodeAsync2 = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
13328
12799
  var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
13329
12800
 
13330
12801
  // ../../node_modules/zod/v4/classic/schemas.js
13331
- var _installedGroups = /* @__PURE__ */ new WeakMap();
13332
- function _installLazyMethods(inst, group, methods) {
13333
- const proto = Object.getPrototypeOf(inst);
13334
- let installed = _installedGroups.get(proto);
13335
- if (!installed) {
13336
- installed = /* @__PURE__ */ new Set();
13337
- _installedGroups.set(proto, installed);
13338
- }
13339
- if (installed.has(group))
13340
- return;
13341
- installed.add(group);
13342
- for (const key in methods) {
13343
- const fn = methods[key];
13344
- Object.defineProperty(proto, key, {
13345
- configurable: true,
13346
- enumerable: false,
13347
- get() {
13348
- const bound = fn.bind(this);
13349
- Object.defineProperty(this, key, {
13350
- configurable: true,
13351
- writable: true,
13352
- enumerable: true,
13353
- value: bound
13354
- });
13355
- return bound;
13356
- },
13357
- set(v) {
13358
- Object.defineProperty(this, key, {
13359
- configurable: true,
13360
- writable: true,
13361
- enumerable: true,
13362
- value: v
13363
- });
13364
- }
13365
- });
13366
- }
13367
- }
13368
12802
  var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
13369
12803
  $ZodType.init(inst, def);
13370
12804
  Object.assign(inst["~standard"], {
@@ -13377,6 +12811,23 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
13377
12811
  inst.def = def;
13378
12812
  inst.type = def.type;
13379
12813
  Object.defineProperty(inst, "_def", { value: def });
12814
+ inst.check = (...checks) => {
12815
+ return inst.clone(util_exports.mergeDefs(def, {
12816
+ checks: [
12817
+ ...def.checks ?? [],
12818
+ ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
12819
+ ]
12820
+ }), {
12821
+ parent: true
12822
+ });
12823
+ };
12824
+ inst.with = inst.check;
12825
+ inst.clone = (def2, params) => clone(inst, def2, params);
12826
+ inst.brand = () => inst;
12827
+ inst.register = ((reg, meta3) => {
12828
+ reg.add(inst, meta3);
12829
+ return inst;
12830
+ });
13380
12831
  inst.parse = (data2, params) => parse2(inst, data2, params, { callee: inst.parse });
13381
12832
  inst.safeParse = (data2, params) => safeParse2(inst, data2, params);
13382
12833
  inst.parseAsync = async (data2, params) => parseAsync2(inst, data2, params, { callee: inst.parseAsync });
@@ -13390,108 +12841,45 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
13390
12841
  inst.safeDecode = (data2, params) => safeDecode2(inst, data2, params);
13391
12842
  inst.safeEncodeAsync = async (data2, params) => safeEncodeAsync2(inst, data2, params);
13392
12843
  inst.safeDecodeAsync = async (data2, params) => safeDecodeAsync2(inst, data2, params);
13393
- _installLazyMethods(inst, "ZodType", {
13394
- check(...chks) {
13395
- const def2 = this.def;
13396
- return this.clone(util_exports.mergeDefs(def2, {
13397
- checks: [
13398
- ...def2.checks ?? [],
13399
- ...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
13400
- ]
13401
- }), { parent: true });
13402
- },
13403
- with(...chks) {
13404
- return this.check(...chks);
13405
- },
13406
- clone(def2, params) {
13407
- return clone(this, def2, params);
13408
- },
13409
- brand() {
13410
- return this;
13411
- },
13412
- register(reg, meta3) {
13413
- reg.add(this, meta3);
13414
- return this;
13415
- },
13416
- refine(check2, params) {
13417
- return this.check(refine(check2, params));
13418
- },
13419
- superRefine(refinement, params) {
13420
- return this.check(superRefine(refinement, params));
13421
- },
13422
- overwrite(fn) {
13423
- return this.check(_overwrite(fn));
13424
- },
13425
- optional() {
13426
- return optional(this);
13427
- },
13428
- exactOptional() {
13429
- return exactOptional(this);
13430
- },
13431
- nullable() {
13432
- return nullable(this);
13433
- },
13434
- nullish() {
13435
- return optional(nullable(this));
13436
- },
13437
- nonoptional(params) {
13438
- return nonoptional(this, params);
13439
- },
13440
- array() {
13441
- return array(this);
13442
- },
13443
- or(arg) {
13444
- return union([this, arg]);
13445
- },
13446
- and(arg) {
13447
- return intersection(this, arg);
13448
- },
13449
- transform(tx) {
13450
- return pipe(this, transform(tx));
13451
- },
13452
- default(d) {
13453
- return _default2(this, d);
13454
- },
13455
- prefault(d) {
13456
- return prefault(this, d);
13457
- },
13458
- catch(params) {
13459
- return _catch2(this, params);
13460
- },
13461
- pipe(target) {
13462
- return pipe(this, target);
13463
- },
13464
- readonly() {
13465
- return readonly(this);
13466
- },
13467
- describe(description) {
13468
- const cl = this.clone();
13469
- globalRegistry.add(cl, { description });
13470
- return cl;
13471
- },
13472
- meta(...args) {
13473
- if (args.length === 0)
13474
- return globalRegistry.get(this);
13475
- const cl = this.clone();
13476
- globalRegistry.add(cl, args[0]);
13477
- return cl;
13478
- },
13479
- isOptional() {
13480
- return this.safeParse(void 0).success;
13481
- },
13482
- isNullable() {
13483
- return this.safeParse(null).success;
13484
- },
13485
- apply(fn) {
13486
- return fn(this);
13487
- }
13488
- });
12844
+ inst.refine = (check2, params) => inst.check(refine(check2, params));
12845
+ inst.superRefine = (refinement) => inst.check(superRefine(refinement));
12846
+ inst.overwrite = (fn) => inst.check(_overwrite(fn));
12847
+ inst.optional = () => optional(inst);
12848
+ inst.exactOptional = () => exactOptional(inst);
12849
+ inst.nullable = () => nullable(inst);
12850
+ inst.nullish = () => optional(nullable(inst));
12851
+ inst.nonoptional = (params) => nonoptional(inst, params);
12852
+ inst.array = () => array(inst);
12853
+ inst.or = (arg) => union([inst, arg]);
12854
+ inst.and = (arg) => intersection(inst, arg);
12855
+ inst.transform = (tx) => pipe(inst, transform(tx));
12856
+ inst.default = (def2) => _default2(inst, def2);
12857
+ inst.prefault = (def2) => prefault(inst, def2);
12858
+ inst.catch = (params) => _catch2(inst, params);
12859
+ inst.pipe = (target) => pipe(inst, target);
12860
+ inst.readonly = () => readonly(inst);
12861
+ inst.describe = (description) => {
12862
+ const cl = inst.clone();
12863
+ globalRegistry.add(cl, { description });
12864
+ return cl;
12865
+ };
13489
12866
  Object.defineProperty(inst, "description", {
13490
12867
  get() {
13491
12868
  return globalRegistry.get(inst)?.description;
13492
12869
  },
13493
12870
  configurable: true
13494
12871
  });
12872
+ inst.meta = (...args) => {
12873
+ if (args.length === 0) {
12874
+ return globalRegistry.get(inst);
12875
+ }
12876
+ const cl = inst.clone();
12877
+ globalRegistry.add(cl, args[0]);
12878
+ return cl;
12879
+ };
12880
+ inst.isOptional = () => inst.safeParse(void 0).success;
12881
+ inst.isNullable = () => inst.safeParse(null).success;
12882
+ inst.apply = (fn) => fn(inst);
13495
12883
  return inst;
13496
12884
  });
13497
12885
  var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
@@ -13502,53 +12890,21 @@ var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
13502
12890
  inst.format = bag.format ?? null;
13503
12891
  inst.minLength = bag.minimum ?? null;
13504
12892
  inst.maxLength = bag.maximum ?? null;
13505
- _installLazyMethods(inst, "_ZodString", {
13506
- regex(...args) {
13507
- return this.check(_regex(...args));
13508
- },
13509
- includes(...args) {
13510
- return this.check(_includes(...args));
13511
- },
13512
- startsWith(...args) {
13513
- return this.check(_startsWith(...args));
13514
- },
13515
- endsWith(...args) {
13516
- return this.check(_endsWith(...args));
13517
- },
13518
- min(...args) {
13519
- return this.check(_minLength(...args));
13520
- },
13521
- max(...args) {
13522
- return this.check(_maxLength(...args));
13523
- },
13524
- length(...args) {
13525
- return this.check(_length(...args));
13526
- },
13527
- nonempty(...args) {
13528
- return this.check(_minLength(1, ...args));
13529
- },
13530
- lowercase(params) {
13531
- return this.check(_lowercase(params));
13532
- },
13533
- uppercase(params) {
13534
- return this.check(_uppercase(params));
13535
- },
13536
- trim() {
13537
- return this.check(_trim());
13538
- },
13539
- normalize(...args) {
13540
- return this.check(_normalize(...args));
13541
- },
13542
- toLowerCase() {
13543
- return this.check(_toLowerCase());
13544
- },
13545
- toUpperCase() {
13546
- return this.check(_toUpperCase());
13547
- },
13548
- slugify() {
13549
- return this.check(_slugify());
13550
- }
13551
- });
12893
+ inst.regex = (...args) => inst.check(_regex(...args));
12894
+ inst.includes = (...args) => inst.check(_includes(...args));
12895
+ inst.startsWith = (...args) => inst.check(_startsWith(...args));
12896
+ inst.endsWith = (...args) => inst.check(_endsWith(...args));
12897
+ inst.min = (...args) => inst.check(_minLength(...args));
12898
+ inst.max = (...args) => inst.check(_maxLength(...args));
12899
+ inst.length = (...args) => inst.check(_length(...args));
12900
+ inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
12901
+ inst.lowercase = (params) => inst.check(_lowercase(params));
12902
+ inst.uppercase = (params) => inst.check(_uppercase(params));
12903
+ inst.trim = () => inst.check(_trim());
12904
+ inst.normalize = (...args) => inst.check(_normalize(...args));
12905
+ inst.toLowerCase = () => inst.check(_toLowerCase());
12906
+ inst.toUpperCase = () => inst.check(_toUpperCase());
12907
+ inst.slugify = () => inst.check(_slugify());
13552
12908
  });
13553
12909
  var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
13554
12910
  $ZodString.init(inst, def);
@@ -13627,7 +12983,7 @@ function url(params) {
13627
12983
  }
13628
12984
  function httpUrl(params) {
13629
12985
  return _url(ZodURL, {
13630
- protocol: regexes_exports.httpProtocol,
12986
+ protocol: /^https?$/,
13631
12987
  hostname: regexes_exports.domain,
13632
12988
  ...util_exports.normalizeParams(params)
13633
12989
  });
@@ -13769,53 +13125,21 @@ var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
13769
13125
  $ZodNumber.init(inst, def);
13770
13126
  ZodType.init(inst, def);
13771
13127
  inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
13772
- _installLazyMethods(inst, "ZodNumber", {
13773
- gt(value, params) {
13774
- return this.check(_gt(value, params));
13775
- },
13776
- gte(value, params) {
13777
- return this.check(_gte(value, params));
13778
- },
13779
- min(value, params) {
13780
- return this.check(_gte(value, params));
13781
- },
13782
- lt(value, params) {
13783
- return this.check(_lt(value, params));
13784
- },
13785
- lte(value, params) {
13786
- return this.check(_lte(value, params));
13787
- },
13788
- max(value, params) {
13789
- return this.check(_lte(value, params));
13790
- },
13791
- int(params) {
13792
- return this.check(int(params));
13793
- },
13794
- safe(params) {
13795
- return this.check(int(params));
13796
- },
13797
- positive(params) {
13798
- return this.check(_gt(0, params));
13799
- },
13800
- nonnegative(params) {
13801
- return this.check(_gte(0, params));
13802
- },
13803
- negative(params) {
13804
- return this.check(_lt(0, params));
13805
- },
13806
- nonpositive(params) {
13807
- return this.check(_lte(0, params));
13808
- },
13809
- multipleOf(value, params) {
13810
- return this.check(_multipleOf(value, params));
13811
- },
13812
- step(value, params) {
13813
- return this.check(_multipleOf(value, params));
13814
- },
13815
- finite() {
13816
- return this;
13817
- }
13818
- });
13128
+ inst.gt = (value, params) => inst.check(_gt(value, params));
13129
+ inst.gte = (value, params) => inst.check(_gte(value, params));
13130
+ inst.min = (value, params) => inst.check(_gte(value, params));
13131
+ inst.lt = (value, params) => inst.check(_lt(value, params));
13132
+ inst.lte = (value, params) => inst.check(_lte(value, params));
13133
+ inst.max = (value, params) => inst.check(_lte(value, params));
13134
+ inst.int = (params) => inst.check(int(params));
13135
+ inst.safe = (params) => inst.check(int(params));
13136
+ inst.positive = (params) => inst.check(_gt(0, params));
13137
+ inst.nonnegative = (params) => inst.check(_gte(0, params));
13138
+ inst.negative = (params) => inst.check(_lt(0, params));
13139
+ inst.nonpositive = (params) => inst.check(_lte(0, params));
13140
+ inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
13141
+ inst.step = (value, params) => inst.check(_multipleOf(value, params));
13142
+ inst.finite = () => inst;
13819
13143
  const bag = inst._zod.bag;
13820
13144
  inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
13821
13145
  inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
@@ -13962,23 +13286,11 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
13962
13286
  ZodType.init(inst, def);
13963
13287
  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
13964
13288
  inst.element = def.element;
13965
- _installLazyMethods(inst, "ZodArray", {
13966
- min(n, params) {
13967
- return this.check(_minLength(n, params));
13968
- },
13969
- nonempty(params) {
13970
- return this.check(_minLength(1, params));
13971
- },
13972
- max(n, params) {
13973
- return this.check(_maxLength(n, params));
13974
- },
13975
- length(n, params) {
13976
- return this.check(_length(n, params));
13977
- },
13978
- unwrap() {
13979
- return this.element;
13980
- }
13981
- });
13289
+ inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
13290
+ inst.nonempty = (params) => inst.check(_minLength(1, params));
13291
+ inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
13292
+ inst.length = (len, params) => inst.check(_length(len, params));
13293
+ inst.unwrap = () => inst.element;
13982
13294
  });
13983
13295
  function array(element, params) {
13984
13296
  return _array(ZodArray, element, params);
@@ -13994,47 +13306,23 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
13994
13306
  util_exports.defineLazy(inst, "shape", () => {
13995
13307
  return def.shape;
13996
13308
  });
13997
- _installLazyMethods(inst, "ZodObject", {
13998
- keyof() {
13999
- return _enum2(Object.keys(this._zod.def.shape));
14000
- },
14001
- catchall(catchall) {
14002
- return this.clone({ ...this._zod.def, catchall });
14003
- },
14004
- passthrough() {
14005
- return this.clone({ ...this._zod.def, catchall: unknown() });
14006
- },
14007
- loose() {
14008
- return this.clone({ ...this._zod.def, catchall: unknown() });
14009
- },
14010
- strict() {
14011
- return this.clone({ ...this._zod.def, catchall: never() });
14012
- },
14013
- strip() {
14014
- return this.clone({ ...this._zod.def, catchall: void 0 });
14015
- },
14016
- extend(incoming) {
14017
- return util_exports.extend(this, incoming);
14018
- },
14019
- safeExtend(incoming) {
14020
- return util_exports.safeExtend(this, incoming);
14021
- },
14022
- merge(other) {
14023
- return util_exports.merge(this, other);
14024
- },
14025
- pick(mask) {
14026
- return util_exports.pick(this, mask);
14027
- },
14028
- omit(mask) {
14029
- return util_exports.omit(this, mask);
14030
- },
14031
- partial(...args) {
14032
- return util_exports.partial(ZodOptional, this, args[0]);
14033
- },
14034
- required(...args) {
14035
- return util_exports.required(ZodNonOptional, this, args[0]);
14036
- }
14037
- });
13309
+ inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape));
13310
+ inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
13311
+ inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
13312
+ inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
13313
+ inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
13314
+ inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
13315
+ inst.extend = (incoming) => {
13316
+ return util_exports.extend(inst, incoming);
13317
+ };
13318
+ inst.safeExtend = (incoming) => {
13319
+ return util_exports.safeExtend(inst, incoming);
13320
+ };
13321
+ inst.merge = (other) => util_exports.merge(inst, other);
13322
+ inst.pick = (mask) => util_exports.pick(inst, mask);
13323
+ inst.omit = (mask) => util_exports.omit(inst, mask);
13324
+ inst.partial = (...args) => util_exports.partial(ZodOptional, inst, args[0]);
13325
+ inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]);
14038
13326
  });
14039
13327
  function object(shape, params) {
14040
13328
  const def = {
@@ -14139,14 +13427,6 @@ var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
14139
13427
  inst.valueType = def.valueType;
14140
13428
  });
14141
13429
  function record(keyType, valueType, params) {
14142
- if (!valueType || !valueType._zod) {
14143
- return new ZodRecord({
14144
- type: "record",
14145
- keyType: string2(),
14146
- valueType: keyType,
14147
- ...util_exports.normalizeParams(valueType)
14148
- });
14149
- }
14150
13430
  return new ZodRecord({
14151
13431
  type: "record",
14152
13432
  keyType,
@@ -14318,12 +13598,10 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
14318
13598
  if (output instanceof Promise) {
14319
13599
  return output.then((output2) => {
14320
13600
  payload.value = output2;
14321
- payload.fallback = true;
14322
13601
  return payload;
14323
13602
  });
14324
13603
  }
14325
13604
  payload.value = output;
14326
- payload.fallback = true;
14327
13605
  return payload;
14328
13606
  };
14329
13607
  });
@@ -14478,20 +13756,6 @@ function codec(in_, out, params) {
14478
13756
  reverseTransform: params.encode
14479
13757
  });
14480
13758
  }
14481
- function invertCodec(codec2) {
14482
- const def = codec2._zod.def;
14483
- return new ZodCodec({
14484
- type: "pipe",
14485
- in: def.out,
14486
- out: def.in,
14487
- transform: def.reverseTransform,
14488
- reverseTransform: def.transform
14489
- });
14490
- }
14491
- var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) => {
14492
- ZodPipe.init(inst, def);
14493
- $ZodPreprocess.init(inst, def);
14494
- });
14495
13759
  var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
14496
13760
  $ZodReadonly.init(inst, def);
14497
13761
  ZodType.init(inst, def);
@@ -14571,8 +13835,8 @@ function custom(fn, _params) {
14571
13835
  function refine(fn, _params = {}) {
14572
13836
  return _refine(ZodCustom, fn, _params);
14573
13837
  }
14574
- function superRefine(fn, params) {
14575
- return _superRefine(fn, params);
13838
+ function superRefine(fn) {
13839
+ return _superRefine(fn);
14576
13840
  }
14577
13841
  var describe2 = describe;
14578
13842
  var meta2 = meta;
@@ -14610,11 +13874,7 @@ function json(params) {
14610
13874
  return jsonSchema;
14611
13875
  }
14612
13876
  function preprocess(fn, schema) {
14613
- return new ZodPreprocess({
14614
- type: "pipe",
14615
- in: transform(fn),
14616
- out: schema
14617
- });
13877
+ return pipe(transform(fn), schema);
14618
13878
  }
14619
13879
 
14620
13880
  // ../../node_modules/zod/v4/classic/compat.js
@@ -15035,6 +14295,12 @@ function convertBaseSchema(schema, ctx) {
15035
14295
  default:
15036
14296
  throw new Error(`Unsupported type: ${type}`);
15037
14297
  }
14298
+ if (schema.description) {
14299
+ zodSchema = zodSchema.describe(schema.description);
14300
+ }
14301
+ if (schema.default !== void 0) {
14302
+ zodSchema = zodSchema.default(schema.default);
14303
+ }
15038
14304
  return zodSchema;
15039
14305
  }
15040
14306
  function convertSchema(schema, ctx) {
@@ -15071,9 +14337,6 @@ function convertSchema(schema, ctx) {
15071
14337
  if (schema.readOnly === true) {
15072
14338
  baseSchema = z.readonly(baseSchema);
15073
14339
  }
15074
- if (schema.default !== void 0) {
15075
- baseSchema = baseSchema.default(schema.default);
15076
- }
15077
14340
  const extraMeta = {};
15078
14341
  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
15079
14342
  for (const key of coreMetadataKeys) {
@@ -15095,32 +14358,23 @@ function convertSchema(schema, ctx) {
15095
14358
  if (Object.keys(extraMeta).length > 0) {
15096
14359
  ctx.registry.add(baseSchema, extraMeta);
15097
14360
  }
15098
- if (schema.description) {
15099
- baseSchema = baseSchema.describe(schema.description);
15100
- }
15101
14361
  return baseSchema;
15102
14362
  }
15103
14363
  function fromJSONSchema(schema, params) {
15104
14364
  if (typeof schema === "boolean") {
15105
14365
  return schema ? z.any() : z.never();
15106
14366
  }
15107
- let normalized;
15108
- try {
15109
- normalized = JSON.parse(JSON.stringify(schema));
15110
- } catch {
15111
- throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
15112
- }
15113
- const version3 = detectVersion(normalized, params?.defaultTarget);
15114
- const defs = normalized.$defs || normalized.definitions || {};
14367
+ const version3 = detectVersion(schema, params?.defaultTarget);
14368
+ const defs = schema.$defs || schema.definitions || {};
15115
14369
  const ctx = {
15116
14370
  version: version3,
15117
14371
  defs,
15118
14372
  refs: /* @__PURE__ */ new Map(),
15119
14373
  processing: /* @__PURE__ */ new Set(),
15120
- rootSchema: normalized,
14374
+ rootSchema: schema,
15121
14375
  registry: params?.registry ?? globalRegistry
15122
14376
  };
15123
- return convertSchema(normalized, ctx);
14377
+ return convertSchema(schema, ctx);
15124
14378
  }
15125
14379
 
15126
14380
  // ../../node_modules/zod/v4/classic/coerce.js