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

package/dist/index.mjs

@@ -1,42 +1,320 @@
-import { custom, ZodFirstPartyTypeKind } from 'zod/v3';
-import wcmatch from 'wildcard-match';
-import { isObject, guard, toArray } from '@temporary-name/shared';
-import { JsonSchemaXNativeType } from '@temporary-name/json-schema';
-import { JSONSchemaFormat } from '@temporary-name/server/openapi';
-import escapeStringRegexp from 'escape-string-regexp';
+import * as core from 'zod/v4/core';
+import { $ZodError, util, _overwrite, _regex, _includes, _startsWith, _endsWith, _minLength, _maxLength, _length, _lowercase, _uppercase, _trim, _normalize, _toLowerCase, _toUpperCase, _gt, _gte, _lt, _lte, _multipleOf } from 'zod/v4/core';
+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 CUSTOM_JSON_SCHEMA_SYMBOL = Symbol("ORPC_CUSTOM_JSON_SCHEMA");
-const CUSTOM_JSON_SCHEMA_INPUT_SYMBOL = Symbol("ORPC_CUSTOM_JSON_SCHEMA_INPUT");
-const CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL = Symbol("ORPC_CUSTOM_JSON_SCHEMA_OUTPUT");
-function getCustomJsonSchema(def, options) {
-  if (options.strategy === "input" && CUSTOM_JSON_SCHEMA_INPUT_SYMBOL in def) {
-    return def[CUSTOM_JSON_SCHEMA_INPUT_SYMBOL];
+const initializer = (inst, issues) => {
+  $ZodError.init(inst, issues);
+  inst.name = "ZodError";
+  Object.defineProperties(inst, {
+    format: {
+      value: (mapper) => core.formatError(inst, mapper)
+      // enumerable: false,
+    },
+    flatten: {
+      value: (mapper) => core.flattenError(inst, mapper)
+      // enumerable: false,
+    },
+    addIssue: {
+      value: (issue) => {
+        inst.issues.push(issue);
+        inst.message = JSON.stringify(inst.issues, core.util.jsonStringifyReplacer, 2);
+      }
+      // enumerable: false,
+    },
+    addIssues: {
+      value: (issues2) => {
+        inst.issues.push(...issues2);
+        inst.message = JSON.stringify(inst.issues, core.util.jsonStringifyReplacer, 2);
+      }
+      // enumerable: false,
+    },
+    isEmpty: {
+      get() {
+        return inst.issues.length === 0;
+      }
+      // enumerable: false,
+    }
+  });
+};
+const ZodError = core.$constructor("ZodError", initializer);
+const ZodRealError = core.$constructor("ZodError", initializer, {
+  Parent: Error
+});
+
+const parse = /* @__PURE__ */ core._parse(ZodRealError);
+const parseAsync = /* @__PURE__ */ core._parseAsync(ZodRealError);
+const safeParse = /* @__PURE__ */ core._safeParse(ZodRealError);
+const safeParseAsync = /* @__PURE__ */ core._safeParseAsync(ZodRealError);
+const encode = /* @__PURE__ */ core._encode(ZodRealError);
+const decode = /* @__PURE__ */ core._decode(ZodRealError);
+const encodeAsync = /* @__PURE__ */ core._encodeAsync(ZodRealError);
+const decodeAsync = /* @__PURE__ */ core._decodeAsync(ZodRealError);
+const safeEncode = /* @__PURE__ */ core._safeEncode(ZodRealError);
+const safeDecode = /* @__PURE__ */ core._safeDecode(ZodRealError);
+const safeEncodeAsync = /* @__PURE__ */ core._safeEncodeAsync(ZodRealError);
+const safeDecodeAsync = /* @__PURE__ */ core._safeDecodeAsync(ZodRealError);
+
+const ZodISODateTime = /* @__PURE__ */ core.$constructor(
+  "ZodISODateTime",
+  (inst, def) => {
+    const coreInit = core.$ZodISODateTime.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function datetime(params) {
+  return core._isoDateTime(ZodISODateTime, params);
+}
+const ZodISODate = /* @__PURE__ */ core.$constructor(
+  "ZodISODate",
+  (inst, def) => {
+    const coreInit = core.$ZodISODate.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function date$1(params) {
+  return core._isoDate(ZodISODate, params);
+}
+const ZodISOTime = /* @__PURE__ */ core.$constructor(
+  "ZodISOTime",
+  (inst, def) => {
+    const coreInit = core.$ZodISOTime.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function time(params) {
+  return core._isoTime(ZodISOTime, params);
+}
+const ZodISODuration = /* @__PURE__ */ core.$constructor(
+  "ZodISODuration",
+  (inst, def) => {
+    const coreInit = core.$ZodISODuration.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function duration(params) {
+  return core._isoDuration(ZodISODuration, params);
+}
+
+const gatingContext = new AsyncLocalStorage();
+function isGateIssueRaw(issue) {
+  return issue.code === "invalid_type" && issue.expected === "never" && issue.inst instanceof ZodGate;
+}
+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;
+  };
+});
+function gate(innerType, gateName) {
+  return new ZodGate({
+    type: "optional",
+    innerType,
+    gateName
+  });
+}
+
+function handleGating(payload) {
+  for (let i = 0; i < payload.issues.length; i++) {
+    const issue = payload.issues[i];
+    if (issue?.code === "invalid_union") {
+      const newErrors = issue.errors.filter((innerIssues) => !innerIssues.some(isGateIssue));
+      issue.errors.splice(0, Infinity, ...newErrors);
+    }
+  }
+  return payload;
+}
+const ZodUnion = /* @__PURE__ */ core.$constructor(
+  "ZodUnion",
+  (inst, def) => {
+    const coreInit = core.$ZodUnion.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.options = def.options;
+    const origParse = inst._zod.parse;
+    inst._zod.parse = (payload, ctx) => {
+      const res = origParse(payload, ctx);
+      if (res instanceof Promise) {
+        return res.then((r) => handleGating(r));
+      } else {
+        return handleGating(res);
+      }
+    };
   }
-  if (options.strategy === "output" && CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL in def) {
-    return def[CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL];
+);
+function union(options, params) {
+  return new ZodUnion({
+    type: "union",
+    options,
+    ...util.normalizeParams(params)
+  });
+}
+const ZodDiscriminatedUnion = /* @__PURE__ */ core.$constructor("ZodDiscriminatedUnion", (inst, def) => {
+  ZodUnion.init(inst, def);
+  const coreInit = core.$ZodDiscriminatedUnion.init;
+  coreInit(inst, def);
+});
+function discriminatedUnion(discriminator, options, params) {
+  return new ZodDiscriminatedUnion({
+    type: "union",
+    options,
+    discriminator,
+    ...util.normalizeParams(params)
+  });
+}
+
+function handlePropertyResult(result, final, key, input) {
+  if (result.issues.length) {
+    final.issues.push(...util.prefixIssues(key, result.issues));
   }
-  if (CUSTOM_JSON_SCHEMA_SYMBOL in def) {
-    return def[CUSTOM_JSON_SCHEMA_SYMBOL];
+  if (result.value === void 0) {
+    if (key in input) {
+      final.value[key] = void 0;
+    }
+  } else {
+    final.value[key] = result.value;
+  }
+}
+const ZodObject = /* @__PURE__ */ core.$constructor(
+  "ZodObject",
+  (inst, def) => {
+    const coreInit = core.$ZodObjectJIT.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    util.defineLazy(inst, "shape", () => {
+      return def.shape;
+    });
+    inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
+    inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
+    inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
+    inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
+    inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
+    inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
+    inst.extend = (incoming) => {
+      return util.extend(inst, incoming);
+    };
+    inst.safeExtend = (incoming) => {
+      return util.safeExtend(inst, incoming);
+    };
+    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]);
+    function handleGating(input, payload, ctx) {
+      const _catchall = def.catchall?._zod;
+      const t = _catchall?.def.type;
+      let newIssues = null;
+      const proms = [];
+      const newUnrecognizedKeys = [];
+      for (let i = 0; i < payload.issues.length; i++) {
+        const issue = payload.issues[i];
+        if (!isGateIssueRaw(issue)) {
+          continue;
+        }
+        newIssues ??= [...payload.issues];
+        newIssues[i] = null;
+        const key = issue.path[0];
+        if (!_catchall) {
+          delete payload.value[key];
+        } else if (t === "never") {
+          newUnrecognizedKeys.push(key);
+        } else {
+          const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+          if (r instanceof Promise) {
+            proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
+          } else {
+            handlePropertyResult(r, payload, key, input);
+          }
+        }
+      }
+      if (newIssues) {
+        payload.issues = newIssues.filter(Boolean);
+      }
+      if (newUnrecognizedKeys.length > 0) {
+        const missingKeyIssue = payload.issues.find(
+          (issue) => issue.code === "unrecognized_keys" && !issue.path
+        );
+        if (missingKeyIssue) {
+          missingKeyIssue.keys.push(...newUnrecognizedKeys);
+        } else {
+          payload.issues.push({
+            code: "unrecognized_keys",
+            keys: newUnrecognizedKeys,
+            input,
+            inst
+          });
+        }
+      }
+      if (proms.length > 0) {
+        return Promise.all(proms).then(() => payload);
+      } else {
+        return payload;
+      }
+    }
+    const origParse = inst._zod.parse;
+    inst._zod.parse = (payload, ctx) => {
+      const input = payload.value;
+      const res = origParse(payload, ctx);
+      if (res instanceof Promise) {
+        return res.then((r) => handleGating(input, r, ctx));
+      } else {
+        return handleGating(input, res, ctx);
+      }
+    };
   }
-  return void 0;
+);
+function object(shape, params) {
+  const def = {
+    type: "object",
+    shape: shape ?? {},
+    ...util.normalizeParams(params)
+  };
+  return new ZodObject(def);
+}
+function strictObject(shape, params) {
+  return new ZodObject({
+    type: "object",
+    shape,
+    catchall: never(),
+    ...util.normalizeParams(params)
+  });
 }
-function customJsonSchema(schema, custom, options = {}) {
-  const SYMBOL = options.strategy === "input" ? CUSTOM_JSON_SCHEMA_INPUT_SYMBOL : options.strategy === "output" ? CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL : CUSTOM_JSON_SCHEMA_SYMBOL;
-  const This = schema.constructor;
-  const newSchema = new This({
-    ...schema._def,
-    [SYMBOL]: custom
+function looseObject(shape, params) {
+  return new ZodObject({
+    type: "object",
+    shape,
+    catchall: unknown(),
+    ...util.normalizeParams(params)
   });
-  return newSchema;
 }
 
 const CUSTOM_ZOD_DEF_SYMBOL = Symbol("ORPC_CUSTOM_ZOD_DEF");
 function setCustomZodDef(def, custom) {
   Object.assign(def, { [CUSTOM_ZOD_DEF_SYMBOL]: custom });
 }
-function getCustomZodDef(def) {
-  return def[CUSTOM_ZOD_DEF_SYMBOL];
-}
 function composeParams(defaultMessage, params) {
   return (val) => {
     const message = defaultMessage(val);
@@ -64,7 +342,7 @@ function composeParams(defaultMessage, params) {
 }
 
 function blob(params) {
-  const schema = custom(
+  const schema = custom$1(
     (val) => val instanceof Blob,
     composeParams(
       () => "Input is not a blob",
@@ -75,33 +353,8 @@ function blob(params) {
   return schema;
 }
 
-function file(params) {
-  const schema = custom(
-    (val) => val instanceof File,
-    composeParams(
-      () => "Input is not a file",
-      params
-    )
-  );
-  setCustomZodDef(schema._def, { type: "file" });
-  return Object.assign(schema, {
-    type: (mimeType, params2) => {
-      const isMatch = wcmatch(mimeType);
-      const refinedSchema = schema.refine(
-        (val) => isMatch(val.type.split(";")[0]),
-        composeParams(
-          (val) => `Expected a file of type ${mimeType} but got a file of type ${val.type || "unknown"}`,
-          params2
-        )
-      );
-      setCustomZodDef(refinedSchema._def, { type: "file", mimeType });
-      return refinedSchema;
-    }
-  });
-}
-
 function regexp(params) {
-  const schema = custom(
+  const schema = custom$1(
     (val) => val instanceof RegExp,
     composeParams(
       () => "Input is not a regexp",
@@ -112,844 +365,1210 @@ function regexp(params) {
   return schema;
 }
 
+const KrustyType = /* @__PURE__ */ core.$constructor(
+  "KrustyType",
+  (inst, def) => {
+    const coreInit = core.$ZodType.init;
+    coreInit(inst, def);
+    inst.def = def;
+    inst.type = def.type;
+    Object.defineProperty(inst, "_def", { value: def });
+    inst.check = (...checks2) => {
+      return inst.clone(
+        util.mergeDefs(def, {
+          checks: [
+            ...def.checks ?? [],
+            ...checks2.map(
+              (ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch
+            )
+          ]
+        })
+      );
+    };
+    inst.clone = (def2, params) => core.clone(inst, def2, params);
+    inst.brand = () => inst;
+    inst.register = ((reg, meta) => {
+      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));
+    inst.gate = (gateName) => gate(inst, gateName);
+    inst.optional = () => optional(inst);
+    inst.nullable = () => nullable(inst);
+    inst.nullish = () => optional(nullable(inst));
+    inst.nonoptional = (params) => nonoptional(inst, params);
+    inst.array = () => array(inst);
+    inst.or = (arg) => union([inst, arg]);
+    inst.and = (arg) => intersection(inst, arg);
+    inst.transform = (tx) => pipe(inst, transform(tx));
+    inst.default = (def2) => _default(inst, def2);
+    inst.prefault = (def2) => prefault(inst, def2);
+    return inst;
+  }
+);
+const _ZodString = /* @__PURE__ */ core.$constructor(
+  "_ZodString",
+  (inst, def) => {
+    const coreInit = core.$ZodString.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    const bag = inst._zod.bag;
+    inst.format = bag.format ?? null;
+    inst.minLength = bag.minimum ?? null;
+    inst.maxLength = bag.maximum ?? null;
+    inst.regex = (...args) => inst.check(_regex(...args));
+    inst.includes = (...args) => inst.check(_includes(...args));
+    inst.startsWith = (...args) => inst.check(_startsWith(...args));
+    inst.endsWith = (...args) => inst.check(_endsWith(...args));
+    inst.min = (...args) => inst.check(_minLength(...args));
+    inst.max = (...args) => inst.check(_maxLength(...args));
+    inst.length = (...args) => inst.check(_length(...args));
+    inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
+    inst.lowercase = (params) => inst.check(_lowercase(params));
+    inst.uppercase = (params) => inst.check(_uppercase(params));
+    inst.trim = () => inst.check(_trim());
+    inst.normalize = (...args) => inst.check(_normalize(...args));
+    inst.toLowerCase = () => inst.check(_toLowerCase());
+    inst.toUpperCase = () => inst.check(_toUpperCase());
+  }
+);
+const ZodString = /* @__PURE__ */ core.$constructor(
+  "ZodString",
+  (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));
+    inst.datetime = (params) => inst.check(datetime(params));
+    inst.date = (params) => inst.check(date$1(params));
+    inst.time = (params) => inst.check(time(params));
+    inst.duration = (params) => inst.check(duration(params));
+  }
+);
+function string(params) {
+  return core._string(ZodString, params);
+}
+const ZodStringFormat = /* @__PURE__ */ core.$constructor(
+  "ZodStringFormat",
+  (inst, def) => {
+    const coreInit = core.$ZodStringFormat.init;
+    coreInit(inst, def);
+    _ZodString.init(inst, def);
+  }
+);
+const ZodEmail = /* @__PURE__ */ core.$constructor(
+  "ZodEmail",
+  (inst, def) => {
+    const coreInit = core.$ZodEmail.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function email(params) {
+  return core._email(ZodEmail, params);
+}
+const ZodGUID = /* @__PURE__ */ core.$constructor("ZodGUID", (inst, def) => {
+  const coreInit = core.$ZodGUID.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function guid(params) {
+  return core._guid(ZodGUID, params);
+}
+const ZodUUID = /* @__PURE__ */ core.$constructor("ZodUUID", (inst, def) => {
+  const coreInit = core.$ZodUUID.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function uuid(params) {
+  return core._uuid(ZodUUID, params);
+}
+function uuidv4(params) {
+  return core._uuidv4(ZodUUID, params);
+}
+function uuidv6(params) {
+  return core._uuidv6(ZodUUID, params);
+}
+function uuidv7(params) {
+  return core._uuidv7(ZodUUID, params);
+}
+const ZodURL = /* @__PURE__ */ core.$constructor("ZodURL", (inst, def) => {
+  const coreInit = core.$ZodURL.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
 function url(params) {
-  const schema = custom(
-    (val) => val instanceof URL,
-    composeParams(
-      () => "Input is not a URL",
-      params
-    )
-  );
-  setCustomZodDef(schema._def, { type: "url" });
-  return schema;
+  return core._url(ZodURL, params);
 }
-
-class ZodSmartCoercionPlugin {
-  init(options) {
-    options.clientInterceptors ??= [];
-    options.clientInterceptors.unshift((options2) => {
-      const inputSchema = options2.procedure["~orpc"].inputSchema;
-      if (!inputSchema || inputSchema["~standard"].vendor !== "zod" || "_zod" in inputSchema) {
-        return options2.next();
-      }
-      const coercedInput = zodCoerceInternal(inputSchema, options2.input);
-      return options2.next({ ...options2, input: coercedInput });
+function httpUrl(params) {
+  return core._url(ZodURL, {
+    protocol: /^https?$/,
+    hostname: core.regexes.domain,
+    ...util.normalizeParams(params)
+  });
+}
+const ZodEmoji = /* @__PURE__ */ core.$constructor(
+  "ZodEmoji",
+  (inst, def) => {
+    const coreInit = core.$ZodEmoji.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function emoji(params) {
+  return core._emoji(ZodEmoji, params);
+}
+const ZodNanoID = /* @__PURE__ */ core.$constructor(
+  "ZodNanoID",
+  (inst, def) => {
+    const coreInit = core.$ZodNanoID.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function nanoid(params) {
+  return core._nanoid(ZodNanoID, params);
+}
+const ZodCUID = /* @__PURE__ */ core.$constructor("ZodCUID", (inst, def) => {
+  const coreInit = core.$ZodCUID.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function cuid(params) {
+  return core._cuid(ZodCUID, params);
+}
+const ZodCUID2 = /* @__PURE__ */ core.$constructor(
+  "ZodCUID2",
+  (inst, def) => {
+    const coreInit = core.$ZodCUID2.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function cuid2(params) {
+  return core._cuid2(ZodCUID2, params);
+}
+const ZodULID = /* @__PURE__ */ core.$constructor("ZodULID", (inst, def) => {
+  const coreInit = core.$ZodULID.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function ulid(params) {
+  return core._ulid(ZodULID, params);
+}
+const ZodXID = /* @__PURE__ */ core.$constructor("ZodXID", (inst, def) => {
+  const coreInit = core.$ZodXID.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function xid(params) {
+  return core._xid(ZodXID, params);
+}
+const ZodKSUID = /* @__PURE__ */ core.$constructor(
+  "ZodKSUID",
+  (inst, def) => {
+    const coreInit = core.$ZodKSUID.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function ksuid(params) {
+  return core._ksuid(ZodKSUID, params);
+}
+const ZodIPv4 = /* @__PURE__ */ core.$constructor("ZodIPv4", (inst, def) => {
+  const coreInit = core.$ZodIPv4.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function ipv4(params) {
+  return core._ipv4(ZodIPv4, params);
+}
+const ZodIPv6 = /* @__PURE__ */ core.$constructor("ZodIPv6", (inst, def) => {
+  const coreInit = core.$ZodIPv6.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function ipv6(params) {
+  return core._ipv6(ZodIPv6, params);
+}
+const ZodCIDRv4 = /* @__PURE__ */ core.$constructor(
+  "ZodCIDRv4",
+  (inst, def) => {
+    const coreInit = core.$ZodCIDRv4.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function cidrv4(params) {
+  return core._cidrv4(ZodCIDRv4, params);
+}
+const ZodCIDRv6 = /* @__PURE__ */ core.$constructor(
+  "ZodCIDRv6",
+  (inst, def) => {
+    const coreInit = core.$ZodCIDRv6.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function cidrv6(params) {
+  return core._cidrv6(ZodCIDRv6, params);
+}
+const ZodBase64 = /* @__PURE__ */ core.$constructor(
+  "ZodBase64",
+  (inst, def) => {
+    const coreInit = core.$ZodBase64.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function base64(params) {
+  return core._base64(ZodBase64, params);
+}
+const ZodBase64URL = /* @__PURE__ */ core.$constructor(
+  "ZodBase64URL",
+  (inst, def) => {
+    const coreInit = core.$ZodBase64URL.init;
+    coreInit(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+function base64url(params) {
+  return core._base64url(ZodBase64URL, params);
+}
+const ZodE164 = /* @__PURE__ */ core.$constructor("ZodE164", (inst, def) => {
+  const coreInit = core.$ZodE164.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function e164(params) {
+  return core._e164(ZodE164, params);
+}
+const ZodJWT = /* @__PURE__ */ core.$constructor("ZodJWT", (inst, def) => {
+  const coreInit = core.$ZodJWT.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function jwt(params) {
+  return core._jwt(ZodJWT, params);
+}
+const ZodCustomStringFormat = /* @__PURE__ */ core.$constructor("ZodCustomStringFormat", (inst, def) => {
+  const coreInit = core.$ZodCustomStringFormat.init;
+  coreInit(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function stringFormat(format, fnOrRegex, _params = {}) {
+  return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
+}
+function hostname(_params) {
+  return core._stringFormat(ZodCustomStringFormat, "hostname", core.regexes.hostname, _params);
+}
+function hex(_params) {
+  return core._stringFormat(ZodCustomStringFormat, "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);
+}
+const ZodNumber = /* @__PURE__ */ core.$constructor(
+  "ZodNumber",
+  (inst, def) => {
+    const coreInit = core.$ZodNumber.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.gt = (value, params) => inst.check(_gt(value, params));
+    inst.gte = (value, params) => inst.check(_gte(value, params));
+    inst.min = (value, params) => inst.check(_gte(value, params));
+    inst.lt = (value, params) => inst.check(_lt(value, params));
+    inst.lte = (value, params) => inst.check(_lte(value, params));
+    inst.max = (value, params) => inst.check(_lte(value, params));
+    inst.int = (params) => inst.check(int(params));
+    inst.safe = (params) => inst.check(int(params));
+    inst.positive = (params) => inst.check(_gt(0, params));
+    inst.nonnegative = (params) => inst.check(_gte(0, params));
+    inst.negative = (params) => inst.check(_lt(0, params));
+    inst.nonpositive = (params) => inst.check(_lte(0, params));
+    inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
+    inst.step = (value, params) => inst.check(_multipleOf(value, params));
+    inst.finite = () => inst;
+    const bag = inst._zod.bag;
+    inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+    inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+    inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
+    inst.isFinite = true;
+    inst.format = bag.format ?? null;
+  }
+);
+function number(params) {
+  return core._number(ZodNumber, params);
+}
+const ZodNumberFormat = /* @__PURE__ */ core.$constructor(
+  "ZodNumberFormat",
+  (inst, def) => {
+    const coreInit = core.$ZodNumberFormat.init;
+    coreInit(inst, def);
+    ZodNumber.init(inst, def);
+  }
+);
+function int(params) {
+  return core._int(ZodNumberFormat, params);
+}
+function float32(params) {
+  return core._float32(ZodNumberFormat, params);
+}
+function float64(params) {
+  return core._float64(ZodNumberFormat, params);
+}
+function int32(params) {
+  return core._int32(ZodNumberFormat, params);
+}
+function uint32(params) {
+  return core._uint32(ZodNumberFormat, params);
+}
+const ZodBoolean = /* @__PURE__ */ core.$constructor(
+  "ZodBoolean",
+  (inst, def) => {
+    const coreInit = core.$ZodBoolean.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function boolean(params) {
+  return core._boolean(ZodBoolean, params);
+}
+const ZodBigInt = /* @__PURE__ */ core.$constructor(
+  "ZodBigInt",
+  (inst, def) => {
+    const coreInit = core.$ZodBigInt.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.gte = (value, params) => inst.check(_gte(value, params));
+    inst.min = (value, params) => inst.check(_gte(value, params));
+    inst.gt = (value, params) => inst.check(_gt(value, params));
+    inst.gte = (value, params) => inst.check(_gte(value, params));
+    inst.min = (value, params) => inst.check(_gte(value, params));
+    inst.lt = (value, params) => inst.check(_lt(value, params));
+    inst.lte = (value, params) => inst.check(_lte(value, params));
+    inst.max = (value, params) => inst.check(_lte(value, params));
+    inst.positive = (params) => inst.check(_gt(BigInt(0), params));
+    inst.negative = (params) => inst.check(_lt(BigInt(0), params));
+    inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params));
+    inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params));
+    inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
+    const bag = inst._zod.bag;
+    inst.minValue = bag.minimum ?? null;
+    inst.maxValue = bag.maximum ?? null;
+    inst.format = bag.format ?? null;
+  }
+);
+function bigint(params) {
+  return core._bigint(ZodBigInt, params);
+}
+const ZodBigIntFormat = /* @__PURE__ */ core.$constructor(
+  "ZodBigIntFormat",
+  (inst, def) => {
+    const coreInit = core.$ZodBigIntFormat.init;
+    coreInit(inst, def);
+    ZodBigInt.init(inst, def);
+  }
+);
+function int64(params) {
+  return core._int64(ZodBigIntFormat, params);
+}
+function uint64(params) {
+  return core._uint64(ZodBigIntFormat, params);
+}
+const ZodSymbol = /* @__PURE__ */ core.$constructor(
+  "ZodSymbol",
+  (inst, def) => {
+    const coreInit = core.$ZodSymbol.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function symbol(params) {
+  return core._symbol(ZodSymbol, params);
+}
+const ZodUndefined = /* @__PURE__ */ core.$constructor(
+  "ZodUndefined",
+  (inst, def) => {
+    const coreInit = core.$ZodUndefined.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function _undefined(params) {
+  return core._undefined(ZodUndefined, params);
+}
+const ZodNull = /* @__PURE__ */ core.$constructor("ZodNull", (inst, def) => {
+  const coreInit = core.$ZodNull.init;
+  coreInit(inst, def);
+  KrustyType.init(inst, def);
+});
+function _null(params) {
+  return core._null(ZodNull, params);
+}
+const ZodAny = /* @__PURE__ */ core.$constructor("ZodAny", (inst, def) => {
+  const coreInit = core.$ZodAny.init;
+  coreInit(inst, def);
+  KrustyType.init(inst, def);
+});
+function any() {
+  return core._any(ZodAny);
+}
+const ZodUnknown = /* @__PURE__ */ core.$constructor(
+  "ZodUnknown",
+  (inst, def) => {
+    const coreInit = core.$ZodUnknown.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function unknown() {
+  return core._unknown(ZodUnknown);
+}
+const ZodNever = /* @__PURE__ */ core.$constructor(
+  "ZodNever",
+  (inst, def) => {
+    const coreInit = core.$ZodNever.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function never(params) {
+  return core._never(ZodNever, params);
+}
+const ZodVoid = /* @__PURE__ */ core.$constructor("ZodVoid", (inst, def) => {
+  const coreInit = core.$ZodVoid.init;
+  coreInit(inst, def);
+  KrustyType.init(inst, def);
+});
+function _void(params) {
+  return core._void(ZodVoid, 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;
+});
+function date(params) {
+  return core._date(ZodDate, params);
+}
+const ZodArray = /* @__PURE__ */ core.$constructor(
+  "ZodArray",
+  (inst, def) => {
+    const coreInit = core.$ZodArray.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.element = def.element;
+    inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
+    inst.nonempty = (params) => inst.check(_minLength(1, params));
+    inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
+    inst.length = (len, params) => inst.check(_length(len, params));
+    inst.unwrap = () => inst.element;
+  }
+);
+function array(element, params) {
+  return core._array(ZodArray, element, params);
+}
+function keyof(schema) {
+  const shape = schema._zod.def.shape;
+  return _enum(Object.keys(shape));
+}
+const ZodIntersection = /* @__PURE__ */ core.$constructor(
+  "ZodIntersection",
+  (inst, def) => {
+    const coreInit = core.$ZodIntersection.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function intersection(left, right) {
+  return new ZodIntersection({
+    type: "intersection",
+    left,
+    right
+  });
+}
+const ZodTuple = /* @__PURE__ */ core.$constructor(
+  "ZodTuple",
+  (inst, def) => {
+    const coreInit = core.$ZodTuple.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.rest = (rest) => inst.clone({
+      ...inst._zod.def,
+      rest
     });
   }
+);
+function tuple(items, _paramsOrRest, _params) {
+  const hasRest = _paramsOrRest instanceof core.$ZodType;
+  const params = hasRest ? _params : _paramsOrRest;
+  const rest = hasRest ? _paramsOrRest : null;
+  return new ZodTuple({
+    type: "tuple",
+    items,
+    rest,
+    ...util.normalizeParams(params)
+  });
 }
-function zodCoerceInternal(schema, value) {
-  const customZodDef = getCustomZodDef(schema._def);
-  switch (customZodDef?.type) {
-    case "regexp": {
-      if (typeof value === "string") {
-        return safeToRegExp(value);
-      }
-      return value;
-    }
-    case "url": {
-      if (typeof value === "string") {
-        return safeToURL(value);
-      }
-      return value;
-    }
+const ZodRecord = /* @__PURE__ */ core.$constructor(
+  "ZodRecord",
+  (inst, def) => {
+    const coreInit = core.$ZodRecord.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
   }
-  const typeName = schema._def.typeName;
-  switch (typeName) {
-    case ZodFirstPartyTypeKind.ZodNumber: {
-      if (typeof value === "string") {
-        return safeToNumber(value);
-      }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodBigInt: {
-      if (typeof value === "string") {
-        return safeToBigInt(value);
-      }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodBoolean: {
-      if (typeof value === "string") {
-        return safeToBoolean(value);
-      }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodDate: {
-      if (typeof value === "string") {
-        return safeToDate(value);
-      }
-      return value;
+);
+function record(keyType, valueType, params) {
+  return new ZodRecord({
+    type: "record",
+    keyType,
+    valueType,
+    ...util.normalizeParams(params)
+  });
+}
+function partialRecord(keyType, valueType, params) {
+  const k = core.clone(keyType);
+  k._zod.values = void 0;
+  return new ZodRecord({
+    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;
+});
+function map(keyType, valueType, params) {
+  return new ZodMap({
+    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));
+});
+function set(valueType, params) {
+  return new ZodSet({
+    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`);
     }
-    case ZodFirstPartyTypeKind.ZodLiteral: {
-      const schema_ = schema;
-      const expectedValue = schema_._def.value;
-      if (typeof value === "string" && typeof expectedValue !== "string") {
-        if (typeof expectedValue === "bigint") {
-          return safeToBigInt(value);
-        } else if (typeof expectedValue === "number") {
-          return safeToNumber(value);
-        } else if (typeof expectedValue === "boolean") {
-          return safeToBoolean(value);
-        }
-      }
-      return value;
+    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`);
     }
-    case ZodFirstPartyTypeKind.ZodNativeEnum: {
-      const schema_ = schema;
-      if (Object.values(schema_._def.values).includes(value)) {
-        return value;
-      }
-      if (typeof value === "string") {
-        for (const expectedValue of Object.values(schema_._def.values)) {
-          if (expectedValue.toString() === value) {
-            return expectedValue;
-          }
+    return new ZodEnum({
+      ...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({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params)
+  });
+}
+function nativeEnum(entries, params) {
+  return new ZodEnum({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params)
+  });
+}
+const ZodLiteral = /* @__PURE__ */ core.$constructor(
+  "ZodLiteral",
+  (inst, def) => {
+    const coreInit = core.$ZodLiteral.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.values = new Set(def.values);
+    Object.defineProperty(inst, "value", {
+      get() {
+        if (def.values.length > 1) {
+          throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
         }
+        return def.values[0];
       }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodObject: {
-      const schema_ = schema;
-      if (isObject(value)) {
-        const newObj = {};
-        const keys = /* @__PURE__ */ new Set([...Object.keys(value), ...Object.keys(schema_.shape)]);
-        for (const k of keys) {
-          newObj[k] = zodCoerceInternal(schema_.shape[k] ?? schema_._def.catchall, value[k]);
-        }
-        return newObj;
+    });
+  }
+);
+function literal(value, params) {
+  return new ZodLiteral({
+    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));
+});
+function file(params) {
+  return core._file(ZodFile, params);
+}
+const ZodTransform = /* @__PURE__ */ core.$constructor(
+  "ZodTransform",
+  (inst, def) => {
+    const coreInit = core.$ZodTransform.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst._zod.parse = (payload, _ctx) => {
+      if (_ctx.direction === "backward") {
+        throw new core.$ZodEncodeError(inst.constructor.name);
       }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodRecord: {
-      const schema_ = schema;
-      if (isObject(value)) {
-        const newObj = {};
-        for (const [k, v] of Object.entries(value)) {
-          const key = zodCoerceInternal(schema_._def.keyType, k);
-          const val = zodCoerceInternal(schema_._def.valueType, v);
-          newObj[key] = val;
+      payload.addIssue = (issue) => {
+        if (typeof issue === "string") {
+          payload.issues.push(util.issue(issue, payload.value, def));
+        } else {
+          const _issue = issue;
+          if (_issue.fatal) _issue.continue = false;
+          _issue.code ??= "custom";
+          _issue.input ??= payload.value;
+          _issue.inst ??= inst;
+          payload.issues.push(util.issue(_issue));
         }
-        return newObj;
-      }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodArray: {
-      const schema_ = schema;
-      if (Array.isArray(value)) {
-        return value.map((v) => zodCoerceInternal(schema_._def.type, v));
-      }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodTuple: {
-      const schema_ = schema;
-      if (Array.isArray(value)) {
-        return value.map((v, i) => {
-          const s = schema_._def.items[i] ?? schema_._def.rest;
-          return s ? zodCoerceInternal(s, v) : v;
+      };
+      const output = def.transform(payload.value, payload);
+      if (output instanceof Promise) {
+        return output.then((output2) => {
+          payload.value = output2;
+          return payload;
         });
       }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodSet: {
-      const schema_ = schema;
-      if (Array.isArray(value)) {
-        return new Set(value.map((v) => zodCoerceInternal(schema_._def.valueType, v)));
-      }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodMap: {
-      const schema_ = schema;
-      if (Array.isArray(value) && value.every((i) => Array.isArray(i) && i.length === 2)) {
-        return new Map(
-          value.map(([k, v]) => [
-            zodCoerceInternal(schema_._def.keyType, k),
-            zodCoerceInternal(schema_._def.valueType, v)
-          ])
-        );
-      }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodUnion:
-    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
-      const schema_ = schema;
-      if (schema_.safeParse(value).success) {
-        return value;
-      }
-      const results = [];
-      for (const s of schema_._def.options) {
-        const newValue = zodCoerceInternal(s, value);
-        const result = schema_.safeParse(newValue);
-        if (result.success) {
-          return newValue;
-        }
-        results.push([newValue, result.error.issues.length]);
-      }
-      if (results.length === 0) {
-        return value;
-      }
-      return results.sort((a, b) => a[1] - b[1])[0][0];
-    }
-    case ZodFirstPartyTypeKind.ZodIntersection: {
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.right, zodCoerceInternal(schema_._def.left, value));
-    }
-    case ZodFirstPartyTypeKind.ZodReadonly: {
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.innerType, value);
-    }
-    case ZodFirstPartyTypeKind.ZodPipeline: {
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.in, value);
-    }
-    case ZodFirstPartyTypeKind.ZodEffects: {
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.schema, value);
-    }
-    case ZodFirstPartyTypeKind.ZodBranded: {
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.type, value);
-    }
-    case ZodFirstPartyTypeKind.ZodCatch: {
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.innerType, value);
-    }
-    case ZodFirstPartyTypeKind.ZodDefault: {
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.innerType, value);
-    }
-    case ZodFirstPartyTypeKind.ZodNullable: {
-      if (value === null) {
-        return null;
-      }
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.innerType, value);
-    }
-    case ZodFirstPartyTypeKind.ZodOptional: {
-      if (value === void 0) {
-        return void 0;
-      }
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.innerType, value);
+      payload.value = output;
+      return payload;
+    };
+  }
+);
+function transform(fn) {
+  return new ZodTransform({
+    type: "transform",
+    transform: fn
+  });
+}
+const ZodOptional = /* @__PURE__ */ core.$constructor(
+  "ZodOptional",
+  (inst, def) => {
+    const coreInit = core.$ZodOptional.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+  }
+);
+function optional(innerType) {
+  return new ZodOptional({
+    type: "optional",
+    innerType
+  });
+}
+const ZodNullable = /* @__PURE__ */ core.$constructor(
+  "ZodNullable",
+  (inst, def) => {
+    const coreInit = core.$ZodNullable.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+  }
+);
+function nullable(innerType) {
+  return new ZodNullable({
+    type: "nullable",
+    innerType
+  });
+}
+function nullish(innerType) {
+  return optional(nullable(innerType));
+}
+const ZodDefault = /* @__PURE__ */ core.$constructor(
+  "ZodDefault",
+  (inst, def) => {
+    const coreInit = core.$ZodDefault.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+    inst.removeDefault = inst.unwrap;
+  }
+);
+function _default(innerType, defaultValue) {
+  return new ZodDefault({
+    type: "default",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
     }
-    case ZodFirstPartyTypeKind.ZodLazy: {
-      const schema_ = schema;
-      if (value !== void 0) {
-        return zodCoerceInternal(schema_._def.getter(), value);
-      }
-      return value;
+  });
+}
+const ZodPrefault = /* @__PURE__ */ core.$constructor(
+  "ZodPrefault",
+  (inst, def) => {
+    const coreInit = core.$ZodPrefault.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+  }
+);
+function prefault(innerType, defaultValue) {
+  return new ZodPrefault({
+    type: "prefault",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
     }
+  });
+}
+const ZodNonOptional = /* @__PURE__ */ core.$constructor(
+  "ZodNonOptional",
+  (inst, def) => {
+    const coreInit = core.$ZodNonOptional.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
   }
-  return value;
+);
+function nonoptional(innerType, params) {
+  return new ZodNonOptional({
+    type: "nonoptional",
+    innerType,
+    ...util.normalizeParams(params)
+  });
 }
-function safeToBigInt(value) {
-  return guard(() => BigInt(value)) ?? value;
+const ZodSuccess = /* @__PURE__ */ core.$constructor(
+  "ZodSuccess",
+  (inst, def) => {
+    const coreInit = core.$ZodSuccess.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+  }
+);
+function success(innerType) {
+  return new ZodSuccess({
+    type: "success",
+    innerType
+  });
 }
-function safeToNumber(value) {
-  const num = Number(value);
-  return Number.isNaN(num) || num.toString() !== value ? value : num;
+const ZodCatch = /* @__PURE__ */ core.$constructor(
+  "ZodCatch",
+  (inst, def) => {
+    const coreInit = core.$ZodCatch.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+    inst.removeCatch = inst.unwrap;
+  }
+);
+function _catch(innerType, catchValue) {
+  return new ZodCatch({
+    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);
+});
+function nan(params) {
+  return core._nan(ZodNaN, params);
 }
-function safeToBoolean(value) {
-  const lower = value.toLowerCase();
-  if (lower === "false" || lower === "off" || lower === "f") {
-    return false;
+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;
+});
+function pipe(in_, out) {
+  return new ZodPipe({
+    type: "pipe",
+    in: in_,
+    out
+    // ...util.normalizeParams(params),
+  });
+}
+const ZodCodec = /* @__PURE__ */ core.$constructor(
+  "ZodCodec",
+  (inst, def) => {
+    ZodPipe.init(inst, def);
+    const coreInit = core.$ZodCodec.init;
+    coreInit(inst, def);
   }
-  if (lower === "true" || lower === "on" || lower === "t") {
-    return true;
+);
+function codec(in_, out, params) {
+  return new ZodCodec({
+    type: "pipe",
+    in: in_,
+    out,
+    transform: params.decode,
+    reverseTransform: params.encode
+  });
+}
+const ZodReadonly = /* @__PURE__ */ core.$constructor(
+  "ZodReadonly",
+  (inst, def) => {
+    const coreInit = core.$ZodReadonly.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
   }
-  return value;
+);
+function readonly(innerType) {
+  return new ZodReadonly({
+    type: "readonly",
+    innerType
+  });
 }
-function safeToRegExp(value) {
-  if (value.startsWith("/")) {
-    const match = value.match(/^\/(.*)\/([a-z]*)$/);
-    if (match) {
-      const [, pattern, flags] = match;
-      return new RegExp(pattern, flags);
-    }
+const ZodTemplateLiteral = /* @__PURE__ */ core.$constructor(
+  "ZodTemplateLiteral",
+  (inst, def) => {
+    const coreInit = core.$ZodTemplateLiteral.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function templateLiteral(parts, params) {
+  return new ZodTemplateLiteral({
+    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();
+});
+function lazy(getter) {
+  return new ZodLazy({
+    type: "lazy",
+    getter
+  });
+}
+const ZodPromise = /* @__PURE__ */ core.$constructor(
+  "ZodPromise",
+  (inst, def) => {
+    const coreInit = core.$ZodPromise.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
   }
-  return value;
+);
+function promise(innerType) {
+  return new ZodPromise({
+    type: "promise",
+    innerType
+  });
 }
-function safeToURL(value) {
-  return guard(() => new URL(value)) ?? value;
+const ZodFunction = /* @__PURE__ */ core.$constructor(
+  "ZodFunction",
+  (inst, def) => {
+    const coreInit = core.$ZodFunction.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function _function(params) {
+  return new ZodFunction({
+    type: "function",
+    input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
+    output: params?.output ?? unknown()
+  });
 }
-function safeToDate(value) {
-  const date = new Date(value);
-  if (!Number.isNaN(date.getTime()) && date.toISOString().startsWith(value)) {
-    return date;
+const ZodCustom = /* @__PURE__ */ core.$constructor(
+  "ZodCustom",
+  (inst, def) => {
+    const coreInit = core.$ZodCustom.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
   }
-  return value;
+);
+function check(fn) {
+  const ch = new core.$ZodCheck({
+    check: "custom"
+    // ...util.normalizeParams(params),
+  });
+  ch._zod.check = fn;
+  return ch;
+}
+function custom(fn, _params) {
+  return core._custom(ZodCustom, fn ?? (() => true), _params);
+}
+function refine(fn, _params = {}) {
+  return core._refine(ZodCustom, fn, _params);
+}
+function superRefine(fn) {
+  return core._superRefine(fn);
+}
+function _instanceof(cls, params = {
+  error: `Input not instance of ${cls.name}`
+}) {
+  const inst = new ZodCustom({
+    type: "custom",
+    check: "custom",
+    fn: (data) => data instanceof cls,
+    abort: true,
+    ...util.normalizeParams(params)
+  });
+  inst._zod.bag.Class = cls;
+  return inst;
+}
+const stringbool = (...args) => core._stringbool(
+  {
+    Codec: ZodCodec,
+    Boolean: ZodBoolean,
+    String: ZodString
+  },
+  ...args
+);
+function json(params) {
+  const jsonSchema = lazy(() => {
+    return union([
+      string(params),
+      number(),
+      boolean(),
+      _null(),
+      array(jsonSchema),
+      record(string(), jsonSchema)
+    ]);
+  });
+  return jsonSchema;
+}
+function preprocess(fn, schema) {
+  return pipe(transform(fn), schema);
 }
 
-class ZodToJsonSchemaConverter {
-  maxLazyDepth;
-  maxStructureDepth;
-  unsupportedJsonSchema;
-  anyJsonSchema;
-  constructor(options = {}) {
-    this.maxLazyDepth = options.maxLazyDepth ?? 3;
-    this.maxStructureDepth = options.maxStructureDepth ?? 10;
-    this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };
-    this.anyJsonSchema = options.anyJsonSchema ?? {};
-  }
-  condition(schema) {
-    return schema !== void 0 && schema["~standard"].vendor === "zod" && !("_zod" in schema);
-  }
-  convert(schema, options, lazyDepth = 0, isHandledCustomJSONSchema = false, isHandledZodDescription = false, structureDepth = 0) {
-    const def = schema._def;
-    if (structureDepth > this.maxStructureDepth) {
-      return [false, this.anyJsonSchema];
-    }
-    if (!options.minStructureDepthForRef || options.minStructureDepthForRef <= structureDepth) {
-      const components = toArray(options.components);
-      for (const component of components) {
-        if (component.schema === schema && component.allowedStrategies.includes(options.strategy)) {
-          return [component.required, { $ref: component.ref }];
-        }
-      }
-    }
-    if (!isHandledZodDescription && "description" in def && typeof def.description === "string") {
-      const [required, json] = this.convert(
-        schema,
-        options,
-        lazyDepth,
-        isHandledCustomJSONSchema,
-        true,
-        structureDepth
-      );
-      return [required, { ...json, description: def.description }];
-    }
-    if (!isHandledCustomJSONSchema) {
-      const customJSONSchema = getCustomJsonSchema(def, options);
-      if (customJSONSchema) {
-        const [required, json] = this.convert(
-          schema,
-          options,
-          lazyDepth,
-          true,
-          isHandledZodDescription,
-          structureDepth
-        );
-        return [required, { ...json, ...customJSONSchema }];
-      }
-    }
-    const customSchema = this.#handleCustomZodDef(def);
-    if (customSchema) {
-      return [true, customSchema];
-    }
-    const typeName = this.#getZodTypeName(def);
-    switch (typeName) {
-      case ZodFirstPartyTypeKind.ZodString: {
-        const schema_ = schema;
-        const json = { type: "string" };
-        for (const check of schema_._def.checks) {
-          switch (check.kind) {
-            case "base64":
-              json.contentEncoding = "base64";
-              break;
-            case "cuid":
-              json.pattern = "^[0-9A-HJKMNP-TV-Z]{26}$";
-              break;
-            case "email":
-              json.format = JSONSchemaFormat.Email;
-              break;
-            case "url":
-              json.format = JSONSchemaFormat.URI;
-              break;
-            case "uuid":
-              json.format = JSONSchemaFormat.UUID;
-              break;
-            case "regex":
-              json.pattern = check.regex.source;
-              break;
-            case "min":
-              json.minLength = check.value;
-              break;
-            case "max":
-              json.maxLength = check.value;
-              break;
-            case "length":
-              json.minLength = check.value;
-              json.maxLength = check.value;
-              break;
-            case "includes":
-              json.pattern = escapeStringRegexp(check.value);
-              break;
-            case "startsWith":
-              json.pattern = `^${escapeStringRegexp(check.value)}`;
-              break;
-            case "endsWith":
-              json.pattern = `${escapeStringRegexp(check.value)}$`;
-              break;
-            case "emoji":
-              json.pattern = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
-              break;
-            case "nanoid":
-              json.pattern = "^[a-zA-Z0-9_-]{21}$";
-              break;
-            case "cuid2":
-              json.pattern = "^[0-9a-z]+$";
-              break;
-            case "ulid":
-              json.pattern = "^[0-9A-HJKMNP-TV-Z]{26}$";
-              break;
-            case "datetime":
-              json.format = JSONSchemaFormat.DateTime;
-              break;
-            case "date":
-              json.format = JSONSchemaFormat.Date;
-              break;
-            case "time":
-              json.format = JSONSchemaFormat.Time;
-              break;
-            case "duration":
-              json.format = JSONSchemaFormat.Duration;
-              break;
-            case "ip": {
-              if (check.version === "v4") {
-                json.format = JSONSchemaFormat.IPv4;
-              } else if (check.version === "v6") {
-                json.format = JSONSchemaFormat.IPv6;
-              } else {
-                json.anyOf = [{ format: JSONSchemaFormat.IPv4 }, { format: JSONSchemaFormat.IPv6 }];
-              }
-              break;
-            }
-            case "jwt":
-              json.pattern = "^[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]*$";
-              break;
-            case "base64url":
-              json.pattern = "^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$";
-              break;
-            default: {
-              check.kind;
-            }
-          }
-        }
-        return [true, json];
-      }
-      case ZodFirstPartyTypeKind.ZodNumber: {
-        const schema_ = schema;
-        const json = { type: "number" };
-        for (const check of schema_._def.checks) {
-          switch (check.kind) {
-            case "int":
-              json.type = "integer";
-              break;
-            case "min":
-              json.minimum = check.value;
-              break;
-            case "max":
-              json.maximum = check.value;
-              break;
-            case "multipleOf":
-              json.multipleOf = check.value;
-              break;
-            default: {
-              check.kind;
-            }
-          }
-        }
-        return [true, json];
-      }
-      case ZodFirstPartyTypeKind.ZodBigInt: {
-        const json = {
-          type: "string",
-          pattern: "^-?[0-9]+$",
-          "x-native-type": JsonSchemaXNativeType.BigInt
-        };
-        return [true, json];
-      }
-      case ZodFirstPartyTypeKind.ZodNaN: {
-        return options.strategy === "input" ? [true, this.unsupportedJsonSchema] : [true, { type: "null" }];
-      }
-      case ZodFirstPartyTypeKind.ZodBoolean: {
-        return [true, { type: "boolean" }];
-      }
-      case ZodFirstPartyTypeKind.ZodDate: {
-        const schema2 = {
-          type: "string",
-          format: JSONSchemaFormat.DateTime,
-          "x-native-type": JsonSchemaXNativeType.Date
-        };
-        return [true, schema2];
-      }
-      case ZodFirstPartyTypeKind.ZodNull: {
-        return [true, { type: "null" }];
-      }
-      case ZodFirstPartyTypeKind.ZodLiteral: {
-        const schema_ = schema;
-        if (schema_._def.value === void 0) {
-          return [false, this.unsupportedJsonSchema];
-        }
-        return [true, { const: schema_._def.value }];
-      }
-      case ZodFirstPartyTypeKind.ZodVoid:
-      case ZodFirstPartyTypeKind.ZodUndefined: {
-        return [false, this.unsupportedJsonSchema];
-      }
-      case ZodFirstPartyTypeKind.ZodUnknown:
-      case ZodFirstPartyTypeKind.ZodAny: {
-        return [false, this.anyJsonSchema];
-      }
-      case ZodFirstPartyTypeKind.ZodEnum: {
-        const schema_ = schema;
-        return [true, { enum: schema_._def.values }];
-      }
-      case ZodFirstPartyTypeKind.ZodNativeEnum: {
-        const schema_ = schema;
-        return [true, { enum: Object.values(schema_._def.values) }];
-      }
-      case ZodFirstPartyTypeKind.ZodArray: {
-        const schema_ = schema;
-        const def2 = schema_._def;
-        const json = { type: "array" };
-        const [itemRequired, itemJson] = this.convert(
-          def2.type,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth + 1
-        );
-        json.items = this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy);
-        if (def2.exactLength) {
-          json.maxItems = def2.exactLength.value;
-          json.minItems = def2.exactLength.value;
-        }
-        if (def2.minLength) {
-          json.minItems = def2.minLength.value;
-        }
-        if (def2.maxLength) {
-          json.maxItems = def2.maxLength.value;
-        }
-        return [true, json];
-      }
-      case ZodFirstPartyTypeKind.ZodTuple: {
-        const schema_ = schema;
-        const prefixItems = [];
-        const json = { type: "array" };
-        for (const item of schema_._def.items) {
-          const [itemRequired, itemJson] = this.convert(
-            item,
-            options,
-            lazyDepth,
-            false,
-            false,
-            structureDepth + 1
-          );
-          prefixItems.push(this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy));
-        }
-        if (prefixItems?.length) {
-          json.prefixItems = prefixItems;
-        }
-        if (schema_._def.rest) {
-          const [itemRequired, itemJson] = this.convert(
-            schema_._def.rest,
-            options,
-            lazyDepth,
-            false,
-            false,
-            structureDepth + 1
-          );
-          json.items = this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy);
-        }
-        return [true, json];
-      }
-      case ZodFirstPartyTypeKind.ZodObject: {
-        const schema_ = schema;
-        const json = { type: "object" };
-        const properties = {};
-        const required = [];
-        for (const [key, value] of Object.entries(schema_.shape)) {
-          const [itemRequired, itemJson] = this.convert(
-            value,
-            options,
-            lazyDepth,
-            false,
-            false,
-            structureDepth + 1
-          );
-          properties[key] = itemJson;
-          if (itemRequired) {
-            required.push(key);
-          }
-        }
-        if (Object.keys(properties).length) {
-          json.properties = properties;
-        }
-        if (required.length) {
-          json.required = required;
-        }
-        const catchAllTypeName = this.#getZodTypeName(schema_._def.catchall._def);
-        if (catchAllTypeName === ZodFirstPartyTypeKind.ZodNever) {
-          if (schema_._def.unknownKeys === "strict") {
-            json.additionalProperties = false;
-          }
-        } else {
-          const [_, addJson] = this.convert(
-            schema_._def.catchall,
-            options,
-            lazyDepth,
-            false,
-            false,
-            structureDepth + 1
-          );
-          json.additionalProperties = addJson;
-        }
-        return [true, json];
-      }
-      case ZodFirstPartyTypeKind.ZodRecord: {
-        const schema_ = schema;
-        const json = { type: "object" };
-        const [__, keyJson] = this.convert(
-          schema_._def.keyType,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth + 1
-        );
-        if (Object.entries(keyJson).some(([k, v]) => k !== "type" || v !== "string")) {
-          json.propertyNames = keyJson;
-        }
-        const [_, itemJson] = this.convert(
-          schema_._def.valueType,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth + 1
-        );
-        json.additionalProperties = itemJson;
-        return [true, json];
-      }
-      case ZodFirstPartyTypeKind.ZodSet: {
-        const schema_ = schema;
-        const json = {
-          type: "array",
-          uniqueItems: true,
-          "x-native-type": JsonSchemaXNativeType.Set
-        };
-        const [itemRequired, itemJson] = this.convert(
-          schema_._def.valueType,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth + 1
-        );
-        json.items = this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy);
-        return [true, json];
-      }
-      case ZodFirstPartyTypeKind.ZodMap: {
-        const schema_ = schema;
-        const [keyRequired, keyJson] = this.convert(
-          schema_._def.keyType,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth + 1
-        );
-        const [valueRequired, valueJson] = this.convert(
-          schema_._def.valueType,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth + 1
-        );
-        const json = {
-          type: "array",
-          items: {
-            type: "array",
-            prefixItems: [
-              this.#toArrayItemJsonSchema(keyRequired, keyJson, options.strategy),
-              this.#toArrayItemJsonSchema(valueRequired, valueJson, options.strategy)
-            ],
-            maxItems: 2,
-            minItems: 2
-          },
-          "x-native-type": JsonSchemaXNativeType.Map
-        };
-        return [true, json];
-      }
-      case ZodFirstPartyTypeKind.ZodUnion:
-      case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
-        const schema_ = schema;
-        const anyOf = [];
-        let required = true;
-        for (const item of schema_._def.options) {
-          const [itemRequired, itemJson] = this.convert(
-            item,
-            options,
-            lazyDepth,
-            false,
-            false,
-            structureDepth
-          );
-          if (!itemRequired) {
-            required = false;
-            if (itemJson !== this.unsupportedJsonSchema) {
-              anyOf.push(itemJson);
-            }
-          } else {
-            anyOf.push(itemJson);
-          }
-        }
-        if (anyOf.length === 1) {
-          return [required, anyOf[0]];
-        }
-        return [required, { anyOf }];
-      }
-      case ZodFirstPartyTypeKind.ZodIntersection: {
-        const schema_ = schema;
-        const allOf = [];
-        let required = false;
-        for (const item of [schema_._def.left, schema_._def.right]) {
-          const [itemRequired, itemJson] = this.convert(
-            item,
-            options,
-            lazyDepth,
-            false,
-            false,
-            structureDepth
-          );
-          allOf.push(itemJson);
-          if (itemRequired) {
-            required = true;
-          }
-        }
-        return [required, { allOf }];
-      }
-      case ZodFirstPartyTypeKind.ZodLazy: {
-        const currentLazyDepth = lazyDepth + 1;
-        if (currentLazyDepth > this.maxLazyDepth) {
-          return [false, this.anyJsonSchema];
-        }
-        const schema_ = schema;
-        return this.convert(schema_._def.getter(), options, currentLazyDepth, false, false, structureDepth);
-      }
-      case ZodFirstPartyTypeKind.ZodOptional: {
-        const schema_ = schema;
-        const [_, inner] = this.convert(
-          schema_._def.innerType,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth
-        );
-        return [false, inner];
-      }
-      case ZodFirstPartyTypeKind.ZodReadonly: {
-        const schema_ = schema;
-        const [required, json] = this.convert(
-          schema_._def.innerType,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth
-        );
-        return [required, { ...json, readOnly: true }];
-      }
-      case ZodFirstPartyTypeKind.ZodDefault: {
-        const schema_ = schema;
-        const [_, json] = this.convert(
-          schema_._def.innerType,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth
-        );
-        return [false, { default: schema_._def.defaultValue(), ...json }];
-      }
-      case ZodFirstPartyTypeKind.ZodEffects: {
-        const schema_ = schema;
-        if (schema_._def.effect.type === "transform" && options.strategy === "output") {
-          return [false, this.anyJsonSchema];
-        }
-        return this.convert(schema_._def.schema, options, lazyDepth, false, false, structureDepth);
-      }
-      case ZodFirstPartyTypeKind.ZodCatch: {
-        const schema_ = schema;
-        return this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
-      }
-      case ZodFirstPartyTypeKind.ZodBranded: {
-        const schema_ = schema;
-        return this.convert(schema_._def.type, options, lazyDepth, false, false, structureDepth);
-      }
-      case ZodFirstPartyTypeKind.ZodPipeline: {
-        const schema_ = schema;
-        return this.convert(
-          options.strategy === "input" ? schema_._def.in : schema_._def.out,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth
-        );
-      }
-      case ZodFirstPartyTypeKind.ZodNullable: {
-        const schema_ = schema;
-        const [required, json] = this.convert(
-          schema_._def.innerType,
-          options,
-          lazyDepth,
-          false,
-          false,
-          structureDepth
-        );
-        return [required, { anyOf: [json, { type: "null" }] }];
-      }
-    }
-    return [true, this.unsupportedJsonSchema];
+class SchemaClass {
+  string(params) {
+    return string(params);
   }
-  #handleCustomZodDef(def) {
-    const customZodDef = getCustomZodDef(def);
-    if (!customZodDef) {
-      return void 0;
-    }
-    switch (customZodDef.type) {
-      case "blob": {
-        return { type: "string", contentMediaType: "*/*" };
-      }
-      case "file": {
-        return { type: "string", contentMediaType: customZodDef.mimeType ?? "*/*" };
-      }
-      case "regexp": {
-        return {
-          type: "string",
-          pattern: "^\\/(.*)\\/([a-z]*)$",
-          "x-native-type": JsonSchemaXNativeType.RegExp
-        };
-      }
-      case "url": {
-        return {
-          type: "string",
-          format: JSONSchemaFormat.URI,
-          "x-native-type": JsonSchemaXNativeType.Url
-        };
-      }
-    }
+  number(params) {
+    return number(params);
   }
-  #getZodTypeName(def) {
-    return def.typeName;
+  int(params) {
+    return this.number().int(params);
   }
-  #toArrayItemJsonSchema(required, schema, strategy) {
-    if (required) {
-      return schema;
-    }
-    return strategy === "input" ? { anyOf: [schema, this.unsupportedJsonSchema] } : { anyOf: [schema, { type: "null" }] };
+  boolean(params) {
+    return boolean(params);
+  }
+  null(params) {
+    return _null(params);
+  }
+  array(element, params) {
+    return array(element, params);
+  }
+  record(keyType, valueType, params) {
+    return record(keyType, valueType, params);
   }
+  union(options, params) {
+    return union(options, params);
+  }
+  discriminatedUnion(discriminator, options, params) {
+    return discriminatedUnion(discriminator, options, params);
+  }
+  object(shape, params) {
+    return object(shape, params);
+  }
+  // TODO: make this a codec?
+  date(params) {
+    return date(params);
+  }
+  any() {
+    return any();
+  }
+  unknown() {
+    return unknown();
+  }
+  never(params) {
+    return never(params);
+  }
+  lazy(getter) {
+    return lazy(getter);
+  }
+  json(params) {
+    return json(params);
+  }
+  /**
+   * TODO: def need to expose
+   * file
+   * literal
+   * nativeEnum
+   */
+  /**
+   * TODO: decide how to handle non-serializeable values
+   * TODO: decide what types to expose
+   * function
+   * promise
+   * readonly
+   * nan
+   * success
+   * set
+   * map
+   * partialRecord
+   * tuple
+   * intersection
+   * keyof
+   * symbol
+   * bigint
+   * blob
+   */
+  /**
+   * TODO: decide what non-chained format helpers to expose
+   * -- OBJECT
+   * strictObject
+   * looseObject
+   * -- STRING
+   * url
+   * regexp
+   * email
+   * guid
+   * uuid
+   * uuidv4
+   * uuidv6
+   * uuidv7
+   * url
+   * httpUrl
+   * emoji
+   * nanoid
+   * cuid
+   * cuid2
+   * ulid
+   * xid
+   * ksuid
+   * jwt
+   * hostname
+   * hex
+   * hash
+   * ipv4
+   * ipv6
+   * cidrv4
+   * cidrv6
+   * base64
+   * base64url
+   * e164
+   * -- NUMBER
+   * float32
+   * float64
+   * int32
+   * uint32
+   * int64
+   * uint64
+   */
+  /**
+   * TODO: decide what other helper methods to expose
+   * preprocess
+   * refine
+   * superRefine
+   * custom
+   * check
+   * codec
+   * pipe
+   * nonoptional
+   * prefault
+   * default
+   * nullish
+   * nullable
+   * optional
+   * transform
+   * stringFormat
+   */
 }
 
-const oz = {
-  file,
-  blob,
-  url,
-  regexp,
-  openapi: customJsonSchema
-};
-
-export { ZodSmartCoercionPlugin, ZodToJsonSchemaConverter, blob, composeParams, customJsonSchema, file, getCustomJsonSchema, getCustomZodDef, oz, regexp, setCustomZodDef, url };
+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 };