@pyreon/mcp 0.5.0

package/lib/types/index.d.ts

@@ -0,0 +1,3392 @@
+#!/usr/bin/env node
+import { ZodOptional, z } from "zod";
+import process$1 from "node:process";
+import { detectReactPatterns, diagnoseError, migrateReactCode } from "@pyreon/compiler";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+//#region \0rolldown/runtime.js
+
+function getErrorMap() {
+  return overrideErrorMap;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v3/helpers/parseUtil.js
+
+function addIssueToContext(ctx, issueData) {
+  const overrideMap = getErrorMap();
+  const issue = makeIssue({
+    issueData,
+    data: ctx.data,
+    path: ctx.path,
+    errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, overrideMap, overrideMap === errorMap ? void 0 : errorMap].filter(x => !!x)
+  });
+  ctx.common.issues.push(issue);
+}
+function processCreateParams(params) {
+  if (!params) return {};
+  const {
+    errorMap,
+    invalid_type_error,
+    required_error,
+    description
+  } = params;
+  if (errorMap && (invalid_type_error || required_error)) throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+  if (errorMap) return {
+    errorMap,
+    description
+  };
+  const customMap = (iss, ctx) => {
+    const {
+      message
+    } = params;
+    if (iss.code === "invalid_enum_value") return {
+      message: message ?? ctx.defaultError
+    };
+    if (typeof ctx.data === "undefined") return {
+      message: message ?? required_error ?? ctx.defaultError
+    };
+    if (iss.code !== "invalid_type") return {
+      message: ctx.defaultError
+    };
+    return {
+      message: message ?? invalid_type_error ?? ctx.defaultError
+    };
+  };
+  return {
+    errorMap: customMap,
+    description
+  };
+}
+function timeRegexSource(args) {
+  let secondsRegexSource = `[0-5]\\d`;
+  if (args.precision) secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;else if (args.precision == null) secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
+  const secondsQuantifier = args.precision ? "+" : "?";
+  return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
+}
+function timeRegex(args) {
+  return new RegExp(`^${timeRegexSource(args)}$`);
+}
+function datetimeRegex(args) {
+  let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
+  const opts = [];
+  opts.push(args.local ? `Z?` : `Z`);
+  if (args.offset) opts.push(`([+-]\\d{2}:?\\d{2})`);
+  regex = `${regex}(${opts.join("|")})`;
+  return new RegExp(`^${regex}$`);
+}
+function isValidIP(ip, version) {
+  if ((version === "v4" || !version) && ipv4Regex.test(ip)) return true;
+  if ((version === "v6" || !version) && ipv6Regex.test(ip)) return true;
+  return false;
+}
+function isValidJWT$1(jwt, alg) {
+  if (!jwtRegex.test(jwt)) return false;
+  try {
+    const [header] = jwt.split(".");
+    if (!header) return false;
+    const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
+    const decoded = JSON.parse(atob(base64));
+    if (typeof decoded !== "object" || decoded === null) return false;
+    if ("typ" in decoded && decoded?.typ !== "JWT") return false;
+    if (!decoded.alg) return false;
+    if (alg && decoded.alg !== alg) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidCidr(ip, version) {
+  if ((version === "v4" || !version) && ipv4CidrRegex.test(ip)) return true;
+  if ((version === "v6" || !version) && ipv6CidrRegex.test(ip)) return true;
+  return false;
+}
+function floatSafeRemainder$1(val, step) {
+  const valDecCount = (val.toString().split(".")[1] || "").length;
+  const stepDecCount = (step.toString().split(".")[1] || "").length;
+  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+  return Number.parseInt(val.toFixed(decCount).replace(".", "")) % Number.parseInt(step.toFixed(decCount).replace(".", "")) / 10 ** decCount;
+}
+function deepPartialify(schema) {
+  if (schema instanceof ZodObject$1) {
+    const newShape = {};
+    for (const key in schema.shape) {
+      const fieldSchema = schema.shape[key];
+      newShape[key] = ZodOptional$2.create(deepPartialify(fieldSchema));
+    }
+    return new ZodObject$1({
+      ...schema._def,
+      shape: () => newShape
+    });
+  } else if (schema instanceof ZodArray$1) return new ZodArray$1({
+    ...schema._def,
+    type: deepPartialify(schema.element)
+  });else if (schema instanceof ZodOptional$2) return ZodOptional$2.create(deepPartialify(schema.unwrap()));else if (schema instanceof ZodNullable$1) return ZodNullable$1.create(deepPartialify(schema.unwrap()));else if (schema instanceof ZodTuple) return ZodTuple.create(schema.items.map(item => deepPartialify(item)));else return schema;
+}
+function mergeValues$1(a, b) {
+  const aType = getParsedType(a);
+  const bType = getParsedType(b);
+  if (a === b) return {
+    valid: true,
+    data: a
+  };else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
+    const bKeys = util.objectKeys(b);
+    const sharedKeys = util.objectKeys(a).filter(key => bKeys.indexOf(key) !== -1);
+    const newObj = {
+      ...a,
+      ...b
+    };
+    for (const key of sharedKeys) {
+      const sharedValue = mergeValues$1(a[key], b[key]);
+      if (!sharedValue.valid) return {
+        valid: false
+      };
+      newObj[key] = sharedValue.data;
+    }
+    return {
+      valid: true,
+      data: newObj
+    };
+  } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
+    if (a.length !== b.length) return {
+      valid: false
+    };
+    const newArray = [];
+    for (let index = 0; index < a.length; index++) {
+      const itemA = a[index];
+      const itemB = b[index];
+      const sharedValue = mergeValues$1(itemA, itemB);
+      if (!sharedValue.valid) return {
+        valid: false
+      };
+      newArray.push(sharedValue.data);
+    }
+    return {
+      valid: true,
+      data: newArray
+    };
+  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) return {
+    valid: true,
+    data: a
+  };else return {
+    valid: false
+  };
+}
+function createZodEnum(values, params) {
+  return new ZodEnum$1({
+    values,
+    typeName: ZodFirstPartyTypeKind.ZodEnum,
+    ...processCreateParams(params)
+  });
+}
+function $constructor(name, initializer, params) {
+  function init(inst, def) {
+    if (!inst._zod) Object.defineProperty(inst, "_zod", {
+      value: {
+        def,
+        constr: _,
+        traits: /* @__PURE__ */new Set()
+      },
+      enumerable: false
+    });
+    if (inst._zod.traits.has(name)) return;
+    inst._zod.traits.add(name);
+    initializer(inst, def);
+    const proto = _.prototype;
+    const keys = Object.keys(proto);
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      if (!(k in inst)) inst[k] = proto[k].bind(inst);
+    }
+  }
+  const Parent = params?.Parent ?? Object;
+  class Definition extends Parent {}
+  Object.defineProperty(Definition, "name", {
+    value: name
+  });
+  function _(def) {
+    var _a;
+    const inst = params?.Parent ? new Definition() : this;
+    init(inst, def);
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    for (const fn of inst._zod.deferred) fn();
+    return inst;
+  }
+  Object.defineProperty(_, "init", {
+    value: init
+  });
+  Object.defineProperty(_, Symbol.hasInstance, {
+    value: inst => {
+      if (params?.Parent && inst instanceof params.Parent) return true;
+      return inst?._zod?.traits?.has(name);
+    }
+  });
+  Object.defineProperty(_, "name", {
+    value: name
+  });
+  return _;
+}
+function config(newConfig) {
+  if (newConfig) Object.assign(globalConfig, newConfig);
+  return globalConfig;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/util.js
+function getEnumValues(entries) {
+  const numericValues = Object.values(entries).filter(v => typeof v === "number");
+  return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+}
+function jsonStringifyReplacer(_, value) {
+  if (typeof value === "bigint") return value.toString();
+  return value;
+}
+function cached(getter) {
+  return {
+    get value() {
+      {
+        const value = getter();
+        Object.defineProperty(this, "value", {
+          value
+        });
+        return value;
+      }
+      throw new Error("cached value already set");
+    }
+  };
+}
+function nullish(input) {
+  return input === null || input === void 0;
+}
+function cleanRegex(source) {
+  const start = source.startsWith("^") ? 1 : 0;
+  const end = source.endsWith("$") ? source.length - 1 : source.length;
+  return source.slice(start, end);
+}
+function floatSafeRemainder(val, step) {
+  const valDecCount = (val.toString().split(".")[1] || "").length;
+  const stepString = step.toString();
+  let stepDecCount = (stepString.split(".")[1] || "").length;
+  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
+    const match = stepString.match(/\d?e-(\d?)/);
+    if (match?.[1]) stepDecCount = Number.parseInt(match[1]);
+  }
+  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+  return Number.parseInt(val.toFixed(decCount).replace(".", "")) % Number.parseInt(step.toFixed(decCount).replace(".", "")) / 10 ** decCount;
+}
+function defineLazy(object, key, getter) {
+  let value = void 0;
+  Object.defineProperty(object, key, {
+    get() {
+      if (value === EVALUATING) return;
+      if (value === void 0) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
+    },
+    set(v) {
+      Object.defineProperty(object, key, {
+        value: v
+      });
+    },
+    configurable: true
+  });
+}
+function assignProp(target, prop, value) {
+  Object.defineProperty(target, prop, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function mergeDefs(...defs) {
+  const mergedDescriptors = {};
+  for (const def of defs) {
+    const descriptors = Object.getOwnPropertyDescriptors(def);
+    Object.assign(mergedDescriptors, descriptors);
+  }
+  return Object.defineProperties({}, mergedDescriptors);
+}
+function esc(str) {
+  return JSON.stringify(str);
+}
+function slugify(input) {
+  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+function isPlainObject$1(o) {
+  if (isObject(o) === false) return false;
+  const ctor = o.constructor;
+  if (ctor === void 0) return true;
+  if (typeof ctor !== "function") return true;
+  const prot = ctor.prototype;
+  if (isObject(prot) === false) return false;
+  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
+  return true;
+}
+function shallowClone(o) {
+  if (isPlainObject$1(o)) return {
+    ...o
+  };
+  if (Array.isArray(o)) return [...o];
+  return o;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(inst, def, params) {
+  const cl = new inst._zod.constr(def ?? inst._zod.def);
+  if (!def || params?.parent) cl._zod.parent = inst;
+  return cl;
+}
+function normalizeParams(_params) {
+  const params = _params;
+  if (!params) return {};
+  if (typeof params === "string") return {
+    error: () => params
+  };
+  if (params?.message !== void 0) {
+    if (params?.error !== void 0) throw new Error("Cannot specify both `message` and `error` params");
+    params.error = params.message;
+  }
+  delete params.message;
+  if (typeof params.error === "string") return {
+    ...params,
+    error: () => params.error
+  };
+  return params;
+}
+function optionalKeys(shape) {
+  return Object.keys(shape).filter(k => {
+    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+  });
+}
+function pick(schema, mask) {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  if (checks && checks.length > 0) throw new Error(".pick() cannot be used on object schemas containing refinements");
+  return clone(schema, mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape = {};
+      for (const key in mask) {
+        if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+        if (!mask[key]) continue;
+        newShape[key] = currDef.shape[key];
+      }
+      assignProp(this, "shape", newShape);
+      return newShape;
+    },
+    checks: []
+  }));
+}
+function omit(schema, mask) {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  if (checks && checks.length > 0) throw new Error(".omit() cannot be used on object schemas containing refinements");
+  return clone(schema, mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape = {
+        ...schema._zod.def.shape
+      };
+      for (const key in mask) {
+        if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+        if (!mask[key]) continue;
+        delete newShape[key];
+      }
+      assignProp(this, "shape", newShape);
+      return newShape;
+    },
+    checks: []
+  }));
+}
+function extend(schema, shape) {
+  if (!isPlainObject$1(shape)) throw new Error("Invalid input to extend: expected a plain object");
+  const checks = schema._zod.def.checks;
+  if (checks && checks.length > 0) {
+    const existingShape = schema._zod.def.shape;
+    for (const key in shape) if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+  }
+  return clone(schema, mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = {
+        ...schema._zod.def.shape,
+        ...shape
+      };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    }
+  }));
+}
+function safeExtend(schema, shape) {
+  if (!isPlainObject$1(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
+  return clone(schema, mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = {
+        ...schema._zod.def.shape,
+        ...shape
+      };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    }
+  }));
+}
+function merge(a, b) {
+  return clone(a, mergeDefs(a._zod.def, {
+    get shape() {
+      const _shape = {
+        ...a._zod.def.shape,
+        ...b._zod.def.shape
+      };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    },
+    get catchall() {
+      return b._zod.def.catchall;
+    },
+    checks: []
+  }));
+}
+function partial(Class, schema, mask) {
+  const checks = schema._zod.def.checks;
+  if (checks && checks.length > 0) throw new Error(".partial() cannot be used on object schemas containing refinements");
+  return clone(schema, mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape = {
+        ...oldShape
+      };
+      if (mask) for (const key in mask) {
+        if (!(key in oldShape)) throw new Error(`Unrecognized key: "${key}"`);
+        if (!mask[key]) continue;
+        shape[key] = Class ? new Class({
+          type: "optional",
+          innerType: oldShape[key]
+        }) : oldShape[key];
+      } else for (const key in oldShape) shape[key] = Class ? new Class({
+        type: "optional",
+        innerType: oldShape[key]
+      }) : oldShape[key];
+      assignProp(this, "shape", shape);
+      return shape;
+    },
+    checks: []
+  }));
+}
+function required(Class, schema, mask) {
+  return clone(schema, mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape = {
+        ...oldShape
+      };
+      if (mask) for (const key in mask) {
+        if (!(key in shape)) throw new Error(`Unrecognized key: "${key}"`);
+        if (!mask[key]) continue;
+        shape[key] = new Class({
+          type: "nonoptional",
+          innerType: oldShape[key]
+        });
+      } else for (const key in oldShape) shape[key] = new Class({
+        type: "nonoptional",
+        innerType: oldShape[key]
+      });
+      assignProp(this, "shape", shape);
+      return shape;
+    }
+  }));
+}
+function aborted(x, startIndex = 0) {
+  if (x.aborted === true) return true;
+  for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
+  return false;
+}
+function prefixIssues(path, issues) {
+  return issues.map(iss => {
+    var _a;
+    (_a = iss).path ?? (_a.path = []);
+    iss.path.unshift(path);
+    return iss;
+  });
+}
+function unwrapMessage(message) {
+  return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config) {
+  const full = {
+    ...iss,
+    path: iss.path ?? []
+  };
+  if (!iss.message) full.message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
+  delete full.inst;
+  delete full.continue;
+  if (!ctx?.reportInput) delete full.input;
+  return full;
+}
+function getLengthableOrigin(input) {
+  if (Array.isArray(input)) return "array";
+  if (typeof input === "string") return "string";
+  return "unknown";
+}
+function issue(...args) {
+  const [iss, input, inst] = args;
+  if (typeof iss === "string") return {
+    message: iss,
+    code: "custom",
+    input,
+    inst
+  };
+  return {
+    ...iss
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/errors.js
+
+function flattenError(error, mapper = issue => issue.message) {
+  const fieldErrors = {};
+  const formErrors = [];
+  for (const sub of error.issues) if (sub.path.length > 0) {
+    fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+    fieldErrors[sub.path[0]].push(mapper(sub));
+  } else formErrors.push(mapper(sub));
+  return {
+    formErrors,
+    fieldErrors
+  };
+}
+function formatError(error, mapper = issue => issue.message) {
+  const fieldErrors = {
+    _errors: []
+  };
+  const processError = error => {
+    for (const issue of error.issues) if (issue.code === "invalid_union" && issue.errors.length) issue.errors.map(issues => processError({
+      issues
+    }));else if (issue.code === "invalid_key") processError({
+      issues: issue.issues
+    });else if (issue.code === "invalid_element") processError({
+      issues: issue.issues
+    });else if (issue.path.length === 0) fieldErrors._errors.push(mapper(issue));else {
+      let curr = fieldErrors;
+      let i = 0;
+      while (i < issue.path.length) {
+        const el = issue.path[i];
+        if (!(i === issue.path.length - 1)) curr[el] = curr[el] || {
+          _errors: []
+        };else {
+          curr[el] = curr[el] || {
+            _errors: []
+          };
+          curr[el]._errors.push(mapper(issue));
+        }
+        curr = curr[el];
+        i++;
+      }
+    }
+  };
+  processError(error);
+  return fieldErrors;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/parse.js
+
+function emoji() {
+  return new RegExp(_emoji$1, "u");
+}
+function timeSource(args) {
+  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
+  return typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+}
+function time$1(args) {
+  return new RegExp(`^${timeSource(args)}$`);
+}
+function datetime$1(args) {
+  const time = timeSource({
+    precision: args.precision
+  });
+  const opts = ["Z"];
+  if (args.local) opts.push("");
+  if (args.offset) opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
+  const timeRegex = `${time}(?:${opts.join("|")})`;
+  return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
+}
+function isValidBase64(data) {
+  if (data === "") return true;
+  if (data.length % 4 !== 0) return false;
+  try {
+    atob(data);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidBase64URL(data) {
+  if (!base64url.test(data)) return false;
+  const base64 = data.replace(/[-_]/g, c => c === "-" ? "+" : "/");
+  return isValidBase64(base64.padEnd(Math.ceil(base64.length / 4) * 4, "="));
+}
+function isValidJWT(token, algorithm = null) {
+  try {
+    const tokensParts = token.split(".");
+    if (tokensParts.length !== 3) return false;
+    const [header] = tokensParts;
+    if (!header) return false;
+    const parsedHeader = JSON.parse(atob(header));
+    if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
+    if (!parsedHeader.alg) return false;
+    if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function handleArrayResult(result, final, index) {
+  if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
+  final.value[index] = result.value;
+}
+function handlePropertyResult(result, final, key, input, isOptionalOut) {
+  if (result.issues.length) {
+    if (isOptionalOut && !(key in input)) return;
+    final.issues.push(...prefixIssues(key, result.issues));
+  }
+  if (result.value === void 0) {
+    if (key in input) final.value[key] = void 0;
+  } else final.value[key] = result.value;
+}
+function normalizeDef(def) {
+  const keys = Object.keys(def.shape);
+  for (const k of keys) if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+  const okeys = optionalKeys(def.shape);
+  return {
+    ...def,
+    keys,
+    keySet: new Set(keys),
+    numKeys: keys.length,
+    optionalKeys: new Set(okeys)
+  };
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+  const unrecognized = [];
+  const keySet = def.keySet;
+  const _catchall = def.catchall._zod;
+  const t = _catchall.def.type;
+  const isOptionalOut = _catchall.optout === "optional";
+  for (const key in input) {
+    if (keySet.has(key)) continue;
+    if (t === "never") {
+      unrecognized.push(key);
+      continue;
+    }
+    const r = _catchall.run({
+      value: input[key],
+      issues: []
+    }, ctx);
+    if (r instanceof Promise) proms.push(r.then(r => handlePropertyResult(r, payload, key, input, isOptionalOut)));else handlePropertyResult(r, payload, key, input, isOptionalOut);
+  }
+  if (unrecognized.length) payload.issues.push({
+    code: "unrecognized_keys",
+    keys: unrecognized,
+    input,
+    inst
+  });
+  if (!proms.length) return payload;
+  return Promise.all(proms).then(() => {
+    return payload;
+  });
+}
+function handleUnionResults(results, final, inst, ctx) {
+  for (const result of results) if (result.issues.length === 0) {
+    final.value = result.value;
+    return final;
+  }
+  const nonaborted = results.filter(r => !aborted(r));
+  if (nonaborted.length === 1) {
+    final.value = nonaborted[0].value;
+    return nonaborted[0];
+  }
+  final.issues.push({
+    code: "invalid_union",
+    input: final.value,
+    inst,
+    errors: results.map(result => result.issues.map(iss => finalizeIssue(iss, ctx, config())))
+  });
+  return final;
+}
+function mergeValues(a, b) {
+  if (a === b) return {
+    valid: true,
+    data: a
+  };
+  if (a instanceof Date && b instanceof Date && +a === +b) return {
+    valid: true,
+    data: a
+  };
+  if (isPlainObject$1(a) && isPlainObject$1(b)) {
+    const bKeys = Object.keys(b);
+    const sharedKeys = Object.keys(a).filter(key => bKeys.indexOf(key) !== -1);
+    const newObj = {
+      ...a,
+      ...b
+    };
+    for (const key of sharedKeys) {
+      const sharedValue = mergeValues(a[key], b[key]);
+      if (!sharedValue.valid) return {
+        valid: false,
+        mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
+      };
+      newObj[key] = sharedValue.data;
+    }
+    return {
+      valid: true,
+      data: newObj
+    };
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return {
+      valid: false,
+      mergeErrorPath: []
+    };
+    const newArray = [];
+    for (let index = 0; index < a.length; index++) {
+      const itemA = a[index];
+      const itemB = b[index];
+      const sharedValue = mergeValues(itemA, itemB);
+      if (!sharedValue.valid) return {
+        valid: false,
+        mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
+      };
+      newArray.push(sharedValue.data);
+    }
+    return {
+      valid: true,
+      data: newArray
+    };
+  }
+  return {
+    valid: false,
+    mergeErrorPath: []
+  };
+}
+function handleIntersectionResults(result, left, right) {
+  const unrecKeys = /* @__PURE__ */new Map();
+  let unrecIssue;
+  for (const iss of left.issues) if (iss.code === "unrecognized_keys") {
+    unrecIssue ?? (unrecIssue = iss);
+    for (const k of iss.keys) {
+      if (!unrecKeys.has(k)) unrecKeys.set(k, {});
+      unrecKeys.get(k).l = true;
+    }
+  } else result.issues.push(iss);
+  for (const iss of right.issues) if (iss.code === "unrecognized_keys") for (const k of iss.keys) {
+    if (!unrecKeys.has(k)) unrecKeys.set(k, {});
+    unrecKeys.get(k).r = true;
+  } else result.issues.push(iss);
+  const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
+  if (bothKeys.length && unrecIssue) result.issues.push({
+    ...unrecIssue,
+    keys: bothKeys
+  });
+  if (aborted(result)) return result;
+  const merged = mergeValues(left.value, right.value);
+  if (!merged.valid) throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
+  result.value = merged.data;
+  return result;
+}
+function handleOptionalResult(result, input) {
+  if (result.issues.length && input === void 0) return {
+    issues: [],
+    value: void 0
+  };
+  return result;
+}
+function handleDefaultResult(payload, def) {
+  if (payload.value === void 0) payload.value = def.defaultValue;
+  return payload;
+}
+function handleNonOptionalResult(payload, inst) {
+  if (!payload.issues.length && payload.value === void 0) payload.issues.push({
+    code: "invalid_type",
+    expected: "nonoptional",
+    input: payload.value,
+    inst
+  });
+  return payload;
+}
+function handlePipeResult(left, next, ctx) {
+  if (left.issues.length) {
+    left.aborted = true;
+    return left;
+  }
+  return next._zod.run({
+    value: left.value,
+    issues: left.issues
+  }, ctx);
+}
+function handleReadonlyResult(payload) {
+  payload.value = Object.freeze(payload.value);
+  return payload;
+}
+function handleRefineResult(result, payload, input, inst) {
+  if (!result) {
+    const _iss = {
+      code: "custom",
+      input,
+      inst,
+      path: [...(inst._zod.def.path ?? [])],
+      continue: !inst._zod.def.abort
+    };
+    if (inst._zod.def.params) _iss.params = inst._zod.def.params;
+    payload.issues.push(issue(_iss));
+  }
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/registries.js
+
+function registry() {
+  return new $ZodRegistry();
+}
+//#endregion
+//#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/api.js
+/* @__NO_SIDE_EFFECTS__ */
+function _string(Class, params) {
+  return new Class({
+    type: "string",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _email(Class, params) {
+  return new Class({
+    type: "string",
+    format: "email",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _guid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "guid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv4(Class, params) {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v4",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv6(Class, params) {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v6",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv7(Class, params) {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v7",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _url(Class, params) {
+  return new Class({
+    type: "string",
+    format: "url",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _emoji(Class, params) {
+  return new Class({
+    type: "string",
+    format: "emoji",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _nanoid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "nanoid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cuid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "cuid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cuid2(Class, params) {
+  return new Class({
+    type: "string",
+    format: "cuid2",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ulid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "ulid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _xid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "xid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ksuid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "ksuid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ipv4(Class, params) {
+  return new Class({
+    type: "string",
+    format: "ipv4",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ipv6(Class, params) {
+  return new Class({
+    type: "string",
+    format: "ipv6",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cidrv4(Class, params) {
+  return new Class({
+    type: "string",
+    format: "cidrv4",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cidrv6(Class, params) {
+  return new Class({
+    type: "string",
+    format: "cidrv6",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _base64(Class, params) {
+  return new Class({
+    type: "string",
+    format: "base64",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _base64url(Class, params) {
+  return new Class({
+    type: "string",
+    format: "base64url",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _e164(Class, params) {
+  return new Class({
+    type: "string",
+    format: "e164",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _jwt(Class, params) {
+  return new Class({
+    type: "string",
+    format: "jwt",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDateTime(Class, params) {
+  return new Class({
+    type: "string",
+    format: "datetime",
+    check: "string_format",
+    offset: false,
+    local: false,
+    precision: null,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDate(Class, params) {
+  return new Class({
+    type: "string",
+    format: "date",
+    check: "string_format",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoTime(Class, params) {
+  return new Class({
+    type: "string",
+    format: "time",
+    check: "string_format",
+    precision: null,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDuration(Class, params) {
+  return new Class({
+    type: "string",
+    format: "duration",
+    check: "string_format",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _number(Class, params) {
+  return new Class({
+    type: "number",
+    checks: [],
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _int(Class, params) {
+  return new Class({
+    type: "number",
+    check: "number_format",
+    abort: false,
+    format: "safeint",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _boolean(Class, params) {
+  return new Class({
+    type: "boolean",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _null$1(Class, params) {
+  return new Class({
+    type: "null",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _unknown(Class) {
+  return new Class({
+    type: "unknown"
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _never(Class, params) {
+  return new Class({
+    type: "never",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _lt(value, params) {
+  return new $ZodCheckLessThan({
+    check: "less_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: false
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _lte(value, params) {
+  return new $ZodCheckLessThan({
+    check: "less_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: true
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _gt(value, params) {
+  return new $ZodCheckGreaterThan({
+    check: "greater_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: false
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _gte(value, params) {
+  return new $ZodCheckGreaterThan({
+    check: "greater_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: true
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _multipleOf(value, params) {
+  return new $ZodCheckMultipleOf({
+    check: "multiple_of",
+    ...normalizeParams(params),
+    value
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _maxLength(maximum, params) {
+  return new $ZodCheckMaxLength({
+    check: "max_length",
+    ...normalizeParams(params),
+    maximum
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _minLength(minimum, params) {
+  return new $ZodCheckMinLength({
+    check: "min_length",
+    ...normalizeParams(params),
+    minimum
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _length(length, params) {
+  return new $ZodCheckLengthEquals({
+    check: "length_equals",
+    ...normalizeParams(params),
+    length
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _regex(pattern, params) {
+  return new $ZodCheckRegex({
+    check: "string_format",
+    format: "regex",
+    ...normalizeParams(params),
+    pattern
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _lowercase(params) {
+  return new $ZodCheckLowerCase({
+    check: "string_format",
+    format: "lowercase",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uppercase(params) {
+  return new $ZodCheckUpperCase({
+    check: "string_format",
+    format: "uppercase",
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _includes(includes, params) {
+  return new $ZodCheckIncludes({
+    check: "string_format",
+    format: "includes",
+    ...normalizeParams(params),
+    includes
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _startsWith(prefix, params) {
+  return new $ZodCheckStartsWith({
+    check: "string_format",
+    format: "starts_with",
+    ...normalizeParams(params),
+    prefix
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _endsWith(suffix, params) {
+  return new $ZodCheckEndsWith({
+    check: "string_format",
+    format: "ends_with",
+    ...normalizeParams(params),
+    suffix
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _overwrite(tx) {
+  return new $ZodCheckOverwrite({
+    check: "overwrite",
+    tx
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _normalize(form) {
+  return /* @__PURE__ */_overwrite(input => input.normalize(form));
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _trim() {
+  return /* @__PURE__ */_overwrite(input => input.trim());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _toLowerCase() {
+  return /* @__PURE__ */_overwrite(input => input.toLowerCase());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _toUpperCase() {
+  return /* @__PURE__ */_overwrite(input => input.toUpperCase());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _slugify() {
+  return /* @__PURE__ */_overwrite(input => slugify(input));
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _array(Class, element, params) {
+  return new Class({
+    type: "array",
+    element,
+    ...normalizeParams(params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _custom(Class, fn, _params) {
+  const norm = normalizeParams(_params);
+  norm.abort ?? (norm.abort = true);
+  return new Class({
+    type: "custom",
+    check: "custom",
+    fn,
+    ...norm
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _refine(Class, fn, _params) {
+  return new Class({
+    type: "custom",
+    check: "custom",
+    fn,
+    ...normalizeParams(_params)
+  });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _superRefine(fn) {
+  const ch = /* @__PURE__ */_check(payload => {
+    payload.addIssue = issue$2 => {
+      if (typeof issue$2 === "string") payload.issues.push(issue(issue$2, payload.value, ch._zod.def));else {
+        const _issue = issue$2;
+        if (_issue.fatal) _issue.continue = false;
+        _issue.code ?? (_issue.code = "custom");
+        _issue.input ?? (_issue.input = payload.value);
+        _issue.inst ?? (_issue.inst = ch);
+        _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
+        payload.issues.push(issue(_issue));
+      }
+    };
+    return fn(payload.value, payload);
+  });
+  return ch;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _check(fn, params) {
+  const ch = new $ZodCheck({
+    check: "custom",
+    ...normalizeParams(params)
+  });
+  ch._zod.check = fn;
+  return ch;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function describe$2(description) {
+  const ch = new $ZodCheck({
+    check: "describe"
+  });
+  ch._zod.onattach = [inst => {
+    const existing = globalRegistry.get(inst) ?? {};
+    globalRegistry.add(inst, {
+      ...existing,
+      description
+    });
+  }];
+  ch._zod.check = () => {};
+  return ch;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function meta$2(metadata) {
+  const ch = new $ZodCheck({
+    check: "meta"
+  });
+  ch._zod.onattach = [inst => {
+    const existing = globalRegistry.get(inst) ?? {};
+    globalRegistry.add(inst, {
+      ...existing,
+      ...metadata
+    });
+  }];
+  ch._zod.check = () => {};
+  return ch;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/to-json-schema.js
+function initializeContext(params) {
+  let target = params?.target ?? "draft-2020-12";
+  if (target === "draft-4") target = "draft-04";
+  if (target === "draft-7") target = "draft-07";
+  return {
+    processors: params.processors ?? {},
+    metadataRegistry: params?.metadata ?? globalRegistry,
+    target,
+    unrepresentable: params?.unrepresentable ?? "throw",
+    override: params?.override ?? (() => {}),
+    io: params?.io ?? "output",
+    counter: 0,
+    seen: /* @__PURE__ */new Map(),
+    cycles: params?.cycles ?? "ref",
+    reused: params?.reused ?? "inline",
+    external: params?.external ?? void 0
+  };
+}
+function process$2(schema, ctx, _params = {
+  path: [],
+  schemaPath: []
+}) {
+  var _a;
+  const def = schema._zod.def;
+  const seen = ctx.seen.get(schema);
+  if (seen) {
+    seen.count++;
+    if (_params.schemaPath.includes(schema)) seen.cycle = _params.path;
+    return seen.schema;
+  }
+  const result = {
+    schema: {},
+    count: 1,
+    cycle: void 0,
+    path: _params.path
+  };
+  ctx.seen.set(schema, result);
+  const overrideSchema = schema._zod.toJSONSchema?.();
+  if (overrideSchema) result.schema = overrideSchema;else {
+    const params = {
+      ..._params,
+      schemaPath: [..._params.schemaPath, schema],
+      path: _params.path
+    };
+    if (schema._zod.processJSONSchema) schema._zod.processJSONSchema(ctx, result.schema, params);else {
+      const _json = result.schema;
+      const processor = ctx.processors[def.type];
+      if (!processor) throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
+      processor(schema, ctx, _json, params);
+    }
+    const parent = schema._zod.parent;
+    if (parent) {
+      if (!result.ref) result.ref = parent;
+      process$2(parent, ctx, params);
+      ctx.seen.get(parent).isParent = true;
+    }
+  }
+  const meta = ctx.metadataRegistry.get(schema);
+  if (meta) Object.assign(result.schema, meta);
+  if (ctx.io === "input" && isTransforming(schema)) {
+    delete result.schema.examples;
+    delete result.schema.default;
+  }
+  if (ctx.io === "input" && result.schema._prefault) (_a = result.schema).default ?? (_a.default = result.schema._prefault);
+  delete result.schema._prefault;
+  return ctx.seen.get(schema).schema;
+}
+function extractDefs(ctx, schema) {
+  const root = ctx.seen.get(schema);
+  if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
+  const idToSchema = /* @__PURE__ */new Map();
+  for (const entry of ctx.seen.entries()) {
+    const id = ctx.metadataRegistry.get(entry[0])?.id;
+    if (id) {
+      const existing = idToSchema.get(id);
+      if (existing && existing !== entry[0]) throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
+      idToSchema.set(id, entry[0]);
+    }
+  }
+  const makeURI = entry => {
+    const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+    if (ctx.external) {
+      const externalId = ctx.external.registry.get(entry[0])?.id;
+      const uriGenerator = ctx.external.uri ?? (id => id);
+      if (externalId) return {
+        ref: uriGenerator(externalId)
+      };
+      const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
+      entry[1].defId = id;
+      return {
+        defId: id,
+        ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}`
+      };
+    }
+    if (entry[1] === root) return {
+      ref: "#"
+    };
+    const defUriPrefix = `#/${defsSegment}/`;
+    const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
+    return {
+      defId,
+      ref: defUriPrefix + defId
+    };
+  };
+  const extractToDef = entry => {
+    if (entry[1].schema.$ref) return;
+    const seen = entry[1];
+    const {
+      ref,
+      defId
+    } = makeURI(entry);
+    seen.def = {
+      ...seen.schema
+    };
+    if (defId) seen.defId = defId;
+    const schema = seen.schema;
+    for (const key in schema) delete schema[key];
+    schema.$ref = ref;
+  };
+  if (ctx.cycles === "throw") for (const entry of ctx.seen.entries()) {
+    const seen = entry[1];
+    if (seen.cycle) throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
+
+Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
+  }
+  for (const entry of ctx.seen.entries()) {
+    const seen = entry[1];
+    if (schema === entry[0]) {
+      extractToDef(entry);
+      continue;
+    }
+    if (ctx.external) {
+      const ext = ctx.external.registry.get(entry[0])?.id;
+      if (schema !== entry[0] && ext) {
+        extractToDef(entry);
+        continue;
+      }
+    }
+    if (ctx.metadataRegistry.get(entry[0])?.id) {
+      extractToDef(entry);
+      continue;
+    }
+    if (seen.cycle) {
+      extractToDef(entry);
+      continue;
+    }
+    if (seen.count > 1) {
+      if (ctx.reused === "ref") {
+        extractToDef(entry);
+        continue;
+      }
+    }
+  }
+}
+function finalize(ctx, schema) {
+  const root = ctx.seen.get(schema);
+  if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
+  const flattenRef = zodSchema => {
+    const seen = ctx.seen.get(zodSchema);
+    if (seen.ref === null) return;
+    const schema = seen.def ?? seen.schema;
+    const _cached = {
+      ...schema
+    };
+    const ref = seen.ref;
+    seen.ref = null;
+    if (ref) {
+      flattenRef(ref);
+      const refSeen = ctx.seen.get(ref);
+      const refSchema = refSeen.schema;
+      if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+        schema.allOf = schema.allOf ?? [];
+        schema.allOf.push(refSchema);
+      } else Object.assign(schema, refSchema);
+      Object.assign(schema, _cached);
+      if (zodSchema._zod.parent === ref) for (const key in schema) {
+        if (key === "$ref" || key === "allOf") continue;
+        if (!(key in _cached)) delete schema[key];
+      }
+      if (refSchema.$ref && refSeen.def) for (const key in schema) {
+        if (key === "$ref" || key === "allOf") continue;
+        if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) delete schema[key];
+      }
+    }
+    const parent = zodSchema._zod.parent;
+    if (parent && parent !== ref) {
+      flattenRef(parent);
+      const parentSeen = ctx.seen.get(parent);
+      if (parentSeen?.schema.$ref) {
+        schema.$ref = parentSeen.schema.$ref;
+        if (parentSeen.def) for (const key in schema) {
+          if (key === "$ref" || key === "allOf") continue;
+          if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) delete schema[key];
+        }
+      }
+    }
+    ctx.override({
+      zodSchema,
+      jsonSchema: schema,
+      path: seen.path ?? []
+    });
+  };
+  for (const entry of [...ctx.seen.entries()].reverse()) flattenRef(entry[0]);
+  const result = {};
+  if (ctx.target === "draft-2020-12") result.$schema = "https://json-schema.org/draft/2020-12/schema";else if (ctx.target === "draft-07") result.$schema = "http://json-schema.org/draft-07/schema#";else if (ctx.target === "draft-04") result.$schema = "http://json-schema.org/draft-04/schema#";else if (ctx.target === "openapi-3.0") {}
+  if (ctx.external?.uri) {
+    const id = ctx.external.registry.get(schema)?.id;
+    if (!id) throw new Error("Schema is missing an `id` property");
+    result.$id = ctx.external.uri(id);
+  }
+  Object.assign(result, root.def ?? root.schema);
+  const defs = ctx.external?.defs ?? {};
+  for (const entry of ctx.seen.entries()) {
+    const seen = entry[1];
+    if (seen.def && seen.defId) defs[seen.defId] = seen.def;
+  }
+  if (ctx.external) {} else if (Object.keys(defs).length > 0) if (ctx.target === "draft-2020-12") result.$defs = defs;else result.definitions = defs;
+  try {
+    const finalized = JSON.parse(JSON.stringify(result));
+    Object.defineProperty(finalized, "~standard", {
+      value: {
+        ...schema["~standard"],
+        jsonSchema: {
+          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
+        }
+      },
+      enumerable: false,
+      writable: false
+    });
+    return finalized;
+  } catch (_err) {
+    throw new Error("Error converting schema to JSON.");
+  }
+}
+function isTransforming(_schema, _ctx) {
+  const ctx = _ctx ?? {
+    seen: /* @__PURE__ */new Set()
+  };
+  if (ctx.seen.has(_schema)) return false;
+  ctx.seen.add(_schema);
+  const def = _schema._zod.def;
+  if (def.type === "transform") return true;
+  if (def.type === "array") return isTransforming(def.element, ctx);
+  if (def.type === "set") return isTransforming(def.valueType, ctx);
+  if (def.type === "lazy") return isTransforming(def.getter(), ctx);
+  if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") return isTransforming(def.innerType, ctx);
+  if (def.type === "intersection") return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+  if (def.type === "record" || def.type === "map") return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+  if (def.type === "pipe") return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+  if (def.type === "object") {
+    for (const key in def.shape) if (isTransforming(def.shape[key], ctx)) return true;
+    return false;
+  }
+  if (def.type === "union") {
+    for (const option of def.options) if (isTransforming(option, ctx)) return true;
+    return false;
+  }
+  if (def.type === "tuple") {
+    for (const item of def.items) if (isTransforming(item, ctx)) return true;
+    if (def.rest && isTransforming(def.rest, ctx)) return true;
+    return false;
+  }
+  return false;
+}
+/**
+* Creates a toJSONSchema method for a schema instance.
+* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+*/
+
+function toJSONSchema(input, params) {
+  if ("_idmap" in input) {
+    const registry = input;
+    const ctx = initializeContext({
+      ...params,
+      processors: allProcessors
+    });
+    const defs = {};
+    for (const entry of registry._idmap.entries()) {
+      const [_, schema] = entry;
+      process$2(schema, ctx);
+    }
+    const schemas = {};
+    ctx.external = {
+      registry,
+      uri: params?.uri,
+      defs
+    };
+    for (const entry of registry._idmap.entries()) {
+      const [key, schema] = entry;
+      extractDefs(ctx, schema);
+      schemas[key] = finalize(ctx, schema);
+    }
+    if (Object.keys(defs).length > 0) schemas.__shared = {
+      [ctx.target === "draft-2020-12" ? "$defs" : "definitions"]: defs
+    };
+    return {
+      schemas
+    };
+  }
+  const ctx = initializeContext({
+    ...params,
+    processors: allProcessors
+  });
+  process$2(input, ctx);
+  extractDefs(ctx, input);
+  return finalize(ctx, input);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/mini/schemas.js
+
+/* @__NO_SIDE_EFFECTS__ */
+function object$1(shape, params) {
+  return new ZodMiniObject({
+    type: "object",
+    shape: shape ?? {},
+    ...normalizeParams(params)
+  });
+}
+//#endregion
+//#region ../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
+function isZ4Schema(s) {
+  return !!s._zod;
+}
+function objectFromShape(shape) {
+  const values = Object.values(shape);
+  if (values.length === 0) return object$1({});
+  const allV4 = values.every(isZ4Schema);
+  const allV3 = values.every(s => !isZ4Schema(s));
+  if (allV4) return object$1(shape);
+  if (allV3) return objectType(shape);
+  throw new Error("Mixed Zod versions detected in object shape.");
+}
+function safeParse$1(schema, data) {
+  if (isZ4Schema(schema)) return safeParse$2(schema, data);
+  return schema.safeParse(data);
+}
+async function safeParseAsync$1(schema, data) {
+  if (isZ4Schema(schema)) return await safeParseAsync$2(schema, data);
+  return await schema.safeParseAsync(data);
+}
+function getObjectShape(schema) {
+  if (!schema) return void 0;
+  let rawShape;
+  if (isZ4Schema(schema)) rawShape = schema._zod?.def?.shape;else rawShape = schema.shape;
+  if (!rawShape) return void 0;
+  if (typeof rawShape === "function") try {
+    return rawShape();
+  } catch {
+    return;
+  }
+  return rawShape;
+}
+/**
+* Normalizes a schema to an object schema. Handles both:
+* - Already-constructed object schemas (v3 or v4)
+* - Raw shapes that need to be wrapped into object schemas
+*/
+function normalizeObjectSchema(schema) {
+  if (!schema) return void 0;
+  if (typeof schema === "object") {
+    const asV3 = schema;
+    const asV4 = schema;
+    if (!asV3._def && !asV4._zod) {
+      const values = Object.values(schema);
+      if (values.length > 0 && values.every(v => typeof v === "object" && v !== null && (v._def !== void 0 || v._zod !== void 0 || typeof v.parse === "function"))) return objectFromShape(schema);
+    }
+  }
+  if (isZ4Schema(schema)) {
+    const def = schema._zod?.def;
+    if (def && (def.type === "object" || def.shape !== void 0)) return schema;
+  } else if (schema.shape !== void 0) return schema;
+}
+/**
+* Safely extracts an error message from a parse result error.
+* Zod errors can have different structures, so we handle various cases.
+*/
+function getParseErrorMessage(error) {
+  if (error && typeof error === "object") {
+    if ("message" in error && typeof error.message === "string") return error.message;
+    if ("issues" in error && Array.isArray(error.issues) && error.issues.length > 0) {
+      const firstIssue = error.issues[0];
+      if (firstIssue && typeof firstIssue === "object" && "message" in firstIssue) return String(firstIssue.message);
+    }
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  }
+  return String(error);
+}
+/**
+* Gets the description from a schema, if available.
+* Works with both Zod v3 and v4.
+*
+* Both versions expose a `.description` getter that returns the description
+* from their respective internal storage (v3: _def, v4: globalRegistry).
+*/
+function getSchemaDescription(schema) {
+  return schema.description;
+}
+/**
+* Checks if a schema is optional.
+* Works with both Zod v3 and v4.
+*/
+function isSchemaOptional(schema) {
+  if (isZ4Schema(schema)) return schema._zod?.def?.type === "optional";
+  const v3Schema = schema;
+  if (typeof schema.isOptional === "function") return schema.isOptional();
+  return v3Schema._def?.typeName === "ZodOptional";
+}
+/**
+* Gets the literal value from a schema, if it's a literal schema.
+* Works with both Zod v3 and v4.
+* Returns undefined if the schema is not a literal or the value cannot be determined.
+*/
+function getLiteralValue(schema) {
+  if (isZ4Schema(schema)) {
+    const def = schema._zod?.def;
+    if (def) {
+      if (def.value !== void 0) return def.value;
+      if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
+    }
+  }
+  const def = schema._def;
+  if (def) {
+    if (def.value !== void 0) return def.value;
+    if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
+  }
+  const directValue = schema.value;
+  if (directValue !== void 0) return directValue;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/iso.js
+
+function datetime(params) {
+  return _isoDateTime(ZodISODateTime, params);
+}
+function date(params) {
+  return _isoDate(ZodISODate, params);
+}
+function time(params) {
+  return _isoTime(ZodISOTime, params);
+}
+function duration(params) {
+  return _isoDuration(ZodISODuration, params);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/errors.js
+
+function string(params) {
+  return _string(ZodString, params);
+}
+function number(params) {
+  return _number(ZodNumber, params);
+}
+function int(params) {
+  return _int(ZodNumberFormat, params);
+}
+function boolean(params) {
+  return _boolean(ZodBoolean, params);
+}
+function _null(params) {
+  return _null$1(ZodNull, params);
+}
+function unknown() {
+  return _unknown(ZodUnknown);
+}
+function never(params) {
+  return _never(ZodNever, params);
+}
+function array(element, params) {
+  return _array(ZodArray, element, params);
+}
+function object(shape, params) {
+  return new ZodObject({
+    type: "object",
+    shape: shape ?? {},
+    ...normalizeParams(params)
+  });
+}
+function looseObject(shape, params) {
+  return new ZodObject({
+    type: "object",
+    shape,
+    catchall: unknown(),
+    ...normalizeParams(params)
+  });
+}
+function union(options, params) {
+  return new ZodUnion({
+    type: "union",
+    options,
+    ...normalizeParams(params)
+  });
+}
+function discriminatedUnion(discriminator, options, params) {
+  return new ZodDiscriminatedUnion({
+    type: "union",
+    options,
+    discriminator,
+    ...normalizeParams(params)
+  });
+}
+function intersection(left, right) {
+  return new ZodIntersection({
+    type: "intersection",
+    left,
+    right
+  });
+}
+function record(keyType, valueType, params) {
+  return new ZodRecord({
+    type: "record",
+    keyType,
+    valueType,
+    ...normalizeParams(params)
+  });
+}
+function _enum(values, params) {
+  return new ZodEnum({
+    type: "enum",
+    entries: Array.isArray(values) ? Object.fromEntries(values.map(v => [v, v])) : values,
+    ...normalizeParams(params)
+  });
+}
+function literal(value, params) {
+  return new ZodLiteral({
+    type: "literal",
+    values: Array.isArray(value) ? value : [value],
+    ...normalizeParams(params)
+  });
+}
+function transform(fn) {
+  return new ZodTransform({
+    type: "transform",
+    transform: fn
+  });
+}
+function optional(innerType) {
+  return new ZodOptional$1({
+    type: "optional",
+    innerType
+  });
+}
+function exactOptional(innerType) {
+  return new ZodExactOptional({
+    type: "optional",
+    innerType
+  });
+}
+function nullable(innerType) {
+  return new ZodNullable({
+    type: "nullable",
+    innerType
+  });
+}
+function _default(innerType, defaultValue) {
+  return new ZodDefault({
+    type: "default",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
+    }
+  });
+}
+function prefault(innerType, defaultValue) {
+  return new ZodPrefault({
+    type: "prefault",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
+    }
+  });
+}
+function nonoptional(innerType, params) {
+  return new ZodNonOptional({
+    type: "nonoptional",
+    innerType,
+    ...normalizeParams(params)
+  });
+}
+function _catch(innerType, catchValue) {
+  return new ZodCatch({
+    type: "catch",
+    innerType,
+    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
+  });
+}
+function pipe(in_, out) {
+  return new ZodPipe({
+    type: "pipe",
+    in: in_,
+    out
+  });
+}
+function readonly(innerType) {
+  return new ZodReadonly({
+    type: "readonly",
+    innerType
+  });
+}
+function custom(fn, _params) {
+  return _custom(ZodCustom, fn ?? (() => true), _params);
+}
+function refine(fn, _params = {}) {
+  return _refine(ZodCustom, fn, _params);
+}
+function superRefine(fn) {
+  return _superRefine(fn);
+}
+function preprocess(fn, schema) {
+  return pipe(transform(fn), schema);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+
+function assertCompleteRequestPrompt(request) {
+  if (request.params.ref.type !== "ref/prompt") throw new TypeError(`Expected CompleteRequestPrompt, but got ${request.params.ref.type}`);
+}
+function assertCompleteRequestResourceTemplate(request) {
+  if (request.params.ref.type !== "ref/resource") throw new TypeError(`Expected CompleteRequestResourceTemplate, but got ${request.params.ref.type}`);
+}
+/**
+* The server's response to a completion/complete request
+*/
+
+//#endregion
+//#region ../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
+/**
+* Experimental task interfaces for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*/
+/**
+* Checks if a task status represents a terminal state.
+* Terminal states are those where the task has finished and will not change.
+*
+* @param status - The task status to check
+* @returns True if the status is terminal (completed, failed, or cancelled)
+* @experimental
+*/
+function isTerminal(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/Options.js
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+function addErrorMessage(res, key, errorMessage, refs) {
+  if (!refs?.errorMessages) return;
+  if (errorMessage) res.errorMessage = {
+    ...res.errorMessage,
+    [key]: errorMessage
+  };
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+function parseAnyDef(refs) {
+  if (refs.target !== "openAi") return {};
+  const anyDefinitionPath = [...refs.basePath, refs.definitionPath, refs.openAiAnyTypeName];
+  refs.flags.hasReferencedOpenAiAnyType = true;
+  return {
+    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+function parseArrayDef(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) res.items = parseDef(def.type._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  if (def.minLength) setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  if (def.maxLength) setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+function parseBigintDef(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) setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);else setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+      } else {
+        if (!check.inclusive) res.exclusiveMinimum = true;
+        setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+      }
+      break;
+    case "max":
+      if (refs.target === "jsonSchema7") {
+        if (check.inclusive) setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);else setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+      } else {
+        if (!check.inclusive) res.exclusiveMaximum = true;
+        setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+      }
+      break;
+    case "multipleOf":
+      setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+      break;
+  }
+  return res;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+function parseBooleanDef() {
+  return {
+    type: "boolean"
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+  if (Array.isArray(strategy)) return {
+    anyOf: strategy.map((item, i) => parseDateDef(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 integerDateParser(def, refs);
+  }
+}
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+
+function parseIntersectionDef(def, refs) {
+  const allOf = [parseDef(def.left._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  }), parseDef(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 (isJsonSchema7AllOfType(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;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+function parseLiteralDef(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
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+
+function parseStringDef(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) for (const check of def.checks) switch (check.kind) {
+    case "min":
+      setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+      break;
+    case "max":
+      setResponseValueAndErrors(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":
+          addFormat(res, "email", check.message, refs);
+          break;
+        case "format:idn-email":
+          addFormat(res, "idn-email", check.message, refs);
+          break;
+        case "pattern:zod":
+          addPattern(res, zodPatterns.email, check.message, refs);
+          break;
+      }
+      break;
+    case "url":
+      addFormat(res, "uri", check.message, refs);
+      break;
+    case "uuid":
+      addFormat(res, "uuid", check.message, refs);
+      break;
+    case "regex":
+      addPattern(res, check.regex, check.message, refs);
+      break;
+    case "cuid":
+      addPattern(res, zodPatterns.cuid, check.message, refs);
+      break;
+    case "cuid2":
+      addPattern(res, zodPatterns.cuid2, check.message, refs);
+      break;
+    case "startsWith":
+      addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
+      break;
+    case "endsWith":
+      addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
+      break;
+    case "datetime":
+      addFormat(res, "date-time", check.message, refs);
+      break;
+    case "date":
+      addFormat(res, "date", check.message, refs);
+      break;
+    case "time":
+      addFormat(res, "time", check.message, refs);
+      break;
+    case "duration":
+      addFormat(res, "duration", check.message, refs);
+      break;
+    case "length":
+      setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+      setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+      break;
+    case "includes":
+      addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
+      break;
+    case "ip":
+      if (check.version !== "v6") addFormat(res, "ipv4", check.message, refs);
+      if (check.version !== "v4") addFormat(res, "ipv6", check.message, refs);
+      break;
+    case "base64url":
+      addPattern(res, zodPatterns.base64url, check.message, refs);
+      break;
+    case "jwt":
+      addPattern(res, zodPatterns.jwt, check.message, refs);
+      break;
+    case "cidr":
+      if (check.version !== "v6") addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+      if (check.version !== "v4") addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+      break;
+    case "emoji":
+      addPattern(res, zodPatterns.emoji(), check.message, refs);
+      break;
+    case "ulid":
+      addPattern(res, zodPatterns.ulid, check.message, refs);
+      break;
+    case "base64":
+      switch (refs.base64Strategy) {
+        case "format:binary":
+          addFormat(res, "binary", check.message, refs);
+          break;
+        case "contentEncoding:base64":
+          setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
+          break;
+        case "pattern:zod":
+          addPattern(res, zodPatterns.base64, check.message, refs);
+          break;
+      }
+      break;
+    case "nanoid":
+      addPattern(res, zodPatterns.nanoid, check.message, refs);
+    case "toLowerCase":
+    case "toUpperCase":
+    case "trim":
+      break;
+    default:
+      (_ => {})(check);
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i = 0; i < source.length; i++) {
+    if (!ALPHA_NUMERIC.has(source[i])) result += "\\";
+    result += source[i];
+  }
+  return result;
+}
+function addFormat(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 setResponseValueAndErrors(schema, "format", value, message, refs);
+}
+function addPattern(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: stringifyRegExpWithFlags(regex, refs),
+      ...(message && refs.errorMessages && {
+        errorMessage: {
+          pattern: message
+        }
+      })
+    });
+  } else setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+}
+function stringifyRegExpWithFlags(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")
+  };
+  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\n]))`;
+        continue;
+      } else if (source[i] === "$") {
+        pattern += `($|(?=[\r\n]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i] === ".") {
+      pattern += inCharGroup ? `${source[i]}\r\n` : `[${source[i]}\r\n]`;
+      continue;
+    }
+    pattern += source[i];
+    if (source[i] === "\\") isEscaped = true;else if (inCharGroup && source[i] === "]") inCharGroup = false;else if (!inCharGroup && source[i] === "[") inCharGroup = true;
+  }
+  try {
+    new RegExp(pattern);
+  } catch {
+    console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
+    return regex.source;
+  }
+  return pattern;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+function parseRecordDef(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) return {
+    type: "object",
+    required: def.keyType._def.values,
+    properties: def.keyType._def.values.reduce((acc, key) => ({
+      ...acc,
+      [key]: parseDef(def.valueType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "properties", key]
+      }) ?? parseAnyDef(refs)
+    }), {}),
+    additionalProperties: refs.rejectedAdditionalProperties
+  };
+  const schema = {
+    type: "object",
+    additionalProperties: parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? refs.allowedAdditionalProperties
+  };
+  if (refs.target === "openApi3") return schema;
+  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+    const {
+      type,
+      ...keyType
+    } = parseStringDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.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
+    } = parseBrandedDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") return parseRecordDef(def, refs);
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [parseDef(def.keyType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", "items", "0"]
+      }) || parseAnyDef(refs), parseDef(def.valueType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", "items", "1"]
+      }) || parseAnyDef(refs)],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+function parseNativeEnumDef(def) {
+  const object = def.values;
+  const actualValues = Object.keys(def.values).filter(key => {
+    return typeof object[object[key]] !== "number";
+  }).map(key => object[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
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+function parseNeverDef(refs) {
+  return refs.target === "openAi" ? void 0 : {
+    not: parseAnyDef({
+      ...refs,
+      currentPath: [...refs.currentPath, "not"]
+    })
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+function parseNullDef(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+
+function parseUnionDef(def, refs) {
+  if (refs.target === "openApi3") return asAnyOf(def, refs);
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options.every(x => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
+    const types = options.reduce((types, x) => {
+      const type = primitiveMappings[x._def.typeName];
+      return type && !types.includes(type) ? [...types, type] : types;
+    }, []);
+    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"];
+        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(x => !acc.includes(x))], [])
+  };
+  return asAnyOf(def, refs);
+}
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+function parseNullableDef(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: primitiveMappings[def.innerType._def.typeName],
+      nullable: true
+    };
+    return {
+      type: [primitiveMappings[def.innerType._def.typeName], "null"]
+    };
+  }
+  if (refs.target === "openApi3") {
+    const base = parseDef(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath]
+    });
+    if (base && "$ref" in base) return {
+      allOf: [base],
+      nullable: true
+    };
+    return base && {
+      ...base,
+      nullable: true
+    };
+  }
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && {
+    anyOf: [base, {
+      type: "null"
+    }]
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+function parseNumberDef(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";
+      addErrorMessage(res, "type", check.message, refs);
+      break;
+    case "min":
+      if (refs.target === "jsonSchema7") {
+        if (check.inclusive) setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);else setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+      } else {
+        if (!check.inclusive) res.exclusiveMinimum = true;
+        setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+      }
+      break;
+    case "max":
+      if (refs.target === "jsonSchema7") {
+        if (check.inclusive) setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);else setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+      } else {
+        if (!check.inclusive) res.exclusiveMaximum = true;
+        setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+      }
+      break;
+    case "multipleOf":
+      setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+      break;
+  }
+  return res;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+function parseObjectDef(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 = safeIsOptional(propDef);
+    if (propOptional && forceOptionalIntoNullable) {
+      if (propDef._def.typeName === "ZodOptional") propDef = propDef._def.innerType;
+      if (!propDef.isNullable()) propDef = propDef.nullable();
+      propOptional = false;
+    }
+    const parsedDef = parseDef(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 = decideAdditionalProperties(def, refs);
+  if (additionalProperties !== void 0) result.additionalProperties = additionalProperties;
+  return result;
+}
+function decideAdditionalProperties(def, refs) {
+  if (def.catchall._def.typeName !== "ZodNever") return parseDef(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 safeIsOptional(schema) {
+  try {
+    return schema.isOptional();
+  } catch {
+    return true;
+  }
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+function parseSetDef(def, refs) {
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items: parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    })
+  };
+  if (def.minSize) setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+  if (def.maxSize) setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+  return schema;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+function parseTupleDef(def, refs) {
+  if (def.rest) return {
+    type: "array",
+    minItems: def.items.length,
+    items: def.items.map((x, i) => parseDef(x._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items", `${i}`]
+    })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
+    additionalItems: parseDef(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) => parseDef(x._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items", `${i}`]
+    })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+function parseUndefinedDef(refs) {
+  return {
+    not: parseAnyDef(refs)
+  };
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+function parseUnknownDef(refs) {
+  return parseAnyDef(refs);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+
+//#endregion
+//#region ../../node_modules/.bun/zod-to-json-schema@3.25.1+3c5d820c62823f0b/node_modules/zod-to-json-schema/dist/esm/parseDef.js
+function parseDef(def, refs, forceResolution = false) {
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+    if (overrideResult !== ignoreOverride) return overrideResult;
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+    if (seenSchema !== void 0) return seenSchema;
+  }
+  const newItem = {
+    def,
+    path: refs.currentPath,
+    jsonSchema: void 0
+  };
+  refs.seen.set(def, newItem);
+  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+  const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema) addMeta(def, refs, jsonSchema);
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema, def, refs);
+    newItem.jsonSchema = jsonSchema;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema;
+  return jsonSchema;
+}
+//#endregion
+//#region ../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
+function mapMiniTarget(t) {
+  if (!t) return "draft-7";
+  if (t === "jsonSchema7" || t === "draft-7") return "draft-7";
+  if (t === "jsonSchema2019-09" || t === "draft-2020-12") return "draft-2020-12";
+  return "draft-7";
+}
+function toJsonSchemaCompat(schema, opts) {
+  if (isZ4Schema(schema)) return toJSONSchema(schema, {
+    target: mapMiniTarget(opts?.target),
+    io: opts?.pipeStrategy ?? "input"
+  });
+  return zodToJsonSchema(schema, {
+    strictUnions: opts?.strictUnions ?? true,
+    pipeStrategy: opts?.pipeStrategy ?? "input"
+  });
+}
+function getMethodLiteral(schema) {
+  const methodSchema = getObjectShape(schema)?.method;
+  if (!methodSchema) throw new Error("Schema is missing a method literal");
+  const value = getLiteralValue(methodSchema);
+  if (typeof value !== "string") throw new Error("Schema method literal must be a string");
+  return value;
+}
+function parseWithCompat(schema, data) {
+  const result = safeParse$1(schema, data);
+  if (!result.success) throw result.error;
+  return result.data;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
+/**
+* The default request timeout, in miliseconds.
+*/
+
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeCapabilities(base, additional) {
+  const result = {
+    ...base
+  };
+  for (const key in additional) {
+    const k = key;
+    const addValue = additional[k];
+    if (addValue === void 0) continue;
+    const baseValue = result[k];
+    if (isPlainObject(baseValue) && isPlainObject(addValue)) result[k] = {
+      ...baseValue,
+      ...addValue
+    };else result[k] = addValue;
+  }
+  return result;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
+
+function createDefaultAjvInstance() {
+  const ajv = new import_ajv.default({
+    strict: false,
+    validateFormats: true,
+    validateSchema: false,
+    allErrors: true
+  });
+  (0, import_dist.default)(ajv);
+  return ajv;
+}
+/**
+* @example
+* ```typescript
+* // Use with default AJV instance (recommended)
+* import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
+* const validator = new AjvJsonSchemaValidator();
+*
+* // Use with custom AJV instance
+* import { Ajv } from 'ajv';
+* const ajv = new Ajv({ strict: true, allErrors: true });
+* const validator = new AjvJsonSchemaValidator(ajv);
+* ```
+*/
+
+//#endregion
+//#region ../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+/**
+* Experimental task capability assertion helpers.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
+* Asserts that task creation is supported for tools/call.
+* Used by Client.assertTaskCapability and Server.assertTaskHandlerCapability.
+*
+* @param requests - The task requests capability object
+* @param method - The method being checked
+* @param entityName - 'Server' or 'Client' for error messages
+* @throws Error if the capability is not supported
+*
+* @experimental
+*/
+function assertToolsCallTaskCapability(requests, method, entityName) {
+  if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  switch (method) {
+    case "tools/call":
+      if (!requests.tools?.call) throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+      break;
+    default:
+      break;
+  }
+}
+/**
+* Asserts that task creation is supported for sampling/createMessage or elicitation/create.
+* Used by Server.assertTaskCapability and Client.assertTaskHandlerCapability.
+*
+* @param requests - The task requests capability object
+* @param method - The method being checked
+* @param entityName - 'Server' or 'Client' for error messages
+* @throws Error if the capability is not supported
+*
+* @experimental
+*/
+function assertClientRequestTaskCapability(requests, method, entityName) {
+  if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  switch (method) {
+    case "sampling/createMessage":
+      if (!requests.sampling?.createMessage) throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+      break;
+    case "elicitation/create":
+      if (!requests.elicitation?.create) throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+      break;
+    default:
+      break;
+  }
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+/**
+* An MCP server on top of a pluggable transport.
+*
+* This server will automatically respond to the initialization flow as initiated from the client.
+*
+* To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
+*
+* ```typescript
+* // Custom schemas
+* const CustomRequestSchema = RequestSchema.extend({...})
+* const CustomNotificationSchema = NotificationSchema.extend({...})
+* const CustomResultSchema = ResultSchema.extend({...})
+*
+* // Type aliases
+* type CustomRequest = z.infer<typeof CustomRequestSchema>
+* type CustomNotification = z.infer<typeof CustomNotificationSchema>
+* type CustomResult = z.infer<typeof CustomResultSchema>
+*
+* // Create typed server
+* const server = new Server<CustomRequest, CustomNotification, CustomResult>({
+*   name: "CustomServer",
+*   version: "1.0.0"
+* })
+* ```
+* @deprecated Use `McpServer` instead for the high-level API. Only use `Server` for advanced use cases.
+*/
+
+/**
+* Checks if a schema is completable (has completion metadata).
+*/
+function isCompletable(schema) {
+  return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
+}
+/**
+* Gets the completer callback from a completable schema, if it exists.
+*/
+function getCompleter(schema) {
+  return schema[COMPLETABLE_SYMBOL]?.complete;
+}
+/**
+* Validates a tool name according to the SEP specification
+* @param name - The tool name to validate
+* @returns An object containing validation result and any warnings
+*/
+function validateToolName(name) {
+  const warnings = [];
+  if (name.length === 0) return {
+    isValid: false,
+    warnings: ["Tool name cannot be empty"]
+  };
+  if (name.length > 128) return {
+    isValid: false,
+    warnings: [`Tool name exceeds maximum length of 128 characters (current: ${name.length})`]
+  };
+  if (name.includes(" ")) warnings.push("Tool name contains spaces, which may cause parsing issues");
+  if (name.includes(",")) warnings.push("Tool name contains commas, which may cause parsing issues");
+  if (name.startsWith("-") || name.endsWith("-")) warnings.push("Tool name starts or ends with a dash, which may cause parsing issues in some contexts");
+  if (name.startsWith(".") || name.endsWith(".")) warnings.push("Tool name starts or ends with a dot, which may cause parsing issues in some contexts");
+  if (!TOOL_NAME_REGEX.test(name)) {
+    const invalidChars = name.split("").filter(char => !/[A-Za-z0-9._-]/.test(char)).filter((char, index, arr) => arr.indexOf(char) === index);
+    warnings.push(`Tool name contains invalid characters: ${invalidChars.map(c => `"${c}"`).join(", ")}`, "Allowed characters are: A-Z, a-z, 0-9, underscore (_), dash (-), and dot (.)");
+    return {
+      isValid: false,
+      warnings
+    };
+  }
+  return {
+    isValid: true,
+    warnings
+  };
+}
+/**
+* Issues warnings for non-conforming tool names
+* @param name - The tool name that triggered the warnings
+* @param warnings - Array of warning messages
+*/
+function issueToolNameWarning(name, warnings) {
+  if (warnings.length > 0) {
+    console.warn(`Tool name validation warning for "${name}":`);
+    for (const warning of warnings) console.warn(`  - ${warning}`);
+    console.warn("Tool registration will proceed, but this may cause compatibility issues.");
+    console.warn("Consider updating the tool name to conform to the MCP tool naming standard.");
+    console.warn("See SEP: Specify Format for Tool Names (https://github.com/modelcontextprotocol/modelcontextprotocol/issues/986) for more details.");
+  }
+}
+/**
+* Validates a tool name and issues warnings for non-conforming names
+* @param name - The tool name to validate
+* @returns true if the name is valid, false otherwise
+*/
+function validateAndWarnToolName(name) {
+  const result = validateToolName(name);
+  issueToolNameWarning(name, result.warnings);
+  return result.isValid;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js
+/**
+* Experimental McpServer task features for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
+* Experimental task features for McpServer.
+*
+* Access via `server.experimental.tasks`:
+* ```typescript
+* server.experimental.tasks.registerToolTask('long-running', config, handler);
+* ```
+*
+* @experimental
+*/
+
+/**
+* Checks if a value looks like a Zod schema by checking for parse/safeParse methods.
+*/
+function isZodTypeLike(value) {
+  return value !== null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
+}
+/**
+* Checks if an object is a Zod schema instance (v3 or v4).
+*
+* Zod schemas have internal markers:
+* - v3: `_def` property
+* - v4: `_zod` property
+*
+* This includes transformed schemas like z.preprocess(), z.transform(), z.pipe().
+*/
+function isZodSchemaInstance(obj) {
+  return "_def" in obj || "_zod" in obj || isZodTypeLike(obj);
+}
+/**
+* Checks if an object is a "raw shape" - a plain object where values are Zod schemas.
+*
+* Raw shapes are used as shorthand: `{ name: z.string() }` instead of `z.object({ name: z.string() })`.
+*
+* IMPORTANT: This must NOT match actual Zod schema instances (like z.preprocess, z.pipe),
+* which have internal properties that could be mistaken for schema values.
+*/
+function isZodRawShapeCompat(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  if (isZodSchemaInstance(obj)) return false;
+  if (Object.keys(obj).length === 0) return true;
+  return Object.values(obj).some(isZodTypeLike);
+}
+/**
+* Converts a provided Zod schema to a Zod object if it is a ZodRawShapeCompat,
+* otherwise returns the schema as is.
+*/
+function getZodSchemaObject(schema) {
+  if (!schema) return;
+  if (isZodRawShapeCompat(schema)) return objectFromShape(schema);
+  return schema;
+}
+function promptArgumentsFromSchema(schema) {
+  const shape = getObjectShape(schema);
+  if (!shape) return [];
+  return Object.entries(shape).map(([name, field]) => {
+    return {
+      name,
+      description: getSchemaDescription(field),
+      required: !isSchemaOptional(field)
+    };
+  });
+}
+function getMethodValue(schema) {
+  const methodSchema = getObjectShape(schema)?.method;
+  if (!methodSchema) throw new Error("Schema is missing a method literal");
+  const value = getLiteralValue(methodSchema);
+  if (typeof value === "string") return value;
+  throw new Error("Schema method literal must be a string");
+}
+function createCompletionResult(suggestions) {
+  return {
+    completion: {
+      values: suggestions.slice(0, 100),
+      total: suggestions.length,
+      hasMore: suggestions.length > 100
+    }
+  };
+}
+function deserializeMessage(line) {
+  return JSONRPCMessageSchema.parse(JSON.parse(line));
+}
+function serializeMessage(message) {
+  return JSON.stringify(message) + "\n";
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+/**
+* Server transport for stdio: this communicates with an MCP client by reading from the current process' stdin and writing to stdout.
+*
+* This transport is only available in Node.js environments.
+*/
+
+//#endregion
+//#region src/project-scanner.ts
+/**
+* Project scanner — extracts route, component, and island information from source files.
+*/
+function generateContext(cwd) {
+  const files = collectSourceFiles(cwd);
+  return {
+    framework: "pyreon",
+    version: readVersion(cwd),
+    generatedAt: (/* @__PURE__ */new Date()).toISOString(),
+    routes: extractRoutes(files, cwd),
+    components: extractComponents(files, cwd),
+    islands: extractIslands(files, cwd)
+  };
+}
+function collectSourceFiles(cwd) {
+  const results = [];
+  const extensions = new Set([".tsx", ".jsx", ".ts", ".js"]);
+  const ignoreDirs = new Set(["node_modules", "dist", "lib", ".pyreon", ".git", "build"]);
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, {
+        withFileTypes: true
+      });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.isDirectory()) continue;
+      if (ignoreDirs.has(entry.name) && entry.isDirectory()) continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(fullPath);else if (entry.isFile() && extensions.has(path.extname(entry.name))) results.push(fullPath);
+    }
+  }
+  walk(cwd);
+  return results;
+}
+function extractRoutes(files, _cwd) {
+  const routes = [];
+  for (const file of files) {
+    let code;
+    try {
+      code = fs.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const routeArrayRe = /(?:createRouter\s*\(\s*\[|(?:const|let)\s+routes\s*(?::\s*RouteRecord\[\])?\s*=\s*\[)([\s\S]*?)\]/g;
+    let match;
+    for (match = routeArrayRe.exec(code); match; match = routeArrayRe.exec(code)) {
+      const block = match[1] ?? "";
+      const routeObjRe = /path\s*:\s*["']([^"']+)["']/g;
+      let routeMatch;
+      for (routeMatch = routeObjRe.exec(block); routeMatch; routeMatch = routeObjRe.exec(block)) {
+        const routePath = routeMatch[1] ?? "";
+        const surroundingStart = Math.max(0, routeMatch.index - 50);
+        const surroundingEnd = Math.min(block.length, routeMatch.index + 200);
+        const surrounding = block.slice(surroundingStart, surroundingEnd);
+        routes.push({
+          path: routePath,
+          name: surrounding.match(/name\s*:\s*["']([^"']+)["']/)?.[1],
+          hasLoader: /loader\s*:/.test(surrounding),
+          hasGuard: /beforeEnter\s*:|beforeLeave\s*:/.test(surrounding),
+          params: extractParams(routePath)
+        });
+      }
+    }
+  }
+  return routes;
+}
+function extractComponents(files, cwd) {
+  const components = [];
+  for (const file of files) {
+    let code;
+    try {
+      code = fs.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const componentRe = /(?:export\s+)?(?:const|function)\s+([A-Z]\w*)\s*(?::\s*ComponentFn<[^>]+>\s*)?=?\s*\(?(?:\s*\{?\s*([^)]*?)\s*\}?\s*)?\)?\s*(?:=>|{)/g;
+    let match;
+    for (match = componentRe.exec(code); match; match = componentRe.exec(code)) {
+      const name = match[1] ?? "Unknown";
+      const props = (match[2] ?? "").split(/[,;]/).map(p => p.trim().replace(/[{}]/g, "").trim().split(":")[0]?.split("=")[0]?.trim() ?? "").filter(p => p && p !== "props");
+      const bodyStart = match.index + match[0].length;
+      const body = code.slice(bodyStart, Math.min(code.length, bodyStart + 2e3));
+      const signalNames = [];
+      const signalRe = /(?:const|let)\s+(\w+)\s*=\s*signal\s*[<(]/g;
+      let sigMatch;
+      for (sigMatch = signalRe.exec(body); sigMatch; sigMatch = signalRe.exec(body)) if (sigMatch[1]) signalNames.push(sigMatch[1]);
+      components.push({
+        name,
+        file: path.relative(cwd, file),
+        hasSignals: signalNames.length > 0,
+        signalNames,
+        props
+      });
+    }
+  }
+  return components;
+}
+function extractIslands(files, cwd) {
+  const islands = [];
+  for (const file of files) {
+    let code;
+    try {
+      code = fs.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const islandRe = /island\s*\(\s*\(\)\s*=>\s*import\(.+?\)\s*,\s*\{[^}]*name\s*:\s*["']([^"']+)["'][^}]*?(?:hydrate\s*:\s*["']([^"']+)["'])?[^}]*\}/g;
+    let match;
+    for (match = islandRe.exec(code); match; match = islandRe.exec(code)) if (match[1]) islands.push({
+      name: match[1],
+      file: path.relative(cwd, file),
+      hydrate: match[2] ?? "load"
+    });
+  }
+  return islands;
+}
+function extractParams(routePath) {
+  const params = [];
+  const paramRe = /:(\w+)\??/g;
+  let match;
+  for (match = paramRe.exec(routePath); match; match = paramRe.exec(routePath)) if (match[1]) params.push(match[1]);
+  return params;
+}
+function readVersion(cwd) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
+    const deps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    for (const [name, ver] of Object.entries(deps)) if (name.startsWith("@pyreon/") && typeof ver === "string") return ver.replace(/^[\^~]/, "");
+    return pkg.version || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* @pyreon/mcp — Model Context Protocol server for Pyreon
+*
+* Exposes tools that AI coding assistants (Claude Code, Cursor, etc.) can use
+* to generate, validate, and migrate Pyreon code.
+*
+* Tools:
+*   get_api        — Look up any Pyreon API: signature, usage, common mistakes
+*   validate       — Check a code snippet for Pyreon anti-patterns
+*   migrate_react  — Convert React code to idiomatic Pyreon
+*   diagnose       — Parse an error message into structured fix information
+*   get_routes     — List all routes in the current project
+*   get_components — List all components with their props and signals
+*
+* Usage:
+*   bunx @pyreon/mcp          # stdio transport (for IDE integration)
+*/
+
+function getContext() {
+  if (!cachedContext || contextCwd !== process.cwd()) {
+    contextCwd = process.cwd();
+    cachedContext = generateContext(contextCwd);
+  }
+  return cachedContext;
+}
+function textResult(text) {
+  return {
+    content: [{
+      type: "text",
+      text
+    }]
+  };
+}
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+//# sourceMappingURL=index.d.ts.map