@mastra/server 1.0.0-beta.6 → 1.0.0-beta.7

package/dist/{chunk-MK6GBMKE.js → chunk-OL6U27XK.js}

@@ -1,10 +1,10 @@
-import { listWorkflowsResponseSchema, LIST_WORKFLOWS_ROUTE, workflowInfoSchema, GET_WORKFLOW_BY_ID_ROUTE, workflowRunsResponseSchema, listWorkflowRunsQuerySchema, LIST_WORKFLOW_RUNS_ROUTE, workflowRunResponseSchema, GET_WORKFLOW_RUN_BY_ID_ROUTE, workflowExecutionResultSchema, GET_WORKFLOW_RUN_EXECUTION_RESULT_ROUTE, createWorkflowRunResponseSchema, CREATE_WORKFLOW_RUN_ROUTE, streamWorkflowBodySchema, STREAM_WORKFLOW_ROUTE, STREAM_VNEXT_WORKFLOW_ROUTE, startAsyncWorkflowBodySchema, START_ASYNC_WORKFLOW_ROUTE, workflowControlResponseSchema, START_WORKFLOW_RUN_ROUTE, OBSERVE_STREAM_WORKFLOW_ROUTE, OBSERVE_STREAM_VNEXT_WORKFLOW_ROUTE, resumeBodySchema, RESUME_ASYNC_WORKFLOW_ROUTE, RESUME_WORKFLOW_ROUTE, RESUME_STREAM_WORKFLOW_ROUTE, CANCEL_WORKFLOW_RUN_ROUTE, streamLegacyWorkflowBodySchema, STREAM_LEGACY_WORKFLOW_ROUTE, OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE } from './chunk-B4UYPCEY.js';
+import { listWorkflowsResponseSchema, LIST_WORKFLOWS_ROUTE, workflowInfoSchema, GET_WORKFLOW_BY_ID_ROUTE, workflowRunsResponseSchema, listWorkflowRunsQuerySchema, LIST_WORKFLOW_RUNS_ROUTE, workflowRunResponseSchema, GET_WORKFLOW_RUN_BY_ID_ROUTE, workflowExecutionResultSchema, GET_WORKFLOW_RUN_EXECUTION_RESULT_ROUTE, createWorkflowRunResponseSchema, CREATE_WORKFLOW_RUN_ROUTE, streamWorkflowBodySchema, STREAM_WORKFLOW_ROUTE, STREAM_VNEXT_WORKFLOW_ROUTE, startAsyncWorkflowBodySchema, START_ASYNC_WORKFLOW_ROUTE, workflowControlResponseSchema, START_WORKFLOW_RUN_ROUTE, OBSERVE_STREAM_WORKFLOW_ROUTE, OBSERVE_STREAM_VNEXT_WORKFLOW_ROUTE, resumeBodySchema, RESUME_ASYNC_WORKFLOW_ROUTE, RESUME_WORKFLOW_ROUTE, RESUME_STREAM_WORKFLOW_ROUTE, CANCEL_WORKFLOW_RUN_ROUTE, streamLegacyWorkflowBodySchema, STREAM_LEGACY_WORKFLOW_ROUTE, OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE } from './chunk-TKL4TD2V.js';
 import { require_token_error } from './chunk-ER3QM7DD.js';
 import { openai } from './chunk-ZULZ2752.js';
 import { createIdGenerator, AISDKError, isAbortError, getErrorMessage, APICallError, delay, safeParseJSON, safeValidateTypes, convertAsyncIteratorToReadableStream, validatorSymbol } from './chunk-RQK4FQUD.js';
-import { WorkflowRegistry } from './chunk-G7BPNX2V.js';
-import { streamResponseSchema } from './chunk-R4M3BSUG.js';
-import { optionalRunIdSchema, runIdSchema } from './chunk-PKRHEXX7.js';
+import { WorkflowRegistry } from './chunk-6YWE7UPT.js';
+import { streamResponseSchema } from './chunk-WE4USCF3.js';
+import { optionalRunIdSchema, runIdSchema } from './chunk-HT4LP3BO.js';
 import { createRoute } from './chunk-SXVANU23.js';
 import { handleError } from './chunk-UXGQZUYZ.js';
 import { HTTPException } from './chunk-6QWQZI4Q.js';
@@ -13,9 +13,9 @@ import { Agent, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, MessageL
 import { MastraMemory } from '@mastra/core/memory';
 import { generateEmptyFromSchema } from '@mastra/core/utils';
 import z19, { z, ZodObject, ZodFirstPartyTypeKind } from 'zod';
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind$1 } from 'zod/v3';
 import * as z42 from 'zod/v4';
 import { z as z$1 } from 'zod/v4';
-import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind$1 } from 'zod/v3';
 import { createTool } from '@mastra/core/tools';
 import { exec as exec$1, execFile as execFile$1, spawn as spawn$1 } from 'child_process';
 import { mkdtemp, rm, readFile, writeFile, mkdir, copyFile, readdir, stat } from 'fs/promises';
@@ -1981,135 +1981,1407 @@ function zodToJsonSchema2(zodSchema5, target = "jsonSchema7", strategy = "relati
     });
   }
 }
-function fixJson(input) {
-  const stack = ["ROOT"];
-  let lastValidIndex = -1;
-  let literalStart = null;
-  function processValueStart(char, i, swapState) {
-    {
-      switch (char) {
-        case '"': {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_STRING");
-          break;
-        }
-        case "f":
-        case "t":
-        case "n": {
-          lastValidIndex = i;
-          literalStart = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_LITERAL");
-          break;
-        }
-        case "-": {
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "0":
-        case "1":
-        case "2":
-        case "3":
-        case "4":
-        case "5":
-        case "6":
-        case "7":
-        case "8":
-        case "9": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "{": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_OBJECT_START");
-          break;
-        }
-        case "[": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_ARRAY_START");
-          break;
-        }
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Options.js
+var ignoreOverride2 = Symbol("Let zodToJsonSchema decide on which parser to use");
+var defaultOptions2 = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  target: "jsonSchema7",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref",
+  openAiAnyTypeName: "OpenAiAnyType"
+};
+var getDefaultOptions2 = (options) => typeof options === "string" ? {
+  ...defaultOptions2,
+  name: options
+} : {
+  ...defaultOptions2,
+  ...options
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Refs.js
+var getRefs2 = (options) => {
+  const _options = getDefaultOptions2(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    flags: { hasReferencedOpenAiAnyType: false },
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(Object.entries(_options.definitions).map(([name21, def]) => [
+      def._def,
+      {
+        def: def._def,
+        path: [..._options.basePath, _options.definitionPath, name21],
+        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+        jsonSchema: void 0
       }
-    }
+    ]))
+  };
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+function addErrorMessage2(res, key, errorMessage, refs) {
+  if (!refs?.errorMessages)
+    return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage
+    };
   }
-  function processAfterObjectValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_OBJECT_AFTER_COMMA");
-        break;
-      }
-      case "}": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
+}
+function setResponseValueAndErrors2(res, key, value, errorMessage, refs) {
+  res[key] = value;
+  addErrorMessage2(res, key, errorMessage, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
+var getRelativePath2 = (pathA, pathB) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i])
+      break;
   }
