@wallarm-org/mcp 2.0.0-rc-feature-AS-882-status-code-ds-ownership.2 → 2.0.0

package/dist/index.js

@@ -1,287 +1,9 @@
 #!/usr/bin/env node
-import { __webpack_require__ } from "./rslib-runtime.js";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import fs from "fs";
 import path_0 from "path";
-var classic_checks_namespaceObject = {};
-__webpack_require__.r(classic_checks_namespaceObject);
-__webpack_require__.d(classic_checks_namespaceObject, {
-    endsWith: ()=>_endsWith,
-    gt: ()=>_gt,
-    gte: ()=>_gte,
-    includes: ()=>_includes,
-    length: ()=>_length,
-    lowercase: ()=>_lowercase,
-    lt: ()=>_lt,
-    lte: ()=>_lte,
-    maxLength: ()=>_maxLength,
-    maxSize: ()=>_maxSize,
-    mime: ()=>_mime,
-    minLength: ()=>_minLength,
-    minSize: ()=>_minSize,
-    multipleOf: ()=>_multipleOf,
-    negative: ()=>_negative,
-    nonnegative: ()=>_nonnegative,
-    nonpositive: ()=>_nonpositive,
-    normalize: ()=>_normalize,
-    overwrite: ()=>_overwrite,
-    positive: ()=>_positive,
-    property: ()=>_property,
-    regex: ()=>_regex,
-    size: ()=>_size,
-    slugify: ()=>_slugify,
-    startsWith: ()=>_startsWith,
-    toLowerCase: ()=>_toLowerCase,
-    toUpperCase: ()=>_toUpperCase,
-    trim: ()=>_trim,
-    uppercase: ()=>_uppercase
-});
-var iso_namespaceObject = {};
-__webpack_require__.r(iso_namespaceObject);
-__webpack_require__.d(iso_namespaceObject, {
-    ZodISODate: ()=>ZodISODate,
-    ZodISODateTime: ()=>ZodISODateTime,
-    ZodISODuration: ()=>ZodISODuration,
-    ZodISOTime: ()=>ZodISOTime,
-    date: ()=>iso_date,
-    datetime: ()=>iso_datetime,
-    duration: ()=>iso_duration,
-    time: ()=>iso_time
-});
-var classic_schemas_namespaceObject = {};
-__webpack_require__.r(classic_schemas_namespaceObject);
-__webpack_require__.d(classic_schemas_namespaceObject, {
-    ZodAny: ()=>ZodAny,
-    ZodArray: ()=>ZodArray,
-    ZodBase64: ()=>ZodBase64,
-    ZodBase64URL: ()=>ZodBase64URL,
-    ZodBigInt: ()=>ZodBigInt,
-    ZodBigIntFormat: ()=>ZodBigIntFormat,
-    ZodBoolean: ()=>ZodBoolean,
-    ZodCIDRv4: ()=>ZodCIDRv4,
-    ZodCIDRv6: ()=>ZodCIDRv6,
-    ZodCUID: ()=>ZodCUID,
-    ZodCUID2: ()=>ZodCUID2,
-    ZodCatch: ()=>ZodCatch,
-    ZodCodec: ()=>ZodCodec,
-    ZodCustom: ()=>ZodCustom,
-    ZodCustomStringFormat: ()=>ZodCustomStringFormat,
-    ZodDate: ()=>ZodDate,
-    ZodDefault: ()=>ZodDefault,
-    ZodDiscriminatedUnion: ()=>ZodDiscriminatedUnion,
-    ZodE164: ()=>ZodE164,
-    ZodEmail: ()=>ZodEmail,
-    ZodEmoji: ()=>ZodEmoji,
-    ZodEnum: ()=>ZodEnum,
-    ZodExactOptional: ()=>ZodExactOptional,
-    ZodFile: ()=>ZodFile,
-    ZodFunction: ()=>ZodFunction,
-    ZodGUID: ()=>ZodGUID,
-    ZodIPv4: ()=>ZodIPv4,
-    ZodIPv6: ()=>ZodIPv6,
-    ZodIntersection: ()=>ZodIntersection,
-    ZodJWT: ()=>ZodJWT,
-    ZodKSUID: ()=>ZodKSUID,
-    ZodLazy: ()=>ZodLazy,
-    ZodLiteral: ()=>ZodLiteral,
-    ZodMAC: ()=>ZodMAC,
-    ZodMap: ()=>ZodMap,
-    ZodNaN: ()=>ZodNaN,
-    ZodNanoID: ()=>ZodNanoID,
-    ZodNever: ()=>ZodNever,
-    ZodNonOptional: ()=>ZodNonOptional,
-    ZodNull: ()=>ZodNull,
-    ZodNullable: ()=>ZodNullable,
-    ZodNumber: ()=>ZodNumber,
-    ZodNumberFormat: ()=>ZodNumberFormat,
-    ZodObject: ()=>ZodObject,
-    ZodOptional: ()=>ZodOptional,
-    ZodPipe: ()=>ZodPipe,
-    ZodPrefault: ()=>ZodPrefault,
-    ZodPromise: ()=>ZodPromise,
-    ZodReadonly: ()=>ZodReadonly,
-    ZodRecord: ()=>ZodRecord,
-    ZodSet: ()=>ZodSet,
-    ZodString: ()=>ZodString,
-    ZodStringFormat: ()=>ZodStringFormat,
-    ZodSuccess: ()=>ZodSuccess,
-    ZodSymbol: ()=>ZodSymbol,
-    ZodTemplateLiteral: ()=>ZodTemplateLiteral,
-    ZodTransform: ()=>ZodTransform,
-    ZodTuple: ()=>ZodTuple,
-    ZodType: ()=>ZodType,
-    ZodULID: ()=>ZodULID,
-    ZodURL: ()=>ZodURL,
-    ZodUUID: ()=>ZodUUID,
-    ZodUndefined: ()=>ZodUndefined,
-    ZodUnion: ()=>ZodUnion,
-    ZodUnknown: ()=>ZodUnknown,
-    ZodVoid: ()=>ZodVoid,
-    ZodXID: ()=>ZodXID,
-    ZodXor: ()=>ZodXor,
-    _ZodString: ()=>_ZodString,
-    _default: ()=>schemas_default,
-    _function: ()=>_function,
-    any: ()=>any,
-    array: ()=>schemas_array,
-    base64: ()=>schemas_base64,
-    base64url: ()=>schemas_base64url,
-    bigint: ()=>schemas_bigint,
-    boolean: ()=>schemas_boolean,
-    catch: ()=>schemas_catch,
-    check: ()=>schemas_check,
-    cidrv4: ()=>schemas_cidrv4,
-    cidrv6: ()=>schemas_cidrv6,
-    codec: ()=>schemas_codec,
-    cuid: ()=>schemas_cuid,
-    cuid2: ()=>schemas_cuid2,
-    custom: ()=>custom,
-    date: ()=>schemas_date,
-    describe: ()=>schemas_describe,
-    discriminatedUnion: ()=>discriminatedUnion,
-    e164: ()=>schemas_e164,
-    email: ()=>schemas_email,
-    emoji: ()=>schemas_emoji,
-    enum: ()=>schemas_enum,
-    exactOptional: ()=>exactOptional,
-    file: ()=>schemas_file,
-    float32: ()=>float32,
-    float64: ()=>float64,
-    function: ()=>_function,
-    guid: ()=>schemas_guid,
-    hash: ()=>hash,
-    hex: ()=>schemas_hex,
-    hostname: ()=>schemas_hostname,
-    httpUrl: ()=>httpUrl,
-    instanceof: ()=>_instanceof,
-    int: ()=>schemas_int,
-    int32: ()=>int32,
-    int64: ()=>int64,
-    intersection: ()=>intersection,
-    ipv4: ()=>schemas_ipv4,
-    ipv6: ()=>schemas_ipv6,
-    json: ()=>schemas_json,
-    jwt: ()=>jwt,
-    keyof: ()=>keyof,
-    ksuid: ()=>schemas_ksuid,
-    lazy: ()=>lazy,
-    literal: ()=>literal,
-    looseObject: ()=>looseObject,
-    looseRecord: ()=>looseRecord,
-    mac: ()=>schemas_mac,
-    map: ()=>schemas_map,
-    meta: ()=>schemas_meta,
-    nan: ()=>nan,
-    nanoid: ()=>schemas_nanoid,
-    nativeEnum: ()=>nativeEnum,
-    never: ()=>never,
-    nonoptional: ()=>nonoptional,
-    null: ()=>schemas_null,
-    nullable: ()=>nullable,
-    nullish: ()=>schemas_nullish,
-    number: ()=>schemas_number,
-    object: ()=>schemas_object,
-    optional: ()=>optional,
-    partialRecord: ()=>partialRecord,
-    pipe: ()=>pipe,
-    prefault: ()=>prefault,
-    preprocess: ()=>preprocess,
-    promise: ()=>promise,
-    readonly: ()=>readonly,
-    record: ()=>record,
-    refine: ()=>refine,
-    set: ()=>schemas_set,
-    strictObject: ()=>strictObject,
-    string: ()=>schemas_string,
-    stringFormat: ()=>stringFormat,
-    stringbool: ()=>stringbool,
-    success: ()=>success,
-    superRefine: ()=>superRefine,
-    symbol: ()=>symbol,
-    templateLiteral: ()=>templateLiteral,
-    transform: ()=>transform,
-    tuple: ()=>tuple,
-    uint32: ()=>uint32,
-    uint64: ()=>uint64,
-    ulid: ()=>schemas_ulid,
-    undefined: ()=>schemas_undefined,
-    union: ()=>union,
-    unknown: ()=>unknown,
-    url: ()=>schemas_url,
-    uuid: ()=>schemas_uuid,
-    uuidv4: ()=>uuidv4,
-    uuidv6: ()=>uuidv6,
-    uuidv7: ()=>uuidv7,
-    void: ()=>schemas_void,
-    xid: ()=>schemas_xid,
-    xor: ()=>xor
-});
-var regexes_namespaceObject = {};
-__webpack_require__.r(regexes_namespaceObject);
-__webpack_require__.d(regexes_namespaceObject, {
-    base64: ()=>regexes_base64,
-    base64url: ()=>regexes_base64url,
-    bigint: ()=>bigint,
-    boolean: ()=>regexes_boolean,
-    browserEmail: ()=>browserEmail,
-    cidrv4: ()=>cidrv4,
-    cidrv6: ()=>cidrv6,
-    cuid: ()=>cuid,
-    cuid2: ()=>cuid2,
-    date: ()=>date,
-    datetime: ()=>datetime,
-    domain: ()=>domain,
-    duration: ()=>duration,
-    e164: ()=>e164,
-    email: ()=>email,
-    emoji: ()=>emoji,
-    extendedDuration: ()=>extendedDuration,
-    guid: ()=>guid,
-    hex: ()=>regexes_hex,
-    hostname: ()=>hostname,
-    html5Email: ()=>html5Email,
-    idnEmail: ()=>idnEmail,
-    integer: ()=>integer,
-    ipv4: ()=>ipv4,
-    ipv6: ()=>ipv6,
-    ksuid: ()=>ksuid,
-    lowercase: ()=>lowercase,
-    mac: ()=>mac,
-    md5_base64: ()=>md5_base64,
-    md5_base64url: ()=>md5_base64url,
-    md5_hex: ()=>md5_hex,
-    nanoid: ()=>nanoid,
-    null: ()=>_null,
-    number: ()=>regexes_number,
-    rfc5322Email: ()=>rfc5322Email,
-    sha1_base64: ()=>sha1_base64,
-    sha1_base64url: ()=>sha1_base64url,
-    sha1_hex: ()=>sha1_hex,
-    sha256_base64: ()=>sha256_base64,
-    sha256_base64url: ()=>sha256_base64url,
-    sha256_hex: ()=>sha256_hex,
-    sha384_base64: ()=>sha384_base64,
-    sha384_base64url: ()=>sha384_base64url,
-    sha384_hex: ()=>sha384_hex,
-    sha512_base64: ()=>sha512_base64,
-    sha512_base64url: ()=>sha512_base64url,
-    sha512_hex: ()=>sha512_hex,
-    string: ()=>string,
-    time: ()=>regexes_time,
-    ulid: ()=>ulid,
-    undefined: ()=>_undefined,
-    unicodeEmail: ()=>unicodeEmail,
-    uppercase: ()=>uppercase,
-    uuid: ()=>uuid,
-    uuid4: ()=>uuid4,
-    uuid6: ()=>uuid6,
-    uuid7: ()=>uuid7,
-    xid: ()=>xid
-});
-Object.freeze({
-    status: "aborted"
-});
+var core_a;
 function $constructor(name, initializer, params) {
     function init(inst, def) {
         if (!inst._zod) Object.defineProperty(inst, "_zod", {
@@ -342,19 +64,71 @@ class $ZodEncodeError extends Error {
         this.name = "ZodEncodeError";
     }
 }
-const globalConfig = {};
+(core_a = globalThis).__zod_globalConfig ?? (core_a.__zod_globalConfig = {});
+const globalConfig = globalThis.__zod_globalConfig;
 function core_config(newConfig) {
     if (newConfig) Object.assign(globalConfig, newConfig);
     return globalConfig;
 }
+const cuid = /^[cC][0-9a-z]{6,}$/;
+const cuid2 = /^[0-9a-z]+$/;
+const ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
+const xid = /^[0-9a-vA-V]{20}$/;
+const ksuid = /^[A-Za-z0-9]{27}$/;
+const nanoid = /^[a-zA-Z0-9_-]{21}$/;
+const duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
+const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+const uuid = (version)=>{
+    if (!version) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
+    return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+};
+const email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+const _emoji = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+function emoji() {
+    return new RegExp(_emoji, "u");
+}
+const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
+const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
+const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
+const regexes_base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
+const regexes_base64url = /^[A-Za-z0-9_-]*$/;
+const httpProtocol = /^https?$/;
+const e164 = /^\+[1-9]\d{6,14}$/;
+const dateSource = "(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))";
+const date = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
+function timeSource(args) {
+    const hhmm = "(?:[01]\\d|2[0-3]):[0-5]\\d";
+    const regex = "number" == typeof args.precision ? -1 === args.precision ? `${hhmm}` : 0 === args.precision ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+    return regex;
+}
+function regexes_time(args) {
+    return new RegExp(`^${timeSource(args)}$`);
+}
+function datetime(args) {
+    const time = timeSource({
+        precision: args.precision
+    });
+    const opts = [
+        "Z"
+    ];
+    if (args.local) opts.push("");
+    if (args.offset) opts.push("([+-](?:[01]\\d|2[0-3]):[0-5]\\d)");
+    const timeRegex = `${time}(?:${opts.join("|")})`;
+    return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
+}
+const string = (params)=>{
+    const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : "[\\s\\S]*";
+    return new RegExp(`^${regex}$`);
+};
+const regexes_boolean = /^(?:true|false)$/i;
+const lowercase = /^[^A-Z]*$/;
+const uppercase = /^[^a-z]*$/;
 function getEnumValues(entries) {
     const numericValues = Object.values(entries).filter((v)=>"number" == typeof v);
     const values = Object.entries(entries).filter(([k, _])=>-1 === numericValues.indexOf(+k)).map(([_, v])=>v);
     return values;
 }
-function joinValues(array, separator = "|") {
-    return array.map((val)=>stringifyPrimitive(val)).join(separator);
-}
 function jsonStringifyReplacer(_, value) {
     if ("bigint" == typeof value) return value.toString();
     return value;
@@ -382,20 +156,7 @@ function cleanRegex(source) {
     const end = source.endsWith("$") ? source.length - 1 : source.length;
     return source.slice(start, end);
 }
-function floatSafeRemainder(val, step) {
-    const valDecCount = (val.toString().split(".")[1] || "").length;
-    const stepString = step.toString();
-    let stepDecCount = (stepString.split(".")[1] || "").length;
-    if (0 === stepDecCount && /\d?e-\d?/.test(stepString)) {
-        const match = stepString.match(/\d?e-(\d?)/);
-        if (match?.[1]) stepDecCount = Number.parseInt(match[1]);
-    }
-    const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
-    const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
-    const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
-    return valInt % stepInt / 10 ** decCount;
-}
-const EVALUATING = Symbol("evaluating");
+const EVALUATING = /* @__PURE__*/ Symbol("evaluating");
 function defineLazy(object, key, getter) {
     let value;
     Object.defineProperty(object, key, {
@@ -441,7 +202,8 @@ const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace
 function util_isObject(data) {
     return "object" == typeof data && null !== data && !Array.isArray(data);
 }
-const util_allowsEval = cached(()=>{
+const util_allowsEval = /* @__PURE__*/ cached(()=>{
+    if (globalConfig.jitless) return false;
     if ("u" > typeof navigator && navigator?.userAgent?.includes("Cloudflare")) return false;
     try {
         const F = Function;
@@ -468,21 +230,15 @@ function shallowClone(o) {
     if (Array.isArray(o)) return [
         ...o
     ];
+    if (o instanceof Map) return new Map(o);
+    if (o instanceof Set) return new Set(o);
     return o;
 }
-const propertyKeyTypes = new Set([
+const propertyKeyTypes = /* @__PURE__*/ new Set([
     "string",
     "number",
     "symbol"
 ]);
-const primitiveTypes = new Set([
-    "string",
-    "number",
-    "bigint",
-    "boolean",
-    "symbol",
-    "undefined"
-]);
 function escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -508,46 +264,9 @@ function normalizeParams(_params) {
     };
     return params;
 }
-function stringifyPrimitive(value) {
-    if ("bigint" == typeof value) return value.toString() + "n";
-    if ("string" == typeof value) return `"${value}"`;
-    return `${value}`;
-}
 function optionalKeys(shape) {
     return Object.keys(shape).filter((k)=>"optional" === shape[k]._zod.optin && "optional" === shape[k]._zod.optout);
 }
-const NUMBER_FORMAT_RANGES = {
-    safeint: [
-        Number.MIN_SAFE_INTEGER,
-        Number.MAX_SAFE_INTEGER
-    ],
-    int32: [
-        -2147483648,
-        2147483647
-    ],
-    uint32: [
-        0,
-        4294967295
-    ],
-    float32: [
-        -3.4028234663852886e+38,
-        3.4028234663852886e38
-    ],
-    float64: [
-        -Number.MAX_VALUE,
-        Number.MAX_VALUE
-    ]
-};
-const BIGINT_FORMAT_RANGES = {
-    int64: [
-        /* @__PURE__*/ BigInt("-9223372036854775808"),
-        /* @__PURE__*/ BigInt("9223372036854775807")
-    ],
-    uint64: [
-        /* @__PURE__*/ BigInt(0),
-        /* @__PURE__*/ BigInt("18446744073709551615")
-    ]
-};
 function pick(schema, mask) {
     const currDef = schema._zod.def;
     const checks = currDef.checks;
@@ -623,6 +342,7 @@ function safeExtend(schema, shape) {
     return clone(schema, def);
 }
 function merge(a, b) {
+    if (a._zod.def.checks?.length) throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
     const def = mergeDefs(a._zod.def, {
         get shape () {
             const _shape = {
@@ -635,7 +355,7 @@ function merge(a, b) {
         get catchall () {
             return b._zod.def.catchall;
         },
-        checks: []
+        checks: b._zod.def.checks ?? []
     });
     return clone(a, def);
 }
@@ -697,6 +417,11 @@ function aborted(x, startIndex = 0) {
     for(let i = startIndex; i < x.issues.length; i++)if (x.issues[i]?.continue !== true) return true;
     return false;
 }
+function explicitlyAborted(x, startIndex = 0) {
+    if (true === x.aborted) return true;
+    for(let i = startIndex; i < x.issues.length; i++)if (x.issues[i]?.continue === false) return true;
+    return false;
+}
 function prefixIssues(path, issues) {
     return issues.map((iss)=>{
         var _a;
@@ -709,45 +434,18 @@ function unwrapMessage(message) {
     return "string" == typeof message ? message : message?.message;
 }
 function finalizeIssue(iss, ctx, config) {
-    const full = {
-        ...iss,
-        path: iss.path ?? []
-    };
-    if (!iss.message) {
-        const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
-        full.message = message;
-    }
-    delete full.inst;
-    delete full.continue;
-    if (!ctx?.reportInput) delete full.input;
-    return full;
-}
-function getSizableOrigin(input) {
-    if (input instanceof Set) return "set";
-    if (input instanceof Map) return "map";
-    if (input instanceof File) return "file";
-    return "unknown";
+    const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
+    const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
+    rest.path ?? (rest.path = []);
+    rest.message = message;
+    if (ctx?.reportInput) rest.input = _input;
+    return rest;
 }
 function getLengthableOrigin(input) {
     if (Array.isArray(input)) return "array";
     if ("string" == typeof input) return "string";
     return "unknown";
 }
-function parsedType(data) {
-    const t = typeof data;
-    switch(t){
-        case "number":
-            return Number.isNaN(data) ? "nan" : "number";
-        case "object":
-            {
-                if (null === data) return "null";
-                if (Array.isArray(data)) return "array";
-                const obj = data;
-                if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) return obj.constructor.name;
-            }
-    }
-    return t;
-}
 function util_issue(...args) {
     const [iss, input, inst] = args;
     if ("string" == typeof iss) return {
@@ -760,677 +458,143 @@ function util_issue(...args) {
         ...iss
     };
 }
-const errors_initializer = (inst, def)=>{
-    inst.name = "$ZodError";
-    Object.defineProperty(inst, "_zod", {
-        value: inst._zod,
-        enumerable: false
-    });
-    Object.defineProperty(inst, "issues", {
-        value: def,
-        enumerable: false
+const $ZodCheck = /*@__PURE__*/ $constructor("$ZodCheck", (inst, def)=>{
+    var _a;
+    inst._zod ?? (inst._zod = {});
+    inst._zod.def = def;
+    (_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+const $ZodCheckMaxLength = /*@__PURE__*/ $constructor("$ZodCheckMaxLength", (inst, def)=>{
+    var _a;
+    $ZodCheck.init(inst, def);
+    (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
+        const val = payload.value;
+        return !nullish(val) && void 0 !== val.length;
     });
-    inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
-    Object.defineProperty(inst, "toString", {
-        value: ()=>inst.message,
-        enumerable: false
+    inst._zod.onattach.push((inst)=>{
+        const curr = inst._zod.bag.maximum ?? 1 / 0;
+        if (def.maximum < curr) inst._zod.bag.maximum = def.maximum;
     });
-};
-const $ZodError = $constructor("$ZodError", errors_initializer);
-const $ZodRealError = $constructor("$ZodError", errors_initializer, {
-    Parent: Error
+    inst._zod.check = (payload)=>{
+        const input = payload.value;
+        const length = input.length;
+        if (length <= def.maximum) return;
+        const origin = getLengthableOrigin(input);
+        payload.issues.push({
+            origin,
+            code: "too_big",
+            maximum: def.maximum,
+            inclusive: true,
+            input,
+            inst,
+            continue: !def.abort
+        });
+    };
 });
-function flattenError(error, mapper = (issue)=>issue.message) {
-    const fieldErrors = {};
-    const formErrors = [];
-    for (const sub of error.issues)if (sub.path.length > 0) {
-        fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-        fieldErrors[sub.path[0]].push(mapper(sub));
-    } else formErrors.push(mapper(sub));
-    return {
-        formErrors,
-        fieldErrors
+const $ZodCheckMinLength = /*@__PURE__*/ $constructor("$ZodCheckMinLength", (inst, def)=>{
+    var _a;
+    $ZodCheck.init(inst, def);
+    (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
+        const val = payload.value;
+        return !nullish(val) && void 0 !== val.length;
+    });
+    inst._zod.onattach.push((inst)=>{
+        const curr = inst._zod.bag.minimum ?? -1 / 0;
+        if (def.minimum > curr) inst._zod.bag.minimum = def.minimum;
+    });
+    inst._zod.check = (payload)=>{
+        const input = payload.value;
+        const length = input.length;
+        if (length >= def.minimum) return;
+        const origin = getLengthableOrigin(input);
+        payload.issues.push({
+            origin,
+            code: "too_small",
+            minimum: def.minimum,
+            inclusive: true,
+            input,
+            inst,
+            continue: !def.abort
+        });
     };
-}
-function formatError(error, mapper = (issue)=>issue.message) {
-    const fieldErrors = {
-        _errors: []
+});
+const $ZodCheckLengthEquals = /*@__PURE__*/ $constructor("$ZodCheckLengthEquals", (inst, def)=>{
+    var _a;
+    $ZodCheck.init(inst, def);
+    (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
+        const val = payload.value;
+        return !nullish(val) && void 0 !== val.length;
+    });
+    inst._zod.onattach.push((inst)=>{
+        const bag = inst._zod.bag;
+        bag.minimum = def.length;
+        bag.maximum = def.length;
+        bag.length = def.length;
+    });
+    inst._zod.check = (payload)=>{
+        const input = payload.value;
+        const length = input.length;
+        if (length === def.length) return;
+        const origin = getLengthableOrigin(input);
+        const tooBig = length > def.length;
+        payload.issues.push({
+            origin,
+            ...tooBig ? {
+                code: "too_big",
+                maximum: def.length
+            } : {
+                code: "too_small",
+                minimum: def.length
+            },
+            inclusive: true,
+            exact: true,
+            input: payload.value,
+            inst,
+            continue: !def.abort
+        });
     };
-    const processError = (error)=>{
-        for (const issue of error.issues)if ("invalid_union" === issue.code && issue.errors.length) issue.errors.map((issues)=>processError({
-                issues
-            }));
-        else if ("invalid_key" === issue.code) processError({
-            issues: issue.issues
+});
+const $ZodCheckStringFormat = /*@__PURE__*/ $constructor("$ZodCheckStringFormat", (inst, def)=>{
+    var _a, _b;
+    $ZodCheck.init(inst, def);
+    inst._zod.onattach.push((inst)=>{
+        const bag = inst._zod.bag;
+        bag.format = def.format;
+        if (def.pattern) {
+            bag.patterns ?? (bag.patterns = new Set());
+            bag.patterns.add(def.pattern);
+        }
+    });
+    if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload)=>{
+        def.pattern.lastIndex = 0;
+        if (def.pattern.test(payload.value)) return;
+        payload.issues.push({
+            origin: "string",
+            code: "invalid_format",
+            format: def.format,
+            input: payload.value,
+            ...def.pattern ? {
+                pattern: def.pattern.toString()
+            } : {},
+            inst,
+            continue: !def.abort
         });
-        else if ("invalid_element" === issue.code) processError({
-            issues: issue.issues
-        });
-        else if (0 === issue.path.length) fieldErrors._errors.push(mapper(issue));
-        else {
-            let curr = fieldErrors;
-            let i = 0;
-            while(i < issue.path.length){
-                const el = issue.path[i];
-                const terminal = i === issue.path.length - 1;
-                if (terminal) {
-                    curr[el] = curr[el] || {
-                        _errors: []
-                    };
-                    curr[el]._errors.push(mapper(issue));
-                } else curr[el] = curr[el] || {
-                    _errors: []
-                };
-                curr = curr[el];
-                i++;
-            }
-        }
-    };
-    processError(error);
-    return fieldErrors;
-}
-const _parse = (_Err)=>(schema, value, _ctx, _params)=>{
-        const ctx = _ctx ? Object.assign(_ctx, {
-            async: false
-        }) : {
-            async: false
-        };
-        const result = schema._zod.run({
-            value,
-            issues: []
-        }, ctx);
-        if (result instanceof Promise) throw new $ZodAsyncError();
-        if (result.issues.length) {
-            const e = new (_params?.Err ?? _Err)(result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())));
-            captureStackTrace(e, _params?.callee);
-            throw e;
-        }
-        return result.value;
-    };
-const parse = /* @__PURE__*/ _parse($ZodRealError);
-const _parseAsync = (_Err)=>async (schema, value, _ctx, params)=>{
-        const ctx = _ctx ? Object.assign(_ctx, {
-            async: true
-        }) : {
-            async: true
-        };
-        let result = schema._zod.run({
-            value,
-            issues: []
-        }, ctx);
-        if (result instanceof Promise) result = await result;
-        if (result.issues.length) {
-            const e = new (params?.Err ?? _Err)(result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())));
-            captureStackTrace(e, params?.callee);
-            throw e;
-        }
-        return result.value;
-    };
-const parseAsync = /* @__PURE__*/ _parseAsync($ZodRealError);
-const _safeParse = (_Err)=>(schema, value, _ctx)=>{
-        const ctx = _ctx ? {
-            ..._ctx,
-            async: false
-        } : {
-            async: false
-        };
-        const result = schema._zod.run({
-            value,
-            issues: []
-        }, ctx);
-        if (result instanceof Promise) throw new $ZodAsyncError();
-        return result.issues.length ? {
-            success: false,
-            error: new (_Err ?? $ZodError)(result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())))
-        } : {
-            success: true,
-            data: result.value
-        };
-    };
-const safeParse = /* @__PURE__*/ _safeParse($ZodRealError);
-const _safeParseAsync = (_Err)=>async (schema, value, _ctx)=>{
-        const ctx = _ctx ? Object.assign(_ctx, {
-            async: true
-        }) : {
-            async: true
-        };
-        let result = schema._zod.run({
-            value,
-            issues: []
-        }, ctx);
-        if (result instanceof Promise) result = await result;
-        return result.issues.length ? {
-            success: false,
-            error: new _Err(result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())))
-        } : {
-            success: true,
-            data: result.value
-        };
-    };
-const safeParseAsync = /* @__PURE__*/ _safeParseAsync($ZodRealError);
-const _encode = (_Err)=>(schema, value, _ctx)=>{
-        const ctx = _ctx ? Object.assign(_ctx, {
-            direction: "backward"
-        }) : {
-            direction: "backward"
-        };
-        return _parse(_Err)(schema, value, ctx);
-    };
-const _decode = (_Err)=>(schema, value, _ctx)=>_parse(_Err)(schema, value, _ctx);
-const _encodeAsync = (_Err)=>async (schema, value, _ctx)=>{
-        const ctx = _ctx ? Object.assign(_ctx, {
-            direction: "backward"
-        }) : {
-            direction: "backward"
-        };
-        return _parseAsync(_Err)(schema, value, ctx);
-    };
-const _decodeAsync = (_Err)=>async (schema, value, _ctx)=>_parseAsync(_Err)(schema, value, _ctx);
-const _safeEncode = (_Err)=>(schema, value, _ctx)=>{
-        const ctx = _ctx ? Object.assign(_ctx, {
-            direction: "backward"
-        }) : {
-            direction: "backward"
-        };
-        return _safeParse(_Err)(schema, value, ctx);
-    };
-const _safeDecode = (_Err)=>(schema, value, _ctx)=>_safeParse(_Err)(schema, value, _ctx);
-const _safeEncodeAsync = (_Err)=>async (schema, value, _ctx)=>{
-        const ctx = _ctx ? Object.assign(_ctx, {
-            direction: "backward"
-        }) : {
-            direction: "backward"
-        };
-        return _safeParseAsync(_Err)(schema, value, ctx);
-    };
-const _safeDecodeAsync = (_Err)=>async (schema, value, _ctx)=>_safeParseAsync(_Err)(schema, value, _ctx);
-const cuid = /^[cC][^\s-]{8,}$/;
-const cuid2 = /^[0-9a-z]+$/;
-const ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
-const xid = /^[0-9a-vA-V]{20}$/;
-const ksuid = /^[A-Za-z0-9]{27}$/;
-const nanoid = /^[a-zA-Z0-9_-]{21}$/;
-const duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
-const extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
-const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
-const uuid = (version)=>{
-    if (!version) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
-    return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
-};
-const uuid4 = /*@__PURE__*/ uuid(4);
-const uuid6 = /*@__PURE__*/ uuid(6);
-const uuid7 = /*@__PURE__*/ uuid(7);
-const email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
-const html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
-const rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
-const unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
-const idnEmail = unicodeEmail;
-const browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
-const _emoji = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
-function emoji() {
-    return new RegExp(_emoji, "u");
-}
-const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
-const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-const mac = (delimiter)=>{
-    const escapedDelim = escapeRegex(delimiter ?? ":");
-    return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
-};
-const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
-const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
-const regexes_base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
-const regexes_base64url = /^[A-Za-z0-9_-]*$/;
-const hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
-const domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
-const e164 = /^\+[1-9]\d{6,14}$/;
-const dateSource = "(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))";
-const date = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
-function timeSource(args) {
-    const hhmm = "(?:[01]\\d|2[0-3]):[0-5]\\d";
-    const regex = "number" == typeof args.precision ? -1 === args.precision ? `${hhmm}` : 0 === args.precision ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
-    return regex;
-}
-function regexes_time(args) {
-    return new RegExp(`^${timeSource(args)}$`);
-}
-function datetime(args) {
-    const time = timeSource({
-        precision: args.precision
-    });
-    const opts = [
-        "Z"
-    ];
-    if (args.local) opts.push("");
-    if (args.offset) opts.push("([+-](?:[01]\\d|2[0-3]):[0-5]\\d)");
-    const timeRegex = `${time}(?:${opts.join("|")})`;
-    return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
-}
-const string = (params)=>{
-    const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : "[\\s\\S]*";
-    return new RegExp(`^${regex}$`);
-};
-const bigint = /^-?\d+n?$/;
-const integer = /^-?\d+$/;
-const regexes_number = /^-?\d+(?:\.\d+)?$/;
-const regexes_boolean = /^(?:true|false)$/i;
-const _null = /^null$/i;
-const _undefined = /^undefined$/i;
-const lowercase = /^[^A-Z]*$/;
-const uppercase = /^[^a-z]*$/;
-const regexes_hex = /^[0-9a-fA-F]*$/;
-function fixedBase64(bodyLength, padding) {
-    return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
-}
-function fixedBase64url(length) {
-    return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
-}
-const md5_hex = /^[0-9a-fA-F]{32}$/;
-const md5_base64 = /*@__PURE__*/ fixedBase64(22, "==");
-const md5_base64url = /*@__PURE__*/ fixedBase64url(22);
-const sha1_hex = /^[0-9a-fA-F]{40}$/;
-const sha1_base64 = /*@__PURE__*/ fixedBase64(27, "=");
-const sha1_base64url = /*@__PURE__*/ fixedBase64url(27);
-const sha256_hex = /^[0-9a-fA-F]{64}$/;
-const sha256_base64 = /*@__PURE__*/ fixedBase64(43, "=");
-const sha256_base64url = /*@__PURE__*/ fixedBase64url(43);
-const sha384_hex = /^[0-9a-fA-F]{96}$/;
-const sha384_base64 = /*@__PURE__*/ fixedBase64(64, "");
-const sha384_base64url = /*@__PURE__*/ fixedBase64url(64);
-const sha512_hex = /^[0-9a-fA-F]{128}$/;
-const sha512_base64 = /*@__PURE__*/ fixedBase64(86, "==");
-const sha512_base64url = /*@__PURE__*/ fixedBase64url(86);
-const $ZodCheck = /*@__PURE__*/ $constructor("$ZodCheck", (inst, def)=>{
-    var _a;
-    inst._zod ?? (inst._zod = {});
-    inst._zod.def = def;
-    (_a = inst._zod).onattach ?? (_a.onattach = []);
-});
-const numericOriginMap = {
-    number: "number",
-    bigint: "bigint",
-    object: "date"
-};
-const $ZodCheckLessThan = /*@__PURE__*/ $constructor("$ZodCheckLessThan", (inst, def)=>{
-    $ZodCheck.init(inst, def);
-    const origin = numericOriginMap[typeof def.value];
-    inst._zod.onattach.push((inst)=>{
-        const bag = inst._zod.bag;
-        const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? 1 / 0;
-        if (def.value < curr) if (def.inclusive) bag.maximum = def.value;
-        else bag.exclusiveMaximum = def.value;
-    });
-    inst._zod.check = (payload)=>{
-        if (def.inclusive ? payload.value <= def.value : payload.value < def.value) return;
-        payload.issues.push({
-            origin,
-            code: "too_big",
-            maximum: "object" == typeof def.value ? def.value.getTime() : def.value,
-            input: payload.value,
-            inclusive: def.inclusive,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckGreaterThan = /*@__PURE__*/ $constructor("$ZodCheckGreaterThan", (inst, def)=>{
-    $ZodCheck.init(inst, def);
-    const origin = numericOriginMap[typeof def.value];
-    inst._zod.onattach.push((inst)=>{
-        const bag = inst._zod.bag;
-        const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? -1 / 0;
-        if (def.value > curr) if (def.inclusive) bag.minimum = def.value;
-        else bag.exclusiveMinimum = def.value;
-    });
-    inst._zod.check = (payload)=>{
-        if (def.inclusive ? payload.value >= def.value : payload.value > def.value) return;
-        payload.issues.push({
-            origin,
-            code: "too_small",
-            minimum: "object" == typeof def.value ? def.value.getTime() : def.value,
-            input: payload.value,
-            inclusive: def.inclusive,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckMultipleOf = /*@__PURE__*/ $constructor("$ZodCheckMultipleOf", (inst, def)=>{
-    $ZodCheck.init(inst, def);
-    inst._zod.onattach.push((inst)=>{
-        var _a;
-        (_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
-    });
-    inst._zod.check = (payload)=>{
-        if (typeof payload.value !== typeof def.value) throw new Error("Cannot mix number and bigint in multiple_of check.");
-        const isMultiple = "bigint" == typeof payload.value ? payload.value % def.value === BigInt(0) : 0 === floatSafeRemainder(payload.value, def.value);
-        if (isMultiple) return;
-        payload.issues.push({
-            origin: typeof payload.value,
-            code: "not_multiple_of",
-            divisor: def.value,
-            input: payload.value,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckNumberFormat = /*@__PURE__*/ $constructor("$ZodCheckNumberFormat", (inst, def)=>{
-    $ZodCheck.init(inst, def);
-    def.format = def.format || "float64";
-    const isInt = def.format?.includes("int");
-    const origin = isInt ? "int" : "number";
-    const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
-    inst._zod.onattach.push((inst)=>{
-        const bag = inst._zod.bag;
-        bag.format = def.format;
-        bag.minimum = minimum;
-        bag.maximum = maximum;
-        if (isInt) bag.pattern = integer;
-    });
-    inst._zod.check = (payload)=>{
-        const input = payload.value;
-        if (isInt) {
-            if (!Number.isInteger(input)) return void payload.issues.push({
-                expected: origin,
-                format: def.format,
-                code: "invalid_type",
-                continue: false,
-                input,
-                inst
-            });
-            if (!Number.isSafeInteger(input)) {
-                if (input > 0) payload.issues.push({
-                    input,
-                    code: "too_big",
-                    maximum: Number.MAX_SAFE_INTEGER,
-                    note: "Integers must be within the safe integer range.",
-                    inst,
-                    origin,
-                    inclusive: true,
-                    continue: !def.abort
-                });
-                else payload.issues.push({
-                    input,
-                    code: "too_small",
-                    minimum: Number.MIN_SAFE_INTEGER,
-                    note: "Integers must be within the safe integer range.",
-                    inst,
-                    origin,
-                    inclusive: true,
-                    continue: !def.abort
-                });
-                return;
-            }
-        }
-        if (input < minimum) payload.issues.push({
-            origin: "number",
-            input,
-            code: "too_small",
-            minimum,
-            inclusive: true,
-            inst,
-            continue: !def.abort
-        });
-        if (input > maximum) payload.issues.push({
-            origin: "number",
-            input,
-            code: "too_big",
-            maximum,
-            inclusive: true,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckBigIntFormat = /*@__PURE__*/ $constructor("$ZodCheckBigIntFormat", (inst, def)=>{
-    $ZodCheck.init(inst, def);
-    const [minimum, maximum] = BIGINT_FORMAT_RANGES[def.format];
-    inst._zod.onattach.push((inst)=>{
-        const bag = inst._zod.bag;
-        bag.format = def.format;
-        bag.minimum = minimum;
-        bag.maximum = maximum;
-    });
-    inst._zod.check = (payload)=>{
-        const input = payload.value;
-        if (input < minimum) payload.issues.push({
-            origin: "bigint",
-            input,
-            code: "too_small",
-            minimum: minimum,
-            inclusive: true,
-            inst,
-            continue: !def.abort
-        });
-        if (input > maximum) payload.issues.push({
-            origin: "bigint",
-            input,
-            code: "too_big",
-            maximum,
-            inclusive: true,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckMaxSize = /*@__PURE__*/ $constructor("$ZodCheckMaxSize", (inst, def)=>{
-    var _a;
-    $ZodCheck.init(inst, def);
-    (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
-        const val = payload.value;
-        return !nullish(val) && void 0 !== val.size;
-    });
-    inst._zod.onattach.push((inst)=>{
-        const curr = inst._zod.bag.maximum ?? 1 / 0;
-        if (def.maximum < curr) inst._zod.bag.maximum = def.maximum;
-    });
-    inst._zod.check = (payload)=>{
-        const input = payload.value;
-        const size = input.size;
-        if (size <= def.maximum) return;
-        payload.issues.push({
-            origin: getSizableOrigin(input),
-            code: "too_big",
-            maximum: def.maximum,
-            inclusive: true,
-            input,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckMinSize = /*@__PURE__*/ $constructor("$ZodCheckMinSize", (inst, def)=>{
-    var _a;
-    $ZodCheck.init(inst, def);
-    (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
-        const val = payload.value;
-        return !nullish(val) && void 0 !== val.size;
-    });
-    inst._zod.onattach.push((inst)=>{
-        const curr = inst._zod.bag.minimum ?? -1 / 0;
-        if (def.minimum > curr) inst._zod.bag.minimum = def.minimum;
-    });
-    inst._zod.check = (payload)=>{
-        const input = payload.value;
-        const size = input.size;
-        if (size >= def.minimum) return;
-        payload.issues.push({
-            origin: getSizableOrigin(input),
-            code: "too_small",
-            minimum: def.minimum,
-            inclusive: true,
-            input,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckSizeEquals = /*@__PURE__*/ $constructor("$ZodCheckSizeEquals", (inst, def)=>{
-    var _a;
-    $ZodCheck.init(inst, def);
-    (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
-        const val = payload.value;
-        return !nullish(val) && void 0 !== val.size;
-    });
-    inst._zod.onattach.push((inst)=>{
-        const bag = inst._zod.bag;
-        bag.minimum = def.size;
-        bag.maximum = def.size;
-        bag.size = def.size;
-    });
-    inst._zod.check = (payload)=>{
-        const input = payload.value;
-        const size = input.size;
-        if (size === def.size) return;
-        const tooBig = size > def.size;
-        payload.issues.push({
-            origin: getSizableOrigin(input),
-            ...tooBig ? {
-                code: "too_big",
-                maximum: def.size
-            } : {
-                code: "too_small",
-                minimum: def.size
-            },
-            inclusive: true,
-            exact: true,
-            input: payload.value,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckMaxLength = /*@__PURE__*/ $constructor("$ZodCheckMaxLength", (inst, def)=>{
-    var _a;
-    $ZodCheck.init(inst, def);
-    (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
-        const val = payload.value;
-        return !nullish(val) && void 0 !== val.length;
-    });
-    inst._zod.onattach.push((inst)=>{
-        const curr = inst._zod.bag.maximum ?? 1 / 0;
-        if (def.maximum < curr) inst._zod.bag.maximum = def.maximum;
-    });
-    inst._zod.check = (payload)=>{
-        const input = payload.value;
-        const length = input.length;
-        if (length <= def.maximum) return;
-        const origin = getLengthableOrigin(input);
-        payload.issues.push({
-            origin,
-            code: "too_big",
-            maximum: def.maximum,
-            inclusive: true,
-            input,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckMinLength = /*@__PURE__*/ $constructor("$ZodCheckMinLength", (inst, def)=>{
-    var _a;
-    $ZodCheck.init(inst, def);
-    (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
-        const val = payload.value;
-        return !nullish(val) && void 0 !== val.length;
-    });
-    inst._zod.onattach.push((inst)=>{
-        const curr = inst._zod.bag.minimum ?? -1 / 0;
-        if (def.minimum > curr) inst._zod.bag.minimum = def.minimum;
-    });
-    inst._zod.check = (payload)=>{
-        const input = payload.value;
-        const length = input.length;
-        if (length >= def.minimum) return;
-        const origin = getLengthableOrigin(input);
-        payload.issues.push({
-            origin,
-            code: "too_small",
-            minimum: def.minimum,
-            inclusive: true,
-            input,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckLengthEquals = /*@__PURE__*/ $constructor("$ZodCheckLengthEquals", (inst, def)=>{
-    var _a;
-    $ZodCheck.init(inst, def);
-    (_a = inst._zod.def).when ?? (_a.when = (payload)=>{
-        const val = payload.value;
-        return !nullish(val) && void 0 !== val.length;
-    });
-    inst._zod.onattach.push((inst)=>{
-        const bag = inst._zod.bag;
-        bag.minimum = def.length;
-        bag.maximum = def.length;
-        bag.length = def.length;
-    });
-    inst._zod.check = (payload)=>{
-        const input = payload.value;
-        const length = input.length;
-        if (length === def.length) return;
-        const origin = getLengthableOrigin(input);
-        const tooBig = length > def.length;
-        payload.issues.push({
-            origin,
-            ...tooBig ? {
-                code: "too_big",
-                maximum: def.length
-            } : {
-                code: "too_small",
-                minimum: def.length
-            },
-            inclusive: true,
-            exact: true,
-            input: payload.value,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCheckStringFormat = /*@__PURE__*/ $constructor("$ZodCheckStringFormat", (inst, def)=>{
-    var _a, _b;
-    $ZodCheck.init(inst, def);
-    inst._zod.onattach.push((inst)=>{
-        const bag = inst._zod.bag;
-        bag.format = def.format;
-        if (def.pattern) {
-            bag.patterns ?? (bag.patterns = new Set());
-            bag.patterns.add(def.pattern);
-        }
-    });
-    if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload)=>{
-        def.pattern.lastIndex = 0;
-        if (def.pattern.test(payload.value)) return;
-        payload.issues.push({
-            origin: "string",
-            code: "invalid_format",
-            format: def.format,
-            input: payload.value,
-            ...def.pattern ? {
-                pattern: def.pattern.toString()
-            } : {},
-            inst,
-            continue: !def.abort
-        });
-    });
-    else (_b = inst._zod).check ?? (_b.check = ()=>{});
-});
-const $ZodCheckRegex = /*@__PURE__*/ $constructor("$ZodCheckRegex", (inst, def)=>{
-    $ZodCheckStringFormat.init(inst, def);
-    inst._zod.check = (payload)=>{
-        def.pattern.lastIndex = 0;
-        if (def.pattern.test(payload.value)) return;
-        payload.issues.push({
-            origin: "string",
-            code: "invalid_format",
-            format: "regex",
-            input: payload.value,
-            pattern: def.pattern.toString(),
-            inst,
-            continue: !def.abort
+    });
+    else (_b = inst._zod).check ?? (_b.check = ()=>{});
+});
+const $ZodCheckRegex = /*@__PURE__*/ $constructor("$ZodCheckRegex", (inst, def)=>{
+    $ZodCheckStringFormat.init(inst, def);
+    inst._zod.check = (payload)=>{
+        def.pattern.lastIndex = 0;
+        if (def.pattern.test(payload.value)) return;
+        payload.issues.push({
+            origin: "string",
+            code: "invalid_format",
+            format: "regex",
+            input: payload.value,
+            pattern: def.pattern.toString(),
+            inst,
+            continue: !def.abort
         });
     };
 });
@@ -1508,87 +672,260 @@ const $ZodCheckEndsWith = /*@__PURE__*/ $constructor("$ZodCheckEndsWith", (inst,
             continue: !def.abort
         });
     };
-});
-function handleCheckPropertyResult(result, payload, property) {
-    if (result.issues.length) payload.issues.push(...prefixIssues(property, result.issues));
-}
-const $ZodCheckProperty = /*@__PURE__*/ $constructor("$ZodCheckProperty", (inst, def)=>{
-    $ZodCheck.init(inst, def);
-    inst._zod.check = (payload)=>{
-        const result = def.schema._zod.run({
-            value: payload.value[def.property],
+});
+const $ZodCheckOverwrite = /*@__PURE__*/ $constructor("$ZodCheckOverwrite", (inst, def)=>{
+    $ZodCheck.init(inst, def);
+    inst._zod.check = (payload)=>{
+        payload.value = def.tx(payload.value);
+    };
+});
+class Doc {
+    constructor(args = []){
+        this.content = [];
+        this.indent = 0;
+        if (this) this.args = args;
+    }
+    indented(fn) {
+        this.indent += 1;
+        fn(this);
+        this.indent -= 1;
+    }
+    write(arg) {
+        if ("function" == typeof arg) {
+            arg(this, {
+                execution: "sync"
+            });
+            arg(this, {
+                execution: "async"
+            });
+            return;
+        }
+        const content = arg;
+        const lines = content.split("\n").filter((x)=>x);
+        const minIndent = Math.min(...lines.map((x)=>x.length - x.trimStart().length));
+        const dedented = lines.map((x)=>x.slice(minIndent)).map((x)=>" ".repeat(2 * this.indent) + x);
+        for (const line of dedented)this.content.push(line);
+    }
+    compile() {
+        const F = Function;
+        const args = this?.args;
+        const content = this?.content ?? [
+            ""
+        ];
+        const lines = [
+            ...content.map((x)=>`  ${x}`)
+        ];
+        return new F(...args, lines.join("\n"));
+    }
+}
+const errors_initializer = (inst, def)=>{
+    inst.name = "$ZodError";
+    Object.defineProperty(inst, "_zod", {
+        value: inst._zod,
+        enumerable: false
+    });
+    Object.defineProperty(inst, "issues", {
+        value: def,
+        enumerable: false
+    });
+    inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+    Object.defineProperty(inst, "toString", {
+        value: ()=>inst.message,
+        enumerable: false
+    });
+};
+const $ZodError = $constructor("$ZodError", errors_initializer);
+const $ZodRealError = $constructor("$ZodError", errors_initializer, {
+    Parent: Error
+});
+function flattenError(error, mapper = (issue)=>issue.message) {
+    const fieldErrors = {};
+    const formErrors = [];
+    for (const sub of error.issues)if (sub.path.length > 0) {
+        fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+        fieldErrors[sub.path[0]].push(mapper(sub));
+    } else formErrors.push(mapper(sub));
+    return {
+        formErrors,
+        fieldErrors
+    };
+}
+function formatError(error, mapper = (issue)=>issue.message) {
+    const fieldErrors = {
+        _errors: []
+    };
+    const processError = (error, path = [])=>{
+        for (const issue of error.issues)if ("invalid_union" === issue.code && issue.errors.length) issue.errors.map((issues)=>processError({
+                issues
+            }, [
+                ...path,
+                ...issue.path
+            ]));
+        else if ("invalid_key" === issue.code) processError({
+            issues: issue.issues
+        }, [
+            ...path,
+            ...issue.path
+        ]);
+        else if ("invalid_element" === issue.code) processError({
+            issues: issue.issues
+        }, [
+            ...path,
+            ...issue.path
+        ]);
+        else {
+            const fullpath = [
+                ...path,
+                ...issue.path
+            ];
+            if (0 === fullpath.length) fieldErrors._errors.push(mapper(issue));
+            else {
+                let curr = fieldErrors;
+                let i = 0;
+                while(i < fullpath.length){
+                    const el = fullpath[i];
+                    const terminal = i === fullpath.length - 1;
+                    if (terminal) {
+                        curr[el] = curr[el] || {
+                            _errors: []
+                        };
+                        curr[el]._errors.push(mapper(issue));
+                    } else curr[el] = curr[el] || {
+                        _errors: []
+                    };
+                    curr = curr[el];
+                    i++;
+                }
+            }
+        }
+    };
+    processError(error);
+    return fieldErrors;
+}
+const _parse = (_Err)=>(schema, value, _ctx, _params)=>{
+        const ctx = _ctx ? {
+            ..._ctx,
+            async: false
+        } : {
+            async: false
+        };
+        const result = schema._zod.run({
+            value,
+            issues: []
+        }, ctx);
+        if (result instanceof Promise) throw new $ZodAsyncError();
+        if (result.issues.length) {
+            const e = new (_params?.Err ?? _Err)(result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())));
+            captureStackTrace(e, _params?.callee);
+            throw e;
+        }
+        return result.value;
+    };
+const _parseAsync = (_Err)=>async (schema, value, _ctx, params)=>{
+        const ctx = _ctx ? {
+            ..._ctx,
+            async: true
+        } : {
+            async: true
+        };
+        let result = schema._zod.run({
+            value,
+            issues: []
+        }, ctx);
+        if (result instanceof Promise) result = await result;
+        if (result.issues.length) {
+            const e = new (params?.Err ?? _Err)(result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())));
+            captureStackTrace(e, params?.callee);
+            throw e;
+        }
+        return result.value;
+    };
+const _safeParse = (_Err)=>(schema, value, _ctx)=>{
+        const ctx = _ctx ? {
+            ..._ctx,
+            async: false
+        } : {
+            async: false
+        };
+        const result = schema._zod.run({
+            value,
             issues: []
-        }, {});
-        if (result instanceof Promise) return result.then((result)=>handleCheckPropertyResult(result, payload, def.property));
-        handleCheckPropertyResult(result, payload, def.property);
+        }, ctx);
+        if (result instanceof Promise) throw new $ZodAsyncError();
+        return result.issues.length ? {
+            success: false,
+            error: new (_Err ?? $ZodError)(result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())))
+        } : {
+            success: true,
+            data: result.value
+        };
     };
-});
-const $ZodCheckMimeType = /*@__PURE__*/ $constructor("$ZodCheckMimeType", (inst, def)=>{
-    $ZodCheck.init(inst, def);
-    const mimeSet = new Set(def.mime);
-    inst._zod.onattach.push((inst)=>{
-        inst._zod.bag.mime = def.mime;
-    });
-    inst._zod.check = (payload)=>{
-        if (mimeSet.has(payload.value.type)) return;
-        payload.issues.push({
-            code: "invalid_value",
-            values: def.mime,
-            input: payload.value.type,
-            inst,
-            continue: !def.abort
-        });
+const safeParse = /* @__PURE__*/ _safeParse($ZodRealError);
+const _safeParseAsync = (_Err)=>async (schema, value, _ctx)=>{
+        const ctx = _ctx ? {
+            ..._ctx,
+            async: true
+        } : {
+            async: true
+        };
+        let result = schema._zod.run({
+            value,
+            issues: []
+        }, ctx);
+        if (result instanceof Promise) result = await result;
+        return result.issues.length ? {
+            success: false,
+            error: new _Err(result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())))
+        } : {
+            success: true,
+            data: result.value
+        };
     };
-});
-const $ZodCheckOverwrite = /*@__PURE__*/ $constructor("$ZodCheckOverwrite", (inst, def)=>{
-    $ZodCheck.init(inst, def);
-    inst._zod.check = (payload)=>{
-        payload.value = def.tx(payload.value);
+const safeParseAsync = /* @__PURE__*/ _safeParseAsync($ZodRealError);
+const _encode = (_Err)=>(schema, value, _ctx)=>{
+        const ctx = _ctx ? {
+            ..._ctx,
+            direction: "backward"
+        } : {
+            direction: "backward"
+        };
+        return _parse(_Err)(schema, value, ctx);
     };
-});
-class Doc {
-    constructor(args = []){
-        this.content = [];
-        this.indent = 0;
-        if (this) this.args = args;
-    }
-    indented(fn) {
-        this.indent += 1;
-        fn(this);
-        this.indent -= 1;
-    }
-    write(arg) {
-        if ("function" == typeof arg) {
-            arg(this, {
-                execution: "sync"
-            });
-            arg(this, {
-                execution: "async"
-            });
-            return;
-        }
-        const content = arg;
-        const lines = content.split("\n").filter((x)=>x);
-        const minIndent = Math.min(...lines.map((x)=>x.length - x.trimStart().length));
-        const dedented = lines.map((x)=>x.slice(minIndent)).map((x)=>" ".repeat(2 * this.indent) + x);
-        for (const line of dedented)this.content.push(line);
-    }
-    compile() {
-        const F = Function;
-        const args = this?.args;
-        const content = this?.content ?? [
-            ""
-        ];
-        const lines = [
-            ...content.map((x)=>`  ${x}`)
-        ];
-        return new F(...args, lines.join("\n"));
-    }
-}
+const _decode = (_Err)=>(schema, value, _ctx)=>_parse(_Err)(schema, value, _ctx);
+const _encodeAsync = (_Err)=>async (schema, value, _ctx)=>{
+        const ctx = _ctx ? {
+            ..._ctx,
+            direction: "backward"
+        } : {
+            direction: "backward"
+        };
+        return _parseAsync(_Err)(schema, value, ctx);
+    };
+const _decodeAsync = (_Err)=>async (schema, value, _ctx)=>_parseAsync(_Err)(schema, value, _ctx);
+const _safeEncode = (_Err)=>(schema, value, _ctx)=>{
+        const ctx = _ctx ? {
+            ..._ctx,
+            direction: "backward"
+        } : {
+            direction: "backward"
+        };
+        return _safeParse(_Err)(schema, value, ctx);
+    };
+const _safeDecode = (_Err)=>(schema, value, _ctx)=>_safeParse(_Err)(schema, value, _ctx);
+const _safeEncodeAsync = (_Err)=>async (schema, value, _ctx)=>{
+        const ctx = _ctx ? {
+            ..._ctx,
+            direction: "backward"
+        } : {
+            direction: "backward"
+        };
+        return _safeParseAsync(_Err)(schema, value, ctx);
+    };
+const _safeDecodeAsync = (_Err)=>async (schema, value, _ctx)=>_safeParseAsync(_Err)(schema, value, _ctx);
 const versions_version = {
     major: 4,
-    minor: 3,
-    patch: 6
+    minor: 4,
+    patch: 3
 };
 const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def)=>{
     var _a;
@@ -1612,6 +949,7 @@ const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def)=>{
             let asyncResult;
             for (const ch of checks){
                 if (ch._zod.def.when) {
+                    if (explicitlyAborted(payload)) continue;
                     const shouldRun = ch._zod.def.when(payload);
                     if (!shouldRun) continue;
                 } else if (isAborted) continue;
@@ -1741,6 +1079,16 @@ const $ZodURL = /*@__PURE__*/ $constructor("$ZodURL", (inst, def)=>{
     inst._zod.check = (payload)=>{
         try {
             const trimmed = payload.value.trim();
+            if (!def.normalize && def.protocol?.source === httpProtocol.source) {
+                if (!/^https?:\/\//i.test(trimmed)) return void payload.issues.push({
+                    code: "invalid_format",
+                    format: "url",
+                    note: "Invalid URL format",
+                    input: payload.value,
+                    inst,
+                    continue: !def.abort
+                });
+            }
             const url = new URL(trimmed);
             if (def.hostname) {
                 def.hostname.lastIndex = 0;
@@ -1847,11 +1195,6 @@ const $ZodIPv6 = /*@__PURE__*/ $constructor("$ZodIPv6", (inst, def)=>{
         }
     };
 });
-const $ZodMAC = /*@__PURE__*/ $constructor("$ZodMAC", (inst, def)=>{
-    def.pattern ?? (def.pattern = mac(def.delimiter));
-    $ZodStringFormat.init(inst, def);
-    inst._zod.bag.format = "mac";
-});
 const $ZodCIDRv4 = /*@__PURE__*/ $constructor("$ZodCIDRv4", (inst, def)=>{
     def.pattern ?? (def.pattern = cidrv4);
     $ZodStringFormat.init(inst, def);
@@ -1882,6 +1225,7 @@ const $ZodCIDRv6 = /*@__PURE__*/ $constructor("$ZodCIDRv6", (inst, def)=>{
 });
 function isValidBase64(data) {
     if ("" === data) return true;
+    if (/\s/.test(data)) return false;
     if (data.length % 4 !== 0) return false;
     try {
         atob(data);
@@ -1931,156 +1275,44 @@ const $ZodE164 = /*@__PURE__*/ $constructor("$ZodE164", (inst, def)=>{
     $ZodStringFormat.init(inst, def);
 });
 function isValidJWT(token, algorithm = null) {
-    try {
-        const tokensParts = token.split(".");
-        if (3 !== tokensParts.length) return false;
-        const [header] = tokensParts;
-        if (!header) return false;
-        const parsedHeader = JSON.parse(atob(header));
-        if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
-        if (!parsedHeader.alg) return false;
-        if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;
-        return true;
-    } catch  {
-        return false;
-    }
-}
-const $ZodJWT = /*@__PURE__*/ $constructor("$ZodJWT", (inst, def)=>{
-    $ZodStringFormat.init(inst, def);
-    inst._zod.check = (payload)=>{
-        if (isValidJWT(payload.value, def.alg)) return;
-        payload.issues.push({
-            code: "invalid_format",
-            format: "jwt",
-            input: payload.value,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodCustomStringFormat = /*@__PURE__*/ $constructor("$ZodCustomStringFormat", (inst, def)=>{
-    $ZodStringFormat.init(inst, def);
-    inst._zod.check = (payload)=>{
-        if (def.fn(payload.value)) return;
-        payload.issues.push({
-            code: "invalid_format",
-            format: def.format,
-            input: payload.value,
-            inst,
-            continue: !def.abort
-        });
-    };
-});
-const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.pattern = inst._zod.bag.pattern ?? regexes_number;
-    inst._zod.parse = (payload, _ctx)=>{
-        if (def.coerce) try {
-            payload.value = Number(payload.value);
-        } catch (_) {}
-        const input = payload.value;
-        if ("number" == typeof input && !Number.isNaN(input) && Number.isFinite(input)) return payload;
-        const received = "number" == typeof input ? Number.isNaN(input) ? "NaN" : Number.isFinite(input) ? void 0 : "Infinity" : void 0;
-        payload.issues.push({
-            expected: "number",
-            code: "invalid_type",
-            input,
-            inst,
-            ...received ? {
-                received
-            } : {}
-        });
-        return payload;
-    };
-});
-const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumberFormat", (inst, def)=>{
-    $ZodCheckNumberFormat.init(inst, def);
-    $ZodNumber.init(inst, def);
-});
-const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.pattern = regexes_boolean;
-    inst._zod.parse = (payload, _ctx)=>{
-        if (def.coerce) try {
-            payload.value = Boolean(payload.value);
-        } catch (_) {}
-        const input = payload.value;
-        if ("boolean" == typeof input) return payload;
-        payload.issues.push({
-            expected: "boolean",
-            code: "invalid_type",
-            input,
-            inst
-        });
-        return payload;
-    };
-});
-const $ZodBigInt = /*@__PURE__*/ $constructor("$ZodBigInt", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.pattern = bigint;
-    inst._zod.parse = (payload, _ctx)=>{
-        if (def.coerce) try {
-            payload.value = BigInt(payload.value);
-        } catch (_) {}
-        if ("bigint" == typeof payload.value) return payload;
-        payload.issues.push({
-            expected: "bigint",
-            code: "invalid_type",
-            input: payload.value,
-            inst
-        });
-        return payload;
-    };
-});
-const $ZodBigIntFormat = /*@__PURE__*/ $constructor("$ZodBigIntFormat", (inst, def)=>{
-    $ZodCheckBigIntFormat.init(inst, def);
-    $ZodBigInt.init(inst, def);
-});
-const $ZodSymbol = /*@__PURE__*/ $constructor("$ZodSymbol", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload, _ctx)=>{
-        const input = payload.value;
-        if ("symbol" == typeof input) return payload;
-        payload.issues.push({
-            expected: "symbol",
-            code: "invalid_type",
-            input,
-            inst
-        });
-        return payload;
-    };
-});
-const $ZodUndefined = /*@__PURE__*/ $constructor("$ZodUndefined", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.pattern = _undefined;
-    inst._zod.values = new Set([
-        void 0
-    ]);
-    inst._zod.optin = "optional";
-    inst._zod.optout = "optional";
-    inst._zod.parse = (payload, _ctx)=>{
-        const input = payload.value;
-        if (void 0 === input) return payload;
+    try {
+        const tokensParts = token.split(".");
+        if (3 !== tokensParts.length) return false;
+        const [header] = tokensParts;
+        if (!header) return false;
+        const parsedHeader = JSON.parse(atob(header));
+        if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
+        if (!parsedHeader.alg) return false;
+        if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;
+        return true;
+    } catch  {
+        return false;
+    }
+}
+const $ZodJWT = /*@__PURE__*/ $constructor("$ZodJWT", (inst, def)=>{
+    $ZodStringFormat.init(inst, def);
+    inst._zod.check = (payload)=>{
+        if (isValidJWT(payload.value, def.alg)) return;
         payload.issues.push({
-            expected: "undefined",
-            code: "invalid_type",
-            input,
-            inst
+            code: "invalid_format",
+            format: "jwt",
+            input: payload.value,
+            inst,
+            continue: !def.abort
         });
-        return payload;
     };
 });
-const $ZodNull = /*@__PURE__*/ $constructor("$ZodNull", (inst, def)=>{
+const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def)=>{
     $ZodType.init(inst, def);
-    inst._zod.pattern = _null;
-    inst._zod.values = new Set([
-        null
-    ]);
+    inst._zod.pattern = regexes_boolean;
     inst._zod.parse = (payload, _ctx)=>{
+        if (def.coerce) try {
+            payload.value = Boolean(payload.value);
+        } catch (_) {}
         const input = payload.value;
-        if (null === input) return payload;
+        if ("boolean" == typeof input) return payload;
         payload.issues.push({
-            expected: "null",
+            expected: "boolean",
             code: "invalid_type",
             input,
             inst
@@ -2088,10 +1320,6 @@ const $ZodNull = /*@__PURE__*/ $constructor("$ZodNull", (inst, def)=>{
         return payload;
     };
 });
-const $ZodAny = /*@__PURE__*/ $constructor("$ZodAny", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload)=>payload;
-});
 const $ZodUnknown = /*@__PURE__*/ $constructor("$ZodUnknown", (inst, def)=>{
     $ZodType.init(inst, def);
     inst._zod.parse = (payload)=>payload;
@@ -2108,42 +1336,6 @@ const $ZodNever = /*@__PURE__*/ $constructor("$ZodNever", (inst, def)=>{
         return payload;
     };
 });
-const $ZodVoid = /*@__PURE__*/ $constructor("$ZodVoid", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload, _ctx)=>{
-        const input = payload.value;
-        if (void 0 === input) return payload;
-        payload.issues.push({
-            expected: "void",
-            code: "invalid_type",
-            input,
-            inst
-        });
-        return payload;
-    };
-});
-const $ZodDate = /*@__PURE__*/ $constructor("$ZodDate", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload, _ctx)=>{
-        if (def.coerce) try {
-            payload.value = new Date(payload.value);
-        } catch (_err) {}
-        const input = payload.value;
-        const isDate = input instanceof Date;
-        const isValidDate = isDate && !Number.isNaN(input.getTime());
-        if (isValidDate) return payload;
-        payload.issues.push({
-            expected: "date",
-            code: "invalid_type",
-            input,
-            ...isDate ? {
-                received: "Invalid Date"
-            } : {},
-            inst
-        });
-        return payload;
-    };
-});
 function handleArrayResult(result, final, index) {
     if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
     final.value[index] = result.value;
@@ -2176,13 +1368,25 @@ const $ZodArray = /*@__PURE__*/ $constructor("$ZodArray", (inst, def)=>{
         return payload;
     };
 });
-function handlePropertyResult(result, final, key, input, isOptionalOut) {
+function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
+    const isPresent = key in input;
     if (result.issues.length) {
-        if (isOptionalOut && !(key in input)) return;
+        if (isOptionalIn && isOptionalOut && !isPresent) return;
         final.issues.push(...prefixIssues(key, result.issues));
     }
+    if (!isPresent && !isOptionalIn) {
+        if (!result.issues.length) final.issues.push({
+            code: "invalid_type",
+            expected: "nonoptional",
+            input: void 0,
+            path: [
+                key
+            ]
+        });
+        return;
+    }
     if (void 0 === result.value) {
-        if (key in input) final.value[key] = void 0;
+        if (isPresent) final.value[key] = void 0;
     } else final.value[key] = result.value;
 }
 function normalizeDef(def) {
@@ -2202,8 +1406,10 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
     const keySet = def.keySet;
     const _catchall = def.catchall._zod;
     const t = _catchall.def.type;
+    const isOptionalIn = "optional" === _catchall.optin;
     const isOptionalOut = "optional" === _catchall.optout;
     for(const key in input){
+        if ("__proto__" === key) continue;
         if (keySet.has(key)) continue;
         if ("never" === t) {
             unrecognized.push(key);
@@ -2213,8 +1419,8 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
             value: input[key],
             issues: []
         }, ctx);
-        if (r instanceof Promise) proms.push(r.then((r)=>handlePropertyResult(r, payload, key, input, isOptionalOut)));
-        else handlePropertyResult(r, payload, key, input, isOptionalOut);
+        if (r instanceof Promise) proms.push(r.then((r)=>handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut)));
+        else handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
     }
     if (unrecognized.length) payload.issues.push({
         code: "unrecognized_keys",
@@ -2275,13 +1481,14 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def)=>{
         const shape = value.shape;
         for (const key of value.keys){
             const el = shape[key];
+            const isOptionalIn = "optional" === el._zod.optin;
             const isOptionalOut = "optional" === el._zod.optout;
             const r = el._zod.run({
                 value: input[key],
                 issues: []
             }, ctx);
-            if (r instanceof Promise) proms.push(r.then((r)=>handlePropertyResult(r, payload, key, input, isOptionalOut)));
-            else handlePropertyResult(r, payload, key, input, isOptionalOut);
+            if (r instanceof Promise) proms.push(r.then((r)=>handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut)));
+            else handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
         }
         if (!catchall) return proms.length ? Promise.all(proms).then(()=>payload) : payload;
         return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
@@ -2311,9 +1518,10 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def)=>{
             const id = ids[key];
             const k = esc(key);
             const schema = shape[key];
+            const isOptionalIn = schema?._zod?.optin === "optional";
             const isOptionalOut = schema?._zod?.optout === "optional";
             doc.write(`const ${id} = ${parseStr(key)};`);
-            if (isOptionalOut) doc.write(`
+            if (isOptionalIn && isOptionalOut) doc.write(`
         if (${id}.issues.length) {
           if (${k} in input) {
             payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
@@ -2332,7 +1540,7 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def)=>{
         }
         
       `);
-            else doc.write(`
+            else if (isOptionalIn) doc.write(`
         if (${id}.issues.length) {
           payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
             ...iss,
@@ -2348,6 +1556,32 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def)=>{
           newResult[${k}] = ${id}.value;
         }
         
+      `);
+            else doc.write(`
+        const ${id}_present = ${k} in input;
+        if (${id}.issues.length) {
+          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${k}, ...iss.path] : [${k}]
+          })));
+        }
+        if (!${id}_present && !${id}.issues.length) {
+          payload.issues.push({
+            code: "invalid_type",
+            expected: "nonoptional",
+            input: undefined,
+            path: [${k}]
+          });
+        }
+
+        if (${id}_present) {
+          if (${id}.value === undefined) {
+            newResult[${k}] = undefined;
+          } else {
+            newResult[${k}] = ${id}.value;
+          }
+        }
+
       `);
         }
         doc.write("payload.value = newResult;");
@@ -2414,10 +1648,9 @@ const $ZodUnion = /*@__PURE__*/ $constructor("$ZodUnion", (inst, def)=>{
             return new RegExp(`^(${patterns.map((p)=>cleanRegex(p.source)).join("|")})$`);
         }
     });
-    const single = 1 === def.options.length;
-    const first = def.options[0]._zod.run;
+    const first = 1 === def.options.length ? def.options[0]._zod.run : null;
     inst._zod.parse = (payload, ctx)=>{
-        if (single) return first(payload, ctx);
+        if (first) return first(payload, ctx);
         let async = false;
         const results = [];
         for (const option of def.options){
@@ -2437,107 +1670,6 @@ const $ZodUnion = /*@__PURE__*/ $constructor("$ZodUnion", (inst, def)=>{
         return Promise.all(results).then((results)=>handleUnionResults(results, payload, inst, ctx));
     };
 });
-function handleExclusiveUnionResults(results, final, inst, ctx) {
-    const successes = results.filter((r)=>0 === r.issues.length);
-    if (1 === successes.length) {
-        final.value = successes[0].value;
-        return final;
-    }
-    if (0 === successes.length) final.issues.push({
-        code: "invalid_union",
-        input: final.value,
-        inst,
-        errors: results.map((result)=>result.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())))
-    });
-    else final.issues.push({
-        code: "invalid_union",
-        input: final.value,
-        inst,
-        errors: [],
-        inclusive: false
-    });
-    return final;
-}
-const $ZodXor = /*@__PURE__*/ $constructor("$ZodXor", (inst, def)=>{
-    $ZodUnion.init(inst, def);
-    def.inclusive = false;
-    const single = 1 === def.options.length;
-    const first = def.options[0]._zod.run;
-    inst._zod.parse = (payload, ctx)=>{
-        if (single) return first(payload, ctx);
-        let async = false;
-        const results = [];
-        for (const option of def.options){
-            const result = option._zod.run({
-                value: payload.value,
-                issues: []
-            }, ctx);
-            if (result instanceof Promise) {
-                results.push(result);
-                async = true;
-            } else results.push(result);
-        }
-        if (!async) return handleExclusiveUnionResults(results, payload, inst, ctx);
-        return Promise.all(results).then((results)=>handleExclusiveUnionResults(results, payload, inst, ctx));
-    };
-});
-const $ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("$ZodDiscriminatedUnion", (inst, def)=>{
-    def.inclusive = false;
-    $ZodUnion.init(inst, def);
-    const _super = inst._zod.parse;
-    defineLazy(inst._zod, "propValues", ()=>{
-        const propValues = {};
-        for (const option of def.options){
-            const pv = option._zod.propValues;
-            if (!pv || 0 === Object.keys(pv).length) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
-            for (const [k, v] of Object.entries(pv)){
-                if (!propValues[k]) propValues[k] = new Set();
-                for (const val of v)propValues[k].add(val);
-            }
-        }
-        return propValues;
-    });
-    const disc = cached(()=>{
-        const opts = def.options;
-        const map = new Map();
-        for (const o of opts){
-            const values = o._zod.propValues?.[def.discriminator];
-            if (!values || 0 === values.size) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
-            for (const v of values){
-                if (map.has(v)) throw new Error(`Duplicate discriminator value "${String(v)}"`);
-                map.set(v, o);
-            }
-        }
-        return map;
-    });
-    inst._zod.parse = (payload, ctx)=>{
-        const input = payload.value;
-        if (!util_isObject(input)) {
-            payload.issues.push({
-                code: "invalid_type",
-                expected: "object",
-                input,
-                inst
-            });
-            return payload;
-        }
-        const opt = disc.value.get(input?.[def.discriminator]);
-        if (opt) return opt._zod.run(payload, ctx);
-        if (def.unionFallback) return _super(payload, ctx);
-        payload.issues.push({
-            code: "invalid_union",
-            errors: [],
-            note: "No matching discriminator",
-            discriminator: def.discriminator,
-            input,
-            path: [
-                def.discriminator
-            ],
-            inst
-        });
-        return payload;
-    };
-});
 const $ZodIntersection = /*@__PURE__*/ $constructor("$ZodIntersection", (inst, def)=>{
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx)=>{
@@ -2638,268 +1770,14 @@ function handleIntersectionResults(result, left, right) {
         ...unrecKeys
     ].filter(([, f])=>f.l && f.r).map(([k])=>k);
     if (bothKeys.length && unrecIssue) result.issues.push({
-        ...unrecIssue,
-        keys: bothKeys
-    });
-    if (aborted(result)) return result;
-    const merged = mergeValues(left.value, right.value);
-    if (!merged.valid) throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
-    result.value = merged.data;
-    return result;
-}
-const $ZodTuple = /*@__PURE__*/ $constructor("$ZodTuple", (inst, def)=>{
-    $ZodType.init(inst, def);
-    const items = def.items;
-    inst._zod.parse = (payload, ctx)=>{
-        const input = payload.value;
-        if (!Array.isArray(input)) {
-            payload.issues.push({
-                input,
-                inst,
-                expected: "tuple",
-                code: "invalid_type"
-            });
-            return payload;
-        }
-        payload.value = [];
-        const proms = [];
-        const reversedIndex = [
-            ...items
-        ].reverse().findIndex((item)=>"optional" !== item._zod.optin);
-        const optStart = -1 === reversedIndex ? 0 : items.length - reversedIndex;
-        if (!def.rest) {
-            const tooBig = input.length > items.length;
-            const tooSmall = input.length < optStart - 1;
-            if (tooBig || tooSmall) {
-                payload.issues.push({
-                    ...tooBig ? {
-                        code: "too_big",
-                        maximum: items.length,
-                        inclusive: true
-                    } : {
-                        code: "too_small",
-                        minimum: items.length
-                    },
-                    input,
-                    inst,
-                    origin: "array"
-                });
-                return payload;
-            }
-        }
-        let i = -1;
-        for (const item of items){
-            i++;
-            if (i >= input.length) {
-                if (i >= optStart) continue;
-            }
-            const result = item._zod.run({
-                value: input[i],
-                issues: []
-            }, ctx);
-            if (result instanceof Promise) proms.push(result.then((result)=>handleTupleResult(result, payload, i)));
-            else handleTupleResult(result, payload, i);
-        }
-        if (def.rest) {
-            const rest = input.slice(items.length);
-            for (const el of rest){
-                i++;
-                const result = def.rest._zod.run({
-                    value: el,
-                    issues: []
-                }, ctx);
-                if (result instanceof Promise) proms.push(result.then((result)=>handleTupleResult(result, payload, i)));
-                else handleTupleResult(result, payload, i);
-            }
-        }
-        if (proms.length) return Promise.all(proms).then(()=>payload);
-        return payload;
-    };
-});
-function handleTupleResult(result, final, index) {
-    if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
-    final.value[index] = result.value;
-}
-const $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload, ctx)=>{
-        const input = payload.value;
-        if (!isPlainObject(input)) {
-            payload.issues.push({
-                expected: "record",
-                code: "invalid_type",
-                input,
-                inst
-            });
-            return payload;
-        }
-        const proms = [];
-        const values = def.keyType._zod.values;
-        if (values) {
-            payload.value = {};
-            const recordKeys = new Set();
-            for (const key of values)if ("string" == typeof key || "number" == typeof key || "symbol" == typeof key) {
-                recordKeys.add("number" == typeof key ? key.toString() : key);
-                const result = def.valueType._zod.run({
-                    value: input[key],
-                    issues: []
-                }, ctx);
-                if (result instanceof Promise) proms.push(result.then((result)=>{
-                    if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
-                    payload.value[key] = result.value;
-                }));
-                else {
-                    if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
-                    payload.value[key] = result.value;
-                }
-            }
-            let unrecognized;
-            for(const key in input)if (!recordKeys.has(key)) {
-                unrecognized = unrecognized ?? [];
-                unrecognized.push(key);
-            }
-            if (unrecognized && unrecognized.length > 0) payload.issues.push({
-                code: "unrecognized_keys",
-                input,
-                inst,
-                keys: unrecognized
-            });
-        } else {
-            payload.value = {};
-            for (const key of Reflect.ownKeys(input)){
-                if ("__proto__" === key) continue;
-                let keyResult = def.keyType._zod.run({
-                    value: key,
-                    issues: []
-                }, ctx);
-                if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
-                const checkNumericKey = "string" == typeof key && regexes_number.test(key) && keyResult.issues.length;
-                if (checkNumericKey) {
-                    const retryResult = def.keyType._zod.run({
-                        value: Number(key),
-                        issues: []
-                    }, ctx);
-                    if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
-                    if (0 === retryResult.issues.length) keyResult = retryResult;
-                }
-                if (keyResult.issues.length) {
-                    if ("loose" === def.mode) payload.value[key] = input[key];
-                    else payload.issues.push({
-                        code: "invalid_key",
-                        origin: "record",
-                        issues: keyResult.issues.map((iss)=>finalizeIssue(iss, ctx, core_config())),
-                        input: key,
-                        path: [
-                            key
-                        ],
-                        inst
-                    });
-                    continue;
-                }
-                const result = def.valueType._zod.run({
-                    value: input[key],
-                    issues: []
-                }, ctx);
-                if (result instanceof Promise) proms.push(result.then((result)=>{
-                    if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
-                    payload.value[keyResult.value] = result.value;
-                }));
-                else {
-                    if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
-                    payload.value[keyResult.value] = result.value;
-                }
-            }
-        }
-        if (proms.length) return Promise.all(proms).then(()=>payload);
-        return payload;
-    };
-});
-const $ZodMap = /*@__PURE__*/ $constructor("$ZodMap", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload, ctx)=>{
-        const input = payload.value;
-        if (!(input instanceof Map)) {
-            payload.issues.push({
-                expected: "map",
-                code: "invalid_type",
-                input,
-                inst
-            });
-            return payload;
-        }
-        const proms = [];
-        payload.value = new Map();
-        for (const [key, value] of input){
-            const keyResult = def.keyType._zod.run({
-                value: key,
-                issues: []
-            }, ctx);
-            const valueResult = def.valueType._zod.run({
-                value: value,
-                issues: []
-            }, ctx);
-            if (keyResult instanceof Promise || valueResult instanceof Promise) proms.push(Promise.all([
-                keyResult,
-                valueResult
-            ]).then(([keyResult, valueResult])=>{
-                handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
-            }));
-            else handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
-        }
-        if (proms.length) return Promise.all(proms).then(()=>payload);
-        return payload;
-    };
-});
-function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
-    if (keyResult.issues.length) if (propertyKeyTypes.has(typeof key)) final.issues.push(...prefixIssues(key, keyResult.issues));
-    else final.issues.push({
-        code: "invalid_key",
-        origin: "map",
-        input,
-        inst,
-        issues: keyResult.issues.map((iss)=>finalizeIssue(iss, ctx, core_config()))
-    });
-    if (valueResult.issues.length) if (propertyKeyTypes.has(typeof key)) final.issues.push(...prefixIssues(key, valueResult.issues));
-    else final.issues.push({
-        origin: "map",
-        code: "invalid_element",
-        input,
-        inst,
-        key: key,
-        issues: valueResult.issues.map((iss)=>finalizeIssue(iss, ctx, core_config()))
-    });
-    final.value.set(keyResult.value, valueResult.value);
-}
-const $ZodSet = /*@__PURE__*/ $constructor("$ZodSet", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload, ctx)=>{
-        const input = payload.value;
-        if (!(input instanceof Set)) {
-            payload.issues.push({
-                input,
-                inst,
-                expected: "set",
-                code: "invalid_type"
-            });
-            return payload;
-        }
-        const proms = [];
-        payload.value = new Set();
-        for (const item of input){
-            const result = def.valueType._zod.run({
-                value: item,
-                issues: []
-            }, ctx);
-            if (result instanceof Promise) proms.push(result.then((result)=>handleSetResult(result, payload)));
-            else handleSetResult(result, payload);
-        }
-        if (proms.length) return Promise.all(proms).then(()=>payload);
-        return payload;
-    };
-});
-function handleSetResult(result, final) {
-    if (result.issues.length) final.issues.push(...result.issues);
-    final.value.add(result.value);
+        ...unrecIssue,
+        keys: bothKeys
+    });
+    if (aborted(result)) return result;
+    const merged = mergeValues(left.value, right.value);
+    if (!merged.valid) throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
+    result.value = merged.data;
+    return result;
 }
 const $ZodEnum = /*@__PURE__*/ $constructor("$ZodEnum", (inst, def)=>{
     $ZodType.init(inst, def);
@@ -2919,40 +1797,9 @@ const $ZodEnum = /*@__PURE__*/ $constructor("$ZodEnum", (inst, def)=>{
         return payload;
     };
 });
-const $ZodLiteral = /*@__PURE__*/ $constructor("$ZodLiteral", (inst, def)=>{
-    $ZodType.init(inst, def);
-    if (0 === def.values.length) throw new Error("Cannot create literal schema with no valid values");
-    const values = new Set(def.values);
-    inst._zod.values = values;
-    inst._zod.pattern = new RegExp(`^(${def.values.map((o)=>"string" == typeof o ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
-    inst._zod.parse = (payload, _ctx)=>{
-        const input = payload.value;
-        if (values.has(input)) return payload;
-        payload.issues.push({
-            code: "invalid_value",
-            values: def.values,
-            input,
-            inst
-        });
-        return payload;
-    };
-});
-const $ZodFile = /*@__PURE__*/ $constructor("$ZodFile", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload, _ctx)=>{
-        const input = payload.value;
-        if (input instanceof File) return payload;
-        payload.issues.push({
-            expected: "file",
-            code: "invalid_type",
-            input,
-            inst
-        });
-        return payload;
-    };
-});
 const $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def)=>{
     $ZodType.init(inst, def);
+    inst._zod.optin = "optional";
     inst._zod.parse = (payload, ctx)=>{
         if ("backward" === ctx.direction) throw new $ZodEncodeError(inst.constructor.name);
         const _out = def.transform(payload.value, payload);
@@ -2960,16 +1807,18 @@ const $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def)=>{
             const output = _out instanceof Promise ? _out : Promise.resolve(_out);
             return output.then((output)=>{
                 payload.value = output;
+                payload.fallback = true;
                 return payload;
             });
         }
         if (_out instanceof Promise) throw new $ZodAsyncError();
         payload.value = _out;
+        payload.fallback = true;
         return payload;
     };
 });
 function handleOptionalResult(result, input) {
-    if (result.issues.length && void 0 === input) return {
+    if (void 0 === input && (result.issues.length || result.fallback)) return {
         issues: [],
         value: void 0
     };
@@ -2989,9 +1838,10 @@ const $ZodOptional = /*@__PURE__*/ $constructor("$ZodOptional", (inst, def)=>{
     });
     inst._zod.parse = (payload, ctx)=>{
         if ("optional" === def.innerType._zod.optin) {
+            const input = payload.value;
             const result = def.innerType._zod.run(payload, ctx);
-            if (result instanceof Promise) return result.then((r)=>handleOptionalResult(r, payload.value));
-            return handleOptionalResult(result, payload.value);
+            if (result instanceof Promise) return result.then((r)=>handleOptionalResult(r, input));
+            return handleOptionalResult(result, input);
         }
         if (void 0 === payload.value) return payload;
         return def.innerType._zod.run(payload, ctx);
@@ -3072,22 +1922,9 @@ function handleNonOptionalResult(payload, inst) {
     });
     return payload;
 }
-const $ZodSuccess = /*@__PURE__*/ $constructor("$ZodSuccess", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload, ctx)=>{
-        if ("backward" === ctx.direction) throw new $ZodEncodeError("ZodSuccess");
-        const result = def.innerType._zod.run(payload, ctx);
-        if (result instanceof Promise) return result.then((result)=>{
-            payload.value = 0 === result.issues.length;
-            return payload;
-        });
-        payload.value = 0 === result.issues.length;
-        return payload;
-    };
-});
 const $ZodCatch = /*@__PURE__*/ $constructor("$ZodCatch", (inst, def)=>{
     $ZodType.init(inst, def);
-    defineLazy(inst._zod, "optin", ()=>def.innerType._zod.optin);
+    inst._zod.optin = "optional";
     defineLazy(inst._zod, "optout", ()=>def.innerType._zod.optout);
     defineLazy(inst._zod, "values", ()=>def.innerType._zod.values);
     inst._zod.parse = (payload, ctx)=>{
@@ -3104,6 +1941,7 @@ const $ZodCatch = /*@__PURE__*/ $constructor("$ZodCatch", (inst, def)=>{
                     input: payload.value
                 });
                 payload.issues = [];
+                payload.fallback = true;
             }
             return payload;
         });
@@ -3117,22 +1955,11 @@ const $ZodCatch = /*@__PURE__*/ $constructor("$ZodCatch", (inst, def)=>{
                 input: payload.value
             });
             payload.issues = [];
+            payload.fallback = true;
         }
         return payload;
     };
 });
-const $ZodNaN = /*@__PURE__*/ $constructor("$ZodNaN", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload, _ctx)=>{
-        if ("number" != typeof payload.value || !Number.isNaN(payload.value)) payload.issues.push({
-            input: payload.value,
-            inst,
-            expected: "nan",
-            code: "invalid_type"
-        });
-        return payload;
-    };
-});
 const $ZodPipe = /*@__PURE__*/ $constructor("$ZodPipe", (inst, def)=>{
     $ZodType.init(inst, def);
     defineLazy(inst._zod, "values", ()=>def.in._zod.values);
@@ -3157,54 +1984,8 @@ function handlePipeResult(left, next, ctx) {
     }
     return next._zod.run({
         value: left.value,
-        issues: left.issues
-    }, ctx);
-}
-const $ZodCodec = /*@__PURE__*/ $constructor("$ZodCodec", (inst, def)=>{
-    $ZodType.init(inst, def);
-    defineLazy(inst._zod, "values", ()=>def.in._zod.values);
-    defineLazy(inst._zod, "optin", ()=>def.in._zod.optin);
-    defineLazy(inst._zod, "optout", ()=>def.out._zod.optout);
-    defineLazy(inst._zod, "propValues", ()=>def.in._zod.propValues);
-    inst._zod.parse = (payload, ctx)=>{
-        const direction = ctx.direction || "forward";
-        if ("forward" === direction) {
-            const left = def.in._zod.run(payload, ctx);
-            if (left instanceof Promise) return left.then((left)=>handleCodecAResult(left, def, ctx));
-            return handleCodecAResult(left, def, ctx);
-        }
-        {
-            const right = def.out._zod.run(payload, ctx);
-            if (right instanceof Promise) return right.then((right)=>handleCodecAResult(right, def, ctx));
-            return handleCodecAResult(right, def, ctx);
-        }
-    };
-});
-function handleCodecAResult(result, def, ctx) {
-    if (result.issues.length) {
-        result.aborted = true;
-        return result;
-    }
-    const direction = ctx.direction || "forward";
-    if ("forward" === direction) {
-        const transformed = def.transform(result.value, result);
-        if (transformed instanceof Promise) return transformed.then((value)=>handleCodecTxResult(result, value, def.out, ctx));
-        return handleCodecTxResult(result, transformed, def.out, ctx);
-    }
-    {
-        const transformed = def.reverseTransform(result.value, result);
-        if (transformed instanceof Promise) return transformed.then((value)=>handleCodecTxResult(result, value, def.in, ctx));
-        return handleCodecTxResult(result, transformed, def.in, ctx);
-    }
-}
-function handleCodecTxResult(left, value, nextSchema, ctx) {
-    if (left.issues.length) {
-        left.aborted = true;
-        return left;
-    }
-    return nextSchema._zod.run({
-        value,
-        issues: left.issues
+        issues: left.issues,
+        fallback: left.fallback
     }, ctx);
 }
 const $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def)=>{
@@ -3224,125 +2005,6 @@ function handleReadonlyResult(payload) {
     payload.value = Object.freeze(payload.value);
     return payload;
 }
-const $ZodTemplateLiteral = /*@__PURE__*/ $constructor("$ZodTemplateLiteral", (inst, def)=>{
-    $ZodType.init(inst, def);
-    const regexParts = [];
-    for (const part of def.parts)if ("object" == typeof part && null !== part) {
-        if (!part._zod.pattern) throw new Error(`Invalid template literal part, no pattern found: ${[
-            ...part._zod.traits
-        ].shift()}`);
-        const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
-        if (!source) throw new Error(`Invalid template literal part: ${part._zod.traits}`);
-        const start = source.startsWith("^") ? 1 : 0;
-        const end = source.endsWith("$") ? source.length - 1 : source.length;
-        regexParts.push(source.slice(start, end));
-    } else if (null === part || primitiveTypes.has(typeof part)) regexParts.push(escapeRegex(`${part}`));
-    else throw new Error(`Invalid template literal part: ${part}`);
-    inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
-    inst._zod.parse = (payload, _ctx)=>{
-        if ("string" != typeof payload.value) {
-            payload.issues.push({
-                input: payload.value,
-                inst,
-                expected: "string",
-                code: "invalid_type"
-            });
-            return payload;
-        }
-        inst._zod.pattern.lastIndex = 0;
-        if (!inst._zod.pattern.test(payload.value)) payload.issues.push({
-            input: payload.value,
-            inst,
-            code: "invalid_format",
-            format: def.format ?? "template_literal",
-            pattern: inst._zod.pattern.source
-        });
-        return payload;
-    };
-});
-const $ZodFunction = /*@__PURE__*/ $constructor("$ZodFunction", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._def = def;
-    inst._zod.def = def;
-    inst.implement = (func)=>{
-        if ("function" != typeof func) throw new Error("implement() must be called with a function");
-        return function(...args) {
-            const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
-            const result = Reflect.apply(func, this, parsedArgs);
-            if (inst._def.output) return parse(inst._def.output, result);
-            return result;
-        };
-    };
-    inst.implementAsync = (func)=>{
-        if ("function" != typeof func) throw new Error("implementAsync() must be called with a function");
-        return async function(...args) {
-            const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;
-            const result = await Reflect.apply(func, this, parsedArgs);
-            if (inst._def.output) return await parseAsync(inst._def.output, result);
-            return result;
-        };
-    };
-    inst._zod.parse = (payload, _ctx)=>{
-        if ("function" != typeof payload.value) {
-            payload.issues.push({
-                code: "invalid_type",
-                expected: "function",
-                input: payload.value,
-                inst
-            });
-            return payload;
-        }
-        const hasPromiseOutput = inst._def.output && "promise" === inst._def.output._zod.def.type;
-        if (hasPromiseOutput) payload.value = inst.implementAsync(payload.value);
-        else payload.value = inst.implement(payload.value);
-        return payload;
-    };
-    inst.input = (...args)=>{
-        const F = inst.constructor;
-        if (Array.isArray(args[0])) return new F({
-            type: "function",
-            input: new $ZodTuple({
-                type: "tuple",
-                items: args[0],
-                rest: args[1]
-            }),
-            output: inst._def.output
-        });
-        return new F({
-            type: "function",
-            input: args[0],
-            output: inst._def.output
-        });
-    };
-    inst.output = (output)=>{
-        const F = inst.constructor;
-        return new F({
-            type: "function",
-            input: inst._def.input,
-            output
-        });
-    };
-    return inst;
-});
-const $ZodPromise = /*@__PURE__*/ $constructor("$ZodPromise", (inst, def)=>{
-    $ZodType.init(inst, def);
-    inst._zod.parse = (payload, ctx)=>Promise.resolve(payload.value).then((inner)=>def.innerType._zod.run({
-                value: inner,
-                issues: []
-            }, ctx));
-});
-const $ZodLazy = /*@__PURE__*/ $constructor("$ZodLazy", (inst, def)=>{
-    $ZodType.init(inst, def);
-    defineLazy(inst._zod, "innerType", ()=>def.getter());
-    defineLazy(inst._zod, "pattern", ()=>inst._zod.innerType?._zod?.pattern);
-    defineLazy(inst._zod, "propValues", ()=>inst._zod.innerType?._zod?.propValues);
-    defineLazy(inst._zod, "optin", ()=>inst._zod.innerType?._zod?.optin ?? void 0);
-    defineLazy(inst._zod, "optout", ()=>inst._zod.innerType?._zod?.optout ?? void 0);
-    inst._zod.parse = (payload, ctx)=>{
-        const inner = inst._zod.innerType;
-        return inner._zod.run(payload, ctx);
-    };
-});
 const $ZodCustom = /*@__PURE__*/ $constructor("$ZodCustom", (inst, def)=>{
     $ZodCheck.init(inst, def);
     $ZodType.init(inst, def);
@@ -3369,121 +2031,6 @@ function handleRefineResult(result, payload, input, inst) {
         payload.issues.push(util_issue(_iss));
     }
 }
-const en_error = ()=>{
-    const Sizable = {
-        string: {
-            unit: "characters",
-            verb: "to have"
-        },
-        file: {
-            unit: "bytes",
-            verb: "to have"
-        },
-        array: {
-            unit: "items",
-            verb: "to have"
-        },
-        set: {
-            unit: "items",
-            verb: "to have"
-        },
-        map: {
-            unit: "entries",
-            verb: "to have"
-        }
-    };
-    function getSizing(origin) {
-        return Sizable[origin] ?? null;
-    }
-    const FormatDictionary = {
-        regex: "input",
-        email: "email address",
-        url: "URL",
-        emoji: "emoji",
-        uuid: "UUID",
-        uuidv4: "UUIDv4",
-        uuidv6: "UUIDv6",
-        nanoid: "nanoid",
-        guid: "GUID",
-        cuid: "cuid",
-        cuid2: "cuid2",
-        ulid: "ULID",
-        xid: "XID",
-        ksuid: "KSUID",
-        datetime: "ISO datetime",
-        date: "ISO date",
-        time: "ISO time",
-        duration: "ISO duration",
-        ipv4: "IPv4 address",
-        ipv6: "IPv6 address",
-        mac: "MAC address",
-        cidrv4: "IPv4 range",
-        cidrv6: "IPv6 range",
-        base64: "base64-encoded string",
-        base64url: "base64url-encoded string",
-        json_string: "JSON string",
-        e164: "E.164 number",
-        jwt: "JWT",
-        template_literal: "input"
-    };
-    const TypeDictionary = {
-        nan: "NaN"
-    };
-    return (issue)=>{
-        switch(issue.code){
-            case "invalid_type":
-                {
-                    const expected = TypeDictionary[issue.expected] ?? issue.expected;
-                    const receivedType = parsedType(issue.input);
-                    const received = TypeDictionary[receivedType] ?? receivedType;
-                    return `Invalid input: expected ${expected}, received ${received}`;
-                }
-            case "invalid_value":
-                if (1 === issue.values.length) return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;
-                return `Invalid option: expected one of ${joinValues(issue.values, "|")}`;
-            case "too_big":
-                {
-                    const adj = issue.inclusive ? "<=" : "<";
-                    const sizing = getSizing(issue.origin);
-                    if (sizing) return `Too big: expected ${issue.origin ?? "value"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
-                    return `Too big: expected ${issue.origin ?? "value"} to be ${adj}${issue.maximum.toString()}`;
-                }
-            case "too_small":
-                {
-                    const adj = issue.inclusive ? ">=" : ">";
-                    const sizing = getSizing(issue.origin);
-                    if (sizing) return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;
-                    return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;
-                }
-            case "invalid_format":
-                {
-                    const _issue = issue;
-                    if ("starts_with" === _issue.format) return `Invalid string: must start with "${_issue.prefix}"`;
-                    if ("ends_with" === _issue.format) return `Invalid string: must end with "${_issue.suffix}"`;
-                    if ("includes" === _issue.format) return `Invalid string: must include "${_issue.includes}"`;
-                    if ("regex" === _issue.format) return `Invalid string: must match pattern ${_issue.pattern}`;
-                    return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
-                }
-            case "not_multiple_of":
-                return `Invalid number: must be a multiple of ${issue.divisor}`;
-            case "unrecognized_keys":
-                return `Unrecognized key${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
-            case "invalid_key":
-                return `Invalid key in ${issue.origin}`;
-            case "invalid_union":
-                return "Invalid input";
-            case "invalid_element":
-                return `Invalid value in ${issue.origin}`;
-            default:
-                return "Invalid input";
-        }
-    };
-};
-function en() {
-    return {
-        localeError: en_error()
-    };
-}
 var registries_a;
 Symbol("ZodOutput");
 Symbol("ZodInput");
@@ -3532,7 +2079,7 @@ function registries_registry() {
     return new $ZodRegistry();
 }
 (registries_a = globalThis).__zod_globalRegistry ?? (registries_a.__zod_globalRegistry = registries_registry());
-const registries_globalRegistry = globalThis.__zod_globalRegistry;
+const globalRegistry = globalThis.__zod_globalRegistry;
 function _string(Class, params) {
     return new Class({
         type: "string",
@@ -3686,15 +2233,6 @@ function _ipv6(Class, params) {
         ...normalizeParams(params)
     });
 }
-function _mac(Class, params) {
-    return new Class({
-        type: "string",
-        format: "mac",
-        check: "string_format",
-        abort: false,
-        ...normalizeParams(params)
-    });
-}
 function _cidrv4(Class, params) {
     return new Class({
         type: "string",
@@ -3722,275 +2260,86 @@ function _base64(Class, params) {
         ...normalizeParams(params)
     });
 }
-function _base64url(Class, params) {
-    return new Class({
-        type: "string",
-        format: "base64url",
-        check: "string_format",
-        abort: false,
-        ...normalizeParams(params)
-    });
-}
-function _e164(Class, params) {
-    return new Class({
-        type: "string",
-        format: "e164",
-        check: "string_format",
-        abort: false,
-        ...normalizeParams(params)
-    });
-}
-function _jwt(Class, params) {
-    return new Class({
-        type: "string",
-        format: "jwt",
-        check: "string_format",
-        abort: false,
-        ...normalizeParams(params)
-    });
-}
-function _isoDateTime(Class, params) {
-    return new Class({
-        type: "string",
-        format: "datetime",
-        check: "string_format",
-        offset: false,
-        local: false,
-        precision: null,
-        ...normalizeParams(params)
-    });
-}
-function _isoDate(Class, params) {
-    return new Class({
-        type: "string",
-        format: "date",
-        check: "string_format",
-        ...normalizeParams(params)
-    });
-}
-function _isoTime(Class, params) {
-    return new Class({
-        type: "string",
-        format: "time",
-        check: "string_format",
-        precision: null,
-        ...normalizeParams(params)
-    });
-}
-function _isoDuration(Class, params) {
-    return new Class({
-        type: "string",
-        format: "duration",
-        check: "string_format",
-        ...normalizeParams(params)
-    });
-}
-function _number(Class, params) {
-    return new Class({
-        type: "number",
-        checks: [],
-        ...normalizeParams(params)
-    });
-}
-function _int(Class, params) {
-    return new Class({
-        type: "number",
-        check: "number_format",
-        abort: false,
-        format: "safeint",
-        ...normalizeParams(params)
-    });
-}
-function _float32(Class, params) {
-    return new Class({
-        type: "number",
-        check: "number_format",
-        abort: false,
-        format: "float32",
-        ...normalizeParams(params)
-    });
-}
-function _float64(Class, params) {
-    return new Class({
-        type: "number",
-        check: "number_format",
-        abort: false,
-        format: "float64",
-        ...normalizeParams(params)
-    });
-}
-function _int32(Class, params) {
-    return new Class({
-        type: "number",
-        check: "number_format",
-        abort: false,
-        format: "int32",
-        ...normalizeParams(params)
-    });
-}
-function _uint32(Class, params) {
-    return new Class({
-        type: "number",
-        check: "number_format",
-        abort: false,
-        format: "uint32",
-        ...normalizeParams(params)
-    });
-}
-function _boolean(Class, params) {
-    return new Class({
-        type: "boolean",
-        ...normalizeParams(params)
-    });
-}
-function _bigint(Class, params) {
-    return new Class({
-        type: "bigint",
-        ...normalizeParams(params)
-    });
-}
-function _int64(Class, params) {
-    return new Class({
-        type: "bigint",
-        check: "bigint_format",
-        abort: false,
-        format: "int64",
-        ...normalizeParams(params)
-    });
-}
-function _uint64(Class, params) {
+function _base64url(Class, params) {
     return new Class({
-        type: "bigint",
-        check: "bigint_format",
+        type: "string",
+        format: "base64url",
+        check: "string_format",
         abort: false,
-        format: "uint64",
         ...normalizeParams(params)
     });
 }
-function _symbol(Class, params) {
+function _e164(Class, params) {
     return new Class({
-        type: "symbol",
+        type: "string",
+        format: "e164",
+        check: "string_format",
+        abort: false,
         ...normalizeParams(params)
     });
 }
-function api_undefined(Class, params) {
+function _jwt(Class, params) {
     return new Class({
-        type: "undefined",
+        type: "string",
+        format: "jwt",
+        check: "string_format",
+        abort: false,
         ...normalizeParams(params)
     });
 }
-function api_null(Class, params) {
+function _isoDateTime(Class, params) {
     return new Class({
-        type: "null",
+        type: "string",
+        format: "datetime",
+        check: "string_format",
+        offset: false,
+        local: false,
+        precision: null,
         ...normalizeParams(params)
     });
 }
-function _any(Class) {
+function _isoDate(Class, params) {
     return new Class({
-        type: "any"
+        type: "string",
+        format: "date",
+        check: "string_format",
+        ...normalizeParams(params)
     });
 }
-function _unknown(Class) {
+function _isoTime(Class, params) {
     return new Class({
-        type: "unknown"
+        type: "string",
+        format: "time",
+        check: "string_format",
+        precision: null,
+        ...normalizeParams(params)
     });
 }
-function _never(Class, params) {
+function _isoDuration(Class, params) {
     return new Class({
-        type: "never",
+        type: "string",
+        format: "duration",
+        check: "string_format",
         ...normalizeParams(params)
     });
 }
-function _void(Class, params) {
+function _boolean(Class, params) {
     return new Class({
-        type: "void",
+        type: "boolean",
         ...normalizeParams(params)
     });
 }
-function _date(Class, params) {
+function _unknown(Class) {
     return new Class({
-        type: "date",
-        ...normalizeParams(params)
+        type: "unknown"
     });
 }
-function _nan(Class, params) {
+function _never(Class, params) {
     return new Class({
-        type: "nan",
+        type: "never",
         ...normalizeParams(params)
     });
 }
-function _lt(value, params) {
-    return new $ZodCheckLessThan({
-        check: "less_than",
-        ...normalizeParams(params),
-        value,
-        inclusive: false
-    });
-}
-function _lte(value, params) {
-    return new $ZodCheckLessThan({
-        check: "less_than",
-        ...normalizeParams(params),
-        value,
-        inclusive: true
-    });
-}
-function _gt(value, params) {
-    return new $ZodCheckGreaterThan({
-        check: "greater_than",
-        ...normalizeParams(params),
-        value,
-        inclusive: false
-    });
-}
-function _gte(value, params) {
-    return new $ZodCheckGreaterThan({
-        check: "greater_than",
-        ...normalizeParams(params),
-        value,
-        inclusive: true
-    });
-}
-function _positive(params) {
-    return _gt(0, params);
-}
-function _negative(params) {
-    return _lt(0, params);
-}
-function _nonpositive(params) {
-    return _lte(0, params);
-}
-function _nonnegative(params) {
-    return _gte(0, params);
-}
-function _multipleOf(value, params) {
-    return new $ZodCheckMultipleOf({
-        check: "multiple_of",
-        ...normalizeParams(params),
-        value
-    });
-}
-function _maxSize(maximum, params) {
-    return new $ZodCheckMaxSize({
-        check: "max_size",
-        ...normalizeParams(params),
-        maximum
-    });
-}
-function _minSize(minimum, params) {
-    return new $ZodCheckMinSize({
-        check: "min_size",
-        ...normalizeParams(params),
-        minimum
-    });
-}
-function _size(size, params) {
-    return new $ZodCheckSizeEquals({
-        check: "size_equals",
-        ...normalizeParams(params),
-        size
-    });
-}
 function _maxLength(maximum, params) {
     const ch = new $ZodCheckMaxLength({
         check: "max_length",
@@ -4059,21 +2408,6 @@ function _endsWith(suffix, params) {
         suffix
     });
 }
-function _property(property, schema, params) {
-    return new $ZodCheckProperty({
-        check: "property",
-        property,
-        schema,
-        ...normalizeParams(params)
-    });
-}
-function _mime(types, params) {
-    return new $ZodCheckMimeType({
-        check: "mime_type",
-        mime: types,
-        ...normalizeParams(params)
-    });
-}
 function _overwrite(tx) {
     return new $ZodCheckOverwrite({
         check: "overwrite",
@@ -4102,23 +2436,6 @@ function _array(Class, element, params) {
         ...normalizeParams(params)
     });
 }
-function _file(Class, params) {
-    return new Class({
-        type: "file",
-        ...normalizeParams(params)
-    });
-}
-function _custom(Class, fn, _params) {
-    const norm = normalizeParams(_params);
-    norm.abort ?? (norm.abort = true);
-    const schema = new Class({
-        type: "custom",
-        check: "custom",
-        fn: fn,
-        ...norm
-    });
-    return schema;
-}
 function _refine(Class, fn, _params) {
     const schema = new Class({
         type: "custom",
@@ -4128,7 +2445,7 @@ function _refine(Class, fn, _params) {
     });
     return schema;
 }
-function _superRefine(fn) {
+function _superRefine(fn, params) {
     const ch = _check((payload)=>{
         payload.addIssue = (issue)=>{
             if ("string" == typeof issue) payload.issues.push(util_issue(issue, payload.value, ch._zod.def));
@@ -4143,7 +2460,7 @@ function _superRefine(fn) {
             }
         };
         return fn(payload.value, payload);
-    });
+    }, params);
     return ch;
 }
 function _check(fn, params) {
@@ -4154,124 +2471,13 @@ function _check(fn, params) {
     ch._zod.check = fn;
     return ch;
 }
-function describe(description) {
-    const ch = new $ZodCheck({
-        check: "describe"
-    });
-    ch._zod.onattach = [
-        (inst)=>{
-            const existing = registries_globalRegistry.get(inst) ?? {};
-            registries_globalRegistry.add(inst, {
-                ...existing,
-                description
-            });
-        }
-    ];
-    ch._zod.check = ()=>{};
-    return ch;
-}
-function api_meta(metadata) {
-    const ch = new $ZodCheck({
-        check: "meta"
-    });
-    ch._zod.onattach = [
-        (inst)=>{
-            const existing = registries_globalRegistry.get(inst) ?? {};
-            registries_globalRegistry.add(inst, {
-                ...existing,
-                ...metadata
-            });
-        }
-    ];
-    ch._zod.check = ()=>{};
-    return ch;
-}
-function _stringbool(Classes, _params) {
-    const params = normalizeParams(_params);
-    let truthyArray = params.truthy ?? [
-        "true",
-        "1",
-        "yes",
-        "on",
-        "y",
-        "enabled"
-    ];
-    let falsyArray = params.falsy ?? [
-        "false",
-        "0",
-        "no",
-        "off",
-        "n",
-        "disabled"
-    ];
-    if ("sensitive" !== params.case) {
-        truthyArray = truthyArray.map((v)=>"string" == typeof v ? v.toLowerCase() : v);
-        falsyArray = falsyArray.map((v)=>"string" == typeof v ? v.toLowerCase() : v);
-    }
-    const truthySet = new Set(truthyArray);
-    const falsySet = new Set(falsyArray);
-    const _Codec = Classes.Codec ?? $ZodCodec;
-    const _Boolean = Classes.Boolean ?? $ZodBoolean;
-    const _String = Classes.String ?? $ZodString;
-    const stringSchema = new _String({
-        type: "string",
-        error: params.error
-    });
-    const booleanSchema = new _Boolean({
-        type: "boolean",
-        error: params.error
-    });
-    const codec = new _Codec({
-        type: "pipe",
-        in: stringSchema,
-        out: booleanSchema,
-        transform: (input, payload)=>{
-            let data = input;
-            if ("sensitive" !== params.case) data = data.toLowerCase();
-            if (truthySet.has(data)) return true;
-            if (falsySet.has(data)) return false;
-            payload.issues.push({
-                code: "invalid_value",
-                expected: "stringbool",
-                values: [
-                    ...truthySet,
-                    ...falsySet
-                ],
-                input: payload.value,
-                inst: codec,
-                continue: false
-            });
-            return {};
-        },
-        reverseTransform: (input, _payload)=>{
-            if (true === input) return truthyArray[0] || "true";
-            return falsyArray[0] || "false";
-        },
-        error: params.error
-    });
-    return codec;
-}
-function _stringFormat(Class, format, fnOrRegex, _params = {}) {
-    const params = normalizeParams(_params);
-    const def = {
-        ...normalizeParams(_params),
-        check: "string_format",
-        type: "string",
-        format,
-        fn: "function" == typeof fnOrRegex ? fnOrRegex : (val)=>fnOrRegex.test(val),
-        ...params
-    };
-    if (fnOrRegex instanceof RegExp) def.pattern = fnOrRegex;
-    const inst = new Class(def);
-    return inst;
-}
 function to_json_schema_initializeContext(params) {
     let target = params?.target ?? "draft-2020-12";
     if ("draft-4" === target) target = "draft-04";
     if ("draft-7" === target) target = "draft-07";
     return {
         processors: params.processors ?? {},
-        metadataRegistry: params?.metadata ?? registries_globalRegistry,
+        metadataRegistry: params?.metadata ?? globalRegistry,
         target,
         unrepresentable: params?.unrepresentable ?? "throw",
         override: params?.override ?? (()=>{}),
@@ -4334,7 +2540,7 @@ function to_json_schema_process(schema, ctx, _params = {
         delete result.schema.examples;
         delete result.schema.default;
     }
-    if ("input" === ctx.io && result.schema._prefault) (_a = result.schema).default ?? (_a.default = result.schema._prefault);
+    if ("input" === ctx.io && "_prefault" in result.schema) (_a = result.schema).default ?? (_a.default = result.schema._prefault);
     delete result.schema._prefault;
     const _result = ctx.seen.get(schema);
     return _result.schema;
@@ -4489,10 +2695,15 @@ function to_json_schema_finalize(ctx, schema) {
         result.$id = ctx.external.uri(id);
     }
     Object.assign(result, root.def ?? root.schema);
+    const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+    if (void 0 !== rootMetaId && result.id === rootMetaId) delete result.id;
     const defs = ctx.external?.defs ?? {};
     for (const entry of ctx.seen.entries()){
         const seen = entry[1];
-        if (seen.def && seen.defId) defs[seen.defId] = seen.def;
+        if (seen.def && seen.defId) {
+            if (seen.def.id === seen.defId) delete seen.def.id;
+            defs[seen.defId] = seen.def;
+        }
     }
     if (ctx.external) ;
     else if (Object.keys(defs).length > 0) if ("draft-2020-12" === ctx.target) result.$defs = defs;
@@ -4529,7 +2740,10 @@ function isTransforming(_schema, _ctx) {
     if ("promise" === def.type || "optional" === def.type || "nonoptional" === def.type || "nullable" === def.type || "readonly" === def.type || "default" === def.type || "prefault" === def.type) return isTransforming(def.innerType, ctx);
     if ("intersection" === def.type) return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
     if ("record" === def.type || "map" === def.type) return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
-    if ("pipe" === def.type) return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+    if ("pipe" === def.type) {
+        if (_schema._zod.traits.has("$ZodCodec")) return true;
+        return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+    }
     if ("object" === def.type) {
         for(const key in def.shape)if (isTransforming(def.shape[key], ctx)) return true;
         return false;
@@ -4599,63 +2813,13 @@ const stringProcessor = (schema, ctx, _json, _params)=>{
         ];
     }
 };
-const numberProcessor = (schema, ctx, _json, _params)=>{
-    const json = _json;
-    const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
-    if ("string" == typeof format && format.includes("int")) json.type = "integer";
-    else json.type = "number";
-    if ("number" == typeof exclusiveMinimum) if ("draft-04" === ctx.target || "openapi-3.0" === ctx.target) {
-        json.minimum = exclusiveMinimum;
-        json.exclusiveMinimum = true;
-    } else json.exclusiveMinimum = exclusiveMinimum;
-    if ("number" == typeof minimum) {
-        json.minimum = minimum;
-        if ("number" == typeof exclusiveMinimum && "draft-04" !== ctx.target) if (exclusiveMinimum >= minimum) delete json.minimum;
-        else delete json.exclusiveMinimum;
-    }
-    if ("number" == typeof exclusiveMaximum) if ("draft-04" === ctx.target || "openapi-3.0" === ctx.target) {
-        json.maximum = exclusiveMaximum;
-        json.exclusiveMaximum = true;
-    } else json.exclusiveMaximum = exclusiveMaximum;
-    if ("number" == typeof maximum) {
-        json.maximum = maximum;
-        if ("number" == typeof exclusiveMaximum && "draft-04" !== ctx.target) if (exclusiveMaximum <= maximum) delete json.maximum;
-        else delete json.exclusiveMaximum;
-    }
-    if ("number" == typeof multipleOf) json.multipleOf = multipleOf;
-};
 const booleanProcessor = (_schema, _ctx, json, _params)=>{
     json.type = "boolean";
 };
-const bigintProcessor = (_schema, ctx, _json, _params)=>{
-    if ("throw" === ctx.unrepresentable) throw new Error("BigInt cannot be represented in JSON Schema");
-};
-const symbolProcessor = (_schema, ctx, _json, _params)=>{
-    if ("throw" === ctx.unrepresentable) throw new Error("Symbols cannot be represented in JSON Schema");
-};
-const nullProcessor = (_schema, ctx, json, _params)=>{
-    if ("openapi-3.0" === ctx.target) {
-        json.type = "string";
-        json.nullable = true;
-        json.enum = [
-            null
-        ];
-    } else json.type = "null";
-};
-const undefinedProcessor = (_schema, ctx, _json, _params)=>{
-    if ("throw" === ctx.unrepresentable) throw new Error("Undefined cannot be represented in JSON Schema");
-};
-const voidProcessor = (_schema, ctx, _json, _params)=>{
-    if ("throw" === ctx.unrepresentable) throw new Error("Void cannot be represented in JSON Schema");
-};
 const neverProcessor = (_schema, _ctx, json, _params)=>{
     json.not = {};
 };
-const anyProcessor = (_schema, _ctx, _json, _params)=>{};
 const unknownProcessor = (_schema, _ctx, _json, _params)=>{};
-const dateProcessor = (_schema, ctx, _json, _params)=>{
-    if ("throw" === ctx.unrepresentable) throw new Error("Date cannot be represented in JSON Schema");
-};
 const enumProcessor = (schema, _ctx, json, _params)=>{
     const def = schema._zod.def;
     const values = getEnumValues(def.entries);
@@ -4663,79 +2827,12 @@ const enumProcessor = (schema, _ctx, json, _params)=>{
     if (values.every((v)=>"string" == typeof v)) json.type = "string";
     json.enum = values;
 };
-const literalProcessor = (schema, ctx, json, _params)=>{
-    const def = schema._zod.def;
-    const vals = [];
-    for (const val of def.values)if (void 0 === val) {
-        if ("throw" === ctx.unrepresentable) throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-    } else if ("bigint" == typeof val) if ("throw" === ctx.unrepresentable) throw new Error("BigInt literals cannot be represented in JSON Schema");
-    else vals.push(Number(val));
-    else vals.push(val);
-    if (0 === vals.length) ;
-    else if (1 === vals.length) {
-        const val = vals[0];
-        json.type = null === val ? "null" : typeof val;
-        if ("draft-04" === ctx.target || "openapi-3.0" === ctx.target) json.enum = [
-            val
-        ];
-        else json.const = val;
-    } else {
-        if (vals.every((v)=>"number" == typeof v)) json.type = "number";
-        if (vals.every((v)=>"string" == typeof v)) json.type = "string";
-        if (vals.every((v)=>"boolean" == typeof v)) json.type = "boolean";
-        if (vals.every((v)=>null === v)) json.type = "null";
-        json.enum = vals;
-    }
-};
-const nanProcessor = (_schema, ctx, _json, _params)=>{
-    if ("throw" === ctx.unrepresentable) throw new Error("NaN cannot be represented in JSON Schema");
-};
-const templateLiteralProcessor = (schema, _ctx, json, _params)=>{
-    const _json = json;
-    const pattern = schema._zod.pattern;
-    if (!pattern) throw new Error("Pattern not found in template literal");
-    _json.type = "string";
-    _json.pattern = pattern.source;
-};
-const fileProcessor = (schema, _ctx, json, _params)=>{
-    const _json = json;
-    const file = {
-        type: "string",
-        format: "binary",
-        contentEncoding: "binary"
-    };
-    const { minimum, maximum, mime } = schema._zod.bag;
-    if (void 0 !== minimum) file.minLength = minimum;
-    if (void 0 !== maximum) file.maxLength = maximum;
-    if (mime) if (1 === mime.length) {
-        file.contentMediaType = mime[0];
-        Object.assign(_json, file);
-    } else {
-        Object.assign(_json, file);
-        _json.anyOf = mime.map((m)=>({
-                contentMediaType: m
-            }));
-    }
-    else Object.assign(_json, file);
-};
-const successProcessor = (_schema, _ctx, json, _params)=>{
-    json.type = "boolean";
-};
 const customProcessor = (_schema, ctx, _json, _params)=>{
     if ("throw" === ctx.unrepresentable) throw new Error("Custom types cannot be represented in JSON Schema");
 };
-const functionProcessor = (_schema, ctx, _json, _params)=>{
-    if ("throw" === ctx.unrepresentable) throw new Error("Function types cannot be represented in JSON Schema");
-};
 const transformProcessor = (_schema, ctx, _json, _params)=>{
     if ("throw" === ctx.unrepresentable) throw new Error("Transforms cannot be represented in JSON Schema");
 };
-const mapProcessor = (_schema, ctx, _json, _params)=>{
-    if ("throw" === ctx.unrepresentable) throw new Error("Map cannot be represented in JSON Schema");
-};
-const setProcessor = (_schema, ctx, _json, _params)=>{
-    if ("throw" === ctx.unrepresentable) throw new Error("Set cannot be represented in JSON Schema");
-};
 const arrayProcessor = (schema, ctx, _json, params)=>{
     const json = _json;
     const def = schema._zod.def;
@@ -4828,90 +2925,6 @@ const intersectionProcessor = (schema, ctx, json, params)=>{
     ];
     json.allOf = allOf;
 };
-const tupleProcessor = (schema, ctx, _json, params)=>{
-    const json = _json;
-    const def = schema._zod.def;
-    json.type = "array";
-    const prefixPath = "draft-2020-12" === ctx.target ? "prefixItems" : "items";
-    const restPath = "draft-2020-12" === ctx.target ? "items" : "openapi-3.0" === ctx.target ? "items" : "additionalItems";
-    const prefixItems = def.items.map((x, i)=>to_json_schema_process(x, ctx, {
-            ...params,
-            path: [
-                ...params.path,
-                prefixPath,
-                i
-            ]
-        }));
-    const rest = def.rest ? to_json_schema_process(def.rest, ctx, {
-        ...params,
-        path: [
-            ...params.path,
-            restPath,
-            ..."openapi-3.0" === ctx.target ? [
-                def.items.length
-            ] : []
-        ]
-    }) : null;
-    if ("draft-2020-12" === ctx.target) {
-        json.prefixItems = prefixItems;
-        if (rest) json.items = rest;
-    } else if ("openapi-3.0" === ctx.target) {
-        json.items = {
-            anyOf: prefixItems
-        };
-        if (rest) json.items.anyOf.push(rest);
-        json.minItems = prefixItems.length;
-        if (!rest) json.maxItems = prefixItems.length;
-    } else {
-        json.items = prefixItems;
-        if (rest) json.additionalItems = rest;
-    }
-    const { minimum, maximum } = schema._zod.bag;
-    if ("number" == typeof minimum) json.minItems = minimum;
-    if ("number" == typeof maximum) json.maxItems = maximum;
-};
-const recordProcessor = (schema, ctx, _json, params)=>{
-    const json = _json;
-    const def = schema._zod.def;
-    json.type = "object";
-    const keyType = def.keyType;
-    const keyBag = keyType._zod.bag;
-    const patterns = keyBag?.patterns;
-    if ("loose" === def.mode && patterns && patterns.size > 0) {
-        const valueSchema = to_json_schema_process(def.valueType, ctx, {
-            ...params,
-            path: [
-                ...params.path,
-                "patternProperties",
-                "*"
-            ]
-        });
-        json.patternProperties = {};
-        for (const pattern of patterns)json.patternProperties[pattern.source] = valueSchema;
-    } else {
-        if ("draft-07" === ctx.target || "draft-2020-12" === ctx.target) json.propertyNames = to_json_schema_process(def.keyType, ctx, {
-            ...params,
-            path: [
-                ...params.path,
-                "propertyNames"
-            ]
-        });
-        json.additionalProperties = to_json_schema_process(def.valueType, ctx, {
-            ...params,
-            path: [
-                ...params.path,
-                "additionalProperties"
-            ]
-        });
-    }
-    const keyValues = keyType._zod.values;
-    if (keyValues) {
-        const validKeyValues = [
-            ...keyValues
-        ].filter((v)=>"string" == typeof v || "number" == typeof v);
-        if (validKeyValues.length > 0) json.required = validKeyValues;
-    }
-};
 const nullableProcessor = (schema, ctx, json, params)=>{
     const def = schema._zod.def;
     const inner = to_json_schema_process(def.innerType, ctx, params);
@@ -4961,7 +2974,8 @@ const catchProcessor = (schema, ctx, json, params)=>{
 };
 const pipeProcessor = (schema, ctx, _json, params)=>{
     const def = schema._zod.def;
-    const innerType = "input" === ctx.io ? "transform" === def.in._zod.def.type ? def.out : def.in : def.out;
+    const inIsTransform = def.in._zod.traits.has("$ZodTransform");
+    const innerType = "input" === ctx.io ? inIsTransform ? def.out : def.in : def.out;
     to_json_schema_process(innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = innerType;
@@ -4973,24 +2987,12 @@ const readonlyProcessor = (schema, ctx, json, params)=>{
     seen.ref = def.innerType;
     json.readOnly = true;
 };
-const promiseProcessor = (schema, ctx, _json, params)=>{
-    const def = schema._zod.def;
-    to_json_schema_process(def.innerType, ctx, params);
-    const seen = ctx.seen.get(schema);
-    seen.ref = def.innerType;
-};
 const optionalProcessor = (schema, ctx, _json, params)=>{
     const def = schema._zod.def;
     to_json_schema_process(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
 };
-const lazyProcessor = (schema, ctx, _json, params)=>{
-    const innerType = schema._zod.innerType;
-    to_json_schema_process(innerType, ctx, params);
-    const seen = ctx.seen.get(schema);
-    seen.ref = innerType;
-};
 const ZodISODateTime = /*@__PURE__*/ $constructor("ZodISODateTime", (inst, def)=>{
     $ZodISODateTime.init(inst, def);
     ZodStringFormat.init(inst, def);
@@ -5048,12 +3050,11 @@ const classic_errors_initializer = (inst, issues)=>{
         }
     });
 };
-$constructor("ZodError", classic_errors_initializer);
-const ZodRealError = $constructor("ZodError", classic_errors_initializer, {
+const ZodRealError = /*@__PURE__*/ $constructor("ZodError", classic_errors_initializer, {
     Parent: Error
 });
-const parse_parse = /* @__PURE__ */ _parse(ZodRealError);
-const parse_parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
+const classic_parse_parse = /* @__PURE__ */ _parse(ZodRealError);
+const classic_parse_parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 const parse_safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
 const parse_safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
 const parse_encode = /* @__PURE__ */ _encode(ZodRealError);
@@ -5064,6 +3065,42 @@ const parse_safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
 const parse_safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
 const parse_safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
 const parse_safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
+const _installedGroups = /* @__PURE__ */ new WeakMap();
+function _installLazyMethods(inst, group, methods) {
+    const proto = Object.getPrototypeOf(inst);
+    let installed = _installedGroups.get(proto);
+    if (!installed) {
+        installed = new Set();
+        _installedGroups.set(proto, installed);
+    }
+    if (installed.has(group)) return;
+    installed.add(group);
+    for(const key in methods){
+        const fn = methods[key];
+        Object.defineProperty(proto, key, {
+            configurable: true,
+            enumerable: false,
+            get () {
+                const bound = fn.bind(this);
+                Object.defineProperty(this, key, {
+                    configurable: true,
+                    writable: true,
+                    enumerable: true,
+                    value: bound
+                });
+                return bound;
+            },
+            set (v) {
+                Object.defineProperty(this, key, {
+                    configurable: true,
+                    writable: true,
+                    enumerable: true,
+                    value: v
+                });
+            }
+        });
+    }
+}
 const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def)=>{
     $ZodType.init(inst, def);
     Object.assign(inst["~standard"], {
@@ -5078,34 +3115,11 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def)=>{
     Object.defineProperty(inst, "_def", {
         value: def
     });
-    inst.check = (...checks)=>inst.clone(mergeDefs(def, {
-            checks: [
-                ...def.checks ?? [],
-                ...checks.map((ch)=>"function" == typeof ch ? {
-                        _zod: {
-                            check: ch,
-                            def: {
-                                check: "custom"
-                            },
-                            onattach: []
-                        }
-                    } : ch)
-            ]
-        }), {
-            parent: true
-        });
-    inst.with = inst.check;
-    inst.clone = (def, params)=>clone(inst, def, params);
-    inst.brand = ()=>inst;
-    inst.register = (reg, meta)=>{
-        reg.add(inst, meta);
-        return inst;
-    };
-    inst.parse = (data, params)=>parse_parse(inst, data, params, {
+    inst.parse = (data, params)=>classic_parse_parse(inst, data, params, {
             callee: inst.parse
         });
     inst.safeParse = (data, params)=>parse_safeParse(inst, data, params);
-    inst.parseAsync = async (data, params)=>parse_parseAsync(inst, data, params, {
+    inst.parseAsync = async (data, params)=>classic_parse_parseAsync(inst, data, params, {
             callee: inst.parseAsync
         });
     inst.safeParseAsync = async (data, params)=>parse_safeParseAsync(inst, data, params);
@@ -5118,48 +3132,122 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def)=>{
     inst.safeDecode = (data, params)=>parse_safeDecode(inst, data, params);
     inst.safeEncodeAsync = async (data, params)=>parse_safeEncodeAsync(inst, data, params);
     inst.safeDecodeAsync = async (data, params)=>parse_safeDecodeAsync(inst, data, params);
-    inst.refine = (check, params)=>inst.check(refine(check, params));
-    inst.superRefine = (refinement)=>inst.check(superRefine(refinement));
-    inst.overwrite = (fn)=>inst.check(_overwrite(fn));
-    inst.optional = ()=>optional(inst);
-    inst.exactOptional = ()=>exactOptional(inst);
-    inst.nullable = ()=>nullable(inst);
-    inst.nullish = ()=>optional(nullable(inst));
-    inst.nonoptional = (params)=>nonoptional(inst, params);
-    inst.array = ()=>schemas_array(inst);
-    inst.or = (arg)=>union([
-            inst,
-            arg
-        ]);
-    inst.and = (arg)=>intersection(inst, arg);
-    inst.transform = (tx)=>pipe(inst, transform(tx));
-    inst.default = (def)=>schemas_default(inst, def);
-    inst.prefault = (def)=>prefault(inst, def);
-    inst.catch = (params)=>schemas_catch(inst, params);
-    inst.pipe = (target)=>pipe(inst, target);
-    inst.readonly = ()=>readonly(inst);
-    inst.describe = (description)=>{
-        const cl = inst.clone();
-        registries_globalRegistry.add(cl, {
-            description
-        });
-        return cl;
-    };
+    _installLazyMethods(inst, "ZodType", {
+        check (...chks) {
+            const def = this.def;
+            return this.clone(mergeDefs(def, {
+                checks: [
+                    ...def.checks ?? [],
+                    ...chks.map((ch)=>"function" == typeof ch ? {
+                            _zod: {
+                                check: ch,
+                                def: {
+                                    check: "custom"
+                                },
+                                onattach: []
+                            }
+                        } : ch)
+                ]
+            }), {
+                parent: true
+            });
+        },
+        with (...chks) {
+            return this.check(...chks);
+        },
+        clone (def, params) {
+            return clone(this, def, params);
+        },
+        brand () {
+            return this;
+        },
+        register (reg, meta) {
+            reg.add(this, meta);
+            return this;
+        },
+        refine (check, params) {
+            return this.check(refine(check, params));
+        },
+        superRefine (refinement, params) {
+            return this.check(superRefine(refinement, params));
+        },
+        overwrite (fn) {
+            return this.check(_overwrite(fn));
+        },
+        optional () {
+            return optional(this);
+        },
+        exactOptional () {
+            return exactOptional(this);
+        },
+        nullable () {
+            return nullable(this);
+        },
+        nullish () {
+            return optional(nullable(this));
+        },
+        nonoptional (params) {
+            return nonoptional(this, params);
+        },
+        array () {
+            return schemas_array(this);
+        },
+        or (arg) {
+            return union([
+                this,
+                arg
+            ]);
+        },
+        and (arg) {
+            return intersection(this, arg);
+        },
+        transform (tx) {
+            return pipe(this, transform(tx));
+        },
+        default (d) {
+            return schemas_default(this, d);
+        },
+        prefault (d) {
+            return prefault(this, d);
+        },
+        catch (params) {
+            return schemas_catch(this, params);
+        },
+        pipe (target) {
+            return pipe(this, target);
+        },
+        readonly () {
+            return readonly(this);
+        },
+        describe (description) {
+            const cl = this.clone();
+            globalRegistry.add(cl, {
+                description
+            });
+            return cl;
+        },
+        meta (...args) {
+            if (0 === args.length) return globalRegistry.get(this);
+            const cl = this.clone();
+            globalRegistry.add(cl, args[0]);
+            return cl;
+        },
+        isOptional () {
+            return this.safeParse(void 0).success;
+        },
+        isNullable () {
+            return this.safeParse(null).success;
+        },
+        apply (fn) {
+            return fn(this);
+        }
+    });
     Object.defineProperty(inst, "description", {
         get () {
-            return registries_globalRegistry.get(inst)?.description;
+            return globalRegistry.get(inst)?.description;
         },
         configurable: true
     });
-    inst.meta = (...args)=>{
-        if (0 === args.length) return registries_globalRegistry.get(inst);
-        const cl = inst.clone();
-        registries_globalRegistry.add(cl, args[0]);
-        return cl;
-    };
-    inst.isOptional = ()=>inst.safeParse(void 0).success;
-    inst.isNullable = ()=>inst.safeParse(null).success;
-    inst.apply = (fn)=>fn(inst);
     return inst;
 });
 const _ZodString = /*@__PURE__*/ $constructor("_ZodString", (inst, def)=>{
@@ -5170,21 +3258,53 @@ const _ZodString = /*@__PURE__*/ $constructor("_ZodString", (inst, def)=>{
     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());
-    inst.slugify = ()=>inst.check(_slugify());
+    _installLazyMethods(inst, "_ZodString", {
+        regex (...args) {
+            return this.check(_regex(...args));
+        },
+        includes (...args) {
+            return this.check(_includes(...args));
+        },
+        startsWith (...args) {
+            return this.check(_startsWith(...args));
+        },
+        endsWith (...args) {
+            return this.check(_endsWith(...args));
+        },
+        min (...args) {
+            return this.check(_minLength(...args));
+        },
+        max (...args) {
+            return this.check(_maxLength(...args));
+        },
+        length (...args) {
+            return this.check(_length(...args));
+        },
+        nonempty (...args) {
+            return this.check(_minLength(1, ...args));
+        },
+        lowercase (params) {
+            return this.check(_lowercase(params));
+        },
+        uppercase (params) {
+            return this.check(_uppercase(params));
+        },
+        trim () {
+            return this.check(_trim());
+        },
+        normalize (...args) {
+            return this.check(_normalize(...args));
+        },
+        toLowerCase () {
+            return this.check(_toLowerCase());
+        },
+        toUpperCase () {
+            return this.check(_toUpperCase());
+        },
+        slugify () {
+            return this.check(_slugify());
+        }
+    });
 });
 const ZodString = /*@__PURE__*/ $constructor("ZodString", (inst, def)=>{
     $ZodString.init(inst, def);
@@ -5228,226 +3348,78 @@ const ZodEmail = /*@__PURE__*/ $constructor("ZodEmail", (inst, def)=>{
     $ZodEmail.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_email(params) {
-    return _email(ZodEmail, params);
-}
 const ZodGUID = /*@__PURE__*/ $constructor("ZodGUID", (inst, def)=>{
     $ZodGUID.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_guid(params) {
-    return _guid(ZodGUID, params);
-}
 const ZodUUID = /*@__PURE__*/ $constructor("ZodUUID", (inst, def)=>{
     $ZodUUID.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_uuid(params) {
-    return _uuid(ZodUUID, params);
-}
-function uuidv4(params) {
-    return _uuidv4(ZodUUID, params);
-}
-function uuidv6(params) {
-    return _uuidv6(ZodUUID, params);
-}
-function uuidv7(params) {
-    return _uuidv7(ZodUUID, params);
-}
 const ZodURL = /*@__PURE__*/ $constructor("ZodURL", (inst, def)=>{
     $ZodURL.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_url(params) {
-    return _url(ZodURL, params);
-}
-function httpUrl(params) {
-    return _url(ZodURL, {
-        protocol: /^https?$/,
-        hostname: domain,
-        ...normalizeParams(params)
-    });
-}
 const ZodEmoji = /*@__PURE__*/ $constructor("ZodEmoji", (inst, def)=>{
     $ZodEmoji.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_emoji(params) {
-    return api_emoji(ZodEmoji, params);
-}
 const ZodNanoID = /*@__PURE__*/ $constructor("ZodNanoID", (inst, def)=>{
     $ZodNanoID.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_nanoid(params) {
-    return _nanoid(ZodNanoID, params);
-}
 const ZodCUID = /*@__PURE__*/ $constructor("ZodCUID", (inst, def)=>{
     $ZodCUID.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_cuid(params) {
-    return _cuid(ZodCUID, params);
-}
 const ZodCUID2 = /*@__PURE__*/ $constructor("ZodCUID2", (inst, def)=>{
     $ZodCUID2.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_cuid2(params) {
-    return _cuid2(ZodCUID2, params);
-}
 const ZodULID = /*@__PURE__*/ $constructor("ZodULID", (inst, def)=>{
     $ZodULID.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_ulid(params) {
-    return _ulid(ZodULID, params);
-}
 const ZodXID = /*@__PURE__*/ $constructor("ZodXID", (inst, def)=>{
     $ZodXID.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_xid(params) {
-    return _xid(ZodXID, params);
-}
 const ZodKSUID = /*@__PURE__*/ $constructor("ZodKSUID", (inst, def)=>{
     $ZodKSUID.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_ksuid(params) {
-    return _ksuid(ZodKSUID, params);
-}
 const ZodIPv4 = /*@__PURE__*/ $constructor("ZodIPv4", (inst, def)=>{
     $ZodIPv4.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_ipv4(params) {
-    return _ipv4(ZodIPv4, params);
-}
-const ZodMAC = /*@__PURE__*/ $constructor("ZodMAC", (inst, def)=>{
-    $ZodMAC.init(inst, def);
-    ZodStringFormat.init(inst, def);
-});
-function schemas_mac(params) {
-    return _mac(ZodMAC, params);
-}
 const ZodIPv6 = /*@__PURE__*/ $constructor("ZodIPv6", (inst, def)=>{
     $ZodIPv6.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_ipv6(params) {
-    return _ipv6(ZodIPv6, params);
-}
 const ZodCIDRv4 = /*@__PURE__*/ $constructor("ZodCIDRv4", (inst, def)=>{
     $ZodCIDRv4.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_cidrv4(params) {
-    return _cidrv4(ZodCIDRv4, params);
-}
 const ZodCIDRv6 = /*@__PURE__*/ $constructor("ZodCIDRv6", (inst, def)=>{
     $ZodCIDRv6.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_cidrv6(params) {
-    return _cidrv6(ZodCIDRv6, params);
-}
 const ZodBase64 = /*@__PURE__*/ $constructor("ZodBase64", (inst, def)=>{
     $ZodBase64.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_base64(params) {
-    return _base64(ZodBase64, params);
-}
 const ZodBase64URL = /*@__PURE__*/ $constructor("ZodBase64URL", (inst, def)=>{
     $ZodBase64URL.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_base64url(params) {
-    return _base64url(ZodBase64URL, params);
-}
 const ZodE164 = /*@__PURE__*/ $constructor("ZodE164", (inst, def)=>{
     $ZodE164.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function schemas_e164(params) {
-    return _e164(ZodE164, params);
-}
 const ZodJWT = /*@__PURE__*/ $constructor("ZodJWT", (inst, def)=>{
     $ZodJWT.init(inst, def);
     ZodStringFormat.init(inst, def);
 });
-function jwt(params) {
-    return _jwt(ZodJWT, params);
-}
-const ZodCustomStringFormat = /*@__PURE__*/ $constructor("ZodCustomStringFormat", (inst, def)=>{
-    $ZodCustomStringFormat.init(inst, def);
-    ZodStringFormat.init(inst, def);
-});
-function stringFormat(format, fnOrRegex, _params = {}) {
-    return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
-}
-function schemas_hostname(_params) {
-    return _stringFormat(ZodCustomStringFormat, "hostname", hostname, _params);
-}
-function schemas_hex(_params) {
-    return _stringFormat(ZodCustomStringFormat, "hex", regexes_hex, _params);
-}
-function hash(alg, params) {
-    const enc = params?.enc ?? "hex";
-    const format = `${alg}_${enc}`;
-    const regex = regexes_namespaceObject[format];
-    if (!regex) throw new Error(`Unrecognized hash format: ${format}`);
-    return _stringFormat(ZodCustomStringFormat, format, regex, params);
-}
-const ZodNumber = /*@__PURE__*/ $constructor("ZodNumber", (inst, def)=>{
-    $ZodNumber.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>numberProcessor(inst, ctx, json, 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.int = (params)=>inst.check(schemas_int(params));
-    inst.safe = (params)=>inst.check(schemas_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 ?? -1 / 0, bag.exclusiveMinimum ?? -1 / 0) ?? null;
-    inst.maxValue = Math.min(bag.maximum ?? 1 / 0, bag.exclusiveMaximum ?? 1 / 0) ?? null;
-    inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
-    inst.isFinite = true;
-    inst.format = bag.format ?? null;
-});
-function schemas_number(params) {
-    return _number(ZodNumber, params);
-}
-const ZodNumberFormat = /*@__PURE__*/ $constructor("ZodNumberFormat", (inst, def)=>{
-    $ZodNumberFormat.init(inst, def);
-    ZodNumber.init(inst, def);
-});
-function schemas_int(params) {
-    return _int(ZodNumberFormat, params);
-}
-function float32(params) {
-    return _float32(ZodNumberFormat, params);
-}
-function float64(params) {
-    return _float64(ZodNumberFormat, params);
-}
-function int32(params) {
-    return _int32(ZodNumberFormat, params);
-}
-function uint32(params) {
-    return _uint32(ZodNumberFormat, params);
-}
 const ZodBoolean = /*@__PURE__*/ $constructor("ZodBoolean", (inst, def)=>{
     $ZodBoolean.init(inst, def);
     ZodType.init(inst, def);
@@ -5456,73 +3428,6 @@ const ZodBoolean = /*@__PURE__*/ $constructor("ZodBoolean", (inst, def)=>{
 function schemas_boolean(params) {
     return _boolean(ZodBoolean, params);
 }
-const ZodBigInt = /*@__PURE__*/ $constructor("ZodBigInt", (inst, def)=>{
-    $ZodBigInt.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>bigintProcessor(inst, ctx, json, params);
-    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 schemas_bigint(params) {
-    return _bigint(ZodBigInt, params);
-}
-const ZodBigIntFormat = /*@__PURE__*/ $constructor("ZodBigIntFormat", (inst, def)=>{
-    $ZodBigIntFormat.init(inst, def);
-    ZodBigInt.init(inst, def);
-});
-function int64(params) {
-    return _int64(ZodBigIntFormat, params);
-}
-function uint64(params) {
-    return _uint64(ZodBigIntFormat, params);
-}
-const ZodSymbol = /*@__PURE__*/ $constructor("ZodSymbol", (inst, def)=>{
-    $ZodSymbol.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>symbolProcessor(inst, ctx, json, params);
-});
-function symbol(params) {
-    return _symbol(ZodSymbol, params);
-}
-const ZodUndefined = /*@__PURE__*/ $constructor("ZodUndefined", (inst, def)=>{
-    $ZodUndefined.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>undefinedProcessor(inst, ctx, json, params);
-});
-function schemas_undefined(params) {
-    return api_undefined(ZodUndefined, params);
-}
-const ZodNull = /*@__PURE__*/ $constructor("ZodNull", (inst, def)=>{
-    $ZodNull.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>nullProcessor(inst, ctx, json, params);
-});
-function schemas_null(params) {
-    return api_null(ZodNull, params);
-}
-const ZodAny = /*@__PURE__*/ $constructor("ZodAny", (inst, def)=>{
-    $ZodAny.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>anyProcessor(inst, ctx, json, params);
-});
-function any() {
-    return _any(ZodAny);
-}
 const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def)=>{
     $ZodUnknown.init(inst, def);
     ZodType.init(inst, def);
@@ -5539,78 +3444,93 @@ const ZodNever = /*@__PURE__*/ $constructor("ZodNever", (inst, def)=>{
 function never(params) {
     return _never(ZodNever, params);
 }
-const ZodVoid = /*@__PURE__*/ $constructor("ZodVoid", (inst, def)=>{
-    $ZodVoid.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>voidProcessor(inst, ctx, json, params);
-});
-function schemas_void(params) {
-    return _void(ZodVoid, params);
-}
-const ZodDate = /*@__PURE__*/ $constructor("ZodDate", (inst, def)=>{
-    $ZodDate.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>dateProcessor(inst, ctx, json, params);
-    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 schemas_date(params) {
-    return _date(ZodDate, params);
-}
 const ZodArray = /*@__PURE__*/ $constructor("ZodArray", (inst, def)=>{
     $ZodArray.init(inst, def);
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params)=>arrayProcessor(inst, ctx, json, params);
     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;
+    _installLazyMethods(inst, "ZodArray", {
+        min (n, params) {
+            return this.check(_minLength(n, params));
+        },
+        nonempty (params) {
+            return this.check(_minLength(1, params));
+        },
+        max (n, params) {
+            return this.check(_maxLength(n, params));
+        },
+        length (n, params) {
+            return this.check(_length(n, params));
+        },
+        unwrap () {
+            return this.element;
+        }
+    });
 });
 function schemas_array(element, params) {
     return _array(ZodArray, element, params);
 }
-function keyof(schema) {
-    const shape = schema._zod.def.shape;
-    return schemas_enum(Object.keys(shape));
-}
 const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def)=>{
     $ZodObjectJIT.init(inst, def);
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params)=>objectProcessor(inst, ctx, json, params);
     defineLazy(inst, "shape", ()=>def.shape);
-    inst.keyof = ()=>schemas_enum(Object.keys(inst._zod.def.shape));
-    inst.catchall = (catchall)=>inst.clone({
-            ...inst._zod.def,
-            catchall: 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)=>extend(inst, incoming);
-    inst.safeExtend = (incoming)=>safeExtend(inst, incoming);
-    inst.merge = (other)=>merge(inst, other);
-    inst.pick = (mask)=>pick(inst, mask);
-    inst.omit = (mask)=>omit(inst, mask);
-    inst.partial = (...args)=>partial(ZodOptional, inst, args[0]);
-    inst.required = (...args)=>required(ZodNonOptional, inst, args[0]);
+    _installLazyMethods(inst, "ZodObject", {
+        keyof () {
+            return schemas_enum(Object.keys(this._zod.def.shape));
+        },
+        catchall (catchall) {
+            return this.clone({
+                ...this._zod.def,
+                catchall: catchall
+            });
+        },
+        passthrough () {
+            return this.clone({
+                ...this._zod.def,
+                catchall: unknown()
+            });
+        },
+        loose () {
+            return this.clone({
+                ...this._zod.def,
+                catchall: unknown()
+            });
+        },
+        strict () {
+            return this.clone({
+                ...this._zod.def,
+                catchall: never()
+            });
+        },
+        strip () {
+            return this.clone({
+                ...this._zod.def,
+                catchall: void 0
+            });
+        },
+        extend (incoming) {
+            return extend(this, incoming);
+        },
+        safeExtend (incoming) {
+            return safeExtend(this, incoming);
+        },
+        merge (other) {
+            return merge(this, other);
+        },
+        pick (mask) {
+            return pick(this, mask);
+        },
+        omit (mask) {
+            return omit(this, mask);
+        },
+        partial (...args) {
+            return partial(ZodOptional, this, args[0]);
+        },
+        required (...args) {
+            return required(ZodNonOptional, this, args[0]);
+        }
+    });
 });
 function schemas_object(shape, params) {
     const def = {
@@ -5620,22 +3540,6 @@ function schemas_object(shape, params) {
     };
     return new ZodObject(def);
 }
-function strictObject(shape, params) {
-    return new ZodObject({
-        type: "object",
-        shape,
-        catchall: never(),
-        ...normalizeParams(params)
-    });
-}
-function looseObject(shape, params) {
-    return new ZodObject({
-        type: "object",
-        shape,
-        catchall: unknown(),
-        ...normalizeParams(params)
-    });
-}
 const ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def)=>{
     $ZodUnion.init(inst, def);
     ZodType.init(inst, def);
@@ -5649,32 +3553,6 @@ function union(options, params) {
         ...normalizeParams(params)
     });
 }
-const ZodXor = /*@__PURE__*/ $constructor("ZodXor", (inst, def)=>{
-    ZodUnion.init(inst, def);
-    $ZodXor.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>unionProcessor(inst, ctx, json, params);
-    inst.options = def.options;
-});
-function xor(options, params) {
-    return new ZodXor({
-        type: "union",
-        options: options,
-        inclusive: false,
-        ...normalizeParams(params)
-    });
-}
-const ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("ZodDiscriminatedUnion", (inst, def)=>{
-    ZodUnion.init(inst, def);
-    $ZodDiscriminatedUnion.init(inst, def);
-});
-function discriminatedUnion(discriminator, options, params) {
-    return new ZodDiscriminatedUnion({
-        type: "union",
-        options,
-        discriminator,
-        ...normalizeParams(params)
-    });
-}
 const ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def)=>{
     $ZodIntersection.init(inst, def);
     ZodType.init(inst, def);
@@ -5687,95 +3565,6 @@ function intersection(left, right) {
         right: right
     });
 }
-const ZodTuple = /*@__PURE__*/ $constructor("ZodTuple", (inst, def)=>{
-    $ZodTuple.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>tupleProcessor(inst, ctx, json, params);
-    inst.rest = (rest)=>inst.clone({
-            ...inst._zod.def,
-            rest: rest
-        });
-});
-function tuple(items, _paramsOrRest, _params) {
-    const hasRest = _paramsOrRest instanceof $ZodType;
-    const params = hasRest ? _params : _paramsOrRest;
-    const rest = hasRest ? _paramsOrRest : null;
-    return new ZodTuple({
-        type: "tuple",
-        items: items,
-        rest,
-        ...normalizeParams(params)
-    });
-}
-const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def)=>{
-    $ZodRecord.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>recordProcessor(inst, ctx, json, params);
-    inst.keyType = def.keyType;
-    inst.valueType = def.valueType;
-});
-function record(keyType, valueType, params) {
-    return new ZodRecord({
-        type: "record",
-        keyType,
-        valueType: valueType,
-        ...normalizeParams(params)
-    });
-}
-function partialRecord(keyType, valueType, params) {
-    const k = clone(keyType);
-    k._zod.values = void 0;
-    return new ZodRecord({
-        type: "record",
-        keyType: k,
-        valueType: valueType,
-        ...normalizeParams(params)
-    });
-}
-function looseRecord(keyType, valueType, params) {
-    return new ZodRecord({
-        type: "record",
-        keyType,
-        valueType: valueType,
-        mode: "loose",
-        ...normalizeParams(params)
-    });
-}
-const ZodMap = /*@__PURE__*/ $constructor("ZodMap", (inst, def)=>{
-    $ZodMap.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>mapProcessor(inst, ctx, json, params);
-    inst.keyType = def.keyType;
-    inst.valueType = def.valueType;
-    inst.min = (...args)=>inst.check(_minSize(...args));
-    inst.nonempty = (params)=>inst.check(_minSize(1, params));
-    inst.max = (...args)=>inst.check(_maxSize(...args));
-    inst.size = (...args)=>inst.check(_size(...args));
-});
-function schemas_map(keyType, valueType, params) {
-    return new ZodMap({
-        type: "map",
-        keyType: keyType,
-        valueType: valueType,
-        ...normalizeParams(params)
-    });
-}
-const ZodSet = /*@__PURE__*/ $constructor("ZodSet", (inst, def)=>{
-    $ZodSet.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>setProcessor(inst, ctx, json, params);
-    inst.min = (...args)=>inst.check(_minSize(...args));
-    inst.nonempty = (params)=>inst.check(_minSize(1, params));
-    inst.max = (...args)=>inst.check(_maxSize(...args));
-    inst.size = (...args)=>inst.check(_size(...args));
-});
-function schemas_set(valueType, params) {
-    return new ZodSet({
-        type: "set",
-        valueType: valueType,
-        ...normalizeParams(params)
-    });
-}
 const ZodEnum = /*@__PURE__*/ $constructor("ZodEnum", (inst, def)=>{
     $ZodEnum.init(inst, def);
     ZodType.init(inst, def);
@@ -5819,47 +3608,6 @@ function schemas_enum(values, params) {
         ...normalizeParams(params)
     });
 }
-function nativeEnum(entries, params) {
-    return new ZodEnum({
-        type: "enum",
-        entries,
-        ...normalizeParams(params)
-    });
-}
-const ZodLiteral = /*@__PURE__*/ $constructor("ZodLiteral", (inst, def)=>{
-    $ZodLiteral.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>literalProcessor(inst, ctx, json, params);
-    inst.values = new Set(def.values);
-    Object.defineProperty(inst, "value", {
-        get () {
-            if (def.values.length > 1) throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
-            return def.values[0];
-        }
-    });
-});
-function literal(value, params) {
-    return new ZodLiteral({
-        type: "literal",
-        values: Array.isArray(value) ? value : [
-            value
-        ],
-        ...normalizeParams(params)
-    });
-}
-const ZodFile = /*@__PURE__*/ $constructor("ZodFile", (inst, def)=>{
-    $ZodFile.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>fileProcessor(inst, ctx, json, params);
-    inst.min = (size, params)=>inst.check(_minSize(size, params));
-    inst.max = (size, params)=>inst.check(_maxSize(size, params));
-    inst.mime = (types, params)=>inst.check(_mime(Array.isArray(types) ? types : [
-            types
-        ], params));
-});
-function schemas_file(params) {
-    return _file(ZodFile, params);
-}
 const ZodTransform = /*@__PURE__*/ $constructor("ZodTransform", (inst, def)=>{
     $ZodTransform.init(inst, def);
     ZodType.init(inst, def);
@@ -5880,9 +3628,11 @@ const ZodTransform = /*@__PURE__*/ $constructor("ZodTransform", (inst, def)=>{
         const output = def.transform(payload.value, payload);
         if (output instanceof Promise) return output.then((output)=>{
             payload.value = output;
+            payload.fallback = true;
             return payload;
         });
         payload.value = output;
+        payload.fallback = true;
         return payload;
     };
 });
@@ -5928,9 +3678,6 @@ function nullable(innerType) {
         innerType: innerType
     });
 }
-function schemas_nullish(innerType) {
-    return optional(nullable(innerType));
-}
 const ZodDefault = /*@__PURE__*/ $constructor("ZodDefault", (inst, def)=>{
     $ZodDefault.init(inst, def);
     ZodType.init(inst, def);
@@ -5975,18 +3722,6 @@ function nonoptional(innerType, params) {
         ...normalizeParams(params)
     });
 }
-const ZodSuccess = /*@__PURE__*/ $constructor("ZodSuccess", (inst, def)=>{
-    $ZodSuccess.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>successProcessor(inst, ctx, json, params);
-    inst.unwrap = ()=>inst._zod.def.innerType;
-});
-function success(innerType) {
-    return new ZodSuccess({
-        type: "success",
-        innerType: innerType
-    });
-}
 const ZodCatch = /*@__PURE__*/ $constructor("ZodCatch", (inst, def)=>{
     $ZodCatch.init(inst, def);
     ZodType.init(inst, def);
@@ -6001,14 +3736,6 @@ function schemas_catch(innerType, catchValue) {
         catchValue: "function" == typeof catchValue ? catchValue : ()=>catchValue
     });
 }
-const ZodNaN = /*@__PURE__*/ $constructor("ZodNaN", (inst, def)=>{
-    $ZodNaN.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>nanProcessor(inst, ctx, json, params);
-});
-function nan(params) {
-    return _nan(ZodNaN, params);
-}
 const ZodPipe = /*@__PURE__*/ $constructor("ZodPipe", (inst, def)=>{
     $ZodPipe.init(inst, def);
     ZodType.init(inst, def);
@@ -6023,19 +3750,6 @@ function pipe(in_, out) {
         out: out
     });
 }
-const ZodCodec = /*@__PURE__*/ $constructor("ZodCodec", (inst, def)=>{
-    ZodPipe.init(inst, def);
-    $ZodCodec.init(inst, def);
-});
-function schemas_codec(in_, out, params) {
-    return new ZodCodec({
-        type: "pipe",
-        in: in_,
-        out: out,
-        transform: params.decode,
-        reverseTransform: params.encode
-    });
-}
 const ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def)=>{
     $ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
@@ -6048,185 +3762,17 @@ function readonly(innerType) {
         innerType: innerType
     });
 }
-const ZodTemplateLiteral = /*@__PURE__*/ $constructor("ZodTemplateLiteral", (inst, def)=>{
-    $ZodTemplateLiteral.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>templateLiteralProcessor(inst, ctx, json, params);
-});
-function templateLiteral(parts, params) {
-    return new ZodTemplateLiteral({
-        type: "template_literal",
-        parts,
-        ...normalizeParams(params)
-    });
-}
-const ZodLazy = /*@__PURE__*/ $constructor("ZodLazy", (inst, def)=>{
-    $ZodLazy.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>lazyProcessor(inst, ctx, json, params);
-    inst.unwrap = ()=>inst._zod.def.getter();
-});
-function lazy(getter) {
-    return new ZodLazy({
-        type: "lazy",
-        getter: getter
-    });
-}
-const ZodPromise = /*@__PURE__*/ $constructor("ZodPromise", (inst, def)=>{
-    $ZodPromise.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>promiseProcessor(inst, ctx, json, params);
-    inst.unwrap = ()=>inst._zod.def.innerType;
-});
-function promise(innerType) {
-    return new ZodPromise({
-        type: "promise",
-        innerType: innerType
-    });
-}
-const ZodFunction = /*@__PURE__*/ $constructor("ZodFunction", (inst, def)=>{
-    $ZodFunction.init(inst, def);
-    ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json, params)=>functionProcessor(inst, ctx, json, params);
-});
-function _function(params) {
-    return new ZodFunction({
-        type: "function",
-        input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? schemas_array(unknown()),
-        output: params?.output ?? unknown()
-    });
-}
 const ZodCustom = /*@__PURE__*/ $constructor("ZodCustom", (inst, def)=>{
     $ZodCustom.init(inst, def);
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params)=>customProcessor(inst, ctx, json, params);
 });
-function schemas_check(fn) {
-    const ch = new $ZodCheck({
-        check: "custom"
-    });
-    ch._zod.check = fn;
-    return ch;
-}
-function custom(fn, _params) {
-    return _custom(ZodCustom, fn ?? (()=>true), _params);
-}
 function refine(fn, _params = {}) {
     return _refine(ZodCustom, fn, _params);
 }
-function superRefine(fn) {
-    return _superRefine(fn);
-}
-const schemas_describe = describe;
-const schemas_meta = api_meta;
-function _instanceof(cls, params = {}) {
-    const inst = new ZodCustom({
-        type: "custom",
-        check: "custom",
-        fn: (data)=>data instanceof cls,
-        abort: true,
-        ...normalizeParams(params)
-    });
-    inst._zod.bag.Class = cls;
-    inst._zod.check = (payload)=>{
-        if (!(payload.value instanceof cls)) payload.issues.push({
-            code: "invalid_type",
-            expected: cls.name,
-            input: payload.value,
-            inst,
-            path: [
-                ...inst._zod.def.path ?? []
-            ]
-        });
-    };
-    return inst;
+function superRefine(fn, params) {
+    return _superRefine(fn, params);
 }
-const stringbool = (...args)=>_stringbool({
-        Codec: ZodCodec,
-        Boolean: ZodBoolean,
-        String: ZodString
-    }, ...args);
-function schemas_json(params) {
-    const jsonSchema = lazy(()=>union([
-            schemas_string(params),
-            schemas_number(),
-            schemas_boolean(),
-            schemas_null(),
-            schemas_array(jsonSchema),
-            record(schemas_string(), jsonSchema)
-        ]));
-    return jsonSchema;
-}
-function preprocess(fn, schema) {
-    return pipe(transform(fn), schema);
-}
-var compat_ZodFirstPartyTypeKind;
-compat_ZodFirstPartyTypeKind || (compat_ZodFirstPartyTypeKind = {});
-({
-    ...classic_schemas_namespaceObject,
-    ...classic_checks_namespaceObject,
-    iso: iso_namespaceObject
-});
-new Set([
-    "$schema",
-    "$ref",
-    "$defs",
-    "definitions",
-    "$id",
-    "id",
-    "$comment",
-    "$anchor",
-    "$vocabulary",
-    "$dynamicRef",
-    "$dynamicAnchor",
-    "type",
-    "enum",
-    "const",
-    "anyOf",
-    "oneOf",
-    "allOf",
-    "not",
-    "properties",
-    "required",
-    "additionalProperties",
-    "patternProperties",
-    "propertyNames",
-    "minProperties",
-    "maxProperties",
-    "items",
-    "prefixItems",
-    "additionalItems",
-    "minItems",
-    "maxItems",
-    "uniqueItems",
-    "contains",
-    "minContains",
-    "maxContains",
-    "minLength",
-    "maxLength",
-    "pattern",
-    "format",
-    "minimum",
-    "maximum",
-    "exclusiveMinimum",
-    "exclusiveMaximum",
-    "multipleOf",
-    "description",
-    "default",
-    "contentEncoding",
-    "contentMediaType",
-    "contentSchema",
-    "unevaluatedItems",
-    "unevaluatedProperties",
-    "if",
-    "then",
-    "else",
-    "dependentSchemas",
-    "dependentRequired",
-    "nullable",
-    "readOnly"
-]);
-core_config(en());
 const propMetadataSchema = schemas_object({
     name: schemas_string(),
     type: schemas_string(),