@temporary-name/zod 1.9.3-alpha.8026644f8b8b29ec5943323a4b1a32713d47dfd2 → 1.9.3-alpha.8dcf0da5d97e7b89ab5ce50c8d1733c158e629a8

package/dist/index.mjs

@@ -1,955 +1,1565 @@
-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';
 
-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 KrustyISODateTime = /* @__PURE__ */ core.$constructor(
+  "KrustyISODateTime",
+  (inst, def) => {
+    const coreInit = core.$ZodISODateTime.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
-  if (options.strategy === "output" && CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL in def) {
-    return def[CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL];
+);
+function datetime(params) {
+  return core._isoDateTime(KrustyISODateTime, params);
+}
+const KrustyISODate = /* @__PURE__ */ core.$constructor(
+  "KrustyISODate",
+  (inst, def) => {
+    const coreInit = core.$ZodISODate.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
-  if (CUSTOM_JSON_SCHEMA_SYMBOL in def) {
-    return def[CUSTOM_JSON_SCHEMA_SYMBOL];
+);
+function date$1(params) {
+  return core._isoDate(KrustyISODate, params);
+}
+const KrustyISOTime = /* @__PURE__ */ core.$constructor(
+  "KrustyISOTime",
+  (inst, def) => {
+    const coreInit = core.$ZodISOTime.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
-  return void 0;
+);
+function time(params) {
+  return core._isoTime(KrustyISOTime, 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
-  });
-  return newSchema;
+const KrustyISODuration = /* @__PURE__ */ core.$constructor(
+  "KrustyISODuration",
+  (inst, def) => {
+    const coreInit = core.$ZodISODuration.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function duration(params) {
+  return core._isoDuration(KrustyISODuration, params);
 }
 
-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 gatingContext = new AsyncLocalStorage();
+function isGateIssueRaw(issue) {
+  return issue.code === "invalid_type" && issue.expected === "never" && issue.inst instanceof KrustyGate;
 }
-
-function blob(params) {
-  const schema = custom(
-    (val) => val instanceof Blob,
-    composeParams(
-      () => "Input is not a blob",
-      params
-    )
-  );
-  setCustomZodDef(schema._def, { type: "blob" });
-  return schema;
+function isGateIssue(issue) {
+  return issue.code === "invalid_type" && issue.expected === "never" && issue.path?.length === 0;
 }
-
-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;
-    }
+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;
-}
-
-function url(params) {
-  const schema = custom(
-    (val) => val instanceof URL,
-    composeParams(
-      () => "Input is not a URL",
-      params
-    )
-  );
-  setCustomZodDef(schema._def, { type: "url" });
-  return schema;
+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;
 }
-
-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 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);
       }
-      const coercedInput = zodCoerceInternal(inputSchema, options2.input);
-      return options2.next({ ...options2, input: coercedInput });
-    });
+    };
   }
+);
+function union(options, params) {
+  return new KrustyUnion({
+    type: "union",
+    options,
+    ...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 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));
   }
-  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;
+  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;
+      if (newIssues) {
+        payload.issues = newIssues.filter(Boolean);
       }
-      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));
-      }
-      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;
-      }
-      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;
+      if (proms.length > 0) {
+        return Promise.all(proms).then(() => payload);
+      } else {
+        return payload;
       }
-      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);
+    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 value;
-    }
+    };
   }
-  return value;
+);
+function object(shape, params) {
+  const def = {
+    type: "object",
+    shape: shape ?? {},
+    ...util.normalizeParams(params)
+  };
+  return new KrustyObject(def);
 }
-function safeToBigInt(value) {
-  return guard(() => BigInt(value)) ?? value;
+function strictObject(shape, params) {
+  return new KrustyObject({
+    type: "object",
+    shape,
+    catchall: never(),
+    ...util.normalizeParams(params)
+  });
 }
-function safeToNumber(value) {
-  const num = Number(value);
-  return Number.isNaN(num) || num.toString() !== value ? value : num;
+function looseObject(shape, params) {
+  return new KrustyObject({
+    type: "object",
+    shape,
+    catchall: unknown(),
+    ...util.normalizeParams(params)
+  });
 }
-function safeToBoolean(value) {
-  const lower = value.toLowerCase();
-  if (lower === "false" || lower === "off" || lower === "f") {
-    return false;
+
+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);
+    return inst;
   }
-  if (lower === "true" || lower === "on" || lower === "t") {
-    return true;
+);
+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));
+    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(KrustyString, params);
 }
-function safeToRegExp(value) {
-  if (value.startsWith("/")) {
-    const match = value.match(/^\/(.*)\/([a-z]*)$/);
-    if (match) {
-      const [, pattern, flags] = match;
-      return new RegExp(pattern, flags);
-    }
+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);
   }
-  return value;
+);
+function email(params) {
+  return core._email(KrustyEmail, params);
 }
-function safeToURL(value) {
-  return guard(() => new URL(value)) ?? value;
+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 safeToDate(value) {
-  const date = new Date(value);
-  if (!Number.isNaN(date.getTime()) && date.toISOString().startsWith(value)) {
-    return date;
+const KrustyUUID = /* @__PURE__ */ core.$constructor(
+  "KrustyUUID",
+  (inst, def) => {
+    const coreInit = core.$ZodUUID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
   }
-  return value;
+);
+function uuid(params) {
+  return core._uuid(KrustyUUID, 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 }];
+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);
+  }
+);
+function url(params) {
+  return core._url(KrustyURL, params);
+}
+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);
+  }
+);
+function emoji(params) {
+  return core._emoji(KrustyEmoji, params);
+}
+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);
+}
+const KrustyCUID = /* @__PURE__ */ core.$constructor(
+  "KrustyCUID",
+  (inst, def) => {
+    const coreInit = core.$ZodCUID.init;
+    coreInit(inst, def);
+    KrustyStringFormat.init(inst, def);
+  }
+);
+function cuid(params) {
+  return core._cuid(KrustyCUID, params);
+}
+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;
+  }
+);
+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);
+  }
+);
+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 core._date(KrustyDate, params);
+}
+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.ZodNativeEnum: {
-        const schema_ = schema;
-        return [true, { enum: Object.values(schema_._def.values) }];
+      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.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 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.");
         }
-        return [true, json];
+        return def.values[0];
       }
-      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];
+    });
+  }
+);
+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.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;
-          }
+      payload.addIssue = (issue) => {
+        if (typeof issue === "string") {
+          payload.issues.push(util.issue(issue, payload.value, def));
         } 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];
+          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;
   }
-  #handleCustomZodDef(def) {
-    const customZodDef = getCustomZodDef(def);
-    if (!customZodDef) {
-      return void 0;
+);
+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;
+  }
+);
+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);
+  }
+  // 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
+   * 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, 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 };