@xyo-network/hash 5.1.18 → 5.1.20

package/dist/browser/worker/wasmHash-bundle.mjs

@@ -49,6 +49,500 @@
     }
   });
 
+  // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/classic/external.js
+  var external_exports = {};
+  __export(external_exports, {
+    $brand: () => $brand,
+    $input: () => $input,
+    $output: () => $output,
+    NEVER: () => NEVER,
+    TimePrecision: () => TimePrecision,
+    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,
+    ZodError: () => ZodError,
+    ZodFile: () => ZodFile,
+    ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+    ZodFunction: () => ZodFunction,
+    ZodGUID: () => ZodGUID,
+    ZodIPv4: () => ZodIPv4,
+    ZodIPv6: () => ZodIPv6,
+    ZodISODate: () => ZodISODate,
+    ZodISODateTime: () => ZodISODateTime,
+    ZodISODuration: () => ZodISODuration,
+    ZodISOTime: () => ZodISOTime,
+    ZodIntersection: () => ZodIntersection,
+    ZodIssueCode: () => ZodIssueCode,
+    ZodJWT: () => ZodJWT,
+    ZodKSUID: () => ZodKSUID,
+    ZodLazy: () => ZodLazy,
+    ZodLiteral: () => ZodLiteral,
+    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,
+    ZodRealError: () => ZodRealError,
+    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,
+    _ZodString: () => _ZodString,
+    _default: () => _default2,
+    _function: () => _function,
+    any: () => any,
+    array: () => array,
+    base64: () => base642,
+    base64url: () => base64url2,
+    bigint: () => bigint2,
+    boolean: () => boolean2,
+    catch: () => _catch2,
+    check: () => check,
+    cidrv4: () => cidrv42,
+    cidrv6: () => cidrv62,
+    clone: () => clone,
+    codec: () => codec,
+    coerce: () => coerce_exports,
+    config: () => config,
+    core: () => core_exports2,
+    cuid: () => cuid3,
+    cuid2: () => cuid22,
+    custom: () => custom,
+    date: () => date3,
+    decode: () => decode2,
+    decodeAsync: () => decodeAsync2,
+    discriminatedUnion: () => discriminatedUnion,
+    e164: () => e1642,
+    email: () => email2,
+    emoji: () => emoji2,
+    encode: () => encode2,
+    encodeAsync: () => encodeAsync2,
+    endsWith: () => _endsWith,
+    enum: () => _enum2,
+    file: () => file,
+    flattenError: () => flattenError,
+    float32: () => float32,
+    float64: () => float64,
+    formatError: () => formatError,
+    function: () => _function,
+    getErrorMap: () => getErrorMap,
+    globalRegistry: () => globalRegistry,
+    gt: () => _gt,
+    gte: () => _gte,
+    guid: () => guid2,
+    hash: () => hash,
+    hex: () => hex2,
+    hostname: () => hostname2,
+    httpUrl: () => httpUrl,
+    includes: () => _includes,
+    instanceof: () => _instanceof,
+    int: () => int,
+    int32: () => int32,
+    int64: () => int64,
+    intersection: () => intersection,
+    ipv4: () => ipv42,
+    ipv6: () => ipv62,
+    iso: () => iso_exports,
+    json: () => json,
+    jwt: () => jwt,
+    keyof: () => keyof,
+    ksuid: () => ksuid2,
+    lazy: () => lazy,
+    length: () => _length,
+    literal: () => literal,
+    locales: () => locales_exports,
+    looseObject: () => looseObject,
+    lowercase: () => _lowercase,
+    lt: () => _lt,
+    lte: () => _lte,
+    map: () => map,
+    maxLength: () => _maxLength,
+    maxSize: () => _maxSize,
+    mime: () => _mime,
+    minLength: () => _minLength,
+    minSize: () => _minSize,
+    multipleOf: () => _multipleOf,
+    nan: () => nan,
+    nanoid: () => nanoid2,
+    nativeEnum: () => nativeEnum,
+    negative: () => _negative,
+    never: () => never,
+    nonnegative: () => _nonnegative,
+    nonoptional: () => nonoptional,
+    nonpositive: () => _nonpositive,
+    normalize: () => _normalize,
+    null: () => _null3,
+    nullable: () => nullable,
+    nullish: () => nullish2,
+    number: () => number2,
+    object: () => object,
+    optional: () => optional,
+    overwrite: () => _overwrite,
+    parse: () => parse2,
+    parseAsync: () => parseAsync2,
+    partialRecord: () => partialRecord,
+    pipe: () => pipe,
+    positive: () => _positive,
+    prefault: () => prefault,
+    preprocess: () => preprocess,
+    prettifyError: () => prettifyError,
+    promise: () => promise,
+    property: () => _property,
+    readonly: () => readonly,
+    record: () => record,
+    refine: () => refine,
+    regex: () => _regex,
+    regexes: () => regexes_exports,
+    registry: () => registry,
+    safeDecode: () => safeDecode2,
+    safeDecodeAsync: () => safeDecodeAsync2,
+    safeEncode: () => safeEncode2,
+    safeEncodeAsync: () => safeEncodeAsync2,
+    safeParse: () => safeParse2,
+    safeParseAsync: () => safeParseAsync2,
+    set: () => set,
+    setErrorMap: () => setErrorMap,
+    size: () => _size,
+    startsWith: () => _startsWith,
+    strictObject: () => strictObject,
+    string: () => string2,
+    stringFormat: () => stringFormat,
+    stringbool: () => stringbool,
+    success: () => success,
+    superRefine: () => superRefine,
+    symbol: () => symbol,
+    templateLiteral: () => templateLiteral,
+    toJSONSchema: () => toJSONSchema,
+    toLowerCase: () => _toLowerCase,
+    toUpperCase: () => _toUpperCase,
+    transform: () => transform,
+    treeifyError: () => treeifyError,
+    trim: () => _trim,
+    tuple: () => tuple,
+    uint32: () => uint32,
+    uint64: () => uint64,
+    ulid: () => ulid2,
+    undefined: () => _undefined3,
+    union: () => union,
+    unknown: () => unknown,
+    uppercase: () => _uppercase,
+    url: () => url,
+    util: () => util_exports,
+    uuid: () => uuid2,
+    uuidv4: () => uuidv4,
+    uuidv6: () => uuidv6,
+    uuidv7: () => uuidv7,
+    void: () => _void2,
+    xid: () => xid2
+  });
+
+  // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/core/index.js
+  var core_exports2 = {};
+  __export(core_exports2, {
+    $ZodAny: () => $ZodAny,
+    $ZodArray: () => $ZodArray,
+    $ZodAsyncError: () => $ZodAsyncError,
+    $ZodBase64: () => $ZodBase64,
+    $ZodBase64URL: () => $ZodBase64URL,
+    $ZodBigInt: () => $ZodBigInt,
+    $ZodBigIntFormat: () => $ZodBigIntFormat,
+    $ZodBoolean: () => $ZodBoolean,
+    $ZodCIDRv4: () => $ZodCIDRv4,
+    $ZodCIDRv6: () => $ZodCIDRv6,
+    $ZodCUID: () => $ZodCUID,
+    $ZodCUID2: () => $ZodCUID2,
+    $ZodCatch: () => $ZodCatch,
+    $ZodCheck: () => $ZodCheck,
+    $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
+    $ZodCheckEndsWith: () => $ZodCheckEndsWith,
+    $ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
+    $ZodCheckIncludes: () => $ZodCheckIncludes,
+    $ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
+    $ZodCheckLessThan: () => $ZodCheckLessThan,
+    $ZodCheckLowerCase: () => $ZodCheckLowerCase,
+    $ZodCheckMaxLength: () => $ZodCheckMaxLength,
+    $ZodCheckMaxSize: () => $ZodCheckMaxSize,
+    $ZodCheckMimeType: () => $ZodCheckMimeType,
+    $ZodCheckMinLength: () => $ZodCheckMinLength,
+    $ZodCheckMinSize: () => $ZodCheckMinSize,
+    $ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
+    $ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
+    $ZodCheckOverwrite: () => $ZodCheckOverwrite,
+    $ZodCheckProperty: () => $ZodCheckProperty,
+    $ZodCheckRegex: () => $ZodCheckRegex,
+    $ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
+    $ZodCheckStartsWith: () => $ZodCheckStartsWith,
+    $ZodCheckStringFormat: () => $ZodCheckStringFormat,
+    $ZodCheckUpperCase: () => $ZodCheckUpperCase,
+    $ZodCodec: () => $ZodCodec,
+    $ZodCustom: () => $ZodCustom,
+    $ZodCustomStringFormat: () => $ZodCustomStringFormat,
+    $ZodDate: () => $ZodDate,
+    $ZodDefault: () => $ZodDefault,
+    $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
+    $ZodE164: () => $ZodE164,
+    $ZodEmail: () => $ZodEmail,
+    $ZodEmoji: () => $ZodEmoji,
+    $ZodEncodeError: () => $ZodEncodeError,
+    $ZodEnum: () => $ZodEnum,
+    $ZodError: () => $ZodError,
+    $ZodFile: () => $ZodFile,
+    $ZodFunction: () => $ZodFunction,
+    $ZodGUID: () => $ZodGUID,
+    $ZodIPv4: () => $ZodIPv4,
+    $ZodIPv6: () => $ZodIPv6,
+    $ZodISODate: () => $ZodISODate,
+    $ZodISODateTime: () => $ZodISODateTime,
+    $ZodISODuration: () => $ZodISODuration,
+    $ZodISOTime: () => $ZodISOTime,
+    $ZodIntersection: () => $ZodIntersection,
+    $ZodJWT: () => $ZodJWT,
+    $ZodKSUID: () => $ZodKSUID,
+    $ZodLazy: () => $ZodLazy,
+    $ZodLiteral: () => $ZodLiteral,
+    $ZodMap: () => $ZodMap,
+    $ZodNaN: () => $ZodNaN,
+    $ZodNanoID: () => $ZodNanoID,
+    $ZodNever: () => $ZodNever,
+    $ZodNonOptional: () => $ZodNonOptional,
+    $ZodNull: () => $ZodNull,
+    $ZodNullable: () => $ZodNullable,
+    $ZodNumber: () => $ZodNumber,
+    $ZodNumberFormat: () => $ZodNumberFormat,
+    $ZodObject: () => $ZodObject,
+    $ZodObjectJIT: () => $ZodObjectJIT,
+    $ZodOptional: () => $ZodOptional,
+    $ZodPipe: () => $ZodPipe,
+    $ZodPrefault: () => $ZodPrefault,
+    $ZodPromise: () => $ZodPromise,
+    $ZodReadonly: () => $ZodReadonly,
+    $ZodRealError: () => $ZodRealError,
+    $ZodRecord: () => $ZodRecord,
+    $ZodRegistry: () => $ZodRegistry,
+    $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,
+    $brand: () => $brand,
+    $constructor: () => $constructor,
+    $input: () => $input,
+    $output: () => $output,
+    Doc: () => Doc,
+    JSONSchema: () => json_schema_exports,
+    JSONSchemaGenerator: () => JSONSchemaGenerator,
+    NEVER: () => NEVER,
+    TimePrecision: () => TimePrecision,
+    _any: () => _any,
+    _array: () => _array,
+    _base64: () => _base64,
+    _base64url: () => _base64url,
+    _bigint: () => _bigint,
+    _boolean: () => _boolean,
+    _catch: () => _catch,
+    _check: () => _check,
+    _cidrv4: () => _cidrv4,
+    _cidrv6: () => _cidrv6,
+    _coercedBigint: () => _coercedBigint,
+    _coercedBoolean: () => _coercedBoolean,
+    _coercedDate: () => _coercedDate,
+    _coercedNumber: () => _coercedNumber,
+    _coercedString: () => _coercedString,
+    _cuid: () => _cuid,
+    _cuid2: () => _cuid2,
+    _custom: () => _custom,
+    _date: () => _date,
+    _decode: () => _decode,
+    _decodeAsync: () => _decodeAsync,
+    _default: () => _default,
+    _discriminatedUnion: () => _discriminatedUnion,
+    _e164: () => _e164,
+    _email: () => _email,
+    _emoji: () => _emoji2,
+    _encode: () => _encode,
+    _encodeAsync: () => _encodeAsync,
+    _endsWith: () => _endsWith,
+    _enum: () => _enum,
+    _file: () => _file,
+    _float32: () => _float32,
+    _float64: () => _float64,
+    _gt: () => _gt,
+    _gte: () => _gte,
+    _guid: () => _guid,
+    _includes: () => _includes,
+    _int: () => _int,
+    _int32: () => _int32,
+    _int64: () => _int64,
+    _intersection: () => _intersection,
+    _ipv4: () => _ipv4,
+    _ipv6: () => _ipv6,
+    _isoDate: () => _isoDate,
+    _isoDateTime: () => _isoDateTime,
+    _isoDuration: () => _isoDuration,
+    _isoTime: () => _isoTime,
+    _jwt: () => _jwt,
+    _ksuid: () => _ksuid,
+    _lazy: () => _lazy,
+    _length: () => _length,
+    _literal: () => _literal,
+    _lowercase: () => _lowercase,
+    _lt: () => _lt,
+    _lte: () => _lte,
+    _map: () => _map,
+    _max: () => _lte,
+    _maxLength: () => _maxLength,
+    _maxSize: () => _maxSize,
+    _mime: () => _mime,
+    _min: () => _gte,
+    _minLength: () => _minLength,
+    _minSize: () => _minSize,
+    _multipleOf: () => _multipleOf,
+    _nan: () => _nan,
+    _nanoid: () => _nanoid,
+    _nativeEnum: () => _nativeEnum,
+    _negative: () => _negative,
+    _never: () => _never,
+    _nonnegative: () => _nonnegative,
+    _nonoptional: () => _nonoptional,
+    _nonpositive: () => _nonpositive,
+    _normalize: () => _normalize,
+    _null: () => _null2,
+    _nullable: () => _nullable,
+    _number: () => _number,
+    _optional: () => _optional,
+    _overwrite: () => _overwrite,
+    _parse: () => _parse,
+    _parseAsync: () => _parseAsync,
+    _pipe: () => _pipe,
+    _positive: () => _positive,
+    _promise: () => _promise,
+    _property: () => _property,
+    _readonly: () => _readonly,
+    _record: () => _record,
+    _refine: () => _refine,
+    _regex: () => _regex,
+    _safeDecode: () => _safeDecode,
+    _safeDecodeAsync: () => _safeDecodeAsync,
+    _safeEncode: () => _safeEncode,
+    _safeEncodeAsync: () => _safeEncodeAsync,
+    _safeParse: () => _safeParse,
+    _safeParseAsync: () => _safeParseAsync,
+    _set: () => _set,
+    _size: () => _size,
+    _startsWith: () => _startsWith,
+    _string: () => _string,
+    _stringFormat: () => _stringFormat,
+    _stringbool: () => _stringbool,
+    _success: () => _success,
+    _superRefine: () => _superRefine,
+    _symbol: () => _symbol,
+    _templateLiteral: () => _templateLiteral,
+    _toLowerCase: () => _toLowerCase,
+    _toUpperCase: () => _toUpperCase,
+    _transform: () => _transform,
+    _trim: () => _trim,
+    _tuple: () => _tuple,
+    _uint32: () => _uint32,
+    _uint64: () => _uint64,
+    _ulid: () => _ulid,
+    _undefined: () => _undefined2,
+    _union: () => _union,
+    _unknown: () => _unknown,
+    _uppercase: () => _uppercase,
+    _url: () => _url,
+    _uuid: () => _uuid,
+    _uuidv4: () => _uuidv4,
+    _uuidv6: () => _uuidv6,
+    _uuidv7: () => _uuidv7,
+    _void: () => _void,
+    _xid: () => _xid,
+    clone: () => clone,
+    config: () => config,
+    decode: () => decode,
+    decodeAsync: () => decodeAsync,
+    encode: () => encode,
+    encodeAsync: () => encodeAsync,
+    flattenError: () => flattenError,
+    formatError: () => formatError,
+    globalConfig: () => globalConfig,
+    globalRegistry: () => globalRegistry,
+    isValidBase64: () => isValidBase64,
+    isValidBase64URL: () => isValidBase64URL,
+    isValidJWT: () => isValidJWT,
+    locales: () => locales_exports,
+    parse: () => parse,
+    parseAsync: () => parseAsync,
+    prettifyError: () => prettifyError,
+    regexes: () => regexes_exports,
+    registry: () => registry,
+    safeDecode: () => safeDecode,
+    safeDecodeAsync: () => safeDecodeAsync,
+    safeEncode: () => safeEncode,
+    safeEncodeAsync: () => safeEncodeAsync,
+    safeParse: () => safeParse,
+    safeParseAsync: () => safeParseAsync,
+    toDotPath: () => toDotPath,
+    toJSONSchema: () => toJSONSchema,
+    treeifyError: () => treeifyError,
+    util: () => util_exports,
+    version: () => version
+  });
+
   // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/core/core.js
   var NEVER = Object.freeze({
     status: "aborted"
@@ -206,10 +700,10 @@
     return value;
   }
   function cached(getter) {
-    const set = false;
+    const set2 = false;
     return {
       get value() {
-        if (!set) {
+        if (!set2) {
           const value = getter();
           Object.defineProperty(this, "value", { value });
           return value;
@@ -242,9 +736,9 @@
     return valInt % stepInt / 10 ** decCount;
   }
   var EVALUATING = Symbol("evaluating");
-  function defineLazy(object, key, getter) {
+  function defineLazy(object2, key, getter) {
     let value = void 0;
-    Object.defineProperty(object, key, {
+    Object.defineProperty(object2, key, {
       get() {
         if (value === EVALUATING) {
           return void 0;
@@ -256,7 +750,7 @@
         return value;
       },
       set(v) {
-        Object.defineProperty(object, key, {
+        Object.defineProperty(object2, key, {
           value: v
           // configurable: true,
         });
@@ -707,8 +1201,8 @@
       return Number.isNaN(Number.parseInt(k, 10));
     }).map((el) => el[1]);
   }
-  function base64ToUint8Array(base642) {
-    const binaryString = atob(base642);
+  function base64ToUint8Array(base643) {
+    const binaryString = atob(base643);
     const bytes = new Uint8Array(binaryString.length);
     for (let i = 0; i < binaryString.length; i++) {
       bytes[i] = binaryString.charCodeAt(i);
@@ -722,16 +1216,16 @@
     }
     return btoa(binaryString);
   }
-  function base64urlToUint8Array(base64url2) {
-    const base642 = base64url2.replace(/-/g, "+").replace(/_/g, "/");
-    const padding = "=".repeat((4 - base642.length % 4) % 4);
-    return base64ToUint8Array(base642 + padding);
+  function base64urlToUint8Array(base64url3) {
+    const base643 = base64url3.replace(/-/g, "+").replace(/_/g, "/");
+    const padding = "=".repeat((4 - base643.length % 4) % 4);
+    return base64ToUint8Array(base643 + padding);
   }
   function uint8ArrayToBase64url(bytes) {
     return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
   }
-  function hexToUint8Array(hex2) {
-    const cleanHex = hex2.replace(/^0x/, "");
+  function hexToUint8Array(hex3) {
+    const cleanHex = hex3.replace(/^0x/, "");
     if (cleanHex.length % 2 !== 0) {
       throw new Error("Invalid hex string length");
     }
@@ -814,6 +1308,76 @@
     processError(error46);
     return fieldErrors;
   }
+  function treeifyError(error46, mapper = (issue2) => issue2.message) {
+    const result = { errors: [] };
+    const processError = (error47, path = []) => {
+      var _a2, _b;
+      for (const issue2 of error47.issues) {
+        if (issue2.code === "invalid_union" && issue2.errors.length) {
+          issue2.errors.map((issues) => processError({ issues }, issue2.path));
+        } else if (issue2.code === "invalid_key") {
+          processError({ issues: issue2.issues }, issue2.path);
+        } else if (issue2.code === "invalid_element") {
+          processError({ issues: issue2.issues }, issue2.path);
+        } else {
+          const fullpath = [...path, ...issue2.path];
+          if (fullpath.length === 0) {
+            result.errors.push(mapper(issue2));
+            continue;
+          }
+          let curr = result;
+          let i = 0;
+          while (i < fullpath.length) {
+            const el = fullpath[i];
+            const terminal = i === fullpath.length - 1;
+            if (typeof el === "string") {
+              curr.properties ?? (curr.properties = {});
+              (_a2 = curr.properties)[el] ?? (_a2[el] = { errors: [] });
+              curr = curr.properties[el];
+            } else {
+              curr.items ?? (curr.items = []);
+              (_b = curr.items)[el] ?? (_b[el] = { errors: [] });
+              curr = curr.items[el];
+            }
+            if (terminal) {
+              curr.errors.push(mapper(issue2));
+            }
+            i++;
+          }
+        }
+      }
+    };
+    processError(error46);
+    return result;
+  }
+  function toDotPath(_path) {
+    const segs = [];
+    const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+    for (const seg of path) {
+      if (typeof seg === "number")
+        segs.push(`[${seg}]`);
+      else if (typeof seg === "symbol")
+        segs.push(`[${JSON.stringify(String(seg))}]`);
+      else if (/[^\w$]/.test(seg))
+        segs.push(`[${JSON.stringify(seg)}]`);
+      else {
+        if (segs.length)
+          segs.push(".");
+        segs.push(seg);
+      }
+    }
+    return segs.join("");
+  }
+  function prettifyError(error46) {
+    const lines = [];
+    const issues = [...error46.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
+    for (const issue2 of issues) {
+      lines.push(`\u2716 ${issue2.message}`);
+      if (issue2.path?.length)
+        lines.push(`  \u2192 at ${toDotPath(issue2.path)}`);
+    }
+    return lines.join("\n");
+  }
 
   // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/core/parse.js
   var _parse = (_Err) => (schema, value, _ctx, _params) => {
@@ -829,6 +1393,7 @@
     }
     return result.value;
   };
+  var parse = /* @__PURE__ */ _parse($ZodRealError);
   var _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);
@@ -841,6 +1406,7 @@
     }
     return result.value;
   };
+  var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
   var _safeParse = (_Err) => (schema, value, _ctx) => {
     const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
     const result = schema._zod.run({ value, issues: [] }, ctx);
@@ -868,30 +1434,38 @@
     const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
     return _parse(_Err)(schema, value, ctx);
   };
+  var encode = /* @__PURE__ */ _encode($ZodRealError);
   var _decode = (_Err) => (schema, value, _ctx) => {
     return _parse(_Err)(schema, value, _ctx);
   };
+  var decode = /* @__PURE__ */ _decode($ZodRealError);
   var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
     const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
     return _parseAsync(_Err)(schema, value, ctx);
   };
+  var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
   var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
     return _parseAsync(_Err)(schema, value, _ctx);
   };
+  var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
   var _safeEncode = (_Err) => (schema, value, _ctx) => {
     const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
     return _safeParse(_Err)(schema, value, ctx);
   };
+  var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
   var _safeDecode = (_Err) => (schema, value, _ctx) => {
     return _safeParse(_Err)(schema, value, _ctx);
   };
+  var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
   var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
     const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
     return _safeParseAsync(_Err)(schema, value, ctx);
   };
+  var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
   var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
     return _safeParseAsync(_Err)(schema, value, _ctx);
   };
+  var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 
   // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/core/regexes.js
   var regexes_exports = {};
@@ -1210,6 +1784,125 @@
       }
     };
   });
+  var $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor("$ZodCheckBigIntFormat", (inst, def) => {
+    $ZodCheck.init(inst, def);
+    const [minimum, maximum] = BIGINT_FORMAT_RANGES[def.format];
+    inst._zod.onattach.push((inst2) => {
+      const bag = inst2._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,
+          inclusive: true,
+          inst,
+          continue: !def.abort
+        });
+      }
+      if (input > maximum) {
+        payload.issues.push({
+          origin: "bigint",
+          input,
+          code: "too_big",
+          maximum,
+          inst
+        });
+      }
+    };
+  });
+  var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => {
+    var _a2;
+    $ZodCheck.init(inst, def);
+    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+      const val = payload.value;
+      return !nullish(val) && val.size !== void 0;
+    });
+    inst._zod.onattach.push((inst2) => {
+      const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
+      if (def.maximum < curr)
+        inst2._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
+      });
+    };
+  });
+  var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => {
+    var _a2;
+    $ZodCheck.init(inst, def);
+    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+      const val = payload.value;
+      return !nullish(val) && val.size !== void 0;
+    });
+    inst._zod.onattach.push((inst2) => {
+      const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
+      if (def.minimum > curr)
+        inst2._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
+      });
+    };
+  });
+  var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => {
+    var _a2;
+    $ZodCheck.init(inst, def);
+    (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
+      const val = payload.value;
+      return !nullish(val) && val.size !== void 0;
+    });
+    inst._zod.onattach.push((inst2) => {
+      const bag = inst2._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
+      });
+    };
+  });
   var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
     var _a2;
     $ZodCheck.init(inst, def);