-  function processAfterArrayValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_ARRAY_AFTER_COMMA");
-        break;
-      }
-      case "]": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+function parseAnyDef2(refs) {
+  if (refs.target !== "openAi") {
+    return {};
   }
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    const currentState = stack[stack.length - 1];
-    switch (currentState) {
-      case "ROOT":
-        processValueStart(char, i, "FINISH");
-        break;
-      case "INSIDE_OBJECT_START": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
+  const anyDefinitionPath = [
+    ...refs.basePath,
+    refs.definitionPath,
+    refs.openAiAnyTypeName
+  ];
+  refs.flags.hasReferencedOpenAiAnyType = true;
+  return {
+    $ref: refs.$refStrategy === "relative" ? getRelativePath2(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+  };
+}
+function parseArrayDef2(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind$1.ZodAny) {
+    res.items = parseDef2(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    setResponseValueAndErrors2(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors2(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors2(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors2(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+function parseBigintDef2(def, refs) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors2(res, "exclusiveMinimum", check.value, check.message, refs);
           }
-          case "}": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
           }
+          setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs);
         }
         break;
-      }
-      case "INSIDE_OBJECT_AFTER_COMMA": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors2(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
           }
+          setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs);
         }
         break;
-      }
-      case "INSIDE_OBJECT_KEY": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_AFTER_KEY");
-            break;
+      case "multipleOf":
+        setResponseValueAndErrors2(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+function parseBooleanDef2() {
+  return {
+    type: "boolean"
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+function parseBrandedDef2(_def, refs) {
+  return parseDef2(_def.type._def, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+var parseCatchDef2 = (def, refs) => {
+  return parseDef2(def.innerType._def, refs);
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+function parseDateDef2(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef2(def, refs, item))
+    };
+  }
+  switch (strategy) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return integerDateParser2(def, refs);
+  }
+}
+var integerDateParser2 = (def, refs) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  if (refs.target === "openApi3") {
+    return res;
+  }
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        setResponseValueAndErrors2(
+          res,
+          "minimum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+      case "max":
+        setResponseValueAndErrors2(
+          res,
+          "maximum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+    }
+  }
+  return res;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+function parseDefaultDef2(_def, refs) {
+  return {
+    ...parseDef2(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+function parseEffectsDef2(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef2(_def.schema._def, refs) : parseAnyDef2(refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+function parseEnumDef2(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+var isJsonSchema7AllOfType2 = (type) => {
+  if ("type" in type && type.type === "string")
+    return false;
+  return "allOf" in type;
+};
+function parseIntersectionDef2(def, refs) {
+  const allOf = [
+    parseDef2(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    }),
+    parseDef2(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "1"]
+    })
+  ].filter((x) => !!x);
+  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType2(schema)) {
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === void 0) {
+        unevaluatedProperties = void 0;
+      }
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      } else {
+        unevaluatedProperties = void 0;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? {
+    allOf: mergedAllOf,
+    ...unevaluatedProperties
+  } : void 0;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+function parseLiteralDef2(def, refs) {
+  const parsedType = typeof def.value;
+  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  if (refs.target === "openApi3") {
+    return {
+      type: parsedType === "bigint" ? "integer" : parsedType,
+      enum: [def.value]
+    };
+  }
+  return {
+    type: parsedType === "bigint" ? "integer" : parsedType,
+    const: def.value
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+var emojiRegex2 = void 0;
+var zodPatterns2 = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex2 === void 0) {
+      emojiRegex2 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+    }
+    return emojiRegex2;
+  },
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef2(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          setResponseValueAndErrors2(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          break;
+        case "max":
+          setResponseValueAndErrors2(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          break;
+        case "email":
+          switch (refs.emailStrategy) {
+            case "format:email":
+              addFormat2(res, "email", check.message, refs);
+              break;
+            case "format:idn-email":
+              addFormat2(res, "idn-email", check.message, refs);
+              break;
+            case "pattern:zod":
+              addPattern2(res, zodPatterns2.email, check.message, refs);
+              break;
+          }
+          break;
+        case "url":
+          addFormat2(res, "uri", check.message, refs);
+          break;
+        case "uuid":
+          addFormat2(res, "uuid", check.message, refs);
+          break;
+        case "regex":
+          addPattern2(res, check.regex, check.message, refs);
+          break;
+        case "cuid":
+          addPattern2(res, zodPatterns2.cuid, check.message, refs);
+          break;
+        case "cuid2":
+          addPattern2(res, zodPatterns2.cuid2, check.message, refs);
+          break;
+        case "startsWith":
+          addPattern2(res, RegExp(`^${escapeLiteralCheckValue2(check.value, refs)}`), check.message, refs);
+          break;
+        case "endsWith":
+          addPattern2(res, RegExp(`${escapeLiteralCheckValue2(check.value, refs)}$`), check.message, refs);
+          break;
+        case "datetime":
+          addFormat2(res, "date-time", check.message, refs);
+          break;
+        case "date":
+          addFormat2(res, "date", check.message, refs);
+          break;
+        case "time":
+          addFormat2(res, "time", check.message, refs);
+          break;
+        case "duration":
+          addFormat2(res, "duration", check.message, refs);
+          break;
+        case "length":
+          setResponseValueAndErrors2(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          setResponseValueAndErrors2(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          break;
+        case "includes": {
+          addPattern2(res, RegExp(escapeLiteralCheckValue2(check.value, refs)), check.message, refs);
+          break;
+        }
+        case "ip": {
+          if (check.version !== "v6") {
+            addFormat2(res, "ipv4", check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addFormat2(res, "ipv6", check.message, refs);
+          }
+          break;
+        }
+        case "base64url":
+          addPattern2(res, zodPatterns2.base64url, check.message, refs);
+          break;
+        case "jwt":
+          addPattern2(res, zodPatterns2.jwt, check.message, refs);
+          break;
+        case "cidr": {
+          if (check.version !== "v6") {
+            addPattern2(res, zodPatterns2.ipv4Cidr, check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addPattern2(res, zodPatterns2.ipv6Cidr, check.message, refs);
+          }
+          break;
+        }
+        case "emoji":
+          addPattern2(res, zodPatterns2.emoji(), check.message, refs);
+          break;
+        case "ulid": {
+          addPattern2(res, zodPatterns2.ulid, check.message, refs);
+          break;
+        }
+        case "base64": {
+          switch (refs.base64Strategy) {
+            case "format:binary": {
+              addFormat2(res, "binary", check.message, refs);
+              break;
+            }
+            case "contentEncoding:base64": {
+              setResponseValueAndErrors2(res, "contentEncoding", "base64", check.message, refs);
+              break;
+            }
+            case "pattern:zod": {
+              addPattern2(res, zodPatterns2.base64, check.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern2(res, zodPatterns2.nanoid, check.message, refs);
+        }
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue2(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric2(literal) : literal;
+}
+var ALPHA_NUMERIC2 = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric2(source) {
+  let result = "";
+  for (let i = 0; i < source.length; i++) {
+    if (!ALPHA_NUMERIC2.has(source[i])) {
+      result += "\\";
+    }
+    result += source[i];
+  }
+  return result;
+}
+function addFormat2(schema, value, message, refs) {
+  if (schema.format || schema.anyOf?.some((x) => x.format)) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { format: schema.errorMessage.format }
+        }
+      });
+      delete schema.format;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.format;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    setResponseValueAndErrors2(schema, "format", value, message, refs);
+  }
+}
+function addPattern2(schema, regex, message, refs) {
+  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { pattern: schema.errorMessage.pattern }
+        }
+      });
+      delete schema.pattern;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.pattern;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags2(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    setResponseValueAndErrors2(schema, "pattern", stringifyRegExpWithFlags2(regex, refs), message, refs);
+  }
+}
+function stringifyRegExpWithFlags2(regex, refs) {
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    m: regex.flags.includes("m"),
+    s: regex.flags.includes("s")
+    // `.` matches newlines
+  };
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = "";
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+  for (let i = 0; i < source.length; i++) {
+    if (isEscaped) {
+      pattern += source[i];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i];
+            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
+            pattern += source[i];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i]}${source[i].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i].match(/[a-z]/)) {
+        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i] === ".") {
+      pattern += inCharGroup ? `${source[i]}\r
+` : `[${source[i]}\r
+]`;
+      continue;
+    }
+    pattern += source[i];
+    if (source[i] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i] === "[") {
+      inCharGroup = true;
+    }
+  }
+  return pattern;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+function parseRecordDef2(def, refs) {
+  if (refs.target === "openAi") {
+    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+  }
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodEnum) {
+    return {
+      type: "object",
+      required: def.keyType._def.values,
+      properties: def.keyType._def.values.reduce((acc, key) => ({
+        ...acc,
+        [key]: parseDef2(def.valueType._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "properties", key]
+        }) ?? parseAnyDef2(refs)
+      }), {}),
+      additionalProperties: refs.rejectedAdditionalProperties
+    };
+  }
+  const schema = {
+    type: "object",
+    additionalProperties: parseDef2(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? refs.allowedAdditionalProperties
+  };
+  if (refs.target === "openApi3") {
+    return schema;
+  }
+  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodString && def.keyType._def.checks?.length) {
+    const { type, ...keyType } = parseStringDef2(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind$1.ZodString && def.keyType._def.type._def.checks?.length) {
+    const { type, ...keyType } = parseBrandedDef2(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+function parseMapDef2(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef2(def, refs);
+  }
+  const keys = parseDef2(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || parseAnyDef2(refs);
+  const values = parseDef2(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef2(refs);
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+function parseNativeEnumDef2(def) {
+  const object5 = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object5[object5[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object5[key]);
+  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+  return {
+    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: actualValues
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+function parseNeverDef2(refs) {
+  return refs.target === "openAi" ? void 0 : {
+    not: parseAnyDef2({
+      ...refs,
+      currentPath: [...refs.currentPath, "not"]
+    })
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+function parseNullDef2(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+var primitiveMappings2 = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function parseUnionDef2(def, refs) {
+  if (refs.target === "openApi3")
+    return asAnyOf2(def, refs);
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options.every((x) => x._def.typeName in primitiveMappings2 && (!x._def.checks || !x._def.checks.length))) {
+    const types = options.reduce((types2, x) => {
+      const type = primitiveMappings2[x._def.typeName];
+      return type && !types2.includes(type) ? [...types2, type] : types2;
+    }, []);
+    return {
+      type: types.length > 1 ? types : types[0]
+    };
+  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types = options.reduce((acc, x) => {
+      const type = typeof x._def.value;
+      switch (type) {
+        case "string":
+        case "number":
+        case "boolean":
+          return [...acc, type];
+        case "bigint":
+          return [...acc, "integer"];
+        case "object":
+          if (x._def.value === null)
+            return [...acc, "null"];
+        case "symbol":
+        case "undefined":
+        case "function":
+        default:
+          return acc;
+      }
+    }, []);
+    if (types.length === options.length) {
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce((acc, x) => {
+          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+        }, [])
+      };
+    }
+  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+    return {
+      type: "string",
+      enum: options.reduce((acc, x) => [
+        ...acc,
+        ...x._def.values.filter((x2) => !acc.includes(x2))
+      ], [])
+    };
+  }
+  return asAnyOf2(def, refs);
+}
+var asAnyOf2 = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef2(x._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", `${i}`]
+  })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
+  return anyOf.length ? { anyOf } : void 0;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+function parseNullableDef2(def, refs) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+    if (refs.target === "openApi3") {
+      return {
+        type: primitiveMappings2[def.innerType._def.typeName],
+        nullable: true
+      };
+    }
+    return {
+      type: [
+        primitiveMappings2[def.innerType._def.typeName],
+        "null"
+      ]
+    };
+  }
+  if (refs.target === "openApi3") {
+    const base2 = parseDef2(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath]
+    });
+    if (base2 && "$ref" in base2)
+      return { allOf: [base2], nullable: true };
+    return base2 && { ...base2, nullable: true };
+  }
+  const base = parseDef2(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+function parseNumberDef2(def, refs) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "int":
+        res.type = "integer";
+        addErrorMessage2(res, "type", check.message, refs);
+        break;
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors2(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors2(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors2(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+function parseObjectDef2(def, refs) {
+  const forceOptionalIntoNullable = refs.target === "openAi";
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required = [];
+  const shape = def.shape();
+  for (const propName in shape) {
+    let propDef = shape[propName];
+    if (propDef === void 0 || propDef._def === void 0) {
+      continue;
+    }
+    let propOptional = safeIsOptional2(propDef);
+    if (propOptional && forceOptionalIntoNullable) {
+      if (propDef._def.typeName === "ZodOptional") {
+        propDef = propDef._def.innerType;
+      }
+      if (!propDef.isNullable()) {
+        propDef = propDef.nullable();
+      }
+      propOptional = false;
+    }
+    const parsedDef = parseDef2(propDef._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "properties", propName],
+      propertyPath: [...refs.currentPath, "properties", propName]
+    });
+    if (parsedDef === void 0) {
+      continue;
+    }
+    result.properties[propName] = parsedDef;
+    if (!propOptional) {
+      required.push(propName);
+    }
+  }
+  if (required.length) {
+    result.required = required;
+  }
+  const additionalProperties = decideAdditionalProperties2(def, refs);
+  if (additionalProperties !== void 0) {
+    result.additionalProperties = additionalProperties;
+  }
+  return result;
+}
+function decideAdditionalProperties2(def, refs) {
+  if (def.catchall._def.typeName !== "ZodNever") {
+    return parseDef2(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    });
+  }
+  switch (def.unknownKeys) {
+    case "passthrough":
+      return refs.allowedAdditionalProperties;
+    case "strict":
+      return refs.rejectedAdditionalProperties;
+    case "strip":
+      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+  }
+}
+function safeIsOptional2(schema) {
+  try {
+    return schema.isOptional();
+  } catch {
+    return true;
+  }
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+var parseOptionalDef2 = (def, refs) => {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+    return parseDef2(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef2(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? {
+    anyOf: [
+      {
+        not: parseAnyDef2(refs)
+      },
+      innerSchema
+    ]
+  } : parseAnyDef2(refs);
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+var parsePipelineDef2 = (def, refs) => {
+  if (refs.pipeStrategy === "input") {
+    return parseDef2(def.in._def, refs);
+  } else if (refs.pipeStrategy === "output") {
+    return parseDef2(def.out._def, refs);
+  }
+  const a = parseDef2(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  });
+  const b = parseDef2(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+  });
+  return {
+    allOf: [a, b].filter((x) => x !== void 0)
+  };
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+function parsePromiseDef2(def, refs) {
+  return parseDef2(def.type._def, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+function parseSetDef2(def, refs) {
+  const items = parseDef2(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items
+  };
+  if (def.minSize) {
+    setResponseValueAndErrors2(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+  }
+  if (def.maxSize) {
+    setResponseValueAndErrors2(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+  }
+  return schema;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+function parseTupleDef2(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map((x, i) => parseDef2(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
+      additionalItems: parseDef2(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalItems"]
+      })
+    };
+  } else {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items.map((x, i) => parseDef2(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+    };
+  }
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+function parseUndefinedDef2(refs) {
+  return {
+    not: parseAnyDef2(refs)
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+function parseUnknownDef2(refs) {
+  return parseAnyDef2(refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+var parseReadonlyDef2 = (def, refs) => {
+  return parseDef2(def.innerType._def, refs);
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/selectParser.js
+var selectParser2 = (def, typeName, refs) => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind$1.ZodString:
+      return parseStringDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodNumber:
+      return parseNumberDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodObject:
+      return parseObjectDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodBigInt:
+      return parseBigintDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodBoolean:
+      return parseBooleanDef2();
+    case ZodFirstPartyTypeKind$1.ZodDate:
+      return parseDateDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodUndefined:
+      return parseUndefinedDef2(refs);
+    case ZodFirstPartyTypeKind$1.ZodNull:
+      return parseNullDef2(refs);
+    case ZodFirstPartyTypeKind$1.ZodArray:
+      return parseArrayDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodUnion:
+    case ZodFirstPartyTypeKind$1.ZodDiscriminatedUnion:
+      return parseUnionDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodIntersection:
+      return parseIntersectionDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodTuple:
+      return parseTupleDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodRecord:
+      return parseRecordDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodLiteral:
+      return parseLiteralDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodEnum:
+      return parseEnumDef2(def);
+    case ZodFirstPartyTypeKind$1.ZodNativeEnum:
+      return parseNativeEnumDef2(def);
+    case ZodFirstPartyTypeKind$1.ZodNullable:
+      return parseNullableDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodOptional:
+      return parseOptionalDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodMap:
+      return parseMapDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodSet:
+      return parseSetDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodLazy:
+      return () => def.getter()._def;
+    case ZodFirstPartyTypeKind$1.ZodPromise:
+      return parsePromiseDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodNaN:
+    case ZodFirstPartyTypeKind$1.ZodNever:
+      return parseNeverDef2(refs);
+    case ZodFirstPartyTypeKind$1.ZodEffects:
+      return parseEffectsDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodAny:
+      return parseAnyDef2(refs);
+    case ZodFirstPartyTypeKind$1.ZodUnknown:
+      return parseUnknownDef2(refs);
+    case ZodFirstPartyTypeKind$1.ZodDefault:
+      return parseDefaultDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodBranded:
+      return parseBrandedDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodReadonly:
+      return parseReadonlyDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodCatch:
+      return parseCatchDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodPipeline:
+      return parsePipelineDef2(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodFunction:
+    case ZodFirstPartyTypeKind$1.ZodVoid:
+    case ZodFirstPartyTypeKind$1.ZodSymbol:
+      return void 0;
+    default:
+      return /* @__PURE__ */ ((_) => void 0)();
+  }
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parseDef.js
+function parseDef2(def, refs, forceResolution = false) {
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+    if (overrideResult !== ignoreOverride2) {
+      return overrideResult;
+    }
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref2(seenItem, refs);
+    if (seenSchema !== void 0) {
+      return seenSchema;
+    }
+  }
+  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
+  refs.seen.set(def, newItem);
+  const jsonSchemaOrGetter = selectParser2(def, def.typeName, refs);
+  const jsonSchema5 = typeof jsonSchemaOrGetter === "function" ? parseDef2(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema5) {
+    addMeta2(def, refs, jsonSchema5);
+  }
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema5, def, refs);
+    newItem.jsonSchema = jsonSchema5;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema5;
+  return jsonSchema5;
+}
+var get$ref2 = (item, refs) => {
+  switch (refs.$refStrategy) {
+    case "root":
+      return { $ref: item.path.join("/") };
+    case "relative":
+      return { $ref: getRelativePath2(refs.currentPath, item.path) };
+    case "none":
+    case "seen": {
+      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+        return parseAnyDef2(refs);
+      }
+      return refs.$refStrategy === "seen" ? parseAnyDef2(refs) : void 0;
+    }
+  }
+};
+var addMeta2 = (def, refs, jsonSchema5) => {
+  if (def.description) {
+    jsonSchema5.description = def.description;
+    if (refs.markdownDescription) {
+      jsonSchema5.markdownDescription = def.description;
+    }
+  }
+  return jsonSchema5;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+var zodToJsonSchema3 = (schema, options) => {
+  const refs = getRefs2(options);
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name26, schema2]) => ({
+    ...acc,
+    [name26]: parseDef2(schema2._def, {
+      ...refs,
+      currentPath: [...refs.basePath, refs.definitionPath, name26]
+    }, true) ?? parseAnyDef2(refs)
+  }), {}) : void 0;
+  const name21 = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
+  const main = parseDef2(schema._def, name21 === void 0 ? refs : {
+    ...refs,
+    currentPath: [...refs.basePath, refs.definitionPath, name21]
+  }, false) ?? parseAnyDef2(refs);
+  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+  if (title !== void 0) {
+    main.title = title;
+  }
+  if (refs.flags.hasReferencedOpenAiAnyType) {
+    if (!definitions) {
+      definitions = {};
+    }
+    if (!definitions[refs.openAiAnyTypeName]) {
+      definitions[refs.openAiAnyTypeName] = {
+        // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+        type: ["string", "number", "integer", "boolean", "array", "null"],
+        items: {
+          $ref: refs.$refStrategy === "relative" ? "1" : [
+            ...refs.basePath,
+            refs.definitionPath,
+            refs.openAiAnyTypeName
+          ].join("/")
+        }
+      };
+    }
+  }
+  const combined = name21 === void 0 ? definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name21
+    ].join("/"),
+    [refs.definitionPath]: {
+      ...definitions,
+      [name21]: main
+    }
+  };
+  if (refs.target === "jsonSchema7") {
+    combined.$schema = "http://json-schema.org/draft-07/schema#";
+  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+  }
+  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
+    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+  }
+  return combined;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/index.js
+var esm_default2 = zodToJsonSchema3;
+function fixJson(input) {
+  const stack = ["ROOT"];
+  let lastValidIndex = -1;
+  let literalStart = null;
+  function processValueStart(char, i, swapState) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_STRING");
+          break;
+        }
+        case "f":
+        case "t":
+        case "n": {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_LITERAL");
+          break;
+        }
+        case "-": {
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "{": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_OBJECT_START");
+          break;
+        }
+        case "[": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_ARRAY_START");
+          break;
+        }
+      }
+    }
+  }
+  function processAfterObjectValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  function processAfterArrayValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+    switch (currentState) {
+      case "ROOT":
+        processValueStart(char, i, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
           }
         }
         break;
@@ -2578,7 +3850,7 @@ function zodSchema(zodSchema22, options) {
   var _a26;
   const useReferences = (_a26 = void 0 ) != null ? _a26 : false;
   return jsonSchema(
-    esm_default(zodSchema22, {
+    esm_default2(zodSchema22, {
       $refStrategy: useReferences ? "root" : "none",
       target: "jsonSchema7"
       // note: openai mode breaks various gemini conversions
@@ -5395,7 +6667,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
     rawValue: parsedResult.rawValue
   };
 };
-var getRelativePath2 = (pathA, pathB) => {
+var getRelativePath3 = (pathA, pathB) => {
   let i = 0;
   for (; i < pathA.length && i < pathB.length; i++) {
     if (pathA[i] !== pathB[i])
@@ -5403,10 +6675,10 @@ var getRelativePath2 = (pathA, pathB) => {
   }
   return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
 };
-var ignoreOverride2 = Symbol(
+var ignoreOverride3 = Symbol(
   "Let zodToJsonSchema decide on which parser to use"
 );
-var defaultOptions2 = {
+var defaultOptions3 = {
   name: void 0,
   $refStrategy: "root",
   basePath: ["#"],
@@ -5427,23 +6699,23 @@ var defaultOptions2 = {
   base64Strategy: "contentEncoding:base64",
   nameStrategy: "ref"
 };
-var getDefaultOptions2 = (options) => typeof options === "string" ? {
-  ...defaultOptions2,
+var getDefaultOptions3 = (options) => typeof options === "string" ? {
+  ...defaultOptions3,
   name: options
 } : {
-  ...defaultOptions2,
+  ...defaultOptions3,
   ...options
 };
-function parseAnyDef2() {
+function parseAnyDef3() {
   return {};
 }
-function parseArrayDef2(def, refs) {
+function parseArrayDef3(def, refs) {
   var _a26, _b8, _c;
   const res = {
     type: "array"
   };
   if (((_a26 = def.type) == null ? void 0 : _a26._def) && ((_c = (_b8 = def.type) == null ? void 0 : _b8._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind$1.ZodAny) {
-    res.items = parseDef2(def.type._def, {
+    res.items = parseDef3(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
     });
@@ -5460,7 +6732,7 @@ function parseArrayDef2(def, refs) {
   }
   return res;
 }
-function parseBigintDef2(def) {
+function parseBigintDef3(def) {
   const res = {
     type: "integer",
     format: "int64"
@@ -5490,20 +6762,20 @@ function parseBigintDef2(def) {
   }
   return res;
 }
-function parseBooleanDef2() {
+function parseBooleanDef3() {
   return { type: "boolean" };
 }
-function parseBrandedDef2(_def, refs) {
-  return parseDef2(_def.type._def, refs);
+function parseBrandedDef3(_def, refs) {
+  return parseDef3(_def.type._def, refs);
 }
-var parseCatchDef2 = (def, refs) => {
-  return parseDef2(def.innerType._def, refs);
+var parseCatchDef3 = (def, refs) => {
+  return parseDef3(def.innerType._def, refs);
 };
-function parseDateDef2(def, refs, overrideDateStrategy) {
+function parseDateDef3(def, refs, overrideDateStrategy) {
   const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
   if (Array.isArray(strategy)) {
     return {
-      anyOf: strategy.map((item, i) => parseDateDef2(def, refs, item))
+      anyOf: strategy.map((item, i) => parseDateDef3(def, refs, item))
     };
   }
   switch (strategy) {
@@ -5519,10 +6791,10 @@ function parseDateDef2(def, refs, overrideDateStrategy) {
         format: "date"
       };
     case "integer":
-      return integerDateParser2(def);
+      return integerDateParser3(def);
   }
 }
-var integerDateParser2 = (def) => {
+var integerDateParser3 = (def) => {
   const res = {
     type: "integer",
     format: "unix-time"
@@ -5539,40 +6811,40 @@ var integerDateParser2 = (def) => {
   }
   return res;
 };
-function parseDefaultDef2(_def, refs) {
+function parseDefaultDef3(_def, refs) {
   return {
-    ...parseDef2(_def.innerType._def, refs),
+    ...parseDef3(_def.innerType._def, refs),
     default: _def.defaultValue()
   };
 }
-function parseEffectsDef2(_def, refs) {
-  return refs.effectStrategy === "input" ? parseDef2(_def.schema._def, refs) : parseAnyDef2();
+function parseEffectsDef3(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef3(_def.schema._def, refs) : parseAnyDef3();
 }
-function parseEnumDef2(def) {
+function parseEnumDef3(def) {
   return {
     type: "string",
     enum: Array.from(def.values)
   };
 }
-var isJsonSchema7AllOfType2 = (type) => {
+var isJsonSchema7AllOfType3 = (type) => {
   if ("type" in type && type.type === "string")
     return false;
   return "allOf" in type;
 };
-function parseIntersectionDef2(def, refs) {
+function parseIntersectionDef3(def, refs) {
   const allOf = [
-    parseDef2(def.left._def, {
+    parseDef3(def.left._def, {
       ...refs,
       currentPath: [...refs.currentPath, "allOf", "0"]
     }),
-    parseDef2(def.right._def, {
+    parseDef3(def.right._def, {
       ...refs,
       currentPath: [...refs.currentPath, "allOf", "1"]
     })
   ].filter((x) => !!x);
   const mergedAllOf = [];
   allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType2(schema)) {
+    if (isJsonSchema7AllOfType3(schema)) {
       mergedAllOf.push(...schema.allOf);
     } else {
       let nestedSchema = schema;
@@ -5585,7 +6857,7 @@ function parseIntersectionDef2(def, refs) {
   });
   return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
 }
-function parseLiteralDef2(def) {
+function parseLiteralDef3(def) {
   const parsedType = typeof def.value;
   if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
     return {
@@ -5597,8 +6869,8 @@ function parseLiteralDef2(def) {
     const: def.value
   };
 }
-var emojiRegex2 = void 0;
-var zodPatterns2 = {
+var emojiRegex3 = void 0;
+var zodPatterns3 = {
   /**
    * `c` was changed to `[cC]` to replicate /i flag
    */
@@ -5621,13 +6893,13 @@ var zodPatterns2 = {
    * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
    */
   emoji: () => {
-    if (emojiRegex2 === void 0) {
-      emojiRegex2 = RegExp(
+    if (emojiRegex3 === void 0) {
+      emojiRegex3 = RegExp(
         "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
         "u"
       );
     }
-    return emojiRegex2;
+    return emojiRegex3;
   },
   /**
    * Unused
@@ -5648,7 +6920,7 @@ var zodPatterns2 = {
   nanoid: /^[a-zA-Z0-9_-]{21}$/,
   jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
 };
-function parseStringDef2(def, refs) {
+function parseStringDef3(def, refs) {
   const res = {
     type: "string"
   };
@@ -5664,67 +6936,67 @@ function parseStringDef2(def, refs) {
         case "email":
           switch (refs.emailStrategy) {
             case "format:email":
-              addFormat2(res, "email", check.message, refs);
+              addFormat3(res, "email", check.message, refs);
               break;
             case "format:idn-email":
-              addFormat2(res, "idn-email", check.message, refs);
+              addFormat3(res, "idn-email", check.message, refs);
               break;
             case "pattern:zod":
-              addPattern2(res, zodPatterns2.email, check.message, refs);
+              addPattern3(res, zodPatterns3.email, check.message, refs);
               break;
           }
           break;
         case "url":
-          addFormat2(res, "uri", check.message, refs);
+          addFormat3(res, "uri", check.message, refs);
           break;
         case "uuid":
-          addFormat2(res, "uuid", check.message, refs);
+          addFormat3(res, "uuid", check.message, refs);
           break;
         case "regex":
-          addPattern2(res, check.regex, check.message, refs);
+          addPattern3(res, check.regex, check.message, refs);
           break;
         case "cuid":
-          addPattern2(res, zodPatterns2.cuid, check.message, refs);
+          addPattern3(res, zodPatterns3.cuid, check.message, refs);
           break;
         case "cuid2":
-          addPattern2(res, zodPatterns2.cuid2, check.message, refs);
+          addPattern3(res, zodPatterns3.cuid2, check.message, refs);
           break;
         case "startsWith":
-          addPattern2(
+          addPattern3(
             res,
-            RegExp(`^${escapeLiteralCheckValue2(check.value, refs)}`),
+            RegExp(`^${escapeLiteralCheckValue3(check.value, refs)}`),
             check.message,
             refs
           );
           break;
         case "endsWith":
-          addPattern2(
+          addPattern3(
             res,
-            RegExp(`${escapeLiteralCheckValue2(check.value, refs)}$`),
+            RegExp(`${escapeLiteralCheckValue3(check.value, refs)}$`),
             check.message,
             refs
           );
           break;
         case "datetime":
-          addFormat2(res, "date-time", check.message, refs);
+          addFormat3(res, "date-time", check.message, refs);
           break;
         case "date":
-          addFormat2(res, "date", check.message, refs);
+          addFormat3(res, "date", check.message, refs);
           break;
         case "time":
-          addFormat2(res, "time", check.message, refs);
+          addFormat3(res, "time", check.message, refs);
           break;
         case "duration":
-          addFormat2(res, "duration", check.message, refs);
+          addFormat3(res, "duration", check.message, refs);
           break;
         case "length":
           res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
           res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
           break;
         case "includes": {
-          addPattern2(
+          addPattern3(
             res,
-            RegExp(escapeLiteralCheckValue2(check.value, refs)),
+            RegExp(escapeLiteralCheckValue3(check.value, refs)),
             check.message,
             refs
           );
@@ -5732,39 +7004,39 @@ function parseStringDef2(def, refs) {
         }
         case "ip": {
           if (check.version !== "v6") {
-            addFormat2(res, "ipv4", check.message, refs);
+            addFormat3(res, "ipv4", check.message, refs);
           }
           if (check.version !== "v4") {
-            addFormat2(res, "ipv6", check.message, refs);
+            addFormat3(res, "ipv6", check.message, refs);
           }
           break;
         }
         case "base64url":
-          addPattern2(res, zodPatterns2.base64url, check.message, refs);
+          addPattern3(res, zodPatterns3.base64url, check.message, refs);
           break;
         case "jwt":
-          addPattern2(res, zodPatterns2.jwt, check.message, refs);
+          addPattern3(res, zodPatterns3.jwt, check.message, refs);
           break;
         case "cidr": {
           if (check.version !== "v6") {
-            addPattern2(res, zodPatterns2.ipv4Cidr, check.message, refs);
+            addPattern3(res, zodPatterns3.ipv4Cidr, check.message, refs);
           }
           if (check.version !== "v4") {
-            addPattern2(res, zodPatterns2.ipv6Cidr, check.message, refs);
+            addPattern3(res, zodPatterns3.ipv6Cidr, check.message, refs);
           }
           break;
         }
         case "emoji":
-          addPattern2(res, zodPatterns2.emoji(), check.message, refs);
+          addPattern3(res, zodPatterns3.emoji(), check.message, refs);
           break;
         case "ulid": {
-          addPattern2(res, zodPatterns2.ulid, check.message, refs);
+          addPattern3(res, zodPatterns3.ulid, check.message, refs);
           break;
         }
         case "base64": {
           switch (refs.base64Strategy) {
             case "format:binary": {
-              addFormat2(res, "binary", check.message, refs);
+              addFormat3(res, "binary", check.message, refs);
               break;
             }
             case "contentEncoding:base64": {
@@ -5772,37 +7044,37 @@ function parseStringDef2(def, refs) {
               break;
             }
             case "pattern:zod": {
-              addPattern2(res, zodPatterns2.base64, check.message, refs);
+              addPattern3(res, zodPatterns3.base64, check.message, refs);
               break;
             }
           }
           break;
         }
         case "nanoid": {
-          addPattern2(res, zodPatterns2.nanoid, check.message, refs);
+          addPattern3(res, zodPatterns3.nanoid, check.message, refs);
         }
       }
     }
   }
   return res;
 }
-function escapeLiteralCheckValue2(literal, refs) {
-  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric2(literal) : literal;
+function escapeLiteralCheckValue3(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric3(literal) : literal;
 }
-var ALPHA_NUMERIC2 = new Set(
+var ALPHA_NUMERIC3 = new Set(
   "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
 );
-function escapeNonAlphaNumeric2(source) {
+function escapeNonAlphaNumeric3(source) {
   let result = "";
   for (let i = 0; i < source.length; i++) {
-    if (!ALPHA_NUMERIC2.has(source[i])) {
+    if (!ALPHA_NUMERIC3.has(source[i])) {
       result += "\\";
     }
     result += source[i];
   }
   return result;
 }
-function addFormat2(schema, value, message, refs) {
+function addFormat3(schema, value, message, refs) {
   var _a26;
   if (schema.format || ((_a26 = schema.anyOf) == null ? void 0 : _a26.some((x) => x.format))) {
     if (!schema.anyOf) {
@@ -5822,7 +7094,7 @@ function addFormat2(schema, value, message, refs) {
     schema.format = value;
   }
 }
-function addPattern2(schema, regex, message, refs) {
+function addPattern3(schema, regex, message, refs) {
   var _a26;
   if (schema.pattern || ((_a26 = schema.allOf) == null ? void 0 : _a26.some((x) => x.pattern))) {
     if (!schema.allOf) {
@@ -5835,14 +7107,14 @@ function addPattern2(schema, regex, message, refs) {
       delete schema.pattern;
     }
     schema.allOf.push({
-      pattern: stringifyRegExpWithFlags2(regex, refs),
+      pattern: stringifyRegExpWithFlags3(regex, refs),
       ...message && refs.errorMessages && { errorMessage: { pattern: message } }
     });
   } else {
-    schema.pattern = stringifyRegExpWithFlags2(regex, refs);
+    schema.pattern = stringifyRegExpWithFlags3(regex, refs);
   }
 }
-function stringifyRegExpWithFlags2(regex, refs) {
+function stringifyRegExpWithFlags3(regex, refs) {
   var _a26;
   if (!refs.applyRegexFlags || !regex.flags) {
     return regex.source;
@@ -5914,17 +7186,17 @@ function stringifyRegExpWithFlags2(regex, refs) {
   }
   return pattern;
 }
-function parseRecordDef2(def, refs) {
+function parseRecordDef3(def, refs) {
   var _a26, _b8, _c, _d, _e, _f;
   const schema = {
     type: "object",
-    additionalProperties: (_a26 = parseDef2(def.valueType._def, {
+    additionalProperties: (_a26 = parseDef3(def.valueType._def, {
       ...refs,
       currentPath: [...refs.currentPath, "additionalProperties"]
     })) != null ? _a26 : refs.allowedAdditionalProperties
   };
   if (((_b8 = def.keyType) == null ? void 0 : _b8._def.typeName) === ZodFirstPartyTypeKind$1.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
-    const { type, ...keyType } = parseStringDef2(def.keyType._def, refs);
+    const { type, ...keyType } = parseStringDef3(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
@@ -5937,7 +7209,7 @@ function parseRecordDef2(def, refs) {
       }
     };
   } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind$1.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind$1.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
-    const { type, ...keyType } = parseBrandedDef2(
+    const { type, ...keyType } = parseBrandedDef3(
       def.keyType._def,
       refs
     );
@@ -5948,18 +7220,18 @@ function parseRecordDef2(def, refs) {
   }
   return schema;
 }
-function parseMapDef2(def, refs) {
+function parseMapDef3(def, refs) {
   if (refs.mapStrategy === "record") {
-    return parseRecordDef2(def, refs);
+    return parseRecordDef3(def, refs);
   }
-  const keys = parseDef2(def.keyType._def, {
+  const keys = parseDef3(def.keyType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items", "items", "0"]
-  }) || parseAnyDef2();
-  const values = parseDef2(def.valueType._def, {
+  }) || parseAnyDef3();
+  const values = parseDef3(def.valueType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items", "items", "1"]
-  }) || parseAnyDef2();
+  }) || parseAnyDef3();
   return {
     type: "array",
     maxItems: 125,
@@ -5971,7 +7243,7 @@ function parseMapDef2(def, refs) {
     }
   };
 }
-function parseNativeEnumDef2(def) {
+function parseNativeEnumDef3(def) {
   const object5 = def.values;
   const actualKeys = Object.keys(def.values).filter((key) => {
     return typeof object5[object5[key]] !== "number";
@@ -5985,28 +7257,28 @@ function parseNativeEnumDef2(def) {
     enum: actualValues
   };
 }
-function parseNeverDef2() {
-  return { not: parseAnyDef2() };
+function parseNeverDef3() {
+  return { not: parseAnyDef3() };
 }
-function parseNullDef2() {
+function parseNullDef3() {
   return {
     type: "null"
   };
 }
-var primitiveMappings2 = {
+var primitiveMappings3 = {
   ZodString: "string",
   ZodNumber: "number",
   ZodBigInt: "integer",
   ZodBoolean: "boolean",
   ZodNull: "null"
 };
-function parseUnionDef2(def, refs) {
+function parseUnionDef3(def, refs) {
   const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
   if (options.every(
-    (x) => x._def.typeName in primitiveMappings2 && (!x._def.checks || !x._def.checks.length)
+    (x) => x._def.typeName in primitiveMappings3 && (!x._def.checks || !x._def.checks.length)
   )) {
     const types = options.reduce((types2, x) => {
-      const type = primitiveMappings2[x._def.typeName];
+      const type = primitiveMappings3[x._def.typeName];
       return type && !types2.includes(type) ? [...types2, type] : types2;
     }, []);
     return {
@@ -6059,11 +7331,11 @@ function parseUnionDef2(def, refs) {
       )
     };
   }
-  return asAnyOf2(def, refs);
+  return asAnyOf3(def, refs);
 }
-var asAnyOf2 = (def, refs) => {
+var asAnyOf3 = (def, refs) => {
   const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
-    (x, i) => parseDef2(x._def, {
+    (x, i) => parseDef3(x._def, {
       ...refs,
       currentPath: [...refs.currentPath, "anyOf", `${i}`]
     })
@@ -6072,24 +7344,24 @@ var asAnyOf2 = (def, refs) => {
   );
   return anyOf.length ? { anyOf } : void 0;
 };
-function parseNullableDef2(def, refs) {
+function parseNullableDef3(def, refs) {
   if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
     def.innerType._def.typeName
   ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
     return {
       type: [
-        primitiveMappings2[def.innerType._def.typeName],
+        primitiveMappings3[def.innerType._def.typeName],
         "null"
       ]
     };
   }
-  const base = parseDef2(def.innerType._def, {
+  const base = parseDef3(def.innerType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "anyOf", "0"]
   });
   return base && { anyOf: [base, { type: "null" }] };
 }
-function parseNumberDef2(def) {
+function parseNumberDef3(def) {
   const res = {
     type: "number"
   };
@@ -6121,7 +7393,7 @@ function parseNumberDef2(def) {
   }
   return res;
 }
-function parseObjectDef2(def, refs) {
+function parseObjectDef3(def, refs) {
   const result = {
     type: "object",
     properties: {}
@@ -6133,8 +7405,8 @@ function parseObjectDef2(def, refs) {
     if (propDef === void 0 || propDef._def === void 0) {
       continue;
     }
-    const propOptional = safeIsOptional2(propDef);
-    const parsedDef = parseDef2(propDef._def, {
+    const propOptional = safeIsOptional3(propDef);
+    const parsedDef = parseDef3(propDef._def, {
       ...refs,
       currentPath: [...refs.currentPath, "properties", propName],
       propertyPath: [...refs.currentPath, "properties", propName]
@@ -6150,15 +7422,15 @@ function parseObjectDef2(def, refs) {
   if (required.length) {
     result.required = required;
   }
-  const additionalProperties = decideAdditionalProperties2(def, refs);
+  const additionalProperties = decideAdditionalProperties3(def, refs);
   if (additionalProperties !== void 0) {
     result.additionalProperties = additionalProperties;
   }
   return result;
 }
-function decideAdditionalProperties2(def, refs) {
+function decideAdditionalProperties3(def, refs) {
   if (def.catchall._def.typeName !== "ZodNever") {
-    return parseDef2(def.catchall._def, {
+    return parseDef3(def.catchall._def, {
       ...refs,
       currentPath: [...refs.currentPath, "additionalProperties"]
     });
@@ -6172,35 +7444,35 @@ function decideAdditionalProperties2(def, refs) {
       return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
   }
 }
-function safeIsOptional2(schema) {
+function safeIsOptional3(schema) {
   try {
     return schema.isOptional();
   } catch (e2) {
     return true;
   }
 }
-var parseOptionalDef2 = (def, refs) => {
+var parseOptionalDef3 = (def, refs) => {
   var _a26;
   if (refs.currentPath.toString() === ((_a26 = refs.propertyPath) == null ? void 0 : _a26.toString())) {
-    return parseDef2(def.innerType._def, refs);
+    return parseDef3(def.innerType._def, refs);
   }
-  const innerSchema = parseDef2(def.innerType._def, {
+  const innerSchema = parseDef3(def.innerType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "anyOf", "1"]
   });
-  return innerSchema ? { anyOf: [{ not: parseAnyDef2() }, innerSchema] } : parseAnyDef2();
+  return innerSchema ? { anyOf: [{ not: parseAnyDef3() }, innerSchema] } : parseAnyDef3();
 };
-var parsePipelineDef2 = (def, refs) => {
+var parsePipelineDef3 = (def, refs) => {
   if (refs.pipeStrategy === "input") {
-    return parseDef2(def.in._def, refs);
+    return parseDef3(def.in._def, refs);
   } else if (refs.pipeStrategy === "output") {
-    return parseDef2(def.out._def, refs);
+    return parseDef3(def.out._def, refs);
   }
-  const a = parseDef2(def.in._def, {
+  const a = parseDef3(def.in._def, {
     ...refs,
     currentPath: [...refs.currentPath, "allOf", "0"]
   });
-  const b = parseDef2(def.out._def, {
+  const b = parseDef3(def.out._def, {
     ...refs,
     currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
   });
@@ -6208,11 +7480,11 @@ var parsePipelineDef2 = (def, refs) => {
     allOf: [a, b].filter((x) => x !== void 0)
   };
 };
-function parsePromiseDef2(def, refs) {
-  return parseDef2(def.type._def, refs);
+function parsePromiseDef3(def, refs) {
+  return parseDef3(def.type._def, refs);
 }
-function parseSetDef2(def, refs) {
-  const items = parseDef2(def.valueType._def, {
+function parseSetDef3(def, refs) {
+  const items = parseDef3(def.valueType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items"]
   });
@@ -6229,13 +7501,13 @@ function parseSetDef2(def, refs) {
   }
   return schema;
 }
-function parseTupleDef2(def, refs) {
+function parseTupleDef3(def, refs) {
   if (def.rest) {
     return {
       type: "array",
       minItems: def.items.length,
       items: def.items.map(
-        (x, i) => parseDef2(x._def, {
+        (x, i) => parseDef3(x._def, {
           ...refs,
           currentPath: [...refs.currentPath, "items", `${i}`]
         })
@@ -6243,7 +7515,7 @@ function parseTupleDef2(def, refs) {
         (acc, x) => x === void 0 ? acc : [...acc, x],
         []
       ),
-      additionalItems: parseDef2(def.rest._def, {
+      additionalItems: parseDef3(def.rest._def, {
         ...refs,
         currentPath: [...refs.currentPath, "additionalItems"]
       })
@@ -6254,7 +7526,7 @@ function parseTupleDef2(def, refs) {
       minItems: def.items.length,
       maxItems: def.items.length,
       items: def.items.map(
-        (x, i) => parseDef2(x._def, {
+        (x, i) => parseDef3(x._def, {
           ...refs,
           currentPath: [...refs.currentPath, "items", `${i}`]
         })
@@ -6265,83 +7537,83 @@ function parseTupleDef2(def, refs) {
     };
   }
 }
-function parseUndefinedDef2() {
+function parseUndefinedDef3() {
   return {
-    not: parseAnyDef2()
+    not: parseAnyDef3()
   };
 }
-function parseUnknownDef2() {
-  return parseAnyDef2();
+function parseUnknownDef3() {
+  return parseAnyDef3();
 }
-var parseReadonlyDef2 = (def, refs) => {
-  return parseDef2(def.innerType._def, refs);
+var parseReadonlyDef3 = (def, refs) => {
+  return parseDef3(def.innerType._def, refs);
 };
-var selectParser2 = (def, typeName, refs) => {
+var selectParser3 = (def, typeName, refs) => {
   switch (typeName) {
     case ZodFirstPartyTypeKind$1.ZodString:
-      return parseStringDef2(def, refs);
+      return parseStringDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodNumber:
-      return parseNumberDef2(def);
+      return parseNumberDef3(def);
     case ZodFirstPartyTypeKind$1.ZodObject:
-      return parseObjectDef2(def, refs);
+      return parseObjectDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodBigInt:
-      return parseBigintDef2(def);
+      return parseBigintDef3(def);
     case ZodFirstPartyTypeKind$1.ZodBoolean:
-      return parseBooleanDef2();
+      return parseBooleanDef3();
     case ZodFirstPartyTypeKind$1.ZodDate:
-      return parseDateDef2(def, refs);
+      return parseDateDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodUndefined:
-      return parseUndefinedDef2();
+      return parseUndefinedDef3();
     case ZodFirstPartyTypeKind$1.ZodNull:
-      return parseNullDef2();
+      return parseNullDef3();
     case ZodFirstPartyTypeKind$1.ZodArray:
-      return parseArrayDef2(def, refs);
+      return parseArrayDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodUnion:
     case ZodFirstPartyTypeKind$1.ZodDiscriminatedUnion:
-      return parseUnionDef2(def, refs);
+      return parseUnionDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodIntersection:
-      return parseIntersectionDef2(def, refs);
+      return parseIntersectionDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodTuple:
-      return parseTupleDef2(def, refs);
+      return parseTupleDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodRecord:
-      return parseRecordDef2(def, refs);
+      return parseRecordDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodLiteral:
-      return parseLiteralDef2(def);
+      return parseLiteralDef3(def);
     case ZodFirstPartyTypeKind$1.ZodEnum:
-      return parseEnumDef2(def);
+      return parseEnumDef3(def);
     case ZodFirstPartyTypeKind$1.ZodNativeEnum:
-      return parseNativeEnumDef2(def);
+      return parseNativeEnumDef3(def);
     case ZodFirstPartyTypeKind$1.ZodNullable:
-      return parseNullableDef2(def, refs);
+      return parseNullableDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodOptional:
-      return parseOptionalDef2(def, refs);
+      return parseOptionalDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodMap:
-      return parseMapDef2(def, refs);
+      return parseMapDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodSet:
-      return parseSetDef2(def, refs);
+      return parseSetDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodLazy:
       return () => def.getter()._def;
     case ZodFirstPartyTypeKind$1.ZodPromise:
-      return parsePromiseDef2(def, refs);
+      return parsePromiseDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodNaN:
     case ZodFirstPartyTypeKind$1.ZodNever:
-      return parseNeverDef2();
+      return parseNeverDef3();
     case ZodFirstPartyTypeKind$1.ZodEffects:
-      return parseEffectsDef2(def, refs);
+      return parseEffectsDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodAny:
-      return parseAnyDef2();
+      return parseAnyDef3();
     case ZodFirstPartyTypeKind$1.ZodUnknown:
-      return parseUnknownDef2();
+      return parseUnknownDef3();
     case ZodFirstPartyTypeKind$1.ZodDefault:
-      return parseDefaultDef2(def, refs);
+      return parseDefaultDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodBranded:
-      return parseBrandedDef2(def, refs);
+      return parseBrandedDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodReadonly:
-      return parseReadonlyDef2(def, refs);
+      return parseReadonlyDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodCatch:
-      return parseCatchDef2(def, refs);
+      return parseCatchDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodPipeline:
-      return parsePipelineDef2(def, refs);
+      return parsePipelineDef3(def, refs);
     case ZodFirstPartyTypeKind$1.ZodFunction:
     case ZodFirstPartyTypeKind$1.ZodVoid:
     case ZodFirstPartyTypeKind$1.ZodSymbol:
@@ -6350,7 +7622,7 @@ var selectParser2 = (def, typeName, refs) => {
       return /* @__PURE__ */ ((_) => void 0)();
   }
 };
-function parseDef2(def, refs, forceResolution = false) {
+function parseDef3(def, refs, forceResolution = false) {
   var _a26;
   const seenItem = refs.seen.get(def);
   if (refs.override) {
@@ -6361,22 +7633,22 @@ function parseDef2(def, refs, forceResolution = false) {
       seenItem,
       forceResolution
     );
-    if (overrideResult !== ignoreOverride2) {
+    if (overrideResult !== ignoreOverride3) {
       return overrideResult;
     }
   }
   if (seenItem && !forceResolution) {
-    const seenSchema = get$ref2(seenItem, refs);
+    const seenSchema = get$ref3(seenItem, refs);
     if (seenSchema !== void 0) {
       return seenSchema;
     }
   }
   const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
   refs.seen.set(def, newItem);
-  const jsonSchemaOrGetter = selectParser2(def, def.typeName, refs);
-  const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef2(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  const jsonSchemaOrGetter = selectParser3(def, def.typeName, refs);
+  const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef3(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
   if (jsonSchema22) {
-    addMeta2(def, refs, jsonSchema22);
+    addMeta3(def, refs, jsonSchema22);
   }
   if (refs.postProcess) {
     const postProcessResult = refs.postProcess(jsonSchema22, def, refs);
@@ -6386,12 +7658,12 @@ function parseDef2(def, refs, forceResolution = false) {
   newItem.jsonSchema = jsonSchema22;
   return jsonSchema22;
 }
-var get$ref2 = (item, refs) => {
+var get$ref3 = (item, refs) => {
   switch (refs.$refStrategy) {
     case "root":
       return { $ref: item.path.join("/") };
     case "relative":
-      return { $ref: getRelativePath2(refs.currentPath, item.path) };
+      return { $ref: getRelativePath3(refs.currentPath, item.path) };
     case "none":
     case "seen": {
       if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
@@ -6400,20 +7672,20 @@ var get$ref2 = (item, refs) => {
             "/"
           )}! Defaulting to any`
         );
-        return parseAnyDef2();
+        return parseAnyDef3();
       }
-      return refs.$refStrategy === "seen" ? parseAnyDef2() : void 0;
+      return refs.$refStrategy === "seen" ? parseAnyDef3() : void 0;
     }
   }
 };
-var addMeta2 = (def, refs, jsonSchema22) => {
+var addMeta3 = (def, refs, jsonSchema22) => {
   if (def.description) {
     jsonSchema22.description = def.description;
   }
   return jsonSchema22;
 };
-var getRefs2 = (options) => {
-  const _options = getDefaultOptions2(options);
+var getRefs3 = (options) => {
+  const _options = getDefaultOptions3(options);
   const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
   return {
     ..._options,
@@ -6432,35 +7704,35 @@ var getRefs2 = (options) => {
     )
   };
 };
-var zodToJsonSchema3 = (schema, options) => {
+var zodToJsonSchema4 = (schema, options) => {
   var _a26;
-  const refs = getRefs2(options);
+  const refs = getRefs3(options);
   let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
     (acc, [name26, schema2]) => {
       var _a27;
       return {
         ...acc,
-        [name26]: (_a27 = parseDef2(
+        [name26]: (_a27 = parseDef3(
           schema2._def,
           {
             ...refs,
             currentPath: [...refs.basePath, refs.definitionPath, name26]
           },
           true
-        )) != null ? _a27 : parseAnyDef2()
+        )) != null ? _a27 : parseAnyDef3()
       };
     },
     {}
   ) : void 0;
   const name21 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
-  const main = (_a26 = parseDef2(
+  const main = (_a26 = parseDef3(
     schema._def,
     name21 === void 0 ? refs : {
       ...refs,
       currentPath: [...refs.basePath, refs.definitionPath, name21]
     },
     false
-  )) != null ? _a26 : parseAnyDef2();
+  )) != null ? _a26 : parseAnyDef3();
   const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
   if (title !== void 0) {
     main.title = title;
@@ -6482,7 +7754,7 @@ var zodToJsonSchema3 = (schema, options) => {
   combined.$schema = "http://json-schema.org/draft-07/schema#";
   return combined;
 };
-var zod_to_json_schema_default = zodToJsonSchema3;
+var zod_to_json_schema_default = zodToJsonSchema4;
 function zod3Schema(zodSchema22, options) {
   var _a26;
   const useReferences = (_a26 = void 0 ) != null ? _a26 : false;
@@ -10476,8 +11748,8 @@ function safeParseJSON3({
     };
   }
 }
-var ignoreOverride3 = Symbol("Let zodToJsonSchema decide on which parser to use");
-var defaultOptions3 = {
+var ignoreOverride4 = Symbol("Let zodToJsonSchema decide on which parser to use");
+var defaultOptions4 = {
   name: void 0,
   $refStrategy: "root",
   basePath: ["#"],
@@ -10501,15 +11773,15 @@ var defaultOptions3 = {
   nameStrategy: "ref",
   openAiAnyTypeName: "OpenAiAnyType"
 };
-var getDefaultOptions3 = (options) => typeof options === "string" ? {
-  ...defaultOptions3,
+var getDefaultOptions4 = (options) => typeof options === "string" ? {
+  ...defaultOptions4,
   name: options
 } : {
-  ...defaultOptions3,
+  ...defaultOptions4,
   ...options
 };
-var getRefs3 = (options) => {
-  const _options = getDefaultOptions3(options);
+var getRefs4 = (options) => {
+  const _options = getDefaultOptions4(options);
   const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
   return {
     ..._options,
@@ -10527,7 +11799,7 @@ var getRefs3 = (options) => {
     ]))
   };
 };
-function addErrorMessage2(res, key, errorMessage, refs) {
+function addErrorMessage3(res, key, errorMessage, refs) {
   if (!refs?.errorMessages)
     return;
   if (errorMessage) {
@@ -10537,11 +11809,11 @@ function addErrorMessage2(res, key, errorMessage, refs) {
     };
   }
 }
-function setResponseValueAndErrors2(res, key, value, errorMessage, refs) {
+function setResponseValueAndErrors3(res, key, value, errorMessage, refs) {
   res[key] = value;
-  addErrorMessage2(res, key, errorMessage, refs);
+  addErrorMessage3(res, key, errorMessage, refs);
 }
-var getRelativePath3 = (pathA, pathB) => {
+var getRelativePath4 = (pathA, pathB) => {
   let i = 0;
   for (; i < pathA.length && i < pathB.length; i++) {
     if (pathA[i] !== pathB[i])
@@ -10549,7 +11821,7 @@ var getRelativePath3 = (pathA, pathB) => {
   }
   return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
 };
-function parseAnyDef3(refs) {
+function parseAnyDef4(refs) {
   if (refs.target !== "openAi") {
     return {};
   }
@@ -10560,32 +11832,32 @@ function parseAnyDef3(refs) {
   ];
   refs.flags.hasReferencedOpenAiAnyType = true;
   return {
-    $ref: refs.$refStrategy === "relative" ? getRelativePath3(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+    $ref: refs.$refStrategy === "relative" ? getRelativePath4(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
   };
 }
-function parseArrayDef3(def, refs) {
+function parseArrayDef4(def, refs) {
   const res = {
     type: "array"
   };
-  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
-    res.items = parseDef3(def.type._def, {
+  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind$1.ZodAny) {
+    res.items = parseDef4(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
     });
   }
   if (def.minLength) {
-    setResponseValueAndErrors2(res, "minItems", def.minLength.value, def.minLength.message, refs);
+    setResponseValueAndErrors3(res, "minItems", def.minLength.value, def.minLength.message, refs);
   }
   if (def.maxLength) {
-    setResponseValueAndErrors2(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+    setResponseValueAndErrors3(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
   }
   if (def.exactLength) {
-    setResponseValueAndErrors2(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
-    setResponseValueAndErrors2(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors3(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors3(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
   }
   return res;
 }
-function parseBigintDef3(def, refs) {
+function parseBigintDef4(def, refs) {
   const res = {
     type: "integer",
     format: "int64"
@@ -10597,54 +11869,54 @@ function parseBigintDef3(def, refs) {
       case "min":
         if (refs.target === "jsonSchema7") {
           if (check.inclusive) {
-            setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs);
+            setResponseValueAndErrors3(res, "minimum", check.value, check.message, refs);
           } else {
-            setResponseValueAndErrors2(res, "exclusiveMinimum", check.value, check.message, refs);
+            setResponseValueAndErrors3(res, "exclusiveMinimum", check.value, check.message, refs);
           }
         } else {
           if (!check.inclusive) {
             res.exclusiveMinimum = true;
           }
-          setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs);
+          setResponseValueAndErrors3(res, "minimum", check.value, check.message, refs);
         }
         break;
       case "max":
         if (refs.target === "jsonSchema7") {
           if (check.inclusive) {
-            setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs);
+            setResponseValueAndErrors3(res, "maximum", check.value, check.message, refs);
           } else {
-            setResponseValueAndErrors2(res, "exclusiveMaximum", check.value, check.message, refs);
+            setResponseValueAndErrors3(res, "exclusiveMaximum", check.value, check.message, refs);
           }
         } else {
           if (!check.inclusive) {
             res.exclusiveMaximum = true;
           }
-          setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs);
+          setResponseValueAndErrors3(res, "maximum", check.value, check.message, refs);
         }
         break;
       case "multipleOf":
-        setResponseValueAndErrors2(res, "multipleOf", check.value, check.message, refs);
+        setResponseValueAndErrors3(res, "multipleOf", check.value, check.message, refs);
         break;
     }
   }
   return res;
 }
-function parseBooleanDef3() {
+function parseBooleanDef4() {
   return {
     type: "boolean"
   };
 }
-function parseBrandedDef3(_def, refs) {
-  return parseDef3(_def.type._def, refs);
+function parseBrandedDef4(_def, refs) {
+  return parseDef4(_def.type._def, refs);
 }
-var parseCatchDef3 = (def, refs) => {
-  return parseDef3(def.innerType._def, refs);
+var parseCatchDef4 = (def, refs) => {
+  return parseDef4(def.innerType._def, refs);
 };
-function parseDateDef3(def, refs, overrideDateStrategy) {
+function parseDateDef4(def, refs, overrideDateStrategy) {
   const strategy = overrideDateStrategy ?? refs.dateStrategy;
   if (Array.isArray(strategy)) {
     return {
-      anyOf: strategy.map((item, i) => parseDateDef3(def, refs, item))
+      anyOf: strategy.map((item, i) => parseDateDef4(def, refs, item))
     };
   }
   switch (strategy) {
@@ -10660,10 +11932,10 @@ function parseDateDef3(def, refs, overrideDateStrategy) {
         format: "date"
       };
     case "integer":
-      return integerDateParser3(def, refs);
+      return integerDateParser4(def, refs);
   }
 }
-var integerDateParser3 = (def, refs) => {
+var integerDateParser4 = (def, refs) => {
   const res = {
     type: "integer",
     format: "unix-time"
@@ -10674,7 +11946,7 @@ var integerDateParser3 = (def, refs) => {
   for (const check of def.checks) {
     switch (check.kind) {
       case "min":
-        setResponseValueAndErrors2(
+        setResponseValueAndErrors3(
           res,
           "minimum",
           check.value,
@@ -10684,7 +11956,7 @@ var integerDateParser3 = (def, refs) => {
         );
         break;
       case "max":
-        setResponseValueAndErrors2(
+        setResponseValueAndErrors3(
           res,
           "maximum",
           check.value,
@@ -10697,33 +11969,33 @@ var integerDateParser3 = (def, refs) => {
   }
   return res;
 };
-function parseDefaultDef3(_def, refs) {
+function parseDefaultDef4(_def, refs) {
   return {
-    ...parseDef3(_def.innerType._def, refs),
+    ...parseDef4(_def.innerType._def, refs),
     default: _def.defaultValue()
   };
 }
-function parseEffectsDef3(_def, refs) {
-  return refs.effectStrategy === "input" ? parseDef3(_def.schema._def, refs) : parseAnyDef3(refs);
+function parseEffectsDef4(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef4(_def.schema._def, refs) : parseAnyDef4(refs);
 }
-function parseEnumDef3(def) {
+function parseEnumDef4(def) {
   return {
     type: "string",
     enum: Array.from(def.values)
   };
 }
-var isJsonSchema7AllOfType3 = (type) => {
+var isJsonSchema7AllOfType4 = (type) => {
   if ("type" in type && type.type === "string")
     return false;
   return "allOf" in type;
 };
-function parseIntersectionDef3(def, refs) {
+function parseIntersectionDef4(def, refs) {
   const allOf = [
-    parseDef3(def.left._def, {
+    parseDef4(def.left._def, {
       ...refs,
       currentPath: [...refs.currentPath, "allOf", "0"]
     }),
-    parseDef3(def.right._def, {
+    parseDef4(def.right._def, {
       ...refs,
       currentPath: [...refs.currentPath, "allOf", "1"]
     })
@@ -10731,7 +12003,7 @@ function parseIntersectionDef3(def, refs) {
   let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
   const mergedAllOf = [];
   allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType3(schema)) {
+    if (isJsonSchema7AllOfType4(schema)) {
       mergedAllOf.push(...schema.allOf);
       if (schema.unevaluatedProperties === void 0) {
         unevaluatedProperties = void 0;
@@ -10752,7 +12024,7 @@ function parseIntersectionDef3(def, refs) {
     ...unevaluatedProperties
   } : void 0;
 }
-function parseLiteralDef3(def, refs) {
+function parseLiteralDef4(def, refs) {
   const parsedType = typeof def.value;
   if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
     return {
@@ -10770,8 +12042,8 @@ function parseLiteralDef3(def, refs) {
     const: def.value
   };
 }
-var emojiRegex3 = void 0;
-var zodPatterns3 = {
+var emojiRegex4 = void 0;
+var zodPatterns4 = {
   /**
    * `c` was changed to `[cC]` to replicate /i flag
    */
@@ -10794,10 +12066,10 @@ var zodPatterns3 = {
    * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
    */
   emoji: () => {
-    if (emojiRegex3 === void 0) {
-      emojiRegex3 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+    if (emojiRegex4 === void 0) {
+      emojiRegex4 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
     }
-    return emojiRegex3;
+    return emojiRegex4;
   },
   /**
    * Unused
@@ -10818,7 +12090,7 @@ var zodPatterns3 = {
   nanoid: /^[a-zA-Z0-9_-]{21}$/,
   jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
 };
-function parseStringDef3(def, refs) {
+function parseStringDef4(def, refs) {
   const res = {
     type: "string"
   };
@@ -10826,136 +12098,136 @@ function parseStringDef3(def, refs) {
     for (const check of def.checks) {
       switch (check.kind) {
         case "min":
-          setResponseValueAndErrors2(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          setResponseValueAndErrors3(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
           break;
         case "max":
-          setResponseValueAndErrors2(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          setResponseValueAndErrors3(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
           break;
         case "email":
           switch (refs.emailStrategy) {
             case "format:email":
-              addFormat3(res, "email", check.message, refs);
+              addFormat4(res, "email", check.message, refs);
               break;
             case "format:idn-email":
-              addFormat3(res, "idn-email", check.message, refs);
+              addFormat4(res, "idn-email", check.message, refs);
               break;
             case "pattern:zod":
-              addPattern3(res, zodPatterns3.email, check.message, refs);
+              addPattern4(res, zodPatterns4.email, check.message, refs);
               break;
           }
           break;
         case "url":
-          addFormat3(res, "uri", check.message, refs);
+          addFormat4(res, "uri", check.message, refs);
           break;
         case "uuid":
-          addFormat3(res, "uuid", check.message, refs);
+          addFormat4(res, "uuid", check.message, refs);
           break;
         case "regex":
-          addPattern3(res, check.regex, check.message, refs);
+          addPattern4(res, check.regex, check.message, refs);
           break;
         case "cuid":
-          addPattern3(res, zodPatterns3.cuid, check.message, refs);
+          addPattern4(res, zodPatterns4.cuid, check.message, refs);
           break;
         case "cuid2":
-          addPattern3(res, zodPatterns3.cuid2, check.message, refs);
+          addPattern4(res, zodPatterns4.cuid2, check.message, refs);
           break;
         case "startsWith":
-          addPattern3(res, RegExp(`^${escapeLiteralCheckValue3(check.value, refs)}`), check.message, refs);
+          addPattern4(res, RegExp(`^${escapeLiteralCheckValue4(check.value, refs)}`), check.message, refs);
           break;
         case "endsWith":
-          addPattern3(res, RegExp(`${escapeLiteralCheckValue3(check.value, refs)}$`), check.message, refs);
+          addPattern4(res, RegExp(`${escapeLiteralCheckValue4(check.value, refs)}$`), check.message, refs);
           break;
         case "datetime":
-          addFormat3(res, "date-time", check.message, refs);
+          addFormat4(res, "date-time", check.message, refs);
           break;
         case "date":
-          addFormat3(res, "date", check.message, refs);
+          addFormat4(res, "date", check.message, refs);
           break;
         case "time":
-          addFormat3(res, "time", check.message, refs);
+          addFormat4(res, "time", check.message, refs);
           break;
         case "duration":
-          addFormat3(res, "duration", check.message, refs);
+          addFormat4(res, "duration", check.message, refs);
           break;
         case "length":
-          setResponseValueAndErrors2(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
-          setResponseValueAndErrors2(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          setResponseValueAndErrors3(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          setResponseValueAndErrors3(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
           break;
         case "includes": {
-          addPattern3(res, RegExp(escapeLiteralCheckValue3(check.value, refs)), check.message, refs);
+          addPattern4(res, RegExp(escapeLiteralCheckValue4(check.value, refs)), check.message, refs);
           break;
         }
         case "ip": {
           if (check.version !== "v6") {
-            addFormat3(res, "ipv4", check.message, refs);
+            addFormat4(res, "ipv4", check.message, refs);
           }
           if (check.version !== "v4") {
-            addFormat3(res, "ipv6", check.message, refs);
+            addFormat4(res, "ipv6", check.message, refs);
           }
           break;
         }
         case "base64url":
-          addPattern3(res, zodPatterns3.base64url, check.message, refs);
+          addPattern4(res, zodPatterns4.base64url, check.message, refs);
           break;
         case "jwt":
-          addPattern3(res, zodPatterns3.jwt, check.message, refs);
+          addPattern4(res, zodPatterns4.jwt, check.message, refs);
           break;
         case "cidr": {
           if (check.version !== "v6") {
-            addPattern3(res, zodPatterns3.ipv4Cidr, check.message, refs);
+            addPattern4(res, zodPatterns4.ipv4Cidr, check.message, refs);
           }
           if (check.version !== "v4") {
-            addPattern3(res, zodPatterns3.ipv6Cidr, check.message, refs);
+            addPattern4(res, zodPatterns4.ipv6Cidr, check.message, refs);
           }
           break;
         }
         case "emoji":
-          addPattern3(res, zodPatterns3.emoji(), check.message, refs);
+          addPattern4(res, zodPatterns4.emoji(), check.message, refs);
           break;
         case "ulid": {
-          addPattern3(res, zodPatterns3.ulid, check.message, refs);
+          addPattern4(res, zodPatterns4.ulid, check.message, refs);
           break;
         }
         case "base64": {
           switch (refs.base64Strategy) {
             case "format:binary": {
-              addFormat3(res, "binary", check.message, refs);
+              addFormat4(res, "binary", check.message, refs);
               break;
             }
             case "contentEncoding:base64": {
-              setResponseValueAndErrors2(res, "contentEncoding", "base64", check.message, refs);
+              setResponseValueAndErrors3(res, "contentEncoding", "base64", check.message, refs);
               break;
             }
             case "pattern:zod": {
-              addPattern3(res, zodPatterns3.base64, check.message, refs);
+              addPattern4(res, zodPatterns4.base64, check.message, refs);
               break;
             }
           }
           break;
         }
         case "nanoid": {
-          addPattern3(res, zodPatterns3.nanoid, check.message, refs);
+          addPattern4(res, zodPatterns4.nanoid, check.message, refs);
         }
       }
     }
   }
   return res;
 }
-function escapeLiteralCheckValue3(literal, refs) {
-  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric3(literal) : literal;
+function escapeLiteralCheckValue4(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric4(literal) : literal;
 }
-var ALPHA_NUMERIC3 = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-function escapeNonAlphaNumeric3(source) {
+var ALPHA_NUMERIC4 = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric4(source) {
   let result = "";
   for (let i = 0; i < source.length; i++) {
-    if (!ALPHA_NUMERIC3.has(source[i])) {
+    if (!ALPHA_NUMERIC4.has(source[i])) {
       result += "\\";
     }
     result += source[i];
   }
   return result;
 }
-function addFormat3(schema, value, message, refs) {
+function addFormat4(schema, value, message, refs) {
   if (schema.format || schema.anyOf?.some((x) => x.format)) {
     if (!schema.anyOf) {
       schema.anyOf = [];
@@ -10980,10 +12252,10 @@ function addFormat3(schema, value, message, refs) {
       ...message && refs.errorMessages && { errorMessage: { format: message } }
     });
   } else {
-    setResponseValueAndErrors2(schema, "format", value, message, refs);
+    setResponseValueAndErrors3(schema, "format", value, message, refs);
   }
 }
-function addPattern3(schema, regex, message, refs) {
+function addPattern4(schema, regex, message, refs) {
   if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
     if (!schema.allOf) {
       schema.allOf = [];
@@ -11004,14 +12276,14 @@ function addPattern3(schema, regex, message, refs) {
       }
     }
     schema.allOf.push({
-      pattern: stringifyRegExpWithFlags3(regex, refs),
+      pattern: stringifyRegExpWithFlags4(regex, refs),
       ...message && refs.errorMessages && { errorMessage: { pattern: message } }
     });
   } else {
-    setResponseValueAndErrors2(schema, "pattern", stringifyRegExpWithFlags3(regex, refs), message, refs);
+    setResponseValueAndErrors3(schema, "pattern", stringifyRegExpWithFlags4(regex, refs), message, refs);
   }
 }
-function stringifyRegExpWithFlags3(regex, refs) {
+function stringifyRegExpWithFlags4(regex, refs) {
   if (!refs.applyRegexFlags || !regex.flags) {
     return regex.source;
   }
@@ -11080,27 +12352,27 @@ function stringifyRegExpWithFlags3(regex, refs) {
   }
   return pattern;
 }
-function parseRecordDef3(def, refs) {
+function parseRecordDef4(def, refs) {
   if (refs.target === "openAi") {
     console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
   }
-  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodEnum) {
     return {
       type: "object",
       required: def.keyType._def.values,
       properties: def.keyType._def.values.reduce((acc, key) => ({
         ...acc,
-        [key]: parseDef3(def.valueType._def, {
+        [key]: parseDef4(def.valueType._def, {
           ...refs,
           currentPath: [...refs.currentPath, "properties", key]
-        }) ?? parseAnyDef3(refs)
+        }) ?? parseAnyDef4(refs)
       }), {}),
       additionalProperties: refs.rejectedAdditionalProperties
     };
   }
   const schema = {
     type: "object",
-    additionalProperties: parseDef3(def.valueType._def, {
+    additionalProperties: parseDef4(def.valueType._def, {
       ...refs,
       currentPath: [...refs.currentPath, "additionalProperties"]
     }) ?? refs.allowedAdditionalProperties
@@ -11108,21 +12380,21 @@ function parseRecordDef3(def, refs) {
   if (refs.target === "openApi3") {
     return schema;
   }
-  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
-    const { type, ...keyType } = parseStringDef3(def.keyType._def, refs);
+  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodString && def.keyType._def.checks?.length) {
+    const { type, ...keyType } = parseStringDef4(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
     };
-  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodEnum) {
     return {
       ...schema,
       propertyNames: {
         enum: def.keyType._def.values
       }
     };
-  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
-    const { type, ...keyType } = parseBrandedDef3(def.keyType._def, refs);
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind$1.ZodString && def.keyType._def.type._def.checks?.length) {
+    const { type, ...keyType } = parseBrandedDef4(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
@@ -11130,18 +12402,18 @@ function parseRecordDef3(def, refs) {
   }
   return schema;
 }
-function parseMapDef3(def, refs) {
+function parseMapDef4(def, refs) {
   if (refs.mapStrategy === "record") {
-    return parseRecordDef3(def, refs);
+    return parseRecordDef4(def, refs);
   }
-  const keys = parseDef3(def.keyType._def, {
+  const keys = parseDef4(def.keyType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items", "items", "0"]
-  }) || parseAnyDef3(refs);
-  const values = parseDef3(def.valueType._def, {
+  }) || parseAnyDef4(refs);
+  const values = parseDef4(def.valueType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items", "items", "1"]
-  }) || parseAnyDef3(refs);
+  }) || parseAnyDef4(refs);
   return {
     type: "array",
     maxItems: 125,
@@ -11153,7 +12425,7 @@ function parseMapDef3(def, refs) {
     }
   };
 }
-function parseNativeEnumDef3(def) {
+function parseNativeEnumDef4(def) {
   const object22 = def.values;
   const actualKeys = Object.keys(def.values).filter((key) => {
     return typeof object22[object22[key]] !== "number";
@@ -11165,15 +12437,15 @@ function parseNativeEnumDef3(def) {
     enum: actualValues
   };
 }
-function parseNeverDef3(refs) {
+function parseNeverDef4(refs) {
   return refs.target === "openAi" ? void 0 : {
-    not: parseAnyDef3({
+    not: parseAnyDef4({
       ...refs,
       currentPath: [...refs.currentPath, "not"]
     })
   };
 }
-function parseNullDef3(refs) {
+function parseNullDef4(refs) {
   return refs.target === "openApi3" ? {
     enum: ["null"],
     nullable: true
@@ -11181,20 +12453,20 @@ function parseNullDef3(refs) {
     type: "null"
   };
 }
-var primitiveMappings3 = {
+var primitiveMappings4 = {
   ZodString: "string",
   ZodNumber: "number",
   ZodBigInt: "integer",
   ZodBoolean: "boolean",
   ZodNull: "null"
 };
-function parseUnionDef3(def, refs) {
+function parseUnionDef4(def, refs) {
   if (refs.target === "openApi3")
-    return asAnyOf3(def, refs);
+    return asAnyOf4(def, refs);
   const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
-  if (options.every((x) => x._def.typeName in primitiveMappings3 && (!x._def.checks || !x._def.checks.length))) {
+  if (options.every((x) => x._def.typeName in primitiveMappings4 && (!x._def.checks || !x._def.checks.length))) {
     const types = options.reduce((types2, x) => {
-      const type = primitiveMappings3[x._def.typeName];
+      const type = primitiveMappings4[x._def.typeName];
       return type && !types2.includes(type) ? [...types2, type] : types2;
     }, []);
     return {
@@ -11238,32 +12510,32 @@ function parseUnionDef3(def, refs) {
       ], [])
     };
   }
-  return asAnyOf3(def, refs);
+  return asAnyOf4(def, refs);
 }
-var asAnyOf3 = (def, refs) => {
-  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef3(x._def, {
+var asAnyOf4 = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef4(x._def, {
     ...refs,
     currentPath: [...refs.currentPath, "anyOf", `${i}`]
   })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
   return anyOf.length ? { anyOf } : void 0;
 };
-function parseNullableDef3(def, refs) {
+function parseNullableDef4(def, refs) {
   if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
     if (refs.target === "openApi3") {
       return {
-        type: primitiveMappings3[def.innerType._def.typeName],
+        type: primitiveMappings4[def.innerType._def.typeName],
         nullable: true
       };
     }
     return {
       type: [
-        primitiveMappings3[def.innerType._def.typeName],
+        primitiveMappings4[def.innerType._def.typeName],
         "null"
       ]
     };
   }
   if (refs.target === "openApi3") {
-    const base2 = parseDef3(def.innerType._def, {
+    const base2 = parseDef4(def.innerType._def, {
       ...refs,
       currentPath: [...refs.currentPath]
     });
@@ -11271,13 +12543,13 @@ function parseNullableDef3(def, refs) {
       return { allOf: [base2], nullable: true };
     return base2 && { ...base2, nullable: true };
   }
-  const base = parseDef3(def.innerType._def, {
+  const base = parseDef4(def.innerType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "anyOf", "0"]
   });
   return base && { anyOf: [base, { type: "null" }] };
 }
-function parseNumberDef3(def, refs) {
+function parseNumberDef4(def, refs) {
   const res = {
     type: "number"
   };
@@ -11287,44 +12559,44 @@ function parseNumberDef3(def, refs) {
     switch (check.kind) {
       case "int":
         res.type = "integer";
-        addErrorMessage2(res, "type", check.message, refs);
+        addErrorMessage3(res, "type", check.message, refs);
         break;
       case "min":
         if (refs.target === "jsonSchema7") {
           if (check.inclusive) {
-            setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs);
+            setResponseValueAndErrors3(res, "minimum", check.value, check.message, refs);
           } else {
-            setResponseValueAndErrors2(res, "exclusiveMinimum", check.value, check.message, refs);
+            setResponseValueAndErrors3(res, "exclusiveMinimum", check.value, check.message, refs);
           }
         } else {
           if (!check.inclusive) {
             res.exclusiveMinimum = true;
           }
-          setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs);
+          setResponseValueAndErrors3(res, "minimum", check.value, check.message, refs);
         }
         break;
       case "max":
         if (refs.target === "jsonSchema7") {
           if (check.inclusive) {
-            setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs);
+            setResponseValueAndErrors3(res, "maximum", check.value, check.message, refs);
           } else {
-            setResponseValueAndErrors2(res, "exclusiveMaximum", check.value, check.message, refs);
+            setResponseValueAndErrors3(res, "exclusiveMaximum", check.value, check.message, refs);
           }
         } else {
           if (!check.inclusive) {
             res.exclusiveMaximum = true;
           }
-          setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs);
+          setResponseValueAndErrors3(res, "maximum", check.value, check.message, refs);
         }
         break;
       case "multipleOf":
-        setResponseValueAndErrors2(res, "multipleOf", check.value, check.message, refs);
+        setResponseValueAndErrors3(res, "multipleOf", check.value, check.message, refs);
         break;
     }
   }
   return res;
 }
-function parseObjectDef3(def, refs) {
+function parseObjectDef4(def, refs) {
   const forceOptionalIntoNullable = refs.target === "openAi";
   const result = {
     type: "object",
@@ -11337,7 +12609,7 @@ function parseObjectDef3(def, refs) {
     if (propDef === void 0 || propDef._def === void 0) {
       continue;
     }
-    let propOptional = safeIsOptional3(propDef);
+    let propOptional = safeIsOptional4(propDef);
     if (propOptional && forceOptionalIntoNullable) {
       if (propDef._def.typeName === "ZodOptional") {
         propDef = propDef._def.innerType;
@@ -11347,7 +12619,7 @@ function parseObjectDef3(def, refs) {
       }
       propOptional = false;
     }
-    const parsedDef = parseDef3(propDef._def, {
+    const parsedDef = parseDef4(propDef._def, {
       ...refs,
       currentPath: [...refs.currentPath, "properties", propName],
       propertyPath: [...refs.currentPath, "properties", propName]
@@ -11363,15 +12635,15 @@ function parseObjectDef3(def, refs) {
   if (required.length) {
     result.required = required;
   }
-  const additionalProperties = decideAdditionalProperties3(def, refs);
+  const additionalProperties = decideAdditionalProperties4(def, refs);
   if (additionalProperties !== void 0) {
     result.additionalProperties = additionalProperties;
   }
   return result;
 }
-function decideAdditionalProperties3(def, refs) {
+function decideAdditionalProperties4(def, refs) {
   if (def.catchall._def.typeName !== "ZodNever") {
-    return parseDef3(def.catchall._def, {
+    return parseDef4(def.catchall._def, {
       ...refs,
       currentPath: [...refs.currentPath, "additionalProperties"]
     });
@@ -11385,41 +12657,41 @@ function decideAdditionalProperties3(def, refs) {
       return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
   }
 }
-function safeIsOptional3(schema) {
+function safeIsOptional4(schema) {
   try {
     return schema.isOptional();
   } catch {
     return true;
   }
 }
-var parseOptionalDef3 = (def, refs) => {
+var parseOptionalDef4 = (def, refs) => {
   if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
-    return parseDef3(def.innerType._def, refs);
+    return parseDef4(def.innerType._def, refs);
   }
-  const innerSchema = parseDef3(def.innerType._def, {
+  const innerSchema = parseDef4(def.innerType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "anyOf", "1"]
   });
   return innerSchema ? {
     anyOf: [
       {
-        not: parseAnyDef3(refs)
+        not: parseAnyDef4(refs)
       },
       innerSchema
     ]
-  } : parseAnyDef3(refs);
+  } : parseAnyDef4(refs);
 };
-var parsePipelineDef3 = (def, refs) => {
+var parsePipelineDef4 = (def, refs) => {
   if (refs.pipeStrategy === "input") {
-    return parseDef3(def.in._def, refs);
+    return parseDef4(def.in._def, refs);
   } else if (refs.pipeStrategy === "output") {
-    return parseDef3(def.out._def, refs);
+    return parseDef4(def.out._def, refs);
   }
-  const a = parseDef3(def.in._def, {
+  const a = parseDef4(def.in._def, {
     ...refs,
     currentPath: [...refs.currentPath, "allOf", "0"]
   });
-  const b = parseDef3(def.out._def, {
+  const b = parseDef4(def.out._def, {
     ...refs,
     currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
   });
@@ -11427,11 +12699,11 @@ var parsePipelineDef3 = (def, refs) => {
     allOf: [a, b].filter((x) => x !== void 0)
   };
 };
-function parsePromiseDef3(def, refs) {
-  return parseDef3(def.type._def, refs);
+function parsePromiseDef4(def, refs) {
+  return parseDef4(def.type._def, refs);
 }
-function parseSetDef3(def, refs) {
-  const items = parseDef3(def.valueType._def, {
+function parseSetDef4(def, refs) {
+  const items = parseDef4(def.valueType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items"]
   });
@@ -11441,144 +12713,144 @@ function parseSetDef3(def, refs) {
     items
   };
   if (def.minSize) {
-    setResponseValueAndErrors2(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+    setResponseValueAndErrors3(schema, "minItems", def.minSize.value, def.minSize.message, refs);
   }
   if (def.maxSize) {
-    setResponseValueAndErrors2(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+    setResponseValueAndErrors3(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
   }
   return schema;
 }
-function parseTupleDef3(def, refs) {
+function parseTupleDef4(def, refs) {
   if (def.rest) {
     return {
       type: "array",
       minItems: def.items.length,
-      items: def.items.map((x, i) => parseDef3(x._def, {
+      items: def.items.map((x, i) => parseDef4(x._def, {
         ...refs,
         currentPath: [...refs.currentPath, "items", `${i}`]
       })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
-      additionalItems: parseDef3(def.rest._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "additionalItems"]
-      })
-    };
-  } else {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      maxItems: def.items.length,
-      items: def.items.map((x, i) => parseDef3(x._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", `${i}`]
-      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
-    };
-  }
-}
-function parseUndefinedDef3(refs) {
-  return {
-    not: parseAnyDef3(refs)
-  };
-}
-function parseUnknownDef3(refs) {
-  return parseAnyDef3(refs);
-}
-var parseReadonlyDef3 = (def, refs) => {
-  return parseDef3(def.innerType._def, refs);
-};
-var selectParser3 = (def, typeName, refs) => {
-  switch (typeName) {
-    case ZodFirstPartyTypeKind.ZodString:
-      return parseStringDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodNumber:
-      return parseNumberDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodObject:
-      return parseObjectDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodBigInt:
-      return parseBigintDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodBoolean:
-      return parseBooleanDef3();
-    case ZodFirstPartyTypeKind.ZodDate:
-      return parseDateDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodUndefined:
-      return parseUndefinedDef3(refs);
-    case ZodFirstPartyTypeKind.ZodNull:
-      return parseNullDef3(refs);
-    case ZodFirstPartyTypeKind.ZodArray:
-      return parseArrayDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodUnion:
-    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-      return parseUnionDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodIntersection:
-      return parseIntersectionDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodTuple:
-      return parseTupleDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodRecord:
-      return parseRecordDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodLiteral:
-      return parseLiteralDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodEnum:
-      return parseEnumDef3(def);
-    case ZodFirstPartyTypeKind.ZodNativeEnum:
-      return parseNativeEnumDef3(def);
-    case ZodFirstPartyTypeKind.ZodNullable:
-      return parseNullableDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodOptional:
-      return parseOptionalDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodMap:
-      return parseMapDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodSet:
-      return parseSetDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodLazy:
+      additionalItems: parseDef4(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalItems"]
+      })
+    };
+  } else {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items.map((x, i) => parseDef4(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+    };
+  }
+}
+function parseUndefinedDef4(refs) {
+  return {
+    not: parseAnyDef4(refs)
+  };
+}
+function parseUnknownDef4(refs) {
+  return parseAnyDef4(refs);
+}
+var parseReadonlyDef4 = (def, refs) => {
+  return parseDef4(def.innerType._def, refs);
+};
+var selectParser4 = (def, typeName, refs) => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind$1.ZodString:
+      return parseStringDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodNumber:
+      return parseNumberDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodObject:
+      return parseObjectDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodBigInt:
+      return parseBigintDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodBoolean:
+      return parseBooleanDef4();
+    case ZodFirstPartyTypeKind$1.ZodDate:
+      return parseDateDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodUndefined:
+      return parseUndefinedDef4(refs);
+    case ZodFirstPartyTypeKind$1.ZodNull:
+      return parseNullDef4(refs);
+    case ZodFirstPartyTypeKind$1.ZodArray:
+      return parseArrayDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodUnion:
+    case ZodFirstPartyTypeKind$1.ZodDiscriminatedUnion:
+      return parseUnionDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodIntersection:
+      return parseIntersectionDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodTuple:
+      return parseTupleDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodRecord:
+      return parseRecordDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodLiteral:
+      return parseLiteralDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodEnum:
+      return parseEnumDef4(def);
+    case ZodFirstPartyTypeKind$1.ZodNativeEnum:
+      return parseNativeEnumDef4(def);
+    case ZodFirstPartyTypeKind$1.ZodNullable:
+      return parseNullableDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodOptional:
+      return parseOptionalDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodMap:
+      return parseMapDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodSet:
+      return parseSetDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodLazy:
       return () => def.getter()._def;
-    case ZodFirstPartyTypeKind.ZodPromise:
-      return parsePromiseDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodNaN:
-    case ZodFirstPartyTypeKind.ZodNever:
-      return parseNeverDef3(refs);
-    case ZodFirstPartyTypeKind.ZodEffects:
-      return parseEffectsDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodAny:
-      return parseAnyDef3(refs);
-    case ZodFirstPartyTypeKind.ZodUnknown:
-      return parseUnknownDef3(refs);
-    case ZodFirstPartyTypeKind.ZodDefault:
-      return parseDefaultDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodBranded:
-      return parseBrandedDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodReadonly:
-      return parseReadonlyDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodCatch:
-      return parseCatchDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodPipeline:
-      return parsePipelineDef3(def, refs);
-    case ZodFirstPartyTypeKind.ZodFunction:
-    case ZodFirstPartyTypeKind.ZodVoid:
-    case ZodFirstPartyTypeKind.ZodSymbol:
+    case ZodFirstPartyTypeKind$1.ZodPromise:
+      return parsePromiseDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodNaN:
+    case ZodFirstPartyTypeKind$1.ZodNever:
+      return parseNeverDef4(refs);
+    case ZodFirstPartyTypeKind$1.ZodEffects:
+      return parseEffectsDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodAny:
+      return parseAnyDef4(refs);
+    case ZodFirstPartyTypeKind$1.ZodUnknown:
+      return parseUnknownDef4(refs);
+    case ZodFirstPartyTypeKind$1.ZodDefault:
+      return parseDefaultDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodBranded:
+      return parseBrandedDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodReadonly:
+      return parseReadonlyDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodCatch:
+      return parseCatchDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodPipeline:
+      return parsePipelineDef4(def, refs);
+    case ZodFirstPartyTypeKind$1.ZodFunction:
+    case ZodFirstPartyTypeKind$1.ZodVoid:
+    case ZodFirstPartyTypeKind$1.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)();
   }
 };
-function parseDef3(def, refs, forceResolution = false) {
+function parseDef4(def, refs, forceResolution = false) {
   const seenItem = refs.seen.get(def);
   if (refs.override) {
     const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
-    if (overrideResult !== ignoreOverride3) {
+    if (overrideResult !== ignoreOverride4) {
       return overrideResult;
     }
   }
   if (seenItem && !forceResolution) {
-    const seenSchema = get$ref3(seenItem, refs);
+    const seenSchema = get$ref4(seenItem, refs);
     if (seenSchema !== void 0) {
       return seenSchema;
     }
   }
   const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
   refs.seen.set(def, newItem);
-  const jsonSchemaOrGetter = selectParser3(def, def.typeName, refs);
-  const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef3(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  const jsonSchemaOrGetter = selectParser4(def, def.typeName, refs);
+  const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef4(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
   if (jsonSchema22) {
-    addMeta3(def, refs, jsonSchema22);
+    addMeta4(def, refs, jsonSchema22);
   }
   if (refs.postProcess) {
     const postProcessResult = refs.postProcess(jsonSchema22, def, refs);
@@ -11588,23 +12860,23 @@ function parseDef3(def, refs, forceResolution = false) {
   newItem.jsonSchema = jsonSchema22;
   return jsonSchema22;
 }
-var get$ref3 = (item, refs) => {
+var get$ref4 = (item, refs) => {
   switch (refs.$refStrategy) {
     case "root":
       return { $ref: item.path.join("/") };
     case "relative":
-      return { $ref: getRelativePath3(refs.currentPath, item.path) };
+      return { $ref: getRelativePath4(refs.currentPath, item.path) };
     case "none":
     case "seen": {
       if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
         console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
-        return parseAnyDef3(refs);
+        return parseAnyDef4(refs);
       }
-      return refs.$refStrategy === "seen" ? parseAnyDef3(refs) : void 0;
+      return refs.$refStrategy === "seen" ? parseAnyDef4(refs) : void 0;
     }
   }
 };
-var addMeta3 = (def, refs, jsonSchema22) => {
+var addMeta4 = (def, refs, jsonSchema22) => {
   if (def.description) {
     jsonSchema22.description = def.description;
     if (refs.markdownDescription) {
@@ -11614,19 +12886,19 @@ var addMeta3 = (def, refs, jsonSchema22) => {
   return jsonSchema22;
 };
 var zodToJsonSchema22 = (schema, options) => {
-  const refs = getRefs3(options);
+  const refs = getRefs4(options);
   let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name182, schema2]) => ({
     ...acc,
-    [name182]: parseDef3(schema2._def, {
+    [name182]: parseDef4(schema2._def, {
       ...refs,
       currentPath: [...refs.basePath, refs.definitionPath, name182]
-    }, true) ?? parseAnyDef3(refs)
+    }, true) ?? parseAnyDef4(refs)
   }), {}) : void 0;
   const name172 = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
-  const main = parseDef3(schema._def, name172 === void 0 ? refs : {
+  const main = parseDef4(schema._def, name172 === void 0 ? refs : {
     ...refs,
     currentPath: [...refs.basePath, refs.definitionPath, name172]
-  }, false) ?? parseAnyDef3(refs);
+  }, false) ?? parseAnyDef4(refs);
   const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
   if (title !== void 0) {
     main.title = title;
@@ -11673,7 +12945,7 @@ var zodToJsonSchema22 = (schema, options) => {
   }
   return combined;
 };
-var esm_default2 = zodToJsonSchema22;
+var esm_default3 = zodToJsonSchema22;
 function fixJson3(input) {
   const stack = ["ROOT"];
   let lastValidIndex = -1;
@@ -12271,7 +13543,7 @@ function zodSchema3(zodSchema22, options) {
   var _a172;
   const useReferences = (_a172 = void 0) != null ? _a172 : false;
   return jsonSchema3(
-    esm_default2(zodSchema22, {
+    esm_default3(zodSchema22, {
       $refStrategy: useReferences ? "root" : "none",
       target: "jsonSchema7"
       // note: openai mode breaks various gemini conversions
@@ -14685,17 +15957,17 @@ async function safeParseJSON4({
     };
   }
 }
-var getRelativePath4 = (pathA, pathB) => {
+var getRelativePath5 = (pathA, pathB) => {
   let i = 0;
   for (; i < pathA.length && i < pathB.length; i++) {
     if (pathA[i] !== pathB[i]) break;
   }
   return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
 };
-var ignoreOverride4 = Symbol(
+var ignoreOverride5 = Symbol(
   "Let zodToJsonSchema decide on which parser to use"
 );
-var defaultOptions4 = {
+var defaultOptions5 = {
   name: void 0,
   $refStrategy: "root",
   basePath: ["#"],
@@ -14716,23 +15988,23 @@ var defaultOptions4 = {
   base64Strategy: "contentEncoding:base64",
   nameStrategy: "ref"
 };
-var getDefaultOptions4 = (options) => typeof options === "string" ? {
-  ...defaultOptions4,
+var getDefaultOptions5 = (options) => typeof options === "string" ? {
+  ...defaultOptions5,
   name: options
 } : {
-  ...defaultOptions4,
+  ...defaultOptions5,
   ...options
 };
-function parseAnyDef4() {
+function parseAnyDef5() {
   return {};
 }
-function parseArrayDef4(def, refs) {
+function parseArrayDef5(def, refs) {
   var _a26, _b8, _c;
   const res = {
     type: "array"
   };
   if (((_a26 = def.type) == null ? void 0 : _a26._def) && ((_c = (_b8 = def.type) == null ? void 0 : _b8._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind$1.ZodAny) {
-    res.items = parseDef4(def.type._def, {
+    res.items = parseDef5(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
     });
@@ -14749,7 +16021,7 @@ function parseArrayDef4(def, refs) {
   }
   return res;
 }
-function parseBigintDef4(def) {
+function parseBigintDef5(def) {
   const res = {
     type: "integer",
     format: "int64"
@@ -14778,20 +16050,20 @@ function parseBigintDef4(def) {
   }
   return res;
 }
-function parseBooleanDef4() {
+function parseBooleanDef5() {
   return { type: "boolean" };
 }
-function parseBrandedDef4(_def, refs) {
-  return parseDef4(_def.type._def, refs);
+function parseBrandedDef5(_def, refs) {
+  return parseDef5(_def.type._def, refs);
 }
-var parseCatchDef4 = (def, refs) => {
-  return parseDef4(def.innerType._def, refs);
+var parseCatchDef5 = (def, refs) => {
+  return parseDef5(def.innerType._def, refs);
 };
-function parseDateDef4(def, refs, overrideDateStrategy) {
+function parseDateDef5(def, refs, overrideDateStrategy) {
   const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
   if (Array.isArray(strategy)) {
     return {
-      anyOf: strategy.map((item, i) => parseDateDef4(def, refs, item))
+      anyOf: strategy.map((item, i) => parseDateDef5(def, refs, item))
     };
   }
   switch (strategy) {
@@ -14807,10 +16079,10 @@ function parseDateDef4(def, refs, overrideDateStrategy) {
         format: "date"
       };
     case "integer":
-      return integerDateParser4(def);
+      return integerDateParser5(def);
   }
 }
-var integerDateParser4 = (def) => {
+var integerDateParser5 = (def) => {
   const res = {
     type: "integer",
     format: "unix-time"
@@ -14827,39 +16099,39 @@ var integerDateParser4 = (def) => {
   }
   return res;
 };
-function parseDefaultDef4(_def, refs) {
+function parseDefaultDef5(_def, refs) {
   return {
-    ...parseDef4(_def.innerType._def, refs),
+    ...parseDef5(_def.innerType._def, refs),
     default: _def.defaultValue()
   };
 }
-function parseEffectsDef4(_def, refs) {
-  return refs.effectStrategy === "input" ? parseDef4(_def.schema._def, refs) : parseAnyDef4();
+function parseEffectsDef5(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef5(_def.schema._def, refs) : parseAnyDef5();
 }
-function parseEnumDef4(def) {
+function parseEnumDef5(def) {
   return {
     type: "string",
     enum: Array.from(def.values)
   };
 }
-var isJsonSchema7AllOfType4 = (type) => {
+var isJsonSchema7AllOfType5 = (type) => {
   if ("type" in type && type.type === "string") return false;
   return "allOf" in type;
 };
-function parseIntersectionDef4(def, refs) {
+function parseIntersectionDef5(def, refs) {
   const allOf = [
-    parseDef4(def.left._def, {
+    parseDef5(def.left._def, {
       ...refs,
       currentPath: [...refs.currentPath, "allOf", "0"]
     }),
-    parseDef4(def.right._def, {
+    parseDef5(def.right._def, {
       ...refs,
       currentPath: [...refs.currentPath, "allOf", "1"]
     })
   ].filter((x) => !!x);
   const mergedAllOf = [];
   allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType4(schema)) {
+    if (isJsonSchema7AllOfType5(schema)) {
       mergedAllOf.push(...schema.allOf);
     } else {
       let nestedSchema = schema;
@@ -14872,7 +16144,7 @@ function parseIntersectionDef4(def, refs) {
   });
   return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
 }
-function parseLiteralDef4(def) {
+function parseLiteralDef5(def) {
   const parsedType = typeof def.value;
   if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
     return {
@@ -14884,8 +16156,8 @@ function parseLiteralDef4(def) {
     const: def.value
   };
 }
-var emojiRegex4 = void 0;
-var zodPatterns4 = {
+var emojiRegex5 = void 0;
+var zodPatterns5 = {
   /**
    * `c` was changed to `[cC]` to replicate /i flag
    */
@@ -14908,13 +16180,13 @@ var zodPatterns4 = {
    * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
    */
   emoji: () => {
-    if (emojiRegex4 === void 0) {
-      emojiRegex4 = RegExp(
+    if (emojiRegex5 === void 0) {
+      emojiRegex5 = RegExp(
         "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
         "u"
       );
     }
-    return emojiRegex4;
+    return emojiRegex5;
   },
   /**
    * Unused
@@ -14935,7 +16207,7 @@ var zodPatterns4 = {
   nanoid: /^[a-zA-Z0-9_-]{21}$/,
   jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
 };
-function parseStringDef4(def, refs) {
+function parseStringDef5(def, refs) {
   const res = {
     type: "string"
   };
@@ -14951,67 +16223,67 @@ function parseStringDef4(def, refs) {
         case "email":
           switch (refs.emailStrategy) {
             case "format:email":
-              addFormat4(res, "email", check.message, refs);
+              addFormat5(res, "email", check.message, refs);
               break;
             case "format:idn-email":
-              addFormat4(res, "idn-email", check.message, refs);
+              addFormat5(res, "idn-email", check.message, refs);
               break;
             case "pattern:zod":
-              addPattern4(res, zodPatterns4.email, check.message, refs);
+              addPattern5(res, zodPatterns5.email, check.message, refs);
               break;
           }
           break;
         case "url":
-          addFormat4(res, "uri", check.message, refs);
+          addFormat5(res, "uri", check.message, refs);
           break;
         case "uuid":
-          addFormat4(res, "uuid", check.message, refs);
+          addFormat5(res, "uuid", check.message, refs);
           break;
         case "regex":
-          addPattern4(res, check.regex, check.message, refs);
+          addPattern5(res, check.regex, check.message, refs);
           break;
         case "cuid":
-          addPattern4(res, zodPatterns4.cuid, check.message, refs);
+          addPattern5(res, zodPatterns5.cuid, check.message, refs);
           break;
         case "cuid2":
-          addPattern4(res, zodPatterns4.cuid2, check.message, refs);
+          addPattern5(res, zodPatterns5.cuid2, check.message, refs);
           break;
         case "startsWith":
-          addPattern4(
+          addPattern5(
             res,
-            RegExp(`^${escapeLiteralCheckValue4(check.value, refs)}`),
+            RegExp(`^${escapeLiteralCheckValue5(check.value, refs)}`),
             check.message,
             refs
           );
           break;
         case "endsWith":
-          addPattern4(
+          addPattern5(
             res,
-            RegExp(`${escapeLiteralCheckValue4(check.value, refs)}$`),
+            RegExp(`${escapeLiteralCheckValue5(check.value, refs)}$`),
             check.message,
             refs
           );
           break;
         case "datetime":
-          addFormat4(res, "date-time", check.message, refs);
+          addFormat5(res, "date-time", check.message, refs);
           break;
         case "date":
-          addFormat4(res, "date", check.message, refs);
+          addFormat5(res, "date", check.message, refs);
           break;
         case "time":
-          addFormat4(res, "time", check.message, refs);
+          addFormat5(res, "time", check.message, refs);
           break;
         case "duration":
-          addFormat4(res, "duration", check.message, refs);
+          addFormat5(res, "duration", check.message, refs);
           break;
         case "length":
           res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
           res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
           break;
         case "includes": {
-          addPattern4(
+          addPattern5(
             res,
-            RegExp(escapeLiteralCheckValue4(check.value, refs)),
+            RegExp(escapeLiteralCheckValue5(check.value, refs)),
             check.message,
             refs
           );
@@ -15019,39 +16291,39 @@ function parseStringDef4(def, refs) {
         }
         case "ip": {
           if (check.version !== "v6") {
-            addFormat4(res, "ipv4", check.message, refs);
+            addFormat5(res, "ipv4", check.message, refs);
           }
           if (check.version !== "v4") {
-            addFormat4(res, "ipv6", check.message, refs);
+            addFormat5(res, "ipv6", check.message, refs);
           }
           break;
         }
         case "base64url":
-          addPattern4(res, zodPatterns4.base64url, check.message, refs);
+          addPattern5(res, zodPatterns5.base64url, check.message, refs);
           break;
         case "jwt":
-          addPattern4(res, zodPatterns4.jwt, check.message, refs);
+          addPattern5(res, zodPatterns5.jwt, check.message, refs);
           break;
         case "cidr": {
           if (check.version !== "v6") {
-            addPattern4(res, zodPatterns4.ipv4Cidr, check.message, refs);
+            addPattern5(res, zodPatterns5.ipv4Cidr, check.message, refs);
           }
           if (check.version !== "v4") {
-            addPattern4(res, zodPatterns4.ipv6Cidr, check.message, refs);
+            addPattern5(res, zodPatterns5.ipv6Cidr, check.message, refs);
           }
           break;
         }
         case "emoji":
-          addPattern4(res, zodPatterns4.emoji(), check.message, refs);
+          addPattern5(res, zodPatterns5.emoji(), check.message, refs);
           break;
         case "ulid": {
-          addPattern4(res, zodPatterns4.ulid, check.message, refs);
+          addPattern5(res, zodPatterns5.ulid, check.message, refs);
           break;
         }
         case "base64": {
           switch (refs.base64Strategy) {
             case "format:binary": {
-              addFormat4(res, "binary", check.message, refs);
+              addFormat5(res, "binary", check.message, refs);
               break;
             }
             case "contentEncoding:base64": {
@@ -15059,37 +16331,37 @@ function parseStringDef4(def, refs) {
               break;
             }
             case "pattern:zod": {
-              addPattern4(res, zodPatterns4.base64, check.message, refs);
+              addPattern5(res, zodPatterns5.base64, check.message, refs);
               break;
             }
           }
           break;
         }
         case "nanoid": {
-          addPattern4(res, zodPatterns4.nanoid, check.message, refs);
+          addPattern5(res, zodPatterns5.nanoid, check.message, refs);
         }
       }
     }
   }
   return res;
 }
-function escapeLiteralCheckValue4(literal, refs) {
-  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric4(literal) : literal;
+function escapeLiteralCheckValue5(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric5(literal) : literal;
 }
-var ALPHA_NUMERIC4 = new Set(
+var ALPHA_NUMERIC5 = new Set(
   "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
 );
-function escapeNonAlphaNumeric4(source) {
+function escapeNonAlphaNumeric5(source) {
   let result = "";
   for (let i = 0; i < source.length; i++) {
-    if (!ALPHA_NUMERIC4.has(source[i])) {
+    if (!ALPHA_NUMERIC5.has(source[i])) {
       result += "\\";
     }
     result += source[i];
   }
   return result;
 }
-function addFormat4(schema, value, message, refs) {
+function addFormat5(schema, value, message, refs) {
   var _a26;
   if (schema.format || ((_a26 = schema.anyOf) == null ? void 0 : _a26.some((x) => x.format))) {
     if (!schema.anyOf) {
@@ -15109,7 +16381,7 @@ function addFormat4(schema, value, message, refs) {
     schema.format = value;
   }
 }
-function addPattern4(schema, regex, message, refs) {
+function addPattern5(schema, regex, message, refs) {
   var _a26;
   if (schema.pattern || ((_a26 = schema.allOf) == null ? void 0 : _a26.some((x) => x.pattern))) {
     if (!schema.allOf) {
@@ -15122,14 +16394,14 @@ function addPattern4(schema, regex, message, refs) {
       delete schema.pattern;
     }
     schema.allOf.push({
-      pattern: stringifyRegExpWithFlags4(regex, refs),
+      pattern: stringifyRegExpWithFlags5(regex, refs),
       ...message && refs.errorMessages && { errorMessage: { pattern: message } }
     });
   } else {
-    schema.pattern = stringifyRegExpWithFlags4(regex, refs);
+    schema.pattern = stringifyRegExpWithFlags5(regex, refs);
   }
 }
-function stringifyRegExpWithFlags4(regex, refs) {
+function stringifyRegExpWithFlags5(regex, refs) {
   var _a26;
   if (!refs.applyRegexFlags || !regex.flags) {
     return regex.source;
@@ -15201,17 +16473,17 @@ function stringifyRegExpWithFlags4(regex, refs) {
   }
   return pattern;
 }
-function parseRecordDef4(def, refs) {
+function parseRecordDef5(def, refs) {
   var _a26, _b8, _c, _d, _e, _f;
   const schema = {
     type: "object",
-    additionalProperties: (_a26 = parseDef4(def.valueType._def, {
+    additionalProperties: (_a26 = parseDef5(def.valueType._def, {
       ...refs,
       currentPath: [...refs.currentPath, "additionalProperties"]
     })) != null ? _a26 : refs.allowedAdditionalProperties
   };
   if (((_b8 = def.keyType) == null ? void 0 : _b8._def.typeName) === ZodFirstPartyTypeKind$1.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
-    const { type, ...keyType } = parseStringDef4(def.keyType._def, refs);
+    const { type, ...keyType } = parseStringDef5(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
@@ -15224,7 +16496,7 @@ function parseRecordDef4(def, refs) {
       }
     };
   } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind$1.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind$1.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
-    const { type, ...keyType } = parseBrandedDef4(
+    const { type, ...keyType } = parseBrandedDef5(
       def.keyType._def,
       refs
     );
@@ -15235,18 +16507,18 @@ function parseRecordDef4(def, refs) {
   }
   return schema;
 }
-function parseMapDef4(def, refs) {
+function parseMapDef5(def, refs) {
   if (refs.mapStrategy === "record") {
-    return parseRecordDef4(def, refs);
+    return parseRecordDef5(def, refs);
   }
-  const keys = parseDef4(def.keyType._def, {
+  const keys = parseDef5(def.keyType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items", "items", "0"]
-  }) || parseAnyDef4();
-  const values = parseDef4(def.valueType._def, {
+  }) || parseAnyDef5();
+  const values = parseDef5(def.valueType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items", "items", "1"]
-  }) || parseAnyDef4();
+  }) || parseAnyDef5();
   return {
     type: "array",
     maxItems: 125,
@@ -15258,7 +16530,7 @@ function parseMapDef4(def, refs) {
     }
   };
 }
-function parseNativeEnumDef4(def) {
+function parseNativeEnumDef5(def) {
   const object5 = def.values;
   const actualKeys = Object.keys(def.values).filter((key) => {
     return typeof object5[object5[key]] !== "number";
@@ -15272,28 +16544,28 @@ function parseNativeEnumDef4(def) {
     enum: actualValues
   };
 }
-function parseNeverDef4() {
-  return { not: parseAnyDef4() };
+function parseNeverDef5() {
+  return { not: parseAnyDef5() };
 }
-function parseNullDef4() {
+function parseNullDef5() {
   return {
     type: "null"
   };
 }
-var primitiveMappings4 = {
+var primitiveMappings5 = {
   ZodString: "string",
   ZodNumber: "number",
   ZodBigInt: "integer",
   ZodBoolean: "boolean",
   ZodNull: "null"
 };
-function parseUnionDef4(def, refs) {
+function parseUnionDef5(def, refs) {
   const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
   if (options.every(
-    (x) => x._def.typeName in primitiveMappings4 && (!x._def.checks || !x._def.checks.length)
+    (x) => x._def.typeName in primitiveMappings5 && (!x._def.checks || !x._def.checks.length)
   )) {
     const types = options.reduce((types2, x) => {
-      const type = primitiveMappings4[x._def.typeName];
+      const type = primitiveMappings5[x._def.typeName];
       return type && !types2.includes(type) ? [...types2, type] : types2;
     }, []);
     return {
@@ -15345,11 +16617,11 @@ function parseUnionDef4(def, refs) {
       )
     };
   }
-  return asAnyOf4(def, refs);
+  return asAnyOf5(def, refs);
 }
-var asAnyOf4 = (def, refs) => {
+var asAnyOf5 = (def, refs) => {
   const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
-    (x, i) => parseDef4(x._def, {
+    (x, i) => parseDef5(x._def, {
       ...refs,
       currentPath: [...refs.currentPath, "anyOf", `${i}`]
     })
@@ -15358,24 +16630,24 @@ var asAnyOf4 = (def, refs) => {
   );
   return anyOf.length ? { anyOf } : void 0;
 };
-function parseNullableDef4(def, refs) {
+function parseNullableDef5(def, refs) {
   if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
     def.innerType._def.typeName
   ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
     return {
       type: [
-        primitiveMappings4[def.innerType._def.typeName],
+        primitiveMappings5[def.innerType._def.typeName],
         "null"
       ]
     };
   }
-  const base = parseDef4(def.innerType._def, {
+  const base = parseDef5(def.innerType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "anyOf", "0"]
   });
   return base && { anyOf: [base, { type: "null" }] };
 }
-function parseNumberDef4(def) {
+function parseNumberDef5(def) {
   const res = {
     type: "number"
   };
@@ -15406,7 +16678,7 @@ function parseNumberDef4(def) {
   }
   return res;
 }
-function parseObjectDef4(def, refs) {
+function parseObjectDef5(def, refs) {
   const result = {
     type: "object",
     properties: {}
@@ -15418,8 +16690,8 @@ function parseObjectDef4(def, refs) {
     if (propDef === void 0 || propDef._def === void 0) {
       continue;
     }
-    const propOptional = safeIsOptional4(propDef);
-    const parsedDef = parseDef4(propDef._def, {
+    const propOptional = safeIsOptional5(propDef);
+    const parsedDef = parseDef5(propDef._def, {
       ...refs,
       currentPath: [...refs.currentPath, "properties", propName],
       propertyPath: [...refs.currentPath, "properties", propName]
@@ -15435,15 +16707,15 @@ function parseObjectDef4(def, refs) {
   if (required.length) {
     result.required = required;
   }
-  const additionalProperties = decideAdditionalProperties4(def, refs);
+  const additionalProperties = decideAdditionalProperties5(def, refs);
   if (additionalProperties !== void 0) {
     result.additionalProperties = additionalProperties;
   }
   return result;
 }
-function decideAdditionalProperties4(def, refs) {
+function decideAdditionalProperties5(def, refs) {
   if (def.catchall._def.typeName !== "ZodNever") {
-    return parseDef4(def.catchall._def, {
+    return parseDef5(def.catchall._def, {
       ...refs,
       currentPath: [...refs.currentPath, "additionalProperties"]
     });
@@ -15457,35 +16729,35 @@ function decideAdditionalProperties4(def, refs) {
       return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
   }
 }
-function safeIsOptional4(schema) {
+function safeIsOptional5(schema) {
   try {
     return schema.isOptional();
   } catch (e2) {
     return true;
   }
 }
-var parseOptionalDef4 = (def, refs) => {
+var parseOptionalDef5 = (def, refs) => {
   var _a26;
   if (refs.currentPath.toString() === ((_a26 = refs.propertyPath) == null ? void 0 : _a26.toString())) {
-    return parseDef4(def.innerType._def, refs);
+    return parseDef5(def.innerType._def, refs);
   }
-  const innerSchema = parseDef4(def.innerType._def, {
+  const innerSchema = parseDef5(def.innerType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "anyOf", "1"]
   });
-  return innerSchema ? { anyOf: [{ not: parseAnyDef4() }, innerSchema] } : parseAnyDef4();
+  return innerSchema ? { anyOf: [{ not: parseAnyDef5() }, innerSchema] } : parseAnyDef5();
 };
-var parsePipelineDef4 = (def, refs) => {
+var parsePipelineDef5 = (def, refs) => {
   if (refs.pipeStrategy === "input") {
-    return parseDef4(def.in._def, refs);
+    return parseDef5(def.in._def, refs);
   } else if (refs.pipeStrategy === "output") {
-    return parseDef4(def.out._def, refs);
+    return parseDef5(def.out._def, refs);
   }
-  const a = parseDef4(def.in._def, {
+  const a = parseDef5(def.in._def, {
     ...refs,
     currentPath: [...refs.currentPath, "allOf", "0"]
   });
-  const b = parseDef4(def.out._def, {
+  const b = parseDef5(def.out._def, {
     ...refs,
     currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
   });
@@ -15493,11 +16765,11 @@ var parsePipelineDef4 = (def, refs) => {
     allOf: [a, b].filter((x) => x !== void 0)
   };
 };
-function parsePromiseDef4(def, refs) {
-  return parseDef4(def.type._def, refs);
+function parsePromiseDef5(def, refs) {
+  return parseDef5(def.type._def, refs);
 }
-function parseSetDef4(def, refs) {
-  const items = parseDef4(def.valueType._def, {
+function parseSetDef5(def, refs) {
+  const items = parseDef5(def.valueType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items"]
   });
@@ -15514,13 +16786,13 @@ function parseSetDef4(def, refs) {
   }
   return schema;
 }
-function parseTupleDef4(def, refs) {
+function parseTupleDef5(def, refs) {
   if (def.rest) {
     return {
       type: "array",
       minItems: def.items.length,
       items: def.items.map(
-        (x, i) => parseDef4(x._def, {
+        (x, i) => parseDef5(x._def, {
           ...refs,
           currentPath: [...refs.currentPath, "items", `${i}`]
         })
@@ -15528,7 +16800,7 @@ function parseTupleDef4(def, refs) {
         (acc, x) => x === void 0 ? acc : [...acc, x],
         []
       ),
-      additionalItems: parseDef4(def.rest._def, {
+      additionalItems: parseDef5(def.rest._def, {
         ...refs,
         currentPath: [...refs.currentPath, "additionalItems"]
       })
@@ -15539,7 +16811,7 @@ function parseTupleDef4(def, refs) {
       minItems: def.items.length,
       maxItems: def.items.length,
       items: def.items.map(
-        (x, i) => parseDef4(x._def, {
+        (x, i) => parseDef5(x._def, {
           ...refs,
           currentPath: [...refs.currentPath, "items", `${i}`]
         })
@@ -15550,83 +16822,83 @@ function parseTupleDef4(def, refs) {
     };
   }
 }
-function parseUndefinedDef4() {
+function parseUndefinedDef5() {
   return {
-    not: parseAnyDef4()
+    not: parseAnyDef5()
   };
 }
-function parseUnknownDef4() {
-  return parseAnyDef4();
+function parseUnknownDef5() {
+  return parseAnyDef5();
 }
-var parseReadonlyDef4 = (def, refs) => {
-  return parseDef4(def.innerType._def, refs);
+var parseReadonlyDef5 = (def, refs) => {
+  return parseDef5(def.innerType._def, refs);
 };
-var selectParser4 = (def, typeName, refs) => {
+var selectParser5 = (def, typeName, refs) => {
   switch (typeName) {
     case ZodFirstPartyTypeKind$1.ZodString:
-      return parseStringDef4(def, refs);
+      return parseStringDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodNumber:
-      return parseNumberDef4(def);
+      return parseNumberDef5(def);
     case ZodFirstPartyTypeKind$1.ZodObject:
-      return parseObjectDef4(def, refs);
+      return parseObjectDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodBigInt:
-      return parseBigintDef4(def);
+      return parseBigintDef5(def);
     case ZodFirstPartyTypeKind$1.ZodBoolean:
-      return parseBooleanDef4();
+      return parseBooleanDef5();
     case ZodFirstPartyTypeKind$1.ZodDate:
-      return parseDateDef4(def, refs);
+      return parseDateDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodUndefined:
-      return parseUndefinedDef4();
+      return parseUndefinedDef5();
     case ZodFirstPartyTypeKind$1.ZodNull:
-      return parseNullDef4();
+      return parseNullDef5();
     case ZodFirstPartyTypeKind$1.ZodArray:
-      return parseArrayDef4(def, refs);
+      return parseArrayDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodUnion:
     case ZodFirstPartyTypeKind$1.ZodDiscriminatedUnion:
-      return parseUnionDef4(def, refs);
+      return parseUnionDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodIntersection:
-      return parseIntersectionDef4(def, refs);
+      return parseIntersectionDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodTuple:
-      return parseTupleDef4(def, refs);
+      return parseTupleDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodRecord:
-      return parseRecordDef4(def, refs);
+      return parseRecordDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodLiteral:
-      return parseLiteralDef4(def);
+      return parseLiteralDef5(def);
     case ZodFirstPartyTypeKind$1.ZodEnum:
-      return parseEnumDef4(def);
+      return parseEnumDef5(def);
     case ZodFirstPartyTypeKind$1.ZodNativeEnum:
-      return parseNativeEnumDef4(def);
+      return parseNativeEnumDef5(def);
     case ZodFirstPartyTypeKind$1.ZodNullable:
-      return parseNullableDef4(def, refs);
+      return parseNullableDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodOptional:
-      return parseOptionalDef4(def, refs);
+      return parseOptionalDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodMap:
-      return parseMapDef4(def, refs);
+      return parseMapDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodSet:
-      return parseSetDef4(def, refs);
+      return parseSetDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodLazy:
       return () => def.getter()._def;
     case ZodFirstPartyTypeKind$1.ZodPromise:
-      return parsePromiseDef4(def, refs);
+      return parsePromiseDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodNaN:
     case ZodFirstPartyTypeKind$1.ZodNever:
-      return parseNeverDef4();
+      return parseNeverDef5();
     case ZodFirstPartyTypeKind$1.ZodEffects:
-      return parseEffectsDef4(def, refs);
+      return parseEffectsDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodAny:
-      return parseAnyDef4();
+      return parseAnyDef5();
     case ZodFirstPartyTypeKind$1.ZodUnknown:
-      return parseUnknownDef4();
+      return parseUnknownDef5();
     case ZodFirstPartyTypeKind$1.ZodDefault:
-      return parseDefaultDef4(def, refs);
+      return parseDefaultDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodBranded:
-      return parseBrandedDef4(def, refs);
+      return parseBrandedDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodReadonly:
-      return parseReadonlyDef4(def, refs);
+      return parseReadonlyDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodCatch:
-      return parseCatchDef4(def, refs);
+      return parseCatchDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodPipeline:
-      return parsePipelineDef4(def, refs);
+      return parsePipelineDef5(def, refs);
     case ZodFirstPartyTypeKind$1.ZodFunction:
     case ZodFirstPartyTypeKind$1.ZodVoid:
     case ZodFirstPartyTypeKind$1.ZodSymbol:
@@ -15635,7 +16907,7 @@ var selectParser4 = (def, typeName, refs) => {
       return /* @__PURE__ */ ((_) => void 0)();
   }
 };
-function parseDef4(def, refs, forceResolution = false) {
+function parseDef5(def, refs, forceResolution = false) {
   var _a26;
   const seenItem = refs.seen.get(def);
   if (refs.override) {
@@ -15646,22 +16918,22 @@ function parseDef4(def, refs, forceResolution = false) {
       seenItem,
       forceResolution
     );
-    if (overrideResult !== ignoreOverride4) {
+    if (overrideResult !== ignoreOverride5) {
       return overrideResult;
     }
   }
   if (seenItem && !forceResolution) {
-    const seenSchema = get$ref4(seenItem, refs);
+    const seenSchema = get$ref5(seenItem, refs);
     if (seenSchema !== void 0) {
       return seenSchema;
     }
   }
   const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
   refs.seen.set(def, newItem);
-  const jsonSchemaOrGetter = selectParser4(def, def.typeName, refs);
-  const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef4(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  const jsonSchemaOrGetter = selectParser5(def, def.typeName, refs);
+  const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef5(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
   if (jsonSchema22) {
-    addMeta4(def, refs, jsonSchema22);
+    addMeta5(def, refs, jsonSchema22);
   }
   if (refs.postProcess) {
     const postProcessResult = refs.postProcess(jsonSchema22, def, refs);
@@ -15671,12 +16943,12 @@ function parseDef4(def, refs, forceResolution = false) {
   newItem.jsonSchema = jsonSchema22;
   return jsonSchema22;
 }
-var get$ref4 = (item, refs) => {
+var get$ref5 = (item, refs) => {
   switch (refs.$refStrategy) {
     case "root":
       return { $ref: item.path.join("/") };
     case "relative":
-      return { $ref: getRelativePath4(refs.currentPath, item.path) };
+      return { $ref: getRelativePath5(refs.currentPath, item.path) };
     case "none":
     case "seen": {
       if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
@@ -15685,20 +16957,20 @@ var get$ref4 = (item, refs) => {
             "/"
           )}! Defaulting to any`
         );
-        return parseAnyDef4();
+        return parseAnyDef5();
       }
-      return refs.$refStrategy === "seen" ? parseAnyDef4() : void 0;
+      return refs.$refStrategy === "seen" ? parseAnyDef5() : void 0;
     }
   }
 };
-var addMeta4 = (def, refs, jsonSchema22) => {
+var addMeta5 = (def, refs, jsonSchema22) => {
   if (def.description) {
     jsonSchema22.description = def.description;
   }
   return jsonSchema22;
 };
-var getRefs4 = (options) => {
-  const _options = getDefaultOptions4(options);
+var getRefs5 = (options) => {
+  const _options = getDefaultOptions5(options);
   const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
   return {
     ..._options,
@@ -15717,35 +16989,35 @@ var getRefs4 = (options) => {
     )
   };
 };
-var zodToJsonSchema4 = (schema, options) => {
+var zodToJsonSchema5 = (schema, options) => {
   var _a26;
-  const refs = getRefs4(options);
+  const refs = getRefs5(options);
   let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
     (acc, [name26, schema2]) => {
       var _a27;
       return {
         ...acc,
-        [name26]: (_a27 = parseDef4(
+        [name26]: (_a27 = parseDef5(
           schema2._def,
           {
             ...refs,
             currentPath: [...refs.basePath, refs.definitionPath, name26]
           },
           true
-        )) != null ? _a27 : parseAnyDef4()
+        )) != null ? _a27 : parseAnyDef5()
       };
     },
     {}
   ) : void 0;
   const name21 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
-  const main = (_a26 = parseDef4(
+  const main = (_a26 = parseDef5(
     schema._def,
     name21 === void 0 ? refs : {
       ...refs,
       currentPath: [...refs.basePath, refs.definitionPath, name21]
     },
     false
-  )) != null ? _a26 : parseAnyDef4();
+  )) != null ? _a26 : parseAnyDef5();
   const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
   if (title !== void 0) {
     main.title = title;
@@ -15767,7 +17039,7 @@ var zodToJsonSchema4 = (schema, options) => {
   combined.$schema = "http://json-schema.org/draft-07/schema#";
   return combined;
 };
-var zod_to_json_schema_default2 = zodToJsonSchema4;
+var zod_to_json_schema_default2 = zodToJsonSchema5;
 function zod3Schema2(zodSchema22, options) {
   var _a26;
   const useReferences = (_a26 = void 0 ) != null ? _a26 : false;
@@ -23212,5 +24484,5 @@ var OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE = createRoute({
 });
 
 export { CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE, CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE, GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE, GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE, GET_AGENT_BUILDER_ACTION_RUN_EXECUTION_RESULT_ROUTE, LIST_AGENT_BUILDER_ACTIONS_ROUTE, LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE, OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE, OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE, OBSERVE_STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE, RESUME_AGENT_BUILDER_ACTION_ROUTE, RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE, RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE, START_AGENT_BUILDER_ACTION_RUN_ROUTE, START_ASYNC_AGENT_BUILDER_ACTION_ROUTE, STREAM_AGENT_BUILDER_ACTION_ROUTE, STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE, STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE, agent_builder_exports };
-//# sourceMappingURL=chunk-MK6GBMKE.js.map
-//# sourceMappingURL=chunk-MK6GBMKE.js.map
+//# sourceMappingURL=chunk-OL6U27XK.js.map
+//# sourceMappingURL=chunk-OL6U27XK.js.map