@temporary-name/zod 1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d → 1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6

package/dist/index.mjs

@@ -1,955 +1,1625 @@
-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/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';
 
-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];
-  }
-  if (options.strategy === "output" && CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL in def) {
-    return def[CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL];
-  }
-  if (CUSTOM_JSON_SCHEMA_SYMBOL in def) {
-    return def[CUSTOM_JSON_SCHEMA_SYMBOL];
-  }
-  return void 0;
-}
-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
+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,
+    }
   });
-  return newSchema;
-}
+};
+const ZodError = core.$constructor("ZodError", initializer);
+const ZodRealError = core.$constructor("ZodError", initializer, {
+  Parent: Error
+});
 
-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);
-    if (!params) {
-      return {
-        message
-      };
-    }
-    if (typeof params === "function") {
-      return {
-        message,
-        ...params(val)
-      };
-    }
-    if (typeof params === "object") {
-      return {
-        message,
-        ...params
-      };
-    }
-    return {
-      message: params
-    };
-  };
-}
+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);
 
-function blob(params) {
-  const schema = custom(
-    (val) => val instanceof Blob,
-    composeParams(
-      () => "Input is not a blob",
-      params
-    )
-  );
-  setCustomZodDef(schema._def, { type: "blob" });
-  return schema;
+const gatingContext = new AsyncLocalStorage();
+function isGateIssueRaw(issue) {
+  return issue.code === "invalid_type" && issue.expected === "never" && issue.inst instanceof KrustyGate;
 }
-
-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 isGateIssue(issue) {
+  return issue.code === "invalid_type" && issue.expected === "never" && issue.path?.length === 0;
+}
+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 KrustyGate({
+    type: "optional",
+    innerType,
+    gateName
   });
 }
 
-function regexp(params) {
-  const schema = custom(
-    (val) => val instanceof RegExp,
-    composeParams(
-      () => "Input is not a regexp",
-      params
-    )
-  );
-  setCustomZodDef(schema._def, { type: "regexp" });
-  return schema;
+const KrustyISODateTime = /* @__PURE__ */ core.$constructor(
+  "KrustyISODateTime",
+  (inst, def) => {
+    const coreInit = core.$ZodISODateTime.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function datetime$1(params) {
+  return core._isoDateTime(KrustyISODateTime, params);
 }
-
-function url(params) {
-  const schema = custom(
-    (val) => val instanceof URL,
-    composeParams(
-      () => "Input is not a URL",
-      params
-    )
-  );
-  setCustomZodDef(schema._def, { type: "url" });
-  return schema;
+const KrustyISODate = /* @__PURE__ */ core.$constructor(
+  "KrustyISODate",
+  (inst, def) => {
+    const coreInit = core.$ZodISODate.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function date$1(params) {
+  return core._isoDate(KrustyISODate, 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 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;
 }
-function zodCoerceInternal(schema, value) {
-  const customZodDef = getCustomZodDef(schema._def);
-  switch (customZodDef?.type) {
-    case "regexp": {
-      if (typeof value === "string") {
-        return safeToRegExp(value);
+const KrustyUnion = /* @__PURE__ */ core.$constructor(
+  "KrustyUnion",
+  (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);
       }
-      return value;
-    }
-    case "url": {
-      if (typeof value === "string") {
-        return safeToURL(value);
-      }
-      return value;
-    }
+    };
   }
-  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 union(options, params) {
+  return new KrustyUnion({
+    type: "union",
+    options,
+    ...util.normalizeParams(params)
+  });
+}
+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 KrustyDiscriminatedUnion({
+    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 (result.value === void 0) {
+    if (key in input) {
+      final.value[key] = void 0;
     }
-    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);
+  } else {
+    final.value[key] = result.value;
+  }
+}
+const KrustyObject = /* @__PURE__ */ core.$constructor(
+  "KrustyObject",
+  (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(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;
+      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;
         }
-      }
-      return value;
-    }
-    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;
+        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);
           }
         }
       }
-      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;
-      }
-      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;
-        }
-        return newObj;
-      }
-      return value;
-    }
-    case ZodFirstPartyTypeKind.ZodArray: {
-      const schema_ = schema;
-      if (Array.isArray(value)) {
-        return value.map((v) => zodCoerceInternal(schema_._def.type, v));
+      if (newIssues) {
+        payload.issues = newIssues.filter(Boolean);
       }
-      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;
-        });
-      }
-      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)
-          ])
+      if (newUnrecognizedKeys.length > 0) {
+        const missingKeyIssue = payload.issues.find(
+          (issue) => issue.code === "unrecognized_keys" && !issue.path
         );
-      }
-      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;
+        if (missingKeyIssue) {
+          missingKeyIssue.keys.push(...newUnrecognizedKeys);
+        } else {
+          payload.issues.push({
+            code: "unrecognized_keys",
+            keys: newUnrecognizedKeys,
+            input,
+            inst
+          });
         }