@@ -1424,6 +2117,43 @@
       });
     };
   });
+  function handleCheckPropertyResult(result, payload, property) {
+    if (result.issues.length) {
+      payload.issues.push(...prefixIssues(property, result.issues));
+    }
+  }
+  var $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],
+        issues: []
+      }, {});
+      if (result instanceof Promise) {
+        return result.then((result2) => handleCheckPropertyResult(result2, payload, def.property));
+      }
+      handleCheckPropertyResult(result, payload, def.property);
+      return;
+    };
+  });
+  var $ZodCheckMimeType = /* @__PURE__ */ $constructor("$ZodCheckMimeType", (inst, def) => {
+    $ZodCheck.init(inst, def);
+    const mimeSet = new Set(def.mime);
+    inst._zod.onattach.push((inst2) => {
+      inst2._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
+      });
+    };
+  });
   var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
     $ZodCheck.init(inst, def);
     inst._zod.check = (payload) => {
@@ -1431,6 +2161,42 @@
     };
   });
 
+  // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/core/doc.js
+  var Doc = class {
+    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 (typeof arg === "function") {
+        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(this.indent * 2) + 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"));
+    }
+  };
+
   // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/core/versions.js
   var version = {
     major: 4,
@@ -1605,10 +2371,10 @@
     inst._zod.check = (payload) => {
       try {
         const trimmed = payload.value.trim();
-        const url = new URL(trimmed);
+        const url2 = new URL(trimmed);
         if (def.hostname) {
           def.hostname.lastIndex = 0;
-          if (!def.hostname.test(url.hostname)) {
+          if (!def.hostname.test(url2.hostname)) {
             payload.issues.push({
               code: "invalid_format",
               format: "url",
@@ -1622,7 +2388,7 @@
         }
         if (def.protocol) {
           def.protocol.lastIndex = 0;
-          if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
+          if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) {
             payload.issues.push({
               code: "invalid_format",
               format: "url",
@@ -1635,7 +2401,7 @@
           }
         }
         if (def.normalize) {
-          payload.value = url.href;
+          payload.value = url2.href;
         } else {
           payload.value = trimmed;
         }
@@ -1789,8 +2555,8 @@
   function isValidBase64URL(data) {
     if (!base64url.test(data))
       return false;
-    const base642 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
-    const padded = base642.padEnd(Math.ceil(base642.length / 4) * 4, "=");
+    const base643 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
+    const padded = base643.padEnd(Math.ceil(base643.length / 4) * 4, "=");
     return isValidBase64(padded);
   }
   var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
@@ -1849,6 +2615,20 @@
       });
     };
   });
+  var $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
+      });
+    };
+  });
   var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.pattern = inst._zod.bag.pattern ?? number;
