@temporary-name/zod 1.9.3-alpha.e2d8d164da72fb570c2b14a4fa956c80f9e33cdc → 1.9.3-alpha.f9f5ce625d5edee78250b87b3a64f1d9760c2244

package/dist/index.mjs

@@ -3,7 +3,6 @@ import { $ZodError, util, _overwrite, _regex, _includes, _startsWith, _endsWith,
 export { core };
 export { _endsWith as endsWith, _gt as gt, _gte as gte, _includes as includes, _length as length, _lowercase as lowercase, _lt as lt, _lte as lte, _maxLength as maxLength, _maxSize as maxSize, _mime as mime, _minLength as minLength, _minSize as minSize, _multipleOf as multipleOf, _negative as negative, _nonnegative as nonnegative, _nonpositive as nonpositive, _normalize as normalize, _overwrite as overwrite, _positive as positive, _property as property, _regex as regex, _size as size, _startsWith as startsWith, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _trim as trim, _uppercase as uppercase } from 'zod/v4/core';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { custom as custom$1 } from 'zod/v3';
 
 const initializer = (inst, issues) => {
   $ZodError.init(inst, issues);
@@ -57,79 +56,82 @@ const safeDecode = /* @__PURE__ */ core._safeDecode(ZodRealError);
 const safeEncodeAsync = /* @__PURE__ */ core._safeEncodeAsync(ZodRealError);
 const safeDecodeAsync = /* @__PURE__ */ core._safeDecodeAsync(ZodRealError);
 
-const ZodISODateTime = /* @__PURE__ */ core.$constructor(
-  "ZodISODateTime",
+const KrustyISODateTime = /* @__PURE__ */ core.$constructor(
+  "KrustyISODateTime",
   (inst, def) => {
     const coreInit = core.$ZodISODateTime.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function datetime(params) {
-  return core._isoDateTime(ZodISODateTime, params);
+  return core._isoDateTime(KrustyISODateTime, params);
 }
-const ZodISODate = /* @__PURE__ */ core.$constructor(
-  "ZodISODate",
+const KrustyISODate = /* @__PURE__ */ core.$constructor(
+  "KrustyISODate",
   (inst, def) => {
     const coreInit = core.$ZodISODate.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function date$1(params) {
-  return core._isoDate(ZodISODate, params);
+  return core._isoDate(KrustyISODate, params);
 }
-const ZodISOTime = /* @__PURE__ */ core.$constructor(
-  "ZodISOTime",
+const KrustyISOTime = /* @__PURE__ */ core.$constructor(
+  "KrustyISOTime",
   (inst, def) => {
     const coreInit = core.$ZodISOTime.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function time(params) {
-  return core._isoTime(ZodISOTime, params);
+  return core._isoTime(KrustyISOTime, params);
 }
-const ZodISODuration = /* @__PURE__ */ core.$constructor(
-  "ZodISODuration",
+const KrustyISODuration = /* @__PURE__ */ core.$constructor(
+  "KrustyISODuration",
   (inst, def) => {
     const coreInit = core.$ZodISODuration.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function duration(params) {
-  return core._isoDuration(ZodISODuration, params);
+  return core._isoDuration(KrustyISODuration, params);
 }
 
 const gatingContext = new AsyncLocalStorage();
 function isGateIssueRaw(issue) {
-  return issue.code === "invalid_type" && issue.expected === "never" && issue.inst instanceof ZodGate;
+  return issue.code === "invalid_type" && issue.expected === "never" && issue.inst instanceof KrustyGate;
 }
 function isGateIssue(issue) {
   return issue.code === "invalid_type" && issue.expected === "never" && issue.path?.length === 0;
 }
-const ZodGate = /* @__PURE__ */ core.$constructor("ZodGate", (inst, def) => {
-  const coreInit = core.$ZodOptional.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst._zod.parse = (payload, ctx) => {
-    const gateEnabled = gatingContext.getStore()?.(def.gateName);
-    if (gateEnabled) {
-      return def.innerType._zod.run(payload, ctx);
-    } else if (payload.value !== void 0) {
-      payload.issues.push({
-        expected: "never",
-        code: "invalid_type",
-        input: payload.value,
-        inst
-      });
-    }
-    return payload;
-  };
-});
+const KrustyGate = /* @__PURE__ */ core.$constructor(
+  "KrustyGate",
+  (inst, def) => {
+    const coreInit = core.$ZodOptional.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst._zod.parse = (payload, ctx) => {
+      const gateEnabled = gatingContext.getStore()?.(def.gateName);
+      if (gateEnabled) {
+        return def.innerType._zod.run(payload, ctx);
+      } else if (payload.value !== void 0) {
+        payload.issues.push({
+          expected: "never",
+          code: "invalid_type",
+          input: payload.value,
+          inst
+        });
+      }
+      return payload;
+    };
+  }
+);
 function gate(innerType, gateName) {
-  return new ZodGate({
+  return new KrustyGate({
     type: "optional",
     innerType,
     gateName
@@ -146,8 +148,8 @@ function handleGating(payload) {
   }
   return payload;
 }
-const ZodUnion = /* @__PURE__ */ core.$constructor(
-  "ZodUnion",
+const KrustyUnion = /* @__PURE__ */ core.$constructor(
+  "KrustyUnion",
   (inst, def) => {
     const coreInit = core.$ZodUnion.init;
     coreInit(inst, def);
@@ -165,19 +167,19 @@ const ZodUnion = /* @__PURE__ */ core.$constructor(
   }
 );
 function union(options, params) {
-  return new ZodUnion({
+  return new KrustyUnion({
     type: "union",
     options,
     ...util.normalizeParams(params)
   });
 }
-const ZodDiscriminatedUnion = /* @__PURE__ */ core.$constructor("ZodDiscriminatedUnion", (inst, def) => {
-  ZodUnion.init(inst, def);
+const KrustyDiscriminatedUnion = /* @__PURE__ */ core.$constructor("KrustyDiscriminatedUnion", (inst, def) => {
+  KrustyUnion.init(inst, def);
   const coreInit = core.$ZodDiscriminatedUnion.init;
   coreInit(inst, def);
 });
 function discriminatedUnion(discriminator, options, params) {
-  return new ZodDiscriminatedUnion({
+  return new KrustyDiscriminatedUnion({
     type: "union",
     options,
     discriminator,
@@ -197,8 +199,8 @@ function handlePropertyResult(result, final, key, input) {
     final.value[key] = result.value;
   }
 }
-const ZodObject = /* @__PURE__ */ core.$constructor(
-  "ZodObject",
+const KrustyObject = /* @__PURE__ */ core.$constructor(
+  "KrustyObject",
   (inst, def) => {
     const coreInit = core.$ZodObjectJIT.init;
     coreInit(inst, def);
@@ -221,8 +223,8 @@ const ZodObject = /* @__PURE__ */ core.$constructor(
     inst.merge = (other) => util.merge(inst, other);
     inst.pick = (mask) => util.pick(inst, mask);
     inst.omit = (mask) => util.omit(inst, mask);
-    inst.partial = (...args) => util.partial(ZodOptional, inst, args[0]);
-    inst.required = (...args) => util.required(ZodNonOptional, inst, args[0]);
+    inst.partial = (...args) => util.partial(KrustyOptional, inst, args[0]);
+    inst.required = (...args) => util.required(KrustyNonOptional, inst, args[0]);
     function handleGating(input, payload, ctx) {
       const _catchall = def.catchall?._zod;
       const t = _catchall?.def.type;
@@ -278,6 +280,26 @@ const ZodObject = /* @__PURE__ */ core.$constructor(
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
       const res = origParse(payload, ctx);
+      if (!def.catchall) {
+        const { parseType } = ctx;
+        if (parseType && parseType !== "output") {
+          const unrecognized = [];
+          const keySet = new Set(Object.keys(def.shape));
+          for (const key in input) {
+            if (!keySet.has(key)) {
+              unrecognized.push(key);
+            }
+          }
+          if (unrecognized.length) {
+            payload.issues.push({
+              code: "unrecognized_keys",
+              keys: unrecognized,
+              input,
+              inst
+            });
+          }
+        }
+      }
       if (res instanceof Promise) {
         return res.then((r) => handleGating(input, r, ctx));
       } else {
@@ -292,10 +314,10 @@ function object(shape, params) {
     shape: shape ?? {},
     ...util.normalizeParams(params)
   };
-  return new ZodObject(def);
+  return new KrustyObject(def);
 }
 function strictObject(shape, params) {
-  return new ZodObject({
+  return new KrustyObject({
     type: "object",
     shape,
     catchall: never(),
@@ -303,7 +325,7 @@ function strictObject(shape, params) {
   });
 }
 function looseObject(shape, params) {
-  return new ZodObject({
+  return new KrustyObject({
     type: "object",
     shape,
     catchall: unknown(),
@@ -311,60 +333,6 @@ function looseObject(shape, params) {
   });
 }
 
-const CUSTOM_ZOD_DEF_SYMBOL = Symbol("ORPC_CUSTOM_ZOD_DEF");
-function setCustomZodDef(def, custom) {
-  Object.assign(def, { [CUSTOM_ZOD_DEF_SYMBOL]: custom });
-}
-function composeParams(defaultMessage, params) {
-  return (val) => {
-    const message = defaultMessage(val);
-    if (!params) {
-      return {
-        message
-      };
-    }
-    if (typeof params === "function") {
-      return {
-        message,
-        ...params(val)
-      };
-    }
-    if (typeof params === "object") {
-      return {
-        message,
-        ...params
-      };
-    }
-    return {
-      message: params
-    };
-  };
-}
-
-function blob(params) {
-  const schema = custom$1(
-    (val) => val instanceof Blob,
-    composeParams(
-      () => "Input is not a blob",
-      params
-    )
-  );
-  setCustomZodDef(schema._def, { type: "blob" });
-  return schema;
-}
-
-function regexp(params) {
-  const schema = custom$1(
-    (val) => val instanceof RegExp,
-    composeParams(
-      () => "Input is not a regexp",
-      params
-    )
-  );
-  setCustomZodDef(schema._def, { type: "regexp" });
-  return schema;
-}
-
 const KrustyType = /* @__PURE__ */ core.$constructor(
   "KrustyType",
   (inst, def) => {
@@ -391,19 +359,6 @@ const KrustyType = /* @__PURE__ */ core.$constructor(
       reg.add(inst, meta);
       return inst;
     });
-    inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
-    inst.safeParse = (data, params) => safeParse(inst, data, params);
-    inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
-    inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
-    inst.spa = inst.safeParseAsync;
-    inst.encode = (data, params) => encode(inst, data, params);
-    inst.decode = (data, params) => decode(inst, data, params);
-    inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
-    inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
-    inst.safeEncode = (data, params) => safeEncode(inst, data, params);
-    inst.safeDecode = (data, params) => safeDecode(inst, data, params);
-    inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
-    inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
     inst.refine = (check2, params) => inst.check(refine(check2, params));
     inst.superRefine = (refinement) => inst.check(superRefine(refinement));
     inst.overwrite = (fn) => inst.check(_overwrite(fn));
@@ -421,8 +376,8 @@ const KrustyType = /* @__PURE__ */ core.$constructor(
     return inst;
   }
 );
-const _ZodString = /* @__PURE__ */ core.$constructor(
-  "_ZodString",
+const _KrustyString = /* @__PURE__ */ core.$constructor(
+  "_KrustyString",
   (inst, def) => {
     const coreInit = core.$ZodString.init;
     coreInit(inst, def);
@@ -447,35 +402,35 @@ const _ZodString = /* @__PURE__ */ core.$constructor(
     inst.toUpperCase = () => inst.check(_toUpperCase());
   }
 );
-const ZodString = /* @__PURE__ */ core.$constructor(
-  "ZodString",
+const KrustyString = /* @__PURE__ */ core.$constructor(
+  "KrustyString",
   (inst, def) => {
     const coreInit = core.$ZodString.init;
     coreInit(inst, def);
-    _ZodString.init(inst, def);
-    inst.email = (params) => inst.check(core._email(ZodEmail, params));
-    inst.url = (params) => inst.check(core._url(ZodURL, params));
-    inst.jwt = (params) => inst.check(core._jwt(ZodJWT, params));
-    inst.emoji = (params) => inst.check(core._emoji(ZodEmoji, params));
-    inst.guid = (params) => inst.check(core._guid(ZodGUID, params));
-    inst.uuid = (params) => inst.check(core._uuid(ZodUUID, params));
-    inst.uuidv4 = (params) => inst.check(core._uuidv4(ZodUUID, params));
-    inst.uuidv6 = (params) => inst.check(core._uuidv6(ZodUUID, params));
-    inst.uuidv7 = (params) => inst.check(core._uuidv7(ZodUUID, params));
-    inst.nanoid = (params) => inst.check(core._nanoid(ZodNanoID, params));
-    inst.guid = (params) => inst.check(core._guid(ZodGUID, params));
-    inst.cuid = (params) => inst.check(core._cuid(ZodCUID, params));
-    inst.cuid2 = (params) => inst.check(core._cuid2(ZodCUID2, params));
-    inst.ulid = (params) => inst.check(core._ulid(ZodULID, params));
-    inst.base64 = (params) => inst.check(core._base64(ZodBase64, params));
-    inst.base64url = (params) => inst.check(core._base64url(ZodBase64URL, params));
-    inst.xid = (params) => inst.check(core._xid(ZodXID, params));
-    inst.ksuid = (params) => inst.check(core._ksuid(ZodKSUID, params));
-    inst.ipv4 = (params) => inst.check(core._ipv4(ZodIPv4, params));
-    inst.ipv6 = (params) => inst.check(core._ipv6(ZodIPv6, params));
-    inst.cidrv4 = (params) => inst.check(core._cidrv4(ZodCIDRv4, params));
-    inst.cidrv6 = (params) => inst.check(core._cidrv6(ZodCIDRv6, params));
-    inst.e164 = (params) => inst.check(core._e164(ZodE164, params));
+    _KrustyString.init(inst, def);
+    inst.email = (params) => inst.check(core._email(KrustyEmail, params));
+    inst.url = (params) => inst.check(core._url(KrustyURL, params));
+    inst.jwt = (params) => inst.check(core._jwt(KrustyJWT, params));
+    inst.emoji = (params) => inst.check(core._emoji(KrustyEmoji, params));
+    inst.guid = (params) => inst.check(core._guid(KrustyGUID, params));
+    inst.uuid = (params) => inst.check(core._uuid(KrustyUUID, params));
+    inst.uuidv4 = (params) => inst.check(core._uuidv4(KrustyUUID, params));
+    inst.uuidv6 = (params) => inst.check(core._uuidv6(KrustyUUID, params));
+    inst.uuidv7 = (params) => inst.check(core._uuidv7(KrustyUUID, params));
+    inst.nanoid = (params) => inst.check(core._nanoid(KrustyNanoID, params));
+    inst.guid = (params) => inst.check(core._guid(KrustyGUID, params));
+    inst.cuid = (params) => inst.check(core._cuid(KrustyCUID, params));
+    inst.cuid2 = (params) => inst.check(core._cuid2(KrustyCUID2, params));
+    inst.ulid = (params) => inst.check(core._ulid(KrustyULID, params));
+    inst.base64 = (params) => inst.check(core._base64(KrustyBase64, params));
+    inst.base64url = (params) => inst.check(core._base64url(KrustyBase64URL, params));
+    inst.xid = (params) => inst.check(core._xid(KrustyXID, params));
+    inst.ksuid = (params) => inst.check(core._ksuid(KrustyKSUID, params));
+    inst.ipv4 = (params) => inst.check(core._ipv4(KrustyIPv4, params));
+    inst.ipv6 = (params) => inst.check(core._ipv6(KrustyIPv6, params));
+    inst.cidrv4 = (params) => inst.check(core._cidrv4(KrustyCIDRv4, params));
+    inst.cidrv6 = (params) => inst.check(core._cidrv6(KrustyCIDRv6, params));
+    inst.e164 = (params) => inst.check(core._e164(KrustyE164, params));
     inst.datetime = (params) => inst.check(datetime(params));
     inst.date = (params) => inst.check(date$1(params));
     inst.time = (params) => inst.check(time(params));
@@ -483,234 +438,264 @@ const ZodString = /* @__PURE__ */ core.$constructor(
   }
 );
 function string(params) {
-  return core._string(ZodString, params);
+  return core._string(KrustyString, params);
 }
-const ZodStringFormat = /* @__PURE__ */ core.$constructor(
-  "ZodStringFormat",
+const KrustyStringFormat = /* @__PURE__ */ core.$constructor(
+  "KrustyStringFormat",
   (inst, def) => {
     const coreInit = core.$ZodStringFormat.init;
     coreInit(inst, def);
-    _ZodString.init(inst, def);
+    _KrustyString.init(inst, def);
   }
 );
-const ZodEmail = /* @__PURE__ */ core.$constructor(
-  "ZodEmail",
+const KrustyEmail = /* @__PURE__ */ core.$constructor(
+  "KrustyEmail",
   (inst, def) => {
     const coreInit = core.$ZodEmail.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function email(params) {
-  return core._email(ZodEmail, params);
+  return core._email(KrustyEmail, params);
 }
-const ZodGUID = /* @__PURE__ */ core.$constructor("ZodGUID", (inst, def) => {
-  const coreInit = core.$ZodGUID.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
+const KrustyGUID = /* @__PURE__ */ core.$constructor(
+  "KrustyGUID",
+  (inst, def) => {
+    const coreInit = core.$ZodGUID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
 function guid(params) {
-  return core._guid(ZodGUID, params);
+  return core._guid(KrustyGUID, params);
 }
-const ZodUUID = /* @__PURE__ */ core.$constructor("ZodUUID", (inst, def) => {
-  const coreInit = core.$ZodUUID.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
+const KrustyUUID = /* @__PURE__ */ core.$constructor(
+  "KrustyUUID",
+  (inst, def) => {
+    const coreInit = core.$ZodUUID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
 function uuid(params) {
-  return core._uuid(ZodUUID, params);
+  return core._uuid(KrustyUUID, params);
 }
 function uuidv4(params) {
-  return core._uuidv4(ZodUUID, params);
+  return core._uuidv4(KrustyUUID, params);
 }
 function uuidv6(params) {
-  return core._uuidv6(ZodUUID, params);
+  return core._uuidv6(KrustyUUID, params);
 }
 function uuidv7(params) {
-  return core._uuidv7(ZodUUID, params);
+  return core._uuidv7(KrustyUUID, params);
 }
-const ZodURL = /* @__PURE__ */ core.$constructor("ZodURL", (inst, def) => {
-  const coreInit = core.$ZodURL.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
+const KrustyURL = /* @__PURE__ */ core.$constructor(
+  "KrustyURL",
+  (inst, def) => {
+    const coreInit = core.$ZodURL.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
 function url(params) {
-  return core._url(ZodURL, params);
+  return core._url(KrustyURL, params);
 }
 function httpUrl(params) {
-  return core._url(ZodURL, {
+  return core._url(KrustyURL, {
     protocol: /^https?$/,
     hostname: core.regexes.domain,
     ...util.normalizeParams(params)
   });
 }
-const ZodEmoji = /* @__PURE__ */ core.$constructor(
-  "ZodEmoji",
+const KrustyEmoji = /* @__PURE__ */ core.$constructor(
+  "KrustyEmoji",
   (inst, def) => {
     const coreInit = core.$ZodEmoji.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function emoji(params) {
-  return core._emoji(ZodEmoji, params);
+  return core._emoji(KrustyEmoji, params);
 }
-const ZodNanoID = /* @__PURE__ */ core.$constructor(
-  "ZodNanoID",
+const KrustyNanoID = /* @__PURE__ */ core.$constructor(
+  "KrustyNanoID",
   (inst, def) => {
     const coreInit = core.$ZodNanoID.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function nanoid(params) {
-  return core._nanoid(ZodNanoID, params);
+  return core._nanoid(KrustyNanoID, params);
 }
-const ZodCUID = /* @__PURE__ */ core.$constructor("ZodCUID", (inst, def) => {
-  const coreInit = core.$ZodCUID.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
+const KrustyCUID = /* @__PURE__ */ core.$constructor(
+  "KrustyCUID",
+  (inst, def) => {
+    const coreInit = core.$ZodCUID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
 function cuid(params) {
-  return core._cuid(ZodCUID, params);
+  return core._cuid(KrustyCUID, params);
 }
-const ZodCUID2 = /* @__PURE__ */ core.$constructor(
-  "ZodCUID2",
+const KrustyCUID2 = /* @__PURE__ */ core.$constructor(
+  "KrustyCUID2",
   (inst, def) => {
     const coreInit = core.$ZodCUID2.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function cuid2(params) {
-  return core._cuid2(ZodCUID2, params);
+  return core._cuid2(KrustyCUID2, params);
 }
-const ZodULID = /* @__PURE__ */ core.$constructor("ZodULID", (inst, def) => {
-  const coreInit = core.$ZodULID.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
+const KrustyULID = /* @__PURE__ */ core.$constructor(
+  "KrustyULID",
+  (inst, def) => {
+    const coreInit = core.$ZodULID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
 function ulid(params) {
-  return core._ulid(ZodULID, params);
+  return core._ulid(KrustyULID, params);
 }
-const ZodXID = /* @__PURE__ */ core.$constructor("ZodXID", (inst, def) => {
-  const coreInit = core.$ZodXID.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
+const KrustyXID = /* @__PURE__ */ core.$constructor(
+  "KrustyXID",
+  (inst, def) => {
+    const coreInit = core.$ZodXID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
 function xid(params) {
-  return core._xid(ZodXID, params);
+  return core._xid(KrustyXID, params);
 }
-const ZodKSUID = /* @__PURE__ */ core.$constructor(
-  "ZodKSUID",
+const KrustyKSUID = /* @__PURE__ */ core.$constructor(
+  "KrustyKSUID",
   (inst, def) => {
     const coreInit = core.$ZodKSUID.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function ksuid(params) {
-  return core._ksuid(ZodKSUID, params);
+  return core._ksuid(KrustyKSUID, params);
 }
-const ZodIPv4 = /* @__PURE__ */ core.$constructor("ZodIPv4", (inst, def) => {
-  const coreInit = core.$ZodIPv4.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
+const KrustyIPv4 = /* @__PURE__ */ core.$constructor(
+  "KrustyIPv4",
+  (inst, def) => {
+    const coreInit = core.$ZodIPv4.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
 function ipv4(params) {
-  return core._ipv4(ZodIPv4, params);
+  return core._ipv4(KrustyIPv4, params);
 }
-const ZodIPv6 = /* @__PURE__ */ core.$constructor("ZodIPv6", (inst, def) => {
-  const coreInit = core.$ZodIPv6.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
+const KrustyIPv6 = /* @__PURE__ */ core.$constructor(
+  "KrustyIPv6",
+  (inst, def) => {
+    const coreInit = core.$ZodIPv6.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
 function ipv6(params) {
-  return core._ipv6(ZodIPv6, params);
+  return core._ipv6(KrustyIPv6, params);
 }
-const ZodCIDRv4 = /* @__PURE__ */ core.$constructor(
-  "ZodCIDRv4",
+const KrustyCIDRv4 = /* @__PURE__ */ core.$constructor(
+  "KrustyCIDRv4",
   (inst, def) => {
     const coreInit = core.$ZodCIDRv4.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function cidrv4(params) {
-  return core._cidrv4(ZodCIDRv4, params);
+  return core._cidrv4(KrustyCIDRv4, params);
 }
-const ZodCIDRv6 = /* @__PURE__ */ core.$constructor(
-  "ZodCIDRv6",
+const KrustyCIDRv6 = /* @__PURE__ */ core.$constructor(
+  "KrustyCIDRv6",
   (inst, def) => {
     const coreInit = core.$ZodCIDRv6.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function cidrv6(params) {
-  return core._cidrv6(ZodCIDRv6, params);
+  return core._cidrv6(KrustyCIDRv6, params);
 }
-const ZodBase64 = /* @__PURE__ */ core.$constructor(
-  "ZodBase64",
+const KrustyBase64 = /* @__PURE__ */ core.$constructor(
+  "KrustyBase64",
   (inst, def) => {
     const coreInit = core.$ZodBase64.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function base64(params) {
-  return core._base64(ZodBase64, params);
+  return core._base64(KrustyBase64, params);
 }
-const ZodBase64URL = /* @__PURE__ */ core.$constructor(
-  "ZodBase64URL",
+const KrustyBase64URL = /* @__PURE__ */ core.$constructor(
+  "KrustyBase64URL",
   (inst, def) => {
     const coreInit = core.$ZodBase64URL.init;
     coreInit(inst, def);
-    ZodStringFormat.init(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
 );
 function base64url(params) {
-  return core._base64url(ZodBase64URL, params);
+  return core._base64url(KrustyBase64URL, params);
 }
-const ZodE164 = /* @__PURE__ */ core.$constructor("ZodE164", (inst, def) => {
-  const coreInit = core.$ZodE164.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
+const KrustyE164 = /* @__PURE__ */ core.$constructor(
+  "KrustyE164",
+  (inst, def) => {
+    const coreInit = core.$ZodE164.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
 function e164(params) {
-  return core._e164(ZodE164, params);
+  return core._e164(KrustyE164, params);
 }
-const ZodJWT = /* @__PURE__ */ core.$constructor("ZodJWT", (inst, def) => {
-  const coreInit = core.$ZodJWT.init;
-  coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
-});
+const KrustyJWT = /* @__PURE__ */ core.$constructor(
+  "KrustyJWT",
+  (inst, def) => {
+    const coreInit = core.$ZodJWT.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
 function jwt(params) {
-  return core._jwt(ZodJWT, params);
+  return core._jwt(KrustyJWT, params);
 }
-const ZodCustomStringFormat = /* @__PURE__ */ core.$constructor("ZodCustomStringFormat", (inst, def) => {
+const KrustyCustomStringFormat = /* @__PURE__ */ core.$constructor("KrustyCustomStringFormat", (inst, def) => {
   const coreInit = core.$ZodCustomStringFormat.init;
   coreInit(inst, def);
-  ZodStringFormat.init(inst, def);
+  KrustyStringFormat.init(inst, def);
 });
 function stringFormat(format, fnOrRegex, _params = {}) {
-  return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
+  return core._stringFormat(KrustyCustomStringFormat, format, fnOrRegex, _params);
 }
 function hostname(_params) {
-  return core._stringFormat(ZodCustomStringFormat, "hostname", core.regexes.hostname, _params);
+  return core._stringFormat(KrustyCustomStringFormat, "hostname", core.regexes.hostname, _params);
 }
 function hex(_params) {
-  return core._stringFormat(ZodCustomStringFormat, "hex", core.regexes.hex, _params);
+  return core._stringFormat(KrustyCustomStringFormat, "hex", core.regexes.hex, _params);
 }
 function hash(alg, params) {
   const enc = params?.enc ?? "hex";
   const format = `${alg}_${enc}`;
   const regex = core.regexes[format];
   if (!regex) throw new Error(`Unrecognized hash format: ${format}`);
-  return core._stringFormat(ZodCustomStringFormat, format, regex, params);
+  return core._stringFormat(KrustyCustomStringFormat, format, regex, params);
 }
-const ZodNumber = /* @__PURE__ */ core.$constructor(
-  "ZodNumber",
+const KrustyNumber = /* @__PURE__ */ core.$constructor(
+  "KrustyNumber",
   (inst, def) => {
     const coreInit = core.$ZodNumber.init;
     coreInit(inst, def);
@@ -736,47 +721,80 @@ const ZodNumber = /* @__PURE__ */ core.$constructor(
     inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
     inst.isFinite = true;
     inst.format = bag.format ?? null;
+    const origParse = inst._zod.parse;
+    inst._zod.parse = (payload, ctx) => {
+      const { parseType } = ctx;
+      if (parseType === "query" && typeof payload.value === "string") {
+        const value = Number(payload.value);
+        if (!Number.isNaN(value)) {
+          payload.value = value;
+        }
+      }
+      return origParse(payload, ctx);
+    };
   }
 );
 function number(params) {
-  return core._number(ZodNumber, params);
+  return core._number(KrustyNumber, params);
 }
-const ZodNumberFormat = /* @__PURE__ */ core.$constructor(
-  "ZodNumberFormat",
+const KrustyNumberFormat = /* @__PURE__ */ core.$constructor(
+  "KrustyNumberFormat",
   (inst, def) => {
     const coreInit = core.$ZodNumberFormat.init;
     coreInit(inst, def);
-    ZodNumber.init(inst, def);
+    KrustyNumber.init(inst, def);
   }
 );
 function int(params) {
-  return core._int(ZodNumberFormat, params);
+  return core._int(KrustyNumberFormat, params);
 }
 function float32(params) {
-  return core._float32(ZodNumberFormat, params);
+  return core._float32(KrustyNumberFormat, params);
 }
 function float64(params) {
-  return core._float64(ZodNumberFormat, params);
+  return core._float64(KrustyNumberFormat, params);
 }
 function int32(params) {
-  return core._int32(ZodNumberFormat, params);
+  return core._int32(KrustyNumberFormat, params);
 }
 function uint32(params) {
-  return core._uint32(ZodNumberFormat, params);
+  return core._uint32(KrustyNumberFormat, params);
 }
-const ZodBoolean = /* @__PURE__ */ core.$constructor(
-  "ZodBoolean",
+const KrustyBoolean = /* @__PURE__ */ core.$constructor(
+  "KrustyBoolean",
   (inst, def) => {
     const coreInit = core.$ZodBoolean.init;
     coreInit(inst, def);
     KrustyType.init(inst, def);
+    const origParse = inst._zod.parse;
+    inst._zod.parse = (payload, ctx) => {
+      const { parseType } = ctx;
+      if (parseType === "query") {
+        if (payload.value === "true") {
+          payload.value = true;
+        } else if (payload.value === "false") {
+          payload.value = false;
+        } else {
+          payload.issues.push({
+            code: "invalid_type",
+            expected: "boolean",
+            values: ["true", "false"],
+            input: payload.value,
+            inst,
+            continue: false
+          });
+          return payload;
+        }
+      }
+      return origParse(payload, ctx);
+    };
   }
 );
 function boolean(params) {
-  return core._boolean(ZodBoolean, params);
+  return core._boolean(KrustyBoolean, params);
 }
-const ZodBigInt = /* @__PURE__ */ core.$constructor(
-  "ZodBigInt",
+const KrustyBigInt = /* @__PURE__ */ core.$constructor(
+  "KrustyBigInt",
   (inst, def) => {
     const coreInit = core.$ZodBigInt.init;
     coreInit(inst, def);
@@ -801,24 +819,24 @@ const ZodBigInt = /* @__PURE__ */ core.$constructor(
   }
 );
 function bigint(params) {
-  return core._bigint(ZodBigInt, params);
+  return core._bigint(KrustyBigInt, params);
 }
-const ZodBigIntFormat = /* @__PURE__ */ core.$constructor(
-  "ZodBigIntFormat",
+const KrustyBigIntFormat = /* @__PURE__ */ core.$constructor(
+  "KrustyBigIntFormat",
   (inst, def) => {
     const coreInit = core.$ZodBigIntFormat.init;
     coreInit(inst, def);
-    ZodBigInt.init(inst, def);
+    KrustyBigInt.init(inst, def);
   }
 );
 function int64(params) {
-  return core._int64(ZodBigIntFormat, params);
+  return core._int64(KrustyBigIntFormat, params);
 }
 function uint64(params) {
-  return core._uint64(ZodBigIntFormat, params);
+  return core._uint64(KrustyBigIntFormat, params);
 }
-const ZodSymbol = /* @__PURE__ */ core.$constructor(
-  "ZodSymbol",
+const KrustySymbol = /* @__PURE__ */ core.$constructor(
+  "KrustySymbol",
   (inst, def) => {
     const coreInit = core.$ZodSymbol.init;
     coreInit(inst, def);
@@ -826,10 +844,10 @@ const ZodSymbol = /* @__PURE__ */ core.$constructor(
   }
 );
 function symbol(params) {
-  return core._symbol(ZodSymbol, params);
+  return core._symbol(KrustySymbol, params);
 }
-const ZodUndefined = /* @__PURE__ */ core.$constructor(
-  "ZodUndefined",
+const KrustyUndefined = /* @__PURE__ */ core.$constructor(
+  "KrustyUndefined",
   (inst, def) => {
     const coreInit = core.$ZodUndefined.init;
     coreInit(inst, def);
@@ -837,26 +855,32 @@ const ZodUndefined = /* @__PURE__ */ core.$constructor(
   }
 );
 function _undefined(params) {
-  return core._undefined(ZodUndefined, params);
+  return core._undefined(KrustyUndefined, params);
 }
-const ZodNull = /* @__PURE__ */ core.$constructor("ZodNull", (inst, def) => {
-  const coreInit = core.$ZodNull.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-});
+const KrustyNull = /* @__PURE__ */ core.$constructor(
+  "KrustyNull",
+  (inst, def) => {
+    const coreInit = core.$ZodNull.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
 function _null(params) {
-  return core._null(ZodNull, params);
+  return core._null(KrustyNull, params);
 }
-const ZodAny = /* @__PURE__ */ core.$constructor("ZodAny", (inst, def) => {
-  const coreInit = core.$ZodAny.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-});
+const KrustyAny = /* @__PURE__ */ core.$constructor(
+  "KrustyAny",
+  (inst, def) => {
+    const coreInit = core.$ZodAny.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
 function any() {
-  return core._any(ZodAny);
+  return core._any(KrustyAny);
 }
-const ZodUnknown = /* @__PURE__ */ core.$constructor(
-  "ZodUnknown",
+const KrustyUnknown = /* @__PURE__ */ core.$constructor(
+  "KrustyUnknown",
   (inst, def) => {
     const coreInit = core.$ZodUnknown.init;
     coreInit(inst, def);
@@ -864,10 +888,10 @@ const ZodUnknown = /* @__PURE__ */ core.$constructor(
   }
 );
 function unknown() {
-  return core._unknown(ZodUnknown);
+  return core._unknown(KrustyUnknown);
 }
-const ZodNever = /* @__PURE__ */ core.$constructor(
-  "ZodNever",
+const KrustyNever = /* @__PURE__ */ core.$constructor(
+  "KrustyNever",
   (inst, def) => {
     const coreInit = core.$ZodNever.init;
     coreInit(inst, def);
@@ -875,31 +899,37 @@ const ZodNever = /* @__PURE__ */ core.$constructor(
   }
 );
 function never(params) {
-  return core._never(ZodNever, params);
+  return core._never(KrustyNever, params);
 }
-const ZodVoid = /* @__PURE__ */ core.$constructor("ZodVoid", (inst, def) => {
-  const coreInit = core.$ZodVoid.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-});
+const KrustyVoid = /* @__PURE__ */ core.$constructor(
+  "KrustyVoid",
+  (inst, def) => {
+    const coreInit = core.$ZodVoid.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
 function _void(params) {
-  return core._void(ZodVoid, params);
+  return core._void(KrustyVoid, params);
 }
-const ZodDate = /* @__PURE__ */ core.$constructor("ZodDate", (inst, def) => {
-  const coreInit = core.$ZodDate.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.min = (value, params) => inst.check(_gte(value, params));
-  inst.max = (value, params) => inst.check(_lte(value, params));
-  const c = inst._zod.bag;
-  inst.minDate = c.minimum ? new Date(c.minimum) : null;
-  inst.maxDate = c.maximum ? new Date(c.maximum) : null;
-});
+const KrustyDate = /* @__PURE__ */ core.$constructor(
+  "KrustyDate",
+  (inst, def) => {
+    const coreInit = core.$ZodDate.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.min = (value, params) => inst.check(_gte(value, params));
+    inst.max = (value, params) => inst.check(_lte(value, params));
+    const c = inst._zod.bag;
+    inst.minDate = c.minimum ? new Date(c.minimum) : null;
+    inst.maxDate = c.maximum ? new Date(c.maximum) : null;
+  }
+);
 function date(params) {
-  return core._date(ZodDate, params);
+  return core._date(KrustyDate, params);
 }
-const ZodArray = /* @__PURE__ */ core.$constructor(
-  "ZodArray",
+const KrustyArray = /* @__PURE__ */ core.$constructor(
+  "KrustyArray",
   (inst, def) => {
     const coreInit = core.$ZodArray.init;
     coreInit(inst, def);
@@ -913,14 +943,14 @@ const ZodArray = /* @__PURE__ */ core.$constructor(
   }
 );
 function array(element, params) {
-  return core._array(ZodArray, element, params);
+  return core._array(KrustyArray, element, params);
 }
 function keyof(schema) {
   const shape = schema._zod.def.shape;
   return _enum(Object.keys(shape));
 }
-const ZodIntersection = /* @__PURE__ */ core.$constructor(
-  "ZodIntersection",
+const KrustyIntersection = /* @__PURE__ */ core.$constructor(
+  "KrustyIntersection",
   (inst, def) => {
     const coreInit = core.$ZodIntersection.init;
     coreInit(inst, def);
@@ -928,14 +958,14 @@ const ZodIntersection = /* @__PURE__ */ core.$constructor(
   }
 );
 function intersection(left, right) {
-  return new ZodIntersection({
+  return new KrustyIntersection({
     type: "intersection",
     left,
     right
   });
 }
-const ZodTuple = /* @__PURE__ */ core.$constructor(
-  "ZodTuple",
+const KrustyTuple = /* @__PURE__ */ core.$constructor(
+  "KrustyTuple",
   (inst, def) => {
     const coreInit = core.$ZodTuple.init;
     coreInit(inst, def);
@@ -950,15 +980,15 @@ function tuple(items, _paramsOrRest, _params) {
   const hasRest = _paramsOrRest instanceof core.$ZodType;
   const params = hasRest ? _params : _paramsOrRest;
   const rest = hasRest ? _paramsOrRest : null;
-  return new ZodTuple({
+  return new KrustyTuple({
     type: "tuple",
     items,
     rest,
     ...util.normalizeParams(params)
   });
 }
-const ZodRecord = /* @__PURE__ */ core.$constructor(
-  "ZodRecord",
+const KrustyRecord = /* @__PURE__ */ core.$constructor(
+  "KrustyRecord",
   (inst, def) => {
     const coreInit = core.$ZodRecord.init;
     coreInit(inst, def);
@@ -968,7 +998,7 @@ const ZodRecord = /* @__PURE__ */ core.$constructor(
   }
 );
 function record(keyType, valueType, params) {
-  return new ZodRecord({
+  return new KrustyRecord({
     type: "record",
     keyType,
     valueType,
@@ -978,97 +1008,106 @@ function record(keyType, valueType, params) {
 function partialRecord(keyType, valueType, params) {
   const k = core.clone(keyType);
   k._zod.values = void 0;
-  return new ZodRecord({
+  return new KrustyRecord({
     type: "record",
     keyType: k,
     valueType,
     ...util.normalizeParams(params)
   });
 }
-const ZodMap = /* @__PURE__ */ core.$constructor("ZodMap", (inst, def) => {
-  const coreInit = core.$ZodMap.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.keyType = def.keyType;
-  inst.valueType = def.valueType;
-});
+const KrustyMap = /* @__PURE__ */ core.$constructor(
+  "KrustyMap",
+  (inst, def) => {
+    const coreInit = core.$ZodMap.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
+  }
+);
 function map(keyType, valueType, params) {
-  return new ZodMap({
+  return new KrustyMap({
     type: "map",
     keyType,
     valueType,
     ...util.normalizeParams(params)
   });
 }
-const ZodSet = /* @__PURE__ */ core.$constructor("ZodSet", (inst, def) => {
-  const coreInit = core.$ZodSet.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.min = (...args) => inst.check(core._minSize(...args));
-  inst.nonempty = (params) => inst.check(core._minSize(1, params));
-  inst.max = (...args) => inst.check(core._maxSize(...args));
-  inst.size = (...args) => inst.check(core._size(...args));
-});
+const KrustySet = /* @__PURE__ */ core.$constructor(
+  "KrustySet",
+  (inst, def) => {
+    const coreInit = core.$ZodSet.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.min = (...args) => inst.check(core._minSize(...args));
+    inst.nonempty = (params) => inst.check(core._minSize(1, params));
+    inst.max = (...args) => inst.check(core._maxSize(...args));
+    inst.size = (...args) => inst.check(core._size(...args));
+  }
+);
 function set(valueType, params) {
-  return new ZodSet({
+  return new KrustySet({
     type: "set",
     valueType,
     ...util.normalizeParams(params)
   });
 }
-const ZodEnum = /* @__PURE__ */ core.$constructor("ZodEnum", (inst, def) => {
-  const coreInit = core.$ZodEnum.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.enum = def.entries;
-  inst.options = Object.values(def.entries);
-  const keys = new Set(Object.keys(def.entries));
-  inst.extract = (values, params) => {
-    const newEntries = {};
-    for (const value of values) {
-      if (keys.has(value)) {
-        newEntries[value] = def.entries[value];
-      } else throw new Error(`Key ${value} not found in enum`);
-    }
-    return new ZodEnum({
-      ...def,
-      checks: [],
-      ...util.normalizeParams(params),
-      entries: newEntries
-    });
-  };
-  inst.exclude = (values, params) => {
-    const newEntries = { ...def.entries };
-    for (const value of values) {
-      if (keys.has(value)) {
-        delete newEntries[value];
-      } else throw new Error(`Key ${value} not found in enum`);
-    }
-    return new ZodEnum({
-      ...def,
-      checks: [],
-      ...util.normalizeParams(params),
-      entries: newEntries
-    });
-  };
-});
+const KrustyEnum = /* @__PURE__ */ core.$constructor(
+  "KrustyEnum",
+  (inst, def) => {
+    const coreInit = core.$ZodEnum.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.enum = def.entries;
+    inst.options = Object.values(def.entries);
+    const keys = new Set(Object.keys(def.entries));
+    inst.extract = (values, params) => {
+      const newEntries = {};
+      for (const value of values) {
+        if (keys.has(value)) {
+          newEntries[value] = def.entries[value];
+        } else throw new Error(`Key ${value} not found in enum`);
+      }
+      return new KrustyEnum({
+        ...def,
+        checks: [],
+        ...util.normalizeParams(params),
+        entries: newEntries
+      });
+    };
+    inst.exclude = (values, params) => {
+      const newEntries = { ...def.entries };
+      for (const value of values) {
+        if (keys.has(value)) {
+          delete newEntries[value];
+        } else throw new Error(`Key ${value} not found in enum`);
+      }
+      return new KrustyEnum({
+        ...def,
+        checks: [],
+        ...util.normalizeParams(params),
+        entries: newEntries
+      });
+    };
+  }
+);
 function _enum(values, params) {
   const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
-  return new ZodEnum({
+  return new KrustyEnum({
     type: "enum",
     entries,
     ...util.normalizeParams(params)
   });
 }
 function nativeEnum(entries, params) {
-  return new ZodEnum({
+  return new KrustyEnum({
     type: "enum",
     entries,
     ...util.normalizeParams(params)
   });
 }
-const ZodLiteral = /* @__PURE__ */ core.$constructor(
-  "ZodLiteral",
+const KrustyLiteral = /* @__PURE__ */ core.$constructor(
+  "KrustyLiteral",
   (inst, def) => {
     const coreInit = core.$ZodLiteral.init;
     coreInit(inst, def);
@@ -1085,25 +1124,28 @@ const ZodLiteral = /* @__PURE__ */ core.$constructor(
   }
 );
 function literal(value, params) {
-  return new ZodLiteral({
+  return new KrustyLiteral({
     type: "literal",
     values: Array.isArray(value) ? value : [value],
     ...util.normalizeParams(params)
   });
 }
-const ZodFile = /* @__PURE__ */ core.$constructor("ZodFile", (inst, def) => {
-  const coreInit = core.$ZodFile.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.min = (size, params) => inst.check(core._minSize(size, params));
-  inst.max = (size, params) => inst.check(core._maxSize(size, params));
-  inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));
-});
+const KrustyFile = /* @__PURE__ */ core.$constructor(
+  "KrustyFile",
+  (inst, def) => {
+    const coreInit = core.$ZodFile.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.min = (size, params) => inst.check(core._minSize(size, params));
+    inst.max = (size, params) => inst.check(core._maxSize(size, params));
+    inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));
+  }
+);
 function file(params) {
-  return core._file(ZodFile, params);
+  return core._file(KrustyFile, params);
 }
-const ZodTransform = /* @__PURE__ */ core.$constructor(
-  "ZodTransform",
+const KrustyTransform = /* @__PURE__ */ core.$constructor(
+  "KrustyTransform",
   (inst, def) => {
     const coreInit = core.$ZodTransform.init;
     coreInit(inst, def);
@@ -1137,13 +1179,13 @@ const ZodTransform = /* @__PURE__ */ core.$constructor(
   }
 );
 function transform(fn) {
-  return new ZodTransform({
+  return new KrustyTransform({
     type: "transform",
     transform: fn
   });
 }
-const ZodOptional = /* @__PURE__ */ core.$constructor(
-  "ZodOptional",
+const KrustyOptional = /* @__PURE__ */ core.$constructor(
+  "KrustyOptional",
   (inst, def) => {
     const coreInit = core.$ZodOptional.init;
     coreInit(inst, def);
@@ -1152,13 +1194,13 @@ const ZodOptional = /* @__PURE__ */ core.$constructor(
   }
 );
 function optional(innerType) {
-  return new ZodOptional({
+  return new KrustyOptional({
     type: "optional",
     innerType
   });
 }
-const ZodNullable = /* @__PURE__ */ core.$constructor(
-  "ZodNullable",
+const KrustyNullable = /* @__PURE__ */ core.$constructor(
+  "KrustyNullable",
   (inst, def) => {
     const coreInit = core.$ZodNullable.init;
     coreInit(inst, def);
@@ -1167,7 +1209,7 @@ const ZodNullable = /* @__PURE__ */ core.$constructor(
   }
 );
 function nullable(innerType) {
-  return new ZodNullable({
+  return new KrustyNullable({
     type: "nullable",
     innerType
   });
@@ -1175,8 +1217,8 @@ function nullable(innerType) {
 function nullish(innerType) {
   return optional(nullable(innerType));
 }
-const ZodDefault = /* @__PURE__ */ core.$constructor(
-  "ZodDefault",
+const KrustyDefault = /* @__PURE__ */ core.$constructor(
+  "KrustyDefault",
   (inst, def) => {
     const coreInit = core.$ZodDefault.init;
     coreInit(inst, def);
@@ -1186,7 +1228,7 @@ const ZodDefault = /* @__PURE__ */ core.$constructor(
   }
 );
 function _default(innerType, defaultValue) {
-  return new ZodDefault({
+  return new KrustyDefault({
     type: "default",
     innerType,
     get defaultValue() {
@@ -1194,8 +1236,8 @@ function _default(innerType, defaultValue) {
     }
   });
 }
-const ZodPrefault = /* @__PURE__ */ core.$constructor(
-  "ZodPrefault",
+const KrustyPrefault = /* @__PURE__ */ core.$constructor(
+  "KrustyPrefault",
   (inst, def) => {
     const coreInit = core.$ZodPrefault.init;
     coreInit(inst, def);
@@ -1204,7 +1246,7 @@ const ZodPrefault = /* @__PURE__ */ core.$constructor(
   }
 );
 function prefault(innerType, defaultValue) {
-  return new ZodPrefault({
+  return new KrustyPrefault({
     type: "prefault",
     innerType,
     get defaultValue() {
@@ -1212,8 +1254,8 @@ function prefault(innerType, defaultValue) {
     }
   });
 }
-const ZodNonOptional = /* @__PURE__ */ core.$constructor(
-  "ZodNonOptional",
+const KrustyNonOptional = /* @__PURE__ */ core.$constructor(
+  "KrustyNonOptional",
   (inst, def) => {
     const coreInit = core.$ZodNonOptional.init;
     coreInit(inst, def);
@@ -1222,14 +1264,14 @@ const ZodNonOptional = /* @__PURE__ */ core.$constructor(
   }
 );
 function nonoptional(innerType, params) {
-  return new ZodNonOptional({
+  return new KrustyNonOptional({
     type: "nonoptional",
     innerType,
     ...util.normalizeParams(params)
   });
 }
-const ZodSuccess = /* @__PURE__ */ core.$constructor(
-  "ZodSuccess",
+const KrustySuccess = /* @__PURE__ */ core.$constructor(
+  "KrustySuccess",
   (inst, def) => {
     const coreInit = core.$ZodSuccess.init;
     coreInit(inst, def);
@@ -1238,13 +1280,13 @@ const ZodSuccess = /* @__PURE__ */ core.$constructor(
   }
 );
 function success(innerType) {
-  return new ZodSuccess({
+  return new KrustySuccess({
     type: "success",
     innerType
   });
 }
-const ZodCatch = /* @__PURE__ */ core.$constructor(
-  "ZodCatch",
+const KrustyCatch = /* @__PURE__ */ core.$constructor(
+  "KrustyCatch",
   (inst, def) => {
     const coreInit = core.$ZodCatch.init;
     coreInit(inst, def);
@@ -1254,45 +1296,51 @@ const ZodCatch = /* @__PURE__ */ core.$constructor(
   }
 );
 function _catch(innerType, catchValue) {
-  return new ZodCatch({
+  return new KrustyCatch({
     type: "catch",
     innerType,
     catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
   });
 }
-const ZodNaN = /* @__PURE__ */ core.$constructor("ZodNaN", (inst, def) => {
-  const coreInit = core.$ZodNaN.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-});
+const KrustyNaN = /* @__PURE__ */ core.$constructor(
+  "KrustyNaN",
+  (inst, def) => {
+    const coreInit = core.$ZodNaN.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
 function nan(params) {
-  return core._nan(ZodNaN, params);
+  return core._nan(KrustyNaN, params);
 }
-const ZodPipe = /* @__PURE__ */ core.$constructor("ZodPipe", (inst, def) => {
-  const coreInit = core.$ZodPipe.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.in = def.in;
-  inst.out = def.out;
-});
+const KrustyPipe = /* @__PURE__ */ core.$constructor(
+  "KrustyPipe",
+  (inst, def) => {
+    const coreInit = core.$ZodPipe.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.in = def.in;
+    inst.out = def.out;
+  }
+);
 function pipe(in_, out) {
-  return new ZodPipe({
+  return new KrustyPipe({
     type: "pipe",
     in: in_,
     out
     // ...util.normalizeParams(params),
   });
 }
-const ZodCodec = /* @__PURE__ */ core.$constructor(
-  "ZodCodec",
+const KrustyCodec = /* @__PURE__ */ core.$constructor(
+  "KrustyCodec",
   (inst, def) => {
-    ZodPipe.init(inst, def);
+    KrustyPipe.init(inst, def);
     const coreInit = core.$ZodCodec.init;
     coreInit(inst, def);
   }
 );
 function codec(in_, out, params) {
-  return new ZodCodec({
+  return new KrustyCodec({
     type: "pipe",
     in: in_,
     out,
@@ -1300,8 +1348,8 @@ function codec(in_, out, params) {
     reverseTransform: params.encode
   });
 }
-const ZodReadonly = /* @__PURE__ */ core.$constructor(
-  "ZodReadonly",
+const KrustyReadonly = /* @__PURE__ */ core.$constructor(
+  "KrustyReadonly",
   (inst, def) => {
     const coreInit = core.$ZodReadonly.init;
     coreInit(inst, def);
@@ -1310,40 +1358,40 @@ const ZodReadonly = /* @__PURE__ */ core.$constructor(
   }
 );
 function readonly(innerType) {
-  return new ZodReadonly({
+  return new KrustyReadonly({
     type: "readonly",
     innerType
   });
 }
-const ZodTemplateLiteral = /* @__PURE__ */ core.$constructor(
-  "ZodTemplateLiteral",
-  (inst, def) => {
-    const coreInit = core.$ZodTemplateLiteral.init;
-    coreInit(inst, def);
-    KrustyType.init(inst, def);
-  }
-);
+const KrustyTemplateLiteral = /* @__PURE__ */ core.$constructor("KrustyTemplateLiteral", (inst, def) => {
+  const coreInit = core.$ZodTemplateLiteral.init;
+  coreInit(inst, def);
+  KrustyType.init(inst, def);
+});
 function templateLiteral(parts, params) {
-  return new ZodTemplateLiteral({
+  return new KrustyTemplateLiteral({
     type: "template_literal",
     parts,
     ...util.normalizeParams(params)
   });
 }
-const ZodLazy = /* @__PURE__ */ core.$constructor("ZodLazy", (inst, def) => {
-  const coreInit = core.$ZodLazy.init;
-  coreInit(inst, def);
-  KrustyType.init(inst, def);
-  inst.unwrap = () => inst._zod.def.getter();
-});
+const KrustyLazy = /* @__PURE__ */ core.$constructor(
+  "KrustyLazy",
+  (inst, def) => {
+    const coreInit = core.$ZodLazy.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.getter();
+  }
+);
 function lazy(getter) {
-  return new ZodLazy({
+  return new KrustyLazy({
     type: "lazy",
     getter
   });
 }
-const ZodPromise = /* @__PURE__ */ core.$constructor(
-  "ZodPromise",
+const KrustyPromise = /* @__PURE__ */ core.$constructor(
+  "KrustyPromise",
   (inst, def) => {
     const coreInit = core.$ZodPromise.init;
     coreInit(inst, def);
@@ -1352,13 +1400,13 @@ const ZodPromise = /* @__PURE__ */ core.$constructor(
   }
 );
 function promise(innerType) {
-  return new ZodPromise({
+  return new KrustyPromise({
     type: "promise",
     innerType
   });
 }
-const ZodFunction = /* @__PURE__ */ core.$constructor(
-  "ZodFunction",
+const KrustyFunction = /* @__PURE__ */ core.$constructor(
+  "KrustyFunction",
   (inst, def) => {
     const coreInit = core.$ZodFunction.init;
     coreInit(inst, def);
@@ -1366,14 +1414,14 @@ const ZodFunction = /* @__PURE__ */ core.$constructor(
   }
 );
 function _function(params) {
-  return new ZodFunction({
+  return new KrustyFunction({
     type: "function",
     input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
     output: params?.output ?? unknown()
   });
 }
-const ZodCustom = /* @__PURE__ */ core.$constructor(
-  "ZodCustom",
+const KrustyCustom = /* @__PURE__ */ core.$constructor(
+  "KrustyCustom",
   (inst, def) => {
     const coreInit = core.$ZodCustom.init;
     coreInit(inst, def);
@@ -1389,10 +1437,10 @@ function check(fn) {
   return ch;
 }
 function custom(fn, _params) {
-  return core._custom(ZodCustom, fn ?? (() => true), _params);
+  return core._custom(KrustyCustom, fn ?? (() => true), _params);
 }
 function refine(fn, _params = {}) {
-  return core._refine(ZodCustom, fn, _params);
+  return core._refine(KrustyCustom, fn, _params);
 }
 function superRefine(fn) {
   return core._superRefine(fn);
@@ -1400,7 +1448,7 @@ function superRefine(fn) {
 function _instanceof(cls, params = {
   error: `Input not instance of ${cls.name}`
 }) {
-  const inst = new ZodCustom({
+  const inst = new KrustyCustom({
     type: "custom",
     check: "custom",
     fn: (data) => data instanceof cls,
@@ -1412,9 +1460,9 @@ function _instanceof(cls, params = {
 }
 const stringbool = (...args) => core._stringbool(
   {
-    Codec: ZodCodec,
-    Boolean: ZodBoolean,
-    String: ZodString
+    Codec: KrustyCodec,
+    Boolean: KrustyBoolean,
+    String: KrustyString
   },
   ...args
 );
@@ -1431,9 +1479,6 @@ function json(params) {
   });
   return jsonSchema;
 }
-function preprocess(fn, schema) {
-  return pipe(transform(fn), schema);
-}
 
 class SchemaClass {
   string(params) {
@@ -1553,7 +1598,6 @@ class SchemaClass {
    */
   /**
    * TODO: decide what other helper methods to expose
-   * preprocess
    * refine
    * superRefine
    * custom
@@ -1571,4 +1615,4 @@ class SchemaClass {
    */
 }
 
-export { KrustyType, SchemaClass, ZodAny, ZodArray, ZodBase64, ZodBase64URL, ZodBigInt, ZodBigIntFormat, ZodBoolean, ZodCIDRv4, ZodCIDRv6, ZodCUID, ZodCUID2, ZodCatch, ZodCodec, ZodCustom, ZodCustomStringFormat, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodE164, ZodEmail, ZodEmoji, ZodEnum, ZodError, ZodFile, ZodFunction, ZodGUID, ZodGate, ZodIPv4, ZodIPv6, ZodIntersection, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPromise, ZodReadonly, ZodRealError, ZodRecord, ZodSet, ZodString, ZodStringFormat, ZodSuccess, ZodSymbol, ZodTemplateLiteral, ZodTransform, ZodTuple, ZodULID, ZodURL, ZodUUID, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, ZodXID, _ZodString, _default, _function, any, array, base64, base64url, bigint, blob, boolean, _catch as catch, check, cidrv4, cidrv6, codec, cuid, cuid2, custom, date, decode, decodeAsync, discriminatedUnion, e164, email, emoji, encode, encodeAsync, _enum as enum, file, float32, float64, _function as function, gate, gatingContext, guid, hash, hex, hostname, httpUrl, _instanceof as instanceof, int, int32, int64, intersection, ipv4, ipv6, isGateIssue, isGateIssueRaw, json, jwt, keyof, ksuid, lazy, literal, looseObject, map, nan, nanoid, nativeEnum, never, nonoptional, _null as null, nullable, nullish, number, object, optional, parse, parseAsync, partialRecord, pipe, prefault, preprocess, promise, readonly, record, refine, regexp, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, set, strictObject, string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, transform, tuple, uint32, uint64, ulid, _undefined as undefined, union, unknown, url, uuid, uuidv4, uuidv6, uuidv7, _void as void, xid };
+export { KrustyAny, KrustyArray, KrustyBase64, KrustyBase64URL, KrustyBigInt, KrustyBigIntFormat, KrustyBoolean, KrustyCIDRv4, KrustyCIDRv6, KrustyCUID, KrustyCUID2, KrustyCatch, KrustyCodec, KrustyCustom, KrustyCustomStringFormat, KrustyDate, KrustyDefault, KrustyDiscriminatedUnion, KrustyE164, KrustyEmail, KrustyEmoji, KrustyEnum, KrustyFile, KrustyFunction, KrustyGUID, KrustyGate, KrustyIPv4, KrustyIPv6, KrustyIntersection, KrustyJWT, KrustyKSUID, KrustyLazy, KrustyLiteral, KrustyMap, KrustyNaN, KrustyNanoID, KrustyNever, KrustyNonOptional, KrustyNull, KrustyNullable, KrustyNumber, KrustyNumberFormat, KrustyObject, KrustyOptional, KrustyPipe, KrustyPrefault, KrustyPromise, KrustyReadonly, KrustyRecord, KrustySet, KrustyString, KrustyStringFormat, KrustySuccess, KrustySymbol, KrustyTemplateLiteral, KrustyTransform, KrustyTuple, KrustyType, KrustyULID, KrustyURL, KrustyUUID, KrustyUndefined, KrustyUnion, KrustyUnknown, KrustyVoid, KrustyXID, SchemaClass, ZodError, ZodRealError, _KrustyString, _default, _function, any, array, base64, base64url, bigint, boolean, _catch as catch, check, cidrv4, cidrv6, codec, cuid, cuid2, custom, date, decode, decodeAsync, discriminatedUnion, e164, email, emoji, encode, encodeAsync, _enum as enum, file, float32, float64, _function as function, gate, gatingContext, guid, hash, hex, hostname, httpUrl, _instanceof as instanceof, int, int32, int64, intersection, ipv4, ipv6, isGateIssue, isGateIssueRaw, json, jwt, keyof, ksuid, lazy, literal, looseObject, map, nan, nanoid, nativeEnum, never, nonoptional, _null as null, nullable, nullish, number, object, optional, parse, parseAsync, partialRecord, pipe, prefault, promise, readonly, record, refine, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, set, strictObject, string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, transform, tuple, uint32, uint64, ulid, _undefined as undefined, union, unknown, url, uuid, uuidv4, uuidv6, uuidv7, _void as void, xid };