-        results.push([newValue, result.error.issues.length]);
       }
-      if (results.length === 0) {
-        return value;
+      if (proms.length > 0) {
+        return Promise.all(proms).then(() => payload);
+      } else {
+        return payload;
       }
-      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 origParse = inst._zod.parse;
+    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
+            });
+          }
+        }
       }
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.innerType, value);
-    }
-    case ZodFirstPartyTypeKind.ZodOptional: {
-      if (value === void 0) {
-        return void 0;
+      if (res instanceof Promise) {
+        return res.then((r) => handleGating(input, r, ctx));
+      } else {
+        return handleGating(input, res, ctx);
       }
-      const schema_ = schema;
-      return zodCoerceInternal(schema_._def.innerType, value);
-    }
-    case ZodFirstPartyTypeKind.ZodLazy: {
-      const schema_ = schema;
-      if (value !== void 0) {
-        return zodCoerceInternal(schema_._def.getter(), value);
+    };
+  }
+);
+function object(shape, params) {
+  const def = {
+    type: "object",
+    shape: shape ?? {},
+    ...util.normalizeParams(params)
+  };
+  return new KrustyObject(def);
+}
+function strictObject(shape, params) {
+  return new KrustyObject({
+    type: "object",
+    shape,
+    catchall: never(),
+    ...util.normalizeParams(params)
+  });
+}
+function looseObject(shape, params) {
+  return new KrustyObject({
+    type: "object",
+    shape,
+    catchall: unknown(),
+    ...util.normalizeParams(params)
+  });
+}
+
+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.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);
+    inst.describe = (description) => {
+      const cl = inst.clone();
+      core.globalRegistry.add(cl, { description });
+      return cl;
+    };
+    Object.defineProperty(inst, "description", {
+      get() {
+        return core.globalRegistry.get(inst)?.description;
+      },
+      configurable: true
+    });
+    inst.meta = (...args) => {
+      if (args.length === 0) {
+        return core.globalRegistry.get(inst);
       }
-      return value;
-    }
+      const cl = inst.clone();
+      core.globalRegistry.add(cl, args[0]);
+      return cl;
+    };
+    return inst;
+  }
+);
+const _KrustyString = /* @__PURE__ */ core.$constructor(
+  "_KrustyString",
+  (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());
   }
-  return value;
+);
+const KrustyString = /* @__PURE__ */ core.$constructor(
+  "KrustyString",
+  (inst, def) => {
+    const coreInit = core.$ZodString.init;
+    coreInit(inst, def);
+    _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));
+  }
+);
+function string(params) {
+  return core._string(KrustyString, params);
 }