@@ -1877,6 +2657,27 @@
     $ZodCheckNumberFormat.init(inst, def);
     $ZodNumber.init(inst, def);
   });
+  var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = boolean;
+    inst._zod.parse = (payload, _ctx) => {
+      if (def.coerce)
+        try {
+          payload.value = Boolean(payload.value);
+        } catch (_) {
+        }
+      const input = payload.value;
+      if (typeof input === "boolean")
+        return payload;
+      payload.issues.push({
+        expected: "boolean",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
   var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.pattern = bigint;
@@ -1897,84 +2698,397 @@
       return payload;
     };
   });
-  function handleArrayResult(result, final, index) {
-    if (result.issues.length) {
-      final.issues.push(...prefixIssues(index, result.issues));
-    }
-    final.value[index] = result.value;
-  }
-  var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+  var $ZodBigIntFormat = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
+    $ZodCheckBigIntFormat.init(inst, def);
+    $ZodBigInt.init(inst, def);
+  });
+  var $ZodSymbol = /* @__PURE__ */ $constructor("$ZodSymbol", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.parse = (payload, ctx) => {
+    inst._zod.parse = (payload, _ctx) => {
       const input = payload.value;
-      if (!Array.isArray(input)) {
-        payload.issues.push({
-          expected: "array",
-          code: "invalid_type",
-          input,
-          inst
-        });
+      if (typeof input === "symbol")
         return payload;
-      }
-      payload.value = Array(input.length);
-      const proms = [];
-      for (let i = 0; i < input.length; i++) {
-        const item = input[i];
-        const result = def.element._zod.run({
-          value: item,
-          issues: []
-        }, ctx);
-        if (result instanceof Promise) {
-          proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
-        } else {
-          handleArrayResult(result, payload, i);
-        }
-      }
-      if (proms.length) {
-        return Promise.all(proms).then(() => payload);
-      }
+      payload.issues.push({
+        expected: "symbol",
+        code: "invalid_type",
+        input,
+        inst
+      });
       return payload;
     };
   });
