@mastra/deployer 0.0.0-commonjs-20250227130920

package/dist/server/index.cjs

@@ -0,0 +1,4930 @@
+'use strict';
+
+var promises = require('fs/promises');
+var path = require('path');
+var url = require('url');
+var http = require('http');
+var http2 = require('http2');
+var stream = require('stream');
+var crypto = require('crypto');
+var filepath = require('hono/utils/filepath');
+var mime = require('hono/utils/mime');
+var fs = require('fs');
+var html = require('hono/html');
+var hono = require('hono');
+var bodyLimit = require('hono/body-limit');
+var cors = require('hono/cors');
+var logger = require('hono/logger');
+var httpException = require('hono/http-exception');
+var zod = require('zod');
+var agent = require('@mastra/core/agent');
+var streaming = require('hono/streaming');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
+// src/server/index.ts
+var RequestError = class extends Error {
+  static name = "RequestError";
+  constructor(message, options) {
+    super(message, options);
+  }
+};
+var toRequestError = (e2) => {
+  if (e2 instanceof RequestError) {
+    return e2;
+  }
+  return new RequestError(e2.message, { cause: e2 });
+};
+var GlobalRequest = global.Request;
+var Request = class extends GlobalRequest {
+  constructor(input, options) {
+    if (typeof input === "object" && getRequestCache in input) {
+      input = input[getRequestCache]();
+    }
+    if (typeof options?.body?.getReader !== "undefined") {
+      options.duplex ??= "half";
+    }
+    super(input, options);
+  }
+};
+var newRequestFromIncoming = (method, url, incoming, abortController) => {
+  const headerRecord = [];
+  const rawHeaders = incoming.rawHeaders;
+  for (let i2 = 0; i2 < rawHeaders.length; i2 += 2) {
+    const { [i2]: key, [i2 + 1]: value } = rawHeaders;
+    if (key.charCodeAt(0) !== /*:*/
+    58) {
+      headerRecord.push([key, value]);
+    }
+  }
+  const init = {
+    method,
+    headers: headerRecord,
+    signal: abortController.signal
+  };
+  if (method === "TRACE") {
+    init.method = "GET";
+    const req = new Request(url, init);
+    Object.defineProperty(req, "method", {
+      get() {
+        return "TRACE";
+      }
+    });
+    return req;
+  }
+  if (!(method === "GET" || method === "HEAD")) {
+    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
+      init.body = new ReadableStream({
+        start(controller) {
+          controller.enqueue(incoming.rawBody);
+          controller.close();
+        }
+      });
+    } else {
+      init.body = stream.Readable.toWeb(incoming);
+    }
+  }
+  return new Request(url, init);
+};
+var getRequestCache = Symbol("getRequestCache");
+var requestCache = Symbol("requestCache");
+var incomingKey = Symbol("incomingKey");
+var urlKey = Symbol("urlKey");
+var abortControllerKey = Symbol("abortControllerKey");
+var getAbortController = Symbol("getAbortController");
+var requestPrototype = {
+  get method() {
+    return this[incomingKey].method || "GET";
+  },
+  get url() {
+    return this[urlKey];
+  },
+  [getAbortController]() {
+    this[getRequestCache]();
+    return this[abortControllerKey];
+  },
+  [getRequestCache]() {
+    this[abortControllerKey] ||= new AbortController();
+    return this[requestCache] ||= newRequestFromIncoming(
+      this.method,
+      this[urlKey],
+      this[incomingKey],
+      this[abortControllerKey]
+    );
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "cache",
+  "credentials",
+  "destination",
+  "headers",
+  "integrity",
+  "mode",
+  "redirect",
+  "referrer",
+  "referrerPolicy",
+  "signal",
+  "keepalive"
+].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    get() {
+      return this[getRequestCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    value: function() {
+      return this[getRequestCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(requestPrototype, Request.prototype);
+var newRequest = (incoming, defaultHostname) => {
+  const req = Object.create(requestPrototype);
+  req[incomingKey] = incoming;
+  const host = (incoming instanceof http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+  if (!host) {
+    throw new RequestError("Missing host header");
+  }
+  const url = new URL(
+    `${incoming instanceof http2.Http2ServerRequest || incoming.socket && incoming.socket.encrypted ? "https" : "http"}://${host}${incoming.url}`
+  );
+  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+    throw new RequestError("Invalid host header");
+  }
+  req[urlKey] = url.href;
+  return req;
+};
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    stream.cancel();
+    return;
+  }
+  const reader = stream.getReader();
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error) {
+      writable.destroy(error);
+    }
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (!writable.write(value)) {
+        writable.once("drain", onDrain);
+      } else {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e2) {
+      cancel(e2);
+    }
+  }
+}
+var buildOutgoingHttpHeaders = (headers) => {
+  const res = {};
+  if (!(headers instanceof Headers)) {
+    headers = new Headers(headers ?? void 0);
+  }
+  const cookies = [];
+  for (const [k, v] of headers) {
+    if (k === "set-cookie") {
+      cookies.push(v);
+    } else {
+      res[k] = v;
+    }
+  }
+  if (cookies.length > 0) {
+    res["set-cookie"] = cookies;
+  }
+  res["content-type"] ??= "text/plain; charset=UTF-8";
+  return res;
+};
+var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
+var cacheKey = Symbol("cache");
+var GlobalResponse = global.Response;
+var Response2 = class _Response {
+  #body;
+  #init;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    this.#body = body;
+    if (init instanceof _Response) {
+      const cachedGlobalResponse = init[responseCache];
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse;
+        this[getResponseCache]();
+        return;
+      } else {
+        this.#init = init.#init;
+      }
+    } else {
+      this.#init = init;
+    }
+    if (typeof body === "string" || typeof body?.getReader !== "undefined") {
+      let headers = init?.headers || { "content-type": "text/plain; charset=UTF-8" };
+      if (headers instanceof Headers) {
+        headers = buildOutgoingHttpHeaders(headers);
+      }
+      this[cacheKey] = [init?.status || 200, body, headers];
+    }
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "headers",
+  "ok",
+  "redirected",
+  "status",
+  "statusText",
+  "trailers",
+  "type",
+  "url"
+].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this[getResponseCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+var stateKey = Reflect.ownKeys(new GlobalResponse()).find(
+  (k) => typeof k === "symbol" && k.toString() === "Symbol(state)"
+);
+if (!stateKey) {
+  console.warn("Failed to find Response internal state key");
+}
+function getInternalBody(response) {
+  if (!stateKey) {
+    return;
+  }
+  if (response instanceof Response2) {
+    response = response[getResponseCache]();
+  }
+  const state = response[stateKey];
+  return state && state.body || void 0;
+}
+var X_ALREADY_SENT = "x-hono-already-sent";
+var webFetch = global.fetch;
+if (typeof global.crypto === "undefined") {
+  global.crypto = crypto__default.default;
+}
+global.fetch = (info, init) => {
+  init = {
+    // Disable compression handling so people can return the result of a fetch
+    // directly in the loader without messing with the Content-Encoding header.
+    compress: false,
+    ...init
+  };
+  return webFetch(info, init);
+};
+var regBuffer = /^no$/i;
+var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
+var handleRequestError = () => new Response(null, {
+  status: 400
+});
+var handleFetchError = (e2) => new Response(null, {
+  status: e2 instanceof Error && (e2.name === "TimeoutError" || e2.constructor.name === "TimeoutError") ? 504 : 500
+});
+var handleResponseError = (e2, outgoing) => {
+  const err = e2 instanceof Error ? e2 : new Error("unknown error", { cause: e2 });
+  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+    console.info("The user aborted a request.");
+  } else {
+    console.error(e2);
+    if (!outgoing.headersSent) {
+      outgoing.writeHead(500, { "Content-Type": "text/plain" });
+    }
+    outgoing.end(`Error: ${err.message}`);
+    outgoing.destroy(err);
+  }
+};
+var responseViaCache = (res, outgoing) => {
+  const [status, body, header] = res[cacheKey];
+  if (typeof body === "string") {
+    header["Content-Length"] = Buffer.byteLength(body);
+    outgoing.writeHead(status, header);
+    outgoing.end(body);
+  } else {
+    outgoing.writeHead(status, header);
+    return writeFromReadableStream(body, outgoing)?.catch(
+      (e2) => handleResponseError(e2, outgoing)
+    );
+  }
+};
+var responseViaResponseObject = async (res, outgoing, options = {}) => {
+  if (res instanceof Promise) {
+    if (options.errorHandler) {
+      try {
+        res = await res;
+      } catch (err) {
+        const errRes = await options.errorHandler(err);
+        if (!errRes) {
+          return;
+        }
+        res = errRes;
+      }
+    } else {
+      res = await res.catch(handleFetchError);
+    }
+  }
+  if (cacheKey in res) {
+    return responseViaCache(res, outgoing);
+  }
+  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+  const internalBody = getInternalBody(res);
+  if (internalBody) {
+    const { length, source, stream } = internalBody;
+    if (source instanceof Uint8Array && source.byteLength !== length) ; else {
+      if (length) {
+        resHeaderRecord["content-length"] = length;
+      }
+      outgoing.writeHead(res.status, resHeaderRecord);
+      if (typeof source === "string" || source instanceof Uint8Array) {
+        outgoing.end(source);
+      } else if (source instanceof Blob) {
+        outgoing.end(new Uint8Array(await source.arrayBuffer()));
+      } else {
+        await writeFromReadableStream(stream, outgoing);
+      }
+      return;
+    }
+  }
+  if (res.body) {
+    const {
+      "transfer-encoding": transferEncoding,
+      "content-encoding": contentEncoding,
+      "content-length": contentLength,
+      "x-accel-buffering": accelBuffering,
+      "content-type": contentType
+    } = resHeaderRecord;
+    if (transferEncoding || contentEncoding || contentLength || // nginx buffering variant
+    accelBuffering && regBuffer.test(accelBuffering) || !regContentType.test(contentType)) {
+      outgoing.writeHead(res.status, resHeaderRecord);
+      await writeFromReadableStream(res.body, outgoing);
+    } else {
+      const buffer = await res.arrayBuffer();
+      resHeaderRecord["content-length"] = buffer.byteLength;
+      outgoing.writeHead(res.status, resHeaderRecord);
+      outgoing.end(new Uint8Array(buffer));
+    }
+  } else if (resHeaderRecord[X_ALREADY_SENT]) ; else {
+    outgoing.writeHead(res.status, resHeaderRecord);
+    outgoing.end();
+  }
+};
+var getRequestListener = (fetchCallback, options = {}) => {
+  if (options.overrideGlobalObjects !== false && global.Request !== Request) {
+    Object.defineProperty(global, "Request", {
+      value: Request
+    });
+    Object.defineProperty(global, "Response", {
+      value: Response2
+    });
+  }
+  return async (incoming, outgoing) => {
+    let res, req;
+    try {
+      req = newRequest(incoming, options.hostname);
+      outgoing.on("close", () => {
+        const abortController = req[abortControllerKey];
+        if (!abortController) {
+          return;
+        }
+        if (incoming.errored) {
+          req[abortControllerKey].abort(incoming.errored.toString());
+        } else if (!outgoing.writableFinished) {
+          req[abortControllerKey].abort("Client connection prematurely closed.");
+        }
+      });
+      res = fetchCallback(req, { incoming, outgoing });
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+    } catch (e2) {
+      if (!res) {
+        if (options.errorHandler) {
+          res = await options.errorHandler(req ? e2 : toRequestError(e2));
+          if (!res) {
+            return;
+          }
+        } else if (!req) {
+          res = handleRequestError();
+        } else {
+          res = handleFetchError(e2);
+        }
+      } else {
+        return handleResponseError(e2, outgoing);
+      }
+    }
+    try {
+      return responseViaResponseObject(res, outgoing, options);
+    } catch (e2) {
+      return handleResponseError(e2, outgoing);
+    }
+  };
+};
+var createAdaptorServer = (options) => {
+  const fetchCallback = options.fetch;
+  const requestListener = getRequestListener(fetchCallback, {
+    hostname: options.hostname,
+    overrideGlobalObjects: options.overrideGlobalObjects
+  });
+  const createServer = options.createServer || http.createServer;
+  const server = createServer(options.serverOptions || {}, requestListener);
+  return server;
+};
+var serve = (options, listeningListener) => {
+  const server = createAdaptorServer(options);
+  server.listen(options?.port, options.hostname, () => {
+    const serverInfo = server.address();
+    listeningListener && listeningListener(serverInfo);
+  });
+  return server;
+};
+var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+var ENCODINGS = {
+  br: ".br",
+  zstd: ".zst",
+  gzip: ".gz"
+};
+var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+var createStreamBody = (stream) => {
+  const body = new ReadableStream({
+    start(controller) {
+      stream.on("data", (chunk) => {
+        controller.enqueue(chunk);
+      });
+      stream.on("end", () => {
+        controller.close();
+      });
+    },
+    cancel() {
+      stream.destroy();
+    }
+  });
+  return body;
+};
+var addCurrentDirPrefix = (path) => {
+  return `./${path}`;
+};
+var getStats = (path) => {
+  let stats;
+  try {
+    stats = fs.lstatSync(path);
+  } catch {
+  }
+  return stats;
+};
+var serveStatic = (options = { root: "" }) => {
+  return async (c2, next) => {
+    if (c2.finalized) {
+      return next();
+    }
+    let filename;
+    try {
+      filename = options.path ?? decodeURIComponent(c2.req.path);
+    } catch {
+      await options.onNotFound?.(c2.req.path, c2);
+      return next();
+    }
+    let path = filepath.getFilePathWithoutDefaultDocument({
+      filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+      root: options.root
+    });
+    if (path) {
+      path = addCurrentDirPrefix(path);
+    } else {
+      return next();
+    }
+    let stats = getStats(path);
+    if (stats && stats.isDirectory()) {
+      path = filepath.getFilePath({
+        filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+        root: options.root,
+        defaultDocument: options.index ?? "index.html"
+      });
+      if (path) {
+        path = addCurrentDirPrefix(path);
+      } else {
+        return next();
+      }
+      stats = getStats(path);
+    }
+    if (!stats) {
+      await options.onNotFound?.(path, c2);
+      return next();
+    }
+    await options.onFound?.(path, c2);
+    const mimeType = mime.getMimeType(path);
+    c2.header("Content-Type", mimeType || "application/octet-stream");
+    if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+      const acceptEncodingSet = new Set(
+        c2.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim())
+      );
+      for (const encoding of ENCODINGS_ORDERED_KEYS) {
+        if (!acceptEncodingSet.has(encoding)) {
+          continue;
+        }
+        const precompressedStats = getStats(path + ENCODINGS[encoding]);
+        if (precompressedStats) {
+          c2.header("Content-Encoding", encoding);
+          c2.header("Vary", "Accept-Encoding", { append: true });
+          stats = precompressedStats;
+          path = path + ENCODINGS[encoding];
+          break;
+        }
+      }
+    }
+    const size = stats.size;
+    if (c2.req.method == "HEAD" || c2.req.method == "OPTIONS") {
+      c2.header("Content-Length", size.toString());
+      c2.status(200);
+      return c2.body(null);
+    }
+    const range = c2.req.header("range") || "";
+    if (!range) {
+      c2.header("Content-Length", size.toString());
+      return c2.body(createStreamBody(fs.createReadStream(path)), 200);
+    }
+    c2.header("Accept-Ranges", "bytes");
+    c2.header("Date", stats.birthtime.toUTCString());
+    const parts = range.replace(/bytes=/, "").split("-", 2);
+    const start = parts[0] ? parseInt(parts[0], 10) : 0;
+    let end = parts[1] ? parseInt(parts[1], 10) : stats.size - 1;
+    if (size < end - start + 1) {
+      end = size - 1;
+    }
+    const chunksize = end - start + 1;
+    const stream = fs.createReadStream(path, { start, end });
+    c2.header("Content-Length", chunksize.toString());
+    c2.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
+    return c2.body(createStreamBody(stream), 206);
+  };
+};
+var RENDER_TYPE = {
+  STRING_ARRAY: "string_array",
+  STRING: "string",
+  JSON_STRING: "json_string",
+  RAW: "raw"
+};
+var RENDER_TYPE_MAP = {
+  configUrl: RENDER_TYPE.STRING,
+  deepLinking: RENDER_TYPE.RAW,
+  presets: RENDER_TYPE.STRING_ARRAY,
+  plugins: RENDER_TYPE.STRING_ARRAY,
+  spec: RENDER_TYPE.JSON_STRING,
+  url: RENDER_TYPE.STRING,
+  urls: RENDER_TYPE.JSON_STRING,
+  layout: RENDER_TYPE.STRING,
+  docExpansion: RENDER_TYPE.STRING,
+  maxDisplayedTags: RENDER_TYPE.RAW,
+  operationsSorter: RENDER_TYPE.RAW,
+  requestInterceptor: RENDER_TYPE.RAW,
+  responseInterceptor: RENDER_TYPE.RAW,
+  persistAuthorization: RENDER_TYPE.RAW,
+  defaultModelsExpandDepth: RENDER_TYPE.RAW,
+  defaultModelExpandDepth: RENDER_TYPE.RAW,
+  defaultModelRendering: RENDER_TYPE.STRING,
+  displayRequestDuration: RENDER_TYPE.RAW,
+  filter: RENDER_TYPE.RAW,
+  showExtensions: RENDER_TYPE.RAW,
+  showCommonExtensions: RENDER_TYPE.RAW,
+  queryConfigEnabled: RENDER_TYPE.RAW,
+  displayOperationId: RENDER_TYPE.RAW,
+  tagsSorter: RENDER_TYPE.RAW,
+  onComplete: RENDER_TYPE.RAW,
+  syntaxHighlight: RENDER_TYPE.JSON_STRING,
+  tryItOutEnabled: RENDER_TYPE.RAW,
+  requestSnippetsEnabled: RENDER_TYPE.RAW,
+  requestSnippets: RENDER_TYPE.JSON_STRING,
+  oauth2RedirectUrl: RENDER_TYPE.STRING,
+  showMutabledRequest: RENDER_TYPE.RAW,
+  request: RENDER_TYPE.JSON_STRING,
+  supportedSubmitMethods: RENDER_TYPE.JSON_STRING,
+  validatorUrl: RENDER_TYPE.STRING,
+  withCredentials: RENDER_TYPE.RAW,
+  modelPropertyMacro: RENDER_TYPE.RAW,
+  parameterMacro: RENDER_TYPE.RAW
+};
+var renderSwaggerUIOptions = (options) => {
+  const optionsStrings = Object.entries(options).map(([k, v]) => {
+    const key = k;
+    if (RENDER_TYPE_MAP[key] === RENDER_TYPE.STRING) {
+      return `${key}: '${v}'`;
+    }
+    if (RENDER_TYPE_MAP[key] === RENDER_TYPE.STRING_ARRAY) {
+      if (!Array.isArray(v)) {
+        return "";
+      }
+      return `${key}: [${v.map((ve) => `${ve}`).join(",")}]`;
+    }
+    if (RENDER_TYPE_MAP[key] === RENDER_TYPE.JSON_STRING) {
+      return `${key}: ${JSON.stringify(v)}`;
+    }
+    if (RENDER_TYPE_MAP[key] === RENDER_TYPE.RAW) {
+      return `${key}: ${v}`;
+    }
+    return "";
+  }).join(",");
+  return optionsStrings;
+};
+var remoteAssets = ({ version }) => {
+  const url = `https://cdn.jsdelivr.net/npm/swagger-ui-dist${version !== void 0 ? `@${version}` : ""}`;
+  return {
+    css: [`${url}/swagger-ui.css`],
+    js: [`${url}/swagger-ui-bundle.js`]
+  };
+};
+var SwaggerUI = (options) => {
+  const asset = remoteAssets({ version: options?.version });
+  delete options.version;
+  if (options.manuallySwaggerUIHtml) {
+    return options.manuallySwaggerUIHtml(asset);
+  }
+  const optionsStrings = renderSwaggerUIOptions(options);
+  return `
+    <div>
+      <div id="swagger-ui"></div>
+      ${asset.css.map((url) => html.html`<link rel="stylesheet" href="${url}" />`)}
+      ${asset.js.map((url) => html.html`<script src="${url}" crossorigin="anonymous"></script>`)}
+      <script>
+        window.onload = () => {
+          window.ui = SwaggerUIBundle({
+            dom_id: '#swagger-ui',${optionsStrings},
+          })
+        }
+      </script>
+    </div>
+  `;
+};
+var middleware = (options) => async (c2) => {
+  const title = options?.title ?? "SwaggerUI";
+  return c2.html(
+    /* html */
+    `
+      <html lang="en">
+        <head>
+          <meta charset="utf-8" />
+          <meta name="viewport" content="width=device-width, initial-scale=1" />
+          <meta name="description" content="SwaggerUI" />
+          <title>${title}</title>
+        </head>
+        <body>
+          ${SwaggerUI(options)}
+        </body>
+      </html>
+    `
+  );
+};
+
+// ../../node_modules/.pnpm/hono-openapi@0.4.4_hono@4.7_c963f431f476ec58780e56f6b21cedc5/node_modules/hono-openapi/utils.js
+var e = Symbol("openapi");
+var s2 = ["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"];
+var n = (e2) => e2.charAt(0).toUpperCase() + e2.slice(1);
+var o = (e2, t2) => {
+  let s3 = e2;
+  if ("/" === t2) return `${s3}Index`;
+  for (const e3 of t2.split("/")) 123 === e3.charCodeAt(0) ? s3 += `By${n(e3.slice(1, -1))}` : s3 += n(e3);
+  return s3;
+};
+function a({ path: e2, method: t2, data: s3, schema: n2 }) {
+  e2 = ((e3) => e3.split("/").map((e4) => {
+    let t3 = e4;
+    return t3.startsWith(":") && (t3 = t3.slice(1, t3.length), t3.endsWith("?") && (t3 = t3.slice(0, -1)), t3 = `{${t3}}`), t3;
+  }).join("/"))(e2);
+  const a2 = t2.toLowerCase();
+  n2[e2] = { ...n2[e2] ? n2[e2] : {}, [a2]: { responses: {}, ...n2[e2]?.[a2] ?? {}, operationId: o(a2, e2), ...s3 } };
+}
+function c(e2, { excludeStaticFile: t2 = true, exclude: s3 = [] }) {
+  const n2 = {}, o2 = Array.isArray(s3) ? s3 : [s3];
+  for (const [s4, a2] of Object.entries(e2)) if (!(o2.some((e3) => "string" == typeof e3 ? s4 === e3 : e3.test(s4)) || s4.includes("*") || t2 && s4.includes("."))) {
+    for (const e3 of Object.keys(a2)) {
+      const t3 = a2[e3];
+      if (s4.includes("{")) {
+        t3.parameters || (t3.parameters = []);
+        const e4 = s4.split("/").filter((e5) => e5.startsWith("{") && !t3.parameters.find((t4) => "path" === t4.in && t4.name === e5.slice(1, e5.length - 1)));
+        for (const s5 of e4) {
+          const e5 = s5.slice(1, s5.length - 1), n3 = t3.parameters.findIndex((t4) => "param" === t4.in && t4.name === e5);
+          -1 !== n3 ? t3.parameters[n3].in = "path" : t3.parameters.push({ schema: { type: "string" }, in: "path", name: e5, required: true });
+        }
+      }
+      t3.responses || (t3.responses = { 200: {} });
+    }
+    n2[s4] = a2;
+  }
+  return n2;
+}
+function i(e2, t2) {
+  const s3 = { version: "3.1.0", components: {} };
+  let n2 = null;
+  return async (o2) => (n2 || (n2 = await r(e2, t2, s3, o2)), o2.json(n2));
+}
+async function r(t2, { documentation: n2 = {}, excludeStaticFile: o2 = true, exclude: i2 = [], excludeMethods: r2 = ["OPTIONS"], excludeTags: p2 = [], defaultOptions: l } = { documentation: {}, excludeStaticFile: true, exclude: [], excludeMethods: ["OPTIONS"], excludeTags: [] }, { version: m = "3.1.0", components: d = {} } = { version: "3.1.0", components: {} }, h) {
+  const u = { version: m, components: d }, f = {};
+  for (const n3 of t2.routes) {
+    if (!(e in n3.handler)) continue;
+    if (r2.includes(n3.method)) continue;
+    if (false === s2.includes(n3.method) && "ALL" !== n3.method) continue;
+    const { resolver: t3, metadata: o3 = {} } = n3.handler[e], c2 = l?.[n3.method], { docs: i3, components: p3 } = await t3({ ...u, ...o3 }, c2);
+    if (u.components = { ...u.components, ...p3 ?? {} }, "ALL" === n3.method) for (const e2 of s2) a({ path: n3.path, data: i3, method: e2, schema: f });
+    else a({ method: n3.method, path: n3.path, data: i3, schema: f });
+  }
+  for (const e2 in f) for (const t3 in f[e2]) {
+    const s3 = f[e2][t3]?.hide;
+    s3 && ("boolean" == typeof s3 ? s3 : h && s3(h)) && delete f[e2][t3];
+  }
+  return { openapi: u.version, ...{ ...n2, tags: n2.tags?.filter((e2) => !p2?.includes(e2?.name)), info: { title: "Hono Documentation", description: "Development documentation", version: "0.0.0", ...n2.info }, paths: { ...c(f, { excludeStaticFile: o2, exclude: i2 }), ...n2.paths }, components: { ...n2.components, schemas: { ...u.components, ...n2.components?.schemas } } } };
+}
+function p(s3) {
+  const { validateResponse: n2, ...o2 } = s3;
+  return Object.assign(async (e2, o3) => {
+    if (await o3(), n2 && s3.responses) {
+      const o4 = e2.res.status, a2 = e2.res.headers.get("content-type");
+      if (o4 && a2) {
+        const c2 = s3.responses[o4];
+        if (c2 && "content" in c2 && c2.content) {
+          const s4 = a2.split(";")[0], o5 = c2.content[s4];
+          if (o5?.schema && "validator" in o5.schema) try {
+            let t2;
+            const n3 = e2.res.clone();
+            if ("application/json" === s4 ? t2 = await n3.json() : "text/plain" === s4 && (t2 = await n3.text()), !t2) throw new Error("No data to validate!");
+            await o5.schema.validator(t2);
+          } catch (e3) {
+            let s5 = { status: 500, message: "Response validation failed!" };
+            throw "object" == typeof n2 && (s5 = { ...s5, ...n2 }), new httpException.HTTPException(s5.status, { message: s5.message, cause: e3 });
+          }
+        }
+      }
+    }
+  }, { [e]: { resolver: (e2, t2) => async function(e3, t3, s4 = {}) {
+    let n3 = {};
+    const o3 = { ...s4, ...t3, responses: { ...s4?.responses, ...t3.responses } };
+    for (const t4 of Object.keys(o3.responses)) {
+      const s5 = o3.responses[t4];
+      if (s5 && "content" in s5) for (const t5 of Object.keys(s5.content ?? {})) {
+        const o4 = s5.content?.[t5];
+        if (o4 && (o4.schema && "builder" in o4.schema)) {
+          const t6 = await o4.schema.builder(e3);
+          o4.schema = t6.schema, t6.components && (n3 = { ...n3, ...t6.components });
+        }
+      }
+    }
+    return { docs: o3, components: n3 };
+  }(e2, o2, t2) } });
+}
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/double-indexed-kv.js
+var DoubleIndexedKV = class {
+  constructor() {
+    this.keyToValue = /* @__PURE__ */ new Map();
+    this.valueToKey = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.keyToValue.set(key, value);
+    this.valueToKey.set(value, key);
+  }
+  getByKey(key) {
+    return this.keyToValue.get(key);
+  }
+  getByValue(value) {
+    return this.valueToKey.get(value);
+  }
+  clear() {
+    this.keyToValue.clear();
+    this.valueToKey.clear();
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/registry.js
+var Registry = class {
+  constructor(generateIdentifier) {
+    this.generateIdentifier = generateIdentifier;
+    this.kv = new DoubleIndexedKV();
+  }
+  register(value, identifier) {
+    if (this.kv.getByValue(value)) {
+      return;
+    }
+    if (!identifier) {
+      identifier = this.generateIdentifier(value);
+    }
+    this.kv.set(identifier, value);
+  }
+  clear() {
+    this.kv.clear();
+  }
+  getIdentifier(value) {
+    return this.kv.getByValue(value);
+  }
+  getValue(identifier) {
+    return this.kv.getByKey(identifier);
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/class-registry.js
+var ClassRegistry = class extends Registry {
+  constructor() {
+    super((c2) => c2.name);
+    this.classToAllowedProps = /* @__PURE__ */ new Map();
+  }
+  register(value, options) {
+    if (typeof options === "object") {
+      if (options.allowProps) {
+        this.classToAllowedProps.set(value, options.allowProps);
+      }
+      super.register(value, options.identifier);
+    } else {
+      super.register(value, options);
+    }
+  }
+  getAllowedProps(value) {
+    return this.classToAllowedProps.get(value);
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/util.js
+function valuesOfObj(record) {
+  if ("values" in Object) {
+    return Object.values(record);
+  }
+  const values = [];
+  for (const key in record) {
+    if (record.hasOwnProperty(key)) {
+      values.push(record[key]);
+    }
+  }
+  return values;
+}
+function find(record, predicate) {
+  const values = valuesOfObj(record);
+  if ("find" in values) {
+    return values.find(predicate);
+  }
+  const valuesNotNever = values;
+  for (let i2 = 0; i2 < valuesNotNever.length; i2++) {
+    const value = valuesNotNever[i2];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function forEach(record, run) {
+  Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+  return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+  for (let i2 = 0; i2 < record.length; i2++) {
+    const value = record[i2];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/custom-transformer-registry.js
+var CustomTransformerRegistry = class {
+  constructor() {
+    this.transfomers = {};
+  }
+  register(transformer) {
+    this.transfomers[transformer.name] = transformer;
+  }
+  findApplicable(v) {
+    return find(this.transfomers, (transformer) => transformer.isApplicable(v));
+  }
+  findByName(name) {
+    return this.transfomers[name];
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/is.js
+var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+var isUndefined = (payload) => typeof payload === "undefined";
+var isNull = (payload) => payload === null;
+var isPlainObject = (payload) => {
+  if (typeof payload !== "object" || payload === null)
+    return false;
+  if (payload === Object.prototype)
+    return false;
+  if (Object.getPrototypeOf(payload) === null)
+    return true;
+  return Object.getPrototypeOf(payload) === Object.prototype;
+};
+var isEmptyObject = (payload) => isPlainObject(payload) && Object.keys(payload).length === 0;
+var isArray = (payload) => Array.isArray(payload);
+var isString = (payload) => typeof payload === "string";
+var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
+var isBoolean = (payload) => typeof payload === "boolean";
+var isRegExp = (payload) => payload instanceof RegExp;
+var isMap = (payload) => payload instanceof Map;
+var isSet = (payload) => payload instanceof Set;
+var isSymbol = (payload) => getType(payload) === "Symbol";
+var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+var isError = (payload) => payload instanceof Error;
+var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
+var isPrimitive = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+var isBigint = (payload) => typeof payload === "bigint";
+var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+var isURL = (payload) => payload instanceof URL;
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/pathstringifier.js
+var escapeKey = (key) => key.replace(/\./g, "\\.");
+var stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
+var parsePath = (string) => {
+  const result = [];
+  let segment = "";
+  for (let i2 = 0; i2 < string.length; i2++) {
+    let char = string.charAt(i2);
+    const isEscapedDot = char === "\\" && string.charAt(i2 + 1) === ".";
+    if (isEscapedDot) {
+      segment += ".";
+      i2++;
+      continue;
+    }
+    const isEndOfSegment = char === ".";
+    if (isEndOfSegment) {
+      result.push(segment);
+      segment = "";
+      continue;
+    }
+    segment += char;
+  }
+  const lastSegment = segment;
+  result.push(lastSegment);
+  return result;
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/transformer.js
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var simpleRules = [
+  simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
+  simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
+    if (typeof BigInt !== "undefined") {
+      return BigInt(v);
+    }
+    console.error("Please add a BigInt polyfill.");
+    return v;
+  }),
+  simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
+  simpleTransformation(isError, "Error", (v, superJson) => {
+    const baseError = {
+      name: v.name,
+      message: v.message
+    };
+    superJson.allowedErrorProps.forEach((prop) => {
+      baseError[prop] = v[prop];
+    });
+    return baseError;
+  }, (v, superJson) => {
+    const e2 = new Error(v.message);
+    e2.name = v.name;
+    e2.stack = v.stack;
+    superJson.allowedErrorProps.forEach((prop) => {
+      e2[prop] = v[prop];
+    });
+    return e2;
+  }),
+  simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
+    const body = regex.slice(1, regex.lastIndexOf("/"));
+    const flags = regex.slice(regex.lastIndexOf("/") + 1);
+    return new RegExp(body, flags);
+  }),
+  simpleTransformation(
+    isSet,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    (v) => [...v.values()],
+    (v) => new Set(v)
+  ),
+  simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
+  simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
+    if (isNaNValue(v)) {
+      return "NaN";
+    }
+    if (v > 0) {
+      return "Infinity";
+    } else {
+      return "-Infinity";
+    }
+  }, Number),
+  simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
+    return "-0";
+  }, Number),
+  simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var symbolRule = compositeTransformation((s3, superJson) => {
+  if (isSymbol(s3)) {
+    const isRegistered = !!superJson.symbolRegistry.getIdentifier(s3);
+    return isRegistered;
+  }
+  return false;
+}, (s3, superJson) => {
+  const identifier = superJson.symbolRegistry.getIdentifier(s3);
+  return ["symbol", identifier];
+}, (v) => v.description, (_, a2, superJson) => {
+  const value = superJson.symbolRegistry.getValue(a2[1]);
+  if (!value) {
+    throw new Error("Trying to deserialize unknown symbol");
+  }
+  return value;
+});
+var constructorToName = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce((obj, ctor) => {
+  obj[ctor.name] = ctor;
+  return obj;
+}, {});
+var typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a2) => {
+  const ctor = constructorToName[a2[1]];
+  if (!ctor) {
+    throw new Error("Trying to deserialize unknown typed array");
+  }
+  return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+  if (potentialClass?.constructor) {
+    const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+    return isRegistered;
+  }
+  return false;
+}
+var classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+  const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+  return ["class", identifier];
+}, (clazz, superJson) => {
+  const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+  if (!allowedProps) {
+    return { ...clazz };
+  }
+  const result = {};
+  allowedProps.forEach((prop) => {
+    result[prop] = clazz[prop];
+  });
+  return result;
+}, (v, a2, superJson) => {
+  const clazz = superJson.classRegistry.getValue(a2[1]);
+  if (!clazz) {
+    throw new Error(`Trying to deserialize unknown class '${a2[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+  }
+  return Object.assign(Object.create(clazz.prototype), v);
+});
+var customRule = compositeTransformation((value, superJson) => {
+  return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return ["custom", transformer.name];
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return transformer.serialize(value);
+}, (v, a2, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findByName(a2[1]);
+  if (!transformer) {
+    throw new Error("Trying to deserialize unknown custom value");
+  }
+  return transformer.deserialize(v);
+});
+var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+var transformValue = (value, superJson) => {
+  const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableCompositeRule) {
+    return {
+      value: applicableCompositeRule.transform(value, superJson),
+      type: applicableCompositeRule.annotation(value, superJson)
+    };
+  }
+  const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableSimpleRule) {
+    return {
+      value: applicableSimpleRule.transform(value, superJson),
+      type: applicableSimpleRule.annotation
+    };
+  }
+  return void 0;
+};
+var simpleRulesByAnnotation = {};
+simpleRules.forEach((rule) => {
+  simpleRulesByAnnotation[rule.annotation] = rule;
+});
+var untransformValue = (json, type, superJson) => {
+  if (isArray(type)) {
+    switch (type[0]) {
+      case "symbol":
+        return symbolRule.untransform(json, type, superJson);
+      case "class":
+        return classRule.untransform(json, type, superJson);
+      case "custom":
+        return customRule.untransform(json, type, superJson);
+      case "typed-array":
+        return typedArrayRule.untransform(json, type, superJson);
+      default:
+        throw new Error("Unknown transformation: " + type);
+    }
+  } else {
+    const transformation = simpleRulesByAnnotation[type];
+    if (!transformation) {
+      throw new Error("Unknown transformation: " + type);
+    }
+    return transformation.untransform(json, superJson);
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/accessDeep.js
+var getNthKey = (value, n2) => {
+  if (n2 > value.size)
+    throw new Error("index out of bounds");
+  const keys = value.keys();
+  while (n2 > 0) {
+    keys.next();
+    n2--;
+  }
+  return keys.next().value;
+};
+function validatePath(path) {
+  if (includes(path, "__proto__")) {
+    throw new Error("__proto__ is not allowed as a property");
+  }
+  if (includes(path, "prototype")) {
+    throw new Error("prototype is not allowed as a property");
+  }
+  if (includes(path, "constructor")) {
+    throw new Error("constructor is not allowed as a property");
+  }
+}
+var getDeep = (object, path) => {
+  validatePath(path);
+  for (let i2 = 0; i2 < path.length; i2++) {
+    const key = path[i2];
+    if (isSet(object)) {
+      object = getNthKey(object, +key);
+    } else if (isMap(object)) {
+      const row = +key;
+      const type = +path[++i2] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(object, row);
+      switch (type) {
+        case "key":
+          object = keyOfRow;
+          break;
+        case "value":
+          object = object.get(keyOfRow);
+          break;
+      }
+    } else {
+      object = object[key];
+    }
+  }
+  return object;
+};
+var setDeep = (object, path, mapper) => {
+  validatePath(path);
+  if (path.length === 0) {
+    return mapper(object);
+  }
+  let parent = object;
+  for (let i2 = 0; i2 < path.length - 1; i2++) {
+    const key = path[i2];
+    if (isArray(parent)) {
+      const index = +key;
+      parent = parent[index];
+    } else if (isPlainObject(parent)) {
+      parent = parent[key];
+    } else if (isSet(parent)) {
+      const row = +key;
+      parent = getNthKey(parent, row);
+    } else if (isMap(parent)) {
+      const isEnd = i2 === path.length - 2;
+      if (isEnd) {
+        break;
+      }
+      const row = +key;
+      const type = +path[++i2] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(parent, row);
+      switch (type) {
+        case "key":
+          parent = keyOfRow;
+          break;
+        case "value":
+          parent = parent.get(keyOfRow);
+          break;
+      }
+    }
+  }
+  const lastKey = path[path.length - 1];
+  if (isArray(parent)) {
+    parent[+lastKey] = mapper(parent[+lastKey]);
+  } else if (isPlainObject(parent)) {
+    parent[lastKey] = mapper(parent[lastKey]);
+  }
+  if (isSet(parent)) {
+    const oldValue = getNthKey(parent, +lastKey);
+    const newValue = mapper(oldValue);
+    if (oldValue !== newValue) {
+      parent.delete(oldValue);
+      parent.add(newValue);
+    }
+  }
+  if (isMap(parent)) {
+    const row = +path[path.length - 2];
+    const keyToRow = getNthKey(parent, row);
+    const type = +lastKey === 0 ? "key" : "value";
+    switch (type) {
+      case "key": {
+        const newKey = mapper(keyToRow);
+        parent.set(newKey, parent.get(keyToRow));
+        if (newKey !== keyToRow) {
+          parent.delete(keyToRow);
+        }
+        break;
+      }
+      case "value": {
+        parent.set(keyToRow, mapper(parent.get(keyToRow)));
+        break;
+      }
+    }
+  }
+  return object;
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/plainer.js
+function traverse(tree, walker2, origin = []) {
+  if (!tree) {
+    return;
+  }
+  if (!isArray(tree)) {
+    forEach(tree, (subtree, key) => traverse(subtree, walker2, [...origin, ...parsePath(key)]));
+    return;
+  }
+  const [nodeValue, children] = tree;
+  if (children) {
+    forEach(children, (child, key) => {
+      traverse(child, walker2, [...origin, ...parsePath(key)]);
+    });
+  }
+  walker2(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, superJson) {
+  traverse(annotations, (type, path) => {
+    plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
+  });
+  return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations) {
+  function apply(identicalPaths, path) {
+    const object = getDeep(plain, parsePath(path));
+    identicalPaths.map(parsePath).forEach((identicalObjectPath) => {
+      plain = setDeep(plain, identicalObjectPath, () => object);
+    });
+  }
+  if (isArray(annotations)) {
+    const [root, other] = annotations;
+    root.forEach((identicalPath) => {
+      plain = setDeep(plain, parsePath(identicalPath), () => plain);
+    });
+    if (other) {
+      forEach(other, apply);
+    }
+  } else {
+    forEach(annotations, apply);
+  }
+  return plain;
+}
+var isDeep = (object, superJson) => isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path, identities) {
+  const existingSet = identities.get(object);
+  if (existingSet) {
+    existingSet.push(path);
+  } else {
+    identities.set(object, [path]);
+  }
+}
+function generateReferentialEqualityAnnotations(identitites, dedupe) {
+  const result = {};
+  let rootEqualityPaths = void 0;
+  identitites.forEach((paths) => {
+    if (paths.length <= 1) {
+      return;
+    }
+    if (!dedupe) {
+      paths = paths.map((path) => path.map(String)).sort((a2, b) => a2.length - b.length);
+    }
+    const [representativePath, ...identicalPaths] = paths;
+    if (representativePath.length === 0) {
+      rootEqualityPaths = identicalPaths.map(stringifyPath);
+    } else {
+      result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+    }
+  });
+  if (rootEqualityPaths) {
+    if (isEmptyObject(result)) {
+      return [rootEqualityPaths];
+    } else {
+      return [rootEqualityPaths, result];
+    }
+  } else {
+    return isEmptyObject(result) ? void 0 : result;
+  }
+}
+var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+  const primitive = isPrimitive(object);
+  if (!primitive) {
+    addIdentity(object, path, identities);
+    const seen = seenObjects.get(object);
+    if (seen) {
+      return dedupe ? {
+        transformedValue: null
+      } : seen;
+    }
+  }
+  if (!isDeep(object, superJson)) {
+    const transformed2 = transformValue(object, superJson);
+    const result2 = transformed2 ? {
+      transformedValue: transformed2.value,
+      annotations: [transformed2.type]
+    } : {
+      transformedValue: object
+    };
+    if (!primitive) {
+      seenObjects.set(object, result2);
+    }
+    return result2;
+  }
+  if (includes(objectsInThisPath, object)) {
+    return {
+      transformedValue: null
+    };
+  }
+  const transformationResult = transformValue(object, superJson);
+  const transformed = transformationResult?.value ?? object;
+  const transformedValue = isArray(transformed) ? [] : {};
+  const innerAnnotations = {};
+  forEach(transformed, (value, index) => {
+    if (index === "__proto__" || index === "constructor" || index === "prototype") {
+      throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
+    }
+    const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
+    transformedValue[index] = recursiveResult.transformedValue;
+    if (isArray(recursiveResult.annotations)) {
+      innerAnnotations[index] = recursiveResult.annotations;
+    } else if (isPlainObject(recursiveResult.annotations)) {
+      forEach(recursiveResult.annotations, (tree, key) => {
+        innerAnnotations[escapeKey(index) + "." + key] = tree;
+      });
+    }
+  });
+  const result = isEmptyObject(innerAnnotations) ? {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type] : void 0
+  } : {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+  };
+  if (!primitive) {
+    seenObjects.set(object, result);
+  }
+  return result;
+};
+
+// ../../node_modules/.pnpm/is-what@4.1.16/node_modules/is-what/dist/index.js
+function getType2(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+}
+function isArray2(payload) {
+  return getType2(payload) === "Array";
+}
+function isPlainObject2(payload) {
+  if (getType2(payload) !== "Object")
+    return false;
+  const prototype = Object.getPrototypeOf(payload);
+  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+
+// ../../node_modules/.pnpm/copy-anything@3.0.5/node_modules/copy-anything/dist/index.js
+function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
+  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+  if (propType === "enumerable")
+    carry[key] = newVal;
+  if (includeNonenumerable && propType === "nonenumerable") {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+function copy(target, options = {}) {
+  if (isArray2(target)) {
+    return target.map((item) => copy(item, options));
+  }
+  if (!isPlainObject2(target)) {
+    return target;
+  }
+  const props = Object.getOwnPropertyNames(target);
+  const symbols = Object.getOwnPropertySymbols(target);
+  return [...props, ...symbols].reduce((carry, key) => {
+    if (isArray2(options.props) && !options.props.includes(key)) {
+      return carry;
+    }
+    const val = target[key];
+    const newVal = copy(val, options);
+    assignProp(carry, key, newVal, target, options.nonenumerable);
+    return carry;
+  }, {});
+}
+
+// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/index.js
+var SuperJSON = class {
+  /**
+   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  constructor({ dedupe = false } = {}) {
+    this.classRegistry = new ClassRegistry();
+    this.symbolRegistry = new Registry((s3) => s3.description ?? "");
+    this.customTransformerRegistry = new CustomTransformerRegistry();
+    this.allowedErrorProps = [];
+    this.dedupe = dedupe;
+  }
+  serialize(object) {
+    const identities = /* @__PURE__ */ new Map();
+    const output = walker(object, identities, this, this.dedupe);
+    const res = {
+      json: output.transformedValue
+    };
+    if (output.annotations) {
+      res.meta = {
+        ...res.meta,
+        values: output.annotations
+      };
+    }
+    const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+    if (equalityAnnotations) {
+      res.meta = {
+        ...res.meta,
+        referentialEqualities: equalityAnnotations
+      };
+    }
+    return res;
+  }
+  deserialize(payload) {
+    const { json, meta } = payload;
+    let result = copy(json);
+    if (meta?.values) {
+      result = applyValueAnnotations(result, meta.values, this);
+    }
+    if (meta?.referentialEqualities) {
+      result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
+    }
+    return result;
+  }
+  stringify(object) {
+    return JSON.stringify(this.serialize(object));
+  }
+  parse(string) {
+    return this.deserialize(JSON.parse(string));
+  }
+  registerClass(v, options) {
+    this.classRegistry.register(v, options);
+  }
+  registerSymbol(v, identifier) {
+    this.symbolRegistry.register(v, identifier);
+  }
+  registerCustom(transformer, name) {
+    this.customTransformerRegistry.register({
+      name,
+      ...transformer
+    });
+  }
+  allowErrorProps(...props) {
+    this.allowedErrorProps.push(...props);
+  }
+};
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+var stringify = SuperJSON.stringify;
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/Options.js
+var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+var defaultOptions = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  definitionPath: "definitions",
+  target: "jsonSchema7",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+  ...defaultOptions,
+  name: options
+} : {
+  ...defaultOptions,
+  ...options
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/Refs.js
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+      def._def,
+      {
+        def: def._def,
+        path: [..._options.basePath, _options.definitionPath, name],
+        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+        jsonSchema: void 0
+      }
+    ]))
+  };
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/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);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+function parseAnyDef() {
+  return {};
+}
+function parseArrayDef(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== zod.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;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/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;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+function parseBooleanDef() {
+  return {
+    type: "boolean"
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+var parseCatchDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/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, i2) => 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);
+  }
+}
+var integerDateParser = (def, refs) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  if (refs.target === "openApi3") {
+    return res;
+  }
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        setResponseValueAndErrors(
+          res,
+          "minimum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+      case "max":
+        setResponseValueAndErrors(
+          res,
+          "maximum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+    }
+  }
+  return res;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : {};
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+var isJsonSchema7AllOfType = (type) => {
+  if ("type" in type && type.type === "string")
+    return false;
+  return "allOf" in type;
+};
+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;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/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
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+var emojiRegex = void 0;
+var zodPatterns = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex === void 0) {
+      emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+    }
+    return emojiRegex;
+  },
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function 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);
+        }
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i2 = 0; i2 < source.length; i2++) {
+    if (!ALPHA_NUMERIC.has(source[i2])) {
+      result += "\\";
+    }
+    result += source[i2];
+  }
+  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")
+    // `.` matches newlines
+  };
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = "";
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+  for (let i2 = 0; i2 < source.length; i2++) {
+    if (isEscaped) {
+      pattern += source[i2];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i2].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i2];
+            pattern += `${source[i2 - 2]}-${source[i2]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i2 + 1] === "-" && source[i2 + 2]?.match(/[a-z]/)) {
+            pattern += source[i2];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i2]}${source[i2].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i2].match(/[a-z]/)) {
+        pattern += `[${source[i2]}${source[i2].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i2] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i2] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i2] === ".") {
+      pattern += inCharGroup ? `${source[i2]}\r
+` : `[${source[i2]}\r
+]`;
+      continue;
+    }
+    pattern += source[i2];
+    if (source[i2] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i2] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i2] === "[") {
+      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;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/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 === zod.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]
+        }) ?? {}
+      }), {}),
+      additionalProperties: false
+    };
+  }
+  const schema = {
+    type: "object",
+    additionalProperties: parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? {}
+  };
+  if (refs.target === "openApi3") {
+    return schema;
+  }
+  if (def.keyType?._def.typeName === zod.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 === zod.ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === zod.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef(def, refs);
+  }
+  const keys = parseDef(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || {};
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || {};
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+function parseNativeEnumDef(def) {
+  const object = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object[object[key]] !== "number";
+  });
+  const actualValues = actualKeys.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
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+function parseNeverDef() {
+  return {
+    not: {}
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+function parseNullDef(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+var primitiveMappings = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+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((types2, x) => {
+      const type = primitiveMappings[x._def.typeName];
+      return type && !types2.includes(type) ? [...types2, type] : types2;
+    }, []);
+    return {
+      type: types.length > 1 ? types : types[0]
+    };
+  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types = options.reduce((acc, x) => {
+      const type = typeof x._def.value;
+      switch (type) {
+        case "string":
+        case "number":
+        case "boolean":
+          return [...acc, type];
+        case "bigint":
+          return [...acc, "integer"];
+        case "object":
+          if (x._def.value === null)
+            return [...acc, "null"];
+        case "symbol":
+        case "undefined":
+        case "function":
+        default:
+          return acc;
+      }
+    }, []);
+    if (types.length === options.length) {
+      const uniqueTypes = types.filter((x, i2, a2) => a2.indexOf(x) === i2);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce((acc, x) => {
+          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+        }, [])
+      };
+    }
+  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+    return {
+      type: "string",
+      enum: options.reduce((acc, x) => [
+        ...acc,
+        ...x._def.values.filter((x2) => !acc.includes(x2))
+      ], [])
+    };
+  }
+  return asAnyOf(def, refs);
+}
+var asAnyOf = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i2) => parseDef(x._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", `${i2}`]
+  })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
+  return anyOf.length ? { anyOf } : void 0;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/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 base2 = parseDef(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath]
+    });
+    if (base2 && "$ref" in base2)
+      return { allOf: [base2], nullable: true };
+    return base2 && { ...base2, nullable: true };
+  }
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/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;
+}
+function decideAdditionalProperties(def, refs) {
+  if (refs.removeAdditionalStrategy === "strict") {
+    return def.catchall._def.typeName === "ZodNever" ? def.unknownKeys !== "strict" : parseDef(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? true;
+  } else {
+    return def.catchall._def.typeName === "ZodNever" ? def.unknownKeys === "passthrough" : parseDef(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? true;
+  }
+}
+function parseObjectDef(def, refs) {
+  const forceOptionalIntoNullable = refs.target === "openAi";
+  const result = {
+    type: "object",
+    ...Object.entries(def.shape()).reduce((acc, [propName, propDef]) => {
+      if (propDef === void 0 || propDef._def === void 0)
+        return acc;
+      let propOptional = propDef.isOptional();
+      if (propOptional && forceOptionalIntoNullable) {
+        if (propDef instanceof zod.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)
+        return acc;
+      return {
+        properties: { ...acc.properties, [propName]: parsedDef },
+        required: propOptional ? acc.required : [...acc.required, propName]
+      };
+    }, { properties: {}, required: [] }),
+    additionalProperties: decideAdditionalProperties(def, refs)
+  };
+  if (!result.required.length)
+    delete result.required;
+  return result;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+var parseOptionalDef = (def, refs) => {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+    return parseDef(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? {
+    anyOf: [
+      {
+        not: {}
+      },
+      innerSchema
+    ]
+  } : {};
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+var parsePipelineDef = (def, refs) => {
+  if (refs.pipeStrategy === "input") {
+    return parseDef(def.in._def, refs);
+  } else if (refs.pipeStrategy === "output") {
+    return parseDef(def.out._def, refs);
+  }
+  const a2 = parseDef(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  });
+  const b = parseDef(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", a2 ? "1" : "0"]
+  });
+  return {
+    allOf: [a2, b].filter((x) => x !== void 0)
+  };
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+function parseSetDef(def, refs) {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    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;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/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, i2) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i2}`]
+      })).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, i2) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i2}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+    };
+  }
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+function parseUndefinedDef() {
+  return {
+    not: {}
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+function parseUnknownDef() {
+  return {};
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+var parseReadonlyDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/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 jsonSchema = selectParser(def, def.typeName, refs);
+  if (jsonSchema) {
+    addMeta(def, refs, jsonSchema);
+  }
+  newItem.jsonSchema = jsonSchema;
+  return jsonSchema;
+}
+var get$ref = (item, refs) => {
+  switch (refs.$refStrategy) {
+    case "root":
+      return { $ref: item.path.join("/") };
+    case "relative":
+      return { $ref: getRelativePath(refs.currentPath, item.path) };
+    case "none":
+    case "seen": {
+      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+        return {};
+      }
+      return refs.$refStrategy === "seen" ? {} : void 0;
+    }
+  }
+};
+var getRelativePath = (pathA, pathB) => {
+  let i2 = 0;
+  for (; i2 < pathA.length && i2 < pathB.length; i2++) {
+    if (pathA[i2] !== pathB[i2])
+      break;
+  }
+  return [(pathA.length - i2).toString(), ...pathB.slice(i2)].join("/");
+};
+var selectParser = (def, typeName, refs) => {
+  switch (typeName) {
+    case zod.ZodFirstPartyTypeKind.ZodString:
+      return parseStringDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodNumber:
+      return parseNumberDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodObject:
+      return parseObjectDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodBigInt:
+      return parseBigintDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodBoolean:
+      return parseBooleanDef();
+    case zod.ZodFirstPartyTypeKind.ZodDate:
+      return parseDateDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodUndefined:
+      return parseUndefinedDef();
+    case zod.ZodFirstPartyTypeKind.ZodNull:
+      return parseNullDef(refs);
+    case zod.ZodFirstPartyTypeKind.ZodArray:
+      return parseArrayDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodUnion:
+    case zod.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodTuple:
+      return parseTupleDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodRecord:
+      return parseRecordDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodLiteral:
+      return parseLiteralDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodEnum:
+      return parseEnumDef(def);
+    case zod.ZodFirstPartyTypeKind.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case zod.ZodFirstPartyTypeKind.ZodNullable:
+      return parseNullableDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodMap:
+      return parseMapDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodSet:
+      return parseSetDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodLazy:
+      return parseDef(def.getter()._def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodNaN:
+    case zod.ZodFirstPartyTypeKind.ZodNever:
+      return parseNeverDef();
+    case zod.ZodFirstPartyTypeKind.ZodEffects:
+      return parseEffectsDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodAny:
+      return parseAnyDef();
+    case zod.ZodFirstPartyTypeKind.ZodUnknown:
+      return parseUnknownDef();
+    case zod.ZodFirstPartyTypeKind.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodCatch:
+      return parseCatchDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodFunction:
+    case zod.ZodFirstPartyTypeKind.ZodVoid:
+    case zod.ZodFirstPartyTypeKind.ZodSymbol:
+      return void 0;
+    default:
+      return /* @__PURE__ */ ((_) => void 0)();
+  }
+};
+var addMeta = (def, refs, jsonSchema) => {
+  if (def.description) {
+    jsonSchema.description = def.description;
+    if (refs.markdownDescription) {
+      jsonSchema.markdownDescription = def.description;
+    }
+  }
+  return jsonSchema;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+var zodToJsonSchema = (schema, options) => {
+  const refs = getRefs(options);
+  const definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
+    ...acc,
+    [name2]: parseDef(schema2._def, {
+      ...refs,
+      currentPath: [...refs.basePath, refs.definitionPath, name2]
+    }, true) ?? {}
+  }), {}) : void 0;
+  const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
+  const main = parseDef(schema._def, name === void 0 ? refs : {
+    ...refs,
+    currentPath: [...refs.basePath, refs.definitionPath, name]
+  }, false) ?? {};
+  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+  if (title !== void 0) {
+    main.title = title;
+  }
+  const combined = name === void 0 ? definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name
+    ].join("/"),
+    [refs.definitionPath]: {
+      ...definitions,
+      [name]: main
+    }
+  };
+  if (refs.target === "jsonSchema7") {
+    combined.$schema = "http://json-schema.org/draft-07/schema#";
+  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+  }
+  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
+    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+  }
+  return combined;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.1_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/index.js
+var esm_default = zodToJsonSchema;
+function handleError(error, defaultMessage) {
+  console.error(defaultMessage, error);
+  const apiError = error;
+  throw new httpException.HTTPException(apiError.status || 500, {
+    message: apiError.message || defaultMessage
+  });
+}
+function errorHandler(err, c2) {
+  if (err instanceof httpException.HTTPException) {
+    return c2.json({ error: err.message }, err.status);
+  }
+  console.error(err);
+  return c2.json({ error: "Internal Server Error" }, 500);
+}
+function validateBody(body) {
+  const errorResponse = Object.entries(body).reduce((acc, [key, value]) => {
+    if (!value) {
+      acc[key] = `${key} is required`;
+    }
+    return acc;
+  }, {});
+  if (Object.keys(errorResponse).length > 0) {
+    throw new httpException.HTTPException(400, { message: JSON.stringify(errorResponse) });
+  }
+}
+
+// src/server/handlers/agents.ts
+async function getAgentsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agents = mastra.getAgents();
+    const serializedAgents = Object.entries(agents).reduce((acc, [_id, _agent]) => {
+      const agent = _agent;
+      const serializedAgentTools = Object.entries(agent?.tools || {}).reduce((acc2, [key, tool]) => {
+        const _tool = tool;
+        acc2[key] = {
+          ..._tool,
+          inputSchema: _tool.inputSchema ? stringify(esm_default(_tool.inputSchema)) : void 0,
+          outputSchema: _tool.outputSchema ? stringify(esm_default(_tool.outputSchema)) : void 0
+        };
+        return acc2;
+      }, {});
+      acc[_id] = {
+        name: agent.name,
+        instructions: agent.instructions,
+        tools: serializedAgentTools,
+        provider: agent.llm?.getProvider(),
+        modelId: agent.llm?.getModelId()
+      };
+      return acc;
+    }, {});
+    return c2.json(serializedAgents);
+  } catch (error) {
+    return handleError(error, "Error getting agents");
+  }
+}
+async function getAgentByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new httpException.HTTPException(404, { message: "Agent not found" });
+    }
+    const serializedAgentTools = Object.entries(agent?.tools || {}).reduce((acc, [key, tool]) => {
+      const _tool = tool;
+      acc[key] = {
+        ..._tool,
+        inputSchema: _tool.inputSchema ? stringify(esm_default(_tool.inputSchema)) : void 0,
+        outputSchema: _tool.outputSchema ? stringify(esm_default(_tool.outputSchema)) : void 0
+      };
+      return acc;
+    }, {});
+    return c2.json({
+      name: agent.name,
+      instructions: agent.instructions,
+      tools: serializedAgentTools,
+      provider: agent.llm?.getProvider(),
+      modelId: agent.llm?.getModelId()
+    });
+  } catch (error) {
+    return handleError(error, "Error getting agent");
+  }
+}
+async function getEvalsByAgentIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.storage?.getEvalsByAgentName?.(agent.name, "test") || [];
+    return c2.json({
+      id: agentId,
+      name: agent.name,
+      instructions: agent.instructions,
+      evals
+    });
+  } catch (error) {
+    return handleError(error, "Error getting test evals");
+  }
+}
+async function getLiveEvalsByAgentIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.storage?.getEvalsByAgentName?.(agent.name, "live") || [];
+    return c2.json({
+      id: agentId,
+      name: agent.name,
+      instructions: agent.instructions,
+      evals
+    });
+  } catch (error) {
+    return handleError(error, "Error getting live evals");
+  }
+}
+async function generateHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new httpException.HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, threadId, resourceid, resourceId, output, runId } = await c2.req.json();
+    validateBody({ messages });
+    if (!Array.isArray(messages)) {
+      throw new httpException.HTTPException(400, { message: "Messages should be an array" });
+    }
+    const finalResourceId = resourceId ?? resourceid;
+    const result = await agent.generate(messages, { threadId, resourceId: finalResourceId, output, runId });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error generating from agent");
+  }
+}
+async function streamGenerateHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new httpException.HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, threadId, resourceid, resourceId, output, runId } = await c2.req.json();
+    validateBody({ messages });
+    if (!Array.isArray(messages)) {
+      throw new httpException.HTTPException(400, { message: "Messages should be an array" });
+    }
+    const finalResourceId = resourceId ?? resourceid;
+    const streamResult = await agent.stream(messages, { threadId, resourceId: finalResourceId, output, runId });
+    const streamResponse = output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
+      sendUsage: true,
+      sendReasoning: true,
+      getErrorMessage: (error) => {
+        return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
+      }
+    });
+    return streamResponse;
+  } catch (error) {
+    return handleError(error, "Error streaming from agent");
+  }
+}
+async function setAgentInstructionsHandler(c2) {
+  try {
+    const isPlayground = c2.get("playground") === true;
+    if (!isPlayground) {
+      return c2.json({ error: "This API is only available in the playground environment" }, 403);
+    }
+    const agentId = c2.req.param("agentId");
+    const { instructions } = await c2.req.json();
+    if (!agentId || !instructions) {
+      return c2.json({ error: "Missing required fields" }, 400);
+    }
+    const mastra = c2.get("mastra");
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      return c2.json({ error: "Agent not found" }, 404);
+    }
+    agent.__updateInstructions(instructions);
+    return c2.json(
+      {
+        instructions
+      },
+      200
+    );
+  } catch (error) {
+    return handleError(error, "Error setting agent instructions");
+  }
+}
+
+// src/server/handlers/client.ts
+var clients = /* @__PURE__ */ new Set();
+function handleClientsRefresh(c2) {
+  const stream = new ReadableStream({
+    start(controller) {
+      clients.add(controller);
+      controller.enqueue("data: connected\n\n");
+      c2.req.raw.signal.addEventListener("abort", () => {
+        clients.delete(controller);
+      });
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+function handleTriggerClientsRefresh(c2) {
+  clients.forEach((controller) => {
+    try {
+      controller.enqueue("data: refresh\n\n");
+    } catch {
+      clients.delete(controller);
+    }
+  });
+  return c2.json({ success: true, clients: clients.size });
+}
+async function getLogsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const transportId = c2.req.query("transportId");
+    if (!transportId) {
+      throw new httpException.HTTPException(400, { message: "transportId is required" });
+    }
+    const logs = await mastra.getLogs(transportId);
+    return c2.json(logs);
+  } catch (error) {
+    return handleError(error, "Error getting logs");
+  }
+}
+async function getLogsByRunIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runId = c2.req.param("runId");
+    const transportId = c2.req.query("transportId");
+    if (!transportId) {
+      throw new httpException.HTTPException(400, { message: "transportId is required" });
+    }
+    const logs = await mastra.getLogsByRunId({ runId, transportId });
+    return c2.json(logs);
+  } catch (error) {
+    return handleError(error, "Error getting logs by run ID");
+  }
+}
+async function getLogTransports(c2) {
+  console.log("here");
+  try {
+    const mastra = c2.get("mastra");
+    const logger2 = mastra.getLogger();
+    const transports = logger2.transports;
+    return c2.json({
+      transports: Object.keys(transports)
+    });
+  } catch (e2) {
+    return handleError(e2, "Error getting log Transports ");
+  }
+}
+function getMemoryFromContext(c2) {
+  const mastra = c2.get("mastra");
+  const agentId = c2.req.query("agentId");
+  const agent = agentId ? mastra.getAgent(agentId) : null;
+  if (agentId && !agent) {
+    throw new httpException.HTTPException(404, { message: "Agent not found" });
+  }
+  const memory = agent?.getMemory?.() || mastra.memory;
+  return memory;
+}
+async function getMemoryStatusHandler(c2) {
+  try {
+    const memory = getMemoryFromContext(c2);
+    if (!memory) {
+      return c2.json({ result: false });
+    }
+    return c2.json({ result: true });
+  } catch (error) {
+    return handleError(error, "Error getting memory status");
+  }
+}
+async function getThreadsHandler(c2) {
+  try {
+    const { resourceid } = c2.req.query();
+    const memory = getMemoryFromContext(c2);
+    if (!memory) {
+      throw new httpException.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    if (!resourceid) {
+      throw new httpException.HTTPException(400, { message: "Resource ID is required" });
+    }
+    const threads = await memory.getThreadsByResourceId({ resourceId: resourceid });
+    return c2.json(threads);
+  } catch (error) {
+    return handleError(error, "Error getting threads");
+  }
+}
+async function getThreadByIdHandler(c2) {
+  try {
+    const memory = getMemoryFromContext(c2);
+    const threadId = c2.req.param("threadId");
+    if (!memory) {
+      throw new httpException.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new httpException.HTTPException(404, { message: "Thread not found" });
+    }
+    return c2.json(thread);
+  } catch (error) {
+    return handleError(error, "Error getting thread");
+  }
+}
+async function saveMessagesHandler(c2) {
+  try {
+    const memory = getMemoryFromContext(c2);
+    const { messages } = await c2.req.json();
+    if (!memory) {
+      throw new httpException.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    validateBody({ messages });
+    if (!Array.isArray(messages)) {
+      throw new httpException.HTTPException(400, { message: "Messages should be an array" });
+    }
+    const processedMessages = messages.map((message) => ({
+      ...message,
+      id: memory.generateId(),
+      createdAt: message.createdAt ? new Date(message.createdAt) : /* @__PURE__ */ new Date()
+    }));
+    const result = await memory.saveMessages({ messages: processedMessages, memoryConfig: {} });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error saving messages");
+  }
+}
+async function createThreadHandler(c2) {
+  try {
+    const memory = getMemoryFromContext(c2);
+    const { title, metadata, resourceid, threadId } = await c2.req.json();
+    if (!memory) {
+      throw new httpException.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    validateBody({ resourceid });
+    const result = await memory.createThread({ resourceId: resourceid, title, metadata, threadId });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error saving thread to memory");
+  }
+}
+async function updateThreadHandler(c2) {
+  try {
+    const memory = getMemoryFromContext(c2);
+    const threadId = c2.req.param("threadId");
+    const { title, metadata, resourceid } = await c2.req.json();
+    const updatedAt = /* @__PURE__ */ new Date();
+    if (!memory) {
+      throw new httpException.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new httpException.HTTPException(404, { message: "Thread not found" });
+    }
+    const updatedThread = {
+      ...thread,
+      title: title || thread.title,
+      metadata: metadata || thread.metadata,
+      resourceId: resourceid || thread.resourceId,
+      createdAt: thread.createdAt,
+      updatedAt
+    };
+    const result = await memory.saveThread({ thread: updatedThread });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error updating thread");
+  }
+}
+async function deleteThreadHandler(c2) {
+  try {
+    const memory = getMemoryFromContext(c2);
+    const threadId = c2.req.param("threadId");
+    if (!memory) {
+      throw new httpException.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new httpException.HTTPException(404, { message: "Thread not found" });
+    }
+    await memory.deleteThread(threadId);
+    return c2.json({ result: "Thread deleted" });
+  } catch (error) {
+    return handleError(error, "Error deleting thread");
+  }
+}
+async function getMessagesHandler(c2) {
+  try {
+    const memory = getMemoryFromContext(c2);
+    const threadId = c2.req.param("threadId");
+    if (!memory) {
+      return c2.json({ error: "Memory is not initialized" }, 400);
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      return c2.json({ error: "Thread not found" }, 404);
+    }
+    const result = await memory.query({ threadId });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting messages");
+  }
+}
+async function generateSystemPromptHandler(c2) {
+  try {
+    const agentId = c2.req.param("agentId");
+    const isPlayground = c2.get("playground") === true;
+    if (!isPlayground) {
+      return c2.json({ error: "This API is only available in the playground environment" }, 403);
+    }
+    const { instructions, comment } = await c2.req.json();
+    if (!instructions) {
+      return c2.json({ error: "Missing instructions in request body" }, 400);
+    }
+    const mastra = c2.get("mastra");
+    const agent$1 = mastra.getAgent(agentId);
+    if (!agent$1) {
+      return c2.json({ error: "Agent not found" }, 404);
+    }
+    let evalSummary = "";
+    try {
+      const testEvals = await mastra.storage?.getEvalsByAgentName?.(agent$1.name, "test") || [];
+      const liveEvals = await mastra.storage?.getEvalsByAgentName?.(agent$1.name, "live") || [];
+      const evalsMapped = [...testEvals, ...liveEvals].filter(
+        ({ instructions: evalInstructions }) => evalInstructions === instructions
+      );
+      evalSummary = evalsMapped.map(
+        ({ input, output, result: result2 }) => `
+          Input: ${input}
+
+          Output: ${output}
+
+          Result: ${JSON.stringify(result2)}
+
+        `
+      ).join("");
+    } catch (error) {
+      mastra.getLogger().error(`Error fetching evals`, { error });
+    }
+    const ENHANCE_SYSTEM_PROMPT_INSTRUCTIONS = `
+            You are an expert system prompt engineer, specialized in analyzing and enhancing instructions to create clear, effective, and comprehensive system prompts. Your goal is to help users transform their basic instructions into well-structured system prompts that will guide AI behavior effectively.
+            Follow these steps to analyze and enhance the instructions:
+            1. ANALYSIS PHASE
+            - Identify the core purpose and goals
+            - Extract key constraints and requirements
+            - Recognize domain-specific terminology and concepts
+            - Note any implicit assumptions that should be made explicit
+            2. PROMPT STRUCTURE
+            Create a system prompt with these components:
+            a) ROLE DEFINITION
+                - Clear statement of the AI's role and purpose
+                - Key responsibilities and scope
+                - Primary stakeholders and users
+            b) CORE CAPABILITIES
+                - Main functions and abilities
+                - Specific domain knowledge required
+                - Tools and resources available
+            c) BEHAVIORAL GUIDELINES
+                - Communication style and tone
+                - Decision-making framework
+                - Error handling approach
+                - Ethical considerations
+            d) CONSTRAINTS & BOUNDARIES
+                - Explicit limitations
+                - Out-of-scope activities
+                - Security and privacy considerations
+            e) SUCCESS CRITERIA
+                - Quality standards
+                - Expected outcomes
+                - Performance metrics
+            3. QUALITY CHECKS
+            Ensure the prompt is:
+            - Clear and unambiguous
+            - Comprehensive yet concise
+            - Properly scoped
+            - Technically accurate
+            - Ethically sound
+            4. OUTPUT FORMAT
+            Return a structured response with:
+            - Enhanced system prompt
+            - Analysis of key components
+            - Identified goals and constraints
+            - Core domain concepts
+            Remember: A good system prompt should be specific enough to guide behavior but flexible enough to handle edge cases. 
+            Focus on creating prompts that are clear, actionable, and aligned with the intended use case.
+        `;
+    const systemPromptAgent = new agent.Agent({
+      name: "system-prompt-enhancer",
+      instructions: ENHANCE_SYSTEM_PROMPT_INSTRUCTIONS,
+      model: agent$1.llm?.getModel()
+    });
+    const result = await systemPromptAgent.generate(
+      `
+            We need to improve the system prompt. 
+            Current: ${instructions}
+            ${comment ? `User feedback: ${comment}` : ""}
+            ${evalSummary ? `
+Evaluation Results:
+${evalSummary}` : ""}
+        `,
+      {
+        output: zod.z.object({
+          new_prompt: zod.z.string(),
+          explanation: zod.z.string()
+        })
+      }
+    );
+    return c2.json(result?.object || {});
+  } catch (error) {
+    return handleError(error, "Error generating system prompt");
+  }
+}
+
+// src/server/handlers/root.ts
+async function rootHandler(c2) {
+  return c2.text("Hello to the Mastra API!");
+}
+async function getTelemetryHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const telemetry = mastra.telemetry;
+    const storage = mastra.storage;
+    const { name, scope, page, perPage } = c2.req.query();
+    const attribute = c2.req.queries("attribute");
+    if (!telemetry) {
+      throw new httpException.HTTPException(400, { message: "Telemetry is not initialized" });
+    }
+    if (!storage) {
+      throw new httpException.HTTPException(400, { message: "Storage is not initialized" });
+    }
+    const attributes = attribute ? Object.fromEntries(
+      (Array.isArray(attribute) ? attribute : [attribute]).map((attr) => {
+        const [key, value] = attr.split(":");
+        return [key, value];
+      })
+    ) : void 0;
+    const traces = await storage.getTraces({
+      name,
+      scope,
+      page: Number(page ?? 0),
+      perPage: Number(perPage ?? 100),
+      attributes
+    });
+    return c2.json({ traces });
+  } catch (error) {
+    return handleError(error, "Error saving messages");
+  }
+}
+async function getToolsHandler(c2) {
+  try {
+    const tools = c2.get("tools");
+    if (!tools) {
+      return c2.json({});
+    }
+    const serializedTools = Object.entries(tools).reduce(
+      (acc, [id, _tool]) => {
+        const tool = _tool;
+        acc[id] = {
+          ...tool,
+          inputSchema: tool.inputSchema ? stringify(esm_default(tool.inputSchema)) : void 0,
+          outputSchema: tool.outputSchema ? stringify(esm_default(tool.outputSchema)) : void 0
+        };
+        return acc;
+      },
+      {}
+    );
+    return c2.json(serializedTools);
+  } catch (error) {
+    return handleError(error, "Error getting tools");
+  }
+}
+async function getToolByIdHandler(c2) {
+  try {
+    const tools = c2.get("tools");
+    const toolId = c2.req.param("toolId");
+    const tool = Object.values(tools || {}).find((tool2) => tool2.id === toolId);
+    if (!tool) {
+      throw new httpException.HTTPException(404, { message: "Tool not found" });
+    }
+    const serializedTool = {
+      ...tool,
+      inputSchema: tool.inputSchema ? stringify(esm_default(tool.inputSchema)) : void 0,
+      outputSchema: tool.outputSchema ? stringify(esm_default(tool.outputSchema)) : void 0
+    };
+    return c2.json(serializedTool);
+  } catch (error) {
+    return handleError(error, "Error getting tool");
+  }
+}
+function executeToolHandler(tools) {
+  return async (c2) => {
+    try {
+      const toolId = decodeURIComponent(c2.req.param("toolId"));
+      const tool = Object.values(tools || {}).find((tool2) => tool2.id === toolId);
+      if (!tool) {
+        return c2.json({ error: "Tool not found" }, 404);
+      }
+      if (!tool?.execute) {
+        return c2.json({ error: "Tool is not executable" }, 400);
+      }
+      const { data } = await c2.req.json();
+      const mastra = c2.get("mastra");
+      const result = await tool.execute({
+        context: data,
+        mastra,
+        runId: mastra.runId
+      });
+      return c2.json(result);
+    } catch (error) {
+      return handleError(error, "Error executing tool");
+    }
+  };
+}
+async function executeAgentToolHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const toolId = c2.req.param("toolId");
+    const agent = mastra.getAgent(agentId);
+    const tool = Object.values(agent?.tools || {}).find((tool2) => tool2.id === toolId);
+    if (!tool) {
+      throw new httpException.HTTPException(404, { message: "Tool not found" });
+    }
+    if (!tool?.execute) {
+      return c2.json({ error: "Tool is not executable" }, 400);
+    }
+    const { data } = await c2.req.json();
+    const result = await tool.execute({
+      context: data,
+      mastra,
+      runId: agentId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error executing tool");
+  }
+}
+var getVector = (c2, vectorName) => {
+  const vector = c2.get("mastra").getVector(vectorName);
+  if (!vector) {
+    throw new httpException.HTTPException(404, { message: `Vector store ${vectorName} not found` });
+  }
+  return vector;
+};
+async function upsertVectors(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const { indexName, vectors, metadata, ids } = await c2.req.json();
+    if (!indexName || !vectors || !Array.isArray(vectors)) {
+      throw new httpException.HTTPException(400, { message: "Invalid request body. indexName and vectors array are required." });
+    }
+    const vector = getVector(c2, vectorName);
+    const result = await vector.upsert(indexName, vectors, metadata, ids);
+    return c2.json({ ids: result });
+  } catch (error) {
+    return handleError(error, "Error upserting vectors");
+  }
+}
+async function createIndex(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const { indexName, dimension, metric } = await c2.req.json();
+    if (!indexName || typeof dimension !== "number" || dimension <= 0) {
+      throw new httpException.HTTPException(400, {
+        message: "Invalid request body. indexName and positive dimension number are required."
+      });
+    }
+    if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
+      throw new httpException.HTTPException(400, { message: "Invalid metric. Must be one of: cosine, euclidean, dotproduct" });
+    }
+    const vector = getVector(c2, vectorName);
+    await vector.createIndex(indexName, dimension, metric);
+    return c2.json({ success: true });
+  } catch (error) {
+    return handleError(error, "Error creating index");
+  }
+}
+async function queryVectors(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = await c2.req.json();
+    if (!indexName || !queryVector || !Array.isArray(queryVector)) {
+      throw new httpException.HTTPException(400, { message: "Invalid request body. indexName and queryVector array are required." });
+    }
+    const vector = getVector(c2, vectorName);
+    const results = await vector.query(indexName, queryVector, topK, filter, includeVector);
+    return c2.json({ results });
+  } catch (error) {
+    return handleError(error, "Error querying vectors");
+  }
+}
+async function listIndexes(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const vector = getVector(c2, vectorName);
+    const indexes = await vector.listIndexes();
+    return c2.json({ indexes: indexes.filter(Boolean) });
+  } catch (error) {
+    return handleError(error, "Error listing indexes");
+  }
+}
+async function describeIndex(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const indexName = c2.req.param("indexName");
+    if (!indexName) {
+      throw new httpException.HTTPException(400, { message: "Index name is required" });
+    }
+    const vector = getVector(c2, vectorName);
+    const stats = await vector.describeIndex(indexName);
+    return c2.json({
+      dimension: stats.dimension,
+      count: stats.count,
+      metric: stats.metric?.toLowerCase()
+    });
+  } catch (error) {
+    return handleError(error, "Error describing index");
+  }
+}
+async function deleteIndex(c2) {
+  try {
+    const vectorName = c2.req.param("vectorName");
+    const indexName = c2.req.param("indexName");
+    if (!indexName) {
+      throw new httpException.HTTPException(400, { message: "Index name is required" });
+    }
+    const vector = getVector(c2, vectorName);
+    await vector.deleteIndex(indexName);
+    return c2.json({ success: true });
+  } catch (error) {
+    return handleError(error, "Error deleting index");
+  }
+}
+async function getWorkflowsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflows = mastra.getWorkflows({ serialized: true });
+    return c2.json(workflows);
+  } catch (error) {
+    return handleError(error, "Error getting workflows");
+  }
+}
+async function getWorkflowByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const workflow = mastra.getWorkflow(workflowId);
+    const triggerSchema = workflow?.triggerSchema;
+    const stepGraph = workflow.stepGraph;
+    const stepSubscriberGraph = workflow.stepSubscriberGraph;
+    const serializedSteps = Object.entries(workflow.steps).reduce((acc, [key, step]) => {
+      const _step = step;
+      acc[key] = {
+        ..._step,
+        inputSchema: _step.inputSchema ? stringify(esm_default(_step.inputSchema)) : void 0,
+        outputSchema: _step.outputSchema ? stringify(esm_default(_step.outputSchema)) : void 0
+      };
+      return acc;
+    }, {});
+    return c2.json({
+      name: workflow.name,
+      triggerSchema: triggerSchema ? stringify(esm_default(triggerSchema)) : void 0,
+      steps: serializedSteps,
+      stepGraph,
+      stepSubscriberGraph
+    });
+  } catch (error) {
+    return handleError(error, "Error getting workflow");
+  }
+}
+async function executeWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const workflow = mastra.getWorkflow(workflowId);
+    const body = await c2.req.json();
+    const { start } = workflow.createRun();
+    const result = await start({
+      triggerData: body
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error executing workflow");
+  }
+}
+async function watchWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const logger2 = mastra.getLogger();
+    const workflowId = c2.req.param("workflowId");
+    const workflow = mastra.getWorkflow(workflowId);
+    return streaming.streamText(
+      c2,
+      async (stream) => {
+        return new Promise((_resolve, _reject) => {
+          let unwatch = workflow.watch(({ activePaths, context }) => {
+            void stream.write(JSON.stringify({ activePaths, context }) + "");
+          });
+          stream.onAbort(() => {
+            unwatch?.();
+          });
+        });
+      },
+      async (err, stream) => {
+        logger2.error("Error in watch stream: " + err?.message);
+        stream.abort();
+        await stream.close();
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error watching workflow");
+  }
+}
+async function resumeWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const workflow = mastra.getWorkflow(workflowId);
+    const { stepId, runId, context } = await c2.req.json();
+    const result = await workflow.resume({
+      stepId,
+      runId,
+      context
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error resuming workflow step");
+  }
+}
+
+// src/server/welcome.ts
+var html2 = `
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Welcome to Mastra</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/inter-ui/3.19.3/inter.min.css" />
+    <style>
+      body {
+        margin: 0;
+        padding: 0;
+        background-color: #0d0d0d;
+        color: #ffffff;
+        font-family:
+          'Inter',
+          -apple-system,
+          BlinkMacSystemFont,
+          system-ui,
+          sans-serif;
+        min-height: 100vh;
+        display: flex;
+        flex-direction: column;
+      }
+
+      main {
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        padding: 2rem;
+        text-align: center;
+      }
+
+      h1 {
+        font-size: 4rem;
+        font-weight: 600;
+        margin: 0 0 1rem 0;
+        background: linear-gradient(to right, #fff, #ccc);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        line-height: 1.2;
+      }
+
+      .subtitle {
+        color: #9ca3af;
+        font-size: 1.25rem;
+        max-width: 600px;
+        margin: 0 auto 3rem auto;
+        line-height: 1.6;
+      }
+
+      .docs-link {
+        background-color: #1a1a1a;
+        padding: 1rem 2rem;
+        border-radius: 0.5rem;
+        display: flex;
+        align-items: center;
+        gap: 1rem;
+        font-family: monospace;
+        font-size: 1rem;
+        color: #ffffff;
+        text-decoration: none;
+        transition: background-color 0.2s;
+      }
+
+      .docs-link:hover {
+        background-color: #252525;
+      }
+
+      .arrow-icon {
+        transition: transform 0.2s;
+      }
+
+      .docs-link:hover .arrow-icon {
+        transform: translateX(4px);
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>Welcome to Mastra</h1>
+      <p class="subtitle">
+        From the team that brought you Gatsby: prototype and productionize AI features with a modern JS/TS stack.
+      </p>
+
+      <a href="https://mastra.ai/docs" class="docs-link">
+        Browse the docs
+        <svg
+          class="arrow-icon"
+          width="20"
+          height="20"
+          viewBox="0 0 24 24"
+          fill="none"
+          stroke="currentColor"
+          stroke-width="2"
+        >
+          <path d="M5 12h14M12 5l7 7-7 7" />
+        </svg>
+      </a>
+    </main>
+  </body>
+</html>
+`;
+
+// src/server/index.ts
+async function createHonoServer(mastra, options = {}) {
+  const app = new hono.Hono();
+  const mastraToolsPaths = process.env.MASTRA_TOOLS_PATH;
+  const toolImports = mastraToolsPaths ? await Promise.all(
+    mastraToolsPaths.split(",").map(async (toolPath) => {
+      return import(url.pathToFileURL(toolPath).href);
+    })
+  ) : [];
+  const tools = toolImports.reduce((acc, toolModule) => {
+    Object.entries(toolModule).forEach(([key, tool]) => {
+      acc[key] = tool;
+    });
+    return acc;
+  }, {});
+  app.use(
+    "*",
+    cors.cors({
+      origin: "*",
+      allowMethods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+      allowHeaders: ["Content-Type", "Authorization"],
+      exposeHeaders: ["Content-Length", "X-Requested-With"],
+      credentials: false,
+      maxAge: 3600
+    })
+  );
+  if (options.apiReqLogs) {
+    app.use(logger.logger());
+  }
+  app.onError(errorHandler);
+  app.use("*", async (c2, next) => {
+    c2.set("mastra", mastra);
+    c2.set("tools", tools);
+    c2.set("playground", options.playground === true);
+    await next();
+  });
+  const bodyLimitOptions = {
+    maxSize: 4.5 * 1024 * 1024,
+    // 4.5 MB,
+    onError: (c2) => c2.json({ error: "Request body too large" }, 413)
+  };
+  app.get(
+    "/api",
+    p({
+      description: "Get API status",
+      tags: ["system"],
+      responses: {
+        200: {
+          description: "Success"
+        }
+      }
+    }),
+    rootHandler
+  );
+  app.get(
+    "/api/agents",
+    p({
+      description: "Get all available agents",
+      tags: ["agents"],
+      responses: {
+        200: {
+          description: "List of all agents"
+        }
+      }
+    }),
+    getAgentsHandler
+  );
+  app.get(
+    "/api/agents/:agentId",
+    p({
+      description: "Get agent by ID",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Agent details"
+        },
+        404: {
+          description: "Agent not found"
+        }
+      }
+    }),
+    getAgentByIdHandler
+  );
+  app.get(
+    "/api/agents/:agentId/evals/ci",
+    p({
+      description: "Get CI evals by agent ID",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of evals"
+        }
+      }
+    }),
+    getEvalsByAgentIdHandler
+  );
+  app.get(
+    "/api/agents/:agentId/evals/live",
+    p({
+      description: "Get live evals by agent ID",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of evals"
+        }
+      }
+    }),
+    getLiveEvalsByAgentIdHandler
+  );
+  app.post(
+    "/api/agents/:agentId/generate",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Generate a response from an agent",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                messages: {
+                  type: "array",
+                  items: { type: "object" }
+                },
+                threadId: { type: "string" },
+                resourceId: { type: "string", description: "The resource ID for the conversation" },
+                resourceid: {
+                  type: "string",
+                  description: "The resource ID for the conversation (deprecated, use resourceId instead)",
+                  deprecated: true
+                },
+                runId: { type: "string" },
+                output: { type: "object" }
+              },
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Generated response"
+        },
+        404: {
+          description: "Agent not found"
+        }
+      }
+    }),
+    generateHandler
+  );
+  app.post(
+    "/api/agents/:agentId/stream",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Stream a response from an agent",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                messages: {
+                  type: "array",
+                  items: { type: "object" }
+                },
+                threadId: { type: "string" },
+                resourceId: { type: "string", description: "The resource ID for the conversation" },
+                resourceid: {
+                  type: "string",
+                  description: "The resource ID for the conversation (deprecated, use resourceId instead)",
+                  deprecated: true
+                },
+                runId: { type: "string" },
+                output: { type: "object" }
+              },
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Streamed response"
+        },
+        404: {
+          description: "Agent not found"
+        }
+      }
+    }),
+    streamGenerateHandler
+  );
+  app.post(
+    "/api/agents/:agentId/instructions",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Update an agent's instructions",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                instructions: {
+                  type: "string",
+                  description: "New instructions for the agent"
+                }
+              },
+              required: ["instructions"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Instructions updated successfully"
+        },
+        403: {
+          description: "Not allowed in non-playground environment"
+        },
+        404: {
+          description: "Agent not found"
+        }
+      }
+    }),
+    setAgentInstructionsHandler
+  );
+  app.post(
+    "/api/agents/:agentId/instructions/enhance",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Generate an improved system prompt from instructions",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" },
+          description: "ID of the agent whose model will be used for prompt generation"
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                instructions: {
+                  type: "string",
+                  description: "Instructions to generate a system prompt from"
+                },
+                comment: {
+                  type: "string",
+                  description: "Optional comment for the enhanced prompt"
+                }
+              },
+              required: ["instructions"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Generated system prompt and analysis",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  explanation: {
+                    type: "string",
+                    description: "Detailed analysis of the instructions"
+                  },
+                  new_prompt: {
+                    type: "string",
+                    description: "The enhanced system prompt"
+                  }
+                }
+              }
+            }
+          }
+        },
+        400: {
+          description: "Missing or invalid request parameters"
+        },
+        404: {
+          description: "Agent not found"
+        },
+        500: {
+          description: "Internal server error or model response parsing error"
+        }
+      }
+    }),
+    generateSystemPromptHandler
+  );
+  app.post(
+    "/api/agents/:agentId/tools/:toolId/execute",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Execute a tool through an agent",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "toolId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                data: { type: "object" }
+              },
+              required: ["data"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Tool execution result"
+        },
+        404: {
+          description: "Tool or agent not found"
+        }
+      }
+    }),
+    executeAgentToolHandler
+  );
+  app.get(
+    "/api/memory/status",
+    p({
+      description: "Get memory status",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Memory status"
+        }
+      }
+    }),
+    getMemoryStatusHandler
+  );
+  app.get(
+    "/api/memory/threads",
+    p({
+      description: "Get all threads",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "resourceid",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of all threads"
+        }
+      }
+    }),
+    getThreadsHandler
+  );
+  app.get(
+    "/api/memory/threads/:threadId",
+    p({
+      description: "Get thread by ID",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "threadId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Thread details"
+        },
+        404: {
+          description: "Thread not found"
+        }
+      }
+    }),
+    getThreadByIdHandler
+  );
+  app.get(
+    "/api/memory/threads/:threadId/messages",
+    p({
+      description: "Get messages for a thread",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "threadId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of messages"
+        }
+      }
+    }),
+    getMessagesHandler
+  );
+  app.post(
+    "/api/memory/threads",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Create a new thread",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                title: { type: "string" },
+                metadata: { type: "object" },
+                resourceid: { type: "string" },
+                threadId: { type: "string" }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Created thread"
+        }
+      }
+    }),
+    createThreadHandler
+  );
+  app.patch(
+    "/api/memory/threads/:threadId",
+    p({
+      description: "Update a thread",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "threadId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: { type: "object" }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Updated thread"
+        },
+        404: {
+          description: "Thread not found"
+        }
+      }
+    }),
+    updateThreadHandler
+  );
+  app.delete(
+    "/api/memory/threads/:threadId",
+    p({
+      description: "Delete a thread",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "threadId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Thread deleted"
+        },
+        404: {
+          description: "Thread not found"
+        }
+      }
+    }),
+    deleteThreadHandler
+  );
+  app.post(
+    "/api/memory/save-messages",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Save messages",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                messages: {
+                  type: "array",
+                  items: { type: "object" }
+                }
+              },
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Messages saved"
+        }
+      }
+    }),
+    saveMessagesHandler
+  );
+  app.get(
+    "/api/telemetry",
+    p({
+      description: "Get all traces",
+      tags: ["telemetry"],
+      responses: {
+        200: {
+          description: "List of all traces (paged)"
+        }
+      }
+    }),
+    getTelemetryHandler
+  );
+  app.get(
+    "/api/workflows",
+    p({
+      description: "Get all workflows",
+      tags: ["workflows"],
+      responses: {
+        200: {
+          description: "List of all workflows"
+        }
+      }
+    }),
+    getWorkflowsHandler
+  );
+  app.get(
+    "/api/workflows/:workflowId",
+    p({
+      description: "Get workflow by ID",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Workflow details"
+        },
+        404: {
+          description: "Workflow not found"
+        }
+      }
+    }),
+    getWorkflowByIdHandler
+  );
+  app.post(
+    "/api/workflows/:workflowId/execute",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Execute/Start a workflow",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                input: { type: "object" }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Workflow execution result"
+        },
+        404: {
+          description: "Workflow not found"
+        }
+      }
+    }),
+    executeWorkflowHandler
+  );
+  app.post(
+    "/api/workflows/:workflowId/resume",
+    p({
+      description: "Resume a suspended workflow step",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                stepId: { type: "string" },
+                runId: { type: "string" },
+                context: { type: "object" }
+              }
+            }
+          }
+        }
+      }
+    }),
+    resumeWorkflowHandler
+  );
+  app.get(
+    "/api/workflows/:workflowId/watch",
+    p({
+      description: "Watch workflow transitions in real-time",
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      tags: ["workflows"],
+      responses: {
+        200: {
+          description: "Workflow transitions in real-time"
+        }
+      }
+    }),
+    watchWorkflowHandler
+  );
+  app.get(
+    "/api/logs",
+    p({
+      description: "Get all logs",
+      tags: ["logs"],
+      parameters: [
+        {
+          name: "transportId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of all logs"
+        }
+      }
+    }),
+    getLogsHandler
+  );
+  app.get(
+    "/api/logs/transports",
+    p({
+      description: "List of all log transports",
+      tags: ["logs"],
+      responses: {
+        200: {
+          description: "List of all log transports"
+        }
+      }
+    }),
+    getLogTransports
+  );
+  app.get(
+    "/api/logs/:runId",
+    p({
+      description: "Get logs by run ID",
+      tags: ["logs"],
+      parameters: [
+        {
+          name: "runId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "transportId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of logs for run ID"
+        }
+      }
+    }),
+    getLogsByRunIdHandler
+  );
+  app.get(
+    "/api/tools",
+    p({
+      description: "Get all tools",
+      tags: ["tools"],
+      responses: {
+        200: {
+          description: "List of all tools"
+        }
+      }
+    }),
+    getToolsHandler
+  );
+  app.get(
+    "/api/tools/:toolId",
+    p({
+      description: "Get tool by ID",
+      tags: ["tools"],
+      parameters: [
+        {
+          name: "toolId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Tool details"
+        },
+        404: {
+          description: "Tool not found"
+        }
+      }
+    }),
+    getToolByIdHandler
+  );
+  app.post(
+    "/api/tools/:toolId/execute",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Execute a tool",
+      tags: ["tools"],
+      parameters: [
+        {
+          name: "toolId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                data: { type: "object" }
+              },
+              required: ["data"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Tool execution result"
+        },
+        404: {
+          description: "Tool not found"
+        }
+      }
+    }),
+    executeToolHandler(tools)
+  );
+  app.post(
+    "/api/vector/:vectorName/upsert",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Upsert vectors into an index",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                indexName: { type: "string" },
+                vectors: {
+                  type: "array",
+                  items: {
+                    type: "array",
+                    items: { type: "number" }
+                  }
+                },
+                metadata: {
+                  type: "array",
+                  items: { type: "object" }
+                },
+                ids: {
+                  type: "array",
+                  items: { type: "string" }
+                }
+              },
+              required: ["indexName", "vectors"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Vectors upserted successfully"
+        }
+      }
+    }),
+    upsertVectors
+  );
+  app.post(
+    "/api/vector/:vectorName/create-index",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Create a new vector index",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                indexName: { type: "string" },
+                dimension: { type: "number" },
+                metric: {
+                  type: "string",
+                  enum: ["cosine", "euclidean", "dotproduct"]
+                }
+              },
+              required: ["indexName", "dimension"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Index created successfully"
+        }
+      }
+    }),
+    createIndex
+  );
+  app.post(
+    "/api/vector/:vectorName/query",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    p({
+      description: "Query vectors from an index",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                indexName: { type: "string" },
+                queryVector: {
+                  type: "array",
+                  items: { type: "number" }
+                },
+                topK: { type: "number" },
+                filter: { type: "object" },
+                includeVector: { type: "boolean" }
+              },
+              required: ["indexName", "queryVector"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Query results"
+        }
+      }
+    }),
+    queryVectors
+  );
+  app.get(
+    "/api/vector/:vectorName/indexes",
+    p({
+      description: "List all indexes for a vector store",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of indexes"
+        }
+      }
+    }),
+    listIndexes
+  );
+  app.get(
+    "/api/vector/:vectorName/indexes/:indexName",
+    p({
+      description: "Get details about a specific index",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "indexName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Index details"
+        }
+      }
+    }),
+    describeIndex
+  );
+  app.delete(
+    "/api/vector/:vectorName/indexes/:indexName",
+    p({
+      description: "Delete a specific index",
+      tags: ["vector"],
+      parameters: [
+        {
+          name: "vectorName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "indexName",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Index deleted successfully"
+        }
+      }
+    }),
+    deleteIndex
+  );
+  app.get(
+    "/openapi.json",
+    i(app, {
+      documentation: {
+        info: { title: "Mastra API", version: "1.0.0", description: "Mastra API" }
+      }
+    })
+  );
+  app.get("/swagger-ui", middleware({ url: "/openapi.json" }));
+  if (options?.swaggerUI) {
+    app.get("/swagger-ui", middleware({ url: "/openapi.json" }));
+  }
+  if (options?.playground) {
+    app.get("/refresh-events", handleClientsRefresh);
+    app.post("/__refresh", handleTriggerClientsRefresh);
+    app.use("/assets/*", async (c2, next) => {
+      const path = c2.req.path;
+      if (path.endsWith(".js")) {
+        c2.header("Content-Type", "application/javascript");
+      } else if (path.endsWith(".css")) {
+        c2.header("Content-Type", "text/css");
+      }
+      await next();
+    });
+    app.use(
+      "/assets/*",
+      serveStatic({
+        root: "./playground/assets"
+      })
+    );
+    app.use(
+      "*",
+      serveStatic({
+        root: "./playground"
+      })
+    );
+  }
+  app.get("*", async (c2, next) => {
+    if (c2.req.path.startsWith("/api/") || c2.req.path.startsWith("/swagger-ui") || c2.req.path.startsWith("/openapi.json")) {
+      return await next();
+    }
+    if (options?.playground) {
+      const indexHtml = await promises.readFile(path.join(process.cwd(), "./playground/index.html"), "utf-8");
+      return c2.newResponse(indexHtml, 200, { "Content-Type": "text/html" });
+    }
+    return c2.newResponse(html2, 200, { "Content-Type": "text/html" });
+  });
+  return app;
+}
+async function createNodeServer(mastra, options = {}) {
+  const app = await createHonoServer(mastra, options);
+  return serve(
+    {
+      fetch: app.fetch,
+      port: Number(process.env.PORT) || 4111
+    },
+    () => {
+      const logger2 = mastra.getLogger();
+      logger2.info(`\u{1F984} Mastra API running on port ${process.env.PORT || 4111}/api`);
+      logger2.info(`\u{1F4DA} Open API documentation available at http://localhost:${process.env.PORT || 4111}/openapi.json`);
+      if (options?.swaggerUI) {
+        logger2.info(`\u{1F9EA} Swagger UI available at http://localhost:${process.env.PORT || 4111}/swagger-ui`);
+      }
+      if (options?.playground) {
+        logger2.info(`\u{1F468}\u200D\u{1F4BB} Playground available at http://localhost:${process.env.PORT || 4111}/`);
+      }
+    }
+  );
+}
+
+exports.createHonoServer = createHonoServer;
+exports.createNodeServer = createNodeServer;