-function safeToBigInt(value) {
-  return guard(() => BigInt(value)) ?? value;
+const KrustyStringFormat = /* @__PURE__ */ core.$constructor(
+  "KrustyStringFormat",
+  (inst, def) => {
+    const coreInit = core.$ZodStringFormat.init;
+    coreInit(inst, def);
+    _KrustyString.init(inst, def);
+  }
+);
+const KrustyEmail = /* @__PURE__ */ core.$constructor(
+  "KrustyEmail",
+  (inst, def) => {
+    const coreInit = core.$ZodEmail.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function email(params) {
+  return core._email(KrustyEmail, params);
 }
-function safeToNumber(value) {
-  const num = Number(value);
-  return Number.isNaN(num) || num.toString() !== value ? value : num;
+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(KrustyGUID, params);
 }
-function safeToBoolean(value) {
-  const lower = value.toLowerCase();
-  if (lower === "false" || lower === "off" || lower === "f") {
-    return false;
+const KrustyUUID = /* @__PURE__ */ core.$constructor(
+  "KrustyUUID",
+  (inst, def) => {
+    const coreInit = core.$ZodUUID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
-  if (lower === "true" || lower === "on" || lower === "t") {
-    return true;
+);
+function uuid(params) {
+  return core._uuid(KrustyUUID, params);
+}
+function uuidv4(params) {
+  return core._uuidv4(KrustyUUID, params);
+}
+function uuidv6(params) {
+  return core._uuidv6(KrustyUUID, params);
+}
+function uuidv7(params) {
+  return core._uuidv7(KrustyUUID, params);
+}
+const KrustyURL = /* @__PURE__ */ core.$constructor(
+  "KrustyURL",
+  (inst, def) => {
+    const coreInit = core.$ZodURL.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
-  return value;
+);
+function url(params) {
+  return core._url(KrustyURL, params);
 }
-function safeToRegExp(value) {
-  if (value.startsWith("/")) {
-    const match = value.match(/^\/(.*)\/([a-z]*)$/);
-    if (match) {
-      const [, pattern, flags] = match;
-      return new RegExp(pattern, flags);
-    }
+function httpUrl(params) {
+  return core._url(KrustyURL, {
+    protocol: /^https?$/,
+    hostname: core.regexes.domain,
+    ...util.normalizeParams(params)
+  });
+}
+const KrustyEmoji = /* @__PURE__ */ core.$constructor(
+  "KrustyEmoji",
+  (inst, def) => {
+    const coreInit = core.$ZodEmoji.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
-  return value;
+);
+function emoji(params) {
+  return core._emoji(KrustyEmoji, params);
 }
-function safeToURL(value) {
-  return guard(() => new URL(value)) ?? value;
+const KrustyNanoID = /* @__PURE__ */ core.$constructor(
+  "KrustyNanoID",
+  (inst, def) => {
+    const coreInit = core.$ZodNanoID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function nanoid(params) {
+  return core._nanoid(KrustyNanoID, params);
 }
-function safeToDate(value) {
-  const date = new Date(value);
-  if (!Number.isNaN(date.getTime()) && date.toISOString().startsWith(value)) {
-    return date;
+const KrustyCUID = /* @__PURE__ */ core.$constructor(
+  "KrustyCUID",
+  (inst, def) => {
+    const coreInit = core.$ZodCUID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
-  return value;
+);
+function cuid(params) {
+  return core._cuid(KrustyCUID, params);
 }
-
-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);
+const KrustyCUID2 = /* @__PURE__ */ core.$constructor(
+  "KrustyCUID2",
+  (inst, def) => {
+    const coreInit = core.$ZodCUID2.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function cuid2(params) {
+  return core._cuid2(KrustyCUID2, params);
+}
+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(KrustyULID, params);
+}
+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(KrustyXID, params);
+}
+const KrustyKSUID = /* @__PURE__ */ core.$constructor(
+  "KrustyKSUID",
+  (inst, def) => {
+    const coreInit = core.$ZodKSUID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function ksuid(params) {
+  return core._ksuid(KrustyKSUID, params);
+}
+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(KrustyIPv4, params);
+}
+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(KrustyIPv6, params);
+}
+const KrustyCIDRv4 = /* @__PURE__ */ core.$constructor(
+  "KrustyCIDRv4",
+  (inst, def) => {
+    const coreInit = core.$ZodCIDRv4.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function cidrv4(params) {
+  return core._cidrv4(KrustyCIDRv4, params);
+}
+const KrustyCIDRv6 = /* @__PURE__ */ core.$constructor(
+  "KrustyCIDRv6",
+  (inst, def) => {
+    const coreInit = core.$ZodCIDRv6.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function cidrv6(params) {
+  return core._cidrv6(KrustyCIDRv6, params);
+}
+const KrustyBase64 = /* @__PURE__ */ core.$constructor(
+  "KrustyBase64",
+  (inst, def) => {
+    const coreInit = core.$ZodBase64.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function base64(params) {
+  return core._base64(KrustyBase64, params);
+}
+const KrustyBase64URL = /* @__PURE__ */ core.$constructor(
+  "KrustyBase64URL",
+  (inst, def) => {
+    const coreInit = core.$ZodBase64URL.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function base64url(params) {
+  return core._base64url(KrustyBase64URL, params);
+}
+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(KrustyE164, params);
+}
+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(KrustyJWT, params);
+}
+const KrustyCustomStringFormat = /* @__PURE__ */ core.$constructor("KrustyCustomStringFormat", (inst, def) => {
+  const coreInit = core.$ZodCustomStringFormat.init;
+  coreInit(inst, def);
+  KrustyStringFormat.init(inst, def);
+});
+function stringFormat(format, fnOrRegex, _params = {}) {
+  return core._stringFormat(KrustyCustomStringFormat, format, fnOrRegex, _params);
+}
+function hostname(_params) {
+  return core._stringFormat(KrustyCustomStringFormat, "hostname", core.regexes.hostname, _params);
+}
+function 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(KrustyCustomStringFormat, format, regex, params);
+}
+const KrustyNumber = /* @__PURE__ */ core.$constructor(
+  "KrustyNumber",
+  (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;
+    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 [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;
-          }
+      return origParse(payload, ctx);
+    };
+  }
+);
+function number(params) {
+  return core._number(KrustyNumber, params);
+}
+const KrustyNumberFormat = /* @__PURE__ */ core.$constructor(
+  "KrustyNumberFormat",
+  (inst, def) => {
+    const coreInit = core.$ZodNumberFormat.init;
+    coreInit(inst, def);
+    KrustyNumber.init(inst, def);
+  }
+);
+function int(params) {
+  return core._int(KrustyNumberFormat, params);
+}
+function float32(params) {
+  return core._float32(KrustyNumberFormat, params);
+}
+function float64(params) {
+  return core._float64(KrustyNumberFormat, params);
+}
+function int32(params) {
+  return core._int32(KrustyNumberFormat, params);
+}
+function uint32(params) {
+  return core._uint32(KrustyNumberFormat, params);
+}
+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 {
-          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;
+          payload.issues.push({
+            code: "invalid_type",
+            expected: "boolean",
+            values: ["true", "false"],
+            input: payload.value,
+            inst,
+            continue: false
+          });
+          return payload;
         }
-        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 }];
+      return origParse(payload, ctx);
+    };
+  }
+);
+function boolean(params) {
+  return core._boolean(KrustyBoolean, params);
+}
+const KrustyBigInt = /* @__PURE__ */ core.$constructor(
+  "KrustyBigInt",
+  (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(KrustyBigInt, params);
+}
+const KrustyBigIntFormat = /* @__PURE__ */ core.$constructor(
+  "KrustyBigIntFormat",
+  (inst, def) => {
+    const coreInit = core.$ZodBigIntFormat.init;
+    coreInit(inst, def);
+    KrustyBigInt.init(inst, def);
+  }
+);
+function int64(params) {
+  return core._int64(KrustyBigIntFormat, params);
+}
+function uint64(params) {
+  return core._uint64(KrustyBigIntFormat, params);
+}
+const KrustySymbol = /* @__PURE__ */ core.$constructor(
+  "KrustySymbol",
+  (inst, def) => {
+    const coreInit = core.$ZodSymbol.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function symbol(params) {
+  return core._symbol(KrustySymbol, params);
+}
+const KrustyUndefined = /* @__PURE__ */ core.$constructor(
+  "KrustyUndefined",
+  (inst, def) => {
+    const coreInit = core.$ZodUndefined.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function _undefined(params) {
+  return core._undefined(KrustyUndefined, params);
+}
+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(KrustyNull, params);
+}
+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(KrustyAny);
+}
+const KrustyUnknown = /* @__PURE__ */ core.$constructor(
+  "KrustyUnknown",
+  (inst, def) => {
+    const coreInit = core.$ZodUnknown.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function unknown() {
+  return core._unknown(KrustyUnknown);
+}
+const KrustyNever = /* @__PURE__ */ core.$constructor(
+  "KrustyNever",
+  (inst, def) => {
+    const coreInit = core.$ZodNever.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function never(params) {
+  return core._never(KrustyNever, params);
+}
+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(KrustyVoid, params);
+}
+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 codec(date$1(params), core._date(KrustyDate, params), {
+    encode: (date2) => `${date2.getFullYear()}-${String(date2.getMonth() + 1).padStart(2, "0")}-${String(date2.getDate()).padStart(2, "0")}`,
+    decode: (isoString2) => {
+      const [y, m, d] = isoString2.split("-");
+      return new Date(Number(y), Number(m) - 1, Number(d));
+    }
+  });
+}
+function datetime(params) {
+  return codec(datetime$1(params), core._date(KrustyDate, params), {
+    encode: (date2) => date2.toISOString(),
+    decode: (isoString2) => new Date(isoString2)
+  });
+}
+const KrustyArray = /* @__PURE__ */ core.$constructor(
+  "KrustyArray",
+  (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(KrustyArray, element, params);
+}
+function keyof(schema) {
+  const shape = schema._zod.def.shape;
+  return _enum(Object.keys(shape));
+}
+const KrustyIntersection = /* @__PURE__ */ core.$constructor(
+  "KrustyIntersection",
+  (inst, def) => {
+    const coreInit = core.$ZodIntersection.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function intersection(left, right) {
+  return new KrustyIntersection({
+    type: "intersection",
+    left,
+    right
+  });
+}
+const KrustyTuple = /* @__PURE__ */ core.$constructor(
+  "KrustyTuple",
+  (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 KrustyTuple({
+    type: "tuple",
+    items,
+    rest,
+    ...util.normalizeParams(params)
+  });
+}
+const KrustyRecord = /* @__PURE__ */ core.$constructor(
+  "KrustyRecord",
+  (inst, def) => {
+    const coreInit = core.$ZodRecord.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
+  }
+);
+function record(keyType, valueType, params) {
+  return new KrustyRecord({
+    type: "record",
+    keyType,
+    valueType,
+    ...util.normalizeParams(params)
+  });
+}
+function partialRecord(keyType, valueType, params) {
+  const k = core.clone(keyType);
+  k._zod.values = void 0;
+  return new KrustyRecord({
+    type: "record",
+    keyType: k,
+    valueType,
+    ...util.normalizeParams(params)
+  });
+}
+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 KrustyMap({
+    type: "map",
+    keyType,
+    valueType,
+    ...util.normalizeParams(params)
+  });
+}
+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 KrustySet({
+    type: "set",
+    valueType,
+    ...util.normalizeParams(params)
+  });
+}
+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`);
       }
-      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 }];
+      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`);
       }
-      case ZodFirstPartyTypeKind.ZodLazy: {
-        const currentLazyDepth = lazyDepth + 1;
-        if (currentLazyDepth > this.maxLazyDepth) {
-          return [false, this.anyJsonSchema];
+      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 KrustyEnum({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params)
+  });
+}
+function nativeEnum(entries, params) {
+  return new KrustyEnum({
+    type: "enum",
+    entries,
+    ...util.normalizeParams(params)
+  });
+}
+const KrustyLiteral = /* @__PURE__ */ core.$constructor(
+  "KrustyLiteral",
+  (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.");
         }
-        const schema_ = schema;
-        return this.convert(schema_._def.getter(), options, currentLazyDepth, false, false, structureDepth);
+        return def.values[0];
       }
-      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 }];
+    });
+  }
+);
+function literal(value, params) {
+  return new KrustyLiteral({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...util.normalizeParams(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(KrustyFile, params);
+}
+const KrustyTransform = /* @__PURE__ */ core.$constructor(
+  "KrustyTransform",
+  (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);
       }
-      case ZodFirstPartyTypeKind.ZodEffects: {
-        const schema_ = schema;
-        if (schema_._def.effect.type === "transform" && options.strategy === "output") {
-          return [false, this.anyJsonSchema];
+      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 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" }] }];
+      };
+      const output = def.transform(payload.value, payload);
+      if (output instanceof Promise) {
+        return output.then((output2) => {
+          payload.value = output2;
+          return payload;
+        });
       }
-    }
-    return [true, this.unsupportedJsonSchema];
+      payload.value = output;
+      return payload;
+    };
+  }
+);
+function transform(fn) {
+  return new KrustyTransform({
+    type: "transform",
+    transform: fn
+  });
+}
+const KrustyOptional = /* @__PURE__ */ core.$constructor(
+  "KrustyOptional",
+  (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 KrustyOptional({
+    type: "optional",
+    innerType
+  });
+}
+const KrustyNullable = /* @__PURE__ */ core.$constructor(
+  "KrustyNullable",
+  (inst, def) => {
+    const coreInit = core.$ZodNullable.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
   }
-  #handleCustomZodDef(def) {
-    const customZodDef = getCustomZodDef(def);
-    if (!customZodDef) {
-      return void 0;
+);
+function nullable(innerType) {
+  return new KrustyNullable({
+    type: "nullable",
+    innerType
+  });
+}
+function nullish(innerType) {
+  return optional(nullable(innerType));
+}
+const KrustyDefault = /* @__PURE__ */ core.$constructor(
+  "KrustyDefault",
+  (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 KrustyDefault({
+    type: "default",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
     }
-    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
-        };
-      }
+  });
+}
+const KrustyPrefault = /* @__PURE__ */ core.$constructor(
+  "KrustyPrefault",
+  (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 KrustyPrefault({
+    type: "prefault",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
     }
+  });
+}
+const KrustyNonOptional = /* @__PURE__ */ core.$constructor(
+  "KrustyNonOptional",
+  (inst, def) => {
+    const coreInit = core.$ZodNonOptional.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
   }
-  #getZodTypeName(def) {
-    return def.typeName;
+);
+function nonoptional(innerType, params) {
+  return new KrustyNonOptional({
+    type: "nonoptional",
+    innerType,
+    ...util.normalizeParams(params)
+  });
+}
+const KrustySuccess = /* @__PURE__ */ core.$constructor(
+  "KrustySuccess",
+  (inst, def) => {
+    const coreInit = core.$ZodSuccess.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
   }
-  #toArrayItemJsonSchema(required, schema, strategy) {
-    if (required) {
-      return schema;
-    }
-    return strategy === "input" ? { anyOf: [schema, this.unsupportedJsonSchema] } : { anyOf: [schema, { type: "null" }] };
+);
+function success(innerType) {
+  return new KrustySuccess({
+    type: "success",
+    innerType
+  });
+}
+const KrustyCatch = /* @__PURE__ */ core.$constructor(
+  "KrustyCatch",
+  (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 KrustyCatch({
+    type: "catch",
+    innerType,
+    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
+  });
+}
+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(KrustyNaN, params);
+}
+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 KrustyPipe({
+    type: "pipe",
+    in: in_,
+    out
+    // ...util.normalizeParams(params),
+  });
+}
+const KrustyCodec = /* @__PURE__ */ core.$constructor(
+  "KrustyCodec",
+  (inst, def) => {
+    KrustyPipe.init(inst, def);
+    const coreInit = core.$ZodCodec.init;
+    coreInit(inst, def);
+  }
+);
+function codec(in_, out, params) {
+  return new KrustyCodec({
+    type: "pipe",
+    in: in_,
+    out,
+    transform: params.decode,
+    reverseTransform: params.encode
+  });
+}
+const KrustyReadonly = /* @__PURE__ */ core.$constructor(
+  "KrustyReadonly",
+  (inst, def) => {
+    const coreInit = core.$ZodReadonly.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+  }
+);
+function readonly(innerType) {
+  return new KrustyReadonly({
+    type: "readonly",
+    innerType
+  });
+}
+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 KrustyTemplateLiteral({
+    type: "template_literal",
+    parts,
+    ...util.normalizeParams(params)
+  });
+}
+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 KrustyLazy({
+    type: "lazy",
+    getter
+  });
+}
+const KrustyPromise = /* @__PURE__ */ core.$constructor(
+  "KrustyPromise",
+  (inst, def) => {
+    const coreInit = core.$ZodPromise.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+  }
+);
+function promise(innerType) {
+  return new KrustyPromise({
+    type: "promise",
+    innerType
+  });
+}
+const KrustyFunction = /* @__PURE__ */ core.$constructor(
+  "KrustyFunction",
+  (inst, def) => {
+    const coreInit = core.$ZodFunction.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+function _function(params) {
+  return new KrustyFunction({
+    type: "function",
+    input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
+    output: params?.output ?? unknown()
+  });
+}
+const KrustyCustom = /* @__PURE__ */ core.$constructor(
+  "KrustyCustom",
+  (inst, def) => {
+    const coreInit = core.$ZodCustom.init;
+    coreInit(inst, def);
+    KrustyType.init(inst, def);
+  }
+);
+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(KrustyCustom, fn ?? (() => true), _params);
+}
+function refine(fn, _params = {}) {
+  return core._refine(KrustyCustom, fn, _params);
+}
+function superRefine(fn) {
+  return core._superRefine(fn);
+}
+function _instanceof(cls, params = {
+  error: `Input not instance of ${cls.name}`
+}) {
+  const inst = new KrustyCustom({
+    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: KrustyCodec,
+    Boolean: KrustyBoolean,
+    String: KrustyString
+  },
+  ...args
+);
+function json(params) {
+  const jsonSchema = lazy(() => {
+    return union([
+      string(params),
+      number(),
+      boolean(),
+      _null(),
+      array(jsonSchema),
+      record(string(), jsonSchema)
+    ]);
+  });
+  return jsonSchema;
 }
 
-const oz = {
-  file,
-  blob,
-  url,
-  regexp,
-  openapi: customJsonSchema
-};
+class SchemaClass {
+  string(params) {
+    return string(params);
+  }
+  number(params) {
+    return number(params);
+  }
+  int(params) {
+    return this.number().int(params);
+  }
+  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);
+  }
+  date(params) {
+    return date(params);
+  }
+  datetime(params) {
+    return datetime(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
+   * refine
+   * superRefine
+   * custom
+   * check
+   * codec
+   * pipe
+   * nonoptional
+   * prefault
+   * default
+   * nullish
+   * nullable
+   * optional
+   * transform
+   * stringFormat
+   */
+}
 
-export { ZodSmartCoercionPlugin, ZodToJsonSchemaConverter, blob, composeParams, customJsonSchema, file, getCustomJsonSchema, getCustomZodDef, oz, regexp, setCustomZodDef, url };
+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, datetime, 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 };