-  function handleUnionResults(results, final, inst, ctx) {
-    for (const result of results) {
-      if (result.issues.length === 0) {
-        final.value = result.value;
-        return final;
-      }
-    }
-    const nonaborted = results.filter((r) => !aborted(r));
-    if (nonaborted.length === 1) {
-      final.value = nonaborted[0].value;
-      return nonaborted[0];
-    }
-    final.issues.push({
-      code: "invalid_union",
-      input: final.value,
-      inst,
-      errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-    });
-    return final;
-  }
-  var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
+  var $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = _undefined;
+    inst._zod.values = /* @__PURE__ */ new Set([void 0]);
+    inst._zod.optin = "optional";
+    inst._zod.optout = "optional";
+    inst._zod.parse = (payload, _ctx) => {
+      const input = payload.value;
+      if (typeof input === "undefined")
+        return payload;
+      payload.issues.push({
+        expected: "undefined",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
+  var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = _null;
+    inst._zod.values = /* @__PURE__ */ new Set([null]);
+    inst._zod.parse = (payload, _ctx) => {
+      const input = payload.value;
+      if (input === null)
+        return payload;
+      payload.issues.push({
+        expected: "null",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
+  var $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload) => payload;
+  });
+  var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload) => payload;
+  });
+  var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, _ctx) => {
+      payload.issues.push({
+        expected: "never",
+        code: "invalid_type",
+        input: payload.value,
+        inst
+      });
+      return payload;
+    };
+  });
+  var $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, _ctx) => {
+      const input = payload.value;
+      if (typeof input === "undefined")
+        return payload;
+      payload.issues.push({
+        expected: "void",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
+  var $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;
+  }
+  var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     $ZodType.init(inst, def);
-    defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
-    defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
-    defineLazy(inst._zod, "values", () => {
-      if (def.options.every((o) => o._zod.values)) {
-        return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
-      }
-      return void 0;
-    });
-    defineLazy(inst._zod, "pattern", () => {
-      if (def.options.every((o) => o._zod.pattern)) {
-        const patterns = def.options.map((o) => o._zod.pattern);
-        return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
-      }
-      return void 0;
-    });
-    const single = def.options.length === 1;
-    const first = def.options[0]._zod.run;
+    inst._zod.parse = (payload, ctx) => {
+      const input = payload.value;
+      if (!Array.isArray(input)) {
+        payload.issues.push({
+          expected: "array",
+          code: "invalid_type",
+          input,
+          inst
+        });
+        return payload;
+      }
+      payload.value = Array(input.length);
+      const proms = [];
+      for (let i = 0; i < input.length; i++) {
+        const item = input[i];
+        const result = def.element._zod.run({
+          value: item,
+          issues: []
+        }, ctx);
+        if (result instanceof Promise) {
+          proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
+        } else {
+          handleArrayResult(result, payload, i);
+        }
+      }
+      if (proms.length) {
+        return Promise.all(proms).then(() => payload);
+      }
+      return payload;
+    };
+  });
+  function handlePropertyResult(result, final, key, input) {
+    if (result.issues.length) {
+      final.issues.push(...prefixIssues(key, result.issues));
+    }
+    if (result.value === void 0) {
+      if (key in input) {
+        final.value[key] = void 0;
+      }
+    } else {
+      final.value[key] = result.value;
+    }
+  }
+  function normalizeDef(def) {
+    const keys = Object.keys(def.shape);
+    for (const k of keys) {
+      if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
+        throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+      }
+    }
+    const okeys = optionalKeys(def.shape);
+    return {
+      ...def,
+      keys,
+      keySet: new Set(keys),
+      numKeys: keys.length,
+      optionalKeys: new Set(okeys)
+    };
+  }
+  function handleCatchall(proms, input, payload, ctx, def, inst) {
+    const unrecognized = [];
+    const keySet = def.keySet;
+    const _catchall = def.catchall._zod;
+    const t = _catchall.def.type;
+    for (const key of Object.keys(input)) {
+      if (keySet.has(key))
+        continue;
+      if (t === "never") {
+        unrecognized.push(key);
+        continue;
+      }
+      const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+      if (r instanceof Promise) {
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
+      } else {
+        handlePropertyResult(r, payload, key, input);
+      }
+    }
+    if (unrecognized.length) {
+      payload.issues.push({
+        code: "unrecognized_keys",
+        keys: unrecognized,
+        input,
+        inst
+      });
+    }
+    if (!proms.length)
+      return payload;
+    return Promise.all(proms).then(() => {
+      return payload;
+    });
+  }
+  var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+    $ZodType.init(inst, def);
+    const desc = Object.getOwnPropertyDescriptor(def, "shape");
+    if (!desc?.get) {
+      const sh = def.shape;
+      Object.defineProperty(def, "shape", {
+        get: () => {
+          const newSh = { ...sh };
+          Object.defineProperty(def, "shape", {
+            value: newSh
+          });
+          return newSh;
+        }
+      });
+    }
+    const _normalized = cached(() => normalizeDef(def));
+    defineLazy(inst._zod, "propValues", () => {
+      const shape = def.shape;
+      const propValues = {};
+      for (const key in shape) {
+        const field = shape[key]._zod;
+        if (field.values) {
+          propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+          for (const v of field.values)
+            propValues[key].add(v);
+        }
+      }
+      return propValues;
+    });
+    const isObject2 = isObject;
+    const catchall = def.catchall;
+    let value;
+    inst._zod.parse = (payload, ctx) => {
+      value ?? (value = _normalized.value);
+      const input = payload.value;
+      if (!isObject2(input)) {
+        payload.issues.push({
+          expected: "object",
+          code: "invalid_type",
+          input,
+          inst
+        });
+        return payload;
+      }
+      payload.value = {};
+      const proms = [];
+      const shape = value.shape;
+      for (const key of value.keys) {
+        const el = shape[key];
+        const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+        if (r instanceof Promise) {
+          proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
+        } else {
+          handlePropertyResult(r, payload, key, input);
+        }
+      }
+      if (!catchall) {
+        return proms.length ? Promise.all(proms).then(() => payload) : payload;
+      }
+      return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+    };
+  });
+  var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
+    $ZodObject.init(inst, def);
+    const superParse = inst._zod.parse;
+    const _normalized = cached(() => normalizeDef(def));
+    const generateFastpass = (shape) => {
+      const doc = new Doc(["shape", "payload", "ctx"]);
+      const normalized = _normalized.value;
+      const parseStr = (key) => {
+        const k = esc(key);
+        return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
+      };
+      doc.write(`const input = payload.value;`);
+      const ids = /* @__PURE__ */ Object.create(null);
+      let counter = 0;
+      for (const key of normalized.keys) {
+        ids[key] = `key_${counter++}`;
+      }
+      doc.write(`const newResult = {};`);
+      for (const key of normalized.keys) {
+        const id = ids[key];
+        const k = esc(key);
+        doc.write(`const ${id} = ${parseStr(key)};`);
+        doc.write(`
+        if (${id}.issues.length) {
+          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${k}, ...iss.path] : [${k}]
+          })));
+        }
+        
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+      }
+      doc.write(`payload.value = newResult;`);
+      doc.write(`return payload;`);
+      const fn = doc.compile();
+      return (payload, ctx) => fn(shape, payload, ctx);
+    };
+    let fastpass;
+    const isObject2 = isObject;
+    const jit = !globalConfig.jitless;
+    const allowsEval2 = allowsEval;
+    const fastEnabled = jit && allowsEval2.value;
+    const catchall = def.catchall;
+    let value;
+    inst._zod.parse = (payload, ctx) => {
+      value ?? (value = _normalized.value);
+      const input = payload.value;
+      if (!isObject2(input)) {
+        payload.issues.push({
+          expected: "object",
+          code: "invalid_type",
+          input,
+          inst
+        });
+        return payload;
+      }
+      if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
+        if (!fastpass)
+          fastpass = generateFastpass(def.shape);
+        payload = fastpass(payload, ctx);
+        if (!catchall)
+          return payload;
+        return handleCatchall([], input, payload, ctx, value, inst);
+      }
+      return superParse(payload, ctx);
+    };
+  });
+  function handleUnionResults(results, final, inst, ctx) {
+    for (const result of results) {
+      if (result.issues.length === 0) {
+        final.value = result.value;
+        return final;
+      }
+    }
+    const nonaborted = results.filter((r) => !aborted(r));
+    if (nonaborted.length === 1) {
+      final.value = nonaborted[0].value;
+      return nonaborted[0];
+    }
+    final.issues.push({
+      code: "invalid_union",
+      input: final.value,
+      inst,
+      errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+    });
+    return final;
+  }
+  var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
+    $ZodType.init(inst, def);
+    defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
+    defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
+    defineLazy(inst._zod, "values", () => {
+      if (def.options.every((o) => o._zod.values)) {
+        return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+      }
+      return void 0;
+    });
+    defineLazy(inst._zod, "pattern", () => {
+      if (def.options.every((o) => o._zod.pattern)) {
+        const patterns = def.options.map((o) => o._zod.pattern);
+        return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
+      }
+      return void 0;
+    });
+    const single = def.options.length === 1;
+    const first = def.options[0]._zod.run;
     inst._zod.parse = (payload, ctx) => {
       if (single) {
         return first(payload, ctx);
@@ -2002,6 +3116,71 @@
       });
     };
   });
+  var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
+    $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 || Object.keys(pv).length === 0)
+          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] = /* @__PURE__ */ new Set();
+          for (const val of v) {
+            propValues[k].add(val);
+          }
+        }
+      }
+      return propValues;
+    });
+    const disc = cached(() => {
+      const opts = def.options;
+      const map2 = /* @__PURE__ */ new Map();
+      for (const o of opts) {
+        const values = o._zod.propValues?.[def.discriminator];
+        if (!values || values.size === 0)
+          throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
+        for (const v of values) {
+          if (map2.has(v)) {
+            throw new Error(`Duplicate discriminator value "${String(v)}"`);
+          }
+          map2.set(v, o);
+        }
+      }
+      return map2;
+    });
+    inst._zod.parse = (payload, ctx) => {
+      const input = payload.value;
+      if (!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;
+    };
+  });
   var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
@@ -2077,6 +3256,322 @@
     result.value = merged.data;
     return result;
   }
+  var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
+    $ZodType.init(inst, def);
+    const items = def.items;
+    const optStart = items.length - [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
+    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 = [];
+      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 } : { 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((result2) => handleTupleResult(result2, 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((result2) => handleTupleResult(result2, 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;
+  }
+  var $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 = [];
+      if (def.keyType._zod.values) {
+        const values = def.keyType._zod.values;
+        payload.value = {};
+        for (const key of values) {
+          if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+            const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+            if (result instanceof Promise) {
+              proms.push(result.then((result2) => {
+                if (result2.issues.length) {
+                  payload.issues.push(...prefixIssues(key, result2.issues));
+                }
+                payload.value[key] = result2.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 (!values.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 (key === "__proto__")
+            continue;
+          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+          if (keyResult instanceof Promise) {
+            throw new Error("Async schemas not supported in object keys currently");
+          }
+          if (keyResult.issues.length) {
+            payload.issues.push({
+              code: "invalid_key",
+              origin: "record",
+              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+              input: key,
+              path: [key],
+              inst
+            });
+            payload.value[keyResult.value] = keyResult.value;
+            continue;
+          }
+          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          if (result instanceof Promise) {
+            proms.push(result.then((result2) => {
+              if (result2.issues.length) {
+                payload.issues.push(...prefixIssues(key, result2.issues));
+              }
+              payload.value[keyResult.value] = result2.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;
+    };
+  });
+  var $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 = /* @__PURE__ */ 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, issues: [] }, ctx);
+        if (keyResult instanceof Promise || valueResult instanceof Promise) {
+          proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
+            handleMapResult(keyResult2, valueResult2, 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, 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,
+          issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+        });
+      }
+    }
+    final.value.set(keyResult.value, valueResult.value);
+  }
+  var $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 = /* @__PURE__ */ 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((result2) => handleSetResult(result2, 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);
+  }
+  var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+    $ZodType.init(inst, def);
+    const values = getEnumValues(def.entries);
+    const valuesSet = new Set(values);
+    inst._zod.values = valuesSet;
+    inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+    inst._zod.parse = (payload, _ctx) => {
+      const input = payload.value;
+      if (valuesSet.has(input)) {
+        return payload;
+      }
+      payload.issues.push({
+        code: "invalid_value",
+        values,
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
+  var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
+    $ZodType.init(inst, def);
+    if (def.values.length === 0) {
+      throw new Error("Cannot create literal schema with no valid values");
+    }
+    inst._zod.values = new Set(def.values);
+    inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
+    inst._zod.parse = (payload, _ctx) => {
+      const input = payload.value;
+      if (inst._zod.values.has(input)) {
+        return payload;
+      }
+      payload.issues.push({
+        code: "invalid_value",
+        values: def.values,
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
+  var $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;
+    };
+  });
   var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
@@ -2209,6 +3704,23 @@
     }
     return payload;
   }
+  var $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, ctx) => {
+      if (ctx.direction === "backward") {
+        throw new $ZodEncodeError("ZodSuccess");
+      }
+      const result = def.innerType._zod.run(payload, ctx);
+      if (result instanceof Promise) {
+        return result.then((result2) => {
+          payload.value = result2.issues.length === 0;
+          return payload;
+        });
+      }
+      payload.value = result.issues.length === 0;
+      return payload;
+    };
+  });
   var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
     $ZodType.init(inst, def);
     defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
@@ -2249,6 +3761,21 @@
       return payload;
     };
   });
+  var $ZodNaN = /* @__PURE__ */ $constructor("$ZodNaN", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, _ctx) => {
+      if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) {
+        payload.issues.push({
+          input: payload.value,
+          inst,
+          expected: "nan",
+          code: "invalid_type"
+        });
+        return payload;
+      }
+      return payload;
+    };
+  });
   var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
     $ZodType.init(inst, def);
     defineLazy(inst._zod, "values", () => def.in._zod.values);
@@ -2277,6 +3804,56 @@
     }
     return next._zod.run({ value: left.value, issues: left.issues }, ctx);
   }
+  var $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 (direction === "forward") {
+        const left = def.in._zod.run(payload, ctx);
+        if (left instanceof Promise) {
+          return left.then((left2) => handleCodecAResult(left2, def, ctx));
+        }
+        return handleCodecAResult(left, def, ctx);
+      } else {
+        const right = def.out._zod.run(payload, ctx);
+        if (right instanceof Promise) {
+          return right.then((right2) => handleCodecAResult(right2, 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 (direction === "forward") {
+      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);
+    } else {
+      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 }, ctx);
+  }
   var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
     $ZodType.init(inst, def);
     defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
@@ -2298,6 +3875,146 @@
     payload.value = Object.freeze(payload.value);
     return payload;
   }
+  var $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (inst, def) => {
+    $ZodType.init(inst, def);
+    const regexParts = [];
+    for (const part of def.parts) {
+      if (typeof part === "object" && part !== null) {
+        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 (part === null || 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 (typeof payload.value !== "string") {
+        payload.issues.push({
+          input: payload.value,
+          inst,
+          expected: "template_literal",
+          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;
+      }
+      return payload;
+    };
+  });
+  var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._def = def;
+    inst._zod.def = def;
+    inst.implement = (func) => {
+      if (typeof func !== "function") {
+        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 (typeof func !== "function") {
+        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 (typeof payload.value !== "function") {
+        payload.issues.push({
+          code: "invalid_type",
+          expected: "function",
+          input: payload.value,
+          inst
+        });
+        return payload;
+      }
+      const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise";
+      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;
+  });
+  var $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, ctx) => {
+      return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));
+    };
+  });
+  var $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);
+    };
+  });
   var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
     $ZodCheck.init(inst, def);
     $ZodType.init(inst, def);
@@ -5409,8 +7126,8 @@
   var capitalizeFirstCharacter = (text) => {
     return text.charAt(0).toUpperCase() + text.slice(1);
   };
-  function getUnitTypeFromNumber(number3) {
-    const abs = Math.abs(number3);
+  function getUnitTypeFromNumber(number4) {
+    const abs = Math.abs(number4);
     const last = abs % 10;
     const last2 = abs % 100;
     if (last2 >= 11 && last2 <= 19 || last === 0)
@@ -8057,6 +9774,13 @@
       ...normalizeParams(params)
     });
   }
+  function _coercedString(Class2, params) {
+    return new Class2({
+      type: "string",
+      coerce: true,
+      ...normalizeParams(params)
+    });
+  }
   function _email(Class2, params) {
     return new Class2({
       type: "string",
@@ -8258,6 +9982,13 @@
       ...normalizeParams(params)
     });
   }
+  var TimePrecision = {
+    Any: null,
+    Minute: -1,
+    Second: 0,
+    Millisecond: 3,
+    Microsecond: 6
+  };
   function _isoDateTime(Class2, params) {
     return new Class2({
       type: "string",
@@ -8301,6 +10032,14 @@
       ...normalizeParams(params)
     });
   }
+  function _coercedNumber(Class2, params) {
+    return new Class2({
+      type: "number",
+      coerce: true,
+      checks: [],
+      ...normalizeParams(params)
+    });
+  }
   function _int(Class2, params) {
     return new Class2({
       type: "number",
@@ -8310,12 +10049,145 @@
       ...normalizeParams(params)
     });
   }
+  function _float32(Class2, params) {
+    return new Class2({
+      type: "number",
+      check: "number_format",
+      abort: false,
+      format: "float32",
+      ...normalizeParams(params)
+    });
+  }
+  function _float64(Class2, params) {
+    return new Class2({
+      type: "number",
+      check: "number_format",
+      abort: false,
+      format: "float64",
+      ...normalizeParams(params)
+    });
+  }
+  function _int32(Class2, params) {
+    return new Class2({
+      type: "number",
+      check: "number_format",
+      abort: false,
+      format: "int32",
+      ...normalizeParams(params)
+    });
+  }
+  function _uint32(Class2, params) {
+    return new Class2({
+      type: "number",
+      check: "number_format",
+      abort: false,
+      format: "uint32",
+      ...normalizeParams(params)
+    });
+  }
+  function _boolean(Class2, params) {
+    return new Class2({
+      type: "boolean",
+      ...normalizeParams(params)
+    });
+  }
+  function _coercedBoolean(Class2, params) {
+    return new Class2({
+      type: "boolean",
+      coerce: true,
+      ...normalizeParams(params)
+    });
+  }
   function _bigint(Class2, params) {
     return new Class2({
       type: "bigint",
       ...normalizeParams(params)
     });
   }
+  function _coercedBigint(Class2, params) {
+    return new Class2({
+      type: "bigint",
+      coerce: true,
+      ...normalizeParams(params)
+    });
+  }
+  function _int64(Class2, params) {
+    return new Class2({
+      type: "bigint",
+      check: "bigint_format",
+      abort: false,
+      format: "int64",
+      ...normalizeParams(params)
+    });
+  }
+  function _uint64(Class2, params) {
+    return new Class2({
+      type: "bigint",
+      check: "bigint_format",
+      abort: false,
+      format: "uint64",
+      ...normalizeParams(params)
+    });
+  }
+  function _symbol(Class2, params) {
+    return new Class2({
+      type: "symbol",
+      ...normalizeParams(params)
+    });
+  }
+  function _undefined2(Class2, params) {
+    return new Class2({
+      type: "undefined",
+      ...normalizeParams(params)
+    });
+  }
+  function _null2(Class2, params) {
+    return new Class2({
+      type: "null",
+      ...normalizeParams(params)
+    });
+  }
+  function _any(Class2) {
+    return new Class2({
+      type: "any"
+    });
+  }
+  function _unknown(Class2) {
+    return new Class2({
+      type: "unknown"
+    });
+  }
+  function _never(Class2, params) {
+    return new Class2({
+      type: "never",
+      ...normalizeParams(params)
+    });
+  }
+  function _void(Class2, params) {
+    return new Class2({
+      type: "void",
+      ...normalizeParams(params)
+    });
+  }
+  function _date(Class2, params) {
+    return new Class2({
+      type: "date",
+      ...normalizeParams(params)
+    });
+  }
+  function _coercedDate(Class2, params) {
+    return new Class2({
+      type: "date",
+      coerce: true,
+      ...normalizeParams(params)
+    });
+  }
+  function _nan(Class2, params) {
+    return new Class2({
+      type: "nan",
+      ...normalizeParams(params)
+    });
+  }
   function _lt(value, params) {
     return new $ZodCheckLessThan({
       check: "less_than",
@@ -8344,15 +10216,48 @@
     return new $ZodCheckGreaterThan({
       check: "greater_than",
       ...normalizeParams(params),
-      value,
-      inclusive: true
+      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 _multipleOf(value, params) {
-    return new $ZodCheckMultipleOf({
-      check: "multiple_of",
+  function _size(size, params) {
+    return new $ZodCheckSizeEquals({
+      check: "size_equals",
       ...normalizeParams(params),
-      value
+      size
     });
   }
   function _maxLength(maximum, params) {
@@ -8423,6 +10328,21 @@
       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",
@@ -8451,6 +10371,180 @@
       ...normalizeParams(params)
     });
   }
+  function _union(Class2, options, params) {
+    return new Class2({
+      type: "union",
+      options,
+      ...normalizeParams(params)
+    });
+  }
+  function _discriminatedUnion(Class2, discriminator, options, params) {
+    return new Class2({
+      type: "union",
+      options,
+      discriminator,
+      ...normalizeParams(params)
+    });
+  }
+  function _intersection(Class2, left, right) {
+    return new Class2({
+      type: "intersection",
+      left,
+      right
+    });
+  }
+  function _tuple(Class2, items, _paramsOrRest, _params) {
+    const hasRest = _paramsOrRest instanceof $ZodType;
+    const params = hasRest ? _params : _paramsOrRest;
+    const rest = hasRest ? _paramsOrRest : null;
+    return new Class2({
+      type: "tuple",
+      items,
+      rest,
+      ...normalizeParams(params)
+    });
+  }
+  function _record(Class2, keyType, valueType, params) {
+    return new Class2({
+      type: "record",
+      keyType,
+      valueType,
+      ...normalizeParams(params)
+    });
+  }
+  function _map(Class2, keyType, valueType, params) {
+    return new Class2({
+      type: "map",
+      keyType,
+      valueType,
+      ...normalizeParams(params)
+    });
+  }
+  function _set(Class2, valueType, params) {
+    return new Class2({
+      type: "set",
+      valueType,
+      ...normalizeParams(params)
+    });
+  }
+  function _enum(Class2, values, params) {
+    const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+    return new Class2({
+      type: "enum",
+      entries,
+      ...normalizeParams(params)
+    });
+  }
+  function _nativeEnum(Class2, entries, params) {
+    return new Class2({
+      type: "enum",
+      entries,
+      ...normalizeParams(params)
+    });
+  }
+  function _literal(Class2, value, params) {
+    return new Class2({
+      type: "literal",
+      values: Array.isArray(value) ? value : [value],
+      ...normalizeParams(params)
+    });
+  }
+  function _file(Class2, params) {
+    return new Class2({
+      type: "file",
+      ...normalizeParams(params)
+    });
+  }
+  function _transform(Class2, fn) {
+    return new Class2({
+      type: "transform",
+      transform: fn
+    });
+  }
+  function _optional(Class2, innerType) {
+    return new Class2({
+      type: "optional",
+      innerType
+    });
+  }
+  function _nullable(Class2, innerType) {
+    return new Class2({
+      type: "nullable",
+      innerType
+    });
+  }
+  function _default(Class2, innerType, defaultValue) {
+    return new Class2({
+      type: "default",
+      innerType,
+      get defaultValue() {
+        return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
+      }
+    });
+  }
+  function _nonoptional(Class2, innerType, params) {
+    return new Class2({
+      type: "nonoptional",
+      innerType,
+      ...normalizeParams(params)
+    });
+  }
+  function _success(Class2, innerType) {
+    return new Class2({
+      type: "success",
+      innerType
+    });
+  }
+  function _catch(Class2, innerType, catchValue) {
+    return new Class2({
+      type: "catch",
+      innerType,
+      catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
+    });
+  }
+  function _pipe(Class2, in_, out) {
+    return new Class2({
+      type: "pipe",
+      in: in_,
+      out
+    });
+  }
+  function _readonly(Class2, innerType) {
+    return new Class2({
+      type: "readonly",
+      innerType
+    });
+  }
+  function _templateLiteral(Class2, parts, params) {
+    return new Class2({
+      type: "template_literal",
+      parts,
+      ...normalizeParams(params)
+    });
+  }
+  function _lazy(Class2, getter) {
+    return new Class2({
+      type: "lazy",
+      getter
+    });
+  }
+  function _promise(Class2, innerType) {
+    return new Class2({
+      type: "promise",
+      innerType
+    });
+  }
+  function _custom(Class2, fn, _params) {
+    const norm = normalizeParams(_params);
+    norm.abort ?? (norm.abort = true);
+    const schema = new Class2({
+      type: "custom",
+      check: "custom",
+      fn,
+      ...norm
+    });
+    return schema;
+  }
   function _refine(Class2, fn, _params) {
     const schema = new Class2({
       type: "custom",
@@ -8476,23 +10570,920 @@
           payload.issues.push(issue(_issue));
         }
       };
-      return fn(payload.value, payload);
-    });
-    return ch;
+      return fn(payload.value, payload);
+    });
+    return ch;
+  }
+  function _check(fn, params) {
+    const ch = new $ZodCheck({
+      check: "custom",
+      ...normalizeParams(params)
+    });
+    ch._zod.check = fn;
+    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 (params.case !== "sensitive") {
+      truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
+      falsyArray = falsyArray.map((v) => typeof v === "string" ? 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 codec2 = new _Codec({
+      type: "pipe",
+      in: stringSchema,
+      out: booleanSchema,
+      transform: ((input, payload) => {
+        let data = input;
+        if (params.case !== "sensitive")
+          data = data.toLowerCase();
+        if (truthySet.has(data)) {
+          return true;
+        } else if (falsySet.has(data)) {
+          return false;
+        } else {
+          payload.issues.push({
+            code: "invalid_value",
+            expected: "stringbool",
+            values: [...truthySet, ...falsySet],
+            input: payload.value,
+            inst: codec2,
+            continue: false
+          });
+          return {};
+        }
+      }),
+      reverseTransform: ((input, _payload) => {
+        if (input === true) {
+          return truthyArray[0] || "true";
+        } else {
+          return falsyArray[0] || "false";
+        }
+      }),
+      error: params.error
+    });
+    return codec2;
+  }
+  function _stringFormat(Class2, format, fnOrRegex, _params = {}) {
+    const params = normalizeParams(_params);
+    const def = {
+      ...normalizeParams(_params),
+      check: "string_format",
+      type: "string",
+      format,
+      fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
+      ...params
+    };
+    if (fnOrRegex instanceof RegExp) {
+      def.pattern = fnOrRegex;
+    }
+    const inst = new Class2(def);
+    return inst;
+  }
+
+  // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/core/to-json-schema.js
+  var JSONSchemaGenerator = class {
+    constructor(params) {
+      this.counter = 0;
+      this.metadataRegistry = params?.metadata ?? globalRegistry;
+      this.target = params?.target ?? "draft-2020-12";
+      this.unrepresentable = params?.unrepresentable ?? "throw";
+      this.override = params?.override ?? (() => {
+      });
+      this.io = params?.io ?? "output";
+      this.seen = /* @__PURE__ */ new Map();
+    }
+    process(schema, _params = { path: [], schemaPath: [] }) {
+      var _a2;
+      const def = schema._zod.def;
+      const formatMap = {
+        guid: "uuid",
+        url: "uri",
+        datetime: "date-time",
+        json_string: "json-string",
+        regex: ""
+        // do not set
+      };
+      const seen = this.seen.get(schema);
+      if (seen) {
+        seen.count++;
+        const isCycle = _params.schemaPath.includes(schema);
+        if (isCycle) {
+          seen.cycle = _params.path;
+        }
+        return seen.schema;
+      }
+      const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
+      this.seen.set(schema, result);
+      const overrideSchema = schema._zod.toJSONSchema?.();
+      if (overrideSchema) {
+        result.schema = overrideSchema;
+      } else {
+        const params = {
+          ..._params,
+          schemaPath: [..._params.schemaPath, schema],
+          path: _params.path
+        };
+        const parent = schema._zod.parent;
+        if (parent) {
+          result.ref = parent;
+          this.process(parent, params);
+          this.seen.get(parent).isParent = true;
+        } else {
+          const _json = result.schema;
+          switch (def.type) {
+            case "string": {
+              const json2 = _json;
+              json2.type = "string";
+              const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
+              if (typeof minimum === "number")
+                json2.minLength = minimum;
+              if (typeof maximum === "number")
+                json2.maxLength = maximum;
+              if (format) {
+                json2.format = formatMap[format] ?? format;
+                if (json2.format === "")
+                  delete json2.format;
+              }
+              if (contentEncoding)
+                json2.contentEncoding = contentEncoding;
+              if (patterns && patterns.size > 0) {
+                const regexes = [...patterns];
+                if (regexes.length === 1)
+                  json2.pattern = regexes[0].source;
+                else if (regexes.length > 1) {
+                  result.schema.allOf = [
+                    ...regexes.map((regex) => ({
+                      ...this.target === "draft-7" || this.target === "draft-4" || this.target === "openapi-3.0" ? { type: "string" } : {},
+                      pattern: regex.source
+                    }))
+                  ];
+                }
+              }
+              break;
+            }
+            case "number": {
+              const json2 = _json;
+              const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+              if (typeof format === "string" && format.includes("int"))
+                json2.type = "integer";
+              else
+                json2.type = "number";
+              if (typeof exclusiveMinimum === "number") {
+                if (this.target === "draft-4" || this.target === "openapi-3.0") {
+                  json2.minimum = exclusiveMinimum;
+                  json2.exclusiveMinimum = true;
+                } else {
+                  json2.exclusiveMinimum = exclusiveMinimum;
+                }
+              }
+              if (typeof minimum === "number") {
+                json2.minimum = minimum;
+                if (typeof exclusiveMinimum === "number" && this.target !== "draft-4") {
+                  if (exclusiveMinimum >= minimum)
+                    delete json2.minimum;
+                  else
+                    delete json2.exclusiveMinimum;
+                }
+              }
+              if (typeof exclusiveMaximum === "number") {
+                if (this.target === "draft-4" || this.target === "openapi-3.0") {
+                  json2.maximum = exclusiveMaximum;
+                  json2.exclusiveMaximum = true;
+                } else {
+                  json2.exclusiveMaximum = exclusiveMaximum;
+                }
+              }
+              if (typeof maximum === "number") {
+                json2.maximum = maximum;
+                if (typeof exclusiveMaximum === "number" && this.target !== "draft-4") {
+                  if (exclusiveMaximum <= maximum)
+                    delete json2.maximum;
+                  else
+                    delete json2.exclusiveMaximum;
+                }
+              }
+              if (typeof multipleOf === "number")
+                json2.multipleOf = multipleOf;
+              break;
+            }
+            case "boolean": {
+              const json2 = _json;
+              json2.type = "boolean";
+              break;
+            }
+            case "bigint": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("BigInt cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            case "symbol": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("Symbols cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            case "null": {
+              if (this.target === "openapi-3.0") {
+                _json.type = "string";
+                _json.nullable = true;
+                _json.enum = [null];
+              } else
+                _json.type = "null";
+              break;
+            }
+            case "any": {
+              break;
+            }
+            case "unknown": {
+              break;
+            }
+            case "undefined": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("Undefined cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            case "void": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("Void cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            case "never": {
+              _json.not = {};
+              break;
+            }
+            case "date": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("Date cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            case "array": {
+              const json2 = _json;
+              const { minimum, maximum } = schema._zod.bag;
+              if (typeof minimum === "number")
+                json2.minItems = minimum;
+              if (typeof maximum === "number")
+                json2.maxItems = maximum;
+              json2.type = "array";
+              json2.items = this.process(def.element, { ...params, path: [...params.path, "items"] });
+              break;
+            }
+            case "object": {
+              const json2 = _json;
+              json2.type = "object";
+              json2.properties = {};
+              const shape = def.shape;
+              for (const key in shape) {
+                json2.properties[key] = this.process(shape[key], {
+                  ...params,
+                  path: [...params.path, "properties", key]
+                });
+              }
+              const allKeys = new Set(Object.keys(shape));
+              const requiredKeys = new Set([...allKeys].filter((key) => {
+                const v = def.shape[key]._zod;
+                if (this.io === "input") {
+                  return v.optin === void 0;
+                } else {
+                  return v.optout === void 0;
+                }
+              }));
+              if (requiredKeys.size > 0) {
+                json2.required = Array.from(requiredKeys);
+              }
+              if (def.catchall?._zod.def.type === "never") {
+                json2.additionalProperties = false;
+              } else if (!def.catchall) {
+                if (this.io === "output")
+                  json2.additionalProperties = false;
+              } else if (def.catchall) {
+                json2.additionalProperties = this.process(def.catchall, {
+                  ...params,
+                  path: [...params.path, "additionalProperties"]
+                });
+              }
+              break;
+            }
+            case "union": {
+              const json2 = _json;
+              const options = def.options.map((x, i) => this.process(x, {
+                ...params,
+                path: [...params.path, "anyOf", i]
+              }));
+              json2.anyOf = options;
+              break;
+            }
+            case "intersection": {
+              const json2 = _json;
+              const a = this.process(def.left, {
+                ...params,
+                path: [...params.path, "allOf", 0]
+              });
+              const b = this.process(def.right, {
+                ...params,
+                path: [...params.path, "allOf", 1]
+              });
+              const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
+              const allOf = [
+                ...isSimpleIntersection(a) ? a.allOf : [a],
+                ...isSimpleIntersection(b) ? b.allOf : [b]
+              ];
+              json2.allOf = allOf;
+              break;
+            }
+            case "tuple": {
+              const json2 = _json;
+              json2.type = "array";
+              const prefixPath = this.target === "draft-2020-12" ? "prefixItems" : "items";
+              const restPath = this.target === "draft-2020-12" ? "items" : this.target === "openapi-3.0" ? "items" : "additionalItems";
+              const prefixItems = def.items.map((x, i) => this.process(x, {
+                ...params,
+                path: [...params.path, prefixPath, i]
+              }));
+              const rest = def.rest ? this.process(def.rest, {
+                ...params,
+                path: [...params.path, restPath, ...this.target === "openapi-3.0" ? [def.items.length] : []]
+              }) : null;
+              if (this.target === "draft-2020-12") {
+                json2.prefixItems = prefixItems;
+                if (rest) {
+                  json2.items = rest;
+                }
+              } else if (this.target === "openapi-3.0") {
+                json2.items = {
+                  anyOf: prefixItems
+                };
+                if (rest) {
+                  json2.items.anyOf.push(rest);
+                }
+                json2.minItems = prefixItems.length;
+                if (!rest) {
+                  json2.maxItems = prefixItems.length;
+                }
+              } else {
+                json2.items = prefixItems;
+                if (rest) {
+                  json2.additionalItems = rest;
+                }
+              }
+              const { minimum, maximum } = schema._zod.bag;
+              if (typeof minimum === "number")
+                json2.minItems = minimum;
+              if (typeof maximum === "number")
+                json2.maxItems = maximum;
+              break;
+            }
+            case "record": {
+              const json2 = _json;
+              json2.type = "object";
+              if (this.target === "draft-7" || this.target === "draft-2020-12") {
+                json2.propertyNames = this.process(def.keyType, {
+                  ...params,
+                  path: [...params.path, "propertyNames"]
+                });
+              }
+              json2.additionalProperties = this.process(def.valueType, {
+                ...params,
+                path: [...params.path, "additionalProperties"]
+              });
+              break;
+            }
+            case "map": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("Map cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            case "set": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("Set cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            case "enum": {
+              const json2 = _json;
+              const values = getEnumValues(def.entries);
+              if (values.every((v) => typeof v === "number"))
+                json2.type = "number";
+              if (values.every((v) => typeof v === "string"))
+                json2.type = "string";
+              json2.enum = values;
+              break;
+            }
+            case "literal": {
+              const json2 = _json;
+              const vals = [];
+              for (const val of def.values) {
+                if (val === void 0) {
+                  if (this.unrepresentable === "throw") {
+                    throw new Error("Literal `undefined` cannot be represented in JSON Schema");
+                  } else {
+                  }
+                } else if (typeof val === "bigint") {
+                  if (this.unrepresentable === "throw") {
+                    throw new Error("BigInt literals cannot be represented in JSON Schema");
+                  } else {
+                    vals.push(Number(val));
+                  }
+                } else {
+                  vals.push(val);
+                }
+              }
+              if (vals.length === 0) {
+              } else if (vals.length === 1) {
+                const val = vals[0];
+                json2.type = val === null ? "null" : typeof val;
+                if (this.target === "draft-4" || this.target === "openapi-3.0") {
+                  json2.enum = [val];
+                } else {
+                  json2.const = val;
+                }
+              } else {
+                if (vals.every((v) => typeof v === "number"))
+                  json2.type = "number";
+                if (vals.every((v) => typeof v === "string"))
+                  json2.type = "string";
+                if (vals.every((v) => typeof v === "boolean"))
+                  json2.type = "string";
+                if (vals.every((v) => v === null))
+                  json2.type = "null";
+                json2.enum = vals;
+              }
+              break;
+            }
+            case "file": {
+              const json2 = _json;
+              const file2 = {
+                type: "string",
+                format: "binary",
+                contentEncoding: "binary"
+              };
+              const { minimum, maximum, mime } = schema._zod.bag;
+              if (minimum !== void 0)
+                file2.minLength = minimum;
+              if (maximum !== void 0)
+                file2.maxLength = maximum;
+              if (mime) {
+                if (mime.length === 1) {
+                  file2.contentMediaType = mime[0];
+                  Object.assign(json2, file2);
+                } else {
+                  json2.anyOf = mime.map((m) => {
+                    const mFile = { ...file2, contentMediaType: m };
+                    return mFile;
+                  });
+                }
+              } else {
+                Object.assign(json2, file2);
+              }
+              break;
+            }
+            case "transform": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("Transforms cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            case "nullable": {
+              const inner = this.process(def.innerType, params);
+              if (this.target === "openapi-3.0") {
+                result.ref = def.innerType;
+                _json.nullable = true;
+              } else {
+                _json.anyOf = [inner, { type: "null" }];
+              }
+              break;
+            }
+            case "nonoptional": {
+              this.process(def.innerType, params);
+              result.ref = def.innerType;
+              break;
+            }
+            case "success": {
+              const json2 = _json;
+              json2.type = "boolean";
+              break;
+            }
+            case "default": {
+              this.process(def.innerType, params);
+              result.ref = def.innerType;
+              _json.default = JSON.parse(JSON.stringify(def.defaultValue));
+              break;
+            }
+            case "prefault": {
+              this.process(def.innerType, params);
+              result.ref = def.innerType;
+              if (this.io === "input")
+                _json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+              break;
+            }
+            case "catch": {
+              this.process(def.innerType, params);
+              result.ref = def.innerType;
+              let catchValue;
+              try {
+                catchValue = def.catchValue(void 0);
+              } catch {
+                throw new Error("Dynamic catch values are not supported in JSON Schema");
+              }
+              _json.default = catchValue;
+              break;
+            }
+            case "nan": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("NaN cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            case "template_literal": {
+              const json2 = _json;
+              const pattern = schema._zod.pattern;
+              if (!pattern)
+                throw new Error("Pattern not found in template literal");
+              json2.type = "string";
+              json2.pattern = pattern.source;
+              break;
+            }
+            case "pipe": {
+              const innerType = this.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
+              this.process(innerType, params);
+              result.ref = innerType;
+              break;
+            }
+            case "readonly": {
+              this.process(def.innerType, params);
+              result.ref = def.innerType;
+              _json.readOnly = true;
+              break;
+            }
+            // passthrough types
+            case "promise": {
+              this.process(def.innerType, params);
+              result.ref = def.innerType;
+              break;
+            }
+            case "optional": {
+              this.process(def.innerType, params);
+              result.ref = def.innerType;
+              break;
+            }
+            case "lazy": {
+              const innerType = schema._zod.innerType;
+              this.process(innerType, params);
+              result.ref = innerType;
+              break;
+            }
+            case "custom": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("Custom types cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            case "function": {
+              if (this.unrepresentable === "throw") {
+                throw new Error("Function types cannot be represented in JSON Schema");
+              }
+              break;
+            }
+            default: {
+              def;
+            }
+          }
+        }
+      }
+      const meta = this.metadataRegistry.get(schema);
+      if (meta)
+        Object.assign(result.schema, meta);
+      if (this.io === "input" && isTransforming(schema)) {
+        delete result.schema.examples;
+        delete result.schema.default;
+      }
+      if (this.io === "input" && result.schema._prefault)
+        (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
+      delete result.schema._prefault;
+      const _result = this.seen.get(schema);
+      return _result.schema;
+    }
+    emit(schema, _params) {
+      const params = {
+        cycles: _params?.cycles ?? "ref",
+        reused: _params?.reused ?? "inline",
+        // unrepresentable: _params?.unrepresentable ?? "throw",
+        // uri: _params?.uri ?? ((id) => `${id}`),
+        external: _params?.external ?? void 0
+      };
+      const root = this.seen.get(schema);
+      if (!root)
+        throw new Error("Unprocessed schema. This is a bug in Zod.");
+      const makeURI = (entry) => {
+        const defsSegment = this.target === "draft-2020-12" ? "$defs" : "definitions";
+        if (params.external) {
+          const externalId = params.external.registry.get(entry[0])?.id;
+          const uriGenerator = params.external.uri ?? ((id2) => id2);
+          if (externalId) {
+            return { ref: uriGenerator(externalId) };
+          }
+          const id = entry[1].defId ?? entry[1].schema.id ?? `schema${this.counter++}`;
+          entry[1].defId = id;
+          return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
+        }
+        if (entry[1] === root) {
+          return { ref: "#" };
+        }
+        const uriPrefix = `#`;
+        const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
+        const defId = entry[1].schema.id ?? `__schema${this.counter++}`;
+        return { defId, ref: defUriPrefix + defId };
+      };
+      const extractToDef = (entry) => {
+        if (entry[1].schema.$ref) {
+          return;
+        }
+        const seen = entry[1];
+        const { ref, defId } = makeURI(entry);
+        seen.def = { ...seen.schema };
+        if (defId)
+          seen.defId = defId;
+        const schema2 = seen.schema;
+        for (const key in schema2) {
+          delete schema2[key];
+        }
+        schema2.$ref = ref;
+      };
+      if (params.cycles === "throw") {
+        for (const entry of this.seen.entries()) {
+          const seen = entry[1];
+          if (seen.cycle) {
+            throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
+
+Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
+          }
+        }
+      }
+      for (const entry of this.seen.entries()) {
+        const seen = entry[1];
+        if (schema === entry[0]) {
+          extractToDef(entry);
+          continue;
+        }
+        if (params.external) {
+          const ext = params.external.registry.get(entry[0])?.id;
+          if (schema !== entry[0] && ext) {
+            extractToDef(entry);
+            continue;
+          }
+        }
+        const id = this.metadataRegistry.get(entry[0])?.id;
+        if (id) {
+          extractToDef(entry);
+          continue;
+        }
+        if (seen.cycle) {
+          extractToDef(entry);
+          continue;
+        }
+        if (seen.count > 1) {
+          if (params.reused === "ref") {
+            extractToDef(entry);
+            continue;
+          }
+        }
+      }
+      const flattenRef = (zodSchema, params2) => {
+        const seen = this.seen.get(zodSchema);
+        const schema2 = seen.def ?? seen.schema;
+        const _cached = { ...schema2 };
+        if (seen.ref === null) {
+          return;
+        }
+        const ref = seen.ref;
+        seen.ref = null;
+        if (ref) {
+          flattenRef(ref, params2);
+          const refSchema = this.seen.get(ref).schema;
+          if (refSchema.$ref && (params2.target === "draft-7" || params2.target === "draft-4" || params2.target === "openapi-3.0")) {
+            schema2.allOf = schema2.allOf ?? [];
+            schema2.allOf.push(refSchema);
+          } else {
+            Object.assign(schema2, refSchema);
+            Object.assign(schema2, _cached);
+          }
+        }
+        if (!seen.isParent)
+          this.override({
+            zodSchema,
+            jsonSchema: schema2,
+            path: seen.path ?? []
+          });
+      };
+      for (const entry of [...this.seen.entries()].reverse()) {
+        flattenRef(entry[0], { target: this.target });
+      }
+      const result = {};
+      if (this.target === "draft-2020-12") {
+        result.$schema = "https://json-schema.org/draft/2020-12/schema";
+      } else if (this.target === "draft-7") {
+        result.$schema = "http://json-schema.org/draft-07/schema#";
+      } else if (this.target === "draft-4") {
+        result.$schema = "http://json-schema.org/draft-04/schema#";
+      } else if (this.target === "openapi-3.0") {
+      } else {
+        console.warn(`Invalid target: ${this.target}`);
+      }
+      if (params.external?.uri) {
+        const id = params.external.registry.get(schema)?.id;
+        if (!id)
+          throw new Error("Schema is missing an `id` property");
+        result.$id = params.external.uri(id);
+      }
+      Object.assign(result, root.def);
+      const defs = params.external?.defs ?? {};
+      for (const entry of this.seen.entries()) {
+        const seen = entry[1];
+        if (seen.def && seen.defId) {
+          defs[seen.defId] = seen.def;
+        }
+      }
+      if (params.external) {
+      } else {
+        if (Object.keys(defs).length > 0) {
+          if (this.target === "draft-2020-12") {
+            result.$defs = defs;
+          } else {
+            result.definitions = defs;
+          }
+        }
+      }
+      try {
+        return JSON.parse(JSON.stringify(result));
+      } catch (_err) {
+        throw new Error("Error converting schema to JSON.");
+      }
+    }
+  };
+  function toJSONSchema(input, _params) {
+    if (input instanceof $ZodRegistry) {
+      const gen2 = new JSONSchemaGenerator(_params);
+      const defs = {};
+      for (const entry of input._idmap.entries()) {
+        const [_, schema] = entry;
+        gen2.process(schema);
+      }
+      const schemas = {};
+      const external = {
+        registry: input,
+        uri: _params?.uri,
+        defs
+      };
+      for (const entry of input._idmap.entries()) {
+        const [key, schema] = entry;
+        schemas[key] = gen2.emit(schema, {
+          ..._params,
+          external
+        });
+      }
+      if (Object.keys(defs).length > 0) {
+        const defsSegment = gen2.target === "draft-2020-12" ? "$defs" : "definitions";
+        schemas.__shared = {
+          [defsSegment]: defs
+        };
+      }
+      return { schemas };
+    }
+    const gen = new JSONSchemaGenerator(_params);
+    gen.process(input);
+    return gen.emit(input, _params);
   }
-  function _check(fn, params) {
-    const ch = new $ZodCheck({
-      check: "custom",
-      ...normalizeParams(params)
-    });
-    ch._zod.check = fn;
-    return ch;
+  function isTransforming(_schema, _ctx) {
+    const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
+    if (ctx.seen.has(_schema))
+      return false;
+    ctx.seen.add(_schema);
+    const schema = _schema;
+    const def = schema._zod.def;
+    switch (def.type) {
+      case "string":
+      case "number":
+      case "bigint":
+      case "boolean":
+      case "date":
+      case "symbol":
+      case "undefined":
+      case "null":
+      case "any":
+      case "unknown":
+      case "never":
+      case "void":
+      case "literal":
+      case "enum":
+      case "nan":
+      case "file":
+      case "template_literal":
+        return false;
+      case "array": {
+        return isTransforming(def.element, ctx);
+      }
+      case "object": {
+        for (const key in def.shape) {
+          if (isTransforming(def.shape[key], ctx))
+            return true;
+        }
+        return false;
+      }
+      case "union": {
+        for (const option of def.options) {
+          if (isTransforming(option, ctx))
+            return true;
+        }
+        return false;
+      }
+      case "intersection": {
+        return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+      }
+      case "tuple": {
+        for (const item of def.items) {
+          if (isTransforming(item, ctx))
+            return true;
+        }
+        if (def.rest && isTransforming(def.rest, ctx))
+          return true;
+        return false;
+      }
+      case "record": {
+        return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+      }
+      case "map": {
+        return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+      }
+      case "set": {
+        return isTransforming(def.valueType, ctx);
+      }
+      // inner types
+      case "promise":
+      case "optional":
+      case "nonoptional":
+      case "nullable":
+      case "readonly":
+        return isTransforming(def.innerType, ctx);
+      case "lazy":
+        return isTransforming(def.getter(), ctx);
+      case "default": {
+        return isTransforming(def.innerType, ctx);
+      }
+      case "prefault": {
+        return isTransforming(def.innerType, ctx);
+      }
+      case "custom": {
+        return false;
+      }
+      case "transform": {
+        return true;
+      }
+      case "pipe": {
+        return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+      }
+      case "success": {
+        return false;
+      }
+      case "catch": {
+        return false;
+      }
+      case "function": {
+        return false;
+      }
+      default:
+        def;
+    }
+    throw new Error(`Unknown schema type: ${def.type}`);
   }
 
   // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/core/json-schema.js
   var json_schema_exports = {};
 
   // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/classic/iso.js
+  var iso_exports = {};
+  __export(iso_exports, {
+    ZodISODate: () => ZodISODate,
+    ZodISODateTime: () => ZodISODateTime,
+    ZodISODuration: () => ZodISODuration,
+    ZodISOTime: () => ZodISOTime,
+    date: () => date2,
+    datetime: () => datetime2,
+    duration: () => duration2,
+    time: () => time2
+  });
   var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
     $ZodISODateTime.init(inst, def);
     ZodStringFormat.init(inst, def);
@@ -8567,14 +11558,14 @@
   var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
   var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
   var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
-  var encode = /* @__PURE__ */ _encode(ZodRealError);
-  var decode = /* @__PURE__ */ _decode(ZodRealError);
-  var encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
-  var decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
-  var safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
-  var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
-  var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
-  var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
+  var encode2 = /* @__PURE__ */ _encode(ZodRealError);
+  var decode2 = /* @__PURE__ */ _decode(ZodRealError);
+  var encodeAsync2 = /* @__PURE__ */ _encodeAsync(ZodRealError);
+  var decodeAsync2 = /* @__PURE__ */ _decodeAsync(ZodRealError);
+  var safeEncode2 = /* @__PURE__ */ _safeEncode(ZodRealError);
+  var safeDecode2 = /* @__PURE__ */ _safeDecode(ZodRealError);
+  var safeEncodeAsync2 = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
+  var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 
   // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/classic/schemas.js
   var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
@@ -8601,15 +11592,15 @@
     inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
     inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
     inst.spa = inst.safeParseAsync;
-    inst.encode = (data, params) => encode(inst, data, params);
-    inst.decode = (data, params) => decode(inst, data, params);
-    inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
-    inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
-    inst.safeEncode = (data, params) => safeEncode(inst, data, params);
-    inst.safeDecode = (data, params) => safeDecode(inst, data, params);
-    inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
-    inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
-    inst.refine = (check, params) => inst.check(refine(check, params));
+    inst.encode = (data, params) => encode2(inst, data, params);
+    inst.decode = (data, params) => decode2(inst, data, params);
+    inst.encodeAsync = async (data, params) => encodeAsync2(inst, data, params);
+    inst.decodeAsync = async (data, params) => decodeAsync2(inst, data, params);
+    inst.safeEncode = (data, params) => safeEncode2(inst, data, params);
+    inst.safeDecode = (data, params) => safeDecode2(inst, data, params);
+    inst.safeEncodeAsync = async (data, params) => safeEncodeAsync2(inst, data, params);
+    inst.safeDecodeAsync = async (data, params) => safeDecodeAsync2(inst, data, params);
+    inst.refine = (check2, params) => inst.check(refine(check2, params));
     inst.superRefine = (refinement) => inst.check(superRefine(refinement));
     inst.overwrite = (fn) => inst.check(_overwrite(fn));
     inst.optional = () => optional(inst);
@@ -8620,9 +11611,9 @@
     inst.or = (arg) => union([inst, arg]);
     inst.and = (arg) => intersection(inst, arg);
     inst.transform = (tx) => pipe(inst, transform(tx));
-    inst.default = (def2) => _default(inst, def2);
+    inst.default = (def2) => _default2(inst, def2);
     inst.prefault = (def2) => prefault(inst, def2);
-    inst.catch = (params) => _catch(inst, params);
+    inst.catch = (params) => _catch2(inst, params);
     inst.pipe = (target) => pipe(inst, target);
     inst.readonly = () => readonly(inst);
     inst.describe = (description) => {
@@ -8712,78 +11703,172 @@
     $ZodEmail.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function email2(params) {
+    return _email(ZodEmail, params);
+  }
   var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
     $ZodGUID.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function guid2(params) {
+    return _guid(ZodGUID, params);
+  }
   var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
     $ZodUUID.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function uuid2(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);
+  }
   var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
     $ZodURL.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function url(params) {
+    return _url(ZodURL, params);
+  }
+  function httpUrl(params) {
+    return _url(ZodURL, {
+      protocol: /^https?$/,
+      hostname: regexes_exports.domain,
+      ...util_exports.normalizeParams(params)
+    });
+  }
   var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
     $ZodEmoji.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function emoji2(params) {
+    return _emoji2(ZodEmoji, params);
+  }
   var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
     $ZodNanoID.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function nanoid2(params) {
+    return _nanoid(ZodNanoID, params);
+  }
   var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
     $ZodCUID.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function cuid3(params) {
+    return _cuid(ZodCUID, params);
+  }
   var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
     $ZodCUID2.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function cuid22(params) {
+    return _cuid2(ZodCUID2, params);
+  }
   var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
     $ZodULID.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function ulid2(params) {
+    return _ulid(ZodULID, params);
+  }
   var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
     $ZodXID.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function xid2(params) {
+    return _xid(ZodXID, params);
+  }
   var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
     $ZodKSUID.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function ksuid2(params) {
+    return _ksuid(ZodKSUID, params);
+  }
   var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
     $ZodIPv4.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function ipv42(params) {
+    return _ipv4(ZodIPv4, params);
+  }
   var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
     $ZodIPv6.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function ipv62(params) {
+    return _ipv6(ZodIPv6, params);
+  }
   var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
     $ZodCIDRv4.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function cidrv42(params) {
+    return _cidrv4(ZodCIDRv4, params);
+  }
   var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
     $ZodCIDRv6.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function cidrv62(params) {
+    return _cidrv6(ZodCIDRv6, params);
+  }
   var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
     $ZodBase64.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function base642(params) {
+    return _base64(ZodBase64, params);
+  }
   var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
     $ZodBase64URL.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function base64url2(params) {
+    return _base64url(ZodBase64URL, params);
+  }
   var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
     $ZodE164.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function e1642(params) {
+    return _e164(ZodE164, params);
+  }
   var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
     $ZodJWT.init(inst, def);
     ZodStringFormat.init(inst, def);
   });
+  function jwt(params) {
+    return _jwt(ZodJWT, params);
+  }
+  var 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 hostname2(_params) {
+    return _stringFormat(ZodCustomStringFormat, "hostname", regexes_exports.hostname, _params);
+  }
+  function hex2(_params) {
+    return _stringFormat(ZodCustomStringFormat, "hex", regexes_exports.hex, _params);
+  }
+  function hash(alg, params) {
+    const enc = params?.enc ?? "hex";
+    const format = `${alg}_${enc}`;
+    const regex = regexes_exports[format];
+    if (!regex)
+      throw new Error(`Unrecognized hash format: ${format}`);
+    return _stringFormat(ZodCustomStringFormat, format, regex, params);
+  }
   var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
     $ZodNumber.init(inst, def);
     ZodType.init(inst, def);
@@ -8819,6 +11904,25 @@
   function 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);
+  }
+  var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
+    $ZodBoolean.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function boolean2(params) {
+    return _boolean(ZodBoolean, params);
+  }
   var ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
     $ZodBigInt.init(inst, def);
     ZodType.init(inst, def);
@@ -8843,6 +11947,77 @@
   function bigint2(params) {
     return _bigint(ZodBigInt, params);
   }
+  var 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);
+  }
+  var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
+    $ZodSymbol.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function symbol(params) {
+    return _symbol(ZodSymbol, params);
+  }
+  var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
+    $ZodUndefined.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function _undefined3(params) {
+    return _undefined2(ZodUndefined, params);
+  }
+  var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
+    $ZodNull.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function _null3(params) {
+    return _null2(ZodNull, params);
+  }
+  var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
+    $ZodAny.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function any() {
+    return _any(ZodAny);
+  }
+  var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
+    $ZodUnknown.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function unknown() {
+    return _unknown(ZodUnknown);
+  }
+  var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
+    $ZodNever.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function never(params) {
+    return _never(ZodNever, params);
+  }
+  var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
+    $ZodVoid.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function _void2(params) {
+    return _void(ZodVoid, params);
+  }
+  var ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
+    $ZodDate.init(inst, def);
+    ZodType.init(inst, def);
+    inst.min = (value, params) => inst.check(_gte(value, params));
+    inst.max = (value, params) => inst.check(_lte(value, params));
+    const c = inst._zod.bag;
+    inst.minDate = c.minimum ? new Date(c.minimum) : null;
+    inst.maxDate = c.maximum ? new Date(c.maximum) : null;
+  });
+  function date3(params) {
+    return _date(ZodDate, params);
+  }
   var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
     $ZodArray.init(inst, def);
     ZodType.init(inst, def);
@@ -8856,6 +12031,58 @@
   function array(element, params) {
     return _array(ZodArray, element, params);
   }
+  function keyof(schema) {
+    const shape = schema._zod.def.shape;
+    return _enum2(Object.keys(shape));
+  }
+  var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
+    $ZodObjectJIT.init(inst, def);
+    ZodType.init(inst, def);
+    util_exports.defineLazy(inst, "shape", () => {
+      return def.shape;
+    });
+    inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape));
+    inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
+    inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
+    inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
+    inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
+    inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
+    inst.extend = (incoming) => {
+      return util_exports.extend(inst, incoming);
+    };
+    inst.safeExtend = (incoming) => {
+      return util_exports.safeExtend(inst, incoming);
+    };
+    inst.merge = (other) => util_exports.merge(inst, other);
+    inst.pick = (mask) => util_exports.pick(inst, mask);
+    inst.omit = (mask) => util_exports.omit(inst, mask);
+    inst.partial = (...args) => util_exports.partial(ZodOptional, inst, args[0]);
+    inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]);
+  });
+  function object(shape, params) {
+    const def = {
+      type: "object",
+      shape: shape ?? {},
+      ...util_exports.normalizeParams(params)
+    };
+    return new ZodObject(def);
+  }
+  function strictObject(shape, params) {
+    return new ZodObject({
+      type: "object",
+      shape,
+      catchall: never(),
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  function looseObject(shape, params) {
+    return new ZodObject({
+      type: "object",
+      shape,
+      catchall: unknown(),
+      ...util_exports.normalizeParams(params)
+    });
+  }
   var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
     $ZodUnion.init(inst, def);
     ZodType.init(inst, def);
@@ -8868,6 +12095,18 @@
       ...util_exports.normalizeParams(params)
     });
   }
+  var 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,
+      ...util_exports.normalizeParams(params)
+    });
+  }
   var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
     $ZodIntersection.init(inst, def);
     ZodType.init(inst, def);
@@ -8879,6 +12118,160 @@
       right
     });
   }
+  var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
+    $ZodTuple.init(inst, def);
+    ZodType.init(inst, def);
+    inst.rest = (rest) => inst.clone({
+      ...inst._zod.def,
+      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,
+      rest,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+    $ZodRecord.init(inst, def);
+    ZodType.init(inst, def);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
+  });
+  function record(keyType, valueType, params) {
+    return new ZodRecord({
+      type: "record",
+      keyType,
+      valueType,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  function partialRecord(keyType, valueType, params) {
+    const k = clone(keyType);
+    k._zod.values = void 0;
+    return new ZodRecord({
+      type: "record",
+      keyType: k,
+      valueType,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
+    $ZodMap.init(inst, def);
+    ZodType.init(inst, def);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
+  });
+  function map(keyType, valueType, params) {
+    return new ZodMap({
+      type: "map",
+      keyType,
+      valueType,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
+    $ZodSet.init(inst, def);
+    ZodType.init(inst, def);
+    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 set(valueType, params) {
+    return new ZodSet({
+      type: "set",
+      valueType,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
+    $ZodEnum.init(inst, def);
+    ZodType.init(inst, def);
+    inst.enum = def.entries;
+    inst.options = Object.values(def.entries);
+    const keys = new Set(Object.keys(def.entries));
+    inst.extract = (values, params) => {
+      const newEntries = {};
+      for (const value of values) {
+        if (keys.has(value)) {
+          newEntries[value] = def.entries[value];
+        } else
+          throw new Error(`Key ${value} not found in enum`);
+      }
+      return new ZodEnum({
+        ...def,
+        checks: [],
+        ...util_exports.normalizeParams(params),
+        entries: newEntries
+      });
+    };
+    inst.exclude = (values, params) => {
+      const newEntries = { ...def.entries };
+      for (const value of values) {
+        if (keys.has(value)) {
+          delete newEntries[value];
+        } else
+          throw new Error(`Key ${value} not found in enum`);
+      }
+      return new ZodEnum({
+        ...def,
+        checks: [],
+        ...util_exports.normalizeParams(params),
+        entries: newEntries
+      });
+    };
+  });
+  function _enum2(values, params) {
+    const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+    return new ZodEnum({
+      type: "enum",
+      entries,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  function nativeEnum(entries, params) {
+    return new ZodEnum({
+      type: "enum",
+      entries,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
+    $ZodLiteral.init(inst, def);
+    ZodType.init(inst, def);
+    inst.values = new Set(def.values);
+    Object.defineProperty(inst, "value", {
+      get() {
+        if (def.values.length > 1) {
+          throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+        }
+        return def.values[0];
+      }
+    });
+  });
+  function literal(value, params) {
+    return new ZodLiteral({
+      type: "literal",
+      values: Array.isArray(value) ? value : [value],
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
+    $ZodFile.init(inst, def);
+    ZodType.init(inst, def);
+    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 file(params) {
+    return _file(ZodFile, params);
+  }
   var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
     $ZodTransform.init(inst, def);
     ZodType.init(inst, def);
@@ -8938,13 +12331,16 @@
       innerType
     });
   }
+  function nullish2(innerType) {
+    return optional(nullable(innerType));
+  }
   var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
     $ZodDefault.init(inst, def);
     ZodType.init(inst, def);
     inst.unwrap = () => inst._zod.def.innerType;
     inst.removeDefault = inst.unwrap;
   });
-  function _default(innerType, defaultValue) {
+  function _default2(innerType, defaultValue) {
     return new ZodDefault({
       type: "default",
       innerType,
@@ -8979,19 +12375,37 @@
       ...util_exports.normalizeParams(params)
     });
   }
+  var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
+    $ZodSuccess.init(inst, def);
+    ZodType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+  });
+  function success(innerType) {
+    return new ZodSuccess({
+      type: "success",
+      innerType
+    });
+  }
   var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
     $ZodCatch.init(inst, def);
     ZodType.init(inst, def);
     inst.unwrap = () => inst._zod.def.innerType;
     inst.removeCatch = inst.unwrap;
   });
-  function _catch(innerType, catchValue) {
+  function _catch2(innerType, catchValue) {
     return new ZodCatch({
       type: "catch",
       innerType,
       catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
     });
   }
+  var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
+    $ZodNaN.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function nan(params) {
+    return _nan(ZodNaN, params);
+  }
   var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
     $ZodPipe.init(inst, def);
     ZodType.init(inst, def);
@@ -9006,6 +12420,19 @@
       // ...util.normalizeParams(params),
     });
   }
+  var ZodCodec = /* @__PURE__ */ $constructor("ZodCodec", (inst, def) => {
+    ZodPipe.init(inst, def);
+    $ZodCodec.init(inst, def);
+  });
+  function codec(in_, out, params) {
+    return new ZodCodec({
+      type: "pipe",
+      in: in_,
+      out,
+      transform: params.decode,
+      reverseTransform: params.encode
+    });
+  }
   var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
     $ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
@@ -9017,18 +12444,157 @@
       innerType
     });
   }
+  var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
+    $ZodTemplateLiteral.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function templateLiteral(parts, params) {
+    return new ZodTemplateLiteral({
+      type: "template_literal",
+      parts,
+      ...util_exports.normalizeParams(params)
+    });
+  }
+  var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
+    $ZodLazy.init(inst, def);
+    ZodType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.getter();
+  });
+  function lazy(getter) {
+    return new ZodLazy({
+      type: "lazy",
+      getter
+    });
+  }
+  var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
+    $ZodPromise.init(inst, def);
+    ZodType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+  });
+  function promise(innerType) {
+    return new ZodPromise({
+      type: "promise",
+      innerType
+    });
+  }
+  var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
+    $ZodFunction.init(inst, def);
+    ZodType.init(inst, def);
+  });
+  function _function(params) {
+    return new ZodFunction({
+      type: "function",
+      input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
+      output: params?.output ?? unknown()
+    });
+  }
   var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
     $ZodCustom.init(inst, def);
     ZodType.init(inst, def);
   });
+  function check(fn) {
+    const ch = new $ZodCheck({
+      check: "custom"
+      // ...util.normalizeParams(params),
+    });
+    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);
   }
+  function _instanceof(cls, params = {
+    error: `Input not instance of ${cls.name}`
+  }) {
+    const inst = new ZodCustom({
+      type: "custom",
+      check: "custom",
+      fn: (data) => data instanceof cls,
+      abort: true,
+      ...util_exports.normalizeParams(params)
+    });
+    inst._zod.bag.Class = cls;
+    return inst;
+  }
+  var stringbool = (...args) => _stringbool({
+    Codec: ZodCodec,
+    Boolean: ZodBoolean,
+    String: ZodString
+  }, ...args);
+  function json(params) {
+    const jsonSchema = lazy(() => {
+      return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
+    });
+    return jsonSchema;
+  }
+  function preprocess(fn, schema) {
+    return pipe(transform(fn), schema);
+  }
+
+  // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/classic/compat.js
+  var ZodIssueCode = {
+    invalid_type: "invalid_type",
+    too_big: "too_big",
+    too_small: "too_small",
+    invalid_format: "invalid_format",
+    not_multiple_of: "not_multiple_of",
+    unrecognized_keys: "unrecognized_keys",
+    invalid_union: "invalid_union",
+    invalid_key: "invalid_key",
+    invalid_element: "invalid_element",
+    invalid_value: "invalid_value",
+    custom: "custom"
+  };
+  function setErrorMap(map2) {
+    config({
+      customError: map2
+    });
+  }
+  function getErrorMap() {
+    return config().customError;
+  }
+  var ZodFirstPartyTypeKind;
+  /* @__PURE__ */ (function(ZodFirstPartyTypeKind2) {
+  })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+
+  // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/classic/coerce.js
+  var coerce_exports = {};
+  __export(coerce_exports, {
+    bigint: () => bigint3,
+    boolean: () => boolean3,
+    date: () => date4,
+    number: () => number3,
+    string: () => string3
+  });
+  function string3(params) {
+    return _coercedString(ZodString, params);
+  }
+  function number3(params) {
+    return _coercedNumber(ZodNumber, params);
+  }
+  function boolean3(params) {
+    return _coercedBoolean(ZodBoolean, params);
+  }
+  function bigint3(params) {
+    return _coercedBigint(ZodBigInt, params);
+  }
+  function date4(params) {
+    return _coercedDate(ZodDate, params);
+  }
+
+  // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/v4/classic/external.js
+  config(en_default());
+
+  // ../../../../../../node_modules/.store/zod-npm-4.1.12-8e1ffc4d68/package/index.js
+  var package_default = external_exports;
 
-  // ../../../../../../node_modules/.store/@xylabs-typeof-npm-5.0.19-4f1b9154ce/package/dist/neutral/index.mjs
+  // ../../../../../../node_modules/.store/@xylabs-typeof-npm-5.0.24-d111798ee6/package/dist/neutral/index.mjs
   function isUndefined(value) {
     return value === void 0;
   }
@@ -9039,7 +12605,7 @@
     return typeof value === "number";
   }
 
-  // ../../../../../../node_modules/.store/@xylabs-hex-npm-5.0.19-d0121eee74/package/dist/neutral/index.mjs
+  // ../../../../../../node_modules/.store/@xylabs-hex-npm-5.0.24-96a0124165/package/dist/neutral/index.mjs
   var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
     return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`);
   };
@@ -9117,7 +12683,7 @@
       }
     }
   };
-  var HexZod = string2().regex(HexRegEx, { message: "Invalid hex format" });
+  var HexZod = package_default.string().regex(HexRegEx, { message: "Invalid hex format" }).transform((val) => val);
   var toHex = (value, config2 = {}) => {
     const { prefix = false } = config2;
     return hexFrom(value, { prefix, ...config2 });
@@ -9162,7 +12728,8 @@
   };
   var isEthAddress = (value, config2 = {}) => {
     const { bitLength = 160, prefix = true } = config2;
-    return isHex(value, { bitLength, prefix });
+    const loweredValue = typeof value === "string" ? value.toLowerCase() : value;
+    return isHex(loweredValue, { bitLength, prefix });
   };
   var EthAddressZod = string2().regex(EthAddressRegEx, { message: "Invalid address format" }).refine(
     isEthAddress
@@ -9185,16 +12752,16 @@
   }
   var HASH_LENGTH = 32;
   var HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH);
-  var HashZod = string2().regex(HashRegEx, { message: "Invalid hex format" });
+  var HashZod = string2().regex(HashRegEx, { message: "Invalid hex format" }).transform((val) => val);
   var HashToJsonZod = HashZod.transform((v) => v);
   var JsonToHashZod = string2().transform((v) => asHash(v, true));
-  function hexToBigInt(hex2) {
-    return BigInt(hexFromHexString(hex2, { prefix: true }));
+  function hexToBigInt(hex3) {
+    return BigInt(hexFromHexString(hex3, { prefix: true }));
   }
   var BigIntToJsonZod = bigint2().nonnegative().transform((x) => toHex(x));
   var JsonToBigIntZod = string2().transform((x) => toHex(x)).transform((x) => hexToBigInt(x));
 
-  // ../../../../../../node_modules/.store/@xylabs-threads-npm-5.0.19-30005df3b4/package/dist/browser/worker/worker.browser.mjs
+  // ../../../../../../node_modules/.store/@xylabs-threads-npm-5.0.24-8d65a89667/package/dist/browser/worker/worker.browser.mjs
   var import_is_observable_2_1_0 = __toESM(require_package(), 1);
   var DefaultErrorSerializer = {
     deserialize(message) {
@@ -9619,8 +13186,8 @@
       const loadWASMPromise = wasmMutex.dispatch(() => __awaiter(this, void 0, void 0, function* () {
         if (!wasmModuleCache.has(binary.name)) {
           const asm = decodeBase64(binary.data);
-          const promise = WebAssembly.compile(asm);
-          wasmModuleCache.set(binary.name, promise);
+          const promise2 = WebAssembly.compile(asm);
+          wasmModuleCache.set(binary.name, promise2);
         }
         const module = yield wasmModuleCache.get(binary.name);
         wasmInstance = yield WebAssembly.instantiate(module, {
@@ -9803,8 +13370,8 @@
       });
     }
     try {
-      const hash = wasmCache$9.calculate(data, 256);
-      return Promise.resolve(hash);
+      const hash2 = wasmCache$9.calculate(data, 256);
+      return Promise.resolve(hash2);
     } catch (err) {
       return Promise.reject(err);
     }